KtFile: 'contextParameters.kt'
  null

KtPackageDirective(0,0): ''
  null

KtImportList(0,0): ''
  null

KtClass(98,135): 'enum class MyEnum {'
  null

KtDeclarationModifierList(98,102): 'enum'
  null

KtClassBody(116,135): '{'
  null

KtEnumEntry(122,133): 'EnumValue1;'
  null

KtClass(137,204): 'sealed class MySealed {'
  null

KtDeclarationModifierList(137,143): 'sealed'
  null

KtClassBody(159,204): '{'
  null

KtObjectDeclaration(165,202): 'object InheritorObject: MySealed() {}'
  null

KtSuperTypeList(189,199): 'MySealed()'
  null

KtSuperTypeCallEntry(189,199): 'MySealed()'
  KaCallResolutionSuccess:
    call = KaDelegatedConstructorCall:
      contextArgumentMapping = {}
      contextArguments = []
      dispatchReceiver = null
      extensionReceiver = null
      kind = SUPER_CALL
      signature = KaFunctionSignature:
        receiverType = null
        returnType = MySealed
        symbol = <constructor>(): MySealed
        valueParameters = []
        contextParameters = []
        callableId = null
      typeArgumentsMapping = {}
      valueArgumentMapping = {}

KtConstructorCalleeExpression(189,197): 'MySealed'
  KaCallResolutionSuccess:
    call = KaDelegatedConstructorCall:
      contextArgumentMapping = {}
      contextArguments = []
      dispatchReceiver = null
      extensionReceiver = null
      kind = SUPER_CALL
      signature = KaFunctionSignature:
        receiverType = null
        returnType = MySealed
        symbol = <constructor>(): MySealed
        valueParameters = []
        contextParameters = []
        callableId = null
      typeArgumentsMapping = {}
      valueArgumentMapping = {}

KtTypeReference(189,197): 'MySealed'
  null

KtUserType(189,197): 'MySealed'
  null

KtNameReferenceExpression(189,197): 'MySealed'
  KaCallResolutionSuccess:
    call = KaDelegatedConstructorCall:
      contextArgumentMapping = {}
      contextArguments = []
      dispatchReceiver = null
      extensionReceiver = null
      kind = SUPER_CALL
      signature = KaFunctionSignature:
        receiverType = null
        returnType = MySealed
        symbol = <constructor>(): MySealed
        valueParameters = []
        contextParameters = []
        callableId = null
      typeArgumentsMapping = {}
      valueArgumentMapping = {}

KtValueArgumentList(197,199): '()'
  null

KtClassBody(200,202): '{}'
  null

KtNamedFunction(206,237): 'context(i: MyEnum)'
  null

KtDeclarationModifierList(206,224): 'context(i: MyEnum)'
  null

KtContextReceiverList(206,224): 'context(i: MyEnum)'
  null

KtParameter(214,223): 'i: MyEnum'
  null

KtTypeReference(217,223): 'MyEnum'
  null

KtUserType(217,223): 'MyEnum'
  null

KtNameReferenceExpression(217,223): 'MyEnum'
  null

KtParameterList(232,234): '()'
  null

KtBlockExpression(235,237): '{}'
  null

KtNamedFunction(239,272): 'context(i: MySealed)'
  null

KtDeclarationModifierList(239,259): 'context(i: MySealed)'
  null

KtContextReceiverList(239,259): 'context(i: MySealed)'
  null

KtParameter(247,258): 'i: MySealed'
  null

KtTypeReference(250,258): 'MySealed'
  null

KtUserType(250,258): 'MySealed'
  null

KtNameReferenceExpression(250,258): 'MySealed'
  null

KtParameterList(267,269): '()'
  null

KtBlockExpression(270,272): '{}'
  null

KtNamedFunction(274,416): 'fun testWithEnum() {'
  null

KtParameterList(290,292): '()'
  null

KtBlockExpression(293,416): '{'
  null

