Add baseline for semantic diagnostics refresh to check for correctness

Author: sheetalkamat

cmd/tsgo/main.go

@@ -20,5 +20,6 @@ func runMain() int {
 			return runAPI(args[1:])
 		}
 	}
-	return int(execute.CommandLine(newSystem(), args))
+	status, _, _, _ := execute.CommandLine(newSystem(), args, false)
+	return int(status)
 }

internal/execute/export_test.go

@@ -12,6 +12,8 @@ import (
 
 	"github.com/microsoft/typescript-go/internal/collections"
 	"github.com/microsoft/typescript-go/internal/core"
+	"github.com/microsoft/typescript-go/internal/execute"
+	"github.com/microsoft/typescript-go/internal/incremental"
 	"github.com/microsoft/typescript-go/internal/testutil/incrementaltestutil"
 	"github.com/microsoft/typescript-go/internal/tsoptions"
 	"github.com/microsoft/typescript-go/internal/vfs"
@@ -95,6 +97,8 @@ type testSys struct {
 	start time.Time
 }
 
+var _ execute.System = (*testSys)(nil)
+
 func (s *testSys) Now() time.Time {
 	// todo: make a "test time" structure
 	return time.Now()
@@ -162,6 +166,29 @@ func (s *testSys) EndWrite() {
 	s.output = append(s.output, output)
 }
 
+func (s *testSys) baselineProgram(baseline *strings.Builder, program *incremental.Program, watcher *execute.Watcher) {
+	if watcher != nil {
+		program = watcher.GetProgram()
+	}
+	if program == nil {
+		return
+	}
+
+	baseline.WriteString("\nSemanticDiagnostics::\n")
+	semanticDiagnostics, diagnosticsFromOldProgram := program.GetTestingData(program.GetProgram())
+	for _, file := range program.GetProgram().GetSourceFiles() {
+		if diagnostics, ok := semanticDiagnostics[file.Path()]; ok {
+			if oldDiagnostics, ok := diagnosticsFromOldProgram[file.Path()]; !ok || oldDiagnostics != diagnostics {
+				baseline.WriteString("*refresh*    " + file.FileName() + "\n")
+			}
+		} else {
+			baseline.WriteString("*not cached* " + file.FileName() + "\n")
+		}
+	}
+
+	// Write signature updates
+}
+
 func (s *testSys) serializeState(baseline *strings.Builder) {
 	s.baselineOutput(baseline)
 	s.baselineFSwithDiff(baseline)

internal/execute/testsys_test.go

@@ -41,30 +41,25 @@ func applyBulkEdits(text string, edits []core.TextChange) string {
 	return b.String()
 }
 
-func CommandLine(sys System, commandLineArgs []string) ExitStatus {
-	status, _, watcher := commandLineWorker(sys, commandLineArgs)
-	if watcher == nil {
-		return status
-	}
-	return start(watcher)
-}
-
-func commandLineWorker(sys System, commandLineArgs []string) (ExitStatus, *tsoptions.ParsedCommandLine, *watcher) {
+func CommandLine(sys System, commandLineArgs []string, testing bool) (ExitStatus, *tsoptions.ParsedCommandLine, *incremental.Program, *Watcher) {
 	if len(commandLineArgs) > 0 {
 		// !!! build mode
 		switch strings.ToLower(commandLineArgs[0]) {
 		case "-b", "--b", "-build", "--build":
 			fmt.Fprint(sys.Writer(), "Build mode is currently unsupported."+sys.NewLine())
 			sys.EndWrite()
-			return ExitStatusNotImplemented, nil, nil
+			return ExitStatusNotImplemented, nil, nil, nil
 			// case "-f":
 			// 	return fmtMain(sys, commandLineArgs[1], commandLineArgs[1])
 		}
 	}
 
 	parsedCommandLine := tsoptions.ParseCommandLine(commandLineArgs, sys)
-	status, watcher := tscCompilation(sys, parsedCommandLine)
-	return status, parsedCommandLine, watcher
+	status, incrementalProgram, watcher := tscCompilation(sys, parsedCommandLine, testing)
+	if watcher == nil {
+		watcher.start()
+	}
+	return status, parsedCommandLine, incrementalProgram, watcher
 }
 
 func fmtMain(sys System, input, output string) ExitStatus {
@@ -93,7 +88,7 @@ func fmtMain(sys System, input, output string) ExitStatus {
 	return ExitStatusSuccess
 }
 
-func tscCompilation(sys System, commandLine *tsoptions.ParsedCommandLine) (ExitStatus, *watcher) {
+func tscCompilation(sys System, commandLine *tsoptions.ParsedCommandLine, testing bool) (ExitStatus, *incremental.Program, *Watcher) {
 	configFileName := ""
 	reportDiagnostic := createDiagnosticReporter(sys, commandLine.CompilerOptions())
 	// if commandLine.Options().Locale != nil
@@ -102,7 +97,7 @@ func tscCompilation(sys System, commandLine *tsoptions.ParsedCommandLine) (ExitS
 		for _, e := range commandLine.Errors {
 			reportDiagnostic(e)
 		}
-		return ExitStatusDiagnosticsPresent_OutputsSkipped, nil
+		return ExitStatusDiagnosticsPresent_OutputsSkipped, nil, nil
 	}
 
 	if pprofDir := commandLine.CompilerOptions().PprofDir; pprofDir != "" {
@@ -112,42 +107,42 @@ func tscCompilation(sys System, commandLine *tsoptions.ParsedCommandLine) (ExitS
 	}
 
 	if commandLine.CompilerOptions().Init.IsTrue() {
-		return ExitStatusNotImplemented, nil
+		return ExitStatusNotImplemented, nil, nil
 	}
 
 	if commandLine.CompilerOptions().Version.IsTrue() {
 		printVersion(sys)
-		return ExitStatusSuccess, nil
+		return ExitStatusSuccess, nil, nil
 	}
 
 	if commandLine.CompilerOptions().Help.IsTrue() || commandLine.CompilerOptions().All.IsTrue() {
 		printHelp(sys, commandLine)
-		return ExitStatusSuccess, nil
+		return ExitStatusSuccess, nil, nil
 	}
 
 	if commandLine.CompilerOptions().Watch.IsTrue() && commandLine.CompilerOptions().ListFilesOnly.IsTrue() {
 		reportDiagnostic(ast.NewCompilerDiagnostic(diagnostics.Options_0_and_1_cannot_be_combined, "watch", "listFilesOnly"))
-		return ExitStatusDiagnosticsPresent_OutputsSkipped, nil
+		return ExitStatusDiagnosticsPresent_OutputsSkipped, nil, nil
 	}
 
 	if commandLine.CompilerOptions().Project != "" {
 		if len(commandLine.FileNames()) != 0 {
 			reportDiagnostic(ast.NewCompilerDiagnostic(diagnostics.Option_project_cannot_be_mixed_with_source_files_on_a_command_line))
-			return ExitStatusDiagnosticsPresent_OutputsSkipped, nil
+			return ExitStatusDiagnosticsPresent_OutputsSkipped, nil, nil
 		}
 
 		fileOrDirectory := tspath.NormalizePath(commandLine.CompilerOptions().Project)
 		if sys.FS().DirectoryExists(fileOrDirectory) {
 			configFileName = tspath.CombinePaths(fileOrDirectory, "tsconfig.json")
 			if !sys.FS().FileExists(configFileName) {
 				reportDiagnostic(ast.NewCompilerDiagnostic(diagnostics.Cannot_find_a_tsconfig_json_file_at_the_current_directory_Colon_0, configFileName))
-				return ExitStatusDiagnosticsPresent_OutputsSkipped, nil
+				return ExitStatusDiagnosticsPresent_OutputsSkipped, nil, nil
 			}
 		} else {
 			configFileName = fileOrDirectory
 			if !sys.FS().FileExists(configFileName) {
 				reportDiagnostic(ast.NewCompilerDiagnostic(diagnostics.The_specified_path_does_not_exist_Colon_0, fileOrDirectory))
-				return ExitStatusDiagnosticsPresent_OutputsSkipped, nil
+				return ExitStatusDiagnosticsPresent_OutputsSkipped, nil, nil
 			}
 		}
 	} else if len(commandLine.FileNames()) == 0 {
@@ -162,7 +157,7 @@ func tscCompilation(sys System, commandLine *tsoptions.ParsedCommandLine) (ExitS
 			printVersion(sys)
 			printHelp(sys, commandLine)
 		}
-		return ExitStatusDiagnosticsPresent_OutputsSkipped, nil
+		return ExitStatusDiagnosticsPresent_OutputsSkipped, nil, nil
 	}
 
 	// !!! convert to options with absolute paths is usually done here, but for ease of implementation, it's done in `tsoptions.ParseCommandLine()`
@@ -179,7 +174,7 @@ func tscCompilation(sys System, commandLine *tsoptions.ParsedCommandLine) (ExitS
 			for _, e := range errors {
 				reportDiagnostic(e)
 			}
-			return ExitStatusDiagnosticsPresent_OutputsGenerated, nil
+			return ExitStatusDiagnosticsPresent_OutputsGenerated, nil, nil
 		}
 		configForCompilation = configParseResult
 		// Updater to reflect pretty
@@ -188,26 +183,28 @@ func tscCompilation(sys System, commandLine *tsoptions.ParsedCommandLine) (ExitS
 
 	if compilerOptionsFromCommandLine.ShowConfig.IsTrue() {
 		showConfig(sys, configForCompilation.CompilerOptions())
-		return ExitStatusSuccess, nil
+		return ExitStatusSuccess, nil, nil
 	}
 	if configForCompilation.CompilerOptions().Watch.IsTrue() {
-		return ExitStatusSuccess, createWatcher(sys, configForCompilation, reportDiagnostic)
+		return ExitStatusSuccess, nil, createWatcher(sys, configForCompilation, reportDiagnostic, testing)
 	} else if configForCompilation.CompilerOptions().IsIncremental() {
-		return performIncrementalCompilation(
+		exitStatus, program := performIncrementalCompilation(
 			sys,
 			configForCompilation,
 			reportDiagnostic,
 			&extendedConfigCache,
 			configTime,
-		), nil
+			testing,
+		)
+		return exitStatus, program, nil
 	}
 	return performCompilation(
 		sys,
 		configForCompilation,
 		reportDiagnostic,
 		&extendedConfigCache,
 		configTime,
-	), nil
+	), nil, nil
 }
 
 func findConfigFile(searchPath string, fileExists func(string) bool, configName string) string {
@@ -230,7 +227,8 @@ func performIncrementalCompilation(
 	reportDiagnostic diagnosticReporter,
 	extendedConfigCache *collections.SyncMap[tspath.Path, *tsoptions.ExtendedConfigCacheEntry],
 	configTime time.Duration,
-) ExitStatus {
+	testing bool,
+) (ExitStatus, *incremental.Program) {
 	host := compiler.NewCachedFSCompilerHost(config.CompilerOptions(), sys.GetCurrentDirectory(), sys.FS(), sys.DefaultLibraryPath(), extendedConfigCache)
 	oldProgram := incremental.ReadBuildInfoProgram(config, incremental.NewBuildInfoReader(host))
 	// todo: cache, statistics, tracing
@@ -241,7 +239,7 @@ func performIncrementalCompilation(
 		JSDocParsingMode: ast.JSDocParsingModeParseForTypeErrors,
 	})
 	parseTime := sys.Now().Sub(parseStart)
-	incrementalProgram := incremental.NewProgram(program, oldProgram)
+	incrementalProgram := incremental.NewProgram(program, oldProgram, testing)
 	return emitAndReportStatistics(
 		sys,
 		incrementalProgram,
@@ -250,7 +248,7 @@ func performIncrementalCompilation(
 		reportDiagnostic,
 		configTime,
 		parseTime,
-	)
+	), incrementalProgram
 }
 
 func performCompilation(

internal/execute/tsc.go

@@ -9,6 +9,7 @@ import (
 	"testing"
 
 	"github.com/microsoft/typescript-go/internal/execute"
+	"github.com/microsoft/typescript-go/internal/incremental"
 	"github.com/microsoft/typescript-go/internal/testutil/baseline"
 )
 
@@ -34,30 +35,28 @@ func (test *tscInput) run(t *testing.T, scenario string) {
 			// initial test tsc compile
 			baselineBuilder := test.startBaseline()
 
-			exit, parsedCommandLine, watcher := execute.CommandLineTest(test.sys, test.commandLineArgs)
+			exit, parsedCommandLine, incrementalProgram, watcher := execute.CommandLine(test.sys, test.commandLineArgs, true)
 			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)
-
+			test.sys.baselineProgram(baselineBuilder, incrementalProgram, watcher)
 			for _, do := range test.edits {
 				do.edit(test.sys)
 				baselineBuilder.WriteString("\n\nEdit:: " + do.caption + "\n")
 
+				var incrementalProgram *incremental.Program
 				if watcher == nil {
-					exit, parsedCommandLine, watcher = execute.CommandLineTest(test.sys, test.commandLineArgs)
+					exit, parsedCommandLine, incrementalProgram, watcher = execute.CommandLine(test.sys, test.commandLineArgs, true)
 					baselineBuilder.WriteString("ExitStatus:: " + fmt.Sprint(exit))
 				} else {
-					execute.RunWatchCycle(watcher)
+					watcher.DoCycle()
 				}
 				test.sys.serializeState(baselineBuilder)
+				test.sys.baselineProgram(baselineBuilder, incrementalProgram, watcher)
 			}
 
 			options, name := test.getBaselineName(scenario, "")
@@ -117,7 +116,7 @@ func (test *tscInput) verifyCommandLineParsing(t *testing.T, scenario string) {
 			// initial test tsc compile
 			baselineBuilder := test.startBaseline()
 
-			exit, parsedCommandLine, _ := execute.CommandLineTest(test.sys, test.commandLineArgs)
+			exit, parsedCommandLine, _, _ := execute.CommandLine(test.sys, test.commandLineArgs, true)
 			baselineBuilder.WriteString("ExitStatus:: " + fmt.Sprint(exit))
 			//nolint:musttag
 			parsedCommandLineString, _ := json.MarshalIndent(parsedCommandLine, "", "    ")