@scriptc/compiler 0.4.3 → 0.4.5

package/dist/frontend/lowering/lower-classes.d.ts

@@ -33,6 +33,10 @@ export interface ClassInfo {
     localPrototypeData?: true;
     prototypeMethodValues?: Map<string, IrExpr>;
     prototypeReflectionReady?: true;
+    /** The global that records at run time that the prototype view was
+     * populated by reflection, so it holds its own `constructor` until the
+     * program deletes it (prototypeReflectedFlag). */
+    prototypeReflectedFlag?: string;
     prototypeObservedMethodsReady?: true;
     /** The globals holding each observed method's original prototype value
      * (set when the prototype data is built), by method name. A typed call
@@ -575,6 +579,15 @@ export declare function staticFieldWriteTarget(lowerer: Lowerer, access: ts.Prop
  * fall through to the ordinary chain so the static fence or the
  * generic member rejection names the site. */
 export declare function lowerStaticFieldRead(lowerer: Lowerer, expr: ts.PropertyAccessExpression): IrExpr | null;
+/** The class a static member read through `receiver` reads exactly: the
+ * class a name binds (directly, through a require binding, or through a
+ * const alias), or null. */
+export declare function staticReceiverClass(lowerer: Lowerer, receiver: ts.Expression): ClassInfo | null;
+/** The static member `name` of `info` read through `receiver` (an exact
+ * reference to the class, see staticReceiverClass): `C.name` for the
+ * property access `site`, or a destructuring element over `C` whose
+ * initializer is `site`. Null when the class has no such member. */
+export declare function lowerClassStaticRead(lowerer: Lowerer, info: ClassInfo, name: string, receiver: ts.Expression, site: ts.Expression): IrExpr | null;
 /** Collect a class expression once per enclosing specialization. Function-local
  * evaluations allocate fresh constructor objects; top-level expressions use
  * immortal templates. Static initialization remains limited to whole top-level
@@ -744,10 +757,13 @@ export declare function classMemberNameOf(lowerer: Lowerer, name: ts.PropertyNam
 export interface ClassIteratorInfo {
     /** The `[Symbol.iterator]()` call's receiver class + its declarer. */
     className: string;
-    /** The iterator object's type (the method's return). */
-    iterT: IrType & {
+    /** The iterator's type (the method's return): a class instance, or a
+     * record (an object literal) whose `next` field is a function. */
+    iterT: IrType & ({
         kind: "object";
-    };
+    } | {
+        kind: "record";
+    });
     /** next()'s result record type. */
     resultT: IrType & {
         kind: "record";
@@ -755,11 +771,36 @@ export interface ClassIteratorInfo {
     valueT: IrType;
     /** False: no done field — the protocol never terminates. */
     hasDone: boolean;
+    /** The iterator declares a zero-parameter return(), which a consumer
+     * that stops before the end calls (IteratorClose). Only consumers that
+     * ask for `close` see such iterators. */
+    hasReturn: boolean;
 }
-export declare function classIteratorOf(lowerer: Lowerer, t: IrType): ClassIteratorInfo | null;
-/** The `it.next()` step of a class iterator as an ordinary (possibly
- * virtual) method call. */
-export declare function classIteratorNextCall(lowerer: Lowerer, cit: ClassIteratorInfo, itRef: IrExpr, loc: SrcLoc): IrExpr;
+/** What a class iterable's consumer handles: `records` accepts an
+ * object-literal iterator; `close` accepts an iterator with return(),
+ * which the consumer calls when it stops early (or never stops early). */
+export interface ClassIteratorOptions {
+    records?: boolean;
+    close?: boolean;
+}
+export declare function classIteratorOf(lowerer: Lowerer, t: IrType, options?: ClassIteratorOptions): ClassIteratorInfo | null;
+/** The `next` an object-literal iterator's protocol calls, read once when
+ * the iterator opens: JS keeps the `next` it reads then in the iterator
+ * record, so a `next` the iterator assigns while it runs is not called.
+ * Null for an iterator class, whose `next` is a method. */
+export declare function classIteratorNextRead(lowerer: Lowerer, cit: ClassIteratorInfo, itRef: IrExpr, loc: SrcLoc): (IrExpr & {
+    type: IrType & {
+        kind: "func";
+    };
+}) | null;
+/** The `it.next()` step of a class iterator: an ordinary (possibly
+ * virtual) method call, or the call of `next`, the object-literal
+ * iterator's `next` that classIteratorNextRead read when it opened. */
+export declare function classIteratorNextCall(lowerer: Lowerer, cit: ClassIteratorInfo, itRef: IrExpr, next: IrExpr | null, loc: SrcLoc): IrExpr;
+/** `it.next()` or `it.return()` of a class iterator: a (possibly virtual)
+ * method call of an iterator class, or the call of an object-literal
+ * iterator's function field. */
+export declare function classIteratorMethodCall(lowerer: Lowerer, cit: ClassIteratorInfo, method: "next" | "return", itRef: IrExpr, loc: SrcLoc): IrExpr;
 /** `recv[Symbol.iterator]()` as an ordinary method call. */
 export declare function classIteratorOpenCall(lowerer: Lowerer, cit: ClassIteratorInfo, recv: IrExpr, loc: SrcLoc): IrExpr;
 /** `[...new C]` / `f(...new C)` over a CLASS ITERABLE: the eager drain —
@@ -851,3 +892,14 @@ export declare function lowerNew(lowerer: Lowerer, expr: ts.NewExpression): IrEx
  * this HALF of the accessor (get and set devirtualize independently),
  * a direct call of the nearest declaration otherwise. */
 export declare function accessorCall(lowerer: Lowerer, className: string, member: string, obj: IrExpr, extraArgs: IrExpr[], ret: IrType, loc: SrcLoc): IrExpr;
+/** The lifted `new crypto.X509Certificate(d)` constructor: raw decodes the
+ * input once (Node's PEM error throws here), and every other field reads
+ * raw. subjectAltName, infoAccess and signatureAlgorithm hold undefined
+ * where the runtime answers "". */
+/** The X509Certificate record `t` built from `data`, a certificate Buffer
+ * (PEM or DER) or PEM string, through the interned constructor helper.
+ * `der` marks a Buffer known to hold a certificate's DER (a TLS socket's),
+ * which is read without looking for PEM armor inside it. */
+export declare function x509RecordCall(lowerer: Lowerer, data: IrExpr, t: IrType & {
+    kind: "record";
+}, loc: SrcLoc, der?: boolean): IrExpr;