KtCallExpression(299,350): 'with<MyEnum, Unit>(EnumValue1){'
  KaCallResolutionSuccess:
    call = KaSimpleFunctionCall:
      contextArgumentMapping = {}
      contextArguments = []
      dispatchReceiver = null
      extensionReceiver = null
      signature = KaFunctionSignature:
        receiverType = null
        returnType = kotlin.Unit
        symbol = kotlin/with(receiver: T, block: T.() -> R): R
        valueParameters = [
          KaVariableSignature:
            name = receiver
            receiverType = null
            returnType = MyEnum
            symbol = receiver: T
            contextParameters = []
            callableId = null,
          KaVariableSignature:
            name = block
            receiverType = null
            returnType = MyEnum.() -> kotlin.Unit
            symbol = block: T.() -> R
            contextParameters = []
            callableId = null
        ]
        contextParameters = []
        callableId = kotlin/with
      typeArgumentsMapping = {
        T -> (MyEnum),
        R -> (kotlin.Unit)
      }
      valueArgumentMapping = {
        EnumValue1 -> (KaVariableSignature:
          name = receiver
          receiverType = null
          returnType = MyEnum
          symbol = receiver: T
          contextParameters = []
          callableId = null),
        {
                foo()
            } -> (KaVariableSignature:
          name = block
          receiverType = null
          returnType = MyEnum.() -> kotlin.Unit
          symbol = block: T.() -> R
          contextParameters = []
          callableId = null)
      }

KtNameReferenceExpression(299,303): 'with'
  KaCallResolutionSuccess:
    call = KaSimpleFunctionCall:
      contextArgumentMapping = {}
      contextArguments = []
      dispatchReceiver = null
      extensionReceiver = null
      signature = KaFunctionSignature:
        receiverType = null
        returnType = kotlin.Unit
        symbol = kotlin/with(receiver: T, block: T.() -> R): R
        valueParameters = [
          KaVariableSignature:
            name = receiver
            receiverType = null
            returnType = MyEnum
            symbol = receiver: T
            contextParameters = []
            callableId = null,
          KaVariableSignature:
            name = block
            receiverType = null
            returnType = MyEnum.() -> kotlin.Unit
            symbol = block: T.() -> R
            contextParameters = []
            callableId = null
        ]
        contextParameters = []
        callableId = kotlin/with
      typeArgumentsMapping = {
        T -> (MyEnum),
        R -> (kotlin.Unit)
      }
      valueArgumentMapping = {
        EnumValue1 -> (KaVariableSignature:
          name = receiver
          receiverType = null
          returnType = MyEnum
          symbol = receiver: T
          contextParameters = []
          callableId = null),
        {
                foo()
            } -> (KaVariableSignature:
          name = block
          receiverType = null
          returnType = MyEnum.() -> kotlin.Unit
          symbol = block: T.() -> R
          contextParameters = []
          callableId = null)
      }

KtTypeArgumentList(303,317): '<MyEnum, Unit>'
  null

KtTypeProjection(304,310): 'MyEnum'
  null

KtTypeReference(304,310): 'MyEnum'
  null

KtUserType(304,310): 'MyEnum'
  null

KtNameReferenceExpression(304,310): 'MyEnum'
  null

KtTypeProjection(312,316): 'Unit'
  null

KtTypeReference(312,316): 'Unit'
  null

KtUserType(312,316): 'Unit'
  null

KtNameReferenceExpression(312,316): 'Unit'
  null

KtValueArgumentList(317,329): '(EnumValue1)'
  null

KtValueArgument(318,328): 'EnumValue1'
  null

