Defer binding of expando assignments and give them lower priority (#2715)

Author: ahejlsberg

internal/binder/binder.go

@@ -41,6 +41,12 @@ const (
 	ContainerFlagsIsThisContainer                                  ContainerFlags = 1 << 8
 )
 
+type ExpandoAssignmentInfo struct {
+	node                *ast.Node
+	container           *ast.Node
+	blockScopeContainer *ast.Node
+}
+
 type Binder struct {
 	file            *ast.SourceFile
 	bindFunc        func(*ast.Node) bool
@@ -73,6 +79,7 @@ type Binder struct {
 	flowNodePool            core.Pool[ast.FlowNode]
 	flowListPool            core.Pool[ast.FlowList]
 	singleDeclarationsPool  core.Pool[*ast.Node]
+	expandoAssignments      []ExpandoAssignmentInfo
 }
 
 func (b *Binder) options() core.SourceFileAffectingCompilerOptions {
@@ -123,6 +130,7 @@ func bindSourceFile(file *ast.SourceFile) {
 		b.inStrictMode = b.options().BindInStrictMode && !file.IsDeclarationFile || ast.IsExternalModule(file)
 		b.unreachableFlow = b.newFlowNode(ast.FlowFlagsUnreachable)
 		b.bind(file.AsNode())
+		b.bindDeferredExpandoAssignments()
 		file.SymbolCount = b.symbolCount
 		file.ClassifiableNames = b.classifiableNames
 	})
@@ -1011,6 +1019,22 @@ func addLateBoundAssignmentDeclarationToSymbol(node *ast.Node, symbol *ast.Symbo
 }
 
 func (b *Binder) bindExpandoPropertyAssignment(node *ast.Node) {
+	b.expandoAssignments = append(b.expandoAssignments, ExpandoAssignmentInfo{
+		node:                node,
+		container:           b.container,
+		blockScopeContainer: b.blockScopeContainer,
+	})
+}
+
+func (b *Binder) bindDeferredExpandoAssignments() {
+	for _, info := range b.expandoAssignments {
+		b.container = info.container
+		b.blockScopeContainer = info.blockScopeContainer
+		b.bindDeferredExpandoAssignment(info.node)
+	}
+}
+
+func (b *Binder) bindDeferredExpandoAssignment(node *ast.Node) {
 	parent := getParentOfPropertyAssignment(node)
 	symbol := b.lookupEntity(parent, b.blockScopeContainer)
 	if symbol == nil {
@@ -1021,7 +1045,11 @@ func (b *Binder) bindExpandoPropertyAssignment(node *ast.Node) {
 			b.bindAnonymousDeclaration(node, ast.SymbolFlagsProperty|ast.SymbolFlagsAssignment, ast.InternalSymbolNameComputed)
 			addLateBoundAssignmentDeclarationToSymbol(node, symbol)
 		} else {
-			b.declareSymbol(ast.GetExports(symbol), symbol, node, ast.SymbolFlagsProperty|ast.SymbolFlagsAssignment, ast.SymbolFlagsPropertyExcludes)
+			// We declare expandos only when there are no non-expando declarations for that name.
+			exports := ast.GetExports(symbol)
+			if existing := exports[b.getDeclarationName(node)]; existing == nil || existing.Flags&ast.SymbolFlagsAssignment != 0 {
+				b.declareSymbol(exports, symbol, node, ast.SymbolFlagsProperty|ast.SymbolFlagsAssignment, ast.SymbolFlagsPropertyExcludes)
+			}
 		}
 	}
 }

testdata/baselines/reference/submodule/compiler/expandoFunctionNestedAssigmentsDeclared.symbols

@@ -21,7 +21,7 @@ declare class Point
 >Point : Symbol(Point, Decl(targetTypeTest1.ts, 8, 1), Decl(targetTypeTest1.ts, 0, 0))
 
       static origin: Point;
->origin : Symbol(Point.origin, Decl(targetTypeTest1.ts, 5, 48), Decl(targetTypeTest1.ts, 22, 17))
+>origin : Symbol(Point.origin, Decl(targetTypeTest1.ts, 5, 48))
 >Point : Symbol(Point, Decl(targetTypeTest1.ts, 8, 1), Decl(targetTypeTest1.ts, 0, 0))
 
 }
@@ -59,19 +59,19 @@ var x = EF1(1,2);
 
 // Point.origin declared as type Point
 Point.origin = new Point(0, 0);
->Point.origin : Symbol(Point.origin, Decl(targetTypeTest1.ts, 5, 48), Decl(targetTypeTest1.ts, 22, 17))
+>Point.origin : Symbol(Point.origin, Decl(targetTypeTest1.ts, 5, 48))
 >Point : Symbol(Point, Decl(targetTypeTest1.ts, 8, 1), Decl(targetTypeTest1.ts, 0, 0))
->origin : Symbol(Point.origin, Decl(targetTypeTest1.ts, 5, 48), Decl(targetTypeTest1.ts, 22, 17))
+>origin : Symbol(Point.origin, Decl(targetTypeTest1.ts, 5, 48))
 >Point : Symbol(Point, Decl(targetTypeTest1.ts, 8, 1), Decl(targetTypeTest1.ts, 0, 0))
 
 // Point.prototype declared as type Point
 // this inferred as Point because of obj.prop assignment
 // dx, dy, and return type inferred using target typing
 Point.prototype.add = function(dx, dy) {
 >Point.prototype.add : Symbol(Point.add, Decl(targetTypeTest1.ts, 4, 23))
->Point.prototype : Symbol(Point.prototype, Decl(targetTypeTest1.ts, 34, 19))
+>Point.prototype : Symbol(Point.prototype)
 >Point : Symbol(Point, Decl(targetTypeTest1.ts, 8, 1), Decl(targetTypeTest1.ts, 0, 0))
->prototype : Symbol(Point.prototype, Decl(targetTypeTest1.ts, 34, 19))
+>prototype : Symbol(Point.prototype)
 >add : Symbol(Point.add, Decl(targetTypeTest1.ts, 4, 23))
 >dx : Symbol(dx, Decl(targetTypeTest1.ts, 30, 31))
 >dy : Symbol(dy, Decl(targetTypeTest1.ts, 30, 34))
@@ -90,9 +90,9 @@ var f : number = 5;
 // this in function add inferred to be type of object literal (i.e. Point)
 // dx, dy, and return type of add inferred using target typing
 Point.prototype = {
->Point.prototype : Symbol(Point.prototype, Decl(targetTypeTest1.ts, 34, 19))
+>Point.prototype : Symbol(Point.prototype)
 >Point : Symbol(Point, Decl(targetTypeTest1.ts, 8, 1), Decl(targetTypeTest1.ts, 0, 0))
->prototype : Symbol(Point.prototype, Decl(targetTypeTest1.ts, 34, 19))
+>prototype : Symbol(Point.prototype)
 
     x: 0,
 >x : Symbol(x, Decl(targetTypeTest1.ts, 39, 19))
@@ -155,9 +155,9 @@ function C(a,b) {
 }
 
 C.prototype = 
->C.prototype : Symbol(C.prototype, Decl(targetTypeTest1.ts, 62, 1))
+>C.prototype : Symbol(C.prototype)
 >C : Symbol(C, Decl(targetTypeTest1.ts, 57, 1), Decl(targetTypeTest1.ts, 50, 1))
->prototype : Symbol(C.prototype, Decl(targetTypeTest1.ts, 62, 1))
+>prototype : Symbol(C.prototype)
 
 	{	a:0,
 >a : Symbol(a, Decl(targetTypeTest1.ts, 65, 2))

testdata/baselines/reference/submodule/compiler/expandoFunctionNestedAssigmentsDeclared.symbols.diff

@@ -17,8 +17,9 @@
 +>Point : Symbol(Point, Decl(targetTypeTest1.ts, 8, 1), Decl(targetTypeTest1.ts, 0, 0))
 
        static origin: Point;
- >origin : Symbol(Point.origin, Decl(targetTypeTest1.ts, 5, 48), Decl(targetTypeTest1.ts, 22, 17))
+->origin : Symbol(Point.origin, Decl(targetTypeTest1.ts, 5, 48), Decl(targetTypeTest1.ts, 22, 17))
 ->Point : Symbol(Point, Decl(targetTypeTest1.ts, 8, 1), Decl(targetTypeTest1.ts, 0, 0), Decl(targetTypeTest1.ts, 22, 17))
++>origin : Symbol(Point.origin, Decl(targetTypeTest1.ts, 5, 48))
 +>Point : Symbol(Point, Decl(targetTypeTest1.ts, 8, 1), Decl(targetTypeTest1.ts, 0, 0))
 
  }
@@ -32,27 +33,28 @@
  >x : Symbol(x, Decl(targetTypeTest1.ts, 13, 15))
  >y : Symbol(y, Decl(targetTypeTest1.ts, 13, 17))
 
-@@= skipped -30, +30 lines =@@
+@@= skipped -29, +29 lines =@@
+
  // Point.origin declared as type Point
  Point.origin = new Point(0, 0);
- >Point.origin : Symbol(Point.origin, Decl(targetTypeTest1.ts, 5, 48), Decl(targetTypeTest1.ts, 22, 17))
+->Point.origin : Symbol(Point.origin, Decl(targetTypeTest1.ts, 5, 48), Decl(targetTypeTest1.ts, 22, 17))
 ->Point : Symbol(Point, Decl(targetTypeTest1.ts, 8, 1), Decl(targetTypeTest1.ts, 0, 0), Decl(targetTypeTest1.ts, 22, 17))
-+>Point : Symbol(Point, Decl(targetTypeTest1.ts, 8, 1), Decl(targetTypeTest1.ts, 0, 0))
- >origin : Symbol(Point.origin, Decl(targetTypeTest1.ts, 5, 48), Decl(targetTypeTest1.ts, 22, 17))
+->origin : Symbol(Point.origin, Decl(targetTypeTest1.ts, 5, 48), Decl(targetTypeTest1.ts, 22, 17))
 ->Point : Symbol(Point, Decl(targetTypeTest1.ts, 8, 1), Decl(targetTypeTest1.ts, 0, 0), Decl(targetTypeTest1.ts, 22, 17))
++>Point.origin : Symbol(Point.origin, Decl(targetTypeTest1.ts, 5, 48))
++>Point : Symbol(Point, Decl(targetTypeTest1.ts, 8, 1), Decl(targetTypeTest1.ts, 0, 0))
++>origin : Symbol(Point.origin, Decl(targetTypeTest1.ts, 5, 48))
 +>Point : Symbol(Point, Decl(targetTypeTest1.ts, 8, 1), Decl(targetTypeTest1.ts, 0, 0))
 
  // Point.prototype declared as type Point
  // this inferred as Point because of obj.prop assignment
- // dx, dy, and return type inferred using target typing
+@@= skipped -11, +11 lines =@@
  Point.prototype.add = function(dx, dy) {
  >Point.prototype.add : Symbol(Point.add, Decl(targetTypeTest1.ts, 4, 23))
-->Point.prototype : Symbol(Point.prototype)
+ >Point.prototype : Symbol(Point.prototype)
 ->Point : Symbol(Point, Decl(targetTypeTest1.ts, 8, 1), Decl(targetTypeTest1.ts, 0, 0), Decl(targetTypeTest1.ts, 22, 17))
-->prototype : Symbol(Point.prototype)
-+>Point.prototype : Symbol(Point.prototype, Decl(targetTypeTest1.ts, 34, 19))
 +>Point : Symbol(Point, Decl(targetTypeTest1.ts, 8, 1), Decl(targetTypeTest1.ts, 0, 0))
-+>prototype : Symbol(Point.prototype, Decl(targetTypeTest1.ts, 34, 19))
+ >prototype : Symbol(Point.prototype)
  >add : Symbol(Point.add, Decl(targetTypeTest1.ts, 4, 23))
  >dx : Symbol(dx, Decl(targetTypeTest1.ts, 30, 31))
  >dy : Symbol(dy, Decl(targetTypeTest1.ts, 30, 34))
@@ -63,37 +65,21 @@
  >dx : Symbol(dx, Decl(targetTypeTest1.ts, 30, 31))
  >dy : Symbol(dy, Decl(targetTypeTest1.ts, 30, 34))
 
-@@= skipped -30, +30 lines =@@
- // this in function add inferred to be type of object literal (i.e. Point)
+@@= skipped -21, +21 lines =@@
  // dx, dy, and return type of add inferred using target typing
  Point.prototype = {
-->Point.prototype : Symbol(Point.prototype)
+ >Point.prototype : Symbol(Point.prototype)
 ->Point : Symbol(Point, Decl(targetTypeTest1.ts, 8, 1), Decl(targetTypeTest1.ts, 0, 0), Decl(targetTypeTest1.ts, 22, 17))
-->prototype : Symbol(Point.prototype)
-+>Point.prototype : Symbol(Point.prototype, Decl(targetTypeTest1.ts, 34, 19))
 +>Point : Symbol(Point, Decl(targetTypeTest1.ts, 8, 1), Decl(targetTypeTest1.ts, 0, 0))
-+>prototype : Symbol(Point.prototype, Decl(targetTypeTest1.ts, 34, 19))
+ >prototype : Symbol(Point.prototype)
 
      x: 0,
- >x : Symbol(x, Decl(targetTypeTest1.ts, 39, 19))
-@@= skipped -16, +16 lines =@@
+@@= skipped -15, +15 lines =@@
  >dy : Symbol(dy, Decl(targetTypeTest1.ts, 42, 21))
 
          return new Point(this.x + dx, this.y + dy);
 ->Point : Symbol(Point, Decl(targetTypeTest1.ts, 8, 1), Decl(targetTypeTest1.ts, 0, 0), Decl(targetTypeTest1.ts, 22, 17))
 +>Point : Symbol(Point, Decl(targetTypeTest1.ts, 8, 1), Decl(targetTypeTest1.ts, 0, 0))
  >dx : Symbol(dx, Decl(targetTypeTest1.ts, 42, 18))
  >dy : Symbol(dy, Decl(targetTypeTest1.ts, 42, 21))
-     }
-@@= skipped -49, +49 lines =@@
- }
-
- C.prototype = 
-->C.prototype : Symbol(C.prototype)
-+>C.prototype : Symbol(C.prototype, Decl(targetTypeTest1.ts, 62, 1))
- >C : Symbol(C, Decl(targetTypeTest1.ts, 57, 1), Decl(targetTypeTest1.ts, 50, 1))
-->prototype : Symbol(C.prototype)
-+>prototype : Symbol(C.prototype, Decl(targetTypeTest1.ts, 62, 1))
-
- 	{	a:0,
- >a : Symbol(a, Decl(targetTypeTest1.ts, 65, 2))
+     }

testdata/baselines/reference/submodule/compiler/targetTypeTest1.symbols

@@ -116,11 +116,11 @@ var f : number = 5;
 // this in function add inferred to be type of object literal (i.e. Point)
 // dx, dy, and return type of add inferred using target typing
 Point.prototype = {
->Point.prototype = {    x: 0,    y: 0,    add: function(dx, dy) {        return new Point(this.x + dx, this.y + dy);    }} : { x: number; y: number; add: (dx: any, dy: any) => Point; }
+>Point.prototype = {    x: 0,    y: 0,    add: function(dx, dy) {        return new Point(this.x + dx, this.y + dy);    }} : { x: number; y: number; add: (dx: number, dy: number) => Point; }
 >Point.prototype : Point
 >Point : typeof Point
 >prototype : Point
->{    x: 0,    y: 0,    add: function(dx, dy) {        return new Point(this.x + dx, this.y + dy);    }} : { x: number; y: number; add: (dx: any, dy: any) => Point; }
+>{    x: 0,    y: 0,    add: function(dx, dy) {        return new Point(this.x + dx, this.y + dy);    }} : { x: number; y: number; add: (dx: number, dy: number) => Point; }
 
     x: 0,
 >x : number
@@ -131,10 +131,10 @@ Point.prototype = {
 >0 : 0
 
     add: function(dx, dy) {
->add : (dx: any, dy: any) => Point
->function(dx, dy) {        return new Point(this.x + dx, this.y + dy);    } : (dx: any, dy: any) => Point
->dx : any
->dy : any
+>add : (dx: number, dy: number) => Point
+>function(dx, dy) {        return new Point(this.x + dx, this.y + dy);    } : (dx: number, dy: number) => Point
+>dx : number
+>dy : number
 
         return new Point(this.x + dx, this.y + dy);
 >new Point(this.x + dx, this.y + dy) : Point
@@ -143,12 +143,12 @@ Point.prototype = {
 >this.x : any
 >this : any
 >x : any
->dx : any
+>dx : number
 >this.y + dy : any
 >this.y : any
 >this : any
 >y : any
->dy : any
+>dy : number
     }
 };
 
@@ -205,13 +205,13 @@ function C(a,b) {
 }
 
 C.prototype = 
->C.prototype = 	{	a:0,		b:0, 		C1M1: function(c,d) {     				return (this.a + c) + (this.b + d);			}	} : { a: number; b: number; C1M1: (c: any, d: any) => any; }
+>C.prototype = 	{	a:0,		b:0, 		C1M1: function(c,d) {     				return (this.a + c) + (this.b + d);			}	} : { a: number; b: number; C1M1: (c: number, d: number) => any; }
 >C.prototype : C
 >C : typeof C
 >prototype : C
 
 	{	a:0,
->{	a:0,		b:0, 		C1M1: function(c,d) {     				return (this.a + c) + (this.b + d);			}	} : { a: number; b: number; C1M1: (c: any, d: any) => any; }
+>{	a:0,		b:0, 		C1M1: function(c,d) {     				return (this.a + c) + (this.b + d);			}	} : { a: number; b: number; C1M1: (c: number, d: number) => any; }
 >a : number
 >0 : 0
 
@@ -220,10 +220,10 @@ C.prototype =
 >0 : 0
 
 		C1M1: function(c,d) {     
->C1M1 : (c: any, d: any) => any
->function(c,d) {     				return (this.a + c) + (this.b + d);			} : (c: any, d: any) => any
->c : any
->d : any
+>C1M1 : (c: number, d: number) => any
+>function(c,d) {     				return (this.a + c) + (this.b + d);			} : (c: number, d: number) => any
+>c : number
+>d : number
 
 				return (this.a + c) + (this.b + d);
 >(this.a + c) + (this.b + d) : any
@@ -232,13 +232,13 @@ C.prototype =
 >this.a : any
 >this : any
 >a : any
->c : any
+>c : number
 >(this.b + d) : any
 >this.b + d : any
 >this.b : any
 >this : any
 >b : any
->d : any
+>d : number
 			}
 	};