val nameCanBeDeclaredInAnnotation = symbol.psi == null

            runIf(nameCanBeDeclaredInAnnotation) { getValueFromParameterNameAnnotation() } ?: symbol.name
        }

    abstract override fun substitute(substitutor: KaSubstitutor): KaVariableLikeSignature<S>

    private fun getValueFromParameterNameAnnotation(): Name? {
        val resultingAnnotation = findParameterNameAnnotation() ?: return null

}

internal class KaFirGenericSubstitutor(
    substitutor: ConeSubstitutor,
    builder: KaSymbolByFirBuilder,
) : AbstractKaFirSubstitutor<ConeSubstitutor>(substitutor, builder)

@OptIn(KaAnalysisApiInternals::class)
internal class KaFirMapBackedSubstitutor(
    substitutor: ConeSubstitutorByMap,
    builder: KaSymbolByFirBuilder,
) : AbstractKaFirSubstitutor<ConeSubstitutorByMap>(substitutor, builder,), KaMapBackedSubstitutor {

#include "absl/strings/str_join.h"
#include "absl/strings/substitute.h"
#include "tensorflow/core/platform/types.h"

namespace tensorflow {
namespace generator {

string Call(const string& object, const string& method,
            std::vector<string> arguments, const char* oper) {
  return absl::Substitute("$0$1$2($3)", object, oper, method,
                          absl::StrJoin(arguments, ", "));
}

namespace tensorflow {
namespace generator {
namespace cpp {

string OpArgumentView::Declaration() const {
  return absl::Substitute("$0 $1", type_name_, variable_name_);
}

string OpArgumentView::Initializer() const {
  if (default_value_.empty()) {
    return "";
  }
  return absl::Substitute(" = $0", default_value_);
}

bool OpArgumentView::HasDefaultValue() const { return !default_value_.empty(); }

}

string AttrView::InputArg(bool with_default_value) const {
  string default_value = DefaultValue();
  if (!with_default_value || default_value.empty()) {
    return absl::Substitute("$0 $1", VariableType(), attr_.name());
  }
  return absl::Substitute("$0 $1 = $2", VariableType(), attr_.name(),
                          default_value);
}

string AttrView::SetterMethod() const {
  if (!attr_.is_list()) {

        public abstract val substitutor: KaSubstitutor
    }

    public class ApplicableAsExtensionCallable(
        substitutor: KaSubstitutor,
        receiverCastRequired: Boolean,
        override val token: KaLifetimeToken
    ) : Applicable() {
        override val substitutor: KaSubstitutor by validityAsserted(substitutor)

        given:
        singleProjectBuildInRootFolder("root") {
            settingsFile << """
                includeBuild('includedBuild') {
                    dependencySubstitution {
                        substitute module('group:name') using project(':')
                    }
                }
            """
        }
        singleProjectBuildInSubfolder("includedBuild")

        when:

limitations under the License.
==============================================================================*/
#include "tensorflow/c/experimental/ops/gen/common/controller.h"

#include "absl/strings/substitute.h"
#include "tensorflow/c/experimental/ops/gen/common/path_config.h"
#include "tensorflow/c/experimental/ops/gen/common/source_code.h"
#include "tensorflow/c/experimental/ops/gen/model/op_spec.h"

    public val mappings: Map<KaTypeParameterSymbol, KaType> get() = withValidityAssertion { backingMapping }

    /**
     * Adds a new [typeParameter] -> [type] substitution to the substitutor which is being built.
     * If there already was a substitution with a [typeParameter], replaces corresponding substitution with a new one.
     */

DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE 
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR 
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER 
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,