@cplieger/deadset-ts 7.2.0-dev.2 → 7.2.0-dev.4

package/dist/bin/mapper-connection.js

@@ -6,6 +6,7 @@
  * https://github.com/microsoft/TypeScript/blob/f9f8d01292562242b6e7c7142e46ed7e470926f9/tsc/internal/contentmapper/hostimpl.go
  */
 import { componentModule } from "../src/component-files.js";
+import { extensionOf } from "../src/paths.js";
 /** The JSON-RPC code of a method this mapper does not serve. */
 const METHOD_NOT_FOUND = -32601;
 /** The JSON-RPC code of a request whose parameters are not the protocol's. */
@@ -42,13 +43,15 @@ function answer(message) {
         case "closeProject":
             return reply(null);
         case "transform": {
-            const content = typeof message.params === "object" && message.params !== null
-                ? message.params.content
-                : undefined;
+            const params = typeof message.params === "object" && message.params !== null ? message.params : {};
+            const { content, fileName } = params;
             if (typeof content !== "string") {
                 return fail(INVALID_PARAMS, "transform: params.content is not a string");
             }
-            const module = componentModule(content);
+            if (typeof fileName !== "string") {
+                return fail(INVALID_PARAMS, "transform: params.fileName is not a string");
+            }
+            const module = componentModule(content, extensionOf(fileName));
             return reply({ text: module.text, extension: module.extension, mappings: module.mappings });
         }
         default:

package/dist/src/analysis.js

@@ -32,7 +32,7 @@ import { intraFunctionFacts, projectParts } from "./intra-function-parts.js";
 import { inventory } from "./inventory.js";
 import { packageEntries, readManifest } from "./manifest.js";
 import { liveFilesAt, matrixOf, referenceKey, sweepMatrix, } from "./matrix.js";
-import { dirnamePath, joinPath, normalizePath, relativePath, resolvePath } from "./paths.js";
+import { dirnamePath, extensionOf, joinPath, normalizePath, relativePath, resolvePath, } from "./paths.js";
 import { byPosition, isComponentFile } from "./position.js";
 import { LANGUAGE } from "./report.js";
 import { SetupError, setupLine } from "./setup-failure.js";
@@ -175,6 +175,7 @@ function readProjects(engine, host, scope, config, stage) {
     const failures = [];
     const unbuildable = [];
     const setupDropped = [];
+    const librariesUnfound = [];
     const consumed = new Map();
     const heldFiles = new Set();
     let outsideTests = [];
@@ -227,10 +228,6 @@ function readProjects(engine, host, scope, config, stage) {
                 : resolvePath(host.workingDirectory(), consumer.path),
             paths: pathsOf(engine, project.configFile),
         });
-        if (reading.failing.length > 0) {
-            failures.push(...reading.failing);
-            return undefined;
-        }
         if (consumer !== undefined && reading.missing.length > 0) {
             unbuildable.push(...reading.missing.map((one) => ({
                 setupClass: "missing-consumer",
@@ -258,6 +255,10 @@ function readProjects(engine, host, scope, config, stage) {
             }
             return undefined;
         }
+        librariesUnfound.push(...raw.unfound.map((one) => ({
+            configFile: project.configFile,
+            error: renderDiagnostic(one, (path) => relativePath(absoluteRoot, path) ?? path),
+        })));
         const configuration = ids.get(project.configFile) ?? project.configFile;
         const read = () => {
             const held = inventory(project, host, targetRoot);
@@ -326,6 +327,7 @@ function readProjects(engine, host, scope, config, stage) {
         notBuilt,
         unanswered: session.unanswered,
         componentsUnread: workspace?.componentsUnread ?? [],
+        librariesUnfound,
         conventionsApplied: conventions.applied,
         conventionUses: conventions.uses,
         memberDirs,
@@ -439,7 +441,7 @@ function readRun(engine, host, scope, config, mode, detectors, extra) {
             testFiles: resolved.testFilePaths,
             evidence,
             componentFiles: components.map(pathOf),
-            componentWarnings: components.flatMap((file) => readComponent(file.originalText).warnings.map((warning) => ({
+            componentWarnings: components.flatMap((file) => readComponent(file.originalText, extensionOf(file.fileName)).warnings.map((warning) => ({
                 path: pathOf(file),
                 line: lineOf(file.originalText, warning.offset),
                 reason: warning.reason,
@@ -528,6 +530,7 @@ function readRun(engine, host, scope, config, mode, detectors, extra) {
         notBuilt: read.notBuilt,
         unanswered: read.unanswered,
         componentsUnread: read.componentsUnread,
+        librariesUnfound: read.librariesUnfound,
         conventionsApplied: read.conventionsApplied,
         conventionUses: read.conventionUses,
         memberDirs: read.memberDirs,
@@ -796,6 +799,7 @@ function readAnalysis(engine, host, scope, config, provenance, mode, detectors)
             notBuilt: read.notBuilt,
             unanswered: read.unanswered,
             componentsUnread: read.componentsUnread,
+            librariesUnfound: read.librariesUnfound,
             conventionsApplied: read.conventionsApplied,
         },
         configured: read.projects.map((one) => one.configured),

package/dist/src/component-files.js

@@ -109,17 +109,17 @@ function scriptTagAt(text, offset) {
         /^<script[\s/>]/iu.test(text.slice(offset, offset + 8)));
 }
 /**
- * The offset past the `}` matching the `{` at `from`, quoted strings skipped, or -1 where
- * none matches before the end or before a `<script` start tag that begins a line, so a
- * stray brace in markup never hides a block.
+ * The braces opening at `from`, quoted strings skipped. The scan stops unclosed at the
+ * end, or before a `<script` start tag that begins a line, so a stray brace in markup
+ * never hides a block.
  */
-function pastBraces(text, from) {
+function scanBraces(text, from) {
     let depth = 0;
     let at = from;
     while (at < text.length) {
         const code = text.charCodeAt(at);
         if (scriptTagAt(text, at)) {
-            return -1;
+            return { end: at, closed: false };
         }
         if (code === 0x22 || code === 0x27 || code === 0x60) {
             at = pastQuoted(text, at);
@@ -131,24 +131,84 @@ function pastBraces(text, from) {
         else if (code === 0x7d) {
             depth -= 1;
             if (depth === 0) {
-                return at + 1;
+                return { end: at + 1, closed: true };
             }
         }
         at += 1;
     }
-    return -1;
+    return { end: text.length, closed: false };
+}
+/** The offset past the `}` matching the `{` at `from`, or -1 where {@link scanBraces} finds none. */
+function pastBraces(text, from) {
+    const braces = scanBraces(text, from);
+    return braces.closed ? braces.end : -1;
+}
+/**
+ * The dialect each framework's parser reads: Vue's tokenizer, Svelte's parser and Astro's
+ * tokenizer, the last for any other extension too. `.vue` also closes `--!>`, which Vue
+ * does not, so a block Vue drops there is still read.
+ * https://github.com/vuejs/core/blob/main/packages/compiler-core/src/tokenizer.ts
+ * https://github.com/sveltejs/svelte/blob/main/packages/svelte/src/compiler/phases/1-parse/state/element.js
+ * https://github.com/withastro/compiler/blob/main/internal/token.go
+ */
+function dialectOf(extension) {
+    switch (extension.toLowerCase()) {
+        case ".svelte":
+            return { shortComments: false, braceIsText: false };
+        case ".vue":
+            return { shortComments: true, braceIsText: true };
+        default:
+            return { shortComments: true, braceIsText: false };
+    }
+}
+/** The offset past the comment whose `<!--` is at `lt`, or the text's length where none ends it. */
+function pastComment(text, lt, dialect) {
+    if (!dialect.shortComments) {
+        const close = text.indexOf("-->", lt + 4);
+        return close < 0 ? text.length : close + 3;
+    }
+    const dashes = text.indexOf("-->", lt + 2);
+    const bang = text.indexOf("--!>", lt + 2);
+    if (bang >= 0 && (dashes < 0 || bang < dashes)) {
+        return bang + 4;
+    }
+    return dashes < 0 ? text.length : dashes + 3;
+}
+/**
+ * Where an unmatched `{` of a start tag ends its braced value: at the first `>`, or where
+ * the brace scan stopped where that comes first.
+ */
+function unmatchedBraceEnd(text, from, braces) {
+    const close = text.indexOf(">", from);
+    return close >= 0 && close < braces.end ? close : braces.end;
 }
-/** The start tag whose `<` is at `from`, to its `>`. A quoted or braced value may hold `>`. */
-function readStartTag(text, from, nameStop) {
+/**
+ * The start tag whose `<` is at `from`, to its `>`. A quoted or braced value may hold `>`.
+ * Past an unmatched `{`, the tag also ends before a `<script` start tag that begins a line.
+ */
+function readStartTag(text, from, nameStop, dialect) {
     const name = text.slice(from + 1, nameStop).toLowerCase();
     const attributes = [];
     let at = nameStop;
     let selfClosing = false;
+    let unmatched = false;
+    /** The braces opening at `at`, and whether they make a braced value rather than text. */
+    const bracesAt = () => {
+        if (text.charCodeAt(at) !== 0x7b) {
+            return undefined;
+        }
+        const braces = scanBraces(text, at);
+        return { braces, value: braces.closed || !dialect.braceIsText };
+    };
+    const bracedEnd = (braces) => braces.closed ? braces.end : unmatchedBraceEnd(text, at, braces);
     while (at < text.length) {
         const code = text.charCodeAt(at);
         if (code === 0x3e) {
             return { name, end: at + 1, selfClosing, attributes };
         }
+        if (unmatched && scriptTagAt(text, at)) {
+            return { name, end: at, selfClosing, attributes };
+        }
         if (isSpace(code)) {
             at += 1;
             continue;
@@ -160,12 +220,13 @@ function readStartTag(text, from, nameStop) {
         }
         selfClosing = false;
         const start = at;
-        if (code === 0x7b) {
-            const past = pastBraces(text, at);
-            at = past < 0 ? text.length : past;
+        const bare = bracesAt();
+        unmatched ||= bare?.braces.closed === false;
+        if (bare?.value === true) {
+            at = bracedEnd(bare.braces);
             attributes.push({
                 name: "",
-                value: text.slice(start + 1, at - 1),
+                value: text.slice(start + 1, bare.braces.closed ? at - 1 : at),
                 start,
                 end: at,
                 valueStart: start + 1,
@@ -191,17 +252,19 @@ function readStartTag(text, from, nameStop) {
                 at += 1;
             }
             const opening = text.charCodeAt(at);
+            const braced = bracesAt();
+            unmatched ||= braced?.braces.closed === false;
             if (opening === 0x22 || opening === 0x27) {
-                const past = pastQuoted(text, at);
+                // An attribute value has no escapes: a backslash before its quote is text.
+                const close = text.indexOf(text.charAt(at), at + 1);
                 valueStart = at + 1;
-                value = text.slice(at + 1, Math.max(past - 1, at + 1));
-                at = past;
+                value = text.slice(at + 1, close < 0 ? text.length : close);
+                at = close < 0 ? text.length : close + 1;
             }
-            else if (opening === 0x7b) {
-                const past = pastBraces(text, at);
-                const stop = past < 0 ? text.length : past;
+            else if (braced?.value === true) {
+                const stop = bracedEnd(braced.braces);
                 valueStart = at + 1;
-                value = text.slice(at + 1, Math.max(stop - 1, at + 1));
+                value = text.slice(at + 1, braced.braces.closed ? stop - 1 : stop);
                 at = stop;
             }
             else {
@@ -305,9 +368,11 @@ function scriptsInside(text, from, to) {
  * The scan keeps a stack of open elements. A comment, a doctype or processing instruction and
  * an expression in braces are text, and an end tag closes back to the nearest open element of
  * its name. A raw-text element at the top level runs to its own end tag, and only a `script`
- * element whose start tag begins a line at the top level is a block.
+ * element whose start tag begins a line at the top level is a block. The file's extension
+ * names the framework whose reading of a comment and of a stray brace applies.
  */
-export function readComponent(text) {
+export function readComponent(text, extension) {
+    const dialect = dialectOf(extension);
     const blocks = [];
     const imports = [];
     const warnings = [];
@@ -337,8 +402,7 @@ export function readComponent(text) {
         }
         const lt = at;
         if (text.startsWith("<!--", lt)) {
-            const close = text.indexOf("-->", lt + 4);
-            at = close < 0 ? text.length : close + 3;
+            at = pastComment(text, lt, dialect);
             continue;
         }
         const next = text.charCodeAt(lt + 1);
@@ -362,7 +426,7 @@ export function readComponent(text) {
             at = lt + 1;
             continue;
         }
-        const tag = readStartTag(text, lt, nameStop);
+        const tag = readStartTag(text, lt, nameStop, dialect);
         const rawText = open.length === 0 && RAW_TEXT.has(tag.name);
         for (const attribute of rawText ? [] : tag.attributes) {
             if (attribute.value !== "") {
@@ -435,9 +499,9 @@ export function readComponent(text) {
     }
 }
 /**
- * Whether the module's text exports a default at its top level: an `export default`
- * or an export clause naming `default`, outside every comment, string, template and
- * regular expression, and outside every bracket.
+ * Whether the module's text exports a default at its top level: an `export default`, an
+ * `export * as default`, or an export clause naming `default`, outside every comment,
+ * string, template and regular expression, and outside every bracket.
  */
 export function exportsDefault(text) {
     const words = [];
@@ -525,7 +589,8 @@ export function exportsDefault(text) {
         const matched = word.exec(text);
         if (matched !== null) {
             const name = matched[0];
-            if (depth === 0 && words.at(-1) === "export" && name === "default") {
+            const starAs = words.at(-3) === "export" && words.at(-2) === "*" && words.at(-1) === "as";
+            if (depth === 0 && (words.at(-1) === "export" || starAs) && name === "default") {
                 return true;
             }
             if (clause && name === "default") {
@@ -554,8 +619,8 @@ export function exportsDefault(text) {
     return false;
 }
 /** The module one component file's text is read as, and the span map back to the file. */
-export function componentModule(text) {
-    const { blocks, imports } = readComponent(text);
+export function componentModule(text, fileExtension) {
+    const { blocks, imports } = readComponent(text, fileExtension);
     const out = [];
     let at = 0;
     let language;

package/dist/src/configuration-files.js

@@ -76,6 +76,7 @@ const CONFIG_FLAGS = new Set(["--config", "-c"]);
 /** The extensions of a module a configuration flag may name. */
 const MODULE_EXTENSIONS = [".js", ".mjs", ".cjs", ".ts", ".mts", ".cts"];
 /** The characters that end a word outside quotes and separate nothing: blanks. */
+// Stryker disable next-line Regex: its \v to \V mutant is no valid escape under the u flag, so the whole module fails to parse
 const BLANK = /[ \t\r\f\v]/u;
 /** The characters that end a word outside quotes and begin an operator: newline included. */
 const OPERATOR = /[\n;&|()<>]/u;
@@ -269,8 +270,9 @@ export function configurationFiles(host, targetRoot, files, parse) {
     const dirs = new Set([root]);
     for (const file of files.byPath.values()) {
         const form = configurationModuleForm(basename(file.fileName));
-        if (form !== undefined && holdsManifest(dirnamePath(file.fileName))) {
-            modules.push({ file, form });
+        const fileDir = dirnamePath(file.fileName);
+        if (form !== undefined && holdsManifest(fileDir)) {
+            modules.push({ file, form, manifestDir: fileDir });
         }
         for (let dir = dirnamePath(file.fileName); relativePath(root, dir) !== undefined && !dirs.has(dir); dir = dirnamePath(dir)) {
             dirs.add(dir);
@@ -300,7 +302,7 @@ export function configurationFiles(host, targetRoot, files, parse) {
                 pending.push({ path, manifestDir: dir });
             }
             else if (held !== undefined) {
-                modules.push({ file: held, form: "a script's configuration flag" });
+                modules.push({ file: held, form: "a script's configuration flag", manifestDir: dir });
             }
             else {
                 named.push({ path, manifestDir: dir });

package/dist/src/configured-declarations.js

@@ -7,6 +7,7 @@
 import { isCallExpression, isExportDeclaration, isExternalModuleReference, isImportDeclaration, isImportEqualsDeclaration, isNoSubstitutionTemplateLiteral, isStringLiteral, SyntaxKind, } from "@typescript/native/ast";
 import { SymbolFlags } from "@typescript/native/sync";
 import { resolvedTargets } from "./calls.js";
+import { declaredComponent } from "./inventory.js";
 import { must, Unanswerable } from "./query.js";
 import { nameComponent } from "./ref.js";
 /** The meanings a name of the global scope is looked up under: any of them. */
@@ -80,9 +81,30 @@ function candidatesOf(project, container, isStatic) {
         ...exported.filter((member) => !isClass || !isClassMember(member)),
     ];
 }
-/** The member of one container a path component spells, followed through any alias. */
+/**
+ * The properties of the type one container declares, or of its constructor's type for a
+ * static member. A member a symbol keys is bound to that type later than the container's
+ * symbol table is built, so the table does not hold it.
+ */
+function typeMembersOf(project, container, isStatic) {
+    const queries = project.queries;
+    const type = must(isStatic ? queries.typeOfSymbol(container) : queries.declaredTypeOf(container));
+    return type === undefined ? [] : must(queries.propertiesOf(type));
+}
+/**
+ * The member of one container a path component spells, followed through any alias. A
+ * component in brackets is a computed key, compared with the key each declaration of a
+ * candidate writes: the checker names a member a symbol keys by no spelling of its own.
+ */
 function memberOf(project, container, component, isStatic) {
-    const member = candidatesOf(project, container, isStatic).find((candidate) => nameComponent(candidate.name) === component);
+    const computed = component.startsWith("[");
+    const candidates = candidatesOf(project, container, isStatic);
+    const member = (computed ? [...candidates, ...typeMembersOf(project, container, isStatic)] : candidates).find((candidate) => nameComponent(candidate.name) === component ||
+        (computed &&
+            candidate.declarations.some((handle) => {
+                const node = project.declarationAt(handle)?.node;
+                return node !== undefined && declaredComponent(node) === component;
+            })));
     return member === undefined ? undefined : unaliased(project, member);
 }
 /** The declaration a path names from one starting symbol, component by component. */

package/dist/src/conformance-record.js

@@ -4,7 +4,7 @@ export const RECORD = {
     conformance: {
         corpusVersion: "5.2.0",
         result: "pass",
-        digest: "sha256:4050d1b67fb757bc12a60f8ece7317a3e8485d3383ec52919cd24b9dfd5509dc",
+        digest: "sha256:012872542679539ec105f49b5ee502b0a9fa35c6bbd9ef3983b5f6e53af83d8e",
     },
     gaps: [],
 };

package/dist/src/contextual-uses.js

@@ -196,12 +196,13 @@ export function contextualUses(project, held, chains, literals, flows, cap, prop
     };
     const calls = new Map();
     /**
-     * The parameter and return types of a type's one call signature, or of its one construct
-     * signature where it has no call signature, read once per type.
+     * The parameter and return types of each of a type's call signatures, or of each of its
+     * construct signatures where it has no call signature, read once per type.
      */
-    const callOf = (type) => {
-        if (calls.has(type.id)) {
-            return calls.get(type.id);
+    const callsOf = (type) => {
+        const known = calls.get(type.id);
+        if (known !== undefined) {
+            return known;
         }
         lookups += 1;
         let kind = SignatureKind.Call;
@@ -211,28 +212,26 @@ export function contextualUses(project, held, chains, literals, flows, cap, prop
             kind = SignatureKind.Construct;
             signatures = queries.signaturesOf(type, kind);
         }
-        let called;
-        const [signature, ...more] = isAnswered(signatures) ? signatures : [];
-        if (signature !== undefined && more.length === 0) {
+        const called = (isAnswered(signatures) ? signatures : []).map((signature) => {
             const parameters = signature.parameters.map((_parameter, index) => queries.parameterType(signature, index));
             const result = queries.returnTypeOf(signature);
             lookups += parameters.length + 1;
-            called = {
+            return {
                 kind,
                 parameters: parameters.map((one) => (isAnswered(one) ? one : undefined)),
                 result: isAnswered(result) ? result : undefined,
             };
-        }
+        });
         calls.set(type.id, called);
         return called;
     };
     /**
      * Each object type a value of `source` is checked as against the object types of
-     * `target`: the value's own, and through array elements, a function's parameters,
-     * checked the other way, and result, and the type arguments two instantiations share
-     * by place, an array among them, as an array reaches `Iterable<T>`.
-     * A source that is one of the target's own object types matches it as it stands. Each
-     * pair is compared once, which ends the walk over a recursive type.
+     * `target`: the value's own, and through array elements, every pair of signatures
+     * (parameters checked the other way, then results), which reads more than the overload
+     * the checker picks, and the type arguments of two instantiations by place, as an array
+     * reaches `Iterable<T>`. A source that is one of the target's own object types matches
+     * it as it stands. Each pair is compared once, which ends the walk over a recursive type.
      */
     const compared = (source, target, into, seen) => {
         const key = `${String(source?.id)}>${String(target?.id)}`;
@@ -253,7 +252,7 @@ export function contextualUses(project, held, chains, literals, flows, cap, prop
                 into.push({ source: one, targets, outside: true });
             }
             const element = elementOf(one);
-            const called = element === undefined ? callOf(one) : undefined;
+            const called = element === undefined ? callsOf(one) : [];
             const sourceArguments = typeArgumentsOf(one);
             for (const part of targets) {
                 const partElement = elementOf(part);
@@ -267,17 +266,17 @@ export function contextualUses(project, held, chains, literals, flows, cap, prop
                 sourceArguments.slice(0, targetArguments.length).forEach((argument, index) => {
                     compared(argument, targetArguments[index], into, seen);
                 });
-                if (element !== undefined) {
+                if (element !== undefined || called.length === 0) {
                     continue;
                 }
-                const other = called === undefined ? undefined : callOf(part);
-                if (called === undefined || other?.kind !== called.kind) {
-                    continue;
+                for (const other of callsOf(part)) {
+                    for (const signature of called.filter((one) => one.kind === other.kind)) {
+                        other.parameters.forEach((parameter, index) => {
+                            compared(parameter, signature.parameters[index], into, seen);
+                        });
+                        compared(signature.result, other.result, into, seen);
+                    }
                 }
-                other.parameters.forEach((parameter, index) => {
-                    compared(parameter, called.parameters[index], into, seen);
-                });
-                compared(called.result, other.result, into, seen);
             }
         }
     };
@@ -298,7 +297,7 @@ export function contextualUses(project, held, chains, literals, flows, cap, prop
             if (element !== undefined) {
                 return mayCarry(element, seen);
             }
-            return callOf(part) !== undefined || typeArgumentsOf(part).some((one) => mayCarry(one, seen));
+            return callsOf(part).length > 0 || typeArgumentsOf(part).some((one) => mayCarry(one, seen));
         });
     };
     const sourced = carried.flatMap((flow, index) => {
@@ -330,10 +329,11 @@ export function contextualUses(project, held, chains, literals, flows, cap, prop
                 continue;
             }
             for (const [name, member] of sourceMembers) {
+                // A member the position shares with the source is no read of it. A member with no
+                // declaration, as a mapped type over literal keys has, is never one it shares.
                 const read = tables.some((table) => {
                     const declared = table.get(name);
                     return (declared !== undefined &&
-                        declared.handles.size > 0 &&
                         ![...declared.handles].some((handle) => member.handles.has(handle)));
                 });
                 if (read) {

package/dist/src/dependencies.js

@@ -244,8 +244,8 @@ export function projectNeeds(project, held, host, targetRoot, parse) {
         return names;
     };
     const configuration = configurationFiles(host, targetRoot, sourceFilesOf(project, targetRoot), parse);
-    for (const { file } of configuration.modules) {
-        const names = declaredAt(file.fileName);
+    for (const { file, manifestDir } of configuration.modules) {
+        const names = declaredAt(joinPath(manifestDir, MANIFEST));
         for (const { node, text } of moduleStrings(file)) {
             use(ownersOf(file, held, node), dependenciesNamed(text, names), file.fileName);
         }

package/dist/src/destructuring.js

@@ -6,8 +6,10 @@
  * it. A rest element names no property: what it copies is read where the copy is.
  */
 import { isArrayLiteralExpression, isBinaryExpression, isForOfStatement, isIdentifier, isNoSubstitutionTemplateLiteral, isNumericLiteral, isObjectBindingPattern, isObjectLiteralExpression, isParameterDeclaration, isParenthesizedExpression, isPropertyAssignment, isShorthandPropertyAssignment, isStringLiteral, SyntaxKind, } from "@typescript/native/ast";
-import { TypeFlags } from "@typescript/native/sync";
+import { SignatureKind, TypeFlags, } from "@typescript/native/sync";
 import { isAnswered, propertyTables, UNANSWERED, } from "./query.js";
+/** The types of an iteration result's `value` that carry no element of the iterable. */
+const NO_ELEMENT = TypeFlags.AnyOrUnknown | TypeFlags.Undefined | TypeFlags.Void | TypeFlags.Null | TypeFlags.Never;
 /** The text a property name spells, or `undefined` for a computed name. */
 function nameText(node) {
     if (node === undefined) {
@@ -207,11 +209,84 @@ export function destructuring(project, cap, properties = propertyTables(project.
         const elements = queries.typeArguments(type);
         return isAnswered(elements) ? elements[0] : UNANSWERED;
     };
+    /** The type of the one property of a type that `matches` accepts, unanswered where two do. */
+    const propertyTypeOf = (owner, matches) => {
+        const table = tableOf(owner);
+        if (!isAnswered(table)) {
+            return UNANSWERED;
+        }
+        const [property, ...more] = [...table.values()].filter(matches);
+        if (property === undefined) {
+            return undefined;
+        }
+        if (more.length > 0) {
+            return UNANSWERED;
+        }
+        patternLookups += 1;
+        return queries.typeOfSymbol(property);
+    };
+    const resultOf = (callee) => {
+        if (callee === undefined || callee === UNANSWERED) {
+            return callee;
+        }
+        patternLookups += 1;
+        const signatures = queries.signaturesOf(callee, SignatureKind.Call);
+        if (!isAnswered(signatures)) {
+            return UNANSWERED;
+        }
+        const [signature] = signatures;
+        if (signature === undefined) {
+            return undefined;
+        }
+        patternLookups += 1;
+        return queries.returnTypeOf(signature);
+    };
+    const iterations = new Map();
+    /**
+     * The type a `for…of` takes from one iterable that is no array, read through the
+     * iteration protocol: the `value` of what the `next()` of its `[Symbol.iterator]()`
+     * answers. A constituent of that answer whose value is {@link NO_ELEMENT} carries no
+     * element; where more than one carries one, the element is left unanswered, so a read
+     * through it is resolved by name.
+     */
+    const iteratedOf = (type) => {
+        if (iterations.has(type.id)) {
+            return iterations.get(type.id);
+        }
+        // The checker keys a member a unique symbol names `__@<name>@<symbol id>`, and escapes
+        // a written key that starts with `__` with one more `_`, so no string key matches; a
+        // unique symbol of the program's own named `iterator` does, which leaves two matches:
+        // https://github.com/microsoft/typescript-go/blob/89d5d5b2849a0db0957065889ca58536fa6d2e4a/internal/checker/checker.go#L23096-L23108
+        // https://github.com/microsoft/typescript-go/blob/89d5d5b2849a0db0957065889ca58536fa6d2e4a/internal/ast/symbol.go#L91-L103
+        const iterator = resultOf(propertyTypeOf(type, (one) => one.escapedName.startsWith("__@iterator@")));
+        const result = iterator === undefined || iterator === UNANSWERED
+            ? iterator
+            : resultOf(propertyTypeOf(iterator, (one) => one.name === "next"));
+        let found = result;
+        if (result !== undefined && result !== UNANSWERED) {
+            let parts = [result];
+            if (result.isUnionType()) {
+                patternLookups += 1;
+                parts = queries.constituents(result);
+            }
+            const values = isAnswered(parts)
+                ? parts.map((part) => propertyTypeOf(part, (one) => one.name === "value"))
+                : [UNANSWERED];
+            const carried = values.filter((value) => value === UNANSWERED || (value !== undefined && (value.flags & NO_ELEMENT) === 0));
+            const [only, ...more] = carried;
+            found = more.length > 0 ? UNANSWERED : only;
+        }
+        iterations.set(type.id, found);
+        return found;
+    };
     const step = (type, next) => {
         const defined = definedOf(type);
         if (defined === undefined || defined === UNANSWERED) {
             return defined;
         }
+        if (next.kind === "iterated") {
+            return elementOf(defined, undefined) ?? iteratedOf(defined);
+        }
         if (next.kind === "property") {
             const table = tableOf(defined);
             if (!isAnswered(table)) {
@@ -224,7 +299,7 @@ export function destructuring(project, cap, properties = propertyTables(project.
             patternLookups += 1;
             return queries.typeOfSymbol(property);
         }
-        return elementOf(defined, next.kind === "element" ? next.index : undefined);
+        return elementOf(defined, next.index);
     };
     const resolve = (reads) => {
         const patterns = [...new Set(reads.map((read) => read.pattern))];