Accept new baselines

ahejlsberg · ahejlsberg · commit 4a3997249003 · 2020-11-18T14:58:08.000-08:00
diff --git a/tests/baselines/reference/api/tsserverlibrary.d.ts b/tests/baselines/reference/api/tsserverlibrary.d.ts
@@ -4214,6 +4214,7 @@ declare namespace ts {
     function isStringTextContainingNode(node: Node): node is StringLiteral | TemplateLiteralToken;
     function isModifier(node: Node): node is Modifier;
     function isEntityName(node: Node): node is EntityName;
+    function isEntityNameOrClassExpression(node: Node): node is EntityName;
     function isPropertyName(node: Node): node is PropertyName;
     function isBindingName(node: Node): node is BindingName;
     function isFunctionLike(node: Node): node is SignatureDeclaration;
diff --git a/tests/baselines/reference/api/typescript.d.ts b/tests/baselines/reference/api/typescript.d.ts
@@ -4214,6 +4214,7 @@ declare namespace ts {
     function isStringTextContainingNode(node: Node): node is StringLiteral | TemplateLiteralToken;
     function isModifier(node: Node): node is Modifier;
     function isEntityName(node: Node): node is EntityName;
+    function isEntityNameOrClassExpression(node: Node): node is EntityName;
     function isPropertyName(node: Node): node is PropertyName;
     function isBindingName(node: Node): node is BindingName;
     function isFunctionLike(node: Node): node is SignatureDeclaration;
diff --git a/tests/baselines/reference/jsdocTypeTag.js b/tests/baselines/reference/jsdocTypeTag.js
@@ -66,6 +66,9 @@ var f;
 
 /** @type {new (s: string) => { s: string }} */
 var ctor;
+
+/** @type {typeof class { s: string; static n: number }} */
+var ctor2;
 
 //// [b.ts]
 var S: string;
@@ -90,6 +93,7 @@ var obj: any;
 var Func: Function;
 var f: (s: string) => number;
 var ctor: new (s: string) => { s: string };
+var ctor2: typeof class { s: string; static n: number };
 
 
 //// [a.js]
@@ -137,6 +141,8 @@ var Func;
 var f;
 /** @type {new (s: string) => { s: string }} */
 var ctor;
+/** @type {typeof class { s: string; static n: number }} */
+var ctor2;
 //// [b.js]
 var S;
 var s;
@@ -160,3 +166,4 @@ var obj;
 var Func;
 var f;
 var ctor;
+var ctor2;
diff --git a/tests/baselines/reference/jsdocTypeTag.symbols b/tests/baselines/reference/jsdocTypeTag.symbols
@@ -87,6 +87,10 @@ var f;
 var ctor;
 >ctor : Symbol(ctor, Decl(a.js, 64, 3), Decl(b.ts, 21, 3))
 
+/** @type {typeof class { s: string; static n: number }} */
+var ctor2;
+>ctor2 : Symbol(ctor2, Decl(a.js, 67, 3), Decl(b.ts, 22, 3))
+
 === tests/cases/conformance/jsdoc/b.ts ===
 var S: string;
 >S : Symbol(S, Decl(a.js, 1, 3), Decl(b.ts, 0, 3))
@@ -160,3 +164,8 @@ var ctor: new (s: string) => { s: string };
 >s : Symbol(s, Decl(b.ts, 21, 15))
 >s : Symbol(s, Decl(b.ts, 21, 30))
 
+var ctor2: typeof class { s: string; static n: number };
+>ctor2 : Symbol(ctor2, Decl(a.js, 67, 3), Decl(b.ts, 22, 3))
+>s : Symbol((Anonymous class).s, Decl(b.ts, 22, 25))
+>n : Symbol((Anonymous class).n, Decl(b.ts, 22, 36))
+
diff --git a/tests/baselines/reference/jsdocTypeTag.types b/tests/baselines/reference/jsdocTypeTag.types
@@ -87,6 +87,10 @@ var f;
 var ctor;
 >ctor : new (s: string) => { s: string; }
 
+/** @type {typeof class { s: string; static n: number }} */
+var ctor2;
+>ctor2 : typeof (Anonymous class)
+
 === tests/cases/conformance/jsdoc/b.ts ===
 var S: string;
 >S : string
@@ -160,3 +164,9 @@ var ctor: new (s: string) => { s: string };
 >s : string
 >s : string
 
+var ctor2: typeof class { s: string; static n: number };
+>ctor2 : typeof (Anonymous class)
+>class { s: string; static n: number } : typeof (Anonymous class)
+>s : string
+>n : number
+
diff --git a/tests/baselines/reference/typeofClassExpression1.errors.txt b/tests/baselines/reference/typeofClassExpression1.errors.txt
@@ -0,0 +1,125 @@
+tests/cases/conformance/types/specifyingTypes/typeQueries/typeofClassExpression1.ts(35,10): error TS2511: Cannot create an instance of an abstract class.
+
+
+==== tests/cases/conformance/types/specifyingTypes/typeQueries/typeofClassExpression1.ts (1 errors) ====
+    type TC1 = typeof class {
+        constructor(s: string);
+        static n: number;
+        s: string;
+    }
+    
+    declare let C1: TC1;
+    C1.n;
+    let c1 = new C1('hello');
+    c1.s;
+    
+    declare let C2: typeof class {
+        constructor(s: string);
+        static n: number;
+        s: string;
+    }
+    C2.n;
+    let c2 = new C2('hello');
+    c2.s;
+    
+    declare let C3: typeof class extends Error {
+        constructor(s: string);
+        static n: number;
+    }
+    C3.n;
+    let c3 = new C3('hello');
+    c3.message;
+    
+    declare let C4: typeof abstract class {
+        constructor(s: string);
+        static n: number;
+        s: string;
+    }
+    C4.n;
+    let c4 = new C4('hello');  // Error
+             ~~~~~~~~~~~~~~~
+!!! error TS2511: Cannot create an instance of an abstract class.
+    
+    declare let C5: typeof class<T> {
+        constructor(x: T);
+        x: T;
+    }
+    
+    let c51 = new C5('hello');
+    c51.x;
+    let c52 = new C5(42);
+    c52.x;
+    
+    type BoxFactory<T> = typeof class Box {
+        static default: T;
+        constructor(value?: T);
+        value: T;
+    }
+    
+    declare let StringBox: BoxFactory<string>;
+    StringBox.default;
+    let sb = new StringBox('hello');
+    sb.value;
+    
+    declare let NumberBox: BoxFactory<number>;
+    NumberBox.default;
+    let nb = new NumberBox(42);
+    nb.value;
+    
+    declare const sb1: InstanceType<BoxFactory<string>>;
+    sb1.value;
+    
+    declare const nb1: InstanceType<BoxFactory<number>>;
+    nb1.value;
+    
+    function Printable1<T extends new (...args: any[]) => object>(Base: T) {
+        return class extends Base {
+            static foo: string;
+            print() {}
+        }
+    }
+    
+    declare function Printable2<T extends new (...args: any[]) => object>(Base: T): typeof class extends Base {
+        static foo: string;
+        print(): void;
+    };
+    
+    type PrintableMixin = typeof class {
+        constructor(...args: any[]);  // Indicates class is a mixin
+        static foo: string;
+        print(): void;
+    };
+    
+    declare function Printable3<T extends new (...args: any[]) => object, U>(Base: T): T & PrintableMixin;
+    
+    declare function Printable4<T extends new (...args: any[]) => object>(Base: T): T & typeof class Printable {
+        constructor(...args: any[]);  // Indicates class is a mixin
+        static foo: string;
+        print(): void;
+    };
+    
+    class MyClass {
+        static bar: number;
+        x!: boolean;
+    }
+    
+    let PC1 = Printable1(MyClass);
+    let pc1 = new PC1();
+    pc1.x;
+    pc1.print;
+    
+    let PC2 = Printable2(MyClass);
+    let pc2 = new PC2();
+    pc2.x;
+    pc2.print;
+    
+    let PC3 = Printable3(MyClass);
+    let pc3 = new PC3();
+    pc3.x;
+    pc3.print;
+    
+    let PC4 = Printable4(MyClass);
+    let pc4 = new PC4();
+    pc4.x;
+    pc4.print;
+    
diff --git a/tests/baselines/reference/typeofClassExpression1.js b/tests/baselines/reference/typeofClassExpression1.js
diff --git a/tests/baselines/reference/typeofClassExpression1.symbols b/tests/baselines/reference/typeofClassExpression1.symbols
diff --git a/tests/baselines/reference/typeofClassExpression1.types b/tests/baselines/reference/typeofClassExpression1.types
