@shd101wyy/yo 0.1.27 → 0.1.29

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

@@ -10,7 +10,7 @@ export interface EvidenceParameter {
     fieldFunctionType: FunctionType;
     cParamName: string;
 }
-export declare function getEvidenceParameters(functionType: FunctionType): EvidenceParameter[];
+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;

package/out/types/src/doc/model.d.ts

@@ -3,7 +3,6 @@ export interface DocParam {
     name: string;
     type: string;
     isComptime: boolean;
-    isImplicit: boolean;
     defaultValue?: string;
     doc?: string;
 }

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

@@ -17,7 +17,6 @@ export interface Variable {
     token: Token;
     isCreatedFromDestructuringAtomVariable?: boolean;
     parameterAlias?: string;
-    isImplicit?: boolean;
     isFromEffectSpread?: boolean;
     isEffectParam?: boolean;
     isModuleLevel?: boolean;
@@ -85,6 +84,7 @@ export declare function addVariableToFrame({ frame, variable, }: {
     frame: Frame;
     variable: Variable;
 }): Frame;
+export declare function _printFrameIndexStats(): void;
 export declare function getVariablesFromFrame(frame: Frame, variableName: string, variableFilter?: (variable: Variable) => boolean): Variable[];
 export declare function getVariablesFromEnv(env: Environment, variableName: string, variableFilter?: (variable: Variable) => boolean): Variable[];
 export declare function findVariableFrameLevel(env: Environment, variableName: string): number | undefined;
@@ -128,7 +128,6 @@ export declare function getReceiverMethodsByNameFromEnv({ env, context, methodNa
     value: Value | undefined;
     needsPointerConversion?: boolean;
 }[];
-export declare function stripImplicitVariablesFromEnv(env: Environment): Environment;
 export declare function keepTopLevelFrameAndComptimeVariablesFromEnv(env: Environment): Environment;
 export declare function getVariablesNeedingDrop(env: Environment): Variable[];
 export declare function findNearestBeginBlockFrameLevel(env: Environment): number;

package/out/types/src/evaluator/calls/helper.d.ts

@@ -25,7 +25,7 @@ export declare function checkIfFunctionParameterMatchesArgument({ functionType,
 };
 export declare function extractFunctionValue(value: Value | undefined): FunctionValue | undefined;
 export declare function _printCallProfile(): void;
-export declare function tryToCallFunctionWithArguments({ expr, functionValue, functionType, functionCalleeExpr, argExprs, callerEnv, context, isMethodCall, skipSpecialization, skipCtfeExecution, }: {
+type TryToCallArgs = {
     functionValue?: FunctionValue;
     functionType: FunctionType;
     expr?: Expr;
@@ -36,10 +36,12 @@ export declare function tryToCallFunctionWithArguments({ expr, functionValue, fu
     isMethodCall: boolean;
     skipSpecialization?: boolean;
     skipCtfeExecution?: boolean;
-}): FunctionCallResult;
+};
+export declare function tryToCallFunctionWithArguments(args: TryToCallArgs): FunctionCallResult;
 export declare function validateFunctionReturnType({ returnType, expr, env, context, }: {
     returnType: Type;
     expr: Expr | undefined;
     env: Environment;
     context: EvaluatorContext;
 }): void;
+export {};

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

@@ -54,6 +54,7 @@ export interface EvaluatorContext {
     stdPath: string;
     currentModulePath?: string;
     isUnsafeFunctionType?: boolean;
+    isControlFunctionType?: boolean;
     enclosingFunctionReturnType?: Type;
     hasControlFunctionImplicitParams?: boolean;
     isInsideWhereClause?: boolean;
@@ -67,7 +68,6 @@ export interface EvaluatorContext {
     isAnalyzingCtfeCapability?: boolean;
     isInFunctionCallCheckingPhase?: boolean;
     isInsideIoAsyncCall?: boolean;
-    isInsideGivenHandler?: boolean;
     isEvaluatingGenericImplSpecialization?: boolean;
     currentlySpecializingFunction?: {
         originalFuncId: string;

package/out/types/src/evaluator/exprs/{escape.d.ts → unwind.d.ts}

@@ -1,7 +1,7 @@
 import { type Environment } from "../../env";
 import { type Expr, type FnCallExpr } from "../../expr";
 import type { EvaluatorContext } from "../context";
-export declare function evaluateEscape({ expr, env, context, }: {
+export declare function evaluateUnwind({ expr, env, context, }: {
     expr: FnCallExpr;
     env: Environment;
     context: EvaluatorContext;

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

@@ -1,6 +1,6 @@
 import { type Environment } from "../../env";
 import { type Expr, type FnCallExpr } from "../../expr";
-import type { FunctionImplicitParameter, FunctionParameter, FunctionType, Type } from "../../types/definitions";
+import type { FunctionParameter, FunctionType, Type } from "../../types/definitions";
 import type { EvaluatorContext } from "../context";
 export declare function evaluateFunctionParameter({ expr, env, context, isParameterComptimeByDefault, allowVariableShadowing, }: {
     expr: Expr;
@@ -32,7 +32,6 @@ export declare function evaluateFunctionParameters({ parameterExprs, env, contex
 }): {
     parameters: FunctionParameter[];
     forallParameters: FunctionParameter[];
-    implicitParameters: FunctionImplicitParameter[];
     variadicParameter?: FunctionParameter;
     whereClauseExprs?: Expr[];
     env: Environment;

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

@@ -6,6 +6,7 @@ export interface SynthesizeTypesOptions {
     setResolvedConcreteType?: boolean;
     token?: Token;
 }
+export declare function _printSynthStats(): void;
 export declare function synthesizeTypes(expected: {
     type: Type;
     env: Environment;

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

@@ -2,4 +2,3 @@ import { type Environment, type Variable } from "../env";
 import { type Expr } from "../expr";
 export declare function isValidVariableName(expr: Expr): boolean;
 export declare function findRcValueOwnerRelationship(rhs: Expr, env: Environment, _modulePath: string): Variable | undefined;
-export declare function throwExprIsImplicitVariableError(rhs: Expr): void;

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

@@ -39,12 +39,12 @@ export interface RuntimeDestructuring {
 }
 export type ControlFlowFlags = {
     return?: boolean;
-    escape?: boolean;
+    unwind?: boolean;
     break?: boolean;
     continue?: boolean;
 };
-export declare function controlFlowOf(kind: "return" | "escape" | "break" | "continue"): ControlFlowFlags;
-export declare function hasControlFlow(cf: ControlFlowFlags | undefined, kind: "return" | "escape" | "break" | "continue"): boolean;
+export declare function controlFlowOf(kind: "return" | "unwind" | "break" | "continue"): ControlFlowFlags;
+export declare function hasControlFlow(cf: ControlFlowFlags | undefined, kind: "return" | "unwind" | "break" | "continue"): boolean;
 export declare function hasAnyControlFlow(cf: ControlFlowFlags | undefined): boolean;
 export declare function mergeControlFlows(flows: ControlFlowFlags[]): ControlFlowFlags;
 export declare function controlFlowToString(cf: ControlFlowFlags): string;
@@ -118,8 +118,6 @@ export declare const BuiltinKeywords: {
     runtime: string[];
     ref: string[];
     forall: string[];
-    using: string[];
-    given: string[];
     where: string[];
     quote: string[];
     unquote: string[];
@@ -128,7 +126,8 @@ export declare const BuiltinKeywords: {
     recur: string[];
     fn: string[];
     unsafe_fn: string[];
-    escape: string[];
+    ctl: string[];
+    unwind: string[];
     extern: string[];
     cond: string[];
     type: string[];

package/out/types/src/test-runner.d.ts

@@ -1,4 +1,5 @@
 import { type Expr } from "./expr";
+export declare const DEFAULT_TEST_BATCH_SIZE = 100;
 export interface TestDeclaration {
     name: string;
     bodyExpr: Expr;
@@ -37,4 +38,5 @@ export declare function runTests(testFiles: string[], options?: {
     keepGeneratedFiles?: boolean;
     profile?: boolean;
     noSanitize?: boolean;
+    testBatchSize?: number;
 }): Promise<TestRunSummary>;

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

@@ -3,7 +3,7 @@ import type { EvaluatorContext } from "../evaluator/context";
 import type { Expr } from "../expr";
 import type { FunctionValue } from "../function-value";
 import { type Value } from "../value";
-import type { ArrayType, ComptimeListType, DynType, EffectsRowType, EnumType, FnTraitType, FunctionForallParameter, FunctionImplicitParameter, FunctionParameter, FunctionParameterExprs, FunctionReturn, FunctionType, FutureTraitType, IsoType, SourceNamespaceType, PtrType, SliceType, SomeType, StructType, TraitType, TupleType, Type, TypeApplicationType, TypeField, TypeHierarchyType, UnionType, VoidType } from "./definitions";
+import type { ArrayType, ComptimeListType, DynType, EnumType, FnTraitType, FunctionForallParameter, FunctionParameter, FunctionParameterExprs, FutureEffect, FunctionReturn, FunctionType, FutureTraitType, IsoType, SourceNamespaceType, PtrType, SliceType, SomeType, StructType, TraitType, TupleType, Type, TypeApplicationType, TypeField, TypeHierarchyType, UnionType, VoidType } from "./definitions";
 export declare function createComptimeIntType(): Type;
 export declare function createComptimeFloatType(): Type;
 export declare function createComptimeStringType(): Type;
@@ -45,10 +45,9 @@ export declare function createSourceNamespaceType(env: Environment): SourceNames
 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, SelfTraitType, isClosure, }: {
+export declare function createFunctionType({ parameters, forallParameters, variadicParameter, whereClauseExprs, return_, env, parametersFrame, SelfType, SelfTraitType, isClosure, isControl, }: {
     parameters: FunctionParameter[];
     forallParameters: FunctionForallParameter[];
-    implicitParameters?: FunctionImplicitParameter[];
     variadicParameter: FunctionParameter | undefined;
     whereClauseExprs?: Expr[];
     return_: FunctionReturn;
@@ -57,6 +56,7 @@ export declare function createFunctionType({ parameters, forallParameters, impli
     SelfType?: Type;
     SelfTraitType?: Type;
     isClosure?: boolean;
+    isControl?: boolean;
 }): FunctionType;
 export declare function createPtrType(childType: Type): PtrType;
 export declare function createIsoType(childType: Type, env: Environment): IsoType;
@@ -71,8 +71,6 @@ export declare function createSomeType(type: TypeHierarchyType, variableName: st
     env: Environment;
     context: EvaluatorContext;
 }): SomeType;
-export declare function createEffectsRowSomeType(variableName: string, env: Environment): SomeType;
-export declare function createEffectsRowType(implicitParameters: FunctionImplicitParameter[]): EffectsRowType;
 export declare function createTypeHierarchy(level: number, baseType?: Type): TypeHierarchyType;
 export declare function getFunctionParameterExprs({ expr, labelExpr, typeExpr, defaultValueExpr, assignedValueExpr, }: {
     expr: Expr;
@@ -82,7 +80,7 @@ export declare function getFunctionParameterExprs({ expr, labelExpr, typeExpr, d
     assignedValueExpr: Expr | undefined;
 }): FunctionParameterExprs;
 export declare function createFnTraitType(fnType: FunctionType, env: Environment): FnTraitType;
-export declare function createFutureTraitType(outputType: Type, env: Environment, effects?: FunctionImplicitParameter[]): FutureTraitType;
+export declare function createFutureTraitType(outputType: Type, env: Environment, effect?: FutureEffect): FutureTraitType;
 export declare function createDynType({ requiredTraits, env, negativeTraits, }: {
     requiredTraits: TraitType[];
     env: Environment;

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

@@ -53,14 +53,8 @@ export interface SomeType extends Type {
         functionValue: FunctionValue;
         argValues: Value[];
     };
-    isEffectsRow?: boolean;
     kindFunctionType?: FunctionType;
 }
-export interface EffectsRowType extends Type {
-    tag: TypeTag.EffectsRow;
-    implicitParameters: FunctionImplicitParameter[];
-    trait: TraitType;
-}
 export interface TypeApplicationType extends Type {
     tag: TypeTag.TypeApplication;
     constructor: SomeType;
@@ -119,18 +113,11 @@ export interface FunctionParameter {
     isCompileTimeOnly: boolean;
     isQuote: boolean;
     isOwningTheRcValue: boolean;
-    isImplicit: boolean;
-    isEffectRowSpread?: boolean;
     exprs: FunctionParameterExprs;
     assignedValue?: Value;
 }
 export type FunctionForallParameter = FunctionParameter & {
     isCompileTimeOnly: true;
-    isImplicit: false;
-};
-export type FunctionImplicitParameter = FunctionParameter & {
-    isCompileTimeOnly: true;
-    isImplicit: true;
 };
 export interface StructType extends Type {
     tag: TypeTag.Struct;
@@ -164,7 +151,7 @@ export interface TraitType extends Type {
     };
     isFuture?: {
         outputType: Type;
-        effects: FunctionImplicitParameter[];
+        effect?: FutureEffect;
     };
     isConcrete?: {
         concreteType: Type;
@@ -181,10 +168,14 @@ export type FnTraitType = TraitType & {
         callType: FunctionType;
     };
 };
+export interface FutureEffect {
+    label: string;
+    type: Type;
+}
 export type FutureTraitType = TraitType & {
     isFuture: {
         outputType: Type;
-        effects: FunctionImplicitParameter[];
+        effect?: FutureEffect;
     };
 };
 export type ConcreteTraitType = TraitType & {
@@ -227,7 +218,6 @@ export interface FunctionType extends Type {
     tag: TypeTag.Function;
     parameters: FunctionParameter[];
     forallParameters: FunctionForallParameter[];
-    implicitParameters: FunctionImplicitParameter[];
     variadicParameter?: FunctionParameter;
     whereClauseExprs?: Expr[];
     return: FunctionReturn;
@@ -237,6 +227,7 @@ export interface FunctionType extends Type {
     SelfTraitType?: Type;
     trait: TraitType;
     isClosure?: boolean;
+    isControl?: boolean;
 }
 export interface PtrType extends Type {
     tag: TypeTag.Ptr;

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

@@ -1,5 +1,5 @@
 import { FunctionValue } from "../function-value";
-import type { ArrayType, ComptimeListType, ConcreteTraitType, DynType, EffectsRowType, EnumType, FnTraitType, FunctionType, FutureTraitType, IsoType, SourceNamespaceType, PtrType, SliceType, SomeType, StructType, TraitType, TupleType, Type, TypeApplicationType, TypeHierarchyType, UnionType, VoidType } from "./definitions";
+import type { ArrayType, ComptimeListType, ConcreteTraitType, DynType, EnumType, FnTraitType, FunctionType, FutureTraitType, IsoType, SourceNamespaceType, PtrType, SliceType, SomeType, StructType, TraitType, TupleType, Type, TypeApplicationType, TypeHierarchyType, UnionType, VoidType } from "./definitions";
 export declare function isPrimitiveType(type: Type): boolean;
 export declare function isUnitType(type?: Type): boolean;
 export declare function isComptimeIntType(type?: Type): boolean;
@@ -77,4 +77,3 @@ export declare function isBoxedType(type: Type): type is StructType & {
     isReferenceSemantics: true;
     __isBoxed: true;
 };
-export declare function isEffectsRowType(type?: Type): type is EffectsRowType;

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

@@ -42,6 +42,5 @@ export declare enum TypeTag {
     Dyn = "Dyn",
     Expr = "Expr",
     ComptimeList = "ComptimeList",
-    EffectsRow = "EffectsRow",
     TypeApplication = "TypeApplication"
 }

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

@@ -7,6 +7,7 @@ export declare function typeProhibitsComptimeModifier(type: Type | undefined, en
 export declare function isComptimeOnlyType(type: Type, env: Environment): boolean;
 export declare function isRuntimeOnlyType(type: Type, env: Environment): boolean;
 export declare function typeContainsRcType(type?: Type, checkedTypes?: Type[]): boolean;
+export declare function typeIsControlBound(type?: Type, checkedTypes?: Type[]): boolean;
 export declare function typeContainsSomeType(type?: Type, checkedTypes?: Type[]): boolean;
 export declare function typeContainsUnknownValue(type: Type, visited?: Set<string>): boolean;
 export declare function getAllSomeTypes(type: Type): Set<SomeType>;