Support for edits in tsc tests

Author: sheetalkamat

internal/execute/export_test.go

@@ -1,9 +1,6 @@
 package execute
 
 import (
-	"github.com/microsoft/typescript-go/internal/ast"
-	"github.com/microsoft/typescript-go/internal/compiler"
-	"github.com/microsoft/typescript-go/internal/incremental"
 	"github.com/microsoft/typescript-go/internal/tsoptions"
 )
 
@@ -14,21 +11,9 @@ func CommandLineTest(sys System, commandLineArgs []string) (ExitStatus, *tsoptio
 func StartForTest(w *watcher) {
 	// this function should perform any initializations before w.doCycle() in `start(watcher)`
 	w.initialize()
+	w.doCycle()
 }
 
 func RunWatchCycle(w *watcher) {
-	// this function should perform the same stuff as w.doCycle() without printing time-related output
-	if w.hasErrorsInTsConfig() {
-		// these are unrecoverable errors--report them and do not build
-		return
-	}
-	// todo: updateProgram()
-	w.program = incremental.NewProgram(compiler.NewProgram(compiler.ProgramOptions{
-		Config:           w.options,
-		Host:             w.host,
-		JSDocParsingMode: ast.JSDocParsingModeParseForTypeErrors,
-	}), w.program)
-	if w.hasBeenModified(w.program.GetProgram()) {
-		w.compileAndEmit()
-	}
+	w.doCycle()
 }

internal/execute/testsys_test.go

@@ -11,6 +11,7 @@ import (
 	"time"
 
 	"github.com/microsoft/typescript-go/internal/collections"
+	"github.com/microsoft/typescript-go/internal/core"
 	"github.com/microsoft/typescript-go/internal/testutil/incrementaltestutil"
 	"github.com/microsoft/typescript-go/internal/tsoptions"
 	"github.com/microsoft/typescript-go/internal/vfs"
@@ -141,10 +142,24 @@ func (s *testSys) Writer() io.Writer {
 	return s.currentWrite
 }
 
+func sanitizeSysOutput(output string, prefixLine string, replaceString string) string {
+	if index := strings.Index(output, prefixLine); index != -1 {
+		indexOfNewLine := strings.Index(output[index:], "\n")
+		if indexOfNewLine != -1 {
+			output = output[:index] + replaceString + output[index+indexOfNewLine+1:]
+		}
+	}
+	return output
+}
+
 func (s *testSys) EndWrite() {
 	// todo: revisit if improving tsc/build/watch unittest baselines
-	s.output = append(s.output, s.currentWrite.String())
+	output := s.currentWrite.String()
 	s.currentWrite.Reset()
+	output = sanitizeSysOutput(output, "Version "+core.Version(), "Version FakeTSVersion\n")
+	output = sanitizeSysOutput(output, "build starting at ", "")
+	output = sanitizeSysOutput(output, "build finished in ", "")
+	s.output = append(s.output, output)
 }
 
 func (s *testSys) serializeState(baseline *strings.Builder) {
@@ -249,3 +264,9 @@ func (s *testSys) printOutputs(baseline io.Writer) {
 	// todo sanitize sys output
 	fmt.Fprint(baseline, strings.Join(s.output, "\n"))
 }
+
+func (s *testSys) WriteFileNoError(path string, content string, writeByteOrderMark bool) {
+	if err := s.FS().WriteFile(path, content, writeByteOrderMark); err != nil {
+		panic(err)
+	}
+}

internal/execute/tsc_test.go

@@ -4,7 +4,7 @@ import (
 	"testing"
 )
 
-func TestTsc(t *testing.T) {
+func TestTscCommandline(t *testing.T) {
 	t.Parallel()
 	testCases := []*tscInput{
 		{
@@ -128,7 +128,7 @@ func TestNoEmit(t *testing.T) {
 			"/home/src/workspaces/project/class1.ts": `export class class1 {}`,
 		}, ""),
 		commandLineArgs: []string{"--noEmit"},
-	}).verify(t, "noEmit")
+	}).run(t, "noEmit")
 }
 
 func TestExtends(t *testing.T) {
@@ -198,7 +198,7 @@ func TestExtends(t *testing.T) {
 	}}
 
 	for _, c := range cases {
-		c.verify(t, "extends")
+		c.run(t, "extends")
 	}
 }
 
@@ -221,5 +221,5 @@ func TestTypeAcquisition(t *testing.T) {
 			"/home/src/workspaces/project",
 		),
 		commandLineArgs: []string{},
-	}).verify(t, "typeAcquisition")
+	}).run(t, "typeAcquisition")
 }

internal/execute/tscincremental_test.go

@@ -125,6 +125,6 @@ func TestIncremental(t *testing.T) {
 	}
 
 	for _, test := range testCases {
-		test.verify(t, "incremental")
+		test.run(t, "incremental")
 	}
 }

