erasableSyntaxOnly.types

//// [tests/cases/compiler/erasableSyntaxOnly.ts] ////

=== index.ts ===
class MyClassErr {
>MyClassErr : MyClassErr
>           : ^^^^^^^^^^

    // No parameter properties
    constructor(public foo: string) { }
>foo : string
>    : ^^^^^^
}

namespace IllegalBecauseInstantiated {
>IllegalBecauseInstantiated : typeof IllegalBecauseInstantiated
>                           : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

    export const m = 1;
>m : 1
>  : ^
>1 : 1
>  : ^
}

namespace AlsoIllegalBecauseInstantiated {
>AlsoIllegalBecauseInstantiated : typeof AlsoIllegalBecauseInstantiated
>                               : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

    class PrivateClass {
>PrivateClass : PrivateClass
>             : ^^^^^^^^^^^^

    }
}

namespace IllegalBecauseNestedInstantiated {
>IllegalBecauseNestedInstantiated : typeof IllegalBecauseNestedInstantiated
>                                 : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

    namespace Nested {
>Nested : typeof Nested
>       : ^^^^^^^^^^^^^

        export const m = 1;
>m : 1
>  : ^
>1 : 1
>  : ^
    }
}

enum NotLegalEnum {
>NotLegalEnum : NotLegalEnum
>             : ^^^^^^^^^^^^

    B = 1
>B : NotLegalEnum.B
>  : ^^^^^^^^^^^^^^
>1 : 1
>  : ^
}

import NoGoodAlias = NotLegalEnum.B;
>NoGoodAlias : NotLegalEnum.B
>            : ^^^^^^^^^^^^^^
>NotLegalEnum : NotLegalEnum
>             : ^^^^^^^^^^^^
>B : NotLegalEnum.B
>  : ^^^^^^^^^^^^^^

const enum NotLegalConstEnum {
>NotLegalConstEnum : NotLegalConstEnum
>                  : ^^^^^^^^^^^^^^^^^

    C = 2
>C : NotLegalConstEnum.C
>  : ^^^^^^^^^^^^^^^^^^^
>2 : 2
>  : ^
}

// No errors after this point
class MyClassOk {
>MyClassOk : MyClassOk
>          : ^^^^^^^^^

    // Not a parameter property, ok
    constructor(foo: string) { }
>foo : string
>    : ^^^^^^
}

// Note for implementors: This should not be an error
// as this entire namespace block is fully erased
namespace NotInstantiated {
    export interface JustAType { }
    export type ATypeInANamespace = {};
>ATypeInANamespace : ATypeInANamespace
>                  : ^^^^^^^^^^^^^^^^^

    namespace Nested {
        export type ATypeInANamespace = {};
>ATypeInANamespace : ATypeInANamespace
>                  : ^^^^^^^^^^^^^^^^^
    }
}
declare namespace AmbientIsNotInstantiated {
>AmbientIsNotInstantiated : typeof AmbientIsNotInstantiated
>                         : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

    export const stillOk = 12;
>stillOk : 12
>        : ^^
>12 : 12
>   : ^^
}

declare enum LegalEnum {
>LegalEnum : LegalEnum
>          : ^^^^^^^^^

    A = 1
>A : LegalEnum.A
>  : ^^^^^^^^^^^
>1 : 1
>  : ^
}

declare namespace AmbientStuff {
>AmbientStuff : typeof AmbientStuff
>             : ^^^^^^^^^^^^^^^^^^^

    namespace Nested {
>Nested : typeof Nested
>       : ^^^^^^^^^^^^^

        export const stillOk = 12;
>stillOk : 12
>        : ^^
>12 : 12
>   : ^^
    }
    enum EnumInAmbientContext {
>EnumInAmbientContext : EnumInAmbientContext
>                     : ^^^^^^^^^^^^^^^^^^^^

        B = 1
>B : EnumInAmbientContext.B
>  : ^^^^^^^^^^^^^^^^^^^^^^
>1 : 1
>  : ^
    }

