KtFile: 'contextParameters.kt'
  NO_CANDIDATES

KtPackageDirective(0,0): ''
  NO_CANDIDATES

KtImportList(0,0): ''
  NO_CANDIDATES

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

KtDeclarationModifierList(98,102): 'enum'
  NO_CANDIDATES

KtClassBody(116,135): '{'
  NO_CANDIDATES

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

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

KtDeclarationModifierList(137,143): 'sealed'
  NO_CANDIDATES

KtClassBody(159,204): '{'
  NO_CANDIDATES

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

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

KtSuperTypeCallEntry(189,199): 'MySealed()'
  KaApplicableCallCandidate:
    candidate = 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 = {}
    isInBestCandidates = true

KtConstructorCalleeExpression(189,197): 'MySealed'
  KaApplicableCallCandidate:
    candidate = 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 = {}
    isInBestCandidates = true

KtTypeReference(189,197): 'MySealed'
  NO_CANDIDATES

KtUserType(189,197): 'MySealed'
  NO_CANDIDATES

KtNameReferenceExpression(189,197): 'MySealed'
  KaApplicableCallCandidate:
    candidate = 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 = {}
    isInBestCandidates = true

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

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

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

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

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

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

KtTypeReference(217,223): 'MyEnum'
  NO_CANDIDATES

KtUserType(217,223): 'MyEnum'
  NO_CANDIDATES

KtNameReferenceExpression(217,223): 'MyEnum'
  NO_CANDIDATES

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

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

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

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

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

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

KtTypeReference(250,258): 'MySealed'
  NO_CANDIDATES

KtUserType(250,258): 'MySealed'
  NO_CANDIDATES

KtNameReferenceExpression(250,258): 'MySealed'
  NO_CANDIDATES

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

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

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

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

KtBlockExpression(293,416): '{'
  NO_CANDIDATES

KtCallExpression(299,350): 'with<MyEnum, Unit>(EnumValue1){'
  KaApplicableCallCandidate:
    candidate = 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)
      }
    isInBestCandidates = true

KtNameReferenceExpression(299,303): 'with'
  KaApplicableCallCandidate:
    candidate = 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)
      }
    isInBestCandidates = true

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

KtTypeProjection(304,310): 'MyEnum'
  NO_CANDIDATES

KtTypeReference(304,310): 'MyEnum'
  NO_CANDIDATES

KtUserType(304,310): 'MyEnum'
  NO_CANDIDATES

KtNameReferenceExpression(304,310): 'MyEnum'
  NO_CANDIDATES

KtTypeProjection(312,316): 'Unit'
  NO_CANDIDATES

KtTypeReference(312,316): 'Unit'
  NO_CANDIDATES

KtUserType(312,316): 'Unit'
  NO_CANDIDATES

KtNameReferenceExpression(312,316): 'Unit'
  NO_CANDIDATES

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

KtValueArgument(318,328): 'EnumValue1'
  NO_CANDIDATES

KtNameReferenceExpression(318,328): 'EnumValue1'
  KaApplicableCallCandidate:
    candidate = 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 = {}
    isInBestCandidates = true

KtLambdaArgument(329,350): '{'
  NO_CANDIDATES

KtLambdaExpression(329,350): '{'
  NO_CANDIDATES

KtFunctionLiteral(329,350): '{'
  NO_CANDIDATES

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

KtCallExpression(339,344): 'foo()'
  KaApplicableCallCandidate:
    candidate = 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 = {}
    isInBestCandidates = true

  KaInapplicableCallCandidate:
    candidate = KaSimpleFunctionCall:
      contextArgumentMapping = {}
      contextArguments = []
      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 = {}
    diagnostic = ERROR<NO_CONTEXT_ARGUMENT: No context argument for 'i: MySealed' found.>
    isInBestCandidates = false

KtNameReferenceExpression(339,342): 'foo'
  KaApplicableCallCandidate:
    candidate = 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 = {}
    isInBestCandidates = true

  KaInapplicableCallCandidate:
    candidate = KaSimpleFunctionCall:
      contextArgumentMapping = {}
      contextArguments = []
      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 = {}
    diagnostic = ERROR<NO_CONTEXT_ARGUMENT: No context argument for 'i: MySealed' found.>
    isInBestCandidates = false

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

KtCallExpression(356,414): 'with<MySealed, Unit>(InheritorObject){'
  KaApplicableCallCandidate:
    candidate = 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)
      }
    isInBestCandidates = true

KtNameReferenceExpression(356,360): 'with'
  KaApplicableCallCandidate:
    candidate = 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)
      }
    isInBestCandidates = true

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

