@scriptc/compiler 0.0.35 → 0.1.1

package/dist/frontend/lowering/lower-namespaces.js

@@ -39,12 +39,12 @@
 import * as ts from "../ts7/adapter.js";
 import { boundIdentifiersOf } from "./lowerer.js";
 import { locOf, resolveImport } from "../program.js";
-import { F64, STRING } from "../../ir/nodes.js";
+import { F64, STRING } from "../../ir/ir.js";
 /** True when this module declaration produces NO runtime construct at all:
  * ambient (`declare namespace/module`, `declare global`, string-named
  * modules — .d.ts surface or user-file declares) or a non-instantiated
  * body (only type-world statements inside). */
-export function nsZeroRuntime(decl) {
+function nsZeroRuntime(decl) {
     if (isAmbientModuleDecl(decl))
         return true;
     if (!ts.isIdentifier(decl.name))
@@ -53,7 +53,7 @@ export function nsZeroRuntime(decl) {
 }
 /** Ambient module declaration: carries `declare` itself, sits in an
  * ambient ancestor, or is the `declare global` augmentation. */
-export function isAmbientModuleDecl(decl) {
+function isAmbientModuleDecl(decl) {
     if (decl.flags & ts.NodeFlags.Ambient)
         return true;
     for (let p = decl; p !== undefined && !ts.isSourceFile(p); p = p.parent) {
@@ -89,19 +89,19 @@ function nsTypeOnlyBody(decl) {
  * declaration's block flattened (the object exists once a block ran;
  * merged ambient declarations don't subtract), "typeOnly"/"ambient" when
  * none did. Null for non-namespace symbols. */
-export function nsSymbolRuntimeKind(L, sym) {
+function nsSymbolRuntimeKind(lowerer, sym) {
     if (!(sym.flags & (ts.SymbolFlags.ValueModule | ts.SymbolFlags.NamespaceModule)))
         return null;
     let sawTypeOnly = false;
     let sawNamespace = false;
-    for (const d of L.checker.declarationsOf(sym)) {
+    for (const d of lowerer.checker.declarationsOf(sym)) {
         if (!ts.isModuleDeclaration(d))
             continue;
         sawNamespace = true;
         let body = d.body;
         while (body !== undefined && ts.isModuleDeclaration(body))
             body = body.body;
-        const kind = body !== undefined ? L.nsBlocks.get(body) : undefined;
+        const kind = body !== undefined ? lowerer.nsBlocks.get(body) : undefined;
         if (kind === "flattened")
             return "instantiated";
         if (kind === "typeOnly")
@@ -118,10 +118,10 @@ export function nsSymbolRuntimeKind(L, sym) {
  * collection lists, everything else joins the init body in source order.
  * Nested namespaces recurse; dotted declarations (`namespace A.B.C`)
  * descend to the innermost block. */
-export function collectNamespaceStmt(L, decl, fp) {
+export function collectNamespaceStmt(lowerer, decl, fp) {
     if (nsZeroRuntime(decl)) {
         if (!isAmbientModuleDecl(decl))
-            registerTypeOnlyBlocks(L, decl);
+            registerTypeOnlyBlocks(lowerer, decl);
         return;
     }
     let body = decl.body;
@@ -129,7 +129,7 @@ export function collectNamespaceStmt(L, decl, fp) {
         body = body.body;
     if (body === undefined || !ts.isModuleBlock(body))
         return; // bodyless non-ambient: tsc-rejected
-    L.nsBlocks.set(body, "flattened");
+    lowerer.nsBlocks.set(body, "flattened");
     for (const s of body.statements) {
         if (ts.isFunctionDeclaration(s))
             fp.fnDecls.push(s);
@@ -138,7 +138,7 @@ export function collectNamespaceStmt(L, decl, fp) {
         else if (ts.isInterfaceDeclaration(s) || ts.isTypeAliasDeclaration(s))
             continue;
         else if (ts.isModuleDeclaration(s))
-            collectNamespaceStmt(L, s, fp);
+            collectNamespaceStmt(lowerer, s, fp);
         // Everything else — member variables, side-effecting statements,
         // import= aliases (lowerStmt handles them), enums (their own fence) —
         // runs in the init body at its source position.
@@ -146,16 +146,16 @@ export function collectNamespaceStmt(L, decl, fp) {
             fp.topStmts.push(s);
     }
 }
-function registerTypeOnlyBlocks(L, decl) {
+function registerTypeOnlyBlocks(lowerer, decl) {
     let body = decl.body;
     while (body !== undefined && ts.isModuleDeclaration(body))
         body = body.body;
     if (body === undefined || !ts.isModuleBlock(body))
         return;
-    L.nsBlocks.set(body, "typeOnly");
+    lowerer.nsBlocks.set(body, "typeOnly");
     for (const s of body.statements) {
         if (ts.isModuleDeclaration(s))
-            registerTypeOnlyBlocks(L, s);
+            registerTypeOnlyBlocks(lowerer, s);
     }
 }
 /** The namespace-path prefix of a declaration's emitted name ("A%B." for
@@ -193,8 +193,8 @@ export function nsPathPrefix(node, modifierDecl) {
  * non-instantiated one, whose only value members are import= aliases), or
  * null. The walk stops at class/function boundaries: a static member of a
  * class INSIDE a namespace is the class's business, not the namespace's. */
-export function nsBlockKindOfSymbol(L, sym) {
-    for (const d of L.checker.declarationsOf(sym)) {
+function nsBlockKindOfSymbol(lowerer, sym) {
+    for (const d of lowerer.checker.declarationsOf(sym)) {
         // TYPE declarations don't make a member a namespace VALUE: a class
         // static `C.B` whose name also carries `namespace C { export
         // interface B }` is the static's business — value references consult
@@ -208,7 +208,7 @@ export function nsBlockKindOfSymbol(L, sym) {
             continue;
         let blocked = false;
         for (let p = d.parent; p !== undefined && !ts.isSourceFile(p); p = p.parent) {
-            const kind = L.nsBlocks.get(p);
+            const kind = lowerer.nsBlocks.get(p);
             if (kind !== undefined) {
                 if (!blocked)
                     return kind;
@@ -231,23 +231,23 @@ export function nsBlockKindOfSymbol(L, sym) {
  * Builtin/stdlib module namespaces (string-named ambient modules in
  * .d.ts files) and npm packages answer null — their own chokepoints and
  * fences keep ownership. */
-export function moduleNsSourceFileOf(L, e) {
+function moduleNsSourceFileOf(lowerer, e) {
     let sym;
     if (ts.isIdentifier(e)) {
-        sym = L.checker.getSymbolAtLocation(e);
+        sym = lowerer.checker.getSymbolAtLocation(e);
     }
     else if (ts.isPropertyAccessExpression(e) &&
         e.questionDotToken === undefined &&
         ts.isIdentifier(e.name)) {
-        sym = L.checker.getSymbolAtLocation(e.name);
+        sym = lowerer.checker.getSymbolAtLocation(e.name);
     }
     if (!sym)
         return null;
     if (sym.flags & ts.SymbolFlags.Alias)
-        sym = L.checker.getAliasedSymbol(sym);
-    for (const d of L.checker.declarationsOf(sym)) {
+        sym = lowerer.checker.getAliasedSymbol(sym);
+    for (const d of lowerer.checker.declarationsOf(sym)) {
         if (sym.flags & ts.SymbolFlags.ValueModule &&
-            ts.isSourceFile(d) && !d.isDeclarationFile && L.fileTag.has(d)) {
+            ts.isSourceFile(d) && !d.isDeclarationFile && lowerer.fileTag.has(d)) {
             return d;
         }
         // A symbol MERGED with type-world declarations (`export type Drink =
@@ -260,8 +260,8 @@ export function moduleNsSourceFileOf(L, e) {
             if ((ts.isImportDeclaration(stmt) || ts.isExportDeclaration(stmt)) &&
                 stmt.moduleSpecifier !== undefined &&
                 ts.isStringLiteral(stmt.moduleSpecifier)) {
-                const dep = resolveImport(L.program, d.getSourceFile(), stmt.moduleSpecifier.text);
-                if (dep && !dep.isDeclarationFile && L.fileTag.has(dep))
+                const dep = resolveImport(lowerer.program, d.getSourceFile(), stmt.moduleSpecifier.text);
+                if (dep && !dep.isDeclarationFile && lowerer.fileTag.has(dep))
                     return dep;
             }
         }
@@ -279,17 +279,17 @@ export function moduleNsSourceFileOf(L, e) {
  * reads are LIVE bindings in Node (the namespace object's properties
  * alias the exporter's storage), which is exactly what resolving to the
  * exporter's module global gives. */
-export function nsMemberIdentOf(L, access) {
+export function nsMemberIdentOf(lowerer, access) {
     if (access.questionDotToken !== undefined)
         return null;
     if (!ts.isIdentifier(access.name))
         return null;
-    const memberSym = L.checker.getSymbolAtLocation(access.name);
+    const memberSym = lowerer.checker.getSymbolAtLocation(access.name);
     if (!memberSym)
         return null;
-    if (nsBlockKindOfSymbol(L, memberSym) !== null)
+    if (nsBlockKindOfSymbol(lowerer, memberSym) !== null)
         return access.name;
-    if (moduleNsSourceFileOf(L, access.expression) !== null)
+    if (moduleNsSourceFileOf(lowerer, access.expression) !== null)
         return access.name;
     return null;
 }
@@ -298,21 +298,21 @@ export function nsMemberIdentOf(L, access) {
  * ModuleDeclaration outside the stdlib/@types surface), or null. Reads
  * through it compile to Node's ReferenceError naming the root — the
  * ambient namespace object never exists at runtime. */
-export function ambientNsRootOf(L, e) {
+export function ambientNsRootOf(lowerer, e) {
     let root = e;
     while (ts.isPropertyAccessExpression(root) && root.questionDotToken === undefined) {
         root = root.expression;
     }
     if (!ts.isIdentifier(root))
         return null;
-    let sym = L.checker.getSymbolAtLocation(root);
+    let sym = lowerer.checker.getSymbolAtLocation(root);
     if (sym && sym.flags & ts.SymbolFlags.Alias)
-        sym = L.checker.getAliasedSymbol(sym);
+        sym = lowerer.checker.getAliasedSymbol(sym);
     if (!sym || !(sym.flags & (ts.SymbolFlags.ValueModule | ts.SymbolFlags.NamespaceModule)))
         return null;
-    if (L.isStdlibSymbol(sym))
+    if (lowerer.isStdlibSymbol(sym))
         return null;
-    const decls = L.checker.declarationsOf(sym);
+    const decls = lowerer.checker.declarationsOf(sym);
     if (decls.length === 0)
         return null;
     for (const d of decls) {
@@ -344,7 +344,7 @@ export function ambientNsRootOf(L, e) {
  *     defined";
  *   - an ambient `declare function` nothing defines (the same erasure,
  *     ambientUndefinedFnSymbolOf);
- *   - a TRAP BINDING (L.trapBindings) — a binding whose own initializer
+ *   - a TRAP BINDING (lowerer.trapBindings) — a binding whose own initializer
  *     provably threw before producing a value, so module init unwound and
  *     no reference to it can ever execute (any lowering is sound there;
  *     the trap keeps the shape honest if reachability analysis is wrong).
@@ -354,11 +354,14 @@ export function ambientNsRootOf(L, e) {
  * null/undefined AFTER a successful read; it cannot guard the root's own
  * ReferenceError), calls and `new` (the callee evaluates before any
  * argument), instantiation expressions, and tagged templates (the tag
- * evaluates first). Callers lower the WHOLE expression to the root's
- * throw, typed by the use site — and never lower the arguments, exactly
- * the order Node dies in. Null for stdlib/@types roots (their own
+ * evaluates first). A manifest-validated direct FFI call is the narrow
+ * exception: its ambient declaration supplies a native implementation, so
+ * the call itself is not an undefined-root read and outer transparent chains
+ * retain that native result. Callers lower every other whole expression to
+ * the root's throw, typed by the use site — and never lower the arguments,
+ * exactly the order Node dies in. Null for stdlib/@types roots (their own
  * chokepoints stand) and anything declared with a value. */
-export function ambientUndefVarRootOf(L, e) {
+export function ambientUndefVarRootOf(lowerer, e) {
     let root = e;
     for (;;) {
         if (ts.isParenthesizedExpression(root) ||
@@ -374,6 +377,11 @@ export function ambientUndefVarRootOf(L, e) {
             continue;
         }
         if (ts.isCallExpression(root) || ts.isNewExpression(root)) {
+            // A configured native binding owns this exact call node. Do not walk
+            // into its signature-only declaration: the call produces a native
+            // result, and normal call lowering must retain its ffiCall IR.
+            if (ts.isCallExpression(root) && lowerer.ownsFfiCall(root))
+                return null;
             root = root.expression;
             continue;
         }
@@ -399,19 +407,19 @@ export function ambientUndefVarRootOf(L, e) {
     // PoisonError out of collection entirely. The collect-phase guard
     // suppresses both; the ordinary lowering that follows a null answer
     // re-resolves with full effects at its own site.
-    const wasCollecting = L.collecting;
-    L.collecting = true;
+    const wasCollecting = lowerer.collecting;
+    lowerer.collecting = true;
     try {
-        const sym = L.resolveValueSymbol(root);
+        const sym = lowerer.resolveValueSymbol(root);
         if (!sym)
             return null;
-        if (L.trapBindings.has(sym))
+        if (lowerer.trapBindings.has(sym))
             return root;
-        if (L.isStdlibSymbol(sym))
+        if (lowerer.isStdlibSymbol(sym))
             return null;
-        if (ambientUndefinedFnSymbolOf(L, root) !== null)
+        if (ambientUndefinedFnSymbolOf(lowerer, root) !== null)
             return root;
-        const decls = L.checker.declarationsOf(sym);
+        const decls = lowerer.checker.declarationsOf(sym);
         if (decls.length === 0)
             return null;
         for (const d of decls) {
@@ -425,7 +433,7 @@ export function ambientUndefVarRootOf(L, e) {
         return root;
     }
     finally {
-        L.collecting = wasCollecting;
+        lowerer.collecting = wasCollecting;
     }
 }
 /** The declaration-classification form of ambientUndefVarRootOf: the root
@@ -451,16 +459,16 @@ export function ambientUndefVarRootOf(L, e) {
  * skips the write forms the no-storage lowering already compiles (a
  * statement-position `x = <ambient-rooted chain>` IS the RHS root's
  * throw — lowerExprStatement never touches the target's storage). */
-export function trapDeclRootOf(L, decl) {
+export function trapDeclRootOf(lowerer, decl) {
     if (decl.initializer === undefined)
         return null;
-    const root = ambientUndefVarRootOf(L, decl.initializer);
+    const root = ambientUndefVarRootOf(lowerer, decl.initializer);
     if (root === null)
         return null;
     for (const nameNode of boundIdentifiersOf(decl.name)) {
-        const sym = L.checker.getSymbolAtLocation(nameNode);
-        if (sym && bindingEverWritten(L, sym, decl.getSourceFile())) {
-            const mapped = L.mapTypeOf(L.checker.getTypeOfSymbol(sym));
+        const sym = lowerer.checker.getSymbolAtLocation(nameNode);
+        if (sym && bindingEverWritten(lowerer, sym, decl.getSourceFile())) {
+            const mapped = lowerer.mapTypeOf(lowerer.checker.getTypeOfSymbol(sym));
             if (mapped !== null && mapped.kind !== "void")
                 return null;
         }
@@ -483,9 +491,9 @@ export function trapDeclRootOf(L, decl) {
  * taggedTemplatesWithTypeArguments1 shape, where the decline pushed the
  * initializer into an ordinary lowering that fences). ambientUndefVarRootOf
  * carries its own collect-guard, so the extra question stays a probe. */
-function bindingEverWritten(L, sym, sf) {
+function bindingEverWritten(lowerer, sym, sf) {
     const symText = sym.name;
-    const namesSym = (e) => ts.isIdentifier(e) && e.text === symText && L.checker.getSymbolAtLocation(e) === sym;
+    const namesSym = (e) => ts.isIdentifier(e) && e.text === symText && lowerer.checker.getSymbolAtLocation(e) === sym;
     const patternWrites = (target) => {
         if (namesSym(target))
             return true;
@@ -519,7 +527,7 @@ function bindingEverWritten(L, sym, sf) {
                         p = p.parent;
                     if (!ts.isExpressionStatement(p))
                         return false;
-                    return ambientUndefVarRootOf(L, n.right) !== null;
+                    return ambientUndefVarRootOf(lowerer, n.right) !== null;
                 };
                 if (namesSym(lhs)) {
                     if (!throwsBeforeTheWrite())
@@ -556,10 +564,10 @@ function bindingEverWritten(L, sym, sf) {
  * type has no mapping (an `any`-typed member off a narrowed ambient), the
  * type the value flows INTO types the throw instead — sound because the
  * read never returns, so the typed dummy is never observed. */
-export function contextualUndefReadType(L, node) {
-    const ctx = L.checker.getContextualType(node);
-    const mapped = ctx ? L.mapTypeOf(ctx) : null;
-    if (mapped && mapped.kind !== "void" && !L.typeNamesUnregisteredClass(mapped))
+export function contextualUndefReadType(lowerer, node) {
+    const ctx = lowerer.checker.getContextualType(node);
+    const mapped = ctx ? lowerer.mapTypeOf(ctx) : null;
+    if (mapped && mapped.kind !== "void" && !lowerer.typeNamesUnregisteredClass(mapped))
         return mapped;
     return null;
 }
@@ -569,12 +577,12 @@ export function contextualUndefReadType(L, node) {
  * reads conformance tests are full of), null otherwise (the callers fall
  * through to their ordinary fences). The read always throws, so the typed
  * dummy is never observed. */
-export function ambientUndefReadType(L, node) {
-    const declared = L.mapTypeOf(L.typeOf(node));
+export function ambientUndefReadType(lowerer, node) {
+    const declared = lowerer.mapTypeOf(lowerer.typeOf(node));
     // A type naming an UNREGISTERED class (an ambient class's instance —
     // nothing collected a shape) would make the emitter name a struct that
     // does not exist; the F64 dummy serves discarded positions instead.
-    if (declared && declared.kind !== "void" && !L.typeNamesUnregisteredClass(declared)) {
+    if (declared && declared.kind !== "void" && !lowerer.typeNamesUnregisteredClass(declared)) {
         return declared;
     }
     const p = node.parent;
@@ -592,14 +600,14 @@ export function ambientUndefReadType(L, node) {
  * stance. Null for stdlib/@types surfaces (their own chokepoints stand),
  * for overload signatures (an implementation exists), and for anything
  * declared in a .d.ts. */
-export function ambientUndefinedFnSymbolOf(L, ident) {
-    const sym = L.resolveValueSymbol(ident);
+export function ambientUndefinedFnSymbolOf(lowerer, ident) {
+    const sym = lowerer.resolveValueSymbol(ident);
     if (!sym || !(sym.flags & ts.SymbolFlags.Function))
         return null;
-    if (L.isStdlibSymbol(sym))
+    if (lowerer.isStdlibSymbol(sym))
         return null;
     let sawFn = false;
-    for (const d of L.checker.declarationsOf(sym)) {
+    for (const d of lowerer.checker.declarationsOf(sym)) {
         if (ts.isInterfaceDeclaration(d) || ts.isTypeAliasDeclaration(d))
             continue; // type-world merge partners
         if (ts.isFunctionDeclaration(d)) {
@@ -620,7 +628,7 @@ export function ambientUndefinedFnSymbolOf(L, ident) {
 /** Node's ReferenceError at an ambient namespace access — the undefRead
  * libCall the ambient `declare const` path already uses, typed by the use
  * site (it always throws; the typed dummy is abandoned by the unwind). */
-export function nsUndefRead(L, rootName, node, type) {
+export function nsUndefRead(lowerer, rootName, node, type) {
     const loc = locOf(node);
     return {
         kind: "libCall",
@@ -644,9 +652,9 @@ function initExecutingPosition(node) {
     }
     return true;
 }
-function earliestSameFileDeclStart(L, sym, sf) {
+function earliestSameFileDeclStart(lowerer, sym, sf) {
     let earliest = Infinity;
-    for (const d of L.checker.declarationsOf(sym)) {
+    for (const d of lowerer.checker.declarationsOf(sym)) {
         if (d.getSourceFile() === sf)
             earliest = Math.min(earliest, d.getStart());
     }
@@ -656,11 +664,11 @@ function earliestSameFileDeclStart(L, sym, sf) {
  * use): the alias statement captures its target's CURRENT value, so an
  * init-position use above the alias — or an alias above its target — would
  * observe what Node leaves uninitialized. Fences instead of diverging. */
-export function fenceEarlyAliasUse(L, ident, refNode) {
-    const sym = L.checker.getSymbolAtLocation(ident);
+export function fenceEarlyAliasUse(lowerer, ident, refNode) {
+    const sym = lowerer.checker.getSymbolAtLocation(ident);
     if (!sym || !(sym.flags & ts.SymbolFlags.Alias))
         return;
-    const aliasDecl = L.checker.declarationsOf(sym).find(ts.isImportEqualsDeclaration);
+    const aliasDecl = lowerer.checker.declarationsOf(sym).find(ts.isImportEqualsDeclaration);
     if (!aliasDecl || ts.isExternalModuleReference(aliasDecl.moduleReference))
         return;
     if (!initExecutingPosition(refNode))
@@ -670,15 +678,15 @@ export function fenceEarlyAliasUse(L, ident, refNode) {
         return; // cross-file: module init order applies
     const aliasStart = aliasDecl.getStart();
     if (refNode.getStart() < aliasStart) {
-        L.unsupported("SC1090", refNode, `reading '${ident.text}' above its \`import ${ident.text} = ...\` alias (Node binds the alias at its statement — this read would observe an uninitialized binding; move it below the alias)`);
+        lowerer.unsupported("SC1090", refNode, `reading '${ident.text}' above its \`import ${ident.text} = ...\` alias (Node binds the alias at its statement — this read would observe an uninitialized binding; move it below the alias)`);
     }
     // The alias itself must run AFTER its target exists: a namespace target
     // needs a contributing block above the alias, a value target its
     // declaration.
-    const target = L.checker.getAliasedSymbol(sym);
-    const targetStart = earliestSameFileDeclStart(L, target, sf);
+    const target = lowerer.checker.getAliasedSymbol(sym);
+    const targetStart = earliestSameFileDeclStart(lowerer, target, sf);
     if (targetStart !== Infinity && aliasStart < targetStart) {
-        L.unsupported("SC1090", refNode, `the \`import ${ident.text} = ...\` alias above its target's declaration (Node binds the alias at its statement, when the target is still uninitialized; move the alias below the target)`);
+        lowerer.unsupported("SC1090", refNode, `the \`import ${ident.text} = ...\` alias above its target's declaration (Node binds the alias at its statement, when the target is still uninitialized; move the alias below the target)`);
     }
 }
 /** The source-order guard for a qualified namespace-member reference in
@@ -690,25 +698,25 @@ export function fenceEarlyAliasUse(L, ident, refNode) {
  * Function-body references are exempt: they take the module-globals stance
  * the compiler already takes for top-level consts read through early
  * calls. */
-export function fenceEarlyNsMemberRef(L, access, memberSym) {
+export function fenceEarlyNsMemberRef(lowerer, access, memberSym) {
     if (!initExecutingPosition(access))
         return;
     const sf = access.getSourceFile();
     const refStart = access.getStart();
-    const memberStart = earliestSameFileDeclStart(L, memberSym, sf);
+    const memberStart = earliestSameFileDeclStart(lowerer, memberSym, sf);
     if (memberStart !== Infinity && refStart < memberStart) {
-        L.unsupported("SC1090", access, `reading namespace member '${access.name.text}' above its declaration (Node evaluates namespace bodies in source order — this read would observe an uninitialized binding; move it below the declaring block)`);
+        lowerer.unsupported("SC1090", access, `reading namespace member '${access.name.text}' above its declaration (Node evaluates namespace bodies in source order — this read would observe an uninitialized binding; move it below the declaring block)`);
     }
     // Alias segments in the qualifier chain (`C.a.Origin` where `a` is
     // `import a = A`): each captures its target at ITS statement.
     for (let e = access.expression;;) {
         if (ts.isPropertyAccessExpression(e) && ts.isIdentifier(e.name)) {
-            fenceEarlyAliasUse(L, e.name, access);
+            fenceEarlyAliasUse(lowerer, e.name, access);
             e = e.expression;
             continue;
         }
         if (ts.isIdentifier(e))
-            fenceEarlyAliasUse(L, e, access);
+            fenceEarlyAliasUse(lowerer, e, access);
         break;
     }
 }
@@ -726,8 +734,8 @@ export function fenceEarlyNsMemberRef(L, access, memberSym) {
  * machinery carries its own guards. Called from resolveValueSymbol with
  * the PRE-alias symbol; property NAMES (qualified reads — runtime
  * property lookups, always fine) never reach it. */
-export function fenceCrossBlockNsRef(L, ident, symbol) {
-    if (L.nsBlocks.size === 0 || L.collecting)
+export function fenceCrossBlockNsRef(lowerer, ident, symbol) {
+    if (lowerer.nsBlocks.size === 0 || lowerer.collecting)
         return;
     if (symbol.flags & ts.SymbolFlags.Alias)
         return;
@@ -737,12 +745,12 @@ export function fenceCrossBlockNsRef(L, ident, symbol) {
     // The registered blocks enclosing the REFERENCE, innermost first.
     const refBlocks = [];
     for (let q = ident.parent; q !== undefined && !ts.isSourceFile(q); q = q.parent) {
-        if (L.nsBlocks.has(q))
+        if (lowerer.nsBlocks.has(q))
             refBlocks.push(q);
     }
-    for (const d of L.checker.declarationsOf(symbol)) {
+    for (const d of lowerer.checker.declarationsOf(symbol)) {
         for (let q = d.parent; q !== undefined && !ts.isSourceFile(q); q = q.parent) {
-            if (!L.nsBlocks.has(q))
+            if (!lowerer.nsBlocks.has(q))
                 continue;
             // Declared in a registered block: fine when that block encloses the
             // reference too (same block, or an enclosing namespace's block).
@@ -752,7 +760,7 @@ export function fenceCrossBlockNsRef(L, ident, symbol) {
                 const m = q.parent;
                 return m !== undefined && ts.isModuleDeclaration(m) && ts.isIdentifier(m.name) ? m.name.text : "N";
             })();
-            L.unsupported("SC1090", ident, `the bare reference to '${ident.text}' from a different block of the merged namespace (Node's TypeScript transform does not bind exported members across namespace blocks — it throws ReferenceError where tsc's emit would qualify; write ${nsName}.${ident.text})`);
+            lowerer.unsupported("SC1090", ident, `the bare reference to '${ident.text}' from a different block of the merged namespace (Node's TypeScript transform does not bind exported members across namespace blocks — it throws ReferenceError where tsc's emit would qualify; write ${nsName}.${ident.text})`);
         }
     }
 }
@@ -762,17 +770,17 @@ export function fenceCrossBlockNsRef(L, ident, symbol) {
  * to consts/functions/classes through the qualifier). Null when `access`
  * is not a lowered-namespace member at all; a member whose declaration
  * never registered storage takes the blocked-binding cascade. */
-export function nsWritableTarget(L, access) {
-    const nsMember = nsMemberIdentOf(L, access);
+export function nsWritableTarget(lowerer, access) {
+    const nsMember = nsMemberIdentOf(lowerer, access);
     if (!nsMember)
         return null;
-    const memberSym = L.checker.getSymbolAtLocation(nsMember);
+    const memberSym = lowerer.checker.getSymbolAtLocation(nsMember);
     if (memberSym)
-        fenceEarlyNsMemberRef(L, access, memberSym);
-    const resolved = L.resolveValueSymbol(nsMember);
-    const g = resolved ? L.globalsBySymbol.get(resolved) : undefined;
+        fenceEarlyNsMemberRef(lowerer, access, memberSym);
+    const resolved = lowerer.resolveValueSymbol(nsMember);
+    const g = resolved ? lowerer.globalsBySymbol.get(resolved) : undefined;
     if (!g) {
-        L.rejectUnresolved(nsMember, `assignment to namespace member '${nsMember.text}' (not a writable module global)`);
+        lowerer.rejectUnresolved(nsMember, `assignment to namespace member '${nsMember.text}' (not a writable module global)`);
     }
     return { id: g.id, type: g.type };
 }
@@ -786,19 +794,19 @@ export function nsWritableTarget(L, access) {
  * collection registered the alias its own const global (keyed by the
  * pre-alias symbol — resolveValueSymbol stops there) and this statement
  * assigns it from the target's storage, exactly when Node does. */
-export function lowerImportEquals(L, stmt) {
+export function lowerImportEquals(lowerer, stmt) {
     if (stmt.isTypeOnly)
         return null;
     if (ts.isExternalModuleReference(stmt.moduleReference)) {
-        L.unsupported("SC1013", stmt, "import = require(...) assignments");
+        lowerer.unsupported("SC1013", stmt, "import = require(...) assignments");
     }
     // A BARE-identifier entity target (`import g = f` inside a block):
     // Node emits `var g = f` — the same cross-block bare-reference hole as
     // any other bare use; the shared fence applies at the alias statement.
     if (ts.isIdentifier(stmt.moduleReference)) {
-        const refSym = L.checker.getSymbolAtLocation(stmt.moduleReference);
+        const refSym = lowerer.checker.getSymbolAtLocation(stmt.moduleReference);
         if (refSym)
-            fenceCrossBlockNsRef(L, stmt.moduleReference, refSym);
+            fenceCrossBlockNsRef(lowerer, stmt.moduleReference, refSym);
     }
     // Node's transform ALWAYS emits `var x = <entity>` — it never elides
     // type-only aliases the way tsc's emit does — so an alias whose entity
@@ -811,32 +819,32 @@ export function lowerImportEquals(L, stmt) {
         while (ts.isQualifiedName(root))
             root = root.left;
         if (ts.isIdentifier(root)) {
-            let rootSym = L.checker.getSymbolAtLocation(root);
+            let rootSym = lowerer.checker.getSymbolAtLocation(root);
             if (rootSym && rootSym.flags & ts.SymbolFlags.Alias) {
-                rootSym = L.checker.getAliasedSymbol(rootSym);
+                rootSym = lowerer.checker.getAliasedSymbol(rootSym);
             }
-            const kind = rootSym ? nsSymbolRuntimeKind(L, rootSym) : null;
+            const kind = rootSym ? nsSymbolRuntimeKind(lowerer, rootSym) : null;
             if (kind === "typeOnly" || kind === "ambient") {
                 const loc = locOf(stmt);
                 return {
                     kind: "exprStmt",
-                    expr: nsUndefRead(L, root.text, stmt, F64),
+                    expr: nsUndefRead(lowerer, root.text, stmt, F64),
                     loc,
                 };
             }
         }
     }
-    const nameSym = L.checker.getSymbolAtLocation(stmt.name);
-    const aliasG = nameSym ? L.globalsBySymbol.get(nameSym) : undefined;
+    const nameSym = lowerer.checker.getSymbolAtLocation(stmt.name);
+    const aliasG = nameSym ? lowerer.globalsBySymbol.get(nameSym) : undefined;
     if (nameSym && aliasG) {
         // The snapshot assignment. The target is a mutable binding with its
         // own module global (a namespace `export var` member, a top-level
         // var reached through an alias chain); a target whose declaration
         // never registered storage takes the blocked-binding cascade.
-        const target = L.checker.getAliasedSymbol(nameSym);
-        const targetG = L.globalsBySymbol.get(target);
+        const target = lowerer.checker.getAliasedSymbol(nameSym);
+        const targetG = lowerer.globalsBySymbol.get(target);
         if (!targetG) {
-            L.rejectUnresolvedSymbol(target, stmt.name.text, stmt.name, `the alias target of '${stmt.name.text}' (no lowered storage)`);
+            lowerer.rejectUnresolvedSymbol(target, stmt.name.text, stmt.name, `the alias target of '${stmt.name.text}' (no lowered storage)`);
         }
         const loc = locOf(stmt);
         return {
@@ -854,30 +862,30 @@ export function lowerImportEquals(L, stmt) {
  * ReferenceError instead when the use site's type maps (the object never
  * exists at runtime). Returns null when `ident` is not a namespace
  * reference at all. */
-export function lowerNsIdentifierValue(L, ident) {
-    const sym = L.resolveValueSymbol(ident);
+export function lowerNsIdentifierValue(lowerer, ident) {
+    const sym = lowerer.resolveValueSymbol(ident);
     if (!sym || !(sym.flags & (ts.SymbolFlags.ValueModule | ts.SymbolFlags.NamespaceModule))) {
         return null;
     }
     if (sym.flags & (ts.SymbolFlags.Class | ts.SymbolFlags.Function | ts.SymbolFlags.RegularEnum | ts.SymbolFlags.ConstEnum | ts.SymbolFlags.Variable)) {
         return null; // merged with a value declaration — its own paths and fences apply
     }
-    const ambientRoot = ambientNsRootOf(L, ident);
+    const ambientRoot = ambientNsRootOf(lowerer, ident);
     if (ambientRoot !== null) {
-        const t = ambientUndefReadType(L, ident);
+        const t = ambientUndefReadType(lowerer, ident);
         if (t)
-            return nsUndefRead(L, ambientRoot.text, ident, t);
+            return nsUndefRead(lowerer, ambientRoot.text, ident, t);
     }
-    if (L.isStdlibSymbol(sym))
+    if (lowerer.isStdlibSymbol(sym))
         return null; // stdlib namespaces keep their chokepoints
     // A MODULE namespace object as a first-class value (`import * as ns`
     // passed/stored/iterated): member accesses resolve statically, but the
     // object itself has no runtime representation — Node's frozen,
     // alphabetically-keyed namespace object is not materialized. Named
     // residual of the SC1013 lowering.
-    if (moduleNsSourceFileOf(L, ident) !== null) {
-        L.unsupported("SC1013", ident, `module namespace objects as first-class values (access '${ident.text}' members directly: ${ident.text}.<member>)`);
+    if (moduleNsSourceFileOf(lowerer, ident) !== null) {
+        lowerer.unsupported("SC1013", ident, `module namespace objects as first-class values (access '${ident.text}' members directly: ${ident.text}.<member>)`);
     }
-    L.unsupported("SC1090", ident, `namespace objects as first-class values (access '${ident.text}' members directly: ${ident.text}.<member>)`);
+    lowerer.unsupported("SC1090", ident, `namespace objects as first-class values (access '${ident.text}' members directly: ${ident.text}.<member>)`);
 }
 //# sourceMappingURL=lower-namespaces.js.map