@scriptc/compiler 0.0.36 → 0.1.2

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

@@ -28,15 +28,22 @@ export interface FnSig {
     /** Call-site result type — Promise<inner> for async functions, the
      * generator type for generator functions. */
     returnType: IrType;
-    /** Async: the IrFunction's returnType is the promise's INNER type. */
+    /** Async: the IrFunction's returnType is the promise's INNER type, or
+     * the generator's TReturn when generator is also present. */
     isAsync?: boolean;
     /** Generator: the IrFunction's returnType is the TReturn channel; the
      * yield/next channels ride here (IrFunction.generator's exact shape). */
     generator?: {
         yieldT: IrType;
         nextT: IrType;
+        resultType: IrType & {
+            kind: "record";
+        };
     };
 }
+export declare function generatorMeta(lowerer: Lowerer, type: IrType & {
+    kind: "generator";
+}): NonNullable<IrFunction["generator"]>;
 /** Instantiation cap per generic function: same-key recursion (`len<T>`
  * calling itself) converges, but POLYMORPHIC recursion (`f<T>` calling
  * `f<T[]>`) would request new instances forever — the cap turns that into a
@@ -223,9 +230,6 @@ export declare function bodyReturnType(lowerer: Lowerer, isAsync: boolean, decla
    * dead code it is; it can only fire if the checker's proof was violated,
    * which would be a lowering bug — hence the please-report wording. */
 export declare function appendImplicitUndefinedReturn(lowerer: Lowerer, body: IrStmt[], bodyReturn: IrType, loc: SrcLoc): void;
-/** A declaration's checker-derived IR return type. The unmappable-type
-   * diagnostic points at `blame` (the name for top-level declarations, the
-   * whole node for lambda-likes — preserving each caller's historical loc). */
 export declare function declaredReturnType(lowerer: Lowerer, decl: ts.SignatureDeclaration, blame: ts.Node): IrType;
 export declare function collectSignature(lowerer: Lowerer, decl: ts.FunctionDeclaration): void;
 export declare function collectSignatureInner(lowerer: Lowerer, decl: ts.FunctionDeclaration): void;
@@ -287,6 +291,11 @@ export declare function implicitMonoFile(sf: ts.SourceFile): boolean;
    * rest/optional/defaulted, never written), null elsewhere. Null overall
    * when nothing qualifies — the declaration keeps today's path. */
 export declare function implicitAnyParamSymbolsOf(lowerer: Lowerer, decl: ts.FunctionDeclaration | ts.MethodDeclaration | ts.FunctionExpression | ts.ArrowFunction): (ts.Symbol | null)[] | null;
+/** True when a `this.method(...)` call targets an implicit npm-static
+ * method whose result is settled from its lowered body rather than the
+ * checker declaration. Uninitialized-local inference uses this to avoid
+ * freezing an evolving `any` slot to stale JSDoc. */
+export declare function implicitMethodCallInfersReturn(lowerer: Lowerer, call: ts.CallExpression): boolean;
 /** The instance a CALL of an implicit-any function-like names: each
    * bindable implicit param takes the call's WIDENED argument checker type
    * when it maps statically (DYN otherwise — today's slot), typed params
@@ -360,10 +369,9 @@ export declare function lowerFfiCall(lowerer: Lowerer, expr: ts.CallExpression):
 export declare function lowerCall(lowerer: Lowerer, expr: ts.CallExpression): IrExpr;
 export declare function lowerDynDispatchMethodCall(lowerer: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression, recv: IrExpr, arrayReceiver: boolean): IrExpr | null;
 /** Tagged templates `tag\`a${x}b\`` — ES's call: tag(strings, ...values).
-   * The strings object is the per-SITE interned cooked array (the
-   * templateStrings node: one immortal string[] per occurrence, so the
-   * spec's identity contract holds — the same site evaluated twice hands
-   * the tag the SAME array; two sites never share). TemplateStringsArray
+   * The strings object is a per-SITE lazily initialized hidden array global,
+   * so the spec's identity contract holds — the same site evaluated twice
+   * hands the tag the SAME array; two sites never share. TemplateStringsArray
    * maps to string[] (type-mapper.ts), so the array rides the ordinary
    * slot-directed coercion into whatever the tag's first parameter wants
    * — string[] exactly, an `any` slot through the dyn boundary, a rest