    import FineAlias = EnumInAmbientContext.B;
>FineAlias : EnumInAmbientContext.B
>          : ^^^^^^^^^^^^^^^^^^^^^^
>EnumInAmbientContext : EnumInAmbientContext
>                     : ^^^^^^^^^^^^^^^^^^^^
>B : EnumInAmbientContext.B
>  : ^^^^^^^^^^^^^^^^^^^^^^
}

// Not erasable
(()=><any>{})();
>(()=><any>{})() : any
>                : ^^^
>(()=><any>{}) : () => any
>              : ^^^^^^   
>()=><any>{} : () => any
>            : ^^^^^^   
><any>{} : any
>        : ^^^
>{} : {}
>   : ^^

(()=>< any >{})();
>(()=>< any >{})() : any
>                  : ^^^
>(()=>< any >{}) : () => any
>                : ^^^^^^   
>()=>< any >{} : () => any
>              : ^^^^^^   
>< any >{} : any
>          : ^^^
>{} : {}
>   : ^^

(()=> < any > {})();
>(()=> < any > {})() : any
>                    : ^^^
>(()=> < any > {}) : () => any
>                  : ^^^^^^   
>()=> < any > {} : () => any
>                : ^^^^^^   
>< any > {} : any
>           : ^^^
>{} : {}
>   : ^^

// Erasable
(()=><any>({}))();
>(()=><any>({}))() : any
>                  : ^^^
>(()=><any>({})) : () => any
>                : ^^^^^^   
>()=><any>({}) : () => any
>              : ^^^^^^   
><any>({}) : any
>          : ^^^
>({}) : {}
>     : ^^
>{} : {}
>   : ^^

(()=>(<any>{}))();
>(()=>(<any>{}))() : any
>                  : ^^^
>(()=>(<any>{})) : () => any
>                : ^^^^^^^^^
>()=>(<any>{}) : () => any
>              : ^^^^^^^^^
>(<any>{}) : any
>          : ^^^
><any>{} : any
>        : ^^^
>{} : {}
>   : ^^

<any>{};
><any>{} : any
>        : ^^^
>{} : {}
>   : ^^


// return and yield ASI
function *gen() {
>gen : () => {}
>    : ^^^^^^^^

    yield <any>
>yield <any>        1 : any
>                     : ^^^
><any>        1 : any
>               : ^^^

        1;
>1 : 1
>  : ^

    return <any>
><any>        1 : any
>               : ^^^

        1;
>1 : 1
>  : ^
}

// at the start of an ExpressionStatement if followed by an object literal; though I'm not sure why one would use it there
<unknown>{foo() {}}.foo();
><unknown>{foo() {}}.foo() : unknown
>                          : ^^^^^^^
>{foo() {}}.foo() : void
>                 : ^^^^
>{foo() {}}.foo : () => void
>               : ^^^^^^^^^^
>{foo() {}} : { foo(): void; }
>           : ^^^^^^^^^^^^^^^^
>foo : () => void
>    : ^^^^^^^^^^
>foo : () => void
>    : ^^^^^^^^^^

// at the start of an ExpressionStatement if followed by function keyword
<unknown>function() {}();
><unknown>function() {}() : unknown
>                         : ^^^^^^^
>function() {}() : void
>                : ^^^^
>function() {} : () => void
>              : ^^^^^^^^^^

<unknown>function() {};
><unknown>function() {} : unknown
>                       : ^^^^^^^
>function() {} : () => void
>              : ^^^^^^^^^^

// at the start of an ExpressionStatement if followed by an anonymous class expression
// note that this exact syntax currently emits invalid JS (no parenthesis added like for function above)
<unknown>class {}
><unknown>class {} : unknown
>                  : ^^^^^^^
>class {} : typeof (Anonymous class)
>         : ^^^^^^^^^^^^^^^^^^^^^^^^

=== commonjs.cts ===
import foo = require("./other.cjs");
>foo : () => void
>    : ^^^^^^    

export = foo;
>foo : () => void
>    : ^^^^^^    


=== other.d.cts ===
declare function foo(): void;
>foo : () => void
>    : ^^^^^^    

export = foo;
>foo : () => void
>    : ^^^^^^    


=== esm.mts ===
const foo = 1234;
>foo : 1234
>    : ^^^^
>1234 : 1234
>     : ^^^^

export default foo;
>foo : 1234
>    : ^^^^