@shd101wyy/yo 0.0.2

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

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

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

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

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

@@ -0,0 +1,16 @@
+import { Environment } from "../../env";
+import { Type } from "../../types";
+export declare function canAssignTypeHierarchy(expected: Type, given: Type): boolean;
+export declare function synthesizeTypes(expected: {
+    type: Type;
+    env: Environment;
+}, given: {
+    type: Type;
+    env: Environment;
+}, checkedTypePairs?: {
+    expected: Type;
+    given: Type;
+}[]): {
+    expectedEnv: Environment;
+    givenEnv: Environment;
+};

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

@@ -0,0 +1,18 @@
+import { Environment } from "../../env";
+import { Expr, FuncCallExpr } from "../../expr";
+import { TupleType } from "../../types";
+import { EvaluatorContext } from "../context";
+export declare function evaluateTupleElementsType({ args, env, context, forType, }: {
+    args: Expr[];
+    env: Environment;
+    context: EvaluatorContext;
+    forType: "tuple" | "struct" | "enum" | "union";
+}): {
+    type: TupleType;
+    env: Environment;
+};
+export declare function evaluateTupleType({ expr, env, context, }: {
+    expr: FuncCallExpr;
+    env: Environment;
+    context: EvaluatorContext;
+}): FuncCallExpr;

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

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

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

@@ -0,0 +1,71 @@
+import { Environment } from "../../env";
+import { DynType, EnumType, IsoType, SomeType, StructType, UnionType } from "../../types";
+import { EvaluatorContext } from "../context";
+export declare function addFunctionSignatureToSelfTypeModule({ label, functionSignature, SelfType, env, context, }: {
+    label: string;
+    functionSignature: string;
+    SelfType: StructType | EnumType | DynType | SomeType | IsoType;
+    env: Environment;
+    context: EvaluatorContext;
+}): Environment;
+export declare function addFunctionCodeToSelfTypeModule({ label, functionCode, SelfType, env, context, }: {
+    label: string;
+    functionCode: string;
+    SelfType: StructType | EnumType | DynType | SomeType | IsoType;
+    env: Environment;
+    context: EvaluatorContext;
+}): Environment;
+export declare const DisposeFnSignature = "(fn(self : Self) -> unit)";
+export declare const DropFnSignature = "(fn(self : Self) -> unit)";
+export declare const DupFnSignature = "(fn(self : Self) -> Self)";
+export declare function addARCFunctionsToStructType({ structType, env, context, }: {
+    structType: StructType;
+    env: Environment;
+    context: EvaluatorContext;
+}): Environment;
+export declare function addARCFunctionSignaturesToStructType({ structType, env, context, }: {
+    structType: StructType;
+    env: Environment;
+    context: EvaluatorContext;
+}): void;
+export declare function addARCFunctionsToEnumType({ enumType, env, context, }: {
+    enumType: EnumType;
+    env: Environment;
+    context: EvaluatorContext;
+}): Environment;
+export declare function addARCFunctionSignaturesToEnumType({ enumType, env, context, }: {
+    enumType: EnumType;
+    env: Environment;
+    context: EvaluatorContext;
+}): void;
+export declare function addARCFunctionsToDynType({ dynType, env, context, }: {
+    dynType: DynType;
+    env: Environment;
+    context: EvaluatorContext;
+}): Environment;
+export declare function addARCFunctionsToSomeType({ someType, env, context, }: {
+    someType: SomeType;
+    env: Environment;
+    context: EvaluatorContext;
+}): Environment;
+export declare function addARCFunctionsToIsoType({ isoType, env, context, }: {
+    isoType: IsoType;
+    env: Environment;
+    context: EvaluatorContext;
+}): Environment;
+export declare function attachModuleToReceiverType(moduleName: string, receiverType: StructType | EnumType | UnionType, env: Environment, context: EvaluatorContext): Environment;
+export declare function autoDeriveSendForStructType({ structType, env, context, }: {
+    structType: StructType;
+    env: Environment;
+    context: EvaluatorContext;
+}): Environment;
+export declare function autoDeriveSendForEnumType({ enumType, env, context, }: {
+    enumType: EnumType;
+    env: Environment;
+    context: EvaluatorContext;
+}): Environment;
+export declare function autoDeriveSendForUnionType({ unionType, env, context, }: {
+    unionType: UnionType;
+    env: Environment;
+    context: EvaluatorContext;
+}): Environment;

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

