Split "use strict" into separate transformer, fix bugs with prologues

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;
 }

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

@@ -22,6 +22,7 @@ f.register(s, null);
 f.unregister(s);
 
 //// [acceptSymbolAsWeakType.js]
+"use strict";
 const s = Symbol('s');
 const ws = new WeakSet([s]);
 ws.add(s);

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

@@ -14,6 +14,7 @@ e as ErrAlias<string>;
 
 
 //// [aliasInstantiationExpressionGenericIntersectionNoCrash1.js]
+"use strict";
 class ErrImpl {
     e;
 }

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

@@ -1,10 +1,8 @@
 --- old.aliasInstantiationExpressionGenericIntersectionNoCrash1.js
 +++ new.aliasInstantiationExpressionGenericIntersectionNoCrash1.js
-@@= skipped -13, +13 lines =@@
-
-
+@@= skipped -15, +15 lines =@@
  //// [aliasInstantiationExpressionGenericIntersectionNoCrash1.js]
--"use strict";
+ "use strict";
  class ErrImpl {
 +    e;
  }

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

@@ -19,4 +19,5 @@ wat as Wat<string>;
 
 
 //// [aliasInstantiationExpressionGenericIntersectionNoCrash2.js]
+"use strict";
 wat;

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

@@ -36,6 +36,7 @@ let check3: test3 = "y";
 
 
 //// [aliasOfGenericFunctionWithRestBehavedSameAsUnaliased.js]
+"use strict";
 // the type printback for every `test` below should be "y"
 let check = "y";
 let check1 = "y";

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

@@ -6,6 +6,7 @@ function f() {
 }
 
 //// [alwaysStrict.js]
+"use strict";
 function f() {
     var arguments = [];
 }

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

@@ -6,6 +6,7 @@ function f() {
 }
 
 //// [alwaysStrictES6.js]
+"use strict";
 function f() {
     var arguments = [];
 }

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

@@ -8,6 +8,7 @@ module M {
 }
 
 //// [alwaysStrictModule.js]
+"use strict";
 var M;
 (function (M) {
     function f() {

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

@@ -18,6 +18,7 @@ function foo<T>(arr: T[], depth: number) {
 }
 
 //// [arrayFakeFlatNoCrashInferenceDeclarations.js]
+"use strict";
 function foo(arr, depth) {
     return flat(arr, depth);
 }

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

@@ -1,10 +1,6 @@
 --- old.arrayFakeFlatNoCrashInferenceDeclarations.js
 +++ new.arrayFakeFlatNoCrashInferenceDeclarations.js
-@@= skipped -17, +17 lines =@@
- }
-
- //// [arrayFakeFlatNoCrashInferenceDeclarations.js]
--"use strict";
+@@= skipped -21, +21 lines =@@
  function foo(arr, depth) {
      return flat(arr, depth);
  }

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

@@ -6,6 +6,7 @@ function foo<T>(arr: T[], depth: number) {
 }
 
 //// [arrayFlatNoCrashInference.js]
+"use strict";
 function foo(arr, depth) {
     return arr.flat(depth);
 }

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

@@ -6,6 +6,7 @@ function foo<T>(arr: T[], depth: number) {
 }
 
 //// [arrayFlatNoCrashInferenceDeclarations.js]
+"use strict";
 function foo(arr, depth) {
     return arr.flat(depth);
 }

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

@@ -27,6 +27,7 @@ animalOrUndef.canMeow; // since is cat, should not be an error
 
 
 //// [assertionFunctionsCanNarrowByDiscriminant.js]
+"use strict";
 const animal = { type: 'cat', canMeow: true };
 assertEqual(animal.type, 'cat');
 animal.canMeow; // since is cat, should not be an error

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

@@ -14,6 +14,7 @@ getValue2<number> = () => 1234;
 
 
 //// [assignmentToInstantiationExpression.js]
+"use strict";
 let obj = {};
 obj.fn = () => 1234;
 let getValue;

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

@@ -1,10 +1,8 @@
 --- old.assignmentToInstantiationExpression.js
 +++ new.assignmentToInstantiationExpression.js
-@@= skipped -13, +13 lines =@@
-
-
+@@= skipped -15, +15 lines =@@
  //// [assignmentToInstantiationExpression.js]
--"use strict";
+ "use strict";
  let obj = {};
 -(obj.fn) = () => 1234;
 +obj.fn = () => 1234;

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

@@ -35,6 +35,7 @@ const increment2: (
 
 
 //// [asyncFunctionContextuallyTypedReturns.js]
+"use strict";
 f(v => v ? [0] : Promise.reject());
 f(async v => v ? [0] : Promise.reject());
 g(v => v ? "contextuallyTypable" : Promise.reject());