ttsc 0.19.2 → 0.20.0

package/tools/shim_audit/baseline.json

@@ -38,7 +38,6 @@
     "ESCAPE|checker|UnionType",
     "ESCAPE|checker|UniqueESSymbolType",
     "ESCAPE|checker|VerbosityContext",
-    "ESCAPE|core|ECMALineStarts",
     "ESCAPE|core|LimitedSemaphore",
     "ESCAPE|core|ModuleDetectionKind",
     "ESCAPE|core|ModuleResolutionKind",
@@ -190,7 +189,6 @@
     "FUNC|ast|IsAutoAccessorPropertyDeclaration",
     "FUNC|ast|IsAwaitExpression",
     "FUNC|ast|IsBigIntLiteral",
-    "FUNC|ast|IsBinaryExpression",
     "FUNC|ast|IsBinaryOperator",
     "FUNC|ast|IsBindableObjectDefinePropertyCall",
     "FUNC|ast|IsBindableStaticAccessExpression",
@@ -646,7 +644,6 @@
     "FUNC|ast|WalkUpBindingElementsAndPatterns",
     "FUNC|checker|CompareTypes",
     "FUNC|checker|FormatTypeFlags",
-    "FUNC|checker|GetDeclarationModifierFlagsFromSymbol",
     "FUNC|checker|GetResolvedSignatureForSignatureHelp",
     "FUNC|checker|GetSingleVariableOfVariableStatement",
     "FUNC|checker|IsExternalModuleSymbol",

package/tools/shim_audit/main.go

