@shd101wyy/yo 0.0.2

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

@@ -0,0 +1,169 @@
+import { Environment } from "../env";
+import { YoError } from "../error";
+import { Expr, FuncCallExpr, PathCollection } from "../expr";
+import { FunctionValue } from "../function-value";
+import { Token } from "../token";
+import { FunctionType, Type } from "../types";
+import { ModuleValue, Value } from "../value";
+export interface FunctionEvaluationContext {
+    kind: "function-body";
+    type: FunctionType;
+    value?: FunctionValue;
+    evaluationEnv: Environment;
+}
+export type LoadModuleFn = (modulePath: string) => {
+    moduleValue: ModuleValue;
+    moduleError: Error | undefined;
+};
+export type EvaluateExpressionFn = ({ expr, env, context, }: {
+    expr: Expr;
+    env: Environment;
+    context: EvaluatorContext;
+}) => Expr;
+export interface AsyncBlockEvaluationContext {
+    kind: "async-block";
+    evaluationEnv: Environment;
+}
+export interface TestBlockEvaluationContext {
+    kind: "test-block";
+    evaluationEnv: Environment;
+}
+export interface EvaluatorContext {
+    isExecuting?: boolean;
+    isValidatingFunctionDefinition?: boolean;
+    expectedType?: {
+        type: Type;
+        env: Environment;
+    };
+    isEvaluatingFunctionBodyOrAsyncBlock?: FunctionEvaluationContext | AsyncBlockEvaluationContext | TestBlockEvaluationContext;
+    capturedVariables?: Map<string, CapturedVariableInfo>;
+    isEvaluatingLoopBody?: {
+        kind: "while" | "for";
+        env: Environment;
+    };
+    SelfType?: Type;
+    ReceiverType?: Type;
+    isEvaluatingFunctionType?: boolean;
+    loadModule?: (modulePath: string) => {
+        moduleValue: ModuleValue;
+        moduleError: Error | undefined;
+    };
+    stdPath: string;
+    currentModulePath?: string;
+    isUnsafeFunctionType?: boolean;
+    isInsideWhereClause?: boolean;
+    isLhsOfAssignment?: boolean;
+    functionReturnImplConcreteType?: Array<{
+        concreteType: Type;
+        env: Environment;
+        token: Token;
+    }>;
+}
+export interface ArgValues {
+    forallArgs: {
+        value: Value;
+        parameterType: Type;
+        argType: Type;
+    }[];
+    args: {
+        value: Value | undefined;
+        parameterType: Type;
+        argType: Type;
+    }[];
+    variadicArgs: {
+        value: Value | undefined;
+        argType: Type;
+    }[];
+}
+export interface FunctionCallResult {
+    calleeEnv: Environment;
+    callerEnv: Environment;
+    pathCollection: PathCollection;
+    returnType: Type;
+    returnValue: Value | undefined;
+    argValues: ArgValues;
+    runtimeArgExprsInOrder: Expr[];
+    specializedFunctionValue?: FunctionValue;
+    deferredDropExpressions?: Expr[];
+}
+export interface TypeCallResult {
+    values: (Value | undefined)[];
+    pathCollection: PathCollection;
+    runtimeArgExprsInOrder: Expr[];
+    callerEnv: Environment;
+}
+export interface ModuleTypeCallResult {
+    moduleValue: ModuleValue;
+    callerEnv: Environment;
+}
+export interface ArrayCallResult {
+    value: Value | undefined;
+    index?: number;
+    type: Type;
+    callerEnv: Environment;
+}
+export interface MacroFunctionCallResult {
+    calleeEnv: Environment;
+    callerEnv: Environment;
+    returnExpr: Expr;
+}
+export interface NumericTypeCallResult {
+    expr: Expr;
+    env: Environment;
+}
+export interface PointerTypeCallResult {
+    expr: Expr;
+    env: Environment;
+}
+export interface FunctionToCall {
+    type: Type;
+    args?: Expr[];
+    value?: Value;
+    result: {
+        kind: "function";
+        result: FunctionCallResult;
+    } | {
+        kind: "type";
+        result: TypeCallResult;
+    } | {
+        kind: "function-type";
+    } | {
+        kind: "array-type";
+    } | {
+        kind: "closure-type";
+    } | {
+        kind: "module-type";
+        result: ModuleTypeCallResult;
+    } | {
+        kind: "array";
+        result: ArrayCallResult;
+    } | {
+        kind: "numeric-type";
+        result: NumericTypeCallResult;
+    } | {
+        kind: "pointer-type";
+        result: PointerTypeCallResult;
+    } | {
+        kind: "iso-value";
+        result: FuncCallExpr;
+    } | {
+        kind: "error";
+        error: Error | YoError;
+    };
+}
+export declare function getFunctionCallResult(functionToCall: FunctionToCall): FunctionCallResult;
+export declare function getTypeCallResult(functionToCall: FunctionToCall): TypeCallResult;
+export declare function getModuleTypeCallResult(functionToCall: FunctionToCall): ModuleTypeCallResult;
+export declare function getArrayCallResult(functionToCall: FunctionToCall): ArrayCallResult;
+export declare function getPointerTypeCallResult(functionToCall: FunctionToCall): PointerTypeCallResult;
+export type EvaluateExpression = ({ expr, env, context, }: {
+    expr: Expr;
+    env: Environment;
+    context: EvaluatorContext;
+}) => Expr;
+export declare function trackVariableUsage(variableName: string, frameLevel: number, usageType: "read" | "write" | "own", token: Token, context: EvaluatorContext): void;
+export interface CapturedVariableInfo {
+    frameLevel: number;
+    usageType: "read" | "write" | "own";
+    token: Token;
+}

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

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

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

