@shd101wyy/yo 0.1.29 → 0.1.30

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

@@ -1,6 +1,8 @@
 import { type FnCallExpr } from "../../expr";
+import type { FutureTraitType } from "../../types/definitions";
 import type { FunctionGenerationContext } from "../functions/context";
 export declare function generateAsyncBlock(expr: FnCallExpr, indent: string, context: FunctionGenerationContext): string;
+export declare function findBundleFieldName(futureTraitType: FutureTraitType, stateMachineVariables: Map<string, import("../../evaluator/async/await-analysis-types").CapturedVariable> | undefined, stateMachineFieldAliases?: Map<string, string>): string | undefined;
 export declare function generateDeferredAsyncBlocks(context: FunctionGenerationContext): void;
 export declare function preRegisterAsyncBlockTypes(context: FunctionGenerationContext): void;
 export declare function generateIoAsyncSyncCall(expr: FnCallExpr, indent: string, context: FunctionGenerationContext): string;

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

@@ -3,3 +3,4 @@ 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;
+export declare function emitIoSpawnEffectInjection(expr: FnCallExpr, futureVar: string, indent: string, context: CodeGenContext): void;

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

@@ -1,6 +1,10 @@
 import { type Environment } from "../../env";
 import { type FnCallExpr } from "../../expr";
+import type { Type } from "../../types/definitions";
+export declare function resolveSomeTypeToConcrete(t: Type): Type;
+import type { FunctionGenerationContext } from "../functions/context";
 import { type CodeGenContext } from "../utils";
 export declare function checkVariableIsClosureCaptured(variableName: string, env: Environment, closureCaptureFrameLevel: number): boolean;
 export declare function isClosureConstruction(expr: FnCallExpr): boolean;
+export declare function registerImplClosureCallMappings(context: FunctionGenerationContext): void;
 export declare function generateClosureConstruction(expr: FnCallExpr, indent: string, context: CodeGenContext): string;

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