@@ -69,8 +69,9 @@ import (
 
 const internalPrefix = "github.com/microsoft/typescript-go/internal/"
 
-// shimDirs maps each shim directory to its upstream internal package suffix.
-// Kept explicit (rather than globbed) so a new shim dir is a conscious add.
+// shimDirs maps each full re-export shim directory to its upstream internal
+// package suffix. Kept explicit (rather than globbed) so a new shim dir is a
+// conscious add.
 var shimDirs = map[string]string{
   "ast":              "ast",
   "bundled":          "bundled",
@@ -90,6 +91,13 @@ var shimDirs = map[string]string{
   "vfs/osvfs":        "vfs/osvfs",
 }
 
+// linknameShimDirs maps deliberately partial go:linkname bridges. They are
+// scanned for their actual references and are covered by the directory gate,
+// but do not claim to re-export every public symbol in the upstream package.
+var linknameShimDirs = map[string]string{
+  "astnav": "astnav",
+}
+
 // auditOnlyInternal lists upstream internal packages that shim sources
 // reference — go:linkname targets and blank imports that compile them into
 // consumer binaries — without owning a shim directory of their own. They are
@@ -202,12 +210,12 @@ var linknameRe = regexp.MustCompile(`(?m)^//go:linkname\s+\S+\s+` +
 func scanShimReachable(shimRoot string) (reachable, error) {
   r := reachable{}
   fset := token.NewFileSet()
-  for dir := range shimDirs {
+  scanDir := func(dir string) error {
     paths, _ := filepath.Glob(filepath.Join(shimRoot, dir, "*.go"))
     for _, p := range paths {
       src, err := os.ReadFile(p)
       if err != nil {
-        return nil, err
+        return err
       }
       // linkname directives live in comments, so scan raw text too.
       for _, m := range linknameRe.FindAllStringSubmatch(string(src), -1) {
@@ -215,7 +223,7 @@ func scanShimReachable(shimRoot string) (reachable, error) {
       }
       f, err := parser.ParseFile(fset, p, src, parser.SkipObjectResolution)
       if err != nil {
-        return nil, fmt.Errorf("%s: %w", p, err)
+        return fmt.Errorf("%s: %w", p, err)
       }
       // alias map: local import name -> internal pkg suffix
       alias := map[string]string{}
@@ -246,6 +254,17 @@ func scanShimReachable(shimRoot string) (reachable, error) {
         return true
       })
     }
+    return nil
+  }
+  for dir := range shimDirs {
+    if err := scanDir(dir); err != nil {
+      return nil, err
+    }
+  }
+  for dir := range linknameShimDirs {
+    if err := scanDir(dir); err != nil {
+      return nil, err
+    }
   }
   return r, nil
 }
@@ -489,10 +508,11 @@ func hasShimSource(dir string) bool {
 }
 
 // checkShimDirCoverage fails if any sub-directory of the shim root (at ANY
-// depth) that contains non-test Go source is not registered in shimDirs. This
-// keeps the audit's package list honest: a newly-added shim — including a
-// NESTED package like vfs/osvfs that a non-recursive, immediate-children scan
-// would miss — cannot escape the gate by omission.
+// depth) that contains non-test Go source is not registered as either a full
+// re-export or an intentionally partial go:linkname bridge. This keeps the
+// audit's package list honest: a newly-added shim — including a NESTED package
+// like vfs/osvfs that a non-recursive, immediate-children scan would miss —
+// cannot escape the gate by omission.
 func checkShimDirCoverage(shimRoot string) error {
   var unmapped []string
   var walk func(dir, rel string) error
@@ -509,7 +529,7 @@ func checkShimDirCoverage(shimRoot string) error {
       if rel != "" {
         childRel = rel + "/" + e.Name()
       }
-      if _, ok := shimDirs[childRel]; !ok && hasShimSource(filepath.Join(dir, e.Name())) {
+      if !isRegisteredShimDir(childRel) && hasShimSource(filepath.Join(dir, e.Name())) {
         unmapped = append(unmapped, childRel)
       }
       if err := walk(filepath.Join(dir, e.Name()), childRel); err != nil {
@@ -523,12 +543,20 @@ func checkShimDirCoverage(shimRoot string) error {
   }
   if len(unmapped) > 0 {
     sort.Strings(unmapped)
-    return fmt.Errorf("shim dir(s) not registered in shimDirs (would escape the audit): %s\n"+
-      "  add them to shimDirs in tools/shim_audit/main.go", strings.Join(unmapped, ", "))
+    return fmt.Errorf("shim dir(s) not registered for audit coverage: %s\n"+
+      "  add a full re-export to shimDirs or a deliberate bridge to linknameShimDirs in tools/shim_audit/main.go", strings.Join(unmapped, ", "))
   }
   return nil
 }
 
+func isRegisteredShimDir(dir string) bool {
+  if _, ok := shimDirs[dir]; ok {
+    return true
+  }
+  _, ok := linknameShimDirs[dir]
+  return ok
+}
+
 // loadInner loads the upstream internal packages via go/types, anchored in a
 // shim module that requires typescript-go (same trick gen_shims uses).
 func loadInner(anchorDir string) (map[string]*packages.Package, error) {
@@ -784,8 +812,8 @@ func main() {
   shimRoot := flag.String("shim", "./shim", "shim root directory")
   flag.Parse()
 
-  // A shim directory that is not registered in shimDirs would silently escape
-  // every check — close that hole before doing anything else.
+  // A shim directory that is not registered for audit coverage would silently
+  // escape every check — close that hole before doing anything else.
   if err := checkShimDirCoverage(*shimRoot); err != nil {
     fmt.Fprintln(os.Stderr, "shim_audit:", err)
     os.Exit(2)

package/tools/shim_audit/shim_dir_coverage_test.go

@@ -0,0 +1,25 @@
+package main
+
+import "testing"
+
+// TestCheckShimDirCoverageIncludesAstnav keeps astnav's partial linkname bridge
+// inside the audit's explicit coverage model without claiming a full re-export.
+//
+//  1. Assert astnav is deliberately classified as a partial bridge.
+//  2. Scan the repository shim root with the same coverage gate as the CLI.
+//  3. Confirm its one linkname target remains visible to reachability scanning.
+func TestCheckShimDirCoverageIncludesAstnav(t *testing.T) {
+  if got := linknameShimDirs["astnav"]; got != "astnav" {
+    t.Fatalf("linknameShimDirs[astnav] = %q, want astnav", got)
+  }
+  if err := checkShimDirCoverage("../../shim"); err != nil {
+    t.Fatal(err)
+  }
+  reachable, err := scanShimReachable("../../shim")
+  if err != nil {
+    t.Fatal(err)
+  }
+  if !reachable.has("astnav", "GetTouchingToken") {
+    t.Fatal("astnav.GetTouchingToken is not reachable")
+  }
+}

package/utility/flags_gen.go

@@ -17,13 +17,13 @@ var HostFlagAllowList = map[string]bool{
   "cwd":            true,
   "emit":           false,
   "manifest":       true,
-  "noEmit":         false,
-  "outDir":         true,
+  "noemit":         false,
+  "outdir":         true,
   "p":              true,
   "plugins-json":   true,
   "project":        true,
   "quiet":          false,
-  "singleThreaded": false,
+  "singlethreaded": false,
   "tsconfig":       true,
   "tsgo-args":      true,
   "verbose":        false,

package/utility/host.go

@@ -264,12 +264,18 @@ func filterHostArgs(args []string) []string {
   return filtered
 }
 
-// flagName strips the leading "--" from a flag argument and reports whether
-// the flag carries an inline value (i.e. the argument contains "=").
+// flagName strips the leading "--" from a flag argument, lower-cases the
+// result, and reports whether the flag carries an inline value (i.e. the
+// argument contains "=").
+//
+// Lower-casing is the same normalization `normalizeFlagToken` in
+// packages/ttsc/src/flags/schema.ts applies, and the generated
+// HostFlagAllowList keys are produced by it, so this layer recognises exactly
+// the spellings the launcher and the compiler do.
 func flagName(arg string) (string, bool) {
   name := strings.TrimPrefix(arg, "--")
   before, _, found := strings.Cut(name, "=")
-  return before, found
+  return strings.ToLower(before), found
 }
 
 // loadUtilityProgram parses plugins JSON, sets the linked-plugin environment