KtNameReferenceExpression(318,328): 'EnumValue1'
  KaCallResolutionSuccess:
    call = KaSimpleVariableAccessCall:
      contextArguments = []
      dispatchReceiver = KaExplicitReceiverValue:
        expression = EnumValue1
        isSafeNavigation = false
        type = kotlin.Unit
      extensionReceiver = null
      isContextSensitive = true
      kind = Read
      signature = KaVariableSignature:
        name = EnumValue1
        receiverType = null
        returnType = MyEnum
        symbol = /MyEnum.EnumValue1
        contextParameters = []
        callableId = /MyEnum.EnumValue1
      typeArgumentsMapping = {}

KtLambdaArgument(329,350): '{'
  null

KtLambdaExpression(329,350): '{'
  null

KtFunctionLiteral(329,350): '{'
  null

KtBlockExpression(339,344): 'foo()'
  null

KtCallExpression(339,344): 'foo()'
  KaCallResolutionSuccess:
    call = KaSimpleFunctionCall:
      contextArgumentMapping = {}
      contextArguments = [
        KaImplicitReceiverValue:
          symbol = KaReceiverParameterSymbol:
            anchorPsi: KtFunctionLiteral
            annotations: []
            callableId: null
            contextParameters: []
            contextReceivers: []
            isActual: false
            isCompanion: false
            isDelegated: false
            isExpect: false
            isExtension: false
            isExternal: false
            isVal: true
            location: LOCAL
            modality: FINAL
            name: <receiver>
            origin: SOURCE
            owningCallableSymbol: KaAnonymousFunctionSymbol(<local>/<no name provided>)
            psi: KtFunctionLiteral
            realPsi: KtFunctionLiteral
            receiverParameter: null
            returnType: KaUsualClassType:
              annotations: []
              typeArguments: []
              type: MyEnum
            typeParameters: []
            visibility: PUBLIC
          type = MyEnum
      ]
      dispatchReceiver = null
      extensionReceiver = null
      signature = KaFunctionSignature:
        receiverType = null
        returnType = kotlin.Unit
        symbol = /foo(): kotlin.Unit
        valueParameters = []
        contextParameters = [
          KaVariableSignature:
            name = i
            receiverType = null
            returnType = MyEnum
            symbol = i: MyEnum
            contextParameters = []
            callableId = null
        ]
        callableId = /foo
      typeArgumentsMapping = {}
      valueArgumentMapping = {}

KtNameReferenceExpression(339,342): 'foo'
  KaCallResolutionSuccess:
    call = KaSimpleFunctionCall:
      contextArgumentMapping = {}
      contextArguments = [
        KaImplicitReceiverValue:
          symbol = KaReceiverParameterSymbol:
            anchorPsi: KtFunctionLiteral
            annotations: []
            callableId: null
            contextParameters: []
            contextReceivers: []
            isActual: false
            isCompanion: false
            isDelegated: false
            isExpect: false
            isExtension: false
            isExternal: false
            isVal: true
            location: LOCAL
            modality: FINAL
            name: <receiver>
            origin: SOURCE
            owningCallableSymbol: KaAnonymousFunctionSymbol(<local>/<no name provided>)
            psi: KtFunctionLiteral
            realPsi: KtFunctionLiteral
            receiverParameter: null
            returnType: KaUsualClassType:
              annotations: []
              typeArguments: []
              type: MyEnum
            typeParameters: []
            visibility: PUBLIC
          type = MyEnum
      ]
      dispatchReceiver = null
      extensionReceiver = null
      signature = KaFunctionSignature:
        receiverType = null
        returnType = kotlin.Unit
        symbol = /foo(): kotlin.Unit
        valueParameters = []
        contextParameters = [
          KaVariableSignature:
            name = i
            receiverType = null
            returnType = MyEnum
            symbol = i: MyEnum
            contextParameters = []
            callableId = null
        ]
        callableId = /foo
      typeArgumentsMapping = {}
      valueArgumentMapping = {}

KtValueArgumentList(342,344): '()'
  null

