@scriptc/compiler 0.4.5 → 0.4.6

package/dist/frontend/lowering/class-protocols.js

@@ -14,6 +14,11 @@ export class ClassProtocols {
     /** The value types of the string-keyed dictionaries that keep checked
      * identity (see markDictionaryViews). */
     dictionaryViews = new Set();
+    /** The structural types a lib Map or Set flows into while it answers one
+     * of their members (see markIdentityFlows). They keep checked identity
+     * without protocol dispatch: their members are invoked on the collection
+     * itself, not read from a property bag. */
+    collectionViews = new Set();
     constructor(checker, sources) {
         this.checker = checker;
         this.sources = sources;
@@ -33,7 +38,20 @@ export class ClassProtocols {
                 this.checker.getBaseTypes(target).forEach(add);
         };
         const usesReceiver = (node) => node.kind === ts.SyntaxKind.ThisKeyword || ts.forEachChild(node, usesReceiver) === true;
+        // The names any type in the program declares as a get/set accessor, and
+        // every object literal in it. A data member of a literal can only
+        // disagree with a target at a name in this set, and marking waits until
+        // the walk ends, so the checker round trip stays off every literal whose
+        // names are not accessors somewhere (this analysis runs on every
+        // program, so it must stay syntax-cheap).
+        const accessorNames = new Set();
+        const literals = [];
         const visit = (node) => {
+            if (ts.isGetAccessorDeclaration(node) || ts.isSetAccessorDeclaration(node)) {
+                const name = propertyNameText(node.name);
+                if (name !== null)
+                    accessorNames.add(name);
+            }
             if (ts.isClassDeclaration(node) || ts.isClassExpression(node)) {
                 for (const clause of node.heritageClauses?.nodes ?? [])
                     if (clause.token === ts.SyntaxKind.ImplementsKeyword)
@@ -50,28 +68,106 @@ export class ClassProtocols {
                     this.methods.set(ts.symbolName(property), entries);
                 }
             }
-            if (ts.isObjectLiteralExpression(node) &&
-                node.properties.nodes.some((property) => (ts.isMethodDeclaration(property) ||
+            if (ts.isObjectLiteralExpression(node)) {
+                if (node.properties.nodes.some((property) => (ts.isMethodDeclaration(property) ||
                     ts.isGetAccessorDeclaration(property) ||
                     ts.isSetAccessorDeclaration(property)) &&
                     property.body !== undefined &&
                     usesReceiver(property.body))) {
-                // Receiver-dependent methods and accessors need a live object even
-                // without a class implementation. Receiver-free methods keep their
-                // native callable fields, including async callbacks.
-                add(this.checker.getTypeAtLocation(node));
-                const contextual = this.checker.getContextualType(node);
-                if (contextual)
-                    add(contextual);
+                    // Receiver-dependent methods and accessors need a live object even
+                    // without a class implementation. Receiver-free methods keep their
+                    // native callable fields, including async callbacks.
+                    add(this.checker.getTypeAtLocation(node));
+                    const contextual = this.checker.getContextualType(node);
+                    if (contextual)
+                        add(contextual);
+                }
+                // Member-kind disagreements with the literal's target type are
+                // checked once the walk ends, when the accessor-name index above is
+                // complete (see markMemberKindViews).
+                literals.push(node);
             }
             ts.forEachChild(node, visit);
         };
         for (const source of this.sources)
             if (!source.isDeclarationFile)
                 visit(source);
+        for (const literal of literals)
+            this.markMemberKindViews(literal, accessorNames, add);
         this.markIdentityFlows(protocols);
         return protocols;
     }
+    /** Marks the structural types a literal's member kinds disagree with: a
+     * get/set accessor satisfying a declared DATA member, or a data property
+     * satisfying a declared accessor member. One static record layout cannot
+     * hold both member kinds at one name (a data member is a storage slot, an
+     * accessor member a `%get:`/`%set:` closure pair), so the target type
+     * keeps checked identity instead: every value of it is a live
+     * checked-dynamic view, where the accessor stays live, `Object.keys`
+     * lists it, and `JSON.stringify` calls it — Node's own model.
+     *
+     * Only the TARGET is marked: the literal then takes the checked-dynamic
+     * literal path (`lowerDynObjectLiteral`), which defines an accessor member
+     * as a live get/set property and a data member as a plain property, so
+     * both directions construct live objects. */
+    markMemberKindViews(literal, accessorNames, add) {
+        const members = [];
+        for (const property of literal.properties.nodes) {
+            if (ts.isSpreadAssignment(property) || property.name === undefined)
+                continue;
+            const name = propertyNameText(property.name);
+            if (name === null)
+                continue;
+            if (ts.isGetAccessorDeclaration(property) || ts.isSetAccessorDeclaration(property)) {
+                members.push({ name, accessor: true });
+                continue;
+            }
+            if ((ts.isPropertyAssignment(property) || ts.isShorthandPropertyAssignment(property)) &&
+                // A data member only disagrees with an accessor-declared target, and
+                // only a type that declares an accessor somewhere can be one: the
+                // name index keeps the checker round trip off the common literal.
+                accessorNames.has(name))
+                members.push({ name, accessor: false });
+        }
+        if (members.length === 0)
+            return;
+        const contextual = attempt(() => this.checker.getContextualType(literal));
+        if (contextual === undefined)
+            return;
+        // Only one object type can be the one the literal converts into: a union
+        // with several arms picks its arm from the value itself, and an
+        // intersection merges members, so neither has the single layout the
+        // literal would have to disagree with. Nullish arms are ignored, so
+        // `Counter | undefined` still names Counter.
+        const present = contextual.isUnionType()
+            ? ts
+                .constituentTypes(contextual)
+                .filter((part) => (part.flags & (ts.TypeFlags.Undefined | ts.TypeFlags.Null)) === 0)
+            : [contextual];
+        const target = present.length === 1 ? present[0] : undefined;
+        if (target === undefined || target.isIntersectionType())
+            return;
+        if ((target.flags & ts.TypeFlags.TypeParameter) !== 0)
+            return;
+        if (!this.isStructuralTarget(target))
+            return;
+        const disagrees = members.some((member) => {
+            const kind = attempt(() => this.memberKind(target, member.name));
+            return kind == null ? false : (kind === "accessor") !== member.accessor;
+        });
+        if (disagrees)
+            add(target);
+    }
+    /** The member kind `type` declares at `name` — an accessor (get/set pair)
+     * or a data property — or null when it declares no member by that name. */
+    memberKind(type, name) {
+        const property = this.checker.getPropertyOfType(type, name);
+        if (property === undefined)
+            return null;
+        return property.flags & (ts.SymbolFlags.GetAccessor | ts.SymbolFlags.SetAccessor)
+            ? "accessor"
+            : "data";
+    }
     /** Structural types that receive a value with identity: a program class
      * instance, or a value of a type already marked here. Natively such a
      * type would be a record, and the conversion into it a field copy, so a
@@ -417,8 +513,12 @@ export class ClassProtocols {
         const added = [...marked].filter((symbol) => !before.has(symbol));
         // A copy of an instance drops the methods its class defines, so a view
         // that exposes one of them stays live wherever such an instance may
-        // arrive.
-        const kept = new Set(added.filter((symbol) => methodViews.has(symbol) || this.needsView(symbol, marked, facts)));
+        // arrive. A record view of a collection needs no protocol: its checked
+        // identity is the collection itself, and its members are the
+        // collection's own methods, which protocol dispatch would read from a
+        // property bag instead of invoking.
+        const kept = new Set(added.filter((symbol) => !this.collectionViews.has(symbol) &&
+            (methodViews.has(symbol) || this.needsView(symbol, marked, facts))));
         let grew = true;
         while (grew) {
             grew = false;
@@ -500,8 +600,9 @@ export class ClassProtocols {
             }
             // A Pick or Omit view's values are instances of the class it views,
             // or of any other program class that has the view's members.
-            if (this.pickOfProgramClass(type)) {
-                add(type.getAliasTypeArguments()[0]);
+            const viewed = this.pickViewOf(type, 0);
+            if (viewed !== null) {
+                add(viewed);
                 for (const other of this.classesAcceptedBy(type))
                     for (const related of this.classFamily(other, facts))
                         out.add(related);
@@ -594,6 +695,15 @@ export class ClassProtocols {
         const target = facts.targets.get(symbol);
         if (target === undefined)
             return true;
+        // A type that exposes a program class's method can never be a record
+        // copy: the copy would drop the method, which Node reads from the
+        // instance's prototype, and a copied receiver would lose overrides.
+        // The mark exists because an identity-carrying value flows into the
+        // type, so keep the view even when nothing compares the value (pi's
+        // `{ handleInput?(data: string): void } | undefined` field receives
+        // component instances directly and is only ever called through).
+        if (this.methodViewSources(target).length > 0)
+            return true;
         const names = new Set(this.checker.getPropertiesOfType(target).map((p) => ts.symbolName(p)));
         const origins = facts.origins.get(symbol) ?? new Set();
         const writesNames = (written) => written === "all" || [...written].some((name) => names.has(name));
@@ -630,6 +740,13 @@ export class ClassProtocols {
                         (declaration.parent !== undefined && facts.genericObservers.has(declaration.parent))));
             }) === true);
     }
+    /** Whether one of `names` is a member the collection type itself
+     * declares (`has`, `get`, `size`, `keys`, ...). */
+    exposesCollectionMember(collection, names) {
+        return this.checker
+            .getPropertiesOfType(collection)
+            .some((property) => names.has(ts.symbolName(property)));
+    }
     /** Whether class `symbol` declares a get or set accessor for one of
      * `names`. */
     hasAccessorFor(symbol, names) {
@@ -680,15 +797,64 @@ export class ClassProtocols {
     /** `Pick<C, K>` or `Omit<C, K>` over a program class instance type: a
      * view of the class's own members, spelled inline instead of as an
      * interface. Like an interface the class matches, a view that exposes a
-     * method needs a live receiver (see protocol). */
+     * method needs a live receiver (see protocol). A program type alias of
+     * such a view names the same view (`type V = Pick<C, K>`), so its
+     * declaration is resolved to the Pick/Omit it spells. */
     pickOfProgramClass(type) {
+        return this.pickViewOf(type, 0) !== null;
+    }
+    /** The program class instance this view views, resolving program type
+     * aliases of views (`type A = B`, `type B = Pick<C, K>`) up to a small
+     * depth; null for everything else. */
+    pickViewOf(type, depth) {
+        if (depth > 8)
+            return null;
         const alias = type.getAliasSymbol();
-        if (alias === undefined || (ts.symbolName(alias) !== "Pick" && ts.symbolName(alias) !== "Omit"))
-            return false;
-        if (!alias.declarations.every((declaration) => declaration.getSourceFile().isDeclarationFile))
+        if (alias === undefined)
+            return null;
+        if (this.isPickOrOmitAlias(alias)) {
+            const source = type.getAliasTypeArguments()[0];
+            return source !== undefined && this.isProgramClassInstance(source) ? source : null;
+        }
+        const declaration = this.programTypeAlias(alias);
+        return declaration === null ? null : this.pickViewNode(declaration.type, depth + 1);
+    }
+    /** The class instance a view's type node views. The resolved type of a
+     * program alias is the alias itself, so the reference is read by name:
+     * `Pick<C, K>` / `Omit<C, K>` keep the class it views, and another alias
+     * is followed through its declaration. */
+    pickViewNode(node, depth) {
+        if (depth > 8)
+            return null;
+        while (ts.isParenthesizedTypeNode(node))
+            node = node.type;
+        if (!ts.isTypeReferenceNode(node))
+            return null;
+        const symbol = attempt(() => this.checker.getSymbolAtLocation(node.typeName));
+        if (symbol === undefined)
+            return null;
+        if (this.isPickOrOmitAlias(symbol)) {
+            const sourceNode = node.typeArguments?.nodes[0];
+            const source = sourceNode === undefined
+                ? undefined
+                : attempt(() => this.checker.getTypeFromTypeNode(sourceNode));
+            return source !== undefined && this.isProgramClassInstance(source) ? source : null;
+        }
+        const declaration = this.programTypeAlias(symbol);
+        return declaration === null ? null : this.pickViewNode(declaration.type, depth + 1);
+    }
+    /** The lib's `Pick` or `Omit` utility type. */
+    isPickOrOmitAlias(symbol) {
+        const name = ts.symbolName(symbol);
+        if (name !== "Pick" && name !== "Omit")
             return false;
-        const source = type.getAliasTypeArguments()[0];
-        return source !== undefined && this.isProgramClassInstance(source);
+        return symbol.declarations.every((declaration) => declaration.getSourceFile().isDeclarationFile);
+    }
+    /** The program's own declaration of a type alias, if the symbol has one. */
+    programTypeAlias(symbol) {
+        const declaration = symbol.declarations.find((candidate) => ts.isTypeAliasDeclaration(candidate) &&
+            !ts.getSourceFileOfNode(candidate).isDeclarationFile);
+        return declaration !== undefined && ts.isTypeAliasDeclaration(declaration) ? declaration : null;
     }
     /** String-keyed dictionaries (`Record<string, V>`, `{ [key: string]: V }`)
      * that receive an existing record or class instance. Natively a
@@ -833,6 +999,51 @@ export class ClassProtocols {
             .getIndexInfosOfType(type)
             .find((index) => (index.keyType.flags & ts.TypeFlags.String) !== 0)?.type;
     }
+    /** A lib Map, Set, ReadonlyMap or ReadonlySet: a live collection. Handed
+     * to a structural type that spells one of its members, a copy would answer
+     * from its own fields and miss later writes to the collection, so the view
+     * stays the collection itself (checked-dynamic identity). */
+    isBuiltinCollection(type) {
+        if ((type.flags & ts.TypeFlags.Object) === 0)
+            return false;
+        const target = type.isTypeReference() ? type.getTarget() : type;
+        const symbol = target?.getSymbol() ?? type.getSymbol();
+        if (symbol === undefined)
+            return false;
+        const name = ts.symbolName(symbol);
+        if (name !== "Map" && name !== "Set" && name !== "ReadonlyMap" && name !== "ReadonlySet")
+            return false;
+        return ((symbol.flags & ts.SymbolFlags.Class) === 0 &&
+            symbol.declarations.length > 0 &&
+            symbol.declarations.every((declaration) => ts.getSourceFileOfNode(declaration).isDeclarationFile));
+    }
+    /** A builtin collection with an `any` or `unknown` type argument is
+     * UNTYPED (`new Map()`). It cannot back a structural view narrower than
+     * the values it may yield — `get` answers `any`, which the view declares
+     * as its own member type — so it keeps the record-shape refusal rather
+     * than carrying identity into the view. */
+    isUntypedCollection(type) {
+        if (!type.isTypeReference())
+            return true;
+        const args = this.checker.getTypeArguments(type);
+        return (args.length === 0 ||
+            args.some((arg) => (arg.flags & (ts.TypeFlags.Any | ts.TypeFlags.Unknown)) !== 0));
+    }
+    /** A lib Error, TypeError, ... instance type (RUNTIME_ERROR_CLASSES' lib
+     * names). Its fields are writable and its checked-dynamic view is the
+     * error itself, so a record built from it would miss later writes. */
+    isBuiltinError(type) {
+        if ((type.flags & ts.TypeFlags.Object) === 0)
+            return false;
+        const symbol = type.getSymbol();
+        if (symbol === undefined)
+            return false;
+        if (!ERROR_LIB_NAMES.has(ts.symbolName(symbol)))
+            return false;
+        return ((symbol.flags & ts.SymbolFlags.Class) === 0 &&
+            symbol.declarations.length > 0 &&
+            symbol.declarations.every((declaration) => ts.getSourceFileOfNode(declaration).isDeclarationFile));
+    }
     isProgramClassInstance(type) {
         const symbol = type.getSymbol();
         return (symbol !== undefined &&
@@ -852,6 +1063,16 @@ export class ClassProtocols {
         }
         if (this.isProgramClassInstance(type))
             return true;
+        // A Map or Set is a live collection: a record built from it answers the
+        // members it copies once and misses every later write. An untyped
+        // `new Map()` cannot back a narrower view (see isUntypedCollection), so
+        // only a fully typed collection carries identity into the view.
+        if (this.isBuiltinCollection(type))
+            return !this.isUntypedCollection(type);
+        // A builtin Error keeps its own identity too: extra fields the program
+        // puts on it (a status, a body) belong to the error, not to a copy.
+        if (this.isBuiltinError(type))
+            return true;
         // A live Pick or Omit view of a program class holds the instance itself.
         if (this.pickOfProgramClass(type) && this.usesCheckedIdentity(type))
             return true;
@@ -931,7 +1152,22 @@ export class ClassProtocols {
         if (from === symbol)
             return false;
         const facts = this.facts;
+        let collectionGrew = false;
         if (facts !== null) {
+            // A Map or Set that reaches the view, which answers one of its
+            // members: a record copy has no live backing behind `has`, `get` or
+            // `size`, and Node's answer changes with every later write. The view
+            // keeps checked identity, but not protocol dispatch: its members are
+            // the collection's own methods. A collection view's value handed on
+            // to another structural type is the same collection, so that view
+            // answers through it too.
+            const collection = this.isBuiltinCollection(source)
+                ? this.exposesCollectionMember(source, new Set(this.checker.getPropertiesOfType(target).map((property) => ts.symbolName(property))))
+                : from !== undefined && this.collectionViews.has(from);
+            if (collection && !this.collectionViews.has(symbol)) {
+                this.collectionViews.add(symbol);
+                collectionGrew = true;
+            }
             // The flow: the source's classes and marked type reach `symbol`.
             const origins = facts.origins.get(symbol) ?? new Set();
             for (const origin of this.originsOf(source, facts))
@@ -945,11 +1181,24 @@ export class ClassProtocols {
                 facts.flows.set(from, flows);
             }
         }
+        // A view marked earlier that becomes a collection view still changes
+        // the fixpoint: the views its values flow into are asked again.
         if (marked.has(symbol))
-            return false;
+            return collectionGrew;
         marked.add(symbol);
         return true;
     }
+    /** Whether `type` is a structural view that a Map or Set reaches and that
+     * answers through the collection's own methods (see markIdentityFlows).
+     * Such a view keeps checked identity but never protocol dispatch: there
+     * is no stored member to read, and the collection answers the call. */
+    collectionView(type) {
+        this.index();
+        if (type.isUnionType() || type.isIntersectionType())
+            return ts.constituentTypes(type).some((part) => this.collectionView(part));
+        const symbol = type.getSymbol();
+        return symbol !== undefined && this.collectionViews.has(symbol);
+    }
     /** Class-backed protocols require live receiver dispatch. Other interfaces,
      * including factories backed by static methods and ordinary records of
      * closures, retain their fixed native layouts. */
@@ -971,8 +1220,11 @@ export class ClassProtocols {
         // it (a literal whose methods read `this`) or when it receives existing
         // objects (markDictionaryViews).
         const dictionaryValue = this.dictionaryValueType(type);
+        const view = type.getSymbol();
         const answer = this.protocol(type) ||
-            (dictionaryValue !== undefined && this.dictionaryViews.has(dictionaryValue));
+            (dictionaryValue !== undefined && this.dictionaryViews.has(dictionaryValue)) ||
+            // A record view of a Map or Set answers through the collection itself.
+            (view !== undefined && this.collectionViews.has(view));
         this.answers.set(type, answer);
         return answer;
     }
@@ -1005,6 +1257,21 @@ export class ClassProtocols {
 }
 /** The empty answer of the symbol maps above. */
 const NO_SYMBOLS = new Set();
+/** The lib names RUNTIME_ERROR_CLASSES gives the runtime error encoding
+ * (`%Error`, `%TypeError`, ...; ir.ts). */
+const ERROR_LIB_NAMES = new Set([
+    "Error",
+    "TypeError",
+    "RangeError",
+    "SyntaxError",
+    "DOMException",
+    "ReferenceError",
+    "EvalError",
+    "URIError",
+    "AggregateError",
+    "AssertionError",
+    "SuppressedError",
+]);
 /** Calls of these namespaces and functions observe whole objects. */
 const OBSERVER_NAMESPACES = new Set(["console", "JSON", "Object", "Reflect", "util", "assert"]);
 const OBSERVER_FUNCTIONS = new Set([
@@ -1120,6 +1387,15 @@ function attempt(query) {
         return undefined;
     }
 }
+/** The static property name a member declares, or null for a computed key
+ * (its name is not a compile-time fact). */
+function propertyNameText(name) {
+    if (ts.isIdentifier(name) || ts.isStringLiteral(name))
+        return name.text;
+    if (ts.isNumericLiteral(name))
+        return String(Number(name.text));
+    return null;
+}
 /** `(value as T).member` and `(value as T)[key]`: the assertion is read or
  * written member-wise in place, which lowers to the instance's own fields
  * and creates no view that could outlive it. */