@shd101wyy/yo 0.1.5 → 0.1.7

package/out/types/src/build-runner.d.ts

@@ -11,7 +11,7 @@ export interface BuildOptions {
     sysroot?: string;
     summary?: boolean;
 }
-export declare function getArtifactOutputFileName(artifact: Pick<BuildArtifact, "kind" | "name" | "target">, targetTriple?: string): string;
+export declare function getArtifactOutputFileName(artifact: Pick<BuildArtifact, "kind" | "name" | "target"> & Partial<Pick<BuildArtifact, "cFlags">>, targetTriple?: string): string;
 export declare function stageRuntimeFiles(runtimeFiles: readonly string[], outputDir: string, verbose?: boolean): string[];
 export declare function runBuild(options: BuildOptions): Promise<void>;
 export interface DAGNode {

package/out/types/src/codegen/async/runtime-io-common.d.ts

@@ -1,4 +1,5 @@
 import { Emitter } from "../../emitter";
 import type { TargetInfo } from "../../target";
+import type { AsyncRuntimeOptions } from "./runtime";
 export declare function generateSysRuntime(emitter: Emitter, targetInfo: TargetInfo): void;
-export declare function generateAsyncRuntimeIOCommon(emitter: Emitter, targetInfo: TargetInfo): void;
+export declare function generateAsyncRuntimeIOCommon(emitter: Emitter, targetInfo: TargetInfo, options: AsyncRuntimeOptions): void;

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

@@ -1,3 +1,7 @@
 import { Emitter } from "../../emitter";
 import type { TargetInfo } from "../../target";
-export declare function generateAsyncRuntime(emitter: Emitter, targetInfo: TargetInfo, _debugAsyncAwait: boolean): void;
+export interface AsyncRuntimeOptions {
+    needsCycleGC: boolean;
+    registerDisposeTypeId?: (disposeFnName: string) => number;
+}
+export declare function generateAsyncRuntime(emitter: Emitter, targetInfo: TargetInfo, _debugAsyncAwait: boolean, options: AsyncRuntimeOptions): void;

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

@@ -1,3 +1,4 @@
+import type { Expr } from "../expr";
 import type { ModuleValue } from "../value";
 export declare class CodeGeneratorC {
     private emitter;
@@ -11,6 +12,7 @@ export declare class CodeGeneratorC {
         debugAsyncAwait?: boolean;
         allocator?: "mimalloc" | "libc";
         isLibrary?: boolean;
+        allModuleLevelInitExprs?: Expr[];
     }): void;
     print(): string;
     getExportedFunctionNames(): Set<string>;

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 CodeGenContext } from "../utils";
-export declare function collectRequiredFunctions(moduleValue: ModuleValue | TraitValue, context: CodeGenContext): void;
+export declare function collectRequiredFunctions(moduleValue: ModuleValue | 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

@@ -107,6 +107,7 @@ export interface FunctionGenerationContext extends CodeGenContext {
     };
     smWhileBodyDrops?: Expr[];
     shortCircuitHandledDropVarNames?: Set<string>;
+    declaredTempVars?: Set<string>;
     effectHandlerParamDrops?: string[];
     effectSmConsumedArgCNames?: Set<string>;
     loopBodyDropsBaselineCount?: number;

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

@@ -4,6 +4,16 @@ 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 emitModuleLevelVariableDeclarations(context: FunctionGenerationContext): Array<{
+    cVarName: string;
+    cTypeStr: string;
+    rhs: Expr;
+}>;
+export declare function generateLibraryInitFunction(context: FunctionGenerationContext, moduleLevelVars: Array<{
+    cVarName: string;
+    cTypeStr: string;
+    rhs: Expr;
+}>): void;
 export declare function generateMainWrapper(context: FunctionGenerationContext): void;
 export declare function preRegisterEffectfulFunctions(context: FunctionGenerationContext): void;
 export declare function generateFunction(functionValue: FunctionValue, cFunctionName: string, context: FunctionGenerationContext): void;

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

@@ -80,8 +80,12 @@ export interface CodeGenContext {
     currentContinueLabel?: string;
     insideMatch?: boolean;
     typeIdStatics?: Map<string, string>;
+    needsCycleGC?: boolean;
+    disposeTypeIds?: Map<string, number>;
+    nextDisposeTypeId?: number;
     isLibrary?: boolean;
     needsIntelAsmSyntax?: boolean;
+    moduleLevelInitExprs?: Expr[];
     currentModuleId?: string;
     exportedFunctionLabels?: Map<FuncValueId, string>;
 }

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

@@ -20,6 +20,7 @@ export interface Variable {
     isImplicit?: boolean;
     isFromEffectSpread?: boolean;
     isEffectParam?: boolean;
+    isModuleLevel?: boolean;
 }
 export type WhereClauseConstraints = {
     someType: SomeType;

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

@@ -109,6 +109,7 @@ export declare class BuildRegistry {
     findTest(name: string): BuildTestSuite | undefined;
     findRunStep(name: string): BuildRunStep | undefined;
     findStep(name: string): BuildStep | undefined;
+    private checkDuplicateArtifactName;
     findDependency(name: string): BuildGitDependency | undefined;
     findPathDependency(name: string): BuildPathDependency | undefined;
     findSystemLibrary(name: string): BuildSystemLibrary | undefined;

package/out/types/src/evaluator/builtins/comptime-index-fns.d.ts

@@ -0,0 +1,17 @@
+import type { Environment } from "../../env";
+import { type FnCallExpr } from "../../expr";
+import type { Token } from "../../token";
+import { type Value } from "../../value";
+import type { EvaluatorContext } from "../context";
+export declare function evaluateYoComptimeIndexFunctions({ expr, env, context, }: {
+    expr: FnCallExpr;
+    env: Environment;
+    context: EvaluatorContext;
+}): FnCallExpr;
+export declare function computeComptimeStringIndex({ strValue, argValue, token, isRange, isInclusive, }: {
+    strValue: string;
+    argValue: Value;
+    token: Token;
+    isRange: boolean;
+    isInclusive: boolean;
+}): Value;

package/out/types/src/evaluator/calls/index-trait.d.ts

@@ -0,0 +1,17 @@
+import type { Environment } from "../../env";
+import { type Expr, type FnCallExpr } from "../../expr";
+import type { Type } from "../../types/definitions";
+import type { EvaluatorContext, IndexCallResult } from "../context";
+export declare function tryToCallWithIndexTrait({ expr, valueType, argExprs, callerEnv, context, }: {
+    expr: FnCallExpr;
+    valueType: Type;
+    argExprs: Expr[];
+    callerEnv: Environment;
+    context: EvaluatorContext;
+}): IndexCallResult;
+export declare function hasIndexImpl({ concreteType, argExprs, callerEnv, _context, }: {
+    concreteType: Type;
+    argExprs: Expr[];
+    callerEnv: Environment;
+    _context: EvaluatorContext;
+}): boolean;

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

@@ -36,6 +36,7 @@ export interface EvaluatorContext {
         env: Environment;
     };
     isEvaluatingFunctionBodyOrAsyncBlock?: FunctionEvaluationContext | AsyncBlockEvaluationContext | TestBlockEvaluationContext;
+    isInsideImplBlock?: boolean;
     capturedVariables?: Map<string, CapturedVariableInfo>;
     isEvaluatingLoopBody?: {
         kind: "while" | "for";
@@ -67,6 +68,7 @@ export interface EvaluatorContext {
     isInFunctionCallCheckingPhase?: boolean;
     isInsideIoAsyncCall?: boolean;
     isInsideGivenHandler?: boolean;
+    isEvaluatingGenericImplSpecialization?: boolean;
 }
 export interface ArgValues {
     forallArgs: {
@@ -118,16 +120,6 @@ export interface TraitSpecializationResult {
     specializedTraitType: TraitType;
     callerEnv: Environment;
 }
-export interface ArrayCallResult {
-    value: Value | undefined;
-    index?: number;
-    arrayElementRef?: {
-        arrayValue: ArrayValue;
-        index: number;
-    };
-    type: Type;
-    callerEnv: Environment;
-}
 export interface MacroFunctionCallResult {
     calleeEnv: Environment;
     callerEnv: Environment;
@@ -141,6 +133,19 @@ export interface PointerTypeCallResult {
     expr: Expr;
     env: Environment;
 }
+export interface IndexCallResult {
+    value: Value | undefined;
+    type: Type;
+    ptrType: Type;
+    indexMethodType: FunctionType | undefined;
+    indexMethodValue: Value | undefined;
+    callerEnv: Environment;
+    index?: number;
+    arrayElementRef?: {
+        arrayValue: ArrayValue;
+        index: number;
+    };
+}
 export interface FunctionToCall {
     type: Type;
     args?: Expr[];
@@ -166,9 +171,6 @@ export interface FunctionToCall {
     } | {
         kind: "trait-specialization";
         result: TraitSpecializationResult;
-    } | {
-        kind: "array";
-        result: ArrayCallResult;
     } | {
         kind: "numeric-type";
         result: NumericTypeCallResult;
@@ -181,6 +183,9 @@ export interface FunctionToCall {
     } | {
         kind: "arc-value";
         result: FnCallExpr;
+    } | {
+        kind: "index";
+        result: IndexCallResult;
     } | {
         kind: "error";
         error: Error | YoError;
@@ -190,7 +195,7 @@ export declare function getFunctionCallResult(functionToCall: FunctionToCall): F
 export declare function getTypeCallResult(functionToCall: FunctionToCall): TypeCallResult;
 export declare function getModuleTypeCallResult(functionToCall: FunctionToCall): ModuleTypeCallResult;
 export declare function getTraitTypeCallResult(functionToCall: FunctionToCall): TraitTypeCallResult;
-export declare function getArrayCallResult(functionToCall: FunctionToCall): ArrayCallResult;
+export declare function getIndexCallResult(functionToCall: FunctionToCall): IndexCallResult;
 export declare function getPointerTypeCallResult(functionToCall: FunctionToCall): PointerTypeCallResult;
 export type EvaluateExpression = ({ expr, env, context, }: {
     expr: Expr;

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

@@ -13,12 +13,14 @@ export default class Evaluator {
     private moduleValue;
     private moduleError;
     private allowPartialModule;
-    constructor({ modulePath, stdPath, loadModule, inputString, allowPartialModule, }: {
+    private registerPartialModule;
+    constructor({ modulePath, stdPath, loadModule, inputString, allowPartialModule, registerPartialModule, }: {
         modulePath: string;
         stdPath: string;
         loadModule: LoadModuleFn;
         inputString?: string;
         allowPartialModule?: boolean;
+        registerPartialModule?: (mv: ModuleValue) => void;
     });
     getProgram(): Expr[];
     getTokens(): Token[];

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

@@ -14,6 +14,7 @@ export declare function checkTypeImplementsSelfConstraints({ targetType, traitTy
     errorToken: Token;
 }): void;
 export declare function typeImplementsComptime(type: Type, env: Environment): boolean;
+export declare function findSomeTypeMissingComptimeConstraint(type: Type, env: Environment): SomeType | undefined;
 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;

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

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

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

@@ -3,7 +3,7 @@ import type { AwaitAnalysisResult } from "./evaluator/async/await-analysis-types
 import type { EvaluatorContext } from "./evaluator/context";
 import type { EffectAnalysisResult } from "./evaluator/effects/effect-analysis-types";
 import { type Token } from "./token";
-import type { StructType, Type } from "./types/definitions";
+import type { FunctionType, StructType, Type } from "./types/definitions";
 import { type ArrayValue, type TraitValue, type Value } from "./value";
 import { ValueTag } from "./value-tag";
 export type Path = string[];
@@ -67,6 +67,10 @@ export interface EvaluatedExprData {
         arrayValue: ArrayValue;
         index: number;
     };
+    indexTraitPtrType?: Type;
+    indexMethodType?: FunctionType;
+    indexMethodValue?: Value;
+    isIndexTraitAddressOf?: boolean;
     isCompileTimeOnlyAssignment?: boolean;
     isAnonymousFunctionDefinition?: boolean;
     comptimeUnrolledBodies?: Expr[];
@@ -195,6 +199,19 @@ export declare const BuiltinFunctions: {
     __yo_ptr_set: string[];
     __yo_slice_len: string[];
     __yo_slice_new: string[];
+    __yo_slice_ptr: string[];
+    __yo_array_index: string[];
+    __yo_slice_index: string[];
+    __yo_array_index_range: string[];
+    __yo_array_index_range_inclusive: string[];
+    __yo_slice_index_range: string[];
+    __yo_slice_index_range_inclusive: string[];
+    __yo_comptime_array_index: string[];
+    __yo_comptime_slice_index: string[];
+    __yo_comptime_array_index_range: string[];
+    __yo_comptime_array_index_range_inclusive: string[];
+    __yo_comptime_slice_index_range: string[];
+    __yo_comptime_slice_index_range_inclusive: string[];
     __yo_as: string[];
     __yo_expr_is_atom: string[];
     __yo_expr_is_fn_call: string[];
@@ -470,6 +487,9 @@ export declare const BuiltinFunctions: {
     __yo_comptime_string_to_upper: string[];
     __yo_comptime_string_to_lower: string[];
     __yo_comptime_string_slice: string[];
+    __yo_comptime_string_index: string[];
+    __yo_comptime_string_index_range: string[];
+    __yo_comptime_string_index_range_inclusive: string[];
     __yo_type_to_comptime_string: string[];
     __yo_type_contains_rc_type: string[];
     __yo_type_can_form_rc_cycle: string[];
@@ -565,6 +585,7 @@ export interface ExprToStringConfig {
     indentLevel?: number;
 }
 export declare function exprToString(expr: Expr, config?: ExprToStringConfig): string;
+export declare function consumeCaseBodyTempVar(evaluatedBody: Expr, env: Environment): Environment;
 export declare function attachTempVariableToExpr(expr: Expr, isOwningTheRcValue: boolean, isOwningTheSameRcValueAs?: Variable): void;
 export declare function mergeAndCheckEnvs(env: Environment, bodies: Expr[]): Environment;
 export declare function replaceFuncCallExprWithFuncCallExpr(funcExpr: FnCallExpr, newFuncExpr: FnCallExpr): void;

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

@@ -8,6 +8,7 @@ export declare class ModuleManager {
     }>;
     private dependencies;
     private dependents;
+    private loadingModules;
     stdPath: string;
     private codeGenratorC;
     private allowPartialModule;

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

@@ -28,4 +28,5 @@ export declare function isTargetMSVC(target: TargetInfo): boolean;
 export declare function isTargetWasm(target: TargetInfo): boolean;
 export declare function isTargetEmscripten(target: TargetInfo): boolean;
 export declare function isTargetStandaloneWasi(target: TargetInfo): boolean;
+export declare function isTargetMusl(target: TargetInfo): boolean;
 export declare function isTargetPosix(target: TargetInfo): boolean;

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

@@ -41,6 +41,8 @@ export type ModuleValue = {
     tag: ValueTag.Module;
     type: ModuleType;
     fields: (Value | undefined)[];
+    moduleLevelInitExprs?: Expr[];
+    isLoading?: boolean;
 };
 export type TraitValue = {
     tag: ValueTag.Trait;
@@ -73,6 +75,7 @@ export type UnknownValue = {
     tag: ValueTag.Unknown;
     type: Type;
     variableName?: string;
+    isRuntimeOnly?: boolean;
 };
 export type PtrValue = {
     tag: ValueTag.Ptr;
@@ -123,7 +126,7 @@ export declare function createUnknownValue(type: Type, { variableName, recursive
     context: EvaluatorContext;
 }): UnknownValue | TypeValue;
 export declare function createStructValue(type: StructType, fields: Value[]): StructValue;
-export declare function createModuleValue(type: ModuleType, fields: (Value | undefined)[]): ModuleValue;
+export declare function createModuleValue(type: ModuleType, fields: (Value | undefined)[], moduleLevelInitExprs?: Expr[]): ModuleValue;
 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;