@scriptc/compiler 0.1.1 → 0.1.3

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
@@ -385,12 +394,14 @@ export declare function lowerTaggedTemplate(lowerer: Lowerer, expr: ts.TaggedTem
    * FLATTENED namespace block count — splitFiles hoisted them into the
    * same collection lists top-level declarations ride. */
 export declare function isTopLevelFnSymbol(lowerer: Lowerer, ident: ts.Identifier): boolean;
-/** Nested `function name(...) {...}`: lowered as `const name = <lambda>`
-   * at the declaration's statement position (JS hoists function declarations
-   * to the top of the enclosing function — calling one before this statement
-   * is a compile error here, not a silent divergence). Self-references inside
-   * the body lower to `selfRef`, not a capture: a box holding its own
-   * closure would be an RC cycle. */
+/** Nested `function name(...) {...}`: declare the mutable function binding
+   * before lowering its body, then initialize it with the lifted closure.
+   * The early declaration is observable only when another nested closure
+   * captures the binding: its box must exist before either side of a mutual
+   * recursion cycle builds its closure. Forward source references use the
+   * same split declaration/assignment through predeclareForwardFnDecl.
+   * Self-references inside the body lower to `selfRef`, not a capture: a box
+   * holding its own closure would be an RC cycle. */
 export declare function lowerNestedFunctionDecl(lowerer: Lowerer, stmt: ts.FunctionDeclaration): IrStmt;
 /** Signature checks + param shapes + IR func type for any lambda-like
    * node. The func type's params are the ABI types, so a lambda with