Merge branch 'main' of https://github.com/microsoft/typescript-go into fix/2426

Author: a-tarasyuk

internal/checker/checker.go

@@ -11452,10 +11452,10 @@ func (c *Checker) checkPropertyAccessibilityAtLocation(location *ast.Node, isSup
 	if flags&ast.ModifierFlagsAbstract != 0 && c.symbolHasNonMethodDeclaration(prop) && (isThisProperty(location) ||
 		isThisInitializedObjectBindingExpression(location) ||
 		ast.IsObjectBindingPattern(location.Parent) && isThisInitializedDeclaration(location.Parent.Parent)) {
-		declaringClassDeclaration := ast.GetClassLikeDeclarationOfSymbol(c.getParentOfSymbol(prop))
-		if declaringClassDeclaration != nil && c.isNodeUsedDuringClassInitialization(location) {
+		parentSymbol := c.getParentOfSymbol(prop)
+		if parentSymbol != nil && parentSymbol.Flags&ast.SymbolFlagsClass != 0 && c.isNodeUsedDuringClassInitialization(location) {
 			if errorNode != nil {
-				c.error(errorNode, diagnostics.Abstract_property_0_in_class_1_cannot_be_accessed_in_the_constructor, c.symbolToString(prop), declaringClassDeclaration.Name().Text())
+				c.error(errorNode, diagnostics.Abstract_property_0_in_class_1_cannot_be_accessed_in_the_constructor, c.symbolToString(prop), c.symbolToString(parentSymbol))
 			}
 			return false
 		}
@@ -18556,6 +18556,9 @@ func findIndexInfo(indexInfos []*IndexInfo, keyType *Type) *IndexInfo {
 }
 
 func (c *Checker) getBaseTypes(t *Type) []*Type {
+	if t.objectFlags&(ObjectFlagsClassOrInterface|ObjectFlagsReference) == 0 {
+		return nil
+	}
 	data := t.AsInterfaceType()
 	if !data.baseTypesResolved {
 		if !c.pushTypeResolution(t, TypeSystemPropertyNameResolvedBaseTypes) {

testdata/baselines/reference/compiler/errorInUnnamedClassExpression.errors.txt

@@ -0,0 +1,21 @@
+errorInUnnamedClassExpression.ts(5,14): error TS2715: Abstract property 'bar' in class 'Foo' cannot be accessed in the constructor.
+errorInUnnamedClassExpression.ts(7,5): error TS1253: Abstract properties can only appear within an abstract class.
+errorInUnnamedClassExpression.ts(7,14): error TS7008: Member 'bar' implicitly has an 'any' type.
+
+
+==== errorInUnnamedClassExpression.ts (3 errors) ====
+    // https://github.com/microsoft/TypeScript/issues/62920
+    
+    let Foo = class {
+        constructor() {
+            this.bar++;
+                 ~~~
+!!! error TS2715: Abstract property 'bar' in class 'Foo' cannot be accessed in the constructor.
+        }
+        abstract bar;
+        ~~~~~~~~
+!!! error TS1253: Abstract properties can only appear within an abstract class.
+                 ~~~
+!!! error TS7008: Member 'bar' implicitly has an 'any' type.
+    };
+    

testdata/baselines/reference/compiler/errorInUnnamedClassExpression.symbols

@@ -0,0 +1,19 @@
+//// [tests/cases/compiler/errorInUnnamedClassExpression.ts] ////
+
+=== errorInUnnamedClassExpression.ts ===
+// https://github.com/microsoft/TypeScript/issues/62920
+
+let Foo = class {
+>Foo : Symbol(Foo, Decl(errorInUnnamedClassExpression.ts, 2, 3))
+
+    constructor() {
+        this.bar++;
+>this.bar : Symbol(Foo.bar, Decl(errorInUnnamedClassExpression.ts, 5, 5))
+>this : Symbol(Foo, Decl(errorInUnnamedClassExpression.ts, 2, 9))
+>bar : Symbol(Foo.bar, Decl(errorInUnnamedClassExpression.ts, 5, 5))
+    }
+    abstract bar;
+>bar : Symbol(Foo.bar, Decl(errorInUnnamedClassExpression.ts, 5, 5))
+
+};
+

testdata/baselines/reference/compiler/errorInUnnamedClassExpression.types

@@ -0,0 +1,21 @@
+//// [tests/cases/compiler/errorInUnnamedClassExpression.ts] ////
+
+=== errorInUnnamedClassExpression.ts ===
+// https://github.com/microsoft/TypeScript/issues/62920
+
+let Foo = class {
+>Foo : typeof Foo
+>class {    constructor() {        this.bar++;    }    abstract bar;} : typeof Foo
+
+    constructor() {
+        this.bar++;
+>this.bar++ : number
+>this.bar : any
+>this : this
+>bar : any
+    }
+    abstract bar;
+>bar : any
+
+};
+

testdata/baselines/reference/compiler/noCrashOnMixin2.errors.txt

@@ -0,0 +1,41 @@
+noCrashOnMixin2.ts(11,33): error TS2370: A rest parameter must be of an array type.
+noCrashOnMixin2.ts(11,40): error TS1047: A rest parameter cannot be optional.
+noCrashOnMixin2.ts(14,12): error TS2545: A mixin class must have a constructor with a single rest parameter of type 'any[]'.
+noCrashOnMixin2.ts(23,9): error TS2674: Constructor of class 'Abstract' is protected and only accessible within the class declaration.
+
+
+==== noCrashOnMixin2.ts (4 errors) ====
+    // https://github.com/microsoft/TypeScript/issues/62921
+    
+    class Abstract {
+        protected constructor() {
+        }
+    }
+    
+    class Concrete extends Abstract {
+    }
+    
+    type Constructor<T = {}> = new (...args?: any[]) => T;
+                                    ~~~~~~~~~~~~~~~
+!!! error TS2370: A rest parameter must be of an array type.
+                                           ~
+!!! error TS1047: A rest parameter cannot be optional.
+    
+    function Mixin<TBase extends Constructor>(Base: TBase) {
+        return class extends Base {
+               ~~~~~
+!!! error TS2545: A mixin class must have a constructor with a single rest parameter of type 'any[]'.
+        };
+    }
+    
+    class Empty {
+    }
+    
+    class CrashTrigger extends Mixin(Empty) {
+        public trigger() {
+            new Concrete();
+            ~~~~~~~~~~~~~~
+!!! error TS2674: Constructor of class 'Abstract' is protected and only accessible within the class declaration.
+        }
+    }
+    

testdata/baselines/reference/compiler/noCrashOnMixin2.symbols

@@ -0,0 +1,53 @@
+//// [tests/cases/compiler/noCrashOnMixin2.ts] ////
+
+=== noCrashOnMixin2.ts ===
+// https://github.com/microsoft/TypeScript/issues/62921
+
+class Abstract {
+>Abstract : Symbol(Abstract, Decl(noCrashOnMixin2.ts, 0, 0))
+
+    protected constructor() {
+    }
+}
+
+class Concrete extends Abstract {
+>Concrete : Symbol(Concrete, Decl(noCrashOnMixin2.ts, 5, 1))
+>Abstract : Symbol(Abstract, Decl(noCrashOnMixin2.ts, 0, 0))
+}
+
+type Constructor<T = {}> = new (...args?: any[]) => T;
+>Constructor : Symbol(Constructor, Decl(noCrashOnMixin2.ts, 8, 1))
+>T : Symbol(T, Decl(noCrashOnMixin2.ts, 10, 17))
+>args : Symbol(args, Decl(noCrashOnMixin2.ts, 10, 32))
+>T : Symbol(T, Decl(noCrashOnMixin2.ts, 10, 17))
+
+function Mixin<TBase extends Constructor>(Base: TBase) {
+>Mixin : Symbol(Mixin, Decl(noCrashOnMixin2.ts, 10, 54))
+>TBase : Symbol(TBase, Decl(noCrashOnMixin2.ts, 12, 15))
+>Constructor : Symbol(Constructor, Decl(noCrashOnMixin2.ts, 8, 1))
+>Base : Symbol(Base, Decl(noCrashOnMixin2.ts, 12, 42))
+>TBase : Symbol(TBase, Decl(noCrashOnMixin2.ts, 12, 15))
+
+    return class extends Base {
+>Base : Symbol(Base, Decl(noCrashOnMixin2.ts, 12, 42))
+
+    };
+}
+
+class Empty {
+>Empty : Symbol(Empty, Decl(noCrashOnMixin2.ts, 15, 1))
+}
+
+class CrashTrigger extends Mixin(Empty) {
+>CrashTrigger : Symbol(CrashTrigger, Decl(noCrashOnMixin2.ts, 18, 1))
+>Mixin : Symbol(Mixin, Decl(noCrashOnMixin2.ts, 10, 54))
+>Empty : Symbol(Empty, Decl(noCrashOnMixin2.ts, 15, 1))
+
+    public trigger() {
+>trigger : Symbol(CrashTrigger.trigger, Decl(noCrashOnMixin2.ts, 20, 41))
+
+        new Concrete();
+>Concrete : Symbol(Concrete, Decl(noCrashOnMixin2.ts, 5, 1))
+    }
+}
+

testdata/baselines/reference/compiler/noCrashOnMixin2.types

@@ -0,0 +1,51 @@
+//// [tests/cases/compiler/noCrashOnMixin2.ts] ////
+
+=== noCrashOnMixin2.ts ===
+// https://github.com/microsoft/TypeScript/issues/62921
+
+class Abstract {
+>Abstract : Abstract
+
+    protected constructor() {
+    }
+}
+
+class Concrete extends Abstract {
+>Concrete : Concrete
+>Abstract : Abstract
+}
+
+type Constructor<T = {}> = new (...args?: any[]) => T;
+>Constructor : Constructor<T>
+>args : any[] | undefined
+
+function Mixin<TBase extends Constructor>(Base: TBase) {
+>Mixin : <TBase extends Constructor<{}>>(Base: TBase) => { new (...args?: any[] | undefined): (Anonymous class); prototype: Mixin.(Anonymous class); } & TBase
+>Base : TBase
+
+    return class extends Base {
+>class extends Base {    } : { new (...args?: any[] | undefined): (Anonymous class); prototype: Mixin.(Anonymous class); } & TBase
+>Base : {}
+
+    };
+}
+
+class Empty {
+>Empty : Empty
+}
+
+class CrashTrigger extends Mixin(Empty) {
+>CrashTrigger : CrashTrigger
+>Mixin(Empty) : Mixin.(Anonymous class)
+>Mixin : <TBase extends Constructor<{}>>(Base: TBase) => { new (...args?: any[] | undefined): (Anonymous class); prototype: Mixin.(Anonymous class); } & TBase
+>Empty : typeof Empty
+
+    public trigger() {
+>trigger : () => void
+
+        new Concrete();
+>new Concrete() : Concrete
+>Concrete : typeof Concrete
+    }
+}
+

testdata/tests/cases/compiler/errorInUnnamedClassExpression.ts

@@ -0,0 +1,11 @@
+// @strict: true
+// @noEmit: true
+
+// https://github.com/microsoft/TypeScript/issues/62920
+
+let Foo = class {
+    constructor() {
+        this.bar++;
+    }
+    abstract bar;
+};

testdata/tests/cases/compiler/noCrashOnMixin2.ts

@@ -0,0 +1,28 @@
+// @strict: true
+// @noEmit: true
+
+// https://github.com/microsoft/TypeScript/issues/62921
+
+class Abstract {
+    protected constructor() {
+    }
+}
+
+class Concrete extends Abstract {
+}
+
+type Constructor<T = {}> = new (...args?: any[]) => T;
+
+function Mixin<TBase extends Constructor>(Base: TBase) {
+    return class extends Base {
+    };
+}
+
+class Empty {
+}
+
+class CrashTrigger extends Mixin(Empty) {
+    public trigger() {
+        new Concrete();
+    }
+}