Question 1

How to fix tsgo LSP server panic 'assignment to entry in nil map' on shutdown?

Accepted Answer

This is a shutdown race in the native TypeScript compiler (tsgo / typescript-go, typescript@7.0.2). When the LSP client does not advertise dynamic file-watch registration, the server's internal watcher (`internal/lsp/lspwatcher`) releases its mutex while installing a watch subscription; a concurrent `Close` sets `w.watches = nil`, and the post-install append then panics with `assignment to entry in nil map`, causing `tsgo --lsp --stdio` to exit with status 2. Fix: upgrade to a build of `@typescript/native-preview` (tsgo) that includes PR microsoft/typescript-go#4845, which rechecks the `closed` flag under the lock before publishing the subscription and returns the `lspwatcher: closed` error instead of panicking. Workaround if pinned to an affected build: enable dynamic file-watch registration in your LSP client (`workspace.didChangeWatchedFiles.dynamicRegistration: true`) so the server skips its internal watcher path.

Question 2

How to fix a non-exported recursive type alias being inlined and becoming `any` in TypeScript declaration files?

Accepted Answer

This happens with `declaration: true` when an exported value uses a non-exported recursive type. The declaration emitter cannot reference the private type name, so it inlines the recursion until it reaches its depth limit and substitutes `any`. Fix it by exporting the recursive type alias from the module that declares it: ```ts // utils.ts export type Recursive = T extends Array ? Recursive : T; export const f = (): Recursive => null!; ``` Then rebuild with `npx tsc -p tsconfig.json`. The generated `.d.ts` can now reference `Recursive` instead of unrolling it. If the type must remain private, remove it from the exported API or give the exported declaration an explicit public return type. A compiler fix was also made in typescript-go PR #4507 to report a declaration error instead of silently producing `any`.

Question 3

How to fix TypeScript CommonJS output adding `exports.x` inside a function loop when a local variable shadows an export?

Accepted Answer

This is a regression in the tsgo CommonJS transformer: a block-scoped loop variable whose name matches an exported name incorrectly receives an `exports.name = name` assignment. It is reproduced in tsgo 7.0/dev builds, while TypeScript 6.0.3 emits the correct code.

Workarounds:

1. Rename the loop-local variable so it does not shadow the export:
```ts
export function f(xs: number[]) {
  for (const x of xs) {
    const localMount = x;
    console.log(localMount);
  }
}
function mount() {}
export { mount };
```

2. Use the stable JavaScript-based compiler instead of the affected tsgo build:
```bash
npm install -D typescript@6.0.3
npx tsc
```

3. If building tsgo locally, patch `internal/transformers/moduletransforms/commonjsmodule.go`. For non-top-level loops, visit the loop body with the regular visitor instead of `topLevelNestedVisitor`:
```diff
- tx.EmitContext().VisitIterationBody(node.Statement, tx.topLevelNestedVisitor)
+ tx.EmitContext().VisitIterationBody(node.Statement, tx.Visitor())
```
Apply the equivalent change in `visitForInOrOfStatement`; top-level loops must continue using the top-level nested visitor. A fix is tracked in the associated pull request.

Question 4

Why does tsc --incremental miss errors after changing a 'declare global' type in a node_modules .d.ts file?

Accepted Answer

This is a known regression in TypeScript 7.0.x (also in 5.6.1-rc; worked in 6.0.3): incremental builds keep stale diagnostics when a `declare global` block in a package's declaration file (loaded via `types`, not imported) changes, so the incremental run reports no errors while a clean `tsc` run reports them (e.g. TS2345). Fix: upgrade to TypeScript 7.1 or newer (confirmed fixed in 7.1 nightly). Workaround on affected versions: delete the `.tsbuildinfo` file before each run (e.g. `rm tsconfig.tsbuildinfo`) or run `tsc --noEmit` without `--incremental` to force a full recheck.

Question 5

Why does TypeScript accept `import defer "./a.js"` and emit it as a normal eager import?

Accepted Answer

A bare `import defer "./a.js"` is invalid: the deferred import proposal requires a namespace binding. TypeScript incorrectly accepts it and drops `defer`, producing `import "./a.js"`, which evaluates the module eagerly.

Use a namespace import for deferred evaluation:

```ts
import defer * as ns from "./a.js";
```

If you intentionally want a side-effect-only import, use a regular eager import instead:

```ts
import "./a.js";
```

Affected versions include TypeScript 5.9.3 and 7.1.0-dev.20261004.1.

TypeScript

Core Features

What It Can't Do

Use Cases

Tags

Getting Started

Similar Projects