error TS5107: Option 'target=ES5' is deprecated and will stop functioning in TypeScript 7.0. Specify compilerOption '"ignoreDeprecations": "6.0"' to silence this error.


!!! error TS5107: Option 'target=ES5' is deprecated and will stop functioning in TypeScript 7.0. Specify compilerOption '"ignoreDeprecations": "6.0"' to silence this error.
==== external.ts (0 errors) ====
    export class Reflect {}
    export interface Foo {}
    export declare namespace Bar { type _ = unknown; }
    export const enum Baz {}
    export default class {};
    
==== locals.ts (0 errors) ====
    export {};
    declare class B { static w(): number; }
    class C extends B {
        static _ = [
            (() => {
                var Reflect; // collision (es2015-es2021 only)
                super.w();
            })(),
            (() => {
                var { Reflect } = { Reflect: null }; // collision (es2015-es2021 only)
                super.w();
            })(),
            (() => {
                var [Reflect] = [null]; // collision (es2015-es2021 only)
                super.w();
            })(),
            (() => {
                class Reflect {} // collision (es2015-es2021 only)
                super.w();
            })(),
            (() => {
                function Reflect() {} // collision (es2015-es2021 only)
                super.w();
            })(),
            (() => {
                enum Reflect {} // collision (es2015-es2021 only)
                super.w();
            })(),
            (() => {
                const enum Reflect {} // collision (es2015-es2021 only)
                super.w();
            })(),
            (() => {
                type Reflect = unknown; // no collision
                super.w();
            })(),
            (() => {
                interface Reflect {}; // no collision
                super.w();
            })(),
            (() => {
                (class Reflect {}); // no collision
                super.w();
            })(),
            (() => {
                (function Reflect() {}); // no collision
                super.w();
            })(),
        ];
    
        static {
            var { Reflect } = { Reflect: null }; // collision (es2015-es2021 only)
            super.w();
        }
    
        static {
            var [Reflect] = [null]; // collision (es2015-es2021 only)
            super.w();
        }
    
        static {
            var Reflect; // collision (es2015-es2021 only)
            super.w();
        }
    
        static {
            class Reflect {} // collision (es2015-es2021 only)
            super.w();
        }
    
        static {
            function Reflect() {} // collision (es2015-es2021 only)
            super.w();
        }
    
        static {
            enum Reflect {} // collision (es2015-es2021 only)
            super.w();
        }
    
        static {
            const enum Reflect {} // collision (es2015-es2021 only)
            super.w();
        }
    
        static {
            type Reflect = unknown; // no collision
            super.w();
        }
    
        static {
            interface Reflect {} // no collision
            super.w();
        }
    
        static {
            (class Reflect {}) // no collision
            super.w();
        }
    
        static {
            (function Reflect() {}) // no collision
            super.w();
        }
    }
    
==== varInContainingScopeStaticField1.ts (0 errors) ====
    export {};
    declare class B { static w(): number; }
    var Reflect = null; // collision (es2015-es2021 only)
    class C extends B {
        static _ = super.w();
    }
    
==== varInContainingScopeStaticField2.ts (0 errors) ====
    export {};
    declare class B { static w(): number; }
    var { Reflect } = { Reflect: null }; // collision (es2015-es2021 only)
    class C extends B {
        static _ = super.w();
    }
    
==== varInContainingScopeStaticField3.ts (0 errors) ====
    export {};
    declare class B { static w(): number; }
    var [Reflect] = [null]; // collision (es2015-es2021 only)
    class C extends B {
        static _ = super.w();
    }
    
==== varInContainingScopeStaticBlock1.ts (0 errors) ====
    export {};
    declare class B { static w(): number; }
    var Reflect = null; // collision (es2015-es2021 only)
    class C extends B {
        static { super.w(); }
    }
    
==== varInContainingScopeStaticBlock2.ts (0 errors) ====
    export {};
    declare class B { static w(): number; }
    var { Reflect } = { Reflect: null }; // collision (es2015-es2021 only)
    class C extends B {
        static { super.w(); }
    }
    
==== varInContainingScopeStaticBlock3.ts (0 errors) ====
    export {};
    declare class B { static w(): number; }
    var [Reflect] = [null]; // collision (es2015-es2021 only)
    class C extends B {
        static { super.w(); }
    }
    
==== classDeclInContainingScopeStaticField.ts (0 errors) ====
    export {};
    declare class B { static w(): number; }
    class Reflect {} // collision (es2015-es2021 only)
    class C extends B {
        static _ = super.w();
    }
    
==== classDeclInContainingScopeStaticBlock.ts (0 errors) ====
    export {};
    declare class B { static w(): number; }
    class Reflect {} // collision (es2015-es2021 only)
    class C extends B {
        static { super.w(); }
    }
    
