plugins/plugin-sandbox/testData/box/metadataRegisteredInIr/classGeneratedAtIrLevel.ll.fir.txt

Module: a
FILE: src.kt
    public open class SourceBase : R|kotlin/Any| {
        public constructor(): R|SourceBase| {
            super<R|kotlin/Any|>()
        }

        public final val srcField: R|kotlin/String| = String(src)
            public get(): R|kotlin/String|

    }
    public final class SourceWithNested : R|kotlin/Any| {
        public constructor(): R|SourceWithNested| {
            super<R|kotlin/Any|>()
        }

    }
    public final class SourceWithCompanion : R|kotlin/Any| {
        public constructor(): R|SourceWithCompanion| {
            super<R|kotlin/Any|>()
        }

    }
    public final class SourceOuterPlain : R|kotlin/Any| {
        public constructor(): R|SourceOuterPlain| {
            super<R|kotlin/Any|>()
        }

    }
    public final class SourceOuterPlain2 : R|kotlin/Any| {
        public constructor(): R|SourceOuterPlain2| {
            super<R|kotlin/Any|>()
        }

    }
    public final class SourceOuterGeneric<T> : R|kotlin/Any| {
        public constructor<T>(): R|SourceOuterGeneric<T>| {
            super<R|kotlin/Any|>()
        }

    }
    public final class SourceOuterGenericPaired<T> : R|kotlin/Any| {
        public constructor<T>(): R|SourceOuterGenericPaired<T>| {
            super<R|kotlin/Any|>()
        }

    }
    public abstract interface Box<T> : R|kotlin/Any| {
        public abstract val value: R|T|
            public get(): R|T|

    }
    @R|org/jetbrains/kotlin/plugin/sandbox/GenerateClassFamily|() public final class Marker : R|kotlin/Any| {
        public constructor(): R|Marker| {
            super<R|kotlin/Any|>()
        }

    }
