valueParameter.receiverType?.let { substitutor.substitute(it) }
                )
            }
        )
    }

    override fun equals(other: Any?): Boolean {
        if (this === other) return true
        if (javaClass != other?.javaClass) return false

        other as KtFe10FunctionLikeSignature<*>

        if (backingSymbol != other.backingSymbol) return false

    override val psi: PsiElement?
        get() = withValidityAssertion { null }

    override val isDefault: Boolean
        get() = withValidityAssertion { true }

    override val isInline: Boolean
        get() = withValidityAssertion { propertyPsi.hasModifier(KtTokens.OVERRIDE_KEYWORD) }

    override val isOverride: Boolean

                    implicitReceiver = implicitReceiverValue,
                    explicitReceiver = firExplicitReceiver,
                    allowUnsafeCall = true,
                    allowUnstableSmartCast = true,
                )

                val firResolvedCall = resolver.resolveSingleCandidate(resolutionParameters) ?: return null

    </ExternalSystemSettings>
    <ExternalSystemDebugServerProcess>false</ExternalSystemDebugServerProcess>
    <ExternalSystemReattachDebugProcess>true</ExternalSystemReattachDebugProcess>
    <DebugAllEnabled>false</DebugAllEnabled>
    <RunAsTest>true</RunAsTest>
    <method v="2" />
  </configuration>

  public void testAllFilesPresentInMetaAnnotations() {
    KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/annotations/metaAnnotations"), Pattern.compile("^(.+)\\.kt$"), null, true);
  }

  @Test
  @TestMetadata("onProperty_javaAnnotation_varargParameter.kt")
  public void testOnProperty_javaAnnotation_varargParameter() {

  public void testAllFilesPresentInClassType() {
    KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/components/typeCreator/classType"), Pattern.compile("^(.+)\\.kt$"), null, true);
  }

  @Test
  @TestMetadata("unresolved.kt")
  public void testUnresolved() {
    runTest("analysis/analysis-api/testData/components/typeCreator/classType/unresolved.kt");
  }

    KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/components/typeInfoProvider/isDenotable"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile(".*\\.descriptors\\.kt$"), true);
  }

  @Test
  @TestMetadata("localTypes.kt")
  public void testLocalTypes() {
    runTest("analysis/analysis-api/testData/components/typeInfoProvider/isDenotable/localTypes.kt");
  }

  @Test

        // TODO use correct session here,
        return analysisSession.firResolveSession.useSiteFirSession.typeContext.newTypeCheckerState(
            errorTypesEqualToAnything = true,
            stubTypesEqualToAnything = true
        )
    }

    fun FirQualifiedAccessExpression.createSubstitutorFromTypeArguments(discardErrorTypes: Boolean = false): KtSubstitutor? {

    KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/annotations/annotationsOnTypes"), Pattern.compile("^(.+)\\.kt$"), null, true);
  }

  @Test
  @TestMetadata("annotaionOnType.kt")
  public void testAnnotaionOnType() {
    runTest("analysis/analysis-api/testData/annotations/annotationsOnTypes/annotaionOnType.kt");
  }

  @Test

    override val parameter: KtValueParameterSymbol by cached {
        DefaultKtValueParameterSymbol(propertyDescriptor, analysisContext)
    }

    override val isDefault: Boolean
        get() = withValidityAssertion { true }

    override val isInline: Boolean
        get() = withValidityAssertion { false }

    override val isOverride: Boolean
        get() = withValidityAssertion { propertyDescriptor.isExplicitOverride }