Port SubtreeFacts (nee TransformFlags) from Strada (microsoft#707)

Author: rbuckton

internal/ast/ast.go

@@ -0,0 +1,116 @@
+package ast
+
+import (
+	"github.com/microsoft/typescript-go/internal/core"
+)
+
+type SubtreeFacts int32
+
+const (
+	// Facts
+	// - Flags used to indicate that a node or subtree contains syntax specific to a particular ECMAScript variant.
+
+	SubtreeContainsTypeScript SubtreeFacts = 1 << iota
+	SubtreeContainsJsx
+	SubtreeContainsESNext
+	SubtreeContainsES2022
+	SubtreeContainsES2021
+	SubtreeContainsES2020
+	SubtreeContainsES2019
+	SubtreeContainsES2018
+	SubtreeContainsES2017
+	SubtreeContainsES2016
+
+	// Markers
+	// - Flags used to indicate that a node or subtree contains a particular kind of syntax.
+
+	SubtreeContainsLexicalThis
+	SubtreeContainsLexicalSuper
+	SubtreeContainsRest
+	SubtreeContainsObjectRestOrSpread
+	SubtreeContainsAwait
+	SubtreeContainsDynamicImport
+	SubtreeContainsClassFields
+	SubtreeContainsDecorators
+	SubtreeContainsIdentifier
+
+	SubtreeFactsComputed              // NOTE: This should always be last
+	SubtreeFactsNone     SubtreeFacts = 0
+
+	// Scope Exclusions
+	// - Bitmasks that exclude flags from propagating out of a specific context
+	//   into the subtree flags of their container.
+
+	SubtreeExclusionsNode                    = SubtreeFactsComputed
+	SubtreeExclusionsEraseable               = ^SubtreeContainsTypeScript
+	SubtreeExclusionsOuterExpression         = SubtreeExclusionsNode
+	SubtreeExclusionsPropertyAccess          = SubtreeExclusionsNode
+	SubtreeExclusionsElementAccess           = SubtreeExclusionsNode
+	SubtreeExclusionsArrowFunction           = SubtreeExclusionsNode | SubtreeContainsAwait | SubtreeContainsObjectRestOrSpread
+	SubtreeExclusionsFunction                = SubtreeExclusionsNode | SubtreeContainsLexicalThis | SubtreeContainsLexicalSuper | SubtreeContainsAwait | SubtreeContainsObjectRestOrSpread
+	SubtreeExclusionsConstructor             = SubtreeExclusionsNode | SubtreeContainsLexicalThis | SubtreeContainsLexicalSuper | SubtreeContainsAwait | SubtreeContainsObjectRestOrSpread
+	SubtreeExclusionsMethod                  = SubtreeExclusionsNode | SubtreeContainsLexicalThis | SubtreeContainsLexicalSuper | SubtreeContainsAwait | SubtreeContainsObjectRestOrSpread
+	SubtreeExclusionsAccessor                = SubtreeExclusionsNode | SubtreeContainsLexicalThis | SubtreeContainsLexicalSuper | SubtreeContainsAwait | SubtreeContainsObjectRestOrSpread
+	SubtreeExclusionsProperty                = SubtreeExclusionsNode | SubtreeContainsLexicalThis | SubtreeContainsLexicalSuper
+	SubtreeExclusionsClass                   = SubtreeExclusionsNode
+	SubtreeExclusionsModule                  = SubtreeExclusionsNode | SubtreeContainsLexicalThis | SubtreeContainsLexicalSuper
+	SubtreeExclusionsObjectLiteral           = SubtreeExclusionsNode | SubtreeContainsObjectRestOrSpread
+	SubtreeExclusionsArrayLiteral            = SubtreeExclusionsNode
+	SubtreeExclusionsCall                    = SubtreeExclusionsNode
+	SubtreeExclusionsNew                     = SubtreeExclusionsNode
+	SubtreeExclusionsVariableDeclarationList = SubtreeExclusionsNode | SubtreeContainsObjectRestOrSpread
+	SubtreeExclusionsParameter               = SubtreeExclusionsNode
+	SubtreeExclusionsCatchClause             = SubtreeExclusionsNode | SubtreeContainsObjectRestOrSpread
+	SubtreeExclusionsBindingPattern          = SubtreeExclusionsNode | SubtreeContainsRest
+
+	// Masks
+	// - Additional bitmasks
+
+	SubtreeContainsLexicalThisOrSuper = SubtreeContainsLexicalThis | SubtreeContainsLexicalSuper
+)
+
+func propagateEraseableSyntaxListSubtreeFacts(children *TypeArgumentList) SubtreeFacts {
+	return core.IfElse(children != nil, SubtreeContainsTypeScript, SubtreeFactsNone)
+}
+
+func propagateEraseableSyntaxSubtreeFacts(child *TypeNode) SubtreeFacts {
+	return core.IfElse(child != nil, SubtreeContainsTypeScript, SubtreeFactsNone)
+}
+
+func propagateObjectBindingElementSubtreeFacts(child *BindingElementNode) SubtreeFacts {
+	facts := propagateSubtreeFacts(child)
+	if facts&SubtreeContainsRest != 0 {
+		facts &= ^SubtreeContainsRest
+		facts |= SubtreeContainsObjectRestOrSpread
+	}
+	return facts
+}
+
+func propagateBindingElementSubtreeFacts(child *BindingElementNode) SubtreeFacts {
+	return propagateSubtreeFacts(child) & ^SubtreeContainsRest
+}
+
+func propagateSubtreeFacts(child *Node) SubtreeFacts {
+	if child == nil {
+		return SubtreeFactsNone
+	}
+	return child.propagateSubtreeFacts()
+}
+
+func propagateNodeListSubtreeFacts(children *NodeList, propagate func(*Node) SubtreeFacts) SubtreeFacts {
+	if children == nil {
+		return SubtreeFactsNone
+	}
+	facts := SubtreeFactsNone
+	for _, child := range children.Nodes {
+		facts |= propagate(child)
+	}
+	return facts
+}
+
+func propagateModifierListSubtreeFacts(children *ModifierList) SubtreeFacts {
+	if children == nil {
+		return SubtreeFactsNone
+	}
+	return propagateNodeListSubtreeFacts(&children.NodeList, propagateSubtreeFacts)
+}

internal/ast/subtreefacts.go

@@ -136,12 +136,10 @@ func (tx *CommonJSModuleTransformer) visit(node *ast.Node) *ast.Node {
 
 // Visits source elements that are not top-level or top-level nested statements without ancestor tracking.
 func (tx *CommonJSModuleTransformer) visitNoStack(node *ast.Node, resultIsDiscarded bool) *ast.Node {
-	// !!!
-	////// This visitor does not need to descend into the tree if there is no dynamic import, destructuring assignment, or update expression
-	////// as export/import statements are only transformed at the top level of a file.
-	////if (!(node.transformFlags & (TransformFlags.ContainsDynamicImport | TransformFlags.ContainsDestructuringAssignment | TransformFlags.ContainsUpdateExpressionForIdentifier)) && !importsAndRequiresToRewriteOrShim?.length) {
-	////	return node;
-	////}
+	// This visitor does not need to descend into the tree if there are no dynamic imports or identifiers in the subtree
+	if !ast.IsSourceFile(node) && node.SubtreeFacts()&(ast.SubtreeContainsDynamicImport|ast.SubtreeContainsIdentifier) == 0 {
+		return node
+	}
 
 	switch node.Kind {
 	case ast.KindSourceFile:
@@ -229,7 +227,7 @@ func (tx *CommonJSModuleTransformer) visitAssignmentPatternNoStack(node *ast.Nod
 func (tx *CommonJSModuleTransformer) visitSourceFile(node *ast.SourceFile) *ast.Node {
 	if node.IsDeclarationFile ||
 		!(ast.IsEffectiveExternalModule(node, tx.compilerOptions) ||
-			containsDynamicImport(tx.emitContext, node) ||
+			node.SubtreeFacts()&ast.SubtreeContainsDynamicImport != 0 ||
 			ast.IsJsonSourceFile(node) && tx.compilerOptions.HasJsonModuleEmitEnabled() && len(tx.compilerOptions.OutFile) > 0) {
 		return node.AsNode()
 	}

internal/transformers/commonjsmodule.go

@@ -61,7 +61,7 @@ func (tx *RuntimeSyntaxTransformer) pushScope(node *ast.Node) (savedCurrentScope
 	case ast.KindCaseBlock, ast.KindModuleBlock, ast.KindBlock:
 		tx.currentScope = node
 		tx.currentScopeFirstDeclarationsOfName = nil
-	case ast.KindFunctionDeclaration, ast.KindClassDeclaration, ast.KindEnumDeclaration, ast.KindModuleDeclaration, ast.KindVariableDeclaration:
+	case ast.KindFunctionDeclaration, ast.KindClassDeclaration, ast.KindEnumDeclaration, ast.KindModuleDeclaration, ast.KindVariableStatement:
 		tx.recordDeclarationInScope(node)
 	}
 	return savedCurrentScope, savedCurrentScopeFirstDeclarationsOfName
@@ -78,11 +78,16 @@ func (tx *RuntimeSyntaxTransformer) popScope(savedCurrentScope *ast.Node, savedC
 
 // Visits each node in the AST
 func (tx *RuntimeSyntaxTransformer) visit(node *ast.Node) *ast.Node {
-	savedCurrentScope, savedCurrentScopeFirstDeclarationsOfName := tx.pushScope(node)
 	grandparentNode := tx.pushNode(node)
 	defer tx.popNode(grandparentNode)
+
+	savedCurrentScope, savedCurrentScopeFirstDeclarationsOfName := tx.pushScope(node)
 	defer tx.popScope(savedCurrentScope, savedCurrentScopeFirstDeclarationsOfName)
 
+	if node.SubtreeFacts()&ast.SubtreeContainsTypeScript == 0 && (tx.currentNamespace == nil && tx.currentEnum == nil || node.SubtreeFacts()&ast.SubtreeContainsIdentifier == 0) {
+		return node
+	}
+
 	switch node.Kind {
 	// TypeScript parameter property modifiers are elided
 	case ast.KindPublicKeyword,
@@ -119,14 +124,33 @@ func (tx *RuntimeSyntaxTransformer) visit(node *ast.Node) *ast.Node {
 
 // Records that a declaration was emitted in the current scope, if it was the first declaration for the provided symbol.
 func (tx *RuntimeSyntaxTransformer) recordDeclarationInScope(node *ast.Node) {
-	name := node.Name()
-	if name != nil && ast.IsIdentifier(name) {
-		if tx.currentScopeFirstDeclarationsOfName == nil {
-			tx.currentScopeFirstDeclarationsOfName = make(map[string]*ast.Node)
+	switch node.Kind {
+	case ast.KindVariableStatement:
+		tx.recordDeclarationInScope(node.AsVariableStatement().DeclarationList)
+		return
+	case ast.KindVariableDeclarationList:
+		for _, decl := range node.AsVariableDeclarationList().Declarations.Nodes {
+			tx.recordDeclarationInScope(decl)
 		}
-		text := name.Text()
-		if _, found := tx.currentScopeFirstDeclarationsOfName[text]; !found {
-			tx.currentScopeFirstDeclarationsOfName[text] = node
+		return
+	case ast.KindArrayBindingPattern, ast.KindObjectBindingPattern:
+		for _, element := range node.AsBindingPattern().Elements.Nodes {
+			tx.recordDeclarationInScope(element)
+		}
+		return
+	}
+	name := node.Name()
+	if name != nil {
+		if ast.IsIdentifier(name) {
+			if tx.currentScopeFirstDeclarationsOfName == nil {
+				tx.currentScopeFirstDeclarationsOfName = make(map[string]*ast.Node)
+			}
+			text := name.Text()
+			if _, found := tx.currentScopeFirstDeclarationsOfName[text]; !found {
+				tx.currentScopeFirstDeclarationsOfName[text] = node
+			}
+		} else if ast.IsBindingPattern(name) {
+			tx.recordDeclarationInScope(name)
 		}
 	}
 }

internal/transformers/runtimesyntax.go

@@ -40,7 +40,10 @@ func (tx *TypeEraserTransformer) elide(node *ast.Statement) *ast.Statement {
 }
 
 func (tx *TypeEraserTransformer) visit(node *ast.Node) *ast.Node {
-	// !!! TransformFlags were traditionally used here to skip over subtrees that contain no TypeScript syntax
+	if node.SubtreeFacts()&ast.SubtreeContainsTypeScript == 0 {
+		return node
+	}
+
 	if ast.IsStatement(node) && ast.HasSyntacticModifier(node, ast.ModifierFlagsAmbient) {
 		return tx.elide(node)
 	}
@@ -260,6 +263,7 @@ func (tx *TypeEraserTransformer) visit(node *ast.Node) *ast.Node {
 			return nil
 		}
 		return tx.factory.UpdateImportDeclaration(n, n.Modifiers(), importClause, n.ModuleSpecifier, n.Attributes)
+
 	case ast.KindImportClause:
 		n := node.AsImportClause()
 		if n.IsTypeOnly {
@@ -273,21 +277,28 @@ func (tx *TypeEraserTransformer) visit(node *ast.Node) *ast.Node {
 			return nil
 		}
 		return tx.factory.UpdateImportClause(n, false /*isTypeOnly*/, name, namedBindings)
+
 	case ast.KindNamedImports:
 		n := node.AsNamedImports()
+		if len(n.Elements.Nodes) == 0 {
+			// Do not elide a side-effect only import declaration.
+			return node
+		}
 		elements := tx.visitor.VisitNodes(n.Elements)
 		if !tx.compilerOptions.VerbatimModuleSyntax.IsTrue() && len(elements.Nodes) == 0 {
 			// all import specifiers were elided
 			return nil
 		}
 		return tx.factory.UpdateNamedImports(n, elements)
+
 	case ast.KindImportSpecifier:
 		n := node.AsImportSpecifier()
 		if n.IsTypeOnly {
 			// elide type-only or unused imports
 			return nil
 		}
 		return node
+
 	case ast.KindExportDeclaration:
 		n := node.AsExportDeclaration()
 		if n.IsTypeOnly {
@@ -303,21 +314,29 @@ func (tx *TypeEraserTransformer) visit(node *ast.Node) *ast.Node {
 			}
 		}
 		return tx.factory.UpdateExportDeclaration(n, nil /*modifiers*/, false /*isTypeOnly*/, exportClause, tx.visitor.VisitNode(n.ModuleSpecifier), tx.visitor.VisitNode(n.Attributes))
+
 	case ast.KindNamedExports:
 		n := node.AsNamedExports()
+		if len(n.Elements.Nodes) == 0 {
+			// Do not elide an empty export declaration.
+			return node
+		}
+
 		elements := tx.visitor.VisitNodes(n.Elements)
 		if !tx.compilerOptions.VerbatimModuleSyntax.IsTrue() && len(elements.Nodes) == 0 {
 			// all export specifiers were elided
 			return nil
 		}
 		return tx.factory.UpdateNamedExports(n, elements)
+
 	case ast.KindExportSpecifier:
 		n := node.AsExportSpecifier()
 		if n.IsTypeOnly {
 			// elide unused export
 			return nil
 		}
 		return node
+
 	default:
 		return tx.visitor.VisitEachChild(node)
 	}

internal/transformers/typeeraser.go

@@ -32,7 +32,6 @@ exports.default = {};
 //// [es6ImportDefaultBindingFollowedWithNamedImport_1.js]
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-require("./es6ImportDefaultBindingFollowedWithNamedImport_0");
 const es6ImportDefaultBindingFollowedWithNamedImport_0_1 = require("./es6ImportDefaultBindingFollowedWithNamedImport_0");
 var x1 = es6ImportDefaultBindingFollowedWithNamedImport_0_1.a;
 const es6ImportDefaultBindingFollowedWithNamedImport_0_2 = require("./es6ImportDefaultBindingFollowedWithNamedImport_0");

testdata/baselines/reference/submodule/compiler/es6ImportDefaultBindingFollowedWithNamedImport.js

@@ -1,14 +1,6 @@
 --- old.es6ImportDefaultBindingFollowedWithNamedImport.js
 +++ new.es6ImportDefaultBindingFollowedWithNamedImport.js
-@@= skipped -31, +31 lines =@@
- //// [es6ImportDefaultBindingFollowedWithNamedImport_1.js]
- "use strict";
- Object.defineProperty(exports, "__esModule", { value: true });
-+require("./es6ImportDefaultBindingFollowedWithNamedImport_0");
- const es6ImportDefaultBindingFollowedWithNamedImport_0_1 = require("./es6ImportDefaultBindingFollowedWithNamedImport_0");
- var x1 = es6ImportDefaultBindingFollowedWithNamedImport_0_1.a;
- const es6ImportDefaultBindingFollowedWithNamedImport_0_2 = require("./es6ImportDefaultBindingFollowedWithNamedImport_0");
-@@= skipped -11, +12 lines =@@
+@@= skipped -42, +42 lines =@@
  var x1 = es6ImportDefaultBindingFollowedWithNamedImport_0_4.x;
  const es6ImportDefaultBindingFollowedWithNamedImport_0_5 = require("./es6ImportDefaultBindingFollowedWithNamedImport_0");
  var x1 = es6ImportDefaultBindingFollowedWithNamedImport_0_5.m;

testdata/baselines/reference/submodule/compiler/es6ImportDefaultBindingFollowedWithNamedImport.js.diff

@@ -49,7 +49,6 @@ exports.x11 = x11;
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.x6 = exports.x3 = exports.x5 = exports.x4 = exports.x2 = exports.x1 = void 0;
-require("./server");
 const server_1 = require("./server");
 exports.x1 = new server_1.a();
 const server_2 = require("./server");

testdata/baselines/reference/submodule/compiler/es6ImportDefaultBindingFollowedWithNamedImportDts.js

@@ -57,7 +57,6 @@
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.x6 = exports.x3 = exports.x5 = exports.x4 = exports.x2 = exports.x1 = void 0;
 -var server_1 = require("./server");
-+require("./server");
 +const server_1 = require("./server");
  exports.x1 = new server_1.a();
 -var server_2 = require("./server");

testdata/baselines/reference/submodule/compiler/es6ImportDefaultBindingFollowedWithNamedImportDts.js.diff

@@ -30,7 +30,6 @@ exports.m = exports.a;
 //// [es6ImportDefaultBindingFollowedWithNamedImportInEs5_1.js]
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-require("./es6ImportDefaultBindingFollowedWithNamedImportInEs5_0");
 const es6ImportDefaultBindingFollowedWithNamedImportInEs5_0_1 = require("./es6ImportDefaultBindingFollowedWithNamedImportInEs5_0");
 var x1 = es6ImportDefaultBindingFollowedWithNamedImportInEs5_0_1.a;
 const es6ImportDefaultBindingFollowedWithNamedImportInEs5_0_2 = require("./es6ImportDefaultBindingFollowedWithNamedImportInEs5_0");