KtCallExpression(356,414): 'with<MySealed, Unit>(InheritorObject){'
  KaCallResolutionSuccess:
    call = KaSimpleFunctionCall:
      contextArgumentMapping = {}
      contextArguments = []
      dispatchReceiver = null
      extensionReceiver = null
      signature = KaFunctionSignature:
        receiverType = null
        returnType = kotlin.Unit
        symbol = kotlin/with(receiver: T, block: T.() -> R): R
        valueParameters = [
          KaVariableSignature:
            name = receiver
            receiverType = null
            returnType = MySealed
            symbol = receiver: T
            contextParameters = []
            callableId = null,
          KaVariableSignature:
            name = block
            receiverType = null
            returnType = MySealed.() -> kotlin.Unit
            symbol = block: T.() -> R
            contextParameters = []
            callableId = null
        ]
        contextParameters = []
        callableId = kotlin/with
      typeArgumentsMapping = {
        T -> (MySealed),
        R -> (kotlin.Unit)
      }
      valueArgumentMapping = {
        InheritorObject -> (KaVariableSignature:
          name = receiver
          receiverType = null
          returnType = MySealed
          symbol = receiver: T
          contextParameters = []
          callableId = null),
        {
                foo()
            } -> (KaVariableSignature:
          name = block
          receiverType = null
          returnType = MySealed.() -> kotlin.Unit
          symbol = block: T.() -> R
          contextParameters = []
          callableId = null)
      }

KtNameReferenceExpression(356,360): 'with'
  KaCallResolutionSuccess:
    call = KaSimpleFunctionCall:
      contextArgumentMapping = {}
      contextArguments = []
      dispatchReceiver = null
      extensionReceiver = null
      signature = KaFunctionSignature:
        receiverType = null
        returnType = kotlin.Unit
        symbol = kotlin/with(receiver: T, block: T.() -> R): R
        valueParameters = [
          KaVariableSignature:
            name = receiver
            receiverType = null
            returnType = MySealed
            symbol = receiver: T
            contextParameters = []
            callableId = null,
          KaVariableSignature:
            name = block
            receiverType = null
            returnType = MySealed.() -> kotlin.Unit
            symbol = block: T.() -> R
            contextParameters = []
            callableId = null
        ]
        contextParameters = []
        callableId = kotlin/with
      typeArgumentsMapping = {
        T -> (MySealed),
        R -> (kotlin.Unit)
      }
      valueArgumentMapping = {
        InheritorObject -> (KaVariableSignature:
          name = receiver
          receiverType = null
          returnType = MySealed
          symbol = receiver: T
          contextParameters = []
          callableId = null),
        {
                foo()
            } -> (KaVariableSignature:
          name = block
          receiverType = null
          returnType = MySealed.() -> kotlin.Unit
          symbol = block: T.() -> R
          contextParameters = []
          callableId = null)
      }

KtTypeArgumentList(360,376): '<MySealed, Unit>'
  null

KtTypeProjection(361,369): 'MySealed'
  null

KtTypeReference(361,369): 'MySealed'
  null

KtUserType(361,369): 'MySealed'
  null

KtNameReferenceExpression(361,369): 'MySealed'
  null

KtTypeProjection(371,375): 'Unit'
  null

KtTypeReference(371,375): 'Unit'
  null

KtUserType(371,375): 'Unit'
  null

KtNameReferenceExpression(371,375): 'Unit'
  null

KtValueArgumentList(376,393): '(InheritorObject)'
  null

KtValueArgument(377,392): 'InheritorObject'
  null

KtNameReferenceExpression(377,392): 'InheritorObject'
  null

KtLambdaArgument(393,414): '{'
  null

KtLambdaExpression(393,414): '{'
  null

KtFunctionLiteral(393,414): '{'
  null

KtBlockExpression(403,408): 'foo()'
  null

