KtFile: 'lambdaReceiver.kt'
  NO_CANDIDATES

KtPackageDirective(0,0): ''
  NO_CANDIDATES

KtImportList(0,0): ''
  NO_CANDIDATES

KtClass(0,166): '// ISSUE: KT-75315'
  NO_CANDIDATES

KtDeclarationModifierList(92,96): 'open'
  NO_CANDIDATES

KtClassBody(109,166): '{'
  NO_CANDIDATES

KtProperty(115,141): 'val superProp: String = ""'
  NO_CANDIDATES

KtTypeReference(130,136): 'String'
  NO_CANDIDATES

KtUserType(130,136): 'String'
  NO_CANDIDATES

KtNameReferenceExpression(130,136): 'String'
  NO_CANDIDATES

KtStringTemplateExpression(139,141): '""'
  NO_CANDIDATES

KtNamedFunction(146,164): 'fun superFunc() {}'
  NO_CANDIDATES

KtParameterList(159,161): '()'
  NO_CANDIDATES

KtBlockExpression(162,164): '{}'
  NO_CANDIDATES

KtClass(168,778): 'open class MyClass {'
  NO_CANDIDATES

KtDeclarationModifierList(168,172): 'open'
  NO_CANDIDATES

KtClassBody(187,778): '{'
  NO_CANDIDATES

KtObjectDeclaration(193,264): 'object InheritorObject: MyClass() {'
  NO_CANDIDATES

KtSuperTypeList(217,226): 'MyClass()'
  NO_CANDIDATES

KtSuperTypeCallEntry(217,226): 'MyClass()'
  KaApplicableCallCandidate:
    candidate = KaDelegatedConstructorCall:
      contextArgumentMapping = {}
      contextArguments = []
      dispatchReceiver = null
      extensionReceiver = null
      kind = SUPER_CALL
      signature = KaFunctionSignature:
        receiverType = null
        returnType = MyClass
        symbol = <constructor>(): MyClass
        valueParameters = []
        contextParameters = []
        callableId = null
      typeArgumentsMapping = {}
      valueArgumentMapping = {}
    isInBestCandidates = true

KtConstructorCalleeExpression(217,224): 'MyClass'
  KaApplicableCallCandidate:
    candidate = KaDelegatedConstructorCall:
      contextArgumentMapping = {}
      contextArguments = []
      dispatchReceiver = null
      extensionReceiver = null
      kind = SUPER_CALL
      signature = KaFunctionSignature:
        receiverType = null
        returnType = MyClass
        symbol = <constructor>(): MyClass
        valueParameters = []
        contextParameters = []
        callableId = null
      typeArgumentsMapping = {}
      valueArgumentMapping = {}
    isInBestCandidates = true

KtTypeReference(217,224): 'MyClass'
  NO_CANDIDATES

KtUserType(217,224): 'MyClass'
  NO_CANDIDATES

KtNameReferenceExpression(217,224): 'MyClass'
  KaApplicableCallCandidate:
    candidate = KaDelegatedConstructorCall:
      contextArgumentMapping = {}
      contextArguments = []
      dispatchReceiver = null
      extensionReceiver = null
      kind = SUPER_CALL
      signature = KaFunctionSignature:
        receiverType = null
        returnType = MyClass
        symbol = <constructor>(): MyClass
        valueParameters = []
        contextParameters = []
        callableId = null
      typeArgumentsMapping = {}
      valueArgumentMapping = {}
    isInBestCandidates = true

KtValueArgumentList(224,226): '()'
  NO_CANDIDATES

KtClassBody(227,264): '{'
  NO_CANDIDATES

KtProperty(237,258): 'val prop: String = ""'
  NO_CANDIDATES

KtTypeReference(247,253): 'String'
  NO_CANDIDATES

KtUserType(247,253): 'String'
  NO_CANDIDATES

KtNameReferenceExpression(247,253): 'String'
  NO_CANDIDATES

KtStringTemplateExpression(256,258): '""'
  NO_CANDIDATES

KtClass(270,339): 'class InheritorClass: MyClass() {'
  NO_CANDIDATES

KtSuperTypeList(292,301): 'MyClass()'
  NO_CANDIDATES

KtSuperTypeCallEntry(292,301): 'MyClass()'
  KaApplicableCallCandidate:
    candidate = KaDelegatedConstructorCall:
      contextArgumentMapping = {}
      contextArguments = []
      dispatchReceiver = null
      extensionReceiver = null
      kind = SUPER_CALL
      signature = KaFunctionSignature:
        receiverType = null
        returnType = MyClass
        symbol = <constructor>(): MyClass
        valueParameters = []
        contextParameters = []
        callableId = null
      typeArgumentsMapping = {}
      valueArgumentMapping = {}
    isInBestCandidates = true

KtConstructorCalleeExpression(292,299): 'MyClass'
  KaApplicableCallCandidate:
    candidate = KaDelegatedConstructorCall:
      contextArgumentMapping = {}
      contextArguments = []
      dispatchReceiver = null
      extensionReceiver = null
      kind = SUPER_CALL
      signature = KaFunctionSignature:
        receiverType = null
        returnType = MyClass
        symbol = <constructor>(): MyClass
        valueParameters = []
        contextParameters = []
        callableId = null
      typeArgumentsMapping = {}
      valueArgumentMapping = {}
    isInBestCandidates = true

KtTypeReference(292,299): 'MyClass'
  NO_CANDIDATES

KtUserType(292,299): 'MyClass'
  NO_CANDIDATES

KtNameReferenceExpression(292,299): 'MyClass'
  KaApplicableCallCandidate:
    candidate = KaDelegatedConstructorCall:
      contextArgumentMapping = {}
      contextArguments = []
      dispatchReceiver = null
      extensionReceiver = null
      kind = SUPER_CALL
      signature = KaFunctionSignature:
        receiverType = null
        returnType = MyClass
        symbol = <constructor>(): MyClass
        valueParameters = []
        contextParameters = []
        callableId = null
      typeArgumentsMapping = {}
      valueArgumentMapping = {}
    isInBestCandidates = true

KtValueArgumentList(299,301): '()'
  NO_CANDIDATES

KtClassBody(302,339): '{'
  NO_CANDIDATES

KtProperty(312,333): 'val prop: String = ""'
  NO_CANDIDATES

KtTypeReference(322,328): 'String'
  NO_CANDIDATES

KtUserType(322,328): 'String'
  NO_CANDIDATES

KtNameReferenceExpression(322,328): 'String'
  NO_CANDIDATES

KtStringTemplateExpression(331,333): '""'
  NO_CANDIDATES

KtObjectDeclaration(345,364): 'object NestedObject'
  NO_CANDIDATES

KtObjectDeclaration(370,776): 'companion object: Super() {'
  NO_CANDIDATES

KtDeclarationModifierList(370,379): 'companion'
  NO_CANDIDATES

KtSuperTypeList(388,395): 'Super()'
  NO_CANDIDATES

KtSuperTypeCallEntry(388,395): 'Super()'
  KaApplicableCallCandidate:
    candidate = KaDelegatedConstructorCall:
      contextArgumentMapping = {}
      contextArguments = []
      dispatchReceiver = null
      extensionReceiver = null
      kind = SUPER_CALL
      signature = KaFunctionSignature:
        receiverType = null
        returnType = Super
        symbol = <constructor>(): Super
        valueParameters = []
        contextParameters = []
        callableId = null
      typeArgumentsMapping = {}
      valueArgumentMapping = {}
    isInBestCandidates = true

KtConstructorCalleeExpression(388,393): 'Super'
  KaApplicableCallCandidate:
    candidate = KaDelegatedConstructorCall:
      contextArgumentMapping = {}
      contextArguments = []
      dispatchReceiver = null
      extensionReceiver = null
      kind = SUPER_CALL
      signature = KaFunctionSignature:
        receiverType = null
        returnType = Super
        symbol = <constructor>(): Super
        valueParameters = []
        contextParameters = []
        callableId = null
      typeArgumentsMapping = {}
      valueArgumentMapping = {}
    isInBestCandidates = true

KtTypeReference(388,393): 'Super'
  NO_CANDIDATES

KtUserType(388,393): 'Super'
  NO_CANDIDATES

KtNameReferenceExpression(388,393): 'Super'
  KaApplicableCallCandidate:
    candidate = KaDelegatedConstructorCall:
      contextArgumentMapping = {}
      contextArguments = []
      dispatchReceiver = null
      extensionReceiver = null
      kind = SUPER_CALL
      signature = KaFunctionSignature:
        receiverType = null
        returnType = Super
        symbol = <constructor>(): Super
        valueParameters = []
        contextParameters = []
        callableId = null
      typeArgumentsMapping = {}
      valueArgumentMapping = {}
    isInBestCandidates = true

KtValueArgumentList(393,395): '()'
  NO_CANDIDATES

KtClassBody(396,776): '{'
  NO_CANDIDATES

KtProperty(406,439): 'val propMyClass: MyClass = TODO()'
  NO_CANDIDATES

KtTypeReference(423,430): 'MyClass'
  NO_CANDIDATES

KtUserType(423,430): 'MyClass'
  NO_CANDIDATES

KtNameReferenceExpression(423,430): 'MyClass'
  NO_CANDIDATES

