Improve memory usage of formatter

internal/execute/fmt_test.go

@@ -0,0 +1,95 @@
+package execute
+
+import (
+	"fmt"
+	"io"
+	"os"
+	"runtime"
+	"testing"
+	"time"
+
+	"github.com/microsoft/typescript-go/internal/bundled"
+	"github.com/microsoft/typescript-go/internal/core"
+	"github.com/microsoft/typescript-go/internal/repo"
+	"github.com/microsoft/typescript-go/internal/tspath"
+	"github.com/microsoft/typescript-go/internal/vfs"
+	"github.com/microsoft/typescript-go/internal/vfs/osvfs"
+)
+
+func BenchmarkFormat(b *testing.B) {
+	checkerPath := tspath.CombinePaths(repo.TypeScriptSubmodulePath, "src", "compiler", "checker.ts")
+
+	tmp := b.TempDir()
+	sys := newSystem()
+
+	var count int
+
+	b.ReportAllocs()
+	time.Sleep(5 * time.Second)
+	for b.Loop() {
+		out := tspath.CombinePaths(tmp, fmt.Sprintf("out%d.ts", count))
+		code := fmtMain(sys, checkerPath, out)
+		if code != 0 {
+			b.Fatalf("Unexpected exit code: %d", code)
+		}
+	}
+}
+
+type osSys struct {
+	writer             io.Writer
+	fs                 vfs.FS
+	defaultLibraryPath string
+	newLine            string
+	cwd                string
+	start              time.Time
+}
+
+func (s *osSys) SinceStart() time.Duration {
+	return time.Since(s.start)
+}
+
+func (s *osSys) Now() time.Time {
+	return time.Now()
+}
+
+func (s *osSys) FS() vfs.FS {
+	return s.fs
+}
+
+func (s *osSys) DefaultLibraryPath() string {
+	return s.defaultLibraryPath
+}
+
+func (s *osSys) GetCurrentDirectory() string {
+	return s.cwd
+}
+
+func (s *osSys) NewLine() string {
+	return s.newLine
+}
+
+func (s *osSys) Writer() io.Writer {
+	return s.writer
+}
+
+func (s *osSys) EndWrite() {
+	// do nothing, this is needed in the interface for testing
+	// todo: revisit if improving tsc/build/watch unittest baselines
+}
+
+func newSystem() *osSys {
+	cwd, err := os.Getwd()
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "Error getting current directory: %v\n", err)
+		os.Exit(int(ExitStatusInvalidProject_OutputsSkipped))
+	}
+
+	return &osSys{
+		cwd:                tspath.NormalizePath(cwd),
+		fs:                 bundled.WrapFS(osvfs.FS()),
+		defaultLibraryPath: bundled.LibPath(),
+		writer:             os.Stdout,
+		newLine:            core.IfElse(runtime.GOOS == "windows", "\r\n", "\n"),
+		start:              time.Now(),
+	}
+}

internal/execute/tsc.go

@@ -13,13 +13,34 @@
 	"github.com/microsoft/typescript-go/internal/compiler"
 	"github.com/microsoft/typescript-go/internal/core"
 	"github.com/microsoft/typescript-go/internal/diagnostics"
+	"github.com/microsoft/typescript-go/internal/format"
+	"github.com/microsoft/typescript-go/internal/parser"
 	"github.com/microsoft/typescript-go/internal/pprof"
+	"github.com/microsoft/typescript-go/internal/scanner"
 	"github.com/microsoft/typescript-go/internal/tsoptions"
 	"github.com/microsoft/typescript-go/internal/tspath"
 )
 
 type cbType = func(p any) any
 
+func applyBulkEdits(text string, edits []core.TextChange) string {
+	b := strings.Builder{}
+	b.Grow(len(text))
+	lastEnd := 0
+	for _, e := range edits {
+		start := e.TextRange.Pos()
+		if start != lastEnd {
+			b.WriteString(text[lastEnd:e.TextRange.Pos()])
+		}
+		b.WriteString(e.NewText)
+
+		lastEnd = e.TextRange.End()
+	}
+	b.WriteString(text[lastEnd:])
+
+	return b.String()
+}
+
 func CommandLine(sys System, cb cbType, commandLineArgs []string) ExitStatus {
 	if len(commandLineArgs) > 0 {
 		// !!! build mode
@@ -28,6 +49,8 @@
 			fmt.Fprint(sys.Writer(), "Build mode is currently unsupported."+sys.NewLine())
 			sys.EndWrite()
 			return ExitStatusNotImplemented
+			// case "-f":
+			// 	return fmtMain(sys, commandLineArgs[1], commandLineArgs[1])
 		}
 	}
 
@@ -39,6 +62,35 @@
 	return start(watcher)
 }
 
