override fun substitute(substitutor: KaSubstitutor): KaVariableLikeSignature<S> = withValidityAssertion {
        KaFe10VariableLikeSignature(
            symbol,
            substitutor.substitute(returnType),
            receiverType?.let { substitutor.substitute(it) },
        )
    }

    override fun equals(other: Any?): Boolean {

    }

    override fun substitute(substitutor: KaSubstitutor): KaFirFunctionLikeSignature<S> = withValidityAssertion {
        if (substitutor is KaSubstitutor.Empty) return@withValidityAssertion this
        require(substitutor is AbstractKaFirSubstitutor<*>)

        KaFirFunctionLikeSubstitutorBasedSignature(token, firSymbol, firSymbolBuilder, substitutor.substitutor)
    }
}

            val signatureAfterSubstitution = symbol.substitute(substitutor)
            prettyPrint {
                appendLine("${KtDeclaration::class.simpleName}: ${declaration::class.simpleName}")

                appendLine("Symbol:")
                appendLine(symbol.render(KaDeclarationRendererForDebug.WITH_QUALIFIED_NAMES))

                appendLine()

                appendLine("Substitutor:")

        val actual = analyseForTest(declaration) {
            val symbol = declaration.getSymbol() as KaCallableSymbol

            val substitutor = SubstitutionParser.parseSubstitutor(analysisSession, mainFile, declaration)

            val signature = symbol.substitute(substitutor)
            prettyPrint {
                appendLine("${KtDeclaration::class.simpleName}: ${declaration::class.simpleName}")

            val symbol = declaration.getSymbol() as KaCallableSymbol

            val substitutor = SubstitutionParser.parseSubstitutor(analysisSession, mainFile, declaration)

            val signatureBeforeSubstitution = symbol.asSignature()
            val signatureAfterSubstitution = signatureBeforeSubstitution.substitute(substitutor)
            prettyPrint {

        if (providingProjects.isEmpty()) {
            LOGGER.debug("Found no composite build substitute for module '{}'.", candidateId);
            return null;
        }
        if (providingProjects.size() == 1) {
            ProjectComponentIdentifier match = providingProjects.iterator().next();
            LOGGER.info("Found project '{}' as substitute for module '{}'.", match, candidateId);
            return match;
        }

                                 'namespace in the generated file')

flags.mark_flags_as_required(['output_file', 'src'])


def _substitute_for_loop_template(module: str) -> str:
  """Substitutes the for loop templates in the given module."""
  compiled_regex = re.compile(
      r'^\s*for\s(.*?)\sin\s(\[.*?\])\s\{(.*?)\}\s//\send\sfor\n',
      re.MULTILINE | re.DOTALL)
  while True:

            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

type Token struct {
	ScanToken
	text string
}

// Make returns a Token with the given rune (ScanToken) and text representation.
func Make(token ScanToken, text string) Token {
	// Substitute the substitutes for . and /.
	text = strings.ReplaceAll(text, "\u00B7", ".")
	text = strings.ReplaceAll(text, "\u2215", "/")
	return Token{ScanToken: token, text: text}
}

func (l Token) String() string {

}

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 {