@scriptc/compiler 0.2.6 → 0.2.8

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

@@ -65,8 +65,8 @@ export type FieldTarget = {
  * tail. 5.9.3's rawText, when a build ever supplies it, wins unchanged. */
 export declare function templateRawTextOf(node: ts.NoSubstitutionTemplateLiteral | ts.TemplateHead | ts.TemplateMiddle | ts.TemplateTail): string;
 /** True when a property access names an ABSTRACT property declaration
- * (`abstract p: number` — a PropertyDeclaration, not an accessor): the
- * named-fence test for reads/writes through abstract-typed receivers. */
+ * (`abstract p: number` — a PropertyDeclaration, not an accessor).
+ * These uses need concrete property dispatch because the base has no slot. */
 export declare function abstractPropertyDeclOf(lowerer: Lowerer, expr: ts.PropertyAccessExpression): boolean;
 export declare function lowerExpr(lowerer: Lowerer, expr: ts.Expression): IrExpr;
 /** `c ? a : b`. An explicit destination constructs each branch at that
@@ -108,6 +108,9 @@ export declare function lowerUnitComparison(lowerer: Lowerer, left: IrExpr, righ
  * results (several non-unit arms) and defaults that change the result
  * type are fenced with narrow-first hints. */
 export declare function lowerNullishCoalesce(lowerer: Lowerer, expr: ts.BinaryExpression, loc: SrcLoc): IrExpr;
+/** The TypeError of a deferred-init field read that finds the field
+ * unassigned where its declared type cannot hold undefined. */
+export declare const DEFERRED_READ_MESSAGE = "undefined is not representable in the target union (a value narrowed or asserted past it still held it)";
 /** A CONDITION-position expression: the result is consumed as a bool
  * only, so `&&`/`||` descend recursively over ToBoolean'd operands —
  * JS-exact (`ToBoolean(a && b)` ≡ `ToBoolean(a) && ToBoolean(b)`), still
@@ -180,6 +183,16 @@ export declare function lowerElementAccess(lowerer: Lowerer, expr: ts.ElementAcc
  * whose key type proves membership (tsc's keyof check): all fields must
  * share the result type, and a smuggled miss traps. */
 export declare function lowerRecordKeyRead(lowerer: Lowerer, expr: ts.ElementAccessExpression, shapeId: string, shape: IrRecordShape, includeUndefined?: boolean): IrExpr;
+/** The stored value of an identifier whose storage holds an undefined arm
+ * that the checker's type at this use has dropped. An assignment from an
+ * unchecked indexed read narrows the declared type even though the value
+ * can be absent at runtime, so presence tests (`=== undefined`, `== null`,
+ * truthiness, `??`, `typeof`) read the storage tag instead of trusting
+ * that narrowing. A guard-proven use answers the same way at runtime. */
+export declare function runtimeOptionalStorageOperand(lowerer: Lowerer, node: ts.Expression): IrExpr | null;
+/** A presence-test operand: an absence-aware element or field read, an
+ * identifier's runtime-optional storage, or the ordinary lowering. */
+export declare function lowerPresenceOperand(lowerer: Lowerer, node: ts.Expression): IrExpr;
 /** A keyed read used only to observe absence (`if (map[k])`, or the left
  * side of `||`/`??`). JavaScript answers undefined for missing record keys
  * and array indices even when noUncheckedIndexedAccess is disabled. Keep
@@ -228,6 +241,13 @@ export declare function lowerPrefixUnary(lowerer: Lowerer, expr: ts.PrefixUnaryE
 /** Member updates evaluate the reference once, convert its old value with
  * ToNumeric, store the new value, then yield the old or new numeric value. */
 export declare function lowerIncDec(lowerer: Lowerer, expr: ts.PrefixUnaryExpression | ts.PostfixUnaryExpression, prefix: boolean): IrExpr;
+/** Numeric updates read the represented slot once and write the computed
+ * value back in that same representation. In particular, an unchecked
+ * indexed initializer can leave undefined in an otherwise numeric binding. */
+export declare function lowerIncDecTarget(lowerer: Lowerer, expr: ts.PrefixUnaryExpression | ts.PostfixUnaryExpression, target: {
+    id: string;
+    type: IrType;
+}, prefix: boolean): IrExpr;
 export declare function lowerCompoundValueToTarget(lowerer: Lowerer, expr: ts.BinaryExpression, compound: CompoundOp, target: {
     id: string;
     type: IrType;