KtCallExpression(433,439): 'TODO()'
  KaApplicableCallCandidate:
    candidate = KaSimpleFunctionCall:
      contextArgumentMapping = {}
      contextArguments = []
      dispatchReceiver = null
      extensionReceiver = null
      signature = KaFunctionSignature:
        receiverType = null
        returnType = kotlin.Nothing
        symbol = kotlin/TODO(): kotlin.Nothing
        valueParameters = []
        contextParameters = []
        callableId = kotlin/TODO
      typeArgumentsMapping = {}
      valueArgumentMapping = {}
    isInBestCandidates = true

  KaInapplicableCallCandidate:
    candidate = KaSimpleFunctionCall:
      contextArgumentMapping = {}
      contextArguments = []
      dispatchReceiver = null
      extensionReceiver = null
      signature = KaFunctionSignature:
        receiverType = null
        returnType = kotlin.Nothing
        symbol = kotlin/TODO(reason: kotlin.String): kotlin.Nothing
        valueParameters = [
          KaVariableSignature:
            name = reason
            receiverType = null
            returnType = kotlin.String
            symbol = reason: kotlin.String
            contextParameters = []
            callableId = null
        ]
        contextParameters = []
        callableId = kotlin/TODO
      typeArgumentsMapping = {}
      valueArgumentMapping = {}
    diagnostic = ERROR<NO_VALUE_FOR_PARAMETER: No value passed for parameter 'reason'.>
    isInBestCandidates = false

KtNameReferenceExpression(433,437): 'TODO'
  KaApplicableCallCandidate:
    candidate = KaSimpleFunctionCall:
      contextArgumentMapping = {}
      contextArguments = []
      dispatchReceiver = null
      extensionReceiver = null
      signature = KaFunctionSignature:
        receiverType = null
        returnType = kotlin.Nothing
        symbol = kotlin/TODO(): kotlin.Nothing
        valueParameters = []
        contextParameters = []
        callableId = kotlin/TODO
      typeArgumentsMapping = {}
      valueArgumentMapping = {}
    isInBestCandidates = true

  KaInapplicableCallCandidate:
    candidate = KaSimpleFunctionCall:
      contextArgumentMapping = {}
      contextArguments = []
      dispatchReceiver = null
      extensionReceiver = null
      signature = KaFunctionSignature:
        receiverType = null
        returnType = kotlin.Nothing
        symbol = kotlin/TODO(reason: kotlin.String): kotlin.Nothing
        valueParameters = [
          KaVariableSignature:
            name = reason
            receiverType = null
            returnType = kotlin.String
            symbol = reason: kotlin.String
            contextParameters = []
            callableId = null
        ]
        contextParameters = []
        callableId = kotlin/TODO
      typeArgumentsMapping = {}
      valueArgumentMapping = {}
    diagnostic = ERROR<NO_VALUE_FOR_PARAMETER: No value passed for parameter 'reason'.>
    isInBestCandidates = false

KtValueArgumentList(437,439): '()'
  NO_CANDIDATES

KtProperty(448,505): 'val propInheritorClass: InheritorClass = InheritorClass()'
  NO_CANDIDATES

KtTypeReference(472,486): 'InheritorClass'
  NO_CANDIDATES

KtUserType(472,486): 'InheritorClass'
  NO_CANDIDATES

KtNameReferenceExpression(472,486): 'InheritorClass'
  NO_CANDIDATES

KtCallExpression(489,505): 'InheritorClass()'
  KaApplicableCallCandidate:
    candidate = KaSimpleFunctionCall:
      contextArgumentMapping = {}
      contextArguments = []
      dispatchReceiver = null
      extensionReceiver = null
      signature = KaFunctionSignature:
        receiverType = null
        returnType = MyClass.InheritorClass
        symbol = <constructor>(): MyClass.InheritorClass
        valueParameters = []
        contextParameters = []
        callableId = null
      typeArgumentsMapping = {}
      valueArgumentMapping = {}
    isInBestCandidates = true

KtNameReferenceExpression(489,503): 'InheritorClass'
  KaApplicableCallCandidate:
    candidate = KaSimpleFunctionCall:
      contextArgumentMapping = {}
      contextArguments = []
      dispatchReceiver = null
      extensionReceiver = null
      signature = KaFunctionSignature:
        receiverType = null
        returnType = MyClass.InheritorClass
        symbol = <constructor>(): MyClass.InheritorClass
        valueParameters = []
        contextParameters = []
        callableId = null
      typeArgumentsMapping = {}
      valueArgumentMapping = {}
    isInBestCandidates = true

KtValueArgumentList(503,505): '()'
  NO_CANDIDATES

KtProperty(514,572): 'val propInheritorObject: InheritorObject = InheritorObject'
  NO_CANDIDATES

KtTypeReference(539,554): 'InheritorObject'
  NO_CANDIDATES

KtUserType(539,554): 'InheritorObject'
  NO_CANDIDATES

KtNameReferenceExpression(539,554): 'InheritorObject'
  NO_CANDIDATES

KtNameReferenceExpression(557,572): 'InheritorObject'
  KaInapplicableCallCandidate:
    candidate = KaSimpleFunctionCall:
      contextArgumentMapping = {}
      contextArguments = []
      dispatchReceiver = null
      extensionReceiver = null
      signature = KaFunctionSignature:
        receiverType = null
        returnType = MyClass.InheritorObject
        symbol = <constructor>(): MyClass.InheritorObject
        valueParameters = []
        contextParameters = []
        callableId = null
      typeArgumentsMapping = {}
      valueArgumentMapping = {}
    diagnostic = ERROR<OTHER_ERROR: Inapplicable candidate>
    isInBestCandidates = false

KtProperty(582,603): 'val prop: String = ""'
  NO_CANDIDATES

KtTypeReference(592,598): 'String'
  NO_CANDIDATES

KtUserType(592,598): 'String'
  NO_CANDIDATES

KtNameReferenceExpression(592,598): 'String'
  NO_CANDIDATES

KtStringTemplateExpression(601,603): '""'
  NO_CANDIDATES

KtProperty(613,645): 'const val constProp: String = ""'
  NO_CANDIDATES

KtDeclarationModifierList(613,618): 'const'
  NO_CANDIDATES

KtTypeReference(634,640): 'String'
  NO_CANDIDATES

KtUserType(634,640): 'String'
  NO_CANDIDATES

KtNameReferenceExpression(634,640): 'String'
  NO_CANDIDATES

KtStringTemplateExpression(643,645): '""'
  NO_CANDIDATES

KtProperty(655,688): 'val lazyProp: String by lazy {""}'
  NO_CANDIDATES

KtTypeReference(669,675): 'String'
  NO_CANDIDATES

KtUserType(669,675): 'String'
  NO_CANDIDATES

KtNameReferenceExpression(669,675): 'String'
  NO_CANDIDATES

KtPropertyDelegate(676,688): 'by lazy {""}'
  KaApplicableCallCandidate:
    candidate = KaDelegatedPropertyCall:
      provideDelegateCall = null
      valueGetterCall = KaSimpleFunctionCall:
        contextArgumentMapping = {}
        contextArguments = []
        dispatchReceiver = null
        extensionReceiver = KaExplicitReceiverValue:
          expression = lazy {""}
          isSafeNavigation = false
          type = kotlin.Lazy<kotlin.String>
        signature = KaFunctionSignature:
          receiverType = kotlin.Lazy<kotlin.String>
          returnType = kotlin.String
          symbol = kotlin/getValue(<extension receiver>: kotlin.Lazy<T>, thisRef: kotlin.Any?, property: kotlin.reflect.KProperty<*>): T
          valueParameters = [
            KaVariableSignature:
              name = thisRef
              receiverType = null
              returnType = kotlin.Any?
              symbol = thisRef: kotlin.Any?
              contextParameters = []
              callableId = null,
            KaVariableSignature:
              name = property
              receiverType = null
              returnType = kotlin.reflect.KProperty<*>
              symbol = property: kotlin.reflect.KProperty<*>
              contextParameters = []
              callableId = null
          ]
          contextParameters = []
          callableId = kotlin/getValue
        typeArgumentsMapping = {
          T -> (kotlin.String)
        }
        valueArgumentMapping = {}
      valueSetterCall = null
    isInBestCandidates = true

KtCallExpression(679,688): 'lazy {""}'
  KaApplicableCallCandidate:
    candidate = KaSimpleFunctionCall:
      contextArgumentMapping = {}
      contextArguments = []
      dispatchReceiver = null
      extensionReceiver = null
      signature = KaFunctionSignature:
        receiverType = null
        returnType = kotlin.Lazy<kotlin.String>
        symbol = kotlin/lazy(initializer: () -> T): kotlin.Lazy<T>
        valueParameters = [
          KaVariableSignature:
            name = initializer
            receiverType = null
            returnType = () -> kotlin.String
            symbol = initializer: () -> T
            contextParameters = []
            callableId = null
        ]
        contextParameters = []
        callableId = kotlin/lazy
      typeArgumentsMapping = {
        T -> (kotlin.String)
      }
      valueArgumentMapping = {
        {""} -> (KaVariableSignature:
          name = initializer
          receiverType = null
          returnType = () -> kotlin.String
          symbol = initializer: () -> T
          contextParameters = []
          callableId = null)
      }
    isInBestCandidates = true

  KaInapplicableCallCandidate:
    candidate = KaSimpleFunctionCall:
      contextArgumentMapping = {}
      contextArguments = []
      dispatchReceiver = null
      extensionReceiver = null
      signature = KaFunctionSignature:
        receiverType = null
        returnType = kotlin.Lazy<kotlin.String>
        symbol = kotlin/lazy(lock: kotlin.Any?, initializer: () -> T): kotlin.Lazy<T>
        valueParameters = [
          KaVariableSignature:
            name = lock
            receiverType = null
            returnType = kotlin.Any?
            symbol = lock: kotlin.Any?
            contextParameters = []
            callableId = null,
          KaVariableSignature:
            name = initializer
            receiverType = null
            returnType = () -> kotlin.String
            symbol = initializer: () -> T
            contextParameters = []
            callableId = null
        ]
        contextParameters = []
        callableId = kotlin/lazy
      typeArgumentsMapping = {
        T -> (kotlin.String)
      }
      valueArgumentMapping = {
        {""} -> (KaVariableSignature:
          name = initializer
          receiverType = null
          returnType = () -> kotlin.String
          symbol = initializer: () -> T
          contextParameters = []
          callableId = null)
      }
    diagnostic = ERROR<NO_VALUE_FOR_PARAMETER: No value passed for parameter 'lock'.>
    isInBestCandidates = false

  KaInapplicableCallCandidate:
    candidate = KaSimpleFunctionCall:
      contextArgumentMapping = {}
      contextArguments = []
      dispatchReceiver = null
      extensionReceiver = null
      signature = KaFunctionSignature:
        receiverType = null
        returnType = kotlin.Lazy<kotlin.String>
        symbol = kotlin/lazy(mode: kotlin.LazyThreadSafetyMode, initializer: () -> T): kotlin.Lazy<T>
        valueParameters = [
          KaVariableSignature:
            name = mode
            receiverType = null
            returnType = kotlin.LazyThreadSafetyMode
            symbol = mode: kotlin.LazyThreadSafetyMode
            contextParameters = []
            callableId = null,
          KaVariableSignature:
            name = initializer
            receiverType = null
            returnType = () -> kotlin.String
            symbol = initializer: () -> T
            contextParameters = []
            callableId = null
        ]
        contextParameters = []
        callableId = kotlin/lazy
      typeArgumentsMapping = {
        T -> (kotlin.String)
      }
      valueArgumentMapping = {
        {""} -> (KaVariableSignature:
          name = initializer
          receiverType = null
          returnType = () -> kotlin.String
          symbol = initializer: () -> T
          contextParameters = []
          callableId = null)
      }
    diagnostic = ERROR<NO_VALUE_FOR_PARAMETER: No value passed for parameter 'mode'.>
    isInBestCandidates = false

