@scriptc/compiler 0.4.8 → 0.4.9

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

@@ -9,6 +9,8 @@ export declare class ClassProtocols {
     private readonly answers;
     /** The program classes each Pick or Omit view accepts (classesAcceptedBy). */
     private readonly accepted;
+    /** copiedArgument's answers, per call and argument position. */
+    private readonly copiedArguments;
     /** What markIdentityFlows learned about the program, while it runs. */
     private facts;
     /** The value types of the string-keyed dictionaries that keep checked
@@ -19,6 +21,9 @@ export declare class ClassProtocols {
      * without protocol dispatch: their members are invoked on the collection
      * itself, not read from a property bag. */
     private readonly collectionViews;
+    /** The mapped views a receiver-dependent literal is used as, whose source
+     * cannot carry the marking (see index). */
+    private readonly literalViews;
     constructor(checker: ts.TypeChecker, sources: readonly ts.SourceFile[]);
     private index;
     /** Marks the structural types a literal's member kinds disagree with: a
@@ -30,11 +35,37 @@ export declare class ClassProtocols {
      * 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. */
+     * Only the TARGET is marked (for an intersection or union, its object
+     * constituents): 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. */
     private markMemberKindViews;
+    /** The view targets `target` needs for a literal with these member kinds,
+     * or null when `target` cannot become a view. An intersection needs the
+     * targets of every constituent. A homomorphic mapped view (Partial, Pick,
+     * Omit, Readonly) has no symbol of its own — its symbol is the shared
+     * mapped `__type`, which every mapped type in the program uses — so the
+     * type it maps is the target instead, and `protocol` answers the view
+     * through that marking. `force` targets a union arm that must keep
+     * checked identity even when it agrees with the literal by itself. */
+    private viewTargets;
+    /** Whether any of the literal's member kinds disagrees with the member
+     * `target` declares under that name (a missing member never disagrees). */
+    private memberKindDisagrees;
+    /** The structural type a homomorphic mapped VIEW maps — Partial, Pick,
+     * Omit or Readonly over a program type. Mapped types share one `__type`
+     * symbol, so a view is identified through the alias it is spelled with;
+     * program aliases of views (`type A = B`, `type B = Partial<X>`) are
+     * followed through their declarations, and nested views
+     * (`Partial<Omit<X, K>>`) resolve to the type carrying the members.
+     * Null for everything else. */
+    private mappedViewSource;
+    /** mappedViewSource for a view spelled as a type node (a program alias's
+     * declaration, whose resolved type is the alias itself). */
+    private mappedViewSourceNode;
+    /** The lib's homomorphic mapped utility types. */
+    private isHomomorphicMappedAlias;
     /** 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. */
     private memberKind;
@@ -81,6 +112,28 @@ export declare class ClassProtocols {
     /** Whether the program can tell a copy of a value of the marked type
      * `symbol` from the original: see markIdentityFlows. */
     private needsView;
+    /** Whether every value of the view arrives as a call argument whose
+     * callee only reads it: then the record copy the boundary builds answers
+     * the same reads the instance itself would, and later writes to the
+     * instance cannot be observed through the view. */
+    private copiedAtEverySite;
+    /** Whether argument `index` of `call` can be copied into the parameter's
+     * record: the callee is a program function whose body reads the instance
+     * only through declared fields of primitive type, keeps no reference to
+     * it, and runs no code that could write to it (assignments only to its
+     * own locals, no await or yield, and every call a numeric builtin). */
+    private copiedArgument;
+    private copiedArgumentNow;
+    /** Whether the function whose body is inspected is the one this call runs:
+     * the callee is the function itself, the identifier of the function
+     * declaration, or the identifier of the `const` binding that holds it.
+     * A `let` binding, a property, or another binding of the same signature
+     * could run a body this analysis never saw. */
+    private fixedCallee;
+    /** The body of `declaration` mentions `name` only as the receiver of a
+     * property read whose value is a primitive, and never stores, returns,
+     * passes on or compares the value itself. */
+    private readsParameterOnlyFields;
     /** Whether one of `names` is a member the collection type itself
      * declares (`has`, `get`, `size`, `keys`, ...). */
     private exposesCollectionMember;