@geastack/compiler 1.0.15

package/dist/semantics/normalize/flow/callable-array-origins.d.ts

@@ -0,0 +1,42 @@
+import ts from 'typescript';
+import type { ValueFlowIndex } from './model.js';
+type CallableBody = ts.FunctionDeclaration | ts.FunctionExpression | ts.ArrowFunction;
+/** @semanticCategory generic-primitive */
+export interface ClosedCallableAuthority {
+    /** Complete callable contents of an authenticated array element. */
+    readonly arrayElementTargetsOf?: (element: ts.ElementAccessExpression) => readonly CallableBody[] | null;
+    /** Identity and mutation proof for an explicit Function.call/apply invocation. */
+    readonly explicitInvocationIsIntact?: (call: ts.CallExpression) => boolean;
+    /** Complete inbound frame, including defaults and writes; partial callers are not evidence. */
+    readonly parameterValuesOf: (parameter: ts.ParameterDeclaration) => readonly ts.Expression[] | null;
+    /** Complete receiver frame; null when a call can enter with an unaccounted receiver. */
+    readonly receiverValuesOf?: (callable: ts.SignatureDeclaration) => readonly ts.Expression[] | null;
+    /**
+     * The complete call-site set of a callable, or null when it is not closed.
+     * Only an EMPTY closed set makes a parameter with no inbound values vacuous;
+     * without this authority such a parameter refuses.
+     */
+    readonly closedCallerSitesOf?: (callable: ts.SignatureDeclaration) => readonly unknown[] | null;
+}
+/** @semanticCategory generic-primitive */
+export interface CallableArrayOriginAuthority extends ClosedCallableAuthority {
+    /** All values stored in the authenticated collection read by this call. */
+    readonly collectionValuesOf: (call: ts.CallExpression) => readonly ts.Expression[] | null;
+    /** All reads of an authenticated collection receiving this array value. */
+    readonly collectionReadsOf: (call: ts.CallExpression, value: ts.Expression) => readonly ts.Expression[] | null;
+    /** Intrinsic Array protocol and prototype integrity, authenticated outside this traversal. */
+    readonly arrayProtocolClosed: (array: ts.Expression) => boolean;
+}
+/**
+ * The complete set of source function bodies `expression` can denote, or
+ * null when it is not closed. Empty means the expression only ever holds
+ * `null`/`undefined`. See `closedCallableResolver` for the three.js shape.
+ */
+export declare const closedCallableTargetsOf: (checker: ts.TypeChecker, flow: ValueFlowIndex, expression: ts.Expression, authority: ClosedCallableAuthority) => readonly CallableBody[] | null;
+/** Complete source callable values reaching a numeric array callee. Local
+ * storage origins and uses come from the shared flow inventory. Collection,
+ * parameter-frame and intrinsic-protocol authorities remain explicit: their
+ * checker signatures alone cannot establish a closed runtime value set.
+ */
+export declare const callableArrayTargetsOf: (checker: ts.TypeChecker, flow: ValueFlowIndex, callee: ts.ElementAccessExpression, authority: CallableArrayOriginAuthority) => readonly CallableBody[] | null;
+export {};

package/dist/semantics/normalize/flow/callable-array-origins.js

