@shd101wyy/yo 0.1.28 → 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/codegen/functions/declarations.d.ts

@@ -10,7 +10,7 @@ export interface EvidenceParameter {
     fieldFunctionType: FunctionType;
     cParamName: string;
 }
-export declare function getEvidenceParameters(functionType: FunctionType): EvidenceParameter[];
+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;

package/out/types/src/doc/model.d.ts

@@ -3,7 +3,6 @@ export interface DocParam {
     name: string;
     type: string;
     isComptime: boolean;
-    isImplicit: boolean;
     defaultValue?: string;
     doc?: string;
 }

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

@@ -11,13 +11,14 @@ export interface Variable {
     isOwningTheRcValue: boolean;
     isOwningTheSameRcValueAs?: Variable;
     isReassignable?: boolean;
+    isRef?: boolean;
+    isParameter?: boolean;
     initializedAtToken: Token | undefined;
     consumedAtToken: Token | undefined;
     frameLevel: number;
     token: Token;
     isCreatedFromDestructuringAtomVariable?: boolean;
     parameterAlias?: string;
-    isImplicit?: boolean;
     isFromEffectSpread?: boolean;
     isEffectParam?: boolean;
     isModuleLevel?: boolean;
@@ -129,7 +130,6 @@ export declare function getReceiverMethodsByNameFromEnv({ env, context, methodNa
     value: Value | undefined;
     needsPointerConversion?: boolean;
 }[];
-export declare function stripImplicitVariablesFromEnv(env: Environment): Environment;
 export declare function keepTopLevelFrameAndComptimeVariablesFromEnv(env: Environment): Environment;
 export declare function getVariablesNeedingDrop(env: Environment): Variable[];
 export declare function findNearestBeginBlockFrameLevel(env: Environment): 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,8 @@ export interface EvaluatorContext {
     stdPath: string;
     currentModulePath?: string;
     isUnsafeFunctionType?: boolean;
+    unsafeContext?: boolean;
+    isControlFunctionType?: boolean;
     enclosingFunctionReturnType?: Type;
     hasControlFunctionImplicitParams?: boolean;
     isInsideWhereClause?: boolean;
@@ -64,10 +66,10 @@ export interface EvaluatorContext {
         token: Token;
     }>;
     forceCompileTimeBindings?: boolean;
+    deferGenericFnTypeCheckToAssignment?: boolean;
     isAnalyzingCtfeCapability?: boolean;
     isInFunctionCallCheckingPhase?: boolean;
     isInsideIoAsyncCall?: boolean;
-    isInsideGivenHandler?: boolean;
     isEvaluatingGenericImplSpecialization?: boolean;
     currentlySpecializingFunction?: {
         originalFuncId: string;

package/out/types/src/evaluator/exprs/{escape.d.ts → unwind.d.ts}

@@ -1,7 +1,7 @@
 import { type Environment } from "../../env";
 import { type Expr, type FnCallExpr } from "../../expr";
 import type { EvaluatorContext } from "../context";
-export declare function evaluateEscape({ expr, env, context, }: {
+export declare function evaluateUnwind({ expr, env, context, }: {
     expr: FnCallExpr;
     env: Environment;
     context: EvaluatorContext;

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/evaluator/types/function.d.ts

@@ -1,6 +1,6 @@
 import { type Environment } from "../../env";
 import { type Expr, type FnCallExpr } from "../../expr";
-import type { FunctionImplicitParameter, FunctionParameter, FunctionType, Type } from "../../types/definitions";
+import type { FunctionParameter, FunctionType, Type } from "../../types/definitions";
 import type { EvaluatorContext } from "../context";
 export declare function evaluateFunctionParameter({ expr, env, context, isParameterComptimeByDefault, allowVariableShadowing, }: {
     expr: Expr;
@@ -32,7 +32,6 @@ export declare function evaluateFunctionParameters({ parameterExprs, env, contex
 }): {
     parameters: FunctionParameter[];
     forallParameters: FunctionParameter[];
-    implicitParameters: FunctionImplicitParameter[];
     variadicParameter?: FunctionParameter;
     whereClauseExprs?: Expr[];
     env: Environment;

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

@@ -2,4 +2,3 @@ import { type Environment, type Variable } from "../env";
 import { type Expr } from "../expr";
 export declare function isValidVariableName(expr: Expr): boolean;
 export declare function findRcValueOwnerRelationship(rhs: Expr, env: Environment, _modulePath: string): Variable | undefined;
-export declare function throwExprIsImplicitVariableError(rhs: Expr): void;

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

@@ -39,12 +39,12 @@ export interface RuntimeDestructuring {
 }
 export type ControlFlowFlags = {
     return?: boolean;
-    escape?: boolean;
+    unwind?: boolean;
     break?: boolean;
     continue?: boolean;
 };
-export declare function controlFlowOf(kind: "return" | "escape" | "break" | "continue"): ControlFlowFlags;
-export declare function hasControlFlow(cf: ControlFlowFlags | undefined, kind: "return" | "escape" | "break" | "continue"): boolean;
+export declare function controlFlowOf(kind: "return" | "unwind" | "break" | "continue"): ControlFlowFlags;
+export declare function hasControlFlow(cf: ControlFlowFlags | undefined, kind: "return" | "unwind" | "break" | "continue"): boolean;
 export declare function hasAnyControlFlow(cf: ControlFlowFlags | undefined): boolean;
 export declare function mergeControlFlows(flows: ControlFlowFlags[]): ControlFlowFlags;
 export declare function controlFlowToString(cf: ControlFlowFlags): string;
@@ -86,6 +86,7 @@ export interface EvaluatedExprData {
     indexMethodType?: FunctionType;
     indexMethodValue?: Value;
     isIndexTraitAddressOf?: boolean;
+    isReturnSlot?: boolean;
     isCompileTimeOnlyAssignment?: boolean;
     isAnonymousFunctionDefinition?: boolean;
     comptimeUnrolledBodies?: Expr[];
@@ -118,8 +119,6 @@ export declare const BuiltinKeywords: {
     runtime: string[];
     ref: string[];
     forall: string[];
-    using: string[];
-    given: string[];
     where: string[];
     quote: string[];
     unquote: string[];
@@ -128,7 +127,8 @@ export declare const BuiltinKeywords: {
     recur: string[];
     fn: string[];
     unsafe_fn: string[];
-    escape: string[];
+    ctl: string[];
+    unwind: string[];
     extern: string[];
     cond: string[];
     type: string[];
@@ -191,6 +191,8 @@ export declare const BuiltinFunctions: {
     typeid: string[];
     downcast: string[];
     consume: string[];
+    unsafe: string[];
+    pragma: string[];
     macro_expand: string[];
     as: string[];
     the: string[];
@@ -610,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/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, 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, 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;
@@ -45,10 +45,9 @@ export declare function createSourceNamespaceType(env: Environment): SourceNames
 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, variadicParameter, whereClauseExprs, return_, env, parametersFrame, SelfType, SelfTraitType, isClosure, isControl, }: {
     parameters: FunctionParameter[];
     forallParameters: FunctionForallParameter[];
-    implicitParameters?: FunctionImplicitParameter[];
     variadicParameter: FunctionParameter | undefined;
     whereClauseExprs?: Expr[];
     return_: FunctionReturn;
@@ -57,6 +56,7 @@ export declare function createFunctionType({ parameters, forallParameters, impli
     SelfType?: Type;
     SelfTraitType?: Type;
     isClosure?: boolean;
+    isControl?: boolean;
 }): FunctionType;
 export declare function createPtrType(childType: Type): PtrType;
 export declare function createIsoType(childType: Type, env: Environment): IsoType;
@@ -71,8 +71,6 @@ export declare function createSomeType(type: TypeHierarchyType, variableName: st
     env: Environment;
     context: EvaluatorContext;
 }): SomeType;
-export declare function createEffectsRowSomeType(variableName: string, env: Environment): SomeType;
-export declare function createEffectsRowType(implicitParameters: FunctionImplicitParameter[]): EffectsRowType;
 export declare function createTypeHierarchy(level: number, baseType?: Type): TypeHierarchyType;
 export declare function getFunctionParameterExprs({ expr, labelExpr, typeExpr, defaultValueExpr, assignedValueExpr, }: {
     expr: Expr;
@@ -82,7 +80,7 @@ export declare function getFunctionParameterExprs({ expr, labelExpr, typeExpr, d
     assignedValueExpr: Expr | undefined;
 }): FunctionParameterExprs;
 export declare function createFnTraitType(fnType: FunctionType, env: Environment): FnTraitType;
-export declare function createFutureTraitType(outputType: Type, env: Environment, effects?: FunctionImplicitParameter[]): FutureTraitType;
+export declare function createFutureTraitType(outputType: Type, env: Environment, effect?: FutureEffect): FutureTraitType;
 export declare function createDynType({ requiredTraits, env, negativeTraits, }: {
     requiredTraits: TraitType[];
     env: Environment;

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

@@ -53,14 +53,8 @@ export interface SomeType extends Type {
         functionValue: FunctionValue;
         argValues: Value[];
     };
-    isEffectsRow?: boolean;
     kindFunctionType?: FunctionType;
 }
-export interface EffectsRowType extends Type {
-    tag: TypeTag.EffectsRow;
-    implicitParameters: FunctionImplicitParameter[];
-    trait: TraitType;
-}
 export interface TypeApplicationType extends Type {
     tag: TypeTag.TypeApplication;
     constructor: SomeType;
@@ -119,18 +113,12 @@ export interface FunctionParameter {
     isCompileTimeOnly: boolean;
     isQuote: boolean;
     isOwningTheRcValue: boolean;
-    isImplicit: boolean;
-    isEffectRowSpread?: boolean;
+    isRef?: boolean;
     exprs: FunctionParameterExprs;
     assignedValue?: Value;
 }
 export type FunctionForallParameter = FunctionParameter & {
     isCompileTimeOnly: true;
-    isImplicit: false;
-};
-export type FunctionImplicitParameter = FunctionParameter & {
-    isCompileTimeOnly: true;
-    isImplicit: true;
 };
 export interface StructType extends Type {
     tag: TypeTag.Struct;
@@ -164,7 +152,7 @@ export interface TraitType extends Type {
     };
     isFuture?: {
         outputType: Type;
-        effects: FunctionImplicitParameter[];
+        effect?: FutureEffect;
     };
     isConcrete?: {
         concreteType: Type;
@@ -181,10 +169,14 @@ export type FnTraitType = TraitType & {
         callType: FunctionType;
     };
 };
+export interface FutureEffect {
+    label: string;
+    type: Type;
+}
 export type FutureTraitType = TraitType & {
     isFuture: {
         outputType: Type;
-        effects: FunctionImplicitParameter[];
+        effect?: FutureEffect;
     };
 };
 export type ConcreteTraitType = TraitType & {
@@ -222,12 +214,12 @@ export interface FunctionReturn {
     isCompileTimeOnly: boolean;
     isUnquote: boolean;
     label: string;
+    isRef?: boolean;
 }
 export interface FunctionType extends Type {
     tag: TypeTag.Function;
     parameters: FunctionParameter[];
     forallParameters: FunctionForallParameter[];
-    implicitParameters: FunctionImplicitParameter[];
     variadicParameter?: FunctionParameter;
     whereClauseExprs?: Expr[];
     return: FunctionReturn;
@@ -237,6 +229,7 @@ export interface FunctionType extends Type {
     SelfTraitType?: Type;
     trait: TraitType;
     isClosure?: boolean;
+    isControl?: boolean;
 }
 export interface PtrType extends Type {
     tag: TypeTag.Ptr;

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

@@ -1,5 +1,5 @@
 import { FunctionValue } from "../function-value";
-import type { ArrayType, ComptimeListType, ConcreteTraitType, DynType, EffectsRowType, 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, 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;
@@ -77,4 +77,3 @@ export declare function isBoxedType(type: Type): type is StructType & {
     isReferenceSemantics: true;
     __isBoxed: true;
 };
-export declare function isEffectsRowType(type?: Type): type is EffectsRowType;

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

@@ -42,6 +42,5 @@ export declare enum TypeTag {
     Dyn = "Dyn",
     Expr = "Expr",
     ComptimeList = "ComptimeList",
-    EffectsRow = "EffectsRow",
     TypeApplication = "TypeApplication"
 }

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

@@ -7,7 +7,12 @@ export declare function typeProhibitsComptimeModifier(type: Type | undefined, en
 export declare function isComptimeOnlyType(type: Type, env: Environment): boolean;
 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;