@shd101wyy/yo 0.1.30 → 0.1.32

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

@@ -31,7 +31,7 @@ export declare class CodeGenerator {
         release?: boolean;
         optimize?: "0" | "1" | "2" | "3";
         allocator?: "mimalloc" | "libc";
-        sanitize?: "address" | "leak";
+        sanitize?: "address" | "leak" | "thread";
         debugSymbols?: boolean;
         strip?: boolean;
         static?: boolean;

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

@@ -8,7 +8,7 @@ export interface CompilerInfo {
 }
 export declare function getCompilerInfo(compiler: string): CompilerInfo;
 export interface SanitizerOptions {
-    sanitize: "address" | "leak";
+    sanitize: "address" | "leak" | "thread";
     compilerInfo: CompilerInfo;
 }
 export interface SanitizerFlags {

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

@@ -0,0 +1,35 @@
+import type { Environment } from "../../env";
+import { type Expr, type FnCallExpr } from "../../expr";
+import type { FunctionType } from "../../types/definitions";
+import type { EvaluatorContext } from "../context";
+export declare function evaluateRequires(args: {
+    expr: FnCallExpr;
+    env: Environment;
+    context: EvaluatorContext;
+}): FnCallExpr;
+export declare function evaluateEnsures(args: {
+    expr: FnCallExpr;
+    env: Environment;
+    context: EvaluatorContext;
+}): FnCallExpr;
+export declare function evaluateInvariant(args: {
+    expr: FnCallExpr;
+    env: Environment;
+    context: EvaluatorContext;
+}): FnCallExpr;
+export declare function evaluateGhost(args: {
+    expr: FnCallExpr;
+    env: Environment;
+    context: EvaluatorContext;
+}): FnCallExpr;
+export declare function evaluateGhostFn({ expr, env, context, }: {
+    expr: FnCallExpr;
+    env: Environment;
+    context: EvaluatorContext;
+}): FnCallExpr;
+export declare function evaluateOld({ expr, env, context, }: {
+    expr: FnCallExpr;
+    env: Environment;
+    context: EvaluatorContext;
+}): FnCallExpr;
+export declare function wrapFunctionBodyWithContracts(body: Expr, fnType: FunctionType): Expr;

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

@@ -1,4 +1,4 @@
-export type PragmaKind = "AllowUnsafe" | "SkipPrelude" | "SkipWasm" | "SkipWasm32Emscripten" | "SkipWasm32Wasi";
+export type PragmaKind = "AllowUnsafe" | "SkipPrelude" | "SkipWasm" | "SkipWasm32Emscripten" | "SkipWasm32Wasi" | "Verify" | "VerifyOrAssert" | "NoContracts";
 export declare function registerFilePragma(modulePath: string, kind: PragmaKind): void;
 export declare function fileHasPragma(modulePath: string | undefined, kind: PragmaKind): boolean;
 export declare function _clearPragmaRegistry(): void;

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

@@ -34,6 +34,8 @@ export declare function evaluateFunctionParameters({ parameterExprs, env, contex
     forallParameters: FunctionParameter[];
     variadicParameter?: FunctionParameter;
     whereClauseExprs?: Expr[];
+    requiresExprs?: Expr[];
+    ensuresExprs?: Expr[];
     env: Environment;
 };
 export declare function evaluateFunctionType({ expr, env, context, }: {

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

@@ -11,11 +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, }: {
+export declare function validateCaptureTraitRequirements({ wrapperType, captureType, env, errorToken, capturedVariablesWithValues, }: {
     wrapperType: SomeType;
     captureType: StructType;
     env: Environment;
     errorToken: Token;
+    capturedVariablesWithValues?: Map<string, FunctionCapturedVariableInfo>;
 }): void;
 export declare function createCaptureTypeAndValue({ expectedCaptureType, capturedVariablesWithValues, env, closureToken, context, }: {
     expectedCaptureType: StructType | undefined;

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

@@ -1,4 +1,7 @@
 import { type Environment, type Variable } from "../env";
 import { type Expr } from "../expr";
+import type { Type } from "../types/definitions";
+export declare function getRootExprOfFieldAccess(expr: Expr): Expr;
+export declare function getAtomicObjectRootType(rootExpr: Expr, env: Environment): Type | undefined;
 export declare function isValidVariableName(expr: Expr): boolean;
 export declare function findRcValueOwnerRelationship(rhs: Expr, env: Environment, _modulePath: string): Variable | undefined;

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

@@ -3,6 +3,19 @@ import { type Expr, type FnCallExpr } from "../../expr";
 import type { FunctionType, SomeType, TraitField, TraitType, Type } from "../../types/definitions";
 import { type TraitValue, type UnknownValue, type Value } from "../../value";
 import type { EvaluatorContext } from "../context";
+interface NegativeGenericImpl {
+    forallParameters: ForallParameter[];
+    whereConstraints: {
+        someType: SomeType;
+        traitType: TraitType;
+        traitExpr?: Expr;
+    }[];
+    receiverTypePattern: Type;
+    traitType: TraitType;
+    sourceModulePath?: string;
+}
+export declare function hasNegativeImpl(typeId: string, traitTypeId: string): boolean;
+export declare function findMatchingNegativeGenericImpl(concreteType: Type, traitType: TraitType, env: Environment): NegativeGenericImpl | undefined;
 export type ForallParameter = {
     kind: "type";
     name: string;
@@ -90,3 +103,4 @@ export declare function evaluateImplBlock({ expr, env, context, }: {
     env: Environment;
     context: EvaluatorContext;
 }): FnCallExpr;
+export {};

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

@@ -602,6 +602,12 @@ export declare const BuiltinFunctions: {
     __yo_build_doc: string[];
     asm: string[];
     global_asm: string[];
+    requires: string[];
+    ensures: string[];
+    invariant: string[];
+    ghost: string[];
+    ghost_fn: string[];
+    old: string[];
 };
 export declare function exprIsInfixOperatorFunctionCall(expr: Expr): boolean;
 export interface ExprToStringConfig {

package/out/types/src/tests/contracts-comptime-violation.test.d.ts

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

package/out/types/src/tests/contracts-runtime-violation.test.d.ts

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

package/out/types/src/tests/thread-safety-codegen.test.d.ts

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

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

@@ -45,11 +45,13 @@ 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, variadicParameter, whereClauseExprs, return_, env, parametersFrame, SelfType, SelfTraitType, isClosure, isControl, }: {
+export declare function createFunctionType({ parameters, forallParameters, variadicParameter, whereClauseExprs, requiresExprs, ensuresExprs, return_, env, parametersFrame, SelfType, SelfTraitType, isClosure, isControl, }: {
     parameters: FunctionParameter[];
     forallParameters: FunctionForallParameter[];
     variadicParameter: FunctionParameter | undefined;
     whereClauseExprs?: Expr[];
+    requiresExprs?: Expr[];
+    ensuresExprs?: Expr[];
     return_: FunctionReturn;
     env: Environment;
     parametersFrame: Frame;

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

@@ -222,6 +222,8 @@ export interface FunctionType extends Type {
     forallParameters: FunctionForallParameter[];
     variadicParameter?: FunctionParameter;
     whereClauseExprs?: Expr[];
+    requiresExprs?: Expr[];
+    ensuresExprs?: Expr[];
     return: FunctionReturn;
     env: Environment;
     parametersFrame: Frame;