@scriptc/compiler 0.0.36 → 0.1.2

package/dist/frontend/lowering/expressions/object-literals.d.ts

@@ -0,0 +1,44 @@
+import * as ts from "../../ts7/adapter.js";
+import type { IrExpr } from "../../../ir/ir.js";
+import type { Lowerer } from "../lowerer.js";
+export declare function foldedStringKeyOf(lowerer: Lowerer, expr: ts.Expression): string | null;
+/** The runtime-keyed JS object literal (a computed key that doesn't fold):
+ * builds a dyn object member-by-member. Keys evaluate before their values,
+ * properties in source order — JS's object-literal evaluation exactly.
+ * Identifier/string keys are compile-time strings; numeric keys take
+ * their canonical number string (`{ 0x10: v }` stores "16" — JS's
+ * ToPropertyKey); computed keys evaluate and pass through ToString (the
+ * dyn's String() for dyn operands — `{ [field]: v }` where field is a
+ * checked-dynamic param). Values convert through the usual dyn boundary
+ * (dynFrom's domain, functions box); a value with no dyn representation
+ * fences per property. Spreads copy through dyn.assign in source order;
+ * accessors stay fenced. */
+export declare function lowerDynObjectLiteral(lowerer: Lowerer, expr: ts.ObjectLiteralExpression, boxValue?: (node: ts.Expression, value: IrExpr) => IrExpr): IrExpr;
+export declare function lowerObjectLiteral(lowerer: Lowerer, expr: ts.ObjectLiteralExpression): IrExpr;
+/** A conditional spread's carrier property: `name: value` or shorthand,
+ * with an identifier/string-literal name. */
+export type CondSpreadProp = (ts.PropertyAssignment | ts.ShorthandPropertyAssignment) & {
+    name: ts.Identifier | ts.StringLiteral;
+};
+/** Parses the conditional-spread idiom `...(c ? { k: v, ... } : {})`
+ * (either orientation). Returns the condition, the non-empty arm's
+ * properties, and which arm carries them; "unsupported" for conditional
+ * sources OUTSIDE the idiom (both arms non-empty, computed/method
+ * members); null when the spread source isn't a conditional at all.
+ * Callers slice their own honest subset (the static record path takes
+ * exactly one property; the island literal takes any number; spawn's
+ * options walk takes a `detached` boolean literal). */
+export declare function conditionalSpreadOf(expr: ts.Expression): {
+    cond: ts.Expression;
+    props: CondSpreadProp[];
+    whenTrue: boolean;
+} | "unsupported" | null;
+/** The value of a shorthand property (`{ x }`): the binding `x` refers to.
+ * The property name's own symbol is the PROPERTY, so resolution goes
+ * through getShorthandAssignmentValueSymbol. */
+export declare function lowerShorthandValue(lowerer: Lowerer, prop: ts.ShorthandPropertyAssignment): IrExpr;
+/** Rejects any `this` inside an object-literal method body — including in
+ * nested arrows, which inherit the method's `this` (nested function
+ * expressions reset it, but their bare `this` is already a tsc error
+ * under noImplicitThis, so over-rejecting them here changes nothing). */
+export declare function rejectThisInObjectMethod(lowerer: Lowerer, node: ts.Node): void;