@@ -0,0 +1,318 @@
+import ts from 'typescript';
+import { isVacuousOrigin, seededOriginSolver } from './seeded-origins.js';
+import { isModuleExportedDeclaration, isTypePositionReference, resolveFlowSymbolAlias, unwrapNaming } from './targets.js';
+const original = (expression) => {
+    let held = unwrapNaming(expression);
+    while (ts.isAsExpression(held) || ts.isTypeAssertionExpression(held) || ts.isSatisfiesExpression(held))
+        held = unwrapNaming(held.expression);
+    return held;
+};
+const appends = new WeakMap();
+const appendValuesAt = (flow, site) => {
+    let inventory = appends.get(flow);
+    if (!inventory) {
+        const collected = new Map();
+        for (const write of flow.allWrites) {
+            if (write.edge !== 'array-append' || !write.value)
+                continue;
+            let values = collected.get(write.site);
+            if (!values)
+                collected.set(write.site, (values = new Set()));
+            values.add(write.value);
+        }
+        inventory = collected;
+        appends.set(flow, inventory);
+    }
+    return inventory.get(site);
+};
+/**
+ * Every function body a callee expression can denote, resolved through the
+ * cells, parameters and operators that carry it. Vacuous origins (`null`,
+ * `undefined`) name no body and refuse nothing.
+ *
+ * The shape this exists for is three's `WebGLRenderList.sort`:
+ * `opaque.sort( customOpaqueSort || painterSortStable )`, reached from
+ * `currentRenderList.sort( _opaqueSort, ... )` where the renderer's `let
+ * _opaqueSort = null` is written only by `this.setOpaqueSort = function (
+ * method ) { _opaqueSort = method }`. With `setOpaqueSort`'s caller set closed
+ * and empty, `method` holds nothing, `_opaqueSort` holds only `null`, and the
+ * comparator is exactly `painterSortStable`.
+ */
+const closedCallableResolver = (checker, flow, authority, targets) => {
+    const origins = seededOriginSolver((value) => {
+        if (ts.isFunctionExpression(value) || ts.isArrowFunction(value)) {
+            targets.add(value);
+            return { seed: true, admitted: true, dependencies: [] };
+        }
+        if (isVacuousOrigin(flow, value))
+            return { seed: false, admitted: true, dependencies: [] };
+        if (ts.isElementAccessExpression(value)) {
+            const incoming = authority.arrayElementTargetsOf?.(value);
+            for (const target of incoming ?? [])
+                targets.add(target);
+            return { seed: (incoming?.length ?? 0) > 0, admitted: incoming !== null && incoming !== undefined, dependencies: [] };
+        }
+        let values = null;
+        if (ts.isConditionalExpression(value))
+            values = [value.whenTrue, value.whenFalse];
+        else if (ts.isBinaryExpression(value) &&
+            (value.operatorToken.kind === ts.SyntaxKind.BarBarToken || value.operatorToken.kind === ts.SyntaxKind.QuestionQuestionToken))
+            values = [value.left, value.right];
+        else if (ts.isIdentifier(value)) {
+            const shorthand = ts.isShorthandPropertyAssignment(value.parent) && value.parent.name === value;
+            const symbol = shorthand
+                ? checker.getShorthandAssignmentValueSymbol(value.parent)
+                : checker.getSymbolAtLocation(value);
+            const alias = symbol && (symbol.flags & ts.SymbolFlags.Alias) !== 0 ? resolveFlowSymbolAlias(checker, symbol)?.valueDeclaration : undefined;
+            const owner = alias ?? (shorthand ? symbol?.valueDeclaration : flow.targetOf(value)?.declaration);
+            if (owner && ts.isParameter(owner)) {
+                values = authority.parameterValuesOf(owner);
+                // No observed argument is not proof that this frame is unreachable.
+                if (values?.length === 0 && !(ts.isFunctionLike(owner.parent) && authority.closedCallerSitesOf?.(owner.parent)?.length === 0))
+                    values = null;
+            }
+            else if (owner && (ts.isFunctionDeclaration(owner) || ts.isVariableDeclaration(owner))) {
+                const writes = flow
+                    .writesToDeclaration(owner)
+                    .filter((write) => write.slot === 'whole' && write.edge !== 'return' && write.edge !== 'yield');
+                if (ts.isFunctionDeclaration(owner)) {
+                    if (owner.body && writes.length === 0) {
+                        targets.add(owner);
+                        return { seed: true, admitted: true, dependencies: [] };
+                    }
+                }
+                else if (writes.length > 0 &&
+                    writes.every((write) => (write.edge === 'declaration-initializer' || write.edge === 'identifier-assignment') && write.value !== null))
+                    values = writes.map((write) => write.value);
+            }
+        }
+        return { seed: false, admitted: values !== null, dependencies: (values ?? []).map(original) };
+    });
+    return (expression) => origins(original(expression)) !== 'refused';
+};
+/**
+ * The complete set of source function bodies `expression` can denote, or
+ * null when it is not closed. Empty means the expression only ever holds
+ * `null`/`undefined`. See `closedCallableResolver` for the three.js shape.
+ */
+export const closedCallableTargetsOf = (checker, flow, expression, authority) => {
+    const targets = new Set();
+    return closedCallableResolver(checker, flow, authority, targets)(expression) ? [...targets] : null;
+};
+/** Complete source callable values reaching a numeric array callee. Local
+ * storage origins and uses come from the shared flow inventory. Collection,
+ * parameter-frame and intrinsic-protocol authorities remain explicit: their
+ * checker signatures alone cannot establish a closed runtime value set.
+ */
+export const callableArrayTargetsOf = (checker, flow, callee, authority) => {
+    const targets = new Set();
+    const arrays = new Set();
+    const cells = new Set();
+    const uses = new Set();
+    let allocated = false;
+    const numeric = (expression) => {
+        const check = (type) => (type.isUnion() ? type.types.every(check) : (type.flags & ts.TypeFlags.NumberLike) !== 0);
+        return check(checker.getTypeAtLocation(expression));
+    };
+    const callable = closedCallableResolver(checker, flow, {
+        ...authority,
+        arrayElementTargetsOf: (element) => (numeric(element.argumentExpression) && array(element.expression) ? [...targets] : null)
+    }, targets);
+    const callableCells = new Set();
+    const callableUses = new Set();
+    const callableCell = (declaration) => {
+        if (callableCells.has(declaration))
+            return true;
+        if (isModuleExportedDeclaration(checker, declaration, checker.getSymbolAtLocation(declaration.name) ?? null))
+            return false;
+        callableCells.add(declaration);
+        const writes = flow.writesToDeclaration(declaration).filter((write) => write.slot === 'whole');
+        return (writes.length > 0 &&
+            writes.every((write) => (write.edge === 'declaration-initializer' || write.edge === 'identifier-assignment') &&
+                write.value !== null &&
+                callable(write.value)) &&
+            flow.referencesToDeclaration(declaration).every(callableUse));
+    };
+    // Reading a callable into a local cell does not change its identity. Close
+    // every write and continuation of that cell just as for the array itself.
+    const callableUse = (reference) => {
+        if (callableUses.has(reference))
+            return true;
+        callableUses.add(reference);
+        if (isTypePositionReference(reference))
+            return true;
+        const parent = reference.parent;
+        if (ts.isParenthesizedExpression(parent) ||
+            ts.isAsExpression(parent) ||
+            ts.isTypeAssertionExpression(parent) ||
+            ts.isNonNullExpression(parent) ||
+            ts.isSatisfiesExpression(parent))
+            return callableUse(parent);
+        if (ts.isVariableDeclaration(parent) && ts.isIdentifier(parent.name))
+            return parent.name === reference || (parent.initializer === reference && callableCell(parent));
+        if (ts.isCallExpression(parent) && parent.expression === reference)
+            return true;
+        if (ts.isPropertyAccessExpression(parent) &&
+            parent.expression === reference &&
+            ts.isCallExpression(parent.parent) &&
+            parent.parent.expression === parent)
+            return authority.explicitInvocationIsIntact?.(parent.parent) === true;
+        if (ts.isBinaryExpression(parent)) {
+            if (parent.operatorToken.kind === ts.SyntaxKind.EqualsToken) {
+                if (parent.left === reference)
+                    return ts.isExpressionStatement(parent.parent);
+                if (parent.right === reference && ts.isIdentifier(parent.left)) {
+                    const owner = flow.targetOf(parent.left)?.declaration;
+                    return !!owner && ts.isVariableDeclaration(owner) && callableCell(owner) && ts.isExpressionStatement(parent.parent);
+                }
+            }
+            if (parent.operatorToken.kind === ts.SyntaxKind.EqualsEqualsEqualsToken ||
+                parent.operatorToken.kind === ts.SyntaxKind.ExclamationEqualsEqualsToken)
+                return true;
+        }
+        return ts.isTypeOfExpression(parent) || (ts.isExpressionStatement(parent) && parent.expression === reference);
+    };
+    const cell = (declaration) => {
+        if (cells.has(declaration))
+            return true;
+        if (isModuleExportedDeclaration(checker, declaration, checker.getSymbolAtLocation(declaration.name) ?? null))
+            return false;
+        cells.add(declaration);
+        const writes = flow.writesToDeclaration(declaration).filter((write) => write.slot === 'whole');
+        return (writes.length > 0 &&
+            writes.every((write) => (write.edge === 'declaration-initializer' || write.edge === 'identifier-assignment') && write.value !== null && array(write.value)) &&
+            flow.referencesToDeclaration(declaration).every(use));
+    };
+    // Solve allocation provenance by components, separately from coinductive
+    // use closure. A map read and the cell stored into that map can form a
+    // seeded cycle. Every outgoing component still needs a complete origin;
+    // an unallocated cycle cannot borrow a different conditional's literal.
+    const origin = seededOriginSolver((value) => {
+        if (ts.isArrayLiteralExpression(value))
+            return { seed: true, admitted: true, dependencies: [] };
+        let values = null;
+        if (ts.isConditionalExpression(value))
+            values = [value.whenTrue, value.whenFalse];
+        else if (ts.isIdentifier(value)) {
+            const declaration = flow.targetOf(value)?.declaration;
+            if (declaration && ts.isVariableDeclaration(declaration)) {
+                const writes = flow.writesToDeclaration(declaration).filter((write) => write.slot === 'whole');
+                if (writes.length > 0 &&
+                    writes.every((write) => (write.edge === 'declaration-initializer' || write.edge === 'identifier-assignment') && write.value !== null))
+                    values = writes.map((write) => write.value);
+            }
+        }
+        else if (ts.isCallExpression(value)) {
+            if (ts.isPropertyAccessExpression(value.expression) && value.expression.name.text === 'slice')
+                values = [value.expression.expression];
+            else
+                values = authority.collectionValuesOf(value);
+        }
+        // No vacuous leaves exist here: an admitted non-seed always has an
+        // origin, so `allocated` is exactly the former valid-and-allocated rule.
+        return { seed: false, admitted: values !== null && values.length > 0, dependencies: (values ?? []).map(original) };
+    });
+    const origins = (expression) => origin(original(expression)) === 'allocated';
+    const array = (expression) => {
+        if (!origins(expression))
+            return false;
+        const value = original(expression);
+        if (arrays.has(value))
+            return true;
+        arrays.add(value);
+        if (ts.isArrayLiteralExpression(value)) {
+            if (!authority.arrayProtocolClosed(value))
+                return false;
+            allocated = true;
+            return (value.elements.every((element) => ts.isOmittedExpression(element) || (!ts.isSpreadElement(element) && callable(element))) &&
+                use(value));
+        }
+        if (ts.isConditionalExpression(value))
+            return array(value.whenTrue) && array(value.whenFalse);
+        if (ts.isIdentifier(value)) {
+            const owner = flow.targetOf(value)?.declaration;
+            return owner !== null && owner !== undefined && ts.isVariableDeclaration(owner) && cell(owner);
+        }
+        if (!ts.isCallExpression(value))
+            return false;
+        const method = value.expression;
+        if (ts.isPropertyAccessExpression(method) && method.name.text === 'slice') {
+            return (value.arguments.length <= 2 &&
+                value.arguments.every(numeric) &&
+                authority.arrayProtocolClosed(method.expression) &&
+                array(method.expression) &&
+                use(value));
+        }
+        const incoming = authority.collectionValuesOf(value);
+        return incoming !== null && incoming.length > 0 && incoming.every(array) && use(value);
+    };
+    const use = (reference) => {
+        if (uses.has(reference))
+            return true;
+        uses.add(reference);
+        const parent = reference.parent;
+        if (isTypePositionReference(reference))
+            return true;
+        if (ts.isParenthesizedExpression(parent) ||
+            ts.isAsExpression(parent) ||
+            ts.isTypeAssertionExpression(parent) ||
+            ts.isNonNullExpression(parent) ||
+            ts.isSatisfiesExpression(parent))
+            return use(parent);
+        if (ts.isVariableDeclaration(parent) && ts.isIdentifier(parent.name)) {
+            return parent.name === reference || (parent.initializer === reference && cell(parent));
+        }
+        if (ts.isBinaryExpression(parent) && parent.operatorToken.kind === ts.SyntaxKind.EqualsToken) {
+            if (parent.left === reference)
+                return ts.isExpressionStatement(parent.parent);
+            if (parent.right === reference && ts.isIdentifier(parent.left)) {
+                const owner = flow.targetOf(parent.left)?.declaration;
+                return (owner !== null && owner !== undefined && ts.isVariableDeclaration(owner) && cell(owner) && ts.isExpressionStatement(parent.parent));
+            }
+        }
+        if (ts.isElementAccessExpression(parent) && parent.expression === reference) {
+            if (!numeric(parent.argumentExpression) || !authority.arrayProtocolClosed(reference))
+                return false;
+            const context = parent.parent;
+            if (ts.isCallExpression(context) && context.expression === parent)
+                return true;
+            if (ts.isDeleteExpression(context))
+                return true;
+            if (ts.isBinaryExpression(context) && context.left === parent && context.operatorToken.kind === ts.SyntaxKind.EqualsToken)
+                return callable(context.right);
+            return callableUse(parent);
+        }
+        if (ts.isPropertyAccessExpression(parent) && parent.expression === reference) {
+            if (!authority.arrayProtocolClosed(reference))
+                return false;
+            const context = parent.parent;
+            if (parent.name.text === 'length') {
+                if (ts.isBinaryExpression(context) && context.left === parent)
+                    return context.operatorToken.kind === ts.SyntaxKind.EqualsToken && numeric(context.right);
+                return true;
+            }
+            if (!ts.isCallExpression(context) || context.expression !== parent || context.arguments.some(ts.isSpreadElement))
+                return false;
+            if (parent.name.text === 'slice')
+                return array(context);
+            if (parent.name.text === 'push' || parent.name.text === 'unshift') {
+                return context.arguments.every((argument) => appendValuesAt(flow, context)?.has(argument) === true && callable(argument));
+            }
+            if (parent.name.text === 'indexOf' || parent.name.text === 'includes')
+                return context.arguments.length <= 2 && (context.arguments.length < 2 || numeric(context.arguments[1]));
+            if (parent.name.text === 'splice')
+                return context.arguments.length <= 2 && context.arguments.every(numeric) && ts.isExpressionStatement(context.parent);
+            return false;
+        }
+        if (ts.isCallExpression(parent)) {
+            const reads = authority.collectionReadsOf(parent, reference);
+            return reads !== null && reads.every((read) => array(read));
+        }
+        if (ts.isBinaryExpression(parent) &&
+            (parent.operatorToken.kind === ts.SyntaxKind.EqualsEqualsEqualsToken ||
+                parent.operatorToken.kind === ts.SyntaxKind.ExclamationEqualsEqualsToken))
+            return true;
+        return ts.isTypeOfExpression(parent) || (ts.isExpressionStatement(parent) && parent.expression === reference);
+    };
+    return numeric(callee.argumentExpression) && array(callee.expression) && allocated && targets.size > 0 ? [...targets] : null;
+};

