@shd101wyy/yo 0.1.32 → 0.1.34

package/out/types/src/codegen/exprs/comptime-value.d.ts

@@ -1,4 +1,5 @@
+import type { Type } from "../../types/definitions";
 import type { Expr } from "../../expr";
 import { type Value } from "../../value";
 import { type CodeGenContext } from "../utils";
-export declare function generateComptimeValue(value: Value, context: CodeGenContext, _sourceExpr?: Expr): string;
+export declare function generateComptimeValue(value: Value, context: CodeGenContext, _sourceExpr?: Expr, expectedType?: Type): string;

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

@@ -16,6 +16,7 @@ export interface FunctionGenerationContext extends CodeGenContext {
         cInclude?: string;
     }>;
     currentFunctionName: string;
+    unwindValueCTypes?: Set<string>;
     currentFunctionType?: FunctionType;
     currentClosureCaptures?: string[];
     currentClosureCaptureFrameLevel?: number;

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

@@ -2,7 +2,7 @@ import type { EnumType, FunctionType, StructType, TupleType, UnionType } from ".
 import { type CodeGenContext } from "../utils";
 export declare function generateTypeDeclarations(context: CodeGenContext): void;
 export declare function generateArrayStructDeclarations(context: CodeGenContext): void;
-export declare function generateSliceStructDeclarations(context: CodeGenContext): void;
+export declare function generateStrTypeDeclaration(context: CodeGenContext): void;
 export declare function generateIsoTypeDeclarations(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;

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

@@ -1,5 +1,5 @@
 import { Emitter } from "../../emitter";
-import { type Environment } from "../../env";
+import { type Environment, type Variable } from "../../env";
 import { type Expr } from "../../expr";
 import type { FunctionValue, FuncValueId } from "../../function-value";
 import type { TargetInfo } from "../../target";
@@ -24,9 +24,6 @@ export interface CodeGenContext {
         childType: string;
         length: number;
     }>;
-    sliceStructTypes: Map<string, {
-        childType: string;
-    }>;
     isoTypes?: Map<string, {
         childTypeCName: string;
         isoType: IsoType;
@@ -97,5 +94,6 @@ export declare function canOptimizeAsSimpleEnum(enumType: EnumType): boolean;
 export declare function getVariableNameForCodegen(variableName: string, env: Environment | undefined): string;
 export declare function getDeferredDupTargetAtomName(dupExpr: Expr): string | undefined;
 export declare function getDeferredDropTargetAtomName(dropExpr: Expr): string | undefined;
+export declare function getDeferredDropTargetVariable(dropExpr: Expr): Variable | undefined;
 export declare function isDeferredDropForClosureCapture(dropExpr: Expr, currentClosureCaptures: readonly string[] | undefined): boolean;
 export declare function findReturnedAsyncBlock(expr: Expr | undefined): Expr | undefined;

package/out/types/src/evaluator/exprs/_expr.d.ts

@@ -3,6 +3,7 @@ import { type Expr } from "../../expr";
 import type { EvaluatorContext } from "../context";
 export declare function _resetEvalProfiler(): void;
 export declare function _printEvalProfile(): void;
+export declare function setEvaluatorDeadline(deadlineMs: number | undefined): void;
 export declare function _evaluateExpression({ expr, env, context, }: {
     expr: Expr;
     env: Environment;

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

@@ -1,6 +1,28 @@
 import { type Expr } from "../../expr";
+import { type Environment, type Variable } from "../../env";
 export declare function isFlowableExpr(expr: Expr, options?: {
     allowSameFrameLocal?: boolean;
     allowParameterSource?: boolean;
     allowComptimeSource?: boolean;
+    maxLocalFrameLevel?: number;
 }): boolean;
+export declare function aliasGroupRoot(variable: Variable): Variable;
+export declare function findPropertyChainRootAtom(expr: Expr): Expr | undefined;
+export declare function requireRefOwnArgumentExclusivity({ parameters, argExprs, env, }: {
+    parameters: {
+        label: string;
+        isRef?: boolean;
+        isOwningTheRcValue: boolean;
+    }[];
+    argExprs: Expr[];
+    env: Environment;
+}): void;
+export declare function requireValidRefArgumentPlaces({ parameters, argExprs, env, }: {
+    parameters: {
+        label: string;
+        isRef?: boolean;
+        isCompileTimeOnly: boolean;
+    }[];
+    argExprs: Expr[];
+    env: Environment;
+}): void;

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

@@ -211,21 +211,12 @@ export declare const BuiltinFunctions: {
     __yo_address_of: string[];
     __yo_ptr_deref: string[];
     __yo_ptr_set: string[];
-    __yo_slice_len: string[];
-    __yo_slice_new: string[];
-    __yo_slice_ptr: string[];
+    __yo_str_from_raw_parts: string[];
+    __yo_str_len: string[];
+    __yo_str_ptr: string[];
+    __yo_str_byte: 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[];

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, EnumType, FnTraitType, FunctionForallParameter, FunctionParameter, FunctionParameterExprs, FutureEffect, FunctionReturn, FunctionType, FutureTraitType, IsoType, SourceNamespaceType, PtrType, SliceType, SomeType, StructType, TraitType, TupleType, Type, TypeApplicationType, TypeField, TypeHierarchyType, UnionType, VoidType } from "./definitions";
+import type { ArrayType, ComptimeListType, DynType, EnumType, FnTraitType, FunctionForallParameter, FunctionParameter, FunctionParameterExprs, FutureEffect, FunctionReturn, FunctionType, FutureTraitType, IsoType, SourceNamespaceType, PtrType, StrType, 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;
@@ -36,8 +36,7 @@ export declare function createULongLongType(): Type;
 export declare function createLongDoubleType(): Type;
 export declare function createType0(baseType?: Type): TypeHierarchyType;
 export declare function createArrayType(childType: Type, length: Value): ArrayType;
-export declare function createSliceType(childType: Type): SliceType;
-export declare function createStrType(env: Environment): Type;
+export declare function createStrType(_env?: Environment): StrType;
 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;

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

@@ -68,9 +68,8 @@ export interface ArrayType extends Type {
     length: Value;
     trait: TraitType;
 }
-export interface SliceType extends Type {
-    tag: TypeTag.Slice;
-    childType: Type;
+export interface StrType extends Type {
+    tag: TypeTag.Str;
     trait: TraitType;
 }
 export interface VoidType extends Type {

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

@@ -1,5 +1,5 @@
 import { FunctionValue } from "../function-value";
-import type { ArrayType, ComptimeListType, ConcreteTraitType, DynType, EnumType, FnTraitType, FunctionType, FutureTraitType, IsoType, SourceNamespaceType, PtrType, SliceType, SomeType, StructType, TraitType, TupleType, Type, TypeApplicationType, TypeHierarchyType, UnionType, VoidType } from "./definitions";
+import type { ArrayType, ComptimeListType, ConcreteTraitType, DynType, EnumType, FnTraitType, FunctionType, FutureTraitType, IsoType, SourceNamespaceType, PtrType, StrType, 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;
@@ -22,7 +22,7 @@ export declare function isF32Type(type?: Type): boolean;
 export declare function isF64Type(type?: Type): boolean;
 export declare function isExprType(type?: Type): boolean;
 export declare function isArrayType(type?: Type): type is ArrayType;
-export declare function isSliceType(type?: Type): type is SliceType;
+export declare function isStrType(type?: Type): type is StrType;
 export declare function isTupleType(type?: Type): type is TupleType;
 export declare function isUnionType(type?: Type): type is UnionType;
 export declare function isEnumType(type?: Type): type is EnumType;

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

@@ -15,7 +15,7 @@ export declare enum TypeTag {
     F64 = "f64",
     ComptimeInt = "comptime_int",
     ComptimeFloat = "comptime_float",
-    ComptimeString = "comptime_string",
+    ComptimeString = "comptime_str",
     Char = "char",
     Short = "short",
     UShort = "ushort",
@@ -35,7 +35,7 @@ export declare enum TypeTag {
     Union = "Union",
     Function = "Function",
     SomeType = "SomeType",
-    Slice = "Slice",
+    Str = "str",
     Trait = "Trait",
     Ptr = "Ptr",
     Iso = "Iso",

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

@@ -19,7 +19,6 @@ export declare enum ValueTag {
     Unit = "Unit",
     Bool = "Bool",
     Array = "Array",
-    Slice = "Slice",
     Function = "Function",
     Tuple = "Tuple",
     Struct = "Struct",

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, PtrType, SliceType, StructType, TraitType, TupleType, Type } from "./types/definitions";
+import type { ArrayType, ComptimeListType, EnumType, ExprType, PtrType, StructType, TraitType, TupleType, Type } from "./types/definitions";
 import type { UnitValue } from "./unit-value";
 import { ValueTag } from "./value-tag";
 export type ComptimeStringValue = {
@@ -49,13 +49,6 @@ export type ArrayValue = {
     type: ArrayType;
     elements: Value[];
 };
-export type SliceValue = {
-    tag: ValueTag.Slice;
-    type: SliceType;
-    sourceArray: [ArrayValue];
-    startIndex: number;
-    endIndex: number;
-};
 export type ExprValue = {
     tag: ValueTag.Expr;
     type: ExprType;
@@ -79,7 +72,7 @@ export type PtrValue = {
     targetValue: [Value];
     targetIndex: number;
 };
-export type Value = TypeValue | ComptimeStringValue | ComptimeListValue | NumberValue | UnitValue | BooleanValue | ArrayValue | SliceValue | TupleValue | StructValue | EnumValue | TraitValue | FunctionValue | ExprValue | UnknownValue | PtrValue;
+export type Value = TypeValue | ComptimeStringValue | ComptimeListValue | NumberValue | UnitValue | BooleanValue | ArrayValue | 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;
@@ -94,7 +87,6 @@ export declare function isUnknownValue(value?: Value): value is UnknownValue;
 export declare function isTupleValue(value?: Value): value is TupleValue;
 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 isTraitValue(value?: Value): value is TraitValue;
 export declare function isPtrValue(value?: Value): value is PtrValue;
@@ -125,7 +117,6 @@ export declare function createTraitValue(type: TraitType, fields: (Value | undef
 export declare function createTupleValue(type: TupleType, fields: Value[]): TupleValue;
 export declare function createEnumValue(type: EnumType, variantName: string, fields: Value[]): EnumValue;
 export declare function createArrayValue(type: ArrayType, elements: Value[]): ArrayValue;
-export declare function createSliceValue(type: SliceType, sourceArray: [ArrayValue], startIndex: number, endIndex: number): SliceValue;
 export declare function createExprValue(expr: Expr): ExprValue;
 export declare function createPtrValue(type: PtrType, targetValue: [Value], targetIndex?: number): PtrValue;
 export declare function areValuesEqual(expected: {