internal/execute/verifytsc_nocheck_test.go renamed to internal/execute/tscnocheck_test.go

@@ -30,6 +30,6 @@ func TestNoCheck(t *testing.T) {
 				// incremental: undefined, true
 			}, "/home/src/workspaces/project"),
 			commandLineArgs: []string{"--noCheck", "--outFile", "built"},
-		}).verify(t, "noCheck")
+		}).run(t, "noCheck")
 	}
 }

internal/execute/tscprojectreferences_test.go

@@ -289,6 +289,6 @@ func TestProjectReferences(t *testing.T) {
 	}
 
 	for _, c := range cases {
-		c.verify(t, "projectReferences")
+		c.run(t, "projectReferences")
 	}
 }

internal/execute/verifytsc_test.go renamed to internal/execute/tsctestrunner_test.go

@@ -4,6 +4,7 @@ import (
 	"encoding/json"
 	"fmt"
 	"path/filepath"
+	"slices"
 	"strings"
 	"testing"
 
@@ -14,57 +15,81 @@ import (
 type testTscEdit struct {
 	caption         string
 	commandLineArgs []string
-	edit            func(execute.System)
+	edit            func(*testSys)
 }
 
 type tscInput struct {
 	subScenario     string
 	commandLineArgs []string
 	sys             *testSys
-
-	// for watch tests
-	data map[string]string
+	edits           []*testTscEdit
 }
 
-func (test *tscInput) verify(t *testing.T, scenario string) {
+func (test *tscInput) run(t *testing.T, scenario string) {
 	t.Helper()
 	t.Run(test.getTestName(scenario), func(t *testing.T) {
 		t.Parallel()
-		t.Run("baseline for the tsc compiles", func(t *testing.T) {
+		t.Run("tsc baseline", func(t *testing.T) {
 			t.Parallel()
 			// initial test tsc compile
 			baselineBuilder := test.startBaseline()
 
-			exit, parsedCommandLine, _ := execute.CommandLineTest(test.sys, test.commandLineArgs)
+			exit, parsedCommandLine, watcher := execute.CommandLineTest(test.sys, test.commandLineArgs)
 			baselineBuilder.WriteString("ExitStatus:: " + fmt.Sprint(exit))
 
 			compilerOptionsString, _ := json.MarshalIndent(parsedCommandLine.CompilerOptions(), "", "    ")
 			baselineBuilder.WriteString("\n\nCompilerOptions::")
 			baselineBuilder.Write(compilerOptionsString)
 
+			if watcher != nil {
+				execute.StartForTest(watcher)
+			}
+
 			test.sys.serializeState(baselineBuilder)
-			options, name := test.getBaselineName(scenario, false, "")
+
+			for _, do := range test.edits {
+				do.edit(test.sys)
+				baselineBuilder.WriteString("\n\nEdit:: " + do.caption + "\n")
+
+				if watcher == nil {
+					exit, parsedCommandLine, watcher = execute.CommandLineTest(test.sys, test.commandLineArgs)
+					baselineBuilder.WriteString("ExitStatus:: " + fmt.Sprint(exit))
+				} else {
+					execute.RunWatchCycle(watcher)
+				}
+				test.sys.serializeState(baselineBuilder)
+			}
+
+			options, name := test.getBaselineName(scenario, "")
 			baseline.Run(t, name, baselineBuilder.String(), options)
 		})
-	})
-}
 
-func (test *tscInput) getTestName(scenario string) string {
-	return "tsc " + strings.Join(test.commandLineArgs, " ") + " " + scenario + ":: " + test.subScenario
+		// !!! sheetal TODO :: add incremental correctness
+	})
 }
 
-func (test *tscInput) getBaselineName(scenario string, watch bool, suffix string) (baseline.Options, string) {
+func (test *tscInput) getTestNamePrefix() string {
 	commandName := "tsc"
-	// todo build
-	// if isBuildCommand(v.data.commandLineArgs) {
-	// 	commandName = "tsbuild"
-	// }
+	if slices.ContainsFunc(test.commandLineArgs, func(arg string) bool {
+		return arg == "--build" || arg == "-b"
+	}) {
+		commandName = "tsbuild"
+	}
 	w := ""
-	if watch {
+	if slices.ContainsFunc(test.commandLineArgs, func(arg string) bool {
+		return arg == "--watch" || arg == "-w"
+	}) {
 		w = "Watch"
 	}
+	return commandName + w
+}
+
+func (test *tscInput) getTestName(scenario string) string {
+	return test.getTestNamePrefix() + " " + scenario + ":: " + test.subScenario + " " + strings.Join(test.commandLineArgs, " ")
+}
 
-	return baseline.Options{Subfolder: filepath.Join(commandName+w, scenario)},
+func (test *tscInput) getBaselineName(scenario string, suffix string) (baseline.Options, string) {
+	return baseline.Options{Subfolder: filepath.Join(test.getTestNamePrefix(), scenario)},
 		strings.ReplaceAll(test.subScenario, " ", "-") + suffix + ".js"
 }
 
@@ -100,7 +125,7 @@ func (test *tscInput) verifyCommandLineParsing(t *testing.T, scenario string) {
 			baselineBuilder.Write(parsedCommandLineString)
 
 			test.sys.serializeState(baselineBuilder)
-			options, name := test.getBaselineName(scenario, false, "")
+			options, name := test.getBaselineName(scenario, "")
 			baseline.Run(t, name, baselineBuilder.String(), options)
 		})
 	})

internal/execute/tscwatch_test.go

@@ -0,0 +1,124 @@
+package execute_test
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestWatch(t *testing.T) {
+	t.Parallel()
+	testCases := []*tscInput{
+		{
+			subScenario: "watch with no tsconfig",
+			sys: newTestSys(FileMap{
+				"/home/src/workspaces/project/index.ts": "",
+			}, "/home/src/workspaces/project"),
+			commandLineArgs: []string{"index.ts", "--watch"},
+		},
+	}
+
+	for _, test := range testCases {
+		test.run(t, "commandLineWatch")
+	}
+}
+
+func listToTsconfig(base string, tsconfigOpts ...string) (string, string) {
+	optionString := strings.Join(tsconfigOpts, ",\n            ")
+	tsconfigText := `{
+	"compilerOptions": {
+`
+	after := "            "
+	if base != "" {
+		tsconfigText += "            " + base
+		after = ",\n            "
+	}
+	if len(tsconfigOpts) != 0 {
+		tsconfigText += after + optionString
+	}
+	tsconfigText += `
+	}
+}`
+	return tsconfigText, optionString
+}
+
+func toTsconfig(base string, compilerOpts string) string {
+	tsconfigText, _ := listToTsconfig(base, compilerOpts)
+	return tsconfigText
+}
+
+func noEmitWatchTestInput(
+	subScenario string,
+	commandLineArgs []string,
+	aText string,
+	tsconfigOptions []string,
+) *tscInput {
+	noEmitOpt := `"noEmit": true`
+	tsconfigText, optionString := listToTsconfig(noEmitOpt, tsconfigOptions...)
+	sys := newTestSys(FileMap{
+		"/home/src/workspaces/project/a.ts":          aText,
+		"/home/src/workspaces/project/tsconfig.json": tsconfigText,
+	}, "/home/src/workspaces/project")
+	return &tscInput{
+		subScenario:     subScenario,
+		commandLineArgs: commandLineArgs,
+		sys:             sys,
+		edits: []*testTscEdit{
+			newTscEdit("fix syntax error", func(sys *testSys) {
+				sys.WriteFileNoError("/home/src/workspaces/project/a.ts", `const a = "hello";`, false)
+			}),
+			newTscEdit("emit after fixing error", func(sys *testSys) {
+				sys.WriteFileNoError("/home/src/workspaces/project/tsconfig.json", toTsconfig("", optionString), false)
+			}),
+			newTscEdit("no emit run after fixing error", func(sys *testSys) {
+				sys.WriteFileNoError("/home/src/workspaces/project/tsconfig.json", toTsconfig(noEmitOpt, optionString), false)
+			}),
+			newTscEdit("introduce error", func(sys *testSys) {
+				sys.WriteFileNoError("/home/src/workspaces/project/a.ts", aText, false)
+			}),
+			newTscEdit("emit when error", func(sys *testSys) {
+				sys.WriteFileNoError("/home/src/workspaces/project/tsconfig.json", toTsconfig("", optionString), false)
+			}),
+			newTscEdit("no emit run when error", func(sys *testSys) {
+				sys.WriteFileNoError("/home/src/workspaces/project/tsconfig.json", toTsconfig(noEmitOpt, optionString), false)
+			}),
+		},
+	}
+}
+
+func newTscEdit(name string, edit func(sys *testSys)) *testTscEdit {
+	return &testTscEdit{name, []string{}, edit}
+}
+
+func TestTscNoEmitWatch(t *testing.T) {
+	t.Parallel()
+
+	testCases := []*tscInput{
+		noEmitWatchTestInput("syntax errors",
+			[]string{"-w"},
+			`const a = "hello`,
+			nil,
+		),
+		noEmitWatchTestInput(
+			"semantic errors",
+			[]string{"-w"},
+			`const a: number = "hello"`,
+			nil,
+		),
+		noEmitWatchTestInput(
+			"dts errors without dts enabled",
+			[]string{"-w"},
+			`const a = class { private p = 10; };`,
+			nil,
+		),
+		noEmitWatchTestInput(
+			"dts errors",
+			[]string{"-w"},
+			`const a = class { private p = 10; };`,
+			[]string{`"declaration": true`},
+		),
+	}
+
+	for _, test := range testCases {
+		test.run(t, "noEmit")
+	}
+}