package/dist/semantics/normalize/flow/callable-completions.d.ts

@@ -0,0 +1,45 @@
+import ts from 'typescript';
+import type { ValueFlowIndex } from './model.js';
+export type CallableExecution = 'sync' | 'async' | 'generator' | 'async-generator';
+/** The source-level completion inventory, before a consumer applies its policy. */
+export interface CallableCompletionSummary {
+    /** Whether a plain call returns directly, or instead returns a Promise/iterator wrapper. */
+    readonly execution: CallableExecution;
+    /** Explicit `return expr` values, retained even when another path returns undefined. */
+    readonly values: readonly ts.Expression[];
+    /** Explicit `yield expr` values, separate from a generator's return completion. */
+    readonly yields: readonly ts.Expression[];
+    /** A bare return or a possible fallthrough contributes an implicit undefined completion. */
+    readonly mayCompleteUndefined: boolean;
+    /** Conservative block-body result from the existing return-path summary. */
+    readonly mayFallThrough: boolean;
+}
+/**
+ * The callable's syntactic completion inventory, or null when it has no
+ * executable source body. Return and yield expressions come from the shared
+ * value-flow write inventory; only the existing conservative fallthrough
+ * summary is consulted here.
+ */
+export declare const callableCompletionSummaryOf: (flow: ValueFlowIndex, target: ts.SignatureDeclaration | ts.JSDocSignature) => CallableCompletionSummary | null;
+/**
+ * Direct values from a synchronous call, or null when it may complete with
+ * undefined, has no named value completion, or returns a Promise/iterator.
+ * Construction applies the separate fresh-this policy below.
+ */
+export declare const callableCompletionValuesOf: (flow: ValueFlowIndex, target: ts.SignatureDeclaration | ts.JSDocSignature) => readonly ts.Expression[] | null;
+/**
+ * Whether `new target( ... )` yields exactly one of `target`'s completion
+ * values, and nothing else.
+ *
+ * `new` allocates `this` first and discards it only when the function
+ * returns an object. A completion that is not one -- `return null`,
+ * `return 1`, a bare `return`, falling off the end -- yields the fresh
+ * `this` instead, an allocation no origin plan enumerates. So every
+ * completion must be syntactically object-producing: an object literal, or
+ * another construction (which `new` always makes an object and whose own
+ * origin is proven the same way). And `this` must not be mentioned at all: a
+ * constructor writing `this.x` is building a second object beside the one it
+ * returns. Three's `new WebGLRenderLists()` returns one literal and never
+ * mentions `this`.
+ */
+export declare const constructionYieldsCompletionOf: (flow: ValueFlowIndex, target: ts.FunctionDeclaration) => boolean;

