Incremental port

cmd/tsgo/main.go

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

internal/ast/diagnostic.go

@@ -21,6 +21,7 @@ type Diagnostic struct {
 	relatedInformation []*Diagnostic
 	reportsUnnecessary bool
 	reportsDeprecated  bool
+	skippedOnNoEmit    bool
 }
 
 func (d *Diagnostic) File() *SourceFile                 { return d.file }
@@ -35,10 +36,12 @@ func (d *Diagnostic) MessageChain() []*Diagnostic       { return d.messageChain
 func (d *Diagnostic) RelatedInformation() []*Diagnostic { return d.relatedInformation }
 func (d *Diagnostic) ReportsUnnecessary() bool          { return d.reportsUnnecessary }
 func (d *Diagnostic) ReportsDeprecated() bool           { return d.reportsDeprecated }
+func (d *Diagnostic) SkippedOnNoEmit() bool             { return d.skippedOnNoEmit }
 
 func (d *Diagnostic) SetFile(file *SourceFile)                  { d.file = file }
 func (d *Diagnostic) SetLocation(loc core.TextRange)            { d.loc = loc }
 func (d *Diagnostic) SetCategory(category diagnostics.Category) { d.category = category }
+func (d *Diagnostic) SetSkippedOnNoEmit()                       { d.skippedOnNoEmit = true }
 
 func (d *Diagnostic) SetMessageChain(messageChain []*Diagnostic) *Diagnostic {
 	d.messageChain = messageChain
@@ -69,6 +72,32 @@ func (d *Diagnostic) Clone() *Diagnostic {
 	return &result
 }
 
+func NewDiagnosticWith(
+	file *SourceFile,
+	loc core.TextRange,
+	code int32,
+	category diagnostics.Category,
+	message string,
+	messageChain []*Diagnostic,
+	relatedInformation []*Diagnostic,
+	reportsUnnecessary bool,
+	reportsDeprecated bool,
+	skippedOnNoEmit bool,
+) *Diagnostic {
+	return &Diagnostic{
+		file:               file,
+		loc:                loc,
+		code:               code,
+		category:           category,
+		message:            message,
+		messageChain:       messageChain,
+		relatedInformation: relatedInformation,
+		reportsUnnecessary: reportsUnnecessary,
+		reportsDeprecated:  reportsDeprecated,
+		skippedOnNoEmit:    skippedOnNoEmit,
+	}
+}
+
 func NewDiagnostic(file *SourceFile, loc core.TextRange, message *diagnostics.Message, args ...any) *Diagnostic {
 	return &Diagnostic{
 		file:               file,

internal/ast/utilities.go

@@ -1644,6 +1644,10 @@ func IsModuleAugmentationExternal(node *Node) bool {
 	return false
 }
 
+func IsModuleWithStringLiteralName(node *Node) bool {
+	return IsModuleDeclaration(node) && node.Name().Kind == KindStringLiteral
+}
+
 func GetContainingClass(node *Node) *Node {
 	return FindAncestor(node.Parent, IsClassLike)
 }

internal/checker/checker.go

@@ -856,6 +856,8 @@ type Checker struct {
 	skipDirectInferenceNodes                    collections.Set[*ast.Node]
 	ctx                                         context.Context
 	packagesMap                                 map[string]bool
+	ambientModulesOnce                          sync.Once
+	ambientModules                              []*ast.Symbol
 }
 
 func NewChecker(program Program) *Checker {
@@ -2104,7 +2106,7 @@ func (c *Checker) getSymbol(symbols ast.SymbolTable, name string, meaning ast.Sy
 }
 
 func (c *Checker) CheckSourceFile(ctx context.Context, sourceFile *ast.SourceFile) {
-	if SkipTypeChecking(sourceFile, c.compilerOptions, c.program) {
+	if SkipTypeChecking(sourceFile, c.compilerOptions, c.program, false) {
 		return
 	}
 	c.checkSourceFile(ctx, sourceFile)
@@ -10088,7 +10090,7 @@ func (c *Checker) checkCollisionWithRequireExportsInGeneratedCode(node *ast.Node
 	parent := ast.GetDeclarationContainer(node)
 	if ast.IsSourceFile(parent) && ast.IsExternalOrCommonJSModule(parent.AsSourceFile()) {
 		// If the declaration happens to be in external module, report error that require and exports are reserved keywords
-		c.error(name, diagnostics.Duplicate_identifier_0_Compiler_reserves_name_1_in_top_level_scope_of_a_module, scanner.DeclarationNameToString(name), scanner.DeclarationNameToString(name))
+		c.errorSkippedOnNoEmit(name, diagnostics.Duplicate_identifier_0_Compiler_reserves_name_1_in_top_level_scope_of_a_module, scanner.DeclarationNameToString(name), scanner.DeclarationNameToString(name))
 	}
 }
 
@@ -13340,6 +13342,12 @@ func (c *Checker) error(location *ast.Node, message *diagnostics.Message, args .
 	return diagnostic
 }
 
+func (c *Checker) errorSkippedOnNoEmit(location *ast.Node, message *diagnostics.Message, args ...any) *ast.Diagnostic {
+	diagnostic := c.error(location, message, args...)
+	diagnostic.SetSkippedOnNoEmit()
+	return diagnostic
+}
+
 func (c *Checker) errorOrSuggestion(isError bool, location *ast.Node, message *diagnostics.Message, args ...any) {
 	c.addErrorOrSuggestion(isError, NewDiagnosticForNode(location, message, args...))
 }
@@ -14836,6 +14844,17 @@ func (c *Checker) tryFindAmbientModule(moduleName string, withAugmentations bool
 	return symbol
 }
 
+func (c *Checker) GetAmbientModules() []*ast.Symbol {
+	c.ambientModulesOnce.Do(func() {
+		for sym, global := range c.globals {
+			if strings.HasPrefix(sym, "\"") && strings.HasSuffix(sym, "\"") {
+				c.ambientModules = append(c.ambientModules, global)
+			}
+		}
+	})
+	return c.ambientModules
+}
+
 func (c *Checker) resolveExternalModuleSymbol(moduleSymbol *ast.Symbol, dontResolveAlias bool) *ast.Symbol {
 	if moduleSymbol != nil {
 		exportEquals := c.resolveSymbolEx(moduleSymbol.Exports[ast.InternalSymbolNameExportEquals], dontResolveAlias)

internal/checker/checker_test.go

@@ -77,7 +77,7 @@ func TestCheckSrcCompiler(t *testing.T) {
 		Config: parsed,
 		Host:   host,
 	})
-	p.CheckSourceFiles(t.Context())
+	p.CheckSourceFiles(t.Context(), nil)
 }
 
 func BenchmarkNewChecker(b *testing.B) {

internal/checker/grammarchecks.go

@@ -42,6 +42,17 @@ func (c *Checker) grammarErrorOnNode(node *ast.Node, message *diagnostics.Messag
 	return false
 }
 
+func (c *Checker) grammarErrorOnNodeSkippedOnNoEmit(node *ast.Node, message *diagnostics.Message, args ...any) bool {
+	sourceFile := ast.GetSourceFileOfNode(node)
+	if !c.hasParseDiagnostics(sourceFile) {
+		d := NewDiagnosticForNode(node, message, args...)
+		d.SetSkippedOnNoEmit()
+		c.diagnostics.Add(d)
+		return true
+	}
+	return false
+}
+
 func (c *Checker) checkGrammarRegularExpressionLiteral(_ *ast.RegularExpressionLiteral) bool {
 	// !!!
 	// Unclear if this is needed until regular expression parsing is more thoroughly implemented.
@@ -1648,7 +1659,7 @@ func (c *Checker) checkGrammarVariableDeclaration(node *ast.VariableDeclaration)
 func (c *Checker) checkGrammarForEsModuleMarkerInBindingName(name *ast.Node) bool {
 	if ast.IsIdentifier(name) {
 		if name.Text() == "__esModule" {
-			return c.grammarErrorOnNode(name, diagnostics.Identifier_expected_esModule_is_reserved_as_an_exported_marker_when_transforming_ECMAScript_modules)
+			return c.grammarErrorOnNodeSkippedOnNoEmit(name, diagnostics.Identifier_expected_esModule_is_reserved_as_an_exported_marker_when_transforming_ECMAScript_modules)
 		}
 	} else {
 		for _, element := range name.AsBindingPattern().Elements.Nodes {

internal/checker/symbolaccessibility.go

@@ -105,11 +105,7 @@ func (ch *Checker) IsAnySymbolAccessible(symbols []*ast.Symbol, enclosingDeclara
 }
 
 func hasNonGlobalAugmentationExternalModuleSymbol(declaration *ast.Node) bool {
-	return isModuleWithStringLiteralName(declaration) || (declaration.Kind == ast.KindSourceFile && ast.IsExternalOrCommonJSModule(declaration.AsSourceFile()))
-}
-
-func isModuleWithStringLiteralName(node *ast.Node) bool {
-	return ast.IsModuleDeclaration(node) && node.Name().Kind == ast.KindStringLiteral
+	return ast.IsModuleWithStringLiteralName(declaration) || (declaration.Kind == ast.KindSourceFile && ast.IsExternalOrCommonJSModule(declaration.AsSourceFile()))
 }
 
 func getQualifiedLeftMeaning(rightMeaning ast.SymbolFlags) ast.SymbolFlags {

internal/checker/utilities.go

@@ -1467,8 +1467,8 @@ func forEachYieldExpression(body *ast.Node, visitor func(expr *ast.Node)) {
 	traverse(body)
 }
 
-func SkipTypeChecking(sourceFile *ast.SourceFile, options *core.CompilerOptions, host Program) bool {
-	return options.NoCheck.IsTrue() ||
+func SkipTypeChecking(sourceFile *ast.SourceFile, options *core.CompilerOptions, host Program, ignoreNoCheck bool) bool {
+	return (!ignoreNoCheck && options.NoCheck.IsTrue()) ||
 		options.SkipLibCheck.IsTrue() && sourceFile.IsDeclarationFile ||
 		options.SkipDefaultLibCheck.IsTrue() && host.IsSourceFileDefaultLibrary(sourceFile.Path()) ||
 		host.IsSourceFromProjectReference(sourceFile.Path()) ||

internal/collections/manytomanymap.go

@@ -0,0 +1,68 @@
+package collections
+
+type ManyToManyMap[K comparable, V comparable] struct {
+	keyToValueSet map[K]*Set[V]
+	valueToKeySet map[V]*Set[K]
+}
+
+func (m *ManyToManyMap[K, V]) GetKeys(value V) (*Set[K], bool) {
+	keys, present := m.valueToKeySet[value]
+	return keys, present
+}
+
+func (m *ManyToManyMap[K, V]) GetValues(key K) (*Set[V], bool) {
+	values, present := m.keyToValueSet[key]
+	return values, present
+}
+
+func (m *ManyToManyMap[K, V]) Len() int {
+	return len(m.keyToValueSet)
+}
+
+func (m *ManyToManyMap[K, V]) Keys() map[K]*Set[V] {
+	return m.keyToValueSet
+}
+
+func (m *ManyToManyMap[K, V]) Add(key K, valueSet *Set[V]) {
+	existingValueSet, hasExisting := m.keyToValueSet[key]
+	if m.keyToValueSet == nil {
+		m.keyToValueSet = make(map[K]*Set[V])
+	}
+	m.keyToValueSet[key] = valueSet
+	for value := range valueSet.Keys() {
+		if !hasExisting || !existingValueSet.Has(value) {
+			// Add to valueToKeySet
+			if m.valueToKeySet == nil {
+				m.valueToKeySet = make(map[V]*Set[K])
+			}
+			addToMapOfSet(m.valueToKeySet, value, key)
+		}
+	}
+
+	if hasExisting {
+		for value := range existingValueSet.Keys() {
+			if !valueSet.Has(value) {
+				// Remove from valueToKeySet
+				defer deleteFromMapOfSet(m.valueToKeySet, value, key)
+			}
+		}
+	}
+}
+
+func addToMapOfSet[K comparable, V comparable](mapKSetV map[K]*Set[V], key K, value V) {
+	set, exists := mapKSetV[key]
+	if !exists {
+		set = &Set[V]{}
+		mapKSetV[key] = set
+	}
+	set.Add(value)
+}
+
+func deleteFromMapOfSet[K comparable, V comparable](mapKSetV map[K]*Set[V], key K, value V) {
+	if set, exists := mapKSetV[key]; exists {
+		set.Delete(value)
+		if set.Len() == 0 {
+			delete(mapKSetV, key)
+		}
+	}
+}

internal/collections/set.go

@@ -1,5 +1,7 @@
 package collections
 
+import "maps"
+
 type Set[T comparable] struct {
 	M map[T]struct{}
 }
@@ -48,6 +50,32 @@ func (s *Set[T]) AddIfAbsent(key T) bool {
 	return true
 }
 
+func (s *Set[T]) Clone() *Set[T] {
+	if s == nil {
+		return nil
+	}
+	clone := &Set[T]{M: maps.Clone(s.M)}
+	return clone
+}
+
+func (s *Set[T]) Equals(other *Set[T]) bool {
+	if s == other {
+		return true
+	}
+	if s == nil || other == nil {
+		return false
+	}
+	if s.Len() != other.Len() {
+		return false
+	}
+	for key := range s.M {
+		if !other.Has(key) {
+			return false
+		}
+	}
+	return true
+}
+
 func NewSetFromItems[T comparable](items ...T) *Set[T] {
 	s := &Set[T]{}
 	for _, item := range items {

internal/collections/syncset.go

@@ -16,3 +16,19 @@ func (s *SyncSet[T]) Add(key T) {
 func (s *SyncSet[T]) Delete(key T) {
 	s.m.Delete(key)
 }
+
+func (s *SyncSet[T]) Range(fn func(key T) bool) {
+	s.m.Range(func(key T, value struct{}) bool {
+		return fn(key)
+	})
+}
+
+func (s *SyncSet[T]) ToArray() []T {
+	var arr []T
+	arr = make([]T, 0, s.m.Size())
+	s.m.Range(func(key T, value struct{}) bool {
+		arr = append(arr, key)
+		return true
+	})
+	return arr
+}

internal/compiler/checkerpool.go

@@ -53,7 +53,7 @@ func (p *checkerPool) GetChecker(ctx context.Context) (*checker.Checker, func())
 
 func (p *checkerPool) createCheckers() {
 	p.createCheckersOnce.Do(func() {
-		wg := core.NewWorkGroup(p.program.singleThreaded())
+		wg := core.NewWorkGroup(p.program.SingleThreaded())
 		for i := range p.checkerCount {
 			wg.Queue(func() {
 				p.checkers[i] = checker.NewChecker(p.program)

internal/compiler/emitHost.go

@@ -14,14 +14,6 @@ import (
 	"github.com/microsoft/typescript-go/internal/tspath"
 )
 
-type WriteFileData struct {
-	SourceMapUrlPos int
-	// BuildInfo BuildInfo
-	Diagnostics      []*ast.Diagnostic
-	DiffersOnlyInMap bool
-	SkippedDtsWrite  bool
-}
-
 // NOTE: EmitHost operations must be thread-safe
 type EmitHost interface {
 	printer.EmitHost
@@ -120,7 +112,7 @@ func (host *emitHost) IsEmitBlocked(file string) bool {
 	return false
 }
 
-func (host *emitHost) WriteFile(fileName string, text string, writeByteOrderMark bool, _ []*ast.SourceFile, _ *printer.WriteFileData) error {
+func (host *emitHost) WriteFile(fileName string, text string, writeByteOrderMark bool) error {
 	return host.program.Host().FS().WriteFile(fileName, text, writeByteOrderMark)
 }