@@ -0,0 +1,3 @@
+import { Token } from "../../token";
+import { ModuleField } from "../../types";
+export declare function validateDisposeFunction(moduleElement: ModuleField, token: Token): void;

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

@@ -0,0 +1,15 @@
+import { Environment } from "../../env";
+import { Expr, FuncCallExpr } from "../../expr";
+import { ArrayType } from "../../types";
+import { EvaluatorContext } from "../context";
+export declare function evaluateArrayFillMethod({ expr, arrayType, fillValueArg, env, context, }: {
+    expr: FuncCallExpr;
+    arrayType: ArrayType;
+    fillValueArg: Expr;
+    env: Environment;
+    context: EvaluatorContext;
+}): {
+    expr: FuncCallExpr;
+    env: Environment;
+};
+export declare function isArrayTypeFillMethodCall(receiverArg: Expr, methodExpr: Expr): boolean;

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

@@ -0,0 +1,35 @@
+import { Environment } from "../../env";
+import { Expr } from "../../expr";
+import { FunctionCapturedVariableInfo } from "../../function-value";
+import { Token } from "../../token";
+import { StructType } from "../../types";
+import { StructValue, UnknownValue } from "../../value";
+import { CapturedVariableInfo, EvaluatorContext } from "../context";
+export declare function consumeCapturedVariables({ capturedVariables, env, closureToken, }: {
+    capturedVariables: Map<string, CapturedVariableInfo>;
+    env: Environment;
+    closureToken: Token;
+}): Environment;
+export declare function buildPathCollectionFromCapturedVariables(capturedVariables: Map<string, CapturedVariableInfo>): string[][];
+export declare function createCaptureTypeAndValue({ expectedCaptureType, capturedVariablesWithValues, env, closureToken, context, }: {
+    expectedCaptureType: StructType | undefined;
+    capturedVariablesWithValues: Map<string, FunctionCapturedVariableInfo> | undefined;
+    env: Environment;
+    closureToken: Token;
+    context: EvaluatorContext;
+}): {
+    captureType: StructType | undefined;
+    captureValue: StructValue | UnknownValue | undefined;
+};
+export declare function enrichCapturedVariables({ capturedVariables, env, }: {
+    capturedVariables: Map<string, CapturedVariableInfo>;
+    env: Environment;
+}): Map<string, FunctionCapturedVariableInfo>;
+export declare function generateCapturedVariableDupExpressions({ capturedVariablesWithValues, env, context, }: {
+    capturedVariablesWithValues: Map<string, FunctionCapturedVariableInfo> | undefined;
+    env: Environment;
+    context: EvaluatorContext;
+}): {
+    capturedVariableDupExpressions: Expr[] | undefined;
+    env: Environment;
+};

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

@@ -0,0 +1,4 @@
+import { Environment, Variable } from "../env";
+import { Expr } from "../expr";
+export declare function isValidVariableName(expr: Expr): boolean;
+export declare function findGcValueOwnerRelationship(rhs: Expr, env: Environment, _modulePath: string): Variable | undefined;

package/out/types/src/evaluator/values/anonymous_function.d.ts

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

package/out/types/src/evaluator/values/anonymous_module.d.ts

@@ -0,0 +1,17 @@
+import { Environment } from "../../env";
+import { Expr } from "../../expr";
+import { ModuleType, Type } from "../../types";
+import { ModuleValue } from "../../value";
+import { EvaluatorContext } from "../context";
+export declare function evaluateAnonymousModuleBeginExprs({ beginExprs, env, context, allowPartialModule, receiverType, }: {
+    beginExprs: Expr[];
+    env: Environment;
+    context: EvaluatorContext;
+    allowPartialModule?: boolean;
+    receiverType?: Type;
+}): {
+    moduleValue: ModuleValue;
+    moduleType: ModuleType;
+    env: Environment;
+    partialModuleError?: Error;
+};

package/out/types/src/evaluator/values/anonymous_struct.d.ts

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

package/out/types/src/evaluator/values/array.d.ts

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

package/out/types/src/evaluator/values/boolean.d.ts

@@ -0,0 +1,3 @@
+import { Environment } from "../../env";
+import { AtomExpr } from "../../expr";
+export declare function evaluateBooleanLiteral(expr: AtomExpr, env: Environment): AtomExpr;

package/out/types/src/evaluator/values/char.d.ts

@@ -0,0 +1,3 @@
+import { Environment } from "../../env";
+import { AtomExpr } from "../../expr";
+export declare function evaluateCharLiteral(expr: AtomExpr, env: Environment): AtomExpr;

package/out/types/src/evaluator/values/compt_list.d.ts

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