KtCallExpression(403,408): 'foo()'
  KaCallResolutionSuccess:
    call = KaSimpleFunctionCall:
      contextArgumentMapping = {}
      contextArguments = [
        KaImplicitReceiverValue:
          symbol = KaReceiverParameterSymbol:
            anchorPsi: KtFunctionLiteral
            annotations: []
            callableId: null
            contextParameters: []
            contextReceivers: []
            isActual: false
            isCompanion: false
            isDelegated: false
            isExpect: false
            isExtension: false
            isExternal: false
            isVal: true
            location: LOCAL
            modality: FINAL
            name: <receiver>
            origin: SOURCE
            owningCallableSymbol: KaAnonymousFunctionSymbol(<local>/<no name provided>)
            psi: KtFunctionLiteral
            realPsi: KtFunctionLiteral
            receiverParameter: null
            returnType: KaUsualClassType:
              annotations: []
              typeArguments: []
              type: MySealed
            typeParameters: []
            visibility: PUBLIC
          type = MySealed
      ]
      dispatchReceiver = null
      extensionReceiver = null
      signature = KaFunctionSignature:
        receiverType = null
        returnType = kotlin.Unit
        symbol = /foo(): kotlin.Unit
        valueParameters = []
        contextParameters = [
          KaVariableSignature:
            name = i
            receiverType = null
            returnType = MySealed
            symbol = i: MySealed
            contextParameters = []
            callableId = null
        ]
        callableId = /foo
      typeArgumentsMapping = {}
      valueArgumentMapping = {}

KtNameReferenceExpression(403,406): 'foo'
  KaCallResolutionSuccess:
    call = KaSimpleFunctionCall:
      contextArgumentMapping = {}
      contextArguments = [
        KaImplicitReceiverValue:
          symbol = KaReceiverParameterSymbol:
            anchorPsi: KtFunctionLiteral
            annotations: []
            callableId: null
            contextParameters: []
            contextReceivers: []
            isActual: false
            isCompanion: false
            isDelegated: false
            isExpect: false
            isExtension: false
            isExternal: false
            isVal: true
            location: LOCAL
            modality: FINAL
            name: <receiver>
            origin: SOURCE
            owningCallableSymbol: KaAnonymousFunctionSymbol(<local>/<no name provided>)
            psi: KtFunctionLiteral
            realPsi: KtFunctionLiteral
            receiverParameter: null
            returnType: KaUsualClassType:
              annotations: []
              typeArguments: []
              type: MySealed
            typeParameters: []
            visibility: PUBLIC
          type = MySealed
      ]
      dispatchReceiver = null
      extensionReceiver = null
      signature = KaFunctionSignature:
        receiverType = null
        returnType = kotlin.Unit
        symbol = /foo(): kotlin.Unit
        valueParameters = []
        contextParameters = [
          KaVariableSignature:
            name = i
            receiverType = null
            returnType = MySealed
            symbol = i: MySealed
            contextParameters = []
            callableId = null
        ]
        callableId = /foo
      typeArgumentsMapping = {}
      valueArgumentMapping = {}

KtValueArgumentList(406,408): '()'
  null

KtProperty(418,472): 'context(i: MyEnum)'
  null

KtDeclarationModifierList(418,436): 'context(i: MyEnum)'
  null

KtContextReceiverList(418,436): 'context(i: MyEnum)'
  null

KtParameter(426,435): 'i: MyEnum'
  null

KtTypeReference(429,435): 'MyEnum'
  null

KtUserType(429,435): 'MyEnum'
  null

KtNameReferenceExpression(429,435): 'MyEnum'
  null

KtTypeReference(441,447): 'String'
  null

KtUserType(441,447): 'String'
  null

KtNameReferenceExpression(441,447): 'String'
  null

KtTypeReference(451,457): 'String'
  null

KtUserType(451,457): 'String'
  null

KtNameReferenceExpression(451,457): 'String'
  null

KtPropertyAccessor(462,472): 'get() = ""'
  null

KtParameterList(465,467): '()'
  null

KtStringTemplateExpression(470,472): '""'
  null

KtNamedFunction(474,560): 'fun testWithEnumWithProp() {'
  null

KtParameterList(498,500): '()'
  null

