@shd101wyy/yo 0.0.25 → 0.0.27

package/out/types/src/codegen/async/state-machine.d.ts

@@ -11,4 +11,4 @@ export interface StateMachineInfo {
 }
 export declare function generateResumeFunctionDeclaration(info: StateMachineInfo, context: FunctionGenerationContext): void;
 export declare function getStateMachineFieldName(variableId: string, kind?: "outer" | "local"): string;
-export declare function generateAsyncBlockResumeFunction(bodyExpr: Expr, asyncBlockId: string, structName: string, resumeFunctionName: string, analysis: AwaitAnalysisResult, futureType: SomeType | DynType, captureType: StructType | undefined, context: FunctionGenerationContext): void;
+export declare function generateAsyncBlockResumeFunction(bodyExpr: Expr, asyncBlockId: string, structName: string, resumeFunctionName: string, analysis: AwaitAnalysisResult, futureType: SomeType | DynType, captureType: StructType | undefined, context: FunctionGenerationContext): string[];

package/out/types/src/codegen/exprs/await.d.ts

@@ -2,3 +2,4 @@ import { type FnCallExpr } from "../../expr";
 import { type CodeGenContext } from "../utils";
 export declare function generateAwait(expr: FnCallExpr, indent: string, context: CodeGenContext): string;
 export declare function generateState(expr: FnCallExpr, indent: string, context: CodeGenContext): string;
+export declare function generateJoinHandleAwait(expr: FnCallExpr, indent: string, context: CodeGenContext): string;

package/out/types/src/codegen/exprs/downcast.d.ts

@@ -0,0 +1,3 @@
+import type { FnCallExpr } from "../../expr";
+import type { CodeGenContext } from "../utils";
+export declare function generateDowncast(expr: FnCallExpr, indent: string, context: CodeGenContext): string;

package/out/types/src/codegen/exprs/return.d.ts

@@ -2,5 +2,6 @@ import { type Expr, type FnCallExpr } from "../../expr";
 import type { FunctionGenerationContext } from "../functions/context";
 import { type CodeGenContext } from "../utils";
 export declare function generatePendingDeferredDrops(indent: string, context: FunctionGenerationContext, expr: Expr, isCompletion?: boolean, skipAlreadyDroppedCheck?: boolean, skipEnvCheck?: boolean): void;
+export declare function generateConsumedVarDropsForEscape(indent: string, context: FunctionGenerationContext, expr: Expr, skipEnvCheck?: boolean): void;
 export declare function generateReturn(expr: FnCallExpr, indent: string, context: CodeGenContext): string;
 export declare function generateImplicitReturnStatement(expr: Expr, indent: string, context: CodeGenContext): void;

package/out/types/src/codegen/exprs/typeid.d.ts

@@ -0,0 +1,3 @@
+import type { FnCallExpr } from "../../expr";
+import type { CodeGenContext } from "../utils";
+export declare function generateTypeId(expr: FnCallExpr, indent: string, context: CodeGenContext): string;

package/out/types/src/codegen/exprs/while.d.ts

@@ -1,3 +1,3 @@
 import { type FnCallExpr } from "../../expr";
-import type { CodeGenContext } from "../utils";
+import { type CodeGenContext } from "../utils";
 export declare function generateWhileLoop(expr: FnCallExpr, indent: string, context: CodeGenContext): string;

package/out/types/src/codegen/functions/context.d.ts

@@ -2,8 +2,8 @@ import type { AwaitAnalysisResult, CapturedVariable } from "../../evaluator/asyn
 import type { Expr } from "../../expr";
 import type { FunctionValue, FuncValueId } from "../../function-value";
 import type { DynType, FunctionType, FutureTraitType, SomeType, StructType, Type, TypeId } from "../../types/definitions";
-import type { EffectStateMachineInfo } from "../effects/effect-state-machine";
 import type { CodeGenContext } from "../utils";