KtTypeProjection(361,369): 'MySealed'
  NO_CANDIDATES

KtTypeReference(361,369): 'MySealed'
  NO_CANDIDATES

KtUserType(361,369): 'MySealed'
  NO_CANDIDATES

KtNameReferenceExpression(361,369): 'MySealed'
  NO_CANDIDATES

KtTypeProjection(371,375): 'Unit'
  NO_CANDIDATES

KtTypeReference(371,375): 'Unit'
  NO_CANDIDATES

KtUserType(371,375): 'Unit'
  NO_CANDIDATES

KtNameReferenceExpression(371,375): 'Unit'
  NO_CANDIDATES

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

KtValueArgument(377,392): 'InheritorObject'
  NO_CANDIDATES

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

KtLambdaArgument(393,414): '{'
  NO_CANDIDATES

KtLambdaExpression(393,414): '{'
  NO_CANDIDATES

KtFunctionLiteral(393,414): '{'
  NO_CANDIDATES

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

KtCallExpression(403,408): 'foo()'
  KaApplicableCallCandidate:
    candidate = 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 = {}
    isInBestCandidates = true

  KaInapplicableCallCandidate:
    candidate = KaSimpleFunctionCall:
      contextArgumentMapping = {}
      contextArguments = []
      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 = {}
    diagnostic = ERROR<NO_CONTEXT_ARGUMENT: No context argument for 'i: MyEnum' found.>
    isInBestCandidates = false

KtNameReferenceExpression(403,406): 'foo'
  KaApplicableCallCandidate:
    candidate = 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 = {}
    isInBestCandidates = true

  KaInapplicableCallCandidate:
    candidate = KaSimpleFunctionCall:
      contextArgumentMapping = {}
      contextArguments = []
      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 = {}
    diagnostic = ERROR<NO_CONTEXT_ARGUMENT: No context argument for 'i: MyEnum' found.>
    isInBestCandidates = false

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

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

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

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

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

KtTypeReference(429,435): 'MyEnum'
  NO_CANDIDATES

KtUserType(429,435): 'MyEnum'
  NO_CANDIDATES

KtNameReferenceExpression(429,435): 'MyEnum'
  NO_CANDIDATES

KtTypeReference(441,447): 'String'
  NO_CANDIDATES

KtUserType(441,447): 'String'
  NO_CANDIDATES

KtNameReferenceExpression(441,447): 'String'
  NO_CANDIDATES

KtTypeReference(451,457): 'String'
  NO_CANDIDATES

KtUserType(451,457): 'String'
  NO_CANDIDATES

KtNameReferenceExpression(451,457): 'String'
  NO_CANDIDATES

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

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

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

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

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

KtBlockExpression(501,560): '{'
  NO_CANDIDATES

KtCallExpression(507,558): 'with<MyEnum, Unit>(EnumValue1) {'
  KaApplicableCallCandidate:
    candidate = 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)
      }
    isInBestCandidates = true

KtNameReferenceExpression(507,511): 'with'
  KaApplicableCallCandidate:
    candidate = 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)
      }
    isInBestCandidates = true

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

KtTypeProjection(512,518): 'MyEnum'
  NO_CANDIDATES

KtTypeReference(512,518): 'MyEnum'
  NO_CANDIDATES

KtUserType(512,518): 'MyEnum'
  NO_CANDIDATES

KtNameReferenceExpression(512,518): 'MyEnum'
  NO_CANDIDATES

KtTypeProjection(520,524): 'Unit'
  NO_CANDIDATES

KtTypeReference(520,524): 'Unit'
  NO_CANDIDATES

KtUserType(520,524): 'Unit'
  NO_CANDIDATES

KtNameReferenceExpression(520,524): 'Unit'
  NO_CANDIDATES

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

KtValueArgument(526,536): 'EnumValue1'
  NO_CANDIDATES

KtNameReferenceExpression(526,536): 'EnumValue1'
  KaApplicableCallCandidate:
    candidate = 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 = {}
    isInBestCandidates = true

KtLambdaArgument(538,558): '{'
  NO_CANDIDATES

KtLambdaExpression(538,558): '{'
  NO_CANDIDATES

KtFunctionLiteral(538,558): '{'
  NO_CANDIDATES

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

KtDotQualifiedExpression(548,552): '"".a'
  KaApplicableCallCandidate:
    candidate = 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 = {}
    isInBestCandidates = true

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

KtNameReferenceExpression(551,552): 'a'
  KaApplicableCallCandidate:
    candidate = 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 = {}
    isInBestCandidates = true