KtBlockExpression(501,560): '{'
  null

KtCallExpression(507,558): 'with<MyEnum, Unit>(EnumValue1) {'
  KaCallResolutionSuccess:
    call = KaSimpleFunctionCall:
      contextArgumentMapping = {}
      contextArguments = []
      dispatchReceiver = null
      extensionReceiver = null
      signature = KaFunctionSignature:
        receiverType = null
        returnType = kotlin.Unit
        symbol = kotlin/with(receiver: T, block: T.() -> R): R
        valueParameters = [
          KaVariableSignature:
            name = receiver
            receiverType = null
            returnType = MyEnum
            symbol = receiver: T
            contextParameters = []
            callableId = null,
          KaVariableSignature:
            name = block
            receiverType = null
            returnType = MyEnum.() -> kotlin.Unit
            symbol = block: T.() -> R
            contextParameters = []
            callableId = null
        ]
        contextParameters = []
        callableId = kotlin/with
      typeArgumentsMapping = {
        T -> (MyEnum),
        R -> (kotlin.Unit)
      }
      valueArgumentMapping = {
        EnumValue1 -> (KaVariableSignature:
          name = receiver
          receiverType = null
          returnType = MyEnum
          symbol = receiver: T
          contextParameters = []
          callableId = null),
        {
                "".a
            } -> (KaVariableSignature:
          name = block
          receiverType = null
          returnType = MyEnum.() -> kotlin.Unit
          symbol = block: T.() -> R
          contextParameters = []
          callableId = null)
      }

KtNameReferenceExpression(507,511): 'with'
  KaCallResolutionSuccess:
    call = KaSimpleFunctionCall:
      contextArgumentMapping = {}
      contextArguments = []
      dispatchReceiver = null
      extensionReceiver = null
      signature = KaFunctionSignature:
        receiverType = null
        returnType = kotlin.Unit
        symbol = kotlin/with(receiver: T, block: T.() -> R): R
        valueParameters = [
          KaVariableSignature:
            name = receiver
            receiverType = null
            returnType = MyEnum
            symbol = receiver: T
            contextParameters = []
            callableId = null,
          KaVariableSignature:
            name = block
            receiverType = null
            returnType = MyEnum.() -> kotlin.Unit
            symbol = block: T.() -> R
            contextParameters = []
            callableId = null
        ]
        contextParameters = []
        callableId = kotlin/with
      typeArgumentsMapping = {
        T -> (MyEnum),
        R -> (kotlin.Unit)
      }
      valueArgumentMapping = {
        EnumValue1 -> (KaVariableSignature:
          name = receiver
          receiverType = null
          returnType = MyEnum
          symbol = receiver: T
          contextParameters = []
          callableId = null),
        {
                "".a
            } -> (KaVariableSignature:
          name = block
          receiverType = null
          returnType = MyEnum.() -> kotlin.Unit
          symbol = block: T.() -> R
          contextParameters = []
          callableId = null)
      }

KtTypeArgumentList(511,525): '<MyEnum, Unit>'
  null

KtTypeProjection(512,518): 'MyEnum'
  null

KtTypeReference(512,518): 'MyEnum'
  null

KtUserType(512,518): 'MyEnum'
  null

KtNameReferenceExpression(512,518): 'MyEnum'
  null

KtTypeProjection(520,524): 'Unit'
  null

KtTypeReference(520,524): 'Unit'
  null

KtUserType(520,524): 'Unit'
  null

KtNameReferenceExpression(520,524): 'Unit'
  null

KtValueArgumentList(525,537): '(EnumValue1)'
  null

KtValueArgument(526,536): 'EnumValue1'
  null