+import type { EvidenceParameter } from "./declarations";
 export interface FunctionGenerationContext extends CodeGenContext {
     functions: Record<FuncValueId, {
         value: FunctionValue;
@@ -25,23 +25,17 @@ export interface FunctionGenerationContext extends CodeGenContext {
         futureType: SomeType | DynType;
     };
     stateMachineVariables?: Map<string, CapturedVariable>;
-    inEffectStateMachine?: EffectStateMachineInfo;
-    deferredEffectfulFunctions?: Array<{
-        functionValue: FunctionValue;
-        cFunctionName: string;
-        info: EffectStateMachineInfo;
-    }>;
+    inEffectStateMachine?: unknown;
+    isModuleEffectMemberFunction?: boolean;
+    currentEvidenceParams?: Map<string, EvidenceParameter>;
     continuationVariables?: Map<string, {
-        smVar: string;
-        smInfo: EffectStateMachineInfo;
-        effectIndex?: number;
-    } | {
         directReturnVar: string;
         directExitLabel?: string;
         isUnitReturn?: boolean;
     }>;
     variableIdRemapping?: Map<string, string>;
     pendingDeferredDrops?: Expr[];
+    consumedVarPendingDrops?: Expr[];
     deferredAsyncBlocks?: Array<{
         bodyExpr: Expr;
         asyncBlockId: string;
@@ -112,12 +106,6 @@ export interface FunctionGenerationContext extends CodeGenContext {
     shortCircuitHandledDropVarNames?: Set<string>;
     effectHandlerParamDrops?: string[];
     effectSmConsumedArgCNames?: Set<string>;
-    effectWhileLoopContinuation?: {
-        label: string;
-        stepExpr: Expr | undefined;
-        whileDoneLabel: string;
-        remainingExprs: Expr[];
-        bodyDropExprs: Expr[];
-    };
     loopBodyDropsBaselineCount?: number;
+    overrideReturnTypeStr?: string;
 }

package/out/types/src/codegen/functions/declarations.d.ts

@@ -3,8 +3,16 @@ import type { FunctionType } from "../../types/definitions";
 import { type CodeGenContext } from "../utils";
 import type { FunctionGenerationContext } from "./context";
 export declare function generateFunctionDeclarations(context: FunctionGenerationContext): void;
-export declare function generateFunctionPrototype(functionType: FunctionType, cFunctionName: string, context: CodeGenContext, overrideReturnType?: string): string;
-export declare function generateFunctionDeclaration(functionType: FunctionType, cFunctionName: string, isExtern: boolean, context: CodeGenContext, functionBody?: Expr): void;
+export interface EvidenceParameter {
+    implicitLabel: string;
+    fieldLabel: string;
+    fieldPath: string[];
+    fieldFunctionType: FunctionType;
+    cParamName: string;
+}
+export declare function getEvidenceParameters(functionType: FunctionType): EvidenceParameter[];
+export declare function generateFunctionPrototype(functionType: FunctionType, cFunctionName: string, context: CodeGenContext, overrideReturnType?: string, originalFunctionType?: FunctionType): string;
+export declare function generateFunctionDeclaration(functionType: FunctionType, cFunctionName: string, isExtern: boolean, context: CodeGenContext, functionBody?: Expr, originalFunctionType?: FunctionType): void;
 export declare function generateObjectConstructorDeclarations(context: FunctionGenerationContext): void;
 export declare function generateClosureConstructorDeclarations(context: FunctionGenerationContext): void;
 export declare function generateCaptureDisposeFunctionDeclarations(context: FunctionGenerationContext): void;

package/out/types/src/codegen/types/dyn.d.ts

@@ -1,4 +1,5 @@
 import type { DynType } from "../../types/definitions";
 import { type CodeGenContext } from "../utils";
+export declare function generateDynForwardDeclarations(context: CodeGenContext): void;
 export declare function generateDynDeclaration(dynType: DynType, cName: string, context: CodeGenContext): void;
 export declare function generateDynBoxTypes(context: CodeGenContext): void;

package/out/types/src/codegen/types/generation.d.ts

@@ -11,4 +11,4 @@ export declare function generateStructDeclaration(structType: StructType, cName:
 export declare function generateTupleDeclaration(tupleType: TupleType, cName: string, context: CodeGenContext): void;
 export declare function generateUnionDeclaration(unionType: UnionType, cName: string, context: CodeGenContext): void;
 export declare function generateEnumDeclaration(enumType: EnumType, cName: string, context: CodeGenContext): void;
-export { generateDynBoxTypes, generateDynDeclaration } from "./dyn";
+export { generateDynBoxTypes, generateDynDeclaration, generateDynForwardDeclarations, } from "./dyn";

package/out/types/src/codegen/utils/index.d.ts

@@ -76,6 +76,7 @@ export interface CodeGenContext {
     currentLoopLabel?: string;
     currentContinueLabel?: string;
     insideMatch?: boolean;
+    typeIdStatics?: Map<string, string>;
 }
 export declare function sanitizeForCIdentifier(str: string, isExternC?: boolean): string;
 export declare function shouldAvoidConst(type: Type): boolean;

package/out/types/src/evaluator/async/await-analysis.d.ts

@@ -6,4 +6,5 @@ export declare function isIoAsyncCall(expr: Expr): boolean;
 export declare function isIoAwaitCall(expr: Expr): boolean;
 export declare function isIoStateCall(expr: Expr): boolean;
 export declare function isIoSpawnCall(expr: Expr): boolean;
+export declare function isJoinHandleAwaitCall(expr: Expr): boolean;
 export declare function getLocalVariablesFromBody(body: Expr): CapturedVariable[];

package/out/types/src/evaluator/builtins/downcast.d.ts

@@ -0,0 +1,8 @@
+import type { Environment } from "../../env";
+import { type FnCallExpr } from "../../expr";
+import type { EvaluatorContext } from "../context";
+export declare function evaluateDowncast({ expr, env, context, }: {
+    expr: FnCallExpr;
+    env: Environment;
+    context: EvaluatorContext;
+}): FnCallExpr;

package/out/types/src/evaluator/builtins/rc-fns.d.ts

@@ -1,6 +1,11 @@
 import { type Environment } from "../../env";
 import { type Expr, type FnCallExpr } from "../../expr";
+import type { EnumType, Type } from "../../types/definitions";
 import type { EvaluatorContext } from "../context";
+export declare function createOptionType(innerType: Type, env: Environment, context: EvaluatorContext): {
+    optionType: EnumType;
+    env: Environment;
+};
 export declare function evaluateYoDecrRc({ expr, env, context, }: {
     expr: FnCallExpr;
     env: Environment;

package/out/types/src/evaluator/builtins/typeid.d.ts

@@ -0,0 +1,8 @@
+import type { Environment } from "../../env";
+import { type FnCallExpr } from "../../expr";
+import type { EvaluatorContext } from "../context";
+export declare function evaluateTypeId({ expr, env, context, }: {
+    expr: FnCallExpr;
+    env: Environment;
+    context: EvaluatorContext;
+}): FnCallExpr;

package/out/types/src/evaluator/context.d.ts

@@ -42,6 +42,8 @@ export interface EvaluatorContext {
         env: Environment;
     };
     SelfType?: Type;
+    SelfTraitType?: Type;
+    SelfModuleType?: Type;
     ReceiverType?: Type;
     isEvaluatingFunctionType?: boolean;
     loadModule?: (modulePath: string) => {

package/out/types/src/expr.d.ts

@@ -50,6 +50,7 @@ export interface EvaluatedExprData {
     comment?: string;
     deferredDupExpressions?: Expr[];
     deferredDropExpressions?: Expr[];
+    consumedVariableDropExpressions?: Expr[];
     asyncStackSize?: Expr;
     asyncStateMachineStructName?: string;
     captureType?: StructType;
@@ -171,6 +172,8 @@ export declare const BuiltinFunctions: {
     typeof: string[];
     sizeof: string[];
     alignof: string[];
+    typeid: string[];
+    downcast: string[];
     consume: string[];
     macro_expand: string[];
     as: string[];

package/out/types/src/function-value.d.ts

@@ -33,6 +33,7 @@ export type FunctionValue = {
     isControlFunction?: boolean;
     definitionSiteEnclosingFunctionType?: FunctionType;
     closureInfo?: ClosureInfo;
+    isModuleEffectMember?: boolean;
     isIoAsyncStateMachineClosure?: boolean;
 };
 export interface FunctionCapturedVariableInfo extends CapturedVariableInfo {

package/out/types/src/types/creators.d.ts

@@ -45,7 +45,7 @@ export declare function createModuleType(env: Environment): ModuleType;
 export declare function createTraitType(env: Environment): TraitType;
 export declare function createEnumType(env: Environment): EnumType;
 export declare function createUnionType(env: Environment): UnionType;
-export declare function createFunctionType({ parameters, forallParameters, implicitParameters, variadicParameter, whereClauseExprs, return_, env, parametersFrame, SelfType, isClosure, }: {
+export declare function createFunctionType({ parameters, forallParameters, implicitParameters, variadicParameter, whereClauseExprs, return_, env, parametersFrame, SelfType, SelfTraitType, SelfModuleType, isClosure, }: {
     parameters: FunctionParameter[];
     forallParameters: FunctionForallParameter[];
     implicitParameters?: FunctionImplicitParameter[];
@@ -55,6 +55,8 @@ export declare function createFunctionType({ parameters, forallParameters, impli
     env: Environment;
     parametersFrame: Frame;
     SelfType?: Type;
+    SelfTraitType?: Type;
+    SelfModuleType?: Type;
     isClosure?: boolean;
 }): FunctionType;
 export declare function createPtrType(childType: Type): PtrType;

package/out/types/src/types/definitions.d.ts

@@ -14,7 +14,7 @@ export interface Type {
     cInclude?: string;
     trait?: TraitType;
     definedInModulePath?: string;
-    ioBuiltin?: "io_async" | "io_await" | "io_state" | "io_spawn";
+    ioBuiltin?: "io_async" | "io_await" | "io_state" | "io_spawn" | "join_handle_await";
 }
 export interface ExprType extends Type {
     tag: TypeTag.Expr;
@@ -229,6 +229,8 @@ export interface FunctionType extends Type {
     env: Environment;
     parametersFrame: Frame;
     SelfType?: Type;
+    SelfTraitType?: Type;
+    SelfModuleType?: Type;
     trait: TraitType;
     isClosure?: boolean;
 }