codeOwlAI · codeOwlAI · Jun 19, 2025 · Jun 19, 2025 · Jun 19, 2025 · Jun 19, 2025
diff --git a/_packages/api/package.json b/_packages/api/package.json
@@ -46,6 +46,6 @@
     },
     "dependencies": {
         "@typescript/ast": "1.0.0",
-        "libsyncrpc": "github:microsoft/libsyncrpc#bb02d84"
+        "@typescript/libsyncrpc": "github:microsoft/libsyncrpc#8cdae454cc482536c5844bef83b796f95464da85"
     }
 }
diff --git a/_packages/api/src/client.ts b/_packages/api/src/client.ts
@@ -1,4 +1,4 @@
-import { SyncRpcChannel } from "libsyncrpc";
+import { SyncRpcChannel } from "@typescript/libsyncrpc";
 import type { FileSystem } from "./fs.ts";
 
 export interface ClientOptions {

diff --git a/_submodules/TypeScript b/_submodules/TypeScript
diff --git a/internal/ast/nodeflags.go b/internal/ast/nodeflags.go
@@ -43,8 +43,6 @@ const (
 	NodeFlagsJsonFile        NodeFlags = 1 << 25 // If node was parsed in a Json
 	NodeFlagsDeprecated      NodeFlags = 1 << 26 // If has '@deprecated' JSDoc tag
 
-	NodeFlagsSkipDirectInference NodeFlags = 1 << 27 // If the node should skip direct type inference.
-
 	NodeFlagsBlockScoped = NodeFlagsLet | NodeFlagsConst | NodeFlagsUsing
 	NodeFlagsConstant    = NodeFlagsConst | NodeFlagsUsing
 	NodeFlagsAwaitUsing  = NodeFlagsConst | NodeFlagsUsing // Variable declaration (NOTE: on a single node these flags would otherwise be mutually exclusive)

diff --git a/internal/ast/utilities.go b/internal/ast/utilities.go
@@ -1611,7 +1611,7 @@ func IsEffectiveExternalModule(node *SourceFile, compilerOptions *core.CompilerO
 }
 
 func isCommonJSContainingModuleKind(kind core.ModuleKind) bool {
-	return kind == core.ModuleKindCommonJS || kind == core.ModuleKindNode16 || kind == core.ModuleKindNodeNext
+	return kind == core.ModuleKindCommonJS || core.ModuleKindNode16 <= kind && kind <= core.ModuleKindNodeNext
 }
 
 func IsExternalModuleIndicator(node *Statement) bool {

diff --git a/internal/checker/checker.go b/internal/checker/checker.go
diff --git a/internal/checker/emitresolver.go b/internal/checker/emitresolver.go
@@ -900,12 +900,10 @@ func (r *emitResolver) CreateLiteralConstValue(emitContext *printer.EmitContext,
 	if t.flags&TypeFlagsLiteral == 0 {
 		return nil // non-literal type
 	}
-	literalValue := t.AsLiteralType().value
-	switch literalValue.(type) {
+	switch value := t.AsLiteralType().value.(type) {
 	case string:
-		return emitContext.Factory.NewStringLiteral(literalValue.(string))
+		return emitContext.Factory.NewStringLiteral(value)
 	case jsnum.Number:
-		value := literalValue.(jsnum.Number)
 		if value.Abs() != value {
 			// negative
 			return emitContext.Factory.NewPrefixUnaryExpression(
@@ -915,20 +913,13 @@ func (r *emitResolver) CreateLiteralConstValue(emitContext *printer.EmitContext,
 		}
 		return emitContext.Factory.NewNumericLiteral(value.String())
 	case jsnum.PseudoBigInt:
-		value := literalValue.(jsnum.PseudoBigInt)
-		if value.Negative {
-			// negative
-			return emitContext.Factory.NewPrefixUnaryExpression(
-				ast.KindMinusToken,
-				emitContext.Factory.NewBigIntLiteral(value.Base10Value),
-			)
-		}
-		return emitContext.Factory.NewNumericLiteral(value.Base10Value)
+		return emitContext.Factory.NewBigIntLiteral(pseudoBigIntToString(value) + "n")
 	case bool:
-		if literalValue.(bool) {
-			return emitContext.Factory.NewKeywordExpression(ast.KindTrueKeyword)
+		kind := ast.KindFalseKeyword
+		if value {
+			kind = ast.KindTrueKeyword
 		}
-		return emitContext.Factory.NewKeywordExpression(ast.KindFalseKeyword)
+		return emitContext.Factory.NewKeywordExpression(kind)
 	}
 	panic("unhandled literal const value kind")
 }

diff --git a/internal/checker/nodebuilder.go b/internal/checker/nodebuilder.go
@@ -18,6 +18,7 @@ func (b *NodeBuilder) EmitContext() *printer.EmitContext {
 }
 
 func (b *NodeBuilder) enterContext(enclosingDeclaration *ast.Node, flags nodebuilder.Flags, internalFlags nodebuilder.InternalFlags, tracker nodebuilder.SymbolTracker) {
+	b.ctxStack = append(b.ctxStack, b.impl.ctx)
 	b.impl.ctx = &NodeBuilderContext{
 		tracker:                  tracker,
 		flags:                    flags,
@@ -36,7 +37,6 @@ func (b *NodeBuilder) enterContext(enclosingDeclaration *ast.Node, flags nodebui
 		tracker = NewSymbolTrackerImpl(b.impl.ctx, nil, b.host)
 		b.impl.ctx.tracker = tracker
 	}
-	b.ctxStack = append(b.ctxStack, b.impl.ctx)
 }
 
 func (b *NodeBuilder) popContext() {

diff --git a/internal/checker/services.go b/internal/checker/services.go
@@ -585,28 +585,27 @@ func (c *Checker) getResolvedSignatureWorker(node *ast.Node, checkMode CheckMode
 }
 
 func (c *Checker) GetCandidateSignaturesForStringLiteralCompletions(call *ast.CallLikeExpression, editingArgument *ast.Node) []*Signature {
-	candidatesSet := collections.Set[*Signature]{}
-
 	// first, get candidates when inference is blocked from the source node.
 	candidates := runWithInferenceBlockedFromSourceNode(c, editingArgument, func() []*Signature {
 		_, blockedInferenceCandidates := c.getResolvedSignatureWorker(call, CheckModeNormal, 0)
 		return blockedInferenceCandidates
 	})
-	for _, candidate := range candidates {
-		candidatesSet.Add(candidate)
-	}
+	candidatesSet := collections.NewSetFromItems(candidates...)
 
 	// next, get candidates where the source node is considered for inference.
-	candidates = runWithoutResolvedSignatureCaching(c, editingArgument, func() []*Signature {
+	otherCandidates := runWithoutResolvedSignatureCaching(c, editingArgument, func() []*Signature {
 		_, inferenceCandidates := c.getResolvedSignatureWorker(call, CheckModeNormal, 0)
 		return inferenceCandidates
 	})
 
-	for _, candidate := range candidates {
-		candidatesSet.Add(candidate)
+	for _, candidate := range otherCandidates {
+		if candidatesSet.Has(candidate) {
+			continue
+		}
+		candidates = append(candidates, candidate)
 	}
 
-	return slices.Collect(maps.Keys(candidatesSet.Keys()))
+	return candidates
 }
 
 func (c *Checker) GetTypeParameterAtPosition(s *Signature, pos int) *Type {

diff --git a/internal/compiler/emitHost.go b/internal/compiler/emitHost.go
@@ -124,3 +124,7 @@ func (host *emitHost) GetEmitResolver(file *ast.SourceFile, skipDiagnostics bool
 	defer done()
 	return checker.GetEmitResolver(file, skipDiagnostics)
 }
+
+func (host *emitHost) IsSourceFileFromExternalLibrary(file *ast.SourceFile) bool {
+	return host.program.IsSourceFileFromExternalLibrary(file)
+}
diff --git a/internal/compiler/emitter.go b/internal/compiler/emitter.go
@@ -2,7 +2,6 @@ package compiler
 
 import (
 	"encoding/base64"
-	"strings"
 
 	"github.com/microsoft/typescript-go/internal/ast"
 	"github.com/microsoft/typescript-go/internal/core"
@@ -305,10 +304,7 @@ func sourceFileMayBeEmitted(sourceFile *ast.SourceFile, host printer.EmitHost, f
 		return false
 	}
 
-	// !!! Source file from node_modules are not emitted. In Strada, this depends on module resolution and uses
-	// `sourceFilesFoundSearchingNodeModules` in `createProgram`. For now, we will just check for `/node_modules/` in
-	// the file name.
-	if strings.Contains(sourceFile.FileName(), "/node_modules/") {
+	if host.IsSourceFileFromExternalLibrary(sourceFile) {
 		return false
 	}
+12 −12		src/compiler/types.ts
+21 −21		tests/baselines/reference/api/typescript.d.ts
+1 −1		tests/baselines/reference/conditionalTypes2.types
+6 −6		tests/baselines/reference/correlatedUnions.types
+1 −1		tests/baselines/reference/generatorYieldContextualType.types
+2 −2		tests/baselines/reference/inOperatorWithValidOperands.errors.txt
+2 −2		tests/baselines/reference/inOperatorWithValidOperands.types
+3 −3		tests/baselines/reference/nonPrimitiveAndTypeVariables.errors.txt
+1 −1		tests/baselines/reference/nonPrimitiveAndTypeVariables.types
+2 −2		tests/baselines/reference/objectLiteralExcessProperties.types
+2 −2		tests/baselines/reference/spreadObjectOrFalsy.types
+3 −3		tests/baselines/reference/templateLiteralTypes3.types
+2 −2		tests/baselines/reference/typeGuardConstructorClassAndNumber.types
+4 −4		tests/baselines/reference/unionOfFunctionAndSignatureIsCallable.types
+2 −2		tests/baselines/reference/vueLikeDataAndPropsInference2.types