KtNameReferenceExpression(679,683): 'lazy'
  KaApplicableCallCandidate:
    candidate = KaSimpleFunctionCall:
      contextArgumentMapping = {}
      contextArguments = []
      dispatchReceiver = null
      extensionReceiver = null
      signature = KaFunctionSignature:
        receiverType = null
        returnType = kotlin.Lazy<kotlin.String>
        symbol = kotlin/lazy(initializer: () -> T): kotlin.Lazy<T>
        valueParameters = [
          KaVariableSignature:
            name = initializer
            receiverType = null
            returnType = () -> kotlin.String
            symbol = initializer: () -> T
            contextParameters = []
            callableId = null
        ]
        contextParameters = []
        callableId = kotlin/lazy
      typeArgumentsMapping = {
        T -> (kotlin.String)
      }
      valueArgumentMapping = {
        {""} -> (KaVariableSignature:
          name = initializer
          receiverType = null
          returnType = () -> kotlin.String
          symbol = initializer: () -> T
          contextParameters = []
          callableId = null)
      }
    isInBestCandidates = true

  KaInapplicableCallCandidate:
    candidate = KaSimpleFunctionCall:
      contextArgumentMapping = {}
      contextArguments = []
      dispatchReceiver = null
      extensionReceiver = null
      signature = KaFunctionSignature:
        receiverType = null
        returnType = kotlin.Lazy<kotlin.String>
        symbol = kotlin/lazy(lock: kotlin.Any?, initializer: () -> T): kotlin.Lazy<T>
        valueParameters = [
          KaVariableSignature:
            name = lock
            receiverType = null
            returnType = kotlin.Any?
            symbol = lock: kotlin.Any?
            contextParameters = []
            callableId = null,
          KaVariableSignature:
            name = initializer
            receiverType = null
            returnType = () -> kotlin.String
            symbol = initializer: () -> T
            contextParameters = []
            callableId = null
        ]
        contextParameters = []
        callableId = kotlin/lazy
      typeArgumentsMapping = {
        T -> (kotlin.String)
      }
      valueArgumentMapping = {
        {""} -> (KaVariableSignature:
          name = initializer
          receiverType = null
          returnType = () -> kotlin.String
          symbol = initializer: () -> T
          contextParameters = []
          callableId = null)
      }
    diagnostic = ERROR<NO_VALUE_FOR_PARAMETER: No value passed for parameter 'lock'.>
    isInBestCandidates = false

  KaInapplicableCallCandidate:
    candidate = KaSimpleFunctionCall:
      contextArgumentMapping = {}
      contextArguments = []
      dispatchReceiver = null
      extensionReceiver = null
      signature = KaFunctionSignature:
        receiverType = null
        returnType = kotlin.Lazy<kotlin.String>
        symbol = kotlin/lazy(mode: kotlin.LazyThreadSafetyMode, initializer: () -> T): kotlin.Lazy<T>
        valueParameters = [
          KaVariableSignature:
            name = mode
            receiverType = null
            returnType = kotlin.LazyThreadSafetyMode
            symbol = mode: kotlin.LazyThreadSafetyMode
            contextParameters = []
            callableId = null,
          KaVariableSignature:
            name = initializer
            receiverType = null
            returnType = () -> kotlin.String
            symbol = initializer: () -> T
            contextParameters = []
            callableId = null
        ]
        contextParameters = []
        callableId = kotlin/lazy
      typeArgumentsMapping = {
        T -> (kotlin.String)
      }
      valueArgumentMapping = {
        {""} -> (KaVariableSignature:
          name = initializer
          receiverType = null
          returnType = () -> kotlin.String
          symbol = initializer: () -> T
          contextParameters = []
          callableId = null)
      }
    diagnostic = ERROR<NO_VALUE_FOR_PARAMETER: No value passed for parameter 'mode'.>
    isInBestCandidates = false

KtLambdaArgument(684,688): '{""}'
  NO_CANDIDATES

KtLambdaExpression(684,688): '{""}'
  NO_CANDIDATES

KtFunctionLiteral(684,688): '{""}'
  NO_CANDIDATES

KtBlockExpression(685,687): '""'
  NO_CANDIDATES

KtStringTemplateExpression(685,687): '""'
  NO_CANDIDATES

KtNamedFunction(698,726): 'fun func(): MyClass = TODO()'
  NO_CANDIDATES

KtParameterList(706,708): '()'
  NO_CANDIDATES

KtTypeReference(710,717): 'MyClass'
  NO_CANDIDATES

KtUserType(710,717): 'MyClass'
  NO_CANDIDATES

KtNameReferenceExpression(710,717): 'MyClass'
  NO_CANDIDATES

KtCallExpression(720,726): 'TODO()'
  KaApplicableCallCandidate:
    candidate = KaSimpleFunctionCall:
      contextArgumentMapping = {}
      contextArguments = []
      dispatchReceiver = null
      extensionReceiver = null
      signature = KaFunctionSignature:
        receiverType = null
        returnType = kotlin.Nothing
        symbol = kotlin/TODO(): kotlin.Nothing
        valueParameters = []
        contextParameters = []
        callableId = kotlin/TODO
      typeArgumentsMapping = {}
      valueArgumentMapping = {}
    isInBestCandidates = true

  KaInapplicableCallCandidate:
    candidate = KaSimpleFunctionCall:
      contextArgumentMapping = {}
      contextArguments = []
      dispatchReceiver = null
      extensionReceiver = null
      signature = KaFunctionSignature:
        receiverType = null
        returnType = kotlin.Nothing
        symbol = kotlin/TODO(reason: kotlin.String): kotlin.Nothing
        valueParameters = [
          KaVariableSignature:
            name = reason
            receiverType = null
            returnType = kotlin.String
            symbol = reason: kotlin.String
            contextParameters = []
            callableId = null
        ]
        contextParameters = []
        callableId = kotlin/TODO
      typeArgumentsMapping = {}
      valueArgumentMapping = {}
    diagnostic = ERROR<NO_VALUE_FOR_PARAMETER: No value passed for parameter 'reason'.>
    isInBestCandidates = false

KtNameReferenceExpression(720,724): 'TODO'
  KaApplicableCallCandidate:
    candidate = KaSimpleFunctionCall:
      contextArgumentMapping = {}
      contextArguments = []
      dispatchReceiver = null
      extensionReceiver = null
      signature = KaFunctionSignature:
        receiverType = null
        returnType = kotlin.Nothing
        symbol = kotlin/TODO(): kotlin.Nothing
        valueParameters = []
        contextParameters = []
        callableId = kotlin/TODO
      typeArgumentsMapping = {}
      valueArgumentMapping = {}
    isInBestCandidates = true

  KaInapplicableCallCandidate:
    candidate = KaSimpleFunctionCall:
      contextArgumentMapping = {}
      contextArguments = []
      dispatchReceiver = null
      extensionReceiver = null
      signature = KaFunctionSignature:
        receiverType = null
        returnType = kotlin.Nothing
        symbol = kotlin/TODO(reason: kotlin.String): kotlin.Nothing
        valueParameters = [
          KaVariableSignature:
            name = reason
            receiverType = null
            returnType = kotlin.String
            symbol = reason: kotlin.String
            contextParameters = []
            callableId = null
        ]
        contextParameters = []
        callableId = kotlin/TODO
      typeArgumentsMapping = {}
      valueArgumentMapping = {}
    diagnostic = ERROR<NO_VALUE_FOR_PARAMETER: No value passed for parameter 'reason'.>
    isInBestCandidates = false

KtValueArgumentList(724,726): '()'
  NO_CANDIDATES

KtProperty(736,770): 'val lambdaProp = {InheritorObject}'
  NO_CANDIDATES

KtLambdaExpression(753,770): '{InheritorObject}'
  NO_CANDIDATES

KtFunctionLiteral(753,770): '{InheritorObject}'
  NO_CANDIDATES

KtBlockExpression(754,769): 'InheritorObject'
  NO_CANDIDATES

