@shd101wyy/yo 0.0.13 → 0.0.14

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

@@ -1,6 +1,6 @@
-import { AwaitPoint } from "../../evaluator/async/await-analysis";
-import { Expr } from "../../expr";
-import { FunctionGenerationContext } from "../functions/context";
+import type { AwaitPoint } from "../../evaluator/async/await-analysis";
+import { type Expr } from "../../expr";
+import type { FunctionGenerationContext } from "../functions/context";
 export interface StateSegment {
     stateNumber: number;
     expressions: Expr[];

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

@@ -1,7 +1,7 @@
-import { AwaitAnalysisResult, AwaitPoint } from "../../evaluator/async/await-analysis";
-import { Expr } from "../../expr";
-import { DynType, SomeType, StructType } from "../../types";
-import { FunctionGenerationContext } from "../functions/context";
+import type { AwaitAnalysisResult, AwaitPoint } from "../../evaluator/async/await-analysis";
+import { type Expr } from "../../expr";
+import type { DynType, SomeType, StructType } from "../../types/definitions";
+import type { FunctionGenerationContext } from "../functions/context";
 export declare function getFutureFieldName(awaitPoint: AwaitPoint, analysis: AwaitAnalysisResult): string;
 export interface StateMachineInfo {
     structName: string;

package/out/types/src/codegen/c/collection.d.ts

@@ -1,3 +1,3 @@
-import { CodeGenContext } from "../utils";
+import type { CodeGenContext } from "../utils";
 export declare function collectCIncludes(context: CodeGenContext): void;
 export declare function emitCIncludes(context: CodeGenContext): void;

package/out/types/src/codegen/codegen-c.d.ts

@@ -1,4 +1,4 @@
-import { ModuleValue } from "../value";
+import type { ModuleValue } from "../value";
 export declare class CodeGeneratorC {
     private emitter;
     constructor();

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

@@ -1,3 +1,3 @@
-import { TypeTag } from "../types";
+import { TypeTag } from "../types/tags";
 export declare const BuiltinYoInlineFunctions: string[];
 export declare const PrimitiveTypeTags: Set<TypeTag>;

package/out/types/src/codegen/exprs/{and_or.d.ts → and-or.d.ts}

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

package/out/types/src/codegen/exprs/{array_fns.d.ts → array-fns.d.ts}

@@ -1,4 +1,4 @@
-import { FnCallExpr } from "../../expr";
-import { CodeGenContext } from "../utils";
+import { type FnCallExpr } from "../../expr";
+import { type CodeGenContext } from "../utils";
 export declare function generateAnonymousArray(expr: FnCallExpr, indent: string, context: CodeGenContext): string | undefined;
 export declare function generateYoArrayFill(expr: FnCallExpr, indent: string, context: CodeGenContext): string;

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

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

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

@@ -1,5 +1,5 @@
-import { FnCallExpr } from "../../expr";
-import { FunctionGenerationContext } from "../functions/context";
+import { type FnCallExpr } from "../../expr";
+import type { FunctionGenerationContext } from "../functions/context";
 export declare function generateAsyncBlock(expr: FnCallExpr, indent: string, context: FunctionGenerationContext): string;
 export declare function generateDeferredAsyncBlocks(context: FunctionGenerationContext): void;
 export declare function preRegisterAsyncBlockTypes(context: FunctionGenerationContext): void;

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

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

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

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

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

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

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

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

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

@@ -1,6 +1,6 @@
-import { Environment } from "../../env";
-import { FnCallExpr } from "../../expr";
-import { CodeGenContext } from "../utils";
+import { type Environment } from "../../env";
+import { type FnCallExpr } from "../../expr";
+import { type CodeGenContext } from "../utils";
 export declare function checkVariableIsClosureCaptured(variableName: string, env: Environment, closureCaptureFrameLevel: number): boolean;
 export declare function isClosureConstruction(expr: FnCallExpr): boolean;
 export declare function generateClosureConstruction(expr: FnCallExpr, indent: string, context: CodeGenContext): string;

package/out/types/src/codegen/exprs/comptime-value.d.ts

@@ -0,0 +1,4 @@
+import type { Expr } from "../../expr";
+import { type Value } from "../../value";
+import { type CodeGenContext } from "../utils";
+export declare function generateComptimeValue(value: Value, context: CodeGenContext, _sourceExpr?: Expr): string;

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

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

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

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

package/out/types/src/codegen/exprs/{drop_dup.d.ts → drop-dup.d.ts}

@@ -1,7 +1,7 @@
-import { Expr } from "../../expr";
-import { Type } from "../../types";
-import { FunctionGenerationContext } from "../functions/context";
-import { CodeGenContext } from "../utils";
+import { type Expr } from "../../expr";
+import type { Type } from "../../types/definitions";
+import type { FunctionGenerationContext } from "../functions/context";
+import { type CodeGenContext } from "../utils";
 export declare function generateDropCodeForValue(valueCode: string, valueType: Type, context: CodeGenContext): string;
 export declare function generateDupCodeForValue(valueCode: string, valueType: Type, context: CodeGenContext): string;
 export declare function getDropFunctionForType(type: Type, context: CodeGenContext): string | undefined;

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

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

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

@@ -1,5 +1,5 @@
-import { Expr } from "../../expr";
-import { CodeGenContext } from "../utils";
+import type { Expr } from "../../expr";
+import type { CodeGenContext } from "../utils";
 export type GenerateExprFn = (expr: Expr, indent: string, context: CodeGenContext) => string;
 export declare function setGenerateExprFn(fn: GenerateExprFn): void;
 export declare function generateExpr(expr: Expr, indent: string, context: CodeGenContext): string;

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

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

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

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

package/out/types/src/codegen/exprs/{initialization_assignment.d.ts → initialization-assignment.d.ts}

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

package/out/types/src/codegen/exprs/{inline_fns.d.ts → inline-fns.d.ts}

@@ -1,3 +1,3 @@
-import { FnCallExpr } from "../../expr";
-import { CodeGenContext } from "../utils";
+import { type FnCallExpr } from "../../expr";
+import { type CodeGenContext } from "../utils";
 export declare function generateYoInlineFunctionCall(functionName: string, args: string[], expr: FnCallExpr, context: CodeGenContext): string;

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

@@ -1,5 +1,5 @@
-import { FnCallExpr } from "../../expr";
-import { CodeGenContext } from "../utils";
+import type { FnCallExpr } from "../../expr";
+import { type CodeGenContext } from "../utils";
 export declare function generateYoIsoExtract(expr: FnCallExpr, indent: string, context: CodeGenContext): string;
 export declare function generateYoIsoDispose(expr: FnCallExpr, indent: string, context: CodeGenContext): string;
 export declare function isIsoTypeCall(expr: FnCallExpr): boolean;

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

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

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

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

package/out/types/src/codegen/exprs/{other_fn_call.d.ts → other-fn-call.d.ts}

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

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

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

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

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

package/out/types/src/codegen/exprs/{property_access.d.ts → property-access.d.ts}

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

package/out/types/src/codegen/exprs/{ptr_fns.d.ts → ptr-fns.d.ts}

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

package/out/types/src/codegen/exprs/{rc_fns.d.ts → rc-fns.d.ts}

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

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

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

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

@@ -1,4 +1,4 @@
-import { Expr, FnCallExpr } from "../../expr";
-import { CodeGenContext } from "../utils";
+import { type Expr, type FnCallExpr } from "../../expr";
+import { type CodeGenContext } from "../utils";
 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/sizeof.d.ts

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

package/out/types/src/codegen/exprs/{tuple_fn.d.ts → tuple-fn.d.ts}

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

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

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

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

@@ -1,5 +1,6 @@
-import { Expr } from "../../expr";
-import { ModuleValue, TraitValue } from "../../value";
-import { CodeGenContext } from "../utils";
+import { type Expr } from "../../expr";
+import { type ModuleValue, type TraitValue } from "../../value";
+import { type CodeGenContext } from "../utils";
 export declare function collectRequiredFunctions(moduleValue: ModuleValue | TraitValue, context: CodeGenContext): void;
 export declare function findFunctionCallsInExpr(expr: Expr, context: CodeGenContext): void;
+export declare function collectDisposeMethodsFromGenericImpls(context: CodeGenContext): void;

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

@@ -1,8 +1,8 @@
-import { AwaitAnalysisResult, CapturedVariable } from "../../evaluator/async/await-analysis";
-import { Expr } from "../../expr";
-import { FunctionValue, FuncValueId } from "../../function-value";
-import { DynType, FunctionType, SomeType, StructType, Type, TypeId } from "../../types";
-import { CodeGenContext } from "../utils";
+import type { AwaitAnalysisResult, CapturedVariable } from "../../evaluator/async/await-analysis";
+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 { CodeGenContext } from "../utils";
 export interface FunctionGenerationContext extends CodeGenContext {
     functions: Record<FuncValueId, {
         value: FunctionValue;
@@ -32,7 +32,7 @@ export interface FunctionGenerationContext extends CodeGenContext {
         constructorName: string;
         disposeFunctionName: string;
         futureType: SomeType | DynType;
-        futureModuleType: import("../../types").FutureTraitType;
+        futureModuleType: FutureTraitType;
         resultType: Type;
         resultTypeCName: string;
         captureType: StructType | undefined;

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

@@ -1,7 +1,7 @@
-import { Expr } from "../../expr";
-import { FunctionType } from "../../types";
-import { CodeGenContext } from "../utils";
-import { FunctionGenerationContext } from "./context";
+import type { Expr } from "../../expr";
+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;

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

@@ -1,4 +1,4 @@
-import { FunctionGenerationContext } from "./context";
+import type { FunctionGenerationContext } from "./context";
 export declare function generateDynDupDrop(context: FunctionGenerationContext): void;
 export declare function generateDynBoxFunctions(context: FunctionGenerationContext): void;
 export declare function generateDynWrapperFunctions(context: FunctionGenerationContext): void;

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

@@ -1,8 +1,8 @@
-import { Expr } from "../../expr";
-import { FunctionValue } from "../../function-value";
-import { FunctionType } from "../../types";
-import { CodeGenContext } from "../utils";
-import { FunctionGenerationContext } from "./context";
+import { type Expr } from "../../expr";
+import { type FunctionValue } from "../../function-value";
+import type { FunctionType } from "../../types/definitions";
+import { type CodeGenContext } from "../utils";
+import type { FunctionGenerationContext } from "./context";
 export declare function generateAllFunctions(context: FunctionGenerationContext): void;
 export declare function generateMainWrapper(context: FunctionGenerationContext): void;
 export declare function generateFunction(functionValue: FunctionValue, cFunctionName: string, context: FunctionGenerationContext): void;

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

@@ -1,7 +1,7 @@
-import { Expr } from "../../expr";
-import { FunctionType, Type } from "../../types";
-import { ModuleValue } from "../../value";
-import { CodeGenContext } from "../utils";
+import { type Expr } from "../../expr";
+import type { FunctionType, Type } from "../../types/definitions";
+import { type ModuleValue } from "../../value";
+import { type CodeGenContext } from "../utils";
 export declare function collectRequiredTypes(moduleValue: ModuleValue, context: CodeGenContext): void;
 export declare function collectTypesFromFunctionType(functionType: FunctionType, context: CodeGenContext): void;
 export declare function collectTypesFromExpr(expr: Expr, context: CodeGenContext): void;

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

@@ -1,4 +1,4 @@
-import { DynType } from "../../types";
-import { CodeGenContext } from "../utils";
+import type { DynType } from "../../types/definitions";
+import { type CodeGenContext } from "../utils";
 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

@@ -1,5 +1,5 @@
-import { EnumType, FunctionType, StructType, TupleType, UnionType } from "../../types";
-import { CodeGenContext } from "../utils";
+import type { EnumType, FunctionType, StructType, TupleType, UnionType } from "../../types/definitions";
+import { type CodeGenContext } from "../utils";
 export declare function generateTypeDeclarations(context: CodeGenContext): void;
 export declare function generateArrayStructDeclarations(context: CodeGenContext): void;
 export declare function generateSliceStructDeclarations(context: CodeGenContext): void;

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

@@ -1,2 +1,2 @@
-import { CodeGenContext } from "./index";
+import type { CodeGenContext } from "./index";
 export declare function fixupDynImplKeys(context: CodeGenContext): void;

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

@@ -1,9 +1,9 @@
 import { Emitter } from "../../emitter";
-import { Environment } from "../../env";
-import { Expr } from "../../expr";
-import { FunctionValue, FuncValueId } from "../../function-value";
-import { DynType, EnumType, FunctionType, IsoType, StructType, Type, TypeId } from "../../types";
-import { TraitValue } from "../../value";
+import { type Environment } from "../../env";
+import { type Expr } from "../../expr";
+import type { FunctionValue, FuncValueId } from "../../function-value";
+import type { DynType, EnumType, FunctionType, IsoType, StructType, Type, TypeId } from "../../types/definitions";
+import { type TraitValue } from "../../value";
 export interface CodeGenContext {
     types: Record<TypeId, {
         type: Type;
@@ -74,7 +74,7 @@ export declare function shouldAvoidConst(type: Type): boolean;
 export declare function getTypeString(type: Type | undefined, context: CodeGenContext): string;
 export declare function getVariableTypeString(type: Type, varName: string, context: CodeGenContext): string;
 export declare function getEnumVariantCName(enumType: EnumType, variantName: string, context: CodeGenContext): string;
-export declare function isComptFunction(functionValue: FunctionValue): boolean;
+export declare function isComptimeFunction(functionValue: FunctionValue): boolean;
 export declare function isFunctionValueWithOnlyBuiltinYoInlineFunctionCall(functionValue: FunctionValue): string | null;
 export declare function canOptimizeAsNullablePointer(enumType: EnumType): Type | null;
 export declare function canOptimizeAsSimpleEnum(enumType: EnumType): boolean;

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

@@ -1,6 +1,7 @@
-import { Token } from "./token";
-import { FunctionType, Type } from "./types";
-import { Value } from "./value";
+import type { EvaluatorContext } from "./evaluator/context";
+import type { Token } from "./token";
+import type { SomeType, TraitType, Type } from "./types/definitions";
+import { type Value } from "./value";
 export interface Variable {
     id: string;
     name: string;
@@ -17,10 +18,16 @@ export interface Variable {
     isCreatedFromDestructuringAtomVariable?: boolean;
     parameterAlias?: string;
 }
+export type WhereClauseConstraints = {
+    someType: SomeType;
+    requiredTraits: TraitType[];
+    negativeTraits: TraitType[];
+};
 export type Frame = {
     variables: Variable[];
     id: string;
     isBeginBlockFrame: boolean;
+    whereClauseConstraints: Map<string, WhereClauseConstraints>;
 };
 export type Environment = {
     functionDeclarationFrameLevel: number;
@@ -34,6 +41,16 @@ export declare function createNewEnv({ modulePath, inputString, }: {
 }): Environment;
 export declare function createEmptyEnv(): Environment;
 export declare function cloneEnvForCTFECheck(env: Environment): Environment;
+export declare function addWhereClauseConstraintToEnv({ env, someType, traitType, isNegated, }: {
+    env: Environment;
+    someType: SomeType;
+    traitType: TraitType;
+    isNegated: boolean;
+}): Environment;
+export declare function getWhereClauseConstraintsForSomeType(env: Environment, someType: SomeType): {
+    requiredTraits: TraitType[];
+    negativeTraits: TraitType[];
+} | undefined;
 export declare function setEnvContainingPrelude(env: Environment): void;
 export declare function clearEnvContainingPrelude(): void;
 export declare function createEnvContainingPrelude(): Environment;
@@ -55,6 +72,7 @@ export declare function addVariableToFrame({ frame, variable, }: {
 }): Frame;
 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;
 export declare function getVariablesFromEnvByFilter(env: Environment, variableFilter: (variable: Variable) => boolean): Variable[];
 export declare function pushEnvFrame(env: Environment, frame?: Frame, isBeginBlockFrame?: boolean): Environment;
 export declare function popEnvFrame(env: Environment, ignoreCheck?: boolean): Environment;
@@ -74,11 +92,22 @@ export declare function getVariableInfo(variable: Variable): {
     isReassignable: boolean;
     isConsumed: boolean;
 };
-export declare function getTypeTraitMethodsByNameFromEnv(env: Environment, methodName: string, type: Type): {
+export declare function getTypeTraitMethodsByNameFromEnv({ env, context, methodName, type, }: {
+    env: Environment;
+    context: EvaluatorContext;
+    methodName: string;
+    type: Type;
+}): {
     type: Type;
     value: Value | undefined;
 }[];
-export declare function getReceiverMethodsByNameFromEnv(env: Environment, methodName: string, receiverType: Type, isInfixOperatorCall?: boolean, currentFunctionType?: FunctionType): {
+export declare function getReceiverMethodsByNameFromEnv({ env, context, methodName, receiverType, isInfixOperatorCall, }: {
+    env: Environment;
+    context: EvaluatorContext;
+    methodName: string;
+    receiverType: Type;
+    isInfixOperatorCall?: boolean;
+}): {
     type: Type;
     value: Value | undefined;
     needsPointerConversion?: boolean;

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

@@ -1,4 +1,4 @@
-import { Token } from "./token";
+import type { Token } from "./token";
 export interface TokenAndError {
     token: Token;
     errorMessage: string;

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

@@ -1,4 +1,4 @@
-import { Type } from "../../types";
+import type { Type } from "../../types/definitions";
 export interface AwaitPoint {
     index: number;
     expr: unknown;

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

@@ -1,4 +1,4 @@
-import { Expr } from "../../expr";
+import { type Expr } from "../../expr";
 export type { AwaitAnalysisResult, AwaitPoint, CapturedVariable, } from "./await-analysis-types";
 import type { AwaitAnalysisResult, CapturedVariable } from "./await-analysis-types";
 export declare function analyzeAwaitPoints(body: Expr): AwaitAnalysisResult;

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

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

package/out/types/src/evaluator/builtins/{and_or.d.ts → and-or.d.ts}

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

package/out/types/src/evaluator/builtins/{array_fns.d.ts → array-fns.d.ts}

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

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

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

package/out/types/src/evaluator/builtins/{async_fns.d.ts → async-fns.d.ts}

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