@shd101wyy/yo 0.0.13 → 0.0.14

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

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

package/out/types/src/evaluator/exprs/{c_include.d.ts → c-include.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 evaluateCInclude({ expr, env, context, }: {
     expr: FnCallExpr;
     env: Environment;

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

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

package/out/types/src/evaluator/exprs/{destructuring_assignment.d.ts → destructuring-assignment.d.ts}

@@ -1,8 +1,8 @@
-import { Environment } from "../../env";
-import { Expr, RuntimeDestructuring } from "../../expr";
-import { Type } from "../../types";
-import { Value } from "../../value";
-import { EvaluatorContext } from "../context";
+import { type Environment } from "../../env";
+import { type Expr, type RuntimeDestructuring } from "../../expr";
+import type { Type } from "../../types/definitions";
+import { type Value } from "../../value";
+import type { EvaluatorContext } from "../context";
 export declare function handleMemberDestructuring({ lhsFunc, lhsFields, rhsFields, rhsValue, rhsType, lhs, env, isCompileTimeOnly, isDestructuringAtomVariable, }: {
     lhsFunc: Expr;
     lhsFields: Expr[];

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

@@ -1,6 +1,6 @@
-import { Environment } from "../../env";
-import { Expr } from "../../expr";
-import { EvaluateExpressionFn, EvaluatorContext } from "../context";
+import type { Environment } from "../../env";
+import type { Expr } from "../../expr";
+import type { EvaluateExpressionFn, EvaluatorContext } from "../context";
 export declare function setEvaluateExpressionFn(fn: EvaluateExpressionFn): void;
 export declare function evaluateExpression({ expr, env, context, }: {
     expr: Expr;

package/out/types/src/evaluator/exprs/extern.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 evaluateExtern({ expr, env, context, }: {
     expr: FnCallExpr;
     env: Environment;

package/out/types/src/evaluator/exprs/{identifer_and_operator.d.ts → identifer-and-operator.d.ts}

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

package/out/types/src/evaluator/exprs/import.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 evaluateImport({ expr, env, context, stdPath, }: {
     expr: FnCallExpr;
     env: Environment;

package/out/types/src/evaluator/exprs/{initialization_assignment.d.ts → initialization-assignment.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 evaluateInitializationAssignment({ expr, env, context, }: {
     expr: FnCallExpr;
     env: Environment;

package/out/types/src/evaluator/exprs/match.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 evaluateMatch({ expr, env, context, }: {
     expr: FnCallExpr;
     env: Environment;

package/out/types/src/evaluator/exprs/open.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 evaluateOpen({ expr, env, context, }: {
     expr: FnCallExpr;
     env: Environment;

package/out/types/src/evaluator/exprs/{property_access.d.ts → property-access.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 evaluatePropertyAccess({ expr, env, context, }: {
     expr: FnCallExpr;
     env: Environment;

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

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

package/out/types/src/evaluator/exprs/runtime.d.ts

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

package/out/types/src/evaluator/exprs/subtype-of.d.ts

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

package/out/types/src/evaluator/exprs/test.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 evaluateTest({ expr, env, context, }: {
     expr: FnCallExpr;
     env: Environment;

package/out/types/src/evaluator/exprs/typeof.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 evaluateTypeOf({ expr, env, context, }: {
     expr: FnCallExpr;
     env: Environment;

package/out/types/src/evaluator/exprs/while.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 evaluateWhile({ expr, env, context, }: {
     expr: FnCallExpr;
     env: Environment;

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

@@ -1,7 +1,7 @@
-import { Expr } from "../expr";
-import { Token } from "../token";
-import { ModuleValue } from "../value";
-import { LoadModuleFn } from "./context";
+import type { Expr } from "../expr";
+import { type Token } from "../token";
+import type { ModuleValue } from "../value";
+import type { LoadModuleFn } from "./context";
 import { clearAllGlobalImplState, clearGenericImplsFromModule, clearImplsFromModule } from "./values/impl";
 export { clearAllGlobalImplState, clearGenericImplsFromModule, clearImplsFromModule, };
 export default class Evaluator {

package/out/types/src/evaluator/trait-checking.d.ts

@@ -0,0 +1,31 @@
+import { type Environment } from "../env";
+import type { Token } from "../token";
+import type { DynType, FnTraitType, FutureTraitType, SomeType, TraitType, Type } from "../types/definitions";
+import type { EvaluatorContext } from "./context";
+export declare function typeImplementsTrait({ targetType, traitType, env, }: {
+    targetType: Type;
+    traitType: TraitType;
+    env: Environment;
+}): boolean;
+export declare function checkTypeImplementsSelfConstraints({ targetType, traitType, env, errorToken, }: {
+    targetType: Type;
+    traitType: TraitType;
+    env: Environment;
+    errorToken: Token;
+}): void;
+export declare function typeImplementsComptime(type: Type, env: Environment): boolean;
+export declare function typeImplementsRuntime(type: Type, env: Environment): boolean;
+export declare function typeImplementsSend(type: Type | undefined, env: Environment): boolean;
+export declare function typeImplementsDispose(type: Type | undefined, env: Environment): boolean;
+export declare function typeImplementsAcyclic(type: Type | undefined, env: Environment): boolean;
+export declare function typeIsComptimeOnly(type: Type, env: Environment): boolean;
+export declare function typeIsRuntimeOnly(type: Type, env: Environment): boolean;
+export declare function typeImplementsFn(type: Type | undefined): type is (SomeType | DynType) & {
+    isFn: true;
+};
+export declare function extractFnTraitFromType(type: Type): FnTraitType | undefined;
+export declare function typeImplementsFuture(type: Type | undefined): type is (SomeType | DynType) & {
+    isFuture: true;
+};
+export declare function extractFutureTraitFromType(type: Type): FutureTraitType | undefined;
+export declare function validateTypeAvailability(type: Type, env: Environment, token: Token, _context?: EvaluatorContext): void;

package/out/types/src/evaluator/types/array.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 evaluateArrayType({ expr, env, context, }: {
     expr: FnCallExpr;
     env: Environment;

package/out/types/src/evaluator/types/closure.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 evaluateClosureType({ expr, env, context, }: {
     expr: FnCallExpr;
     env: Environment;

package/out/types/src/evaluator/types/comptime-list.d.ts

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

package/out/types/src/evaluator/types/{concrete_trait.d.ts → concrete-trait.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 evaluateConcreteType({ expr, env, context, }: {
     expr: FnCallExpr;
     env: Environment;

package/out/types/src/evaluator/types/dyn.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 evaluateDynType({ expr, env, context, }: {
     expr: FnCallExpr;
     env: Environment;

package/out/types/src/evaluator/types/enum.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 evaluateEnumType({ expr, env, context, }: {
     expr: FnCallExpr;
     env: Environment;

package/out/types/src/evaluator/types/{expr_synthesizer.d.ts → expr-synthesizer.d.ts}

@@ -1,7 +1,7 @@
-import { Environment } from "../../env";
-import { Expr } from "../../expr";
-import { Type } from "../../types";
-import { EvaluatorContext } from "../context";
+import type { Environment } from "../../env";
+import { type Expr } from "../../expr";
+import type { Type } from "../../types/definitions";
+import type { EvaluatorContext } from "../context";
 export declare function synthesizeExprAndType({ expr, type, env, context, }: {
     expr: Expr;
     type: Type;

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

@@ -1,7 +1,7 @@
-import { Environment } from "../../env";
-import { Expr } from "../../expr";
-import { TypeField } from "../../types";
-import { EvaluatorContext } from "../context";
+import type { Environment } from "../../env";
+import { type Expr } from "../../expr";
+import type { TypeField } from "../../types/definitions";
+import type { EvaluatorContext } from "../context";
 export declare function evaluateTypeField({ expr, tupleFieldIndex, env, context, forType, }: {
     expr: Expr;
     tupleFieldIndex: number;

package/out/types/src/evaluator/types/{fn_trait.d.ts → fn-trait.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 evaluateFnTraitType({ expr, env, context, }: {
     expr: FnCallExpr;
     env: Environment;

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

@@ -1,18 +1,27 @@
-import { Environment } from "../../env";
-import { Expr, FnCallExpr } from "../../expr";
-import { FunctionParameter, FunctionType, SomeType, TraitType, Type } from "../../types";
-import { EvaluatorContext } from "../context";
-export declare function evaluateFunctionParameter({ expr, env, context, isParameterComptByDefault, }: {
+import { type Environment } from "../../env";
+import { type Expr, type FnCallExpr } from "../../expr";
+import type { FunctionParameter, FunctionType, Type } from "../../types/definitions";
+import type { EvaluatorContext } from "../context";
+export declare function evaluateFunctionParameter({ expr, env, context, isParameterComptimeByDefault, }: {
     expr: Expr;
     env: Environment;
     context: EvaluatorContext & {
         isEvaluatingFunctionType: true;
     };
-    isParameterComptByDefault: boolean;
+    isParameterComptimeByDefault: boolean;
 }): {
     parameter: FunctionParameter;
     env: Environment;
 };
+export declare function applyWhereClauseConstraints({ constraintExprs, env, context, }: {
+    constraintExprs: Expr[];
+    env: Environment;
+    context: EvaluatorContext & {
+        isEvaluatingFunctionType: true;
+    };
+}): {
+    env: Environment;
+};
 export declare function evaluateFunctionParameters({ parameterExprs, env, context, }: {
     parameterExprs: Expr[];
     env: Environment;
@@ -23,11 +32,8 @@ export declare function evaluateFunctionParameters({ parameterExprs, env, contex
     parameters: FunctionParameter[];
     forallParameters: FunctionParameter[];
     variadicParameter?: FunctionParameter;
+    whereClauseExprs?: Expr[];
     env: Environment;
-    whereClauseConstraints?: Map<SomeType, {
-        requiredTraits: TraitType[];
-        negativeTraits: TraitType[];
-    }>;
 };
 export declare function evaluateFunctionType({ expr, env, context, }: {
     expr: FnCallExpr;

package/out/types/src/evaluator/types/{future_trait.d.ts → future-trait.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 evaluateFutureType({ expr, env, context, }: {
     expr: FnCallExpr;
     env: Environment;

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

@@ -1,7 +1,7 @@
-import { Environment } from "../../env";
-import { Expr, FnCallExpr } from "../../expr";
-import { ModuleField } from "../../types";
-import { EvaluatorContext } from "../context";
+import type { Environment } from "../../env";
+import { type Expr, type FnCallExpr } from "../../expr";
+import type { ModuleField } from "../../types/definitions";
+import type { EvaluatorContext } from "../context";
 export declare function evaluateModuleField({ expr, moduleFieldIndex, env, context, isForEvaluatingModuleType, }: {
     expr: Expr;
     moduleFieldIndex: number;

package/out/types/src/evaluator/types/newtype.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 evaluateNewtypeType({ expr, env, context, }: {
     expr: FnCallExpr;
     env: Environment;

package/out/types/src/evaluator/types/object.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 evaluateObjectType({ expr, env, context, }: {
     expr: FnCallExpr;
     env: Environment;

package/out/types/src/evaluator/types/slice.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 evaluateSliceType({ expr, env, context, }: {
     expr: FnCallExpr;
     env: Environment;

package/out/types/src/evaluator/types/struct.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 evaluateStructType({ expr, env, context, }: {
     expr: FnCallExpr;
     env: Environment;

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

@@ -1,5 +1,5 @@
-import { Environment } from "../../env";
-import { Type } from "../../types";
+import { type Environment } from "../../env";
+import type { Type } from "../../types/definitions";
 export declare function canAssignTypeHierarchy(expected: Type, given: Type): boolean;
 export declare function synthesizeTypes(expected: {
     type: Type;

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

@@ -1,7 +1,7 @@
-import { Environment } from "../../env";
-import { Expr, FnCallExpr } from "../../expr";
-import { TraitField } from "../../types";
-import { EvaluatorContext } from "../context";
+import { type Environment } from "../../env";
+import { type Expr, type FnCallExpr } from "../../expr";
+import type { TraitField } from "../../types/definitions";
+import type { EvaluatorContext } from "../context";
 export declare function evaluateTraitField({ expr, traitFieldIndex, env, context, isForEvaluatingTraitType, }: {
     expr: Expr;
     traitFieldIndex: number;

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

@@ -1,7 +1,7 @@
-import { Environment } from "../../env";
-import { Expr, FnCallExpr } from "../../expr";
-import { TupleType } from "../../types";
-import { EvaluatorContext } from "../context";
+import type { Environment } from "../../env";
+import { type Expr, type FnCallExpr } from "../../expr";
+import type { TupleType } from "../../types/definitions";
+import type { EvaluatorContext } from "../context";
 export declare function evaluateTupleElementsType({ args, env, context, forType, }: {
     args: Expr[];
     env: Environment;

package/out/types/src/evaluator/types/union.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 evaluateUnionType({ expr, env, context, }: {
     expr: FnCallExpr;
     env: Environment;