@shd101wyy/yo 0.0.23 → 0.0.25

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

@@ -0,0 +1,5 @@
+import type { FnCallExpr } from "../../expr";
+import { type CodeGenContext } from "../utils";
+export declare function generateYoArcDispose(expr: FnCallExpr, indent: string, context: CodeGenContext): string;
+export declare function isArcTypeCall(expr: FnCallExpr): boolean;
+export declare function generateArcTypeCall(expr: FnCallExpr, indent: string, context: CodeGenContext): string;

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

@@ -4,6 +4,8 @@ export declare function generateTypeDeclarations(context: CodeGenContext): void;
 export declare function generateArrayStructDeclarations(context: CodeGenContext): void;
 export declare function generateSliceStructDeclarations(context: CodeGenContext): void;
 export declare function generateIsoTypeDeclarations(context: CodeGenContext): void;
+export declare function generateArcTypeForwardDeclarations(context: CodeGenContext): void;
+export declare function generateArcTypeDefinitions(context: CodeGenContext): void;
 export declare function generateClosureDeclaration(functionType: FunctionType, cName: string, captureType: StructType | undefined, context: CodeGenContext): void;
 export declare function generateStructDeclaration(structType: StructType, cName: string, context: CodeGenContext): void;
 export declare function generateTupleDeclaration(tupleType: TupleType, cName: string, context: CodeGenContext): void;

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

@@ -2,7 +2,7 @@ import { Emitter } from "../../emitter";
 import { type Environment } from "../../env";
 import { type Expr } from "../../expr";
 import type { FunctionValue, FuncValueId } from "../../function-value";
