@shd101wyy/yo 0.1.15 → 0.1.16

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

@@ -1,7 +1,7 @@
 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 generatePendingDeferredDrops(indent: string, context: FunctionGenerationContext, expr: Expr, isCompletion?: boolean, skipAlreadyDroppedCheck?: boolean, skipEnvCheck?: boolean, additionalSkipVarNames?: Set<string>): 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/types/generation.d.ts

@@ -4,8 +4,6 @@ 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

@@ -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 { ArcType, DynType, EnumType, FunctionType, IsoType, StructType, Type, TypeId } from "../../types/definitions";
+import type { DynType, EnumType, FunctionType, IsoType, StructType, Type, TypeId } from "../../types/definitions";
 import { type TraitValue } from "../../value";
 export interface CodeGenContext {
     types: Record<TypeId, {
@@ -36,13 +36,6 @@ 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;
@@ -61,6 +54,7 @@ export interface CodeGenContext {
         functionCName: string;
         callTypeId: TypeId;
         callType?: FunctionType;
+        consumedCaptures?: string[];
     }>;
     currentFunctionName: string;
     cIncludes: Set<string>;

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

@@ -61,11 +61,6 @@ 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/context.d.ts

@@ -38,6 +38,7 @@ export interface EvaluatorContext {
     isEvaluatingFunctionBodyOrAsyncBlock?: FunctionEvaluationContext | AsyncBlockEvaluationContext | TestBlockEvaluationContext;
     isInsideImplBlock?: boolean;
     capturedVariables?: Map<string, CapturedVariableInfo>;
+    ownConsumedCaptures?: Set<string>;
     isEvaluatingLoopBody?: {
         kind: "while" | "for";
         env: Environment;
@@ -69,6 +70,12 @@ export interface EvaluatorContext {
     isInsideIoAsyncCall?: boolean;
     isInsideGivenHandler?: boolean;
     isEvaluatingGenericImplSpecialization?: boolean;
+    currentlySpecializingFunction?: {
+        originalFuncId: string;
+        specializedFuncId: string;
+        specializedReturnType: Type;
+        originalFunction: FunctionValue;
+    };
     docCommentLookup?: Map<string, string>;
 }
 export interface ArgValues {
@@ -178,9 +185,6 @@ export interface FunctionToCall {
     } | {
         kind: "iso-value";
         result: FnCallExpr;
-    } | {
-        kind: "arc-value";
-        result: FnCallExpr;
     } | {
         kind: "index";
         result: IndexCallResult;

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

@@ -16,6 +16,8 @@ export declare function checkTypeImplementsSelfConstraints({ targetType, traitTy
 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 beginSendDerivation(typeId: string): void;
+export declare function endSendDerivation(typeId: string): void;
 export declare function typeImplementsSend(type: Type | undefined, env: Environment): boolean;
 export declare function typeImplementsDispose(type: Type | undefined, env: Environment): boolean;
 export declare function typeImplementsAcyclic(type: Type | undefined, env: Environment): boolean;

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

@@ -1,8 +1,9 @@
 import type { Environment } from "../../env";
 import { type FnCallExpr } from "../../expr";
 import type { EvaluatorContext } from "../context";
-export declare function evaluateObjectType({ expr, env, context, }: {
+export declare function evaluateObjectType({ expr, env, context, isAtomicRc, }: {
     expr: FnCallExpr;
     env: Environment;
     context: EvaluatorContext;
+    isAtomicRc?: boolean;
 }): FnCallExpr;

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

@@ -1,8 +1,9 @@
 import type { Environment } from "../../env";
 import { type FnCallExpr } from "../../expr";
 import type { EvaluatorContext } from "../context";
-export declare function evaluateStructType({ expr, env, context, }: {
+export declare function evaluateStructType({ expr, env, context, isAtomicRc, }: {
     expr: FnCallExpr;
     env: Environment;
     context: EvaluatorContext;
+    isAtomicRc?: boolean;
 }): FnCallExpr;

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 { ArcType, DynType, EnumType, IsoType, SomeType, StructType, TupleType, UnionType } from "../../types/definitions";
+import type { 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 | ArcType;
+    SelfType: StructType | EnumType | DynType | SomeType | IsoType;
     env: Environment;
     context: EvaluatorContext;
 }): Environment;
 export declare function addFunctionCodeToSelfTypeModule({ label, functionCode, SelfType, env, context, }: {
     label: string;
     functionCode: string;
-    SelfType: StructType | EnumType | DynType | SomeType | IsoType | ArcType;
+    SelfType: StructType | EnumType | DynType | SomeType | IsoType;
     env: Environment;
     context: EvaluatorContext;
 }): Environment;
@@ -54,11 +54,6 @@ 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/expr.d.ts

@@ -133,6 +133,7 @@ export declare const BuiltinKeywords: {
     type: string[];
     match: string[];
     test: string[];
+    atomic: string[];
     struct: string[];
     object: string[];
     newtype: string[];
@@ -166,7 +167,6 @@ export declare const BuiltinKeywords: {
     unique: string[];
     Ptr: string[];
     Iso: string[];
-    Arc: string[];
     Tuple: string[];
     Array: string[];
     Slice: string[];
@@ -552,7 +552,6 @@ 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[];

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

@@ -46,4 +46,5 @@ export interface ClosureInfo {
     closureType: FnTraitType;
     captureType: Type | undefined;
     effectParamNames?: string[];
+    consumedCaptures?: string[];
 }

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 { ArcType, 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, ModuleType, 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;
@@ -40,7 +40,7 @@ export declare function createSliceType(childType: Type): SliceType;
 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): StructType;
+export declare function createStructType(env: Environment, isReferenceSemantics?: boolean, isNewtype?: boolean, isAtomicRc?: boolean): StructType;
 export declare function createModuleType(env: Environment): ModuleType;
 export declare function createTraitType(env: Environment): TraitType;
 export declare function createEnumType(env: Environment): EnumType;
@@ -61,7 +61,6 @@ 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

@@ -133,6 +133,7 @@ export type FunctionImplicitParameter = FunctionParameter & {
 export interface StructType extends Type {
     tag: TypeTag.Struct;
     isReferenceSemantics: boolean;
+    isAtomicRc?: boolean;
     isNewtype: boolean;
     functionValue?: FunctionValue;
     fields: TypeField[];
@@ -259,12 +260,6 @@ 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 { ArcType, 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, ConcreteModuleType, DynType, EffectsRowType, EnumType, FnTraitType, FunctionType, FutureTraitType, IsoType, ModuleType, 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;
@@ -30,6 +30,10 @@ export declare function isStructType(type?: Type): type is StructType;
 export declare function isObjectType(type?: Type): type is StructType & {
     isReferenceSemantics: true;
 };
+export declare function isAtomicObjectType(type?: Type): type is StructType & {
+    isReferenceSemantics: true;
+    isAtomicRc: true;
+};
 export declare function isNewtypeType(type?: Type): type is StructType & {
     isNewtype: true;
 };
@@ -45,7 +49,6 @@ 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 isTypeApplicationType(type?: Type): type is TypeApplicationType;
 export declare function isRcType(type?: Type): boolean;

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

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