KtNameReferenceExpression(754,769): 'InheritorObject'
  KaInapplicableCallCandidate:
    candidate = KaSimpleFunctionCall:
      contextArgumentMapping = {}
      contextArguments = []
      dispatchReceiver = null
      extensionReceiver = null
      signature = KaFunctionSignature:
        receiverType = null
        returnType = MyClass.InheritorObject
        symbol = <constructor>(): MyClass.InheritorObject
        valueParameters = []
        contextParameters = []
        callableId = null
      typeArgumentsMapping = {}
      valueArgumentMapping = {}
    diagnostic = ERROR<OTHER_ERROR: Inapplicable candidate>
    isInBestCandidates = false

KtNamedFunction(779,814): 'fun <T>receiveLambda(l: () -> T) {}'
  NO_CANDIDATES

KtTypeParameterList(783,786): '<T>'
  NO_CANDIDATES

KtTypeParameter(784,785): 'T'
  NO_CANDIDATES

KtParameterList(799,811): '(l: () -> T)'
  NO_CANDIDATES

KtParameter(800,810): 'l: () -> T'
  NO_CANDIDATES

KtTypeReference(803,810): '() -> T'
  NO_CANDIDATES

KtFunctionType(803,810): '() -> T'
  NO_CANDIDATES

KtParameterList(803,805): '()'
  NO_CANDIDATES

KtTypeReference(809,810): 'T'
  NO_CANDIDATES

KtUserType(809,810): 'T'
  NO_CANDIDATES

KtNameReferenceExpression(809,810): 'T'
  NO_CANDIDATES

KtBlockExpression(812,814): '{}'
  NO_CANDIDATES

KtNamedFunction(816,1409): 'fun testReceivedLambda() {'
  NO_CANDIDATES

KtParameterList(838,840): '()'
  NO_CANDIDATES

KtBlockExpression(841,1409): '{'
  NO_CANDIDATES

KtCallExpression(847,889): 'receiveLambda<MyClass> { InheritorObject }'
  KaApplicableCallCandidate:
    candidate = KaSimpleFunctionCall:
      contextArgumentMapping = {}
      contextArguments = []
      dispatchReceiver = null
      extensionReceiver = null
      signature = KaFunctionSignature:
        receiverType = null
        returnType = kotlin.Unit
        symbol = /receiveLambda(l: () -> T): kotlin.Unit
        valueParameters = [
          KaVariableSignature:
            name = l
            receiverType = null
            returnType = () -> MyClass
            symbol = l: () -> T
            contextParameters = []
            callableId = null
        ]
        contextParameters = []
        callableId = /receiveLambda
      typeArgumentsMapping = {
        T -> (MyClass)
      }
      valueArgumentMapping = {
        { InheritorObject } -> (KaVariableSignature:
          name = l
          receiverType = null
          returnType = () -> MyClass
          symbol = l: () -> T
          contextParameters = []
          callableId = null)
      }
    isInBestCandidates = true

KtNameReferenceExpression(847,860): 'receiveLambda'
  KaApplicableCallCandidate:
    candidate = KaSimpleFunctionCall:
      contextArgumentMapping = {}
      contextArguments = []
      dispatchReceiver = null
      extensionReceiver = null
      signature = KaFunctionSignature:
        receiverType = null
        returnType = kotlin.Unit
        symbol = /receiveLambda(l: () -> T): kotlin.Unit
        valueParameters = [
          KaVariableSignature:
            name = l
            receiverType = null
            returnType = () -> MyClass
            symbol = l: () -> T
            contextParameters = []
            callableId = null
        ]
        contextParameters = []
        callableId = /receiveLambda
      typeArgumentsMapping = {
        T -> (MyClass)
      }
      valueArgumentMapping = {
        { InheritorObject } -> (KaVariableSignature:
          name = l
          receiverType = null
          returnType = () -> MyClass
          symbol = l: () -> T
          contextParameters = []
          callableId = null)
      }
    isInBestCandidates = true

KtTypeArgumentList(860,869): '<MyClass>'
  NO_CANDIDATES

KtTypeProjection(861,868): 'MyClass'
  NO_CANDIDATES

KtTypeReference(861,868): 'MyClass'
  NO_CANDIDATES

KtUserType(861,868): 'MyClass'
  NO_CANDIDATES

KtNameReferenceExpression(861,868): 'MyClass'
  NO_CANDIDATES

KtLambdaArgument(870,889): '{ InheritorObject }'
  NO_CANDIDATES

KtLambdaExpression(870,889): '{ InheritorObject }'
  NO_CANDIDATES

KtFunctionLiteral(870,889): '{ InheritorObject }'
  NO_CANDIDATES

KtBlockExpression(872,887): 'InheritorObject'
  NO_CANDIDATES

KtNameReferenceExpression(872,887): 'InheritorObject'
  KaInapplicableCallCandidate:
    candidate = KaSimpleFunctionCall:
      contextArgumentMapping = {}
      contextArguments = []
      dispatchReceiver = null
      extensionReceiver = null
      signature = KaFunctionSignature:
        receiverType = null
        returnType = MyClass.InheritorObject
        symbol = <constructor>(): MyClass.InheritorObject
        valueParameters = []
        contextParameters = []
        callableId = null
      typeArgumentsMapping = {}
      valueArgumentMapping = {}
    diagnostic = ERROR<OTHER_ERROR: Inapplicable candidate>
    isInBestCandidates = false

KtCallExpression(894,932): 'receiveLambda<MyClass> { propMyClass }'
  KaApplicableCallCandidate:
    candidate = KaSimpleFunctionCall:
      contextArgumentMapping = {}
      contextArguments = []
      dispatchReceiver = null
      extensionReceiver = null
      signature = KaFunctionSignature:
        receiverType = null
        returnType = kotlin.Unit
        symbol = /receiveLambda(l: () -> T): kotlin.Unit
        valueParameters = [
          KaVariableSignature:
            name = l
            receiverType = null
            returnType = () -> MyClass
            symbol = l: () -> T
            contextParameters = []
            callableId = null
        ]
        contextParameters = []
        callableId = /receiveLambda
      typeArgumentsMapping = {
        T -> (MyClass)
      }
      valueArgumentMapping = {
        { propMyClass } -> (KaVariableSignature:
          name = l
          receiverType = null
          returnType = () -> MyClass
          symbol = l: () -> T
          contextParameters = []
          callableId = null)
      }
    isInBestCandidates = true

KtNameReferenceExpression(894,907): 'receiveLambda'
  KaApplicableCallCandidate:
    candidate = KaSimpleFunctionCall:
      contextArgumentMapping = {}
      contextArguments = []
      dispatchReceiver = null
      extensionReceiver = null
      signature = KaFunctionSignature:
        receiverType = null
        returnType = kotlin.Unit
        symbol = /receiveLambda(l: () -> T): kotlin.Unit
        valueParameters = [
          KaVariableSignature:
            name = l
            receiverType = null
            returnType = () -> MyClass
            symbol = l: () -> T
            contextParameters = []
            callableId = null
        ]
        contextParameters = []
        callableId = /receiveLambda
      typeArgumentsMapping = {
        T -> (MyClass)
      }
      valueArgumentMapping = {
        { propMyClass } -> (KaVariableSignature:
          name = l
          receiverType = null
          returnType = () -> MyClass
          symbol = l: () -> T
          contextParameters = []
          callableId = null)
      }
    isInBestCandidates = true

KtTypeArgumentList(907,916): '<MyClass>'
  NO_CANDIDATES

KtTypeProjection(908,915): 'MyClass'
  NO_CANDIDATES

KtTypeReference(908,915): 'MyClass'
  NO_CANDIDATES

KtUserType(908,915): 'MyClass'
  NO_CANDIDATES

KtNameReferenceExpression(908,915): 'MyClass'
  NO_CANDIDATES

KtLambdaArgument(917,932): '{ propMyClass }'
  NO_CANDIDATES

KtLambdaExpression(917,932): '{ propMyClass }'
  NO_CANDIDATES

KtFunctionLiteral(917,932): '{ propMyClass }'
  NO_CANDIDATES

KtBlockExpression(919,930): 'propMyClass'
  NO_CANDIDATES

KtNameReferenceExpression(919,930): 'propMyClass'
  KaApplicableCallCandidate:
    candidate = KaSimpleVariableAccessCall:
      contextArguments = []
      dispatchReceiver = KaExplicitReceiverValue:
        expression = propMyClass
        isSafeNavigation = false
        type = MyClass.Companion
      extensionReceiver = null
      isContextSensitive = true
      kind = Read
      signature = KaVariableSignature:
        name = propMyClass
        receiverType = null
        returnType = MyClass
        symbol = val propMyClass: MyClass
        contextParameters = []
        callableId = /MyClass.Companion.propMyClass
      typeArgumentsMapping = {}
    isInBestCandidates = true

KtCallExpression(937,982): 'receiveLambda<MyClass> { propInheritorClass }'
  KaApplicableCallCandidate:
    candidate = KaSimpleFunctionCall:
      contextArgumentMapping = {}
      contextArguments = []
      dispatchReceiver = null
      extensionReceiver = null
      signature = KaFunctionSignature:
        receiverType = null
        returnType = kotlin.Unit
        symbol = /receiveLambda(l: () -> T): kotlin.Unit
        valueParameters = [
          KaVariableSignature:
            name = l
            receiverType = null
            returnType = () -> MyClass
            symbol = l: () -> T
            contextParameters = []
            callableId = null
        ]
        contextParameters = []
        callableId = /receiveLambda
      typeArgumentsMapping = {
        T -> (MyClass)
      }
      valueArgumentMapping = {
        { propInheritorClass } -> (KaVariableSignature:
          name = l
          receiverType = null
          returnType = () -> MyClass
          symbol = l: () -> T
          contextParameters = []
          callableId = null)
      }
    isInBestCandidates = true

