<profile version="1.0">
      <inspection_tool class="BodyLimit" enabled="true" level="WARNING" enabled_by_default="true" />
      <inspection_tool class="GrazieCommit" enabled="true" level="TYPO" enabled_by_default="true" />
      <inspection_tool class="SubjectBodySeparation" enabled="true" level="ERROR" enabled_by_default="true" />

    }

    override fun JvmSignatureWriter.writeGenericType(type: KotlinTypeMarker, asmType: Type, mode: TypeMappingMode) {
        require(type is KotlinType)

        val typeDeclaration = type.constructor.declarationDescriptor

        val skipArguments = skipGenericSignature()
                || typeContext.hasNothingInNonContravariantPosition(type)
                || type.arguments.isEmpty()
                || typeDeclaration == null

        }
        else -> arguments.any { typeProjection ->
            // A star projection type (lazily) built by type parameter will be yet another type with a star projection,
            // resulting in stack overflow if we keep checking allowed type parameter descriptors
            !typeProjection.isStarProjection &&
                    typeProjection.type.hasReferenceOtherThan(allowedTypeParameterDescriptors)
        }
    }
}

/**

  }

  @Test
  @TestMetadata("getClass_type.kt")
  public void testGetClass_type() {
    runTest("analysis/analysis-api/testData/components/typeInfoProvider/doubleColonReceiverType/getClass_type.kt");
  }

  @Test
  @TestMetadata("getClass_variable.kt")
  public void testGetClass_variable() {

            }
            val kotlinType = ErrorUtils.createErrorType(ErrorTypeKind.UNRESOLVED_CLASS_TYPE, name)
            return KtFe10ClassErrorType(kotlinType, analysisContext)
        }

        val typeParameters = descriptor.typeConstructor.parameters
        val type = if (typeParameters.size == builder.arguments.size) {
            val projections = builder.arguments.mapIndexed { index, arg ->

        return getSmartCastedInfo(firSmartCastExpression)
    }

    private fun getSmartCastedInfo(expression: FirSmartCastExpression): KtSmartCastInfo? {
        val type = expression.smartcastType.coneTypeSafe<ConeKotlinType>()?.asKtType() ?: return null
        return KtSmartCastInfo(type, expression.isStable, token)
    }

    private val KtExpression.isImplicitSmartCastInfoTarget: Boolean

            }
        else firFunctionSymbol.valueParameters[valueParameterReference.parameterIndex]
    )

    // Util function to avoid hard coding names of the classes. Type inference will do a better job figuring out the best type to cast to.
    // This visitor isn't type-safe anyway
    private inline fun <reified T> ConeContractDescriptionElement.accept() =
        accept(this@ConeContractDescriptionElementToAnalysisApi, Unit) as T

    override val analysisContext: Fe10AnalysisContext,
) : KtReceiverParameterSymbol(), KtFe10DescSymbol<ReceiverParameterDescriptor> {

    override val type: KtType
        get() = withValidityAssertion {
            descriptor.returnType?.toKtType(analysisContext) ?: error("expect return type for $descriptor")
        }

    override val owningCallableSymbol: KtCallableSymbol

<component name="ProjectRunConfigurationManager">
  <configuration default="false" name="Generate Compiler Arguments Copy" type="GradleRunConfiguration" factoryName="Gradle" folderName="Generators">
    <ExternalSystemSettings>
      <option name="executionName" />
      <option name="externalProjectPath" value="$PROJECT_DIR$/generators" />
      <option name="externalSystemIdString" value="GRADLE" />
      <option name="scriptParameters" value="" />

    override val isVal: Boolean
        get() = withValidityAssertion { !descriptor.isVar }

    override val returnType: KtType
        get() = withValidityAssertion { descriptor.type.toKtType(analysisContext) }

    override val symbolKind: KtSymbolKind
        get() = withValidityAssertion { KtSymbolKind.LOCAL }