Module: b
FILE: main.kt
    public final fun box(): R|kotlin/String| {
        lval plain: <ERROR TYPE REF: Unresolved name: Plain> = <Unresolved name: Plain>#()
        when () {
            !=(R|<local>/plain|.<Unresolved name: x>#, Int(42)) ->  {
                ^box <strcat>(String(FAIL plain.x: ), R|<local>/plain|.<Unresolved name: x>#)
            }
        }

        when () {
            !=(R|<local>/plain|.<Unresolved name: foo>#(), String(ok)) ->  {
                ^box <strcat>(String(FAIL plain.foo: ), R|<local>/plain|.<Unresolved name: foo>#())
            }
        }

        lval generic: <ERROR TYPE REF: Unresolved name: WithGeneric> = <Unresolved name: WithGeneric>#<R|kotlin/String|>()
        when () {
            !=(R|<local>/generic|.<Unresolved name: x>#, Int(42)) ->  {
                ^box <strcat>(String(FAIL generic.x: ), R|<local>/generic|.<Unresolved name: x>#)
            }
        }

        when () {
            !=(R|<local>/generic|.<Unresolved name: foo>#(), String(ok)) ->  {
                ^box <strcat>(String(FAIL generic.foo: ), R|<local>/generic|.<Unresolved name: foo>#())
            }
        }

        lval es: <ERROR TYPE REF: Unresolved name: ExtendsSource> = <Unresolved name: ExtendsSource>#()
        when () {
            !=(R|<local>/es|.<Unresolved name: x>#, Int(42)) ->  {
                ^box <strcat>(String(FAIL es.x: ), R|<local>/es|.<Unresolved name: x>#)
            }
        }

        when () {
            !=(R|<local>/es|.<Unresolved name: foo>#(), String(ok)) ->  {
                ^box <strcat>(String(FAIL es.foo: ), R|<local>/es|.<Unresolved name: foo>#())
            }
        }

        when () {
            !=(R|<local>/es|.<Unresolved name: srcField>#, String(src)) ->  {
                ^box <strcat>(String(FAIL es.srcField (inherited from source): ), R|<local>/es|.<Unresolved name: srcField>#)
            }
        }

        lval ep: <ERROR TYPE REF: Unresolved name: ExtendsPlain> = <Unresolved name: ExtendsPlain>#()
        when () {
            !=(R|<local>/ep|.<Unresolved name: x>#, Int(42)) ->  {
                ^box <strcat>(String(FAIL ep.x (inherited from Plain): ), R|<local>/ep|.<Unresolved name: x>#)
            }
        }

        when () {
            !=(R|<local>/ep|.<Unresolved name: foo>#(), String(ok)) ->  {
                ^box <strcat>(String(FAIL ep.foo (inherited from Plain): ), R|<local>/ep|.<Unresolved name: foo>#())
            }
        }

        lval s: <ERROR TYPE REF: Symbol not found for MySealed> = <Unresolved name: SubA>#()
        lval tag: R|kotlin/String| = when (lval <when-subject>: <ERROR TYPE REF: Symbol not found for MySealed> = R|<local>/s|) {
            ($subj$ is <ERROR TYPE REF: Symbol not found for SubA>) ->  {
                String(a)
            }
            ($subj$ is <ERROR TYPE REF: Symbol not found for SubB>) ->  {
                String(b)
            }
        }

        when () {
            !=(R|<local>/tag|, String(a)) ->  {
                ^box <strcat>(String(FAIL sealed when: ), R|<local>/tag|)
            }
        }

        when () {
            !=(R|<local>/s|.<Unresolved name: x>#, Int(42)) ->  {
                ^box <strcat>(String(FAIL sealed inherited x: ), R|<local>/s|.<Unresolved name: x>#)
            }
        }

        lval nested: <ERROR TYPE REF: Unresolved name: Nested> = Q|SourceWithNested|.<Unresolved name: Nested>#()
        when () {
            !=(R|<local>/nested|.<Unresolved name: x>#, Int(42)) ->  {
                ^box <strcat>(String(FAIL nested.x: ), R|<local>/nested|.<Unresolved name: x>#)
            }
        }

        when () {
            !=(R|<local>/nested|.<Unresolved name: foo>#(), String(ok)) ->  {
                ^box <strcat>(String(FAIL nested.foo: ), R|<local>/nested|.<Unresolved name: foo>#())
            }
        }

        when () {
            !=(Q|SourceWithCompanion|.<Unresolved name: x>#, Int(42)) ->  {
                ^box <strcat>(String(FAIL companion.x: ), Q|SourceWithCompanion|.<Unresolved name: x>#)
            }
        }

        lval inner: <ERROR TYPE REF: Unresolved name: Inner> = <Unresolved name: WithNestedFamily>#.<Unresolved name: Inner>#()
        when () {
            !=(R|<local>/inner|.<Unresolved name: x>#, Int(42)) ->  {
                ^box <strcat>(String(FAIL inner.x: ), R|<local>/inner|.<Unresolved name: x>#)
            }
        }

        when () {
            !=(<Unresolved name: WithNestedFamily>#.<Unresolved name: fromCompanion>#(), String(from-companion)) ->  {
                ^box String(FAIL companion fn)
            }
        }

        lval innerA: <ERROR TYPE REF: Unresolved name: InnerPlain> = R|/SourceOuterPlain.SourceOuterPlain|().<Unresolved name: InnerPlain>#()
        when () {
            !=(R|<local>/innerA|.<Unresolved name: x>#, Int(42)) ->  {
                ^box <strcat>(String(FAIL innerA.x: ), R|<local>/innerA|.<Unresolved name: x>#)
            }
        }

        when () {
            !=(R|<local>/innerA|.<Unresolved name: foo>#(), String(ok)) ->  {
                ^box <strcat>(String(FAIL innerA.foo: ), R|<local>/innerA|.<Unresolved name: foo>#())
            }
        }

        lval innerB: <ERROR TYPE REF: Unresolved name: InnerPlain> = R|/SourceOuterGeneric.SourceOuterGeneric|<R|kotlin/String|>().<Unresolved name: InnerPlain>#()
        when () {
            !=(R|<local>/innerB|.<Unresolved name: x>#, Int(42)) ->  {
                ^box <strcat>(String(FAIL innerB.x: ), R|<local>/innerB|.<Unresolved name: x>#)
            }
        }

        when () {
            !=(R|<local>/innerB|.<Unresolved name: foo>#(), String(ok)) ->  {
                ^box <strcat>(String(FAIL innerB.foo: ), R|<local>/innerB|.<Unresolved name: foo>#())
            }
        }

        lval innerC: <ERROR TYPE REF: Unresolved name: InnerGeneric> = R|/SourceOuterPlain2.SourceOuterPlain2|().<Unresolved name: InnerGeneric>#<R|kotlin/String|>()
        when () {
            !=(R|<local>/innerC|.<Unresolved name: x>#, Int(42)) ->  {
                ^box <strcat>(String(FAIL innerC.x: ), R|<local>/innerC|.<Unresolved name: x>#)
            }
        }

        when () {
            !=(R|<local>/innerC|.<Unresolved name: foo>#(), String(ok)) ->  {
                ^box <strcat>(String(FAIL innerC.foo: ), R|<local>/innerC|.<Unresolved name: foo>#())
            }
        }

        lval innerD: <ERROR TYPE REF: Unresolved name: InnerGeneric> = R|/SourceOuterGenericPaired.SourceOuterGenericPaired|<R|kotlin/Int|>().<Unresolved name: InnerGeneric>#<R|kotlin/String|>()
        when () {
            !=(R|<local>/innerD|.<Unresolved name: x>#, Int(42)) ->  {
                ^box <strcat>(String(FAIL innerD.x: ), R|<local>/innerD|.<Unresolved name: x>#)
            }
        }

        when () {
            !=(R|<local>/innerD|.<Unresolved name: foo>#(), String(ok)) ->  {
                ^box <strcat>(String(FAIL innerD.foo: ), R|<local>/innerD|.<Unresolved name: foo>#())
            }
        }

        lval withInner: <ERROR TYPE REF: Unresolved name: WithInnerFamily> = <Unresolved name: WithInnerFamily>#<R|kotlin/Int|>()
        lval innerE: <ERROR TYPE REF: Unresolved name: Inner> = R|<local>/withInner|.<Unresolved name: Inner>#<R|kotlin/String|>()
        when () {
            !=(R|<local>/innerE|.<Unresolved name: x>#, Int(42)) ->  {
                ^box <strcat>(String(FAIL innerE.x: ), R|<local>/innerE|.<Unresolved name: x>#)
            }
        }

        when () {
            !=(R|<local>/innerE|.<Unresolved name: foo>#(), String(ok)) ->  {
                ^box <strcat>(String(FAIL innerE.foo: ), R|<local>/innerE|.<Unresolved name: foo>#())
            }
        }

        lval deep: <ERROR TYPE REF: Unresolved name: DeeplyInner> = <Unresolved name: WithDeepInnerFamily>#<R|kotlin/Int|>().<Unresolved name: Inner>#<R|kotlin/String|>().<Unresolved name: DeeplyInner>#<R|kotlin/Double|>()
        when () {
            !=(R|<local>/deep|.<Unresolved name: x>#, Int(42)) ->  {
                ^box <strcat>(String(FAIL deep.x: ), R|<local>/deep|.<Unresolved name: x>#)
            }
        }

        when () {
            !=(R|<local>/deep|.<Unresolved name: foo>#(), String(ok)) ->  {
                ^box <strcat>(String(FAIL deep.foo: ), R|<local>/deep|.<Unresolved name: foo>#())
            }
        }

        lval deepSelf: <ERROR TYPE REF: Symbol not found for WithDeepInnerFamily> = R|<local>/deep|.<Unresolved name: self>#()
        when () {
            !=(R|<local>/deepSelf|.<Unresolved name: x>#, Int(42)) ->  {
                ^box <strcat>(String(FAIL deepSelf.x: ), R|<local>/deepSelf|.<Unresolved name: x>#)
            }
        }

        lval c: R|kotlin/Double| = R|<local>/deep|.<Unresolved name: idC>#(Double(3.14))
        when () {
            !=(R|<local>/c|, Double(3.14)) ->  {
                ^box <strcat>(String(FAIL deep.idC: ), R|<local>/c|)
            }
        }

        lval b: R|kotlin/String| = R|<local>/deep|.<Unresolved name: idB>#(String(hi))
        when () {
            !=(R|<local>/b|, String(hi)) ->  {
                ^box <strcat>(String(FAIL deep.idB: ), R|<local>/b|)
            }
        }

        lval a: R|kotlin/Int| = R|<local>/deep|.<Unresolved name: idA>#(Int(7))
        when () {
            !=(R|<local>/a|, Int(7)) ->  {
                ^box <strcat>(String(FAIL deep.idA: ), R|<local>/a|)
            }
        }

        lval outerBox: <ERROR TYPE REF: Unresolved name: Outer> = <Unresolved name: Outer>#<R|kotlin/String|>()
        lval ib: R|Box<kotlin/String>| = R|<local>/outerBox|.<Unresolved name: InnerBox>#(String(boxed))
        when () {
            !=(R|<local>/ib|.R|SubstitutionOverride</Box.value: R|kotlin/String|>|, String(boxed)) ->  {
                ^box <strcat>(String(FAIL ib.value: ), R|<local>/ib|.R|SubstitutionOverride</Box.value: R|kotlin/String|>|)
            }
        }

        lval ib2: <ERROR TYPE REF: Unresolved name: InnerBox> = R|<local>/outerBox|.<Unresolved name: InnerBox>#(String(direct))
        when () {
            !=(R|<local>/ib2|.<Unresolved name: value>#, String(direct)) ->  {
                ^box <strcat>(String(FAIL ib2.value: ), R|<local>/ib2|.<Unresolved name: value>#)
            }
        }

        ^box String(OK)
    }