KtNameReferenceExpression(937,950): 'receiveLambda'
  KaApplicableCallCandidate:
    candidate = KaSimpleFunctionCall:
      contextArgumentMapping = {}
      contextArguments = []
      dispatchReceiver = null
      extensionReceiver = null
      signature = KaFunctionSignature:
        receiverType = null
        returnType = kotlin.Unit
        symbol = /receiveLambda(l: () -> T): kotlin.Unit
        valueParameters = [
          KaVariableSignature:
            name = l
            receiverType = null
            returnType = () -> MyClass
            symbol = l: () -> T
            contextParameters = []
            callableId = null
        ]
        contextParameters = []
        callableId = /receiveLambda
      typeArgumentsMapping = {
        T -> (MyClass)
      }
      valueArgumentMapping = {
        { propInheritorClass } -> (KaVariableSignature:
          name = l
          receiverType = null
          returnType = () -> MyClass
          symbol = l: () -> T
          contextParameters = []
          callableId = null)
      }
    isInBestCandidates = true

KtTypeArgumentList(950,959): '<MyClass>'
  NO_CANDIDATES

KtTypeProjection(951,958): 'MyClass'
  NO_CANDIDATES

KtTypeReference(951,958): 'MyClass'
  NO_CANDIDATES

KtUserType(951,958): 'MyClass'
  NO_CANDIDATES

KtNameReferenceExpression(951,958): 'MyClass'
  NO_CANDIDATES

KtLambdaArgument(960,982): '{ propInheritorClass }'
  NO_CANDIDATES

KtLambdaExpression(960,982): '{ propInheritorClass }'
  NO_CANDIDATES

KtFunctionLiteral(960,982): '{ propInheritorClass }'
  NO_CANDIDATES

KtBlockExpression(962,980): 'propInheritorClass'
  NO_CANDIDATES

KtNameReferenceExpression(962,980): 'propInheritorClass'
  KaApplicableCallCandidate:
    candidate = KaSimpleVariableAccessCall:
      contextArguments = []
      dispatchReceiver = KaExplicitReceiverValue:
        expression = propInheritorClass
        isSafeNavigation = false
        type = MyClass.Companion
      extensionReceiver = null
      isContextSensitive = true
      kind = Read
      signature = KaVariableSignature:
        name = propInheritorClass
        receiverType = null
        returnType = MyClass.InheritorClass
        symbol = val propInheritorClass: MyClass.InheritorClass
        contextParameters = []
        callableId = /MyClass.Companion.propInheritorClass
      typeArgumentsMapping = {}
    isInBestCandidates = true

KtCallExpression(987,1033): 'receiveLambda<MyClass> { propInheritorObject }'
  KaApplicableCallCandidate:
    candidate = KaSimpleFunctionCall:
      contextArgumentMapping = {}
      contextArguments = []
      dispatchReceiver = null
      extensionReceiver = null
      signature = KaFunctionSignature:
        receiverType = null
        returnType = kotlin.Unit
        symbol = /receiveLambda(l: () -> T): kotlin.Unit
        valueParameters = [
          KaVariableSignature:
            name = l
            receiverType = null
            returnType = () -> MyClass
            symbol = l: () -> T
            contextParameters = []
            callableId = null
        ]
        contextParameters = []
        callableId = /receiveLambda
      typeArgumentsMapping = {
        T -> (MyClass)
      }
      valueArgumentMapping = {
        { propInheritorObject } -> (KaVariableSignature:
          name = l
          receiverType = null
          returnType = () -> MyClass
          symbol = l: () -> T
          contextParameters = []
          callableId = null)
      }
    isInBestCandidates = true

KtNameReferenceExpression(987,1000): 'receiveLambda'
  KaApplicableCallCandidate:
    candidate = KaSimpleFunctionCall:
      contextArgumentMapping = {}
      contextArguments = []
      dispatchReceiver = null
      extensionReceiver = null
      signature = KaFunctionSignature:
        receiverType = null
        returnType = kotlin.Unit
        symbol = /receiveLambda(l: () -> T): kotlin.Unit
        valueParameters = [
          KaVariableSignature:
            name = l
            receiverType = null
            returnType = () -> MyClass
            symbol = l: () -> T
            contextParameters = []
            callableId = null
        ]
        contextParameters = []
        callableId = /receiveLambda
      typeArgumentsMapping = {
        T -> (MyClass)
      }
      valueArgumentMapping = {
        { propInheritorObject } -> (KaVariableSignature:
          name = l
          receiverType = null
          returnType = () -> MyClass
          symbol = l: () -> T
          contextParameters = []
          callableId = null)
      }
    isInBestCandidates = true

KtTypeArgumentList(1000,1009): '<MyClass>'
  NO_CANDIDATES

KtTypeProjection(1001,1008): 'MyClass'
  NO_CANDIDATES

KtTypeReference(1001,1008): 'MyClass'
  NO_CANDIDATES

KtUserType(1001,1008): 'MyClass'
  NO_CANDIDATES

KtNameReferenceExpression(1001,1008): 'MyClass'
  NO_CANDIDATES

KtLambdaArgument(1010,1033): '{ propInheritorObject }'
  NO_CANDIDATES

KtLambdaExpression(1010,1033): '{ propInheritorObject }'
  NO_CANDIDATES

KtFunctionLiteral(1010,1033): '{ propInheritorObject }'
  NO_CANDIDATES

KtBlockExpression(1012,1031): 'propInheritorObject'
  NO_CANDIDATES

KtNameReferenceExpression(1012,1031): 'propInheritorObject'
  KaApplicableCallCandidate:
    candidate = KaSimpleVariableAccessCall:
      contextArguments = []
      dispatchReceiver = KaExplicitReceiverValue:
        expression = propInheritorObject
        isSafeNavigation = false
        type = MyClass.Companion
      extensionReceiver = null
      isContextSensitive = true
      kind = Read
      signature = KaVariableSignature:
        name = propInheritorObject
        receiverType = null
        returnType = MyClass.InheritorObject
        symbol = val propInheritorObject: MyClass.InheritorObject
        contextParameters = []
        callableId = /MyClass.Companion.propInheritorObject
      typeArgumentsMapping = {}
    isInBestCandidates = true

KtCallExpression(1039,1070): 'receiveLambda<MyClass> { prop }'
  KaInapplicableCallCandidate:
    candidate = KaSimpleFunctionCall:
      contextArgumentMapping = {}
      contextArguments = []
      dispatchReceiver = null
      extensionReceiver = null
      signature = KaFunctionSignature:
        receiverType = null
        returnType = kotlin.Unit
        symbol = /receiveLambda(l: () -> T): kotlin.Unit
        valueParameters = [
          KaVariableSignature:
            name = l
            receiverType = null
            returnType = () -> MyClass
            symbol = l: () -> T
            contextParameters = []
            callableId = null
        ]
        contextParameters = []
        callableId = /receiveLambda
      typeArgumentsMapping = {
        T -> (MyClass)
      }
      valueArgumentMapping = {
        { prop } -> (KaVariableSignature:
          name = l
          receiverType = null
          returnType = () -> MyClass
          symbol = l: () -> T
          contextParameters = []
          callableId = null)
      }
    diagnostic = ERROR<INAPPLICABLE_CANDIDATE: Inapplicable candidate(s): fun <T> receiveLambda(l: () -> T): Unit>
    isInBestCandidates = true

KtNameReferenceExpression(1039,1052): 'receiveLambda'
  KaInapplicableCallCandidate:
    candidate = KaSimpleFunctionCall:
      contextArgumentMapping = {}
      contextArguments = []
      dispatchReceiver = null
      extensionReceiver = null
      signature = KaFunctionSignature:
        receiverType = null
        returnType = kotlin.Unit
        symbol = /receiveLambda(l: () -> T): kotlin.Unit
        valueParameters = [
          KaVariableSignature:
            name = l
            receiverType = null
            returnType = () -> MyClass
            symbol = l: () -> T
            contextParameters = []
            callableId = null
        ]
        contextParameters = []
        callableId = /receiveLambda
      typeArgumentsMapping = {
        T -> (MyClass)
      }
      valueArgumentMapping = {
        { prop } -> (KaVariableSignature:
          name = l
          receiverType = null
          returnType = () -> MyClass
          symbol = l: () -> T
          contextParameters = []
          callableId = null)
      }
    diagnostic = ERROR<INAPPLICABLE_CANDIDATE: Inapplicable candidate(s): fun <T> receiveLambda(l: () -> T): Unit>
    isInBestCandidates = true

KtTypeArgumentList(1052,1061): '<MyClass>'
  NO_CANDIDATES

KtTypeProjection(1053,1060): 'MyClass'
  NO_CANDIDATES

KtTypeReference(1053,1060): 'MyClass'
  NO_CANDIDATES

KtUserType(1053,1060): 'MyClass'
  NO_CANDIDATES

KtNameReferenceExpression(1053,1060): 'MyClass'
  NO_CANDIDATES

KtLambdaArgument(1062,1070): '{ prop }'
  NO_CANDIDATES

KtLambdaExpression(1062,1070): '{ prop }'
  NO_CANDIDATES

KtFunctionLiteral(1062,1070): '{ prop }'
  NO_CANDIDATES

KtBlockExpression(1064,1068): 'prop'
  NO_CANDIDATES

KtNameReferenceExpression(1064,1068): 'prop'
  KaApplicableCallCandidate:
    candidate = KaSimpleVariableAccessCall:
      contextArguments = []
      dispatchReceiver = KaExplicitReceiverValue:
        expression = prop
        isSafeNavigation = false
        type = MyClass.Companion
      extensionReceiver = null
      isContextSensitive = true
      kind = Read
      signature = KaVariableSignature:
        name = prop
        receiverType = null
        returnType = kotlin.String
        symbol = val prop: kotlin.String
        contextParameters = []
        callableId = /MyClass.Companion.prop
      typeArgumentsMapping = {}
    isInBestCandidates = true

