@geastack/compiler 1.0.15

package/dist/semantics/alias-this-field-declaration-transform.js

@@ -0,0 +1,207 @@
+import ts from 'typescript';
+/**
+ * `this.field = expr`, written through a captured lexical alias rather than
+ * `this` itself: `const scope = this; ... function later() { scope.field =
+ * expr; } ...` -- a plain, generic JS idiom for reaching the enclosing
+ * instance from inside a nested (non-arrow) helper, where a bare `this`
+ * would rebind to something else. `WebGLRenderer`'s own constructor is built
+ * out of it (`const _this = this;`, then a dozen nested `function
+ * initGLContext() { ... _this.info = info; ... }`-shaped helpers).
+ *
+ * TypeScript's own JS-class member inference (the mechanism
+ * `field-bindings.ts`'s header describes at length) reads a class's implicit
+ * members from `this.field = expr` assignments, but only ones it can trace
+ * to the constructor's own `this` binding directly -- it does not follow a
+ * variable that merely happens to alias `this`, even though the alias is a
+ * perfectly ordinary closure capture and refers to the exact same object at
+ * every one of its uses, arbitrarily nested. The result: `checker.
+ * getSymbolAtLocation` returns nothing at ALL for `scope.field`, and nothing
+ * for `this.field` at any of the class's own read sites either -- there is
+ * no symbol for `field-bindings.ts` (or anything else) to hang a type on, so
+ * every read boxes.
+ *
+ * ## The fix, and why it is a source transform
+ *
+ * Once a field is given an ordinary bare declaration (`field;`, no
+ * annotation -- `field-bindings.ts`'s own "second shape"), TypeScript's
+ * property lookup resolves `scope.field`, `this.field`, and every alias in
+ * between to that ONE declaration's symbol, regardless of nesting -- lookup
+ * through a value of a known type has none of implicit-member-inference's
+ * traversal limits. So this transform's only job is to make the declaration
+ * exist: find every `alias.field = expr` this idiom produces, for an alias
+ * that provably names nothing but `this`, and inject a bare field for each
+ * name the class does not already declare some other way. `field-bindings.ts`
+ * then types it exactly as it types any other bare field -- from the JOIN of
+ * every write reaching that symbol, direct or aliased alike, since once the
+ * declaration exists the checker treats them identically.
+ *
+ * This has to happen before the checker ever sees the class, which is what
+ * makes it a source transform rather than a census rule: a census can only
+ * ask the checker questions, and the checker has already thrown the fact
+ * away (no symbol at all) by the time any census would run.
+ *
+ * ## What counts as an alias
+ *
+ * A `const alias = this;` (not `let`/`var`: this module trusts nothing it
+ * cannot prove never gets reassigned to something else mid-scope) whose
+ * declaration sits inside one of the class's own members -- constructor or
+ * method. Its scope is exactly what JavaScript gives it: the block it is
+ * declared in, plus everything nested inside, EXCEPT a nested scope that
+ * shadows the same name with its own binding (a parameter, another
+ * `const`/`let`/`var`, a nested function of that name) -- reads/writes past
+ * that point name a different value, and this module does not attempt to
+ * follow which.
+ *
+ * ## What is deliberately left alone
+ *
+ * - A field also written as a DIRECT `this.field = expr` ANYWHERE in the
+ *   class is skipped for alias purposes entirely, even where the alias write
+ *   is a different field -- not because the direct write is wrong, but
+ *   because it may already be a working candidate (top-level in the
+ *   constructor, the one shape TypeScript's own inference already handles),
+ *   and this module has no way to tell "already inferred" from "not" without
+ *   asking the checker, which does not exist yet. Adding a redundant bare
+ *   declaration alongside a real inferred one would mix two declaration
+ *   SHAPES on one symbol and make `field-bindings.ts`'s own candidate test
+ *   refuse it -- a regression this module must never risk. Refusing to act
+ *   on a name is always safe; guessing which of two declarations is the real
+ *   one is not.
+ * - A name already declared some other way (a real property, an accessor, a
+ *   method) is left untouched -- the checker already has an answer, or the
+ *   name is not a data member at all.
+ * - `this` used directly inside a nested PLAIN (non-arrow) function is not
+ *   an alias of anything; that `this` is a different binding by the language
+ *   itself, and this module does not treat it as one. An arrow function needs
+ *   no alias to begin with -- it
+ *   inherits `this` lexically, and TypeScript's own inference already
+ *   follows it there.
+ */
+/** The static string a key names, for `alias.field` or `alias['field']` -- never a computed key. */
+const staticKeyOf = (node) => {
+    if (ts.isPropertyAccessExpression(node))
+        return node.name.text;
+    if (ts.isStringLiteralLike(node.argumentExpression))
+        return node.argumentExpression.text;
+    return null;
+};
+/** Whether `node` is `name.field` / `name['field']` over exactly the identifier `name`, with a static key. */
+const staticAliasFieldNameOf = (node, aliasName) => {
+    if (!ts.isPropertyAccessExpression(node) && !ts.isElementAccessExpression(node))
+        return null;
+    if (!ts.isIdentifier(node.expression) || node.expression.text !== aliasName)
+        return null;
+    return staticKeyOf(node);
+};
+/** Whether `node` binds a name that would shadow `aliasName` inside its own subtree. */
+const shadowsAlias = (node, aliasName) => {
+    if (ts.isParameter(node) || ts.isVariableDeclaration(node) || ts.isBindingElement(node)) {
+        return ts.isIdentifier(node.name) && node.name.text === aliasName;
+    }
+    if (ts.isFunctionDeclaration(node) || ts.isClassDeclaration(node)) {
+        return node.name !== undefined && node.name.text === aliasName;
+    }
+    return false;
+};
+/** Every field name written as `aliasName.field = expr` anywhere under `root`, stopping at a shadowing re-binding. */
+const aliasFieldWritesUnder = (root, aliasName) => {
+    const names = new Set();
+    const walk = (node) => {
+        if (shadowsAlias(node, aliasName))
+            return;
+        // A nested class could rebind `this` for its own members; nothing under it is this alias's scope.
+        if (ts.isClassLike(node) && node !== root)
+            return;
+        if (ts.isBinaryExpression(node) && node.operatorToken.kind === ts.SyntaxKind.EqualsToken) {
+            const name = staticAliasFieldNameOf(node.left, aliasName);
+            if (name !== null)
+                names.add(name);
+        }
+        ts.forEachChild(node, walk);
+    };
+    ts.forEachChild(root, walk);
+    return names;
+};
+/** Every field name written as a DIRECT `this.field = expr` / `this['field'] = expr` anywhere in `klass`, any depth. */
+const directThisFieldWritesIn = (klass) => {
+    const names = new Set();
+    const walk = (node) => {
+        if (ts.isBinaryExpression(node) && node.operatorToken.kind === ts.SyntaxKind.EqualsToken) {
+            const left = node.left;
+            if ((ts.isPropertyAccessExpression(left) || ts.isElementAccessExpression(left)) &&
+                left.expression.kind === ts.SyntaxKind.ThisKeyword) {
+                const name = staticKeyOf(left);
+                if (name !== null)
+                    names.add(name);
+            }
+        }
+        ts.forEachChild(node, walk);
+    };
+    for (const member of klass.members)
+        walk(member);
+    return names;
+};
+/** Every member name `klass` already declares some other way -- a real field, an accessor, a method. */
+const alreadyDeclaredIn = (klass) => {
+    const names = new Set();
+    for (const member of klass.members) {
+        if ((ts.isPropertyDeclaration(member) || ts.isMethodDeclaration(member) || ts.isGetAccessor(member) || ts.isSetAccessor(member)) &&
+            ts.isIdentifier(member.name)) {
+            names.add(member.name.text);
+        }
+    }
+    return names;
+};
+/** Every `const alias = this;` declared inside one of `klass`'s own members, with the alias's own scope root. */
+const thisAliasesIn = (klass) => {
+    const aliases = [];
+    const walk = (node) => {
+        if (ts.isClassLike(node) && node !== klass)
+            return;
+        if (ts.isVariableStatement(node) && (node.declarationList.flags & ts.NodeFlags.Const) !== 0) {
+            for (const declaration of node.declarationList.declarations) {
+                if (ts.isIdentifier(declaration.name) && declaration.initializer?.kind === ts.SyntaxKind.ThisKeyword) {
+                    // Scope = the statement's own containing block/source list, so
+                    // sibling statements after it (and everything nested under them)
+                    // are in scope, exactly as JavaScript's own block scoping gives it.
+                    const scope = node.parent;
+                    aliases.push({ name: declaration.name.text, scope });
+                }
+            }
+        }
+        ts.forEachChild(node, walk);
+    };
+    for (const member of klass.members)
+        walk(member);
+    return aliases;
+};
+export const aliasThisFieldDeclarationTransform = (input) => {
+    const file = ts.createSourceFile(input.fileName, input.text, ts.ScriptTarget.Latest, true, ts.ScriptKind.JS);
+    const edits = [];
+    const visitTopLevel = (node) => {
+        if (ts.isClassDeclaration(node) && node.name) {
+            const already = alreadyDeclaredIn(node);
+            const direct = directThisFieldWritesIn(node);
+            const candidates = new Set();
+            for (const alias of thisAliasesIn(node)) {
+                for (const name of aliasFieldWritesUnder(alias.scope, alias.name)) {
+                    if (already.has(name) || direct.has(name))
+                        continue;
+                    candidates.add(name);
+                }
+            }
+            if (candidates.size > 0) {
+                const fieldTexts = [...candidates].sort().map((name) => `\t${name};\n`);
+                edits.push({ at: node.members.pos, text: fieldTexts.join('') });
+            }
+        }
+        ts.forEachChild(node, visitTopLevel);
+    };
+    visitTopLevel(file);
+    if (edits.length === 0)
+        return null;
+    edits.sort((a, b) => b.at - a.at);
+    let text = input.text;
+    for (const edit of edits)
+        text = text.slice(0, edit.at) + edit.text + text.slice(edit.at);
+    return text;
+};

