@scriptc/compiler 0.3.4 → 0.3.6

package/dist/frontend/lowering/class-protocols.d.ts

@@ -7,8 +7,63 @@ export declare class ClassProtocols {
     private implemented;
     private readonly methods;
     private readonly answers;
+    /** What markIdentityFlows learned about the program, while it runs. */
+    private facts;
     constructor(checker: ts.TypeChecker, sources: readonly ts.SourceFile[]);
     private index;
+    /** 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
+     * write or identity check through the record would miss the original
+     * (`function bump(o: { n: number }) { o.n++ }` called with a class
+     * instance). Marking keeps every value of the type a live, checked view.
+     * Flows are scanned syntactically, and only sites whose source carries
+     * identity query their target type.
+     *
+     * A copy differs from the original only when something observes the
+     * difference, so a type is marked only when the program can: values of
+     * the type are written through, compared by identity (`===`, `switch`,
+     * assert), used as Set/Map keys or array search needles, given to
+     * whole-object observers (console, JSON, Object, util, structuredClone,
+     * spreads, for-in, templates, `unknown` parameters) or tested with
+     * instanceof; or a field the type
+     * exposes is written on the source class after construction, so a copy
+     * could read a stale value. A view of readonly data that nothing
+     * observes stays a native record. */
+    private markIdentityFlows;
+    /** The symbols of `type`'s object parts: union and intersection members,
+     * and to `depth` levels the elements and type arguments they hold. */
+    private collectSymbols;
+    /** Program classes whose instances can be values of `source`: a class,
+     * its bases and the classes extending it, or the classes behind a marked
+     * structural type. */
+    private originsOf;
+    /** A class symbol with its base classes and the program classes that
+     * extend it. */
+    private classFamily;
+    /** Whether the program can tell a copy of a value of the marked type
+     * `symbol` from the original: see markIdentityFlows. */
+    private needsView;
+    /** Whether class `symbol` declares a get or set accessor for one of
+     * `names`. */
+    private hasAccessorFor;
+    /** `unknown`, `any`, `object`, `{}` and type-parameter parameters, alone
+     * or in a union. */
+    private acceptsAnyValue;
+    /** The value a flow site hands over: casts through `unknown` or `any`
+     * keep the original value (`t as unknown as { v: number }`). */
+    /** The expression whose type a flow site carries: parentheses, non-null
+     * assertions and casts through `unknown`/`any` keep the value itself. */
+    private flowSourceNode;
+    private isProgramClassInstance;
+    private carriesIdentity;
+    /** A structural target that natively becomes a record: a program object
+     * type that is not a class instance, array, tuple, function or library
+     * type. */
+    private isStructuralTarget;
+    /** Marks the structural parts of `target` that the identity-carrying
+     * parts of `source` flow into. Answers whether anything new was marked. */
+    private markTarget;
     /** 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. */