@cplieger/deadset-ts 3.13.0 → 4.0.1

package/dist/src/calls.js

@@ -8,7 +8,7 @@
 import { isArrayLiteralExpression, isCallExpression, isClassDeclaration, isDecorator, isIdentifier, isObjectLiteralExpression, isParenthesizedExpression, isPropertyAccessExpression, isPropertyAssignment, isShorthandPropertyAssignment, isSpreadElement, } from "@typescript/native/unstable/ast";
 import { SymbolFlags } from "@typescript/native/unstable/sync";
 import { nodeKey } from "./inventory.js";
-import { DEFAULT_BATCH_CAP } from "./references.js";
+import { must } from "./query.js";
 /** The name node a callee or a decorator expression resolves through, where it has one. */
 export function calleeName(expression) {
     if (isParenthesizedExpression(expression)) {
@@ -37,31 +37,32 @@ export function decoratorsOf(node) {
 /**
  * What each of a batch of nodes resolves to, every alias followed to the declaration
  * it stands for. A node the checker resolves to nothing, and an alias that resolves
- * to nothing, are absent from the answer. Each alias is followed once.
+ * to nothing, are absent from the answer. Each alias is followed once. A question the
+ * checker does not answer stops the pass, as {@link must} stops.
  */
 export function resolvedTargets(project, nodes) {
     const followed = new Map();
     const targets = new Map();
-    for (let from = 0; from < nodes.length; from += DEFAULT_BATCH_CAP) {
-        const run = nodes.slice(from, from + DEFAULT_BATCH_CAP);
-        project.symbolsAt(run.map((node) => project.handle(node))).forEach((symbol, index) => {
-            const node = run[index];
-            if (symbol === undefined || node === undefined) {
-                return;
-            }
-            let target = symbol;
-            if ((symbol.flags & SymbolFlags.Alias) !== 0) {
-                if (!followed.has(symbol.id)) {
-                    const aliased = project.checker.getAliasedSymbol(symbol);
-                    followed.set(symbol.id, aliased.declarations.length === 0 ? undefined : aliased);
-                }
-                target = followed.get(symbol.id);
-            }
-            if (target !== undefined) {
-                targets.set(node, target);
+    project
+        .symbolsAt(nodes.map((node) => project.handle(node)))
+        .map(must)
+        .forEach((symbol, index) => {
+        const node = nodes[index];
+        if (symbol === undefined || node === undefined) {
+            return;
+        }
+        let target = symbol;
+        if ((symbol.flags & SymbolFlags.Alias) !== 0) {
+            if (!followed.has(symbol.id)) {
+                const aliased = must(project.queries.aliased(symbol));
+                followed.set(symbol.id, aliased.declarations.length === 0 ? undefined : aliased);
             }
-        });
-    }
+            target = followed.get(symbol.id);
+        }
+        if (target !== undefined) {
+            targets.set(node, target);
+        }
+    });
     return targets;
 }
 /** The values one expression passes: itself, or what an array or object literal holds. */
@@ -109,7 +110,7 @@ export function classesPassed(project, held, chains, calls) {
     const classes = new Set(held.symbols.filter((symbol) => symbol.kind === "class").map((symbol) => symbol.id));
     const classesOf = (value) => {
         const symbol = value.shorthand
-            ? project.shorthandValueAt(project.handle(value.name))
+            ? must(project.shorthandValueAt(project.handle(value.name)))
             : targets.get(value.name);
         return symbol === undefined
             ? []

package/dist/src/class-members.js

@@ -5,7 +5,7 @@
  */
 import { isClassDeclaration, isClassExpression } from "@typescript/native/unstable/ast";
 import { nodeKey } from "./inventory.js";
-import { DEFAULT_BATCH_CAP } from "./references.js";
+import { must } from "./query.js";
 /** The name node of each class declaration of the target, by the class's identifier. */
 export function classNames(project, held) {
     const names = new Map();
@@ -23,13 +23,12 @@ export function classNames(project, held) {
     }
     return names;
 }
-/** The types of a batch of nodes, asked in capped batches. */
+/**
+ * The types of a batch of nodes, for a pass that cannot go on past a type the checker
+ * did not answer: it stops there, as {@link must} stops.
+ */
 export function typesAt(project, nodes) {
-    const types = [];
-    for (let from = 0; from < nodes.length; from += DEFAULT_BATCH_CAP) {
-        types.push(...project.checker.getTypeAtLocation(nodes.slice(from, from + DEFAULT_BATCH_CAP)));
-    }
-    return types;
+    return project.queries.typesAt(nodes).map(must);
 }
 /**
  * The type one side of each class is: the instance type at the class's name, or the
@@ -39,9 +38,9 @@ function sideTypes(project, nodes, side) {
     if (side === "instance") {
         return typesAt(project, nodes);
     }
-    const symbols = project.symbolsAt(nodes.map((node) => project.handle(node)));
+    const symbols = project.symbolsAt(nodes.map((node) => project.handle(node))).map(must);
     const present = symbols.filter((symbol) => symbol !== undefined);
-    const types = present.length === 0 ? [] : project.checker.getTypeOfSymbol(present);
+    const types = project.queries.typesOfSymbols(present).map(must);
     let next = 0;
     return symbols.map((symbol) => (symbol === undefined ? undefined : types[next++]));
 }
@@ -52,7 +51,7 @@ function sideTypes(project, nodes, side) {
  */
 export function classMembers(project, held, classIds, side) {
     const named = [...classNames(project, held)].filter(([id]) => classIds.has(id));
-    const own = new Set(project.ownSourceFiles().map((file) => file.fileName));
+    const own = project.ownPaths();
     const types = sideTypes(project, named.map(([, node]) => node), side);
     const members = new Map();
     named.forEach(([id], index) => {
@@ -61,7 +60,7 @@ export function classMembers(project, held, classIds, side) {
             return;
         }
         const found = [];
-        for (const property of project.checker.getPropertiesOfType(type)) {
+        for (const property of must(project.queries.propertiesOf(type))) {
             for (const handle of property.declarations) {
                 if (!own.has(handle.path)) {
                     continue;

package/dist/src/configured-declarations.js

@@ -7,6 +7,7 @@
 import { isCallExpression, isExportDeclaration, isExternalModuleReference, isImportDeclaration, isImportEqualsDeclaration, isNoSubstitutionTemplateLiteral, isStringLiteral, SyntaxKind, } from "@typescript/native/unstable/ast";
 import { SymbolFlags, } from "@typescript/native/unstable/sync";
 import { resolvedTargets } from "./calls.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. */
 const ANY_MEANING = SymbolFlags.Value | SymbolFlags.Type | SymbolFlags.Namespace;
@@ -55,7 +56,7 @@ function unaliased(project, symbol) {
     if ((symbol.flags & SymbolFlags.Alias) === 0) {
         return symbol;
     }
-    const target = project.checker.getAliasedSymbol(symbol);
+    const target = must(project.queries.aliased(symbol));
     return target.declarations.length === 0 ? undefined : target;
 }
 /** Whether one symbol is a member a class declares: a property, a method or an accessor. */
@@ -68,20 +69,20 @@ function isClassMember(symbol) {
  * with the static suffix names one of the first and a component without it names an
  * instance member or one of the second.
  */
-function candidatesOf(container, isStatic) {
-    const exported = [...container.getExports().values()];
+function candidatesOf(project, container, isStatic) {
+    const exported = [...must(project.queries.exportsOf(container)).values()];
     if (isStatic) {
         return exported.filter(isClassMember);
     }
     const isClass = (container.flags & SymbolFlags.Class) !== 0;
     return [
-        ...container.getMembers().values(),
+        ...must(project.queries.membersOf(container)).values(),
         ...exported.filter((member) => !isClass || !isClassMember(member)),
     ];
 }
 /** The member of one container a path component spells, followed through any alias. */
 function memberOf(project, container, component, isStatic) {
-    const member = candidatesOf(container, isStatic).find((candidate) => nameComponent(candidate.name) === component);
+    const member = candidatesOf(project, container, isStatic).find((candidate) => nameComponent(candidate.name) === component);
     return member === undefined ? undefined : unaliased(project, member);
 }
 /** The declaration a path names from one starting symbol, component by component. */
@@ -131,7 +132,7 @@ function modulesNamed(project, specifiers) {
         file.forEachChild(visit);
     }
     const specified = [...written];
-    const symbols = project.symbolsAt(specified.map(([, node]) => project.handle(node)));
+    const symbols = project.symbolsAt(specified.map(([, node]) => project.handle(node))).map(must);
     const modules = new Map();
     specified.forEach(([name], index) => {
         const symbol = symbols[index];
@@ -171,7 +172,7 @@ export function resolveEntries(project, held, entries) {
             start = module === undefined ? undefined : memberOf(project, module, first, false);
         }
         else if (nameComponent(first) === first) {
-            const global = project.checker.resolveName(first, ANY_MEANING, undefined, false);
+            const global = must(project.queries.resolveName(first, ANY_MEANING, undefined, false));
             start = global === undefined ? undefined : unaliased(project, global);
         }
         const declared = walkPath(project, start, rest, isStatic);
@@ -247,9 +248,21 @@ export function configuredDeclarations(config) {
         ...config.ts.serializers.map((entry) => ({ key: "ts.serializers", entry })),
     ];
 }
-/** Whether each configured entry names a declaration in one project, in the entries' order. */
+/**
+ * Whether each configured entry names a declaration in one project, in the entries'
+ * order. Where the checker leaves a question of the resolution unanswered, every entry
+ * counts as naming one, so no entry is reported as naming nothing on a gap.
+ */
 export function declarationsNamed(project, held, configured) {
-    return resolveEntries(project, held, configured.map((one) => one.entry)).map(namesADeclaration);
+    try {
+        return resolveEntries(project, held, configured.map((one) => one.entry)).map(namesADeclaration);
+    }
+    catch (error) {
+        if (!(error instanceof Unanswerable)) {
+            throw error;
+        }
+        return configured.map(() => true);
+    }
 }
 /**
  * The reference a finding about a configured entry names it by, the entry as the

package/dist/src/dependencies.js

@@ -8,7 +8,7 @@
 import { isExportDeclaration, isExternalModuleReference, isIdentifier, isImportDeclaration, isImportEqualsDeclaration, isNamespaceExport, isShorthandPropertyAssignment, isStringLiteral, isNoSubstitutionTemplateLiteral, SyntaxKind, } from "@typescript/native/unstable/ast";
 import { nodeKey, packageScope } from "./inventory.js";
 import { dirnamePath, isAbsolutePath, joinPath, resolvePath } from "./paths.js";
-import { DEFAULT_BATCH_CAP } from "./references.js";
+import { UNANSWERED } from "./query.js";
 const MANIFEST = "package.json";
 const MODULES_DIR = "node_modules";
 const MODULES_SEGMENT = `/${MODULES_DIR}/`;
@@ -207,10 +207,11 @@ export function projectNeeds(project, held, host) {
         }
     };
     use([PROJECT_OWNER], packages);
+    let unanswered = false;
     for (const file of project.ownSourceFiles()) {
-        fileNeeds(project, held, file, programPackages, use);
+        unanswered = fileNeeds(project, held, file, programPackages, use) || unanswered;
     }
-    return { packages, uses };
+    return { packages, uses, unanswered };
 }
 /** The declarations of the inventory a use written at one node belongs to. */
 function ownersOf(file, held, node) {
@@ -235,6 +236,7 @@ function ownersOf(file, held, node) {
     }
     return [PROJECT_OWNER];
 }
+/** Records the needs of one file, and answers whether a specifier of it went unanswered. */
 function fileNeeds(project, held, file, programPackages, use) {
     const specifiers = [...file.imports, ...file.moduleAugmentations].filter(isLiteralText);
     const bindings = [];
@@ -262,13 +264,8 @@ function fileNeeds(project, held, file, programPackages, use) {
         visit(file);
     }
     const asked = [...specifiers, ...bindings.map(({ node }) => node), ...candidates];
-    const resolved = [];
-    for (let at = 0; at < asked.length; at += DEFAULT_BATCH_CAP) {
-        const handles = asked
-            .slice(at, at + DEFAULT_BATCH_CAP)
-            .map((node) => project.handle(node));
-        resolved.push(...project.symbolsAt(handles));
-    }
+    const handles = asked.map((node) => project.handle(node));
+    const resolved = project.symbolsAt(handles);
     const packagesOf = new Map();
     specifiers.forEach((specifier, index) => {
         const named = new Set();
@@ -276,7 +273,8 @@ function fileNeeds(project, held, file, programPackages, use) {
         if (byName !== undefined) {
             named.add(byName);
         }
-        for (const declaration of resolved[index]?.declarations ?? []) {
+        const symbol = resolved[index];
+        for (const declaration of typeof symbol === "object" ? symbol.declarations : []) {
             const byPath = packageOfPath(declaration.path);
             if (byPath !== undefined) {
                 named.add(byPath);
@@ -284,11 +282,20 @@ function fileNeeds(project, held, file, programPackages, use) {
         }
         packagesOf.set(specifier, [...named]);
     });
+    // A name the checker could not resolve counts as a use of every package a binding of
+    // that name brings in, so a gap never makes a dependency read as unused.
     const bySymbol = new Map();
-    bindings.forEach(({ specifier }, index) => {
+    const byName = new Map();
+    const unresolvedNames = new Set();
+    bindings.forEach(({ node, specifier }, index) => {
+        const packages = packagesOf.get(specifier) ?? [];
+        byName.set(node.text, [...(byName.get(node.text) ?? []), ...packages]);
         const symbol = resolved[specifiers.length + index];
-        if (symbol !== undefined) {
-            bySymbol.set(symbol.id, packagesOf.get(specifier) ?? []);
+        if (symbol === UNANSWERED) {
+            unresolvedNames.add(node.text);
+        }
+        else if (symbol !== undefined) {
+            bySymbol.set(symbol.id, packages);
         }
     });
     for (const specifier of specifiers) {
@@ -304,7 +311,12 @@ function fileNeeds(project, held, file, programPackages, use) {
         if (parent !== undefined && isShorthandPropertyAssignment(parent) && parent.name === node) {
             symbol = project.shorthandValueAt(project.handle(node));
         }
-        const named = symbol === undefined ? undefined : bySymbol.get(symbol.id);
+        const named = symbol === UNANSWERED || (unresolvedNames.has(node.text) && symbol === undefined)
+            ? byName.get(node.text)
+            : symbol === undefined
+                ? undefined
+                : (bySymbol.get(symbol.id) ??
+                    (unresolvedNames.has(node.text) ? byName.get(node.text) : undefined));
         if (named !== undefined) {
             use(ownersOf(file, held, node), named);
         }
@@ -312,6 +324,7 @@ function fileNeeds(project, held, file, programPackages, use) {
     for (const reference of file.typeReferenceDirectives) {
         use(ownersOf(file, held, file), typePackages(reference.fileName, programPackages));
     }
+    return resolved.slice(0, specifiers.length).includes(UNANSWERED);
 }
 /** The offset just past the JSON value that starts at `at` in text the parser has accepted. */
 function valueEnd(text, at) {
@@ -470,12 +483,16 @@ export function dependenciesOf(host, targetRoot, perProject, candidates) {
     const needed = new Set();
     const uses = new Map();
     for (const project of perProject) {
-        project.packages.forEach((one) => needed.add(one));
-        for (const [id, used] of project.uses) {
+        // A specifier the checker left unanswered may resolve to any declared dependency,
+        // and what the configuration needs is never deleted, so it is needed there.
+        const unknown = project.unanswered ? declared.map((dependency) => dependency.name) : [];
+        const held = unknown.length === 0 ? [] : [[PROJECT_OWNER, new Set(unknown)]];
+        for (const [id, used] of [...project.uses, ...held]) {
             const merged = uses.get(id) ?? new Set();
             used.forEach((one) => merged.add(one));
             uses.set(id, merged);
         }
+        [...project.packages, ...unknown].forEach((one) => needed.add(one));
     }
     const users = new Map();
     for (const used of uses.values()) {

package/dist/src/deprecation.js

@@ -8,7 +8,7 @@
  */
 import { isVariableStatement, SyntaxKind } from "@typescript/native/unstable/ast";
 import { nodeKey } from "./inventory.js";
-import { DEFAULT_BATCH_CAP } from "./references.js";
+import { isAnswered, UNANSWERED } from "./query.js";
 /** The tag the TypeScript tools recognize as marking a declaration deprecated. */
 const DEPRECATED_TAG = "deprecated";
 /** Whether one node's own documentation carries the deprecation tag. */
@@ -21,15 +21,15 @@ function nameNode(node) {
     return node.name ?? node;
 }
 /**
- * The identifiers of every declaration of one project that carries the deprecation
- * marker, in the inventory's order.
+ * The declarations of one project that carry the deprecation marker.
  *
  * The checker is asked only for a symbol with a declaration in a file whose tree holds
  * the tag, so a project whose files hold none costs no round trip, and one that does
- * costs one batch per file and one request per symbol that could carry the tag.
+ * costs one batch per file and one for the tags of the symbols that could carry it.
  */
 export function deprecatedDeclarations(project, held) {
     const marked = new Set();
+    const unknown = new Set();
     const markedPaths = new Set();
     const declared = [];
     for (const file of project.ownSourceFiles()) {
@@ -56,28 +56,39 @@ export function deprecatedDeclarations(project, held) {
         declared.push(named);
     }
     if (markedPaths.size > 0) {
-        const asked = new Map();
-        const carriesTag = (symbol) => {
-            const known = asked.get(symbol.id);
-            if (known !== undefined) {
-                return known;
+        const pairs = declared.flatMap((named) => {
+            const symbols = project.symbolsAt(named.map((one) => one.handle));
+            return named.flatMap((one, at) => {
+                const symbol = symbols[at];
+                if (symbol === UNANSWERED) {
+                    unknown.add(one.id);
+                }
+                return typeof symbol === "object" &&
+                    symbol.declarations.some((declaration) => markedPaths.has(declaration.path))
+                    ? [{ id: one.id, symbol }]
+                    : [];
+            });
+        });
+        const distinct = [...new Map(pairs.map((one) => [one.symbol.id, one.symbol])).values()];
+        const tags = project.queries.jsDocTags(distinct);
+        const unread = new Set(distinct.filter((_, at) => tags[at] === UNANSWERED).map((one) => one.id));
+        const carries = new Set(distinct.flatMap((symbol, at) => {
+            const read = tags[at];
+            return read !== undefined &&
+                isAnswered(read) &&
+                read.some((tag) => tag.name === DEPRECATED_TAG)
+                ? [symbol.id]
+                : [];
+        }));
+        for (const one of pairs) {
+            if (carries.has(one.symbol.id)) {
+                marked.add(one.id);
             }
-            const carries = symbol.declarations.some((declaration) => markedPaths.has(declaration.path)) &&
-                symbol.getJsDocTags(project.checker).some((tag) => tag.name === DEPRECATED_TAG);
-            asked.set(symbol.id, carries);
-            return carries;
-        };
-        for (const named of declared) {
-            for (let start = 0; start < named.length; start += DEFAULT_BATCH_CAP) {
-                const batch = named.slice(start, start + DEFAULT_BATCH_CAP);
-                project.symbolsAt(batch.map((one) => one.handle)).forEach((symbol, at) => {
-                    const one = batch[at];
-                    if (symbol !== undefined && one !== undefined && carriesTag(symbol)) {
-                        marked.add(one.id);
-                    }
-                });
+            if (unread.has(one.symbol.id)) {
+                unknown.add(one.id);
             }
         }
     }
-    return held.symbols.filter((symbol) => marked.has(symbol.id)).map((symbol) => symbol.id);
+    const inOrder = (ids) => held.symbols.filter((symbol) => ids.has(symbol.id)).map((symbol) => symbol.id);
+    return { deprecated: inOrder(marked), unanswered: inOrder(unknown) };
 }

package/dist/src/destructuring.js

@@ -7,6 +7,7 @@
  */
 import { isArrayLiteralExpression, isBinaryExpression, isForOfStatement, isIdentifier, isNoSubstitutionTemplateLiteral, isNumericLiteral, isObjectBindingPattern, isObjectLiteralExpression, isParameterDeclaration, isParenthesizedExpression, isPropertyAssignment, isShorthandPropertyAssignment, isStringLiteral, SyntaxKind, } from "@typescript/native/unstable/ast";
 import { TypeFlags } from "@typescript/native/unstable/sync";
+import { isAnswered, UNANSWERED } from "./query.js";
 /** The text a property name spells, or `undefined` for a computed name. */
 function nameText(node) {
     if (node === undefined) {
@@ -151,29 +152,22 @@ function sourceOf(target) {
  * places and a table answers every name of it.
  */
 export function destructuring(project, cap) {
-    const checker = project.checker;
+    const queries = project.queries;
     const tables = new Map();
     let patternBatches = 0;
     let patternLookups = 0;
-    const typesAt = (nodes) => {
-        const types = [];
-        for (let from = 0; from < nodes.length; from += cap) {
-            types.push(...checker.getTypeAtLocation(nodes.slice(from, from + cap)));
-            patternBatches += 1;
-        }
-        return types;
-    };
     const tableOf = (type) => {
         const known = tables.get(type.id);
         if (known !== undefined) {
             return known;
         }
-        const table = new Map();
+        let table = new Map();
         if ((type.flags & TypeFlags.AnyOrUnknown) === 0) {
             patternLookups += 1;
-            for (const property of checker.getPropertiesOfType(type)) {
-                table.set(property.name, property);
-            }
+            const properties = queries.propertiesOf(type);
+            table = isAnswered(properties)
+                ? new Map(properties.map((property) => [property.name, property]))
+                : UNANSWERED;
         }
         tables.set(type.id, table);
         return table;
@@ -183,7 +177,7 @@ export function destructuring(project, cap) {
             return type;
         }
         patternLookups += 1;
-        return checker.getNonNullableType(type);
+        return queries.nonNullable(type);
     };
     /**
      * The type one element of an array or tuple value has: a tuple's element at `index`,
@@ -193,33 +187,42 @@ export function destructuring(project, cap) {
         if (!type.isTypeReference()) {
             return undefined;
         }
-        patternLookups += 1;
-        if (checker.isTupleType(type)) {
+        if (type.isTupleType()) {
             if (index === undefined) {
                 return undefined;
             }
             patternLookups += 1;
-            return checker.getTypeArguments(type)[index];
+            const elements = queries.typeArguments(type);
+            return isAnswered(elements) ? elements[index] : UNANSWERED;
         }
         patternLookups += 1;
-        if (!checker.isArrayType(type)) {
+        const array = queries.isArray(type);
+        if (!isAnswered(array)) {
+            return UNANSWERED;
+        }
+        if (!array) {
             return undefined;
         }
         patternLookups += 1;
-        return checker.getTypeArguments(type)[0];
+        const elements = queries.typeArguments(type);
+        return isAnswered(elements) ? elements[0] : UNANSWERED;
     };
     const step = (type, next) => {
         const defined = definedOf(type);
-        if (defined === undefined) {
-            return undefined;
+        if (defined === undefined || defined === UNANSWERED) {
+            return defined;
         }
         if (next.kind === "property") {
-            const property = tableOf(defined).get(next.name);
+            const table = tableOf(defined);
+            if (!isAnswered(table)) {
+                return UNANSWERED;
+            }
+            const property = table.get(next.name);
             if (property === undefined) {
                 return undefined;
             }
             patternLookups += 1;
-            return checker.getTypeOfSymbol(property);
+            return queries.typeOfSymbol(property);
         }
         return elementOf(defined, next.kind === "element" ? next.index : undefined);
     };
@@ -238,11 +241,12 @@ export function destructuring(project, cap) {
                 asking.add(source.expression);
             }
         }
-        const answered = new Map();
         const asked = [...asking];
-        typesAt(asked).forEach((type, index) => {
+        patternBatches += Math.ceil(asked.length / cap);
+        const answered = new Map();
+        queries.typesAt(asked, cap).forEach((type, index) => {
             const node = asked[index];
-            if (type !== undefined && node !== undefined) {
+            if (node !== undefined) {
                 answered.set(node, type);
             }
         });
@@ -255,13 +259,17 @@ export function destructuring(project, cap) {
             }
             let type = answered.get(source.expression);
             for (const next of source.steps) {
-                type = type === undefined ? undefined : step(type, next);
+                type = type === undefined || type === UNANSWERED ? type : step(type, next);
             }
-            patternTypes.set(pattern, type === undefined ? undefined : definedOf(type));
+            patternTypes.set(pattern, type === undefined || type === UNANSWERED ? type : definedOf(type));
         }
         return reads.map((read) => {
             const type = patternTypes.get(read.pattern);
-            return type === undefined ? undefined : tableOf(type).get(read.name);
+            if (type === undefined || type === UNANSWERED) {
+                return type;
+            }
+            const table = tableOf(type);
+            return isAnswered(table) ? table.get(read.name) : UNANSWERED;
         });
     };
     return {