KtCallExpression(1075,1111): 'receiveLambda<MyClass> { superProp }'
  KaInapplicableCallCandidate:
    candidate = KaSimpleFunctionCall:
      contextArgumentMapping = {}
      contextArguments = []
      dispatchReceiver = null
      extensionReceiver = null
      signature = KaFunctionSignature:
        receiverType = null
        returnType = kotlin.Unit
        symbol = /receiveLambda(l: () -> T): kotlin.Unit
        valueParameters = [
          KaVariableSignature:
            name = l
            receiverType = null
            returnType = () -> MyClass
            symbol = l: () -> T
            contextParameters = []
            callableId = null
        ]
        contextParameters = []
        callableId = /receiveLambda
      typeArgumentsMapping = {
        T -> (MyClass)
      }
      valueArgumentMapping = {
        { superProp } -> (KaVariableSignature:
          name = l
          receiverType = null
          returnType = () -> MyClass
          symbol = l: () -> T
          contextParameters = []
          callableId = null)
      }
    diagnostic = ERROR<INAPPLICABLE_CANDIDATE: Inapplicable candidate(s): fun <T> receiveLambda(l: () -> T): Unit>
    isInBestCandidates = true

KtNameReferenceExpression(1075,1088): 'receiveLambda'
  KaInapplicableCallCandidate:
    candidate = KaSimpleFunctionCall:
      contextArgumentMapping = {}
      contextArguments = []
      dispatchReceiver = null
      extensionReceiver = null
      signature = KaFunctionSignature:
        receiverType = null
        returnType = kotlin.Unit
        symbol = /receiveLambda(l: () -> T): kotlin.Unit
        valueParameters = [
          KaVariableSignature:
            name = l
            receiverType = null
            returnType = () -> MyClass
            symbol = l: () -> T
            contextParameters = []
            callableId = null
        ]
        contextParameters = []
        callableId = /receiveLambda
      typeArgumentsMapping = {
        T -> (MyClass)
      }
      valueArgumentMapping = {
        { superProp } -> (KaVariableSignature:
          name = l
          receiverType = null
          returnType = () -> MyClass
          symbol = l: () -> T
          contextParameters = []
          callableId = null)
      }
    diagnostic = ERROR<INAPPLICABLE_CANDIDATE: Inapplicable candidate(s): fun <T> receiveLambda(l: () -> T): Unit>
    isInBestCandidates = true

KtTypeArgumentList(1088,1097): '<MyClass>'
  NO_CANDIDATES

KtTypeProjection(1089,1096): 'MyClass'
  NO_CANDIDATES

KtTypeReference(1089,1096): 'MyClass'
  NO_CANDIDATES

KtUserType(1089,1096): 'MyClass'
  NO_CANDIDATES

KtNameReferenceExpression(1089,1096): 'MyClass'
  NO_CANDIDATES

KtLambdaArgument(1098,1111): '{ superProp }'
  NO_CANDIDATES

KtLambdaExpression(1098,1111): '{ superProp }'
  NO_CANDIDATES

KtFunctionLiteral(1098,1111): '{ superProp }'
  NO_CANDIDATES

KtBlockExpression(1100,1109): 'superProp'
  NO_CANDIDATES

KtNameReferenceExpression(1100,1109): 'superProp'
  KaApplicableCallCandidate:
    candidate = KaSimpleVariableAccessCall:
      contextArguments = []
      dispatchReceiver = KaExplicitReceiverValue:
        expression = superProp
        isSafeNavigation = false
        type = MyClass.Companion
      extensionReceiver = null
      isContextSensitive = true
      kind = Read
      signature = KaVariableSignature:
        name = superProp
        receiverType = null
        returnType = kotlin.String
        symbol = val superProp: kotlin.String
        contextParameters = []
        callableId = /Super.superProp
      typeArgumentsMapping = {}
    isInBestCandidates = true

KtCallExpression(1116,1152): 'receiveLambda<MyClass> { constProp }'
  KaInapplicableCallCandidate:
    candidate = KaSimpleFunctionCall:
      contextArgumentMapping = {}
      contextArguments = []
      dispatchReceiver = null
      extensionReceiver = null
      signature = KaFunctionSignature:
        receiverType = null
        returnType = kotlin.Unit
        symbol = /receiveLambda(l: () -> T): kotlin.Unit
        valueParameters = [
          KaVariableSignature:
            name = l
            receiverType = null
            returnType = () -> MyClass
            symbol = l: () -> T
            contextParameters = []
            callableId = null
        ]
        contextParameters = []
        callableId = /receiveLambda
      typeArgumentsMapping = {
        T -> (MyClass)
      }
      valueArgumentMapping = {
        { constProp } -> (KaVariableSignature:
          name = l
          receiverType = null
          returnType = () -> MyClass
          symbol = l: () -> T
          contextParameters = []
          callableId = null)
      }
    diagnostic = ERROR<INAPPLICABLE_CANDIDATE: Inapplicable candidate(s): fun <T> receiveLambda(l: () -> T): Unit>
    isInBestCandidates = true

KtNameReferenceExpression(1116,1129): 'receiveLambda'
  KaInapplicableCallCandidate:
    candidate = KaSimpleFunctionCall:
      contextArgumentMapping = {}
      contextArguments = []
      dispatchReceiver = null
      extensionReceiver = null
      signature = KaFunctionSignature:
        receiverType = null
        returnType = kotlin.Unit
        symbol = /receiveLambda(l: () -> T): kotlin.Unit
        valueParameters = [
          KaVariableSignature:
            name = l
            receiverType = null
            returnType = () -> MyClass
            symbol = l: () -> T
            contextParameters = []
            callableId = null
        ]
        contextParameters = []
        callableId = /receiveLambda
      typeArgumentsMapping = {
        T -> (MyClass)
      }
      valueArgumentMapping = {
        { constProp } -> (KaVariableSignature:
          name = l
          receiverType = null
          returnType = () -> MyClass
          symbol = l: () -> T
          contextParameters = []
          callableId = null)
      }
    diagnostic = ERROR<INAPPLICABLE_CANDIDATE: Inapplicable candidate(s): fun <T> receiveLambda(l: () -> T): Unit>
    isInBestCandidates = true

KtTypeArgumentList(1129,1138): '<MyClass>'
  NO_CANDIDATES

KtTypeProjection(1130,1137): 'MyClass'
  NO_CANDIDATES

KtTypeReference(1130,1137): 'MyClass'
  NO_CANDIDATES

KtUserType(1130,1137): 'MyClass'
  NO_CANDIDATES

KtNameReferenceExpression(1130,1137): 'MyClass'
  NO_CANDIDATES

KtLambdaArgument(1139,1152): '{ constProp }'
  NO_CANDIDATES

KtLambdaExpression(1139,1152): '{ constProp }'
  NO_CANDIDATES

KtFunctionLiteral(1139,1152): '{ constProp }'
  NO_CANDIDATES

KtBlockExpression(1141,1150): 'constProp'
  NO_CANDIDATES

KtNameReferenceExpression(1141,1150): 'constProp'
  KaApplicableCallCandidate:
    candidate = KaSimpleVariableAccessCall:
      contextArguments = []
      dispatchReceiver = KaExplicitReceiverValue:
        expression = constProp
        isSafeNavigation = false
        type = MyClass.Companion
      extensionReceiver = null
      isContextSensitive = true
      kind = Read
      signature = KaVariableSignature:
        name = constProp
        receiverType = null
        returnType = kotlin.String
        symbol = val constProp: kotlin.String
        contextParameters = []
        callableId = /MyClass.Companion.constProp
      typeArgumentsMapping = {}
    isInBestCandidates = true

KtCallExpression(1157,1194): 'receiveLambda<MyClass> { lambdaProp }'
  KaInapplicableCallCandidate:
    candidate = KaSimpleFunctionCall:
      contextArgumentMapping = {}
      contextArguments = []
      dispatchReceiver = null
      extensionReceiver = null
      signature = KaFunctionSignature:
        receiverType = null
        returnType = kotlin.Unit
        symbol = /receiveLambda(l: () -> T): kotlin.Unit
        valueParameters = [
          KaVariableSignature:
            name = l
            receiverType = null
            returnType = () -> MyClass
            symbol = l: () -> T
            contextParameters = []
            callableId = null
        ]
        contextParameters = []
        callableId = /receiveLambda
      typeArgumentsMapping = {
        T -> (MyClass)
      }
      valueArgumentMapping = {
        { lambdaProp } -> (KaVariableSignature:
          name = l
          receiverType = null
          returnType = () -> MyClass
          symbol = l: () -> T
          contextParameters = []
          callableId = null)
      }
    diagnostic = ERROR<INAPPLICABLE_CANDIDATE: Inapplicable candidate(s): fun <T> receiveLambda(l: () -> T): Unit>
    isInBestCandidates = true

KtNameReferenceExpression(1157,1170): 'receiveLambda'
  KaInapplicableCallCandidate:
    candidate = KaSimpleFunctionCall:
      contextArgumentMapping = {}
      contextArguments = []
      dispatchReceiver = null
      extensionReceiver = null
      signature = KaFunctionSignature:
        receiverType = null
        returnType = kotlin.Unit
        symbol = /receiveLambda(l: () -> T): kotlin.Unit
        valueParameters = [
          KaVariableSignature:
            name = l
            receiverType = null
            returnType = () -> MyClass
            symbol = l: () -> T
            contextParameters = []
            callableId = null
        ]
        contextParameters = []
        callableId = /receiveLambda
      typeArgumentsMapping = {
        T -> (MyClass)
      }
      valueArgumentMapping = {
        { lambdaProp } -> (KaVariableSignature:
          name = l
          receiverType = null
          returnType = () -> MyClass
          symbol = l: () -> T
          contextParameters = []
          callableId = null)
      }
    diagnostic = ERROR<INAPPLICABLE_CANDIDATE: Inapplicable candidate(s): fun <T> receiveLambda(l: () -> T): Unit>
    isInBestCandidates = true

