@shd101wyy/yo 0.0.26 → 0.0.28

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

@@ -0,0 +1,22 @@
+import { BuildRegistry } from "./evaluator/builtins/build";
+export interface BuildOptions {
+    buildFile: string;
+    targetTriple?: string;
+    verbose?: boolean;
+    dryRun?: boolean;
+    listSteps?: boolean;
+    steps?: string[];
+    defines?: Record<string, string>;
+    cCompiler?: string;
+    sysroot?: string;
+    summary?: boolean;
+}
+export declare function runBuild(options: BuildOptions): Promise<void>;
+export interface DAGNode {
+    name: string;
+    kind: "artifact" | "test" | "run" | "step";
+    dependsOn: string[];
+}
+export declare function buildDAG(registry: BuildRegistry, rootStepName: string): DAGNode[];
+export declare function detectCycle(dag: DAGNode[]): string[] | null;
+export declare function computeDependencyHash(registry: BuildRegistry, depName: string, projectDir: string): string;

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

@@ -0,0 +1,3 @@
+export declare function getGlobalCacheDir(): string;
+export declare function getGlobalDepsCacheDir(): string;
+export declare function ensureGlobalDepsCacheDir(): string;

package/out/types/src/codegen/async/state-machine.d.ts

@@ -11,4 +11,4 @@ export interface StateMachineInfo {
 }
 export declare function generateResumeFunctionDeclaration(info: StateMachineInfo, context: FunctionGenerationContext): void;
 export declare function getStateMachineFieldName(variableId: string, kind?: "outer" | "local"): string;
-export declare function generateAsyncBlockResumeFunction(bodyExpr: Expr, asyncBlockId: string, structName: string, resumeFunctionName: string, analysis: AwaitAnalysisResult, futureType: SomeType | DynType, captureType: StructType | undefined, context: FunctionGenerationContext): void;
+export declare function generateAsyncBlockResumeFunction(bodyExpr: Expr, asyncBlockId: string, structName: string, resumeFunctionName: string, analysis: AwaitAnalysisResult, futureType: SomeType | DynType, captureType: StructType | undefined, context: FunctionGenerationContext): string[];

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

@@ -1,12 +1,15 @@
 import type { ModuleValue } from "../value";
 export declare class CodeGeneratorC {
     private emitter;
+    private exportedFunctionNames;
     constructor();
     compileModule(modulePath: string, moduleValue: ModuleValue, options?: {
         debugGc?: boolean;
         debugParallelism?: boolean;
         debugAsyncAwait?: boolean;
         allocator?: "mimalloc" | "libc";
+        isLibrary?: boolean;
     }): void;
     print(): string;
+    getExportedFunctionNames(): Set<string>;
 }

package/out/types/src/codegen/exprs/await.d.ts

@@ -2,3 +2,4 @@ import { type FnCallExpr } from "../../expr";
 import { type CodeGenContext } from "../utils";
 export declare function generateAwait(expr: FnCallExpr, indent: string, context: CodeGenContext): string;
 export declare function generateState(expr: FnCallExpr, indent: string, context: CodeGenContext): string;
+export declare function generateJoinHandleAwait(expr: FnCallExpr, indent: string, context: CodeGenContext): string;

package/out/types/src/codegen/exprs/return.d.ts

@@ -2,5 +2,6 @@ import { type Expr, type FnCallExpr } from "../../expr";
 import type { FunctionGenerationContext } from "../functions/context";
 import { type CodeGenContext } from "../utils";
 export declare function generatePendingDeferredDrops(indent: string, context: FunctionGenerationContext, expr: Expr, isCompletion?: boolean, skipAlreadyDroppedCheck?: boolean, skipEnvCheck?: boolean): void;