package/out/types/src/evaluator/values/dyn.d.ts

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

package/out/types/src/evaluator/values/float.d.ts

@@ -0,0 +1,4 @@
+import { Environment } from "../../env";
+import { AtomExpr } from "../../expr";
+import { EvaluatorContext } from "../context";
+export declare function evaluateFloatLiteral(expr: AtomExpr, env: Environment, context: EvaluatorContext): AtomExpr;

package/out/types/src/evaluator/values/integer.d.ts

@@ -0,0 +1,4 @@
+import { Environment } from "../../env";
+import { AtomExpr } from "../../expr";
+import { EvaluatorContext } from "../context";
+export declare function evaluateIntegerLiteral(expr: AtomExpr, env: Environment, context: EvaluatorContext): AtomExpr;

package/out/types/src/evaluator/values/module.d.ts

@@ -0,0 +1,58 @@
+import { Environment } from "../../env";
+import { Expr, FuncCallExpr } from "../../expr";
+import { FunctionType, ModuleType, SomeType, Type } from "../../types";
+import { ModuleValue, UnknownValue, Value } from "../../value";
+import { EvaluatorContext } from "../context";
+export type ForallParameter = {
+    kind: "type";
+    name: string;
+    someType: SomeType;
+} | {
+    kind: "value";
+    name: string;
+    type: Type;
+    unknownValue: UnknownValue;
+};
+export interface GenericImpl {
+    forallParameters: ForallParameter[];
+    whereConstraints: {
+        someType: SomeType;
+        moduleType: ModuleType;
+    }[];
+    receiverTypePattern: Type;
+    moduleType: ModuleType;
+    moduleValue: ModuleValue;
+    expr: Expr;
+    sourceModulePath?: string;
+    definitionEnv: Environment;
+}
+export declare function clearGenericImplsFromModule(modulePath: string): void;
+export declare function clearAllGlobalImplState(): void;
+export declare function findMatchingGenericImpl({ concreteType, moduleType, env, }: {
+    concreteType: Type;
+    moduleType: ModuleType;
+    env: Environment;
+}): GenericImpl | undefined;
+export declare function findMethodsFromGenericImpls({ concreteType, methodName, env, }: {
+    concreteType: Type;
+    methodName: string;
+    env: Environment;
+}): {
+    type: FunctionType;
+    value: Value | undefined;
+}[];
+export declare function findMethodFromGenericImplForModule({ concreteType, moduleType, methodName, env, }: {
+    concreteType: Type;
+    moduleType: ModuleType;
+    methodName: string;
+    env: Environment;
+}): {
+    type: FunctionType;
+    value: Value | undefined;
+} | undefined;
+export declare function clearImplsFromModule(modulePath: string): void;
+export declare function evaluateModuleValue({ expr, env, context, }: {
+    expr: FuncCallExpr;
+    env: Environment;
+    context: EvaluatorContext;
+}): FuncCallExpr;

package/out/types/src/evaluator/values/string.d.ts

@@ -0,0 +1,3 @@
+import { Environment } from "../../env";
+import { AtomExpr } from "../../expr";
+export declare function evaluateStringLiteral(expr: AtomExpr, env: Environment): AtomExpr;

package/out/types/src/evaluator/values/tuple.d.ts

@@ -0,0 +1,32 @@
+import { Environment } from "../../env";
+import { Expr, FuncCallExpr } from "../../expr";
+import { TupleType, TypeField } from "../../types";
+import { TupleValue, Value } from "../../value";
+import { EvaluatorContext } from "../context";
+export declare function evaluateTupleElementValue({ expr, tupleFieldIndex, env, context, elementIndex, runtimeArgExprsInOrder, }: {
+    expr: Expr;
+    tupleFieldIndex: number;
+    env: Environment;
+    context: EvaluatorContext;
+    elementIndex: number;
+    runtimeArgExprsInOrder: Expr[];
+}): {
+    type: TypeField;
+    value: Value | undefined;
+    env: Environment;
+};
+export declare function evaluateTupleElementsValue({ args, env, context, }: {
+    args: Expr[];
+    env: Environment;
+    context: EvaluatorContext;
+}): {
+    type: TupleType;
+    value: TupleValue | undefined;
+    env: Environment;
+    runtimeArgExprsInOrder: Expr[];
+};
+export declare function evaluateTupleValue({ expr, env, context, }: {
+    expr: FuncCallExpr;
+    env: Environment;
+    context: EvaluatorContext;
+}): FuncCallExpr;