KtTypeArgumentList(1170,1179): '<MyClass>'
  NO_CANDIDATES

KtTypeProjection(1171,1178): 'MyClass'
  NO_CANDIDATES

KtTypeReference(1171,1178): 'MyClass'
  NO_CANDIDATES

KtUserType(1171,1178): 'MyClass'
  NO_CANDIDATES

KtNameReferenceExpression(1171,1178): 'MyClass'
  NO_CANDIDATES

KtLambdaArgument(1180,1194): '{ lambdaProp }'
  NO_CANDIDATES

KtLambdaExpression(1180,1194): '{ lambdaProp }'
  NO_CANDIDATES

KtFunctionLiteral(1180,1194): '{ lambdaProp }'
  NO_CANDIDATES

KtBlockExpression(1182,1192): 'lambdaProp'
  NO_CANDIDATES

KtNameReferenceExpression(1182,1192): 'lambdaProp'
  KaApplicableCallCandidate:
    candidate = KaSimpleVariableAccessCall:
      contextArguments = []
      dispatchReceiver = KaExplicitReceiverValue:
        expression = lambdaProp
        isSafeNavigation = false
        type = MyClass.Companion
      extensionReceiver = null
      isContextSensitive = true
      kind = Read
      signature = KaVariableSignature:
        name = lambdaProp
        receiverType = null
        returnType = () -> MyClass.InheritorObject
        symbol = val lambdaProp: () -> MyClass.InheritorObject
        contextParameters = []
        callableId = /MyClass.Companion.lambdaProp
      typeArgumentsMapping = {}
    isInBestCandidates = true

KtCallExpression(1199,1234): 'receiveLambda<MyClass> { lazyProp }'
  KaInapplicableCallCandidate:
    candidate = KaSimpleFunctionCall:
      contextArgumentMapping = {}
      contextArguments = []
      dispatchReceiver = null
      extensionReceiver = null
      signature = KaFunctionSignature:
        receiverType = null
        returnType = kotlin.Unit
        symbol = /receiveLambda(l: () -> T): kotlin.Unit
        valueParameters = [
          KaVariableSignature:
            name = l
            receiverType = null
            returnType = () -> MyClass
            symbol = l: () -> T
            contextParameters = []
            callableId = null
        ]
        contextParameters = []
        callableId = /receiveLambda
      typeArgumentsMapping = {
        T -> (MyClass)
      }
      valueArgumentMapping = {
        { lazyProp } -> (KaVariableSignature:
          name = l
          receiverType = null
          returnType = () -> MyClass
          symbol = l: () -> T
          contextParameters = []
          callableId = null)
      }
    diagnostic = ERROR<INAPPLICABLE_CANDIDATE: Inapplicable candidate(s): fun <T> receiveLambda(l: () -> T): Unit>
    isInBestCandidates = true

KtNameReferenceExpression(1199,1212): 'receiveLambda'
  KaInapplicableCallCandidate:
    candidate = KaSimpleFunctionCall:
      contextArgumentMapping = {}
      contextArguments = []
      dispatchReceiver = null
      extensionReceiver = null
      signature = KaFunctionSignature:
        receiverType = null
        returnType = kotlin.Unit
        symbol = /receiveLambda(l: () -> T): kotlin.Unit
        valueParameters = [
          KaVariableSignature:
            name = l
            receiverType = null
            returnType = () -> MyClass
            symbol = l: () -> T
            contextParameters = []
            callableId = null
        ]
        contextParameters = []
        callableId = /receiveLambda
      typeArgumentsMapping = {
        T -> (MyClass)
      }
      valueArgumentMapping = {
        { lazyProp } -> (KaVariableSignature:
          name = l
          receiverType = null
          returnType = () -> MyClass
          symbol = l: () -> T
          contextParameters = []
          callableId = null)
      }
    diagnostic = ERROR<INAPPLICABLE_CANDIDATE: Inapplicable candidate(s): fun <T> receiveLambda(l: () -> T): Unit>
    isInBestCandidates = true

KtTypeArgumentList(1212,1221): '<MyClass>'
  NO_CANDIDATES

KtTypeProjection(1213,1220): 'MyClass'
  NO_CANDIDATES

KtTypeReference(1213,1220): 'MyClass'
  NO_CANDIDATES

KtUserType(1213,1220): 'MyClass'
  NO_CANDIDATES

KtNameReferenceExpression(1213,1220): 'MyClass'
  NO_CANDIDATES

KtLambdaArgument(1222,1234): '{ lazyProp }'
  NO_CANDIDATES

KtLambdaExpression(1222,1234): '{ lazyProp }'
  NO_CANDIDATES

KtFunctionLiteral(1222,1234): '{ lazyProp }'
  NO_CANDIDATES

KtBlockExpression(1224,1232): 'lazyProp'
  NO_CANDIDATES

KtNameReferenceExpression(1224,1232): 'lazyProp'
  KaApplicableCallCandidate:
    candidate = KaSimpleVariableAccessCall:
      contextArguments = []
      dispatchReceiver = KaExplicitReceiverValue:
        expression = lazyProp
        isSafeNavigation = false
        type = MyClass.Companion
      extensionReceiver = null
      isContextSensitive = true
      kind = Read
      signature = KaVariableSignature:
        name = lazyProp
        receiverType = null
        returnType = kotlin.String
        symbol = val lazyProp: kotlin.String
        contextParameters = []
        callableId = /MyClass.Companion.lazyProp
      typeArgumentsMapping = {}
    isInBestCandidates = true

KtCallExpression(1239,1277): 'receiveLambda<MyClass> { NestedObject}'
  KaInapplicableCallCandidate:
    candidate = KaSimpleFunctionCall:
      contextArgumentMapping = {}
      contextArguments = []
      dispatchReceiver = null
      extensionReceiver = null
      signature = KaFunctionSignature:
        receiverType = null
        returnType = kotlin.Unit
        symbol = /receiveLambda(l: () -> T): kotlin.Unit
        valueParameters = [
          KaVariableSignature:
            name = l
            receiverType = null
            returnType = () -> MyClass
            symbol = l: () -> T
            contextParameters = []
            callableId = null
        ]
        contextParameters = []
        callableId = /receiveLambda
      typeArgumentsMapping = {
        T -> (MyClass)
      }
      valueArgumentMapping = {
        { NestedObject} -> (KaVariableSignature:
          name = l
          receiverType = null
          returnType = () -> MyClass
          symbol = l: () -> T
          contextParameters = []
          callableId = null)
      }
    diagnostic = ERROR<INAPPLICABLE_CANDIDATE: Inapplicable candidate(s): fun <T> receiveLambda(l: () -> T): Unit>
    isInBestCandidates = true

KtNameReferenceExpression(1239,1252): 'receiveLambda'
  KaInapplicableCallCandidate:
    candidate = KaSimpleFunctionCall:
      contextArgumentMapping = {}
      contextArguments = []
      dispatchReceiver = null
      extensionReceiver = null
      signature = KaFunctionSignature:
        receiverType = null
        returnType = kotlin.Unit
        symbol = /receiveLambda(l: () -> T): kotlin.Unit
        valueParameters = [
          KaVariableSignature:
            name = l
            receiverType = null
            returnType = () -> MyClass
            symbol = l: () -> T
            contextParameters = []
            callableId = null
        ]
        contextParameters = []
        callableId = /receiveLambda
      typeArgumentsMapping = {
        T -> (MyClass)
      }
      valueArgumentMapping = {
        { NestedObject} -> (KaVariableSignature:
          name = l
          receiverType = null
          returnType = () -> MyClass
          symbol = l: () -> T
          contextParameters = []
          callableId = null)
      }
    diagnostic = ERROR<INAPPLICABLE_CANDIDATE: Inapplicable candidate(s): fun <T> receiveLambda(l: () -> T): Unit>
    isInBestCandidates = true

KtTypeArgumentList(1252,1261): '<MyClass>'
  NO_CANDIDATES

KtTypeProjection(1253,1260): 'MyClass'
  NO_CANDIDATES

KtTypeReference(1253,1260): 'MyClass'
  NO_CANDIDATES

KtUserType(1253,1260): 'MyClass'
  NO_CANDIDATES

KtNameReferenceExpression(1253,1260): 'MyClass'
  NO_CANDIDATES

KtLambdaArgument(1262,1277): '{ NestedObject}'
  NO_CANDIDATES

KtLambdaExpression(1262,1277): '{ NestedObject}'
  NO_CANDIDATES

KtFunctionLiteral(1262,1277): '{ NestedObject}'
  NO_CANDIDATES

KtBlockExpression(1264,1276): 'NestedObject'
  NO_CANDIDATES

KtNameReferenceExpression(1264,1276): 'NestedObject'
  KaInapplicableCallCandidate:
    candidate = KaSimpleFunctionCall:
      contextArgumentMapping = {}
      contextArguments = []
      dispatchReceiver = null
      extensionReceiver = null
      signature = KaFunctionSignature:
        receiverType = null
        returnType = MyClass.NestedObject
        symbol = <constructor>(): MyClass.NestedObject
        valueParameters = []
        contextParameters = []
        callableId = null
      typeArgumentsMapping = {}
      valueArgumentMapping = {}
    diagnostic = ERROR<OTHER_ERROR: Inapplicable candidate>
    isInBestCandidates = false