package/dist/semantics/ambient-type-realization-transform.d.ts

@@ -0,0 +1,62 @@
+/**
+ * A declared type a feature package's own runtime REPLACES with a concrete
+ * type it ships as ordinary source.
+ *
+ * `WebGLRenderer`'s `_gl` parameter is documented, by `@types/three` and by
+ * three's own JSDoc, as an AMBIENT browser interface -- `WebGLRenderingContext`
+ * in one place, the correct `WebGL2RenderingContext` in another -- because
+ * that is the type a browser host would hand it. This build's host is not a
+ * browser: `@geastack/native-webgl-angle` ships `NativeWebGL2RenderingContext`,
+ * an ordinary TypeScript class this compiler already compiles from source, and
+ * every `_gl` this program ever actually holds is one of ITS instances
+ * (`createNativeWebGLCanvas(...).getContext('webgl2')`).
+ *
+ * The ambient interface and the concrete class are structurally unrelated --
+ * `WebGLRenderingContext` is the WebGL 1 surface and lacks
+ * `renderbufferStorageMultisample`/`blitFramebuffer`/`invalidateFramebuffer`
+ * and the WebGL 2 framebuffer constants three's own renderer calls -- so a
+ * member read through the STATED type either does not exist (the checker
+ * answers `any`, and every read of it boxes) or answers a DIFFERENT host's
+ * member than the one that will ever run.
+ *
+ * `type`/`importedFrom` name the concrete replacement and where a value
+ * consumer imports it from, exactly as three's own source already does
+ * (`import { createNativeWebGLCanvas } from '@geastack/native-webgl-angle/nativeWebGL'`)
+ * -- so respelling a stated ambient name to this one is not inventing a fact,
+ * it is stating in the type layer what the program's own value layer already
+ * says.
+ */
+export interface AmbientTypeRealization {
+    /** The concrete type's own name, as its package exports it. */
+    readonly type: string;
+    /** The module specifier a consumer imports `type` from, UNQUOTED. */
+    readonly importedFrom: string;
+}
+/**
+ * Respell JSDoc and TypeScript type references to a host's concrete type.
+ * Value references remain untouched: an interface realization does not imply
+ * that a browser constructor exists on the native host.
+ *
+ * Built from `realizations` -- the union of every installed plugin's own
+ * `PluginCapabilities.ambientTypeRealizations` -- rather than reading any
+ * name here: an empty map (no plugin states one) costs one size check and
+ * changes nothing, exactly as `jsdocNamepathTransform` costs one substring
+ * test on a file with no `~`.
+ *
+ * Runs after `declarationOverlayTransform` in `compiler.ts`'s own pipeline so
+ * it sees what THAT transform injects -- `@types/three`'s own `_gl:
+ * WebGLRenderingContext` -- and not only what the program's own source
+ * already wrote.
+ *
+ * Whole-comment, word-boundary text replacement, the same shape
+ * `jsdocNamepathTransform` uses for the identical reason: this compiler does
+ * not parse a JSDoc type expression into a tree before rewriting it, so
+ * scoping the replacement to "inside a `/**\/` range" is what keeps it out of
+ * ordinary code and prose comments, and a plain `\b` match is exact for a
+ * name that is a single, unqualified identifier -- which every ambient
+ * protocol name in `lib.dom.d.ts` is.
+ */
+export declare const createAmbientTypeRealizationTransform: (realizations: ReadonlyMap<string, AmbientTypeRealization>) => ((input: {
+    readonly fileName: string;
+    readonly text: string;
+}) => string | null);