KtNameReferenceExpression(526,536): 'EnumValue1'
  KaCallResolutionSuccess:
    call = KaSimpleVariableAccessCall:
      contextArguments = []
      dispatchReceiver = KaExplicitReceiverValue:
        expression = EnumValue1
        isSafeNavigation = false
        type = kotlin.Unit
      extensionReceiver = null
      isContextSensitive = true
      kind = Read
      signature = KaVariableSignature:
        name = EnumValue1
        receiverType = null
        returnType = MyEnum
        symbol = /MyEnum.EnumValue1
        contextParameters = []
        callableId = /MyEnum.EnumValue1
      typeArgumentsMapping = {}

KtLambdaArgument(538,558): '{'
  null

KtLambdaExpression(538,558): '{'
  null

KtFunctionLiteral(538,558): '{'
  null

KtBlockExpression(548,552): '"".a'
  null

KtDotQualifiedExpression(548,552): '"".a'
  KaCallResolutionSuccess:
    call = KaSimpleVariableAccessCall:
      contextArguments = [
        KaImplicitReceiverValue:
          symbol = KaReceiverParameterSymbol:
            anchorPsi: KtFunctionLiteral
            annotations: []
            callableId: null
            contextParameters: []
            contextReceivers: []
            isActual: false
            isCompanion: false
            isDelegated: false
            isExpect: false
            isExtension: false
            isExternal: false
            isVal: true
            location: LOCAL
            modality: FINAL
            name: <receiver>
            origin: SOURCE
            owningCallableSymbol: KaAnonymousFunctionSymbol(<local>/<no name provided>)
            psi: KtFunctionLiteral
            realPsi: KtFunctionLiteral
            receiverParameter: null
            returnType: KaUsualClassType:
              annotations: []
              typeArguments: []
              type: MyEnum
            typeParameters: []
            visibility: PUBLIC
          type = MyEnum
      ]
      dispatchReceiver = null
      extensionReceiver = KaExplicitReceiverValue:
        expression = ""
        isSafeNavigation = false
        type = kotlin.String
      isContextSensitive = false
      kind = Read
      signature = KaVariableSignature:
        name = a
        receiverType = kotlin.String
        returnType = kotlin.String
        symbol = val a: kotlin.String
        contextParameters = [
          KaVariableSignature:
            name = i
            receiverType = null
            returnType = MyEnum
            symbol = i: MyEnum
            contextParameters = []
            callableId = null
        ]
        callableId = /a
      typeArgumentsMapping = {}

KtStringTemplateExpression(548,550): '""'
  null

KtNameReferenceExpression(551,552): 'a'
  KaCallResolutionSuccess:
    call = KaSimpleVariableAccessCall:
      contextArguments = [
        KaImplicitReceiverValue:
          symbol = KaReceiverParameterSymbol:
            anchorPsi: KtFunctionLiteral
            annotations: []
            callableId: null
            contextParameters: []
            contextReceivers: []
            isActual: false
            isCompanion: false
            isDelegated: false
            isExpect: false
            isExtension: false
            isExternal: false
            isVal: true
            location: LOCAL
            modality: FINAL
            name: <receiver>
            origin: SOURCE
            owningCallableSymbol: KaAnonymousFunctionSymbol(<local>/<no name provided>)
            psi: KtFunctionLiteral
            realPsi: KtFunctionLiteral
            receiverParameter: null
            returnType: KaUsualClassType:
              annotations: []
              typeArguments: []
              type: MyEnum
            typeParameters: []
            visibility: PUBLIC
          type = MyEnum
      ]
      dispatchReceiver = null
      extensionReceiver = KaExplicitReceiverValue:
        expression = ""
        isSafeNavigation = false
        type = kotlin.String
      isContextSensitive = false
      kind = Read
      signature = KaVariableSignature:
        name = a
        receiverType = kotlin.String
        returnType = kotlin.String
        symbol = val a: kotlin.String
        contextParameters = [
          KaVariableSignature:
            name = i
            receiverType = null
            returnType = MyEnum
            symbol = i: MyEnum
            contextParameters = []
            callableId = null
        ]
        callableId = /a
      typeArgumentsMapping = {}
