Add commandline --build parsing

Author: sheetalkamat

internal/core/buildoptions.go

@@ -0,0 +1,15 @@
+package core
+
+type BuildOptions struct {
+	_ noCopy
+
+	Dry               Tristate `json:"dry,omitzero"`
+	Force             Tristate `json:"force,omitzero"`
+	Verbose           Tristate `json:"verbose,omitzero"`
+	StopBuildOnErrors Tristate `json:"stopBuildOnErrors,omitzero"`
+
+	// CompilerOptions are not parsed here and will be available on ParsedBuildCommandLine
+
+	// Internal fields
+	Clean Tristate `json:"clean,omitzero"`
+}

internal/core/compileroptions.go

@@ -26,7 +26,6 @@ type CompilerOptions struct {
 	AllowUnusedLabels                         Tristate                                  `json:"allowUnusedLabels,omitzero"`
 	AssumeChangesOnlyAffectDirectDependencies Tristate                                  `json:"assumeChangesOnlyAffectDirectDependencies,omitzero"`
 	AlwaysStrict                              Tristate                                  `json:"alwaysStrict,omitzero"`
-	Build                                     Tristate                                  `json:"build,omitzero"`
 	CheckJs                                   Tristate                                  `json:"checkJs,omitzero"`
 	CustomConditions                          []string                                  `json:"customConditions,omitzero"`
 	Composite                                 Tristate                                  `json:"composite,omitzero"`
@@ -142,7 +141,7 @@ type CompilerOptions struct {
 	Version             Tristate `json:"version,omitzero"`
 	Watch               Tristate `json:"watch,omitzero"`
 	ShowConfig          Tristate `json:"showConfig,omitzero"`
-	TscBuild            Tristate `json:"tscBuild,omitzero"`
+	Build               Tristate `json:"build,omitzero"`
 	Help                Tristate `json:"help,omitzero"`
 	All                 Tristate `json:"all,omitzero"`
 

internal/core/projectreference.go

@@ -9,10 +9,10 @@ type ProjectReference struct {
 }
 
 func ResolveProjectReferencePath(ref *ProjectReference) string {
-	return resolveConfigFileNameOfProjectReference(ref.Path)
+	return ResolveConfigFileNameOfProjectReference(ref.Path)
 }
 
-func resolveConfigFileNameOfProjectReference(path string) string {
+func ResolveConfigFileNameOfProjectReference(path string) string {
 	if tspath.FileExtensionIs(path, tspath.ExtensionJson) {
 		return path
 	}

internal/outputpaths/outputpaths.go

@@ -195,7 +195,7 @@ func getDeclarationEmitExtensionForPath(fileName string) string {
 }
 
 func GetBuildInfoFileName(options *core.CompilerOptions, opts tspath.ComparePathsOptions) string {
-	if !options.IsIncremental() && !options.TscBuild.IsTrue() {
+	if !options.IsIncremental() && !options.Build.IsTrue() {
 		return ""
 	}
 	if options.TsBuildInfoFile != "" {

internal/tsoptions/commandlineparser.go

@@ -67,6 +67,56 @@ func ParseCommandLine(
 	}
 }
 
+func ParseBuildCommandLine(
+	commandLine []string,
+	host ParseConfigHost,
+) *ParsedBuildCommandLine {
+	if commandLine == nil {
+		commandLine = []string{}
+	}
+	parser := parseCommandLineWorker(buildOptionsDidYouMeanDiagnostics, commandLine, host.FS())
+	compilerOptions := &core.CompilerOptions{}
+	for key, value := range parser.options.Entries() {
+		buildOption := BuildNameMap.Get(key)
+		if buildOption == &TscBuildOption || buildOption == CompilerNameMap.Get(key) {
+			ParseCompilerOptions(key, value, compilerOptions)
+		}
+	}
+	result := &ParsedBuildCommandLine{
+		BuildOptions:    convertMapToOptions(parser.options, &buildOptionsParser{&core.BuildOptions{}}).BuildOptions,
+		CompilerOptions: compilerOptions,
+		WatchOptions:    convertMapToOptions(parser.options, &watchOptionsParser{&core.WatchOptions{}}).WatchOptions,
+		Projects:        parser.fileNames,
+		Errors:          parser.errors,
+
+		comparePathsOptions: tspath.ComparePathsOptions{
+			UseCaseSensitiveFileNames: host.FS().UseCaseSensitiveFileNames(),
+			CurrentDirectory:          host.GetCurrentDirectory(),
+		},
+	}
+
+	if len(result.Projects) == 0 {
+		// tsc -b invoked with no extra arguments; act as if invoked with "tsc -b ."
+		result.Projects = append(result.Projects, ".")
+	}
+
+	// Nonsensical combinations
+	if result.BuildOptions.Clean.IsTrue() && result.BuildOptions.Force.IsTrue() {
+		result.Errors = append(result.Errors, ast.NewCompilerDiagnostic(diagnostics.Options_0_and_1_cannot_be_combined, "clean", "force"))
+	}
+	if result.BuildOptions.Clean.IsTrue() && result.BuildOptions.Verbose.IsTrue() {
+		result.Errors = append(result.Errors, ast.NewCompilerDiagnostic(diagnostics.Options_0_and_1_cannot_be_combined, "clean", "verbose"))
+	}
+	if result.BuildOptions.Clean.IsTrue() && result.CompilerOptions.Watch.IsTrue() {
+		result.Errors = append(result.Errors, ast.NewCompilerDiagnostic(diagnostics.Options_0_and_1_cannot_be_combined, "clean", "watch"))
+	}
+	if result.CompilerOptions.Watch.IsTrue() && result.BuildOptions.Dry.IsTrue() {
+		result.Errors = append(result.Errors, ast.NewCompilerDiagnostic(diagnostics.Options_0_and_1_cannot_be_combined, "watch", "dry"))
+	}
+
+	return result
+}
+
 func parseCommandLineWorker(
 	parseCommandLineWithDiagnostics *ParseCommandLineWorkerDiagnostics,
 	commandLine []string,
@@ -116,7 +166,7 @@ func (p *commandLineParser) parseStrings(args []string) {
 
 func getInputOptionName(input string) string {
 	// removes at most two leading '-' from the input string
-	return strings.ToLower(strings.TrimPrefix(strings.TrimPrefix(input, "-"), "-"))
+	return strings.TrimPrefix(strings.TrimPrefix(input, "-"), "-")
 }
 
 func (p *commandLineParser) parseResponseFile(fileName string) {

internal/tsoptions/commandlineparser_test.go

@@ -15,6 +15,8 @@ import (
 	"github.com/microsoft/typescript-go/internal/testutil/baseline"
 	"github.com/microsoft/typescript-go/internal/testutil/filefixture"
 	"github.com/microsoft/typescript-go/internal/tsoptions"
+	"github.com/microsoft/typescript-go/internal/tsoptions/tsoptionstest"
+	"github.com/microsoft/typescript-go/internal/tspath"
 	"github.com/microsoft/typescript-go/internal/vfs/osvfs"
 	"gotest.tools/v3/assert"
 )
@@ -80,7 +82,7 @@ func TestCommandLineParseResult(t *testing.T) {
 	}
 
 	for _, testCase := range parseCommandLineSubScenarios {
-		testCase.createSubScenario().assertParseResult(t)
+		testCase.createSubScenario("parseCommandLine").assertParseResult(t)
 	}
 }
 
@@ -89,7 +91,7 @@ func TestParseCommandLineVerifyNull(t *testing.T) {
 	repo.SkipIfNoTypeScriptSubmodule(t)
 
 	// run test for boolean
-	subScenarioInput{"allows setting option type boolean to false", []string{"--composite", "false", "0.ts"}}.createSubScenario().assertParseResult(t)
+	subScenarioInput{"allows setting option type boolean to false", []string{"--composite", "false", "0.ts"}}.createSubScenario("parseCommandLine").assertParseResult(t)
 
 	verifyNullSubScenarios := []verifyNull{
 		{
@@ -114,26 +116,30 @@ func TestParseCommandLineVerifyNull(t *testing.T) {
 
 	for _, verifyNullCase := range verifyNullSubScenarios {
 		createSubScenario(
+			"parseCommandLine",
 			verifyNullCase.subScenario+" allows setting it to null",
 			[]string{"--" + verifyNullCase.optionName, "null", "0.ts"},
 			verifyNullCase.optDecls,
 		).assertParseResult(t)
 
 		if verifyNullCase.nonNullValue != "" {
 			createSubScenario(
+				"parseCommandLine",
 				verifyNullCase.subScenario+" errors if non null value is passed",
 				[]string{"--" + verifyNullCase.optionName, verifyNullCase.nonNullValue, "0.ts"},
 				verifyNullCase.optDecls,
 			).assertParseResult(t)
 		}
 
 		createSubScenario(
+			"parseCommandLine",
 			verifyNullCase.subScenario+" errors if its followed by another option",
 			[]string{"0.ts", "--strictNullChecks", "--" + verifyNullCase.optionName},
 			verifyNullCase.optDecls,
 		).assertParseResult(t)
 
 		createSubScenario(
+			"parseCommandLine",
 			verifyNullCase.subScenario+" errors if its last option",
 			[]string{"0.ts", "--" + verifyNullCase.optionName},
 			verifyNullCase.optDecls,
@@ -195,10 +201,6 @@ func (f commandLineSubScenario) assertParseResult(t *testing.T) {
 	})
 }
 
-func (f *commandLineSubScenario) getBaselineName() (baseline.Options, string) {
-	return baseline.Options{Subfolder: "tsoptions/commandLineParsing"}, f.testName
-}
-
 func parseExistingCompilerBaseline(t *testing.T, baseline string) *TestCommandLineParser {
 	_, rest, _ := strings.Cut(baseline, "CompilerOptions::\n")
 	compilerOptions, rest, watchFound := strings.Cut(rest, "\nWatchOptions::\n")
@@ -243,27 +245,112 @@ func formatNewBaseline(
 	return formatted.String()
 }
 
-// todo: --build not implemented
-// func parseExistingBuildBaseline(baseline string) *TestCommandLineParser {
-// 	_, rest, _ := strings.Cut(baseline, "BuildOptions::\n")
-// 	buildOptions, rest, _ := strings.Cut(rest, "\nWatchOptions::\n")
-// 	_, rest, _ = strings.Cut(rest, "\nProjects::\n")
-// 	fileNames, errors, _ := strings.Cut(rest, "\nErrors::\n")
+func (f commandLineSubScenario) assertBuildParseResult(t *testing.T) {
+	t.Helper()
+	t.Run(f.testName, func(t *testing.T) {
+		t.Parallel()
+		originalBaseline := f.baseline.ReadFile(t)
+		tsBaseline := parseExistingCompilerBaselineBuild(t, originalBaseline)
+
+		// f.workerDiagnostic is either defined or set to default pointer in `createSubScenario`
+		parsed := tsoptions.ParseBuildCommandLine(f.commandLine, &tsoptionstest.VfsParseConfigHost{
+			Vfs:              osvfs.FS(),
+			CurrentDirectory: tspath.NormalizeSlashes(repo.TypeScriptSubmodulePath),
+		})
+
+		newBaselineProjects := strings.Join(parsed.Projects, ",")
+		assert.Equal(t, tsBaseline.projects, newBaselineProjects)
+
+		o, _ := json.Marshal(parsed.BuildOptions)
+		newParsedBuildOptions := &core.BuildOptions{}
+		e := json.Unmarshal(o, newParsedBuildOptions)
+		assert.NilError(t, e)
+		assert.DeepEqual(t, tsBaseline.options, newParsedBuildOptions, cmpopts.IgnoreUnexported(core.BuildOptions{}))
+
+		compilerOpts, _ := json.Marshal(parsed.CompilerOptions)
+		newParsedCompilerOptions := &core.CompilerOptions{}
+		e = json.Unmarshal(compilerOpts, newParsedCompilerOptions)
+		assert.NilError(t, e)
+		assert.DeepEqual(t, tsBaseline.compilerOptions, newParsedCompilerOptions, cmpopts.IgnoreUnexported(core.CompilerOptions{}))
+
+		newParsedWatchOptions := core.WatchOptions{}
+		e = json.Unmarshal(o, &newParsedWatchOptions)
+		assert.NilError(t, e)
+
+		// !!! useful for debugging but will not pass due to `none` as enum options
+		// assert.DeepEqual(t, tsBaseline.watchoptions, newParsedWatchOptions)
+
+		var formattedErrors strings.Builder
+		diagnosticwriter.WriteFormatDiagnostics(&formattedErrors, parsed.Errors, &diagnosticwriter.FormattingOptions{NewLine: "\n"})
+		newBaselineErrors := formattedErrors.String()
+
+		// !!!
+		// useful for debugging--compares the new errors with the old errors. currently will NOT pass because of unimplemented options, not completely identical enum options, etc
+		// assert.Equal(t, tsBaseline.errors, newBaselineErrors)
+
+		baseline.Run(t, f.testName+".js", formatNewBaselineBuild(f.commandLine, o, compilerOpts, newBaselineProjects, newBaselineErrors), baseline.Options{Subfolder: "tsoptions/commandLineParsing"})
+	})
+}
+
+func parseExistingCompilerBaselineBuild(t *testing.T, baseline string) *TestCommandLineParserBuild {
+	_, rest, _ := strings.Cut(baseline, "buildOptions::\n")
+	buildOptions, rest, watchFound := strings.Cut(rest, "\nWatchOptions::\n")
+	watchOptions, rest, _ := strings.Cut(rest, "\nProjects::\n")
+	projects, errors, _ := strings.Cut(rest, "\nErrors::\n")
+
+	baselineBuildOptions := &core.BuildOptions{}
+	e := json.Unmarshal([]byte(buildOptions), &baselineBuildOptions)
+	assert.NilError(t, e)
+
+	baselineCompilerOptions := &core.CompilerOptions{}
+	e = json.Unmarshal([]byte(buildOptions), &baselineCompilerOptions)
+	assert.NilError(t, e)
 
-// 	// todo: change CompilerOptions to buildoptions
-// 	baselineOptions := &core.CompilerOptions{}
-// 	json.Unmarshal([]byte(buildOptions), &baselineOptions)
+	baselineWatchOptions := &core.WatchOptions{}
+	if watchFound && watchOptions != "" {
+		e2 := json.Unmarshal([]byte(watchOptions), &baselineWatchOptions)
+		assert.NilError(t, e2)
+	}
+
+	return &TestCommandLineParserBuild{
+		options:         baselineBuildOptions,
+		compilerOptions: baselineCompilerOptions,
+		watchoptions:    baselineWatchOptions,
+		projects:        projects,
+		errors:          errors,
+	}
+}
 
-// 	var parser = TestCommandLineParser{
-// 		options:   *baselineOptions,
-// 		fileNames: fileNames,
-// 		errors:    errors,
-// 	}
-// 	return &parser
-// }
+func formatNewBaselineBuild(
+	commandLine []string,
+	opts []byte,
+	compilerOpts []byte,
+	projects string,
+	errors string,
+) string {
+	var formatted strings.Builder
+	formatted.WriteString("Args::\n")
+	if len(commandLine) == 0 {
+		formatted.WriteString("[]")
+	} else {
+		formatted.WriteString("[\"" + strings.Join(commandLine, "\", \"") + "\"]")
+	}
+	formatted.WriteString("\n\nbuildOptions::\n")
+	formatted.Write(opts)
+	formatted.WriteString("\n\ncompilerOptions::\n")
+	formatted.Write(compilerOpts)
+	// todo: watch options not implemented
+	// formatted.WriteString("WatchOptions::\n")
+	formatted.WriteString("\n\nProjects::\n")
+	formatted.WriteString(projects)
+	formatted.WriteString("\n\nErrors::\n")
+	formatted.WriteString(errors)
+	return formatted.String()
+}
 
-func createSubScenario(subScenarioName string, commandline []string, opts ...[]*tsoptions.CommandLineOption) *commandLineSubScenario {
-	baselineFileName := "tests/baselines/reference/config/commandLineParsing/parseCommandLine/" + subScenarioName + ".js"
+func createSubScenario(scenarioKind string, subScenarioName string, commandline []string, opts ...[]*tsoptions.CommandLineOption) *commandLineSubScenario {
+	subScenarioName = scenarioKind + "/" + subScenarioName
+	baselineFileName := "tests/baselines/reference/config/commandLineParsing/" + subScenarioName + ".js"
 
 	result := &commandLineSubScenario{
 		filefixture.FromFile(subScenarioName, filepath.Join(repo.TypeScriptSubmodulePath, baselineFileName)),
@@ -282,8 +369,8 @@ type subScenarioInput struct {
 	commandLineArgs []string
 }
 
-func (f subScenarioInput) createSubScenario() *commandLineSubScenario {
-	return createSubScenario(f.name, f.commandLineArgs)
+func (f subScenarioInput) createSubScenario(scenarioKind string) *commandLineSubScenario {
+	return createSubScenario(scenarioKind, f.name, f.commandLineArgs)
 }
 
 type commandLineSubScenario struct {
@@ -306,6 +393,47 @@ type TestCommandLineParser struct {
 	fileNames, errors string
 }
 
+type TestCommandLineParserBuild struct {
+	options          *core.BuildOptions
+	compilerOptions  *core.CompilerOptions
+	watchoptions     *core.WatchOptions
+	projects, errors string
+}
+
+func TestParseBuildCommandLine(t *testing.T) {
+	t.Parallel()
+	repo.SkipIfNoTypeScriptSubmodule(t)
+
+	parseCommandLineSubScenarios := []*subScenarioInput{
+		{"parse build without any options ", []string{}},
+		{"Parse multiple options", []string{"--verbose", "--force", "tests"}},
+		{"Parse option with invalid option", []string{"--verbose", "--invalidOption"}},
+		{"Parse multiple flags with input projects at the end", []string{"--force", "--verbose", "src", "tests"}},
+		{"Parse multiple flags with input projects in the middle", []string{"--force", "src", "tests", "--verbose"}},
+		{"Parse multiple flags with input projects in the beginning", []string{"src", "tests", "--force", "--verbose"}},
+		{"parse build with --incremental", []string{"--incremental", "tests"}},
+		{"parse build with --locale en-us", []string{"--locale", "en-us", "src"}},
+		{"parse build with --tsBuildInfoFile", []string{"--tsBuildInfoFile", "build.tsbuildinfo", "tests"}},
+		{"reports other common may not be used with --build flags", []string{"--strict"}},
+		{`--clean and --force together is invalid`, []string{"--clean", "--force"}},
+		{`--clean and --verbose together is invalid`, []string{"--clean", "--verbose"}},
+		{`--clean and --watch together is invalid`, []string{"--clean", "--watch"}},
+		{`--watch and --dry together is invalid`, []string{"--watch", "--dry"}},
+		{"parse --watchFile", []string{"--watchFile", "UseFsEvents", "--verbose"}},
+		{"parse --watchDirectory", []string{"--watchDirectory", "FixedPollingInterval", "--verbose"}},
+		{"parse --fallbackPolling", []string{"--fallbackPolling", "PriorityInterval", "--verbose"}},
+		{"parse --synchronousWatchDirectory", []string{"--synchronousWatchDirectory", "--verbose"}},
+		{"errors on missing argument", []string{"--verbose", "--fallbackPolling"}},
+		{"errors on invalid excludeDirectories", []string{"--excludeDirectories", "**/../*"}},
+		{"parse --excludeFiles", []string{"--excludeFiles", "**/temp/*.ts"}},
+		{"errors on invalid excludeFiles", []string{"--excludeFiles", "**/../*"}},
+	}
+
+	for _, testCase := range parseCommandLineSubScenarios {
+		testCase.createSubScenario("parseBuildOptions").assertBuildParseResult(t)
+	}
+}
+
 func TestAffectsBuildInfo(t *testing.T) {
 	t.Parallel()
 	t.Run("should have affectsBuildInfo true for every option with affectsSemanticDiagnostics", func(t *testing.T) {

internal/tsoptions/decls_test.go

@@ -26,7 +26,7 @@ func TestCompilerOptionsDeclaration(t *testing.T) {
 		"noEmitForJsFiles",
 		"pathsBasePath",
 		"suppressOutputPathCheck",
-		"tscBuild",
+		"build",
 	}
 
 	internalOptionsMap := make(map[string]string)