+export declare function generateConsumedVarDropsForEscape(indent: string, context: FunctionGenerationContext, expr: Expr, skipEnvCheck?: boolean): void;
 export declare function generateReturn(expr: FnCallExpr, indent: string, context: CodeGenContext): string;
 export declare function generateImplicitReturnStatement(expr: Expr, indent: string, context: CodeGenContext): void;

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

@@ -1,3 +1,3 @@
 import { type FnCallExpr } from "../../expr";
-import type { CodeGenContext } from "../utils";
+import { type CodeGenContext } from "../utils";
 export declare function generateWhileLoop(expr: FnCallExpr, indent: string, context: CodeGenContext): string;

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

@@ -2,8 +2,8 @@ import type { AwaitAnalysisResult, CapturedVariable } from "../../evaluator/asyn
 import type { Expr } from "../../expr";
 import type { FunctionValue, FuncValueId } from "../../function-value";
 import type { DynType, FunctionType, FutureTraitType, SomeType, StructType, Type, TypeId } from "../../types/definitions";
-import type { EffectStateMachineInfo } from "../effects/effect-state-machine";
 import type { CodeGenContext } from "../utils";
+import type { EvidenceParameter } from "./declarations";
 export interface FunctionGenerationContext extends CodeGenContext {
     functions: Record<FuncValueId, {
         value: FunctionValue;
@@ -25,23 +25,17 @@ export interface FunctionGenerationContext extends CodeGenContext {
         futureType: SomeType | DynType;
     };
     stateMachineVariables?: Map<string, CapturedVariable>;
-    inEffectStateMachine?: EffectStateMachineInfo;
-    deferredEffectfulFunctions?: Array<{
-        functionValue: FunctionValue;
-        cFunctionName: string;
-        info: EffectStateMachineInfo;
-    }>;
+    inEffectStateMachine?: unknown;
+    isModuleEffectMemberFunction?: boolean;
+    currentEvidenceParams?: Map<string, EvidenceParameter>;
     continuationVariables?: Map<string, {
-        smVar: string;
-        smInfo: EffectStateMachineInfo;
-        effectIndex?: number;
-    } | {
         directReturnVar: string;
         directExitLabel?: string;
         isUnitReturn?: boolean;
     }>;
     variableIdRemapping?: Map<string, string>;
     pendingDeferredDrops?: Expr[];
+    consumedVarPendingDrops?: Expr[];
     deferredAsyncBlocks?: Array<{
         bodyExpr: Expr;
         asyncBlockId: string;
@@ -112,12 +106,6 @@ export interface FunctionGenerationContext extends CodeGenContext {
     shortCircuitHandledDropVarNames?: Set<string>;
     effectHandlerParamDrops?: string[];
     effectSmConsumedArgCNames?: Set<string>;
-    effectWhileLoopContinuation?: {
-        label: string;
-        stepExpr: Expr | undefined;
-        whileDoneLabel: string;
-        remainingExprs: Expr[];
-        bodyDropExprs: Expr[];
-    };
     loopBodyDropsBaselineCount?: number;
+    overrideReturnTypeStr?: string;
 }

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

@@ -3,8 +3,16 @@ import type { FunctionType } from "../../types/definitions";
 import { type CodeGenContext } from "../utils";
 import type { FunctionGenerationContext } from "./context";
 export declare function generateFunctionDeclarations(context: FunctionGenerationContext): void;
-export declare function generateFunctionPrototype(functionType: FunctionType, cFunctionName: string, context: CodeGenContext, overrideReturnType?: string): string;
-export declare function generateFunctionDeclaration(functionType: FunctionType, cFunctionName: string, isExtern: boolean, context: CodeGenContext, functionBody?: Expr): void;
+export interface EvidenceParameter {
+    implicitLabel: string;
+    fieldLabel: string;
+    fieldPath: string[];
+    fieldFunctionType: FunctionType;
+    cParamName: string;
+}
+export declare function getEvidenceParameters(functionType: FunctionType): EvidenceParameter[];
+export declare function generateFunctionPrototype(functionType: FunctionType, cFunctionName: string, context: CodeGenContext, overrideReturnType?: string, originalFunctionType?: FunctionType): string;
+export declare function generateFunctionDeclaration(functionType: FunctionType, cFunctionName: string, isExtern: boolean, context: CodeGenContext, functionBody?: Expr, originalFunctionType?: FunctionType): void;
 export declare function generateObjectConstructorDeclarations(context: FunctionGenerationContext): void;
 export declare function generateClosureConstructorDeclarations(context: FunctionGenerationContext): void;
 export declare function generateCaptureDisposeFunctionDeclarations(context: FunctionGenerationContext): void;

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

@@ -5,6 +5,8 @@ export declare class CodeGenerator {
         output: string;
         cCompiler: string;
         target: "c";
+        targetTriple?: string;
+        sysroot?: string;
         extern: string[];
         includePaths?: string[];
         libraryPaths?: string[];
@@ -23,6 +25,8 @@ export declare class CodeGenerator {
         debugSymbols?: boolean;
         strip?: boolean;
         static?: boolean;
+        shared?: boolean;
+        staticLibrary?: boolean;
         cflags?: string;
     }): void;
 }

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

@@ -77,6 +77,9 @@ export interface CodeGenContext {
     currentContinueLabel?: string;
     insideMatch?: boolean;
     typeIdStatics?: Map<string, string>;
+    isLibrary?: boolean;
+    currentModuleId?: string;
+    exportedFunctionLabels?: Map<FuncValueId, string>;
 }
 export declare function sanitizeForCIdentifier(str: string, isExternC?: boolean): string;
 export declare function shouldAvoidConst(type: Type): boolean;

package/out/types/src/evaluator/async/await-analysis.d.ts

@@ -6,4 +6,5 @@ export declare function isIoAsyncCall(expr: Expr): boolean;
 export declare function isIoAwaitCall(expr: Expr): boolean;
 export declare function isIoStateCall(expr: Expr): boolean;
 export declare function isIoSpawnCall(expr: Expr): boolean;
+export declare function isJoinHandleAwaitCall(expr: Expr): boolean;
 export declare function getLocalVariablesFromBody(body: Expr): CapturedVariable[];

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

@@ -0,0 +1,135 @@
+import type { Environment } from "../../env";
+import { type FnCallExpr } from "../../expr";
+import type { EvaluatorContext } from "../context";
+export interface BuildProject {
+    name: string;
+    root: string;
+}
+export interface BuildArtifact {
+    kind: "executable" | "static_library" | "shared_library";
+    name: string;
+    root: string;
+    target: string;
+    optimize: string;
+    allocator: string;
+    sanitize: string;
+    linkLibraries: string[];
+    includePaths: string[];
+    libraryPaths: string[];
+    cSources: string[];
+    cFlags: string[];
+    defines: string[];
+    strip: boolean;
+    staticLink: boolean;
+    linkedArtifacts: string[];
+    linkedSystemLibraries: string[];
+}
+export interface BuildTestSuite {
+    name: string;
+    root: string;
+    target: string;
+    verbose: boolean;
+    bail: boolean;
+    parallel: number;
+}
+export interface BuildRunStep {
+    name: string;
+    artifactName: string;
+    args: string[];
+}
+export interface BuildStep {
+    name: string;
+    description: string;
+    dependencyNames: string[];
+}
+export interface BuildGitDependency {
+    name: string;
+    url: string;
+    ref: string;
+    path: string;
+}
+export interface BuildPathDependency {
+    name: string;
+    path: string;
+}
+export interface BuildSystemLibrary {
+    name: string;
+    pkgConfig: string;
+    fallbackInclude: string;
+    fallbackLib: string;
+    fallbackLink: string;
+}
+export interface DependencyArtifactRef {
+    dependencyName: string;
+    artifactName: string;
+}
+export declare class BuildRegistry {
+    project: BuildProject | undefined;
+    artifacts: BuildArtifact[];
+    testSuites: BuildTestSuite[];
+    runSteps: BuildRunStep[];
+    steps: BuildStep[];
+    dependencies: BuildGitDependency[];
+    pathDependencies: BuildPathDependency[];
+    systemLibraries: BuildSystemLibrary[];
+    dependencyArtifacts: DependencyArtifactRef[];
+    cliOptions: Map<string, string>;
+    declaredOptions: Map<string, {
+        description: string;
+        defaultValue: string;
+    }>;
+    setCliOptions(options: Map<string, string>): void;
+    registerProject(name: string, root: string): void;
+    registerExecutable(config: Omit<BuildArtifact, "kind">): void;
+    registerStaticLibrary(config: Omit<BuildArtifact, "kind">): void;
+    registerSharedLibrary(config: Omit<BuildArtifact, "kind">): void;
+    registerTest(config: BuildTestSuite): void;
+    registerRun(artifactName: string, args: string[]): void;
+    registerStep(name: string, description: string, dependencyNames?: string[]): void;
+    addStepDependency(stepName: string, depName: string): void;
+    registerDependency(dep: BuildGitDependency): void;
+    registerPathDependency(dep: BuildPathDependency): void;
+    registerSystemLibrary(lib: BuildSystemLibrary): void;
+    registerDependencyArtifact(ref: DependencyArtifactRef): void;
+    registerLink(artifactName: string, libraryName: string): void;
+    findArtifact(name: string): BuildArtifact | undefined;
+    findTest(name: string): BuildTestSuite | undefined;
+    findRunStep(name: string): BuildRunStep | undefined;
+    findStep(name: string): BuildStep | undefined;
+    findDependency(name: string): BuildGitDependency | undefined;
+    findPathDependency(name: string): BuildPathDependency | undefined;
+    findSystemLibrary(name: string): BuildSystemLibrary | undefined;
+    getStepNames(): string[];
+    resolveDependency(name: string): {
+        kind: "artifact";
+        value: BuildArtifact;
+    } | {
+        kind: "test";
+        value: BuildTestSuite;
+    } | {
+        kind: "run";
+        value: BuildRunStep;
+    } | {
+        kind: "step";
+        value: BuildStep;
+    } | undefined;
+    resolveDependencies(step: BuildStep): {
+        artifacts: BuildArtifact[];
+        tests: BuildTestSuite[];
+        runs: BuildRunStep[];
+    };
+    clear(): void;
+}
+export declare function getRootBuildProjectDir(): string | undefined;
+export declare function setRootBuildProjectDir(dir: string | undefined): void;
+export declare function getDependencyProjectRoot(depDir: string): string | undefined;
+export declare function setDependencyProjectRoot(depDir: string, root: string): void;
+export declare function clearDependencyProjectRoots(): void;
+export declare function getBuildRegistry(): BuildRegistry;
+export declare function clearBuildRegistry(): void;
+export declare function swapBuildRegistry(newRegistry: BuildRegistry | undefined): BuildRegistry | undefined;
+export declare function evaluateYoBuildFunctions({ expr, env, }: {
+    expr: FnCallExpr;
+    env: Environment;
+    context: EvaluatorContext;
+}): FnCallExpr;

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

@@ -43,6 +43,7 @@ export interface EvaluatorContext {
     };
     SelfType?: Type;
     SelfTraitType?: Type;
+    SelfModuleType?: Type;
     ReceiverType?: Type;
     isEvaluatingFunctionType?: boolean;
     loadModule?: (modulePath: string) => {

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

@@ -50,6 +50,7 @@ export interface EvaluatedExprData {
     comment?: string;
     deferredDupExpressions?: Expr[];
     deferredDropExpressions?: Expr[];
+    consumedVariableDropExpressions?: Expr[];
     asyncStackSize?: Expr;
     asyncStateMachineStructName?: string;
     captureType?: StructType;
@@ -530,6 +531,23 @@ export declare const BuiltinFunctions: {
     __yo_maybe_uninit_assume_init: string[];
     __yo_process_platform: string[];
     __yo_process_arch: string[];
+    __yo_build_project: string[];
+    __yo_build_executable: string[];
+    __yo_build_static_library: string[];
+    __yo_build_shared_library: string[];
+    __yo_build_test: string[];
+    __yo_build_run: string[];
+    __yo_build_step: string[];
+    __yo_build_step_depend_on: string[];
+    __yo_build_link: string[];
+    __yo_build_link_system_library: string[];
+    __yo_build_target_host: string[];
+    __yo_build_target_parse: string[];
+    __yo_build_dependency: string[];
+    __yo_build_path_dependency: string[];
+    __yo_build_system_library: string[];
+    __yo_build_option: string[];
+    __yo_build_dep_artifact: string[];
 };
 export declare function exprIsInfixOperatorFunctionCall(expr: Expr): boolean;
 export interface ExprToStringConfig {

package/out/types/src/fetch-command.d.ts

@@ -0,0 +1,6 @@
+export interface FetchOptions {
+    buildFile: string;
+    verbose: boolean;
+    update: boolean;
+}
+export declare function runFetch(options: FetchOptions): Promise<void>;

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

@@ -0,0 +1,10 @@
+import type { BuildGitDependency } from "./evaluator/builtins/build";
+import { type LockFile } from "./lock-file";
+export declare function getCacheDir(_projectDir?: string): string;
+export interface FetchResult {
+    resolvedPaths: Map<string, string>;
+    lockFile: LockFile;
+}
+export declare function fetchAllDependencies(projectDir: string, dependencies: BuildGitDependency[], verbose?: boolean, update?: boolean): FetchResult;
+export declare function areDependenciesCached(projectDir: string, dependencies: BuildGitDependency[]): boolean;
+export declare function resolveDependencyPath(projectDir: string, depName: string, depPath?: string): string | undefined;

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

@@ -33,6 +33,7 @@ export type FunctionValue = {
     isControlFunction?: boolean;
     definitionSiteEnclosingFunctionType?: FunctionType;
     closureInfo?: ClosureInfo;
+    isModuleEffectMember?: boolean;
     isIoAsyncStateMachineClosure?: boolean;
 };
 export interface FunctionCapturedVariableInfo extends CapturedVariableInfo {

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

@@ -0,0 +1,5 @@
+export interface InitOptions {
+    dir: string;
+    name?: string;
+}
+export declare function initProject(options: InitOptions): void;

package/out/types/src/install-command.d.ts

@@ -0,0 +1,6 @@
+export interface InstallOptions {
+    package: string;
+    buildFile: string;
+    verbose: boolean;
+}
+export declare function runInstall(options: InstallOptions): Promise<void>;

package/out/types/src/lock-file.d.ts

@@ -0,0 +1,16 @@
+export interface LockEntry {
+    name: string;
+    url: string;
+    ref: string;
+    commit: string;
+    hash: string;
+}
+export interface LockFile {
+    dependencies: LockEntry[];
+}
+export declare function parseLockFile(content: string): LockFile;
+export declare function writeLockFileContent(lockFile: LockFile): string;
+export declare function readLockFile(projectDir: string): LockFile;
+export declare function saveLockFile(projectDir: string, lockFile: LockFile): void;
+export declare function findLockEntry(lockFile: LockFile, name: string): LockEntry | undefined;
+export declare function upsertLockEntry(lockFile: LockFile, entry: LockEntry): LockFile;

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

@@ -28,12 +28,14 @@ export declare class ModuleManager {
         moduleError: Error | undefined;
     };
     deleteModule(modulePath: string): void;
-    compileModule(modulePath: string, { emitC, debugGc, debugParallelism, debugAsyncAwait, allocator, }?: {
+    compileModule(modulePath: string, { emitC, debugGc, debugParallelism, debugAsyncAwait, allocator, isLibrary, }?: {
         emitC?: boolean;
         debugGc?: boolean;
         debugParallelism?: boolean;
         debugAsyncAwait?: boolean;
         allocator?: "mimalloc" | "libc";
+        isLibrary?: boolean;
     }): void;
     getGeneratedCode(): string;
+    getExportedFunctionNames(): Set<string>;
 }

package/out/types/src/pkg-config.d.ts

@@ -0,0 +1,11 @@
+import type { BuildSystemLibrary } from "./evaluator/builtins/build";
+export interface PkgConfigResult {
+    cFlags: string[];
+    ldFlags: string[];
+    includePaths: string[];
+    libraryPaths: string[];
+    linkLibraries: string[];
+}
+export declare function isPkgConfigAvailable(): boolean;
+export declare function resolveSystemLibrary(lib: BuildSystemLibrary, verbose?: boolean): PkgConfigResult;
+export declare function resolveAllSystemLibraries(libraries: BuildSystemLibrary[], verbose?: boolean): PkgConfigResult;

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

@@ -0,0 +1,28 @@
+export type Arch = "x86_64" | "aarch64" | "x86" | "arm" | "wasm32";
+export type Os = "linux" | "macos" | "windows" | "freebsd" | "wasi";
+export type Abi = "gnu" | "musl" | "msvc" | "none" | "wasm";
+export interface TargetInfo {
+    arch: Arch;
+    os: Os;
+    abi: Abi | undefined;
+    pointerSizeBits: 32 | 64;
+    triple: string;
+}
+export interface HostInfo {
+    platform: Os;
+    arch: Arch;
+}
+export declare function pointerSizeForArch(arch: Arch): 32 | 64;
+export declare function detectHost(): HostInfo;
+export declare function hostTarget(): TargetInfo;
+export declare function parseTarget(triple: string): TargetInfo;
+export declare function clangTriple(target: TargetInfo): string;
+export declare function setCurrentTarget(target: TargetInfo): void;
+export declare function getCurrentTarget(): TargetInfo;
+export declare function targetOsToYoString(os: Os): string;
+export declare function targetArchToYoString(arch: Arch): string;
+export declare function isTargetWindows(target: TargetInfo): boolean;
+export declare function isTargetLinux(target: TargetInfo): boolean;
+export declare function isTargetMacos(target: TargetInfo): boolean;
+export declare function isTargetMSVC(target: TargetInfo): boolean;
+export declare function isTargetWasm(target: TargetInfo): boolean;

package/out/types/src/tests/build-system.test.d.ts

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

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

@@ -45,7 +45,7 @@ export declare function createModuleType(env: Environment): ModuleType;
 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, isClosure, }: {
+export declare function createFunctionType({ parameters, forallParameters, implicitParameters, variadicParameter, whereClauseExprs, return_, env, parametersFrame, SelfType, SelfTraitType, SelfModuleType, isClosure, }: {
     parameters: FunctionParameter[];
     forallParameters: FunctionForallParameter[];
     implicitParameters?: FunctionImplicitParameter[];
@@ -56,6 +56,7 @@ 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

@@ -14,7 +14,7 @@ export interface Type {
     cInclude?: string;
     trait?: TraitType;
     definedInModulePath?: string;
-    ioBuiltin?: "io_async" | "io_await" | "io_state" | "io_spawn";
+    ioBuiltin?: "io_async" | "io_await" | "io_state" | "io_spawn" | "join_handle_await";
 }
 export interface ExprType extends Type {
     tag: TypeTag.Expr;
@@ -230,6 +230,7 @@ export interface FunctionType extends Type {
     parametersFrame: Frame;
     SelfType?: Type;
     SelfTraitType?: Type;
+    SelfModuleType?: Type;
     trait: TraitType;
     isClosure?: boolean;
 }