package/dist/semantics/ambient-type-realization-transform.js

@@ -0,0 +1,168 @@
+import ts from 'typescript';
+import { documentationRangesIn } from './documentation-ranges.js';
+const scriptKindOf = (fileName) => fileName.endsWith('.tsx')
+    ? ts.ScriptKind.TSX
+    : fileName.endsWith('.jsx')
+        ? ts.ScriptKind.JSX
+        : fileName.endsWith('.js') || fileName.endsWith('.mjs') || fileName.endsWith('.cjs')
+            ? ts.ScriptKind.JS
+            : ts.ScriptKind.TS;
+/**
+ * Locally declared names cannot be assumed to denote a host ambient type.
+ * Without a checker in this source transform, conservatively exclude a name
+ * shadowed in any scope. Include type declarations and destructured bindings.
+ */
+const boundNamesIn = (file) => {
+    const bound = new Set();
+    const binding = (name) => {
+        if (ts.isIdentifier(name))
+            bound.add(name.text);
+        else
+            for (const element of name.elements)
+                if (ts.isBindingElement(element))
+                    binding(element.name);
+    };
+    const visit = (node) => {
+        if (ts.isVariableDeclaration(node) || ts.isParameter(node))
+            binding(node.name);
+        else if (ts.isClassDeclaration(node) ||
+            ts.isClassExpression(node) ||
+            ts.isFunctionDeclaration(node) ||
+            ts.isFunctionExpression(node) ||
+            ts.isInterfaceDeclaration(node) ||
+            ts.isTypeAliasDeclaration(node) ||
+            ts.isTypeParameterDeclaration(node) ||
+            ts.isImportSpecifier(node) ||
+            ts.isImportClause(node) ||
+            ts.isNamespaceImport(node) ||
+            ts.isImportEqualsDeclaration(node) ||
+            ts.isEnumDeclaration(node) ||
+            ts.isModuleDeclaration(node)) {
+            if (node.name && ts.isIdentifier(node.name))
+                bound.add(node.name.text);
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(file);
+    return bound;
+};
+/**
+ * Respell JSDoc and TypeScript type references to a host's concrete type.
+ * Value references remain untouched: an interface realization does not imply
+ * that a browser constructor exists on the native host.
+ *
+ * Built from `realizations` -- the union of every installed plugin's own
+ * `PluginCapabilities.ambientTypeRealizations` -- rather than reading any
+ * name here: an empty map (no plugin states one) costs one size check and
+ * changes nothing, exactly as `jsdocNamepathTransform` costs one substring
+ * test on a file with no `~`.
+ *
+ * Runs after `declarationOverlayTransform` in `compiler.ts`'s own pipeline so
+ * it sees what THAT transform injects -- `@types/three`'s own `_gl:
+ * WebGLRenderingContext` -- and not only what the program's own source
+ * already wrote.
+ *
+ * Whole-comment, word-boundary text replacement, the same shape
+ * `jsdocNamepathTransform` uses for the identical reason: this compiler does
+ * not parse a JSDoc type expression into a tree before rewriting it, so
+ * scoping the replacement to "inside a `/**\/` range" is what keeps it out of
+ * ordinary code and prose comments, and a plain `\b` match is exact for a
+ * name that is a single, unqualified identifier -- which every ambient
+ * protocol name in `lib.dom.d.ts` is.
+ */
+export const createAmbientTypeRealizationTransform = (realizations) => {
+    if (realizations.size === 0)
+        return () => null;
+    const patterns = [...realizations].map(([name, realization]) => ({
+        name,
+        realization,
+        pattern: new RegExp(`\\b${name}\\b`, 'g')
+    }));
+    return (input) => {
+        if (input.fileName.endsWith('.d.ts'))
+            return null;
+        let mentioned = false;
+        for (const { name } of patterns) {
+            if (input.text.includes(name)) {
+                mentioned = true;
+                break;
+            }
+        }
+        if (!mentioned)
+            return null;
+        const file = ts.createSourceFile(input.fileName, input.text, ts.ScriptTarget.Latest, true, scriptKindOf(input.fileName));
+        const ranges = documentationRangesIn(file, input.text);
+        const bound = boundNamesIn(file);
+        const usable = patterns
+            .filter(({ name }) => !bound.has(name))
+            .map((entry) => {
+            // Reuse an existing import of the same exported native type. Otherwise
+            // alias a collision instead of silently leaving a browser layout behind.
+            for (const statement of file.statements) {
+                if (!ts.isImportDeclaration(statement) ||
+                    !ts.isStringLiteral(statement.moduleSpecifier) ||
+                    statement.moduleSpecifier.text !== entry.realization.importedFrom)
+                    continue;
+                const bindings = statement.importClause?.namedBindings;
+                if (!bindings || !ts.isNamedImports(bindings))
+                    continue;
+                const existing = bindings.elements.find((element) => (element.propertyName ?? element.name).text === entry.realization.type);
+                if (existing)
+                    return { ...entry, local: existing.name.text, imported: true };
+            }
+            let local = entry.realization.type;
+            for (let suffix = 0; bound.has(local); suffix++)
+                local = `__gea_ambient_${entry.name}_${suffix}`;
+            return { ...entry, local, imported: false };
+        });
+        if (usable.length === 0)
+            return null;
+        const needed = new Map();
+        const use = (entry) => {
+            if (!entry.imported)
+                needed.set(entry.local, { exported: entry.realization.type, specifier: entry.realization.importedFrom });
+            return entry.local;
+        };
+        const edits = [];
+        for (const range of ranges) {
+            const comment = input.text.slice(range.pos, range.end);
+            let respelled = comment;
+            for (const entry of usable) {
+                const { pattern } = entry;
+                pattern.lastIndex = 0;
+                if (!pattern.test(respelled))
+                    continue;
+                pattern.lastIndex = 0;
+                respelled = respelled.replace(pattern, use(entry));
+            }
+            if (respelled === comment)
+                continue;
+            edits.push({ pos: range.pos, end: range.end, text: respelled });
+        }
+        const visit = (node) => {
+            if (ts.isTypeReferenceNode(node) && ts.isIdentifier(node.typeName)) {
+                const entry = usable.find((candidate) => candidate.name === node.typeName.getText(file));
+                if (entry)
+                    edits.push({ pos: node.typeName.getStart(file), end: node.typeName.end, text: use(entry) });
+            }
+            ts.forEachChild(node, visit);
+        };
+        visit(file);
+        if (edits.length === 0)
+            return null;
+        let rewritten = input.text;
+        for (const edit of edits.sort((left, right) => right.pos - left.pos)) {
+            rewritten = rewritten.slice(0, edit.pos) + edit.text + rewritten.slice(edit.end);
+        }
+        const javascript = scriptKindOf(input.fileName) === ts.ScriptKind.JS || scriptKindOf(input.fileName) === ts.ScriptKind.JSX;
+        const header = [...needed]
+            .map(([local, { exported, specifier }]) => {
+            const binding = local === exported ? exported : `${exported} as ${local}`;
+            return javascript
+                ? `/** @import { ${binding} } from ${JSON.stringify(specifier)} */`
+                : `import type { ${binding} } from ${JSON.stringify(specifier)};`;
+        })
+            .join('\n');
+        return header ? `${header}\n${rewritten}` : rewritten;
+    };
+};

package/dist/semantics/ambient.d.ts

@@ -0,0 +1,24 @@
+import ts from 'typescript';
+/**
+ * The one-declaration half of the same fact.
+ *
+ * `isAmbientSymbol` asks it of every declaration a symbol has; a caller
+ * holding a single `ts.Declaration` -- resolving which copy of a generic a
+ * name means, say -- asks it of that one. Both go through this so the three
+ * spellings of "ambient" below are stated once: a fourth caller deriving its
+ * own is the drift this file exists to prevent.
+ */
+export declare const isAmbientDeclaration: (declaration: ts.Declaration) => boolean;
+export declare const isAmbientSymbol: (symbol: ts.Symbol) => boolean;
+/**
+ * Every declared base of a class or interface type, nearest first.
+ *
+ * A class can be recognized by what it derives from, and the base that
+ * identifies it may be reached through an intermediate the program wrote
+ * (`class View extends Base`, then `class Home extends View`). Stopping at the
+ * immediate base would admit the first spelling and refuse the second for no
+ * reason the program could act on, so the whole chain is walked -- and a type
+ * visited twice is not revisited, because a declaration file is free to
+ * declare a cycle this walk must still terminate on.
+ */
+export declare const declaredBaseTypesOf: (checker: ts.TypeChecker, type: ts.Type) => readonly ts.Type[];

package/dist/semantics/ambient.js

@@ -0,0 +1,119 @@
+import ts from 'typescript';
+/**
+ * Declared, never defined: what a host owns.
+ *
+ * A declaration file states that something exists; it never brings it into
+ * being. That is the language's own notion, the same one `declare` spells
+ * inside an ordinary file, and it is what separates a value the program owns
+ * from one a host supplies. A symbol with even one non-ambient declaration is
+ * defined by this program somewhere and is not a host's.
+ *
+ * This lives on its own rather than beside its callers because what they
+ * decide with it is something a program cannot recover from being wrong about
+ * -- placing a binding as an external cell, admitting a class into a library's
+ * protocol -- and two spellings of "ambient" that drifted apart would disagree
+ * silently on exactly the declarations that matter.
+ */
+/**
+ * Whether an enclosing block put this declaration in an ambient context.
+ *
+ * `getCombinedModifierFlags` answers only for the declaration itself (and, for
+ * a variable, its own statement). It walks out of neither `declare global { }`
+ * nor `declare module 'x' { }`, whose `declare` sits on the block -- so a
+ * function declared inside one carries no ambient modifier of its own and
+ * reads as a definition this program owns.
+ *
+ * The parser does record it, as an internal `NodeFlags.Ambient` bit the public
+ * typings do not expose; deriving the same fact from the ancestor chain asks
+ * the same question through the API that is actually documented.
+ */
+const isInsideAmbientBlock = (declaration) => {
+    for (let node = declaration.parent; node !== undefined; node = node.parent) {
+        if ((ts.getCombinedModifierFlags(node) & ts.ModifierFlags.Ambient) !== 0)
+            return true;
+    }
+    return false;
+};
+/**
+ * The one-declaration half of the same fact.
+ *
+ * `isAmbientSymbol` asks it of every declaration a symbol has; a caller
+ * holding a single `ts.Declaration` -- resolving which copy of a generic a
+ * name means, say -- asks it of that one. Both go through this so the three
+ * spellings of "ambient" below are stated once: a fourth caller deriving its
+ * own is the drift this file exists to prevent.
+ */
+export const isAmbientDeclaration = (declaration) => declaration.getSourceFile().isDeclarationFile ||
+    (ts.getCombinedModifierFlags(declaration) & ts.ModifierFlags.Ambient) !== 0 ||
+    // The third spelling, and the one the other two miss.
+    //
+    // `declare global { function requestAnimationFrame(...): number }` in an
+    // ordinary `.ts` file puts no `declare` modifier on the *function*: the
+    // modifier is on the block, and `getCombinedModifierFlags` walks up only
+    // from a variable declaration to its statement, not out of an ambient
+    // module body. What the parser does instead is mark every node inside a
+    // `declare` context with `NodeFlags.Ambient`, which is the language's own
+    // answer to this exact question and is what the checker itself consults.
+    //
+    // Missing it made a host function look like one this program defines:
+    // `canvas-3d` declares `requestAnimationFrame` that way, and the symbol
+    // -- ambient in `lib`'s own `.d.ts` and ambient again here -- was judged
+    // non-ambient on the strength of the second declaration. It then
+    // allocated a function object with no body behind it, whose ABI declared
+    // one parameter nothing could bind, and the whole program was refused.
+    isInsideAmbientBlock(declaration);
+export const isAmbientSymbol = (symbol) => {
+    const declarations = symbol.declarations;
+    if (!declarations || declarations.length === 0)
+        return false;
+    return declarations.every(isAmbientDeclaration);
+};
+/**
+ * Every declared base of a class or interface type, nearest first.
+ *
+ * A class can be recognized by what it derives from, and the base that
+ * identifies it may be reached through an intermediate the program wrote
+ * (`class View extends Base`, then `class Home extends View`). Stopping at the
+ * immediate base would admit the first spelling and refuse the second for no
+ * reason the program could act on, so the whole chain is walked -- and a type
+ * visited twice is not revisited, because a declaration file is free to
+ * declare a cycle this walk must still terminate on.
+ */
+export const declaredBaseTypesOf = (checker, type) => {
+    const found = [];
+    const seen = new Set();
+    /**
+     * The declaration-shaped type whose bases the checker will answer for.
+     *
+     * `getBaseTypes` answers only for the `ClassOrInterface` a declaration
+     * produced. A *generic* class reached through an instantiation is not that:
+     * `ReactiveComponent<unknown>` is a `Reference`, and its `target` is the
+     * declaration-shaped type that actually states `extends Component<...>`.
+     * Without this step the walk asked a reference for its bases, got none, and
+     * stopped -- reporting a class that plainly extends something as having no
+     * bases at all, at the first generic link in the chain.
+     */
+    const declarationShapeOf = (current) => {
+        if (current.isClassOrInterface())
+            return current;
+        if ((current.flags & ts.TypeFlags.Object) === 0)
+            return null;
+        if ((current.objectFlags & ts.ObjectFlags.Reference) === 0)
+            return null;
+        const target = current.target;
+        return target !== current && target.isClassOrInterface() ? target : null;
+    };
+    const visit = (current) => {
+        if (seen.has(current))
+            return;
+        seen.add(current);
+        const declared = declarationShapeOf(current);
+        const bases = declared ? checker.getBaseTypes(declared) : [];
+        for (const base of bases) {
+            found.push(base);
+            visit(base);
+        }
+    };
+    visit(type);
+    return found;
+};

package/dist/semantics/borrowed-builtin-call-bind-source-transform.d.ts

@@ -0,0 +1,4 @@
+export declare const borrowedBuiltinCallBindSourceTransform: (input: {
+    readonly fileName: string;
+    readonly text: string;
+}) => string | null;