+func fmtMain(sys System, input, output string) ExitStatus {
+	ctx := format.WithFormatCodeSettings(context.Background(), format.GetDefaultFormatCodeSettings(sys.NewLine()), sys.NewLine())
+	input = string(tspath.ToPath(input, sys.GetCurrentDirectory(), sys.FS().UseCaseSensitiveFileNames()))
+	output = string(tspath.ToPath(output, sys.GetCurrentDirectory(), sys.FS().UseCaseSensitiveFileNames()))
+	fileContent, ok := sys.FS().ReadFile(input)
+	if !ok {
+		fmt.Fprint(sys.Writer(), "File not found: "+input+sys.NewLine())
+		return ExitStatusNotImplemented
+	}
+	text := string(fileContent)
+	pathified := tspath.ToPath(input, sys.GetCurrentDirectory(), true)
+	sourceFile := parser.ParseSourceFile(
+		string(pathified),
+		pathified,
+		text,
+		core.ScriptTargetESNext,
+		scanner.JSDocParsingModeParseAll,
+	)
+	ast.SetParentInChildren(sourceFile.AsNode())
+	edits := format.FormatDocument(ctx, sourceFile)
+	newText := applyBulkEdits(text, edits)
+
+	if err := sys.FS().WriteFile(output, newText, false); err != nil {
+		fmt.Fprint(sys.Writer(), err.Error()+sys.NewLine())
+		return ExitStatusNotImplemented
+	}
+	return ExitStatusSuccess
+}
+
 func executeCommandLineWorker(sys System, cb cbType, commandLine *tsoptions.ParsedCommandLine) (ExitStatus, *watcher) {
 	configFileName := ""
 	reportDiagnostic := createDiagnosticReporter(sys, commandLine.CompilerOptions())

internal/format/context.go

@@ -86,8 +86,8 @@ func GetDefaultFormatCodeSettings(newLineCharacter string) *FormatCodeSettings {
 }
 
 type formattingContext struct {
-	currentTokenSpan   *TextRangeWithKind
-	nextTokenSpan      *TextRangeWithKind
+	currentTokenSpan   TextRangeWithKind
+	nextTokenSpan      TextRangeWithKind
 	contextNode        *ast.Node
 	currentTokenParent *ast.Node
 	nextTokenParent    *ast.Node
@@ -117,16 +117,10 @@ func NewFormattingContext(file *ast.SourceFile, kind FormatRequestKind, options
 	return res
 }
 
-func (this *formattingContext) UpdateContext(cur *TextRangeWithKind, curParent *ast.Node, next *TextRangeWithKind, nextParent *ast.Node, commonParent *ast.Node) {
-	if cur == nil {
-		panic("nil current range in update context")
-	}
+func (this *formattingContext) UpdateContext(cur TextRangeWithKind, curParent *ast.Node, next TextRangeWithKind, nextParent *ast.Node, commonParent *ast.Node) {
 	if curParent == nil {
 		panic("nil current range node parent in update context")
 	}
-	if next == nil {
-		panic("nil next range in update context")
-	}
 	if nextParent == nil {
 		panic("nil next range node parent in update context")
 	}

internal/format/indent.go

@@ -152,7 +152,11 @@ func getActualIndentationForListItem(node *ast.Node, sourceFile *ast.SourceFile,
 		if listIndentsChild {
 			delta = options.IndentSize
 		}
-		return getActualIndentationForListStartLine(containingList, sourceFile, options) + delta
+		res := getActualIndentationForListStartLine(containingList, sourceFile, options)
+		if res == -1 {
+			return delta
+		}
+		return res + delta
 	}
 	return -1
 }

internal/format/rulecontext.go

@@ -15,11 +15,11 @@ import (
 ///
 
 type (
-	optionSelector    = func(options *FormatCodeSettings) core.Tristate
-	anyOptionSelector = func(options *FormatCodeSettings) any
+	optionSelector                  = func(options *FormatCodeSettings) core.Tristate
+	anyOptionSelector[T comparable] = func(options *FormatCodeSettings) T
 )
 
-func semicolonOption(options *FormatCodeSettings) any { return options.Semicolons }
+func semicolonOption(options *FormatCodeSettings) SemicolonPreference { return options.Semicolons }
 func insertSpaceAfterCommaDelimiterOption(options *FormatCodeSettings) core.Tristate {
 	return options.InsertSpaceAfterCommaDelimiter
 }
@@ -96,7 +96,7 @@ func indentSwitchCaseOption(options *FormatCodeSettings) core.Tristate {
 	return options.IndentSwitchCase
 }
 
-func optionEquals(optionName anyOptionSelector, optionValue any) contextPredicate {
+func optionEquals[T comparable](optionName anyOptionSelector[T], optionValue T) contextPredicate {
 	return func(context *formattingContext) bool {
 		if context.Options == nil {
 			return false
@@ -494,7 +494,7 @@ func isConstructorSignatureContext(context *formattingContext) bool {
 	return context.contextNode.Kind == ast.KindConstructSignature
 }
 
-func isTypeArgumentOrParameterOrAssertion(token *TextRangeWithKind, parent *ast.Node) bool {
+func isTypeArgumentOrParameterOrAssertion(token TextRangeWithKind, parent *ast.Node) bool {
 	if token.Kind != ast.KindLessThanToken && token.Kind != ast.KindGreaterThanToken {
 		return false
 	}

internal/format/rulesmap.go

@@ -7,10 +7,9 @@ import (
 	"github.com/microsoft/typescript-go/internal/ast"
 )
 
-func getRules(context *formattingContext) []*ruleImpl {
+func getRules(context *formattingContext, rules []*ruleImpl) []*ruleImpl {
 	bucket := getRulesMap()[getRuleBucketIndex(context.currentTokenSpan.Kind, context.nextTokenSpan.Kind)]
 	if len(bucket) > 0 {
-		var rules []*ruleImpl
 		ruleActionMask := ruleActionNone
 	outer:
 		for _, rule := range bucket {
@@ -28,7 +27,7 @@ func getRules(context *formattingContext) []*ruleImpl {
 		}
 		return rules
 	}
-	return nil
+	return rules
 }
 
 func getRuleBucketIndex(row ast.Kind, column ast.Kind) int {