is ByteValue -> KtConstantValue.KtByteConstantValue(value, sourcePsi = null)
        is CharValue -> KtConstantValue.KtCharConstantValue(value, sourcePsi = null)
        is IntValue -> KtConstantValue.KtIntConstantValue(value, sourcePsi = null)
        is LongValue -> KtConstantValue.KtLongConstantValue(value, sourcePsi = null)
        is ShortValue -> KtConstantValue.KtShortConstantValue(value, sourcePsi = null)

            KtImplicitReceiverSmartCastKind.EXTENSION -> firExpression.extensionReceiver
        }

        if (receiver == null || receiver == firExpression.explicitReceiver) return null
        if (!receiver.isStableSmartcast()) return null

        val type = receiver.resolvedType.asKtType()
        return KtImplicitReceiverSmartCast(type, kind, token)
    }
}

                ?: extensions.singleOrNull { it.useSiteModule == null }
                ?: error(KtFe10AnalysisHandlerExtension::class.java.name + " should be registered")
        }
    }

    var resolveSession: ResolveSession? = null
        private set

    var deprecationResolver: DeprecationResolver? = null
        private set

    var callResolver: CallResolver? = null
        private set

                if (parentInternalName != null) "$parentInternalName$$selfName" else null
            }
            else -> selfName.asString()
        }
    }

    private fun computeSupertypeInternalName(descriptor: ClassDescriptor): String {
        var interfaceSupertypeInternalName: String? = null

        for (supertype in descriptor.typeConstructor.supertypes) {

        val function = assignment.operationReference.mainReference.resolve() as? KtNamedFunction ?: return null
        val name = function.name ?: return null
        return if (Name.identifier(name) in OperatorConventions.ASSIGNMENT_OPERATIONS.values)
            ReferenceAccess.READ to assignment
        else
            null
    }

                val substitutor = firResolvedCall.createSubstitutorFromTypeArguments() ?: return null

                val receiverCastRequired = firResolvedCall.calleeReference is FirErrorReferenceWithCandidate

                if (firSymbol is FirVariableSymbol<*> && firSymbol.resolvedReturnType.receiverType(firCallSiteSession) != null) {

  @Test
  public void testAllFilesPresentInReferenceResolve() {
    KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/referenceResolve"), Pattern.compile("^([^.]+)\\.kt$"), null, true);
  }

  @Test
  @TestMetadata("AnnotationForClass.kt")
  public void testAnnotationForClass() {
    runTest("analysis/analysis-api/testData/referenceResolve/AnnotationForClass.kt");
  }

  @Test

) : KtSymbolProviderByJavaPsi(), Fe10KtAnalysisSessionComponent {
    override fun getNamedClassSymbol(psiClass: PsiClass): KtNamedClassOrObjectSymbol? {
        return null /*TODO*/
    }

    override fun getCallableSymbol(callable: PsiMember): KtCallableSymbol? {
        return null /*TODO*/
    }

        get() = withValidityAssertion { null }

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

    override val receiverParameter: KtReceiverParameterSymbol?
        get() = withValidityAssertion {
            if (!propertyPsi.isExtensionDeclaration()) {
                return null
            }

    ): KtContractReturnsContractEffectDeclaration =
        when (val value = returnsEffect.value) {
            ConeContractConstantValues.NULL ->
                KtContractReturnsSpecificValueEffectDeclaration(KtContractConstantValue(KtContractConstantType.NULL, builder.token))
            ConeContractConstantValues.NOT_NULL -> KtContractReturnsNotNullEffectDeclaration(builder.token)