@@ -0,0 +1,9 @@
+import { Environment } from "../../env";
+import { ControlFlowKind, Expr, FuncCallExpr } from "../../expr";
+import { EvaluatorContext } from "../context";
+export declare function throwRhsContainsControlFlowExpressionError(rhs: Expr, controlFlow: ControlFlowKind): void;
+export declare function evaluateAssignment({ expr, env, context, }: {
+    expr: FuncCallExpr;
+    env: Environment;
+    context: EvaluatorContext;
+}): FuncCallExpr;

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

@@ -0,0 +1,10 @@
+import { Environment, Variable } from "../../env";
+import { Expr } from "../../expr";
+import { EvaluatorContext } from "../context";
+export declare function evaluateBeginExpression({ expr, env, context, variablesToAdd, isEvaluatingFunctionBodyBeginBlock, }: {
+    expr: Expr;
+    env: Environment;
+    context: EvaluatorContext;
+    variablesToAdd: Omit<Variable, "frameLevel" | "id">[];
+    isEvaluatingFunctionBodyBeginBlock?: boolean;
+}): Expr;

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

@@ -0,0 +1,12 @@
+import { Environment } from "../../env";
+import { Expr, FuncCallExpr } from "../../expr";
+import { EvaluatorContext } from "../context";
+export declare function evaluateBinding({ expr, env, context, }: {
+    expr: FuncCallExpr;
+    env: Environment;
+    context: EvaluatorContext;
+}): {
+    expr: FuncCallExpr;
+    variableExpr: Expr;
+    variableName: string;
+};

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

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

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

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

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

@@ -0,0 +1,33 @@
+import { Environment } from "../../env";
+import { Expr, RuntimeDestructuring } from "../../expr";
+import { Type } from "../../types";
+import { Value } from "../../value";
+import { EvaluatorContext } from "../context";
+export declare function handleMemberDestructuring({ lhsFunc, lhsFields, rhsFields, rhsValue, rhsType, lhs, env, isCompileTimeOnly, isDestructuringAtomVariable, }: {
+    lhsFunc: Expr;
+    lhsFields: Expr[];
+    rhsFields: {
+        label: string;
+        type: Type;
+    }[];
+    rhsValue: Value | undefined;
+    rhsType: Type;
+    lhs: Expr;
+    env: Environment;
+    context: EvaluatorContext;
+    isCompileTimeOnly: boolean;
+    isDestructuringAtomVariable: boolean;
+}): {
+    env: Environment;
+    runtimeDestructurings: RuntimeDestructuring[];
+};
+export declare function evaluateDestructuringAssignment({ lhs, rhs, env, isCompileTimeOnly, context, }: {
+    lhs: Expr;
+    rhs: Expr;
+    env: Environment;
+    isCompileTimeOnly: boolean;
+    context: EvaluatorContext;
+}): {
+    env: Environment;
+    runtimeDestructurings: RuntimeDestructuring[];
+};

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,21 @@
+import { Environment } from "../../env";
+import { FuncCallExpr } from "../../expr";
+import { Token } from "../../token";
+import { ModuleType, Type } from "../../types";
+import { EvaluatorContext } from "../context";
+export declare function typeImplementsModule({ targetType, moduleType, env, }: {
+    targetType: Type;
+    moduleType: ModuleType;
+    env: Environment;
+}): boolean;
+export declare function checkTypeImplementsSelfConstraints({ targetType, moduleType, env, errorToken, }: {
+    targetType: Type;
+    moduleType: ModuleType;
+    env: Environment;
+    errorToken: Token;
+}): void;
+export declare function evaluateSubtypeOf({ expr, env, context, }: {
+    expr: FuncCallExpr;
+    env: Environment;
+    context: EvaluatorContext;
+}): FuncCallExpr;

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

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

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

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

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

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

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