@@ -51,6 +51,12 @@ export interface FunctionGenerationContext extends CodeGenContext {
         resultTypeCName: string;
         captureType: StructType | undefined;
         analysis: AwaitAnalysisResult;
+        closureParamSlots?: {
+            fieldName: string;
+            cType: string;
+            paramName: string;
+            paramType: Type;
+        }[];
     }>;
     asyncCondBranchInfo?: Map<number, {
         branches: Array<{

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

@@ -11,6 +11,8 @@ export interface Variable {
     isOwningTheRcValue: boolean;
     isOwningTheSameRcValueAs?: Variable;
     isReassignable?: boolean;
+    isRef?: boolean;
+    isParameter?: boolean;
     initializedAtToken: Token | undefined;
     consumedAtToken: Token | undefined;
     frameLevel: number;

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

@@ -0,0 +1,9 @@
+import type { Environment } from "../../env";
+import { type Expr, type FnCallExpr } from "../../expr";
+import type { EvaluatorContext } from "../context";
+export declare function evaluatePragma({ expr, env, context, }: {
+    expr: FnCallExpr;
+    env: Environment;
+    context: EvaluatorContext;
+}): FnCallExpr;
+export declare function preScanForSkipPrelude(program: Expr[], modulePath: string): boolean;

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

@@ -0,0 +1,8 @@
+import type { Environment } from "../../env";
+import { type FnCallExpr } from "../../expr";
+import type { EvaluatorContext } from "../context";
+export declare function evaluateUnsafe({ expr, env, context, }: {
+    expr: FnCallExpr;
+    env: Environment;
+    context: EvaluatorContext;
+}): FnCallExpr;

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

@@ -54,6 +54,7 @@ export interface EvaluatorContext {
     stdPath: string;
     currentModulePath?: string;
     isUnsafeFunctionType?: boolean;
+    unsafeContext?: boolean;
     isControlFunctionType?: boolean;
     enclosingFunctionReturnType?: Type;
     hasControlFunctionImplicitParams?: boolean;
@@ -65,6 +66,7 @@ export interface EvaluatorContext {
         token: Token;
     }>;
     forceCompileTimeBindings?: boolean;
+    deferGenericFnTypeCheckToAssignment?: boolean;
     isAnalyzingCtfeCapability?: boolean;
     isInFunctionCallCheckingPhase?: boolean;
     isInsideIoAsyncCall?: boolean;

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

@@ -1,6 +1,6 @@
 import { type Environment } from "../env";
 import type { Expr } from "../expr";
-import { type Token } from "../token";
+import type { Token } from "../token";
 import type { StructValue } from "../value";
 import type { LoadModuleFn } from "./context";
 import { clearAllGlobalImplState, clearGenericImplsFromModule, clearImplsFromModule } from "./values/impl";

package/out/types/src/evaluator/memory-safety.d.ts

@@ -0,0 +1,14 @@
+export type PragmaKind = "AllowUnsafe" | "SkipPrelude" | "SkipWasm" | "SkipWasm32Emscripten" | "SkipWasm32Wasi";
+export declare function registerFilePragma(modulePath: string, kind: PragmaKind): void;
+export declare function fileHasPragma(modulePath: string | undefined, kind: PragmaKind): boolean;
+export declare function _clearPragmaRegistry(): void;
+export declare function _clearPragmaForModule(modulePath: string): void;
+export declare function isImplicitlyUnsafeCapableFile(modulePath: string | undefined): boolean;
+export declare function isAutoGeneratedExpansion(modulePath: string | undefined): boolean;
+type ExternCallSiteRecord = {
+    modulePath: string;
+    characterOffset: number;
+    calleeName: string;
+};
+export declare function recordExternCallSite(record: ExternCallSiteRecord): void;
+export {};

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

@@ -0,0 +1,6 @@
+import { type Expr } from "../../expr";
+export declare function isFlowableExpr(expr: Expr, options?: {
+    allowSameFrameLocal?: boolean;
+    allowParameterSource?: boolean;
+    allowComptimeSource?: boolean;
+}): boolean;

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

@@ -1,4 +1,5 @@
 import { type Expr } from "./expr";
+export declare function allPathsUnwind(expr: Expr): boolean;
 export declare function evaluatedBodyContainsEscape(expr: Expr): boolean;
 export declare function exprTreeContainsReturn(expr: Expr): boolean;
 export declare function exprContainsAwait(expr: Expr): boolean;

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

@@ -86,6 +86,7 @@ export interface EvaluatedExprData {
     indexMethodType?: FunctionType;
     indexMethodValue?: Value;
     isIndexTraitAddressOf?: boolean;
+    isReturnSlot?: boolean;
     isCompileTimeOnlyAssignment?: boolean;
     isAnonymousFunctionDefinition?: boolean;
     comptimeUnrolledBodies?: Expr[];
@@ -190,6 +191,8 @@ export declare const BuiltinFunctions: {
     typeid: string[];
     downcast: string[];
     consume: string[];
+    unsafe: string[];
+    pragma: string[];
     macro_expand: string[];
     as: string[];
     the: string[];
@@ -609,7 +612,7 @@ export interface ExprToStringConfig {
 }
 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 attachTempVariableToExpr(expr: Expr, isOwningTheRcValue: boolean, isOwningTheSameRcValueAs?: Variable, isRef?: boolean): void;
 export declare function mergeAndCheckEnvs(env: Environment, bodies: Expr[]): Environment;
 export declare function replaceFuncCallExprWithFuncCallExpr(funcExpr: FnCallExpr, newFuncExpr: FnCallExpr): void;
 export declare function replaceFuncCallExprWithAtomExpr(funcExpr: FnCallExpr, newAtomExpr: AtomExpr): void;

package/out/types/src/public-safe-report.d.ts

@@ -0,0 +1,19 @@
+export interface PublicSafeFinding {
+    file: string;
+    line: number;
+    column: number;
+    declName: string;
+    slot: "parameter" | "return";
+    pointerType: string;
+    snippet: string;
+}
+export interface PublicSafeReport {
+    findings: PublicSafeFinding[];
+    totals: {
+        filesScanned: number;
+        publicDeclsScanned: number;
+        findings: number;
+    };
+}
+export declare function generatePublicSafeReport(rootPath: string): PublicSafeReport;
+export declare function formatPublicSafeReport(report: PublicSafeReport): string;

package/out/types/src/tests/comptime-ref-gate.test.d.ts

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

package/out/types/src/tests/pragma-validation.test.d.ts

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

package/out/types/src/tests/public-safe-report.test.d.ts

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

package/out/types/src/tests/type-representation-pointer.test.d.ts

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

package/out/types/src/tests/unsafe-gate.test.d.ts

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

package/out/types/src/tests/unsafe-report-classify.test.d.ts

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

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

@@ -113,6 +113,7 @@ export interface FunctionParameter {
     isCompileTimeOnly: boolean;
     isQuote: boolean;
     isOwningTheRcValue: boolean;
+    isRef?: boolean;
     exprs: FunctionParameterExprs;
     assignedValue?: Value;
 }
@@ -213,6 +214,7 @@ export interface FunctionReturn {
     isCompileTimeOnly: boolean;
     isUnquote: boolean;
     label: string;
+    isRef?: boolean;
 }
 export interface FunctionType extends Type {
     tag: TypeTag.Function;

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

@@ -8,7 +8,11 @@ export declare function isComptimeOnlyType(type: Type, env: Environment): boolea
 export declare function isRuntimeOnlyType(type: Type, env: Environment): boolean;
 export declare function typeContainsRcType(type?: Type, checkedTypes?: Type[]): boolean;
 export declare function typeIsControlBound(type?: Type, checkedTypes?: Type[]): boolean;
+export declare function typeRepresentationContainsRawPtr(type?: Type, checkedTypes?: Type[]): boolean;
+export declare function typeMayProvideSliceSource(type?: Type, checkedTypes?: Type[]): boolean;
 export declare function typeContainsSomeType(type?: Type, checkedTypes?: Type[]): boolean;
+export declare function typeContainsUnboundSomeType(type?: Type, boundNames?: Set<string>, checkedTypes?: Type[]): boolean;
+export declare function typeContainsSomeTypeForCodegenParam(type?: Type, checkedTypes?: Type[]): boolean;
 export declare function typeContainsUnknownValue(type: Type, visited?: Set<string>): boolean;
 export declare function getAllSomeTypes(type: Type): Set<SomeType>;
 export declare function typeRequiresInference(type?: Type): boolean;

package/out/types/src/unsafe-report.d.ts

@@ -0,0 +1,29 @@
+export type UnsafeSubKind = "extern-call" | "deref" | "arith" | "addr-of" | "other";
+export interface UnsafeFinding {
+    file: string;
+    line: number;
+    column: number;
+    kind: "unsafe" | "asm" | "extern" | "pragma";
+    subKind?: UnsafeSubKind;
+    calleeName?: string;
+    snippet: string;
+    safetyComment?: string;
+}
+export interface UnsafeReport {
+    privilegedFiles: string[];
+    findings: UnsafeFinding[];
+    totals: {
+        filesScanned: number;
+        privileged: number;
+        unsafeSites: number;
+        unsafeBySubKind: Record<UnsafeSubKind, number>;
+        asmSites: number;
+        externSites: number;
+    };
+    topExternCallees: Array<{
+        callee: string;
+        count: number;
+    }>;
+}
+export declare function generateUnsafeReport(rootPath: string): UnsafeReport;
+export declare function formatUnsafeReport(report: UnsafeReport): string;

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

@@ -71,6 +71,7 @@ export type UnknownValue = {
     type: Type;
     variableName?: string;
     isRuntimeOnly?: boolean;
+    resolvedFuncValueId?: string;
 };
 export type PtrValue = {
     tag: ValueTag.Ptr;