Split "use strict" into separate transformer, fix bugs with prologues (#2028)

Co-authored-by: Sheetal Nandi <shkamat@microsoft.com>

Author: jakebailey

internal/compiler/emitter.go

@@ -125,6 +125,8 @@ func getScriptTransformers(emitContext *printer.EmitContext, host printer.EmitHo
 		tx = append(tx, downleveler)
 	}
 
+	tx = append(tx, estransforms.NewUseStrictTransformer(&opts))
+
 	// transform module syntax
 	tx = append(tx, getModuleTransformer(&opts))
 

internal/execute/tsctests/tscbuild_test.go

@@ -1949,6 +1949,7 @@ func TestBuildProgramUpdates(t *testing.T) {
 						sys.writeFileNoError("/user/username/projects/project/project2.tsconfig.json", stringtestutil.Dedent(`
 						{
                             "extends": "./alpha.tsconfig.json",
+                            "files": ["other.ts"]
                         }`), false)
 					},
 				},

internal/printer/factory.go

@@ -399,7 +399,7 @@ func (f *NodeFactory) SplitStandardPrologue(source []*ast.Statement) (prologue [
 			return source[:i], source[i:]
 		}
 	}
-	return nil, source
+	return source, nil
 }
 
 // Splits a slice of statements into two parts: custom prologue statements (e.g., with `EFCustomPrologue` set) and the rest of the statements

internal/printer/printer.go

@@ -1558,10 +1558,10 @@ func (p *Printer) emitFunctionBody(body *ast.Block) {
 
 	if p.shouldEmitBlockFunctionBodyOnSingleLine(body) && statementOffset == 0 && pos == p.writer.GetTextPos() {
 		p.decreaseIndent()
-		p.emitList((*Printer).emitStatement, body.AsNode(), body.Statements, LFSingleLineFunctionBodyStatements)
+		p.emitListRange((*Printer).emitStatement, body.AsNode(), body.Statements, LFSingleLineFunctionBodyStatements, statementOffset, -1)
 		p.increaseIndent()
 	} else {
-		p.emitList((*Printer).emitStatement, body.AsNode(), body.Statements, LFMultiLineFunctionBodyStatements)
+		p.emitListRange((*Printer).emitStatement, body.AsNode(), body.Statements, LFMultiLineFunctionBodyStatements, statementOffset, -1)
 	}
 
 	p.emitDetachedCommentsAfterStatementList(body.AsNode(), body.Statements.Loc, detachedState)

internal/transformers/estransforms/usestrict.go

@@ -0,0 +1,55 @@
+package estransforms
+
+import (
+	"github.com/microsoft/typescript-go/internal/ast"
+	"github.com/microsoft/typescript-go/internal/core"
+	"github.com/microsoft/typescript-go/internal/transformers"
+)
+
+func NewUseStrictTransformer(opts *transformers.TransformOptions) *transformers.Transformer {
+	tx := &useStrictTransformer{
+		compilerOptions:           opts.CompilerOptions,
+		getEmitModuleFormatOfFile: opts.GetEmitModuleFormatOfFile,
+	}
+	return tx.NewTransformer(tx.visit, opts.Context)
+}
+
+type useStrictTransformer struct {
+	transformers.Transformer
+	compilerOptions           *core.CompilerOptions
+	getEmitModuleFormatOfFile func(file ast.HasFileName) core.ModuleKind
+}
+
+func (tx *useStrictTransformer) visit(node *ast.Node) *ast.Node {
+	if node.Kind != ast.KindSourceFile {
+		return node
+	}
+	return tx.visitSourceFile(node.AsSourceFile())
+}
+
+func (tx *useStrictTransformer) visitSourceFile(node *ast.SourceFile) *ast.Node {
+	if node.ScriptKind == core.ScriptKindJSON {
+		return node.AsNode()
+	}
+
+	if tx.compilerOptions.GetEmitModuleKind() == core.ModuleKindPreserve {
+		return node.AsNode()
+	}
+
+	isExternalModule := ast.IsExternalModule(node)
+	format := tx.getEmitModuleFormatOfFile(node)
+
+	if isExternalModule && format >= core.ModuleKindES2015 {
+		return node.AsNode()
+	}
+
+	if isExternalModule ||
+		tx.compilerOptions.AlwaysStrict.DefaultIfUnknown(tx.compilerOptions.Strict).IsTrue() {
+		statements := tx.Factory().EnsureUseStrict(node.Statements.Nodes)
+		statementList := tx.Factory().NewNodeList(statements)
+		statementList.Loc = node.Statements.Loc
+		return tx.Factory().UpdateSourceFile(node, statementList, node.EndOfFileToken).AsSourceFile().AsNode()
+	}
+
+	return node.AsNode()
+}

internal/transformers/moduletransforms/commonjsmodule.go

@@ -297,12 +297,6 @@ func (tx *CommonJSModuleTransformer) transformCommonJSModule(node *ast.SourceFil
 	prologue, rest := tx.Factory().SplitStandardPrologue(node.Statements.Nodes)
 	statements := slices.Clone(prologue)
 
-	// ensure "use strict" if not present
-	if ast.IsExternalModule(tx.currentSourceFile) ||
-		tx.compilerOptions.AlwaysStrict.DefaultIfUnknown(tx.compilerOptions.Strict).IsTrue() {
-		statements = tx.Factory().EnsureUseStrict(statements)
-	}
-
 	// emit custom prologues from other transformations
 	custom, rest := tx.Factory().SplitCustomPrologue(rest)
 	statements = append(statements, core.FirstResult(tx.topLevelVisitor.VisitSlice(custom))...)

testdata/baselines/reference/compiler/jsxNestedIndentation.js

@@ -13,6 +13,7 @@ function Test() {
 
 
 //// [jsxNestedIndentation.js]
+"use strict";
 function Test() {
     return React.createElement(Child, null,
         React.createElement(Child, null,

testdata/baselines/reference/conformance/deepElementAccessExpressionInJS.js

@@ -16,6 +16,7 @@ function calculatePropertyName(index) {
 
 
 //// [elementAccessExpressionInJS.js]
+"use strict";
 if (module[calculatePropertyName(1)]) {
 }
 function calculatePropertyName(index) {

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

@@ -11,7 +11,6 @@ function foo() {
 //// [abstractIdentifierNameStrict.js]
 var abstract = true;
 function foo() {
-    "use strict";
     "use strict";
     var abstract = true;
 }