package/dist/semantics/normalize/flow/callable-completions.js

@@ -0,0 +1,82 @@
+import ts from 'typescript';
+import { unwrapErasedExpression } from '../producers/erasure.js';
+import { definitelyReturns } from '../return-paths.js';
+const summaries = new WeakMap();
+const callableBodyOf = (target) => ts.isFunctionLike(target) && 'body' in target ? target.body : undefined;
+/**
+ * The callable's syntactic completion inventory, or null when it has no
+ * executable source body. Return and yield expressions come from the shared
+ * value-flow write inventory; only the existing conservative fallthrough
+ * summary is consulted here.
+ */
+export const callableCompletionSummaryOf = (flow, target) => {
+    let byTarget = summaries.get(flow);
+    if (!byTarget)
+        summaries.set(flow, (byTarget = new WeakMap()));
+    if (byTarget.has(target))
+        return byTarget.get(target) ?? null;
+    // The shared write/receiver inventory only describes the portions of the
+    // source tree that the reachability pass admitted. A body pruned there can
+    // still exist on the TypeScript node, but its empty or partial write set is
+    // not a complete completion summary.
+    if (!flow.callableBodyIsIndexed(target)) {
+        byTarget.set(target, null);
+        return null;
+    }
+    const body = callableBodyOf(target);
+    if (!body) {
+        byTarget.set(target, null);
+        return null;
+    }
+    const modifiers = ts.canHaveModifiers(target) ? ts.getModifiers(target) : undefined;
+    const async = modifiers?.some((modifier) => modifier.kind === ts.SyntaxKind.AsyncKeyword) ?? false;
+    const generator = 'asteriskToken' in target && target.asteriskToken !== undefined;
+    const execution = async ? (generator ? 'async-generator' : 'async') : generator ? 'generator' : 'sync';
+    const writes = flow.writesToDeclaration(target);
+    const returnWrites = writes.filter((write) => write.edge === 'return');
+    const values = ts.isBlock(body)
+        ? returnWrites.flatMap((write) => (write.value ? [unwrapErasedExpression(write.value)] : []))
+        : [unwrapErasedExpression(body)];
+    const yields = writes.flatMap((write) => (write.edge === 'yield' && write.value ? [unwrapErasedExpression(write.value)] : []));
+    const hasBareReturn = returnWrites.some((write) => write.value === null);
+    const mayFallThrough = ts.isBlock(body) && !definitelyReturns(body.statements);
+    const summary = {
+        execution,
+        values,
+        yields,
+        mayCompleteUndefined: hasBareReturn || mayFallThrough,
+        mayFallThrough
+    };
+    byTarget.set(target, summary);
+    return summary;
+};
+/**
+ * Direct values from a synchronous call, or null when it may complete with
+ * undefined, has no named value completion, or returns a Promise/iterator.
+ * Construction applies the separate fresh-this policy below.
+ */
+export const callableCompletionValuesOf = (flow, target) => {
+    const summary = callableCompletionSummaryOf(flow, target);
+    return summary && summary.execution === 'sync' && !summary.mayCompleteUndefined && summary.values.length > 0 ? summary.values : null;
+};
+/**
+ * Whether `new target( ... )` yields exactly one of `target`'s completion
+ * values, and nothing else.
+ *
+ * `new` allocates `this` first and discards it only when the function
+ * returns an object. A completion that is not one -- `return null`,
+ * `return 1`, a bare `return`, falling off the end -- yields the fresh
+ * `this` instead, an allocation no origin plan enumerates. So every
+ * completion must be syntactically object-producing: an object literal, or
+ * another construction (which `new` always makes an object and whose own
+ * origin is proven the same way). And `this` must not be mentioned at all: a
+ * constructor writing `this.x` is building a second object beside the one it
+ * returns. Three's `new WebGLRenderLists()` returns one literal and never
+ * mentions `this`.
+ */
+export const constructionYieldsCompletionOf = (flow, target) => {
+    if (flow.receiverReferencesToDeclaration(target).length > 0)
+        return false;
+    const values = callableCompletionValuesOf(flow, target);
+    return values !== null && values.every((value) => ts.isObjectLiteralExpression(value) || ts.isNewExpression(value));
+};