@@ -0,0 +1,26 @@
+import { Expr } from "../expr";
+import { Token } from "../token";
+import { ModuleValue } from "../value";
+import { LoadModuleFn } from "./context";
+import { clearAllGlobalImplState, clearGenericImplsFromModule, clearImplsFromModule } from "./values/module";
+export { clearAllGlobalImplState, clearGenericImplsFromModule, clearImplsFromModule, };
+export default class Evaluator {
+    private inputString;
+    private modulePath;
+    private parser;
+    private program;
+    private tokens;
+    private moduleValue;
+    private moduleError;
+    constructor({ modulePath, stdPath, loadModule, inputString, }: {
+        modulePath: string;
+        stdPath: string;
+        loadModule: LoadModuleFn;
+        inputString?: string;
+    });
+    getProgram(): Expr[];
+    getTokens(): Token[];
+    private evaluateProgram;
+    getModuleValue(): ModuleValue;
+    getModuleError(): Error | undefined;
+}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,14 @@
+import { Environment } from "../../env";
+import { Expr } from "../../expr";
+import { TypeField } from "../../types";
+import { EvaluatorContext } from "../context";
+export declare function evaluateTypeField({ expr, tupleFieldIndex, env, context, forType, }: {
+    expr: Expr;
+    tupleFieldIndex: number;
+    env: Environment;
+    context: EvaluatorContext;
+    forType: "tuple" | "struct" | "enum" | "union";
+}): {
+    field: TypeField;
+    env: Environment;
+};

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

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

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

@@ -0,0 +1,58 @@
+import { Environment } from "../../env";
+import { Expr, FuncCallExpr } from "../../expr";
+import { FunctionParameter, FunctionType, ModuleType, SomeType, Type } from "../../types";
+import { EvaluatorContext } from "../context";
+export declare function evaluateFunctionParameter({ expr, env, context, isParameterComptByDefault, }: {
+    expr: Expr;
+    env: Environment;
+    context: EvaluatorContext & {
+        isEvaluatingFunctionType: true;
+    };
+    isParameterComptByDefault: boolean;
+}): {
+    parameter: FunctionParameter;
+    env: Environment;
+};
+export declare function evaluateFunctionParameters({ parameterExprs, env, context, }: {
+    parameterExprs: Expr[];
+    env: Environment;
+    context: EvaluatorContext & {
+        isEvaluatingFunctionType: true;
+    };
+}): {
+    parameters: FunctionParameter[];
+    forallParameters: FunctionParameter[];
+    variadicParameter?: FunctionParameter;
+    env: Environment;
+    whereClauseConstraints?: Map<SomeType, {
+        requiredModules: ModuleType[];
+        negativeModules: ModuleType[];
+    }>;
+};
+export declare function evaluateFunctionType({ expr, env, context, }: {
+    expr: FuncCallExpr;
+    env: Environment;
+    context: EvaluatorContext;
+}): FuncCallExpr;
+export declare function evaluateFunctionParameterTypeAgain({ parameter, calleeEnv, context, functionType, }: {
+    parameter: FunctionParameter;
+    calleeEnv: Environment;
+    context: EvaluatorContext & {
+        isEvaluatingFunctionType: true;
+    };
+    functionType: FunctionType;
+}): {
+    parameterType: Type;
+    calleeEnv: Environment;
+};
+export declare function evaluateFunctionReturnTypeAgain({ functionType, calleeEnv, context, functionCalleeExpr, }: {
+    functionType: FunctionType;
+    calleeEnv: Environment;
+    context: EvaluatorContext & {
+        isEvaluatingFunctionType: true;
+    };
+    functionCalleeExpr?: Expr;
+}): {
+    returnType: Type;
+    calleeEnv: Environment;
+};

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

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

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

@@ -0,0 +1,19 @@
+import { Environment } from "../../env";
+import { Expr, FuncCallExpr } from "../../expr";
+import { ModuleField } from "../../types";
+import { EvaluatorContext } from "../context";
+export declare function evaluateModuleField({ expr, moduleFieldIndex, env, context, isForEvaluatingModuleType, }: {
+    expr: Expr;
+    moduleFieldIndex: number;
+    env: Environment;
+    context: EvaluatorContext;
+    isForEvaluatingModuleType: boolean;
+}): {
+    field: ModuleField;
+    env: Environment;
+};
+export declare function evaluateModuleType({ expr, env, context, }: {
+    expr: FuncCallExpr;
+    env: Environment;
+    context: EvaluatorContext;
+}): FuncCallExpr;

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

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

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

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