==== funcDeclInContainingScopeStaticField.ts (0 errors) ====
    export {};
    declare class B { static w(): number; }
    function Reflect() {} // collision (es2015-es2021 only)
    class C extends B {
        static _ = super.w();
    }
    
==== funcDeclInContainingScopeStaticBlock.ts (0 errors) ====
    export {};
    declare class B { static w(): number; }
    function Reflect() {} // collision (es2015-es2021 only)
    class C extends B {
        static { super.w(); }
    }
    
==== valueNamespaceInContainingScopeStaticField.ts (0 errors) ====
    export {};
    declare class B { static w(): number; }
    namespace Reflect {} // collision (es2015-es2021 only)
    class C extends B {
        static _ = super.w();
    }
    
==== valueNamespaceInContainingScopeStaticBlock.ts (0 errors) ====
    export {};
    declare class B { static w(): number; }
    namespace Reflect {} // collision (es2015-es2021 only)
    class C extends B {
        static { super.w(); }
    }
    
==== enumInContainingScopeStaticField.ts (0 errors) ====
    export {};
    declare class B { static w(): number; }
    enum Reflect {} // collision (es2015-es2021 only)
    class C extends B {
        static _ = super.w();
    }
    
==== enumInContainingScopeStaticBlock.ts (0 errors) ====
    export {};
    declare class B { static w(): number; }
    enum Reflect {} // collision (es2015-es2021 only)
    class C extends B {
        static { super.w(); }
    }
    
==== constEnumInContainingScopeStaticField.ts (0 errors) ====
    export {};
    declare class B { static w(): number; }
    const enum Reflect {} // collision (es2015-es2021 only)
    class C extends B {
        static _ = super.w();
    }
    
==== constEnumInContainingScopeStaticBlock.ts (0 errors) ====
    export {};
    declare class B { static w(): number; }
    const enum Reflect {} // collision (es2015-es2021 only)
    class C extends B {
        static { super.w(); }
    }
    
==== namespaceImportInContainingScopeStaticField.ts (0 errors) ====
    export {};
    declare class B { static w(): number; }
    import * as Reflect from "./external"; // collision (es2015-es2021 only)
    class C extends B {
        static _ = super.w();
    }
    
==== namespaceImportInContainingScopeStaticBlock.ts (0 errors) ====
    export {};
    declare class B { static w(): number; }
    import * as Reflect from "./external"; // collision (es2015-es2021 only)
    class C extends B {
        static { super.w(); }
    }
    
==== namedImportInContainingScopeStaticField.ts (0 errors) ====
    export {};
    declare class B { static w(): number; }
    import { Reflect } from "./external"; // collision (es2015-es2021 only)
    class C extends B {
        static _ = super.w();
    }
    
==== namedImportInContainingScopeStaticBlock.ts (0 errors) ====
    export {};
    declare class B { static w(): number; }
    import { Reflect } from "./external"; // collision (es2015-es2021 only)
    class C extends B {
        static { super.w(); }
    }
    
==== namedImportOfInterfaceInContainingScopeStaticField.ts (0 errors) ====
    export {};
    declare class B { static w(): number; }
    import { Foo as Reflect } from "./external"; // collision (es2015-es2021 only, not a type-only import)
    class C extends B {
        static _ = super.w();
    }
    
==== namedImportOfInterfaceInContainingScopeStaticBlock.ts (0 errors) ====
    export {};
    declare class B { static w(): number; }
    import { Foo as Reflect } from "./external"; // collision (es2015-es2021 only, not a type-only import)
    class C extends B {
        static { super.w(); }
    }
    
==== namedImportOfUninstantiatedNamespaceInContainingScopeStaticField.ts (0 errors) ====
    export {};
    declare class B { static w(): number; }
    import { Bar as Reflect } from "./external"; // collision (es2015-es2021 only, not a type-only import)
    class C extends B {
        static _ = super.w();
    }
    
==== namedImportOfUninstantiatedNamespaceInContainingScopeStaticBlock.ts (0 errors) ====
    export {};
    declare class B { static w(): number; }
    import { Bar as Reflect } from "./external"; // collision (es2015-es2021 only, not a type-only import)
    class C extends B {
        static { super.w(); }
    }
    
==== namedImportOfConstEnumInContainingScopeStaticField.ts (0 errors) ====
    export {};
    declare class B { static w(): number; }
    import { Baz as Reflect } from "./external"; // collision (es2015-es2021 only)
    class C extends B {
        static _ = super.w();
    }
    
==== namedImportOfConstEnumInContainingScopeStaticBlock.ts (0 errors) ====
    export {};
    declare class B { static w(): number; }
    import { Baz as Reflect } from "./external"; // collision (es2015-es2021 only)
    class C extends B {
        static { super.w(); }
    }
    