-import type { DynType, EnumType, FunctionType, IsoType, StructType, Type, TypeId } from "../../types/definitions";
+import type { ArcType, DynType, EnumType, FunctionType, IsoType, StructType, Type, TypeId } from "../../types/definitions";
 import { type TraitValue } from "../../value";
 export interface CodeGenContext {
     types: Record<TypeId, {
@@ -35,6 +35,13 @@ export interface CodeGenContext {
         extractGenerated?: boolean;
         disposeGenerated?: boolean;
     }>;
+    arcTypes?: Map<string, {
+        childTypeCName: string;
+        arcType: ArcType;
+        structGenerated?: boolean;
+        createGenerated?: boolean;
+        disposeGenerated?: boolean;
+    }>;
     spawnedFunctionSignatures: Map<string, {
         parameterTypes: Type[];
         returnType: Type;

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

@@ -56,6 +56,11 @@ export declare function evaluateYoIsoDispose({ expr, env, context, }: {
     env: Environment;
     context: EvaluatorContext;
 }): Expr;
+export declare function evaluateYoArcDispose({ expr, env, context, }: {
+    expr: FnCallExpr;
+    env: Environment;
+    context: EvaluatorContext;
+}): Expr;
 export declare function evaluateYoDropArrayElement({ expr, env, context, }: {
     expr: FnCallExpr;
     env: Environment;

package/out/types/src/evaluator/calls/arc.d.ts

@@ -0,0 +1,15 @@
+import { type Environment } from "../../env";
+import { type FnCallExpr } from "../../expr";
+import type { ArcType } from "../../types/definitions";
+import type { EvaluatorContext } from "../context";
+export declare function evaluateArcTypeCall({ expr, env, context, }: {
+    expr: FnCallExpr;
+    env: Environment;
+    context: EvaluatorContext;
+}): FnCallExpr;
+export declare function evaluateArcValueCall({ expr, env, context, arcType, }: {
+    expr: FnCallExpr;
+    env: Environment;
+    context: EvaluatorContext;
+    arcType: ArcType;
+}): FnCallExpr;

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

@@ -1,7 +1,14 @@
 import { type Environment } from "../../env";
 import { type Expr } from "../../expr";
 import type { TraitType } from "../../types/definitions";
-import type { EvaluatorContext, TraitTypeCallResult } from "../context";
+import type { EvaluatorContext, TraitSpecializationResult, TraitTypeCallResult } from "../context";
+export declare function tryToSpecializeTraitType({ traitType, argExprs, callerEnv, context, }: {
+    traitExpr: Expr;
+    traitType: TraitType;
+    argExprs: Expr[];
+    callerEnv: Environment;
+    context: EvaluatorContext;
+}): TraitSpecializationResult;
 export declare function tryToImplementTraitWithArgumentsByTraitType({ traitExpr, traitType, argExprs, callerEnv, context, }: {
     traitExpr: Expr;
     traitType: TraitType;

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

@@ -3,7 +3,7 @@ import { YoError } from "../error";
 import type { Expr, FnCallExpr, PathCollection } from "../expr";
 import type { FunctionValue } from "../function-value";
 import type { Token } from "../token";
-import type { FunctionType, Type } from "../types/definitions";
+import type { FunctionType, TraitType, Type } from "../types/definitions";
 import type { ArrayValue, ModuleValue, TraitValue, Value } from "../value";
 export interface FunctionEvaluationContext {
     kind: "function-body";
@@ -112,6 +112,10 @@ export interface TraitTypeCallResult {
     traitValue: TraitValue;
     callerEnv: Environment;
 }
+export interface TraitSpecializationResult {
+    specializedTraitType: TraitType;
+    callerEnv: Environment;
+}
 export interface ArrayCallResult {
     value: Value | undefined;
     index?: number;
@@ -157,6 +161,9 @@ export interface FunctionToCall {
     } | {
         kind: "trait-type";
         result: TraitTypeCallResult;
+    } | {
+        kind: "trait-specialization";
+        result: TraitSpecializationResult;
     } | {
         kind: "array";
         result: ArrayCallResult;
@@ -169,6 +176,9 @@ export interface FunctionToCall {
     } | {
         kind: "iso-value";
         result: FnCallExpr;
+    } | {
+        kind: "arc-value";
+        result: FnCallExpr;
     } | {
         kind: "error";
         error: Error | YoError;

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

@@ -1,18 +1,18 @@
 import type { Environment } from "../../env";
 import type { Token } from "../../token";
-import type { DynType, EnumType, IsoType, SomeType, StructType, TupleType, UnionType } from "../../types/definitions";
+import type { ArcType, DynType, EnumType, IsoType, SomeType, StructType, TupleType, UnionType } from "../../types/definitions";
 import type { EvaluatorContext } from "../context";
 export declare function addFunctionSignatureToSelfTypeModule({ label, functionSignature, SelfType, env, context, }: {
     label: string;
     functionSignature: string;
-    SelfType: StructType | EnumType | DynType | SomeType | IsoType;
+    SelfType: StructType | EnumType | DynType | SomeType | IsoType | ArcType;
     env: Environment;
     context: EvaluatorContext;
 }): Environment;
 export declare function addFunctionCodeToSelfTypeModule({ label, functionCode, SelfType, env, context, }: {
     label: string;
     functionCode: string;
-    SelfType: StructType | EnumType | DynType | SomeType | IsoType;
+    SelfType: StructType | EnumType | DynType | SomeType | IsoType | ArcType;
     env: Environment;
     context: EvaluatorContext;
 }): Environment;
@@ -54,6 +54,11 @@ export declare function addRcFunctionsToIsoType({ isoType, env, context, }: {
     env: Environment;
     context: EvaluatorContext;
 }): Environment;
+export declare function addRcFunctionsToArcType({ arcType, env, context, }: {
+    arcType: ArcType;
+    env: Environment;
+    context: EvaluatorContext;
+}): Environment;
 export declare function attachTraitToReceiverType(moduleName: string, receiverType: StructType | EnumType | UnionType | TupleType | SomeType, env: Environment, context: EvaluatorContext): Environment;
 export declare function autoDeriveSendForStructType({ structType, env, context, }: {
     structType: StructType;

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

@@ -2,7 +2,7 @@ import { type Environment } from "../../env";
 import { type Expr } from "../../expr";
 import type { FunctionCapturedVariableInfo } from "../../function-value";
 import type { Token } from "../../token";
-import type { StructType } from "../../types/definitions";
+import type { SomeType, StructType } from "../../types/definitions";
 import { type StructValue, type UnknownValue } from "../../value";
 import type { CapturedVariableInfo, EvaluatorContext } from "../context";
 export declare function consumeCapturedVariables({ capturedVariables, env, closureToken, }: {
@@ -11,6 +11,12 @@ export declare function consumeCapturedVariables({ capturedVariables, env, closu
     closureToken: Token;
 }): Environment;
 export declare function buildPathCollectionFromCapturedVariables(capturedVariables: Map<string, CapturedVariableInfo>): string[][];
+export declare function validateCaptureTraitRequirements({ wrapperType, captureType, env, errorToken, }: {
+    wrapperType: SomeType;
+    captureType: StructType;
+    env: Environment;
+    errorToken: Token;
+}): void;
 export declare function createCaptureTypeAndValue({ expectedCaptureType, capturedVariablesWithValues, env, closureToken, context, }: {
     expectedCaptureType: StructType | undefined;
     capturedVariablesWithValues: Map<string, FunctionCapturedVariableInfo> | undefined;

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

@@ -44,6 +44,14 @@ export declare function findMethodsFromGenericImpls({ concreteType, methodName,
     type: FunctionType;
     value: Value | undefined;
 }[];
+export declare function findAssociatedTypeFromGenericImpls({ concreteType, propertyName, env, }: {
+    concreteType: Type;
+    propertyName: string;
+    env: Environment;
+}): {
+    type: Type;
+    value: Value;
+} | undefined;
 export declare function findMethodFromGenericImplForTrait({ concreteType, traitType, methodName, env, }: {
     concreteType: Type;
     traitType: TraitType;

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

@@ -147,6 +147,7 @@ export declare const BuiltinKeywords: {
     unique: string[];
     Ptr: string[];
     Iso: string[];
+    Arc: string[];
     Tuple: string[];
     Array: string[];
     Slice: string[];
@@ -190,6 +191,7 @@ export declare const BuiltinFunctions: {
     __yo_ptr_deref: string[];
     __yo_ptr_set: string[];
     __yo_slice_len: string[];
+    __yo_slice_new: string[];
     __yo_as: string[];
     __yo_expr_is_atom: string[];
     __yo_expr_is_fn_call: string[];
@@ -501,6 +503,7 @@ export declare const BuiltinFunctions: {
     __yo_rc_own: string[];
     __yo_iso_extract: string[];
     __yo_iso_dispose: string[];
+    __yo_arc_dispose: string[];
     __yo_gc_collect: string[];
     __yo_dyn_drop: string[];
     __yo_dyn_dup: string[];
@@ -517,6 +520,9 @@ export declare const BuiltinFunctions: {
     __yo_noop: string[];
     __yo_return_self: string[];
     __yo_ms_sleep: string[];
+    __yo_getrandom: string[];
+    __yo_arc4random_buf: string[];
+    __yo_bcrypt_gen_random: string[];
     __yo_maybe_uninit_new: string[];
     __yo_maybe_uninit_as_ptr: string[];
     __yo_maybe_uninit_assume_init: string[];

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

@@ -16,6 +16,7 @@ export interface TestResult {
     passed: boolean;
     errorMessage?: string;
     duration: number;
+    profileInfo?: string;
 }
 export interface TestRunSummary {
     totalTests: number;
@@ -33,4 +34,5 @@ export declare function runTests(testFiles: string[], options?: {
     testNamePattern?: string;
     parallel?: number;
     keepGeneratedFiles?: boolean;
+    profile?: boolean;
 }): Promise<TestRunSummary>;

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, TypeField, TypeHierarchyType, UnionType, VoidType } from "./definitions";
+import type { ArcType, ArrayType, ComptimeListType, DynType, EffectsRowType, EnumType, FnTraitType, FunctionForallParameter, FunctionImplicitParameter, FunctionParameter, FunctionParameterExprs, FunctionReturn, FunctionType, FutureTraitType, IsoType, ModuleType, PtrType, SliceType, SomeType, StructType, TraitType, TupleType, Type, TypeField, TypeHierarchyType, UnionType, VoidType } from "./definitions";
 export declare function createComptimeIntType(): Type;
 export declare function createComptimeFloatType(): Type;
 export declare function createComptimeStringType(): Type;
@@ -59,6 +59,7 @@ export declare function createFunctionType({ parameters, forallParameters, impli
 }): FunctionType;
 export declare function createPtrType(childType: Type): PtrType;
 export declare function createIsoType(childType: Type, env: Environment): IsoType;
+export declare function createArcType(childType: Type, env: Environment): ArcType;
 export declare function createSomeType(type: TypeHierarchyType, variableName: string, { id, requiredTraits, negativeTraits, recursiveTypeRef, env, context, }: {
     id?: string;
     requiredTraits?: TraitType[];

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

@@ -169,6 +169,10 @@ export interface TraitType extends Type {
         concreteType: Type;
     };
     definedInModulePath?: string;
+    associatedTypeConstraints?: {
+        label: string;
+        constraintType: Type;
+    }[];
 }
 export type FnTraitType = TraitType & {
     isFn: {
@@ -239,6 +243,12 @@ export interface IsoType extends Type {
     trait: TraitType;
     env: Environment;
 }
+export interface ArcType extends Type {
+    tag: TypeTag.Arc;
+    childType: Type;
+    trait: TraitType;
+    env: Environment;
+}
 export interface DynType extends Type {
     tag: TypeTag.Dyn;
     requiredTraits: {

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, TypeHierarchyType, UnionType, VoidType } from "./definitions";
+import type { ArcType, ArrayType, ComptimeListType, ConcreteModuleType, DynType, EffectsRowType, EnumType, FnTraitType, FunctionType, FutureTraitType, IsoType, ModuleType, PtrType, SliceType, SomeType, StructType, TraitType, TupleType, Type, 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;
@@ -45,6 +45,7 @@ export declare function isType0(type?: Type): boolean;
 export declare function isSomeType(type?: Type): type is SomeType;
 export declare function isPtrType(type?: Type): type is PtrType;
 export declare function isIsoType(type?: Type): type is IsoType;
+export declare function isArcType(type?: Type): type is ArcType;
 export declare function isDynType(type?: Type): type is DynType;
 export declare function isRcType(type?: Type): boolean;
 export declare function isIntegerType(type?: Type): boolean;

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

@@ -40,6 +40,7 @@ export declare enum TypeTag {
     Trait = "Trait",
     Ptr = "Ptr",
     Iso = "Iso",
+    Arc = "Arc",
     Dyn = "Dyn",
     Expr = "Expr",
     ComptimeList = "ComptimeList",