KtCallExpression(1283,1316): 'receiveLambda<MyClass> { func() }'
  KaInapplicableCallCandidate:
    candidate = KaSimpleFunctionCall:
      contextArgumentMapping = {}
      contextArguments = []
      dispatchReceiver = null
      extensionReceiver = null
      signature = KaFunctionSignature:
        receiverType = null
        returnType = kotlin.Unit
        symbol = /receiveLambda(l: () -> T): kotlin.Unit
        valueParameters = [
          KaVariableSignature:
            name = l
            receiverType = null
            returnType = () -> MyClass
            symbol = l: () -> T
            contextParameters = []
            callableId = null
        ]
        contextParameters = []
        callableId = /receiveLambda
      typeArgumentsMapping = {
        T -> (MyClass)
      }
      valueArgumentMapping = {
        { func() } -> (KaVariableSignature:
          name = l
          receiverType = null
          returnType = () -> MyClass
          symbol = l: () -> T
          contextParameters = []
          callableId = null)
      }
    diagnostic = ERROR<INAPPLICABLE_CANDIDATE: Inapplicable candidate(s): fun <T> receiveLambda(l: () -> T): Unit>
    isInBestCandidates = true

KtNameReferenceExpression(1283,1296): 'receiveLambda'
  KaInapplicableCallCandidate:
    candidate = KaSimpleFunctionCall:
      contextArgumentMapping = {}
      contextArguments = []
      dispatchReceiver = null
      extensionReceiver = null
      signature = KaFunctionSignature:
        receiverType = null
        returnType = kotlin.Unit
        symbol = /receiveLambda(l: () -> T): kotlin.Unit
        valueParameters = [
          KaVariableSignature:
            name = l
            receiverType = null
            returnType = () -> MyClass
            symbol = l: () -> T
            contextParameters = []
            callableId = null
        ]
        contextParameters = []
        callableId = /receiveLambda
      typeArgumentsMapping = {
        T -> (MyClass)
      }
      valueArgumentMapping = {
        { func() } -> (KaVariableSignature:
          name = l
          receiverType = null
          returnType = () -> MyClass
          symbol = l: () -> T
          contextParameters = []
          callableId = null)
      }
    diagnostic = ERROR<INAPPLICABLE_CANDIDATE: Inapplicable candidate(s): fun <T> receiveLambda(l: () -> T): Unit>
    isInBestCandidates = true

KtTypeArgumentList(1296,1305): '<MyClass>'
  NO_CANDIDATES

KtTypeProjection(1297,1304): 'MyClass'
  NO_CANDIDATES

KtTypeReference(1297,1304): 'MyClass'
  NO_CANDIDATES

KtUserType(1297,1304): 'MyClass'
  NO_CANDIDATES

KtNameReferenceExpression(1297,1304): 'MyClass'
  NO_CANDIDATES

KtLambdaArgument(1306,1316): '{ func() }'
  NO_CANDIDATES

KtLambdaExpression(1306,1316): '{ func() }'
  NO_CANDIDATES

KtFunctionLiteral(1306,1316): '{ func() }'
  NO_CANDIDATES

KtBlockExpression(1308,1314): 'func()'
  NO_CANDIDATES

KtCallExpression(1308,1314): 'func()'
  NO_CANDIDATES

KtNameReferenceExpression(1308,1312): 'func'
  NO_CANDIDATES

KtValueArgumentList(1312,1314): '()'
  NO_CANDIDATES

KtCallExpression(1321,1364): 'receiveLambda<MyClass> { InheritorClass() }'
  KaInapplicableCallCandidate:
    candidate = KaSimpleFunctionCall:
      contextArgumentMapping = {}
      contextArguments = []
      dispatchReceiver = null
      extensionReceiver = null
      signature = KaFunctionSignature:
        receiverType = null
        returnType = kotlin.Unit
        symbol = /receiveLambda(l: () -> T): kotlin.Unit
        valueParameters = [
          KaVariableSignature:
            name = l
            receiverType = null
            returnType = () -> MyClass
            symbol = l: () -> T
            contextParameters = []
            callableId = null
        ]
        contextParameters = []
        callableId = /receiveLambda
      typeArgumentsMapping = {
        T -> (MyClass)
      }
      valueArgumentMapping = {
        { InheritorClass() } -> (KaVariableSignature:
          name = l
          receiverType = null
          returnType = () -> MyClass
          symbol = l: () -> T
          contextParameters = []
          callableId = null)
      }
    diagnostic = ERROR<INAPPLICABLE_CANDIDATE: Inapplicable candidate(s): fun <T> receiveLambda(l: () -> T): Unit>
    isInBestCandidates = true

KtNameReferenceExpression(1321,1334): 'receiveLambda'
  KaInapplicableCallCandidate:
    candidate = KaSimpleFunctionCall:
      contextArgumentMapping = {}
      contextArguments = []
      dispatchReceiver = null
      extensionReceiver = null
      signature = KaFunctionSignature:
        receiverType = null
        returnType = kotlin.Unit
        symbol = /receiveLambda(l: () -> T): kotlin.Unit
        valueParameters = [
          KaVariableSignature:
            name = l
            receiverType = null
            returnType = () -> MyClass
            symbol = l: () -> T
            contextParameters = []
            callableId = null
        ]
        contextParameters = []
        callableId = /receiveLambda
      typeArgumentsMapping = {
        T -> (MyClass)
      }
      valueArgumentMapping = {
        { InheritorClass() } -> (KaVariableSignature:
          name = l
          receiverType = null
          returnType = () -> MyClass
          symbol = l: () -> T
          contextParameters = []
          callableId = null)
      }
    diagnostic = ERROR<INAPPLICABLE_CANDIDATE: Inapplicable candidate(s): fun <T> receiveLambda(l: () -> T): Unit>
    isInBestCandidates = true

KtTypeArgumentList(1334,1343): '<MyClass>'
  NO_CANDIDATES

KtTypeProjection(1335,1342): 'MyClass'
  NO_CANDIDATES

KtTypeReference(1335,1342): 'MyClass'
  NO_CANDIDATES

KtUserType(1335,1342): 'MyClass'
  NO_CANDIDATES

KtNameReferenceExpression(1335,1342): 'MyClass'
  NO_CANDIDATES

KtLambdaArgument(1344,1364): '{ InheritorClass() }'
  NO_CANDIDATES

KtLambdaExpression(1344,1364): '{ InheritorClass() }'
  NO_CANDIDATES

KtFunctionLiteral(1344,1364): '{ InheritorClass() }'
  NO_CANDIDATES

KtBlockExpression(1346,1362): 'InheritorClass()'
  NO_CANDIDATES

KtCallExpression(1346,1362): 'InheritorClass()'
  NO_CANDIDATES

KtNameReferenceExpression(1346,1360): 'InheritorClass'
  NO_CANDIDATES

KtValueArgumentList(1360,1362): '()'
  NO_CANDIDATES

KtCallExpression(1369,1407): 'receiveLambda<MyClass> { superFunc() }'
  KaInapplicableCallCandidate:
    candidate = KaSimpleFunctionCall:
      contextArgumentMapping = {}
      contextArguments = []
      dispatchReceiver = null
      extensionReceiver = null
      signature = KaFunctionSignature:
        receiverType = null
        returnType = kotlin.Unit
        symbol = /receiveLambda(l: () -> T): kotlin.Unit
        valueParameters = [
          KaVariableSignature:
            name = l
            receiverType = null
            returnType = () -> MyClass
            symbol = l: () -> T
            contextParameters = []
            callableId = null
        ]
        contextParameters = []
        callableId = /receiveLambda
      typeArgumentsMapping = {
        T -> (MyClass)
      }
      valueArgumentMapping = {
        { superFunc() } -> (KaVariableSignature:
          name = l
          receiverType = null
          returnType = () -> MyClass
          symbol = l: () -> T
          contextParameters = []
          callableId = null)
      }
    diagnostic = ERROR<INAPPLICABLE_CANDIDATE: Inapplicable candidate(s): fun <T> receiveLambda(l: () -> T): Unit>
    isInBestCandidates = true

KtNameReferenceExpression(1369,1382): 'receiveLambda'
  KaInapplicableCallCandidate:
    candidate = KaSimpleFunctionCall:
      contextArgumentMapping = {}
      contextArguments = []
      dispatchReceiver = null
      extensionReceiver = null
      signature = KaFunctionSignature:
        receiverType = null
        returnType = kotlin.Unit
        symbol = /receiveLambda(l: () -> T): kotlin.Unit
        valueParameters = [
          KaVariableSignature:
            name = l
            receiverType = null
            returnType = () -> MyClass
            symbol = l: () -> T
            contextParameters = []
            callableId = null
        ]
        contextParameters = []
        callableId = /receiveLambda
      typeArgumentsMapping = {
        T -> (MyClass)
      }
      valueArgumentMapping = {
        { superFunc() } -> (KaVariableSignature:
          name = l
          receiverType = null
          returnType = () -> MyClass
          symbol = l: () -> T
          contextParameters = []
          callableId = null)
      }
    diagnostic = ERROR<INAPPLICABLE_CANDIDATE: Inapplicable candidate(s): fun <T> receiveLambda(l: () -> T): Unit>
    isInBestCandidates = true

KtTypeArgumentList(1382,1391): '<MyClass>'
  NO_CANDIDATES

KtTypeProjection(1383,1390): 'MyClass'
  NO_CANDIDATES

KtTypeReference(1383,1390): 'MyClass'
  NO_CANDIDATES

KtUserType(1383,1390): 'MyClass'
  NO_CANDIDATES

KtNameReferenceExpression(1383,1390): 'MyClass'
  NO_CANDIDATES

KtLambdaArgument(1392,1407): '{ superFunc() }'
  NO_CANDIDATES

KtLambdaExpression(1392,1407): '{ superFunc() }'
  NO_CANDIDATES

KtFunctionLiteral(1392,1407): '{ superFunc() }'
  NO_CANDIDATES

KtBlockExpression(1394,1405): 'superFunc()'
  NO_CANDIDATES

KtCallExpression(1394,1405): 'superFunc()'
  NO_CANDIDATES

KtNameReferenceExpression(1394,1403): 'superFunc'
  NO_CANDIDATES

KtValueArgumentList(1403,1405): '()'
  NO_CANDIDATES