==== typeOnlyNamedImportInContainingScopeStaticField.ts (0 errors) ====
    export {};
    declare class B { static w(): number; }
    import type { Reflect } from "./external"; // no collision
    class C extends B {
        static _ = super.w();
    }
    
==== typeOnlyNamedImportInContainingScopeStaticBlock.ts (0 errors) ====
    export {};
    declare class B { static w(): number; }
    import type { Reflect } from "./external"; // no collision
    class C extends B {
        static { super.w(); }
    }
    
==== defaultImportInContainingScopeStaticField.ts (0 errors) ====
    export {};
    declare class B { static w(): number; }
    import Reflect from "./external"; // collision (es2015-es2021 only)
    class C extends B {
        static _ = super.w();
    }
    
==== defaultImportInContainingScopeStaticBlock.ts (0 errors) ====
    export {};
    declare class B { static w(): number; }
    import Reflect from "./external"; // collision (es2015-es2021 only)
    class C extends B {
        static { super.w(); }
    }
    
==== typeOnlyDefaultImportInContainingScopeStaticField.ts (0 errors) ====
    export {};
    declare class B { static w(): number; }
    import type Reflect from "./external"; // no collision
    class C extends B {
        static _ = super.w();
    }
    
==== typeOnlyDefaultImportInContainingScopeStaticBlock.ts (0 errors) ====
    export {};
    declare class B { static w(): number; }
    import type Reflect from "./external"; // no collision
    class C extends B {
        static { super.w(); }
    }
    
==== typeInContainingScopeStaticField.ts (0 errors) ====
    export {};
    declare class B { static w(): number; }
    type Reflect = unknown; // no collision
    class C extends B {
        static _ = super.w();
    }
    
==== typeInContainingScopeStaticBlock.ts (0 errors) ====
    export {};
    declare class B { static w(): number; }
    type Reflect = unknown; // no collision
    class C extends B {
        static { super.w(); }
    }
    
==== interfaceInContainingScopeStaticField.ts (0 errors) ====
    export {};
    declare class B { static w(): number; }
    interface Reflect {}; // no collision
    class C extends B {
        static _ = super.w();
    }
    
==== interfaceInContainingScopeStaticBlock.ts (0 errors) ====
    export {};
    declare class B { static w(): number; }
    interface Reflect {}; // no collision
    class C extends B {
        static { super.w(); }
    }
    
==== uninstantiatedNamespaceInContainingScopeStaticField.ts (0 errors) ====
    export {};
    declare class B { static w(): number; }
    declare namespace Reflect { type _ = unknown; }; // no collision
    class C extends B {
        static _ = super.w();
    }
    
==== uninstantiatedNamespaceInContainingScopeStaticBlock.ts (0 errors) ====
    export {};
    declare class B { static w(): number; }
    declare namespace Reflect { type _ = unknown; }; // no collision
    class C extends B {
        static { super.w(); }
    }
    
==== classExprInContainingScopeStaticField.ts (0 errors) ====
    export {};
    declare class B { static w(): number; }
    (class Reflect {}); // no collision
    class C extends B {
        static _ = super.w();
    }
    
==== classExprInContainingScopeStaticBlock.ts (0 errors) ====
    export {};
    declare class B { static w(): number; }
    (class Reflect {}); // no collision
    class C extends B {
        static { super.w(); }
    }
    
==== inContainingClassExprStaticField.ts (0 errors) ====
    export {};
    declare class B { static w(): number; }
    (class Reflect { // collision (es2015-es2021 only)
        static {
            class C extends B {
                static _ = super.w();
            }
        }
    });
    
==== inContainingClassExprStaticBlock.ts (0 errors) ====
    export {};
    declare class B { static w(): number; }
    (class Reflect { // collision (es2015-es2021 only)
        static {
            class C extends B {
                static { super.w(); }
            }
        }
    });
    
==== funcExprInContainingScopeStaticField.ts (0 errors) ====
    export {};
    declare class B { static w(): number; }
    (function Reflect() {}); // no collision
    class C extends B {
        static _ = super.w();
    }
    
==== funcExprInContainingScopeStaticBlock.ts (0 errors) ====
    export {};
    declare class B { static w(): number; }
    (function Reflect() {}); // no collision
    class C extends B {
        static { super.w(); }
    }
    
==== inContainingFuncExprStaticField.ts (0 errors) ====
    export {};
    declare class B { static w(): number; }
    (function Reflect() { // collision (es2015-es2021 only)
        class C extends B {
            static _ = super.w();
        }
    });
    
==== inContainingFuncExprStaticBlock.ts (0 errors) ====
    export {};
    declare class B { static w(): number; }
    (function Reflect() { // collision (es2015-es2021 only)
        class C extends B {
            static { super.w(); }
        }
    });
    