@shd101wyy/yo 0.1.25 → 0.1.27

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

@@ -1,12 +1,12 @@
 import type { Expr } from "../expr";
-import type { ModuleValue } from "../value";
+import type { StructValue } from "../value";
 export declare class CodeGeneratorC {
     private emitter;
     private exportedFunctionNames;
     private _needsIntelAsmSyntax;
     private _usesParallelism;
     constructor();
-    compileModule(modulePath: string, moduleValue: ModuleValue, options?: {
+    compileModule(modulePath: string, moduleValue: StructValue, options?: {
         debugGc?: boolean;
         debugParallelism?: boolean;
         debugAsyncAwait?: boolean;

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

@@ -1,6 +1,6 @@
 import { type Expr } from "../../expr";
-import { type ModuleValue, type TraitValue } from "../../value";
+import { type StructValue, type TraitValue } from "../../value";
 import { type CodeGenContext } from "../utils";
-export declare function collectRequiredFunctions(moduleValue: ModuleValue | TraitValue, context: CodeGenContext, isTopLevelExport?: boolean): void;
+export declare function collectRequiredFunctions(moduleValue: StructValue | TraitValue, context: CodeGenContext, isTopLevelExport?: boolean): 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

@@ -27,7 +27,7 @@ export interface FunctionGenerationContext extends CodeGenContext {
     stateMachineVariables?: Map<string, CapturedVariable>;
     stateMachineFieldAliases?: Map<string, string>;
     inEffectStateMachine?: unknown;
-    isModuleEffectMemberFunction?: boolean;
+    isEffectRecordMemberFunction?: boolean;
     currentEvidenceParams?: Map<string, EvidenceParameter>;
     continuationVariables?: Map<string, {
         directReturnVar: string;
@@ -44,8 +44,9 @@ export interface FunctionGenerationContext extends CodeGenContext {
         resumeFunctionName: string;
         constructorName: string;
         disposeFunctionName: string;
+        setEffectFunctionName: string;
         futureType: SomeType | DynType;
-        futureModuleType: FutureTraitType;
+        futureTraitType: FutureTraitType;
         resultType: Type;
         resultTypeCName: string;
         captureType: StructType | undefined;

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

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

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

@@ -3,7 +3,7 @@ import { type Environment } from "../../env";
 import { type Expr } from "../../expr";
 import type { FunctionValue, FuncValueId } from "../../function-value";
 import type { TargetInfo } from "../../target";
-import type { DynType, EnumType, FunctionType, IsoType, StructType, Type, TypeId } from "../../types/definitions";
+import type { DynType, EnumType, FunctionType, IsoType, StructType, Type, TypeField, TypeId } from "../../types/definitions";
 import { type TraitValue } from "../../value";
 export interface CodeGenContext {
     types: Record<TypeId, {
@@ -83,6 +83,8 @@ export interface CodeGenContext {
     currentModuleId?: string;
     exportedFunctionLabels?: Map<FuncValueId, string>;
 }
+export declare function isComptimeOnlyStructField(field: TypeField, _ownerType: StructType): boolean;
+export declare function getRuntimeStructFields(structType: StructType): TypeField[];
 export declare function sanitizeForCIdentifier(str: string, isExternC?: boolean): string;
 export declare function shouldAvoidConst(type: Type): boolean;
 export declare function getTypeString(type: Type | undefined, context: CodeGenContext): string;

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

@@ -1,12 +1,12 @@
 import type { Token } from "../token";
 import type { Environment } from "../env";
-import type { ModuleValue } from "../value";
+import type { StructValue } from "../value";
 import type { DocExtractionResult } from "./extractor";
 import type { DocModule } from "./model";
 export interface BuildDocModuleOptions {
     name: string;
     path: string;
-    moduleValue: ModuleValue;
+    moduleValue: StructValue;
     extraction: DocExtractionResult;
     tokens: Token[];
     env?: Environment;

package/out/types/src/evaluator/calls/closure-type.d.ts

@@ -2,9 +2,9 @@ import { type Environment } from "../../env";
 import { type Expr, type FnCallExpr } from "../../expr";
 import type { DynType, FnTraitType, SomeType } from "../../types/definitions";
 import type { EvaluatorContext } from "../context";
-export declare function tryToImplementClosureByFnModuleType({ expr, fnModuleType, wrapperType, callerEnv, context, }: {
+export declare function tryToImplementClosureByFnTraitType({ expr, fnTraitType, wrapperType, callerEnv, context, }: {
     expr: FnCallExpr;
-    fnModuleType: FnTraitType;
+    fnTraitType: FnTraitType;
     wrapperType: SomeType | DynType;
     callerEnv: Environment;
     context: EvaluatorContext;

package/out/types/src/evaluator/calls/record-type.d.ts

@@ -0,0 +1,11 @@
+import { type Environment } from "../../env";
+import { type Expr } from "../../expr";
+import type { SourceNamespaceType } from "../../types/definitions";
+import type { EvaluatorContext, RecordTypeCallResult } from "../context";
+export declare function tryToImplementRecordWithArgumentsByRecordType({ moduleExpr, sourceNamespaceType, argExprs, callerEnv, context, }: {
+    moduleExpr: Expr;
+    sourceNamespaceType: SourceNamespaceType;
+    argExprs: Expr[];
+    callerEnv: Environment;
+    context: EvaluatorContext;
+}): RecordTypeCallResult;

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

@@ -4,7 +4,7 @@ import type { Expr, FnCallExpr, PathCollection, ComptimeRef } from "../expr";
 import type { FunctionValue } from "../function-value";
 import type { Token } from "../token";
 import type { FunctionType, TraitType, Type } from "../types/definitions";
-import type { ModuleValue, TraitValue, Value } from "../value";
+import type { StructValue, TraitValue, Value } from "../value";
 export interface FunctionEvaluationContext {
     kind: "function-body";
     type: FunctionType;
@@ -12,7 +12,7 @@ export interface FunctionEvaluationContext {
     evaluationEnv: Environment;
 }
 export type LoadModuleFn = (modulePath: string) => {
-    moduleValue: ModuleValue;
+    moduleValue: StructValue;
     moduleError: Error | undefined;
 };
 export type EvaluateExpressionFn = ({ expr, env, context, }: {
@@ -45,11 +45,10 @@ export interface EvaluatorContext {
     };
     SelfType?: Type;
     SelfTraitType?: Type;
-    SelfModuleType?: Type;
     ReceiverType?: Type;
     isEvaluatingFunctionType?: boolean;
     loadModule?: (modulePath: string) => {
-        moduleValue: ModuleValue;
+        moduleValue: StructValue;
         moduleError: Error | undefined;
     };
     stdPath: string;
@@ -122,8 +121,8 @@ export interface TypeCallResult {
     runtimeArgExprsInOrder: Expr[];
     callerEnv: Environment;
 }
-export interface ModuleTypeCallResult {
-    moduleValue: ModuleValue;
+export interface RecordTypeCallResult {
+    moduleValue: StructValue;
     callerEnv: Environment;
 }
 export interface TraitTypeCallResult {
@@ -174,8 +173,8 @@ export interface FunctionToCall {
     } | {
         kind: "closure-type";
     } | {
-        kind: "module-type";
-        result: ModuleTypeCallResult;
+        kind: "record-type";
+        result: RecordTypeCallResult;
     } | {
         kind: "trait-type";
         result: TraitTypeCallResult;
@@ -201,7 +200,7 @@ export interface FunctionToCall {
 }
 export declare function getFunctionCallResult(functionToCall: FunctionToCall): FunctionCallResult;
 export declare function getTypeCallResult(functionToCall: FunctionToCall): TypeCallResult;
-export declare function getModuleTypeCallResult(functionToCall: FunctionToCall): ModuleTypeCallResult;
+export declare function getRecordTypeCallResult(functionToCall: FunctionToCall): RecordTypeCallResult;
 export declare function getTraitTypeCallResult(functionToCall: FunctionToCall): TraitTypeCallResult;
 export declare function getIndexCallResult(functionToCall: FunctionToCall): IndexCallResult;
 export declare function getPointerTypeCallResult(functionToCall: FunctionToCall): PointerTypeCallResult;

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

@@ -1,7 +1,7 @@
 import { type Environment } from "../env";
 import type { Expr } from "../expr";
 import { type Token } from "../token";
-import type { ModuleValue } from "../value";
+import type { StructValue } from "../value";
 import type { LoadModuleFn } from "./context";
 import { clearAllGlobalImplState, clearGenericImplsFromModule, clearImplsFromModule } from "./values/impl";
 export { clearAllGlobalImplState, clearGenericImplsFromModule, clearImplsFromModule, };
@@ -22,12 +22,12 @@ export default class Evaluator {
         loadModule: LoadModuleFn;
         inputString?: string;
         allowPartialModule?: boolean;
-        registerPartialModule?: (mv: ModuleValue) => void;
+        registerPartialModule?: (mv: StructValue) => void;
     });
     getProgram(): Expr[];
     getTokens(): Token[];
     private evaluateProgram;
-    getModuleValue(): ModuleValue;
+    getModuleValue(): StructValue;
     getModuleError(): Error | undefined;
     getEnv(): Environment;
 }

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

@@ -0,0 +1,14 @@
+import type { Environment } from "../../env";
+import { type Expr } from "../../expr";
+import type { TypeField } from "../../types/definitions";
+import type { EvaluatorContext } from "../context";
+export declare function evaluateRecordField({ expr, recordFieldIndex, env, context, isForEvaluatingRecordType, }: {
+    expr: Expr;
+    recordFieldIndex: number;
+    env: Environment;
+    context: EvaluatorContext;
+    isForEvaluatingRecordType: boolean;
+}): {
+    field: TypeField;
+    env: Environment;
+};

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

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

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

@@ -1,17 +1,17 @@
 import { type Environment } from "../../env";
 import { type Expr } from "../../expr";
-import type { ModuleType } from "../../types/definitions";
-import type { ModuleValue } from "../../value";
+import type { SourceNamespaceType } from "../../types/definitions";
+import type { StructValue } from "../../value";
 import type { EvaluatorContext } from "../context";
 export declare function evaluateAnonymousModuleBeginExprs({ beginExprs, env, context, allowPartialModule, registerPartialModule, }: {
     beginExprs: Expr[];
     env: Environment;
     context: EvaluatorContext;
     allowPartialModule?: boolean;
-    registerPartialModule?: (mv: ModuleValue) => void;
+    registerPartialModule?: (mv: StructValue) => void;
 }): {
-    moduleValue: ModuleValue;
-    moduleType: ModuleType;
+    moduleValue: StructValue;
+    sourceNamespaceType: SourceNamespaceType;
     env: Environment;
     partialModuleError?: Error;
 };

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

@@ -85,7 +85,7 @@ export declare function findMethodFromGenericImplForTrait({ concreteType, traitT
 } | undefined;
 export declare function clearImplsFromModule(modulePath: string): void;
 export declare function snapshotAllImplTraitFields(): Map<TraitType, TraitField[]>;
-export declare function evaluateModuleValue({ expr, env, context, }: {
+export declare function evaluateImplBlock({ expr, env, context, }: {
     expr: FnCallExpr;
     env: Environment;
     context: EvaluatorContext;

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

@@ -4,7 +4,7 @@ import type { EvaluatorContext } from "./evaluator/context";
 import type { EffectAnalysisResult } from "./evaluator/effects/effect-analysis-types";
 import { type Token } from "./token";
 import type { FunctionType, StructType, Type } from "./types/definitions";
-import { type ArrayValue, type ComptimeListValue, type StructValue, type TupleValue, type TraitValue, type Value } from "./value";
+import { type ArrayValue, type ComptimeListValue, type StructValue, type TraitValue, type TupleValue, type Value } from "./value";
 import { ValueTag } from "./value-tag";
 export type Path = string[];
 export type PathCollection = Path[];
@@ -140,12 +140,10 @@ export declare const BuiltinKeywords: {
     newtype: string[];
     enum: string[];
     union: string[];
-    module: string[];
     trait: string[];
     impl: string[];
     Impl: string[];
     begin: string[];
-    module_begin: string[];
     import: string[];
     export: string[];
     open: string[];
@@ -174,7 +172,6 @@ export declare const BuiltinKeywords: {
     Future: string[];
     Concrete: string[];
     Type: string[];
-    Module: string[];
     Trait: string[];
     ComptimeList: string[];
     tuple: string[];

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

@@ -0,0 +1,11 @@
+export interface FormatYoFilesOptions {
+    check?: boolean;
+    cwd?: string;
+}
+export interface FormatYoFilesResult {
+    files: string[];
+    changed: string[];
+}
+export declare function formatYoSource(input: string, modulePath?: string): string;
+export declare function findYoFormatFiles(inputPaths: string[], cwd?: string): string[];
+export declare function formatYoFiles(inputPaths: string[], options?: FormatYoFilesOptions): FormatYoFilesResult;

package/out/types/src/function-value.d.ts

@@ -33,7 +33,7 @@ export type FunctionValue = {
     isControlFunction?: boolean;
     definitionSiteEnclosingFunctionType?: FunctionType;
     closureInfo?: ClosureInfo;
-    isModuleEffectMember?: boolean;
+    isEffectRecordMember?: boolean;
     isIoAsyncStateMachineClosure?: boolean;
     deriveRule?: FunctionValue;
 };

package/out/types/src/lsp/document-manager.d.ts

@@ -14,7 +14,7 @@ export declare class LspDocumentManager {
     attachToDocuments(documents: TextDocuments<TextDocument>, onDiagnostics: (uri: string) => void): void;
     analyzeDocument(document: TextDocument, onDiagnostics: (uri: string) => void): void;
     getModule(uri: string): {
-        moduleValue: import("../value").ModuleValue;
+        moduleValue: import("../value").StructValue;
         moduleError: Error | undefined;
         evaluator: import("../evaluator").default;
     } | undefined;

package/out/types/src/lsp/formatting.d.ts

@@ -0,0 +1,2 @@
+import { TextEdit } from "vscode-languageserver/node";
+export declare function handleDocumentFormatting(uri: string, content: string): TextEdit[] | null;

package/out/types/src/module-manager.d.ts

@@ -1,8 +1,8 @@
 import Evaluator from "./evaluator/index";
-import type { ModuleValue } from "./value";
+import type { StructValue } from "./value";
 export declare class ModuleManager {
     modules: Map<string, {
-        moduleValue: ModuleValue;
+        moduleValue: StructValue;
         moduleError: Error | undefined;
         evaluator: Evaluator;
     }>;
@@ -25,7 +25,7 @@ export declare class ModuleManager {
     private clearDependencies;
     resetAllState(): void;
     loadModule(modulePath: string, inputString?: string, parentModule?: string): {
-        moduleValue: ModuleValue;
+        moduleValue: StructValue;
         moduleError: Error | undefined;
     };
     deleteModule(modulePath: string): void;

package/out/types/src/tests/formatter.test.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -3,7 +3,7 @@ import type { EvaluatorContext } from "../evaluator/context";
 import type { Expr } from "../expr";
 import type { FunctionValue } from "../function-value";
 import { type Value } from "../value";
-import type { ArrayType, ComptimeListType, DynType, EffectsRowType, EnumType, FnTraitType, FunctionForallParameter, FunctionImplicitParameter, FunctionParameter, FunctionParameterExprs, FunctionReturn, FunctionType, FutureTraitType, IsoType, ModuleType, PtrType, SliceType, SomeType, StructType, TraitType, TupleType, Type, TypeApplicationType, TypeField, TypeHierarchyType, UnionType, VoidType } from "./definitions";
+import type { ArrayType, ComptimeListType, DynType, EffectsRowType, EnumType, FnTraitType, FunctionForallParameter, FunctionImplicitParameter, FunctionParameter, FunctionParameterExprs, FunctionReturn, FunctionType, FutureTraitType, IsoType, SourceNamespaceType, PtrType, SliceType, SomeType, StructType, TraitType, TupleType, Type, TypeApplicationType, TypeField, TypeHierarchyType, UnionType, VoidType } from "./definitions";
 export declare function createComptimeIntType(): Type;
 export declare function createComptimeFloatType(): Type;
 export declare function createComptimeStringType(): Type;
@@ -41,11 +41,11 @@ export declare function createStrType(env: Environment): Type;
 export declare function createVoidType(): VoidType;
 export declare function createTupleType(fields: TypeField[]): TupleType;
 export declare function createStructType(env: Environment, isReferenceSemantics?: boolean, isNewtype?: boolean, isAtomicRc?: boolean): StructType;
-export declare function createModuleType(env: Environment): ModuleType;
+export declare function createSourceNamespaceType(env: Environment): SourceNamespaceType;
 export declare function createTraitType(env: Environment): TraitType;
 export declare function createEnumType(env: Environment): EnumType;
 export declare function createUnionType(env: Environment): UnionType;
-export declare function createFunctionType({ parameters, forallParameters, implicitParameters, variadicParameter, whereClauseExprs, return_, env, parametersFrame, SelfType, SelfTraitType, SelfModuleType, isClosure, }: {
+export declare function createFunctionType({ parameters, forallParameters, implicitParameters, variadicParameter, whereClauseExprs, return_, env, parametersFrame, SelfType, SelfTraitType, isClosure, }: {
     parameters: FunctionParameter[];
     forallParameters: FunctionForallParameter[];
     implicitParameters?: FunctionImplicitParameter[];
@@ -56,7 +56,6 @@ export declare function createFunctionType({ parameters, forallParameters, impli
     parametersFrame: Frame;
     SelfType?: Type;
     SelfTraitType?: Type;
-    SelfModuleType?: Type;
     isClosure?: boolean;
 }): FunctionType;
 export declare function createPtrType(childType: Type): PtrType;

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

@@ -93,10 +93,12 @@ export type FieldExprs = {
 export interface TypeField {
     type: Type;
     label: string;
+    isCompileTimeOnly?: boolean;
     defaultValue?: Value;
     assignedValue?: Value;
     exprs: FieldExprs;
     isEffectParam?: boolean;
+    sourceModulePath?: string;
     docComment?: string;
 }
 export interface TupleType extends Type {
@@ -135,30 +137,18 @@ export interface StructType extends Type {
     isReferenceSemantics: boolean;
     isAtomicRc?: boolean;
     isNewtype: boolean;
+    isSourceNamespace?: true;
     functionValue?: FunctionValue;
     fields: TypeField[];
     trait: TraitType;
     env: Environment;
 }
-export interface ModuleField {
-    type: Type;
-    label: string;
-    sourceModulePath?: string;
-    defaultValue?: Value;
-    assignedValue?: Value;
-    exprs: FieldExprs;
-    docComment?: string;
-}
-export interface TraitField extends ModuleField {
+export interface TraitField extends TypeField {
     unassignedSomeType?: SomeType;
 }
-export interface ModuleType extends Type {
-    tag: TypeTag.Module;
-    functionValue?: FunctionValue;
-    fields: ModuleField[];
-    trait: undefined;
-    env: Environment;
-}
+export type SourceNamespaceType = StructType & {
+    isSourceNamespace: true;
+};
 export interface TraitType extends Type {
     tag: TypeTag.Trait;
     functionValue?: FunctionValue;
@@ -197,7 +187,7 @@ export type FutureTraitType = TraitType & {
         effects: FunctionImplicitParameter[];
     };
 };
-export type ConcreteModuleType = TraitType & {
+export type ConcreteTraitType = TraitType & {
     isConcrete: {
         concreteType: Type;
     };
@@ -245,7 +235,6 @@ export interface FunctionType extends Type {
     parametersFrame: Frame;
     SelfType?: Type;
     SelfTraitType?: Type;
-    SelfModuleType?: Type;
     trait: TraitType;
     isClosure?: boolean;
 }

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

@@ -1,5 +1,5 @@
 import { FunctionValue } from "../function-value";
-import type { ArrayType, ComptimeListType, ConcreteModuleType, DynType, EffectsRowType, EnumType, FnTraitType, FunctionType, FutureTraitType, IsoType, ModuleType, PtrType, SliceType, SomeType, StructType, TraitType, TupleType, Type, TypeApplicationType, TypeHierarchyType, UnionType, VoidType } from "./definitions";
+import type { ArrayType, ComptimeListType, ConcreteTraitType, DynType, EffectsRowType, EnumType, FnTraitType, FunctionType, FutureTraitType, IsoType, SourceNamespaceType, PtrType, SliceType, SomeType, StructType, TraitType, TupleType, Type, TypeApplicationType, TypeHierarchyType, UnionType, VoidType } from "./definitions";
 export declare function isPrimitiveType(type: Type): boolean;
 export declare function isUnitType(type?: Type): boolean;
 export declare function isComptimeIntType(type?: Type): boolean;
@@ -37,7 +37,7 @@ export declare function isAtomicObjectType(type?: Type): type is StructType & {
 export declare function isNewtypeType(type?: Type): type is StructType & {
     isNewtype: true;
 };
-export declare function isModuleType(type?: Type): type is ModuleType;
+export declare function isSourceNamespaceType(type?: Type): type is SourceNamespaceType;
 export declare function isTraitType(type?: Type): type is TraitType;
 export declare function isFnTraitType(type?: Type): type is FnTraitType;
 export declare function isFunctionType(type?: Type): type is FunctionType;
@@ -68,7 +68,7 @@ export declare function isULongLongType(type?: Type): boolean;
 export declare function isLongDoubleType(type?: Type): boolean;
 export declare function isVoidType(type?: Type): type is VoidType;
 export declare function isFutureTraitType(type?: Type): type is FutureTraitType;
-export declare function isConcreteTraitType(type?: Type): type is ConcreteModuleType;
+export declare function isConcreteTraitType(type?: Type): type is ConcreteTraitType;
 export declare function isCCompatibleType(type?: Type): boolean;
 export declare function isFunctionTypeGeneric(functionType: FunctionType): boolean;
 export declare function isFunctionTypeHardGeneric(functionType: FunctionType): boolean;

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

@@ -36,7 +36,6 @@ export declare enum TypeTag {
     Function = "Function",
     SomeType = "SomeType",
     Slice = "Slice",
-    Module = "Module",
     Trait = "Trait",
     Ptr = "Ptr",
     Iso = "Iso",

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

@@ -1,7 +1,7 @@
 import type { Environment } from "../env";
 import { type Expr } from "../expr";
 import { type Token } from "../token";
-import type { FunctionParameter, SomeType, Type, TypeField } from "./definitions";
+import type { FunctionParameter, TypeField, SomeType, Type } from "./definitions";
 export declare function typeRequiresComptimeModifier(type: Type | undefined, env: Environment): boolean;
 export declare function typeProhibitsComptimeModifier(type: Type | undefined, env: Environment): boolean;
 export declare function isComptimeOnlyType(type: Type, env: Environment): boolean;

package/out/types/src/value-tag.d.ts

@@ -24,7 +24,6 @@ export declare enum ValueTag {
     Tuple = "Tuple",
     Struct = "Struct",
     Enum = "Enum",
-    Module = "Module",
     Trait = "Trait",
     Expr = "Expr",
     ComptimeList = "ComptimeList",

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

@@ -3,7 +3,7 @@ import { type EvaluatorContext } from "./evaluator/context";
 import { type Expr } from "./expr";
 import type { FunctionValue } from "./function-value";
 import type { TypeValue } from "./type-value";
-import type { ArrayType, ComptimeListType, EnumType, ExprType, ModuleType, PtrType, SliceType, StructType, TraitType, TupleType, Type } from "./types/definitions";
+import type { ArrayType, ComptimeListType, EnumType, ExprType, PtrType, SliceType, StructType, TraitType, TupleType, Type } from "./types/definitions";
 import type { UnitValue } from "./unit-value";
 import { ValueTag } from "./value-tag";
 export type ComptimeStringValue = {
@@ -29,7 +29,9 @@ export type TupleValue = {
 export type StructValue = {
     tag: ValueTag.Struct;
     type: StructType;
-    fields: Value[];
+    fields: (Value | undefined)[];
+    moduleLevelInitExprs?: Expr[];
+    isLoading?: boolean;
 };
 export type EnumValue = {
     tag: ValueTag.Enum;
@@ -37,13 +39,6 @@ export type EnumValue = {
     variantName: string;
     fields: Value[];
 };
-export type ModuleValue = {
-    tag: ValueTag.Module;
-    type: ModuleType;
-    fields: (Value | undefined)[];
-    moduleLevelInitExprs?: Expr[];
-    isLoading?: boolean;
-};
 export type TraitValue = {
     tag: ValueTag.Trait;
     type: TraitType;
@@ -83,7 +78,7 @@ export type PtrValue = {
     targetValue: [Value];
     targetIndex: number;
 };
-export type Value = TypeValue | ComptimeStringValue | ComptimeListValue | NumberValue | UnitValue | BooleanValue | ArrayValue | SliceValue | TupleValue | StructValue | EnumValue | ModuleValue | TraitValue | FunctionValue | ExprValue | UnknownValue | PtrValue;
+export type Value = TypeValue | ComptimeStringValue | ComptimeListValue | NumberValue | UnitValue | BooleanValue | ArrayValue | SliceValue | TupleValue | StructValue | EnumValue | TraitValue | FunctionValue | ExprValue | UnknownValue | PtrValue;
 export declare function valueToString(value?: Value): string;
 export declare function isTypeValue(value?: Value): value is TypeValue;
 export declare function isComptimeIntValue(value?: Value): value is NumberValue;
@@ -100,7 +95,6 @@ export declare function isStructValue(value?: Value): value is StructValue;
 export declare function isArrayValue(value?: Value): value is ArrayValue;
 export declare function isSliceValue(value?: Value): value is SliceValue;
 export declare function isEnumValue(value?: Value): value is EnumValue;
-export declare function isModuleValue(value?: Value): value is ModuleValue;
 export declare function isTraitValue(value?: Value): value is TraitValue;
 export declare function isPtrValue(value?: Value): value is PtrValue;
 export declare function isRegionValue(_value?: Value): boolean;
@@ -125,8 +119,7 @@ export declare function createUnknownValue(type: Type, { variableName, recursive
     env: Environment;
     context: EvaluatorContext;
 }): UnknownValue | TypeValue;
-export declare function createStructValue(type: StructType, fields: Value[]): StructValue;
-export declare function createModuleValue(type: ModuleType, fields: (Value | undefined)[], moduleLevelInitExprs?: Expr[]): ModuleValue;
+export declare function createStructValue(type: StructType, fields: (Value | undefined)[], moduleLevelInitExprs?: Expr[]): StructValue;
 export declare function createTraitValue(type: TraitType, fields: (Value | undefined)[]): TraitValue;
 export declare function createTupleValue(type: TupleType, fields: Value[]): TupleValue;
 export declare function createEnumValue(type: EnumType, variantName: string, fields: Value[]): EnumValue;