From e4c01a3571b4053c0f8ebb146e6ae8814febfa61 Mon Sep 17 00:00:00 2001 From: Mell0r Date: Fri, 7 Mar 2025 21:08:50 +0300 Subject: [PATCH 01/44] feat: added fuzzer code with some issues --- fuzzer/src/config.ts | 86 +++ fuzzer/src/context.ts | 87 +++ fuzzer/src/formatter.ts | 620 ++++++++++++++++++ fuzzer/src/generators/constant.ts | 133 ++++ fuzzer/src/generators/contract.ts | 130 ++++ fuzzer/src/generators/expression.ts | 931 ++++++++++++++++++++++++++++ fuzzer/src/generators/field.ts | 56 ++ fuzzer/src/generators/function.ts | 241 +++++++ fuzzer/src/generators/generator.ts | 35 ++ fuzzer/src/generators/index.ts | 8 + fuzzer/src/generators/parameter.ts | 41 ++ fuzzer/src/generators/program.ts | 183 ++++++ fuzzer/src/generators/receiver.ts | 122 ++++ fuzzer/src/generators/statement.ts | 622 +++++++++++++++++++ fuzzer/src/generators/struct.ts | 105 ++++ fuzzer/src/generators/trait.ts | 122 ++++ fuzzer/src/id.ts | 8 + fuzzer/src/scope.ts | 357 +++++++++++ fuzzer/src/stdlib.ts | 33 + fuzzer/src/types.ts | 451 ++++++++++++++ fuzzer/src/util.ts | 237 +++++++ fuzzer/test/compilation.spec.ts | 123 ++++ fuzzer/test/expression.spec.ts | 67 ++ fuzzer/test/program.spec.ts | 59 ++ fuzzer/test/testUtils.ts | 65 ++ 25 files changed, 4922 insertions(+) create mode 100644 fuzzer/src/config.ts create mode 100644 fuzzer/src/context.ts create mode 100644 fuzzer/src/formatter.ts create mode 100644 fuzzer/src/generators/constant.ts create mode 100644 fuzzer/src/generators/contract.ts create mode 100644 fuzzer/src/generators/expression.ts create mode 100644 fuzzer/src/generators/field.ts create mode 100644 fuzzer/src/generators/function.ts create mode 100644 fuzzer/src/generators/generator.ts create mode 100644 fuzzer/src/generators/index.ts create mode 100644 fuzzer/src/generators/parameter.ts create mode 100644 fuzzer/src/generators/program.ts create mode 100644 fuzzer/src/generators/receiver.ts create mode 100644 fuzzer/src/generators/statement.ts create mode 100644 fuzzer/src/generators/struct.ts create mode 100644 fuzzer/src/generators/trait.ts create mode 100644 fuzzer/src/id.ts create mode 100644 fuzzer/src/scope.ts create mode 100644 fuzzer/src/stdlib.ts create mode 100644 fuzzer/src/types.ts create mode 100644 fuzzer/src/util.ts create mode 100644 fuzzer/test/compilation.spec.ts create mode 100644 fuzzer/test/expression.spec.ts create mode 100644 fuzzer/test/program.spec.ts create mode 100644 fuzzer/test/testUtils.ts diff --git a/fuzzer/src/config.ts b/fuzzer/src/config.ts new file mode 100644 index 0000000000..c6fca01e46 --- /dev/null +++ b/fuzzer/src/config.ts @@ -0,0 +1,86 @@ +import * as os from "os"; +import { existsSync, mkdirSync } from "fs"; + +/** + * The default number of executions per test. Corresponds to fast-check defaults. + */ +const DEFAULT_NUM_RUNS: number = 100; + +/** + * Configuration handler for fuzz testing settings. + */ +export class FuzzConfig { + /** + * The number of samples to dump during fuzz testing. + * If `samplesNum` is not set, the fuzzer won't dump samples. + */ + public samplesNum: number | undefined; + + /** + * A format used to dump samples. + */ + public samplesFormat: "ast" | "json" = "ast"; + + /** + * Explicitly specified fast-check seed. + */ + public seed: number | undefined; + + /** + * Number of AST generation cycles. POSITIVE_INFINITY means running in the continuous fuzzing mode. + */ + public numRuns: number; + + /** + * Directory to save contracts compiled during the compilation test. + */ + public compileDir: string; + + /** + * Maximum AST generation depth. + */ + public maxDepth: number = 5; + + constructor() { + this.samplesNum = process.env.SAMPLES_NUM + ? parseInt(process.env.SAMPLES_NUM) + : undefined; + if (process.env.SAMPLES_FORMAT) { + this.validateAndSetFormat(process.env.SAMPLES_FORMAT); + } + this.compileDir = process.env.COMPILE_DIR + ? process.env.COMPILE_DIR + : os.tmpdir(); + if (process.env.COMPILE_DIR && !existsSync(process.env.COMPILE_DIR)) { + mkdirSync(process.env.COMPILE_DIR, { recursive: true }); + } + this.seed = process.env.SEED ? parseInt(process.env.SEED) : undefined; + this.numRuns = + process.env.FUZZ === "1" + ? Number.POSITIVE_INFINITY + : process.env.NUM_RUNS + ? parseInt(process.env.NUM_RUNS) + : DEFAULT_NUM_RUNS; + if (this.samplesNum && this.numRuns < this.samplesNum) { + console.warn( + `the requested number of SAMPLES_NUM=${this.samplesNum} is less than NUM_RUNS=${this.numRuns}`, + ); + } + } + + /** + * Validates and sets the sample format based on the provided format string. + * Throws an error if the format is not supported. + * @param fmt The format string to validate and set. + */ + private validateAndSetFormat(fmt: string): void { + const supportedFormats: ("ast" | "json")[] = ["ast", "json"]; + if (supportedFormats.includes(fmt as "ast" | "json")) { + this.samplesFormat = fmt as "ast" | "json"; + } else { + throw new Error( + `unsupported SAMPLES_FMT: ${fmt} (supported options: "ast" and "json")`, + ); + } + } +} diff --git a/fuzzer/src/context.ts b/fuzzer/src/context.ts new file mode 100644 index 0000000000..959ec22d99 --- /dev/null +++ b/fuzzer/src/context.ts @@ -0,0 +1,87 @@ +import JSONbig from "json-bigint"; + +import { formatAst } from "./formatter"; +import { FuzzConfig } from "./config"; +import { AstNode } from "../../src/ast/ast"; + +/** + * FuzzContext represents a stateful context that handles AST generation. + * It keeps the global options used to control and configure the AST generation. + */ +export class FuzzContext { + /** + * Tracks the number of samples that have been printed. + */ + private printedSamplesCount: number = 0; + + /** + * Configuration of the fuzzer. + */ + public config: FuzzConfig; + + /** + * Current depth of AST expression generation, which limits recursive generation. + */ + private currentDepth: number = 0; + + constructor() { + this.config = new FuzzConfig(); + } + + public getDepth(): number { + return this.currentDepth; + } + + public incDepth(): void { + this.currentDepth++; + } + + public decDepth(): void { + this.currentDepth--; + if (this.currentDepth < 0) { + throw new Error("Reached negative recursion depth"); + } + } + + public resetDepth(): void { + this.currentDepth = 0; + } + + /** + * Formats the given AST construction according to the current formatter configuration. + */ + public format(value: AstNode, fmt = this.config.samplesFormat): string { + switch (fmt) { + case "json": + return `${JSONbig.stringify(value, null, 2)}`; + case "ast": + return `${formatAst(value)}`; + default: + throw new Error( + `Unsupported sample format: ${this.config.samplesFormat}`, + ); + } + } + + /** + * Prints the given sample if the number of already printed samples is less than the configured limit. + * @param sample The sample to print. + */ + public printSample(sample: AstNode): void { + if ( + this.config.samplesNum === undefined || + this.printedSamplesCount >= this.config.samplesNum + ) { + return; + } + console.log(`Sample #${this.printedSamplesCount}:\n${this.format(sample)}`); + this.printedSamplesCount++; + } +} + +/** + * A global context accessible and mutable throughout the generation process to + * reflect changes across the AST. + */ +// eslint-disable-next-line prefer-const +export let GlobalContext: FuzzContext = new FuzzContext(); diff --git a/fuzzer/src/formatter.ts b/fuzzer/src/formatter.ts new file mode 100644 index 0000000000..5fcd62adca --- /dev/null +++ b/fuzzer/src/formatter.ts @@ -0,0 +1,620 @@ +import { + AstConstantDecl, + AstConstantDef, + AstImport, + AstNativeFunctionDecl, + AstModule, + AstBouncedMessageType, + AstMapType, + AstReceiver, + AstContractInit, + AstStatementRepeat, + AstStatementUntil, + AstStatementWhile, + AstStatementForEach, + AstStatementTry, + AstStructFieldInitializer, + AstStatementCondition, + AstStatementAugmentedAssign, + AstStatementAssign, + AstStatementExpression, + AstStatementReturn, + AstStatementLet, + AstFunctionDef, + AstFunctionDecl, + AstType, + AstStatement, + AstExpression, + AstFieldDecl, + AstPrimitiveTypeDecl, + AstStructDecl, + AstContract, + AstTrait, + AstMessageDecl, + AstNode, + AstTraitDeclaration, + AstModuleItem, + AstContractDeclaration, +} from "../../src/ast/ast"; + +/** + * PrettyPrinter class provides methods to format and indent Tact code. + */ +class PrettyPrinter { + /** + * @param indentLevel Initial level of indentation. + * @param indentSpaces Number of spaces per indentation level. + */ + constructor( + private indentLevel: number = 0, + private readonly indentSpaces: number = 2, + ) {} + + private increaseIndent() { + this.indentLevel += 1; + } + + private decreaseIndent() { + this.indentLevel -= 1; + } + + private indent(): string { + return " ".repeat(this.indentLevel * this.indentSpaces); + } + + ppAstPrimitive(primitive: AstPrimitiveTypeDecl): string { + return `${this.indent()}primitive ${primitive.name.text};`; + } + + // + // Types + // + + ppAstType(typeRef: AstType): string { + switch (typeRef.kind) { + case "type_id": + return typeRef.text; + case "optional_type": + return `${this.ppAstType(typeRef.typeArg)}?`; + case "map_type": + return this.ppAstTypeRefMap(typeRef); + case "bounced_message_type": + return this.ppAstBouncedMessageType(typeRef); + default: + throw new Error(`Unknown TypeRef kind: ${typeRef}`); + } + } + + ppAstTypeRefMap(typeRef: AstMapType): string { + const keyAlias = typeRef.keyStorageType + ? ` as ${typeRef.keyStorageType}` + : ""; + const valueAlias = typeRef.valueStorageType + ? ` as ${typeRef.valueStorageType}` + : ""; + return `map<${typeRef.keyType}${keyAlias}, ${typeRef.valueType}${valueAlias}>`; + } + + ppAstBouncedMessageType(type: AstBouncedMessageType): string { + return `bounced<${type.messageType.text}>`; + } + + // + // Expressions + // + + /** + * Returns precedence used in unary/binary operations. + * Lower number means higher precedence + */ + getPrecedence(kind: string, op?: string): number { + switch (kind) { + case "op_binary": + switch (op) { + case "||": + return 1; + case "&&": + return 2; + case "|": + return 3; + case "^": + return 4; + case "&": + return 5; + case "==": + case "!=": + return 6; + case "<": + case ">": + case "<=": + case ">=": + return 7; + case "+": + case "-": + return 8; + case "*": + case "/": + case "%": + return 9; + default: + return 11; + } + case "conditional": + case "op_call": + case "op_static_call": + return 0; + case "op_unary": + return 10; + default: + return 11; + } + } + + ppAstExpression(expr: AstExpression, parentPrecedence: number = 0): string { + let result; + let currentPrecedence = this.getPrecedence(expr.kind); + + switch (expr.kind) { + case "op_binary": + currentPrecedence = this.getPrecedence(expr.kind, expr.op); + result = `${this.ppAstExpression(expr.left, currentPrecedence)} ${expr.op} ${this.ppAstExpression(expr.right, currentPrecedence)}`; + break; + case "op_unary": + currentPrecedence = this.getPrecedence(expr.kind, expr.op); + result = `${expr.op}${this.ppAstExpression(expr.operand, currentPrecedence)}`; + break; + case "field_access": + result = `${this.ppAstExpression(expr.aggregate, currentPrecedence)}.${expr.field.text}`; + break; + case "method_call": + result = `${this.ppAstExpression(expr.self, currentPrecedence)}.${expr.method.text}(${expr.args.map((arg) => this.ppAstExpression(arg, currentPrecedence)).join(", ")})`; + break; + case "static_call": + result = `${expr.function.text}(${expr.args.map((arg) => this.ppAstExpression(arg, currentPrecedence)).join(", ")})`; + break; + case "struct_instance": + result = `${expr.type.text}{${expr.args.map((x) => this.ppAstStructFieldInitializer(x)).join(", ")}}`; + break; + case "init_of": + result = `initOf ${expr.contract.text}(${expr.args.map((arg) => this.ppAstExpression(arg, currentPrecedence)).join(", ")})`; + break; + case "conditional": + result = `${this.ppAstExpression(expr.condition, currentPrecedence)} ? ${this.ppAstExpression(expr.thenBranch, currentPrecedence)} : ${this.ppAstExpression(expr.elseBranch, currentPrecedence)}`; + break; + case "number": + result = expr.value.toString(); + break; + case "id": + result = expr.text; + break; + case "boolean": + result = expr.value.toString(); + break; + case "string": + result = `"${expr.value}"`; + break; + case "null": + result = "null"; + break; + default: + throw new Error(`Unsupported expression type: ${expr}`); + } + + // Set parens when needed + if ( + parentPrecedence > 0 && + currentPrecedence > 0 && + currentPrecedence < parentPrecedence + ) { + result = `(${result})`; + } + + return result; + } + + ppAstStructFieldInitializer(param: AstStructFieldInitializer): string { + return `${param.field.text}: ${this.ppAstExpression(param.initializer)}`; + } + + // + // Program + // + + ppAstProgram(program: AstModule): string { + const entriesFormatted = program.items + .map((entry, index, array) => { + const formattedEntry = this.ppProgramItem(entry); + const nextEntry = array[index + 1]; + if ( + entry.kind === "constant_def" && + nextEntry?.kind === "constant_def" + ) { + return formattedEntry; + } + return formattedEntry + "\n"; + }) + .join("\n"); + return entriesFormatted.trim(); + } + + ppProgramItem(item: AstModuleItem): string { + switch (item.kind) { + case "struct_decl": + case "message_decl": + return this.ppAstStruct(item); + case "contract": + return this.ppAstContract(item); + case "primitive_type_decl": + return this.ppAstPrimitive(item); + case "function_def": + return this.ppAstFunction(item); + case "native_function_decl": + return this.ppAstNativeFunction(item); + case "trait": + return this.ppAstTrait(item); + case "constant_def": + return this.ppAstConstant(item); + default: + return `Unknown Program Item Type: ${item}`; + } + } + + ppAstProgramImport(importItem: AstImport): string { + return `${this.indent()}import "${importItem.importPath}";`; + } //TODO: there is no more imports in contract? + + ppAstStruct(struct: AstStructDecl | AstMessageDecl): string { + const typePrefix = struct.kind === "message_decl" ? "message" : "struct"; + const prefixFormatted = + struct.kind === "message_decl" && struct.opcode !== null + ? `(${struct.opcode}) ` + : ""; + this.increaseIndent(); + const fieldsFormatted = struct.fields + .map((field) => this.ppAstField(field)) + .join("\n"); + this.decreaseIndent(); + return `${this.indent()}${typePrefix} ${prefixFormatted}${struct.name.text} {\n${fieldsFormatted}\n}`; + } + + ppAstTrait(trait: AstTrait): string { + const traitsFormatted = trait.traits.map((t) => t.text).join(", "); + const attrsRaw = trait.attributes + .map((attr) => `@${attr.type}("${attr.name.value}")`) + .join(" "); + const attrsFormatted = attrsRaw ? `${attrsRaw} ` : ""; + this.increaseIndent(); + const bodyFormatted = trait.declarations + .map((dec, index, array) => { + const formattedDec = this.ppTraitBody(dec); + const nextDec = array[index + 1]; + if ( + (dec.kind === "constant_def" && nextDec?.kind === "constant_def") || + (dec.kind === "constant_decl" && nextDec?.kind === "constant_decl") || + (dec.kind === "field_decl" && nextDec?.kind === "field_decl") + ) { + return formattedDec; + } + return formattedDec + "\n"; + }) + .join("\n"); + const header = traitsFormatted + ? `trait ${trait.name.text} with ${traitsFormatted}` + : `trait ${trait.name.text}`; + this.decreaseIndent(); + return `${this.indent()}${attrsFormatted}${header} {\n${bodyFormatted}${this.indent()}}`; + } + + ppTraitBody(item: AstTraitDeclaration): string { + switch (item.kind) { + case "field_decl": + return this.ppAstField(item); + case "function_decl": + case "function_def": + return this.ppAstFunction(item); + case "receiver": + return this.ppAstReceive(item); + case "constant_decl": + case "constant_def": + return this.ppAstConstant(item); + default: + return `Unknown Trait Body Type: ${item}`; + } + } + + ppAstField(field: AstFieldDecl): string { + const typeFormatted = this.ppAstType(field.type); + const initializer = field.initializer + ? ` = ${this.ppAstExpression(field.initializer)}` + : ""; + const asAlias = field.as ? ` as ${field.as}` : ""; + return `${this.indent()}${field.name.text}: ${typeFormatted}${asAlias}${initializer};`; + } + + ppAstConstant(constant: AstConstantDecl | AstConstantDef): string { + const valueFormatted = + constant.kind === "constant_def" + ? ` = ${this.ppAstExpression(constant.initializer)}` + : ""; + const attrsRaw = constant.attributes.map((attr) => attr.type).join(" "); + const attrsFormatted = attrsRaw ? `${attrsRaw} ` : ""; + return `${this.indent()}${attrsFormatted}const ${constant.name.text}: ${this.ppAstType(constant.type)}${valueFormatted};`; + } + + ppAstContract(contract: AstContract): string { + const traitsFormatted = contract.traits + .map((trait) => trait.text) + .join(", "); + this.increaseIndent(); + const bodyFormatted = contract.declarations + .map((dec, index, array) => { + const formattedDec = this.ppContractBody(dec); + const nextDec = array[index + 1]; + if ( + (dec.kind === "constant_def" && nextDec?.kind === "constant_def") || + (dec.kind === "field_decl" && nextDec?.kind === "field_decl") + ) { + return formattedDec; + } + return formattedDec + "\n"; + }) + .join("\n"); + this.decreaseIndent(); + const header = traitsFormatted + ? `contract ${contract.name.text} with ${traitsFormatted}` + : `contract ${contract.name.text}`; + const attrsRaw = contract.attributes + .map((attr) => `@interface("${attr.name.value}")`) + .join(" "); + const attrsFormatted = attrsRaw ? `${attrsRaw} ` : ""; + return `${this.indent()}${attrsFormatted}${header} {\n${bodyFormatted}${this.indent()}}`; + } + + ppContractBody(declaration: AstContractDeclaration): string { + switch (declaration.kind) { + case "field_decl": + return this.ppAstField(declaration); + case "function_def": + return this.ppAstFunction(declaration); + case "contract_init": + return this.ppAstInitFunction(declaration); + case "receiver": + return this.ppAstReceive(declaration); + case "constant_def": + return this.ppAstConstant(declaration); + default: + return `Unknown Contract Body Type: ${declaration}`; + } + } + + public ppAstFunction(func: AstFunctionDecl | AstFunctionDef): string { + const argsFormatted = func.params + .map((arg) => `${arg.name.text}: ${this.ppAstType(arg.type)}`) + .join(", "); + const attrsRaw = func.attributes.map((attr) => attr.type).join(" "); + const attrsFormatted = attrsRaw ? `${attrsRaw} ` : ""; + const returnType = func.return ? `: ${this.ppAstType(func.return)}` : ""; + this.increaseIndent(); + const stmtsFormatted = + func.kind === "function_def" + ? func.statements.map((stmt) => this.ppAstStatement(stmt)).join("\n") + : ""; + const body = + func.kind === "function_def" + ? ` {\n${stmtsFormatted}\n${this.indent()}}` + : ";"; + this.decreaseIndent(); + return `${this.indent()}${attrsFormatted}fun ${func.name.text}(${argsFormatted})${returnType}${body}`; + } + + ppAstReceive(receive: AstReceiver): string { + const header = this.ppAstReceiveHeader(receive); + const stmtsFormatted = this.ppStatementBlock(receive.statements); + return `${this.indent()}${header} ${stmtsFormatted}`; + } + + ppAstReceiveHeader(receive: AstReceiver): string { + switch (receive.selector.kind) { + case "internal": + switch (receive.selector.subKind.kind) { + case "simple": + return `receive(${receive.selector.subKind.param.name.text}: ${this.ppAstType(receive.selector.subKind.param.type)})`; + case "fallback": + return `receive()`; + case "comment": + return `receive("${receive.selector.subKind.comment.value}")`; + } + case "bounce": + return `bounced(${receive.selector.param.name.text}: ${this.ppAstType(receive.selector.param.type)})`; + case "external": + switch (receive.selector.subKind.kind) { + case "simple": + return `external(${receive.selector.subKind.param.name.text}: ${this.ppAstType(receive.selector.subKind.param.type)})`; + case "fallback": + return `external()`; + case "comment": + return `external("${receive.selector.subKind.comment.value}")`; + } + } //TODO: refactor: ends build equally, prefix also + } + + ppAstNativeFunction(func: AstNativeFunctionDecl): string { + const argsFormatted = func.params + .map((arg) => `${arg.name.text}: ${this.ppAstType(arg.type)}`) + .join(", "); + const returnType = func.return ? `: ${this.ppAstType(func.return)}` : ""; + let attrs = func.attributes.map((attr) => attr.type).join(" "); + attrs = attrs ? attrs + " " : ""; + return `${this.indent()}@name(${func.nativeName})\n${this.indent()}${attrs}native ${func.name}(${argsFormatted})${returnType};`; + } + + ppAstInitFunction(initFunc: AstContractInit): string { + const argsFormatted = initFunc.params + .map((arg) => `${arg.name.text}: ${this.ppAstType(arg.type)}`) + .join(", "); + + this.increaseIndent(); + const stmtsFormatted = initFunc.statements + ? initFunc.statements.map((stmt) => this.ppAstStatement(stmt)).join("\n") + : ""; + this.decreaseIndent(); + + return `${this.indent()}init(${argsFormatted}) {${stmtsFormatted == "" ? "" : "\n"}${stmtsFormatted}${stmtsFormatted == "" ? "" : "\n" + this.indent()}}`; + } + + // + // Statements + // + + ppAstStatement(stmt: AstStatement): string { + switch (stmt.kind) { + case "statement_let": + return this.ppAstStatementLet(stmt); + case "statement_return": + return this.ppAstStatementReturn(stmt); + case "statement_expression": + return this.ppAstStatementExpression(stmt); + case "statement_assign": + return this.ppAstStatementAssign(stmt); + case "statement_augmentedassign": + return this.ppAstStatementAugmentedAssign(stmt); + case "statement_condition": + return this.ppAstCondition(stmt); + case "statement_while": + return this.ppAstStatementWhile(stmt); + case "statement_until": + return this.ppAstStatementUntil(stmt); + case "statement_repeat": + return this.ppAstStatementRepeat(stmt); + case "statement_foreach": + return this.ppAstStatementForEach(stmt); + case "statement_try": + return this.ppAstStatementTry(stmt); + default: + return `Unsopported statement kind: ${stmt.kind}`; + } + } + + ppStatementBlock(stmts: readonly AstStatement[]): string { + this.increaseIndent(); + const stmntsFormatted = stmts + .map((stmt) => this.ppAstStatement(stmt)) + .join("\n"); + this.decreaseIndent(); + const result = `{\n${stmntsFormatted}\n${this.indent()}}`; + return result; + } + + ppAstStatementLet(statement: AstStatementLet): string { + const expression = this.ppAstExpression(statement.expression); + const tyAnnotation = + statement.type === undefined ? "" : `: ${this.ppAstType(statement.type)}`; + return `${this.indent()}let ${statement.name.text}${tyAnnotation} = ${expression};`; + } + + ppAstStatementReturn(statement: AstStatementReturn): string { + const expression = statement.expression + ? this.ppAstExpression(statement.expression) + : ""; + return `${this.indent()}return ${expression};`; + } + + ppAstStatementExpression(statement: AstStatementExpression): string { + return `${this.indent()}${this.ppAstExpression(statement.expression)};`; + } + + ppAstStatementAssign(statement: AstStatementAssign): string { + return `${this.indent()}${this.ppAstExpression(statement.path)} = ${this.ppAstExpression(statement.expression)};`; + } + + ppAstStatementAugmentedAssign( + statement: AstStatementAugmentedAssign, + ): string { + return `${this.indent()}${this.ppAstExpression(statement.path)} ${statement.op}= ${this.ppAstExpression(statement.expression)};`; + } + + ppAstCondition(statement: AstStatementCondition): string { + const condition = this.ppAstExpression(statement.condition); + const trueBranch = this.ppStatementBlock(statement.trueStatements); + const falseBranch = statement.falseStatements + ? ` else ${this.ppStatementBlock(statement.falseStatements)}` + : ""; + return `${this.indent()}if (${condition}) ${trueBranch}${falseBranch}`; + } + + ppAstStatementWhile(statement: AstStatementWhile): string { + const condition = this.ppAstExpression(statement.condition); + const stmts = this.ppStatementBlock(statement.statements); + return `${this.indent()}while (${condition}) ${stmts}`; + } + + ppAstStatementRepeat(statement: AstStatementRepeat): string { + const condition = this.ppAstExpression(statement.iterations); + const stmts = this.ppStatementBlock(statement.statements); + return `${this.indent()}repeat (${condition}) ${stmts}`; + } + + ppAstStatementUntil(statement: AstStatementUntil): string { + const condition = this.ppAstExpression(statement.condition); + const stmts = this.ppStatementBlock(statement.statements); + return `${this.indent()}do ${stmts} until (${condition});`; + } + + ppAstStatementForEach(statement: AstStatementForEach): string { + const header = `foreach (${statement.keyName}, ${statement.valueName} in ${this.ppAstExpression(statement.map)})`; + const body = this.ppStatementBlock(statement.statements); + return `${this.indent()}${header} ${body}`; + } + + ppAstStatementTry(statement: AstStatementTry): string { + const tryBody = this.ppStatementBlock(statement.statements); + const tryPrefix = `${this.indent()}try ${tryBody}`; + const catchSuffix = statement.catchBlock + ? ` catch (${statement.catchBlock.catchName.text}) ${this.ppStatementBlock(statement.catchBlock.catchStatements)}` + : ""; + return tryPrefix + catchSuffix; + } +} + +/** + * Formats an Ast node into a pretty-printed string representation. + * @param input The Ast node to format. + * @returns A string that represents the formatted Ast node. + */ +// eslint-disable-next-line @typescript-eslint/no-explicit-any +export function formatAst(input: AstNode): string { + const pp = new PrettyPrinter(); + switch (input.kind) { + case "module": + return pp.ppAstProgram(input); + case "op_binary": + case "op_unary": + case "field_access": + case "method_call": + case "static_call": + case "struct_instance": + case "init_of": + case "conditional": + case "number": + case "id": + case "boolean": + case "string": + case "null": + return pp.ppAstExpression(input); + case "struct_decl": + case "message_decl": + return pp.ppAstStruct(input); + case "constant_decl": + case "constant_def": + return pp.ppAstConstant(input); + case "function_decl": + case "function_def": + return pp.ppAstFunction(input); + case "contract": + return pp.ppAstContract(input); + case "trait": + return pp.ppAstTrait(input); + default: + throw new Error(`Unsupported Ast type: ${input.kind}`); + } +} diff --git a/fuzzer/src/generators/constant.ts b/fuzzer/src/generators/constant.ts new file mode 100644 index 0000000000..9ad56cc290 --- /dev/null +++ b/fuzzer/src/generators/constant.ts @@ -0,0 +1,133 @@ +import { + AstConstantDecl, + AstConstantDef, + AstConstantAttribute, + AstExpression, +} from "../../../src/ast/ast"; +import { + generateAstIdFromName, + createSample, + generateAstId, + generateName, +} from "../util"; +import { tyToAstType, Type } from "../types"; +import { Scope } from "../scope"; +import { GenerativeEntity } from "./generator"; + +import fc from "fast-check"; +import { dummySrcInfo } from "../../../src/grammar/"; + +/** + * An object that encapsulates a generated AstConstantDecl. + */ +export class ConstantDecl extends GenerativeEntity { + constructor(scope: Scope, type: Type) { + super(type); + this.name = createSample(generateAstId(scope, "constantDecl")); + } + + private getAttributes( + extraAttrs: AstConstantAttribute[], + ): AstConstantAttribute[] { + const attrs: AstConstantAttribute[] = extraAttrs; + attrs.push({ type: "abstract", loc: dummySrcInfo }); + return attrs; + } + + private generateImpl( + extraAttrs: AstConstantAttribute[], + ): fc.Arbitrary { + return fc.record({ + kind: fc.constant("constant_decl"), + id: fc.constant(this.idx), + name: fc.constant(this.name!), + type: fc.constant(tyToAstType(this.type)), + attributes: fc.constantFrom(this.getAttributes(extraAttrs)), + loc: fc.constant(dummySrcInfo), + }); + } + + /** + * Generates a constant declaration without extra attributes. + */ + public generate(): fc.Arbitrary { + return this.generateImpl([]); + } + + /** + * Create definition for this constant destination. + * @param init An initializer evaluable in compile-time. + */ + public createDefinition(init: fc.Arbitrary): ConstantDef { + return new ConstantDef(this.name?.text!, this.type, init); + } +} + +/** + * An object that encapsulates a generated AstConstantDef. + * @parentScope Scope this constant belongs to. + */ +export class ConstantDef extends GenerativeEntity { + /** + * Create new constant definition from its name and type. Used to create definition from an existing declaration. + * @param init An initializer evaluable in compile-time. + */ + constructor( + name: string, + type: Type, + private init: fc.Arbitrary, + ) { + super(type); + this.name = generateAstIdFromName(name); + } +/** + * Create a new constant definition generation name from scope. + * @param scope Scope to generate constant name from. + * @param type Constant type. + * @param init An initializer evaluable in compile-time. + */ + public static fromScope( + scope: Scope, + type: Type, + init: fc.Arbitrary, + ): ConstantDef { + return new ConstantDef( + createSample(generateName(scope, "constantDef")), + type, + init, + ); + } + + private generateImpl( + extraAttrs: AstConstantAttribute[], + init?: fc.Arbitrary, + ): fc.Arbitrary { + const choosenInit = init !== undefined ? init : this.init; + return fc.record({ + kind: fc.constant("constant_def"), + id: fc.constant(this.idx), + name: fc.constant(this.name!), + type: fc.constant(tyToAstType(this.type)), + initializer: choosenInit, + attributes: fc.constantFrom(extraAttrs), + loc: fc.constant(dummySrcInfo), + }); + } + + /** + * Generates a constant definition without extra attributes. + */ + public generate(): fc.Arbitrary { + return this.generateImpl([]); + } + + /** + * Generates a constant definition with extra attributes and overriden init. + */ + public generateWithAttrs( + extraAttrs: AstConstantAttribute[] = [], + init?: fc.Arbitrary, + ): fc.Arbitrary { + return this.generateImpl(extraAttrs, init); + } +} diff --git a/fuzzer/src/generators/contract.ts b/fuzzer/src/generators/contract.ts new file mode 100644 index 0000000000..90cdc353eb --- /dev/null +++ b/fuzzer/src/generators/contract.ts @@ -0,0 +1,130 @@ +import { + AstContract, + AstConstantDef, + AstFunctionDef, + AstFieldDecl, +} from "../../../src/ast/ast"; +import { createSample, generateAstId } from "../util"; +import { FunctionDef } from "./function"; +import { Trait } from "./trait"; +import { Expression } from "./expression"; +import { Receive } from "./receiver"; +import { FunctionType, UtilType } from "../types"; +import { Scope } from "../scope"; +import { GenerativeEntity } from "./generator"; + +import fc from "fast-check"; +import { Field } from "./field"; +import { dummySrcInfo } from "../../../src/grammar/"; + +export interface ContractParameters { + /** + * Number of receive method generated within a contract. + * @default 1 + */ + receiveNum: number; +} + +/** + * An object that encapsulates a randomly generated AstContract including extra information + * about its entries and their scopes. + */ +export class Contract extends GenerativeEntity { + /** Scope used within the generated contract. */ + private scope: Scope; + + private receiveNum: number; + + /** + * @param methodSignatures Signatures of methods to be generated in the contract. + * @param trait An optional trait that the generated contract must implement. + */ + constructor( + parentScope: Scope, + private methodSignatures: FunctionType[], + private trait?: Trait, + params: Partial = {}, + ) { + super({ kind: "util", type: UtilType.Contract }); + this.scope = new Scope("contract", parentScope); + this.name = createSample(generateAstId(this.scope, "contract")); + + const { receiveNum = 1 } = params; + this.receiveNum = receiveNum; + } + + public generate(): fc.Arbitrary { + // Implemented declarations from the trait + let traitFields: fc.Arbitrary[] = []; + let traitConstants: fc.Arbitrary[] = []; + let traitMethods: fc.Arbitrary[] = []; + if (this.trait !== undefined) { + traitFields = this.trait.fieldDeclarations.map(({ type, name }) => { + const init = new Expression(this.scope, type, { + compileTimeEval: true, + }).generate(); + return new Field(this.scope, type, init, name).generate(); + }); + traitConstants = this.trait.constantDeclarations + .map((decl) => { + const init = new Expression(this.scope, decl.type, { + compileTimeEval: true, + }).generate(); + return decl + .createDefinition(init) + .generateWithAttrs([{ type: "override", loc: dummySrcInfo }]); + }) + .concat( + this.trait.constantDefinitions.map((def) => + def.generateWithAttrs([{ type: "override", loc: dummySrcInfo }]), + ), + ); + traitMethods = this.trait.methodDeclarations.map((m) => { + return m.generateDefinition("method", [ + { kind: "function_attribute", type: "override", loc: dummySrcInfo }, + { + kind: "function_attribute", + type: "get", + loc: dummySrcInfo, + methodId: undefined, + }, + ]); + }); + } + + const requestedMethods = this.methodSignatures.map((signature) => + new FunctionDef(this.scope, "method", signature).generate(), + ); + const generatedMethods = Array.from(this.scope.getAll("methodDef")).map( + (m) => m.generate(), + ); + const requestedReceives = Array.from({ length: this.receiveNum }).map((_) => + new Receive(this.scope).generate(), + ); + const generatedConstants = Array.from(this.scope.getAll("constantDef")).map( + (c) => c.generate(), + ); + const generatedFields = Array.from(this.scope.getAll("field")).map((f) => + f.generate(), + ); + return fc.record({ + kind: fc.constant("contract"), + id: fc.constant(this.idx), + name: fc.constant(this.name!), + traits: fc.constant(this.trait === undefined ? [] : [this.trait.name!]), + attributes: fc.constantFrom([]), + declarations: fc.tuple( + ...traitConstants, + ...generatedConstants, + ...traitFields, + ...generatedFields, + ...requestedReceives, + ...traitMethods, + ...generatedMethods, + ...requestedMethods, + ), + loc: fc.constant(dummySrcInfo), + params: fc.constant(undefined), + }); + } +} diff --git a/fuzzer/src/generators/expression.ts b/fuzzer/src/generators/expression.ts new file mode 100644 index 0000000000..ffc46aca5f --- /dev/null +++ b/fuzzer/src/generators/expression.ts @@ -0,0 +1,931 @@ +import { + AstBoolean, + AstExpression, + AstId, + AstNull, + AstNumber, + AstOpBinary, + AstFieldAccess, + AstMethodCall, + AstStaticCall, + AstOpUnary, + AstSimplifiedString, + AstStructFieldInitializer, + AstStructInstance, + AstNumberBase, +} from "../../../src/ast/ast"; +import JSONbig from "json-bigint"; +import fc from "fast-check"; + +import { ConstantDecl, ConstantDef } from "./constant"; +import { Let, Statement } from "./statement"; +import { Field } from "./field"; +import { + randomBool, + randomElement, + packArbitraries, + generateAstIdFromName, +} from "../util"; +import { GenerativeEntity, GenerativeEntityOpt } from "./generator"; +import { nextId } from "../id"; +import { + StdlibType, + tyToString, + tyEq, + UtilType, + Type, + throwTyError, + makeFunctionTy, + StructField, +} from "../types"; +import { GlobalContext } from "../context"; +import { Scope } from "../scope"; +import { dummySrcInfo } from "../../../src/grammar/"; +import { FunctionDef } from "./function"; + +export function generateNumber( //TODO: add random base generation or pass the needed one, where number is generated + base?: AstNumberBase, + constValue?: bigint, +): fc.Arbitrary { + const value = + constValue === undefined ? fc.bigInt() : fc.constantFrom(constValue); + return fc.record({ + kind: fc.constant("number"), + id: fc.constant(nextId()), + value, + loc: fc.constant(dummySrcInfo), + base: fc.constant(base ?? 10), + }); +} + +export function generateBoolean( + constValue?: boolean, +): fc.Arbitrary { + const value = + constValue === undefined ? fc.boolean() : fc.constantFrom(constValue); + return fc.record({ + kind: fc.constant("boolean"), + id: fc.constant(nextId()), + value, + loc: fc.constant(dummySrcInfo), + }); +} + +export function generateString( + nonEmpty: boolean = false, + constValue?: string, +): fc.Arbitrary { + const value = + constValue === undefined + ? nonEmpty + ? fc.string({ minLength: 1 }) + : fc.string() + : fc.constantFrom(constValue); + return fc.record({ + kind: fc.constant("simplified_string"), + id: fc.constant(nextId()), + value, + loc: fc.constant(dummySrcInfo), + }); +} + +export function generateNull(): fc.Arbitrary { + return fc.record({ + kind: fc.constant("null"), + id: fc.constant(nextId()), + loc: fc.constant(dummySrcInfo), + }); +} + +export function generateFieldAccess( + name: string, + aggregate?: AstExpression, +): AstFieldAccess { + return { + kind: "field_access", + aggregate: aggregate ?? generateThisID(), + field: generateAstIdFromName(name), + id: nextId(), + loc: dummySrcInfo, + }; +} + +export function generateThisID(): AstId { + return { kind: "id", id: nextId(), text: "self", loc: dummySrcInfo }; +} + +/** + * Generates an value that could be assigned to any variable with the `Map` type. + */ +export function generateMapInit( + ty: Type, + scope: Scope, +): fc.Arbitrary { + if (scope.definedIn("block", "method", "function") && randomBool()) { + return new StaticCall(ty, "emptyMap", []).generate(); + } else { + return generateNull(); + } +} + +/** + * Generates an value that could be assigned to a struct instance. + */ +export function generateStructInit( + ty: Type, + scope: Scope, +): fc.Arbitrary { + if (ty.kind !== "struct" && ty.kind !== "message") { + throwTyError(ty); + } + const args: fc.Arbitrary[] = ty.fields.map( + (field: StructField) => { + return fc.record({ + kind: fc.constant("struct_field_initializer"), + id: fc.constant(nextId()), + field: fc.constant(generateAstIdFromName(field.name)), + initializer: new Expression(scope, field.type).generate(), + loc: fc.constant(dummySrcInfo), + }); + }, + ); + return fc.record({ + kind: fc.constantFrom("struct_instance"), + id: fc.constantFrom(nextId()), + type: fc.constantFrom(generateAstIdFromName(tyToString(ty))), + args: packArbitraries(args), + loc: fc.constant(dummySrcInfo), + }); +} + +/** + * Generates expressions used in actual function call arguments. + * @param funTy Signature of the function. + * @param funScope Scope of the function. + */ +export function generateFunctionCallArgs( + funTy: Type, + funScope: Scope, +): fc.Arbitrary[] { + if (funTy.kind !== "function") { + throw new Error(`Incorrect type for function: ${JSONbig.stringify(funTy)}`); + } + if (funTy.signature.length === 1) { + return []; + } + return funTy.signature + .slice(0, -1) + .map((argTy) => new Expression(funScope, argTy).generate()); +} + +/** + * Generates expressions used in actual method call arguments. + * @param methodTy Signature of the method. + * @param methodScope Scope of the method. + */ +export function generateMethodCallArgs( + methodTy: Type, + methodScope: Scope, +): fc.Arbitrary[] { + if (methodTy.kind !== "function") { + throw new Error( + `Incorrect type for method: ${JSONbig.stringify(methodTy)}`, + ); + } + if (methodTy.signature.length === 2) { + return []; + } + return methodTy.signature + .slice(1, -1) + .map((argTy) => new Expression(methodScope, argTy).generate()); +} + +/** + * Generates field and contract constants access operations. + */ +export class FieldAccess extends GenerativeEntity { + constructor( + type: Type, + fieldName: string, + private src?: AstId, + ) { + super(type, generateAstIdFromName(fieldName)); + } + + generate(): fc.Arbitrary { + return fc.record({ + kind: fc.constant("field_access"), + aggregate: fc.constant(this.src ? this.src : generateThisID()), + field: fc.constant(this.name!), + id: fc.constant(this.idx), + loc: fc.constant(dummySrcInfo), + }); + } +} + +/** + * Generates method calls. + */ +export class MethodCall extends GenerativeEntity { + constructor( + type: Type, + name: string, + private src: AstExpression, + private args?: fc.Arbitrary[], + ) { + super(type, generateAstIdFromName(name)); + } + generate(): fc.Arbitrary { + return fc.record({ + kind: fc.constant("method_call"), + self: fc.constant(this.src), + method: fc.constant(this.name!), + args: packArbitraries(this.args), + id: fc.constant(this.idx), + loc: fc.constant(dummySrcInfo), + }); + } +} + +/** + * Generates free function calls. + */ +export class StaticCall extends GenerativeEntity { + constructor( + type: Type, + name: string, + private args?: fc.Arbitrary[], + ) { + super(type, generateAstIdFromName(name)); + } + generate(): fc.Arbitrary { + return fc.record({ + kind: fc.constant("static_call"), + function: fc.constantFrom(this.name!), + args: packArbitraries(this.args), + id: fc.constant(this.idx), + loc: fc.constant(dummySrcInfo), + }); + } +} + +export namespace OpUnary { + function generate( + args: fc.Arbitrary[], + allowedOps: readonly AstOpUnary["op"][], + ): fc.Arbitrary { + return fc.letrec((tie) => ({ + astExpression: fc.oneof( + { maxDepth: 1 }, + ...args.map((gen) => ({ arbitrary: gen, weight: 1 })), + { + arbitrary: tie("astOpUnary"), + weight: 1, + }, + ), + astOpUnary: fc.record({ + kind: fc.constant("op_unary"), + id: fc.constant(nextId()), + op: fc.constantFrom(...allowedOps), + loc: fc.constant(dummySrcInfo), + operand: tie("astExpression") as fc.Arbitrary, + }), + })).astOpUnary; + } + + // Generates numeric expressions + // num -> num + export const Num = generate([generateNumber()], ["+", "-"]); + + // Generates boolean expressions + // bool -> bool + export const Bool = generate([generateBoolean()], ["!"]); + + // TODO: Handle optionals (`!!`) +} + +export namespace OpBinary { + export function generate( + args: fc.Arbitrary[], + allowedOps: readonly AstOpBinary["op"][], + ): fc.Arbitrary { + return fc.letrec((tie) => ({ + astExpression: fc.oneof( + { maxDepth: 1 }, + ...args.map((gen) => ({ arbitrary: gen, weight: 1 })), + { + arbitrary: tie("astOpBinary"), + weight: 1, + }, + ), + astOpBinary: fc.record({ + kind: fc.constant("op_binary"), + id: fc.constant(nextId()), + op: fc.constantFrom(...allowedOps), + left: tie("astExpression") as fc.Arbitrary, + right: tie("astExpression") as fc.Arbitrary, + loc: fc.constant(dummySrcInfo), + }), + })).astOpBinary; + } + + // num -> num -> num + export const NumOps: AstOpBinary["op"][] = [ + "+", + "-", + "*", + "/", + "%", + "<<", + ">>", + "&", + "|", + ]; + export const NumGens = [generateNumber(), OpUnary.Num]; + + // bool -> bool -> bool + export const BoolOps: AstOpBinary["op"][] = ["&&", "||"]; + export const BoolGens = [ + generateBoolean(), + OpUnary.Bool, + // bool -> bool -> bool + generate([generateBoolean()], BoolOps), + // num -> num -> bool + // mkAstOpBinaryGen([ Primitive.NumberGen ], + // ["==", "!=", "&&", "||"]), + ]; +} + +/** + * Generates struct field access expressions, e.g., `myStruct.a`. + * This class wraps up the logic that finds an appropriate struct and field that match + * the desired type and creates an access expression. + */ +export class StructAccess extends GenerativeEntityOpt< + AstExpression | undefined +> { + constructor( + private parentScope: Scope, + private resultTy: Type, + ) { + super(resultTy); + } + + generate(): fc.Arbitrary | undefined { + const structEntries = this.findStructsWithMatchingFields(); + if (structEntries.size === 0) { + return undefined; // No suitable struct found + } + let structVarNames = this.findVariablesOfStructTypes(structEntries); + if (structVarNames.size === 0) { + structVarNames = this.createStructInstance(structEntries); + } + return this.createFieldAccessExpression(structEntries, structVarNames); + } + + /** + * Collects structs that have fields returning the desired `resultTy`. + */ + private findStructsWithMatchingFields(): Map { + return this.parentScope + .getItemsRecursive("struct") + .reduce((acc, struct) => { + if (struct.type.kind !== "struct") { + throwTyError(struct.type); + } + const matchingFieldNames = struct.type.fields.reduce((acc, field) => { + if (tyEq(field.type, this.resultTy)) { + acc.push(field.name); + } + return acc; + }, [] as string[]); + if (matchingFieldNames.length > 0) { + acc.set(struct.name?.text!, [struct.type, matchingFieldNames]); + } + return acc; + }, new Map()); + } + + /** + * Finds local variables that have a type defined by `structEntries`. + */ + private findVariablesOfStructTypes( + structEntries: Map, + ): Map { + return Array.from(structEntries.keys()).reduce((acc, structName) => { + const structType = structEntries.get(structName)![0]; + const variableNames = this.parentScope.getNamesRecursive( + "let", + structType, + ); + if (variableNames.length > 0) { + acc.set(structName, [structType, variableNames]); + } + return acc; + }, new Map()); + } + + /** + * Defines a local variable with a struct type that has matching fields. + * @returns Updated variables map. + */ + private createStructInstance( + structEntries: Map, + ): Map { + const chosenStructName = randomElement(Array.from(structEntries.keys())); + const structType = structEntries.get(chosenStructName)![0]; + const initExpr = new Expression(this.parentScope, structType).generate(); + const varStmt = new Let(this.parentScope, structType, initExpr); + this.parentScope.add("let", varStmt); + return new Map([[chosenStructName, [structType, [varStmt.name?.text!]]]]); + } + + /** + * Creates a field access expression for one of the available variables of the struct types. + */ + private createFieldAccessExpression( + structEntries: Map, + structVarNames: Map, + ): fc.Arbitrary | undefined { + const chosenStructName = randomElement(Array.from(structVarNames.keys())); + const [_, varNames] = structVarNames.get(chosenStructName)!; + const varName = randomElement(varNames); + const fieldName = randomElement(structEntries.get(chosenStructName)![1]); + return new FieldAccess( + this.resultTy, + fieldName, + generateAstIdFromName(varName), + ).generate(); + } +} + +export interface ExpressionParameters { + /** + * Determines whether functions should be generated in this run. + * @default true + */ + generateFunctions: boolean; + + /** + * Determines whether contract methods should be generated in this run. + * @default true + */ + generateMethods: boolean; + + /** + * Determines whether constants should be generated in this run. + * @default true + */ + generateConstants: boolean; + + /** + * Determines whether contract fields should be generated in this run. + * @default true + */ + generateFields: boolean; + + /** + * Determines whether statements should be generated in this run. + * @default true + */ + generateStatements: boolean; + + /** + * Indicates whether the generated expression must be evaluable at compile time. + * @default false + */ + compileTimeEval: boolean; + + /** + * Number of the generated linear-flow statements in the block. + * @default 2 + */ + generatedStatementsNum: number; +} + +export const NonGenerativeExpressionParams: Partial = { + generateFunctions: false, + generateMethods: false, + generateConstants: false, + generateFields: false, + generateStatements: false, +}; + +/** + * Contains the logic to generate expressions based on their types. + * AST generation proceeds from the bottom up, meaning the expression generator + * may recursively create additional constructs, such as functions and constants, + * in outer scopes. + */ +export class Expression extends GenerativeEntity { + private generateFunctions: boolean; + private generateMethods: boolean; + private generateConstants: boolean; + private generateFields: boolean; + private generateStatements: boolean; + private compileTimeEval: boolean; + private generatedStatementsNum: number; + + /** + * @param parentScope Scope the generated expression belongs to. + * @param type Type of the generated expression. + * @param params Optional parameters for expression generation. + */ + constructor( + private parentScope: Scope, + type: Type, + params: Partial = {}, + ) { + super(type); + + const { + generateFunctions = true, + generateMethods = true, + generateConstants = true, + generateFields = true, + generateStatements = true, + compileTimeEval = false, + generatedStatementsNum = 2, + } = params; + this.generateFunctions = generateFunctions; + this.generateMethods = generateMethods; + this.generateConstants = generateConstants; + this.generateFields = generateFields; + this.generateStatements = generateStatements; + this.compileTimeEval = compileTimeEval; + this.generatedStatementsNum = generatedStatementsNum; + + // Forcefully change the parameters based on the current context state to avoid endless recursion. + if (GlobalContext.getDepth() >= GlobalContext.config.maxDepth) { + this.generateFunctions = false; + this.generateMethods = false; + this.generateConstants = false; + this.generateFields = false; + this.generateStatements = false; + } + GlobalContext.incDepth(); + } + + /** + * Generates or chooses an available constant and makes a "use" expression from it. + * @return Use of the generated constant, or `undefined` if that type is unsupported. + */ + private makeConstantUse(ty: Type): fc.Arbitrary | undefined { + if (this.compileTimeEval || !this.generateConstants) { + return undefined; + } + // Don't generate constants that cannot be initialized in compile time: https://github.com/tact-lang/tact/issues/284 + if (ty.kind === "map" || ty.kind === "struct" || ty.kind === "message") { + return undefined; + } + + // Collect suitable constants names + let constantNames = this.parentScope + .getNamesRecursive("constantDef", ty) + .concat(this.parentScope.getNamesRecursive("constantDecl", ty)); + // Trait constants cannot be used within trait method definitions + const traitScope = this.parentScope.findParent("trait"); + if (traitScope !== undefined) { + const traitConstantNames = new Set( + traitScope + .getNames("constantDef", ty) + .concat(traitScope.getNames("constantDecl", ty)), + ); + constantNames = constantNames.filter( + (name) => !traitConstantNames.has(name), + ); + // Don't generate new constants inside traits, since they cannot be used + if (constantNames.length === 0) { + return undefined; + } + } + + let scope = this.parentScope; // scope to add/use a constant + if (constantNames.length === 0) { + scope = + this.parentScope.definedIn("program") || randomBool() + ? this.parentScope + : this.parentScope.parentScope!; + // NOTE: Mandatory for contracts; see: tact#332. + const init = + scope.definedIn("contract", "method") || randomBool() + ? new Expression(this.parentScope, ty, { + compileTimeEval: true, + }).generate() + : undefined; + if (init) { + const constant = ConstantDef.fromScope(scope, ty, init); + this.parentScope.add("constantDef", constant); + constantNames.push(constant.name?.text!); + } else { + const constant = new ConstantDecl(scope, ty); + this.parentScope.add("constantDecl", constant); + constantNames.push(constant.name?.text!); + } + } + const arbs = scope.definedIn("contract", "method") + ? constantNames.map((name) => new FieldAccess(ty, name).generate()) + : constantNames.map((name) => fc.constant(generateAstIdFromName(name))); + return arbs.length > 0 ? fc.oneof(...arbs) : undefined; + } + + /** + * Generates or chooses an available field and makes a "use" expression from it. + * @return Use expression of the generated field, or `undefined` if cannot create it.expre + */ + private makeFieldUse(ty: Type): fc.Arbitrary | undefined { + if ( + this.compileTimeEval || + !this.generateFields || + !this.parentScope.definedIn("method") || + this.parentScope.hasParent("trait") + ) { + return undefined; + } + + // Struct fields cannot be initialized in compile time: https://github.com/tact-lang/tact/issues/284 + // TODO: Therefore they must be initialized in the init function. + if (ty.kind === "struct" || ty.kind === "message") { + return undefined; + } + + const fieldNames = this.parentScope.getNamesRecursive("field", ty); + if (fieldNames.length === 0) { + // NOTE: This init is mandatory since we don't generate init functions yet. + // Maps cannot be initialized in compile-time. + const init = + ty.kind === "map" + ? undefined + : new Expression(this.parentScope, ty, { + compileTimeEval: true, + }).generate(); + const field = new Field(this.parentScope, ty, init); + if (field === undefined) { + return undefined; + } + this.parentScope.add("field", field); + fieldNames.push(field.name?.text!); + } + const arbs = fieldNames.map((name) => new FieldAccess(ty, name).generate()); + return arbs.length > 0 ? fc.oneof(...arbs) : undefined; + } + + /** + * Generates or chooses an available local variables and makes a "use" expression from it. + * The process of generating local variables involves creating new statements in the function/method body. + * @return Use expression of the generated local variable, or `undefined` if cannot create it. + */ + private makeLocalVarUse(ty: Type): fc.Arbitrary | undefined { + if ( + this.compileTimeEval || + !this.generateStatements || + !this.parentScope.definedIn("method", "function") + ) { + return undefined; + } + const varNames = this.parentScope.getNamesRecursive("let", ty); + if (varNames.length === 0) { + const init = new Expression(this.parentScope, ty).generate(); + const varStmt = new Let(this.parentScope, ty, init); + if (varStmt === undefined) { + return undefined; + } + this.parentScope.add("let", varStmt); + varNames.push(varStmt.name?.text!); + } + const arbs = varNames.map((name) => + fc.constant(generateAstIdFromName(name)), + ); + return arbs.length > 0 ? fc.oneof(...arbs) : undefined; + } + + /** + * Generates or chooses an available local variables of a struct type and makes an expression that accesses a struct field. + * The process of generating local variables involves creating new statements in the function/method body. + * @return Use expression of the generated local variable, or `undefined` if cannot create it. + */ + private makeStructFieldAccess( + ty: Type, + ): fc.Arbitrary | undefined { + if ( + this.compileTimeEval || + !this.generateStatements || + !this.parentScope.definedIn("method", "function") + ) { + return undefined; + } + return new StructAccess(this.parentScope, ty).generate(); + } + + /** + * Generates statements in the block that uses local and global variables. + */ + private generateStatementsInBlock(): void { + if ( + !this.generateStatements || + this.parentScope.definedIn("program", "contract") + ) { + return; + } + Array.from({ length: this.generatedStatementsNum }).forEach(() => { + const stmt = new Statement(this.parentScope); + this.parentScope.add("statement", stmt); + }); + } + + /** + * Generates or chooses an available free function and makes a call expression from it. + * @return Use expression of the generated call, or `undefined` if it is not possible to create it. + */ + private makeFunCall(returnTy: Type): fc.Arbitrary | undefined { + if (this.compileTimeEval || !this.generateFunctions) { + return undefined; + } + const funNames = this.parentScope + .findFunction("functionDef", returnTy) + .concat(this.parentScope.findFunction("methodDef", returnTy)); + if (funNames.length === 0) { + const programScope = this.parentScope.getProgramScope(); + const funTy = makeFunctionTy("function", returnTy); + const fun = new FunctionDef(programScope, "function", funTy); + this.parentScope.add("functionDef", fun); + funNames.push([fun.name?.text!, funTy]); + } + const arbs = funNames.map(([name, funTy]) => + new StaticCall( + returnTy, + name, + generateFunctionCallArgs(funTy, this.parentScope), + ).generate(), + ); + return arbs.length > 0 ? fc.oneof(...arbs) : undefined; + } + + /** + * Generates or chooses an available method and makes a call expression from it. + * @return Use expression of the generated call, or `undefined` if it is not possible to create it. + */ + private makeMethodCall( + returnTy: Type, + ): fc.Arbitrary | undefined { + if ( + this.compileTimeEval || + !this.generateMethods || + this.parentScope.definedIn("program", "function") || + this.parentScope.hasParent("trait") + ) { + return undefined; + } + + // Collect the available standard library methods + const stdlibArbs = [ + // self.map_field.get(key) + ...this.parentScope + .getEntriesRecursive("field") + .reduce((acc, [mapName, mapTy]) => { + if (mapTy.kind === "map" && tyEq(mapTy.type.value, returnTy)) { + const opCall = new MethodCall( + returnTy, + "get", + { kind: "id", id: nextId(), text: mapName, loc: dummySrcInfo }, + [ + fc.constantFrom(generateThisID()), + new Expression(this.parentScope, mapTy.type.key).generate(), + ], + ).generate(); + acc.push(opCall); + } + return acc; + }, [] as fc.Arbitrary[]), + // map_var.get(key) + ...this.parentScope + .getEntriesRecursive("let") + .reduce((acc, [mapName, mapTy]) => { + if (mapTy.kind === "map" && tyEq(mapTy.type.value, returnTy)) { + const opCall = new MethodCall( + returnTy, + "get", + { kind: "id", id: nextId(), text: mapName, loc: dummySrcInfo }, + [new Expression(this.parentScope, mapTy.type.key).generate()], + ).generate(); + acc.push(opCall); + } + return acc; + }, [] as fc.Arbitrary[]), + ]; + + // Generate or collect the available user-defined methods + const userMethods: [string, Type][] = this.parentScope.findFunction( + "methodDef", + returnTy, + ); + if (userMethods.length === 0) { + const contractScope = this.parentScope.getContractScope(); + if (contractScope === undefined) { + return undefined; + } + const methodTy = makeFunctionTy("method", returnTy); + const method = new FunctionDef(contractScope, "method", methodTy); + this.parentScope.add("methodDef", method); + userMethods.push([method.name?.text!, methodTy]); + } + const userArbs = userMethods.map(([name, methodTy]) => + new MethodCall( + returnTy, + name, + generateThisID(), + generateMethodCallArgs(methodTy, this.parentScope), + ).generate(), + ); + return userArbs.length > 0 && stdlibArbs.length > 0 + ? fc.oneof(...userArbs, ...stdlibArbs) + : undefined; + } + + /** Generates `require` function call. */ + private generateRequireCall(): fc.Arbitrary { + const condition = new Expression(this.parentScope, { + kind: "stdlib", + type: StdlibType.Bool, + }).generate(); + const error = new Expression(this.parentScope, { + kind: "stdlib", + type: StdlibType.String, + }).generate(); + return new StaticCall({ kind: "util", type: UtilType.Unit }, "require", [ + condition, + error, + ]).generate(); + } + + /** + * Generates expressions that returns the given standard type when evaluated. + */ + private generateExpressions(ty: Type): fc.Arbitrary { + const funCall = this.makeFunCall(ty); + const methodCall = this.makeMethodCall(ty); + const constant = this.makeConstantUse(ty); + const field = this.makeFieldUse(ty); + const localVarUse = this.makeLocalVarUse(ty); + const structVarAccess = this.makeStructFieldAccess(ty); + + // Add statements to bodies of functions/methods + this.generateStatementsInBlock(); + + const baseGenerator = (() => { + if (ty.kind === "stdlib") { + switch (ty.type) { + case StdlibType.Int: + return [generateNumber()]; + case StdlibType.Bool: + return [generateBoolean()]; + case StdlibType.String: + return [generateString()]; + default: + throwTyError(ty); + } + } else if (ty.kind === "map") { + return [generateMapInit(this.type, this.parentScope)]; + } else if (ty.kind === "struct") { + return [generateStructInit(this.type, this.parentScope)]; + } else if (ty.kind === "util" && ty.type === UtilType.Unit) { + return [this.generateRequireCall()]; + } else { + throwTyError(ty); + } + })(); + + return fc.oneof( + ...baseGenerator, + ...(funCall ? [funCall] : []), + ...(methodCall ? [methodCall] : []), + ...(constant ? [constant] : []), + ...(field ? [field] : []), + ...(localVarUse ? [localVarUse] : []), + ...(structVarAccess ? [structVarAccess] : []), + ); + } + + /** + * Generates an AST expression from the specified type. + * During expression generation, the generator creates new AST entries in the outer scopes, + * including functions and constants saving them to the given context. + */ + generate(): fc.Arbitrary { + let expr: fc.Arbitrary; + switch (this.type.kind) { + case "stdlib": + case "map": + case "struct": + case "message": + case "util": + expr = this.generateExpressions(this.type); + break; + case "function": + throw new Error( + `Cannot generate an expression from type: ${JSONbig.stringify(this.type)}`, + ); + } + return expr; + } +} diff --git a/fuzzer/src/generators/field.ts b/fuzzer/src/generators/field.ts new file mode 100644 index 0000000000..84de16e261 --- /dev/null +++ b/fuzzer/src/generators/field.ts @@ -0,0 +1,56 @@ +import { + AstFieldDecl, + AstExpression, + AstId, +} from "../../../src/ast/ast"; +import { createSample, generateAstId } from "../util"; +import { tyToAstType, Type } from "../types"; +import { Scope } from "../scope"; +import { GenerativeEntity } from "./generator"; + +import fc from "fast-check"; +import { dummySrcInfo } from "../../../src/grammar/"; + +/** + * An object that encapsulates a generated AstFieldDecl. + */ +export class Field extends GenerativeEntity { + /** + * @param init An optional initializer evaluable in compile-time. + * @param parentScope Scope this field belongs to. Could be a contract or program for struct fields. + */ + constructor( + parentScope: Scope, + type: Type, + private init?: fc.Arbitrary, + name?: AstId, + ) { + if ( + !parentScope.definedIn( + "contract", + "method", + "program" /* struct field */, + "trait", + ) + ) { + throw new Error(`Cannot define a field in a ${parentScope.kind} scope`); + } + super(type); + this.name = + name === undefined + ? createSample(generateAstId(parentScope, "field")) + : name; + } + + generate(): fc.Arbitrary { + return fc.record({ + kind: fc.constant("field_decl"), + id: fc.constant(this.idx), + name: fc.constant(this.name!), + type: fc.constant(tyToAstType(this.type)), + initializer: this.init === undefined ? fc.constant(undefined) : this.init, + as: fc.constantFrom(undefined), + loc: fc.constant(dummySrcInfo), + }); + } +} diff --git a/fuzzer/src/generators/function.ts b/fuzzer/src/generators/function.ts new file mode 100644 index 0000000000..77ca373d34 --- /dev/null +++ b/fuzzer/src/generators/function.ts @@ -0,0 +1,241 @@ +import { + AstFunctionDef, + AstTypedParameter, + AstFunctionAttribute, + AstStatement, + AstFunctionDecl, +} from "../../../src/ast/ast"; +import { + tyToAstType, + StdlibType, + FunctionType, + Type, + isThis, + getReturnType, + isUnit, + UtilType, +} from "../types"; +import { Return } from "./statement"; +import { Parameter } from "./parameter"; +import { Scope } from "../scope"; +import { createSample, generateAstId, generateAstIdFromName } from "../util"; +import { GenerativeEntity } from "./generator"; +import { dummySrcInfo } from "../../../src/grammar/"; + +import fc from "fast-check"; + +/** + * Utility type, used inside function definition and declaration classes and in shared functions. + */ +type FunctionKind = "function" | "method"; + +export const SUPPORTED_RETURN_TYS = [ + StdlibType.Int, + StdlibType.Bool, + StdlibType.String, +]; + +function doesntHaveArguments(kind: FunctionKind, type: FunctionType): boolean { + if (kind === "function") { + return type.signature.length === 1; + } else { + const firstArg = type.signature[0]; + return isThis(firstArg) && type.signature.length === 2; + } +} + +/** + * Creates parameters entries saving them in the scope of the function or method as variables. + */ +function generateParameters( + kind: FunctionKind, + type: FunctionType, + scope: Scope, +): AstTypedParameter[] { + if (doesntHaveArguments(kind, type)) { + return []; + } + const slice = + kind === "method" + ? type.signature.slice(1, -1) + : type.signature.slice(0, -1); + return slice.map((argty) => { + const param = new Parameter(scope, argty); + scope.add("parameter", param); + return createSample(param.generate()); + }); +} + +/** + * Prepares the final list of attributes based on function kind and the current implementation details. + */ +function getAttributes( + extraAttrs: AstFunctionAttribute[], + kind: FunctionKind, + onlyDeclaration: boolean, +): AstFunctionAttribute[] { + const attrs: AstFunctionAttribute[] = extraAttrs; + + // We are marking all the methods with the `get` attribute to ensure they + // will be compiled to func and tested by compilation tests. + // TODO: However, we cannot use `get` for abstract and overridden methods: + // https://github.com/tact-lang/tact/issues/490 + if (kind === "method" && !extraAttrs.find((a) => a.type === "override")) { + attrs.push({ + kind: "function_attribute", + type: "get", + loc: dummySrcInfo, + methodId: undefined, + }); + } + + if (onlyDeclaration) { + attrs.push({ + kind: "function_attribute", + type: "abstract", + loc: dummySrcInfo, + }); + } + + return attrs; +} + +/** + * An object that encapsulates the generated free function or contract method definition including + * its scope and nested elements. + */ +export class FunctionDef extends GenerativeEntity { + /** Generated body items. */ + private body: fc.Arbitrary[] = []; + + /** Scope used within the generated function. */ + private scope: Scope; + + private kind: FunctionKind; + + constructor( + parentScope: Scope, + kind: FunctionKind, + type: FunctionType, + name?: string, + ) { + super(type); + this.scope = new Scope(kind, parentScope); + this.kind = kind; + this.name = name + ? generateAstIdFromName(name) + : createSample( + generateAstId( + this.scope, + kind === "function" ? "functionDef" : "methodDef", + ), + ); + } + + /** + * Generates body of the function emitting return statement and statements generated from the bottom-up. + */ + private generateBody(): fc.Arbitrary { + const type = this.type as FunctionType; + const returnTy: Type = + type.signature.length > 0 + ? getReturnType(type) + : { kind: "util", type: UtilType.Unit }; + const returnStmt = new Return(this.scope, returnTy).generate(); + const generatedLetBindings = Array.from(this.scope.getAll("let")).map((c) => + c.generate(), + ); + const generatedStmts = Array.from(this.scope.getAll("statement")).map((c) => + c.generate(), + ); + this.body = [...generatedLetBindings, ...generatedStmts, returnStmt]; + return fc.tuple(...this.body); + } + + public generateImpl( + extraAttrs: AstFunctionAttribute[], + ): fc.Arbitrary { + const returnTy = getReturnType(this.type as FunctionType); + return fc.record({ + kind: fc.constant("function_def"), + id: fc.constant(this.idx), + attributes: fc.constant(getAttributes(extraAttrs, this.kind, false)), + name: fc.constant(this.name!), + return: fc.constant(isUnit(returnTy) ? undefined : tyToAstType(returnTy)), + params: fc.constant( + generateParameters(this.kind, this.type as FunctionType, this.scope), + ), + statements: this.generateBody(), + loc: fc.constant(dummySrcInfo), + }); + } + + /** + * Generates a function definition without extra attributes. + */ + public generate(): fc.Arbitrary { + return this.generateImpl([]); + } +} + +/** + * An object that encapsulates the generated free function or trait method declaration including + * its scope and nested elements. + */ +export class FunctionDecl extends GenerativeEntity { + /** Scope used within the generated function. */ + private scope: Scope; + + private kind: FunctionKind; + + constructor(parentScope: Scope, kind: FunctionKind, type: FunctionType) { + super(type); + this.kind = "method"; + this.scope = new Scope(kind, parentScope); + this.name = createSample( + generateAstId( + this.scope, + kind === "function" ? "functionDecl" : "methodDecl", + ), + ); + } + + private generateImpl( + extraAttrs: AstFunctionAttribute[], + ): fc.Arbitrary { + const returnTy = getReturnType(this.type as FunctionType); + return fc.record({ + kind: fc.constant("function_decl"), + id: fc.constant(this.idx), + attributes: fc.constant(getAttributes(extraAttrs, this.kind, true)), + name: fc.constant(this.name!), + return: fc.constant(isUnit(returnTy) ? undefined : tyToAstType(returnTy)), + params: fc.constant( + generateParameters(this.kind, this.type as FunctionType, this.scope), + ), + loc: fc.constant(dummySrcInfo), + }); + } + + /** + * Generates a function definition without extra attributes. + */ + public generate(): fc.Arbitrary { + return this.generateImpl([]); + } + + /** + * Generates a new function definition for this declaration. + */ + public generateDefinition( + kind: FunctionKind, + attrs: AstFunctionAttribute[] = [], + ): fc.Arbitrary { + return new FunctionDef( + this.scope.parentScope!, + kind, + this.type as FunctionType, + this.name!.text, + ).generateImpl(attrs); + } +} diff --git a/fuzzer/src/generators/generator.ts b/fuzzer/src/generators/generator.ts new file mode 100644 index 0000000000..19d3d28ddc --- /dev/null +++ b/fuzzer/src/generators/generator.ts @@ -0,0 +1,35 @@ +import { AstId } from "../../../src/ast/ast"; +import { IDIdx, nextId } from "../id"; +import { Type } from "../types"; + +import fc from "fast-check"; + +abstract class GenerativeEntityBase { + /** The unique index of the entity. */ + public idx: IDIdx; + + /** An optional name of the entity. */ + public name?: AstId; + + /** The type of the entity. */ + public type: Type; + + constructor(type: Type, name?: AstId) { + this.idx = nextId(); + this.name = name; + this.type = type; + } +} + +/** + * Abstract base class for entities that generate AST structures. + */ +export abstract class GenerativeEntity extends GenerativeEntityBase { + abstract generate(): fc.Arbitrary; +} +/** + * A specialized version of GenerativeEntity that cannot generate AST entities in some cases. + */ +export abstract class GenerativeEntityOpt extends GenerativeEntityBase { + abstract generate(): fc.Arbitrary | undefined; +} diff --git a/fuzzer/src/generators/index.ts b/fuzzer/src/generators/index.ts new file mode 100644 index 0000000000..04e7240026 --- /dev/null +++ b/fuzzer/src/generators/index.ts @@ -0,0 +1,8 @@ +export { ConstantDef, ConstantDecl } from "./constant"; +export { Field } from "./field"; +export { Contract } from "./contract"; +export { FunctionDef, FunctionDecl } from "./function"; +export { Program } from "./program"; +export { Expression, NonGenerativeExpressionParams } from "./expression"; +export { Statement } from "./statement"; +export { GenerativeEntity } from "./generator"; diff --git a/fuzzer/src/generators/parameter.ts b/fuzzer/src/generators/parameter.ts new file mode 100644 index 0000000000..30a1a47e89 --- /dev/null +++ b/fuzzer/src/generators/parameter.ts @@ -0,0 +1,41 @@ +import { AstTypedParameter } from "../../../src/ast/ast"; +import { createSample, generateAstId } from "../util"; +import { tyToAstType, Type } from "../types"; +import { Scope } from "../scope"; +import { GenerativeEntity } from "./generator"; + +import fc from "fast-check"; +import { dummySrcInfo } from "../../../src/grammar/"; + +/** + * An object that encapsulates generated AstTypedParameter. + */ +export class Parameter extends GenerativeEntity { + /** + * @param parentScope Scope of the function this argument belongs to. + * @param isBounced If the type of the argument should be wrapped in `bounced<>` + */ + constructor( + parentScope: Scope, + type: Type, + private isBounced: boolean = false, + ) { + if (!parentScope.definedIn("receive", "method", "function")) { + throw new Error( + `Cannot define a function argument in the ${parentScope.kind} scope`, + ); + } + super(type); + this.name = createSample(generateAstId(parentScope, "field")); + } + + generate(): fc.Arbitrary { + return fc.record({ + kind: fc.constant("typed_parameter"), + id: fc.constant(this.idx), + name: fc.constant(this.name!), + type: fc.constant(tyToAstType(this.type, this.isBounced)), + loc: fc.constant(dummySrcInfo), + }); + } +} diff --git a/fuzzer/src/generators/program.ts b/fuzzer/src/generators/program.ts new file mode 100644 index 0000000000..cea8272f41 --- /dev/null +++ b/fuzzer/src/generators/program.ts @@ -0,0 +1,183 @@ +import { AstModule } from "../../../src/ast/ast"; +import { + createSamplesArray, + createSample, + randomInt, + randomBool, + randomElement, + generateAstIdFromName, +} from "../util"; +import { TypeGen, UtilType, getStdlibTypes } from "../types"; +import { Contract } from "./contract"; +import { Message, Struct } from "./struct"; +import { Trait } from "./trait"; +import { Scope } from "../scope"; +import { GenerativeEntity } from "./generator"; +import { getStdlibTraits } from "../stdlib"; + +import fc from "fast-check"; + +export interface ProgramParameters { + /** Add definitions that mock stdlib ones to the generated program. */ + addStdlib: boolean; + + /** + * Number of structures generated on the program level. + * @default Random: [1-3] + */ + structsNum: number; + + /** + * Number of messages generated on the program level. + * @default Random: [1-3] + */ + messagesNum: number; + + /** + * Number of the generated traits. Some of them might be used by the generated contracts. + * @default Random: [1-2] + */ + traitsNum: number; +} + +/** + * An object that encapsulates a randomly generated AstModule including extra information + * about its entries and their scopes. + */ +export class Program extends GenerativeEntity { + /** Top-level global scope. */ + private scope: Scope; + + private addStdlib: boolean; + + constructor(params: Partial = {}) { + super( + { kind: "util", type: UtilType.Program }, + generateAstIdFromName("program"), + ); + + const { + addStdlib = false, + structsNum = randomInt(1, 3), + messagesNum = randomInt(1, 3), + traitsNum = randomInt(1, 2), + } = params; + this.addStdlib = addStdlib; + + this.scope = new Scope("program", undefined); + + // NOTE: Structures and messages must be generated prior to contracts in order + // to add their entries to scopes for futher reuse. + Array.from({ length: structsNum }).forEach((_) => { + this.scope.add("struct", this.makeStruct()); + }); + + Array.from({ length: messagesNum }).forEach((_) => { + this.scope.add("message", this.makeMessage()); + }); + + // NOTE: Traits must be generated prior to contracts to enable them implement them. + const traits: Trait[] = []; + Array.from({ length: traitsNum }).forEach((_) => { + const trait = this.makeTrait(); + traits.push(trait); + this.scope.add("trait", trait); + }); + + // One of the traits could be implemented by the main contract. + const traitToImplement = + traitsNum > 0 && randomBool() ? randomElement(traits) : undefined; + this.scope.add("contract", this.makeContract(traitToImplement)); + } + + /** + * Generates a Tact program. + * + * It always follows a structure that includes a single contract with a few methods + * which are considered as entry points of the random program generation. This means, the generation + * starts bottom-up from the return types of these methods and adds different AST entries, including + * constants, functions and contract fields. AST nodes inside the contract implementation may vary, + * as determined by fast-check. + */ + public generate(): fc.Arbitrary { + const stdlibEntries = this.addStdlib + ? getStdlibTraits() + .concat(getStdlibTypes()) + .map((entry) => fc.constant(entry)) + : []; + const traits = Array.from(this.scope.getAll("trait")).map((t) => + t.generate(), + ); + const contracts = Array.from(this.scope.getAll("contract")).map((c) => + c.generate(), + ); + const structs = Array.from(this.scope.getAll("struct")).map((s) => + s.generate(), + ); + const messages = Array.from(this.scope.getAll("message")).map((m) => + m.generate(), + ); + const constants = Array.from(this.scope.getAll("constantDef")).map((c) => + c.generate(), + ); + const functions = Array.from(this.scope.getAll("functionDef")).map((f) => + f.generate(), + ); + return fc.record({ + kind: fc.constantFrom("module"), + id: fc.constantFrom(this.idx), + items: fc.tuple( + ...stdlibEntries, + ...structs, + ...messages, + ...constants, + ...functions, + ...traits, + ...contracts, + ), + imports: fc.constant([]), + }); + } + + /** + * Creates a contract object with the predefined structure which is an entry point of the generation. + * @param trait Trait the generated contract should implement + */ + private makeContract(trait?: Trait): Contract { + const methodSignatures = createSamplesArray( + () => TypeGen.fromScope(this.scope).generateMethod(), + 1, + 3, + ).map((arb) => createSample(arb)); + return new Contract(this.scope, methodSignatures, trait); + } + + /** + * Creates a structure in the program scope. + */ + private makeStruct(): Struct { + // TODO: What if the struct-instance/field pair is the same as second-contract-instance/field pair? + return new Struct( + this.scope, + createSample(TypeGen.fromScope(this.scope).generateStruct(false)), + ); + } + + /** + * Creates a message in the program scope. + */ + private makeMessage(): Message { + // TODO: What if the struct-instance/field pair is the same as second-contract-instance/field pair? + return new Message( + this.scope, + createSample(TypeGen.fromScope(this.scope).generateStruct(true)), + ); + } + + /** + * Creates a trait in the program scope. + */ + private makeTrait(): Trait { + return new Trait(this.scope); + } +} diff --git a/fuzzer/src/generators/receiver.ts b/fuzzer/src/generators/receiver.ts new file mode 100644 index 0000000000..c9b3c2e2fd --- /dev/null +++ b/fuzzer/src/generators/receiver.ts @@ -0,0 +1,122 @@ +import { + AstReceiver, + AstStatement, + AstString, + AstReceiverKind, +} from "../../../src/ast/ast"; +import { UtilType, Type, StdlibType, isBouncedMessage } from "../types"; +import { Scope } from "../scope"; +import { GenerativeEntity } from "./generator"; +import { createSample, randomBool, randomElement } from "../util"; +import { Expression, generateString } from "./expression"; +import { Parameter } from "./parameter"; +import { StatementExpression } from "./statement"; + +import fc from "fast-check"; +import { dummySrcInfo } from "../../../src/grammar/"; + +const RECEIVE_RETURN_TY: Type = { kind: "util", type: UtilType.Unit }; + +/** + * An object that encapsulates an AstReceiver. + */ +export class Receive extends GenerativeEntity { + /** Generated body items. */ + private body: fc.Arbitrary[] = []; + + /** Scope used within the generated receive method. */ + private scope: Scope; + + constructor(parentScope: Scope) { + super(RECEIVE_RETURN_TY); + this.scope = new Scope("receive", parentScope); + } + + private generateSelector(): fc.Arbitrary { + if (randomBool()) { + const ty = createSample( + fc.record({ + kind: fc.constant("stdlib"), + type: fc.constantFrom( + // TODO: Support Slice + StdlibType.String, + ), + }), + ); + const param = new Parameter(this.scope, ty); + this.scope.add("parameter", param); + const internalSimple = fc.record({ //TODO: make a real generatable from this + kind: fc.constantFrom("internal"), + param: param.generate(), + }); + const externalSimple = fc.record({ + kind: fc.constantFrom("external-simple"), + param: param.generate(), + }); + return fc.oneof(internalSimple, externalSimple); + } + + // Choose a random message and create a bounced receiver using it. + const messages = this.scope.getProgramScope().getAll("message"); + if (messages.length > 0 && randomBool()) { + const msg = randomElement(messages); + const param = new Parameter( + this.scope, + msg.type, + isBouncedMessage(msg.type), + ); + this.scope.add("parameter", param); + return fc.record({ + kind: fc.constantFrom("bounce"), + param: param.generate(), + }); + } + + const internalFallback = fc.record({ + kind: fc.constantFrom("internal-fallback"), + }); + const externalFallback = fc.record({ + kind: fc.constantFrom("external-fallback"), + }); + const internalComment = fc.record({ + kind: fc.constantFrom("internal-comment"), + comment: generateString(/*nonEmpty=*/ true) as fc.Arbitrary, + }); + const externalComment = fc.record({ + kind: fc.constantFrom("external-comment"), + comment: generateString(/*nonEmpty=*/ true) as fc.Arbitrary, + }); + + return fc.oneof( + internalFallback, + externalFallback, + internalComment, + externalComment, + ); + } + + private generateBody(): fc.Arbitrary { + // Create a dummy expression to execute the bottom-up AST generation. + const expr = new Expression(this.scope, this.type).generate(); + const stmt = new StatementExpression(expr).generate(); + + const generatedLetBindings = Array.from(this.scope.getAll("let")).map((c) => + c.generate(), + ); + const generatedStmts = Array.from(this.scope.getAll("statement")).map((c) => + c.generate(), + ); + this.body = [...generatedLetBindings, ...generatedStmts, stmt]; + return fc.tuple(...this.body); + } + + public generate(): fc.Arbitrary { + return fc.record({ + kind: fc.constant("receiver"), + id: fc.constant(this.idx), + selector: this.generateSelector(), + statements: this.generateBody(), + loc: fc.constant(dummySrcInfo), + }); + } +} diff --git a/fuzzer/src/generators/statement.ts b/fuzzer/src/generators/statement.ts new file mode 100644 index 0000000000..3501605376 --- /dev/null +++ b/fuzzer/src/generators/statement.ts @@ -0,0 +1,622 @@ +import { + AstStatementReturn, + AstFieldAccess, + AstStatementExpression, + AstStatement, + AstStatementTry, + AstStatementForEach, + AstStatementCondition, + AstStatementRepeat, + AstStatementAssign, + AstStatementAugmentedAssign, + AstAugmentedAssignOperation, + AstStatementWhile, + AstStatementUntil, + AstExpression, + AstStatementLet, + AstId, + AstCatchBlock, +} from "../../../src/ast/ast"; +import fc from "fast-check"; + +import { + Expression, + generateBoolean, + NonGenerativeExpressionParams, + StaticCall, + MethodCall, + generateFunctionCallArgs, + generateMethodCallArgs, + generateThisID, + generateFieldAccess, +} from "./expression"; +import { + randomBool, + createSample, + generateName, + packArbitraries, + randomElement, + generateAstId, + generateAstIdFromName, +} from "../util"; +import { GenerativeEntity } from "./generator"; +import { Type, StdlibType, UtilType, tyToAstType } from "../types"; +import { Scope, ScopeItemKind } from "../scope"; +import { dummySrcInfo } from "../../../src/grammar/"; + +/** Type all the imperative constructions have. */ +const STMT_TY: Type = { kind: "util", type: UtilType.Unit }; + +/** + * Generates `return` statements. + */ +export class Return extends GenerativeEntity { + /** + * @param parentScope Scope this statement belongs to. + */ + constructor( + private parentScope: Scope, + type: Type, + ) { + super(type); + } + generate(): fc.Arbitrary { + return fc.record({ + kind: fc.constant("statement_return"), + id: fc.constant(this.idx), + expression: + this.type.kind === "util" && this.type.type === UtilType.Unit + ? fc.constant(undefined) + : new Expression(this.parentScope, this.type).generate(), + loc: fc.constant(dummySrcInfo), + }); + } +} + +/** + * Let generator is the entry point of the bottom-up statement generation. + * It creates a variable binding and then adds additional statements that mutate the created binding and the global state. + */ +export class Let extends GenerativeEntity { + /** + * @param parentScope Scope this statement belongs to. + * @param type Type of the generated binding. + * @param expr Expression generator to initialize that binding. + */ + constructor( + parentScope: Scope, + type: Type, + private expr: fc.Arbitrary, + ) { + super(type); + this.name = createSample(generateAstId(parentScope, "constantDef")); + } + + generate(): fc.Arbitrary { + return fc.record({ + kind: fc.constant("statement_let"), + id: fc.constant(this.idx), + name: fc.constantFrom(this.name!), + type: fc.constantFrom(tyToAstType(this.type)), + expression: this.expr, + loc: fc.constant(dummySrcInfo), + }); + } +} + +/** + * Creates assignments and augmented assignments to modify global or local variables. + */ +export class AssignStatement extends GenerativeEntity { + /** + * @param path A qualified name of the lhs. + * @param rhs Expression to assign to. + * @param rhsTy Type of the rhs of the assignment. + * @param ty Type of the statement. + */ + constructor( + private path: AstExpression, + private rhs: fc.Arbitrary, + private rhsTy: Type, + ty = STMT_TY, + ) { + super(ty); + } + + generate(): fc.Arbitrary { + const assigns: fc.Arbitrary[] = [ + fc.record({ + kind: fc.constant("statement_assign"), + id: fc.constant(this.idx), + path: fc.constant(this.path), + expression: this.rhs, + loc: fc.constant(dummySrcInfo), + }), + ]; + // Only integer types in augmented assignments are supported. + // See: https://github.com/tact-lang/tact/issues/353. + if (this.rhsTy.kind === "stdlib" && this.rhsTy.type === StdlibType.Int) { + assigns.push( + fc.record({ + kind: fc.constant("statement_augmentedassign"), + id: fc.constant(this.idx), + op: fc.constantFrom( + "+", + "-", + "*", + "/", + "%", + ), + path: fc.constantFrom(this.path), + expression: this.rhs, + loc: fc.constant(dummySrcInfo), + }), + ); + } + return fc.oneof(...assigns); + } +} + +/** + * Generates `while` and `until` loops. + */ +export class WhileUntilStatement extends GenerativeEntity { + constructor( + private condition: fc.Arbitrary, + private body: fc.Arbitrary[], + private kind: "until" | "while", + type: Type = STMT_TY, + ) { + super(type); + } + generate(): fc.Arbitrary { + return fc.record({ + kind: fc.constant(`statement_${this.kind}`), + id: fc.constant(this.idx), + condition: this.condition, + statements: packArbitraries(this.body), + loc: fc.constant(dummySrcInfo), + }) as fc.Arbitrary; + } +} + +/** + * Generates `repeat` loops. + */ +export class RepeatStatement extends GenerativeEntity { + constructor( + private parentScope: Scope, + private body: fc.Arbitrary[], + type: Type = STMT_TY, + ) { + super(type); + } + generate(): fc.Arbitrary { + const iterations = new Expression(this.parentScope, { + kind: "stdlib", + type: StdlibType.Int, + }).generate(); + return fc.record({ + kind: fc.constant(`statement_repeat`), + id: fc.constant(this.idx), + iterations, + statements: packArbitraries(this.body), + loc: fc.constant(dummySrcInfo), + }) as fc.Arbitrary; + } +} + +/** + * Generates `foreach` loops. + */ +export class ForeachStatement extends GenerativeEntity { + constructor( + private map: fc.Arbitrary, + private keyName: string, + private valueName: string, + private body: fc.Arbitrary[], + type: Type = STMT_TY, + ) { + super(type); + } + generate(): fc.Arbitrary { + return fc.record({ + kind: fc.constant("statement_foreach"), + keyName: fc.constant(generateAstIdFromName(this.keyName)), + valueName: fc.constant(generateAstIdFromName(this.valueName)), + map: this.map, + statements: packArbitraries(this.body), + id: fc.constant(this.idx), + loc: fc.constant(dummySrcInfo), + }); + } +} + +/** + * Generates conditional statements. + */ +export class ConditionStatement extends GenerativeEntity { + constructor( + private parentScope: Scope, + private trueStmts: fc.Arbitrary[], + private falseStmts?: fc.Arbitrary[], + private elseif?: fc.Arbitrary, + type: Type = STMT_TY, + ) { + super(type); + } + generate(): fc.Arbitrary { + const condition = new Expression(this.parentScope, { + kind: "stdlib", + type: StdlibType.Bool, + }).generate(); + return fc.record({ + kind: fc.constant(`statement_condition`), + condition, + trueStatements: packArbitraries(this.trueStmts), + falseStatements: this.falseStmts + ? packArbitraries(this.falseStmts) + : fc.constant(undefined), + // elseif: this.elseif ? this.elseif : fc.constant(null), // TODO: check how if else works + id: fc.constant(this.idx), + loc: fc.constant(dummySrcInfo), + }); + } +} + +/** + * Generates try-catch statements. + */ +export class TryCatch extends GenerativeEntity { + constructor( + private tryStmts: fc.Arbitrary[], + private catchBlock?: AstCatchBlock, + type: Type = STMT_TY, + ) { + super(type); + } + generate(): fc.Arbitrary { + return fc.record({ + kind: fc.constant("statement_try"), + id: fc.constant(this.idx), + statements: packArbitraries(this.tryStmts), + catchBlock: fc.constant(this.catchBlock), + loc: fc.constant(dummySrcInfo), + }); + } +} + +/** + * Generates expression statements. + * The return value of the function/method calls generated by this is never used. + */ +export class StatementExpression extends GenerativeEntity { + constructor( + private expr: fc.Arbitrary, + type: Type = STMT_TY, + ) { + super(type); + } + generate(): fc.Arbitrary { + return fc.record({ + kind: fc.constant("statement_expression"), + id: fc.constant(this.idx), + expression: this.expr, + loc: fc.constant(dummySrcInfo), + }); + } +} + +export interface StatementParameters { + /** + * Determines the maximum depth of nested statement blocks. + * @default 2 + */ + nestedBlocksNum: number; + + /** + * Number of statements in each block. + * @default 3 + */ + stmtsInBlock: number; +} + +/** + * The generator that creates statements in the given block which mutate global or local state. + */ +export class Statement extends GenerativeEntity { + private nestedBlocksNum: number; + private stmtsInBlock: number; + private params: Partial; + + /** + * @param parentScope Scope the generated statements belongs to. + * @param recursionLevel Used internally within Statement. + * @param params Optional parameters for statement generation. + * @param type Type of the generated statement. + */ + constructor( + private parentScope: Scope, + private recursionLevel = 0, + params: Partial = {}, + type: Type = STMT_TY, + ) { + if (parentScope.definedIn("program", "contract")) { + throw new Error( + `Cannot generate statements in the ${parentScope.kind} scope`, + ); + } + super(type); + + const { nestedBlocksNum = 2, stmtsInBlock = 3 } = params; + this.nestedBlocksNum = nestedBlocksNum; + this.stmtsInBlock = stmtsInBlock; + + this.params = params; + } + + generate(): fc.Arbitrary { + const varAssign = this.makeVarAssign(); + const fieldAssign = this.makeFieldAssign(); + const loopStmt = randomBool() ? this.makeWhileUntil() : this.makeRepeat(); + const foreachStmt = this.makeForEach(); + const condStmt = this.makeCondition(); + const tryCatch = this.makeTryCatch(); + const callStmt = this.makeCall(); + const generated = [ + ...(varAssign ? [varAssign] : []), + ...(fieldAssign ? [fieldAssign] : []), + ...(loopStmt ? [loopStmt] : []), + ...(foreachStmt ? [foreachStmt] : []), + ...(condStmt ? [condStmt] : []), + ...(tryCatch ? [tryCatch] : []), + ...(callStmt ? [callStmt] : []), + ]; + if (generated.length === 0) { + // No variables in local/global scopes are available: generate dummy statements. + generated.push(this.makeDummyStmt()); + } + return fc.oneof(...generated); + } + + /** + * Creates statements that mutate local variables, including assignments and augmented assignments. + */ + private makeVarAssign(): fc.Arbitrary | undefined { + const varEntries: [string, Type][] = + this.parentScope.getEntriesRecursive("let"); + if (varEntries.length === 0) { + return undefined; + } + const arbs = varEntries.map(([name, ty]) => { + const expr = new Expression(this.parentScope, ty).generate(); + return new AssignStatement( + generateAstIdFromName(name), + expr, + ty, + ).generate(); + }); + return arbs.length > 0 ? fc.oneof(...arbs) : undefined; + } + + /** + * Creates statements that mutate contract fields, including assignments and augmented assignments. + */ + private makeFieldAssign(): fc.Arbitrary | undefined { + if (!this.parentScope.definedIn("method")) { + return undefined; + } + const fieldEntries: [string, Type][] = + this.parentScope.getEntriesRecursive("field"); + if (fieldEntries.length === 0) { + return undefined; + } + const arbs = fieldEntries.map(([name, ty]) => { + const expr = new Expression( + this.parentScope, + ty, + NonGenerativeExpressionParams, + ).generate(); + return new AssignStatement( + generateFieldAccess(name), + expr, + ty, + ).generate(); + }); + return arbs.length > 0 ? fc.oneof(...arbs) : undefined; + } + + /** + * Creates either while or until loops. + */ + private makeWhileUntil(): fc.Arbitrary | undefined { + if (this.recursionLevel >= this.nestedBlocksNum) { + return undefined; + } + const condition = new Expression( + this.parentScope, + { kind: "stdlib", type: StdlibType.Bool }, + NonGenerativeExpressionParams, + ).generate(); + const body = this.makeStmtsBlock(); + return new WhileUntilStatement( + condition, + body, + randomBool() ? "while" : "until", + ).generate(); + } + + /** + * Generates repeat loops. + */ + private makeRepeat(): fc.Arbitrary | undefined { + if (this.recursionLevel >= this.nestedBlocksNum) { + return undefined; + } + const body = this.makeStmtsBlock(); + return new RepeatStatement(this.parentScope, body).generate(); + } + + /** + * Collects all local map AstIds in parent scope. + */ + private collectLocalMapIds(entryKinds: ScopeItemKind[]): AstId[] { + return this.parentScope + .getEntriesRecursive(...entryKinds) + .filter(([_, mapTy]: [string, Type]) => mapTy.kind === "map") + .map(([mapName, _]: [string, Type]) => generateAstIdFromName(mapName)); + } + + /** + * Collects all field map AstIds in parent scope. + */ + private collectFieldMapIds(entryKinds: ScopeItemKind[]): AstFieldAccess[] { + return this.parentScope + .getEntriesRecursive(...entryKinds) + .filter(([_, mapTy]: [string, Type]) => mapTy.kind === "map") + .map(([mapName, _]: [string, Type]) => generateFieldAccess(mapName)); + } + + /** + * Generates foreach loops. + */ + private makeForEach(): fc.Arbitrary | undefined { + if (this.recursionLevel >= this.nestedBlocksNum) { + return undefined; + } + const scope = new Scope("block", this.parentScope); + const simpleMapIds = this.collectLocalMapIds([ + "let", + "constantDecl", + "constantDef", + ]); + const fieldMapPaths = this.collectFieldMapIds(["field"]); + const mapIds = [ + ...simpleMapIds.map(fc.constant), + ...fieldMapPaths.map(fc.constant), + ]; + if (mapIds.length === 0) { + return undefined; + } + const map: fc.Arbitrary = fc.oneof(...mapIds); + const keyVarName = createSample(generateName(scope, "let")); + const valueVarName = createSample(generateName(scope, "let")); + const body = this.makeStmtsBlock(scope); + return new ForeachStatement(map, keyVarName, valueVarName, body).generate(); + } + + /** + * Generates conditional statements. + * @param allowElseif Allow creating additional AstStatementCondition in else-if blocks. + */ + private makeCondition( + allowElseif: boolean = true, + ): fc.Arbitrary | undefined { + if (this.recursionLevel >= this.nestedBlocksNum) { + return undefined; + } + const trueStatements = this.makeStmtsBlock(); + const falseStatements = randomBool() ? undefined : this.makeStmtsBlock(); + const elseif = + allowElseif && falseStatements === undefined + ? this.makeCondition(false) + : undefined; + return new ConditionStatement( + this.parentScope, + trueStatements, + falseStatements, + elseif, + ).generate(); + } + + /** + * Generates try and try-catch statements + */ + private makeTryCatch(): fc.Arbitrary | undefined { + if (this.recursionLevel >= this.nestedBlocksNum) { + return undefined; + } + const tryStmts = this.makeStmtsBlock(); + if (randomBool()) { + const catchScope = new Scope("block", this.parentScope); + const catchName = createSample(generateName(catchScope, "let")); + const catchStmts = this.makeStmtsBlock(catchScope).map((stmt) => + createSample(stmt), + ); + return new TryCatch(tryStmts, { + catchName: generateAstIdFromName(catchName), + catchStatements: catchStmts, + }).generate(); + } else { + return new TryCatch(tryStmts).generate(); + } + } + + /** + * Generates function or method calls without using the return value. + */ + private makeCall(): fc.Arbitrary | undefined { + if (this.recursionLevel >= this.nestedBlocksNum) { + return undefined; + } + if (this.parentScope.definedIn("method", "contract") && randomBool()) { + // Call a method + const methodEntries = this.parentScope.getEntriesRecursive("methodDef"); + if (methodEntries.length === 0) { + return undefined; + } + const [funName, funTy] = randomElement(methodEntries); + return new StatementExpression( + new MethodCall( + funTy, + funName, + generateThisID(), + generateMethodCallArgs(funTy, this.parentScope), + ).generate(), + ).generate(); + } else { + // Call a function + const funEntries = this.parentScope.getEntriesRecursive("functionDef"); + if (funEntries.length === 0) { + return undefined; + } + const [funName, funTy] = randomElement(funEntries); + return new StatementExpression( + new StaticCall( + funTy, + funName, + generateFunctionCallArgs(funTy, this.parentScope), + ).generate(), + ).generate(); + } + } + + /** + * Creates a block of statements nested in curly braces in concrete syntax. + */ + private makeStmtsBlock(blockScope?: Scope): fc.Arbitrary[] { + const scope = + blockScope === undefined + ? new Scope("block", this.parentScope) + : blockScope; + const block: fc.Arbitrary[] = []; + Array.from({ length: this.stmtsInBlock }).forEach(() => { + const stmt = new Statement( + scope, + this.recursionLevel + 1, + this.params, + ).generate(); + block.push(stmt); + }); + return block; + } + + /** + * Generates a dummy statement which doesn't have affect on control-flow nor state: + * `while (false) { }` + */ + private makeDummyStmt(): fc.Arbitrary { + const falseExpr = generateBoolean(false); + return new WhileUntilStatement(falseExpr, [], "while").generate(); + } +} diff --git a/fuzzer/src/generators/struct.ts b/fuzzer/src/generators/struct.ts new file mode 100644 index 0000000000..ec9caefcd5 --- /dev/null +++ b/fuzzer/src/generators/struct.ts @@ -0,0 +1,105 @@ +import { + AstMessageDecl, + AstStructDecl, +} from "../../../src/ast/ast"; +import { Type, tyToString, StructField, throwTyError } from "../types"; +import { Scope } from "../scope"; +import { Field } from "./field"; +import { generateAstIdFromName, packArbitraries } from "../util"; +import { GenerativeEntity } from "./generator"; +import { dummySrcInfo } from "../../../src/grammar/"; + +import fc from "fast-check"; + +/** + * An object that generates AstStructDecl object. + */ +export class Struct extends GenerativeEntity { + /** + * @param programScope A program scope the structure defined in. + */ + constructor( + private programScope: Scope, + type: Type, + ) { + if (type.kind !== "struct") { + throw new Error( + `Cannot create a structure with the ${tyToString(type)} type`, + ); + } + if (!programScope.definedIn("program")) { + throw new Error( + `Cannot define a struct out of the program scope (got ${programScope.kind})`, + ); + } + super(type, generateAstIdFromName(type.name)); + } + + generate(): fc.Arbitrary { + if (this.type.kind !== "struct") { + throwTyError(this.type); + } + const fields = this.type.fields.map((fieldTy: StructField) => { + return new Field( + this.programScope, + fieldTy.type, + fieldTy.default, + generateAstIdFromName(fieldTy.name), + ).generate(); + }); + return fc.record({ + kind: fc.constant("struct_decl"), + id: fc.constant(this.idx), + name: fc.constant(this.name!), + fields: packArbitraries(fields), + loc: fc.constant(dummySrcInfo), + }); + } +} + +/** + * An object that generates AstMessageDecl object messages. + */ +export class Message extends GenerativeEntity { + /** + * @param programScope A program scope the structure defined in. + */ + constructor( + private programScope: Scope, + type: Type, + ) { + if (type.kind !== "message") { + throw new Error( + `Cannot create a message with the ${tyToString(type)} type`, + ); + } + if (!programScope.definedIn("program")) { + throw new Error( + `Cannot define a struct out of the program scope (got ${programScope.kind})`, + ); + } + super(type, generateAstIdFromName(type.name)); + } + + generate(): fc.Arbitrary { + if (this.type.kind !== "message") { + throwTyError(this.type); + } + const fields = this.type.fields.map((fieldTy: StructField) => { + return new Field( + this.programScope, + fieldTy.type, + fieldTy.default, + generateAstIdFromName(fieldTy.name), + ).generate(); + }); + return fc.record({ + kind: fc.constant("message_decl"), + id: fc.constant(this.idx), + name: fc.constant(this.name!), + opcode: fc.constant(undefined), + fields: packArbitraries(fields), + loc: fc.constant(dummySrcInfo), + }); + } +} diff --git a/fuzzer/src/generators/trait.ts b/fuzzer/src/generators/trait.ts new file mode 100644 index 0000000000..544b1f3d01 --- /dev/null +++ b/fuzzer/src/generators/trait.ts @@ -0,0 +1,122 @@ +import { AstTrait, AstExpression } from "../../../src/ast/ast"; +import { createSample, generateAstId, randomBool } from "../util"; +import { FunctionDecl } from "./function"; +import { Field } from "./field"; +import { ConstantDecl, ConstantDef } from "./constant"; +import { Expression } from "./expression"; +import { Type, TypeGen, makeFunctionTy, UtilType } from "../types"; +import { Scope } from "../scope"; +import { GenerativeEntity } from "./generator"; + +import fc from "fast-check"; +import { dummySrcInfo } from "../../../src/grammar/"; + +export interface TraitParameters { + /** + * Number of fields generated within a trait. + * @default 1 + */ + fieldNum: number; + + /** + * Number of method declarations generated within a trait. + * @default 1 + */ + methodDeclarationsNum: number; + + /** + * Number of constant declarations generated within a trait. + * @default 1 + */ + constantNum: number; +} + +/** + * An object that encapsulates a randomly generated AstTrait. + */ +export class Trait extends GenerativeEntity { + /** Trait scope. */ + private scope: Scope; + + // Configuration options + private fieldNum: number; + private methodDeclarationsNum: number; + private constantNum: number; + + // Declarations to be defined within contracts/traits that implement this trait. + public fieldDeclarations: Field[] = []; + public constantDeclarations: ConstantDecl[] = []; + public constantDefinitions: ConstantDef[] = []; + public methodDeclarations: FunctionDecl[] = []; + + constructor(programScope: Scope, params: Partial = {}) { + super({ kind: "util", type: UtilType.Trait }); + this.scope = new Scope("trait", programScope); + this.name = createSample(generateAstId(this.scope, "trait")); + + const { fieldNum = 1, methodDeclarationsNum = 1, constantNum = 1 } = params; + this.fieldNum = fieldNum; + this.methodDeclarationsNum = methodDeclarationsNum; + this.constantNum = constantNum; + + this.prepareDeclarationTypes(); + } + + /** + * Randomly generates init expressions for constants. + */ + private makeInit(ty: Type): fc.Arbitrary | undefined { + return ty.kind === "map" || randomBool() + ? undefined + : new Expression(this.scope, ty, { + compileTimeEval: true, + }).generate(); + } + + /** + * Generates arbitrary types for fields, methods and constants that will be + * defined in the trait. + */ + private prepareDeclarationTypes() { + this.fieldDeclarations = Array.from({ length: this.fieldNum }).map((_) => { + const ty = TypeGen.fromScope(this.scope).pick(); + const field = new Field(this.scope, ty); + this.scope.add("field", field); + return field; + }); + this.methodDeclarations = Array.from({ + length: this.methodDeclarationsNum, + }).map((_) => { + const returnTy = TypeGen.fromScope(this.scope).pick(); + const funTy = makeFunctionTy("method", returnTy); + return new FunctionDecl(this.scope, "method", funTy); + }); + this.constantDeclarations = []; + this.constantDefinitions = []; + Array.from({ length: this.constantNum }).forEach((_) => { + const ty = TypeGen.fromScope(this.scope).pick(); + const init = this.makeInit(ty); + if (init) + this.constantDefinitions.push( + ConstantDef.fromScope(this.scope, ty, init), + ); + else this.constantDeclarations.push(new ConstantDecl(this.scope, ty)); + }); + } + + public generate(): fc.Arbitrary { + // NOTE: It doesn't implement any receive functions, to don't clutter the top-level with them. + const constants = this.constantDeclarations.map((c) => c.generate()); + const fields = this.fieldDeclarations.map((f) => f.generate()); + const methods = this.methodDeclarations.map((m) => m.generate()); + return fc.record({ + kind: fc.constant("trait"), + id: fc.constant(this.idx), + name: fc.constant(this.name!), + traits: fc.constant([]), + attributes: fc.constant([]), + declarations: fc.tuple(...constants, ...fields, ...methods), + loc: fc.constant(dummySrcInfo), + }); + } +} diff --git a/fuzzer/src/id.ts b/fuzzer/src/id.ts new file mode 100644 index 0000000000..0eb925c3da --- /dev/null +++ b/fuzzer/src/id.ts @@ -0,0 +1,8 @@ +export type IDIdx = number; + +let currentId: IDIdx = 0; + +export function nextId(): IDIdx { + currentId += 1; + return currentId; +} diff --git a/fuzzer/src/scope.ts b/fuzzer/src/scope.ts new file mode 100644 index 0000000000..8711140d6f --- /dev/null +++ b/fuzzer/src/scope.ts @@ -0,0 +1,357 @@ +import { Type, getReturnType } from "./types"; +import { IDIdx } from "./id"; +import { GenerativeEntity } from "./generators"; +import { + AstFunctionDef, + AstTypedParameter, + AstTrait, + AstStatement, + AstStructDecl, + AstFieldDecl, + AstReceiver, + AstContract, + AstConstantDecl, + AstConstantDef, + AstFunctionDecl, + AstMessageDecl, +} from "../../src/ast/ast"; + +export type ScopeKind = + | "program" + | "trait" + | "contract" + | "function" + | "method" + | "receive" + | "block"; + +export type ScopeItemKind = + | "let" + | "parameter" + | "statement" + | "struct" + | "message" + | "constantDecl" + | "constantDef" + | "functionDecl" + | "functionDef" + | "methodDecl" + | "methodDef" + | "receive" + | "field" + | "contract" + | "trait"; + +/** Maps each ScopeItemKind to its respective GenerativeEntity specialization. */ +type GenerativeEntityMap = { + let: GenerativeEntity; + parameter: GenerativeEntity; + statement: GenerativeEntity; + struct: GenerativeEntity; + message: GenerativeEntity; + constantDecl: GenerativeEntity; + constantDef: GenerativeEntity; + functionDecl: GenerativeEntity; + functionDef: GenerativeEntity; + methodDecl: GenerativeEntity; + methodDef: GenerativeEntity; + receive: GenerativeEntity; + field: GenerativeEntity; + contract: GenerativeEntity; + trait: GenerativeEntity; +}; + +/** + * Scope contains AST entries generated during the bottom-up AST generation and + * provides an information to access data in parent scopes. + */ +export class Scope { + kind: ScopeKind; + + /** Reference to the parent scope. `undefined` for the top-level scope. */ + readonly parentScope?: Scope; + + /** + * Contains AST entries generated during the bottom-up AST generation. + */ + // eslint-disable-next-line @typescript-eslint/no-explicit-any + private map: Map>> = + new Map(); + + constructor(kind: ScopeKind, parentScope: Scope | undefined) { + this.kind = kind; + this.parentScope = parentScope; + } + + public isProgramScope(): boolean { + return this.parentScope === undefined; + } + + /** + * Returns the top-level scope. + */ + public getProgramScope(): Scope { + return this.isProgramScope() ? this : this.parentScope!.getProgramScope(); + } + + /** + * Returns the contract-level scope or `undefined` if it is not possible to reach it from the current scope. + */ + public getContractScope(): Scope | undefined { + if (this.isContractScope()) { + return this; + } + if (this.parentScope === undefined) { + return undefined; + } + return this.parentScope!.getContractScope(); + } + + public isContractScope(): boolean { + return ( + this.parentScope !== undefined && + this.parentScope.isProgramScope() && + this.kind === "contract" + ); + } + + /** + * Put a new entity in the scope according to the Tact semantics. + */ + public add( + kind: T, + entity: GenerativeEntityMap[T], + ): void { + // Determine the appropriate parent scope based on the kind of entity + let targetScope: Scope | undefined; + switch (kind) { + case "let": + case "parameter": + case "statement": + // eslint-disable-next-line @typescript-eslint/no-this-alias + targetScope = this; + break; + case "constantDecl": + case "constantDef": + targetScope = this.findParent("trait", "contract", "program"); + break; + case "functionDecl": + case "functionDef": + case "trait": + targetScope = this.findParent("program"); + break; + case "methodDecl": + case "methodDef": + case "field": + case "receive": + targetScope = this.findParent("trait", "contract"); + break; + case "contract": + case "struct": + case "message": + targetScope = this.findParent("program"); + break; + default: + throw new Error("Unsupported kind for adding to scope."); + } + if (targetScope === undefined) { + throw new Error(`Cannot add "${kind}" to the "${this.kind}" scope`); + } + + if (targetScope.map.has(kind)) { + targetScope.map.get(kind)!.set(entity.idx, entity); + } else { + targetScope.map.set(kind, new Map()).get(kind)!.set(entity.idx, entity); + } + } + + public get( + kind: T, + id: IDIdx, + ): GenerativeEntityMap[T] | undefined { + return this.map.get(kind)?.get(id); + } + + public getAll(kind: T): GenerativeEntityMap[T][] { + const kindMap = this.map.get(kind); + if (kindMap) { + return Array.from(kindMap.values()); + } + return []; + } + + /** + * Collects name-type tuples of all the entries with the given type defined within this scope. + */ + public getEntries(kind: ScopeItemKind): [string, Type][] { + const names = this.map.get(kind); + if (names === undefined) { + return []; + } + return Array.from(names) + .map(([_id, entry]) => [entry.name?.text!, entry.type] as [string, Type]) + .filter((entry): entry is [string, Type] => entry[0] !== undefined); + } + + /** + * Collects name-type tuples of all the entries with the given type defined within scope + * and its parent scopes. + */ + public getEntriesRecursive(...kinds: ScopeItemKind[]): [string, Type][] { + const recursiveHelper = ( + kinds: ScopeItemKind[], + acc: [string, Type][], + scope?: Scope, + ): [string, Type][] => { + if (scope === undefined) { + return acc; + } + const entries = kinds.flatMap((kind) => scope.getEntries(kind)); + if (scope.isProgramScope()) { + return acc.concat(entries); + } else { + return recursiveHelper(kinds, acc.concat(entries), scope.parentScope); + } + }; + return recursiveHelper(kinds, [], this); + } + + /** + * Collects names of all the entries with the given type defined within this scope. + */ + public getNames(kind: ScopeItemKind, ty: Type): string[] { + return this.getEntries(kind) + .filter(([_name, type]) => type === ty) + .map(([name, _type]) => name); + } + + /** + * Collects names of all the entries with the given type defined within scope + * and its parent scopes. + */ + public getNamesRecursive( + kind: ScopeItemKind, + ty: Type, + acc: string[] = [], + ): string[] { + const names = this.getNames(kind, ty); + if (this.isProgramScope()) { + return acc.concat(names); + } else { + return acc.concat(this.parentScope!.getNamesRecursive(kind, ty, names)); + } + } + + /** + * Returns all items of the given type defined within this scope. + */ + // eslint-disable-next-line @typescript-eslint/no-explicit-any + public getItems(kind: ScopeItemKind): GenerativeEntity[] { + const result = this.map.get(kind); + return result === undefined ? [] : Array.from(result.values()); + } + + /** + * Returns all items of the given type defined within this scope and its parents. + */ + public getItemsRecursive( + kind: ScopeItemKind, + // eslint-disable-next-line @typescript-eslint/no-explicit-any + acc: GenerativeEntity[] = [], + // eslint-disable-next-line @typescript-eslint/no-explicit-any + ): GenerativeEntity[] { + const currentItems = this.getItems(kind); + const accN = acc.concat(currentItems); + if (!this.isProgramScope() && this.parentScope) { + return this.parentScope.getItemsRecursive(kind, accN); + } else { + return accN; + } + } + + /** + * Recursively searches for functions or methods that return the specified type. + * @param kind The kind of callable to search for. + * @param returnTy The return type to match. + * @return An array of tuples containing the function/method names and their full signatures. + */ + public findFunction( + kind: "methodDecl" | "methodDef" | "functionDecl" | "functionDef", + returnTy: Type, + ): [string, Type][] { + const functions = this.getItemsRecursive(kind); + if (functions === undefined) { + return this.isProgramScope() + ? [] + : this.parentScope!.findFunction(kind, returnTy); + } + return Array.from(functions.values()).reduce<[string, Type][]>( + (acc, entry) => { + if ( + entry.type.kind === "function" && + getReturnType(entry.type) === returnTy + ) { + acc.push([entry.name?.text!, entry.type]); + } + return acc; + }, + [], + ); + } + + /** + * Checks if the given scope defines an identifier. + */ + public has(kind: ScopeItemKind, name: string): boolean { + return ( + this.map.has(kind) && + Array.from(this.map.get(kind)!).find( + ([_id, entry]) => entry.name?.text === name, + ) !== undefined + ); + } + + /** + * Checks if the given scope or its parents define an identifier. + */ + public hasRecursive(kind: ScopeItemKind, name: string): boolean { + if (this.has(kind, name)) { + return true; + } else if (this.isProgramScope()) { + return false; + } else { + return this.parentScope!.hasRecursive(kind, name); + } + } + + /** + * Looks for a parent scope with one of the given kinds. + */ + public findParent(...kinds: ScopeKind[]): Scope | undefined { + if (kinds.find((kind) => this.kind === kind)) { + return this; + } else if (this.parentScope === undefined) { + return undefined; + } else if ( + kinds.find((kind) => this.parentScope && this.parentScope.kind === kind) + ) { + return this.parentScope; + } else { + return this.parentScope.findParent(...kinds); + } + } + + /** + * Returns true if the given scope has one or more ancestors with the given kind. + */ + public hasParent(...kinds: ScopeKind[]): boolean { + return this.findParent(...kinds) !== undefined; + } + + /** + * Returns true if the given scope is defined inside one of the given kinds. + */ + public definedIn(...kinds: ScopeKind[]): boolean { + return kinds.find((k) => this.kind == k) !== undefined; + } +} diff --git a/fuzzer/src/stdlib.ts b/fuzzer/src/stdlib.ts new file mode 100644 index 0000000000..f49f230ff0 --- /dev/null +++ b/fuzzer/src/stdlib.ts @@ -0,0 +1,33 @@ +import { AstTypeDecl } from "../../src/ast/ast"; +import { nextId } from "./id"; + +import * as path from "path"; +import files from "../../src/stdlib/stdlib"; +import { createVirtualFileSystem } from "../../src/vfs/createVirtualFileSystem"; +import { generateAstIdFromName } from "./util"; +import { dummySrcInfo } from "../../src/grammar/"; + +const StdlibFilePath = path.join(__dirname, "..", "..", "tact", "stdlib"); +const StdlibVFS = createVirtualFileSystem(StdlibFilePath, files); +export const StdlibPath = StdlibVFS.resolve("stdlib.fc"); +export const StdlibCode = StdlibVFS.readFile(StdlibPath).toString(); +export const StdlibExPath = StdlibVFS.resolve("stdlib_ex.fc"); +export const StdlibExCode = StdlibVFS.readFile(StdlibExPath).toString(); + +/** + * Returns traits defined in stdlib. + * TODO: We should parse its sources instead + */ +export function getStdlibTraits(): AstTypeDecl[] { + return [ + { + kind: "trait", + id: nextId(), + name: generateAstIdFromName("BaseTrait"), + traits: [], + attributes: [], + declarations: [], + loc: dummySrcInfo, + }, + ]; +} diff --git a/fuzzer/src/types.ts b/fuzzer/src/types.ts new file mode 100644 index 0000000000..d191bb10f9 --- /dev/null +++ b/fuzzer/src/types.ts @@ -0,0 +1,451 @@ +import { + AstPrimitiveTypeDecl, + AstType, + AstExpression, + AstTypeId, + AstTypeDecl, +} from "../../src/ast/ast"; +import { + createSample, + generateName, + randomInt, + randomBool, + generateAstIdFromName, +} from "./util"; +import { Scope } from "./scope"; +import { TypeRef } from "../../src/types/types"; +import JSONbig from "json-bigint"; + +import { nextId } from "./id"; +import fc from "fast-check"; +import { dummySrcInfo } from "../../src/grammar/"; + +/** + * Types from Tact stdlib. + */ +export enum StdlibType { + Int = "Int", + Bool = "Bool", + Builder = "Builder", + Slice = "Slice", + Cell = "Cell", + Address = "Address", + String = "String", + StringBuilder = "StringBuilder", +} + +/** User-defined maps. */ +export type MapType = { + key: Type; + value: Type; +}; + +/** A single struct or message field. */ +export type StructField = { + name: string; + type: Type; + default?: fc.Arbitrary; +}; + +/** Utility types used internally in the generator. */ +export enum UtilType { + Contract = "Contract", + Trait = "Trait", + Program = "Program", + This = "This", + /** + * Functional Unit type that refers to the `void` type in languages like C++. + * Typically used when returning nothing from functions/methods or in imperative + * constructions which only mutate the state. + */ + Unit = "Unit", +} + +/** + * Represents the signature of a function in a format typical for functional languages, such as Int -> Int -> Int. + * The last element of the list means the return type, previous elements are types of the arguments. + */ +export type FunctionType = { + kind: "function"; + signature: Type[]; +}; + +export type Type = + | { + kind: "stdlib"; + type: StdlibType; + } + | { + kind: "map"; + type: MapType; + } + | { + kind: "struct"; + name: string; + fields: StructField[]; + } + | { + kind: "message"; + name: string; + fields: StructField[]; + } + | { + kind: "util"; + type: UtilType; + } + | FunctionType; + +// eslint-disable-next-line @typescript-eslint/no-explicit-any +export function throwTyError(ty: any): never { + throw new Error(`Unsupported type: ${JSONbig.stringify(ty)}`); +} + +export function tyToString(ty: Type): string { + switch (ty.kind) { + case "stdlib": + return `${ty.type}`; + case "struct": + case "message": + return `${ty.name}`; + case "map": + return `map<${tyToString(ty.type.key)}, ${tyToString(ty.type.value)}>`; + default: + throwTyError(ty); + } +} + +export function tyEq(lhs: Type, rhs: Type): boolean { + return tyToString(lhs) === tyToString(rhs); +} + +/** + * A subset of supported Stdlib types that might be used in AST generation. + */ +export const SUPPORTED_STDLIB_TYPES: StdlibType[] = [ + StdlibType.String, + StdlibType.Bool, + StdlibType.Int, +]; + +namespace make { + export function PrimitiveType(name: string): AstPrimitiveTypeDecl { + const kind = "primitive_type_decl"; + return { + kind, + id: nextId(), + name: generateAstIdFromName(name), + loc: dummySrcInfo, + }; + } + export function ASTTypeRef(name: string): AstTypeId { + return { + kind: "type_id", + id: nextId(), + text: name, + loc: dummySrcInfo, + }; + } + export function TypeRef(name: string): TypeRef { + return { + kind: "ref", + name, + optional: false, + }; + } +} + +/** + * Cache for Stdlib types. + */ +const StdlibTypeCache = new Map(); +Object.values(StdlibType).forEach((ty) => { + StdlibTypeCache.set(ty, [ + transformTy(ty, make.PrimitiveType), + transformTy(ty, make.ASTTypeRef), + transformTy(ty, make.TypeRef), + ]); +}); + +/** + * Creates a Tact type entry from the given tact-check type defintion. + */ +function transformTy(ty: StdlibType, transform: (type: StdlibType) => T): T { + if (!Object.values(StdlibType).includes(ty)) { + throwTyError(ty); + } + return transform(ty); +} +export function tyToAstTypeDecl(ty: Type): AstTypeDecl { + switch (ty.kind) { + case "stdlib": { + const result = StdlibTypeCache.get(ty.type); + if (!result) { + throwTyError(ty); + } + return result[0]; + } + default: + throwTyError(ty); + } +} +export function tyToAstType(ty: Type, isBounced = false): AstType { + let generateAstTypeId = (text: string) => + { + kind: "type_id", + text, + id: nextId(), + loc: dummySrcInfo, + }; + + switch (ty.kind) { + case "stdlib": { + const result = StdlibTypeCache.get(ty.type); + if (!result) { + throwTyError(ty); + } + return result[1]; + } + case "struct": + case "message": + const simpleType: AstTypeId = { + kind: "type_id", + text: ty.name, + id: nextId(), + loc: dummySrcInfo, + }; + return isBounced + ? { + kind: "bounced_message_type", + messageType: simpleType, + id: nextId(), + loc: dummySrcInfo, + } + : simpleType; + case "map": + return { + kind: "map_type", + id: nextId(), + keyType: generateAstTypeId(tyToString(ty.type.key)), + keyStorageType: undefined, + valueType: generateAstTypeId(tyToString(ty.type.value)), + valueStorageType: undefined, + loc: dummySrcInfo, + }; + default: + throwTyError(ty); + } +} + +export function tyToTypeRef(ty: Type): TypeRef { + switch (ty.kind) { + case "stdlib": { + const result = StdlibTypeCache.get(ty.type); + if (!result) { + throwTyError(ty); + } + return result[2]; + } + default: + throwTyError(ty); + } +} + +/** + * Retrieves a return type from the function type. + */ +export function getReturnType(ty: FunctionType): Type { + if (ty.signature.length === 0) { + throw new Error("Empty function signature"); + } + return ty.signature[ty.signature.length - 1]; +} + +/** + * Returns mock AST entries for types defined in standard library. + */ +export function getStdlibTypes(): AstTypeDecl[] { + return [...Object.values(StdlibType)].map((type) => make.PrimitiveType(type)); +} + +/** + * An utility class used to generate internal tact-check types. + */ +export class TypeGen { + private constructor(private scope: Scope) {} + + public static fromScope(scope: Scope): TypeGen { + return new TypeGen(scope); + } + + /** Arbitrary that generates stdlib types. */ + public stdlibArbitrary: fc.Arbitrary = fc.record({ + kind: fc.constant("stdlib"), + type: fc.constantFrom(...SUPPORTED_STDLIB_TYPES), + }); + + /** Arbitrary that generates map types. */ + public mapArbitrary: fc.Arbitrary = fc.record({ + kind: fc.constant("map"), + type: fc.record({ + key: fc.record({ + kind: fc.constant("stdlib"), + type: fc.constantFrom( + // TODO: Support Address + StdlibType.Int, + ), + }) as fc.Arbitrary, + value: fc.record({ + kind: fc.constant("stdlib"), + type: fc.constantFrom( + // TODO: Support Address, Cell, Struct, Message + StdlibType.Int, + StdlibType.Bool, + ), + }) as fc.Arbitrary, + }), + }); + + /** + * Picks an arbitrary type available within the scope. + * This doesn't generate new type definitions. + */ + public pick(): Type { + const arb = fc.oneof( + this.stdlibArbitrary, + // this.mapArbitrary, + // ...this.getStructs(), + ); + return createSample(arb); + } + + /** + * Generates any of the supported types. + */ + public generate(): fc.Arbitrary { + return fc.oneof( + this.stdlibArbitrary, + this.generateFun(), + this.generateStruct(randomBool()), + ); + } + + /** + * Generates an arbitrary function signature. + */ + public generateFun(minLength = 1, maxLength = 3): fc.Arbitrary { + const structs = this.getStructs(); + return fc.record({ + kind: fc.constant("function"), + signature: fc.array( + fc.oneof(this.stdlibArbitrary, this.mapArbitrary, ...structs), + { + minLength, + maxLength, + }, + ), + }); + } + + /** + * Generates an arbitrary method signature that always starts with `this`. + */ + public generateMethod(): fc.Arbitrary { + return this.generateFun().map((funType) => ({ + kind: "function", + signature: [{ kind: "util", type: UtilType.This }, ...funType.signature], + })); + } + + /** + * Generates an arbitrary struct or message signature. + */ + public generateStruct(isMessage: boolean): fc.Arbitrary { + const kind = isMessage ? "message" : "struct"; + const structName = createSample( + generateName(this.scope, kind, /*shadowing=*/ true, /*isType=*/ true), + ); + + // NOTE: It doesn't support nested structs/messages as they are not + const fields = fc + .array( + fc.record({ + name: generateName(this.scope, kind), // TODO: kind in arguments doesn't makes sense here, change generateName signature so you can pass nothing in this argument + type: this.stdlibArbitrary, + default: fc.constantFrom(undefined), + }), + { minLength: 1, maxLength: 4 }, + ) + .filter((generatedFields) => + generatedFields.every( + (item, index) => generatedFields.indexOf(item) === index, + ), + ); + if (isMessage) { + return fc.record({ + kind: fc.constant("message"), + name: fc.constant(structName), + fields: fields, + }); + } else { + return fc.record({ + kind: fc.constant("struct"), + name: fc.constant(structName), + fields: fields, + }); + } + } + + /** + * Returns arbitraries to generate structs available in the program scope. + */ + private getStructs(): fc.Arbitrary[] { + const structs = this.scope.getItemsRecursive("struct"); + if (structs.length === 0) { + return []; + } + return structs.map((s) => fc.constantFrom(s.type)); + } +} + +/** + * Creates an arbitrary function or method signature that returns the given type. + */ +export function makeFunctionTy( + kind: "function" | "method", + returnTy: Type, + minArgs = 1, + maxArgs = 3, +): FunctionType { + const argsLength = randomInt(minArgs, maxArgs); + const thisArg: Type[] = + kind === "method" ? [{ kind: "util", type: UtilType.This }] : []; + const args: Type[] = Array.from({ length: argsLength }, () => { + const idx = randomInt(0, SUPPORTED_STDLIB_TYPES.length - 1); + return { kind: "stdlib", type: SUPPORTED_STDLIB_TYPES[idx] }; + }); + return { kind: "function", signature: [...thisArg, ...args, returnTy] }; +} + +export function isUnit(ty: Type): boolean { + return ty.kind === "util" && ty.type === "Unit"; +} + +export function isThis(ty: Type): boolean { + return ty.kind === "util" && ty.type === "This"; +} + +/** + * An heuristic that replicates the `resolvePartialFields` logic in the compiler in order to + * detect if the message ough to be wrapped in `bounced<>`. + */ +export function isBouncedMessage(ty: Type): boolean { + if (ty.kind !== "message") { + throwTyError(ty); + } + for (const f of ty.fields) { + if (!(f.type.kind === "stdlib" && f.type.type === StdlibType.Bool)) { + return true; // too big; must be wrapped + } + } + return false; +} diff --git a/fuzzer/src/util.ts b/fuzzer/src/util.ts new file mode 100644 index 0000000000..40aabe531d --- /dev/null +++ b/fuzzer/src/util.ts @@ -0,0 +1,237 @@ +import os from "os"; +import { createNodeFileSystem } from "../../src/vfs/createNodeFileSystem"; +import { VirtualFileSystem } from "../../src/vfs/VirtualFileSystem"; +import { mkdtemp } from "fs/promises"; +import fs from "fs/promises"; +import * as path from "path"; +import fc from "fast-check"; + +import { Scope, ScopeItemKind } from "./scope"; +import { GlobalContext } from "./context"; +import { Type } from "./types"; +import { AstId, AstNode } from "../../src/ast/ast"; +import { dummySrcInfo } from "../../src/grammar/"; +import { nextId } from "./id"; + +export const VALID_ID = /^[a-zA-Z_]+[a-zA-Z_0-9]$/; +export const VALID_TYPE_ID = /^[A-Z]+[a-zA-Z_0-9]$/; + +/** + * Creates a temp node file system to use inside a property. + */ +export async function withNodeFS(f: (vfs: VirtualFileSystem) => Promise) { + const tempDir = await mkdtemp( + path.join(GlobalContext.config.compileDir, "tact-check-"), + ); + const vfs = createNodeFileSystem(tempDir, false); + try { + await f(vfs); + } finally { + if (GlobalContext.config.compileDir == os.tmpdir()) { + await fs.rm(tempDir, { recursive: true }); + } + } +} + +/** + * Creates a new property that executes additional logic implemented in tact-check. + */ +export function createProperty( + ...args: [ + ...arbitraries: { [K in keyof Ts]: fc.Arbitrary }, + predicate: (...args: Ts) => boolean | void, + ] +): fc.IPropertyWithHooks { + const arbitraries = args.slice(0, -1) as unknown as { + [K in keyof Ts]: fc.Arbitrary; + }; + const originalPredicate = args[args.length - 1] as ( + ...args: Ts + ) => boolean | void; + const enhancedPredicate = (...args: Ts): boolean | void => { + args.forEach((arg) => GlobalContext.printSample(arg as AstNode)); + return originalPredicate(...args); + }; + return fc.property(...arbitraries, enhancedPredicate); +} + +/** + * Create parameters for custom property checking. + */ +function makeParams(numRuns: number | undefined): fc.Parameters { + return { + numRuns: numRuns ? numRuns : GlobalContext.config.numRuns, + seed: GlobalContext.config.seed, + reporter(out) { + if (out.failed) { + if ( + out.counterexample !== null && + out.counterexample !== undefined && + out.error !== null && + out.error !== undefined + ) { + // eslint-disable-next-line @typescript-eslint/no-explicit-any + let generated: any = out.counterexample; + if (!generated.kind && generated[0] && generated[0].kind) { + generated = generated[0]; + } + out.error += `\n-----\nGenerated program:\n${GlobalContext.format(generated)}\n-----\n`; + } + throw new Error(fc.defaultReportMessage(out)); + } + }, + }; +} + +/** + * Checks the given property enhancing `fc.assert` with additional functionality. + */ +export function checkProperty( + property: fc.IPropertyWithHooks, + numRuns: number | undefined = undefined, +) { + fc.assert(property, makeParams(numRuns)); +} + +/** + * Checks the given async property enhancing `fc.assert` with additional functionality. + */ +export async function checkAsyncProperty( + property: fc.IAsyncPropertyWithHooks, + numRuns: number | undefined = undefined, +) { + await fc.assert(property, makeParams(numRuns)); +} + +/** + * Creates a single fast-check sample with respect to the current global configuration. + * @param gen The arbitrary generator used to create the sample. + * @throws If the arbitrary cannot generate any elements. + */ +export function createSample(gen: fc.Arbitrary): T { + return fc.sample(gen, { + seed: GlobalContext.config.seed, + numRuns: 1, + })[0]; +} + +/** + * Generates an array of items using the provided generator function, with a length determined by a sampled range. + * @param fn The generator function to create items. + * @param minLength The minimum length of the array. + * @param maxLength The maximum length of the array. + * @returns An array of generated items. + */ +export function createSamplesArray( + fn: () => T, + minLength: number, + maxLength: number, +): T[] { + const length = createSample(fc.integer({ min: minLength, max: maxLength })); + return Array.from({ length }, () => fn()); +} + +/** + * Generates a new valid identifier with a name unique within the current scope and with unique id. + * @param shadowing Allow shadowing (using names available in parent scopes) + */ +export function generateName( + scope: Scope, + kind: ScopeItemKind, + shadowing: boolean = true, + isType: boolean = false, +): fc.Arbitrary { + const availableNames = shadowing + ? scope.getEntries(kind) + : scope.getEntriesRecursive(kind); + + return fc + .stringMatching(isType ? VALID_TYPE_ID : VALID_ID) + .filter((generatedName) => { + if (availableNames.find(([name, _]) => name == generatedName)) { + return false; + } + return true; + }); +} + +/** + * Generates AstId from string name and with new id. + */ +export function generateAstIdFromName(name: string): AstId { + return { + kind: "id", + text: name, + id: nextId(), + loc: dummySrcInfo, + }; +} + +/** + * Generates AstId. + * @param scope Current scope, from which AstId.text will be generated. + * @param kind Entity for which AstId is generated. + * @param shadowing Allow shadowing (using names available in parent scopes) + */ +export function generateAstId( + scope: Scope, + kind: ScopeItemKind, + shadowing: boolean = true, + isType: boolean = false, +): fc.Arbitrary { + return fc.record({ + kind: fc.constant("id"), + text: generateName(scope, kind, shadowing, isType), + id: fc.constant(nextId()), + loc: fc.constant(dummySrcInfo), + }); +} + +/** + * Chooses an arbitrary identifier available in the current scope. + * @returns Chosen identifier or `undefined` if there are no identifiers available with the given kind/type. + */ +export function choose( + scope: Scope, + kind: ScopeItemKind, + ty: Type, +): string | undefined { + const availableNames = scope.getNamesRecursive(kind, ty); + if (availableNames.length === 0) { + return undefined; + } + return createSample(fc.constantFrom(...availableNames)); +} + +/** + * Randomly chooses a boolean value using wrt to SEED. + */ +export function randomBool(): boolean { + return createSample(fc.boolean()); +} + +/** + * Randomly chooses an integer value using wrt to SEED. + */ +export function randomInt(min: number, max: number): number { + return createSample(fc.integer({ min, max })); +} + +/** + * Chooses a random list element wrt to SEED. + */ +export function randomElement(list: T[]): T { + if (list.length === 0) { + throw new Error("Empty list"); + } + if (list.length === 1) { + return list[0]; + } + return list[randomInt(1, list.length - 1)]; +} + +export function packArbitraries( + arbs?: fc.Arbitrary[], +): fc.Arbitrary { + return arbs ? fc.tuple(...(arbs as [fc.Arbitrary])) : fc.constant([]); +} diff --git a/fuzzer/test/compilation.spec.ts b/fuzzer/test/compilation.spec.ts new file mode 100644 index 0000000000..d1c4ad7d06 --- /dev/null +++ b/fuzzer/test/compilation.spec.ts @@ -0,0 +1,123 @@ +import { funcCompile } from "../../src/func/funcCompile"; +import { posixNormalize } from "../../src/utils/filePath"; +import { AstModule, AstContract } from "../../src/ast/ast"; +import { writeFileSync } from "fs"; +import * as path from "path"; +import fc from "fast-check"; + +import { Program } from "../src/generators"; +import { StdlibCode, StdlibPath } from "../src/stdlib"; +import { withNodeFS, checkAsyncProperty } from "../src/util"; +import { + compile, + precompile, + createContext, + enableFeatures, +} from "./testUtils"; +import { GlobalContext } from "../src/context"; + +function getContract(program: AstModule): AstContract | undefined { + for (const entry of program.items) { + if (entry.kind === "contract") { + return entry; + } + } + return undefined; +} + +async function compileProgram(program: AstModule) { + await withNodeFS(async (vfs) => { + let ctx = createContext(program); + ctx = enableFeatures(ctx, "external"); + ctx = precompile(ctx); + const compilationOutput = vfs.root; + + const contract = getContract(program)!; + + // Save the generated contract to a file + const contractCode = GlobalContext.format(contract, "ast"); + writeFileSync(path.join(compilationOutput, "contract.tact"), contractCode); + + // Compile contracts to FunC + const res = await compile(ctx, contract.name.text); + for (const files of res.output.files) { + const ffc = vfs.resolve(compilationOutput, files.name); + vfs.writeFile(ffc, files.code); + } + + // Process compilation output + const codeFc = res.output.files.map((v) => ({ + path: posixNormalize(vfs.resolve(compilationOutput, v.name)), + content: v.code, + })); + const codeEntrypoint = res.output.entrypoint; + + // Compile the resulted FunC code + // NOTE: We intentionally disabled stdlibEx, since the generated + // contracts currently don't use it. + const c = await funcCompile({ + entries: [ + StdlibPath, + // stdlibExPath, + posixNormalize(vfs.resolve(compilationOutput, codeEntrypoint)), + ], + sources: [ + { path: StdlibPath, content: StdlibCode }, + // { + // path: stdlibExPath, + // content: stdlibExCode, + // }, + ...codeFc, + ], + logger: { + info: (_) => {}, + debug: (_) => {}, + warn: (_) => {}, + error: (_) => {}, + }, + }); + try { + expect(c.ok).toBeTruthy(); + } catch (error) { + throw new Error(`FunC compilation failed:\n${c.log}`); + } + + GlobalContext.resetDepth(); + }); +} + +describe("properties", () => { + it( + "compiles contracts", + async () => { + // The generated AST is compiled once on compilation tests. + // This approach is used to speed-up testing, since non-structural changes + // are not significant for this case. + // + // Instead, the original NUM_RUNS option is used to generate the requested number of + // programs with a different structure. + const numRuns = GlobalContext.config.numRuns; + + const compileAndCheckProperty = async () => { + const property = fc.asyncProperty( + new Program({ addStdlib: true }).generate(), + compileProgram, + ); + await checkAsyncProperty(property, /*numRuns=*/ 1); + }; + + if (numRuns === Infinity) { + while (true) { + await compileAndCheckProperty(); + } + } else { + await Promise.all( + Array.from({ length: numRuns }).map(async () => { + await compileAndCheckProperty(); + }), + ); + } + }, + /*timeout_ms=*/ 60 * 60 * 1000 /*1hr*/, + ); +}); diff --git a/fuzzer/test/expression.spec.ts b/fuzzer/test/expression.spec.ts new file mode 100644 index 0000000000..29cd2f4454 --- /dev/null +++ b/fuzzer/test/expression.spec.ts @@ -0,0 +1,67 @@ +import { CompilerContext } from "../../src/context/context"; +import { + resolveExpression, + getExpType, +} from "../../src/types/resolveExpression"; +import { StatementContext } from "../../src/types/resolveStatements"; +import { TypeRef } from "../../src/types/types"; +import assert from "assert"; + +import { Expression, NonGenerativeExpressionParams } from "../src/generators"; +import { Scope } from "../src/scope"; +import { SUPPORTED_STDLIB_TYPES, Type } from "../src/types"; +import { createProperty, checkProperty } from "../src/util"; +import { dummySrcInfo } from "../../src/grammar/src-info"; + +function emptyContext(): StatementContext { + return { + root: dummySrcInfo, + returns: { kind: "void" }, + vars: new Map(), + requiredFields: [], + funName: null, + }; +} + +function setupContexts(): [CompilerContext, StatementContext] { + const ctx: CompilerContext = new CompilerContext(); + const sctx = emptyContext(); + return [ctx, sctx]; +} + +describe("properties", () => { + it("generates well-typed expressions", () => { + const results = setupContexts(); + let compilerCtx = results[0]; + const stmtCtx = results[1]; + const globalScope = new Scope("program", undefined); + for (const type of SUPPORTED_STDLIB_TYPES) { + const ty: Type = { kind: "stdlib", type }; + // NOTE: This test checks only pure expressions, without introducing new + // entries to any scopes. + const exprGen = new Expression( + globalScope, + ty, + NonGenerativeExpressionParams, + ).generate(); + const property = createProperty(exprGen, (expr) => { + compilerCtx = resolveExpression(expr, stmtCtx, compilerCtx); + const resolvedTy = getExpType(compilerCtx, expr); + if (ty.kind == "stdlib") { + if (resolvedTy.kind == "ref") { + assert.strictEqual( + resolvedTy.name, + ty.type, + `The resolved type ${resolvedTy.name} does not match the expected type ${ty}`, + ); + } else { + assert.fail(`Unexpected type: ${resolvedTy.kind}`); + } + } else { + assert.fail(`Unsupported expression type: ${ty}`); + } + }); + checkProperty(property); + } + }); +}); diff --git a/fuzzer/test/program.spec.ts b/fuzzer/test/program.spec.ts new file mode 100644 index 0000000000..4f1bf7babf --- /dev/null +++ b/fuzzer/test/program.spec.ts @@ -0,0 +1,59 @@ +import { Program } from "../src/generators"; +import assert from "assert"; + +import { precompile, createContext, enableFeatures } from "./testUtils"; +import { createProperty, checkProperty } from "../src/util"; +import { GlobalContext } from "../src/context"; + +describe("properties", () => { + it("generates well-typed programs", () => { + const property = createProperty( + new Program({ addStdlib: true }).generate(), + (program) => { + let ctx = createContext(program); + ctx = enableFeatures(ctx, "external"); + precompile(ctx); + GlobalContext.resetDepth(); + }, + ); + checkProperty(property); + }); + + it("generates reproducible AST", () => { + // Setting a fixed seed for reproducibility + const originalSeed = GlobalContext.config.seed; + GlobalContext.config.seed = 42; + + let program1: string | undefined; + let program2: string | undefined; + + // Create a single property that generates two programs + const property = createProperty(new Program().generate(), (program) => { + if (program1 === undefined) { + program1 = GlobalContext.format(program, "ast"); + } else { + program2 = GlobalContext.format(program, "ast"); + } + GlobalContext.resetDepth(); + }); + + // Execute property twice + checkProperty(property, /*numRuns=*/ 1); + checkProperty(property, /*numRuns=*/ 1); + + assert.notEqual( + program1, + undefined, + "First program should not be undefined", + ); + assert.notEqual( + program2, + undefined, + "Second program should not be undefined", + ); + assert.equal(program1, program2, "Both programs should be identical"); + + // Restore the original seed + GlobalContext.config.seed = originalSeed; + }); +}); diff --git a/fuzzer/test/testUtils.ts b/fuzzer/test/testUtils.ts new file mode 100644 index 0000000000..364642f8de --- /dev/null +++ b/fuzzer/test/testUtils.ts @@ -0,0 +1,65 @@ +import { CompilerContext } from "../../src/context/context"; +import { createABI } from "../../src/generator/createABI"; +import { writeProgram } from "../../src/generator/writeProgram"; +import { AstModule } from "../../src/ast/ast"; +import { openContext } from "../../src/context/store"; +import { resolveAllocations } from "../../src/storage/resolveAllocation"; +import { featureEnable } from "../../src/config/features"; +import { resolveDescriptors } from "../../src/types/resolveDescriptors"; +import { resolveSignatures } from "../../src/types/resolveSignatures"; +import { resolveStatements } from "../../src/types/resolveStatements"; +import { resolveErrors } from "../../src/types/resolveErrors"; +import { getAstFactory } from "../../src/ast/ast-helpers"; +import { getParser } from "../../src/grammar/grammar"; + +export function createContext(program: AstModule): CompilerContext { + let ctx = new CompilerContext(); + ctx = openContext( + ctx, + /*sources=*/ [], + /*funcSources=*/ [], + getParser(getAstFactory(), "new"), + [program], + ); + return ctx; +} + +/** + * Replicates the `precompile` pipeline. + */ +export function precompile(ctx: CompilerContext): CompilerContext { + const ast = getAstFactory(); + ctx = resolveDescriptors(ctx, ast); + ctx = resolveSignatures(ctx, ast); + ctx = resolveAllocations(ctx); + ctx = resolveStatements(ctx); + ctx = resolveErrors(ctx, ast); + return ctx; +} + +/** + * Enables compiler's features. + */ +export function enableFeatures( + ctx: CompilerContext, + ...features: ["inline" | "debug" | "masterchain" | "external"] +): CompilerContext { + return features.reduce((accCtx, feature) => { + return featureEnable(accCtx, feature); + }, ctx); +} + +/** + * Replicates the `compile` pipeline. + */ +export async function compile(ctx: CompilerContext, contractName: string) { + const abi = createABI(ctx, contractName); + const output = await writeProgram( + ctx, + abi, + `tact_check_${contractName}`, + {}, //ContractCodes + false, + ); + return { output, ctx }; +} From 86568f92a299b0a484d7671b6c6e24ebc2a21645 Mon Sep 17 00:00:00 2001 From: Mell0r Date: Sun, 9 Mar 2025 22:36:10 +0300 Subject: [PATCH 02/44] fix: receiver.ts rewritten, many small bugfixes --- fuzzer/src/formatter.ts | 6 +- fuzzer/src/generators/expression.ts | 1658 ++++++++++++++------------- fuzzer/src/generators/field.ts | 79 +- fuzzer/src/generators/receiver.ts | 239 ++-- fuzzer/src/stdlib.ts | 12 +- 5 files changed, 1055 insertions(+), 939 deletions(-) diff --git a/fuzzer/src/formatter.ts b/fuzzer/src/formatter.ts index 5fcd62adca..00c0fc68eb 100644 --- a/fuzzer/src/formatter.ts +++ b/fuzzer/src/formatter.ts @@ -92,7 +92,7 @@ class PrettyPrinter { const valueAlias = typeRef.valueStorageType ? ` as ${typeRef.valueStorageType}` : ""; - return `map<${typeRef.keyType}${keyAlias}, ${typeRef.valueType}${valueAlias}>`; + return `map<${typeRef.keyType.text}${keyAlias}, ${typeRef.valueType.text}${valueAlias}>`; } ppAstBouncedMessageType(type: AstBouncedMessageType): string { @@ -190,14 +190,14 @@ class PrettyPrinter { case "boolean": result = expr.value.toString(); break; - case "string": + case "simplified_string": result = `"${expr.value}"`; break; case "null": result = "null"; break; default: - throw new Error(`Unsupported expression type: ${expr}`); + throw new Error(`Unsupported expression type: ${expr.kind}`); } // Set parens when needed diff --git a/fuzzer/src/generators/expression.ts b/fuzzer/src/generators/expression.ts index ffc46aca5f..54698de1b0 100644 --- a/fuzzer/src/generators/expression.ts +++ b/fuzzer/src/generators/expression.ts @@ -1,18 +1,19 @@ import { - AstBoolean, - AstExpression, - AstId, - AstNull, - AstNumber, - AstOpBinary, - AstFieldAccess, - AstMethodCall, - AstStaticCall, - AstOpUnary, - AstSimplifiedString, - AstStructFieldInitializer, - AstStructInstance, - AstNumberBase, + AstBoolean, + AstExpression, + AstId, + AstNull, + AstNumber, + AstOpBinary, + AstFieldAccess, + AstMethodCall, + AstStaticCall, + AstOpUnary, + AstSimplifiedString, + AstStructFieldInitializer, + AstStructInstance, + AstNumberBase, + AstString, } from "../../../src/ast/ast"; import JSONbig from "json-bigint"; import fc from "fast-check"; @@ -21,22 +22,22 @@ import { ConstantDecl, ConstantDef } from "./constant"; import { Let, Statement } from "./statement"; import { Field } from "./field"; import { - randomBool, - randomElement, - packArbitraries, - generateAstIdFromName, + randomBool, + randomElement, + packArbitraries, + generateAstIdFromName, } from "../util"; import { GenerativeEntity, GenerativeEntityOpt } from "./generator"; import { nextId } from "../id"; import { - StdlibType, - tyToString, - tyEq, - UtilType, - Type, - throwTyError, - makeFunctionTy, - StructField, + StdlibType, + tyToString, + tyEq, + UtilType, + Type, + throwTyError, + makeFunctionTy, + StructField, } from "../types"; import { GlobalContext } from "../context"; import { Scope } from "../scope"; @@ -44,118 +45,135 @@ import { dummySrcInfo } from "../../../src/grammar/"; import { FunctionDef } from "./function"; export function generateNumber( //TODO: add random base generation or pass the needed one, where number is generated - base?: AstNumberBase, - constValue?: bigint, + base?: AstNumberBase, + constValue?: bigint, ): fc.Arbitrary { - const value = - constValue === undefined ? fc.bigInt() : fc.constantFrom(constValue); - return fc.record({ - kind: fc.constant("number"), - id: fc.constant(nextId()), - value, - loc: fc.constant(dummySrcInfo), - base: fc.constant(base ?? 10), - }); + const value = + constValue === undefined ? fc.bigInt() : fc.constantFrom(constValue); + return fc.record({ + kind: fc.constant("number"), + id: fc.constant(nextId()), + value, + loc: fc.constant(dummySrcInfo), + base: fc.constant(base ?? 10), + }); } export function generateBoolean( - constValue?: boolean, -): fc.Arbitrary { - const value = - constValue === undefined ? fc.boolean() : fc.constantFrom(constValue); - return fc.record({ - kind: fc.constant("boolean"), - id: fc.constant(nextId()), - value, - loc: fc.constant(dummySrcInfo), - }); + constValue?: boolean, +): fc.Arbitrary { + const value = + constValue === undefined ? fc.boolean() : fc.constantFrom(constValue); + return fc.record({ + kind: fc.constant("boolean"), + id: fc.constant(nextId()), + value, + loc: fc.constant(dummySrcInfo), + }); +} + +function generateStringValue( + nonEmpty: boolean = false, + constValue?: string, +): fc.Arbitrary { + return constValue === undefined + ? nonEmpty + ? fc.string({ minLength: 1 }) + : fc.string() + : fc.constantFrom(constValue); +} + +export function generateSimplifiedString( + nonEmpty: boolean = false, + constValue?: string, +): fc.Arbitrary { + return fc.record({ + kind: fc.constant("simplified_string"), + id: fc.constant(nextId()), + value: generateStringValue(nonEmpty, constValue), + loc: fc.constant(dummySrcInfo), + }); } export function generateString( - nonEmpty: boolean = false, - constValue?: string, -): fc.Arbitrary { - const value = - constValue === undefined - ? nonEmpty - ? fc.string({ minLength: 1 }) - : fc.string() - : fc.constantFrom(constValue); - return fc.record({ - kind: fc.constant("simplified_string"), - id: fc.constant(nextId()), - value, - loc: fc.constant(dummySrcInfo), - }); + nonEmpty: boolean = false, + constValue?: string, +): fc.Arbitrary { + return fc.record({ + kind: fc.constant("string"), + id: fc.constant(nextId()), + value: generateStringValue(nonEmpty, constValue), + loc: fc.constant(dummySrcInfo), + }); } -export function generateNull(): fc.Arbitrary { - return fc.record({ - kind: fc.constant("null"), - id: fc.constant(nextId()), - loc: fc.constant(dummySrcInfo), - }); +export function generateNull(): fc.Arbitrary { + return fc.record({ + kind: fc.constant("null"), + id: fc.constant(nextId()), + loc: fc.constant(dummySrcInfo), + }); } export function generateFieldAccess( - name: string, - aggregate?: AstExpression, + name: string, + aggregate?: AstExpression, ): AstFieldAccess { - return { - kind: "field_access", - aggregate: aggregate ?? generateThisID(), - field: generateAstIdFromName(name), - id: nextId(), - loc: dummySrcInfo, - }; + return { + kind: "field_access", + aggregate: aggregate ?? generateThisID(), + field: generateAstIdFromName(name), + id: nextId(), + loc: dummySrcInfo, + }; } export function generateThisID(): AstId { - return { kind: "id", id: nextId(), text: "self", loc: dummySrcInfo }; + return { kind: "id", id: nextId(), text: "self", loc: dummySrcInfo }; } /** * Generates an value that could be assigned to any variable with the `Map` type. */ export function generateMapInit( - ty: Type, - scope: Scope, + ty: Type, + scope: Scope, ): fc.Arbitrary { - if (scope.definedIn("block", "method", "function") && randomBool()) { - return new StaticCall(ty, "emptyMap", []).generate(); - } else { - return generateNull(); - } + if (scope.definedIn("block", "method", "function") && randomBool()) { + return new StaticCall(ty, "emptyMap", []).generate(); + } else { + return generateNull(); + } } /** * Generates an value that could be assigned to a struct instance. */ export function generateStructInit( - ty: Type, - scope: Scope, -): fc.Arbitrary { - if (ty.kind !== "struct" && ty.kind !== "message") { - throwTyError(ty); - } - const args: fc.Arbitrary[] = ty.fields.map( - (field: StructField) => { - return fc.record({ - kind: fc.constant("struct_field_initializer"), - id: fc.constant(nextId()), - field: fc.constant(generateAstIdFromName(field.name)), - initializer: new Expression(scope, field.type).generate(), + ty: Type, + scope: Scope, +): fc.Arbitrary { + if (ty.kind !== "struct" && ty.kind !== "message") { + throwTyError(ty); + } + const args: fc.Arbitrary[] = ty.fields.map( + (field: StructField) => { + return fc.record({ + kind: fc.constant("struct_field_initializer"), + id: fc.constant(nextId()), + field: fc.constant(generateAstIdFromName(field.name)), + initializer: new Expression(scope, field.type).generate(), + loc: fc.constant(dummySrcInfo), + }); + }, + ); + return fc.record({ + kind: fc.constantFrom("struct_instance"), + id: fc.constantFrom(nextId()), + type: fc.constantFrom(generateAstIdFromName(tyToString(ty))), + args: packArbitraries(args), loc: fc.constant(dummySrcInfo), - }); - }, - ); - return fc.record({ - kind: fc.constantFrom("struct_instance"), - id: fc.constantFrom(nextId()), - type: fc.constantFrom(generateAstIdFromName(tyToString(ty))), - args: packArbitraries(args), - loc: fc.constant(dummySrcInfo), - }); + }); } /** @@ -164,18 +182,20 @@ export function generateStructInit( * @param funScope Scope of the function. */ export function generateFunctionCallArgs( - funTy: Type, - funScope: Scope, + funTy: Type, + funScope: Scope, ): fc.Arbitrary[] { - if (funTy.kind !== "function") { - throw new Error(`Incorrect type for function: ${JSONbig.stringify(funTy)}`); - } - if (funTy.signature.length === 1) { - return []; - } - return funTy.signature - .slice(0, -1) - .map((argTy) => new Expression(funScope, argTy).generate()); + if (funTy.kind !== "function") { + throw new Error( + `Incorrect type for function: ${JSONbig.stringify(funTy)}`, + ); + } + if (funTy.signature.length === 1) { + return []; + } + return funTy.signature + .slice(0, -1) + .map((argTy) => new Expression(funScope, argTy).generate()); } /** @@ -184,176 +204,176 @@ export function generateFunctionCallArgs( * @param methodScope Scope of the method. */ export function generateMethodCallArgs( - methodTy: Type, - methodScope: Scope, + methodTy: Type, + methodScope: Scope, ): fc.Arbitrary[] { - if (methodTy.kind !== "function") { - throw new Error( - `Incorrect type for method: ${JSONbig.stringify(methodTy)}`, - ); - } - if (methodTy.signature.length === 2) { - return []; - } - return methodTy.signature - .slice(1, -1) - .map((argTy) => new Expression(methodScope, argTy).generate()); + if (methodTy.kind !== "function") { + throw new Error( + `Incorrect type for method: ${JSONbig.stringify(methodTy)}`, + ); + } + if (methodTy.signature.length === 2) { + return []; + } + return methodTy.signature + .slice(1, -1) + .map((argTy) => new Expression(methodScope, argTy).generate()); } /** * Generates field and contract constants access operations. */ -export class FieldAccess extends GenerativeEntity { - constructor( - type: Type, - fieldName: string, - private src?: AstId, - ) { - super(type, generateAstIdFromName(fieldName)); - } - - generate(): fc.Arbitrary { - return fc.record({ - kind: fc.constant("field_access"), - aggregate: fc.constant(this.src ? this.src : generateThisID()), - field: fc.constant(this.name!), - id: fc.constant(this.idx), - loc: fc.constant(dummySrcInfo), - }); - } +export class FieldAccess extends GenerativeEntity { + constructor( + type: Type, + fieldName: string, + private src?: AstId, + ) { + super(type, generateAstIdFromName(fieldName)); + } + + generate(): fc.Arbitrary { + return fc.record({ + kind: fc.constant("field_access"), + aggregate: fc.constant(this.src ? this.src : generateThisID()), + field: fc.constant(this.name!), + id: fc.constant(this.idx), + loc: fc.constant(dummySrcInfo), + }); + } } /** * Generates method calls. */ -export class MethodCall extends GenerativeEntity { - constructor( - type: Type, - name: string, - private src: AstExpression, - private args?: fc.Arbitrary[], - ) { - super(type, generateAstIdFromName(name)); - } - generate(): fc.Arbitrary { - return fc.record({ - kind: fc.constant("method_call"), - self: fc.constant(this.src), - method: fc.constant(this.name!), - args: packArbitraries(this.args), - id: fc.constant(this.idx), - loc: fc.constant(dummySrcInfo), - }); - } +export class MethodCall extends GenerativeEntity { + constructor( + type: Type, + name: string, + private src: AstExpression, + private args?: fc.Arbitrary[], + ) { + super(type, generateAstIdFromName(name)); + } + generate(): fc.Arbitrary { + return fc.record({ + kind: fc.constant("method_call"), + self: fc.constant(this.src), + method: fc.constant(this.name!), + args: packArbitraries(this.args), + id: fc.constant(this.idx), + loc: fc.constant(dummySrcInfo), + }); + } } /** * Generates free function calls. */ -export class StaticCall extends GenerativeEntity { - constructor( - type: Type, - name: string, - private args?: fc.Arbitrary[], - ) { - super(type, generateAstIdFromName(name)); - } - generate(): fc.Arbitrary { - return fc.record({ - kind: fc.constant("static_call"), - function: fc.constantFrom(this.name!), - args: packArbitraries(this.args), - id: fc.constant(this.idx), - loc: fc.constant(dummySrcInfo), - }); - } +export class StaticCall extends GenerativeEntity { + constructor( + type: Type, + name: string, + private args?: fc.Arbitrary[], + ) { + super(type, generateAstIdFromName(name)); + } + generate(): fc.Arbitrary { + return fc.record({ + kind: fc.constant("static_call"), + function: fc.constantFrom(this.name!), + args: packArbitraries(this.args), + id: fc.constant(this.idx), + loc: fc.constant(dummySrcInfo), + }); + } } export namespace OpUnary { - function generate( - args: fc.Arbitrary[], - allowedOps: readonly AstOpUnary["op"][], - ): fc.Arbitrary { - return fc.letrec((tie) => ({ - astExpression: fc.oneof( - { maxDepth: 1 }, - ...args.map((gen) => ({ arbitrary: gen, weight: 1 })), - { - arbitrary: tie("astOpUnary"), - weight: 1, - }, - ), - astOpUnary: fc.record({ - kind: fc.constant("op_unary"), - id: fc.constant(nextId()), - op: fc.constantFrom(...allowedOps), - loc: fc.constant(dummySrcInfo), - operand: tie("astExpression") as fc.Arbitrary, - }), - })).astOpUnary; - } + function generate( + args: fc.Arbitrary[], + allowedOps: readonly AstOpUnary["op"][], + ): fc.Arbitrary { + return fc.letrec((tie) => ({ + astExpression: fc.oneof( + { maxDepth: 1 }, + ...args.map((gen) => ({ arbitrary: gen, weight: 1 })), + { + arbitrary: tie("astOpUnary"), + weight: 1, + }, + ), + astOpUnary: fc.record({ + kind: fc.constant("op_unary"), + id: fc.constant(nextId()), + op: fc.constantFrom(...allowedOps), + loc: fc.constant(dummySrcInfo), + operand: tie("astExpression") as fc.Arbitrary, + }), + })).astOpUnary; + } - // Generates numeric expressions - // num -> num - export const Num = generate([generateNumber()], ["+", "-"]); + // Generates numeric expressions + // num -> num + export const Num = generate([generateNumber()], ["+", "-"]); - // Generates boolean expressions - // bool -> bool - export const Bool = generate([generateBoolean()], ["!"]); + // Generates boolean expressions + // bool -> bool + export const Bool = generate([generateBoolean()], ["!"]); - // TODO: Handle optionals (`!!`) + // TODO: Handle optionals (`!!`) } export namespace OpBinary { - export function generate( - args: fc.Arbitrary[], - allowedOps: readonly AstOpBinary["op"][], - ): fc.Arbitrary { - return fc.letrec((tie) => ({ - astExpression: fc.oneof( - { maxDepth: 1 }, - ...args.map((gen) => ({ arbitrary: gen, weight: 1 })), - { - arbitrary: tie("astOpBinary"), - weight: 1, - }, - ), - astOpBinary: fc.record({ - kind: fc.constant("op_binary"), - id: fc.constant(nextId()), - op: fc.constantFrom(...allowedOps), - left: tie("astExpression") as fc.Arbitrary, - right: tie("astExpression") as fc.Arbitrary, - loc: fc.constant(dummySrcInfo), - }), - })).astOpBinary; - } - - // num -> num -> num - export const NumOps: AstOpBinary["op"][] = [ - "+", - "-", - "*", - "/", - "%", - "<<", - ">>", - "&", - "|", - ]; - export const NumGens = [generateNumber(), OpUnary.Num]; - - // bool -> bool -> bool - export const BoolOps: AstOpBinary["op"][] = ["&&", "||"]; - export const BoolGens = [ - generateBoolean(), - OpUnary.Bool, + export function generate( + args: fc.Arbitrary[], + allowedOps: readonly AstOpBinary["op"][], + ): fc.Arbitrary { + return fc.letrec((tie) => ({ + astExpression: fc.oneof( + { maxDepth: 1 }, + ...args.map((gen) => ({ arbitrary: gen, weight: 1 })), + { + arbitrary: tie("astOpBinary"), + weight: 1, + }, + ), + astOpBinary: fc.record({ + kind: fc.constant("op_binary"), + id: fc.constant(nextId()), + op: fc.constantFrom(...allowedOps), + left: tie("astExpression") as fc.Arbitrary, + right: tie("astExpression") as fc.Arbitrary, + loc: fc.constant(dummySrcInfo), + }), + })).astOpBinary; + } + + // num -> num -> num + export const NumOps: AstOpBinary["op"][] = [ + "+", + "-", + "*", + "/", + "%", + "<<", + ">>", + "&", + "|", + ]; + export const NumGens = [generateNumber(), OpUnary.Num]; + // bool -> bool -> bool - generate([generateBoolean()], BoolOps), - // num -> num -> bool - // mkAstOpBinaryGen([ Primitive.NumberGen ], - // ["==", "!=", "&&", "||"]), - ]; + export const BoolOps: AstOpBinary["op"][] = ["&&", "||"]; + export const BoolGens = [ + generateBoolean(), + OpUnary.Bool, + // bool -> bool -> bool + generate([generateBoolean()], BoolOps), + // num -> num -> bool + // mkAstOpBinaryGen([ Primitive.NumberGen ], + // ["==", "!=", "&&", "||"]), + ]; } /** @@ -362,153 +382,170 @@ export namespace OpBinary { * the desired type and creates an access expression. */ export class StructAccess extends GenerativeEntityOpt< - AstExpression | undefined + AstExpression | undefined > { - constructor( - private parentScope: Scope, - private resultTy: Type, - ) { - super(resultTy); - } - - generate(): fc.Arbitrary | undefined { - const structEntries = this.findStructsWithMatchingFields(); - if (structEntries.size === 0) { - return undefined; // No suitable struct found - } - let structVarNames = this.findVariablesOfStructTypes(structEntries); - if (structVarNames.size === 0) { - structVarNames = this.createStructInstance(structEntries); + constructor( + private parentScope: Scope, + private resultTy: Type, + ) { + super(resultTy); } - return this.createFieldAccessExpression(structEntries, structVarNames); - } - - /** - * Collects structs that have fields returning the desired `resultTy`. - */ - private findStructsWithMatchingFields(): Map { - return this.parentScope - .getItemsRecursive("struct") - .reduce((acc, struct) => { - if (struct.type.kind !== "struct") { - throwTyError(struct.type); + + generate(): fc.Arbitrary | undefined { + const structEntries = this.findStructsWithMatchingFields(); + if (structEntries.size === 0) { + return undefined; // No suitable struct found } - const matchingFieldNames = struct.type.fields.reduce((acc, field) => { - if (tyEq(field.type, this.resultTy)) { - acc.push(field.name); - } - return acc; - }, [] as string[]); - if (matchingFieldNames.length > 0) { - acc.set(struct.name?.text!, [struct.type, matchingFieldNames]); + let structVarNames = this.findVariablesOfStructTypes(structEntries); + if (structVarNames.size === 0) { + structVarNames = this.createStructInstance(structEntries); } - return acc; - }, new Map()); - } - - /** - * Finds local variables that have a type defined by `structEntries`. - */ - private findVariablesOfStructTypes( - structEntries: Map, - ): Map { - return Array.from(structEntries.keys()).reduce((acc, structName) => { - const structType = structEntries.get(structName)![0]; - const variableNames = this.parentScope.getNamesRecursive( - "let", - structType, - ); - if (variableNames.length > 0) { - acc.set(structName, [structType, variableNames]); - } - return acc; - }, new Map()); - } - - /** - * Defines a local variable with a struct type that has matching fields. - * @returns Updated variables map. - */ - private createStructInstance( - structEntries: Map, - ): Map { - const chosenStructName = randomElement(Array.from(structEntries.keys())); - const structType = structEntries.get(chosenStructName)![0]; - const initExpr = new Expression(this.parentScope, structType).generate(); - const varStmt = new Let(this.parentScope, structType, initExpr); - this.parentScope.add("let", varStmt); - return new Map([[chosenStructName, [structType, [varStmt.name?.text!]]]]); - } - - /** - * Creates a field access expression for one of the available variables of the struct types. - */ - private createFieldAccessExpression( - structEntries: Map, - structVarNames: Map, - ): fc.Arbitrary | undefined { - const chosenStructName = randomElement(Array.from(structVarNames.keys())); - const [_, varNames] = structVarNames.get(chosenStructName)!; - const varName = randomElement(varNames); - const fieldName = randomElement(structEntries.get(chosenStructName)![1]); - return new FieldAccess( - this.resultTy, - fieldName, - generateAstIdFromName(varName), - ).generate(); - } + return this.createFieldAccessExpression(structEntries, structVarNames); + } + + /** + * Collects structs that have fields returning the desired `resultTy`. + */ + private findStructsWithMatchingFields(): Map { + return this.parentScope + .getItemsRecursive("struct") + .reduce((acc, struct) => { + if (struct.type.kind !== "struct") { + throwTyError(struct.type); + } + const matchingFieldNames = struct.type.fields.reduce( + (acc, field) => { + if (tyEq(field.type, this.resultTy)) { + acc.push(field.name); + } + return acc; + }, + [] as string[], + ); + if (matchingFieldNames.length > 0) { + acc.set(struct.name?.text!, [ + struct.type, + matchingFieldNames, + ]); + } + return acc; + }, new Map()); + } + + /** + * Finds local variables that have a type defined by `structEntries`. + */ + private findVariablesOfStructTypes( + structEntries: Map, + ): Map { + return Array.from(structEntries.keys()).reduce((acc, structName) => { + const structType = structEntries.get(structName)![0]; + const variableNames = this.parentScope.getNamesRecursive( + "let", + structType, + ); + if (variableNames.length > 0) { + acc.set(structName, [structType, variableNames]); + } + return acc; + }, new Map()); + } + + /** + * Defines a local variable with a struct type that has matching fields. + * @returns Updated variables map. + */ + private createStructInstance( + structEntries: Map, + ): Map { + const chosenStructName = randomElement( + Array.from(structEntries.keys()), + ); + const structType = structEntries.get(chosenStructName)![0]; + const initExpr = new Expression( + this.parentScope, + structType, + ).generate(); + const varStmt = new Let(this.parentScope, structType, initExpr); + this.parentScope.add("let", varStmt); + return new Map([ + [chosenStructName, [structType, [varStmt.name?.text!]]], + ]); + } + + /** + * Creates a field access expression for one of the available variables of the struct types. + */ + private createFieldAccessExpression( + structEntries: Map, + structVarNames: Map, + ): fc.Arbitrary { + const chosenStructName = randomElement( + Array.from(structVarNames.keys()), + ); + const [_, varNames] = structVarNames.get(chosenStructName)!; + const varName = randomElement(varNames); + const fieldName = randomElement( + structEntries.get(chosenStructName)![1], + ); + return new FieldAccess( + this.resultTy, + fieldName, + generateAstIdFromName(varName), + ).generate(); + } } export interface ExpressionParameters { - /** - * Determines whether functions should be generated in this run. - * @default true - */ - generateFunctions: boolean; - - /** - * Determines whether contract methods should be generated in this run. - * @default true - */ - generateMethods: boolean; - - /** - * Determines whether constants should be generated in this run. - * @default true - */ - generateConstants: boolean; - - /** - * Determines whether contract fields should be generated in this run. - * @default true - */ - generateFields: boolean; - - /** - * Determines whether statements should be generated in this run. - * @default true - */ - generateStatements: boolean; - - /** - * Indicates whether the generated expression must be evaluable at compile time. - * @default false - */ - compileTimeEval: boolean; - - /** - * Number of the generated linear-flow statements in the block. - * @default 2 - */ - generatedStatementsNum: number; + /** + * Determines whether functions should be generated in this run. + * @default true + */ + generateFunctions: boolean; + + /** + * Determines whether contract methods should be generated in this run. + * @default true + */ + generateMethods: boolean; + + /** + * Determines whether constants should be generated in this run. + * @default true + */ + generateConstants: boolean; + + /** + * Determines whether contract fields should be generated in this run. + * @default true + */ + generateFields: boolean; + + /** + * Determines whether statements should be generated in this run. + * @default true + */ + generateStatements: boolean; + + /** + * Indicates whether the generated expression must be evaluable at compile time. + * @default false + */ + compileTimeEval: boolean; + + /** + * Number of the generated linear-flow statements in the block. + * @default 2 + */ + generatedStatementsNum: number; } export const NonGenerativeExpressionParams: Partial = { - generateFunctions: false, - generateMethods: false, - generateConstants: false, - generateFields: false, - generateStatements: false, + generateFunctions: false, + generateMethods: false, + generateConstants: false, + generateFields: false, + generateStatements: false, }; /** @@ -518,414 +555,449 @@ export const NonGenerativeExpressionParams: Partial = { * in outer scopes. */ export class Expression extends GenerativeEntity { - private generateFunctions: boolean; - private generateMethods: boolean; - private generateConstants: boolean; - private generateFields: boolean; - private generateStatements: boolean; - private compileTimeEval: boolean; - private generatedStatementsNum: number; - - /** - * @param parentScope Scope the generated expression belongs to. - * @param type Type of the generated expression. - * @param params Optional parameters for expression generation. - */ - constructor( - private parentScope: Scope, - type: Type, - params: Partial = {}, - ) { - super(type); - - const { - generateFunctions = true, - generateMethods = true, - generateConstants = true, - generateFields = true, - generateStatements = true, - compileTimeEval = false, - generatedStatementsNum = 2, - } = params; - this.generateFunctions = generateFunctions; - this.generateMethods = generateMethods; - this.generateConstants = generateConstants; - this.generateFields = generateFields; - this.generateStatements = generateStatements; - this.compileTimeEval = compileTimeEval; - this.generatedStatementsNum = generatedStatementsNum; - - // Forcefully change the parameters based on the current context state to avoid endless recursion. - if (GlobalContext.getDepth() >= GlobalContext.config.maxDepth) { - this.generateFunctions = false; - this.generateMethods = false; - this.generateConstants = false; - this.generateFields = false; - this.generateStatements = false; - } - GlobalContext.incDepth(); - } - - /** - * Generates or chooses an available constant and makes a "use" expression from it. - * @return Use of the generated constant, or `undefined` if that type is unsupported. - */ - private makeConstantUse(ty: Type): fc.Arbitrary | undefined { - if (this.compileTimeEval || !this.generateConstants) { - return undefined; - } - // Don't generate constants that cannot be initialized in compile time: https://github.com/tact-lang/tact/issues/284 - if (ty.kind === "map" || ty.kind === "struct" || ty.kind === "message") { - return undefined; + private generateFunctions: boolean; + private generateMethods: boolean; + private generateConstants: boolean; + private generateFields: boolean; + private generateStatements: boolean; + private compileTimeEval: boolean; + private generatedStatementsNum: number; + + /** + * @param parentScope Scope the generated expression belongs to. + * @param type Type of the generated expression. + * @param params Optional parameters for expression generation. + */ + constructor( + private parentScope: Scope, + type: Type, + params: Partial = {}, + ) { + super(type); + + const { + generateFunctions = true, + generateMethods = true, + generateConstants = true, + generateFields = true, + generateStatements = true, + compileTimeEval = false, + generatedStatementsNum = 2, + } = params; + this.generateFunctions = generateFunctions; + this.generateMethods = generateMethods; + this.generateConstants = generateConstants; + this.generateFields = generateFields; + this.generateStatements = generateStatements; + this.compileTimeEval = compileTimeEval; + this.generatedStatementsNum = generatedStatementsNum; + + // Forcefully change the parameters based on the current context state to avoid endless recursion. + if (GlobalContext.getDepth() >= GlobalContext.config.maxDepth) { + this.generateFunctions = false; + this.generateMethods = false; + this.generateConstants = false; + this.generateFields = false; + this.generateStatements = false; + } + GlobalContext.incDepth(); } - // Collect suitable constants names - let constantNames = this.parentScope - .getNamesRecursive("constantDef", ty) - .concat(this.parentScope.getNamesRecursive("constantDecl", ty)); - // Trait constants cannot be used within trait method definitions - const traitScope = this.parentScope.findParent("trait"); - if (traitScope !== undefined) { - const traitConstantNames = new Set( - traitScope - .getNames("constantDef", ty) - .concat(traitScope.getNames("constantDecl", ty)), - ); - constantNames = constantNames.filter( - (name) => !traitConstantNames.has(name), - ); - // Don't generate new constants inside traits, since they cannot be used - if (constantNames.length === 0) { - return undefined; - } - } + /** + * Generates or chooses an available constant and makes a "use" expression from it. + * @return Use of the generated constant, or `undefined` if that type is unsupported. + */ + private makeConstantUse(ty: Type): fc.Arbitrary | undefined { + if (this.compileTimeEval || !this.generateConstants) { + return undefined; + } + // Don't generate constants that cannot be initialized in compile time: https://github.com/tact-lang/tact/issues/284 + if ( + ty.kind === "map" || + ty.kind === "struct" || + ty.kind === "message" + ) { + return undefined; + } - let scope = this.parentScope; // scope to add/use a constant - if (constantNames.length === 0) { - scope = - this.parentScope.definedIn("program") || randomBool() - ? this.parentScope - : this.parentScope.parentScope!; - // NOTE: Mandatory for contracts; see: tact#332. - const init = - scope.definedIn("contract", "method") || randomBool() - ? new Expression(this.parentScope, ty, { - compileTimeEval: true, - }).generate() - : undefined; - if (init) { - const constant = ConstantDef.fromScope(scope, ty, init); - this.parentScope.add("constantDef", constant); - constantNames.push(constant.name?.text!); - } else { - const constant = new ConstantDecl(scope, ty); - this.parentScope.add("constantDecl", constant); - constantNames.push(constant.name?.text!); - } - } - const arbs = scope.definedIn("contract", "method") - ? constantNames.map((name) => new FieldAccess(ty, name).generate()) - : constantNames.map((name) => fc.constant(generateAstIdFromName(name))); - return arbs.length > 0 ? fc.oneof(...arbs) : undefined; - } - - /** - * Generates or chooses an available field and makes a "use" expression from it. - * @return Use expression of the generated field, or `undefined` if cannot create it.expre - */ - private makeFieldUse(ty: Type): fc.Arbitrary | undefined { - if ( - this.compileTimeEval || - !this.generateFields || - !this.parentScope.definedIn("method") || - this.parentScope.hasParent("trait") - ) { - return undefined; - } + // Collect suitable constants names + let constantNames = this.parentScope + .getNamesRecursive("constantDef", ty) + .concat(this.parentScope.getNamesRecursive("constantDecl", ty)); + // Trait constants cannot be used within trait method definitions + const traitScope = this.parentScope.findParent("trait"); + if (traitScope !== undefined) { + const traitConstantNames = new Set( + traitScope + .getNames("constantDef", ty) + .concat(traitScope.getNames("constantDecl", ty)), + ); + constantNames = constantNames.filter( + (name) => !traitConstantNames.has(name), + ); + // Don't generate new constants inside traits, since they cannot be used + if (constantNames.length === 0) { + return undefined; + } + } - // Struct fields cannot be initialized in compile time: https://github.com/tact-lang/tact/issues/284 - // TODO: Therefore they must be initialized in the init function. - if (ty.kind === "struct" || ty.kind === "message") { - return undefined; + let scope = this.parentScope; // scope to add/use a constant + if (constantNames.length === 0) { + scope = + this.parentScope.definedIn("program") || randomBool() + ? this.parentScope + : this.parentScope.parentScope!; + // NOTE: Mandatory for contracts; see: tact#332. + const init = + scope.definedIn("contract", "method") || randomBool() + ? new Expression(this.parentScope, ty, { + compileTimeEval: true, + }).generate() + : undefined; + if (init) { + const constant = ConstantDef.fromScope(scope, ty, init); + this.parentScope.add("constantDef", constant); + constantNames.push(constant.name?.text!); + } else { + const constant = new ConstantDecl(scope, ty); + this.parentScope.add("constantDecl", constant); + constantNames.push(constant.name?.text!); + } + } + const arbs = scope.definedIn("contract", "method") + ? constantNames.map((name) => new FieldAccess(ty, name).generate()) + : constantNames.map((name) => + fc.constant(generateAstIdFromName(name)), + ); + return arbs.length > 0 ? fc.oneof(...arbs) : undefined; } - const fieldNames = this.parentScope.getNamesRecursive("field", ty); - if (fieldNames.length === 0) { - // NOTE: This init is mandatory since we don't generate init functions yet. - // Maps cannot be initialized in compile-time. - const init = - ty.kind === "map" - ? undefined - : new Expression(this.parentScope, ty, { - compileTimeEval: true, - }).generate(); - const field = new Field(this.parentScope, ty, init); - if (field === undefined) { - return undefined; - } - this.parentScope.add("field", field); - fieldNames.push(field.name?.text!); - } - const arbs = fieldNames.map((name) => new FieldAccess(ty, name).generate()); - return arbs.length > 0 ? fc.oneof(...arbs) : undefined; - } - - /** - * Generates or chooses an available local variables and makes a "use" expression from it. - * The process of generating local variables involves creating new statements in the function/method body. - * @return Use expression of the generated local variable, or `undefined` if cannot create it. - */ - private makeLocalVarUse(ty: Type): fc.Arbitrary | undefined { - if ( - this.compileTimeEval || - !this.generateStatements || - !this.parentScope.definedIn("method", "function") - ) { - return undefined; - } - const varNames = this.parentScope.getNamesRecursive("let", ty); - if (varNames.length === 0) { - const init = new Expression(this.parentScope, ty).generate(); - const varStmt = new Let(this.parentScope, ty, init); - if (varStmt === undefined) { - return undefined; - } - this.parentScope.add("let", varStmt); - varNames.push(varStmt.name?.text!); + /** + * Generates or chooses an available field and makes a "use" expression from it. + * @return Use expression of the generated field, or `undefined` if cannot create it.expre + */ + private makeFieldUse(ty: Type): fc.Arbitrary | undefined { + if ( + this.compileTimeEval || + !this.generateFields || + !this.parentScope.definedIn("method") || + this.parentScope.hasParent("trait") + ) { + return undefined; + } + + // Struct fields cannot be initialized in compile time: https://github.com/tact-lang/tact/issues/284 + // TODO: Therefore they must be initialized in the init function. + if (ty.kind === "struct" || ty.kind === "message") { + return undefined; + } + + const fieldNames = this.parentScope.getNamesRecursive("field", ty); + if (fieldNames.length === 0) { + // NOTE: This init is mandatory since we don't generate init functions yet. + // Maps cannot be initialized in compile-time. + const init = + ty.kind === "map" + ? undefined + : new Expression(this.parentScope, ty, { + compileTimeEval: true, + }).generate(); + const field = new Field(this.parentScope, ty, init); + if (field === undefined) { + return undefined; + } + this.parentScope.add("field", field); + fieldNames.push(field.name?.text!); + } + const arbs = fieldNames.map((name) => + new FieldAccess(ty, name).generate(), + ); + return arbs.length > 0 ? fc.oneof(...arbs) : undefined; } - const arbs = varNames.map((name) => - fc.constant(generateAstIdFromName(name)), - ); - return arbs.length > 0 ? fc.oneof(...arbs) : undefined; - } - - /** - * Generates or chooses an available local variables of a struct type and makes an expression that accesses a struct field. - * The process of generating local variables involves creating new statements in the function/method body. - * @return Use expression of the generated local variable, or `undefined` if cannot create it. - */ - private makeStructFieldAccess( - ty: Type, - ): fc.Arbitrary | undefined { - if ( - this.compileTimeEval || - !this.generateStatements || - !this.parentScope.definedIn("method", "function") - ) { - return undefined; + + /** + * Generates or chooses an available local variables and makes a "use" expression from it. + * The process of generating local variables involves creating new statements in the function/method body. + * @return Use expression of the generated local variable, or `undefined` if cannot create it. + */ + private makeLocalVarUse(ty: Type): fc.Arbitrary | undefined { + if ( + this.compileTimeEval || + !this.generateStatements || + !this.parentScope.definedIn("method", "function") + ) { + return undefined; + } + const varNames = this.parentScope.getNamesRecursive("let", ty); + if (varNames.length === 0) { + const init = new Expression(this.parentScope, ty).generate(); + const varStmt = new Let(this.parentScope, ty, init); + if (varStmt === undefined) { + return undefined; + } + this.parentScope.add("let", varStmt); + varNames.push(varStmt.name?.text!); + } + const arbs = varNames.map((name) => + fc.constant(generateAstIdFromName(name)), + ); + return arbs.length > 0 ? fc.oneof(...arbs) : undefined; } - return new StructAccess(this.parentScope, ty).generate(); - } - - /** - * Generates statements in the block that uses local and global variables. - */ - private generateStatementsInBlock(): void { - if ( - !this.generateStatements || - this.parentScope.definedIn("program", "contract") - ) { - return; + + /** + * Generates or chooses an available local variables of a struct type and makes an expression that accesses a struct field. + * The process of generating local variables involves creating new statements in the function/method body. + * @return Use expression of the generated local variable, or `undefined` if cannot create it. + */ + private makeStructFieldAccess( + ty: Type, + ): fc.Arbitrary | undefined { + if ( + this.compileTimeEval || + !this.generateStatements || + !this.parentScope.definedIn("method", "function") + ) { + return undefined; + } + return new StructAccess(this.parentScope, ty).generate(); } - Array.from({ length: this.generatedStatementsNum }).forEach(() => { - const stmt = new Statement(this.parentScope); - this.parentScope.add("statement", stmt); - }); - } - - /** - * Generates or chooses an available free function and makes a call expression from it. - * @return Use expression of the generated call, or `undefined` if it is not possible to create it. - */ - private makeFunCall(returnTy: Type): fc.Arbitrary | undefined { - if (this.compileTimeEval || !this.generateFunctions) { - return undefined; + + /** + * Generates statements in the block that uses local and global variables. + */ + private generateStatementsInBlock(): void { + if ( + !this.generateStatements || + this.parentScope.definedIn("program", "contract") + ) { + return; + } + Array.from({ length: this.generatedStatementsNum }).forEach(() => { + const stmt = new Statement(this.parentScope); + this.parentScope.add("statement", stmt); + }); } - const funNames = this.parentScope - .findFunction("functionDef", returnTy) - .concat(this.parentScope.findFunction("methodDef", returnTy)); - if (funNames.length === 0) { - const programScope = this.parentScope.getProgramScope(); - const funTy = makeFunctionTy("function", returnTy); - const fun = new FunctionDef(programScope, "function", funTy); - this.parentScope.add("functionDef", fun); - funNames.push([fun.name?.text!, funTy]); + + /** + * Generates or chooses an available free function and makes a call expression from it. + * @return Use expression of the generated call, or `undefined` if it is not possible to create it. + */ + private makeFunCall( + returnTy: Type, + ): fc.Arbitrary | undefined { + if (this.compileTimeEval || !this.generateFunctions) { + return undefined; + } + const funNames = this.parentScope + .findFunction("functionDef", returnTy) + .concat(this.parentScope.findFunction("methodDef", returnTy)); + if (funNames.length === 0) { + const programScope = this.parentScope.getProgramScope(); + const funTy = makeFunctionTy("function", returnTy); + const fun = new FunctionDef(programScope, "function", funTy); + this.parentScope.add("functionDef", fun); + funNames.push([fun.name?.text!, funTy]); + } + const arbs = funNames.map(([name, funTy]) => + new StaticCall( + returnTy, + name, + generateFunctionCallArgs(funTy, this.parentScope), + ).generate(), + ); + return arbs.length > 0 ? fc.oneof(...arbs) : undefined; } - const arbs = funNames.map(([name, funTy]) => - new StaticCall( - returnTy, - name, - generateFunctionCallArgs(funTy, this.parentScope), - ).generate(), - ); - return arbs.length > 0 ? fc.oneof(...arbs) : undefined; - } - - /** - * Generates or chooses an available method and makes a call expression from it. - * @return Use expression of the generated call, or `undefined` if it is not possible to create it. - */ - private makeMethodCall( - returnTy: Type, - ): fc.Arbitrary | undefined { - if ( - this.compileTimeEval || - !this.generateMethods || - this.parentScope.definedIn("program", "function") || - this.parentScope.hasParent("trait") - ) { - return undefined; + + /** + * Generates or chooses an available method and makes a call expression from it. + * @return Use expression of the generated call, or `undefined` if it is not possible to create it. + */ + private makeMethodCall( + returnTy: Type, + ): fc.Arbitrary | undefined { + if ( + this.compileTimeEval || + !this.generateMethods || + this.parentScope.definedIn("program", "function") || + this.parentScope.hasParent("trait") + ) { + return undefined; + } + + // Collect the available standard library methods + const stdlibArbs = [ + // self.map_field.get(key) + ...this.parentScope + .getEntriesRecursive("field") + .reduce((acc, [mapName, mapTy]) => { + if ( + mapTy.kind === "map" && + tyEq(mapTy.type.value, returnTy) + ) { + const opCall = new MethodCall( + returnTy, + "get", + { + kind: "id", + id: nextId(), + text: mapName, + loc: dummySrcInfo, + }, + [ + fc.constantFrom(generateThisID()), + new Expression( + this.parentScope, + mapTy.type.key, + ).generate(), + ], + ).generate(); + acc.push(opCall); + } + return acc; + }, [] as fc.Arbitrary[]), + // map_var.get(key) + ...this.parentScope + .getEntriesRecursive("let") + .reduce((acc, [mapName, mapTy]) => { + if ( + mapTy.kind === "map" && + tyEq(mapTy.type.value, returnTy) + ) { + const opCall = new MethodCall( + returnTy, + "get", + { + kind: "id", + id: nextId(), + text: mapName, + loc: dummySrcInfo, + }, + [ + new Expression( + this.parentScope, + mapTy.type.key, + ).generate(), + ], + ).generate(); + acc.push(opCall); + } + return acc; + }, [] as fc.Arbitrary[]), + ]; + + // Generate or collect the available user-defined methods + const userMethods: [string, Type][] = this.parentScope.findFunction( + "methodDef", + returnTy, + ); + if (userMethods.length === 0) { + const contractScope = this.parentScope.getContractScope(); + if (contractScope === undefined) { + return undefined; + } + const methodTy = makeFunctionTy("method", returnTy); + const method = new FunctionDef(contractScope, "method", methodTy); + this.parentScope.add("methodDef", method); + userMethods.push([method.name?.text!, methodTy]); + } + const userArbs = userMethods.map(([name, methodTy]) => + new MethodCall( + returnTy, + name, + generateThisID(), + generateMethodCallArgs(methodTy, this.parentScope), + ).generate(), + ); + return userArbs.length > 0 && stdlibArbs.length > 0 + ? fc.oneof(...userArbs, ...stdlibArbs) + : undefined; } - // Collect the available standard library methods - const stdlibArbs = [ - // self.map_field.get(key) - ...this.parentScope - .getEntriesRecursive("field") - .reduce((acc, [mapName, mapTy]) => { - if (mapTy.kind === "map" && tyEq(mapTy.type.value, returnTy)) { - const opCall = new MethodCall( - returnTy, - "get", - { kind: "id", id: nextId(), text: mapName, loc: dummySrcInfo }, - [ - fc.constantFrom(generateThisID()), - new Expression(this.parentScope, mapTy.type.key).generate(), - ], - ).generate(); - acc.push(opCall); - } - return acc; - }, [] as fc.Arbitrary[]), - // map_var.get(key) - ...this.parentScope - .getEntriesRecursive("let") - .reduce((acc, [mapName, mapTy]) => { - if (mapTy.kind === "map" && tyEq(mapTy.type.value, returnTy)) { - const opCall = new MethodCall( - returnTy, - "get", - { kind: "id", id: nextId(), text: mapName, loc: dummySrcInfo }, - [new Expression(this.parentScope, mapTy.type.key).generate()], - ).generate(); - acc.push(opCall); - } - return acc; - }, [] as fc.Arbitrary[]), - ]; + /** Generates `require` function call. */ + private generateRequireCall(): fc.Arbitrary { + const condition = new Expression(this.parentScope, { + kind: "stdlib", + type: StdlibType.Bool, + }).generate(); + const error = new Expression(this.parentScope, { + kind: "stdlib", + type: StdlibType.String, + }).generate(); + return new StaticCall( + { kind: "util", type: UtilType.Unit }, + "require", + [condition, error], + ).generate(); + } - // Generate or collect the available user-defined methods - const userMethods: [string, Type][] = this.parentScope.findFunction( - "methodDef", - returnTy, - ); - if (userMethods.length === 0) { - const contractScope = this.parentScope.getContractScope(); - if (contractScope === undefined) { - return undefined; - } - const methodTy = makeFunctionTy("method", returnTy); - const method = new FunctionDef(contractScope, "method", methodTy); - this.parentScope.add("methodDef", method); - userMethods.push([method.name?.text!, methodTy]); + /** + * Generates expressions that returns the given standard type when evaluated. + */ + private generateExpressions(ty: Type): fc.Arbitrary { + const funCall = this.makeFunCall(ty); + const methodCall = this.makeMethodCall(ty); + const constant = this.makeConstantUse(ty); + const field = this.makeFieldUse(ty); + const localVarUse = this.makeLocalVarUse(ty); + const structVarAccess = this.makeStructFieldAccess(ty); + + // Add statements to bodies of functions/methods + this.generateStatementsInBlock(); + + const baseGenerator = (() => { + if (ty.kind === "stdlib") { + switch (ty.type) { + case StdlibType.Int: + return [generateNumber()]; + case StdlibType.Bool: + return [generateBoolean()]; + case StdlibType.String: + return [generateSimplifiedString()]; + default: + throwTyError(ty); + } + } else if (ty.kind === "map") { + return [generateMapInit(this.type, this.parentScope)]; + } else if (ty.kind === "struct") { + return [generateStructInit(this.type, this.parentScope)]; + } else if (ty.kind === "util" && ty.type === UtilType.Unit) { + return [this.generateRequireCall()]; + } else { + throwTyError(ty); + } + })(); + + return fc.oneof( + ...baseGenerator, + ...(funCall ? [funCall] : []), + ...(methodCall ? [methodCall] : []), + ...(constant ? [constant] : []), + ...(field ? [field] : []), + ...(localVarUse ? [localVarUse] : []), + ...(structVarAccess ? [structVarAccess] : []), + ); } - const userArbs = userMethods.map(([name, methodTy]) => - new MethodCall( - returnTy, - name, - generateThisID(), - generateMethodCallArgs(methodTy, this.parentScope), - ).generate(), - ); - return userArbs.length > 0 && stdlibArbs.length > 0 - ? fc.oneof(...userArbs, ...stdlibArbs) - : undefined; - } - - /** Generates `require` function call. */ - private generateRequireCall(): fc.Arbitrary { - const condition = new Expression(this.parentScope, { - kind: "stdlib", - type: StdlibType.Bool, - }).generate(); - const error = new Expression(this.parentScope, { - kind: "stdlib", - type: StdlibType.String, - }).generate(); - return new StaticCall({ kind: "util", type: UtilType.Unit }, "require", [ - condition, - error, - ]).generate(); - } - - /** - * Generates expressions that returns the given standard type when evaluated. - */ - private generateExpressions(ty: Type): fc.Arbitrary { - const funCall = this.makeFunCall(ty); - const methodCall = this.makeMethodCall(ty); - const constant = this.makeConstantUse(ty); - const field = this.makeFieldUse(ty); - const localVarUse = this.makeLocalVarUse(ty); - const structVarAccess = this.makeStructFieldAccess(ty); - - // Add statements to bodies of functions/methods - this.generateStatementsInBlock(); - - const baseGenerator = (() => { - if (ty.kind === "stdlib") { - switch (ty.type) { - case StdlibType.Int: - return [generateNumber()]; - case StdlibType.Bool: - return [generateBoolean()]; - case StdlibType.String: - return [generateString()]; - default: - throwTyError(ty); + + /** + * Generates an AST expression from the specified type. + * During expression generation, the generator creates new AST entries in the outer scopes, + * including functions and constants saving them to the given context. + */ + generate(): fc.Arbitrary { + let expr: fc.Arbitrary; + switch (this.type.kind) { + case "stdlib": + case "map": + case "struct": + case "message": + case "util": + expr = this.generateExpressions(this.type); + break; + case "function": + throw new Error( + `Cannot generate an expression from type: ${JSONbig.stringify(this.type)}`, + ); } - } else if (ty.kind === "map") { - return [generateMapInit(this.type, this.parentScope)]; - } else if (ty.kind === "struct") { - return [generateStructInit(this.type, this.parentScope)]; - } else if (ty.kind === "util" && ty.type === UtilType.Unit) { - return [this.generateRequireCall()]; - } else { - throwTyError(ty); - } - })(); - - return fc.oneof( - ...baseGenerator, - ...(funCall ? [funCall] : []), - ...(methodCall ? [methodCall] : []), - ...(constant ? [constant] : []), - ...(field ? [field] : []), - ...(localVarUse ? [localVarUse] : []), - ...(structVarAccess ? [structVarAccess] : []), - ); - } - - /** - * Generates an AST expression from the specified type. - * During expression generation, the generator creates new AST entries in the outer scopes, - * including functions and constants saving them to the given context. - */ - generate(): fc.Arbitrary { - let expr: fc.Arbitrary; - switch (this.type.kind) { - case "stdlib": - case "map": - case "struct": - case "message": - case "util": - expr = this.generateExpressions(this.type); - break; - case "function": - throw new Error( - `Cannot generate an expression from type: ${JSONbig.stringify(this.type)}`, - ); + return expr; } - return expr; - } } diff --git a/fuzzer/src/generators/field.ts b/fuzzer/src/generators/field.ts index 84de16e261..27a43d667b 100644 --- a/fuzzer/src/generators/field.ts +++ b/fuzzer/src/generators/field.ts @@ -1,8 +1,4 @@ -import { - AstFieldDecl, - AstExpression, - AstId, -} from "../../../src/ast/ast"; +import { AstFieldDecl, AstExpression, AstId } from "../../../src/ast/ast"; import { createSample, generateAstId } from "../util"; import { tyToAstType, Type } from "../types"; import { Scope } from "../scope"; @@ -15,42 +11,45 @@ import { dummySrcInfo } from "../../../src/grammar/"; * An object that encapsulates a generated AstFieldDecl. */ export class Field extends GenerativeEntity { - /** - * @param init An optional initializer evaluable in compile-time. - * @param parentScope Scope this field belongs to. Could be a contract or program for struct fields. - */ - constructor( - parentScope: Scope, - type: Type, - private init?: fc.Arbitrary, - name?: AstId, - ) { - if ( - !parentScope.definedIn( - "contract", - "method", - "program" /* struct field */, - "trait", - ) + /** + * @param init An optional initializer evaluable in compile-time. + * @param parentScope Scope this field belongs to. Could be a contract or program for struct fields. + */ + constructor( + parentScope: Scope, + type: Type, + private init?: fc.Arbitrary, + name?: AstId, ) { - throw new Error(`Cannot define a field in a ${parentScope.kind} scope`); + if ( + !parentScope.definedIn( + "contract", + "method", + "program" /* struct field */, + "trait", + ) + ) { + throw new Error( + `Cannot define a field in a ${parentScope.kind} scope`, + ); + } + super(type); + this.name = + name === undefined + ? createSample(generateAstId(parentScope, "field")) + : name; } - super(type); - this.name = - name === undefined - ? createSample(generateAstId(parentScope, "field")) - : name; - } - generate(): fc.Arbitrary { - return fc.record({ - kind: fc.constant("field_decl"), - id: fc.constant(this.idx), - name: fc.constant(this.name!), - type: fc.constant(tyToAstType(this.type)), - initializer: this.init === undefined ? fc.constant(undefined) : this.init, - as: fc.constantFrom(undefined), - loc: fc.constant(dummySrcInfo), - }); - } + generate(): fc.Arbitrary { + return fc.record({ + kind: fc.constant("field_decl"), + id: fc.constant(this.idx), + name: fc.constant(this.name!), + type: fc.constant(tyToAstType(this.type)), + initializer: + this.init === undefined ? fc.constant(undefined) : this.init, + as: fc.constantFrom(undefined), + loc: fc.constant(dummySrcInfo), + }); + } } diff --git a/fuzzer/src/generators/receiver.ts b/fuzzer/src/generators/receiver.ts index c9b3c2e2fd..d871cd07bf 100644 --- a/fuzzer/src/generators/receiver.ts +++ b/fuzzer/src/generators/receiver.ts @@ -1,8 +1,11 @@ import { - AstReceiver, - AstStatement, - AstString, - AstReceiverKind, + AstReceiver, + AstStatement, + AstReceiverKind, + AstReceiverSubKind, + AstReceiverSimple, + AstReceiverFallback, + AstReceiverComment, } from "../../../src/ast/ast"; import { UtilType, Type, StdlibType, isBouncedMessage } from "../types"; import { Scope } from "../scope"; @@ -14,109 +17,151 @@ import { StatementExpression } from "./statement"; import fc from "fast-check"; import { dummySrcInfo } from "../../../src/grammar/"; +import { nextId } from "../id"; const RECEIVE_RETURN_TY: Type = { kind: "util", type: UtilType.Unit }; +function generateReceiverSimpleSubKind( + param: Parameter, +): fc.Arbitrary { + return fc.record({ + kind: fc.constant("simple"), + param: param.generate(), + id: fc.constant(nextId()), + }); +} + +function generateReceiverFallbackSubKind(): fc.Arbitrary { + return fc.record({ + kind: fc.constant("fallback"), + id: fc.constant(nextId()), + }); +} + +function generateReceiverCommentSubKind(): fc.Arbitrary { + return fc.record({ + kind: fc.constant("comment"), + comment: generateString(/*nonEmpty=*/ true), + id: fc.constant(nextId()), + }); +} + +function generateRecieverKind( + kind: "internal" | "external" | "comment", + subKind: fc.Arbitrary, +): fc.Arbitrary { + return fc.record({ + kind: fc.constant(kind), + subKind, + id: fc.constant(nextId()), + loc: fc.constant(dummySrcInfo), + } as any); //TODO: types are correct here, but i don't know how to explain to typescript, what T is equal to T | T +} + /** * An object that encapsulates an AstReceiver. */ export class Receive extends GenerativeEntity { - /** Generated body items. */ - private body: fc.Arbitrary[] = []; - - /** Scope used within the generated receive method. */ - private scope: Scope; - - constructor(parentScope: Scope) { - super(RECEIVE_RETURN_TY); - this.scope = new Scope("receive", parentScope); - } - - private generateSelector(): fc.Arbitrary { - if (randomBool()) { - const ty = createSample( - fc.record({ - kind: fc.constant("stdlib"), - type: fc.constantFrom( - // TODO: Support Slice - StdlibType.String, - ), - }), - ); - const param = new Parameter(this.scope, ty); - this.scope.add("parameter", param); - const internalSimple = fc.record({ //TODO: make a real generatable from this - kind: fc.constantFrom("internal"), - param: param.generate(), - }); - const externalSimple = fc.record({ - kind: fc.constantFrom("external-simple"), - param: param.generate(), - }); - return fc.oneof(internalSimple, externalSimple); + /** Generated body items. */ + private body: fc.Arbitrary[] = []; + + /** Scope used within the generated receive method. */ + private scope: Scope; + + constructor(parentScope: Scope) { + super(RECEIVE_RETURN_TY); + this.scope = new Scope("receive", parentScope); } - // Choose a random message and create a bounced receiver using it. - const messages = this.scope.getProgramScope().getAll("message"); - if (messages.length > 0 && randomBool()) { - const msg = randomElement(messages); - const param = new Parameter( - this.scope, - msg.type, - isBouncedMessage(msg.type), - ); - this.scope.add("parameter", param); - return fc.record({ - kind: fc.constantFrom("bounce"), - param: param.generate(), - }); + private generateSelector(): fc.Arbitrary { + if (randomBool()) { + const ty = createSample( + fc.record({ + kind: fc.constant("stdlib"), + type: fc.constantFrom( + // TODO: Support Slice + StdlibType.String, + ), + }), + ); + const param = new Parameter(this.scope, ty); + this.scope.add("parameter", param); + const internalSimple = generateRecieverKind( + "internal", + generateReceiverSimpleSubKind(param), + ); + const externalSimple = generateRecieverKind( + "external", + generateReceiverSimpleSubKind(param), + ); + return fc.oneof(internalSimple, externalSimple); + } + + // Choose a random message and create a bounced receiver using it. + const messages = this.scope.getProgramScope().getAll("message"); + if (messages.length > 0 && randomBool()) { + const msg = randomElement(messages); + const param = new Parameter( + this.scope, + msg.type, + isBouncedMessage(msg.type), + ); + this.scope.add("parameter", param); + return fc.record({ + kind: fc.constantFrom("bounce"), + param: param.generate(), + id: fc.constant(nextId()), + loc: fc.constant(dummySrcInfo), + }); + } + + const internalFallback = generateRecieverKind( + "internal", + generateReceiverFallbackSubKind(), + ); + const externalFallback = generateRecieverKind( + "external", + generateReceiverFallbackSubKind(), + ); + const internalComment = generateRecieverKind( + "internal", + generateReceiverCommentSubKind(), + ); + const externalComment = generateRecieverKind( + "external", + generateReceiverCommentSubKind(), + ); + + return fc.oneof( + internalFallback, + externalFallback, + internalComment, + externalComment, + ); } - const internalFallback = fc.record({ - kind: fc.constantFrom("internal-fallback"), - }); - const externalFallback = fc.record({ - kind: fc.constantFrom("external-fallback"), - }); - const internalComment = fc.record({ - kind: fc.constantFrom("internal-comment"), - comment: generateString(/*nonEmpty=*/ true) as fc.Arbitrary, - }); - const externalComment = fc.record({ - kind: fc.constantFrom("external-comment"), - comment: generateString(/*nonEmpty=*/ true) as fc.Arbitrary, - }); + private generateBody(): fc.Arbitrary { + // Create a dummy expression to execute the bottom-up AST generation. + const expr = new Expression(this.scope, this.type).generate(); + const stmt = new StatementExpression(expr).generate(); - return fc.oneof( - internalFallback, - externalFallback, - internalComment, - externalComment, - ); - } - - private generateBody(): fc.Arbitrary { - // Create a dummy expression to execute the bottom-up AST generation. - const expr = new Expression(this.scope, this.type).generate(); - const stmt = new StatementExpression(expr).generate(); - - const generatedLetBindings = Array.from(this.scope.getAll("let")).map((c) => - c.generate(), - ); - const generatedStmts = Array.from(this.scope.getAll("statement")).map((c) => - c.generate(), - ); - this.body = [...generatedLetBindings, ...generatedStmts, stmt]; - return fc.tuple(...this.body); - } - - public generate(): fc.Arbitrary { - return fc.record({ - kind: fc.constant("receiver"), - id: fc.constant(this.idx), - selector: this.generateSelector(), - statements: this.generateBody(), - loc: fc.constant(dummySrcInfo), - }); - } + const generatedLetBindings = Array.from(this.scope.getAll("let")).map( + (c) => c.generate(), + ); + const generatedStmts = Array.from(this.scope.getAll("statement")).map( + (c) => c.generate(), + ); + this.body = [...generatedLetBindings, ...generatedStmts, stmt]; + return fc.tuple(...this.body); + } + + public generate(): fc.Arbitrary { + return fc.record({ + kind: fc.constant("receiver"), + id: fc.constant(this.idx), + selector: this.generateSelector(), + statements: this.generateBody(), + loc: fc.constant(dummySrcInfo), + }); + } } diff --git a/fuzzer/src/stdlib.ts b/fuzzer/src/stdlib.ts index f49f230ff0..dfefe7cc4e 100644 --- a/fuzzer/src/stdlib.ts +++ b/fuzzer/src/stdlib.ts @@ -7,12 +7,12 @@ import { createVirtualFileSystem } from "../../src/vfs/createVirtualFileSystem"; import { generateAstIdFromName } from "./util"; import { dummySrcInfo } from "../../src/grammar/"; -const StdlibFilePath = path.join(__dirname, "..", "..", "tact", "stdlib"); -const StdlibVFS = createVirtualFileSystem(StdlibFilePath, files); -export const StdlibPath = StdlibVFS.resolve("stdlib.fc"); -export const StdlibCode = StdlibVFS.readFile(StdlibPath).toString(); -export const StdlibExPath = StdlibVFS.resolve("stdlib_ex.fc"); -export const StdlibExCode = StdlibVFS.readFile(StdlibExPath).toString(); +// const StdlibFilePath = path.join(__dirname, "..", "..", "src", "stdlib", "stdlib", "std"); +// const StdlibVFS = createVirtualFileSystem(StdlibFilePath, files); +// export const StdlibPath = StdlibVFS.resolve("stdlib.fc"); +// export const StdlibCode = StdlibVFS.readFile(StdlibPath).toString(); +// export const StdlibExPath = StdlibVFS.resolve("stdlib_ex.fc"); +// export const StdlibExCode = StdlibVFS.readFile(StdlibExPath).toString(); /** * Returns traits defined in stdlib. From f49d0c9d9f7ef996285aca7bebeeb391acf9b9dc Mon Sep 17 00:00:00 2001 From: Mell0r Date: Mon, 10 Mar 2025 01:46:23 +0300 Subject: [PATCH 03/44] fix: many linter fixes, all files codestyle switched to 4 spaces --- fuzzer/src/config.ts | 126 ++- fuzzer/src/context.ts | 116 +-- fuzzer/src/formatter.ts | 1191 +++++++++++++-------------- fuzzer/src/generators/constant.ts | 213 ++--- fuzzer/src/generators/contract.ts | 217 ++--- fuzzer/src/generators/expression.ts | 21 +- fuzzer/src/generators/field.ts | 15 +- fuzzer/src/generators/function.ts | 393 ++++----- fuzzer/src/generators/generator.ts | 35 +- fuzzer/src/generators/parameter.ts | 57 +- fuzzer/src/generators/program.ts | 324 ++++---- fuzzer/src/generators/receiver.ts | 5 +- fuzzer/src/generators/statement.ts | 1098 ++++++++++++------------ fuzzer/src/generators/struct.ts | 160 ++-- fuzzer/src/generators/trait.ts | 194 ++--- fuzzer/src/id.ts | 4 +- fuzzer/src/scope.ts | 629 +++++++------- fuzzer/src/stdlib.ts | 30 +- fuzzer/src/types.ts | 673 +++++++-------- fuzzer/src/util.ts | 231 +++--- fuzzer/test/compilation.spec.ts | 193 ++--- fuzzer/test/expression.spec.ts | 93 +-- fuzzer/test/program.spec.ts | 98 +-- fuzzer/test/testUtils.ts | 73 +- tsconfig.eslint.json | 2 +- 25 files changed, 3130 insertions(+), 3061 deletions(-) diff --git a/fuzzer/src/config.ts b/fuzzer/src/config.ts index c6fca01e46..e9374e8e3e 100644 --- a/fuzzer/src/config.ts +++ b/fuzzer/src/config.ts @@ -10,77 +10,75 @@ const DEFAULT_NUM_RUNS: number = 100; * Configuration handler for fuzz testing settings. */ export class FuzzConfig { - /** - * The number of samples to dump during fuzz testing. - * If `samplesNum` is not set, the fuzzer won't dump samples. - */ - public samplesNum: number | undefined; + /** + * The number of samples to dump during fuzz testing. + * If `samplesNum` is not set, the fuzzer won't dump samples. + */ + public samplesNum: number | undefined; - /** - * A format used to dump samples. - */ - public samplesFormat: "ast" | "json" = "ast"; + /** + * A format used to dump samples. + */ + public samplesFormat: "ast" | "json" = "ast"; - /** - * Explicitly specified fast-check seed. - */ - public seed: number | undefined; + /** + * Explicitly specified fast-check seed. + */ + public seed: number | undefined; - /** - * Number of AST generation cycles. POSITIVE_INFINITY means running in the continuous fuzzing mode. - */ - public numRuns: number; + /** + * Number of AST generation cycles. POSITIVE_INFINITY means running in the continuous fuzzing mode. + */ + public numRuns: number; - /** - * Directory to save contracts compiled during the compilation test. - */ - public compileDir: string; + /** + * Directory to save contracts compiled during the compilation test. + */ + public compileDir: string; - /** - * Maximum AST generation depth. - */ - public maxDepth: number = 5; + /** + * Maximum AST generation depth. + */ + public maxDepth: number = 5; - constructor() { - this.samplesNum = process.env.SAMPLES_NUM - ? parseInt(process.env.SAMPLES_NUM) - : undefined; - if (process.env.SAMPLES_FORMAT) { - this.validateAndSetFormat(process.env.SAMPLES_FORMAT); + constructor() { + this.samplesNum = process.env.SAMPLES_NUM + ? parseInt(process.env.SAMPLES_NUM) + : undefined; + if (process.env.SAMPLES_FORMAT) { + this.validateAndSetFormat(process.env.SAMPLES_FORMAT); + } + this.compileDir = process.env.COMPILE_DIR ?? os.tmpdir(); + if (process.env.COMPILE_DIR && !existsSync(process.env.COMPILE_DIR)) { + mkdirSync(process.env.COMPILE_DIR, { recursive: true }); + } + this.seed = process.env.SEED ? parseInt(process.env.SEED) : undefined; + this.numRuns = + process.env.FUZZ === "1" + ? Number.POSITIVE_INFINITY + : process.env.NUM_RUNS + ? parseInt(process.env.NUM_RUNS) + : DEFAULT_NUM_RUNS; + if (this.samplesNum && this.numRuns < this.samplesNum) { + console.warn( + `the requested number of SAMPLES_NUM=${this.samplesNum} is less than NUM_RUNS=${this.numRuns}`, + ); + } } - this.compileDir = process.env.COMPILE_DIR - ? process.env.COMPILE_DIR - : os.tmpdir(); - if (process.env.COMPILE_DIR && !existsSync(process.env.COMPILE_DIR)) { - mkdirSync(process.env.COMPILE_DIR, { recursive: true }); - } - this.seed = process.env.SEED ? parseInt(process.env.SEED) : undefined; - this.numRuns = - process.env.FUZZ === "1" - ? Number.POSITIVE_INFINITY - : process.env.NUM_RUNS - ? parseInt(process.env.NUM_RUNS) - : DEFAULT_NUM_RUNS; - if (this.samplesNum && this.numRuns < this.samplesNum) { - console.warn( - `the requested number of SAMPLES_NUM=${this.samplesNum} is less than NUM_RUNS=${this.numRuns}`, - ); - } - } - /** - * Validates and sets the sample format based on the provided format string. - * Throws an error if the format is not supported. - * @param fmt The format string to validate and set. - */ - private validateAndSetFormat(fmt: string): void { - const supportedFormats: ("ast" | "json")[] = ["ast", "json"]; - if (supportedFormats.includes(fmt as "ast" | "json")) { - this.samplesFormat = fmt as "ast" | "json"; - } else { - throw new Error( - `unsupported SAMPLES_FMT: ${fmt} (supported options: "ast" and "json")`, - ); + /** + * Validates and sets the sample format based on the provided format string. + * Throws an error if the format is not supported. + * @param fmt The format string to validate and set. + */ + private validateAndSetFormat(fmt: string): void { + const supportedFormats: ("ast" | "json")[] = ["ast", "json"]; + if (supportedFormats.includes(fmt as "ast" | "json")) { + this.samplesFormat = fmt as "ast" | "json"; + } else { + throw new Error( + `unsupported SAMPLES_FMT: ${fmt} (supported options: "ast" and "json")`, + ); + } } - } } diff --git a/fuzzer/src/context.ts b/fuzzer/src/context.ts index 959ec22d99..60a5952e44 100644 --- a/fuzzer/src/context.ts +++ b/fuzzer/src/context.ts @@ -2,81 +2,83 @@ import JSONbig from "json-bigint"; import { formatAst } from "./formatter"; import { FuzzConfig } from "./config"; -import { AstNode } from "../../src/ast/ast"; +import type { AstNode } from "../../src/ast/ast"; /** * FuzzContext represents a stateful context that handles AST generation. * It keeps the global options used to control and configure the AST generation. */ export class FuzzContext { - /** - * Tracks the number of samples that have been printed. - */ - private printedSamplesCount: number = 0; + /** + * Tracks the number of samples that have been printed. + */ + private printedSamplesCount: number = 0; - /** - * Configuration of the fuzzer. - */ - public config: FuzzConfig; + /** + * Configuration of the fuzzer. + */ + public config: FuzzConfig; - /** - * Current depth of AST expression generation, which limits recursive generation. - */ - private currentDepth: number = 0; + /** + * Current depth of AST expression generation, which limits recursive generation. + */ + private currentDepth: number = 0; - constructor() { - this.config = new FuzzConfig(); - } + constructor() { + this.config = new FuzzConfig(); + } - public getDepth(): number { - return this.currentDepth; - } + public getDepth(): number { + return this.currentDepth; + } - public incDepth(): void { - this.currentDepth++; - } + public incDepth(): void { + this.currentDepth++; + } - public decDepth(): void { - this.currentDepth--; - if (this.currentDepth < 0) { - throw new Error("Reached negative recursion depth"); + public decDepth(): void { + this.currentDepth--; + if (this.currentDepth < 0) { + throw new Error("Reached negative recursion depth"); + } } - } - public resetDepth(): void { - this.currentDepth = 0; - } + public resetDepth(): void { + this.currentDepth = 0; + } - /** - * Formats the given AST construction according to the current formatter configuration. - */ - public format(value: AstNode, fmt = this.config.samplesFormat): string { - switch (fmt) { - case "json": - return `${JSONbig.stringify(value, null, 2)}`; - case "ast": - return `${formatAst(value)}`; - default: - throw new Error( - `Unsupported sample format: ${this.config.samplesFormat}`, - ); + /** + * Formats the given AST construction according to the current formatter configuration. + */ + public format(value: AstNode, fmt = this.config.samplesFormat): string { + switch (fmt) { + case "json": + return JSONbig.stringify(value, null, 2); + case "ast": + return formatAst(value); + default: + throw new Error( + `Unsupported sample format: ${this.config.samplesFormat}`, + ); + } } - } - /** - * Prints the given sample if the number of already printed samples is less than the configured limit. - * @param sample The sample to print. - */ - public printSample(sample: AstNode): void { - if ( - this.config.samplesNum === undefined || - this.printedSamplesCount >= this.config.samplesNum - ) { - return; + /** + * Prints the given sample if the number of already printed samples is less than the configured limit. + * @param sample The sample to print. + */ + public printSample(sample: AstNode): void { + if ( + this.config.samplesNum === undefined || + this.printedSamplesCount >= this.config.samplesNum + ) { + return; + } + console.log( + `Sample #${this.printedSamplesCount}:\n${this.format(sample)}`, + ); + this.printedSamplesCount++; } - console.log(`Sample #${this.printedSamplesCount}:\n${this.format(sample)}`); - this.printedSamplesCount++; - } } /** diff --git a/fuzzer/src/formatter.ts b/fuzzer/src/formatter.ts index 00c0fc68eb..3dad805afe 100644 --- a/fuzzer/src/formatter.ts +++ b/fuzzer/src/formatter.ts @@ -1,579 +1,578 @@ -import { - AstConstantDecl, - AstConstantDef, - AstImport, - AstNativeFunctionDecl, - AstModule, - AstBouncedMessageType, - AstMapType, - AstReceiver, - AstContractInit, - AstStatementRepeat, - AstStatementUntil, - AstStatementWhile, - AstStatementForEach, - AstStatementTry, - AstStructFieldInitializer, - AstStatementCondition, - AstStatementAugmentedAssign, - AstStatementAssign, - AstStatementExpression, - AstStatementReturn, - AstStatementLet, - AstFunctionDef, - AstFunctionDecl, - AstType, - AstStatement, - AstExpression, - AstFieldDecl, - AstPrimitiveTypeDecl, - AstStructDecl, - AstContract, - AstTrait, - AstMessageDecl, - AstNode, - AstTraitDeclaration, - AstModuleItem, - AstContractDeclaration, +import type { + AstConstantDecl, + AstConstantDef, + AstImport, + AstNativeFunctionDecl, + AstModule, + AstBouncedMessageType, + AstMapType, + AstReceiver, + AstContractInit, + AstStatementRepeat, + AstStatementUntil, + AstStatementWhile, + AstStatementForEach, + AstStatementTry, + AstStructFieldInitializer, + AstStatementCondition, + AstStatementAugmentedAssign, + AstStatementAssign, + AstStatementExpression, + AstStatementReturn, + AstStatementLet, + AstFunctionDef, + AstFunctionDecl, + AstType, + AstStatement, + AstExpression, + AstFieldDecl, + AstPrimitiveTypeDecl, + AstStructDecl, + AstContract, + AstTrait, + AstMessageDecl, + AstNode, + AstTraitDeclaration, + AstModuleItem, + AstContractDeclaration, } from "../../src/ast/ast"; /** * PrettyPrinter class provides methods to format and indent Tact code. */ class PrettyPrinter { - /** - * @param indentLevel Initial level of indentation. - * @param indentSpaces Number of spaces per indentation level. - */ - constructor( - private indentLevel: number = 0, - private readonly indentSpaces: number = 2, - ) {} - - private increaseIndent() { - this.indentLevel += 1; - } - - private decreaseIndent() { - this.indentLevel -= 1; - } - - private indent(): string { - return " ".repeat(this.indentLevel * this.indentSpaces); - } - - ppAstPrimitive(primitive: AstPrimitiveTypeDecl): string { - return `${this.indent()}primitive ${primitive.name.text};`; - } - - // - // Types - // - - ppAstType(typeRef: AstType): string { - switch (typeRef.kind) { - case "type_id": - return typeRef.text; - case "optional_type": - return `${this.ppAstType(typeRef.typeArg)}?`; - case "map_type": - return this.ppAstTypeRefMap(typeRef); - case "bounced_message_type": - return this.ppAstBouncedMessageType(typeRef); - default: - throw new Error(`Unknown TypeRef kind: ${typeRef}`); - } - } - - ppAstTypeRefMap(typeRef: AstMapType): string { - const keyAlias = typeRef.keyStorageType - ? ` as ${typeRef.keyStorageType}` - : ""; - const valueAlias = typeRef.valueStorageType - ? ` as ${typeRef.valueStorageType}` - : ""; - return `map<${typeRef.keyType.text}${keyAlias}, ${typeRef.valueType.text}${valueAlias}>`; - } - - ppAstBouncedMessageType(type: AstBouncedMessageType): string { - return `bounced<${type.messageType.text}>`; - } - - // - // Expressions - // - - /** - * Returns precedence used in unary/binary operations. - * Lower number means higher precedence - */ - getPrecedence(kind: string, op?: string): number { - switch (kind) { - case "op_binary": - switch (op) { - case "||": - return 1; - case "&&": - return 2; - case "|": - return 3; - case "^": - return 4; - case "&": - return 5; - case "==": - case "!=": - return 6; - case "<": - case ">": - case "<=": - case ">=": - return 7; - case "+": - case "-": - return 8; - case "*": - case "/": - case "%": - return 9; - default: - return 11; + /** + * @param indentLevel Initial level of indentation. + * @param indentSpaces Number of spaces per indentation level. + */ + constructor( + private indentLevel: number = 0, + private readonly indentSpaces: number = 2, + ) {} + + private increaseIndent() { + this.indentLevel += 1; + } + + private decreaseIndent() { + this.indentLevel -= 1; + } + + private indent(): string { + return " ".repeat(this.indentLevel * this.indentSpaces); + } + + ppAstPrimitive(primitive: AstPrimitiveTypeDecl): string { + return `${this.indent()}primitive ${primitive.name.text};`; + } + + // + // Types + // + + ppAstType(typeRef: AstType): string { + switch (typeRef.kind) { + case "type_id": + return typeRef.text; + case "optional_type": + return `${this.ppAstType(typeRef.typeArg)}?`; + case "map_type": + return this.ppAstTypeRefMap(typeRef); + case "bounced_message_type": + return this.ppAstBouncedMessageType(typeRef); } - case "conditional": - case "op_call": - case "op_static_call": - return 0; - case "op_unary": - return 10; - default: - return 11; - } - } - - ppAstExpression(expr: AstExpression, parentPrecedence: number = 0): string { - let result; - let currentPrecedence = this.getPrecedence(expr.kind); - - switch (expr.kind) { - case "op_binary": - currentPrecedence = this.getPrecedence(expr.kind, expr.op); - result = `${this.ppAstExpression(expr.left, currentPrecedence)} ${expr.op} ${this.ppAstExpression(expr.right, currentPrecedence)}`; - break; - case "op_unary": - currentPrecedence = this.getPrecedence(expr.kind, expr.op); - result = `${expr.op}${this.ppAstExpression(expr.operand, currentPrecedence)}`; - break; - case "field_access": - result = `${this.ppAstExpression(expr.aggregate, currentPrecedence)}.${expr.field.text}`; - break; - case "method_call": - result = `${this.ppAstExpression(expr.self, currentPrecedence)}.${expr.method.text}(${expr.args.map((arg) => this.ppAstExpression(arg, currentPrecedence)).join(", ")})`; - break; - case "static_call": - result = `${expr.function.text}(${expr.args.map((arg) => this.ppAstExpression(arg, currentPrecedence)).join(", ")})`; - break; - case "struct_instance": - result = `${expr.type.text}{${expr.args.map((x) => this.ppAstStructFieldInitializer(x)).join(", ")}}`; - break; - case "init_of": - result = `initOf ${expr.contract.text}(${expr.args.map((arg) => this.ppAstExpression(arg, currentPrecedence)).join(", ")})`; - break; - case "conditional": - result = `${this.ppAstExpression(expr.condition, currentPrecedence)} ? ${this.ppAstExpression(expr.thenBranch, currentPrecedence)} : ${this.ppAstExpression(expr.elseBranch, currentPrecedence)}`; - break; - case "number": - result = expr.value.toString(); - break; - case "id": - result = expr.text; - break; - case "boolean": - result = expr.value.toString(); - break; - case "simplified_string": - result = `"${expr.value}"`; - break; - case "null": - result = "null"; - break; - default: - throw new Error(`Unsupported expression type: ${expr.kind}`); - } - - // Set parens when needed - if ( - parentPrecedence > 0 && - currentPrecedence > 0 && - currentPrecedence < parentPrecedence - ) { - result = `(${result})`; - } - - return result; - } - - ppAstStructFieldInitializer(param: AstStructFieldInitializer): string { - return `${param.field.text}: ${this.ppAstExpression(param.initializer)}`; - } - - // - // Program - // - - ppAstProgram(program: AstModule): string { - const entriesFormatted = program.items - .map((entry, index, array) => { - const formattedEntry = this.ppProgramItem(entry); - const nextEntry = array[index + 1]; - if ( - entry.kind === "constant_def" && - nextEntry?.kind === "constant_def" - ) { - return formattedEntry; + } + + ppAstTypeRefMap(typeRef: AstMapType): string { + const keyAlias = typeRef.keyStorageType + ? ` as ${typeRef.keyStorageType.text}` + : ""; + const valueAlias = typeRef.valueStorageType + ? ` as ${typeRef.valueStorageType.text}` + : ""; + return `map<${typeRef.keyType.text}${keyAlias}, ${typeRef.valueType.text}${valueAlias}>`; + } + + ppAstBouncedMessageType(type: AstBouncedMessageType): string { + return `bounced<${type.messageType.text}>`; + } + + // + // Expressions + // + + /** + * Returns precedence used in unary/binary operations. + * Lower number means higher precedence + */ + getPrecedence(kind: string, op?: string): number { + switch (kind) { + case "op_binary": + switch (op) { + case "||": + return 1; + case "&&": + return 2; + case "|": + return 3; + case "^": + return 4; + case "&": + return 5; + case "==": + case "!=": + return 6; + case "<": + case ">": + case "<=": + case ">=": + return 7; + case "+": + case "-": + return 8; + case "*": + case "/": + case "%": + return 9; + default: + return 11; + } + case "conditional": + case "op_call": + case "op_static_call": + return 0; + case "op_unary": + return 10; + default: + return 11; } - return formattedEntry + "\n"; - }) - .join("\n"); - return entriesFormatted.trim(); - } - - ppProgramItem(item: AstModuleItem): string { - switch (item.kind) { - case "struct_decl": - case "message_decl": - return this.ppAstStruct(item); - case "contract": - return this.ppAstContract(item); - case "primitive_type_decl": - return this.ppAstPrimitive(item); - case "function_def": - return this.ppAstFunction(item); - case "native_function_decl": - return this.ppAstNativeFunction(item); - case "trait": - return this.ppAstTrait(item); - case "constant_def": - return this.ppAstConstant(item); - default: - return `Unknown Program Item Type: ${item}`; - } - } - - ppAstProgramImport(importItem: AstImport): string { - return `${this.indent()}import "${importItem.importPath}";`; - } //TODO: there is no more imports in contract? - - ppAstStruct(struct: AstStructDecl | AstMessageDecl): string { - const typePrefix = struct.kind === "message_decl" ? "message" : "struct"; - const prefixFormatted = - struct.kind === "message_decl" && struct.opcode !== null - ? `(${struct.opcode}) ` - : ""; - this.increaseIndent(); - const fieldsFormatted = struct.fields - .map((field) => this.ppAstField(field)) - .join("\n"); - this.decreaseIndent(); - return `${this.indent()}${typePrefix} ${prefixFormatted}${struct.name.text} {\n${fieldsFormatted}\n}`; - } - - ppAstTrait(trait: AstTrait): string { - const traitsFormatted = trait.traits.map((t) => t.text).join(", "); - const attrsRaw = trait.attributes - .map((attr) => `@${attr.type}("${attr.name.value}")`) - .join(" "); - const attrsFormatted = attrsRaw ? `${attrsRaw} ` : ""; - this.increaseIndent(); - const bodyFormatted = trait.declarations - .map((dec, index, array) => { - const formattedDec = this.ppTraitBody(dec); - const nextDec = array[index + 1]; - if ( - (dec.kind === "constant_def" && nextDec?.kind === "constant_def") || - (dec.kind === "constant_decl" && nextDec?.kind === "constant_decl") || - (dec.kind === "field_decl" && nextDec?.kind === "field_decl") - ) { - return formattedDec; + } + + ppAstExpression(expr: AstExpression, parentPrecedence: number = 0): string { + let result; + let currentPrecedence = this.getPrecedence(expr.kind); + + switch (expr.kind) { + case "op_binary": + currentPrecedence = this.getPrecedence(expr.kind, expr.op); + result = `${this.ppAstExpression(expr.left, currentPrecedence)} ${expr.op} ${this.ppAstExpression(expr.right, currentPrecedence)}`; + break; + case "op_unary": + currentPrecedence = this.getPrecedence(expr.kind, expr.op); + result = `${expr.op}${this.ppAstExpression(expr.operand, currentPrecedence)}`; + break; + case "field_access": + result = `${this.ppAstExpression(expr.aggregate, currentPrecedence)}.${expr.field.text}`; + break; + case "method_call": + result = `${this.ppAstExpression(expr.self, currentPrecedence)}.${expr.method.text}(${expr.args.map((arg) => this.ppAstExpression(arg, currentPrecedence)).join(", ")})`; + break; + case "static_call": + result = `${expr.function.text}(${expr.args.map((arg) => this.ppAstExpression(arg, currentPrecedence)).join(", ")})`; + break; + case "struct_instance": + result = `${expr.type.text}{${expr.args.map((x) => this.ppAstStructFieldInitializer(x)).join(", ")}}`; + break; + case "init_of": + result = `initOf ${expr.contract.text}(${expr.args.map((arg) => this.ppAstExpression(arg, currentPrecedence)).join(", ")})`; + break; + case "conditional": + result = `${this.ppAstExpression(expr.condition, currentPrecedence)} ? ${this.ppAstExpression(expr.thenBranch, currentPrecedence)} : ${this.ppAstExpression(expr.elseBranch, currentPrecedence)}`; + break; + case "number": + result = expr.value.toString(); + break; + case "id": + result = expr.text; + break; + case "boolean": + result = expr.value.toString(); + break; + case "simplified_string": + result = `"${expr.value}"`; + break; + case "null": + result = "null"; + break; + default: + throw new Error(`Unsupported expression type: ${expr.kind}`); } - return formattedDec + "\n"; - }) - .join("\n"); - const header = traitsFormatted - ? `trait ${trait.name.text} with ${traitsFormatted}` - : `trait ${trait.name.text}`; - this.decreaseIndent(); - return `${this.indent()}${attrsFormatted}${header} {\n${bodyFormatted}${this.indent()}}`; - } - - ppTraitBody(item: AstTraitDeclaration): string { - switch (item.kind) { - case "field_decl": - return this.ppAstField(item); - case "function_decl": - case "function_def": - return this.ppAstFunction(item); - case "receiver": - return this.ppAstReceive(item); - case "constant_decl": - case "constant_def": - return this.ppAstConstant(item); - default: - return `Unknown Trait Body Type: ${item}`; - } - } - - ppAstField(field: AstFieldDecl): string { - const typeFormatted = this.ppAstType(field.type); - const initializer = field.initializer - ? ` = ${this.ppAstExpression(field.initializer)}` - : ""; - const asAlias = field.as ? ` as ${field.as}` : ""; - return `${this.indent()}${field.name.text}: ${typeFormatted}${asAlias}${initializer};`; - } - - ppAstConstant(constant: AstConstantDecl | AstConstantDef): string { - const valueFormatted = - constant.kind === "constant_def" - ? ` = ${this.ppAstExpression(constant.initializer)}` - : ""; - const attrsRaw = constant.attributes.map((attr) => attr.type).join(" "); - const attrsFormatted = attrsRaw ? `${attrsRaw} ` : ""; - return `${this.indent()}${attrsFormatted}const ${constant.name.text}: ${this.ppAstType(constant.type)}${valueFormatted};`; - } - - ppAstContract(contract: AstContract): string { - const traitsFormatted = contract.traits - .map((trait) => trait.text) - .join(", "); - this.increaseIndent(); - const bodyFormatted = contract.declarations - .map((dec, index, array) => { - const formattedDec = this.ppContractBody(dec); - const nextDec = array[index + 1]; + + // Set parens when needed if ( - (dec.kind === "constant_def" && nextDec?.kind === "constant_def") || - (dec.kind === "field_decl" && nextDec?.kind === "field_decl") + parentPrecedence > 0 && + currentPrecedence > 0 && + currentPrecedence < parentPrecedence ) { - return formattedDec; + result = `(${result})`; } - return formattedDec + "\n"; - }) - .join("\n"); - this.decreaseIndent(); - const header = traitsFormatted - ? `contract ${contract.name.text} with ${traitsFormatted}` - : `contract ${contract.name.text}`; - const attrsRaw = contract.attributes - .map((attr) => `@interface("${attr.name.value}")`) - .join(" "); - const attrsFormatted = attrsRaw ? `${attrsRaw} ` : ""; - return `${this.indent()}${attrsFormatted}${header} {\n${bodyFormatted}${this.indent()}}`; - } - - ppContractBody(declaration: AstContractDeclaration): string { - switch (declaration.kind) { - case "field_decl": - return this.ppAstField(declaration); - case "function_def": - return this.ppAstFunction(declaration); - case "contract_init": - return this.ppAstInitFunction(declaration); - case "receiver": - return this.ppAstReceive(declaration); - case "constant_def": - return this.ppAstConstant(declaration); - default: - return `Unknown Contract Body Type: ${declaration}`; - } - } - - public ppAstFunction(func: AstFunctionDecl | AstFunctionDef): string { - const argsFormatted = func.params - .map((arg) => `${arg.name.text}: ${this.ppAstType(arg.type)}`) - .join(", "); - const attrsRaw = func.attributes.map((attr) => attr.type).join(" "); - const attrsFormatted = attrsRaw ? `${attrsRaw} ` : ""; - const returnType = func.return ? `: ${this.ppAstType(func.return)}` : ""; - this.increaseIndent(); - const stmtsFormatted = - func.kind === "function_def" - ? func.statements.map((stmt) => this.ppAstStatement(stmt)).join("\n") - : ""; - const body = - func.kind === "function_def" - ? ` {\n${stmtsFormatted}\n${this.indent()}}` - : ";"; - this.decreaseIndent(); - return `${this.indent()}${attrsFormatted}fun ${func.name.text}(${argsFormatted})${returnType}${body}`; - } - - ppAstReceive(receive: AstReceiver): string { - const header = this.ppAstReceiveHeader(receive); - const stmtsFormatted = this.ppStatementBlock(receive.statements); - return `${this.indent()}${header} ${stmtsFormatted}`; - } - - ppAstReceiveHeader(receive: AstReceiver): string { - switch (receive.selector.kind) { - case "internal": - switch (receive.selector.subKind.kind) { - case "simple": - return `receive(${receive.selector.subKind.param.name.text}: ${this.ppAstType(receive.selector.subKind.param.type)})`; - case "fallback": - return `receive()`; - case "comment": - return `receive("${receive.selector.subKind.comment.value}")`; + + return result; + } + + ppAstStructFieldInitializer(param: AstStructFieldInitializer): string { + return `${param.field.text}: ${this.ppAstExpression(param.initializer)}`; + } + + // + // Program + // + + ppAstProgram(program: AstModule): string { + const entriesFormatted = program.items + .map((entry, index, array) => { + const formattedEntry = this.ppProgramItem(entry); + const nextEntry = array[index + 1]; + if ( + entry.kind === "constant_def" && + nextEntry.kind === "constant_def" + ) { + return formattedEntry; + } + return formattedEntry + "\n"; + }) + .join("\n"); + return entriesFormatted.trim(); + } + + ppProgramItem(item: AstModuleItem): string { + switch (item.kind) { + case "struct_decl": + case "message_decl": + return this.ppAstStruct(item); + case "contract": + return this.ppAstContract(item); + case "primitive_type_decl": + return this.ppAstPrimitive(item); + case "function_def": + return this.ppAstFunction(item); + case "native_function_decl": + return this.ppAstNativeFunction(item); + case "trait": + return this.ppAstTrait(item); + case "constant_def": + return this.ppAstConstant(item); + default: + return `Unknown Program Item Type: ${item.kind}`; + } + } + + ppAstProgramImport(importItem: AstImport): string { + return `${this.indent()}import "${importItem.importPath.path.segments.join()}";`; + } + + ppAstStruct(struct: AstStructDecl | AstMessageDecl): string { + const typePrefix = + struct.kind === "message_decl" ? "message" : "struct"; + const prefixFormatted = + struct.kind === "message_decl" && struct.opcode !== undefined + ? this.ppAstExpression(struct.opcode) + : ""; + this.increaseIndent(); + const fieldsFormatted = struct.fields + .map((field) => this.ppAstField(field)) + .join("\n"); + this.decreaseIndent(); + return `${this.indent()}${typePrefix} ${prefixFormatted}${struct.name.text} {\n${fieldsFormatted}\n}`; + } + + ppAstTrait(trait: AstTrait): string { + const traitsFormatted = trait.traits.map((t) => t.text).join(", "); + const attrsRaw = trait.attributes + .map((attr) => `@${attr.type}("${attr.name.value}")`) + .join(" "); + const attrsFormatted = attrsRaw ? `${attrsRaw} ` : ""; + this.increaseIndent(); + const bodyFormatted = trait.declarations + .map((dec, index, array) => { + const formattedDec = this.ppTraitBody(dec); + const nextDec = array[index + 1]; + if ( + (dec.kind === "constant_def" && + nextDec.kind === "constant_def") || + (dec.kind === "constant_decl" && + nextDec.kind === "constant_decl") || + (dec.kind === "field_decl" && nextDec.kind === "field_decl") + ) { + return formattedDec; + } + return formattedDec + "\n"; + }) + .join("\n"); + const header = traitsFormatted + ? `trait ${trait.name.text} with ${traitsFormatted}` + : `trait ${trait.name.text}`; + this.decreaseIndent(); + return `${this.indent()}${attrsFormatted}${header} {\n${bodyFormatted}${this.indent()}}`; + } + + ppTraitBody(item: AstTraitDeclaration): string { + switch (item.kind) { + case "field_decl": + return this.ppAstField(item); + case "function_decl": + case "function_def": + return this.ppAstFunction(item); + case "receiver": + return this.ppAstReceive(item); + case "constant_decl": + case "constant_def": + return this.ppAstConstant(item); + default: + return `Unknown Trait Body Type: ${item.kind}`; + } + } + + ppAstField(field: AstFieldDecl): string { + const typeFormatted = this.ppAstType(field.type); + const initializer = field.initializer + ? ` = ${this.ppAstExpression(field.initializer)}` + : ""; + const asAlias = field.as ? ` as ${field.as.text}` : ""; + return `${this.indent()}${field.name.text}: ${typeFormatted}${asAlias}${initializer};`; + } + + ppAstConstant(constant: AstConstantDecl | AstConstantDef): string { + const valueFormatted = + constant.kind === "constant_def" + ? ` = ${this.ppAstExpression(constant.initializer)}` + : ""; + const attrsRaw = constant.attributes.map((attr) => attr.type).join(" "); + const attrsFormatted = attrsRaw ? `${attrsRaw} ` : ""; + return `${this.indent()}${attrsFormatted}const ${constant.name.text}: ${this.ppAstType(constant.type)}${valueFormatted};`; + } + + ppAstContract(contract: AstContract): string { + const traitsFormatted = contract.traits + .map((trait) => trait.text) + .join(", "); + this.increaseIndent(); + const bodyFormatted = contract.declarations + .map((dec, index, array) => { + const formattedDec = this.ppContractBody(dec); + const nextDec = array[index + 1]; + if ( + (dec.kind === "constant_def" && + nextDec.kind === "constant_def") || + (dec.kind === "field_decl" && nextDec.kind === "field_decl") + ) { + return formattedDec; + } + return formattedDec + "\n"; + }) + .join("\n"); + this.decreaseIndent(); + const header = traitsFormatted + ? `contract ${contract.name.text} with ${traitsFormatted}` + : `contract ${contract.name.text}`; + const attrsRaw = contract.attributes + .map((attr) => `@interface("${attr.name.value}")`) + .join(" "); + const attrsFormatted = attrsRaw ? `${attrsRaw} ` : ""; + return `${this.indent()}${attrsFormatted}${header} {\n${bodyFormatted}${this.indent()}}`; + } + + ppContractBody(declaration: AstContractDeclaration): string { + switch (declaration.kind) { + case "field_decl": + return this.ppAstField(declaration); + case "function_def": + return this.ppAstFunction(declaration); + case "contract_init": + return this.ppAstInitFunction(declaration); + case "receiver": + return this.ppAstReceive(declaration); + case "constant_def": + return this.ppAstConstant(declaration); + default: + return `Unknown Contract Body Type: ${declaration.kind}`; } - case "bounce": - return `bounced(${receive.selector.param.name.text}: ${this.ppAstType(receive.selector.param.type)})`; - case "external": - switch (receive.selector.subKind.kind) { - case "simple": - return `external(${receive.selector.subKind.param.name.text}: ${this.ppAstType(receive.selector.subKind.param.type)})`; - case "fallback": - return `external()`; - case "comment": - return `external("${receive.selector.subKind.comment.value}")`; + } + + public ppAstFunction(func: AstFunctionDecl | AstFunctionDef): string { + const argsFormatted = func.params + .map((arg) => `${arg.name.text}: ${this.ppAstType(arg.type)}`) + .join(", "); + const attrsRaw = func.attributes.map((attr) => attr.type).join(" "); + const attrsFormatted = attrsRaw ? `${attrsRaw} ` : ""; + const returnType = func.return + ? `: ${this.ppAstType(func.return)}` + : ""; + this.increaseIndent(); + const stmtsFormatted = + func.kind === "function_def" + ? func.statements + .map((stmt) => this.ppAstStatement(stmt)) + .join("\n") + : ""; + const body = + func.kind === "function_def" + ? ` {\n${stmtsFormatted}\n${this.indent()}}` + : ";"; + this.decreaseIndent(); + return `${this.indent()}${attrsFormatted}fun ${func.name.text}(${argsFormatted})${returnType}${body}`; + } + + ppAstReceive(receive: AstReceiver): string { + const header = this.ppAstReceiveHeader(receive); + const stmtsFormatted = this.ppStatementBlock(receive.statements); + return `${this.indent()}${header} ${stmtsFormatted}`; + } + + ppAstReceiveHeader(receive: AstReceiver): string { + if (receive.selector.kind === "bounce") + return `bounced(${receive.selector.param.name.text}: ${this.ppAstType(receive.selector.param.type)})`; + const prefix = + receive.selector.kind === "internal" ? "receive" : "external"; + const suffix = + receive.selector.subKind.kind === "simple" + ? `(${receive.selector.subKind.param.name.text}: ${this.ppAstType(receive.selector.subKind.param.type)})` + : receive.selector.subKind.kind === "fallback" + ? "()" + : `("${receive.selector.subKind.comment.value}")`; + return prefix + suffix; + } + + ppAstNativeFunction(func: AstNativeFunctionDecl): string { + const argsFormatted = func.params + .map((arg) => `${arg.name.text}: ${this.ppAstType(arg.type)}`) + .join(", "); + const returnType = func.return + ? `: ${this.ppAstType(func.return)}` + : ""; + let attrs = func.attributes.map((attr) => attr.type).join(" "); + attrs = attrs ? attrs + " " : ""; + return `${this.indent()}@name(${func.nativeName.text})\n${this.indent()}${attrs}native ${func.name.text}(${argsFormatted})${returnType};`; + } + + ppAstInitFunction(initFunc: AstContractInit): string { + const argsFormatted = initFunc.params + .map((arg) => `${arg.name.text}: ${this.ppAstType(arg.type)}`) + .join(", "); + + this.increaseIndent(); + const stmtsFormatted = initFunc.statements + .map((stmt) => this.ppAstStatement(stmt)) + .join("\n"); + this.decreaseIndent(); + + return `${this.indent()}init(${argsFormatted}) {${stmtsFormatted === "" ? "" : "\n"}${stmtsFormatted}${stmtsFormatted === "" ? "" : "\n" + this.indent()}}`; + } + + // + // Statements + // + + ppAstStatement(stmt: AstStatement): string { + switch (stmt.kind) { + case "statement_let": + return this.ppAstStatementLet(stmt); + case "statement_return": + return this.ppAstStatementReturn(stmt); + case "statement_expression": + return this.ppAstStatementExpression(stmt); + case "statement_assign": + return this.ppAstStatementAssign(stmt); + case "statement_augmentedassign": + return this.ppAstStatementAugmentedAssign(stmt); + case "statement_condition": + return this.ppAstCondition(stmt); + case "statement_while": + return this.ppAstStatementWhile(stmt); + case "statement_until": + return this.ppAstStatementUntil(stmt); + case "statement_repeat": + return this.ppAstStatementRepeat(stmt); + case "statement_foreach": + return this.ppAstStatementForEach(stmt); + case "statement_try": + return this.ppAstStatementTry(stmt); + default: + return `Unsopported statement kind: ${stmt.kind}`; } - } //TODO: refactor: ends build equally, prefix also - } - - ppAstNativeFunction(func: AstNativeFunctionDecl): string { - const argsFormatted = func.params - .map((arg) => `${arg.name.text}: ${this.ppAstType(arg.type)}`) - .join(", "); - const returnType = func.return ? `: ${this.ppAstType(func.return)}` : ""; - let attrs = func.attributes.map((attr) => attr.type).join(" "); - attrs = attrs ? attrs + " " : ""; - return `${this.indent()}@name(${func.nativeName})\n${this.indent()}${attrs}native ${func.name}(${argsFormatted})${returnType};`; - } - - ppAstInitFunction(initFunc: AstContractInit): string { - const argsFormatted = initFunc.params - .map((arg) => `${arg.name.text}: ${this.ppAstType(arg.type)}`) - .join(", "); - - this.increaseIndent(); - const stmtsFormatted = initFunc.statements - ? initFunc.statements.map((stmt) => this.ppAstStatement(stmt)).join("\n") - : ""; - this.decreaseIndent(); - - return `${this.indent()}init(${argsFormatted}) {${stmtsFormatted == "" ? "" : "\n"}${stmtsFormatted}${stmtsFormatted == "" ? "" : "\n" + this.indent()}}`; - } - - // - // Statements - // - - ppAstStatement(stmt: AstStatement): string { - switch (stmt.kind) { - case "statement_let": - return this.ppAstStatementLet(stmt); - case "statement_return": - return this.ppAstStatementReturn(stmt); - case "statement_expression": - return this.ppAstStatementExpression(stmt); - case "statement_assign": - return this.ppAstStatementAssign(stmt); - case "statement_augmentedassign": - return this.ppAstStatementAugmentedAssign(stmt); - case "statement_condition": - return this.ppAstCondition(stmt); - case "statement_while": - return this.ppAstStatementWhile(stmt); - case "statement_until": - return this.ppAstStatementUntil(stmt); - case "statement_repeat": - return this.ppAstStatementRepeat(stmt); - case "statement_foreach": - return this.ppAstStatementForEach(stmt); - case "statement_try": - return this.ppAstStatementTry(stmt); - default: - return `Unsopported statement kind: ${stmt.kind}`; - } - } - - ppStatementBlock(stmts: readonly AstStatement[]): string { - this.increaseIndent(); - const stmntsFormatted = stmts - .map((stmt) => this.ppAstStatement(stmt)) - .join("\n"); - this.decreaseIndent(); - const result = `{\n${stmntsFormatted}\n${this.indent()}}`; - return result; - } - - ppAstStatementLet(statement: AstStatementLet): string { - const expression = this.ppAstExpression(statement.expression); - const tyAnnotation = - statement.type === undefined ? "" : `: ${this.ppAstType(statement.type)}`; - return `${this.indent()}let ${statement.name.text}${tyAnnotation} = ${expression};`; - } - - ppAstStatementReturn(statement: AstStatementReturn): string { - const expression = statement.expression - ? this.ppAstExpression(statement.expression) - : ""; - return `${this.indent()}return ${expression};`; - } - - ppAstStatementExpression(statement: AstStatementExpression): string { - return `${this.indent()}${this.ppAstExpression(statement.expression)};`; - } - - ppAstStatementAssign(statement: AstStatementAssign): string { - return `${this.indent()}${this.ppAstExpression(statement.path)} = ${this.ppAstExpression(statement.expression)};`; - } - - ppAstStatementAugmentedAssign( - statement: AstStatementAugmentedAssign, - ): string { - return `${this.indent()}${this.ppAstExpression(statement.path)} ${statement.op}= ${this.ppAstExpression(statement.expression)};`; - } - - ppAstCondition(statement: AstStatementCondition): string { - const condition = this.ppAstExpression(statement.condition); - const trueBranch = this.ppStatementBlock(statement.trueStatements); - const falseBranch = statement.falseStatements - ? ` else ${this.ppStatementBlock(statement.falseStatements)}` - : ""; - return `${this.indent()}if (${condition}) ${trueBranch}${falseBranch}`; - } - - ppAstStatementWhile(statement: AstStatementWhile): string { - const condition = this.ppAstExpression(statement.condition); - const stmts = this.ppStatementBlock(statement.statements); - return `${this.indent()}while (${condition}) ${stmts}`; - } - - ppAstStatementRepeat(statement: AstStatementRepeat): string { - const condition = this.ppAstExpression(statement.iterations); - const stmts = this.ppStatementBlock(statement.statements); - return `${this.indent()}repeat (${condition}) ${stmts}`; - } - - ppAstStatementUntil(statement: AstStatementUntil): string { - const condition = this.ppAstExpression(statement.condition); - const stmts = this.ppStatementBlock(statement.statements); - return `${this.indent()}do ${stmts} until (${condition});`; - } - - ppAstStatementForEach(statement: AstStatementForEach): string { - const header = `foreach (${statement.keyName}, ${statement.valueName} in ${this.ppAstExpression(statement.map)})`; - const body = this.ppStatementBlock(statement.statements); - return `${this.indent()}${header} ${body}`; - } - - ppAstStatementTry(statement: AstStatementTry): string { - const tryBody = this.ppStatementBlock(statement.statements); - const tryPrefix = `${this.indent()}try ${tryBody}`; - const catchSuffix = statement.catchBlock - ? ` catch (${statement.catchBlock.catchName.text}) ${this.ppStatementBlock(statement.catchBlock.catchStatements)}` - : ""; - return tryPrefix + catchSuffix; - } + } + + ppStatementBlock(stmts: readonly AstStatement[]): string { + this.increaseIndent(); + const stmntsFormatted = stmts + .map((stmt) => this.ppAstStatement(stmt)) + .join("\n"); + this.decreaseIndent(); + const result = `{\n${stmntsFormatted}\n${this.indent()}}`; + return result; + } + + ppAstStatementLet(statement: AstStatementLet): string { + const expression = this.ppAstExpression(statement.expression); + const tyAnnotation = + statement.type === undefined + ? "" + : `: ${this.ppAstType(statement.type)}`; + return `${this.indent()}let ${statement.name.text}${tyAnnotation} = ${expression};`; + } + + ppAstStatementReturn(statement: AstStatementReturn): string { + const expression = statement.expression + ? this.ppAstExpression(statement.expression) + : ""; + return `${this.indent()}return ${expression};`; + } + + ppAstStatementExpression(statement: AstStatementExpression): string { + return `${this.indent()}${this.ppAstExpression(statement.expression)};`; + } + + ppAstStatementAssign(statement: AstStatementAssign): string { + return `${this.indent()}${this.ppAstExpression(statement.path)} = ${this.ppAstExpression(statement.expression)};`; + } + + ppAstStatementAugmentedAssign( + statement: AstStatementAugmentedAssign, + ): string { + return `${this.indent()}${this.ppAstExpression(statement.path)} ${statement.op}= ${this.ppAstExpression(statement.expression)};`; + } + + ppAstCondition(statement: AstStatementCondition): string { + const condition = this.ppAstExpression(statement.condition); + const trueBranch = this.ppStatementBlock(statement.trueStatements); + const falseBranch = statement.falseStatements + ? ` else ${this.ppStatementBlock(statement.falseStatements)}` + : ""; + return `${this.indent()}if (${condition}) ${trueBranch}${falseBranch}`; + } + + ppAstStatementWhile(statement: AstStatementWhile): string { + const condition = this.ppAstExpression(statement.condition); + const stmts = this.ppStatementBlock(statement.statements); + return `${this.indent()}while (${condition}) ${stmts}`; + } + + ppAstStatementRepeat(statement: AstStatementRepeat): string { + const condition = this.ppAstExpression(statement.iterations); + const stmts = this.ppStatementBlock(statement.statements); + return `${this.indent()}repeat (${condition}) ${stmts}`; + } + + ppAstStatementUntil(statement: AstStatementUntil): string { + const condition = this.ppAstExpression(statement.condition); + const stmts = this.ppStatementBlock(statement.statements); + return `${this.indent()}do ${stmts} until (${condition});`; + } + + ppAstStatementForEach(statement: AstStatementForEach): string { + const header = `foreach (${statement.keyName.text}, ${statement.valueName.text} in ${this.ppAstExpression(statement.map)})`; + const body = this.ppStatementBlock(statement.statements); + return `${this.indent()}${header} ${body}`; + } + + ppAstStatementTry(statement: AstStatementTry): string { + const tryBody = this.ppStatementBlock(statement.statements); + const tryPrefix = `${this.indent()}try ${tryBody}`; + const catchSuffix = statement.catchBlock + ? ` catch (${statement.catchBlock.catchName.text}) ${this.ppStatementBlock(statement.catchBlock.catchStatements)}` + : ""; + return tryPrefix + catchSuffix; + } } /** @@ -583,38 +582,38 @@ class PrettyPrinter { */ // eslint-disable-next-line @typescript-eslint/no-explicit-any export function formatAst(input: AstNode): string { - const pp = new PrettyPrinter(); - switch (input.kind) { - case "module": - return pp.ppAstProgram(input); - case "op_binary": - case "op_unary": - case "field_access": - case "method_call": - case "static_call": - case "struct_instance": - case "init_of": - case "conditional": - case "number": - case "id": - case "boolean": - case "string": - case "null": - return pp.ppAstExpression(input); - case "struct_decl": - case "message_decl": - return pp.ppAstStruct(input); - case "constant_decl": - case "constant_def": - return pp.ppAstConstant(input); - case "function_decl": - case "function_def": - return pp.ppAstFunction(input); - case "contract": - return pp.ppAstContract(input); - case "trait": - return pp.ppAstTrait(input); - default: - throw new Error(`Unsupported Ast type: ${input.kind}`); - } + const pp = new PrettyPrinter(); + switch (input.kind) { + case "module": + return pp.ppAstProgram(input); + case "op_binary": + case "op_unary": + case "field_access": + case "method_call": + case "static_call": + case "struct_instance": + case "init_of": + case "conditional": + case "number": + case "id": + case "boolean": + case "string": + case "null": + return pp.ppAstExpression(input); + case "struct_decl": + case "message_decl": + return pp.ppAstStruct(input); + case "constant_decl": + case "constant_def": + return pp.ppAstConstant(input); + case "function_decl": + case "function_def": + return pp.ppAstFunction(input); + case "contract": + return pp.ppAstContract(input); + case "trait": + return pp.ppAstTrait(input); + default: + throw new Error(`Unsupported Ast type: ${input.kind}`); + } } diff --git a/fuzzer/src/generators/constant.ts b/fuzzer/src/generators/constant.ts index 9ad56cc290..ce4c58ef92 100644 --- a/fuzzer/src/generators/constant.ts +++ b/fuzzer/src/generators/constant.ts @@ -1,17 +1,18 @@ -import { - AstConstantDecl, - AstConstantDef, - AstConstantAttribute, - AstExpression, +import type { + AstConstantDecl, + AstConstantDef, + AstConstantAttribute, + AstExpression, } from "../../../src/ast/ast"; import { - generateAstIdFromName, - createSample, - generateAstId, - generateName, + generateAstIdFromName, + createSample, + generateAstId, + generateName, } from "../util"; -import { tyToAstType, Type } from "../types"; -import { Scope } from "../scope"; +import { tyToAstType } from "../types"; +import type { Type } from "../types"; +import type { Scope } from "../scope"; import { GenerativeEntity } from "./generator"; import fc from "fast-check"; @@ -21,46 +22,46 @@ import { dummySrcInfo } from "../../../src/grammar/"; * An object that encapsulates a generated AstConstantDecl. */ export class ConstantDecl extends GenerativeEntity { - constructor(scope: Scope, type: Type) { - super(type); - this.name = createSample(generateAstId(scope, "constantDecl")); - } + constructor(scope: Scope, type: Type) { + super(type); + this.name = createSample(generateAstId(scope, "constantDecl")); + } - private getAttributes( - extraAttrs: AstConstantAttribute[], - ): AstConstantAttribute[] { - const attrs: AstConstantAttribute[] = extraAttrs; - attrs.push({ type: "abstract", loc: dummySrcInfo }); - return attrs; - } + private getAttributes( + extraAttrs: AstConstantAttribute[], + ): AstConstantAttribute[] { + const attrs: AstConstantAttribute[] = extraAttrs; + attrs.push({ type: "abstract", loc: dummySrcInfo }); + return attrs; + } - private generateImpl( - extraAttrs: AstConstantAttribute[], - ): fc.Arbitrary { - return fc.record({ - kind: fc.constant("constant_decl"), - id: fc.constant(this.idx), - name: fc.constant(this.name!), - type: fc.constant(tyToAstType(this.type)), - attributes: fc.constantFrom(this.getAttributes(extraAttrs)), - loc: fc.constant(dummySrcInfo), - }); - } + private generateImpl( + extraAttrs: AstConstantAttribute[], + ): fc.Arbitrary { + return fc.record({ + kind: fc.constant("constant_decl"), + id: fc.constant(this.idx), + name: fc.constant(this.name!), + type: fc.constant(tyToAstType(this.type)), + attributes: fc.constantFrom(this.getAttributes(extraAttrs)), + loc: fc.constant(dummySrcInfo), + }); + } - /** - * Generates a constant declaration without extra attributes. - */ - public generate(): fc.Arbitrary { - return this.generateImpl([]); - } + /** + * Generates a constant declaration without extra attributes. + */ + public generate(): fc.Arbitrary { + return this.generateImpl([]); + } - /** - * Create definition for this constant destination. - * @param init An initializer evaluable in compile-time. - */ - public createDefinition(init: fc.Arbitrary): ConstantDef { - return new ConstantDef(this.name?.text!, this.type, init); - } + /** + * Create definition for this constant destination. + * @param init An initializer evaluable in compile-time. + */ + public createDefinition(init: fc.Arbitrary): ConstantDef { + return new ConstantDef(this.name?.text!, this.type, init); + } } /** @@ -68,66 +69,66 @@ export class ConstantDecl extends GenerativeEntity { * @parentScope Scope this constant belongs to. */ export class ConstantDef extends GenerativeEntity { - /** - * Create new constant definition from its name and type. Used to create definition from an existing declaration. - * @param init An initializer evaluable in compile-time. - */ - constructor( - name: string, - type: Type, - private init: fc.Arbitrary, - ) { - super(type); - this.name = generateAstIdFromName(name); - } -/** - * Create a new constant definition generation name from scope. - * @param scope Scope to generate constant name from. - * @param type Constant type. - * @param init An initializer evaluable in compile-time. - */ - public static fromScope( - scope: Scope, - type: Type, - init: fc.Arbitrary, - ): ConstantDef { - return new ConstantDef( - createSample(generateName(scope, "constantDef")), - type, - init, - ); - } + /** + * Create new constant definition from its name and type. Used to create definition from an existing declaration. + * @param init An initializer evaluable in compile-time. + */ + constructor( + name: string, + type: Type, + private init: fc.Arbitrary, + ) { + super(type); + this.name = generateAstIdFromName(name); + } + /** + * Create a new constant definition generation name from scope. + * @param scope Scope to generate constant name from. + * @param type Constant type. + * @param init An initializer evaluable in compile-time. + */ + public static fromScope( + scope: Scope, + type: Type, + init: fc.Arbitrary, + ): ConstantDef { + return new ConstantDef( + createSample(generateName(scope, "constantDef")), + type, + init, + ); + } - private generateImpl( - extraAttrs: AstConstantAttribute[], - init?: fc.Arbitrary, - ): fc.Arbitrary { - const choosenInit = init !== undefined ? init : this.init; - return fc.record({ - kind: fc.constant("constant_def"), - id: fc.constant(this.idx), - name: fc.constant(this.name!), - type: fc.constant(tyToAstType(this.type)), - initializer: choosenInit, - attributes: fc.constantFrom(extraAttrs), - loc: fc.constant(dummySrcInfo), - }); - } + private generateImpl( + extraAttrs: AstConstantAttribute[], + init?: fc.Arbitrary, + ): fc.Arbitrary { + const choosenInit = init ?? this.init; + return fc.record({ + kind: fc.constant("constant_def"), + id: fc.constant(this.idx), + name: fc.constant(this.name!), + type: fc.constant(tyToAstType(this.type)), + initializer: choosenInit, + attributes: fc.constantFrom(extraAttrs), + loc: fc.constant(dummySrcInfo), + }); + } - /** - * Generates a constant definition without extra attributes. - */ - public generate(): fc.Arbitrary { - return this.generateImpl([]); - } + /** + * Generates a constant definition without extra attributes. + */ + public generate(): fc.Arbitrary { + return this.generateImpl([]); + } - /** - * Generates a constant definition with extra attributes and overriden init. - */ - public generateWithAttrs( - extraAttrs: AstConstantAttribute[] = [], - init?: fc.Arbitrary, - ): fc.Arbitrary { - return this.generateImpl(extraAttrs, init); - } + /** + * Generates a constant definition with extra attributes and overriden init. + */ + public generateWithAttrs( + extraAttrs: AstConstantAttribute[] = [], + init?: fc.Arbitrary, + ): fc.Arbitrary { + return this.generateImpl(extraAttrs, init); + } } diff --git a/fuzzer/src/generators/contract.ts b/fuzzer/src/generators/contract.ts index 90cdc353eb..bb504f5c8b 100644 --- a/fuzzer/src/generators/contract.ts +++ b/fuzzer/src/generators/contract.ts @@ -1,15 +1,16 @@ -import { - AstContract, - AstConstantDef, - AstFunctionDef, - AstFieldDecl, +import type { + AstContract, + AstConstantDef, + AstFunctionDef, + AstFieldDecl, } from "../../../src/ast/ast"; import { createSample, generateAstId } from "../util"; import { FunctionDef } from "./function"; -import { Trait } from "./trait"; +import type { Trait } from "./trait"; import { Expression } from "./expression"; import { Receive } from "./receiver"; -import { FunctionType, UtilType } from "../types"; +import { UtilType } from "../types"; +import type { FunctionType } from "../types"; import { Scope } from "../scope"; import { GenerativeEntity } from "./generator"; @@ -18,11 +19,11 @@ import { Field } from "./field"; import { dummySrcInfo } from "../../../src/grammar/"; export interface ContractParameters { - /** - * Number of receive method generated within a contract. - * @default 1 - */ - receiveNum: number; + /** + * Number of receive method generated within a contract. + * @default 1 + */ + receiveNum: number; } /** @@ -30,101 +31,111 @@ export interface ContractParameters { * about its entries and their scopes. */ export class Contract extends GenerativeEntity { - /** Scope used within the generated contract. */ - private scope: Scope; + /** Scope used within the generated contract. */ + private scope: Scope; - private receiveNum: number; + private receiveNum: number; - /** - * @param methodSignatures Signatures of methods to be generated in the contract. - * @param trait An optional trait that the generated contract must implement. - */ - constructor( - parentScope: Scope, - private methodSignatures: FunctionType[], - private trait?: Trait, - params: Partial = {}, - ) { - super({ kind: "util", type: UtilType.Contract }); - this.scope = new Scope("contract", parentScope); - this.name = createSample(generateAstId(this.scope, "contract")); + /** + * @param methodSignatures Signatures of methods to be generated in the contract. + * @param trait An optional trait that the generated contract must implement. + */ + constructor( + parentScope: Scope, + private methodSignatures: FunctionType[], + private trait?: Trait, + params: Partial = {}, + ) { + super({ kind: "util", type: UtilType.Contract }); + this.scope = new Scope("contract", parentScope); + this.name = createSample(generateAstId(this.scope, "contract")); - const { receiveNum = 1 } = params; - this.receiveNum = receiveNum; - } + const { receiveNum = 1 } = params; + this.receiveNum = receiveNum; + } + + public generate(): fc.Arbitrary { + // Implemented declarations from the trait + let traitFields: fc.Arbitrary[] = []; + let traitConstants: fc.Arbitrary[] = []; + let traitMethods: fc.Arbitrary[] = []; + if (this.trait !== undefined) { + traitFields = this.trait.fieldDeclarations.map(({ type, name }) => { + const init = new Expression(this.scope, type, { + compileTimeEval: true, + }).generate(); + return new Field(this.scope, type, init, name).generate(); + }); + traitConstants = this.trait.constantDeclarations + .map((decl) => { + const init = new Expression(this.scope, decl.type, { + compileTimeEval: true, + }).generate(); + return decl + .createDefinition(init) + .generateWithAttrs([ + { type: "override", loc: dummySrcInfo }, + ]); + }) + .concat( + this.trait.constantDefinitions.map((def) => + def.generateWithAttrs([ + { type: "override", loc: dummySrcInfo }, + ]), + ), + ); + traitMethods = this.trait.methodDeclarations.map((m) => { + return m.generateDefinition("method", [ + { + kind: "function_attribute", + type: "override", + loc: dummySrcInfo, + }, + { + kind: "function_attribute", + type: "get", + loc: dummySrcInfo, + methodId: undefined, + }, + ]); + }); + } - public generate(): fc.Arbitrary { - // Implemented declarations from the trait - let traitFields: fc.Arbitrary[] = []; - let traitConstants: fc.Arbitrary[] = []; - let traitMethods: fc.Arbitrary[] = []; - if (this.trait !== undefined) { - traitFields = this.trait.fieldDeclarations.map(({ type, name }) => { - const init = new Expression(this.scope, type, { - compileTimeEval: true, - }).generate(); - return new Field(this.scope, type, init, name).generate(); - }); - traitConstants = this.trait.constantDeclarations - .map((decl) => { - const init = new Expression(this.scope, decl.type, { - compileTimeEval: true, - }).generate(); - return decl - .createDefinition(init) - .generateWithAttrs([{ type: "override", loc: dummySrcInfo }]); - }) - .concat( - this.trait.constantDefinitions.map((def) => - def.generateWithAttrs([{ type: "override", loc: dummySrcInfo }]), - ), + const requestedMethods = this.methodSignatures.map((signature) => + new FunctionDef(this.scope, "method", signature).generate(), + ); + const generatedMethods = Array.from(this.scope.getAll("methodDef")).map( + (m) => m.generate(), ); - traitMethods = this.trait.methodDeclarations.map((m) => { - return m.generateDefinition("method", [ - { kind: "function_attribute", type: "override", loc: dummySrcInfo }, - { - kind: "function_attribute", - type: "get", - loc: dummySrcInfo, - methodId: undefined, - }, - ]); - }); + const requestedReceives = Array.from({ length: this.receiveNum }).map( + (_) => new Receive(this.scope).generate(), + ); + const generatedConstants = Array.from( + this.scope.getAll("constantDef"), + ).map((c) => c.generate()); + const generatedFields = Array.from(this.scope.getAll("field")).map( + (f) => f.generate(), + ); + return fc.record({ + kind: fc.constant("contract"), + id: fc.constant(this.idx), + name: fc.constant(this.name!), + traits: fc.constant( + this.trait === undefined ? [] : [this.trait.name!], + ), + attributes: fc.constantFrom([]), + declarations: fc.tuple( + ...traitConstants, + ...generatedConstants, + ...traitFields, + ...generatedFields, + ...requestedReceives, + ...traitMethods, + ...generatedMethods, + ...requestedMethods, + ), + loc: fc.constant(dummySrcInfo), + params: fc.constant(undefined), + }); } - - const requestedMethods = this.methodSignatures.map((signature) => - new FunctionDef(this.scope, "method", signature).generate(), - ); - const generatedMethods = Array.from(this.scope.getAll("methodDef")).map( - (m) => m.generate(), - ); - const requestedReceives = Array.from({ length: this.receiveNum }).map((_) => - new Receive(this.scope).generate(), - ); - const generatedConstants = Array.from(this.scope.getAll("constantDef")).map( - (c) => c.generate(), - ); - const generatedFields = Array.from(this.scope.getAll("field")).map((f) => - f.generate(), - ); - return fc.record({ - kind: fc.constant("contract"), - id: fc.constant(this.idx), - name: fc.constant(this.name!), - traits: fc.constant(this.trait === undefined ? [] : [this.trait.name!]), - attributes: fc.constantFrom([]), - declarations: fc.tuple( - ...traitConstants, - ...generatedConstants, - ...traitFields, - ...generatedFields, - ...requestedReceives, - ...traitMethods, - ...generatedMethods, - ...requestedMethods, - ), - loc: fc.constant(dummySrcInfo), - params: fc.constant(undefined), - }); - } } diff --git a/fuzzer/src/generators/expression.ts b/fuzzer/src/generators/expression.ts index 54698de1b0..ddae83a6a9 100644 --- a/fuzzer/src/generators/expression.ts +++ b/fuzzer/src/generators/expression.ts @@ -1,4 +1,4 @@ -import { +import type { AstBoolean, AstExpression, AstId, @@ -12,9 +12,9 @@ import { AstSimplifiedString, AstStructFieldInitializer, AstStructInstance, - AstNumberBase, AstString, } from "../../../src/ast/ast"; +import { AstNumberBase } from "../../../src/ast/ast"; import JSONbig from "json-bigint"; import fc from "fast-check"; @@ -34,17 +34,16 @@ import { tyToString, tyEq, UtilType, - Type, throwTyError, makeFunctionTy, - StructField, } from "../types"; +import type { StructField, Type } from "../types"; import { GlobalContext } from "../context"; -import { Scope } from "../scope"; +import type { Scope } from "../scope"; import { dummySrcInfo } from "../../../src/grammar/"; import { FunctionDef } from "./function"; -export function generateNumber( //TODO: add random base generation or pass the needed one, where number is generated +export function generateNumber( base?: AstNumberBase, constValue?: bigint, ): fc.Arbitrary { @@ -55,7 +54,7 @@ export function generateNumber( //TODO: add random base generation or pass the n id: fc.constant(nextId()), value, loc: fc.constant(dummySrcInfo), - base: fc.constant(base ?? 10), + base: base ? fc.constant(base) : fc.constantFrom(2, 8, 10, 16), }); } @@ -235,7 +234,7 @@ export class FieldAccess extends GenerativeEntity { generate(): fc.Arbitrary { return fc.record({ kind: fc.constant("field_access"), - aggregate: fc.constant(this.src ? this.src : generateThisID()), + aggregate: fc.constant(this.src ?? generateThisID()), field: fc.constant(this.name!), id: fc.constant(this.idx), loc: fc.constant(dummySrcInfo), @@ -703,9 +702,6 @@ export class Expression extends GenerativeEntity { compileTimeEval: true, }).generate(); const field = new Field(this.parentScope, ty, init); - if (field === undefined) { - return undefined; - } this.parentScope.add("field", field); fieldNames.push(field.name?.text!); } @@ -732,9 +728,6 @@ export class Expression extends GenerativeEntity { if (varNames.length === 0) { const init = new Expression(this.parentScope, ty).generate(); const varStmt = new Let(this.parentScope, ty, init); - if (varStmt === undefined) { - return undefined; - } this.parentScope.add("let", varStmt); varNames.push(varStmt.name?.text!); } diff --git a/fuzzer/src/generators/field.ts b/fuzzer/src/generators/field.ts index 27a43d667b..5f09e5c669 100644 --- a/fuzzer/src/generators/field.ts +++ b/fuzzer/src/generators/field.ts @@ -1,7 +1,8 @@ -import { AstFieldDecl, AstExpression, AstId } from "../../../src/ast/ast"; +import type { AstFieldDecl, AstExpression, AstId } from "../../../src/ast/ast"; import { createSample, generateAstId } from "../util"; -import { tyToAstType, Type } from "../types"; -import { Scope } from "../scope"; +import { tyToAstType } from "../types"; +import type { Type } from "../types"; +import type { Scope } from "../scope"; import { GenerativeEntity } from "./generator"; import fc from "fast-check"; @@ -34,10 +35,7 @@ export class Field extends GenerativeEntity { ); } super(type); - this.name = - name === undefined - ? createSample(generateAstId(parentScope, "field")) - : name; + this.name = name ?? createSample(generateAstId(parentScope, "field")); } generate(): fc.Arbitrary { @@ -46,8 +44,7 @@ export class Field extends GenerativeEntity { id: fc.constant(this.idx), name: fc.constant(this.name!), type: fc.constant(tyToAstType(this.type)), - initializer: - this.init === undefined ? fc.constant(undefined) : this.init, + initializer: this.init ?? fc.constant(undefined), as: fc.constantFrom(undefined), loc: fc.constant(dummySrcInfo), }); diff --git a/fuzzer/src/generators/function.ts b/fuzzer/src/generators/function.ts index 77ca373d34..dd60595986 100644 --- a/fuzzer/src/generators/function.ts +++ b/fuzzer/src/generators/function.ts @@ -1,20 +1,19 @@ -import { - AstFunctionDef, - AstTypedParameter, - AstFunctionAttribute, - AstStatement, - AstFunctionDecl, +import type { + AstFunctionDef, + AstTypedParameter, + AstFunctionAttribute, + AstStatement, + AstFunctionDecl, } from "../../../src/ast/ast"; import { - tyToAstType, - StdlibType, - FunctionType, - Type, - isThis, - getReturnType, - isUnit, - UtilType, + tyToAstType, + StdlibType, + isThis, + getReturnType, + isUnit, + UtilType, } from "../types"; +import type { FunctionType, Type } from "../types"; import { Return } from "./statement"; import { Parameter } from "./parameter"; import { Scope } from "../scope"; @@ -30,74 +29,74 @@ import fc from "fast-check"; type FunctionKind = "function" | "method"; export const SUPPORTED_RETURN_TYS = [ - StdlibType.Int, - StdlibType.Bool, - StdlibType.String, + StdlibType.Int, + StdlibType.Bool, + StdlibType.String, ]; function doesntHaveArguments(kind: FunctionKind, type: FunctionType): boolean { - if (kind === "function") { - return type.signature.length === 1; - } else { - const firstArg = type.signature[0]; - return isThis(firstArg) && type.signature.length === 2; - } + if (kind === "function") { + return type.signature.length === 1; + } else { + const firstArg = type.signature[0]; + return isThis(firstArg) && type.signature.length === 2; + } } /** * Creates parameters entries saving them in the scope of the function or method as variables. */ function generateParameters( - kind: FunctionKind, - type: FunctionType, - scope: Scope, + kind: FunctionKind, + type: FunctionType, + scope: Scope, ): AstTypedParameter[] { - if (doesntHaveArguments(kind, type)) { - return []; - } - const slice = - kind === "method" - ? type.signature.slice(1, -1) - : type.signature.slice(0, -1); - return slice.map((argty) => { - const param = new Parameter(scope, argty); - scope.add("parameter", param); - return createSample(param.generate()); - }); + if (doesntHaveArguments(kind, type)) { + return []; + } + const slice = + kind === "method" + ? type.signature.slice(1, -1) + : type.signature.slice(0, -1); + return slice.map((argty) => { + const param = new Parameter(scope, argty); + scope.add("parameter", param); + return createSample(param.generate()); + }); } /** * Prepares the final list of attributes based on function kind and the current implementation details. */ function getAttributes( - extraAttrs: AstFunctionAttribute[], - kind: FunctionKind, - onlyDeclaration: boolean, + extraAttrs: AstFunctionAttribute[], + kind: FunctionKind, + onlyDeclaration: boolean, ): AstFunctionAttribute[] { - const attrs: AstFunctionAttribute[] = extraAttrs; - - // We are marking all the methods with the `get` attribute to ensure they - // will be compiled to func and tested by compilation tests. - // TODO: However, we cannot use `get` for abstract and overridden methods: - // https://github.com/tact-lang/tact/issues/490 - if (kind === "method" && !extraAttrs.find((a) => a.type === "override")) { - attrs.push({ - kind: "function_attribute", - type: "get", - loc: dummySrcInfo, - methodId: undefined, - }); - } - - if (onlyDeclaration) { - attrs.push({ - kind: "function_attribute", - type: "abstract", - loc: dummySrcInfo, - }); - } - - return attrs; + const attrs: AstFunctionAttribute[] = extraAttrs; + + // We are marking all the methods with the `get` attribute to ensure they + // will be compiled to func and tested by compilation tests. + // TODO: However, we cannot use `get` for abstract and overridden methods: + // https://github.com/tact-lang/tact/issues/490 + if (kind === "method" && !extraAttrs.find((a) => a.type === "override")) { + attrs.push({ + kind: "function_attribute", + type: "get", + loc: dummySrcInfo, + methodId: undefined, + }); + } + + if (onlyDeclaration) { + attrs.push({ + kind: "function_attribute", + type: "abstract", + loc: dummySrcInfo, + }); + } + + return attrs; } /** @@ -105,77 +104,85 @@ function getAttributes( * its scope and nested elements. */ export class FunctionDef extends GenerativeEntity { - /** Generated body items. */ - private body: fc.Arbitrary[] = []; - - /** Scope used within the generated function. */ - private scope: Scope; - - private kind: FunctionKind; - - constructor( - parentScope: Scope, - kind: FunctionKind, - type: FunctionType, - name?: string, - ) { - super(type); - this.scope = new Scope(kind, parentScope); - this.kind = kind; - this.name = name - ? generateAstIdFromName(name) - : createSample( - generateAstId( - this.scope, - kind === "function" ? "functionDef" : "methodDef", - ), + /** Generated body items. */ + private body: fc.Arbitrary[] = []; + + /** Scope used within the generated function. */ + private scope: Scope; + + private kind: FunctionKind; + + constructor( + parentScope: Scope, + kind: FunctionKind, + type: FunctionType, + name?: string, + ) { + super(type); + this.scope = new Scope(kind, parentScope); + this.kind = kind; + this.name = name + ? generateAstIdFromName(name) + : createSample( + generateAstId( + this.scope, + kind === "function" ? "functionDef" : "methodDef", + ), + ); + } + + /** + * Generates body of the function emitting return statement and statements generated from the bottom-up. + */ + private generateBody(): fc.Arbitrary { + const type = this.type as FunctionType; + const returnTy: Type = + type.signature.length > 0 + ? getReturnType(type) + : { kind: "util", type: UtilType.Unit }; + const returnStmt = new Return(this.scope, returnTy).generate(); + const generatedLetBindings = Array.from(this.scope.getAll("let")).map( + (c) => c.generate(), ); - } - - /** - * Generates body of the function emitting return statement and statements generated from the bottom-up. - */ - private generateBody(): fc.Arbitrary { - const type = this.type as FunctionType; - const returnTy: Type = - type.signature.length > 0 - ? getReturnType(type) - : { kind: "util", type: UtilType.Unit }; - const returnStmt = new Return(this.scope, returnTy).generate(); - const generatedLetBindings = Array.from(this.scope.getAll("let")).map((c) => - c.generate(), - ); - const generatedStmts = Array.from(this.scope.getAll("statement")).map((c) => - c.generate(), - ); - this.body = [...generatedLetBindings, ...generatedStmts, returnStmt]; - return fc.tuple(...this.body); - } - - public generateImpl( - extraAttrs: AstFunctionAttribute[], - ): fc.Arbitrary { - const returnTy = getReturnType(this.type as FunctionType); - return fc.record({ - kind: fc.constant("function_def"), - id: fc.constant(this.idx), - attributes: fc.constant(getAttributes(extraAttrs, this.kind, false)), - name: fc.constant(this.name!), - return: fc.constant(isUnit(returnTy) ? undefined : tyToAstType(returnTy)), - params: fc.constant( - generateParameters(this.kind, this.type as FunctionType, this.scope), - ), - statements: this.generateBody(), - loc: fc.constant(dummySrcInfo), - }); - } - - /** - * Generates a function definition without extra attributes. - */ - public generate(): fc.Arbitrary { - return this.generateImpl([]); - } + const generatedStmts = Array.from(this.scope.getAll("statement")).map( + (c) => c.generate(), + ); + this.body = [...generatedLetBindings, ...generatedStmts, returnStmt]; + return fc.tuple(...this.body); + } + + public generateImpl( + extraAttrs: AstFunctionAttribute[], + ): fc.Arbitrary { + const returnTy = getReturnType(this.type as FunctionType); + return fc.record({ + kind: fc.constant("function_def"), + id: fc.constant(this.idx), + attributes: fc.constant( + getAttributes(extraAttrs, this.kind, false), + ), + name: fc.constant(this.name!), + return: fc.constant( + isUnit(returnTy) ? undefined : tyToAstType(returnTy), + ), + params: fc.constant( + generateParameters( + this.kind, + this.type as FunctionType, + this.scope, + ), + ), + statements: this.generateBody(), + loc: fc.constant(dummySrcInfo), + }); + } + + /** + * Generates a function definition without extra attributes. + */ + public generate(): fc.Arbitrary { + return this.generateImpl([]); + } } /** @@ -183,59 +190,65 @@ export class FunctionDef extends GenerativeEntity { * its scope and nested elements. */ export class FunctionDecl extends GenerativeEntity { - /** Scope used within the generated function. */ - private scope: Scope; - - private kind: FunctionKind; - - constructor(parentScope: Scope, kind: FunctionKind, type: FunctionType) { - super(type); - this.kind = "method"; - this.scope = new Scope(kind, parentScope); - this.name = createSample( - generateAstId( - this.scope, - kind === "function" ? "functionDecl" : "methodDecl", - ), - ); - } - - private generateImpl( - extraAttrs: AstFunctionAttribute[], - ): fc.Arbitrary { - const returnTy = getReturnType(this.type as FunctionType); - return fc.record({ - kind: fc.constant("function_decl"), - id: fc.constant(this.idx), - attributes: fc.constant(getAttributes(extraAttrs, this.kind, true)), - name: fc.constant(this.name!), - return: fc.constant(isUnit(returnTy) ? undefined : tyToAstType(returnTy)), - params: fc.constant( - generateParameters(this.kind, this.type as FunctionType, this.scope), - ), - loc: fc.constant(dummySrcInfo), - }); - } - - /** - * Generates a function definition without extra attributes. - */ - public generate(): fc.Arbitrary { - return this.generateImpl([]); - } - - /** - * Generates a new function definition for this declaration. - */ - public generateDefinition( - kind: FunctionKind, - attrs: AstFunctionAttribute[] = [], - ): fc.Arbitrary { - return new FunctionDef( - this.scope.parentScope!, - kind, - this.type as FunctionType, - this.name!.text, - ).generateImpl(attrs); - } + /** Scope used within the generated function. */ + private scope: Scope; + + private kind: FunctionKind; + + constructor(parentScope: Scope, kind: FunctionKind, type: FunctionType) { + super(type); + this.kind = "method"; + this.scope = new Scope(kind, parentScope); + this.name = createSample( + generateAstId( + this.scope, + kind === "function" ? "functionDecl" : "methodDecl", + ), + ); + } + + private generateImpl( + extraAttrs: AstFunctionAttribute[], + ): fc.Arbitrary { + const returnTy = getReturnType(this.type as FunctionType); + return fc.record({ + kind: fc.constant("function_decl"), + id: fc.constant(this.idx), + attributes: fc.constant(getAttributes(extraAttrs, this.kind, true)), + name: fc.constant(this.name!), + return: fc.constant( + isUnit(returnTy) ? undefined : tyToAstType(returnTy), + ), + params: fc.constant( + generateParameters( + this.kind, + this.type as FunctionType, + this.scope, + ), + ), + loc: fc.constant(dummySrcInfo), + }); + } + + /** + * Generates a function definition without extra attributes. + */ + public generate(): fc.Arbitrary { + return this.generateImpl([]); + } + + /** + * Generates a new function definition for this declaration. + */ + public generateDefinition( + kind: FunctionKind, + attrs: AstFunctionAttribute[] = [], + ): fc.Arbitrary { + return new FunctionDef( + this.scope.parentScope!, + kind, + this.type as FunctionType, + this.name!.text, + ).generateImpl(attrs); + } } diff --git a/fuzzer/src/generators/generator.ts b/fuzzer/src/generators/generator.ts index 19d3d28ddc..209afc7167 100644 --- a/fuzzer/src/generators/generator.ts +++ b/fuzzer/src/generators/generator.ts @@ -1,35 +1,36 @@ -import { AstId } from "../../../src/ast/ast"; -import { IDIdx, nextId } from "../id"; -import { Type } from "../types"; +import type { AstId } from "../../../src/ast/ast"; +import { nextId } from "../id"; +import type { IDIdx } from "../id"; +import type { Type } from "../types"; -import fc from "fast-check"; +import type fc from "fast-check"; abstract class GenerativeEntityBase { - /** The unique index of the entity. */ - public idx: IDIdx; + /** The unique index of the entity. */ + public idx: IDIdx; - /** An optional name of the entity. */ - public name?: AstId; + /** An optional name of the entity. */ + public name?: AstId; - /** The type of the entity. */ - public type: Type; + /** The type of the entity. */ + public type: Type; - constructor(type: Type, name?: AstId) { - this.idx = nextId(); - this.name = name; - this.type = type; - } + constructor(type: Type, name?: AstId) { + this.idx = nextId(); + this.name = name; + this.type = type; + } } /** * Abstract base class for entities that generate AST structures. */ export abstract class GenerativeEntity extends GenerativeEntityBase { - abstract generate(): fc.Arbitrary; + abstract generate(): fc.Arbitrary; } /** * A specialized version of GenerativeEntity that cannot generate AST entities in some cases. */ export abstract class GenerativeEntityOpt extends GenerativeEntityBase { - abstract generate(): fc.Arbitrary | undefined; + abstract generate(): fc.Arbitrary | undefined; } diff --git a/fuzzer/src/generators/parameter.ts b/fuzzer/src/generators/parameter.ts index 30a1a47e89..d61d92f266 100644 --- a/fuzzer/src/generators/parameter.ts +++ b/fuzzer/src/generators/parameter.ts @@ -1,7 +1,8 @@ -import { AstTypedParameter } from "../../../src/ast/ast"; +import type { AstTypedParameter } from "../../../src/ast/ast"; import { createSample, generateAstId } from "../util"; -import { tyToAstType, Type } from "../types"; -import { Scope } from "../scope"; +import { tyToAstType } from "../types"; +import type { Type } from "../types"; +import type { Scope } from "../scope"; import { GenerativeEntity } from "./generator"; import fc from "fast-check"; @@ -11,31 +12,31 @@ import { dummySrcInfo } from "../../../src/grammar/"; * An object that encapsulates generated AstTypedParameter. */ export class Parameter extends GenerativeEntity { - /** - * @param parentScope Scope of the function this argument belongs to. - * @param isBounced If the type of the argument should be wrapped in `bounced<>` - */ - constructor( - parentScope: Scope, - type: Type, - private isBounced: boolean = false, - ) { - if (!parentScope.definedIn("receive", "method", "function")) { - throw new Error( - `Cannot define a function argument in the ${parentScope.kind} scope`, - ); + /** + * @param parentScope Scope of the function this argument belongs to. + * @param isBounced If the type of the argument should be wrapped in `bounced<>` + */ + constructor( + parentScope: Scope, + type: Type, + private isBounced: boolean = false, + ) { + if (!parentScope.definedIn("receive", "method", "function")) { + throw new Error( + `Cannot define a function argument in the ${parentScope.kind} scope`, + ); + } + super(type); + this.name = createSample(generateAstId(parentScope, "field")); } - super(type); - this.name = createSample(generateAstId(parentScope, "field")); - } - generate(): fc.Arbitrary { - return fc.record({ - kind: fc.constant("typed_parameter"), - id: fc.constant(this.idx), - name: fc.constant(this.name!), - type: fc.constant(tyToAstType(this.type, this.isBounced)), - loc: fc.constant(dummySrcInfo), - }); - } + generate(): fc.Arbitrary { + return fc.record({ + kind: fc.constant("typed_parameter"), + id: fc.constant(this.idx), + name: fc.constant(this.name!), + type: fc.constant(tyToAstType(this.type, this.isBounced)), + loc: fc.constant(dummySrcInfo), + }); + } } diff --git a/fuzzer/src/generators/program.ts b/fuzzer/src/generators/program.ts index cea8272f41..6f0bf1cb33 100644 --- a/fuzzer/src/generators/program.ts +++ b/fuzzer/src/generators/program.ts @@ -1,11 +1,11 @@ -import { AstModule } from "../../../src/ast/ast"; +import type { AstModule } from "../../../src/ast/ast"; import { - createSamplesArray, - createSample, - randomInt, - randomBool, - randomElement, - generateAstIdFromName, + createSamplesArray, + createSample, + randomInt, + randomBool, + randomElement, + generateAstIdFromName, } from "../util"; import { TypeGen, UtilType, getStdlibTypes } from "../types"; import { Contract } from "./contract"; @@ -18,26 +18,26 @@ import { getStdlibTraits } from "../stdlib"; import fc from "fast-check"; export interface ProgramParameters { - /** Add definitions that mock stdlib ones to the generated program. */ - addStdlib: boolean; - - /** - * Number of structures generated on the program level. - * @default Random: [1-3] - */ - structsNum: number; - - /** - * Number of messages generated on the program level. - * @default Random: [1-3] - */ - messagesNum: number; - - /** - * Number of the generated traits. Some of them might be used by the generated contracts. - * @default Random: [1-2] - */ - traitsNum: number; + /** Add definitions that mock stdlib ones to the generated program. */ + addStdlib: boolean; + + /** + * Number of structures generated on the program level. + * @default Random: [1-3] + */ + structsNum: number; + + /** + * Number of messages generated on the program level. + * @default Random: [1-3] + */ + messagesNum: number; + + /** + * Number of the generated traits. Some of them might be used by the generated contracts. + * @default Random: [1-2] + */ + traitsNum: number; } /** @@ -45,139 +45,139 @@ export interface ProgramParameters { * about its entries and their scopes. */ export class Program extends GenerativeEntity { - /** Top-level global scope. */ - private scope: Scope; - - private addStdlib: boolean; - - constructor(params: Partial = {}) { - super( - { kind: "util", type: UtilType.Program }, - generateAstIdFromName("program"), - ); - - const { - addStdlib = false, - structsNum = randomInt(1, 3), - messagesNum = randomInt(1, 3), - traitsNum = randomInt(1, 2), - } = params; - this.addStdlib = addStdlib; - - this.scope = new Scope("program", undefined); - - // NOTE: Structures and messages must be generated prior to contracts in order - // to add their entries to scopes for futher reuse. - Array.from({ length: structsNum }).forEach((_) => { - this.scope.add("struct", this.makeStruct()); - }); - - Array.from({ length: messagesNum }).forEach((_) => { - this.scope.add("message", this.makeMessage()); - }); - - // NOTE: Traits must be generated prior to contracts to enable them implement them. - const traits: Trait[] = []; - Array.from({ length: traitsNum }).forEach((_) => { - const trait = this.makeTrait(); - traits.push(trait); - this.scope.add("trait", trait); - }); - - // One of the traits could be implemented by the main contract. - const traitToImplement = - traitsNum > 0 && randomBool() ? randomElement(traits) : undefined; - this.scope.add("contract", this.makeContract(traitToImplement)); - } - - /** - * Generates a Tact program. - * - * It always follows a structure that includes a single contract with a few methods - * which are considered as entry points of the random program generation. This means, the generation - * starts bottom-up from the return types of these methods and adds different AST entries, including - * constants, functions and contract fields. AST nodes inside the contract implementation may vary, - * as determined by fast-check. - */ - public generate(): fc.Arbitrary { - const stdlibEntries = this.addStdlib - ? getStdlibTraits() - .concat(getStdlibTypes()) - .map((entry) => fc.constant(entry)) - : []; - const traits = Array.from(this.scope.getAll("trait")).map((t) => - t.generate(), - ); - const contracts = Array.from(this.scope.getAll("contract")).map((c) => - c.generate(), - ); - const structs = Array.from(this.scope.getAll("struct")).map((s) => - s.generate(), - ); - const messages = Array.from(this.scope.getAll("message")).map((m) => - m.generate(), - ); - const constants = Array.from(this.scope.getAll("constantDef")).map((c) => - c.generate(), - ); - const functions = Array.from(this.scope.getAll("functionDef")).map((f) => - f.generate(), - ); - return fc.record({ - kind: fc.constantFrom("module"), - id: fc.constantFrom(this.idx), - items: fc.tuple( - ...stdlibEntries, - ...structs, - ...messages, - ...constants, - ...functions, - ...traits, - ...contracts, - ), - imports: fc.constant([]), - }); - } - - /** - * Creates a contract object with the predefined structure which is an entry point of the generation. - * @param trait Trait the generated contract should implement - */ - private makeContract(trait?: Trait): Contract { - const methodSignatures = createSamplesArray( - () => TypeGen.fromScope(this.scope).generateMethod(), - 1, - 3, - ).map((arb) => createSample(arb)); - return new Contract(this.scope, methodSignatures, trait); - } - - /** - * Creates a structure in the program scope. - */ - private makeStruct(): Struct { - // TODO: What if the struct-instance/field pair is the same as second-contract-instance/field pair? - return new Struct( - this.scope, - createSample(TypeGen.fromScope(this.scope).generateStruct(false)), - ); - } - - /** - * Creates a message in the program scope. - */ - private makeMessage(): Message { - // TODO: What if the struct-instance/field pair is the same as second-contract-instance/field pair? - return new Message( - this.scope, - createSample(TypeGen.fromScope(this.scope).generateStruct(true)), - ); - } - - /** - * Creates a trait in the program scope. - */ - private makeTrait(): Trait { - return new Trait(this.scope); - } + /** Top-level global scope. */ + private scope: Scope; + + private addStdlib: boolean; + + constructor(params: Partial = {}) { + super( + { kind: "util", type: UtilType.Program }, + generateAstIdFromName("program"), + ); + + const { + addStdlib = false, + structsNum = randomInt(1, 3), + messagesNum = randomInt(1, 3), + traitsNum = randomInt(1, 2), + } = params; + this.addStdlib = addStdlib; + + this.scope = new Scope("program", undefined); + + // NOTE: Structures and messages must be generated prior to contracts in order + // to add their entries to scopes for futher reuse. + Array.from({ length: structsNum }).forEach((_) => { + this.scope.add("struct", this.makeStruct()); + }); + + Array.from({ length: messagesNum }).forEach((_) => { + this.scope.add("message", this.makeMessage()); + }); + + // NOTE: Traits must be generated prior to contracts to enable them implement them. + const traits: Trait[] = []; + Array.from({ length: traitsNum }).forEach((_) => { + const trait = this.makeTrait(); + traits.push(trait); + this.scope.add("trait", trait); + }); + + // One of the traits could be implemented by the main contract. + const traitToImplement = + traitsNum > 0 && randomBool() ? randomElement(traits) : undefined; + this.scope.add("contract", this.makeContract(traitToImplement)); + } + + /** + * Generates a Tact program. + * + * It always follows a structure that includes a single contract with a few methods + * which are considered as entry points of the random program generation. This means, the generation + * starts bottom-up from the return types of these methods and adds different AST entries, including + * constants, functions and contract fields. AST nodes inside the contract implementation may vary, + * as determined by fast-check. + */ + public generate(): fc.Arbitrary { + const stdlibEntries = this.addStdlib + ? getStdlibTraits() + .concat(getStdlibTypes()) + .map((entry) => fc.constant(entry)) + : []; + const traits = Array.from(this.scope.getAll("trait")).map((t) => + t.generate(), + ); + const contracts = Array.from(this.scope.getAll("contract")).map((c) => + c.generate(), + ); + const structs = Array.from(this.scope.getAll("struct")).map((s) => + s.generate(), + ); + const messages = Array.from(this.scope.getAll("message")).map((m) => + m.generate(), + ); + const constants = Array.from(this.scope.getAll("constantDef")).map( + (c) => c.generate(), + ); + const functions = Array.from(this.scope.getAll("functionDef")).map( + (f) => f.generate(), + ); + return fc.record({ + kind: fc.constantFrom("module"), + id: fc.constantFrom(this.idx), + items: fc.tuple( + ...stdlibEntries, + ...structs, + ...messages, + ...constants, + ...functions, + ...traits, + ...contracts, + ), + imports: fc.constant([]), + }); + } + + /** + * Creates a contract object with the predefined structure which is an entry point of the generation. + * @param trait Trait the generated contract should implement + */ + private makeContract(trait?: Trait): Contract { + const methodSignatures = createSamplesArray( + () => TypeGen.fromScope(this.scope).generateMethod(), + 1, + 3, + ).map((arb) => createSample(arb)); + return new Contract(this.scope, methodSignatures, trait); + } + + /** + * Creates a structure in the program scope. + */ + private makeStruct(): Struct { + // TODO: What if the struct-instance/field pair is the same as second-contract-instance/field pair? + return new Struct( + this.scope, + createSample(TypeGen.fromScope(this.scope).generateStruct(false)), + ); + } + + /** + * Creates a message in the program scope. + */ + private makeMessage(): Message { + // TODO: What if the struct-instance/field pair is the same as second-contract-instance/field pair? + return new Message( + this.scope, + createSample(TypeGen.fromScope(this.scope).generateStruct(true)), + ); + } + + /** + * Creates a trait in the program scope. + */ + private makeTrait(): Trait { + return new Trait(this.scope); + } } diff --git a/fuzzer/src/generators/receiver.ts b/fuzzer/src/generators/receiver.ts index d871cd07bf..4b43e45373 100644 --- a/fuzzer/src/generators/receiver.ts +++ b/fuzzer/src/generators/receiver.ts @@ -1,4 +1,4 @@ -import { +import type { AstReceiver, AstStatement, AstReceiverKind, @@ -7,7 +7,8 @@ import { AstReceiverFallback, AstReceiverComment, } from "../../../src/ast/ast"; -import { UtilType, Type, StdlibType, isBouncedMessage } from "../types"; +import { UtilType, StdlibType, isBouncedMessage } from "../types"; +import type { Type } from "../types"; import { Scope } from "../scope"; import { GenerativeEntity } from "./generator"; import { createSample, randomBool, randomElement } from "../util"; diff --git a/fuzzer/src/generators/statement.ts b/fuzzer/src/generators/statement.ts index 3501605376..a0e0d3d5eb 100644 --- a/fuzzer/src/generators/statement.ts +++ b/fuzzer/src/generators/statement.ts @@ -1,47 +1,49 @@ -import { - AstStatementReturn, - AstFieldAccess, - AstStatementExpression, - AstStatement, - AstStatementTry, - AstStatementForEach, - AstStatementCondition, - AstStatementRepeat, - AstStatementAssign, - AstStatementAugmentedAssign, - AstAugmentedAssignOperation, - AstStatementWhile, - AstStatementUntil, - AstExpression, - AstStatementLet, - AstId, - AstCatchBlock, +import type { + AstStatementReturn, + AstFieldAccess, + AstStatementExpression, + AstStatement, + AstStatementTry, + AstStatementForEach, + AstStatementCondition, + AstStatementRepeat, + AstStatementAssign, + AstStatementAugmentedAssign, + AstAugmentedAssignOperation, + AstStatementWhile, + AstStatementUntil, + AstExpression, + AstStatementLet, + AstId, + AstCatchBlock, } from "../../../src/ast/ast"; import fc from "fast-check"; import { - Expression, - generateBoolean, - NonGenerativeExpressionParams, - StaticCall, - MethodCall, - generateFunctionCallArgs, - generateMethodCallArgs, - generateThisID, - generateFieldAccess, + Expression, + generateBoolean, + NonGenerativeExpressionParams, + StaticCall, + MethodCall, + generateFunctionCallArgs, + generateMethodCallArgs, + generateThisID, + generateFieldAccess, } from "./expression"; import { - randomBool, - createSample, - generateName, - packArbitraries, - randomElement, - generateAstId, - generateAstIdFromName, + randomBool, + createSample, + generateName, + packArbitraries, + randomElement, + generateAstId, + generateAstIdFromName, } from "../util"; import { GenerativeEntity } from "./generator"; -import { Type, StdlibType, UtilType, tyToAstType } from "../types"; -import { Scope, ScopeItemKind } from "../scope"; +import { StdlibType, UtilType, tyToAstType } from "../types"; +import type { Type } from "../types"; +import { Scope } from "../scope"; +import type { ScopeItemKind } from "../scope"; import { dummySrcInfo } from "../../../src/grammar/"; /** Type all the imperative constructions have. */ @@ -51,26 +53,26 @@ const STMT_TY: Type = { kind: "util", type: UtilType.Unit }; * Generates `return` statements. */ export class Return extends GenerativeEntity { - /** - * @param parentScope Scope this statement belongs to. - */ - constructor( - private parentScope: Scope, - type: Type, - ) { - super(type); - } - generate(): fc.Arbitrary { - return fc.record({ - kind: fc.constant("statement_return"), - id: fc.constant(this.idx), - expression: - this.type.kind === "util" && this.type.type === UtilType.Unit - ? fc.constant(undefined) - : new Expression(this.parentScope, this.type).generate(), - loc: fc.constant(dummySrcInfo), - }); - } + /** + * @param parentScope Scope this statement belongs to. + */ + constructor( + private parentScope: Scope, + type: Type, + ) { + super(type); + } + generate(): fc.Arbitrary { + return fc.record({ + kind: fc.constant("statement_return"), + id: fc.constant(this.idx), + expression: + this.type.kind === "util" && this.type.type === UtilType.Unit + ? fc.constant(undefined) + : new Expression(this.parentScope, this.type).generate(), + loc: fc.constant(dummySrcInfo), + }); + } } /** @@ -78,212 +80,214 @@ export class Return extends GenerativeEntity { * It creates a variable binding and then adds additional statements that mutate the created binding and the global state. */ export class Let extends GenerativeEntity { - /** - * @param parentScope Scope this statement belongs to. - * @param type Type of the generated binding. - * @param expr Expression generator to initialize that binding. - */ - constructor( - parentScope: Scope, - type: Type, - private expr: fc.Arbitrary, - ) { - super(type); - this.name = createSample(generateAstId(parentScope, "constantDef")); - } - - generate(): fc.Arbitrary { - return fc.record({ - kind: fc.constant("statement_let"), - id: fc.constant(this.idx), - name: fc.constantFrom(this.name!), - type: fc.constantFrom(tyToAstType(this.type)), - expression: this.expr, - loc: fc.constant(dummySrcInfo), - }); - } + /** + * @param parentScope Scope this statement belongs to. + * @param type Type of the generated binding. + * @param expr Expression generator to initialize that binding. + */ + constructor( + parentScope: Scope, + type: Type, + private expr: fc.Arbitrary, + ) { + super(type); + this.name = createSample(generateAstId(parentScope, "constantDef")); + } + + generate(): fc.Arbitrary { + return fc.record({ + kind: fc.constant("statement_let"), + id: fc.constant(this.idx), + name: fc.constantFrom(this.name!), + type: fc.constantFrom(tyToAstType(this.type)), + expression: this.expr, + loc: fc.constant(dummySrcInfo), + }); + } } /** * Creates assignments and augmented assignments to modify global or local variables. */ export class AssignStatement extends GenerativeEntity { - /** - * @param path A qualified name of the lhs. - * @param rhs Expression to assign to. - * @param rhsTy Type of the rhs of the assignment. - * @param ty Type of the statement. - */ - constructor( - private path: AstExpression, - private rhs: fc.Arbitrary, - private rhsTy: Type, - ty = STMT_TY, - ) { - super(ty); - } - - generate(): fc.Arbitrary { - const assigns: fc.Arbitrary[] = [ - fc.record({ - kind: fc.constant("statement_assign"), - id: fc.constant(this.idx), - path: fc.constant(this.path), - expression: this.rhs, - loc: fc.constant(dummySrcInfo), - }), - ]; - // Only integer types in augmented assignments are supported. - // See: https://github.com/tact-lang/tact/issues/353. - if (this.rhsTy.kind === "stdlib" && this.rhsTy.type === StdlibType.Int) { - assigns.push( - fc.record({ - kind: fc.constant("statement_augmentedassign"), - id: fc.constant(this.idx), - op: fc.constantFrom( - "+", - "-", - "*", - "/", - "%", - ), - path: fc.constantFrom(this.path), - expression: this.rhs, - loc: fc.constant(dummySrcInfo), - }), - ); - } - return fc.oneof(...assigns); - } + /** + * @param path A qualified name of the lhs. + * @param rhs Expression to assign to. + * @param rhsTy Type of the rhs of the assignment. + * @param ty Type of the statement. + */ + constructor( + private path: AstExpression, + private rhs: fc.Arbitrary, + private rhsTy: Type, + ty = STMT_TY, + ) { + super(ty); + } + + generate(): fc.Arbitrary { + const assigns: fc.Arbitrary[] = [ + fc.record({ + kind: fc.constant("statement_assign"), + id: fc.constant(this.idx), + path: fc.constant(this.path), + expression: this.rhs, + loc: fc.constant(dummySrcInfo), + }), + ]; + // Only integer types in augmented assignments are supported. + // See: https://github.com/tact-lang/tact/issues/353. + if ( + this.rhsTy.kind === "stdlib" && + this.rhsTy.type === StdlibType.Int + ) { + assigns.push( + fc.record({ + kind: fc.constant("statement_augmentedassign"), + id: fc.constant(this.idx), + op: fc.constantFrom( + "+", + "-", + "*", + "/", + "%", + ), + path: fc.constantFrom(this.path), + expression: this.rhs, + loc: fc.constant(dummySrcInfo), + }), + ); + } + return fc.oneof(...assigns); + } } /** * Generates `while` and `until` loops. */ export class WhileUntilStatement extends GenerativeEntity { - constructor( - private condition: fc.Arbitrary, - private body: fc.Arbitrary[], - private kind: "until" | "while", - type: Type = STMT_TY, - ) { - super(type); - } - generate(): fc.Arbitrary { - return fc.record({ - kind: fc.constant(`statement_${this.kind}`), - id: fc.constant(this.idx), - condition: this.condition, - statements: packArbitraries(this.body), - loc: fc.constant(dummySrcInfo), - }) as fc.Arbitrary; - } + constructor( + private condition: fc.Arbitrary, + private body: fc.Arbitrary[], + private kind: "until" | "while", + type: Type = STMT_TY, + ) { + super(type); + } + generate(): fc.Arbitrary { + return fc.record({ + kind: fc.constant(`statement_${this.kind}`), + id: fc.constant(this.idx), + condition: this.condition, + statements: packArbitraries(this.body), + loc: fc.constant(dummySrcInfo), + }) as fc.Arbitrary; + } } /** * Generates `repeat` loops. */ export class RepeatStatement extends GenerativeEntity { - constructor( - private parentScope: Scope, - private body: fc.Arbitrary[], - type: Type = STMT_TY, - ) { - super(type); - } - generate(): fc.Arbitrary { - const iterations = new Expression(this.parentScope, { - kind: "stdlib", - type: StdlibType.Int, - }).generate(); - return fc.record({ - kind: fc.constant(`statement_repeat`), - id: fc.constant(this.idx), - iterations, - statements: packArbitraries(this.body), - loc: fc.constant(dummySrcInfo), - }) as fc.Arbitrary; - } + constructor( + private parentScope: Scope, + private body: fc.Arbitrary[], + type: Type = STMT_TY, + ) { + super(type); + } + generate(): fc.Arbitrary { + const iterations = new Expression(this.parentScope, { + kind: "stdlib", + type: StdlibType.Int, + }).generate(); + return fc.record({ + kind: fc.constant(`statement_repeat`), + id: fc.constant(this.idx), + iterations, + statements: packArbitraries(this.body), + loc: fc.constant(dummySrcInfo), + }) as fc.Arbitrary; + } } /** * Generates `foreach` loops. */ export class ForeachStatement extends GenerativeEntity { - constructor( - private map: fc.Arbitrary, - private keyName: string, - private valueName: string, - private body: fc.Arbitrary[], - type: Type = STMT_TY, - ) { - super(type); - } - generate(): fc.Arbitrary { - return fc.record({ - kind: fc.constant("statement_foreach"), - keyName: fc.constant(generateAstIdFromName(this.keyName)), - valueName: fc.constant(generateAstIdFromName(this.valueName)), - map: this.map, - statements: packArbitraries(this.body), - id: fc.constant(this.idx), - loc: fc.constant(dummySrcInfo), - }); - } + constructor( + private map: fc.Arbitrary, + private keyName: string, + private valueName: string, + private body: fc.Arbitrary[], + type: Type = STMT_TY, + ) { + super(type); + } + generate(): fc.Arbitrary { + return fc.record({ + kind: fc.constant("statement_foreach"), + keyName: fc.constant(generateAstIdFromName(this.keyName)), + valueName: fc.constant(generateAstIdFromName(this.valueName)), + map: this.map, + statements: packArbitraries(this.body), + id: fc.constant(this.idx), + loc: fc.constant(dummySrcInfo), + }); + } } /** * Generates conditional statements. */ export class ConditionStatement extends GenerativeEntity { - constructor( - private parentScope: Scope, - private trueStmts: fc.Arbitrary[], - private falseStmts?: fc.Arbitrary[], - private elseif?: fc.Arbitrary, - type: Type = STMT_TY, - ) { - super(type); - } - generate(): fc.Arbitrary { - const condition = new Expression(this.parentScope, { - kind: "stdlib", - type: StdlibType.Bool, - }).generate(); - return fc.record({ - kind: fc.constant(`statement_condition`), - condition, - trueStatements: packArbitraries(this.trueStmts), - falseStatements: this.falseStmts - ? packArbitraries(this.falseStmts) - : fc.constant(undefined), - // elseif: this.elseif ? this.elseif : fc.constant(null), // TODO: check how if else works - id: fc.constant(this.idx), - loc: fc.constant(dummySrcInfo), - }); - } + constructor( + private parentScope: Scope, + private trueStmts: fc.Arbitrary[], + private falseStmts?: fc.Arbitrary[], + private elseif?: fc.Arbitrary, + type: Type = STMT_TY, + ) { + super(type); + } + generate(): fc.Arbitrary { + const condition = new Expression(this.parentScope, { + kind: "stdlib", + type: StdlibType.Bool, + }).generate(); + return fc.record({ + kind: fc.constant(`statement_condition`), + condition, + trueStatements: packArbitraries(this.trueStmts), + falseStatements: this.falseStmts + ? packArbitraries(this.falseStmts) + : fc.constant(undefined), + id: fc.constant(this.idx), + loc: fc.constant(dummySrcInfo), + }); + } } /** * Generates try-catch statements. */ export class TryCatch extends GenerativeEntity { - constructor( - private tryStmts: fc.Arbitrary[], - private catchBlock?: AstCatchBlock, - type: Type = STMT_TY, - ) { - super(type); - } - generate(): fc.Arbitrary { - return fc.record({ - kind: fc.constant("statement_try"), - id: fc.constant(this.idx), - statements: packArbitraries(this.tryStmts), - catchBlock: fc.constant(this.catchBlock), - loc: fc.constant(dummySrcInfo), - }); - } + constructor( + private tryStmts: fc.Arbitrary[], + private catchBlock?: AstCatchBlock, + type: Type = STMT_TY, + ) { + super(type); + } + generate(): fc.Arbitrary { + return fc.record({ + kind: fc.constant("statement_try"), + id: fc.constant(this.idx), + statements: packArbitraries(this.tryStmts), + catchBlock: fc.constant(this.catchBlock), + loc: fc.constant(dummySrcInfo), + }); + } } /** @@ -291,332 +295,336 @@ export class TryCatch extends GenerativeEntity { * The return value of the function/method calls generated by this is never used. */ export class StatementExpression extends GenerativeEntity { - constructor( - private expr: fc.Arbitrary, - type: Type = STMT_TY, - ) { - super(type); - } - generate(): fc.Arbitrary { - return fc.record({ - kind: fc.constant("statement_expression"), - id: fc.constant(this.idx), - expression: this.expr, - loc: fc.constant(dummySrcInfo), - }); - } + constructor( + private expr: fc.Arbitrary, + type: Type = STMT_TY, + ) { + super(type); + } + generate(): fc.Arbitrary { + return fc.record({ + kind: fc.constant("statement_expression"), + id: fc.constant(this.idx), + expression: this.expr, + loc: fc.constant(dummySrcInfo), + }); + } } export interface StatementParameters { - /** - * Determines the maximum depth of nested statement blocks. - * @default 2 - */ - nestedBlocksNum: number; - - /** - * Number of statements in each block. - * @default 3 - */ - stmtsInBlock: number; + /** + * Determines the maximum depth of nested statement blocks. + * @default 2 + */ + nestedBlocksNum: number; + + /** + * Number of statements in each block. + * @default 3 + */ + stmtsInBlock: number; } /** * The generator that creates statements in the given block which mutate global or local state. */ export class Statement extends GenerativeEntity { - private nestedBlocksNum: number; - private stmtsInBlock: number; - private params: Partial; - - /** - * @param parentScope Scope the generated statements belongs to. - * @param recursionLevel Used internally within Statement. - * @param params Optional parameters for statement generation. - * @param type Type of the generated statement. - */ - constructor( - private parentScope: Scope, - private recursionLevel = 0, - params: Partial = {}, - type: Type = STMT_TY, - ) { - if (parentScope.definedIn("program", "contract")) { - throw new Error( - `Cannot generate statements in the ${parentScope.kind} scope`, - ); - } - super(type); - - const { nestedBlocksNum = 2, stmtsInBlock = 3 } = params; - this.nestedBlocksNum = nestedBlocksNum; - this.stmtsInBlock = stmtsInBlock; - - this.params = params; - } - - generate(): fc.Arbitrary { - const varAssign = this.makeVarAssign(); - const fieldAssign = this.makeFieldAssign(); - const loopStmt = randomBool() ? this.makeWhileUntil() : this.makeRepeat(); - const foreachStmt = this.makeForEach(); - const condStmt = this.makeCondition(); - const tryCatch = this.makeTryCatch(); - const callStmt = this.makeCall(); - const generated = [ - ...(varAssign ? [varAssign] : []), - ...(fieldAssign ? [fieldAssign] : []), - ...(loopStmt ? [loopStmt] : []), - ...(foreachStmt ? [foreachStmt] : []), - ...(condStmt ? [condStmt] : []), - ...(tryCatch ? [tryCatch] : []), - ...(callStmt ? [callStmt] : []), - ]; - if (generated.length === 0) { - // No variables in local/global scopes are available: generate dummy statements. - generated.push(this.makeDummyStmt()); - } - return fc.oneof(...generated); - } - - /** - * Creates statements that mutate local variables, including assignments and augmented assignments. - */ - private makeVarAssign(): fc.Arbitrary | undefined { - const varEntries: [string, Type][] = - this.parentScope.getEntriesRecursive("let"); - if (varEntries.length === 0) { - return undefined; - } - const arbs = varEntries.map(([name, ty]) => { - const expr = new Expression(this.parentScope, ty).generate(); - return new AssignStatement( - generateAstIdFromName(name), - expr, - ty, - ).generate(); - }); - return arbs.length > 0 ? fc.oneof(...arbs) : undefined; - } - - /** - * Creates statements that mutate contract fields, including assignments and augmented assignments. - */ - private makeFieldAssign(): fc.Arbitrary | undefined { - if (!this.parentScope.definedIn("method")) { - return undefined; - } - const fieldEntries: [string, Type][] = - this.parentScope.getEntriesRecursive("field"); - if (fieldEntries.length === 0) { - return undefined; - } - const arbs = fieldEntries.map(([name, ty]) => { - const expr = new Expression( - this.parentScope, - ty, - NonGenerativeExpressionParams, - ).generate(); - return new AssignStatement( - generateFieldAccess(name), - expr, - ty, - ).generate(); - }); - return arbs.length > 0 ? fc.oneof(...arbs) : undefined; - } - - /** - * Creates either while or until loops. - */ - private makeWhileUntil(): fc.Arbitrary | undefined { - if (this.recursionLevel >= this.nestedBlocksNum) { - return undefined; - } - const condition = new Expression( - this.parentScope, - { kind: "stdlib", type: StdlibType.Bool }, - NonGenerativeExpressionParams, - ).generate(); - const body = this.makeStmtsBlock(); - return new WhileUntilStatement( - condition, - body, - randomBool() ? "while" : "until", - ).generate(); - } - - /** - * Generates repeat loops. - */ - private makeRepeat(): fc.Arbitrary | undefined { - if (this.recursionLevel >= this.nestedBlocksNum) { - return undefined; - } - const body = this.makeStmtsBlock(); - return new RepeatStatement(this.parentScope, body).generate(); - } - - /** - * Collects all local map AstIds in parent scope. - */ - private collectLocalMapIds(entryKinds: ScopeItemKind[]): AstId[] { - return this.parentScope - .getEntriesRecursive(...entryKinds) - .filter(([_, mapTy]: [string, Type]) => mapTy.kind === "map") - .map(([mapName, _]: [string, Type]) => generateAstIdFromName(mapName)); - } - - /** - * Collects all field map AstIds in parent scope. - */ - private collectFieldMapIds(entryKinds: ScopeItemKind[]): AstFieldAccess[] { - return this.parentScope - .getEntriesRecursive(...entryKinds) - .filter(([_, mapTy]: [string, Type]) => mapTy.kind === "map") - .map(([mapName, _]: [string, Type]) => generateFieldAccess(mapName)); - } - - /** - * Generates foreach loops. - */ - private makeForEach(): fc.Arbitrary | undefined { - if (this.recursionLevel >= this.nestedBlocksNum) { - return undefined; - } - const scope = new Scope("block", this.parentScope); - const simpleMapIds = this.collectLocalMapIds([ - "let", - "constantDecl", - "constantDef", - ]); - const fieldMapPaths = this.collectFieldMapIds(["field"]); - const mapIds = [ - ...simpleMapIds.map(fc.constant), - ...fieldMapPaths.map(fc.constant), - ]; - if (mapIds.length === 0) { - return undefined; - } - const map: fc.Arbitrary = fc.oneof(...mapIds); - const keyVarName = createSample(generateName(scope, "let")); - const valueVarName = createSample(generateName(scope, "let")); - const body = this.makeStmtsBlock(scope); - return new ForeachStatement(map, keyVarName, valueVarName, body).generate(); - } - - /** - * Generates conditional statements. - * @param allowElseif Allow creating additional AstStatementCondition in else-if blocks. - */ - private makeCondition( - allowElseif: boolean = true, - ): fc.Arbitrary | undefined { - if (this.recursionLevel >= this.nestedBlocksNum) { - return undefined; - } - const trueStatements = this.makeStmtsBlock(); - const falseStatements = randomBool() ? undefined : this.makeStmtsBlock(); - const elseif = - allowElseif && falseStatements === undefined - ? this.makeCondition(false) - : undefined; - return new ConditionStatement( - this.parentScope, - trueStatements, - falseStatements, - elseif, - ).generate(); - } - - /** - * Generates try and try-catch statements - */ - private makeTryCatch(): fc.Arbitrary | undefined { - if (this.recursionLevel >= this.nestedBlocksNum) { - return undefined; - } - const tryStmts = this.makeStmtsBlock(); - if (randomBool()) { - const catchScope = new Scope("block", this.parentScope); - const catchName = createSample(generateName(catchScope, "let")); - const catchStmts = this.makeStmtsBlock(catchScope).map((stmt) => - createSample(stmt), - ); - return new TryCatch(tryStmts, { - catchName: generateAstIdFromName(catchName), - catchStatements: catchStmts, - }).generate(); - } else { - return new TryCatch(tryStmts).generate(); - } - } - - /** - * Generates function or method calls without using the return value. - */ - private makeCall(): fc.Arbitrary | undefined { - if (this.recursionLevel >= this.nestedBlocksNum) { - return undefined; - } - if (this.parentScope.definedIn("method", "contract") && randomBool()) { - // Call a method - const methodEntries = this.parentScope.getEntriesRecursive("methodDef"); - if (methodEntries.length === 0) { - return undefined; - } - const [funName, funTy] = randomElement(methodEntries); - return new StatementExpression( - new MethodCall( - funTy, - funName, - generateThisID(), - generateMethodCallArgs(funTy, this.parentScope), - ).generate(), - ).generate(); - } else { - // Call a function - const funEntries = this.parentScope.getEntriesRecursive("functionDef"); - if (funEntries.length === 0) { - return undefined; - } - const [funName, funTy] = randomElement(funEntries); - return new StatementExpression( - new StaticCall( - funTy, - funName, - generateFunctionCallArgs(funTy, this.parentScope), - ).generate(), - ).generate(); - } - } - - /** - * Creates a block of statements nested in curly braces in concrete syntax. - */ - private makeStmtsBlock(blockScope?: Scope): fc.Arbitrary[] { - const scope = - blockScope === undefined - ? new Scope("block", this.parentScope) - : blockScope; - const block: fc.Arbitrary[] = []; - Array.from({ length: this.stmtsInBlock }).forEach(() => { - const stmt = new Statement( - scope, - this.recursionLevel + 1, - this.params, - ).generate(); - block.push(stmt); - }); - return block; - } - - /** - * Generates a dummy statement which doesn't have affect on control-flow nor state: - * `while (false) { }` - */ - private makeDummyStmt(): fc.Arbitrary { - const falseExpr = generateBoolean(false); - return new WhileUntilStatement(falseExpr, [], "while").generate(); - } + private nestedBlocksNum: number; + private stmtsInBlock: number; + private params: Partial; + + /** + * @param parentScope Scope the generated statements belongs to. + * @param recursionLevel Used internally within Statement. + * @param params Optional parameters for statement generation. + * @param type Type of the generated statement. + */ + constructor( + private parentScope: Scope, + private recursionLevel = 0, + params: Partial = {}, + type: Type = STMT_TY, + ) { + if (parentScope.definedIn("program", "contract")) { + throw new Error( + `Cannot generate statements in the ${parentScope.kind} scope`, + ); + } + super(type); + + const { nestedBlocksNum = 2, stmtsInBlock = 3 } = params; + this.nestedBlocksNum = nestedBlocksNum; + this.stmtsInBlock = stmtsInBlock; + + this.params = params; + } + + generate(): fc.Arbitrary { + const varAssign = this.makeVarAssign(); + const fieldAssign = this.makeFieldAssign(); + const loopStmt = randomBool() + ? this.makeWhileUntil() + : this.makeRepeat(); + const foreachStmt = this.makeForEach(); + const condStmt = this.makeCondition(); + const tryCatch = this.makeTryCatch(); + const callStmt = this.makeCall(); + const generated = [ + ...(varAssign ? [varAssign] : []), + ...(fieldAssign ? [fieldAssign] : []), + ...(loopStmt ? [loopStmt] : []), + ...(foreachStmt ? [foreachStmt] : []), + ...(condStmt ? [condStmt] : []), + ...(tryCatch ? [tryCatch] : []), + ...(callStmt ? [callStmt] : []), + ]; + if (generated.length === 0) { + // No variables in local/global scopes are available: generate dummy statements. + generated.push(this.makeDummyStmt()); + } + return fc.oneof(...generated); + } + + /** + * Creates statements that mutate local variables, including assignments and augmented assignments. + */ + private makeVarAssign(): fc.Arbitrary | undefined { + const varEntries: [string, Type][] = + this.parentScope.getEntriesRecursive("let"); + if (varEntries.length === 0) { + return undefined; + } + const arbs = varEntries.map(([name, ty]) => { + const expr = new Expression(this.parentScope, ty).generate(); + return new AssignStatement( + generateAstIdFromName(name), + expr, + ty, + ).generate(); + }); + return arbs.length > 0 ? fc.oneof(...arbs) : undefined; + } + + /** + * Creates statements that mutate contract fields, including assignments and augmented assignments. + */ + private makeFieldAssign(): fc.Arbitrary | undefined { + if (!this.parentScope.definedIn("method")) { + return undefined; + } + const fieldEntries: [string, Type][] = + this.parentScope.getEntriesRecursive("field"); + if (fieldEntries.length === 0) { + return undefined; + } + const arbs = fieldEntries.map(([name, ty]) => { + const expr = new Expression( + this.parentScope, + ty, + NonGenerativeExpressionParams, + ).generate(); + return new AssignStatement( + generateFieldAccess(name), + expr, + ty, + ).generate(); + }); + return arbs.length > 0 ? fc.oneof(...arbs) : undefined; + } + + /** + * Creates either while or until loops. + */ + private makeWhileUntil(): fc.Arbitrary | undefined { + if (this.recursionLevel >= this.nestedBlocksNum) { + return undefined; + } + const condition = new Expression( + this.parentScope, + { kind: "stdlib", type: StdlibType.Bool }, + NonGenerativeExpressionParams, + ).generate(); + const body = this.makeStmtsBlock(); + return new WhileUntilStatement( + condition, + body, + randomBool() ? "while" : "until", + ).generate(); + } + + /** + * Generates repeat loops. + */ + private makeRepeat(): fc.Arbitrary | undefined { + if (this.recursionLevel >= this.nestedBlocksNum) { + return undefined; + } + const body = this.makeStmtsBlock(); + return new RepeatStatement(this.parentScope, body).generate(); + } + + /** + * Collects all local map AstIds in parent scope. + */ + private collectLocalMapIds(entryKinds: ScopeItemKind[]): AstId[] { + return this.parentScope + .getEntriesRecursive(...entryKinds) + .filter(([_, mapTy]: [string, Type]) => mapTy.kind === "map") + .map(([mapName, _]: [string, Type]) => + generateAstIdFromName(mapName), + ); + } + + /** + * Collects all field map AstIds in parent scope. + */ + private collectFieldMapIds(entryKinds: ScopeItemKind[]): AstFieldAccess[] { + return this.parentScope + .getEntriesRecursive(...entryKinds) + .filter(([_, mapTy]: [string, Type]) => mapTy.kind === "map") + .map(([mapName, _]: [string, Type]) => + generateFieldAccess(mapName), + ); + } + + /** + * Generates foreach loops. + */ + private makeForEach(): fc.Arbitrary | undefined { + if (this.recursionLevel >= this.nestedBlocksNum) { + return undefined; + } + const scope = new Scope("block", this.parentScope); + const simpleMapIds = this.collectLocalMapIds([ + "let", + "constantDecl", + "constantDef", + ]); + const fieldMapPaths = this.collectFieldMapIds(["field"]); + const mapIds = [ + ...simpleMapIds.map(fc.constant), + ...fieldMapPaths.map(fc.constant), + ]; + if (mapIds.length === 0) { + return undefined; + } + const map: fc.Arbitrary = fc.oneof(...mapIds); + const keyVarName = createSample(generateName(scope, "let")); + const valueVarName = createSample(generateName(scope, "let")); + const body = this.makeStmtsBlock(scope); + return new ForeachStatement( + map, + keyVarName, + valueVarName, + body, + ).generate(); + } + + /** + * Generates conditional statements. + */ + private makeCondition(): fc.Arbitrary | undefined { + if (this.recursionLevel >= this.nestedBlocksNum) { + return undefined; + } + const trueStatements = this.makeStmtsBlock(); + const falseStatements = randomBool() + ? undefined + : this.makeStmtsBlock(); + return new ConditionStatement( + this.parentScope, + trueStatements, + falseStatements, + ).generate(); + } + + /** + * Generates try and try-catch statements + */ + private makeTryCatch(): fc.Arbitrary | undefined { + if (this.recursionLevel >= this.nestedBlocksNum) { + return undefined; + } + const tryStmts = this.makeStmtsBlock(); + if (randomBool()) { + const catchScope = new Scope("block", this.parentScope); + const catchName = createSample(generateName(catchScope, "let")); + const catchStmts = this.makeStmtsBlock(catchScope).map((stmt) => + createSample(stmt), + ); + return new TryCatch(tryStmts, { + catchName: generateAstIdFromName(catchName), + catchStatements: catchStmts, + }).generate(); + } else { + return new TryCatch(tryStmts).generate(); + } + } + + /** + * Generates function or method calls without using the return value. + */ + private makeCall(): fc.Arbitrary | undefined { + if (this.recursionLevel >= this.nestedBlocksNum) { + return undefined; + } + if (this.parentScope.definedIn("method", "contract") && randomBool()) { + // Call a method + const methodEntries = + this.parentScope.getEntriesRecursive("methodDef"); + if (methodEntries.length === 0) { + return undefined; + } + const [funName, funTy] = randomElement(methodEntries); + return new StatementExpression( + new MethodCall( + funTy, + funName, + generateThisID(), + generateMethodCallArgs(funTy, this.parentScope), + ).generate(), + ).generate(); + } else { + // Call a function + const funEntries = + this.parentScope.getEntriesRecursive("functionDef"); + if (funEntries.length === 0) { + return undefined; + } + const [funName, funTy] = randomElement(funEntries); + return new StatementExpression( + new StaticCall( + funTy, + funName, + generateFunctionCallArgs(funTy, this.parentScope), + ).generate(), + ).generate(); + } + } + + /** + * Creates a block of statements nested in curly braces in concrete syntax. + */ + private makeStmtsBlock(blockScope?: Scope): fc.Arbitrary[] { + const scope = blockScope ?? new Scope("block", this.parentScope); + const block: fc.Arbitrary[] = []; + Array.from({ length: this.stmtsInBlock }).forEach(() => { + const stmt = new Statement( + scope, + this.recursionLevel + 1, + this.params, + ).generate(); + block.push(stmt); + }); + return block; + } + + /** + * Generates a dummy statement which doesn't have affect on control-flow nor state: + * `while (false) { }` + */ + private makeDummyStmt(): fc.Arbitrary { + const falseExpr = generateBoolean(false); + return new WhileUntilStatement(falseExpr, [], "while").generate(); + } } diff --git a/fuzzer/src/generators/struct.ts b/fuzzer/src/generators/struct.ts index ec9caefcd5..b963408a52 100644 --- a/fuzzer/src/generators/struct.ts +++ b/fuzzer/src/generators/struct.ts @@ -1,9 +1,7 @@ -import { - AstMessageDecl, - AstStructDecl, -} from "../../../src/ast/ast"; -import { Type, tyToString, StructField, throwTyError } from "../types"; -import { Scope } from "../scope"; +import type { AstMessageDecl, AstStructDecl } from "../../../src/ast/ast"; +import { tyToString, throwTyError } from "../types"; +import type { Type, StructField } from "../types"; +import type { Scope } from "../scope"; import { Field } from "./field"; import { generateAstIdFromName, packArbitraries } from "../util"; import { GenerativeEntity } from "./generator"; @@ -15,91 +13,91 @@ import fc from "fast-check"; * An object that generates AstStructDecl object. */ export class Struct extends GenerativeEntity { - /** - * @param programScope A program scope the structure defined in. - */ - constructor( - private programScope: Scope, - type: Type, - ) { - if (type.kind !== "struct") { - throw new Error( - `Cannot create a structure with the ${tyToString(type)} type`, - ); + /** + * @param programScope A program scope the structure defined in. + */ + constructor( + private programScope: Scope, + type: Type, + ) { + if (type.kind !== "struct") { + throw new Error( + `Cannot create a structure with the ${tyToString(type)} type`, + ); + } + if (!programScope.definedIn("program")) { + throw new Error( + `Cannot define a struct out of the program scope (got ${programScope.kind})`, + ); + } + super(type, generateAstIdFromName(type.name)); } - if (!programScope.definedIn("program")) { - throw new Error( - `Cannot define a struct out of the program scope (got ${programScope.kind})`, - ); - } - super(type, generateAstIdFromName(type.name)); - } - generate(): fc.Arbitrary { - if (this.type.kind !== "struct") { - throwTyError(this.type); + generate(): fc.Arbitrary { + if (this.type.kind !== "struct") { + throwTyError(this.type); + } + const fields = this.type.fields.map((fieldTy: StructField) => { + return new Field( + this.programScope, + fieldTy.type, + fieldTy.default, + generateAstIdFromName(fieldTy.name), + ).generate(); + }); + return fc.record({ + kind: fc.constant("struct_decl"), + id: fc.constant(this.idx), + name: fc.constant(this.name!), + fields: packArbitraries(fields), + loc: fc.constant(dummySrcInfo), + }); } - const fields = this.type.fields.map((fieldTy: StructField) => { - return new Field( - this.programScope, - fieldTy.type, - fieldTy.default, - generateAstIdFromName(fieldTy.name), - ).generate(); - }); - return fc.record({ - kind: fc.constant("struct_decl"), - id: fc.constant(this.idx), - name: fc.constant(this.name!), - fields: packArbitraries(fields), - loc: fc.constant(dummySrcInfo), - }); - } } /** * An object that generates AstMessageDecl object messages. */ export class Message extends GenerativeEntity { - /** - * @param programScope A program scope the structure defined in. - */ - constructor( - private programScope: Scope, - type: Type, - ) { - if (type.kind !== "message") { - throw new Error( - `Cannot create a message with the ${tyToString(type)} type`, - ); - } - if (!programScope.definedIn("program")) { - throw new Error( - `Cannot define a struct out of the program scope (got ${programScope.kind})`, - ); + /** + * @param programScope A program scope the structure defined in. + */ + constructor( + private programScope: Scope, + type: Type, + ) { + if (type.kind !== "message") { + throw new Error( + `Cannot create a message with the ${tyToString(type)} type`, + ); + } + if (!programScope.definedIn("program")) { + throw new Error( + `Cannot define a struct out of the program scope (got ${programScope.kind})`, + ); + } + super(type, generateAstIdFromName(type.name)); } - super(type, generateAstIdFromName(type.name)); - } - generate(): fc.Arbitrary { - if (this.type.kind !== "message") { - throwTyError(this.type); + generate(): fc.Arbitrary { + if (this.type.kind !== "message") { + throwTyError(this.type); + } + const fields = this.type.fields.map((fieldTy: StructField) => { + return new Field( + this.programScope, + fieldTy.type, + fieldTy.default, + generateAstIdFromName(fieldTy.name), + ).generate(); + }); + return fc.record({ + kind: fc.constant("message_decl"), + id: fc.constant(this.idx), + name: fc.constant(this.name!), + opcode: fc.constant(undefined), + fields: packArbitraries(fields), + loc: fc.constant(dummySrcInfo), + }); } - const fields = this.type.fields.map((fieldTy: StructField) => { - return new Field( - this.programScope, - fieldTy.type, - fieldTy.default, - generateAstIdFromName(fieldTy.name), - ).generate(); - }); - return fc.record({ - kind: fc.constant("message_decl"), - id: fc.constant(this.idx), - name: fc.constant(this.name!), - opcode: fc.constant(undefined), - fields: packArbitraries(fields), - loc: fc.constant(dummySrcInfo), - }); - } } diff --git a/fuzzer/src/generators/trait.ts b/fuzzer/src/generators/trait.ts index 544b1f3d01..9a706ce96f 100644 --- a/fuzzer/src/generators/trait.ts +++ b/fuzzer/src/generators/trait.ts @@ -1,10 +1,11 @@ -import { AstTrait, AstExpression } from "../../../src/ast/ast"; +import type { AstTrait, AstExpression } from "../../../src/ast/ast"; import { createSample, generateAstId, randomBool } from "../util"; import { FunctionDecl } from "./function"; import { Field } from "./field"; import { ConstantDecl, ConstantDef } from "./constant"; import { Expression } from "./expression"; -import { Type, TypeGen, makeFunctionTy, UtilType } from "../types"; +import { TypeGen, makeFunctionTy, UtilType } from "../types"; +import type {Type} from "../types"; import { Scope } from "../scope"; import { GenerativeEntity } from "./generator"; @@ -12,111 +13,120 @@ import fc from "fast-check"; import { dummySrcInfo } from "../../../src/grammar/"; export interface TraitParameters { - /** - * Number of fields generated within a trait. - * @default 1 - */ - fieldNum: number; + /** + * Number of fields generated within a trait. + * @default 1 + */ + fieldNum: number; - /** - * Number of method declarations generated within a trait. - * @default 1 - */ - methodDeclarationsNum: number; + /** + * Number of method declarations generated within a trait. + * @default 1 + */ + methodDeclarationsNum: number; - /** - * Number of constant declarations generated within a trait. - * @default 1 - */ - constantNum: number; + /** + * Number of constant declarations generated within a trait. + * @default 1 + */ + constantNum: number; } /** * An object that encapsulates a randomly generated AstTrait. */ export class Trait extends GenerativeEntity { - /** Trait scope. */ - private scope: Scope; + /** Trait scope. */ + private scope: Scope; - // Configuration options - private fieldNum: number; - private methodDeclarationsNum: number; - private constantNum: number; + // Configuration options + private fieldNum: number; + private methodDeclarationsNum: number; + private constantNum: number; - // Declarations to be defined within contracts/traits that implement this trait. - public fieldDeclarations: Field[] = []; - public constantDeclarations: ConstantDecl[] = []; - public constantDefinitions: ConstantDef[] = []; - public methodDeclarations: FunctionDecl[] = []; + // Declarations to be defined within contracts/traits that implement this trait. + public fieldDeclarations: Field[] = []; + public constantDeclarations: ConstantDecl[] = []; + public constantDefinitions: ConstantDef[] = []; + public methodDeclarations: FunctionDecl[] = []; - constructor(programScope: Scope, params: Partial = {}) { - super({ kind: "util", type: UtilType.Trait }); - this.scope = new Scope("trait", programScope); - this.name = createSample(generateAstId(this.scope, "trait")); + constructor(programScope: Scope, params: Partial = {}) { + super({ kind: "util", type: UtilType.Trait }); + this.scope = new Scope("trait", programScope); + this.name = createSample(generateAstId(this.scope, "trait")); - const { fieldNum = 1, methodDeclarationsNum = 1, constantNum = 1 } = params; - this.fieldNum = fieldNum; - this.methodDeclarationsNum = methodDeclarationsNum; - this.constantNum = constantNum; + const { + fieldNum = 1, + methodDeclarationsNum = 1, + constantNum = 1, + } = params; + this.fieldNum = fieldNum; + this.methodDeclarationsNum = methodDeclarationsNum; + this.constantNum = constantNum; - this.prepareDeclarationTypes(); - } + this.prepareDeclarationTypes(); + } - /** - * Randomly generates init expressions for constants. - */ - private makeInit(ty: Type): fc.Arbitrary | undefined { - return ty.kind === "map" || randomBool() - ? undefined - : new Expression(this.scope, ty, { - compileTimeEval: true, - }).generate(); - } + /** + * Randomly generates init expressions for constants. + */ + private makeInit(ty: Type): fc.Arbitrary | undefined { + return ty.kind === "map" || randomBool() + ? undefined + : new Expression(this.scope, ty, { + compileTimeEval: true, + }).generate(); + } - /** - * Generates arbitrary types for fields, methods and constants that will be - * defined in the trait. - */ - private prepareDeclarationTypes() { - this.fieldDeclarations = Array.from({ length: this.fieldNum }).map((_) => { - const ty = TypeGen.fromScope(this.scope).pick(); - const field = new Field(this.scope, ty); - this.scope.add("field", field); - return field; - }); - this.methodDeclarations = Array.from({ - length: this.methodDeclarationsNum, - }).map((_) => { - const returnTy = TypeGen.fromScope(this.scope).pick(); - const funTy = makeFunctionTy("method", returnTy); - return new FunctionDecl(this.scope, "method", funTy); - }); - this.constantDeclarations = []; - this.constantDefinitions = []; - Array.from({ length: this.constantNum }).forEach((_) => { - const ty = TypeGen.fromScope(this.scope).pick(); - const init = this.makeInit(ty); - if (init) - this.constantDefinitions.push( - ConstantDef.fromScope(this.scope, ty, init), + /** + * Generates arbitrary types for fields, methods and constants that will be + * defined in the trait. + */ + private prepareDeclarationTypes() { + this.fieldDeclarations = Array.from({ length: this.fieldNum }).map( + (_) => { + const ty = TypeGen.fromScope(this.scope).pick(); + const field = new Field(this.scope, ty); + this.scope.add("field", field); + return field; + }, ); - else this.constantDeclarations.push(new ConstantDecl(this.scope, ty)); - }); - } + this.methodDeclarations = Array.from({ + length: this.methodDeclarationsNum, + }).map((_) => { + const returnTy = TypeGen.fromScope(this.scope).pick(); + const funTy = makeFunctionTy("method", returnTy); + return new FunctionDecl(this.scope, "method", funTy); + }); + this.constantDeclarations = []; + this.constantDefinitions = []; + Array.from({ length: this.constantNum }).forEach((_) => { + const ty = TypeGen.fromScope(this.scope).pick(); + const init = this.makeInit(ty); + if (init) + this.constantDefinitions.push( + ConstantDef.fromScope(this.scope, ty, init), + ); + else + this.constantDeclarations.push( + new ConstantDecl(this.scope, ty), + ); + }); + } - public generate(): fc.Arbitrary { - // NOTE: It doesn't implement any receive functions, to don't clutter the top-level with them. - const constants = this.constantDeclarations.map((c) => c.generate()); - const fields = this.fieldDeclarations.map((f) => f.generate()); - const methods = this.methodDeclarations.map((m) => m.generate()); - return fc.record({ - kind: fc.constant("trait"), - id: fc.constant(this.idx), - name: fc.constant(this.name!), - traits: fc.constant([]), - attributes: fc.constant([]), - declarations: fc.tuple(...constants, ...fields, ...methods), - loc: fc.constant(dummySrcInfo), - }); - } + public generate(): fc.Arbitrary { + // NOTE: It doesn't implement any receive functions, to don't clutter the top-level with them. + const constants = this.constantDeclarations.map((c) => c.generate()); + const fields = this.fieldDeclarations.map((f) => f.generate()); + const methods = this.methodDeclarations.map((m) => m.generate()); + return fc.record({ + kind: fc.constant("trait"), + id: fc.constant(this.idx), + name: fc.constant(this.name!), + traits: fc.constant([]), + attributes: fc.constant([]), + declarations: fc.tuple(...constants, ...fields, ...methods), + loc: fc.constant(dummySrcInfo), + }); + } } diff --git a/fuzzer/src/id.ts b/fuzzer/src/id.ts index 0eb925c3da..26c8786a42 100644 --- a/fuzzer/src/id.ts +++ b/fuzzer/src/id.ts @@ -3,6 +3,6 @@ export type IDIdx = number; let currentId: IDIdx = 0; export function nextId(): IDIdx { - currentId += 1; - return currentId; + currentId += 1; + return currentId; } diff --git a/fuzzer/src/scope.ts b/fuzzer/src/scope.ts index 8711140d6f..5c95747840 100644 --- a/fuzzer/src/scope.ts +++ b/fuzzer/src/scope.ts @@ -1,64 +1,65 @@ -import { Type, getReturnType } from "./types"; -import { IDIdx } from "./id"; -import { GenerativeEntity } from "./generators"; -import { - AstFunctionDef, - AstTypedParameter, - AstTrait, - AstStatement, - AstStructDecl, - AstFieldDecl, - AstReceiver, - AstContract, - AstConstantDecl, - AstConstantDef, - AstFunctionDecl, - AstMessageDecl, +import type { Type } from "./types"; +import { getReturnType } from "./types"; +import type { IDIdx } from "./id"; +import type { GenerativeEntity } from "./generators"; +import type { + AstFunctionDef, + AstTypedParameter, + AstTrait, + AstStatement, + AstStructDecl, + AstFieldDecl, + AstReceiver, + AstContract, + AstConstantDecl, + AstConstantDef, + AstFunctionDecl, + AstMessageDecl, } from "../../src/ast/ast"; export type ScopeKind = - | "program" - | "trait" - | "contract" - | "function" - | "method" - | "receive" - | "block"; + | "program" + | "trait" + | "contract" + | "function" + | "method" + | "receive" + | "block"; export type ScopeItemKind = - | "let" - | "parameter" - | "statement" - | "struct" - | "message" - | "constantDecl" - | "constantDef" - | "functionDecl" - | "functionDef" - | "methodDecl" - | "methodDef" - | "receive" - | "field" - | "contract" - | "trait"; + | "let" + | "parameter" + | "statement" + | "struct" + | "message" + | "constantDecl" + | "constantDef" + | "functionDecl" + | "functionDef" + | "methodDecl" + | "methodDef" + | "receive" + | "field" + | "contract" + | "trait"; /** Maps each ScopeItemKind to its respective GenerativeEntity specialization. */ type GenerativeEntityMap = { - let: GenerativeEntity; - parameter: GenerativeEntity; - statement: GenerativeEntity; - struct: GenerativeEntity; - message: GenerativeEntity; - constantDecl: GenerativeEntity; - constantDef: GenerativeEntity; - functionDecl: GenerativeEntity; - functionDef: GenerativeEntity; - methodDecl: GenerativeEntity; - methodDef: GenerativeEntity; - receive: GenerativeEntity; - field: GenerativeEntity; - contract: GenerativeEntity; - trait: GenerativeEntity; + let: GenerativeEntity; + parameter: GenerativeEntity; + statement: GenerativeEntity; + struct: GenerativeEntity; + message: GenerativeEntity; + constantDecl: GenerativeEntity; + constantDef: GenerativeEntity; + functionDecl: GenerativeEntity; + functionDef: GenerativeEntity; + methodDecl: GenerativeEntity; + methodDef: GenerativeEntity; + receive: GenerativeEntity; + field: GenerativeEntity; + contract: GenerativeEntity; + trait: GenerativeEntity; }; /** @@ -66,292 +67,306 @@ type GenerativeEntityMap = { * provides an information to access data in parent scopes. */ export class Scope { - kind: ScopeKind; + kind: ScopeKind; - /** Reference to the parent scope. `undefined` for the top-level scope. */ - readonly parentScope?: Scope; + /** Reference to the parent scope. `undefined` for the top-level scope. */ + readonly parentScope?: Scope; - /** - * Contains AST entries generated during the bottom-up AST generation. - */ - // eslint-disable-next-line @typescript-eslint/no-explicit-any - private map: Map>> = - new Map(); + /** + * Contains AST entries generated during the bottom-up AST generation. + */ + // eslint-disable-next-line @typescript-eslint/no-explicit-any + private map: Map>> = + new Map(); - constructor(kind: ScopeKind, parentScope: Scope | undefined) { - this.kind = kind; - this.parentScope = parentScope; - } + constructor(kind: ScopeKind, parentScope: Scope | undefined) { + this.kind = kind; + this.parentScope = parentScope; + } - public isProgramScope(): boolean { - return this.parentScope === undefined; - } + public isProgramScope(): boolean { + return this.parentScope === undefined; + } - /** - * Returns the top-level scope. - */ - public getProgramScope(): Scope { - return this.isProgramScope() ? this : this.parentScope!.getProgramScope(); - } + /** + * Returns the top-level scope. + */ + public getProgramScope(): Scope { + return this.isProgramScope() + ? this + : this.parentScope!.getProgramScope(); + } - /** - * Returns the contract-level scope or `undefined` if it is not possible to reach it from the current scope. - */ - public getContractScope(): Scope | undefined { - if (this.isContractScope()) { - return this; + /** + * Returns the contract-level scope or `undefined` if it is not possible to reach it from the current scope. + */ + public getContractScope(): Scope | undefined { + if (this.isContractScope()) { + return this; + } + if (this.parentScope === undefined) { + return undefined; + } + return this.parentScope!.getContractScope(); } - if (this.parentScope === undefined) { - return undefined; + + public isContractScope(): boolean { + return ( + this.parentScope !== undefined && + this.parentScope.isProgramScope() && + this.kind === "contract" + ); } - return this.parentScope!.getContractScope(); - } - public isContractScope(): boolean { - return ( - this.parentScope !== undefined && - this.parentScope.isProgramScope() && - this.kind === "contract" - ); - } + /** + * Put a new entity in the scope according to the Tact semantics. + */ + public add( + kind: T, + entity: GenerativeEntityMap[T], + ): void { + // Determine the appropriate parent scope based on the kind of entity + let targetScope: Scope | undefined; + switch (kind) { + case "let": + case "parameter": + case "statement": + // eslint-disable-next-line @typescript-eslint/no-this-alias + targetScope = this; + break; + case "constantDecl": + case "constantDef": + targetScope = this.findParent("trait", "contract", "program"); + break; + case "functionDecl": + case "functionDef": + case "trait": + targetScope = this.findParent("program"); + break; + case "methodDecl": + case "methodDef": + case "field": + case "receive": + targetScope = this.findParent("trait", "contract"); + break; + case "contract": + case "struct": + case "message": + targetScope = this.findParent("program"); + break; + default: + throw new Error("Unsupported kind for adding to scope."); + } + if (targetScope === undefined) { + throw new Error(`Cannot add "${kind}" to the "${this.kind}" scope`); + } - /** - * Put a new entity in the scope according to the Tact semantics. - */ - public add( - kind: T, - entity: GenerativeEntityMap[T], - ): void { - // Determine the appropriate parent scope based on the kind of entity - let targetScope: Scope | undefined; - switch (kind) { - case "let": - case "parameter": - case "statement": - // eslint-disable-next-line @typescript-eslint/no-this-alias - targetScope = this; - break; - case "constantDecl": - case "constantDef": - targetScope = this.findParent("trait", "contract", "program"); - break; - case "functionDecl": - case "functionDef": - case "trait": - targetScope = this.findParent("program"); - break; - case "methodDecl": - case "methodDef": - case "field": - case "receive": - targetScope = this.findParent("trait", "contract"); - break; - case "contract": - case "struct": - case "message": - targetScope = this.findParent("program"); - break; - default: - throw new Error("Unsupported kind for adding to scope."); + if (targetScope.map.has(kind)) { + targetScope.map.get(kind)!.set(entity.idx, entity); + } else { + targetScope.map + .set(kind, new Map()) + .get(kind)! + .set(entity.idx, entity); + } } - if (targetScope === undefined) { - throw new Error(`Cannot add "${kind}" to the "${this.kind}" scope`); + + public get( + kind: T, + id: IDIdx, + ): GenerativeEntityMap[T] | undefined { + return this.map.get(kind)?.get(id); } - if (targetScope.map.has(kind)) { - targetScope.map.get(kind)!.set(entity.idx, entity); - } else { - targetScope.map.set(kind, new Map()).get(kind)!.set(entity.idx, entity); + public getAll(kind: T): GenerativeEntityMap[T][] { + const kindMap = this.map.get(kind); + if (kindMap) { + return Array.from(kindMap.values()); + } + return []; } - } - public get( - kind: T, - id: IDIdx, - ): GenerativeEntityMap[T] | undefined { - return this.map.get(kind)?.get(id); - } + /** + * Collects name-type tuples of all the entries with the given type defined within this scope. + */ + public getEntries(kind: ScopeItemKind): [string, Type][] { + const names = this.map.get(kind); + if (names === undefined) { + return []; + } + return Array.from(names) + .map( + ([_id, entry]) => + [entry.name?.text, entry.type] as [ + string | undefined, + Type, + ], + ) + .filter((nameType): nameType is [string, Type] => nameType[0] !== undefined); + } - public getAll(kind: T): GenerativeEntityMap[T][] { - const kindMap = this.map.get(kind); - if (kindMap) { - return Array.from(kindMap.values()); + /** + * Collects name-type tuples of all the entries with the given type defined within scope + * and its parent scopes. + */ + public getEntriesRecursive(...kinds: ScopeItemKind[]): [string, Type][] { + const recursiveHelper = ( + kinds: ScopeItemKind[], + acc: [string, Type][], + scope?: Scope, + ): [string, Type][] => { + if (scope === undefined) { + return acc; + } + const entries = kinds.flatMap((kind) => scope.getEntries(kind)); + if (scope.isProgramScope()) { + return acc.concat(entries); + } else { + return recursiveHelper( + kinds, + acc.concat(entries), + scope.parentScope, + ); + } + }; + return recursiveHelper(kinds, [], this); } - return []; - } - /** - * Collects name-type tuples of all the entries with the given type defined within this scope. - */ - public getEntries(kind: ScopeItemKind): [string, Type][] { - const names = this.map.get(kind); - if (names === undefined) { - return []; + /** + * Collects names of all the entries with the given type defined within this scope. + */ + public getNames(kind: ScopeItemKind, ty: Type): string[] { + return this.getEntries(kind) + .filter(([_name, type]) => type === ty) + .map(([name, _type]) => name); } - return Array.from(names) - .map(([_id, entry]) => [entry.name?.text!, entry.type] as [string, Type]) - .filter((entry): entry is [string, Type] => entry[0] !== undefined); - } - /** - * Collects name-type tuples of all the entries with the given type defined within scope - * and its parent scopes. - */ - public getEntriesRecursive(...kinds: ScopeItemKind[]): [string, Type][] { - const recursiveHelper = ( - kinds: ScopeItemKind[], - acc: [string, Type][], - scope?: Scope, - ): [string, Type][] => { - if (scope === undefined) { - return acc; - } - const entries = kinds.flatMap((kind) => scope.getEntries(kind)); - if (scope.isProgramScope()) { - return acc.concat(entries); - } else { - return recursiveHelper(kinds, acc.concat(entries), scope.parentScope); - } - }; - return recursiveHelper(kinds, [], this); - } + /** + * Collects names of all the entries with the given type defined within scope + * and its parent scopes. + */ + public getNamesRecursive( + kind: ScopeItemKind, + ty: Type, + acc: string[] = [], + ): string[] { + const names = this.getNames(kind, ty); + if (this.isProgramScope()) { + return acc.concat(names); + } else { + return acc.concat( + this.parentScope!.getNamesRecursive(kind, ty, names), + ); + } + } - /** - * Collects names of all the entries with the given type defined within this scope. - */ - public getNames(kind: ScopeItemKind, ty: Type): string[] { - return this.getEntries(kind) - .filter(([_name, type]) => type === ty) - .map(([name, _type]) => name); - } + /** + * Returns all items of the given type defined within this scope. + */ + // eslint-disable-next-line @typescript-eslint/no-explicit-any + public getItems(kind: ScopeItemKind): GenerativeEntity[] { + const result = this.map.get(kind); + return result === undefined ? [] : Array.from(result.values()); + } - /** - * Collects names of all the entries with the given type defined within scope - * and its parent scopes. - */ - public getNamesRecursive( - kind: ScopeItemKind, - ty: Type, - acc: string[] = [], - ): string[] { - const names = this.getNames(kind, ty); - if (this.isProgramScope()) { - return acc.concat(names); - } else { - return acc.concat(this.parentScope!.getNamesRecursive(kind, ty, names)); + /** + * Returns all items of the given type defined within this scope and its parents. + */ + public getItemsRecursive( + kind: ScopeItemKind, + // eslint-disable-next-line @typescript-eslint/no-explicit-any + acc: GenerativeEntity[] = [], + // eslint-disable-next-line @typescript-eslint/no-explicit-any + ): GenerativeEntity[] { + const currentItems = this.getItems(kind); + const accN = acc.concat(currentItems); + if (!this.isProgramScope() && this.parentScope) { + return this.parentScope.getItemsRecursive(kind, accN); + } else { + return accN; + } } - } - /** - * Returns all items of the given type defined within this scope. - */ - // eslint-disable-next-line @typescript-eslint/no-explicit-any - public getItems(kind: ScopeItemKind): GenerativeEntity[] { - const result = this.map.get(kind); - return result === undefined ? [] : Array.from(result.values()); - } + /** + * Recursively searches for functions or methods that return the specified type. + * @param kind The kind of callable to search for. + * @param returnTy The return type to match. + * @return An array of tuples containing the function/method names and their full signatures. + */ + public findFunction( + kind: "methodDecl" | "methodDef" | "functionDecl" | "functionDef", + returnTy: Type, + ): [string, Type][] { + const functions = this.getItemsRecursive(kind); + return Array.from(functions.values()).reduce<[string, Type][]>( + (acc, entry) => { + if ( + entry.type.kind === "function" && + getReturnType(entry.type) === returnTy + ) { + acc.push([entry.name?.text!, entry.type]); + } + return acc; + }, + [], + ); + } - /** - * Returns all items of the given type defined within this scope and its parents. - */ - public getItemsRecursive( - kind: ScopeItemKind, - // eslint-disable-next-line @typescript-eslint/no-explicit-any - acc: GenerativeEntity[] = [], - // eslint-disable-next-line @typescript-eslint/no-explicit-any - ): GenerativeEntity[] { - const currentItems = this.getItems(kind); - const accN = acc.concat(currentItems); - if (!this.isProgramScope() && this.parentScope) { - return this.parentScope.getItemsRecursive(kind, accN); - } else { - return accN; + /** + * Checks if the given scope defines an identifier. + */ + public has(kind: ScopeItemKind, name: string): boolean { + return ( + this.map.has(kind) && + Array.from(this.map.get(kind)!).find( + ([_id, entry]) => entry.name?.text === name, + ) !== undefined + ); } - } - /** - * Recursively searches for functions or methods that return the specified type. - * @param kind The kind of callable to search for. - * @param returnTy The return type to match. - * @return An array of tuples containing the function/method names and their full signatures. - */ - public findFunction( - kind: "methodDecl" | "methodDef" | "functionDecl" | "functionDef", - returnTy: Type, - ): [string, Type][] { - const functions = this.getItemsRecursive(kind); - if (functions === undefined) { - return this.isProgramScope() - ? [] - : this.parentScope!.findFunction(kind, returnTy); + /** + * Checks if the given scope or its parents define an identifier. + */ + public hasRecursive(kind: ScopeItemKind, name: string): boolean { + if (this.has(kind, name)) { + return true; + } else if (this.isProgramScope()) { + return false; + } else { + return this.parentScope!.hasRecursive(kind, name); + } } - return Array.from(functions.values()).reduce<[string, Type][]>( - (acc, entry) => { - if ( - entry.type.kind === "function" && - getReturnType(entry.type) === returnTy + + /** + * Looks for a parent scope with one of the given kinds. + */ + public findParent(...kinds: ScopeKind[]): Scope | undefined { + if (kinds.find((kind) => this.kind === kind)) { + return this; + } else if (this.parentScope === undefined) { + return undefined; + } else if ( + kinds.find( + (kind) => this.parentScope && this.parentScope.kind === kind, + ) ) { - acc.push([entry.name?.text!, entry.type]); + return this.parentScope; + } else { + return this.parentScope.findParent(...kinds); } - return acc; - }, - [], - ); - } - - /** - * Checks if the given scope defines an identifier. - */ - public has(kind: ScopeItemKind, name: string): boolean { - return ( - this.map.has(kind) && - Array.from(this.map.get(kind)!).find( - ([_id, entry]) => entry.name?.text === name, - ) !== undefined - ); - } - - /** - * Checks if the given scope or its parents define an identifier. - */ - public hasRecursive(kind: ScopeItemKind, name: string): boolean { - if (this.has(kind, name)) { - return true; - } else if (this.isProgramScope()) { - return false; - } else { - return this.parentScope!.hasRecursive(kind, name); } - } - /** - * Looks for a parent scope with one of the given kinds. - */ - public findParent(...kinds: ScopeKind[]): Scope | undefined { - if (kinds.find((kind) => this.kind === kind)) { - return this; - } else if (this.parentScope === undefined) { - return undefined; - } else if ( - kinds.find((kind) => this.parentScope && this.parentScope.kind === kind) - ) { - return this.parentScope; - } else { - return this.parentScope.findParent(...kinds); + /** + * Returns true if the given scope has one or more ancestors with the given kind. + */ + public hasParent(...kinds: ScopeKind[]): boolean { + return this.findParent(...kinds) !== undefined; } - } - - /** - * Returns true if the given scope has one or more ancestors with the given kind. - */ - public hasParent(...kinds: ScopeKind[]): boolean { - return this.findParent(...kinds) !== undefined; - } - /** - * Returns true if the given scope is defined inside one of the given kinds. - */ - public definedIn(...kinds: ScopeKind[]): boolean { - return kinds.find((k) => this.kind == k) !== undefined; - } + /** + * Returns true if the given scope is defined inside one of the given kinds. + */ + public definedIn(...kinds: ScopeKind[]): boolean { + return kinds.find((k) => this.kind == k) !== undefined; + } } diff --git a/fuzzer/src/stdlib.ts b/fuzzer/src/stdlib.ts index dfefe7cc4e..1e9bf00299 100644 --- a/fuzzer/src/stdlib.ts +++ b/fuzzer/src/stdlib.ts @@ -1,9 +1,9 @@ -import { AstTypeDecl } from "../../src/ast/ast"; +import type { AstTypeDecl } from "../../src/ast/ast"; import { nextId } from "./id"; -import * as path from "path"; -import files from "../../src/stdlib/stdlib"; -import { createVirtualFileSystem } from "../../src/vfs/createVirtualFileSystem"; +// import * as path from "path"; +// import files from "../../src/stdlib/stdlib"; +// import { createVirtualFileSystem } from "../../src/vfs/createVirtualFileSystem"; import { generateAstIdFromName } from "./util"; import { dummySrcInfo } from "../../src/grammar/"; @@ -19,15 +19,15 @@ import { dummySrcInfo } from "../../src/grammar/"; * TODO: We should parse its sources instead */ export function getStdlibTraits(): AstTypeDecl[] { - return [ - { - kind: "trait", - id: nextId(), - name: generateAstIdFromName("BaseTrait"), - traits: [], - attributes: [], - declarations: [], - loc: dummySrcInfo, - }, - ]; + return [ + { + kind: "trait", + id: nextId(), + name: generateAstIdFromName("BaseTrait"), + traits: [], + attributes: [], + declarations: [], + loc: dummySrcInfo, + }, + ]; } diff --git a/fuzzer/src/types.ts b/fuzzer/src/types.ts index d191bb10f9..069b63d02a 100644 --- a/fuzzer/src/types.ts +++ b/fuzzer/src/types.ts @@ -1,19 +1,19 @@ -import { - AstPrimitiveTypeDecl, - AstType, - AstExpression, - AstTypeId, - AstTypeDecl, +import type { + AstPrimitiveTypeDecl, + AstType, + AstExpression, + AstTypeId, + AstTypeDecl, } from "../../src/ast/ast"; import { - createSample, - generateName, - randomInt, - randomBool, - generateAstIdFromName, + createSample, + generateName, + randomInt, + randomBool, + generateAstIdFromName, } from "./util"; -import { Scope } from "./scope"; -import { TypeRef } from "../../src/types/types"; +import type { Scope } from "./scope"; +import type { TypeRef } from "../../src/types/types"; import JSONbig from "json-bigint"; import { nextId } from "./id"; @@ -24,41 +24,41 @@ import { dummySrcInfo } from "../../src/grammar/"; * Types from Tact stdlib. */ export enum StdlibType { - Int = "Int", - Bool = "Bool", - Builder = "Builder", - Slice = "Slice", - Cell = "Cell", - Address = "Address", - String = "String", - StringBuilder = "StringBuilder", + Int = "Int", + Bool = "Bool", + Builder = "Builder", + Slice = "Slice", + Cell = "Cell", + Address = "Address", + String = "String", + StringBuilder = "StringBuilder", } /** User-defined maps. */ export type MapType = { - key: Type; - value: Type; + key: Type; + value: Type; }; /** A single struct or message field. */ export type StructField = { - name: string; - type: Type; - default?: fc.Arbitrary; + name: string; + type: Type; + default?: fc.Arbitrary; }; /** Utility types used internally in the generator. */ export enum UtilType { - Contract = "Contract", - Trait = "Trait", - Program = "Program", - This = "This", - /** - * Functional Unit type that refers to the `void` type in languages like C++. - * Typically used when returning nothing from functions/methods or in imperative - * constructions which only mutate the state. - */ - Unit = "Unit", + Contract = "Contract", + Trait = "Trait", + Program = "Program", + This = "This", + /** + * Functional Unit type that refers to the `void` type in languages like C++. + * Typically used when returning nothing from functions/methods or in imperative + * constructions which only mutate the state. + */ + Unit = "Unit", } /** @@ -66,372 +66,387 @@ export enum UtilType { * The last element of the list means the return type, previous elements are types of the arguments. */ export type FunctionType = { - kind: "function"; - signature: Type[]; + kind: "function"; + signature: Type[]; }; export type Type = - | { - kind: "stdlib"; - type: StdlibType; - } - | { - kind: "map"; - type: MapType; - } - | { - kind: "struct"; - name: string; - fields: StructField[]; - } - | { - kind: "message"; - name: string; - fields: StructField[]; - } - | { - kind: "util"; - type: UtilType; - } - | FunctionType; + | { + kind: "stdlib"; + type: StdlibType; + } + | { + kind: "map"; + type: MapType; + } + | { + kind: "struct"; + name: string; + fields: StructField[]; + } + | { + kind: "message"; + name: string; + fields: StructField[]; + } + | { + kind: "util"; + type: UtilType; + } + | FunctionType; // eslint-disable-next-line @typescript-eslint/no-explicit-any export function throwTyError(ty: any): never { - throw new Error(`Unsupported type: ${JSONbig.stringify(ty)}`); + throw new Error(`Unsupported type: ${JSONbig.stringify(ty)}`); } export function tyToString(ty: Type): string { - switch (ty.kind) { - case "stdlib": - return `${ty.type}`; - case "struct": - case "message": - return `${ty.name}`; - case "map": - return `map<${tyToString(ty.type.key)}, ${tyToString(ty.type.value)}>`; - default: - throwTyError(ty); - } + switch (ty.kind) { + case "stdlib": + return ty.type; + case "struct": + case "message": + return ty.name; + case "map": + return `map<${tyToString(ty.type.key)}, ${tyToString(ty.type.value)}>`; + default: + throwTyError(ty); + } } export function tyEq(lhs: Type, rhs: Type): boolean { - return tyToString(lhs) === tyToString(rhs); + return tyToString(lhs) === tyToString(rhs); } /** * A subset of supported Stdlib types that might be used in AST generation. */ export const SUPPORTED_STDLIB_TYPES: StdlibType[] = [ - StdlibType.String, - StdlibType.Bool, - StdlibType.Int, + StdlibType.String, + StdlibType.Bool, + StdlibType.Int, ]; namespace make { - export function PrimitiveType(name: string): AstPrimitiveTypeDecl { - const kind = "primitive_type_decl"; - return { - kind, - id: nextId(), - name: generateAstIdFromName(name), - loc: dummySrcInfo, - }; - } - export function ASTTypeRef(name: string): AstTypeId { - return { - kind: "type_id", - id: nextId(), - text: name, - loc: dummySrcInfo, - }; - } - export function TypeRef(name: string): TypeRef { - return { - kind: "ref", - name, - optional: false, - }; - } + export function PrimitiveType(name: string): AstPrimitiveTypeDecl { + const kind = "primitive_type_decl"; + return { + kind, + id: nextId(), + name: generateAstIdFromName(name), + loc: dummySrcInfo, + }; + } + export function ASTTypeRef(name: string): AstTypeId { + return { + kind: "type_id", + id: nextId(), + text: name, + loc: dummySrcInfo, + }; + } + export function TypeRef(name: string): TypeRef { + return { + kind: "ref", + name, + optional: false, + }; + } } /** * Cache for Stdlib types. */ -const StdlibTypeCache = new Map(); +const StdlibTypeCache: Map = + new Map(); Object.values(StdlibType).forEach((ty) => { - StdlibTypeCache.set(ty, [ - transformTy(ty, make.PrimitiveType), - transformTy(ty, make.ASTTypeRef), - transformTy(ty, make.TypeRef), - ]); + StdlibTypeCache.set(ty, [ + transformTy(ty, make.PrimitiveType), + transformTy(ty, make.ASTTypeRef), + transformTy(ty, make.TypeRef), + ]); }); /** * Creates a Tact type entry from the given tact-check type defintion. */ function transformTy(ty: StdlibType, transform: (type: StdlibType) => T): T { - if (!Object.values(StdlibType).includes(ty)) { - throwTyError(ty); - } - return transform(ty); + if (!Object.values(StdlibType).includes(ty)) { + throwTyError(ty); + } + return transform(ty); } export function tyToAstTypeDecl(ty: Type): AstTypeDecl { - switch (ty.kind) { - case "stdlib": { - const result = StdlibTypeCache.get(ty.type); - if (!result) { - throwTyError(ty); - } - return result[0]; + switch (ty.kind) { + case "stdlib": { + const result = StdlibTypeCache.get(ty.type); + if (!result) { + throwTyError(ty); + } + return result[0]; + } + default: + throwTyError(ty); } - default: - throwTyError(ty); - } } export function tyToAstType(ty: Type, isBounced = false): AstType { - let generateAstTypeId = (text: string) => - { - kind: "type_id", - text, - id: nextId(), - loc: dummySrcInfo, - }; - - switch (ty.kind) { - case "stdlib": { - const result = StdlibTypeCache.get(ty.type); - if (!result) { - throwTyError(ty); - } - return result[1]; - } - case "struct": - case "message": - const simpleType: AstTypeId = { - kind: "type_id", - text: ty.name, - id: nextId(), - loc: dummySrcInfo, - }; - return isBounced - ? { - kind: "bounced_message_type", - messageType: simpleType, + const generateAstTypeId = (text: string) => + ({ + kind: "type_id", + text, id: nextId(), loc: dummySrcInfo, - } - : simpleType; - case "map": - return { - kind: "map_type", - id: nextId(), - keyType: generateAstTypeId(tyToString(ty.type.key)), - keyStorageType: undefined, - valueType: generateAstTypeId(tyToString(ty.type.value)), - valueStorageType: undefined, - loc: dummySrcInfo, - }; - default: - throwTyError(ty); - } + }) as AstTypeId; + + switch (ty.kind) { + case "stdlib": { + const result = StdlibTypeCache.get(ty.type); + if (!result) { + throwTyError(ty); + } + return result[1]; + } + case "struct": + case "message": { + const simpleType: AstTypeId = { + kind: "type_id", + text: ty.name, + id: nextId(), + loc: dummySrcInfo, + }; + return isBounced + ? { + kind: "bounced_message_type", + messageType: simpleType, + id: nextId(), + loc: dummySrcInfo, + } + : simpleType; + } + case "map": + return { + kind: "map_type", + id: nextId(), + keyType: generateAstTypeId(tyToString(ty.type.key)), + keyStorageType: undefined, + valueType: generateAstTypeId(tyToString(ty.type.value)), + valueStorageType: undefined, + loc: dummySrcInfo, + }; + default: + throwTyError(ty); + } } export function tyToTypeRef(ty: Type): TypeRef { - switch (ty.kind) { - case "stdlib": { - const result = StdlibTypeCache.get(ty.type); - if (!result) { - throwTyError(ty); - } - return result[2]; + switch (ty.kind) { + case "stdlib": { + const result = StdlibTypeCache.get(ty.type); + if (!result) { + throwTyError(ty); + } + return result[2]; + } + default: + throwTyError(ty); } - default: - throwTyError(ty); - } } /** * Retrieves a return type from the function type. */ export function getReturnType(ty: FunctionType): Type { - if (ty.signature.length === 0) { - throw new Error("Empty function signature"); - } - return ty.signature[ty.signature.length - 1]; + if (ty.signature.length === 0) { + throw new Error("Empty function signature"); + } + return ty.signature[ty.signature.length - 1]; } /** * Returns mock AST entries for types defined in standard library. */ export function getStdlibTypes(): AstTypeDecl[] { - return [...Object.values(StdlibType)].map((type) => make.PrimitiveType(type)); + return [...Object.values(StdlibType)].map((type) => + make.PrimitiveType(type), + ); } /** * An utility class used to generate internal tact-check types. */ export class TypeGen { - private constructor(private scope: Scope) {} - - public static fromScope(scope: Scope): TypeGen { - return new TypeGen(scope); - } - - /** Arbitrary that generates stdlib types. */ - public stdlibArbitrary: fc.Arbitrary = fc.record({ - kind: fc.constant("stdlib"), - type: fc.constantFrom(...SUPPORTED_STDLIB_TYPES), - }); - - /** Arbitrary that generates map types. */ - public mapArbitrary: fc.Arbitrary = fc.record({ - kind: fc.constant("map"), - type: fc.record({ - key: fc.record({ - kind: fc.constant("stdlib"), - type: fc.constantFrom( - // TODO: Support Address - StdlibType.Int, - ), - }) as fc.Arbitrary, - value: fc.record({ + private constructor(private scope: Scope) {} + + public static fromScope(scope: Scope): TypeGen { + return new TypeGen(scope); + } + + /** Arbitrary that generates stdlib types. */ + public stdlibArbitrary: fc.Arbitrary = fc.record({ kind: fc.constant("stdlib"), - type: fc.constantFrom( - // TODO: Support Address, Cell, Struct, Message - StdlibType.Int, - StdlibType.Bool, - ), - }) as fc.Arbitrary, - }), - }); - - /** - * Picks an arbitrary type available within the scope. - * This doesn't generate new type definitions. - */ - public pick(): Type { - const arb = fc.oneof( - this.stdlibArbitrary, - // this.mapArbitrary, - // ...this.getStructs(), - ); - return createSample(arb); - } - - /** - * Generates any of the supported types. - */ - public generate(): fc.Arbitrary { - return fc.oneof( - this.stdlibArbitrary, - this.generateFun(), - this.generateStruct(randomBool()), - ); - } - - /** - * Generates an arbitrary function signature. - */ - public generateFun(minLength = 1, maxLength = 3): fc.Arbitrary { - const structs = this.getStructs(); - return fc.record({ - kind: fc.constant("function"), - signature: fc.array( - fc.oneof(this.stdlibArbitrary, this.mapArbitrary, ...structs), - { - minLength, - maxLength, - }, - ), + type: fc.constantFrom(...SUPPORTED_STDLIB_TYPES), }); - } - - /** - * Generates an arbitrary method signature that always starts with `this`. - */ - public generateMethod(): fc.Arbitrary { - return this.generateFun().map((funType) => ({ - kind: "function", - signature: [{ kind: "util", type: UtilType.This }, ...funType.signature], - })); - } - - /** - * Generates an arbitrary struct or message signature. - */ - public generateStruct(isMessage: boolean): fc.Arbitrary { - const kind = isMessage ? "message" : "struct"; - const structName = createSample( - generateName(this.scope, kind, /*shadowing=*/ true, /*isType=*/ true), - ); - // NOTE: It doesn't support nested structs/messages as they are not - const fields = fc - .array( - fc.record({ - name: generateName(this.scope, kind), // TODO: kind in arguments doesn't makes sense here, change generateName signature so you can pass nothing in this argument - type: this.stdlibArbitrary, - default: fc.constantFrom(undefined), + /** Arbitrary that generates map types. */ + public mapArbitrary: fc.Arbitrary = fc.record({ + kind: fc.constant("map"), + type: fc.record({ + key: fc.record({ + kind: fc.constant("stdlib"), + type: fc.constantFrom( + // TODO: Support Address + StdlibType.Int, + ), + }) as fc.Arbitrary, + value: fc.record({ + kind: fc.constant("stdlib"), + type: fc.constantFrom( + // TODO: Support Address, Cell, Struct, Message + StdlibType.Int, + StdlibType.Bool, + ), + }) as fc.Arbitrary, }), - { minLength: 1, maxLength: 4 }, - ) - .filter((generatedFields) => - generatedFields.every( - (item, index) => generatedFields.indexOf(item) === index, - ), - ); - if (isMessage) { - return fc.record({ - kind: fc.constant("message"), - name: fc.constant(structName), - fields: fields, - }); - } else { - return fc.record({ - kind: fc.constant("struct"), - name: fc.constant(structName), - fields: fields, - }); + }); + + /** + * Picks an arbitrary type available within the scope. + * This doesn't generate new type definitions. + */ + public pick(): Type { + const arb = fc.oneof( + this.stdlibArbitrary, + // this.mapArbitrary, + // ...this.getStructs(), + ); + return createSample(arb); + } + + /** + * Generates any of the supported types. + */ + public generate(): fc.Arbitrary { + return fc.oneof( + this.stdlibArbitrary, + this.generateFun(), + this.generateStruct(randomBool()), + ); } - } - - /** - * Returns arbitraries to generate structs available in the program scope. - */ - private getStructs(): fc.Arbitrary[] { - const structs = this.scope.getItemsRecursive("struct"); - if (structs.length === 0) { - return []; + + /** + * Generates an arbitrary function signature. + */ + public generateFun( + minLength = 1, + maxLength = 3, + ): fc.Arbitrary { + const structs = this.getStructs(); + return fc.record({ + kind: fc.constant("function"), + signature: fc.array( + fc.oneof(this.stdlibArbitrary, this.mapArbitrary, ...structs), + { + minLength, + maxLength, + }, + ), + }); + } + + /** + * Generates an arbitrary method signature that always starts with `this`. + */ + public generateMethod(): fc.Arbitrary { + return this.generateFun().map((funType) => ({ + kind: "function", + signature: [ + { kind: "util", type: UtilType.This }, + ...funType.signature, + ], + })); + } + + /** + * Generates an arbitrary struct or message signature. + */ + public generateStruct(isMessage: boolean): fc.Arbitrary { + const kind = isMessage ? "message" : "struct"; + const structName = createSample( + generateName( + this.scope, + kind, + /*shadowing=*/ true, + /*isType=*/ true, + ), + ); + + // NOTE: It doesn't support nested structs/messages as they are not + const fields = fc + .array( + fc.record({ + name: generateName(this.scope, kind), // TODO: kind in arguments doesn't makes sense here, change generateName signature so you can pass nothing in this argument + type: this.stdlibArbitrary, + default: fc.constantFrom(undefined), + }), + { minLength: 1, maxLength: 4 }, + ) + .filter((generatedFields) => + generatedFields.every( + (item, index) => generatedFields.indexOf(item) === index, + ), + ); + if (isMessage) { + return fc.record({ + kind: fc.constant("message"), + name: fc.constant(structName), + fields: fields, + }); + } else { + return fc.record({ + kind: fc.constant("struct"), + name: fc.constant(structName), + fields: fields, + }); + } + } + + /** + * Returns arbitraries to generate structs available in the program scope. + */ + private getStructs(): fc.Arbitrary[] { + const structs = this.scope.getItemsRecursive("struct"); + if (structs.length === 0) { + return []; + } + return structs.map((s) => fc.constantFrom(s.type)); } - return structs.map((s) => fc.constantFrom(s.type)); - } } /** * Creates an arbitrary function or method signature that returns the given type. */ export function makeFunctionTy( - kind: "function" | "method", - returnTy: Type, - minArgs = 1, - maxArgs = 3, + kind: "function" | "method", + returnTy: Type, + minArgs = 1, + maxArgs = 3, ): FunctionType { - const argsLength = randomInt(minArgs, maxArgs); - const thisArg: Type[] = - kind === "method" ? [{ kind: "util", type: UtilType.This }] : []; - const args: Type[] = Array.from({ length: argsLength }, () => { - const idx = randomInt(0, SUPPORTED_STDLIB_TYPES.length - 1); - return { kind: "stdlib", type: SUPPORTED_STDLIB_TYPES[idx] }; - }); - return { kind: "function", signature: [...thisArg, ...args, returnTy] }; + const argsLength = randomInt(minArgs, maxArgs); + const thisArg: Type[] = + kind === "method" ? [{ kind: "util", type: UtilType.This }] : []; + const args: Type[] = Array.from({ length: argsLength }, () => { + const idx = randomInt(0, SUPPORTED_STDLIB_TYPES.length - 1); + return { kind: "stdlib", type: SUPPORTED_STDLIB_TYPES[idx] }; + }); + return { kind: "function", signature: [...thisArg, ...args, returnTy] }; } export function isUnit(ty: Type): boolean { - return ty.kind === "util" && ty.type === "Unit"; + return ty.kind === "util" && ty.type === "Unit"; } export function isThis(ty: Type): boolean { - return ty.kind === "util" && ty.type === "This"; + return ty.kind === "util" && ty.type === "This"; } /** @@ -439,13 +454,13 @@ export function isThis(ty: Type): boolean { * detect if the message ough to be wrapped in `bounced<>`. */ export function isBouncedMessage(ty: Type): boolean { - if (ty.kind !== "message") { - throwTyError(ty); - } - for (const f of ty.fields) { - if (!(f.type.kind === "stdlib" && f.type.type === StdlibType.Bool)) { - return true; // too big; must be wrapped + if (ty.kind !== "message") { + throwTyError(ty); + } + for (const f of ty.fields) { + if (!(f.type.kind === "stdlib" && f.type.type === StdlibType.Bool)) { + return true; // too big; must be wrapped + } } - } - return false; + return false; } diff --git a/fuzzer/src/util.ts b/fuzzer/src/util.ts index 40aabe531d..7e9928b278 100644 --- a/fuzzer/src/util.ts +++ b/fuzzer/src/util.ts @@ -1,15 +1,15 @@ import os from "os"; import { createNodeFileSystem } from "../../src/vfs/createNodeFileSystem"; -import { VirtualFileSystem } from "../../src/vfs/VirtualFileSystem"; +import type { VirtualFileSystem } from "../../src/vfs/VirtualFileSystem"; import { mkdtemp } from "fs/promises"; import fs from "fs/promises"; import * as path from "path"; import fc from "fast-check"; -import { Scope, ScopeItemKind } from "./scope"; +import type { Scope, ScopeItemKind } from "./scope"; import { GlobalContext } from "./context"; -import { Type } from "./types"; -import { AstId, AstNode } from "../../src/ast/ast"; +import type { Type } from "./types"; +import type { AstId, AstNode } from "../../src/ast/ast"; import { dummySrcInfo } from "../../src/grammar/"; import { nextId } from "./id"; @@ -20,87 +20,84 @@ export const VALID_TYPE_ID = /^[A-Z]+[a-zA-Z_0-9]$/; * Creates a temp node file system to use inside a property. */ export async function withNodeFS(f: (vfs: VirtualFileSystem) => Promise) { - const tempDir = await mkdtemp( - path.join(GlobalContext.config.compileDir, "tact-check-"), - ); - const vfs = createNodeFileSystem(tempDir, false); - try { - await f(vfs); - } finally { - if (GlobalContext.config.compileDir == os.tmpdir()) { - await fs.rm(tempDir, { recursive: true }); + const tempDir = await mkdtemp( + path.join(GlobalContext.config.compileDir, "tact-check-"), + ); + const vfs = createNodeFileSystem(tempDir, false); + try { + await f(vfs); + } finally { + if (GlobalContext.config.compileDir == os.tmpdir()) { + await fs.rm(tempDir, { recursive: true }); + } } - } } /** * Creates a new property that executes additional logic implemented in tact-check. */ export function createProperty( - ...args: [ - ...arbitraries: { [K in keyof Ts]: fc.Arbitrary }, - predicate: (...args: Ts) => boolean | void, - ] + ...args: [ + ...arbitraries: { [K in keyof Ts]: fc.Arbitrary }, + predicate: (...args: Ts) => boolean | void, + ] ): fc.IPropertyWithHooks { - const arbitraries = args.slice(0, -1) as unknown as { - [K in keyof Ts]: fc.Arbitrary; - }; - const originalPredicate = args[args.length - 1] as ( - ...args: Ts - ) => boolean | void; - const enhancedPredicate = (...args: Ts): boolean | void => { - args.forEach((arg) => GlobalContext.printSample(arg as AstNode)); - return originalPredicate(...args); - }; - return fc.property(...arbitraries, enhancedPredicate); + const arbitraries = args.slice(0, -1) as unknown as { + [K in keyof Ts]: fc.Arbitrary; + }; + const originalPredicate = args[args.length - 1] as ( + ...args: Ts + ) => boolean | void; + const enhancedPredicate = (...args: Ts): boolean | void => { + args.forEach((arg) => { + GlobalContext.printSample(arg as AstNode); + }); + return originalPredicate(...args); + }; + return fc.property(...arbitraries, enhancedPredicate); } /** * Create parameters for custom property checking. */ function makeParams(numRuns: number | undefined): fc.Parameters { - return { - numRuns: numRuns ? numRuns : GlobalContext.config.numRuns, - seed: GlobalContext.config.seed, - reporter(out) { - if (out.failed) { - if ( - out.counterexample !== null && - out.counterexample !== undefined && - out.error !== null && - out.error !== undefined - ) { - // eslint-disable-next-line @typescript-eslint/no-explicit-any - let generated: any = out.counterexample; - if (!generated.kind && generated[0] && generated[0].kind) { - generated = generated[0]; - } - out.error += `\n-----\nGenerated program:\n${GlobalContext.format(generated)}\n-----\n`; - } - throw new Error(fc.defaultReportMessage(out)); - } - }, - }; + return { + numRuns: numRuns ?? GlobalContext.config.numRuns, + seed: GlobalContext.config.seed, + reporter(out) { + if (out.failed) { + if (out.counterexample !== null && out.error !== null) { + // eslint-disable-next-line @typescript-eslint/no-explicit-any + let generated: any = out.counterexample; + if (!generated.kind && generated[0]?.kind) { + generated = generated[0]; + } + out.error += `\n-----\nGenerated program:\n${GlobalContext.format(generated)}\n-----\n`; + } + throw new Error(fc.defaultReportMessage(out)); + } + }, + }; } /** * Checks the given property enhancing `fc.assert` with additional functionality. */ export function checkProperty( - property: fc.IPropertyWithHooks, - numRuns: number | undefined = undefined, + property: fc.IPropertyWithHooks, + numRuns: number | undefined = undefined, ) { - fc.assert(property, makeParams(numRuns)); + fc.assert(property, makeParams(numRuns)); } /** * Checks the given async property enhancing `fc.assert` with additional functionality. */ export async function checkAsyncProperty( - property: fc.IAsyncPropertyWithHooks, - numRuns: number | undefined = undefined, + property: fc.IAsyncPropertyWithHooks, + numRuns: number | undefined = undefined, ) { - await fc.assert(property, makeParams(numRuns)); + await fc.assert(property, makeParams(numRuns)); } /** @@ -109,10 +106,10 @@ export async function checkAsyncProperty( * @throws If the arbitrary cannot generate any elements. */ export function createSample(gen: fc.Arbitrary): T { - return fc.sample(gen, { - seed: GlobalContext.config.seed, - numRuns: 1, - })[0]; + return fc.sample(gen, { + seed: GlobalContext.config.seed, + numRuns: 1, + })[0]; } /** @@ -123,12 +120,12 @@ export function createSample(gen: fc.Arbitrary): T { * @returns An array of generated items. */ export function createSamplesArray( - fn: () => T, - minLength: number, - maxLength: number, + fn: () => T, + minLength: number, + maxLength: number, ): T[] { - const length = createSample(fc.integer({ min: minLength, max: maxLength })); - return Array.from({ length }, () => fn()); + const length = createSample(fc.integer({ min: minLength, max: maxLength })); + return Array.from({ length }, () => fn()); } /** @@ -136,35 +133,35 @@ export function createSamplesArray( * @param shadowing Allow shadowing (using names available in parent scopes) */ export function generateName( - scope: Scope, - kind: ScopeItemKind, - shadowing: boolean = true, - isType: boolean = false, + scope: Scope, + kind: ScopeItemKind, + shadowing: boolean = true, + isType: boolean = false, ): fc.Arbitrary { - const availableNames = shadowing - ? scope.getEntries(kind) - : scope.getEntriesRecursive(kind); - - return fc - .stringMatching(isType ? VALID_TYPE_ID : VALID_ID) - .filter((generatedName) => { - if (availableNames.find(([name, _]) => name == generatedName)) { - return false; - } - return true; - }); + const availableNames = shadowing + ? scope.getEntries(kind) + : scope.getEntriesRecursive(kind); + + return fc + .stringMatching(isType ? VALID_TYPE_ID : VALID_ID) + .filter((generatedName) => { + if (availableNames.find(([name, _]) => name == generatedName)) { + return false; + } + return true; + }); } /** * Generates AstId from string name and with new id. */ export function generateAstIdFromName(name: string): AstId { - return { - kind: "id", - text: name, - id: nextId(), - loc: dummySrcInfo, - }; + return { + kind: "id", + text: name, + id: nextId(), + loc: dummySrcInfo, + }; } /** @@ -174,17 +171,17 @@ export function generateAstIdFromName(name: string): AstId { * @param shadowing Allow shadowing (using names available in parent scopes) */ export function generateAstId( - scope: Scope, - kind: ScopeItemKind, - shadowing: boolean = true, - isType: boolean = false, + scope: Scope, + kind: ScopeItemKind, + shadowing: boolean = true, + isType: boolean = false, ): fc.Arbitrary { - return fc.record({ - kind: fc.constant("id"), - text: generateName(scope, kind, shadowing, isType), - id: fc.constant(nextId()), - loc: fc.constant(dummySrcInfo), - }); + return fc.record({ + kind: fc.constant("id"), + text: generateName(scope, kind, shadowing, isType), + id: fc.constant(nextId()), + loc: fc.constant(dummySrcInfo), + }); } /** @@ -192,46 +189,46 @@ export function generateAstId( * @returns Chosen identifier or `undefined` if there are no identifiers available with the given kind/type. */ export function choose( - scope: Scope, - kind: ScopeItemKind, - ty: Type, + scope: Scope, + kind: ScopeItemKind, + ty: Type, ): string | undefined { - const availableNames = scope.getNamesRecursive(kind, ty); - if (availableNames.length === 0) { - return undefined; - } - return createSample(fc.constantFrom(...availableNames)); + const availableNames = scope.getNamesRecursive(kind, ty); + if (availableNames.length === 0) { + return undefined; + } + return createSample(fc.constantFrom(...availableNames)); } /** * Randomly chooses a boolean value using wrt to SEED. */ export function randomBool(): boolean { - return createSample(fc.boolean()); + return createSample(fc.boolean()); } /** * Randomly chooses an integer value using wrt to SEED. */ export function randomInt(min: number, max: number): number { - return createSample(fc.integer({ min, max })); + return createSample(fc.integer({ min, max })); } /** * Chooses a random list element wrt to SEED. */ export function randomElement(list: T[]): T { - if (list.length === 0) { - throw new Error("Empty list"); - } - if (list.length === 1) { - return list[0]; - } - return list[randomInt(1, list.length - 1)]; + if (list.length === 0) { + throw new Error("Empty list"); + } + if (list.length === 1) { + return list[0]; + } + return list[randomInt(1, list.length - 1)]; } export function packArbitraries( - arbs?: fc.Arbitrary[], + arbs?: fc.Arbitrary[], ): fc.Arbitrary { - return arbs ? fc.tuple(...(arbs as [fc.Arbitrary])) : fc.constant([]); + return arbs ? fc.tuple(...(arbs as [fc.Arbitrary])) : fc.constant([]); } diff --git a/fuzzer/test/compilation.spec.ts b/fuzzer/test/compilation.spec.ts index d1c4ad7d06..2764ebdb87 100644 --- a/fuzzer/test/compilation.spec.ts +++ b/fuzzer/test/compilation.spec.ts @@ -1,123 +1,128 @@ import { funcCompile } from "../../src/func/funcCompile"; import { posixNormalize } from "../../src/utils/filePath"; -import { AstModule, AstContract } from "../../src/ast/ast"; +import type { AstModule, AstContract } from "../../src/ast/ast"; import { writeFileSync } from "fs"; import * as path from "path"; import fc from "fast-check"; import { Program } from "../src/generators"; -import { StdlibCode, StdlibPath } from "../src/stdlib"; +// import { StdlibCode, StdlibPath } from "../src/stdlib"; import { withNodeFS, checkAsyncProperty } from "../src/util"; import { - compile, - precompile, - createContext, - enableFeatures, + compile, + precompile, + createContext, + enableFeatures, } from "./testUtils"; import { GlobalContext } from "../src/context"; +import { getAstFactory } from "../../src/ast/ast-helpers"; function getContract(program: AstModule): AstContract | undefined { - for (const entry of program.items) { - if (entry.kind === "contract") { - return entry; + for (const entry of program.items) { + if (entry.kind === "contract") { + return entry; + } } - } - return undefined; + return undefined; } async function compileProgram(program: AstModule) { - await withNodeFS(async (vfs) => { - let ctx = createContext(program); - ctx = enableFeatures(ctx, "external"); - ctx = precompile(ctx); - const compilationOutput = vfs.root; + await withNodeFS(async (vfs) => { + const factoryAst = getAstFactory(); + let ctx = createContext(program, factoryAst); + ctx = enableFeatures(ctx, "external"); + ctx = precompile(ctx, factoryAst); + const compilationOutput = vfs.root; - const contract = getContract(program)!; + const contract = getContract(program)!; - // Save the generated contract to a file - const contractCode = GlobalContext.format(contract, "ast"); - writeFileSync(path.join(compilationOutput, "contract.tact"), contractCode); + // Save the generated contract to a file + const contractCode = GlobalContext.format(contract, "ast"); + writeFileSync( + path.join(compilationOutput, "contract.tact"), + contractCode, + ); - // Compile contracts to FunC - const res = await compile(ctx, contract.name.text); - for (const files of res.output.files) { - const ffc = vfs.resolve(compilationOutput, files.name); - vfs.writeFile(ffc, files.code); - } + // Compile contracts to FunC + const res = await compile(ctx, contract.name.text); + for (const files of res.output.files) { + const ffc = vfs.resolve(compilationOutput, files.name); + vfs.writeFile(ffc, files.code); + } - // Process compilation output - const codeFc = res.output.files.map((v) => ({ - path: posixNormalize(vfs.resolve(compilationOutput, v.name)), - content: v.code, - })); - const codeEntrypoint = res.output.entrypoint; + // Process compilation output + const codeFc = res.output.files.map((v) => ({ + path: posixNormalize(vfs.resolve(compilationOutput, v.name)), + content: v.code, + })); + const codeEntrypoint = res.output.entrypoint; - // Compile the resulted FunC code - // NOTE: We intentionally disabled stdlibEx, since the generated - // contracts currently don't use it. - const c = await funcCompile({ - entries: [ - StdlibPath, - // stdlibExPath, - posixNormalize(vfs.resolve(compilationOutput, codeEntrypoint)), - ], - sources: [ - { path: StdlibPath, content: StdlibCode }, - // { - // path: stdlibExPath, - // content: stdlibExCode, - // }, - ...codeFc, - ], - logger: { - info: (_) => {}, - debug: (_) => {}, - warn: (_) => {}, - error: (_) => {}, - }, - }); - try { - expect(c.ok).toBeTruthy(); - } catch (error) { - throw new Error(`FunC compilation failed:\n${c.log}`); - } + // Compile the resulted FunC code + // NOTE: We intentionally disabled stdlibEx, since the generated + // contracts currently don't use it. + const c = await funcCompile({ + entries: [ + // StdlibPath, + // stdlibExPath, + posixNormalize(vfs.resolve(compilationOutput, codeEntrypoint)), + ], + sources: [ + // { path: StdlibPath, content: StdlibCode }, + // { + // path: stdlibExPath, + // content: stdlibExCode, + // }, + ...codeFc, + ], + logger: { + info: (_) => {}, + debug: (_) => {}, + warn: (_) => {}, + error: (_) => {}, + }, + }); + try { + expect(c.ok).toBeTruthy(); + } catch (_error) { + throw new Error(`FunC compilation failed:\n${c.log}`); + } - GlobalContext.resetDepth(); - }); + GlobalContext.resetDepth(); + }); } describe("properties", () => { - it( - "compiles contracts", - async () => { - // The generated AST is compiled once on compilation tests. - // This approach is used to speed-up testing, since non-structural changes - // are not significant for this case. - // - // Instead, the original NUM_RUNS option is used to generate the requested number of - // programs with a different structure. - const numRuns = GlobalContext.config.numRuns; + it( + "compiles contracts", + async () => { + // The generated AST is compiled once on compilation tests. + // This approach is used to speed-up testing, since non-structural changes + // are not significant for this case. + // + // Instead, the original NUM_RUNS option is used to generate the requested number of + // programs with a different structure. + const numRuns = GlobalContext.config.numRuns; - const compileAndCheckProperty = async () => { - const property = fc.asyncProperty( - new Program({ addStdlib: true }).generate(), - compileProgram, - ); - await checkAsyncProperty(property, /*numRuns=*/ 1); - }; + const compileAndCheckProperty = async () => { + const property = fc.asyncProperty( + new Program({ addStdlib: true }).generate(), + compileProgram, + ); + await checkAsyncProperty(property, /*numRuns=*/ 1); + }; - if (numRuns === Infinity) { - while (true) { - await compileAndCheckProperty(); - } - } else { - await Promise.all( - Array.from({ length: numRuns }).map(async () => { - await compileAndCheckProperty(); - }), - ); - } - }, - /*timeout_ms=*/ 60 * 60 * 1000 /*1hr*/, - ); + if (numRuns === Infinity) { + for(;;) { + await compileAndCheckProperty(); + } + } else { + await Promise.all( + Array.from({ length: numRuns }).map(async () => { + await compileAndCheckProperty(); + }), + ); + } + }, + /*timeout_ms=*/ 60 * 60 * 1000 /*1hr*/, + ); }); diff --git a/fuzzer/test/expression.spec.ts b/fuzzer/test/expression.spec.ts index 29cd2f4454..a1d21f6827 100644 --- a/fuzzer/test/expression.spec.ts +++ b/fuzzer/test/expression.spec.ts @@ -1,67 +1,64 @@ import { CompilerContext } from "../../src/context/context"; import { - resolveExpression, - getExpType, + resolveExpression, + getExpType, } from "../../src/types/resolveExpression"; -import { StatementContext } from "../../src/types/resolveStatements"; -import { TypeRef } from "../../src/types/types"; +import type { StatementContext } from "../../src/types/resolveStatements"; +import type { TypeRef } from "../../src/types/types"; import assert from "assert"; import { Expression, NonGenerativeExpressionParams } from "../src/generators"; import { Scope } from "../src/scope"; -import { SUPPORTED_STDLIB_TYPES, Type } from "../src/types"; +import { SUPPORTED_STDLIB_TYPES } from "../src/types"; +import type { Type } from "../src/types"; import { createProperty, checkProperty } from "../src/util"; import { dummySrcInfo } from "../../src/grammar/src-info"; function emptyContext(): StatementContext { - return { - root: dummySrcInfo, - returns: { kind: "void" }, - vars: new Map(), - requiredFields: [], - funName: null, - }; + return { + root: dummySrcInfo, + returns: { kind: "void" }, + vars: new Map(), + requiredFields: [], + funName: null, + }; } function setupContexts(): [CompilerContext, StatementContext] { - const ctx: CompilerContext = new CompilerContext(); - const sctx = emptyContext(); - return [ctx, sctx]; + const ctx: CompilerContext = new CompilerContext(); + const sctx = emptyContext(); + return [ctx, sctx]; } describe("properties", () => { - it("generates well-typed expressions", () => { - const results = setupContexts(); - let compilerCtx = results[0]; - const stmtCtx = results[1]; - const globalScope = new Scope("program", undefined); - for (const type of SUPPORTED_STDLIB_TYPES) { - const ty: Type = { kind: "stdlib", type }; - // NOTE: This test checks only pure expressions, without introducing new - // entries to any scopes. - const exprGen = new Expression( - globalScope, - ty, - NonGenerativeExpressionParams, - ).generate(); - const property = createProperty(exprGen, (expr) => { - compilerCtx = resolveExpression(expr, stmtCtx, compilerCtx); - const resolvedTy = getExpType(compilerCtx, expr); - if (ty.kind == "stdlib") { - if (resolvedTy.kind == "ref") { - assert.strictEqual( - resolvedTy.name, - ty.type, - `The resolved type ${resolvedTy.name} does not match the expected type ${ty}`, - ); - } else { - assert.fail(`Unexpected type: ${resolvedTy.kind}`); - } - } else { - assert.fail(`Unsupported expression type: ${ty}`); + it("generates well-typed expressions", () => { + const results = setupContexts(); + let compilerCtx = results[0]; + const stmtCtx = results[1]; + const globalScope = new Scope("program", undefined); + for (const type of SUPPORTED_STDLIB_TYPES) { + const ty: Type = { kind: "stdlib", type }; + // NOTE: This test checks only pure expressions, without introducing new + // entries to any scopes. + const exprGen = new Expression( + globalScope, + ty, + NonGenerativeExpressionParams, + ).generate(); + const property = createProperty(exprGen, (expr) => { + compilerCtx = resolveExpression(expr, stmtCtx, compilerCtx); + const resolvedTy = getExpType(compilerCtx, expr); + if (resolvedTy.kind == "ref") { + assert.strictEqual( + resolvedTy.name, + ty.type, + `The resolved type ${resolvedTy.name} does not match the expected type ${ty.type}`, + ); + } else { + assert.fail(`Unexpected type: ${resolvedTy.kind}`); + } + }); + checkProperty(property); } - }); - checkProperty(property); - } - }); + }); }); diff --git a/fuzzer/test/program.spec.ts b/fuzzer/test/program.spec.ts index 4f1bf7babf..2e197d113f 100644 --- a/fuzzer/test/program.spec.ts +++ b/fuzzer/test/program.spec.ts @@ -4,56 +4,58 @@ import assert from "assert"; import { precompile, createContext, enableFeatures } from "./testUtils"; import { createProperty, checkProperty } from "../src/util"; import { GlobalContext } from "../src/context"; +import { getAstFactory } from "../../src/ast/ast-helpers"; describe("properties", () => { - it("generates well-typed programs", () => { - const property = createProperty( - new Program({ addStdlib: true }).generate(), - (program) => { - let ctx = createContext(program); - ctx = enableFeatures(ctx, "external"); - precompile(ctx); - GlobalContext.resetDepth(); - }, - ); - checkProperty(property); - }); - - it("generates reproducible AST", () => { - // Setting a fixed seed for reproducibility - const originalSeed = GlobalContext.config.seed; - GlobalContext.config.seed = 42; - - let program1: string | undefined; - let program2: string | undefined; - - // Create a single property that generates two programs - const property = createProperty(new Program().generate(), (program) => { - if (program1 === undefined) { - program1 = GlobalContext.format(program, "ast"); - } else { - program2 = GlobalContext.format(program, "ast"); - } - GlobalContext.resetDepth(); + it("generates well-typed programs", () => { + const property = createProperty( + new Program({ addStdlib: true }).generate(), + (program) => { + const factoryAst = getAstFactory(); + let ctx = createContext(program, factoryAst); + ctx = enableFeatures(ctx, "external"); + precompile(ctx, factoryAst); + GlobalContext.resetDepth(); + }, + ); + checkProperty(property); }); - // Execute property twice - checkProperty(property, /*numRuns=*/ 1); - checkProperty(property, /*numRuns=*/ 1); - - assert.notEqual( - program1, - undefined, - "First program should not be undefined", - ); - assert.notEqual( - program2, - undefined, - "Second program should not be undefined", - ); - assert.equal(program1, program2, "Both programs should be identical"); - - // Restore the original seed - GlobalContext.config.seed = originalSeed; - }); + it("generates reproducible AST", () => { + // Setting a fixed seed for reproducibility + const originalSeed = GlobalContext.config.seed; + GlobalContext.config.seed = 42; + + let program1: string | undefined; + let program2: string | undefined; + + // Create a single property that generates two programs + const property = createProperty(new Program().generate(), (program) => { + if (program1 === undefined) { + program1 = GlobalContext.format(program, "ast"); + } else { + program2 = GlobalContext.format(program, "ast"); + } + GlobalContext.resetDepth(); + }); + + // Execute property twice + checkProperty(property, /*numRuns=*/ 1); + checkProperty(property, /*numRuns=*/ 1); + + assert.notEqual( + program1, + undefined, + "First program should not be undefined", + ); + assert.notEqual( + program2, + undefined, + "Second program should not be undefined", + ); + assert.equal(program1, program2, "Both programs should be identical"); + + // Restore the original seed + GlobalContext.config.seed = originalSeed; + }); }); diff --git a/fuzzer/test/testUtils.ts b/fuzzer/test/testUtils.ts index 364642f8de..44041c8818 100644 --- a/fuzzer/test/testUtils.ts +++ b/fuzzer/test/testUtils.ts @@ -1,7 +1,7 @@ import { CompilerContext } from "../../src/context/context"; import { createABI } from "../../src/generator/createABI"; import { writeProgram } from "../../src/generator/writeProgram"; -import { AstModule } from "../../src/ast/ast"; +import type { AstModule } from "../../src/ast/ast"; import { openContext } from "../../src/context/store"; import { resolveAllocations } from "../../src/storage/resolveAllocation"; import { featureEnable } from "../../src/config/features"; @@ -9,57 +9,62 @@ import { resolveDescriptors } from "../../src/types/resolveDescriptors"; import { resolveSignatures } from "../../src/types/resolveSignatures"; import { resolveStatements } from "../../src/types/resolveStatements"; import { resolveErrors } from "../../src/types/resolveErrors"; -import { getAstFactory } from "../../src/ast/ast-helpers"; +import type { FactoryAst } from "../../src/ast/ast-helpers"; import { getParser } from "../../src/grammar/grammar"; -export function createContext(program: AstModule): CompilerContext { - let ctx = new CompilerContext(); - ctx = openContext( - ctx, - /*sources=*/ [], - /*funcSources=*/ [], - getParser(getAstFactory(), "new"), - [program], - ); - return ctx; +export function createContext( + program: AstModule, + factoryAst: FactoryAst, +): CompilerContext { + let ctx = new CompilerContext(); + ctx = openContext( + ctx, + /*sources=*/ [], + /*funcSources=*/ [], + getParser(factoryAst, "new"), + [program], + ); + return ctx; } /** * Replicates the `precompile` pipeline. */ -export function precompile(ctx: CompilerContext): CompilerContext { - const ast = getAstFactory(); - ctx = resolveDescriptors(ctx, ast); - ctx = resolveSignatures(ctx, ast); - ctx = resolveAllocations(ctx); - ctx = resolveStatements(ctx); - ctx = resolveErrors(ctx, ast); - return ctx; +export function precompile( + ctx: CompilerContext, + factoryAst: FactoryAst, +): CompilerContext { + ctx = resolveDescriptors(ctx, factoryAst); + ctx = resolveSignatures(ctx, factoryAst); + ctx = resolveAllocations(ctx); + ctx = resolveStatements(ctx); + ctx = resolveErrors(ctx, factoryAst); + return ctx; } /** * Enables compiler's features. */ export function enableFeatures( - ctx: CompilerContext, - ...features: ["inline" | "debug" | "masterchain" | "external"] + ctx: CompilerContext, + ...features: ["inline" | "debug" | "masterchain" | "external"] ): CompilerContext { - return features.reduce((accCtx, feature) => { - return featureEnable(accCtx, feature); - }, ctx); + return features.reduce((accCtx, feature) => { + return featureEnable(accCtx, feature); + }, ctx); } /** * Replicates the `compile` pipeline. */ export async function compile(ctx: CompilerContext, contractName: string) { - const abi = createABI(ctx, contractName); - const output = await writeProgram( - ctx, - abi, - `tact_check_${contractName}`, - {}, //ContractCodes - false, - ); - return { output, ctx }; + const abi = createABI(ctx, contractName); + const output = await writeProgram( + ctx, + abi, + `tact_check_${contractName}`, + {}, //ContractCodes + false, + ); + return { output, ctx }; } diff --git a/tsconfig.eslint.json b/tsconfig.eslint.json index 851c8fd4a7..38efeeb25e 100644 --- a/tsconfig.eslint.json +++ b/tsconfig.eslint.json @@ -4,6 +4,6 @@ "noImplicitReturns": false /* Report error when not all code paths in function return a value. */, "noUncheckedIndexedAccess": false /* Include 'undefined' in index signature results */ }, - "include": ["src/", "examples/", "scripts/"], + "include": ["src/", "examples/", "scripts/", "fuzzer/"], "exclude": ["**/*.bind.ts", "src/test/**/output/**/*"] } From debcb8d4aa541884266dca9a4a7449921cd6db3f Mon Sep 17 00:00:00 2001 From: Mell0r Date: Mon, 10 Mar 2025 01:55:22 +0300 Subject: [PATCH 04/44] style: prettier fixes --- fuzzer/src/generators/trait.ts | 2 +- fuzzer/src/scope.ts | 5 ++++- fuzzer/test/compilation.spec.ts | 2 +- 3 files changed, 6 insertions(+), 3 deletions(-) diff --git a/fuzzer/src/generators/trait.ts b/fuzzer/src/generators/trait.ts index 9a706ce96f..6e205877f3 100644 --- a/fuzzer/src/generators/trait.ts +++ b/fuzzer/src/generators/trait.ts @@ -5,7 +5,7 @@ import { Field } from "./field"; import { ConstantDecl, ConstantDef } from "./constant"; import { Expression } from "./expression"; import { TypeGen, makeFunctionTy, UtilType } from "../types"; -import type {Type} from "../types"; +import type { Type } from "../types"; import { Scope } from "../scope"; import { GenerativeEntity } from "./generator"; diff --git a/fuzzer/src/scope.ts b/fuzzer/src/scope.ts index 5c95747840..2ff2165776 100644 --- a/fuzzer/src/scope.ts +++ b/fuzzer/src/scope.ts @@ -202,7 +202,10 @@ export class Scope { Type, ], ) - .filter((nameType): nameType is [string, Type] => nameType[0] !== undefined); + .filter( + (nameType): nameType is [string, Type] => + nameType[0] !== undefined, + ); } /** diff --git a/fuzzer/test/compilation.spec.ts b/fuzzer/test/compilation.spec.ts index 2764ebdb87..ebe4d56cb6 100644 --- a/fuzzer/test/compilation.spec.ts +++ b/fuzzer/test/compilation.spec.ts @@ -112,7 +112,7 @@ describe("properties", () => { }; if (numRuns === Infinity) { - for(;;) { + for (;;) { await compileAndCheckProperty(); } } else { From 20daeefef4433c151365c374a0a59756c2cd8c99 Mon Sep 17 00:00:00 2001 From: Mell0r Date: Tue, 11 Mar 2025 10:12:57 +0300 Subject: [PATCH 05/44] fix: added non empty src info, but it is not working still --- fuzzer/src/formatter.ts | 2 +- fuzzer/src/generators/constant.ts | 8 +++---- fuzzer/src/generators/contract.ts | 13 +++++------ fuzzer/src/generators/expression.ts | 34 ++++++++++++++--------------- fuzzer/src/generators/field.ts | 5 ++--- fuzzer/src/generators/function.ts | 11 +++++----- fuzzer/src/generators/parameter.ts | 5 ++--- fuzzer/src/generators/receiver.ts | 9 ++++---- fuzzer/src/generators/statement.ts | 22 +++++++++---------- fuzzer/src/generators/struct.ts | 7 +++--- fuzzer/src/generators/trait.ts | 5 ++--- fuzzer/src/stdlib.ts | 5 ++--- fuzzer/src/types.ts | 14 ++++++------ fuzzer/src/util.ts | 8 ++++--- fuzzer/test/expression.spec.ts | 4 ++-- 15 files changed, 73 insertions(+), 79 deletions(-) diff --git a/fuzzer/src/formatter.ts b/fuzzer/src/formatter.ts index 3dad805afe..10dcc55d84 100644 --- a/fuzzer/src/formatter.ts +++ b/fuzzer/src/formatter.ts @@ -149,7 +149,7 @@ class PrettyPrinter { } ppAstExpression(expr: AstExpression, parentPrecedence: number = 0): string { - let result; + let result : string; let currentPrecedence = this.getPrecedence(expr.kind); switch (expr.kind) { diff --git a/fuzzer/src/generators/constant.ts b/fuzzer/src/generators/constant.ts index ce4c58ef92..8ab7e5f9b0 100644 --- a/fuzzer/src/generators/constant.ts +++ b/fuzzer/src/generators/constant.ts @@ -9,6 +9,7 @@ import { createSample, generateAstId, generateName, + dummySrcInfoPrintable, } from "../util"; import { tyToAstType } from "../types"; import type { Type } from "../types"; @@ -16,7 +17,6 @@ import type { Scope } from "../scope"; import { GenerativeEntity } from "./generator"; import fc from "fast-check"; -import { dummySrcInfo } from "../../../src/grammar/"; /** * An object that encapsulates a generated AstConstantDecl. @@ -31,7 +31,7 @@ export class ConstantDecl extends GenerativeEntity { extraAttrs: AstConstantAttribute[], ): AstConstantAttribute[] { const attrs: AstConstantAttribute[] = extraAttrs; - attrs.push({ type: "abstract", loc: dummySrcInfo }); + attrs.push({ type: "abstract", loc: dummySrcInfoPrintable }); return attrs; } @@ -44,7 +44,7 @@ export class ConstantDecl extends GenerativeEntity { name: fc.constant(this.name!), type: fc.constant(tyToAstType(this.type)), attributes: fc.constantFrom(this.getAttributes(extraAttrs)), - loc: fc.constant(dummySrcInfo), + loc: fc.constant(dummySrcInfoPrintable), }); } @@ -111,7 +111,7 @@ export class ConstantDef extends GenerativeEntity { type: fc.constant(tyToAstType(this.type)), initializer: choosenInit, attributes: fc.constantFrom(extraAttrs), - loc: fc.constant(dummySrcInfo), + loc: fc.constant(dummySrcInfoPrintable), }); } diff --git a/fuzzer/src/generators/contract.ts b/fuzzer/src/generators/contract.ts index bb504f5c8b..2ecd9daeab 100644 --- a/fuzzer/src/generators/contract.ts +++ b/fuzzer/src/generators/contract.ts @@ -4,7 +4,7 @@ import type { AstFunctionDef, AstFieldDecl, } from "../../../src/ast/ast"; -import { createSample, generateAstId } from "../util"; +import { createSample, dummySrcInfoPrintable, generateAstId } from "../util"; import { FunctionDef } from "./function"; import type { Trait } from "./trait"; import { Expression } from "./expression"; @@ -16,7 +16,6 @@ import { GenerativeEntity } from "./generator"; import fc from "fast-check"; import { Field } from "./field"; -import { dummySrcInfo } from "../../../src/grammar/"; export interface ContractParameters { /** @@ -74,13 +73,13 @@ export class Contract extends GenerativeEntity { return decl .createDefinition(init) .generateWithAttrs([ - { type: "override", loc: dummySrcInfo }, + { type: "override", loc: dummySrcInfoPrintable }, ]); }) .concat( this.trait.constantDefinitions.map((def) => def.generateWithAttrs([ - { type: "override", loc: dummySrcInfo }, + { type: "override", loc: dummySrcInfoPrintable }, ]), ), ); @@ -89,12 +88,12 @@ export class Contract extends GenerativeEntity { { kind: "function_attribute", type: "override", - loc: dummySrcInfo, + loc: dummySrcInfoPrintable, }, { kind: "function_attribute", type: "get", - loc: dummySrcInfo, + loc: dummySrcInfoPrintable, methodId: undefined, }, ]); @@ -134,7 +133,7 @@ export class Contract extends GenerativeEntity { ...generatedMethods, ...requestedMethods, ), - loc: fc.constant(dummySrcInfo), + loc: fc.constant(dummySrcInfoPrintable), params: fc.constant(undefined), }); } diff --git a/fuzzer/src/generators/expression.ts b/fuzzer/src/generators/expression.ts index ddae83a6a9..0cc6bfd5d5 100644 --- a/fuzzer/src/generators/expression.ts +++ b/fuzzer/src/generators/expression.ts @@ -26,6 +26,7 @@ import { randomElement, packArbitraries, generateAstIdFromName, + dummySrcInfoPrintable, } from "../util"; import { GenerativeEntity, GenerativeEntityOpt } from "./generator"; import { nextId } from "../id"; @@ -40,7 +41,6 @@ import { import type { StructField, Type } from "../types"; import { GlobalContext } from "../context"; import type { Scope } from "../scope"; -import { dummySrcInfo } from "../../../src/grammar/"; import { FunctionDef } from "./function"; export function generateNumber( @@ -53,7 +53,7 @@ export function generateNumber( kind: fc.constant("number"), id: fc.constant(nextId()), value, - loc: fc.constant(dummySrcInfo), + loc: fc.constant(dummySrcInfoPrintable), base: base ? fc.constant(base) : fc.constantFrom(2, 8, 10, 16), }); } @@ -67,7 +67,7 @@ export function generateBoolean( kind: fc.constant("boolean"), id: fc.constant(nextId()), value, - loc: fc.constant(dummySrcInfo), + loc: fc.constant(dummySrcInfoPrintable), }); } @@ -90,7 +90,7 @@ export function generateSimplifiedString( kind: fc.constant("simplified_string"), id: fc.constant(nextId()), value: generateStringValue(nonEmpty, constValue), - loc: fc.constant(dummySrcInfo), + loc: fc.constant(dummySrcInfoPrintable), }); } @@ -102,7 +102,7 @@ export function generateString( kind: fc.constant("string"), id: fc.constant(nextId()), value: generateStringValue(nonEmpty, constValue), - loc: fc.constant(dummySrcInfo), + loc: fc.constant(dummySrcInfoPrintable), }); } @@ -110,7 +110,7 @@ export function generateNull(): fc.Arbitrary { return fc.record({ kind: fc.constant("null"), id: fc.constant(nextId()), - loc: fc.constant(dummySrcInfo), + loc: fc.constant(dummySrcInfoPrintable), }); } @@ -123,12 +123,12 @@ export function generateFieldAccess( aggregate: aggregate ?? generateThisID(), field: generateAstIdFromName(name), id: nextId(), - loc: dummySrcInfo, + loc: dummySrcInfoPrintable, }; } export function generateThisID(): AstId { - return { kind: "id", id: nextId(), text: "self", loc: dummySrcInfo }; + return { kind: "id", id: nextId(), text: "self", loc: dummySrcInfoPrintable }; } /** @@ -162,7 +162,7 @@ export function generateStructInit( id: fc.constant(nextId()), field: fc.constant(generateAstIdFromName(field.name)), initializer: new Expression(scope, field.type).generate(), - loc: fc.constant(dummySrcInfo), + loc: fc.constant(dummySrcInfoPrintable), }); }, ); @@ -171,7 +171,7 @@ export function generateStructInit( id: fc.constantFrom(nextId()), type: fc.constantFrom(generateAstIdFromName(tyToString(ty))), args: packArbitraries(args), - loc: fc.constant(dummySrcInfo), + loc: fc.constant(dummySrcInfoPrintable), }); } @@ -237,7 +237,7 @@ export class FieldAccess extends GenerativeEntity { aggregate: fc.constant(this.src ?? generateThisID()), field: fc.constant(this.name!), id: fc.constant(this.idx), - loc: fc.constant(dummySrcInfo), + loc: fc.constant(dummySrcInfoPrintable), }); } } @@ -261,7 +261,7 @@ export class MethodCall extends GenerativeEntity { method: fc.constant(this.name!), args: packArbitraries(this.args), id: fc.constant(this.idx), - loc: fc.constant(dummySrcInfo), + loc: fc.constant(dummySrcInfoPrintable), }); } } @@ -283,7 +283,7 @@ export class StaticCall extends GenerativeEntity { function: fc.constantFrom(this.name!), args: packArbitraries(this.args), id: fc.constant(this.idx), - loc: fc.constant(dummySrcInfo), + loc: fc.constant(dummySrcInfoPrintable), }); } } @@ -306,7 +306,7 @@ export namespace OpUnary { kind: fc.constant("op_unary"), id: fc.constant(nextId()), op: fc.constantFrom(...allowedOps), - loc: fc.constant(dummySrcInfo), + loc: fc.constant(dummySrcInfoPrintable), operand: tie("astExpression") as fc.Arbitrary, }), })).astOpUnary; @@ -343,7 +343,7 @@ export namespace OpBinary { op: fc.constantFrom(...allowedOps), left: tie("astExpression") as fc.Arbitrary, right: tie("astExpression") as fc.Arbitrary, - loc: fc.constant(dummySrcInfo), + loc: fc.constant(dummySrcInfoPrintable), }), })).astOpBinary; } @@ -834,7 +834,7 @@ export class Expression extends GenerativeEntity { kind: "id", id: nextId(), text: mapName, - loc: dummySrcInfo, + loc: dummySrcInfoPrintable, }, [ fc.constantFrom(generateThisID()), @@ -863,7 +863,7 @@ export class Expression extends GenerativeEntity { kind: "id", id: nextId(), text: mapName, - loc: dummySrcInfo, + loc: dummySrcInfoPrintable, }, [ new Expression( diff --git a/fuzzer/src/generators/field.ts b/fuzzer/src/generators/field.ts index 5f09e5c669..f31dbabe22 100644 --- a/fuzzer/src/generators/field.ts +++ b/fuzzer/src/generators/field.ts @@ -1,12 +1,11 @@ import type { AstFieldDecl, AstExpression, AstId } from "../../../src/ast/ast"; -import { createSample, generateAstId } from "../util"; +import { createSample, dummySrcInfoPrintable, generateAstId } from "../util"; import { tyToAstType } from "../types"; import type { Type } from "../types"; import type { Scope } from "../scope"; import { GenerativeEntity } from "./generator"; import fc from "fast-check"; -import { dummySrcInfo } from "../../../src/grammar/"; /** * An object that encapsulates a generated AstFieldDecl. @@ -46,7 +45,7 @@ export class Field extends GenerativeEntity { type: fc.constant(tyToAstType(this.type)), initializer: this.init ?? fc.constant(undefined), as: fc.constantFrom(undefined), - loc: fc.constant(dummySrcInfo), + loc: fc.constant(dummySrcInfoPrintable), }); } } diff --git a/fuzzer/src/generators/function.ts b/fuzzer/src/generators/function.ts index dd60595986..2ab080ec4e 100644 --- a/fuzzer/src/generators/function.ts +++ b/fuzzer/src/generators/function.ts @@ -17,9 +17,8 @@ import type { FunctionType, Type } from "../types"; import { Return } from "./statement"; import { Parameter } from "./parameter"; import { Scope } from "../scope"; -import { createSample, generateAstId, generateAstIdFromName } from "../util"; +import { createSample, dummySrcInfoPrintable, generateAstId, generateAstIdFromName } from "../util"; import { GenerativeEntity } from "./generator"; -import { dummySrcInfo } from "../../../src/grammar/"; import fc from "fast-check"; @@ -83,7 +82,7 @@ function getAttributes( attrs.push({ kind: "function_attribute", type: "get", - loc: dummySrcInfo, + loc: dummySrcInfoPrintable, methodId: undefined, }); } @@ -92,7 +91,7 @@ function getAttributes( attrs.push({ kind: "function_attribute", type: "abstract", - loc: dummySrcInfo, + loc: dummySrcInfoPrintable, }); } @@ -173,7 +172,7 @@ export class FunctionDef extends GenerativeEntity { ), ), statements: this.generateBody(), - loc: fc.constant(dummySrcInfo), + loc: fc.constant(dummySrcInfoPrintable), }); } @@ -226,7 +225,7 @@ export class FunctionDecl extends GenerativeEntity { this.scope, ), ), - loc: fc.constant(dummySrcInfo), + loc: fc.constant(dummySrcInfoPrintable), }); } diff --git a/fuzzer/src/generators/parameter.ts b/fuzzer/src/generators/parameter.ts index d61d92f266..dd362fce9a 100644 --- a/fuzzer/src/generators/parameter.ts +++ b/fuzzer/src/generators/parameter.ts @@ -1,12 +1,11 @@ import type { AstTypedParameter } from "../../../src/ast/ast"; -import { createSample, generateAstId } from "../util"; +import { createSample, dummySrcInfoPrintable, generateAstId } from "../util"; import { tyToAstType } from "../types"; import type { Type } from "../types"; import type { Scope } from "../scope"; import { GenerativeEntity } from "./generator"; import fc from "fast-check"; -import { dummySrcInfo } from "../../../src/grammar/"; /** * An object that encapsulates generated AstTypedParameter. @@ -36,7 +35,7 @@ export class Parameter extends GenerativeEntity { id: fc.constant(this.idx), name: fc.constant(this.name!), type: fc.constant(tyToAstType(this.type, this.isBounced)), - loc: fc.constant(dummySrcInfo), + loc: fc.constant(dummySrcInfoPrintable), }); } } diff --git a/fuzzer/src/generators/receiver.ts b/fuzzer/src/generators/receiver.ts index 4b43e45373..17374b3454 100644 --- a/fuzzer/src/generators/receiver.ts +++ b/fuzzer/src/generators/receiver.ts @@ -11,13 +11,12 @@ import { UtilType, StdlibType, isBouncedMessage } from "../types"; import type { Type } from "../types"; import { Scope } from "../scope"; import { GenerativeEntity } from "./generator"; -import { createSample, randomBool, randomElement } from "../util"; +import { createSample, dummySrcInfoPrintable, randomBool, randomElement } from "../util"; import { Expression, generateString } from "./expression"; import { Parameter } from "./parameter"; import { StatementExpression } from "./statement"; import fc from "fast-check"; -import { dummySrcInfo } from "../../../src/grammar/"; import { nextId } from "../id"; const RECEIVE_RETURN_TY: Type = { kind: "util", type: UtilType.Unit }; @@ -55,7 +54,7 @@ function generateRecieverKind( kind: fc.constant(kind), subKind, id: fc.constant(nextId()), - loc: fc.constant(dummySrcInfo), + loc: fc.constant(dummySrcInfoPrintable), } as any); //TODO: types are correct here, but i don't know how to explain to typescript, what T is equal to T | T } @@ -112,7 +111,7 @@ export class Receive extends GenerativeEntity { kind: fc.constantFrom("bounce"), param: param.generate(), id: fc.constant(nextId()), - loc: fc.constant(dummySrcInfo), + loc: fc.constant(dummySrcInfoPrintable), }); } @@ -162,7 +161,7 @@ export class Receive extends GenerativeEntity { id: fc.constant(this.idx), selector: this.generateSelector(), statements: this.generateBody(), - loc: fc.constant(dummySrcInfo), + loc: fc.constant(dummySrcInfoPrintable), }); } } diff --git a/fuzzer/src/generators/statement.ts b/fuzzer/src/generators/statement.ts index a0e0d3d5eb..64aca03fec 100644 --- a/fuzzer/src/generators/statement.ts +++ b/fuzzer/src/generators/statement.ts @@ -38,13 +38,13 @@ import { randomElement, generateAstId, generateAstIdFromName, + dummySrcInfoPrintable, } from "../util"; import { GenerativeEntity } from "./generator"; import { StdlibType, UtilType, tyToAstType } from "../types"; import type { Type } from "../types"; import { Scope } from "../scope"; import type { ScopeItemKind } from "../scope"; -import { dummySrcInfo } from "../../../src/grammar/"; /** Type all the imperative constructions have. */ const STMT_TY: Type = { kind: "util", type: UtilType.Unit }; @@ -70,7 +70,7 @@ export class Return extends GenerativeEntity { this.type.kind === "util" && this.type.type === UtilType.Unit ? fc.constant(undefined) : new Expression(this.parentScope, this.type).generate(), - loc: fc.constant(dummySrcInfo), + loc: fc.constant(dummySrcInfoPrintable), }); } } @@ -101,7 +101,7 @@ export class Let extends GenerativeEntity { name: fc.constantFrom(this.name!), type: fc.constantFrom(tyToAstType(this.type)), expression: this.expr, - loc: fc.constant(dummySrcInfo), + loc: fc.constant(dummySrcInfoPrintable), }); } } @@ -132,7 +132,7 @@ export class AssignStatement extends GenerativeEntity { id: fc.constant(this.idx), path: fc.constant(this.path), expression: this.rhs, - loc: fc.constant(dummySrcInfo), + loc: fc.constant(dummySrcInfoPrintable), }), ]; // Only integer types in augmented assignments are supported. @@ -154,7 +154,7 @@ export class AssignStatement extends GenerativeEntity { ), path: fc.constantFrom(this.path), expression: this.rhs, - loc: fc.constant(dummySrcInfo), + loc: fc.constant(dummySrcInfoPrintable), }), ); } @@ -180,7 +180,7 @@ export class WhileUntilStatement extends GenerativeEntity { id: fc.constant(this.idx), condition: this.condition, statements: packArbitraries(this.body), - loc: fc.constant(dummySrcInfo), + loc: fc.constant(dummySrcInfoPrintable), }) as fc.Arbitrary; } } @@ -206,7 +206,7 @@ export class RepeatStatement extends GenerativeEntity { id: fc.constant(this.idx), iterations, statements: packArbitraries(this.body), - loc: fc.constant(dummySrcInfo), + loc: fc.constant(dummySrcInfoPrintable), }) as fc.Arbitrary; } } @@ -232,7 +232,7 @@ export class ForeachStatement extends GenerativeEntity { map: this.map, statements: packArbitraries(this.body), id: fc.constant(this.idx), - loc: fc.constant(dummySrcInfo), + loc: fc.constant(dummySrcInfoPrintable), }); } } @@ -263,7 +263,7 @@ export class ConditionStatement extends GenerativeEntity ? packArbitraries(this.falseStmts) : fc.constant(undefined), id: fc.constant(this.idx), - loc: fc.constant(dummySrcInfo), + loc: fc.constant(dummySrcInfoPrintable), }); } } @@ -285,7 +285,7 @@ export class TryCatch extends GenerativeEntity { id: fc.constant(this.idx), statements: packArbitraries(this.tryStmts), catchBlock: fc.constant(this.catchBlock), - loc: fc.constant(dummySrcInfo), + loc: fc.constant(dummySrcInfoPrintable), }); } } @@ -306,7 +306,7 @@ export class StatementExpression extends GenerativeEntity { kind: fc.constant("statement_expression"), id: fc.constant(this.idx), expression: this.expr, - loc: fc.constant(dummySrcInfo), + loc: fc.constant(dummySrcInfoPrintable), }); } } diff --git a/fuzzer/src/generators/struct.ts b/fuzzer/src/generators/struct.ts index b963408a52..b67ff8ca56 100644 --- a/fuzzer/src/generators/struct.ts +++ b/fuzzer/src/generators/struct.ts @@ -3,9 +3,8 @@ import { tyToString, throwTyError } from "../types"; import type { Type, StructField } from "../types"; import type { Scope } from "../scope"; import { Field } from "./field"; -import { generateAstIdFromName, packArbitraries } from "../util"; +import { dummySrcInfoPrintable, generateAstIdFromName, packArbitraries } from "../util"; import { GenerativeEntity } from "./generator"; -import { dummySrcInfo } from "../../../src/grammar/"; import fc from "fast-check"; @@ -50,7 +49,7 @@ export class Struct extends GenerativeEntity { id: fc.constant(this.idx), name: fc.constant(this.name!), fields: packArbitraries(fields), - loc: fc.constant(dummySrcInfo), + loc: fc.constant(dummySrcInfoPrintable), }); } } @@ -97,7 +96,7 @@ export class Message extends GenerativeEntity { name: fc.constant(this.name!), opcode: fc.constant(undefined), fields: packArbitraries(fields), - loc: fc.constant(dummySrcInfo), + loc: fc.constant(dummySrcInfoPrintable), }); } } diff --git a/fuzzer/src/generators/trait.ts b/fuzzer/src/generators/trait.ts index 6e205877f3..fc15732695 100644 --- a/fuzzer/src/generators/trait.ts +++ b/fuzzer/src/generators/trait.ts @@ -1,5 +1,5 @@ import type { AstTrait, AstExpression } from "../../../src/ast/ast"; -import { createSample, generateAstId, randomBool } from "../util"; +import { createSample, dummySrcInfoPrintable, generateAstId, randomBool } from "../util"; import { FunctionDecl } from "./function"; import { Field } from "./field"; import { ConstantDecl, ConstantDef } from "./constant"; @@ -10,7 +10,6 @@ import { Scope } from "../scope"; import { GenerativeEntity } from "./generator"; import fc from "fast-check"; -import { dummySrcInfo } from "../../../src/grammar/"; export interface TraitParameters { /** @@ -126,7 +125,7 @@ export class Trait extends GenerativeEntity { traits: fc.constant([]), attributes: fc.constant([]), declarations: fc.tuple(...constants, ...fields, ...methods), - loc: fc.constant(dummySrcInfo), + loc: fc.constant(dummySrcInfoPrintable), }); } } diff --git a/fuzzer/src/stdlib.ts b/fuzzer/src/stdlib.ts index 1e9bf00299..7f9ff72daf 100644 --- a/fuzzer/src/stdlib.ts +++ b/fuzzer/src/stdlib.ts @@ -4,8 +4,7 @@ import { nextId } from "./id"; // import * as path from "path"; // import files from "../../src/stdlib/stdlib"; // import { createVirtualFileSystem } from "../../src/vfs/createVirtualFileSystem"; -import { generateAstIdFromName } from "./util"; -import { dummySrcInfo } from "../../src/grammar/"; +import { dummySrcInfoPrintable, generateAstIdFromName } from "./util"; // const StdlibFilePath = path.join(__dirname, "..", "..", "src", "stdlib", "stdlib", "std"); // const StdlibVFS = createVirtualFileSystem(StdlibFilePath, files); @@ -27,7 +26,7 @@ export function getStdlibTraits(): AstTypeDecl[] { traits: [], attributes: [], declarations: [], - loc: dummySrcInfo, + loc: dummySrcInfoPrintable, }, ]; } diff --git a/fuzzer/src/types.ts b/fuzzer/src/types.ts index 069b63d02a..c725fe0745 100644 --- a/fuzzer/src/types.ts +++ b/fuzzer/src/types.ts @@ -11,6 +11,7 @@ import { randomInt, randomBool, generateAstIdFromName, + dummySrcInfoPrintable, } from "./util"; import type { Scope } from "./scope"; import type { TypeRef } from "../../src/types/types"; @@ -18,7 +19,6 @@ import JSONbig from "json-bigint"; import { nextId } from "./id"; import fc from "fast-check"; -import { dummySrcInfo } from "../../src/grammar/"; /** * Types from Tact stdlib. @@ -134,7 +134,7 @@ namespace make { kind, id: nextId(), name: generateAstIdFromName(name), - loc: dummySrcInfo, + loc: dummySrcInfoPrintable, }; } export function ASTTypeRef(name: string): AstTypeId { @@ -142,7 +142,7 @@ namespace make { kind: "type_id", id: nextId(), text: name, - loc: dummySrcInfo, + loc: dummySrcInfoPrintable, }; } export function TypeRef(name: string): TypeRef { @@ -195,7 +195,7 @@ export function tyToAstType(ty: Type, isBounced = false): AstType { kind: "type_id", text, id: nextId(), - loc: dummySrcInfo, + loc: dummySrcInfoPrintable, }) as AstTypeId; switch (ty.kind) { @@ -212,14 +212,14 @@ export function tyToAstType(ty: Type, isBounced = false): AstType { kind: "type_id", text: ty.name, id: nextId(), - loc: dummySrcInfo, + loc: dummySrcInfoPrintable, }; return isBounced ? { kind: "bounced_message_type", messageType: simpleType, id: nextId(), - loc: dummySrcInfo, + loc: dummySrcInfoPrintable, } : simpleType; } @@ -231,7 +231,7 @@ export function tyToAstType(ty: Type, isBounced = false): AstType { keyStorageType: undefined, valueType: generateAstTypeId(tyToString(ty.type.value)), valueStorageType: undefined, - loc: dummySrcInfo, + loc: dummySrcInfoPrintable, }; default: throwTyError(ty); diff --git a/fuzzer/src/util.ts b/fuzzer/src/util.ts index 7e9928b278..b0593c81ff 100644 --- a/fuzzer/src/util.ts +++ b/fuzzer/src/util.ts @@ -10,8 +10,8 @@ import type { Scope, ScopeItemKind } from "./scope"; import { GlobalContext } from "./context"; import type { Type } from "./types"; import type { AstId, AstNode } from "../../src/ast/ast"; -import { dummySrcInfo } from "../../src/grammar/"; import { nextId } from "./id"; +import { getSrcInfo } from "../../src/grammar/src-info"; export const VALID_ID = /^[a-zA-Z_]+[a-zA-Z_0-9]$/; export const VALID_TYPE_ID = /^[A-Z]+[a-zA-Z_0-9]$/; @@ -160,7 +160,7 @@ export function generateAstIdFromName(name: string): AstId { kind: "id", text: name, id: nextId(), - loc: dummySrcInfo, + loc: dummySrcInfoPrintable, }; } @@ -180,7 +180,7 @@ export function generateAstId( kind: fc.constant("id"), text: generateName(scope, kind, shadowing, isType), id: fc.constant(nextId()), - loc: fc.constant(dummySrcInfo), + loc: fc.constant(dummySrcInfoPrintable), }); } @@ -232,3 +232,5 @@ export function packArbitraries( ): fc.Arbitrary { return arbs ? fc.tuple(...(arbs as [fc.Arbitrary])) : fc.constant([]); } + +export const dummySrcInfoPrintable = getSrcInfo("", 10, 11, null, "user"); \ No newline at end of file diff --git a/fuzzer/test/expression.spec.ts b/fuzzer/test/expression.spec.ts index a1d21f6827..629094fe7f 100644 --- a/fuzzer/test/expression.spec.ts +++ b/fuzzer/test/expression.spec.ts @@ -12,11 +12,11 @@ import { Scope } from "../src/scope"; import { SUPPORTED_STDLIB_TYPES } from "../src/types"; import type { Type } from "../src/types"; import { createProperty, checkProperty } from "../src/util"; -import { dummySrcInfo } from "../../src/grammar/src-info"; +import { dummySrcInfoPrintable } from "../../src/grammar/src-info"; function emptyContext(): StatementContext { return { - root: dummySrcInfo, + root: dummySrcInfoPrintable, returns: { kind: "void" }, vars: new Map(), requiredFields: [], From 8e21cff7ec4aa13ac5f45c57a524a7ae4ec99df3 Mon Sep 17 00:00:00 2001 From: Mell0r Date: Sun, 16 Mar 2025 20:02:29 +0300 Subject: [PATCH 06/44] fix: replaced simplified-string with string, added non-empty locInfo, added stdlib read back, but it's not working yet --- fuzzer/src/formatter.ts | 3 ++- fuzzer/src/generators/expression.ts | 9 +++++++-- fuzzer/src/stdlib.ts | 14 +++++++------- fuzzer/src/util.ts | 2 +- fuzzer/test/compilation.spec.ts | 6 +++--- fuzzer/test/expression.spec.ts | 7 +++++-- 6 files changed, 25 insertions(+), 16 deletions(-) diff --git a/fuzzer/src/formatter.ts b/fuzzer/src/formatter.ts index 10dcc55d84..0620269391 100644 --- a/fuzzer/src/formatter.ts +++ b/fuzzer/src/formatter.ts @@ -149,7 +149,7 @@ class PrettyPrinter { } ppAstExpression(expr: AstExpression, parentPrecedence: number = 0): string { - let result : string; + let result: string; let currentPrecedence = this.getPrecedence(expr.kind); switch (expr.kind) { @@ -189,6 +189,7 @@ class PrettyPrinter { result = expr.value.toString(); break; case "simplified_string": + case "string": result = `"${expr.value}"`; break; case "null": diff --git a/fuzzer/src/generators/expression.ts b/fuzzer/src/generators/expression.ts index 0cc6bfd5d5..d042880826 100644 --- a/fuzzer/src/generators/expression.ts +++ b/fuzzer/src/generators/expression.ts @@ -128,7 +128,12 @@ export function generateFieldAccess( } export function generateThisID(): AstId { - return { kind: "id", id: nextId(), text: "self", loc: dummySrcInfoPrintable }; + return { + kind: "id", + id: nextId(), + text: "self", + loc: dummySrcInfoPrintable, + }; } /** @@ -945,7 +950,7 @@ export class Expression extends GenerativeEntity { case StdlibType.Bool: return [generateBoolean()]; case StdlibType.String: - return [generateSimplifiedString()]; + return [generateString()]; default: throwTyError(ty); } diff --git a/fuzzer/src/stdlib.ts b/fuzzer/src/stdlib.ts index 7f9ff72daf..5e101aec05 100644 --- a/fuzzer/src/stdlib.ts +++ b/fuzzer/src/stdlib.ts @@ -1,15 +1,15 @@ import type { AstTypeDecl } from "../../src/ast/ast"; import { nextId } from "./id"; -// import * as path from "path"; -// import files from "../../src/stdlib/stdlib"; -// import { createVirtualFileSystem } from "../../src/vfs/createVirtualFileSystem"; +import * as path from "path"; +import files from "../../src/stdlib/stdlib"; +import { createVirtualFileSystem } from "../../src/vfs/createVirtualFileSystem"; import { dummySrcInfoPrintable, generateAstIdFromName } from "./util"; -// const StdlibFilePath = path.join(__dirname, "..", "..", "src", "stdlib", "stdlib", "std"); -// const StdlibVFS = createVirtualFileSystem(StdlibFilePath, files); -// export const StdlibPath = StdlibVFS.resolve("stdlib.fc"); -// export const StdlibCode = StdlibVFS.readFile(StdlibPath).toString(); +const StdlibFilePath = path.join(__dirname, "..", "..", "src", "stdlib", "stdlib", "std"); +const StdlibVFS = createVirtualFileSystem(StdlibFilePath, files); +export const StdlibPath = StdlibVFS.resolve("stdlib.fc"); +export const StdlibCode = StdlibVFS.readFile(StdlibPath).toString(); // export const StdlibExPath = StdlibVFS.resolve("stdlib_ex.fc"); // export const StdlibExCode = StdlibVFS.readFile(StdlibExPath).toString(); diff --git a/fuzzer/src/util.ts b/fuzzer/src/util.ts index b0593c81ff..d7555c4552 100644 --- a/fuzzer/src/util.ts +++ b/fuzzer/src/util.ts @@ -233,4 +233,4 @@ export function packArbitraries( return arbs ? fc.tuple(...(arbs as [fc.Arbitrary])) : fc.constant([]); } -export const dummySrcInfoPrintable = getSrcInfo("", 10, 11, null, "user"); \ No newline at end of file +export const dummySrcInfoPrintable = getSrcInfo(" ", 0, 0, null, "user"); \ No newline at end of file diff --git a/fuzzer/test/compilation.spec.ts b/fuzzer/test/compilation.spec.ts index ebe4d56cb6..fe063fb4a0 100644 --- a/fuzzer/test/compilation.spec.ts +++ b/fuzzer/test/compilation.spec.ts @@ -6,7 +6,7 @@ import * as path from "path"; import fc from "fast-check"; import { Program } from "../src/generators"; -// import { StdlibCode, StdlibPath } from "../src/stdlib"; +import { StdlibCode, StdlibPath } from "../src/stdlib"; import { withNodeFS, checkAsyncProperty } from "../src/util"; import { compile, @@ -62,12 +62,12 @@ async function compileProgram(program: AstModule) { // contracts currently don't use it. const c = await funcCompile({ entries: [ - // StdlibPath, + StdlibPath, // stdlibExPath, posixNormalize(vfs.resolve(compilationOutput, codeEntrypoint)), ], sources: [ - // { path: StdlibPath, content: StdlibCode }, + { path: StdlibPath, content: StdlibCode }, // { // path: stdlibExPath, // content: stdlibExCode, diff --git a/fuzzer/test/expression.spec.ts b/fuzzer/test/expression.spec.ts index 629094fe7f..5f3a8e643a 100644 --- a/fuzzer/test/expression.spec.ts +++ b/fuzzer/test/expression.spec.ts @@ -11,8 +11,11 @@ import { Expression, NonGenerativeExpressionParams } from "../src/generators"; import { Scope } from "../src/scope"; import { SUPPORTED_STDLIB_TYPES } from "../src/types"; import type { Type } from "../src/types"; -import { createProperty, checkProperty } from "../src/util"; -import { dummySrcInfoPrintable } from "../../src/grammar/src-info"; +import { + createProperty, + checkProperty, + dummySrcInfoPrintable, +} from "../src/util"; function emptyContext(): StatementContext { return { From de9ebcad096031f4e65cfaabcb7a273841f1f8ba Mon Sep 17 00:00:00 2001 From: Mell0r Date: Sat, 29 Mar 2025 15:54:33 +0300 Subject: [PATCH 07/44] fix: added stdlib to compilation --- fuzzer/src/stdlib.ts | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/fuzzer/src/stdlib.ts b/fuzzer/src/stdlib.ts index 5e101aec05..450bbb3ce7 100644 --- a/fuzzer/src/stdlib.ts +++ b/fuzzer/src/stdlib.ts @@ -6,11 +6,11 @@ import files from "../../src/stdlib/stdlib"; import { createVirtualFileSystem } from "../../src/vfs/createVirtualFileSystem"; import { dummySrcInfoPrintable, generateAstIdFromName } from "./util"; -const StdlibFilePath = path.join(__dirname, "..", "..", "src", "stdlib", "stdlib", "std"); +const StdlibFilePath = path.join(__dirname, "..", "..", "src", "stdlib", "stdlib"); const StdlibVFS = createVirtualFileSystem(StdlibFilePath, files); -export const StdlibPath = StdlibVFS.resolve("stdlib.fc"); +export const StdlibPath = StdlibVFS.resolve("std/stdlib.fc"); export const StdlibCode = StdlibVFS.readFile(StdlibPath).toString(); -// export const StdlibExPath = StdlibVFS.resolve("stdlib_ex.fc"); +// export const StdlibExPath = StdlibVFS.resolve("std/stdlib_ex.fc"); // export const StdlibExCode = StdlibVFS.readFile(StdlibExPath).toString(); /** From 159d6bd2f9fe3f746e12a81ddb6d805b1ab9f6d4 Mon Sep 17 00:00:00 2001 From: Mell0r Date: Sat, 29 Mar 2025 18:00:50 +0300 Subject: [PATCH 08/44] fix: added evalComptimeExpressions in the precompile replica --- fuzzer/test/testUtils.ts | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/fuzzer/test/testUtils.ts b/fuzzer/test/testUtils.ts index 44041c8818..d015686e74 100644 --- a/fuzzer/test/testUtils.ts +++ b/fuzzer/test/testUtils.ts @@ -8,6 +8,7 @@ import { featureEnable } from "../../src/config/features"; import { resolveDescriptors } from "../../src/types/resolveDescriptors"; import { resolveSignatures } from "../../src/types/resolveSignatures"; import { resolveStatements } from "../../src/types/resolveStatements"; +import { evalComptimeExpressions } from "../../src/types/evalComptimeExpressions"; import { resolveErrors } from "../../src/types/resolveErrors"; import type { FactoryAst } from "../../src/ast/ast-helpers"; import { getParser } from "../../src/grammar/grammar"; @@ -35,10 +36,11 @@ export function precompile( factoryAst: FactoryAst, ): CompilerContext { ctx = resolveDescriptors(ctx, factoryAst); - ctx = resolveSignatures(ctx, factoryAst); - ctx = resolveAllocations(ctx); ctx = resolveStatements(ctx); + evalComptimeExpressions(ctx, factoryAst); + ctx = resolveSignatures(ctx, factoryAst); ctx = resolveErrors(ctx, factoryAst); + ctx = resolveAllocations(ctx); return ctx; } From 608af6623256a356040d7928c8a41cb75f6ef8a2 Mon Sep 17 00:00:00 2001 From: Mell0r Date: Sat, 29 Mar 2025 23:44:02 +0300 Subject: [PATCH 09/44] fix: added constant definitions to trait generation --- fuzzer/src/generators/trait.ts | 13 +++++++++++-- 1 file changed, 11 insertions(+), 2 deletions(-) diff --git a/fuzzer/src/generators/trait.ts b/fuzzer/src/generators/trait.ts index fc15732695..7785feb31f 100644 --- a/fuzzer/src/generators/trait.ts +++ b/fuzzer/src/generators/trait.ts @@ -1,5 +1,10 @@ import type { AstTrait, AstExpression } from "../../../src/ast/ast"; -import { createSample, dummySrcInfoPrintable, generateAstId, randomBool } from "../util"; +import { + createSample, + dummySrcInfoPrintable, + generateAstId, + randomBool, +} from "../util"; import { FunctionDecl } from "./function"; import { Field } from "./field"; import { ConstantDecl, ConstantDef } from "./constant"; @@ -115,7 +120,11 @@ export class Trait extends GenerativeEntity { public generate(): fc.Arbitrary { // NOTE: It doesn't implement any receive functions, to don't clutter the top-level with them. - const constants = this.constantDeclarations.map((c) => c.generate()); + const constants = ( + this.constantDeclarations as (ConstantDecl | ConstantDef)[] + ) + .concat(this.constantDefinitions) + .map((c) => c.generate()); const fields = this.fieldDeclarations.map((f) => f.generate()); const methods = this.methodDeclarations.map((m) => m.generate()); return fc.record({ From 0418907c64ca7acc59e666c92dd11e4da5b3dd40 Mon Sep 17 00:00:00 2001 From: Mell0r Date: Sun, 30 Mar 2025 15:52:57 +0300 Subject: [PATCH 10/44] fix: there is not possible to generate two equal entities of different type with equal name in one scope --- fuzzer/src/generators/constant.ts | 8 ++------ fuzzer/src/generators/contract.ts | 2 +- fuzzer/src/generators/field.ts | 2 +- fuzzer/src/generators/function.ts | 21 ++++++++------------- fuzzer/src/generators/parameter.ts | 2 +- fuzzer/src/generators/statement.ts | 8 ++++---- fuzzer/src/generators/trait.ts | 2 +- fuzzer/src/scope.ts | 18 ++++++++++++++++++ fuzzer/src/types.ts | 15 ++++++--------- fuzzer/src/util.ts | 11 ++++------- 10 files changed, 46 insertions(+), 43 deletions(-) diff --git a/fuzzer/src/generators/constant.ts b/fuzzer/src/generators/constant.ts index 8ab7e5f9b0..1d23273a7e 100644 --- a/fuzzer/src/generators/constant.ts +++ b/fuzzer/src/generators/constant.ts @@ -24,7 +24,7 @@ import fc from "fast-check"; export class ConstantDecl extends GenerativeEntity { constructor(scope: Scope, type: Type) { super(type); - this.name = createSample(generateAstId(scope, "constantDecl")); + this.name = createSample(generateAstId(scope)); } private getAttributes( @@ -92,11 +92,7 @@ export class ConstantDef extends GenerativeEntity { type: Type, init: fc.Arbitrary, ): ConstantDef { - return new ConstantDef( - createSample(generateName(scope, "constantDef")), - type, - init, - ); + return new ConstantDef(createSample(generateName(scope)), type, init); } private generateImpl( diff --git a/fuzzer/src/generators/contract.ts b/fuzzer/src/generators/contract.ts index 2ecd9daeab..581570d97a 100644 --- a/fuzzer/src/generators/contract.ts +++ b/fuzzer/src/generators/contract.ts @@ -47,7 +47,7 @@ export class Contract extends GenerativeEntity { ) { super({ kind: "util", type: UtilType.Contract }); this.scope = new Scope("contract", parentScope); - this.name = createSample(generateAstId(this.scope, "contract")); + this.name = createSample(generateAstId(this.scope)); const { receiveNum = 1 } = params; this.receiveNum = receiveNum; diff --git a/fuzzer/src/generators/field.ts b/fuzzer/src/generators/field.ts index f31dbabe22..765e209812 100644 --- a/fuzzer/src/generators/field.ts +++ b/fuzzer/src/generators/field.ts @@ -34,7 +34,7 @@ export class Field extends GenerativeEntity { ); } super(type); - this.name = name ?? createSample(generateAstId(parentScope, "field")); + this.name = name ?? createSample(generateAstId(parentScope)); } generate(): fc.Arbitrary { diff --git a/fuzzer/src/generators/function.ts b/fuzzer/src/generators/function.ts index 2ab080ec4e..6b11781896 100644 --- a/fuzzer/src/generators/function.ts +++ b/fuzzer/src/generators/function.ts @@ -17,7 +17,12 @@ import type { FunctionType, Type } from "../types"; import { Return } from "./statement"; import { Parameter } from "./parameter"; import { Scope } from "../scope"; -import { createSample, dummySrcInfoPrintable, generateAstId, generateAstIdFromName } from "../util"; +import { + createSample, + dummySrcInfoPrintable, + generateAstId, + generateAstIdFromName, +} from "../util"; import { GenerativeEntity } from "./generator"; import fc from "fast-check"; @@ -122,12 +127,7 @@ export class FunctionDef extends GenerativeEntity { this.kind = kind; this.name = name ? generateAstIdFromName(name) - : createSample( - generateAstId( - this.scope, - kind === "function" ? "functionDef" : "methodDef", - ), - ); + : createSample(generateAstId(this.scope)); } /** @@ -198,12 +198,7 @@ export class FunctionDecl extends GenerativeEntity { super(type); this.kind = "method"; this.scope = new Scope(kind, parentScope); - this.name = createSample( - generateAstId( - this.scope, - kind === "function" ? "functionDecl" : "methodDecl", - ), - ); + this.name = createSample(generateAstId(this.scope)); } private generateImpl( diff --git a/fuzzer/src/generators/parameter.ts b/fuzzer/src/generators/parameter.ts index dd362fce9a..0e2f84ba0c 100644 --- a/fuzzer/src/generators/parameter.ts +++ b/fuzzer/src/generators/parameter.ts @@ -26,7 +26,7 @@ export class Parameter extends GenerativeEntity { ); } super(type); - this.name = createSample(generateAstId(parentScope, "field")); + this.name = createSample(generateAstId(parentScope)); } generate(): fc.Arbitrary { diff --git a/fuzzer/src/generators/statement.ts b/fuzzer/src/generators/statement.ts index 64aca03fec..f8bd74e114 100644 --- a/fuzzer/src/generators/statement.ts +++ b/fuzzer/src/generators/statement.ts @@ -91,7 +91,7 @@ export class Let extends GenerativeEntity { private expr: fc.Arbitrary, ) { super(type); - this.name = createSample(generateAstId(parentScope, "constantDef")); + this.name = createSample(generateAstId(parentScope)); } generate(): fc.Arbitrary { @@ -509,8 +509,8 @@ export class Statement extends GenerativeEntity { return undefined; } const map: fc.Arbitrary = fc.oneof(...mapIds); - const keyVarName = createSample(generateName(scope, "let")); - const valueVarName = createSample(generateName(scope, "let")); + const keyVarName = createSample(generateName(scope)); + const valueVarName = createSample(generateName(scope)); const body = this.makeStmtsBlock(scope); return new ForeachStatement( map, @@ -548,7 +548,7 @@ export class Statement extends GenerativeEntity { const tryStmts = this.makeStmtsBlock(); if (randomBool()) { const catchScope = new Scope("block", this.parentScope); - const catchName = createSample(generateName(catchScope, "let")); + const catchName = createSample(generateName(catchScope)); const catchStmts = this.makeStmtsBlock(catchScope).map((stmt) => createSample(stmt), ); diff --git a/fuzzer/src/generators/trait.ts b/fuzzer/src/generators/trait.ts index 7785feb31f..6b3cf0e62b 100644 --- a/fuzzer/src/generators/trait.ts +++ b/fuzzer/src/generators/trait.ts @@ -57,7 +57,7 @@ export class Trait extends GenerativeEntity { constructor(programScope: Scope, params: Partial = {}) { super({ kind: "util", type: UtilType.Trait }); this.scope = new Scope("trait", programScope); - this.name = createSample(generateAstId(this.scope, "trait")); + this.name = createSample(generateAstId(this.scope)); const { fieldNum = 1, diff --git a/fuzzer/src/scope.ts b/fuzzer/src/scope.ts index 2ff2165776..29d78d1e1d 100644 --- a/fuzzer/src/scope.ts +++ b/fuzzer/src/scope.ts @@ -262,6 +262,24 @@ export class Scope { ); } } + + /** + * Collects all names of all entities in the scope. + */ + public getAllNames(): string[] { + return Array.from(this.map.values()).flatMap((m) => + Array.from(m.values()).map((entity) => entity.name?.text ?? ""), + ); + } + + /** + * Collects all names of all entities in the scope and it all parent scopes. + */ + public getAllNamesRecursive(): string[] { + return this.getAllNames().concat( + this.parentScope?.getAllNamesRecursive() ?? [], + ); + } /** * Returns all items of the given type defined within this scope. diff --git a/fuzzer/src/types.ts b/fuzzer/src/types.ts index c725fe0745..04e6b7af5a 100644 --- a/fuzzer/src/types.ts +++ b/fuzzer/src/types.ts @@ -370,21 +370,15 @@ export class TypeGen { * Generates an arbitrary struct or message signature. */ public generateStruct(isMessage: boolean): fc.Arbitrary { - const kind = isMessage ? "message" : "struct"; const structName = createSample( - generateName( - this.scope, - kind, - /*shadowing=*/ true, - /*isType=*/ true, - ), + generateName(this.scope, /*shadowing=*/ true, /*isType=*/ true), ); // NOTE: It doesn't support nested structs/messages as they are not const fields = fc .array( fc.record({ - name: generateName(this.scope, kind), // TODO: kind in arguments doesn't makes sense here, change generateName signature so you can pass nothing in this argument + name: generateName(this.scope), type: this.stdlibArbitrary, default: fc.constantFrom(undefined), }), @@ -392,7 +386,10 @@ export class TypeGen { ) .filter((generatedFields) => generatedFields.every( - (item, index) => generatedFields.indexOf(item) === index, + (item, index) => + generatedFields.findIndex( + (other) => other.name === item.name, + ) === index, ), ); if (isMessage) { diff --git a/fuzzer/src/util.ts b/fuzzer/src/util.ts index d7555c4552..d1af83bd8d 100644 --- a/fuzzer/src/util.ts +++ b/fuzzer/src/util.ts @@ -134,13 +134,12 @@ export function createSamplesArray( */ export function generateName( scope: Scope, - kind: ScopeItemKind, shadowing: boolean = true, isType: boolean = false, ): fc.Arbitrary { const availableNames = shadowing - ? scope.getEntries(kind) - : scope.getEntriesRecursive(kind); + ? scope.getAllNames() + : scope.getAllNamesRecursive(); return fc .stringMatching(isType ? VALID_TYPE_ID : VALID_ID) @@ -167,18 +166,16 @@ export function generateAstIdFromName(name: string): AstId { /** * Generates AstId. * @param scope Current scope, from which AstId.text will be generated. - * @param kind Entity for which AstId is generated. * @param shadowing Allow shadowing (using names available in parent scopes) */ export function generateAstId( scope: Scope, - kind: ScopeItemKind, shadowing: boolean = true, isType: boolean = false, ): fc.Arbitrary { return fc.record({ kind: fc.constant("id"), - text: generateName(scope, kind, shadowing, isType), + text: generateName(scope, shadowing, isType), id: fc.constant(nextId()), loc: fc.constant(dummySrcInfoPrintable), }); @@ -233,4 +230,4 @@ export function packArbitraries( return arbs ? fc.tuple(...(arbs as [fc.Arbitrary])) : fc.constant([]); } -export const dummySrcInfoPrintable = getSrcInfo(" ", 0, 0, null, "user"); \ No newline at end of file +export const dummySrcInfoPrintable = getSrcInfo(" ", 0, 0, null, "user"); From 8a0969149845033f264726bbe68fce5a7855c082 Mon Sep 17 00:00:00 2001 From: Mell0r Date: Sun, 30 Mar 2025 18:13:44 +0300 Subject: [PATCH 11/44] refactor: separated named and unnamed entities in scope to provide null safety --- fuzzer/src/generators/constant.ts | 18 ++- fuzzer/src/generators/contract.ts | 23 ++-- fuzzer/src/generators/expression.ts | 56 ++++---- fuzzer/src/generators/field.ts | 9 +- fuzzer/src/generators/function.ts | 37 ++--- fuzzer/src/generators/generator.ts | 16 ++- fuzzer/src/generators/parameter.ts | 9 +- fuzzer/src/generators/program.ts | 28 ++-- fuzzer/src/generators/receiver.ts | 25 ++-- fuzzer/src/generators/statement.ts | 27 ++-- fuzzer/src/generators/struct.ts | 14 +- fuzzer/src/generators/trait.ts | 17 ++- fuzzer/src/scope.ts | 207 ++++++++++++++++++---------- fuzzer/src/util.ts | 6 +- 14 files changed, 289 insertions(+), 203 deletions(-) diff --git a/fuzzer/src/generators/constant.ts b/fuzzer/src/generators/constant.ts index 1d23273a7e..74dcb07a5d 100644 --- a/fuzzer/src/generators/constant.ts +++ b/fuzzer/src/generators/constant.ts @@ -14,17 +14,16 @@ import { import { tyToAstType } from "../types"; import type { Type } from "../types"; import type { Scope } from "../scope"; -import { GenerativeEntity } from "./generator"; +import { NamedGenerativeEntity } from "./generator"; import fc from "fast-check"; /** * An object that encapsulates a generated AstConstantDecl. */ -export class ConstantDecl extends GenerativeEntity { +export class ConstantDecl extends NamedGenerativeEntity { constructor(scope: Scope, type: Type) { - super(type); - this.name = createSample(generateAstId(scope)); + super(type, createSample(generateAstId(scope))); } private getAttributes( @@ -41,7 +40,7 @@ export class ConstantDecl extends GenerativeEntity { return fc.record({ kind: fc.constant("constant_decl"), id: fc.constant(this.idx), - name: fc.constant(this.name!), + name: fc.constant(this.name), type: fc.constant(tyToAstType(this.type)), attributes: fc.constantFrom(this.getAttributes(extraAttrs)), loc: fc.constant(dummySrcInfoPrintable), @@ -60,7 +59,7 @@ export class ConstantDecl extends GenerativeEntity { * @param init An initializer evaluable in compile-time. */ public createDefinition(init: fc.Arbitrary): ConstantDef { - return new ConstantDef(this.name?.text!, this.type, init); + return new ConstantDef(this.name?.text, this.type, init); } } @@ -68,7 +67,7 @@ export class ConstantDecl extends GenerativeEntity { * An object that encapsulates a generated AstConstantDef. * @parentScope Scope this constant belongs to. */ -export class ConstantDef extends GenerativeEntity { +export class ConstantDef extends NamedGenerativeEntity { /** * Create new constant definition from its name and type. Used to create definition from an existing declaration. * @param init An initializer evaluable in compile-time. @@ -78,8 +77,7 @@ export class ConstantDef extends GenerativeEntity { type: Type, private init: fc.Arbitrary, ) { - super(type); - this.name = generateAstIdFromName(name); + super(type, generateAstIdFromName(name)); } /** * Create a new constant definition generation name from scope. @@ -103,7 +101,7 @@ export class ConstantDef extends GenerativeEntity { return fc.record({ kind: fc.constant("constant_def"), id: fc.constant(this.idx), - name: fc.constant(this.name!), + name: fc.constant(this.name), type: fc.constant(tyToAstType(this.type)), initializer: choosenInit, attributes: fc.constantFrom(extraAttrs), diff --git a/fuzzer/src/generators/contract.ts b/fuzzer/src/generators/contract.ts index 581570d97a..8f6e797edc 100644 --- a/fuzzer/src/generators/contract.ts +++ b/fuzzer/src/generators/contract.ts @@ -12,7 +12,7 @@ import { Receive } from "./receiver"; import { UtilType } from "../types"; import type { FunctionType } from "../types"; import { Scope } from "../scope"; -import { GenerativeEntity } from "./generator"; +import { NamedGenerativeEntity } from "./generator"; import fc from "fast-check"; import { Field } from "./field"; @@ -29,7 +29,7 @@ export interface ContractParameters { * An object that encapsulates a randomly generated AstContract including extra information * about its entries and their scopes. */ -export class Contract extends GenerativeEntity { +export class Contract extends NamedGenerativeEntity { /** Scope used within the generated contract. */ private scope: Scope; @@ -45,9 +45,12 @@ export class Contract extends GenerativeEntity { private trait?: Trait, params: Partial = {}, ) { - super({ kind: "util", type: UtilType.Contract }); - this.scope = new Scope("contract", parentScope); - this.name = createSample(generateAstId(this.scope)); + const scope = new Scope("contract", parentScope); + super( + { kind: "util", type: UtilType.Contract }, + createSample(generateAstId(scope)), + ); + this.scope = scope; const { receiveNum = 1 } = params; this.receiveNum = receiveNum; @@ -103,24 +106,24 @@ export class Contract extends GenerativeEntity { const requestedMethods = this.methodSignatures.map((signature) => new FunctionDef(this.scope, "method", signature).generate(), ); - const generatedMethods = Array.from(this.scope.getAll("methodDef")).map( + const generatedMethods = Array.from(this.scope.getAllNamed("methodDef")).map( (m) => m.generate(), ); const requestedReceives = Array.from({ length: this.receiveNum }).map( (_) => new Receive(this.scope).generate(), ); const generatedConstants = Array.from( - this.scope.getAll("constantDef"), + this.scope.getAllNamed("constantDef"), ).map((c) => c.generate()); - const generatedFields = Array.from(this.scope.getAll("field")).map( + const generatedFields = Array.from(this.scope.getAllNamed("field")).map( (f) => f.generate(), ); return fc.record({ kind: fc.constant("contract"), id: fc.constant(this.idx), - name: fc.constant(this.name!), + name: fc.constant(this.name), traits: fc.constant( - this.trait === undefined ? [] : [this.trait.name!], + this.trait === undefined ? [] : [this.trait.name], ), attributes: fc.constantFrom([]), declarations: fc.tuple( diff --git a/fuzzer/src/generators/expression.ts b/fuzzer/src/generators/expression.ts index d042880826..e47c199986 100644 --- a/fuzzer/src/generators/expression.ts +++ b/fuzzer/src/generators/expression.ts @@ -28,7 +28,11 @@ import { generateAstIdFromName, dummySrcInfoPrintable, } from "../util"; -import { GenerativeEntity, GenerativeEntityOpt } from "./generator"; +import { + GenerativeEntity, + NamedGenerativeEntity, + GenerativeEntityOpt, +} from "./generator"; import { nextId } from "../id"; import { StdlibType, @@ -227,7 +231,7 @@ export function generateMethodCallArgs( /** * Generates field and contract constants access operations. */ -export class FieldAccess extends GenerativeEntity { +export class FieldAccess extends NamedGenerativeEntity { constructor( type: Type, fieldName: string, @@ -240,7 +244,7 @@ export class FieldAccess extends GenerativeEntity { return fc.record({ kind: fc.constant("field_access"), aggregate: fc.constant(this.src ?? generateThisID()), - field: fc.constant(this.name!), + field: fc.constant(this.name), id: fc.constant(this.idx), loc: fc.constant(dummySrcInfoPrintable), }); @@ -250,7 +254,7 @@ export class FieldAccess extends GenerativeEntity { /** * Generates method calls. */ -export class MethodCall extends GenerativeEntity { +export class MethodCall extends NamedGenerativeEntity { constructor( type: Type, name: string, @@ -263,7 +267,7 @@ export class MethodCall extends GenerativeEntity { return fc.record({ kind: fc.constant("method_call"), self: fc.constant(this.src), - method: fc.constant(this.name!), + method: fc.constant(this.name), args: packArbitraries(this.args), id: fc.constant(this.idx), loc: fc.constant(dummySrcInfoPrintable), @@ -274,7 +278,7 @@ export class MethodCall extends GenerativeEntity { /** * Generates free function calls. */ -export class StaticCall extends GenerativeEntity { +export class StaticCall extends NamedGenerativeEntity { constructor( type: Type, name: string, @@ -285,7 +289,7 @@ export class StaticCall extends GenerativeEntity { generate(): fc.Arbitrary { return fc.record({ kind: fc.constant("static_call"), - function: fc.constantFrom(this.name!), + function: fc.constantFrom(this.name), args: packArbitraries(this.args), id: fc.constant(this.idx), loc: fc.constant(dummySrcInfoPrintable), @@ -427,7 +431,7 @@ export class StructAccess extends GenerativeEntityOpt< [] as string[], ); if (matchingFieldNames.length > 0) { - acc.set(struct.name?.text!, [ + acc.set(struct.name.text, [ struct.type, matchingFieldNames, ]); @@ -471,10 +475,8 @@ export class StructAccess extends GenerativeEntityOpt< structType, ).generate(); const varStmt = new Let(this.parentScope, structType, initExpr); - this.parentScope.add("let", varStmt); - return new Map([ - [chosenStructName, [structType, [varStmt.name?.text!]]], - ]); + this.parentScope.addNamed("let", varStmt); + return new Map([[chosenStructName, [structType, [varStmt.name.text]]]]); } /** @@ -660,12 +662,12 @@ export class Expression extends GenerativeEntity { : undefined; if (init) { const constant = ConstantDef.fromScope(scope, ty, init); - this.parentScope.add("constantDef", constant); - constantNames.push(constant.name?.text!); + this.parentScope.addNamed("constantDef", constant); + constantNames.push(constant.name.text); } else { const constant = new ConstantDecl(scope, ty); - this.parentScope.add("constantDecl", constant); - constantNames.push(constant.name?.text!); + this.parentScope.addNamed("constantDecl", constant); + constantNames.push(constant.name.text); } } const arbs = scope.definedIn("contract", "method") @@ -707,8 +709,8 @@ export class Expression extends GenerativeEntity { compileTimeEval: true, }).generate(); const field = new Field(this.parentScope, ty, init); - this.parentScope.add("field", field); - fieldNames.push(field.name?.text!); + this.parentScope.addNamed("field", field); + fieldNames.push(field.name.text); } const arbs = fieldNames.map((name) => new FieldAccess(ty, name).generate(), @@ -733,8 +735,8 @@ export class Expression extends GenerativeEntity { if (varNames.length === 0) { const init = new Expression(this.parentScope, ty).generate(); const varStmt = new Let(this.parentScope, ty, init); - this.parentScope.add("let", varStmt); - varNames.push(varStmt.name?.text!); + this.parentScope.addNamed("let", varStmt); + varNames.push(varStmt.name.text); } const arbs = varNames.map((name) => fc.constant(generateAstIdFromName(name)), @@ -772,7 +774,7 @@ export class Expression extends GenerativeEntity { } Array.from({ length: this.generatedStatementsNum }).forEach(() => { const stmt = new Statement(this.parentScope); - this.parentScope.add("statement", stmt); + this.parentScope.addUnnamed("statement", stmt); }); } @@ -793,8 +795,8 @@ export class Expression extends GenerativeEntity { const programScope = this.parentScope.getProgramScope(); const funTy = makeFunctionTy("function", returnTy); const fun = new FunctionDef(programScope, "function", funTy); - this.parentScope.add("functionDef", fun); - funNames.push([fun.name?.text!, funTy]); + this.parentScope.addNamed("functionDef", fun); + funNames.push([fun.name.text, funTy]); } const arbs = funNames.map(([name, funTy]) => new StaticCall( @@ -826,7 +828,7 @@ export class Expression extends GenerativeEntity { const stdlibArbs = [ // self.map_field.get(key) ...this.parentScope - .getEntriesRecursive("field") + .getNamedEntriesRecursive("field") .reduce((acc, [mapName, mapTy]) => { if ( mapTy.kind === "map" && @@ -855,7 +857,7 @@ export class Expression extends GenerativeEntity { }, [] as fc.Arbitrary[]), // map_var.get(key) ...this.parentScope - .getEntriesRecursive("let") + .getNamedEntriesRecursive("let") .reduce((acc, [mapName, mapTy]) => { if ( mapTy.kind === "map" && @@ -895,8 +897,8 @@ export class Expression extends GenerativeEntity { } const methodTy = makeFunctionTy("method", returnTy); const method = new FunctionDef(contractScope, "method", methodTy); - this.parentScope.add("methodDef", method); - userMethods.push([method.name?.text!, methodTy]); + this.parentScope.addNamed("methodDef", method); + userMethods.push([method.name.text, methodTy]); } const userArbs = userMethods.map(([name, methodTy]) => new MethodCall( diff --git a/fuzzer/src/generators/field.ts b/fuzzer/src/generators/field.ts index 765e209812..8e39fbe044 100644 --- a/fuzzer/src/generators/field.ts +++ b/fuzzer/src/generators/field.ts @@ -3,14 +3,14 @@ import { createSample, dummySrcInfoPrintable, generateAstId } from "../util"; import { tyToAstType } from "../types"; import type { Type } from "../types"; import type { Scope } from "../scope"; -import { GenerativeEntity } from "./generator"; +import { NamedGenerativeEntity } from "./generator"; import fc from "fast-check"; /** * An object that encapsulates a generated AstFieldDecl. */ -export class Field extends GenerativeEntity { +export class Field extends NamedGenerativeEntity { /** * @param init An optional initializer evaluable in compile-time. * @param parentScope Scope this field belongs to. Could be a contract or program for struct fields. @@ -33,15 +33,14 @@ export class Field extends GenerativeEntity { `Cannot define a field in a ${parentScope.kind} scope`, ); } - super(type); - this.name = name ?? createSample(generateAstId(parentScope)); + super(type, name ?? createSample(generateAstId(parentScope))); } generate(): fc.Arbitrary { return fc.record({ kind: fc.constant("field_decl"), id: fc.constant(this.idx), - name: fc.constant(this.name!), + name: fc.constant(this.name), type: fc.constant(tyToAstType(this.type)), initializer: this.init ?? fc.constant(undefined), as: fc.constantFrom(undefined), diff --git a/fuzzer/src/generators/function.ts b/fuzzer/src/generators/function.ts index 6b11781896..ac79aca016 100644 --- a/fuzzer/src/generators/function.ts +++ b/fuzzer/src/generators/function.ts @@ -23,7 +23,7 @@ import { generateAstId, generateAstIdFromName, } from "../util"; -import { GenerativeEntity } from "./generator"; +import { NamedGenerativeEntity } from "./generator"; import fc from "fast-check"; @@ -64,7 +64,7 @@ function generateParameters( : type.signature.slice(0, -1); return slice.map((argty) => { const param = new Parameter(scope, argty); - scope.add("parameter", param); + scope.addNamed("parameter", param); return createSample(param.generate()); }); } @@ -107,7 +107,7 @@ function getAttributes( * An object that encapsulates the generated free function or contract method definition including * its scope and nested elements. */ -export class FunctionDef extends GenerativeEntity { +export class FunctionDef extends NamedGenerativeEntity { /** Generated body items. */ private body: fc.Arbitrary[] = []; @@ -122,12 +122,15 @@ export class FunctionDef extends GenerativeEntity { type: FunctionType, name?: string, ) { - super(type); - this.scope = new Scope(kind, parentScope); + const scope = new Scope(kind, parentScope); + super( + type, + name + ? generateAstIdFromName(name) + : createSample(generateAstId(scope)), + ); + this.scope = scope; this.kind = kind; - this.name = name - ? generateAstIdFromName(name) - : createSample(generateAstId(this.scope)); } /** @@ -140,10 +143,10 @@ export class FunctionDef extends GenerativeEntity { ? getReturnType(type) : { kind: "util", type: UtilType.Unit }; const returnStmt = new Return(this.scope, returnTy).generate(); - const generatedLetBindings = Array.from(this.scope.getAll("let")).map( + const generatedLetBindings = Array.from(this.scope.getAllNamed("let")).map( (c) => c.generate(), ); - const generatedStmts = Array.from(this.scope.getAll("statement")).map( + const generatedStmts = Array.from(this.scope.getAllUnnamed("statement")).map( (c) => c.generate(), ); this.body = [...generatedLetBindings, ...generatedStmts, returnStmt]; @@ -160,7 +163,7 @@ export class FunctionDef extends GenerativeEntity { attributes: fc.constant( getAttributes(extraAttrs, this.kind, false), ), - name: fc.constant(this.name!), + name: fc.constant(this.name), return: fc.constant( isUnit(returnTy) ? undefined : tyToAstType(returnTy), ), @@ -188,17 +191,17 @@ export class FunctionDef extends GenerativeEntity { * An object that encapsulates the generated free function or trait method declaration including * its scope and nested elements. */ -export class FunctionDecl extends GenerativeEntity { +export class FunctionDecl extends NamedGenerativeEntity { /** Scope used within the generated function. */ private scope: Scope; private kind: FunctionKind; constructor(parentScope: Scope, kind: FunctionKind, type: FunctionType) { - super(type); + const scope = new Scope(kind, parentScope); + super(type, createSample(generateAstId(scope))); this.kind = "method"; - this.scope = new Scope(kind, parentScope); - this.name = createSample(generateAstId(this.scope)); + this.scope = scope; } private generateImpl( @@ -209,7 +212,7 @@ export class FunctionDecl extends GenerativeEntity { kind: fc.constant("function_decl"), id: fc.constant(this.idx), attributes: fc.constant(getAttributes(extraAttrs, this.kind, true)), - name: fc.constant(this.name!), + name: fc.constant(this.name), return: fc.constant( isUnit(returnTy) ? undefined : tyToAstType(returnTy), ), @@ -242,7 +245,7 @@ export class FunctionDecl extends GenerativeEntity { this.scope.parentScope!, kind, this.type as FunctionType, - this.name!.text, + this.name.text, ).generateImpl(attrs); } } diff --git a/fuzzer/src/generators/generator.ts b/fuzzer/src/generators/generator.ts index 209afc7167..d59d616963 100644 --- a/fuzzer/src/generators/generator.ts +++ b/fuzzer/src/generators/generator.ts @@ -9,15 +9,11 @@ abstract class GenerativeEntityBase { /** The unique index of the entity. */ public idx: IDIdx; - /** An optional name of the entity. */ - public name?: AstId; - /** The type of the entity. */ public type: Type; - constructor(type: Type, name?: AstId) { + constructor(type: Type) { this.idx = nextId(); - this.name = name; this.type = type; } } @@ -28,6 +24,16 @@ abstract class GenerativeEntityBase { export abstract class GenerativeEntity extends GenerativeEntityBase { abstract generate(): fc.Arbitrary; } + +export abstract class NamedGenerativeEntity extends GenerativeEntity { + public name: AstId; + + constructor(type: Type, name: AstId) { + super(type); + this.name = name; + } +} + /** * A specialized version of GenerativeEntity that cannot generate AST entities in some cases. */ diff --git a/fuzzer/src/generators/parameter.ts b/fuzzer/src/generators/parameter.ts index 0e2f84ba0c..1cd2252578 100644 --- a/fuzzer/src/generators/parameter.ts +++ b/fuzzer/src/generators/parameter.ts @@ -3,14 +3,14 @@ import { createSample, dummySrcInfoPrintable, generateAstId } from "../util"; import { tyToAstType } from "../types"; import type { Type } from "../types"; import type { Scope } from "../scope"; -import { GenerativeEntity } from "./generator"; +import { NamedGenerativeEntity } from "./generator"; import fc from "fast-check"; /** * An object that encapsulates generated AstTypedParameter. */ -export class Parameter extends GenerativeEntity { +export class Parameter extends NamedGenerativeEntity { /** * @param parentScope Scope of the function this argument belongs to. * @param isBounced If the type of the argument should be wrapped in `bounced<>` @@ -25,15 +25,14 @@ export class Parameter extends GenerativeEntity { `Cannot define a function argument in the ${parentScope.kind} scope`, ); } - super(type); - this.name = createSample(generateAstId(parentScope)); + super(type, createSample(generateAstId(parentScope))); } generate(): fc.Arbitrary { return fc.record({ kind: fc.constant("typed_parameter"), id: fc.constant(this.idx), - name: fc.constant(this.name!), + name: fc.constant(this.name), type: fc.constant(tyToAstType(this.type, this.isBounced)), loc: fc.constant(dummySrcInfoPrintable), }); diff --git a/fuzzer/src/generators/program.ts b/fuzzer/src/generators/program.ts index 6f0bf1cb33..d6041268b5 100644 --- a/fuzzer/src/generators/program.ts +++ b/fuzzer/src/generators/program.ts @@ -12,7 +12,7 @@ import { Contract } from "./contract"; import { Message, Struct } from "./struct"; import { Trait } from "./trait"; import { Scope } from "../scope"; -import { GenerativeEntity } from "./generator"; +import { NamedGenerativeEntity } from "./generator"; import { getStdlibTraits } from "../stdlib"; import fc from "fast-check"; @@ -44,7 +44,7 @@ export interface ProgramParameters { * An object that encapsulates a randomly generated AstModule including extra information * about its entries and their scopes. */ -export class Program extends GenerativeEntity { +export class Program extends NamedGenerativeEntity { /** Top-level global scope. */ private scope: Scope; @@ -69,11 +69,11 @@ export class Program extends GenerativeEntity { // NOTE: Structures and messages must be generated prior to contracts in order // to add their entries to scopes for futher reuse. Array.from({ length: structsNum }).forEach((_) => { - this.scope.add("struct", this.makeStruct()); + this.scope.addNamed("struct", this.makeStruct()); }); Array.from({ length: messagesNum }).forEach((_) => { - this.scope.add("message", this.makeMessage()); + this.scope.addNamed("message", this.makeMessage()); }); // NOTE: Traits must be generated prior to contracts to enable them implement them. @@ -81,13 +81,13 @@ export class Program extends GenerativeEntity { Array.from({ length: traitsNum }).forEach((_) => { const trait = this.makeTrait(); traits.push(trait); - this.scope.add("trait", trait); + this.scope.addNamed("trait", trait); }); // One of the traits could be implemented by the main contract. const traitToImplement = traitsNum > 0 && randomBool() ? randomElement(traits) : undefined; - this.scope.add("contract", this.makeContract(traitToImplement)); + this.scope.addNamed("contract", this.makeContract(traitToImplement)); } /** @@ -105,22 +105,22 @@ export class Program extends GenerativeEntity { .concat(getStdlibTypes()) .map((entry) => fc.constant(entry)) : []; - const traits = Array.from(this.scope.getAll("trait")).map((t) => + const traits = Array.from(this.scope.getAllNamed("trait")).map((t) => t.generate(), ); - const contracts = Array.from(this.scope.getAll("contract")).map((c) => - c.generate(), + const contracts = Array.from(this.scope.getAllNamed("contract")).map( + (c) => c.generate(), ); - const structs = Array.from(this.scope.getAll("struct")).map((s) => + const structs = Array.from(this.scope.getAllNamed("struct")).map((s) => s.generate(), ); - const messages = Array.from(this.scope.getAll("message")).map((m) => - m.generate(), + const messages = Array.from(this.scope.getAllNamed("message")).map( + (m) => m.generate(), ); - const constants = Array.from(this.scope.getAll("constantDef")).map( + const constants = Array.from(this.scope.getAllNamed("constantDef")).map( (c) => c.generate(), ); - const functions = Array.from(this.scope.getAll("functionDef")).map( + const functions = Array.from(this.scope.getAllNamed("functionDef")).map( (f) => f.generate(), ); return fc.record({ diff --git a/fuzzer/src/generators/receiver.ts b/fuzzer/src/generators/receiver.ts index 17374b3454..9b341ef7e5 100644 --- a/fuzzer/src/generators/receiver.ts +++ b/fuzzer/src/generators/receiver.ts @@ -11,7 +11,12 @@ import { UtilType, StdlibType, isBouncedMessage } from "../types"; import type { Type } from "../types"; import { Scope } from "../scope"; import { GenerativeEntity } from "./generator"; -import { createSample, dummySrcInfoPrintable, randomBool, randomElement } from "../util"; +import { + createSample, + dummySrcInfoPrintable, + randomBool, + randomElement, +} from "../util"; import { Expression, generateString } from "./expression"; import { Parameter } from "./parameter"; import { StatementExpression } from "./statement"; @@ -85,7 +90,7 @@ export class Receive extends GenerativeEntity { }), ); const param = new Parameter(this.scope, ty); - this.scope.add("parameter", param); + this.scope.addNamed("parameter", param); const internalSimple = generateRecieverKind( "internal", generateReceiverSimpleSubKind(param), @@ -98,7 +103,7 @@ export class Receive extends GenerativeEntity { } // Choose a random message and create a bounced receiver using it. - const messages = this.scope.getProgramScope().getAll("message"); + const messages = this.scope.getProgramScope().getAllNamed("message"); if (messages.length > 0 && randomBool()) { const msg = randomElement(messages); const param = new Parameter( @@ -106,7 +111,7 @@ export class Receive extends GenerativeEntity { msg.type, isBouncedMessage(msg.type), ); - this.scope.add("parameter", param); + this.scope.addNamed("parameter", param); return fc.record({ kind: fc.constantFrom("bounce"), param: param.generate(), @@ -145,12 +150,12 @@ export class Receive extends GenerativeEntity { const expr = new Expression(this.scope, this.type).generate(); const stmt = new StatementExpression(expr).generate(); - const generatedLetBindings = Array.from(this.scope.getAll("let")).map( - (c) => c.generate(), - ); - const generatedStmts = Array.from(this.scope.getAll("statement")).map( - (c) => c.generate(), - ); + const generatedLetBindings = Array.from( + this.scope.getAllNamed("let"), + ).map((c) => c.generate()); + const generatedStmts = Array.from( + this.scope.getAllUnnamed("statement"), + ).map((c) => c.generate()); this.body = [...generatedLetBindings, ...generatedStmts, stmt]; return fc.tuple(...this.body); } diff --git a/fuzzer/src/generators/statement.ts b/fuzzer/src/generators/statement.ts index f8bd74e114..c668b74d97 100644 --- a/fuzzer/src/generators/statement.ts +++ b/fuzzer/src/generators/statement.ts @@ -40,11 +40,11 @@ import { generateAstIdFromName, dummySrcInfoPrintable, } from "../util"; -import { GenerativeEntity } from "./generator"; +import { GenerativeEntity, NamedGenerativeEntity } from "./generator"; import { StdlibType, UtilType, tyToAstType } from "../types"; import type { Type } from "../types"; import { Scope } from "../scope"; -import type { ScopeItemKind } from "../scope"; +import type { NamedScopeItemKind } from "../scope"; /** Type all the imperative constructions have. */ const STMT_TY: Type = { kind: "util", type: UtilType.Unit }; @@ -79,7 +79,7 @@ export class Return extends GenerativeEntity { * Let generator is the entry point of the bottom-up statement generation. * It creates a variable binding and then adds additional statements that mutate the created binding and the global state. */ -export class Let extends GenerativeEntity { +export class Let extends NamedGenerativeEntity { /** * @param parentScope Scope this statement belongs to. * @param type Type of the generated binding. @@ -90,15 +90,14 @@ export class Let extends GenerativeEntity { type: Type, private expr: fc.Arbitrary, ) { - super(type); - this.name = createSample(generateAstId(parentScope)); + super(type, createSample(generateAstId(parentScope))); } generate(): fc.Arbitrary { return fc.record({ kind: fc.constant("statement_let"), id: fc.constant(this.idx), - name: fc.constantFrom(this.name!), + name: fc.constantFrom(this.name), type: fc.constantFrom(tyToAstType(this.type)), expression: this.expr, loc: fc.constant(dummySrcInfoPrintable), @@ -390,7 +389,7 @@ export class Statement extends GenerativeEntity { */ private makeVarAssign(): fc.Arbitrary | undefined { const varEntries: [string, Type][] = - this.parentScope.getEntriesRecursive("let"); + this.parentScope.getNamedEntriesRecursive("let"); if (varEntries.length === 0) { return undefined; } @@ -413,7 +412,7 @@ export class Statement extends GenerativeEntity { return undefined; } const fieldEntries: [string, Type][] = - this.parentScope.getEntriesRecursive("field"); + this.parentScope.getNamedEntriesRecursive("field"); if (fieldEntries.length === 0) { return undefined; } @@ -466,9 +465,9 @@ export class Statement extends GenerativeEntity { /** * Collects all local map AstIds in parent scope. */ - private collectLocalMapIds(entryKinds: ScopeItemKind[]): AstId[] { + private collectLocalMapIds(entryKinds: NamedScopeItemKind[]): AstId[] { return this.parentScope - .getEntriesRecursive(...entryKinds) + .getNamedEntriesRecursive(...entryKinds) .filter(([_, mapTy]: [string, Type]) => mapTy.kind === "map") .map(([mapName, _]: [string, Type]) => generateAstIdFromName(mapName), @@ -478,9 +477,9 @@ export class Statement extends GenerativeEntity { /** * Collects all field map AstIds in parent scope. */ - private collectFieldMapIds(entryKinds: ScopeItemKind[]): AstFieldAccess[] { + private collectFieldMapIds(entryKinds: NamedScopeItemKind[]): AstFieldAccess[] { return this.parentScope - .getEntriesRecursive(...entryKinds) + .getNamedEntriesRecursive(...entryKinds) .filter(([_, mapTy]: [string, Type]) => mapTy.kind === "map") .map(([mapName, _]: [string, Type]) => generateFieldAccess(mapName), @@ -571,7 +570,7 @@ export class Statement extends GenerativeEntity { if (this.parentScope.definedIn("method", "contract") && randomBool()) { // Call a method const methodEntries = - this.parentScope.getEntriesRecursive("methodDef"); + this.parentScope.getNamedEntriesRecursive("methodDef"); if (methodEntries.length === 0) { return undefined; } @@ -587,7 +586,7 @@ export class Statement extends GenerativeEntity { } else { // Call a function const funEntries = - this.parentScope.getEntriesRecursive("functionDef"); + this.parentScope.getNamedEntriesRecursive("functionDef"); if (funEntries.length === 0) { return undefined; } diff --git a/fuzzer/src/generators/struct.ts b/fuzzer/src/generators/struct.ts index b67ff8ca56..c1e44bd0ca 100644 --- a/fuzzer/src/generators/struct.ts +++ b/fuzzer/src/generators/struct.ts @@ -3,15 +3,19 @@ import { tyToString, throwTyError } from "../types"; import type { Type, StructField } from "../types"; import type { Scope } from "../scope"; import { Field } from "./field"; -import { dummySrcInfoPrintable, generateAstIdFromName, packArbitraries } from "../util"; -import { GenerativeEntity } from "./generator"; +import { + dummySrcInfoPrintable, + generateAstIdFromName, + packArbitraries, +} from "../util"; +import { NamedGenerativeEntity } from "./generator"; import fc from "fast-check"; /** * An object that generates AstStructDecl object. */ -export class Struct extends GenerativeEntity { +export class Struct extends NamedGenerativeEntity { /** * @param programScope A program scope the structure defined in. */ @@ -47,7 +51,7 @@ export class Struct extends GenerativeEntity { return fc.record({ kind: fc.constant("struct_decl"), id: fc.constant(this.idx), - name: fc.constant(this.name!), + name: fc.constant(this.name), fields: packArbitraries(fields), loc: fc.constant(dummySrcInfoPrintable), }); @@ -57,7 +61,7 @@ export class Struct extends GenerativeEntity { /** * An object that generates AstMessageDecl object messages. */ -export class Message extends GenerativeEntity { +export class Message extends NamedGenerativeEntity { /** * @param programScope A program scope the structure defined in. */ diff --git a/fuzzer/src/generators/trait.ts b/fuzzer/src/generators/trait.ts index 6b3cf0e62b..dc02cd43d4 100644 --- a/fuzzer/src/generators/trait.ts +++ b/fuzzer/src/generators/trait.ts @@ -12,7 +12,7 @@ import { Expression } from "./expression"; import { TypeGen, makeFunctionTy, UtilType } from "../types"; import type { Type } from "../types"; import { Scope } from "../scope"; -import { GenerativeEntity } from "./generator"; +import { NamedGenerativeEntity } from "./generator"; import fc from "fast-check"; @@ -39,7 +39,7 @@ export interface TraitParameters { /** * An object that encapsulates a randomly generated AstTrait. */ -export class Trait extends GenerativeEntity { +export class Trait extends NamedGenerativeEntity { /** Trait scope. */ private scope: Scope; @@ -55,9 +55,12 @@ export class Trait extends GenerativeEntity { public methodDeclarations: FunctionDecl[] = []; constructor(programScope: Scope, params: Partial = {}) { - super({ kind: "util", type: UtilType.Trait }); - this.scope = new Scope("trait", programScope); - this.name = createSample(generateAstId(this.scope)); + const scope = new Scope("trait", programScope); + super( + { kind: "util", type: UtilType.Trait }, + createSample(generateAstId(scope)), + ); + this.scope = scope; const { fieldNum = 1, @@ -91,7 +94,7 @@ export class Trait extends GenerativeEntity { (_) => { const ty = TypeGen.fromScope(this.scope).pick(); const field = new Field(this.scope, ty); - this.scope.add("field", field); + this.scope.addNamed("field", field); return field; }, ); @@ -130,7 +133,7 @@ export class Trait extends GenerativeEntity { return fc.record({ kind: fc.constant("trait"), id: fc.constant(this.idx), - name: fc.constant(this.name!), + name: fc.constant(this.name), traits: fc.constant([]), attributes: fc.constant([]), declarations: fc.tuple(...constants, ...fields, ...methods), diff --git a/fuzzer/src/scope.ts b/fuzzer/src/scope.ts index 29d78d1e1d..740369a625 100644 --- a/fuzzer/src/scope.ts +++ b/fuzzer/src/scope.ts @@ -16,6 +16,7 @@ import type { AstFunctionDecl, AstMessageDecl, } from "../../src/ast/ast"; +import type { NamedGenerativeEntity } from "./generators/generator"; export type ScopeKind = | "program" @@ -26,40 +27,50 @@ export type ScopeKind = | "receive" | "block"; -export type ScopeItemKind = - | "let" - | "parameter" - | "statement" - | "struct" - | "message" - | "constantDecl" - | "constantDef" - | "functionDecl" - | "functionDef" - | "methodDecl" - | "methodDef" - | "receive" - | "field" - | "contract" - | "trait"; +const namedScopeItemKinds = [ + "field", + "contract", + "trait", + "struct", + "message", + "constantDecl", + "constantDef", + "functionDecl", + "functionDef", + "methodDecl", + "methodDef", + "let", + "parameter", +] as const; +export type NamedScopeItemKind = (typeof namedScopeItemKinds)[number]; +function isNamedScopeItemKind(val: string): val is NamedScopeItemKind { + return namedScopeItemKinds.find((tpe) => tpe === val) ? true : false; +} + +const unnamedScopeItemKinds = ["statement", "receive"] as const; +export type UnnamedScopeItemKind = (typeof unnamedScopeItemKinds)[number]; + +export type ScopeItemKind = NamedScopeItemKind | UnnamedScopeItemKind; /** Maps each ScopeItemKind to its respective GenerativeEntity specialization. */ +type NamedGenerativeEntityMap = { + let: NamedGenerativeEntity; + parameter: NamedGenerativeEntity; + struct: NamedGenerativeEntity; + message: NamedGenerativeEntity; + constantDecl: NamedGenerativeEntity; + constantDef: NamedGenerativeEntity; + functionDecl: NamedGenerativeEntity; + functionDef: NamedGenerativeEntity; + methodDecl: NamedGenerativeEntity; + methodDef: NamedGenerativeEntity; + field: NamedGenerativeEntity; + contract: NamedGenerativeEntity; + trait: NamedGenerativeEntity; +}; type GenerativeEntityMap = { - let: GenerativeEntity; - parameter: GenerativeEntity; statement: GenerativeEntity; - struct: GenerativeEntity; - message: GenerativeEntity; - constantDecl: GenerativeEntity; - constantDef: GenerativeEntity; - functionDecl: GenerativeEntity; - functionDef: GenerativeEntity; - methodDecl: GenerativeEntity; - methodDef: GenerativeEntity; receive: GenerativeEntity; - field: GenerativeEntity; - contract: GenerativeEntity; - trait: GenerativeEntity; }; /** @@ -76,8 +87,16 @@ export class Scope { * Contains AST entries generated during the bottom-up AST generation. */ // eslint-disable-next-line @typescript-eslint/no-explicit-any - private map: Map>> = - new Map(); + private mapUnnamed: Map< + UnnamedScopeItemKind, + Map> + > = new Map(); + + // eslint-disable-next-line @typescript-eslint/no-explicit-any + private mapNamed: Map< + NamedScopeItemKind, + Map> + > = new Map(); constructor(kind: ScopeKind, parentScope: Scope | undefined) { this.kind = kind; @@ -119,13 +138,9 @@ export class Scope { } /** - * Put a new entity in the scope according to the Tact semantics. + * Determine the appropriate parent scope based on the kind of entity */ - public add( - kind: T, - entity: GenerativeEntityMap[T], - ): void { - // Determine the appropriate parent scope based on the kind of entity + private getTargetScopeToAdd(kind: ScopeItemKind) { let targetScope: Scope | undefined; switch (kind) { case "let": @@ -160,26 +175,61 @@ export class Scope { if (targetScope === undefined) { throw new Error(`Cannot add "${kind}" to the "${this.kind}" scope`); } + return targetScope; + } - if (targetScope.map.has(kind)) { - targetScope.map.get(kind)!.set(entity.idx, entity); + /** + * Put a new entity in the scope according to the Tact semantics. + */ + public addUnnamed( + kind: T, + entity: GenerativeEntityMap[T], + ): void { + const targetScope = this.getTargetScopeToAdd(kind); + if (targetScope.mapUnnamed.has(kind)) { + targetScope.mapUnnamed.get(kind)!.set(entity.idx, entity); } else { - targetScope.map + targetScope.mapUnnamed .set(kind, new Map()) .get(kind)! .set(entity.idx, entity); } } - public get( + /** + * Put a new entity in the scope according to the Tact semantics. + */ + public addNamed( kind: T, - id: IDIdx, - ): GenerativeEntityMap[T] | undefined { - return this.map.get(kind)?.get(id); + entity: NamedGenerativeEntityMap[T], + ): void { + const targetScope = this.getTargetScopeToAdd(kind); + + if (isNamedScopeItemKind(kind)) { + if (targetScope.mapNamed.has(kind)) { + targetScope.mapNamed.get(kind)!.set(entity.idx, entity); + } else { + targetScope.mapNamed + .set(kind, new Map()) + .get(kind)! + .set(entity.idx, entity); + } + } } - public getAll(kind: T): GenerativeEntityMap[T][] { - const kindMap = this.map.get(kind); + public getAllUnnamed( + kind: T, + ): GenerativeEntityMap[T][] { + const kindMap = this.mapUnnamed.get(kind); + if (kindMap) { + return Array.from(kindMap.values()); + } + return []; + } + public getAllNamed( + kind: T, + ): NamedGenerativeEntityMap[T][] { + const kindMap = this.mapNamed.get(kind); if (kindMap) { return Array.from(kindMap.values()); } @@ -189,18 +239,15 @@ export class Scope { /** * Collects name-type tuples of all the entries with the given type defined within this scope. */ - public getEntries(kind: ScopeItemKind): [string, Type][] { - const names = this.map.get(kind); + public getNamedEntries(kind: NamedScopeItemKind): [string, Type][] { + const names = this.mapNamed.get(kind); if (names === undefined) { return []; } return Array.from(names) .map( ([_id, entry]) => - [entry.name?.text, entry.type] as [ - string | undefined, - Type, - ], + [entry.name.text, entry.type] as [string | undefined, Type], ) .filter( (nameType): nameType is [string, Type] => @@ -212,16 +259,20 @@ export class Scope { * Collects name-type tuples of all the entries with the given type defined within scope * and its parent scopes. */ - public getEntriesRecursive(...kinds: ScopeItemKind[]): [string, Type][] { + public getNamedEntriesRecursive( + ...kinds: NamedScopeItemKind[] + ): [string, Type][] { const recursiveHelper = ( - kinds: ScopeItemKind[], + kinds: NamedScopeItemKind[], acc: [string, Type][], scope?: Scope, ): [string, Type][] => { if (scope === undefined) { return acc; } - const entries = kinds.flatMap((kind) => scope.getEntries(kind)); + const entries = kinds.flatMap((kind) => + scope.getNamedEntries(kind), + ); if (scope.isProgramScope()) { return acc.concat(entries); } else { @@ -238,8 +289,8 @@ export class Scope { /** * Collects names of all the entries with the given type defined within this scope. */ - public getNames(kind: ScopeItemKind, ty: Type): string[] { - return this.getEntries(kind) + public getNames(kind: NamedScopeItemKind, ty: Type): string[] { + return this.getNamedEntries(kind) .filter(([_name, type]) => type === ty) .map(([name, _type]) => name); } @@ -249,7 +300,7 @@ export class Scope { * and its parent scopes. */ public getNamesRecursive( - kind: ScopeItemKind, + kind: NamedScopeItemKind, ty: Type, acc: string[] = [], ): string[] { @@ -262,13 +313,13 @@ export class Scope { ); } } - + /** * Collects all names of all entities in the scope. */ public getAllNames(): string[] { - return Array.from(this.map.values()).flatMap((m) => - Array.from(m.values()).map((entity) => entity.name?.text ?? ""), + return Array.from(this.mapNamed.values()).flatMap((m) => + Array.from(m.values()).map((entity) => entity.name.text), ); } @@ -286,13 +337,25 @@ export class Scope { */ // eslint-disable-next-line @typescript-eslint/no-explicit-any public getItems(kind: ScopeItemKind): GenerativeEntity[] { - const result = this.map.get(kind); + const result = isNamedScopeItemKind(kind) + ? this.mapNamed.get(kind) + : this.mapUnnamed.get(kind); return result === undefined ? [] : Array.from(result.values()); } /** * Returns all items of the given type defined within this scope and its parents. */ + public getItemsRecursive( + kind: NamedScopeItemKind, + // eslint-disable-next-line @typescript-eslint/no-explicit-any + acc?: GenerativeEntity[], // eslint-disable-next-line @typescript-eslint/no-explicit-any + ): NamedGenerativeEntity[]; + public getItemsRecursive( + kind: UnnamedScopeItemKind, + // eslint-disable-next-line @typescript-eslint/no-explicit-any + acc?: GenerativeEntity[], // eslint-disable-next-line @typescript-eslint/no-explicit-any + ): GenerativeEntity[]; public getItemsRecursive( kind: ScopeItemKind, // eslint-disable-next-line @typescript-eslint/no-explicit-any @@ -301,9 +364,11 @@ export class Scope { ): GenerativeEntity[] { const currentItems = this.getItems(kind); const accN = acc.concat(currentItems); - if (!this.isProgramScope() && this.parentScope) { - return this.parentScope.getItemsRecursive(kind, accN); - } else { + if (!this.isProgramScope() && this.parentScope) + return isNamedScopeItemKind(kind) + ? this.parentScope.getItemsRecursive(kind, accN) + : this.parentScope.getItemsRecursive(kind, accN); + else { return accN; } } @@ -325,7 +390,7 @@ export class Scope { entry.type.kind === "function" && getReturnType(entry.type) === returnTy ) { - acc.push([entry.name?.text!, entry.type]); + acc.push([entry.name.text, entry.type]); } return acc; }, @@ -336,11 +401,11 @@ export class Scope { /** * Checks if the given scope defines an identifier. */ - public has(kind: ScopeItemKind, name: string): boolean { + public has(kind: NamedScopeItemKind, name: string): boolean { return ( - this.map.has(kind) && - Array.from(this.map.get(kind)!).find( - ([_id, entry]) => entry.name?.text === name, + this.mapNamed.has(kind) && + Array.from(this.mapNamed.get(kind)!).find( + ([_id, entry]) => entry.name.text === name, ) !== undefined ); } @@ -348,7 +413,7 @@ export class Scope { /** * Checks if the given scope or its parents define an identifier. */ - public hasRecursive(kind: ScopeItemKind, name: string): boolean { + public hasRecursive(kind: NamedScopeItemKind, name: string): boolean { if (this.has(kind, name)) { return true; } else if (this.isProgramScope()) { diff --git a/fuzzer/src/util.ts b/fuzzer/src/util.ts index d1af83bd8d..268129fd50 100644 --- a/fuzzer/src/util.ts +++ b/fuzzer/src/util.ts @@ -6,7 +6,7 @@ import fs from "fs/promises"; import * as path from "path"; import fc from "fast-check"; -import type { Scope, ScopeItemKind } from "./scope"; +import type { NamedScopeItemKind, Scope } from "./scope"; import { GlobalContext } from "./context"; import type { Type } from "./types"; import type { AstId, AstNode } from "../../src/ast/ast"; @@ -39,7 +39,7 @@ export async function withNodeFS(f: (vfs: VirtualFileSystem) => Promise) { export function createProperty( ...args: [ ...arbitraries: { [K in keyof Ts]: fc.Arbitrary }, - predicate: (...args: Ts) => boolean | void, + predicate: (...args: Ts) => boolean | void, // eslint-disable-line @typescript-eslint/no-invalid-void-type ] ): fc.IPropertyWithHooks { const arbitraries = args.slice(0, -1) as unknown as { @@ -187,7 +187,7 @@ export function generateAstId( */ export function choose( scope: Scope, - kind: ScopeItemKind, + kind: NamedScopeItemKind, ty: Type, ): string | undefined { const availableNames = scope.getNamesRecursive(kind, ty); From 7af613571383a0b55f6f8937adf44b98bcfae62a Mon Sep 17 00:00:00 2001 From: Mell0r Date: Sun, 30 Mar 2025 19:07:26 +0300 Subject: [PATCH 12/44] refactor: various small linter and cspell fixes --- fuzzer/src/formatter.ts | 8 +- fuzzer/src/generators/constant.ts | 14 +-- fuzzer/src/generators/contract.ts | 6 +- fuzzer/src/generators/expression.ts | 182 ++++++++++++++-------------- fuzzer/src/generators/field.ts | 2 +- fuzzer/src/generators/function.ts | 20 +-- fuzzer/src/generators/program.ts | 2 +- fuzzer/src/generators/receiver.ts | 38 +++--- fuzzer/src/generators/statement.ts | 4 +- fuzzer/src/scope.ts | 7 +- fuzzer/src/stdlib.ts | 9 +- fuzzer/src/types.ts | 59 +++++---- fuzzer/src/util.ts | 3 +- 13 files changed, 182 insertions(+), 172 deletions(-) diff --git a/fuzzer/src/formatter.ts b/fuzzer/src/formatter.ts index 0620269391..16a8fb7b95 100644 --- a/fuzzer/src/formatter.ts +++ b/fuzzer/src/formatter.ts @@ -489,17 +489,17 @@ class PrettyPrinter { case "statement_try": return this.ppAstStatementTry(stmt); default: - return `Unsopported statement kind: ${stmt.kind}`; + return `Unsupported statement kind: ${stmt.kind}`; } } - ppStatementBlock(stmts: readonly AstStatement[]): string { + ppStatementBlock(statements: readonly AstStatement[]): string { this.increaseIndent(); - const stmntsFormatted = stmts + const statementsFormatted = statements .map((stmt) => this.ppAstStatement(stmt)) .join("\n"); this.decreaseIndent(); - const result = `{\n${stmntsFormatted}\n${this.indent()}}`; + const result = `{\n${statementsFormatted}\n${this.indent()}}`; return result; } diff --git a/fuzzer/src/generators/constant.ts b/fuzzer/src/generators/constant.ts index 74dcb07a5d..daff485c3d 100644 --- a/fuzzer/src/generators/constant.ts +++ b/fuzzer/src/generators/constant.ts @@ -56,10 +56,10 @@ export class ConstantDecl extends NamedGenerativeEntity { /** * Create definition for this constant destination. - * @param init An initializer evaluable in compile-time. + * @param init An initializer evaluable in compile-time. // cspell:disable-line */ public createDefinition(init: fc.Arbitrary): ConstantDef { - return new ConstantDef(this.name?.text, this.type, init); + return new ConstantDef(this.name.text, this.type, init); } } @@ -70,7 +70,7 @@ export class ConstantDecl extends NamedGenerativeEntity { export class ConstantDef extends NamedGenerativeEntity { /** * Create new constant definition from its name and type. Used to create definition from an existing declaration. - * @param init An initializer evaluable in compile-time. + * @param init An initializer evaluable in compile-time. // cspell:disable-line */ constructor( name: string, @@ -83,7 +83,7 @@ export class ConstantDef extends NamedGenerativeEntity { * Create a new constant definition generation name from scope. * @param scope Scope to generate constant name from. * @param type Constant type. - * @param init An initializer evaluable in compile-time. + * @param init An initializer evaluable in compile-time. // cspell:disable-line */ public static fromScope( scope: Scope, @@ -97,13 +97,13 @@ export class ConstantDef extends NamedGenerativeEntity { extraAttrs: AstConstantAttribute[], init?: fc.Arbitrary, ): fc.Arbitrary { - const choosenInit = init ?? this.init; + const chosenInit = init ?? this.init; return fc.record({ kind: fc.constant("constant_def"), id: fc.constant(this.idx), name: fc.constant(this.name), type: fc.constant(tyToAstType(this.type)), - initializer: choosenInit, + initializer: chosenInit, attributes: fc.constantFrom(extraAttrs), loc: fc.constant(dummySrcInfoPrintable), }); @@ -117,7 +117,7 @@ export class ConstantDef extends NamedGenerativeEntity { } /** - * Generates a constant definition with extra attributes and overriden init. + * Generates a constant definition with extra attributes and overridden init. */ public generateWithAttrs( extraAttrs: AstConstantAttribute[] = [], diff --git a/fuzzer/src/generators/contract.ts b/fuzzer/src/generators/contract.ts index 8f6e797edc..149278577f 100644 --- a/fuzzer/src/generators/contract.ts +++ b/fuzzer/src/generators/contract.ts @@ -106,9 +106,9 @@ export class Contract extends NamedGenerativeEntity { const requestedMethods = this.methodSignatures.map((signature) => new FunctionDef(this.scope, "method", signature).generate(), ); - const generatedMethods = Array.from(this.scope.getAllNamed("methodDef")).map( - (m) => m.generate(), - ); + const generatedMethods = Array.from( + this.scope.getAllNamed("methodDef"), + ).map((m) => m.generate()); const requestedReceives = Array.from({ length: this.receiveNum }).map( (_) => new Receive(this.scope).generate(), ); diff --git a/fuzzer/src/generators/expression.ts b/fuzzer/src/generators/expression.ts index e47c199986..6429a50f18 100644 --- a/fuzzer/src/generators/expression.ts +++ b/fuzzer/src/generators/expression.ts @@ -4,17 +4,17 @@ import type { AstId, AstNull, AstNumber, - AstOpBinary, + // AstOpBinary, AstFieldAccess, AstMethodCall, AstStaticCall, - AstOpUnary, + // AstOpUnary, AstSimplifiedString, AstStructFieldInitializer, AstStructInstance, AstString, } from "../../../src/ast/ast"; -import { AstNumberBase } from "../../../src/ast/ast"; +import type { AstNumberBase } from "../../../src/ast/ast"; import JSONbig from "json-bigint"; import fc from "fast-check"; @@ -297,92 +297,92 @@ export class StaticCall extends NamedGenerativeEntity { } } -export namespace OpUnary { - function generate( - args: fc.Arbitrary[], - allowedOps: readonly AstOpUnary["op"][], - ): fc.Arbitrary { - return fc.letrec((tie) => ({ - astExpression: fc.oneof( - { maxDepth: 1 }, - ...args.map((gen) => ({ arbitrary: gen, weight: 1 })), - { - arbitrary: tie("astOpUnary"), - weight: 1, - }, - ), - astOpUnary: fc.record({ - kind: fc.constant("op_unary"), - id: fc.constant(nextId()), - op: fc.constantFrom(...allowedOps), - loc: fc.constant(dummySrcInfoPrintable), - operand: tie("astExpression") as fc.Arbitrary, - }), - })).astOpUnary; - } - - // Generates numeric expressions - // num -> num - export const Num = generate([generateNumber()], ["+", "-"]); - - // Generates boolean expressions - // bool -> bool - export const Bool = generate([generateBoolean()], ["!"]); - - // TODO: Handle optionals (`!!`) -} - -export namespace OpBinary { - export function generate( - args: fc.Arbitrary[], - allowedOps: readonly AstOpBinary["op"][], - ): fc.Arbitrary { - return fc.letrec((tie) => ({ - astExpression: fc.oneof( - { maxDepth: 1 }, - ...args.map((gen) => ({ arbitrary: gen, weight: 1 })), - { - arbitrary: tie("astOpBinary"), - weight: 1, - }, - ), - astOpBinary: fc.record({ - kind: fc.constant("op_binary"), - id: fc.constant(nextId()), - op: fc.constantFrom(...allowedOps), - left: tie("astExpression") as fc.Arbitrary, - right: tie("astExpression") as fc.Arbitrary, - loc: fc.constant(dummySrcInfoPrintable), - }), - })).astOpBinary; - } - - // num -> num -> num - export const NumOps: AstOpBinary["op"][] = [ - "+", - "-", - "*", - "/", - "%", - "<<", - ">>", - "&", - "|", - ]; - export const NumGens = [generateNumber(), OpUnary.Num]; - - // bool -> bool -> bool - export const BoolOps: AstOpBinary["op"][] = ["&&", "||"]; - export const BoolGens = [ - generateBoolean(), - OpUnary.Bool, - // bool -> bool -> bool - generate([generateBoolean()], BoolOps), - // num -> num -> bool - // mkAstOpBinaryGen([ Primitive.NumberGen ], - // ["==", "!=", "&&", "||"]), - ]; -} +// export namespace OpUnary { +// function generate( +// args: fc.Arbitrary[], +// allowedOps: readonly AstOpUnary["op"][], +// ): fc.Arbitrary { +// return fc.letrec((tie) => ({ +// astExpression: fc.oneof( +// { maxDepth: 1 }, +// ...args.map((gen) => ({ arbitrary: gen, weight: 1 })), +// { +// arbitrary: tie("astOpUnary"), +// weight: 1, +// }, +// ), +// astOpUnary: fc.record({ +// kind: fc.constant("op_unary"), +// id: fc.constant(nextId()), +// op: fc.constantFrom(...allowedOps), +// loc: fc.constant(dummySrcInfoPrintable), +// operand: tie("astExpression") as fc.Arbitrary, +// }), +// })).astOpUnary; +// } + +// // Generates numeric expressions +// // num -> num +// export const Num = generate([generateNumber()], ["+", "-"]); + +// // Generates boolean expressions +// // bool -> bool +// export const Bool = generate([generateBoolean()], ["!"]); + +// // TODO: Handle optionals (`!!`) +// } + +// export namespace OpBinary { +// export function generate( +// args: fc.Arbitrary[], +// allowedOps: readonly AstOpBinary["op"][], +// ): fc.Arbitrary { +// return fc.letrec((tie) => ({ +// astExpression: fc.oneof( +// { maxDepth: 1 }, +// ...args.map((gen) => ({ arbitrary: gen, weight: 1 })), +// { +// arbitrary: tie("astOpBinary"), +// weight: 1, +// }, +// ), +// astOpBinary: fc.record({ +// kind: fc.constant("op_binary"), +// id: fc.constant(nextId()), +// op: fc.constantFrom(...allowedOps), +// left: tie("astExpression") as fc.Arbitrary, +// right: tie("astExpression") as fc.Arbitrary, +// loc: fc.constant(dummySrcInfoPrintable), +// }), +// })).astOpBinary; +// } + +// // num -> num -> num +// export const NumOps: AstOpBinary["op"][] = [ +// "+", +// "-", +// "*", +// "/", +// "%", +// "<<", +// ">>", +// "&", +// "|", +// ]; +// export const NumGens = [generateNumber(), OpUnary.Num]; + +// // bool -> bool -> bool +// export const BoolOps: AstOpBinary["op"][] = ["&&", "||"]; +// export const BoolGens = [ +// generateBoolean(), +// OpUnary.Bool, +// // bool -> bool -> bool +// generate([generateBoolean()], BoolOps), +// // num -> num -> bool +// // mkAstOpBinaryGen([ Primitive.NumberGen ], +// // ["==", "!=", "&&", "||"]), +// ]; +// } /** * Generates struct field access expressions, e.g., `myStruct.a`. @@ -534,7 +534,7 @@ export interface ExpressionParameters { generateStatements: boolean; /** - * Indicates whether the generated expression must be evaluable at compile time. + * Indicates whether the generated expression must be evaluable at compile time. // cspell:disable-line * @default false */ compileTimeEval: boolean; @@ -680,7 +680,7 @@ export class Expression extends GenerativeEntity { /** * Generates or chooses an available field and makes a "use" expression from it. - * @return Use expression of the generated field, or `undefined` if cannot create it.expre + * @return Use expression of the generated field, or `undefined` if cannot create it. */ private makeFieldUse(ty: Type): fc.Arbitrary | undefined { if ( diff --git a/fuzzer/src/generators/field.ts b/fuzzer/src/generators/field.ts index 8e39fbe044..f15b32b4be 100644 --- a/fuzzer/src/generators/field.ts +++ b/fuzzer/src/generators/field.ts @@ -12,7 +12,7 @@ import fc from "fast-check"; */ export class Field extends NamedGenerativeEntity { /** - * @param init An optional initializer evaluable in compile-time. + * @param init An optional initializer evaluable in compile-time. // cspell:disable-line * @param parentScope Scope this field belongs to. Could be a contract or program for struct fields. */ constructor( diff --git a/fuzzer/src/generators/function.ts b/fuzzer/src/generators/function.ts index ac79aca016..43572e350f 100644 --- a/fuzzer/src/generators/function.ts +++ b/fuzzer/src/generators/function.ts @@ -38,7 +38,7 @@ export const SUPPORTED_RETURN_TYS = [ StdlibType.String, ]; -function doesntHaveArguments(kind: FunctionKind, type: FunctionType): boolean { +function doesntHaveArguments(kind: FunctionKind, type: FunctionType): boolean { // cspell:disable-line if (kind === "function") { return type.signature.length === 1; } else { @@ -55,15 +55,15 @@ function generateParameters( type: FunctionType, scope: Scope, ): AstTypedParameter[] { - if (doesntHaveArguments(kind, type)) { + if (doesntHaveArguments(kind, type)) { // cspell:disable-line return []; } const slice = kind === "method" ? type.signature.slice(1, -1) : type.signature.slice(0, -1); - return slice.map((argty) => { - const param = new Parameter(scope, argty); + return slice.map((argType) => { + const param = new Parameter(scope, argType); scope.addNamed("parameter", param); return createSample(param.generate()); }); @@ -143,12 +143,12 @@ export class FunctionDef extends NamedGenerativeEntity { ? getReturnType(type) : { kind: "util", type: UtilType.Unit }; const returnStmt = new Return(this.scope, returnTy).generate(); - const generatedLetBindings = Array.from(this.scope.getAllNamed("let")).map( - (c) => c.generate(), - ); - const generatedStmts = Array.from(this.scope.getAllUnnamed("statement")).map( - (c) => c.generate(), - ); + const generatedLetBindings = Array.from( + this.scope.getAllNamed("let"), + ).map((c) => c.generate()); + const generatedStmts = Array.from( + this.scope.getAllUnnamed("statement"), + ).map((c) => c.generate()); this.body = [...generatedLetBindings, ...generatedStmts, returnStmt]; return fc.tuple(...this.body); } diff --git a/fuzzer/src/generators/program.ts b/fuzzer/src/generators/program.ts index d6041268b5..8ea984216b 100644 --- a/fuzzer/src/generators/program.ts +++ b/fuzzer/src/generators/program.ts @@ -67,7 +67,7 @@ export class Program extends NamedGenerativeEntity { this.scope = new Scope("program", undefined); // NOTE: Structures and messages must be generated prior to contracts in order - // to add their entries to scopes for futher reuse. + // to add their entries to scopes for further reuse. Array.from({ length: structsNum }).forEach((_) => { this.scope.addNamed("struct", this.makeStruct()); }); diff --git a/fuzzer/src/generators/receiver.ts b/fuzzer/src/generators/receiver.ts index 9b341ef7e5..4054d450b2 100644 --- a/fuzzer/src/generators/receiver.ts +++ b/fuzzer/src/generators/receiver.ts @@ -51,16 +51,26 @@ function generateReceiverCommentSubKind(): fc.Arbitrary { }); } -function generateRecieverKind( - kind: "internal" | "external" | "comment", +function generateInternalReceiverKind( subKind: fc.Arbitrary, ): fc.Arbitrary { return fc.record({ - kind: fc.constant(kind), + kind: fc.constant("internal"), subKind, id: fc.constant(nextId()), loc: fc.constant(dummySrcInfoPrintable), - } as any); //TODO: types are correct here, but i don't know how to explain to typescript, what T is equal to T | T + }); +} + +function generateExternalReceiverKind( + subKind: fc.Arbitrary, +): fc.Arbitrary { + return fc.record({ + kind: fc.constant("external"), + subKind, + id: fc.constant(nextId()), + loc: fc.constant(dummySrcInfoPrintable), + }); } /** @@ -91,12 +101,10 @@ export class Receive extends GenerativeEntity { ); const param = new Parameter(this.scope, ty); this.scope.addNamed("parameter", param); - const internalSimple = generateRecieverKind( - "internal", + const internalSimple = generateInternalReceiverKind( generateReceiverSimpleSubKind(param), ); - const externalSimple = generateRecieverKind( - "external", + const externalSimple = generateExternalReceiverKind( generateReceiverSimpleSubKind(param), ); return fc.oneof(internalSimple, externalSimple); @@ -120,20 +128,16 @@ export class Receive extends GenerativeEntity { }); } - const internalFallback = generateRecieverKind( - "internal", + const internalFallback = generateInternalReceiverKind( generateReceiverFallbackSubKind(), ); - const externalFallback = generateRecieverKind( - "external", + const externalFallback = generateExternalReceiverKind( generateReceiverFallbackSubKind(), ); - const internalComment = generateRecieverKind( - "internal", + const internalComment = generateInternalReceiverKind( generateReceiverCommentSubKind(), ); - const externalComment = generateRecieverKind( - "external", + const externalComment = generateExternalReceiverKind( generateReceiverCommentSubKind(), ); @@ -142,7 +146,7 @@ export class Receive extends GenerativeEntity { externalFallback, internalComment, externalComment, - ); + ); // TODO: add bounce receiver generation } private generateBody(): fc.Arbitrary { diff --git a/fuzzer/src/generators/statement.ts b/fuzzer/src/generators/statement.ts index c668b74d97..7a7182d501 100644 --- a/fuzzer/src/generators/statement.ts +++ b/fuzzer/src/generators/statement.ts @@ -477,7 +477,9 @@ export class Statement extends GenerativeEntity { /** * Collects all field map AstIds in parent scope. */ - private collectFieldMapIds(entryKinds: NamedScopeItemKind[]): AstFieldAccess[] { + private collectFieldMapIds( + entryKinds: NamedScopeItemKind[], + ): AstFieldAccess[] { return this.parentScope .getNamedEntriesRecursive(...entryKinds) .filter(([_, mapTy]: [string, Type]) => mapTy.kind === "map") diff --git a/fuzzer/src/scope.ts b/fuzzer/src/scope.ts index 740369a625..07291e64fb 100644 --- a/fuzzer/src/scope.ts +++ b/fuzzer/src/scope.ts @@ -47,6 +47,7 @@ function isNamedScopeItemKind(val: string): val is NamedScopeItemKind { return namedScopeItemKinds.find((tpe) => tpe === val) ? true : false; } +// eslint-disable-next-line @typescript-eslint/no-unused-vars const unnamedScopeItemKinds = ["statement", "receive"] as const; export type UnnamedScopeItemKind = (typeof unnamedScopeItemKinds)[number]; @@ -86,16 +87,14 @@ export class Scope { /** * Contains AST entries generated during the bottom-up AST generation. */ - // eslint-disable-next-line @typescript-eslint/no-explicit-any private mapUnnamed: Map< UnnamedScopeItemKind, - Map> + Map> // eslint-disable-line @typescript-eslint/no-explicit-any > = new Map(); - // eslint-disable-next-line @typescript-eslint/no-explicit-any private mapNamed: Map< NamedScopeItemKind, - Map> + Map> // eslint-disable-line @typescript-eslint/no-explicit-any > = new Map(); constructor(kind: ScopeKind, parentScope: Scope | undefined) { diff --git a/fuzzer/src/stdlib.ts b/fuzzer/src/stdlib.ts index 450bbb3ce7..8341daf623 100644 --- a/fuzzer/src/stdlib.ts +++ b/fuzzer/src/stdlib.ts @@ -6,7 +6,14 @@ import files from "../../src/stdlib/stdlib"; import { createVirtualFileSystem } from "../../src/vfs/createVirtualFileSystem"; import { dummySrcInfoPrintable, generateAstIdFromName } from "./util"; -const StdlibFilePath = path.join(__dirname, "..", "..", "src", "stdlib", "stdlib"); +const StdlibFilePath = path.join( + __dirname, + "..", + "..", + "src", + "stdlib", + "stdlib", +); const StdlibVFS = createVirtualFileSystem(StdlibFilePath, files); export const StdlibPath = StdlibVFS.resolve("std/stdlib.fc"); export const StdlibCode = StdlibVFS.readFile(StdlibPath).toString(); diff --git a/fuzzer/src/types.ts b/fuzzer/src/types.ts index 04e6b7af5a..3102abfaea 100644 --- a/fuzzer/src/types.ts +++ b/fuzzer/src/types.ts @@ -127,31 +127,28 @@ export const SUPPORTED_STDLIB_TYPES: StdlibType[] = [ StdlibType.Int, ]; -namespace make { - export function PrimitiveType(name: string): AstPrimitiveTypeDecl { - const kind = "primitive_type_decl"; - return { - kind, - id: nextId(), - name: generateAstIdFromName(name), - loc: dummySrcInfoPrintable, - }; - } - export function ASTTypeRef(name: string): AstTypeId { - return { - kind: "type_id", - id: nextId(), - text: name, - loc: dummySrcInfoPrintable, - }; - } - export function TypeRef(name: string): TypeRef { - return { - kind: "ref", - name, - optional: false, - }; - } +function makePrimitiveType(name: string): AstPrimitiveTypeDecl { + return { + kind: "primitive_type_decl", + id: nextId(), + name: generateAstIdFromName(name), + loc: dummySrcInfoPrintable, + }; +} +function makeASTTypeRef(name: string): AstTypeId { + return { + kind: "type_id", + id: nextId(), + text: name, + loc: dummySrcInfoPrintable, + }; +} +function makeTypeRef(name: string): TypeRef { + return { + kind: "ref", + name, + optional: false, + }; } /** @@ -161,14 +158,14 @@ const StdlibTypeCache: Map = new Map(); Object.values(StdlibType).forEach((ty) => { StdlibTypeCache.set(ty, [ - transformTy(ty, make.PrimitiveType), - transformTy(ty, make.ASTTypeRef), - transformTy(ty, make.TypeRef), + transformTy(ty, makePrimitiveType), + transformTy(ty, makeASTTypeRef), + transformTy(ty, makeTypeRef), ]); }); /** - * Creates a Tact type entry from the given tact-check type defintion. + * Creates a Tact type entry from the given tact-check type definition. */ function transformTy(ty: StdlibType, transform: (type: StdlibType) => T): T { if (!Object.values(StdlibType).includes(ty)) { @@ -267,7 +264,7 @@ export function getReturnType(ty: FunctionType): Type { */ export function getStdlibTypes(): AstTypeDecl[] { return [...Object.values(StdlibType)].map((type) => - make.PrimitiveType(type), + makePrimitiveType(type), ); } @@ -448,7 +445,7 @@ export function isThis(ty: Type): boolean { /** * An heuristic that replicates the `resolvePartialFields` logic in the compiler in order to - * detect if the message ough to be wrapped in `bounced<>`. + * detect if the message ought to be wrapped in `bounced<>`. */ export function isBouncedMessage(ty: Type): boolean { if (ty.kind !== "message") { diff --git a/fuzzer/src/util.ts b/fuzzer/src/util.ts index 268129fd50..1d654add12 100644 --- a/fuzzer/src/util.ts +++ b/fuzzer/src/util.ts @@ -47,7 +47,8 @@ export function createProperty( }; const originalPredicate = args[args.length - 1] as ( ...args: Ts - ) => boolean | void; + ) => boolean | void; // eslint-disable-line @typescript-eslint/no-invalid-void-type + // eslint-disable-next-line @typescript-eslint/no-invalid-void-type const enhancedPredicate = (...args: Ts): boolean | void => { args.forEach((arg) => { GlobalContext.printSample(arg as AstNode); From c41a314d8d4c88d01c48650297794c5f478da10e Mon Sep 17 00:00:00 2001 From: Mell0r Date: Sun, 30 Mar 2025 19:54:56 +0300 Subject: [PATCH 13/44] style: import type --- fuzzer/src/generators/expression.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/fuzzer/src/generators/expression.ts b/fuzzer/src/generators/expression.ts index f030d163aa..6fa2d9156e 100644 --- a/fuzzer/src/generators/expression.ts +++ b/fuzzer/src/generators/expression.ts @@ -14,7 +14,7 @@ import type { StructInstance as AstStructInstance, String as AstString, } from "../../../src/ast/ast"; -import { NumberBase as AstNumberBase } from "../../../src/ast/ast"; +import type { NumberBase as AstNumberBase } from "../../../src/ast/ast"; import JSONbig from "json-bigint"; import fc from "fast-check"; From 1a113747b84a1e698ba234e1fa4c3d2221555a02 Mon Sep 17 00:00:00 2001 From: Mell0r Date: Mon, 31 Mar 2025 11:03:37 +0300 Subject: [PATCH 14/44] feat: added correct wildcard formatting --- fuzzer/src/formatter.ts | 27 ++++++++++++++++----------- 1 file changed, 16 insertions(+), 11 deletions(-) diff --git a/fuzzer/src/formatter.ts b/fuzzer/src/formatter.ts index 9625fcffb7..9c17d6a1c5 100644 --- a/fuzzer/src/formatter.ts +++ b/fuzzer/src/formatter.ts @@ -36,6 +36,7 @@ import type { TraitDeclaration as AstTraitDeclaration, ModuleItem as AstModuleItem, ContractDeclaration as AstContractDeclaration, + OptionalId, } from "../../src/ast/ast"; /** @@ -102,6 +103,10 @@ class PrettyPrinter { // Expressions // + ppAstOptionalId(id: OptionalId): string { + return "text" in id ? id.text : "_"; + } + /** * Returns precedence used in unary/binary operations. * Lower number means higher precedence @@ -395,8 +400,8 @@ class PrettyPrinter { const argsFormatted = func.params .map( (arg) => - `${(arg.name as AstId).text}: ${this.ppAstType(arg.type)}`, - ) //TODO: wildcard + `${this.ppAstOptionalId(arg.name)}: ${this.ppAstType(arg.type)}`, + ) .join(", "); const attrsRaw = func.attributes.map((attr) => attr.type).join(" "); const attrsFormatted = attrsRaw ? `${attrsRaw} ` : ""; @@ -426,12 +431,12 @@ class PrettyPrinter { ppAstReceiveHeader(receive: AstReceiver): string { if (receive.selector.kind === "bounce") - return `bounced(${(receive.selector.param.name as AstId).text}: ${this.ppAstType(receive.selector.param.type)})`; //TODO: wildcard + return `bounced(${this.ppAstOptionalId(receive.selector.param.name)}: ${this.ppAstType(receive.selector.param.type)})`; const prefix = receive.selector.kind === "internal" ? "receive" : "external"; const suffix = receive.selector.subKind.kind === "simple" - ? `(${(receive.selector.subKind.param.name as AstId).text}: ${this.ppAstType(receive.selector.subKind.param.type)})` //TODO: wildcard + ? `(${this.ppAstOptionalId(receive.selector.subKind.param.name)}: ${this.ppAstType(receive.selector.subKind.param.type)})` : receive.selector.subKind.kind === "fallback" ? "()" : `("${receive.selector.subKind.comment.value}")`; @@ -442,8 +447,8 @@ class PrettyPrinter { const argsFormatted = func.params .map( (arg) => - `${(arg.name as AstId).text}: ${this.ppAstType(arg.type)}`, - ) //TODO: wildcard + `${this.ppAstOptionalId(arg.name)}: ${this.ppAstType(arg.type)}`, + ) .join(", "); const returnType = func.return ? `: ${this.ppAstType(func.return)}` @@ -457,8 +462,8 @@ class PrettyPrinter { const argsFormatted = initFunc.params .map( (arg) => - `${(arg.name as AstId).text}: ${this.ppAstType(arg.type)}`, - ) //TODO: wildcard + `${this.ppAstOptionalId(arg.name)}: ${this.ppAstType(arg.type)}`, + ) .join(", "); this.increaseIndent(); @@ -519,7 +524,7 @@ class PrettyPrinter { statement.type === undefined ? "" : `: ${this.ppAstType(statement.type)}`; - return `${this.indent()}let ${(statement.name as AstId).text}${tyAnnotation} = ${expression};`; //TODO: wildcard + return `${this.indent()}let ${this.ppAstOptionalId(statement.name)}${tyAnnotation} = ${expression};`; } ppAstStatementReturn(statement: AstStatementReturn): string { @@ -571,7 +576,7 @@ class PrettyPrinter { } ppAstStatementForEach(statement: AstStatementForEach): string { - const header = `foreach (${(statement.keyName as AstId).text}, ${(statement.valueName as AstId).text} in ${this.ppAstExpression(statement.map)})`; //TODO: wildcard + const header = `foreach (${this.ppAstOptionalId(statement.keyName)}, ${(statement.valueName as AstId).text} in ${this.ppAstExpression(statement.map)})`; const body = this.ppStatementBlock(statement.statements); return `${this.indent()}${header} ${body}`; } @@ -580,7 +585,7 @@ class PrettyPrinter { const tryBody = this.ppStatementBlock(statement.statements); const tryPrefix = `${this.indent()}try ${tryBody}`; const catchSuffix = statement.catchBlock - ? ` catch (${(statement.catchBlock.catchName as AstId).text}) ${this.ppStatementBlock(statement.catchBlock.catchStatements)}` //TODO: wildcard + ? ` catch (${this.ppAstOptionalId(statement.catchBlock.catchName)}) ${this.ppStatementBlock(statement.catchBlock.catchStatements)}` : ""; return tryPrefix + catchSuffix; } From a37ca2c99d1cfca513348d3efda98580789cfbf0 Mon Sep 17 00:00:00 2001 From: Mell0r Date: Mon, 31 Mar 2025 11:27:18 +0300 Subject: [PATCH 15/44] refactor: adressed couple of todos and formatted files --- fuzzer/src/generators/expression.ts | 5 +++-- fuzzer/src/generators/function.ts | 6 ++---- fuzzer/src/generators/program.ts | 2 -- fuzzer/src/generators/trait.ts | 5 ++++- fuzzer/test/compilation.spec.ts | 5 ++++- 5 files changed, 13 insertions(+), 10 deletions(-) diff --git a/fuzzer/src/generators/expression.ts b/fuzzer/src/generators/expression.ts index 6fa2d9156e..b1955f6d0c 100644 --- a/fuzzer/src/generators/expression.ts +++ b/fuzzer/src/generators/expression.ts @@ -13,6 +13,7 @@ import type { StructFieldInitializer as AstStructFieldInitializer, StructInstance as AstStructInstance, String as AstString, + // UnaryOperation, } from "../../../src/ast/ast"; import type { NumberBase as AstNumberBase } from "../../../src/ast/ast"; import JSONbig from "json-bigint"; @@ -300,7 +301,7 @@ export class StaticCall extends NamedGenerativeEntity { // export namespace OpUnary { // function generate( // args: fc.Arbitrary[], -// allowedOps: readonly AstOpUnary["op"][], +// allowedOps: readonly UnaryOperation[], // ): fc.Arbitrary { // return fc.letrec((tie) => ({ // astExpression: fc.oneof( @@ -383,7 +384,7 @@ export class StaticCall extends NamedGenerativeEntity { // // ["==", "!=", "&&", "||"]), // ]; // } -// TODO: figure out what does this code does and why it is unused +// TODO: This part has to be rewritten and used in generation. /** * Generates struct field access expressions, e.g., `myStruct.a`. diff --git a/fuzzer/src/generators/function.ts b/fuzzer/src/generators/function.ts index 58ea6bd60f..0a90e243cb 100644 --- a/fuzzer/src/generators/function.ts +++ b/fuzzer/src/generators/function.ts @@ -38,8 +38,7 @@ export const SUPPORTED_RETURN_TYS = [ StdlibType.String, ]; -function doesntHaveArguments(kind: FunctionKind, type: FunctionType): boolean { - // cspell:disable-line +function notHaveArguments(kind: FunctionKind, type: FunctionType): boolean { if (kind === "function") { return type.signature.length === 1; } else { @@ -56,8 +55,7 @@ function generateParameters( type: FunctionType, scope: Scope, ): AstTypedParameter[] { - if (doesntHaveArguments(kind, type)) { - // cspell:disable-line + if (notHaveArguments(kind, type)) { return []; } const slice = diff --git a/fuzzer/src/generators/program.ts b/fuzzer/src/generators/program.ts index e50dfeb9c2..e62daac62d 100644 --- a/fuzzer/src/generators/program.ts +++ b/fuzzer/src/generators/program.ts @@ -156,7 +156,6 @@ export class Program extends NamedGenerativeEntity { * Creates a structure in the program scope. */ private makeStruct(): Struct { - // TODO: What if the struct-instance/field pair is the same as second-contract-instance/field pair? return new Struct( this.scope, createSample(TypeGen.fromScope(this.scope).generateStruct(false)), @@ -167,7 +166,6 @@ export class Program extends NamedGenerativeEntity { * Creates a message in the program scope. */ private makeMessage(): Message { - // TODO: What if the struct-instance/field pair is the same as second-contract-instance/field pair? return new Message( this.scope, createSample(TypeGen.fromScope(this.scope).generateStruct(true)), diff --git a/fuzzer/src/generators/trait.ts b/fuzzer/src/generators/trait.ts index fcc44fd78d..39024aa6e9 100644 --- a/fuzzer/src/generators/trait.ts +++ b/fuzzer/src/generators/trait.ts @@ -1,4 +1,7 @@ -import type { Trait as AstTrait, Expression as AstExpression } from "../../../src/ast/ast"; +import type { + Trait as AstTrait, + Expression as AstExpression, +} from "../../../src/ast/ast"; import { createSample, dummySrcInfoPrintable, diff --git a/fuzzer/test/compilation.spec.ts b/fuzzer/test/compilation.spec.ts index fbe0af427f..74b03c2f80 100644 --- a/fuzzer/test/compilation.spec.ts +++ b/fuzzer/test/compilation.spec.ts @@ -1,6 +1,9 @@ import { funcCompile } from "../../src/func/funcCompile"; import { posixNormalize } from "../../src/utils/filePath"; -import type { Module as AstModule, Contract as AstContract } from "../../src/ast/ast"; +import type { + Module as AstModule, + Contract as AstContract, +} from "../../src/ast/ast"; import { writeFileSync } from "fs"; import * as path from "path"; import fc from "fast-check"; From 8e363526731330bb17d40c9e2d7426b57e3c997f Mon Sep 17 00:00:00 2001 From: Mell0r Date: Mon, 31 Mar 2025 15:15:37 +0300 Subject: [PATCH 16/44] style: done suggested change to prettifying imports from ast --- fuzzer/src/formatter.ts | 126 +++++++++--------------- fuzzer/src/generators/constant.ts | 51 +++++----- fuzzer/src/generators/contract.ts | 21 ++-- fuzzer/src/generators/expression.ts | 147 +++++++++++++--------------- fuzzer/src/generators/field.ts | 18 ++-- fuzzer/src/generators/function.ts | 44 ++++----- fuzzer/src/generators/generator.ts | 6 +- fuzzer/src/generators/parameter.ts | 10 +- fuzzer/src/generators/program.ts | 10 +- fuzzer/src/generators/receiver.ts | 50 ++++------ fuzzer/src/generators/statement.ts | 144 ++++++++++++--------------- fuzzer/src/generators/struct.ts | 21 ++-- fuzzer/src/generators/trait.ts | 15 ++- fuzzer/src/scope.ts | 45 +++------ fuzzer/src/stdlib.ts | 4 +- fuzzer/src/types.ts | 30 +++--- fuzzer/src/util.ts | 14 +-- fuzzer/test/compilation.spec.ts | 9 +- fuzzer/test/testUtils.ts | 4 +- 19 files changed, 322 insertions(+), 447 deletions(-) diff --git a/fuzzer/src/formatter.ts b/fuzzer/src/formatter.ts index 9c17d6a1c5..4b185edcb0 100644 --- a/fuzzer/src/formatter.ts +++ b/fuzzer/src/formatter.ts @@ -1,43 +1,4 @@ -import type { - Id as AstId, - ConstantDecl as AstConstantDecl, - ConstantDef as AstConstantDef, - Import as AstImport, - NativeFunctionDecl as AstNativeFunctionDecl, - Module as AstModule, - BouncedMessageType as AstBouncedMessageType, - MapType as AstMapType, - Receiver as AstReceiver, - ContractInit as AstContractInit, - StatementRepeat as AstStatementRepeat, - StatementUntil as AstStatementUntil, - StatementWhile as AstStatementWhile, - StatementForEach as AstStatementForEach, - StatementTry as AstStatementTry, - StructFieldInitializer as AstStructFieldInitializer, - StatementCondition as AstStatementCondition, - StatementAugmentedAssign as AstStatementAugmentedAssign, - StatementAssign as AstStatementAssign, - StatementExpression as AstStatementExpression, - StatementReturn as AstStatementReturn, - StatementLet as AstStatementLet, - FunctionDef as AstFunctionDef, - FunctionDecl as AstFunctionDecl, - Type as AstType, - Statement as AstStatement, - Expression as AstExpression, - FieldDecl as AstFieldDecl, - PrimitiveTypeDecl as AstPrimitiveTypeDecl, - StructDecl as AstStructDecl, - Contract as AstContract, - Trait as AstTrait, - MessageDecl as AstMessageDecl, - AstNode, - TraitDeclaration as AstTraitDeclaration, - ModuleItem as AstModuleItem, - ContractDeclaration as AstContractDeclaration, - OptionalId, -} from "../../src/ast/ast"; +import type * as Ast from "../../src/ast/ast"; /** * PrettyPrinter class provides methods to format and indent Tact code. @@ -64,7 +25,7 @@ class PrettyPrinter { return " ".repeat(this.indentLevel * this.indentSpaces); } - ppAstPrimitive(primitive: AstPrimitiveTypeDecl): string { + ppAstPrimitive(primitive: Ast.PrimitiveTypeDecl): string { return `${this.indent()}primitive ${primitive.name.text};`; } @@ -72,7 +33,7 @@ class PrettyPrinter { // Types // - ppAstType(typeRef: AstType): string { + ppAstType(typeRef: Ast.Type): string { switch (typeRef.kind) { case "type_id": return typeRef.text; @@ -85,7 +46,7 @@ class PrettyPrinter { } } - ppAstTypeRefMap(typeRef: AstMapType): string { + ppAstTypeRefMap(typeRef: Ast.MapType): string { const keyAlias = typeRef.keyStorageType ? ` as ${typeRef.keyStorageType.text}` : ""; @@ -95,7 +56,7 @@ class PrettyPrinter { return `map<${typeRef.keyType.text}${keyAlias}, ${typeRef.valueType.text}${valueAlias}>`; } - ppAstBouncedMessageType(type: AstBouncedMessageType): string { + ppAstBouncedMessageType(type: Ast.BouncedMessageType): string { return `bounced<${type.messageType.text}>`; } @@ -103,7 +64,7 @@ class PrettyPrinter { // Expressions // - ppAstOptionalId(id: OptionalId): string { + ppAstOptionalId(id: Ast.OptionalId): string { return "text" in id ? id.text : "_"; } @@ -154,7 +115,10 @@ class PrettyPrinter { } } - ppAstExpression(expr: AstExpression, parentPrecedence: number = 0): string { + ppAstExpression( + expr: Ast.Expression, + parentPrecedence: number = 0, + ): string { let result: string; let currentPrecedence = this.getPrecedence(expr.kind); @@ -217,7 +181,7 @@ class PrettyPrinter { return result; } - ppAstStructFieldInitializer(param: AstStructFieldInitializer): string { + ppAstStructFieldInitializer(param: Ast.StructFieldInitializer): string { return `${param.field.text}: ${this.ppAstExpression(param.initializer)}`; } @@ -225,7 +189,7 @@ class PrettyPrinter { // Program // - ppAstProgram(program: AstModule): string { + ppAstProgram(program: Ast.Module): string { const entriesFormatted = program.items .map((entry, index, array) => { const formattedEntry = this.ppProgramItem(entry); @@ -242,7 +206,7 @@ class PrettyPrinter { return entriesFormatted.trim(); } - ppProgramItem(item: AstModuleItem): string { + ppProgramItem(item: Ast.ModuleItem): string { switch (item.kind) { case "struct_decl": case "message_decl": @@ -264,11 +228,11 @@ class PrettyPrinter { } } - ppAstProgramImport(importItem: AstImport): string { + ppAstProgramImport(importItem: Ast.Import): string { return `${this.indent()}import "${importItem.importPath.path.segments.join()}";`; } - ppAstStruct(struct: AstStructDecl | AstMessageDecl): string { + ppAstStruct(struct: Ast.StructDecl | Ast.MessageDecl): string { const typePrefix = struct.kind === "message_decl" ? "message" : "struct"; const prefixFormatted = @@ -283,7 +247,7 @@ class PrettyPrinter { return `${this.indent()}${typePrefix} ${prefixFormatted}${struct.name.text} {\n${fieldsFormatted}\n}`; } - ppAstTrait(trait: AstTrait): string { + ppAstTrait(trait: Ast.Trait): string { const traitsFormatted = trait.traits.map((t) => t.text).join(", "); const attrsRaw = trait.attributes .map((attr) => `@${attr.type}("${attr.name.value}")`) @@ -313,7 +277,7 @@ class PrettyPrinter { return `${this.indent()}${attrsFormatted}${header} {\n${bodyFormatted}${this.indent()}}`; } - ppTraitBody(item: AstTraitDeclaration): string { + ppTraitBody(item: Ast.TraitDeclaration): string { switch (item.kind) { case "field_decl": return this.ppAstField(item); @@ -330,7 +294,7 @@ class PrettyPrinter { } } - ppAstField(field: AstFieldDecl): string { + ppAstField(field: Ast.FieldDecl): string { const typeFormatted = this.ppAstType(field.type); const initializer = field.initializer ? ` = ${this.ppAstExpression(field.initializer)}` @@ -339,7 +303,7 @@ class PrettyPrinter { return `${this.indent()}${field.name.text}: ${typeFormatted}${asAlias}${initializer};`; } - ppAstConstant(constant: AstConstantDecl | AstConstantDef): string { + ppAstConstant(constant: Ast.ConstantDecl | Ast.ConstantDef): string { const valueFormatted = constant.kind === "constant_def" ? ` = ${this.ppAstExpression(constant.initializer)}` @@ -349,7 +313,7 @@ class PrettyPrinter { return `${this.indent()}${attrsFormatted}const ${constant.name.text}: ${this.ppAstType(constant.type)}${valueFormatted};`; } - ppAstContract(contract: AstContract): string { + ppAstContract(contract: Ast.Contract): string { const traitsFormatted = contract.traits .map((trait) => trait.text) .join(", "); @@ -379,7 +343,7 @@ class PrettyPrinter { return `${this.indent()}${attrsFormatted}${header} {\n${bodyFormatted}${this.indent()}}`; } - ppContractBody(declaration: AstContractDeclaration): string { + ppContractBody(declaration: Ast.ContractDeclaration): string { switch (declaration.kind) { case "field_decl": return this.ppAstField(declaration); @@ -396,7 +360,7 @@ class PrettyPrinter { } } - public ppAstFunction(func: AstFunctionDecl | AstFunctionDef): string { + public ppAstFunction(func: Ast.FunctionDecl | Ast.FunctionDef): string { const argsFormatted = func.params .map( (arg) => @@ -423,13 +387,13 @@ class PrettyPrinter { return `${this.indent()}${attrsFormatted}fun ${func.name.text}(${argsFormatted})${returnType}${body}`; } - ppAstReceive(receive: AstReceiver): string { + ppAstReceive(receive: Ast.Receiver): string { const header = this.ppAstReceiveHeader(receive); const stmtsFormatted = this.ppStatementBlock(receive.statements); return `${this.indent()}${header} ${stmtsFormatted}`; } - ppAstReceiveHeader(receive: AstReceiver): string { + ppAstReceiveHeader(receive: Ast.Receiver): string { if (receive.selector.kind === "bounce") return `bounced(${this.ppAstOptionalId(receive.selector.param.name)}: ${this.ppAstType(receive.selector.param.type)})`; const prefix = @@ -443,7 +407,7 @@ class PrettyPrinter { return prefix + suffix; } - ppAstNativeFunction(func: AstNativeFunctionDecl): string { + ppAstNativeFunction(func: Ast.NativeFunctionDecl): string { const argsFormatted = func.params .map( (arg) => @@ -458,7 +422,7 @@ class PrettyPrinter { return `${this.indent()}@name(${func.nativeName.text})\n${this.indent()}${attrs}native ${func.name.text}(${argsFormatted})${returnType};`; } - ppAstInitFunction(initFunc: AstContractInit): string { + ppAstInitFunction(initFunc: Ast.ContractInit): string { const argsFormatted = initFunc.params .map( (arg) => @@ -479,7 +443,7 @@ class PrettyPrinter { // Statements // - ppAstStatement(stmt: AstStatement): string { + ppAstStatement(stmt: Ast.Statement): string { switch (stmt.kind) { case "statement_let": return this.ppAstStatementLet(stmt); @@ -508,7 +472,7 @@ class PrettyPrinter { } } - ppStatementBlock(statements: readonly AstStatement[]): string { + ppStatementBlock(statements: readonly Ast.Statement[]): string { this.increaseIndent(); const statementsFormatted = statements .map((stmt) => this.ppAstStatement(stmt)) @@ -518,7 +482,7 @@ class PrettyPrinter { return result; } - ppAstStatementLet(statement: AstStatementLet): string { + ppAstStatementLet(statement: Ast.StatementLet): string { const expression = this.ppAstExpression(statement.expression); const tyAnnotation = statement.type === undefined @@ -527,28 +491,28 @@ class PrettyPrinter { return `${this.indent()}let ${this.ppAstOptionalId(statement.name)}${tyAnnotation} = ${expression};`; } - ppAstStatementReturn(statement: AstStatementReturn): string { + ppAstStatementReturn(statement: Ast.StatementReturn): string { const expression = statement.expression ? this.ppAstExpression(statement.expression) : ""; return `${this.indent()}return ${expression};`; } - ppAstStatementExpression(statement: AstStatementExpression): string { + ppAstStatementExpression(statement: Ast.StatementExpression): string { return `${this.indent()}${this.ppAstExpression(statement.expression)};`; } - ppAstStatementAssign(statement: AstStatementAssign): string { + ppAstStatementAssign(statement: Ast.StatementAssign): string { return `${this.indent()}${this.ppAstExpression(statement.path)} = ${this.ppAstExpression(statement.expression)};`; } ppAstStatementAugmentedAssign( - statement: AstStatementAugmentedAssign, + statement: Ast.StatementAugmentedAssign, ): string { return `${this.indent()}${this.ppAstExpression(statement.path)} ${statement.op}= ${this.ppAstExpression(statement.expression)};`; } - ppAstCondition(statement: AstStatementCondition): string { + ppAstCondition(statement: Ast.StatementCondition): string { const condition = this.ppAstExpression(statement.condition); const trueBranch = this.ppStatementBlock(statement.trueStatements); const falseBranch = statement.falseStatements @@ -557,31 +521,31 @@ class PrettyPrinter { return `${this.indent()}if (${condition}) ${trueBranch}${falseBranch}`; } - ppAstStatementWhile(statement: AstStatementWhile): string { + ppAstStatementWhile(statement: Ast.StatementWhile): string { const condition = this.ppAstExpression(statement.condition); const stmts = this.ppStatementBlock(statement.statements); return `${this.indent()}while (${condition}) ${stmts}`; } - ppAstStatementRepeat(statement: AstStatementRepeat): string { + ppAstStatementRepeat(statement: Ast.StatementRepeat): string { const condition = this.ppAstExpression(statement.iterations); const stmts = this.ppStatementBlock(statement.statements); return `${this.indent()}repeat (${condition}) ${stmts}`; } - ppAstStatementUntil(statement: AstStatementUntil): string { + ppAstStatementUntil(statement: Ast.StatementUntil): string { const condition = this.ppAstExpression(statement.condition); const stmts = this.ppStatementBlock(statement.statements); return `${this.indent()}do ${stmts} until (${condition});`; } - ppAstStatementForEach(statement: AstStatementForEach): string { - const header = `foreach (${this.ppAstOptionalId(statement.keyName)}, ${(statement.valueName as AstId).text} in ${this.ppAstExpression(statement.map)})`; + ppAstStatementForEach(statement: Ast.StatementForEach): string { + const header = `foreach (${this.ppAstOptionalId(statement.keyName)}, ${(statement.valueName as Ast.Id).text} in ${this.ppAstExpression(statement.map)})`; const body = this.ppStatementBlock(statement.statements); return `${this.indent()}${header} ${body}`; } - ppAstStatementTry(statement: AstStatementTry): string { + ppAstStatementTry(statement: Ast.StatementTry): string { const tryBody = this.ppStatementBlock(statement.statements); const tryPrefix = `${this.indent()}try ${tryBody}`; const catchSuffix = statement.catchBlock @@ -592,12 +556,12 @@ class PrettyPrinter { } /** - * Formats an Ast node into a pretty-printed string representation. - * @param input The Ast node to format. - * @returns A string that represents the formatted Ast node. + * Formats an Ast. node into a pretty-printed string representation. + * @param input The Ast. node to format. + * @returns A string that represents the formatted Ast. node. */ // eslint-disable-next-line @typescript-eslint/no-explicit-any -export function formatAst(input: AstNode): string { +export function formatAst(input: Ast.AstNode): string { const pp = new PrettyPrinter(); switch (input.kind) { case "module": @@ -630,6 +594,6 @@ export function formatAst(input: AstNode): string { case "trait": return pp.ppAstTrait(input); default: - throw new Error(`Unsupported Ast type: ${input.kind}`); + throw new Error(`Unsupported Ast. type: ${input.kind}`); } } diff --git a/fuzzer/src/generators/constant.ts b/fuzzer/src/generators/constant.ts index eb6317ad49..15c5e07607 100644 --- a/fuzzer/src/generators/constant.ts +++ b/fuzzer/src/generators/constant.ts @@ -1,9 +1,4 @@ -import type { - ConstantDecl as AstConstantDecl, - ConstantDef as AstConstantDef, - ConstantAttribute as AstConstantAttribute, - Expression as AstExpression, -} from "../../../src/ast/ast"; +import type * as Ast from "../../../src/ast/ast"; import { generateAstIdFromName, createSample, @@ -19,25 +14,25 @@ import { NamedGenerativeEntity } from "./generator"; import fc from "fast-check"; /** - * An object that encapsulates a generated AstConstantDecl. + * An object that encapsulates a generated Ast.ConstantDecl. */ -export class ConstantDecl extends NamedGenerativeEntity { +export class ConstantDecl extends NamedGenerativeEntity { constructor(scope: Scope, type: Type) { super(type, createSample(generateAstId(scope))); } private getAttributes( - extraAttrs: AstConstantAttribute[], - ): AstConstantAttribute[] { - const attrs: AstConstantAttribute[] = extraAttrs; + extraAttrs: Ast.ConstantAttribute[], + ): Ast.ConstantAttribute[] { + const attrs: Ast.ConstantAttribute[] = extraAttrs; attrs.push({ type: "abstract", loc: dummySrcInfoPrintable }); return attrs; } private generateImpl( - extraAttrs: AstConstantAttribute[], - ): fc.Arbitrary { - return fc.record({ + extraAttrs: Ast.ConstantAttribute[], + ): fc.Arbitrary { + return fc.record({ kind: fc.constant("constant_decl"), id: fc.constant(this.idx), name: fc.constant(this.name), @@ -50,7 +45,7 @@ export class ConstantDecl extends NamedGenerativeEntity { /** * Generates a constant declaration without extra attributes. */ - public generate(): fc.Arbitrary { + public generate(): fc.Arbitrary { return this.generateImpl([]); } @@ -58,16 +53,16 @@ export class ConstantDecl extends NamedGenerativeEntity { * Create definition for this constant destination. * @param init An initializer evaluable in compile-time. // cspell:disable-line */ - public createDefinition(init: fc.Arbitrary): ConstantDef { + public createDefinition(init: fc.Arbitrary): ConstantDef { return new ConstantDef(this.name.text, this.type, init); } } /** - * An object that encapsulates a generated AstConstantDef. + * An object that encapsulates a generated Ast.ConstantDef. * @parentScope Scope this constant belongs to. */ -export class ConstantDef extends NamedGenerativeEntity { +export class ConstantDef extends NamedGenerativeEntity { /** * Create new constant definition from its name and type. Used to create definition from an existing declaration. * @param init An initializer evaluable in compile-time. // cspell:disable-line @@ -75,7 +70,7 @@ export class ConstantDef extends NamedGenerativeEntity { constructor( name: string, type: Type, - private init: fc.Arbitrary, + private init: fc.Arbitrary, ) { super(type, generateAstIdFromName(name)); } @@ -88,17 +83,17 @@ export class ConstantDef extends NamedGenerativeEntity { public static fromScope( scope: Scope, type: Type, - init: fc.Arbitrary, + init: fc.Arbitrary, ): ConstantDef { return new ConstantDef(createSample(generateName(scope)), type, init); } private generateImpl( - extraAttrs: AstConstantAttribute[], - init?: fc.Arbitrary, - ): fc.Arbitrary { + extraAttrs: Ast.ConstantAttribute[], + init?: fc.Arbitrary, + ): fc.Arbitrary { const chosenInit = init ?? this.init; - return fc.record({ + return fc.record({ kind: fc.constant("constant_def"), id: fc.constant(this.idx), name: fc.constant(this.name), @@ -112,7 +107,7 @@ export class ConstantDef extends NamedGenerativeEntity { /** * Generates a constant definition without extra attributes. */ - public generate(): fc.Arbitrary { + public generate(): fc.Arbitrary { return this.generateImpl([]); } @@ -120,9 +115,9 @@ export class ConstantDef extends NamedGenerativeEntity { * Generates a constant definition with extra attributes and overridden init. */ public generateWithAttrs( - extraAttrs: AstConstantAttribute[] = [], - init?: fc.Arbitrary, - ): fc.Arbitrary { + extraAttrs: Ast.ConstantAttribute[] = [], + init?: fc.Arbitrary, + ): fc.Arbitrary { return this.generateImpl(extraAttrs, init); } } diff --git a/fuzzer/src/generators/contract.ts b/fuzzer/src/generators/contract.ts index 473a9d4004..b0b0ab06f1 100644 --- a/fuzzer/src/generators/contract.ts +++ b/fuzzer/src/generators/contract.ts @@ -1,9 +1,4 @@ -import type { - Contract as AstContract, - ConstantDef as AstConstantDef, - FunctionDef as AstFunctionDef, - FieldDecl as AstFieldDecl, -} from "../../../src/ast/ast"; +import type * as Ast from "../../../src/ast/ast"; import { createSample, dummySrcInfoPrintable, generateAstId } from "../util"; import { FunctionDef } from "./function"; import type { Trait } from "./trait"; @@ -26,10 +21,10 @@ export interface ContractParameters { } /** - * An object that encapsulates a randomly generated AstContract including extra information + * An object that encapsulates a randomly generated Ast.Contract including extra information * about its entries and their scopes. */ -export class Contract extends NamedGenerativeEntity { +export class Contract extends NamedGenerativeEntity { /** Scope used within the generated contract. */ private scope: Scope; @@ -56,11 +51,11 @@ export class Contract extends NamedGenerativeEntity { this.receiveNum = receiveNum; } - public generate(): fc.Arbitrary { + public generate(): fc.Arbitrary { // Implemented declarations from the trait - let traitFields: fc.Arbitrary[] = []; - let traitConstants: fc.Arbitrary[] = []; - let traitMethods: fc.Arbitrary[] = []; + let traitFields: fc.Arbitrary[] = []; + let traitConstants: fc.Arbitrary[] = []; + let traitMethods: fc.Arbitrary[] = []; if (this.trait !== undefined) { traitFields = this.trait.fieldDeclarations.map(({ type, name }) => { const init = new Expression(this.scope, type, { @@ -118,7 +113,7 @@ export class Contract extends NamedGenerativeEntity { const generatedFields = Array.from(this.scope.getAllNamed("field")).map( (f) => f.generate(), ); - return fc.record({ + return fc.record({ kind: fc.constant("contract"), id: fc.constant(this.idx), name: fc.constant(this.name), diff --git a/fuzzer/src/generators/expression.ts b/fuzzer/src/generators/expression.ts index b1955f6d0c..2c5fc5f99f 100644 --- a/fuzzer/src/generators/expression.ts +++ b/fuzzer/src/generators/expression.ts @@ -1,21 +1,4 @@ -import type { - Boolean as AstBoolean, - Expression as AstExpression, - Id as AstId, - Null as AstNull, - Number as AstNumber, - // OpBinary as AstOpBinary, - FieldAccess as AstFieldAccess, - MethodCall as AstMethodCall, - StaticCall as AstStaticCall, - // OpUnary as AstOpUnary, - SimplifiedString as AstSimplifiedString, - StructFieldInitializer as AstStructFieldInitializer, - StructInstance as AstStructInstance, - String as AstString, - // UnaryOperation, -} from "../../../src/ast/ast"; -import type { NumberBase as AstNumberBase } from "../../../src/ast/ast"; +import type * as Ast from "../../../src/ast/ast"; import JSONbig from "json-bigint"; import fc from "fast-check"; @@ -49,12 +32,12 @@ import type { Scope } from "../scope"; import { FunctionDef } from "./function"; export function generateNumber( - base?: AstNumberBase, + base?: Ast.NumberBase, constValue?: bigint, -): fc.Arbitrary { +): fc.Arbitrary { const value = constValue === undefined ? fc.bigInt() : fc.constantFrom(constValue); - return fc.record({ + return fc.record({ kind: fc.constant("number"), id: fc.constant(nextId()), value, @@ -65,10 +48,10 @@ export function generateNumber( export function generateBoolean( constValue?: boolean, -): fc.Arbitrary { +): fc.Arbitrary { const value = constValue === undefined ? fc.boolean() : fc.constantFrom(constValue); - return fc.record({ + return fc.record({ kind: fc.constant("boolean"), id: fc.constant(nextId()), value, @@ -90,8 +73,8 @@ function generateStringValue( export function generateSimplifiedString( nonEmpty: boolean = false, constValue?: string, -): fc.Arbitrary { - return fc.record({ +): fc.Arbitrary { + return fc.record({ kind: fc.constant("simplified_string"), id: fc.constant(nextId()), value: generateStringValue(nonEmpty, constValue), @@ -102,8 +85,8 @@ export function generateSimplifiedString( export function generateString( nonEmpty: boolean = false, constValue?: string, -): fc.Arbitrary { - return fc.record({ +): fc.Arbitrary { + return fc.record({ kind: fc.constant("string"), id: fc.constant(nextId()), value: generateStringValue(nonEmpty, constValue), @@ -111,8 +94,8 @@ export function generateString( }); } -export function generateNull(): fc.Arbitrary { - return fc.record({ +export function generateNull(): fc.Arbitrary { + return fc.record({ kind: fc.constant("null"), id: fc.constant(nextId()), loc: fc.constant(dummySrcInfoPrintable), @@ -121,8 +104,8 @@ export function generateNull(): fc.Arbitrary { export function generateFieldAccess( name: string, - aggregate?: AstExpression, -): AstFieldAccess { + aggregate?: Ast.Expression, +): Ast.FieldAccess { return { kind: "field_access", aggregate: aggregate ?? generateThisID(), @@ -132,7 +115,7 @@ export function generateFieldAccess( }; } -export function generateThisID(): AstId { +export function generateThisID(): Ast.Id { return { kind: "id", id: nextId(), @@ -147,7 +130,7 @@ export function generateThisID(): AstId { export function generateMapInit( ty: Type, scope: Scope, -): fc.Arbitrary { +): fc.Arbitrary { if (scope.definedIn("block", "method", "function") && randomBool()) { return new StaticCall(ty, "emptyMap", []).generate(); } else { @@ -161,13 +144,13 @@ export function generateMapInit( export function generateStructInit( ty: Type, scope: Scope, -): fc.Arbitrary { +): fc.Arbitrary { if (ty.kind !== "struct" && ty.kind !== "message") { throwTyError(ty); } - const args: fc.Arbitrary[] = ty.fields.map( + const args: fc.Arbitrary[] = ty.fields.map( (field: StructField) => { - return fc.record({ + return fc.record({ kind: fc.constant("struct_field_initializer"), id: fc.constant(nextId()), field: fc.constant(generateAstIdFromName(field.name)), @@ -176,7 +159,7 @@ export function generateStructInit( }); }, ); - return fc.record({ + return fc.record({ kind: fc.constantFrom("struct_instance"), id: fc.constantFrom(nextId()), type: fc.constantFrom(generateAstIdFromName(tyToString(ty))), @@ -193,7 +176,7 @@ export function generateStructInit( export function generateFunctionCallArgs( funTy: Type, funScope: Scope, -): fc.Arbitrary[] { +): fc.Arbitrary[] { if (funTy.kind !== "function") { throw new Error( `Incorrect type for function: ${JSONbig.stringify(funTy)}`, @@ -215,7 +198,7 @@ export function generateFunctionCallArgs( export function generateMethodCallArgs( methodTy: Type, methodScope: Scope, -): fc.Arbitrary[] { +): fc.Arbitrary[] { if (methodTy.kind !== "function") { throw new Error( `Incorrect type for method: ${JSONbig.stringify(methodTy)}`, @@ -232,17 +215,17 @@ export function generateMethodCallArgs( /** * Generates field and contract constants access operations. */ -export class FieldAccess extends NamedGenerativeEntity { +export class FieldAccess extends NamedGenerativeEntity { constructor( type: Type, fieldName: string, - private src?: AstId, + private src?: Ast.Id, ) { super(type, generateAstIdFromName(fieldName)); } - generate(): fc.Arbitrary { - return fc.record({ + generate(): fc.Arbitrary { + return fc.record({ kind: fc.constant("field_access"), aggregate: fc.constant(this.src ?? generateThisID()), field: fc.constant(this.name), @@ -255,17 +238,17 @@ export class FieldAccess extends NamedGenerativeEntity { /** * Generates method calls. */ -export class MethodCall extends NamedGenerativeEntity { +export class MethodCall extends NamedGenerativeEntity { constructor( type: Type, name: string, - private src: AstExpression, - private args?: fc.Arbitrary[], + private src: Ast.Expression, + private args?: fc.Arbitrary[], ) { super(type, generateAstIdFromName(name)); } - generate(): fc.Arbitrary { - return fc.record({ + generate(): fc.Arbitrary { + return fc.record({ kind: fc.constant("method_call"), self: fc.constant(this.src), method: fc.constant(this.name), @@ -279,16 +262,16 @@ export class MethodCall extends NamedGenerativeEntity { /** * Generates free function calls. */ -export class StaticCall extends NamedGenerativeEntity { +export class StaticCall extends NamedGenerativeEntity { constructor( type: Type, name: string, - private args?: fc.Arbitrary[], + private args?: fc.Arbitrary[], ) { super(type, generateAstIdFromName(name)); } - generate(): fc.Arbitrary { - return fc.record({ + generate(): fc.Arbitrary { + return fc.record({ kind: fc.constant("static_call"), function: fc.constantFrom(this.name), args: packArbitraries(this.args), @@ -300,9 +283,9 @@ export class StaticCall extends NamedGenerativeEntity { // export namespace OpUnary { // function generate( -// args: fc.Arbitrary[], +// args: fc.Arbitrary[], // allowedOps: readonly UnaryOperation[], -// ): fc.Arbitrary { +// ): fc.Arbitrary { // return fc.letrec((tie) => ({ // astExpression: fc.oneof( // { maxDepth: 1 }, @@ -312,12 +295,12 @@ export class StaticCall extends NamedGenerativeEntity { // weight: 1, // }, // ), -// astOpUnary: fc.record({ +// astOpUnary: fc.record({ // kind: fc.constant("op_unary"), // id: fc.constant(nextId()), // op: fc.constantFrom(...allowedOps), // loc: fc.constant(dummySrcInfoPrintable), -// operand: tie("astExpression") as fc.Arbitrary, +// operand: tie("astExpression") as fc.Arbitrary, // }), // })).astOpUnary; // } @@ -335,9 +318,9 @@ export class StaticCall extends NamedGenerativeEntity { // export namespace OpBinary { // export function generate( -// args: fc.Arbitrary[], -// allowedOps: readonly AstOpBinary["op"][], -// ): fc.Arbitrary { +// args: fc.Arbitrary[], +// allowedOps: readonly Ast.OpBinary["op"][], +// ): fc.Arbitrary { // return fc.letrec((tie) => ({ // astExpression: fc.oneof( // { maxDepth: 1 }, @@ -347,19 +330,19 @@ export class StaticCall extends NamedGenerativeEntity { // weight: 1, // }, // ), -// astOpBinary: fc.record({ +// astOpBinary: fc.record({ // kind: fc.constant("op_binary"), // id: fc.constant(nextId()), // op: fc.constantFrom(...allowedOps), -// left: tie("astExpression") as fc.Arbitrary, -// right: tie("astExpression") as fc.Arbitrary, +// left: tie("astExpression") as fc.Arbitrary, +// right: tie("astExpression") as fc.Arbitrary, // loc: fc.constant(dummySrcInfoPrintable), // }), // })).astOpBinary; // } // // num -> num -> num -// export const NumOps: AstOpBinary["op"][] = [ +// export const NumOps: Ast.OpBinary["op"][] = [ // "+", // "-", // "*", @@ -373,14 +356,14 @@ export class StaticCall extends NamedGenerativeEntity { // export const NumGens = [generateNumber(), OpUnary.Num]; // // bool -> bool -> bool -// export const BoolOps: AstOpBinary["op"][] = ["&&", "||"]; +// export const BoolOps: Ast.OpBinary["op"][] = ["&&", "||"]; // export const BoolGens = [ // generateBoolean(), // OpUnary.Bool, // // bool -> bool -> bool // generate([generateBoolean()], BoolOps), // // num -> num -> bool -// // mkAstOpBinaryGen([ Primitive.NumberGen ], +// // mkAst.OpBinaryGen([ Primitive.NumberGen ], // // ["==", "!=", "&&", "||"]), // ]; // } @@ -392,7 +375,7 @@ export class StaticCall extends NamedGenerativeEntity { * the desired type and creates an access expression. */ export class StructAccess extends GenerativeEntityOpt< - AstExpression | undefined + Ast.Expression | undefined > { constructor( private parentScope: Scope, @@ -401,7 +384,7 @@ export class StructAccess extends GenerativeEntityOpt< super(resultTy); } - generate(): fc.Arbitrary | undefined { + generate(): fc.Arbitrary | undefined { const structEntries = this.findStructsWithMatchingFields(); if (structEntries.size === 0) { return undefined; // No suitable struct found @@ -487,7 +470,7 @@ export class StructAccess extends GenerativeEntityOpt< private createFieldAccessExpression( structEntries: Map, structVarNames: Map, - ): fc.Arbitrary { + ): fc.Arbitrary { const chosenStructName = randomElement( Array.from(structVarNames.keys()), ); @@ -562,7 +545,7 @@ export const NonGenerativeExpressionParams: Partial = { * may recursively create additional constructs, such as functions and constants, * in outer scopes. */ -export class Expression extends GenerativeEntity { +export class Expression extends GenerativeEntity { private generateFunctions: boolean; private generateMethods: boolean; private generateConstants: boolean; @@ -615,7 +598,9 @@ export class Expression extends GenerativeEntity { * Generates or chooses an available constant and makes a "use" expression from it. * @return Use of the generated constant, or `undefined` if that type is unsupported. */ - private makeConstantUse(ty: Type): fc.Arbitrary | undefined { + private makeConstantUse( + ty: Type, + ): fc.Arbitrary | undefined { if (this.compileTimeEval || !this.generateConstants) { return undefined; } @@ -684,7 +669,7 @@ export class Expression extends GenerativeEntity { * Generates or chooses an available field and makes a "use" expression from it. * @return Use expression of the generated field, or `undefined` if cannot create it. */ - private makeFieldUse(ty: Type): fc.Arbitrary | undefined { + private makeFieldUse(ty: Type): fc.Arbitrary | undefined { if ( this.compileTimeEval || !this.generateFields || @@ -725,7 +710,7 @@ export class Expression extends GenerativeEntity { * The process of generating local variables involves creating new statements in the function/method body. * @return Use expression of the generated local variable, or `undefined` if cannot create it. */ - private makeLocalVarUse(ty: Type): fc.Arbitrary | undefined { + private makeLocalVarUse(ty: Type): fc.Arbitrary | undefined { if ( this.compileTimeEval || !this.generateStatements || @@ -753,7 +738,7 @@ export class Expression extends GenerativeEntity { */ private makeStructFieldAccess( ty: Type, - ): fc.Arbitrary | undefined { + ): fc.Arbitrary | undefined { if ( this.compileTimeEval || !this.generateStatements || @@ -786,7 +771,7 @@ export class Expression extends GenerativeEntity { */ private makeFunCall( returnTy: Type, - ): fc.Arbitrary | undefined { + ): fc.Arbitrary | undefined { if (this.compileTimeEval || !this.generateFunctions) { return undefined; } @@ -816,7 +801,7 @@ export class Expression extends GenerativeEntity { */ private makeMethodCall( returnTy: Type, - ): fc.Arbitrary | undefined { + ): fc.Arbitrary | undefined { if ( this.compileTimeEval || !this.generateMethods || @@ -856,7 +841,7 @@ export class Expression extends GenerativeEntity { acc.push(opCall); } return acc; - }, [] as fc.Arbitrary[]), + }, [] as fc.Arbitrary[]), // map_var.get(key) ...this.parentScope .getNamedEntriesRecursive("let") @@ -884,7 +869,7 @@ export class Expression extends GenerativeEntity { acc.push(opCall); } return acc; - }, [] as fc.Arbitrary[]), + }, [] as fc.Arbitrary[]), ]; // Generate or collect the available user-defined methods @@ -916,7 +901,7 @@ export class Expression extends GenerativeEntity { } /** Generates `require` function call. */ - private generateRequireCall(): fc.Arbitrary { + private generateRequireCall(): fc.Arbitrary { const condition = new Expression(this.parentScope, { kind: "stdlib", type: StdlibType.Bool, @@ -935,7 +920,7 @@ export class Expression extends GenerativeEntity { /** * Generates expressions that returns the given standard type when evaluated. */ - private generateExpressions(ty: Type): fc.Arbitrary { + private generateExpressions(ty: Type): fc.Arbitrary { const funCall = this.makeFunCall(ty); const methodCall = this.makeMethodCall(ty); const constant = this.makeConstantUse(ty); @@ -985,8 +970,8 @@ export class Expression extends GenerativeEntity { * During expression generation, the generator creates new AST entries in the outer scopes, * including functions and constants saving them to the given context. */ - generate(): fc.Arbitrary { - let expr: fc.Arbitrary; + generate(): fc.Arbitrary { + let expr: fc.Arbitrary; switch (this.type.kind) { case "stdlib": case "map": diff --git a/fuzzer/src/generators/field.ts b/fuzzer/src/generators/field.ts index fcd2d8ab06..764d049240 100644 --- a/fuzzer/src/generators/field.ts +++ b/fuzzer/src/generators/field.ts @@ -1,8 +1,4 @@ -import type { - FieldDecl as AstFieldDecl, - Expression as AstExpression, - Id as AstId, -} from "../../../src/ast/ast"; +import type * as Ast from "../../../src/ast/ast"; import { createSample, dummySrcInfoPrintable, generateAstId } from "../util"; import { tyToAstType } from "../types"; import type { Type } from "../types"; @@ -12,9 +8,9 @@ import { NamedGenerativeEntity } from "./generator"; import fc from "fast-check"; /** - * An object that encapsulates a generated AstFieldDecl. + * An object that encapsulates a generated Ast.FieldDecl. */ -export class Field extends NamedGenerativeEntity { +export class Field extends NamedGenerativeEntity { /** * @param init An optional initializer evaluable in compile-time. // cspell:disable-line * @param parentScope Scope this field belongs to. Could be a contract or program for struct fields. @@ -22,8 +18,8 @@ export class Field extends NamedGenerativeEntity { constructor( parentScope: Scope, type: Type, - private init?: fc.Arbitrary, - name?: AstId, + private init?: fc.Arbitrary, + name?: Ast.Id, ) { if ( !parentScope.definedIn( @@ -40,8 +36,8 @@ export class Field extends NamedGenerativeEntity { super(type, name ?? createSample(generateAstId(parentScope))); } - generate(): fc.Arbitrary { - return fc.record({ + generate(): fc.Arbitrary { + return fc.record({ kind: fc.constant("field_decl"), id: fc.constant(this.idx), name: fc.constant(this.name), diff --git a/fuzzer/src/generators/function.ts b/fuzzer/src/generators/function.ts index 0a90e243cb..b6d0348141 100644 --- a/fuzzer/src/generators/function.ts +++ b/fuzzer/src/generators/function.ts @@ -1,10 +1,4 @@ -import type { - FunctionDef as AstFunctionDef, - TypedParameter as AstTypedParameter, - FunctionAttribute as AstFunctionAttribute, - Statement as AstStatement, - FunctionDecl as AstFunctionDecl, -} from "../../../src/ast/ast"; +import type * as Ast from "../../../src/ast/ast"; import { tyToAstType, StdlibType, @@ -54,7 +48,7 @@ function generateParameters( kind: FunctionKind, type: FunctionType, scope: Scope, -): AstTypedParameter[] { +): Ast.TypedParameter[] { if (notHaveArguments(kind, type)) { return []; } @@ -73,11 +67,11 @@ function generateParameters( * Prepares the final list of attributes based on function kind and the current implementation details. */ function getAttributes( - extraAttrs: AstFunctionAttribute[], + extraAttrs: Ast.FunctionAttribute[], kind: FunctionKind, onlyDeclaration: boolean, -): AstFunctionAttribute[] { - const attrs: AstFunctionAttribute[] = extraAttrs; +): Ast.FunctionAttribute[] { + const attrs: Ast.FunctionAttribute[] = extraAttrs; // We are marking all the methods with the `get` attribute to ensure they // will be compiled to func and tested by compilation tests. @@ -107,9 +101,9 @@ function getAttributes( * An object that encapsulates the generated free function or contract method definition including * its scope and nested elements. */ -export class FunctionDef extends NamedGenerativeEntity { +export class FunctionDef extends NamedGenerativeEntity { /** Generated body items. */ - private body: fc.Arbitrary[] = []; + private body: fc.Arbitrary[] = []; /** Scope used within the generated function. */ private scope: Scope; @@ -136,7 +130,7 @@ export class FunctionDef extends NamedGenerativeEntity { /** * Generates body of the function emitting return statement and statements generated from the bottom-up. */ - private generateBody(): fc.Arbitrary { + private generateBody(): fc.Arbitrary { const type = this.type as FunctionType; const returnTy: Type = type.signature.length > 0 @@ -154,10 +148,10 @@ export class FunctionDef extends NamedGenerativeEntity { } public generateImpl( - extraAttrs: AstFunctionAttribute[], - ): fc.Arbitrary { + extraAttrs: Ast.FunctionAttribute[], + ): fc.Arbitrary { const returnTy = getReturnType(this.type as FunctionType); - return fc.record({ + return fc.record({ kind: fc.constant("function_def"), id: fc.constant(this.idx), attributes: fc.constant( @@ -182,7 +176,7 @@ export class FunctionDef extends NamedGenerativeEntity { /** * Generates a function definition without extra attributes. */ - public generate(): fc.Arbitrary { + public generate(): fc.Arbitrary { return this.generateImpl([]); } } @@ -191,7 +185,7 @@ export class FunctionDef extends NamedGenerativeEntity { * An object that encapsulates the generated free function or trait method declaration including * its scope and nested elements. */ -export class FunctionDecl extends NamedGenerativeEntity { +export class FunctionDecl extends NamedGenerativeEntity { /** Scope used within the generated function. */ private scope: Scope; @@ -205,10 +199,10 @@ export class FunctionDecl extends NamedGenerativeEntity { } private generateImpl( - extraAttrs: AstFunctionAttribute[], - ): fc.Arbitrary { + extraAttrs: Ast.FunctionAttribute[], + ): fc.Arbitrary { const returnTy = getReturnType(this.type as FunctionType); - return fc.record({ + return fc.record({ kind: fc.constant("function_decl"), id: fc.constant(this.idx), attributes: fc.constant(getAttributes(extraAttrs, this.kind, true)), @@ -230,7 +224,7 @@ export class FunctionDecl extends NamedGenerativeEntity { /** * Generates a function definition without extra attributes. */ - public generate(): fc.Arbitrary { + public generate(): fc.Arbitrary { return this.generateImpl([]); } @@ -239,8 +233,8 @@ export class FunctionDecl extends NamedGenerativeEntity { */ public generateDefinition( kind: FunctionKind, - attrs: AstFunctionAttribute[] = [], - ): fc.Arbitrary { + attrs: Ast.FunctionAttribute[] = [], + ): fc.Arbitrary { return new FunctionDef( this.scope.parentScope!, kind, diff --git a/fuzzer/src/generators/generator.ts b/fuzzer/src/generators/generator.ts index b57edebd50..faae6579d8 100644 --- a/fuzzer/src/generators/generator.ts +++ b/fuzzer/src/generators/generator.ts @@ -1,4 +1,4 @@ -import type { Id as AstId } from "../../../src/ast/ast"; +import type * as Ast from "../../../src/ast/ast"; import { nextId } from "../id"; import type { IDIdx } from "../id"; import type { Type } from "../types"; @@ -26,9 +26,9 @@ export abstract class GenerativeEntity extends GenerativeEntityBase { } export abstract class NamedGenerativeEntity extends GenerativeEntity { - public name: AstId; + public name: Ast.Id; - constructor(type: Type, name: AstId) { + constructor(type: Type, name: Ast.Id) { super(type); this.name = name; } diff --git a/fuzzer/src/generators/parameter.ts b/fuzzer/src/generators/parameter.ts index 3aa82e56f3..7fa544cf46 100644 --- a/fuzzer/src/generators/parameter.ts +++ b/fuzzer/src/generators/parameter.ts @@ -1,4 +1,4 @@ -import type { TypedParameter as AstTypedParameter } from "../../../src/ast/ast"; +import type * as Ast from "../../../src/ast/ast"; import { createSample, dummySrcInfoPrintable, generateAstId } from "../util"; import { tyToAstType } from "../types"; import type { Type } from "../types"; @@ -8,9 +8,9 @@ import { NamedGenerativeEntity } from "./generator"; import fc from "fast-check"; /** - * An object that encapsulates generated AstTypedParameter. + * An object that encapsulates generated Ast.TypedParameter. */ -export class Parameter extends NamedGenerativeEntity { +export class Parameter extends NamedGenerativeEntity { /** * @param parentScope Scope of the function this argument belongs to. * @param isBounced If the type of the argument should be wrapped in `bounced<>` @@ -28,8 +28,8 @@ export class Parameter extends NamedGenerativeEntity { super(type, createSample(generateAstId(parentScope))); } - generate(): fc.Arbitrary { - return fc.record({ + generate(): fc.Arbitrary { + return fc.record({ kind: fc.constant("typed_parameter"), id: fc.constant(this.idx), name: fc.constant(this.name), diff --git a/fuzzer/src/generators/program.ts b/fuzzer/src/generators/program.ts index e62daac62d..c468082a44 100644 --- a/fuzzer/src/generators/program.ts +++ b/fuzzer/src/generators/program.ts @@ -1,4 +1,4 @@ -import type { Module as AstModule } from "../../../src/ast/ast"; +import type * as Ast from "../../../src/ast/ast"; import { createSamplesArray, createSample, @@ -41,10 +41,10 @@ export interface ProgramParameters { } /** - * An object that encapsulates a randomly generated AstModule including extra information + * An object that encapsulates a randomly generated Ast.Module including extra information * about its entries and their scopes. */ -export class Program extends NamedGenerativeEntity { +export class Program extends NamedGenerativeEntity { /** Top-level global scope. */ private scope: Scope; @@ -99,7 +99,7 @@ export class Program extends NamedGenerativeEntity { * constants, functions and contract fields. AST nodes inside the contract implementation may vary, * as determined by fast-check. */ - public generate(): fc.Arbitrary { + public generate(): fc.Arbitrary { const stdlibEntries = this.addStdlib ? getStdlibTraits() .concat(getStdlibTypes()) @@ -123,7 +123,7 @@ export class Program extends NamedGenerativeEntity { const functions = Array.from(this.scope.getAllNamed("functionDef")).map( (f) => f.generate(), ); - return fc.record({ + return fc.record({ kind: fc.constantFrom("module"), id: fc.constantFrom(this.idx), items: fc.tuple( diff --git a/fuzzer/src/generators/receiver.ts b/fuzzer/src/generators/receiver.ts index 526a893a00..c779687c86 100644 --- a/fuzzer/src/generators/receiver.ts +++ b/fuzzer/src/generators/receiver.ts @@ -1,12 +1,4 @@ -import type { - Receiver as AstReceiver, - Statement as AstStatement, - ReceiverKind as AstReceiverKind, - ReceiverSubKind as AstReceiverSubKind, - ReceiverSimple as AstReceiverSimple, - ReceiverFallback as AstReceiverFallback, - ReceiverComment as AstReceiverComment, -} from "../../../src/ast/ast"; +import type * as Ast from "../../../src/ast/ast"; import { UtilType, StdlibType, isBouncedMessage } from "../types"; import type { Type } from "../types"; import { Scope } from "../scope"; @@ -28,23 +20,23 @@ const RECEIVE_RETURN_TY: Type = { kind: "util", type: UtilType.Unit }; function generateReceiverSimpleSubKind( param: Parameter, -): fc.Arbitrary { - return fc.record({ +): fc.Arbitrary { + return fc.record({ kind: fc.constant("simple"), param: param.generate(), id: fc.constant(nextId()), }); } -function generateReceiverFallbackSubKind(): fc.Arbitrary { - return fc.record({ +function generateReceiverFallbackSubKind(): fc.Arbitrary { + return fc.record({ kind: fc.constant("fallback"), id: fc.constant(nextId()), }); } -function generateReceiverCommentSubKind(): fc.Arbitrary { - return fc.record({ +function generateReceiverCommentSubKind(): fc.Arbitrary { + return fc.record({ kind: fc.constant("comment"), comment: generateString(/*nonEmpty=*/ true), id: fc.constant(nextId()), @@ -52,9 +44,9 @@ function generateReceiverCommentSubKind(): fc.Arbitrary { } function generateInternalReceiverKind( - subKind: fc.Arbitrary, -): fc.Arbitrary { - return fc.record({ + subKind: fc.Arbitrary, +): fc.Arbitrary { + return fc.record({ kind: fc.constant("internal"), subKind, id: fc.constant(nextId()), @@ -63,9 +55,9 @@ function generateInternalReceiverKind( } function generateExternalReceiverKind( - subKind: fc.Arbitrary, -): fc.Arbitrary { - return fc.record({ + subKind: fc.Arbitrary, +): fc.Arbitrary { + return fc.record({ kind: fc.constant("external"), subKind, id: fc.constant(nextId()), @@ -74,11 +66,11 @@ function generateExternalReceiverKind( } /** - * An object that encapsulates an AstReceiver. + * An object that encapsulates an Ast.Receiver. */ -export class Receive extends GenerativeEntity { +export class Receive extends GenerativeEntity { /** Generated body items. */ - private body: fc.Arbitrary[] = []; + private body: fc.Arbitrary[] = []; /** Scope used within the generated receive method. */ private scope: Scope; @@ -88,7 +80,7 @@ export class Receive extends GenerativeEntity { this.scope = new Scope("receive", parentScope); } - private generateSelector(): fc.Arbitrary { + private generateSelector(): fc.Arbitrary { if (randomBool()) { const ty = createSample( fc.record({ @@ -120,7 +112,7 @@ export class Receive extends GenerativeEntity { isBouncedMessage(msg.type), ); this.scope.addNamed("parameter", param); - return fc.record({ + return fc.record({ kind: fc.constantFrom("bounce"), param: param.generate(), id: fc.constant(nextId()), @@ -149,7 +141,7 @@ export class Receive extends GenerativeEntity { ); // TODO: add bounce receiver generation } - private generateBody(): fc.Arbitrary { + private generateBody(): fc.Arbitrary { // Create a dummy expression to execute the bottom-up AST generation. const expr = new Expression(this.scope, this.type).generate(); const stmt = new StatementExpression(expr).generate(); @@ -164,8 +156,8 @@ export class Receive extends GenerativeEntity { return fc.tuple(...this.body); } - public generate(): fc.Arbitrary { - return fc.record({ + public generate(): fc.Arbitrary { + return fc.record({ kind: fc.constant("receiver"), id: fc.constant(this.idx), selector: this.generateSelector(), diff --git a/fuzzer/src/generators/statement.ts b/fuzzer/src/generators/statement.ts index 30c29a9a37..011e88ed4e 100644 --- a/fuzzer/src/generators/statement.ts +++ b/fuzzer/src/generators/statement.ts @@ -1,22 +1,4 @@ -import type { - StatementReturn as AstStatementReturn, - FieldAccess as AstFieldAccess, - StatementExpression as AstStatementExpression, - Statement as AstStatement, - StatementTry as AstStatementTry, - StatementForEach as AstStatementForEach, - StatementCondition as AstStatementCondition, - StatementRepeat as AstStatementRepeat, - StatementAssign as AstStatementAssign, - StatementAugmentedAssign as AstStatementAugmentedAssign, - AugmentedAssignOperation as AstAugmentedAssignOperation, - StatementWhile as AstStatementWhile, - StatementUntil as AstStatementUntil, - Expression as AstExpression, - StatementLet as AstStatementLet, - Id as AstId, - CatchBlock as AstCatchBlock, -} from "../../../src/ast/ast"; +import type * as Ast from "../../../src/ast/ast"; import fc from "fast-check"; import { @@ -52,7 +34,7 @@ const STMT_TY: Type = { kind: "util", type: UtilType.Unit }; /** * Generates `return` statements. */ -export class Return extends GenerativeEntity { +export class Return extends GenerativeEntity { /** * @param parentScope Scope this statement belongs to. */ @@ -62,8 +44,8 @@ export class Return extends GenerativeEntity { ) { super(type); } - generate(): fc.Arbitrary { - return fc.record({ + generate(): fc.Arbitrary { + return fc.record({ kind: fc.constant("statement_return"), id: fc.constant(this.idx), expression: @@ -79,7 +61,7 @@ export class Return extends GenerativeEntity { * Let generator is the entry point of the bottom-up statement generation. * It creates a variable binding and then adds additional statements that mutate the created binding and the global state. */ -export class Let extends NamedGenerativeEntity { +export class Let extends NamedGenerativeEntity { /** * @param parentScope Scope this statement belongs to. * @param type Type of the generated binding. @@ -88,13 +70,13 @@ export class Let extends NamedGenerativeEntity { constructor( parentScope: Scope, type: Type, - private expr: fc.Arbitrary, + private expr: fc.Arbitrary, ) { super(type, createSample(generateAstId(parentScope))); } - generate(): fc.Arbitrary { - return fc.record({ + generate(): fc.Arbitrary { + return fc.record({ kind: fc.constant("statement_let"), id: fc.constant(this.idx), name: fc.constantFrom(this.name), @@ -108,7 +90,7 @@ export class Let extends NamedGenerativeEntity { /** * Creates assignments and augmented assignments to modify global or local variables. */ -export class AssignStatement extends GenerativeEntity { +export class AssignStatement extends GenerativeEntity { /** * @param path A qualified name of the lhs. * @param rhs Expression to assign to. @@ -116,17 +98,17 @@ export class AssignStatement extends GenerativeEntity { * @param ty Type of the statement. */ constructor( - private path: AstExpression, - private rhs: fc.Arbitrary, + private path: Ast.Expression, + private rhs: fc.Arbitrary, private rhsTy: Type, ty = STMT_TY, ) { super(ty); } - generate(): fc.Arbitrary { - const assigns: fc.Arbitrary[] = [ - fc.record({ + generate(): fc.Arbitrary { + const assigns: fc.Arbitrary[] = [ + fc.record({ kind: fc.constant("statement_assign"), id: fc.constant(this.idx), path: fc.constant(this.path), @@ -141,10 +123,10 @@ export class AssignStatement extends GenerativeEntity { this.rhsTy.type === StdlibType.Int ) { assigns.push( - fc.record({ + fc.record({ kind: fc.constant("statement_augmentedassign"), id: fc.constant(this.idx), - op: fc.constantFrom( + op: fc.constantFrom( "+=", "-=", "*=", @@ -164,38 +146,38 @@ export class AssignStatement extends GenerativeEntity { /** * Generates `while` and `until` loops. */ -export class WhileUntilStatement extends GenerativeEntity { +export class WhileUntilStatement extends GenerativeEntity { constructor( - private condition: fc.Arbitrary, - private body: fc.Arbitrary[], + private condition: fc.Arbitrary, + private body: fc.Arbitrary[], private kind: "until" | "while", type: Type = STMT_TY, ) { super(type); } - generate(): fc.Arbitrary { + generate(): fc.Arbitrary { return fc.record({ kind: fc.constant(`statement_${this.kind}`), id: fc.constant(this.idx), condition: this.condition, statements: packArbitraries(this.body), loc: fc.constant(dummySrcInfoPrintable), - }) as fc.Arbitrary; + }) as fc.Arbitrary; } } /** * Generates `repeat` loops. */ -export class RepeatStatement extends GenerativeEntity { +export class RepeatStatement extends GenerativeEntity { constructor( private parentScope: Scope, - private body: fc.Arbitrary[], + private body: fc.Arbitrary[], type: Type = STMT_TY, ) { super(type); } - generate(): fc.Arbitrary { + generate(): fc.Arbitrary { const iterations = new Expression(this.parentScope, { kind: "stdlib", type: StdlibType.Int, @@ -206,25 +188,25 @@ export class RepeatStatement extends GenerativeEntity { iterations, statements: packArbitraries(this.body), loc: fc.constant(dummySrcInfoPrintable), - }) as fc.Arbitrary; + }) as fc.Arbitrary; } } /** * Generates `foreach` loops. */ -export class ForeachStatement extends GenerativeEntity { +export class ForeachStatement extends GenerativeEntity { constructor( - private map: fc.Arbitrary, + private map: fc.Arbitrary, private keyName: string, private valueName: string, - private body: fc.Arbitrary[], + private body: fc.Arbitrary[], type: Type = STMT_TY, ) { super(type); } - generate(): fc.Arbitrary { - return fc.record({ + generate(): fc.Arbitrary { + return fc.record({ kind: fc.constant("statement_foreach"), keyName: fc.constant(generateAstIdFromName(this.keyName)), valueName: fc.constant(generateAstIdFromName(this.valueName)), @@ -239,22 +221,22 @@ export class ForeachStatement extends GenerativeEntity { /** * Generates conditional statements. */ -export class ConditionStatement extends GenerativeEntity { +export class ConditionStatement extends GenerativeEntity { constructor( private parentScope: Scope, - private trueStmts: fc.Arbitrary[], - private falseStmts?: fc.Arbitrary[], - private elseif?: fc.Arbitrary, + private trueStmts: fc.Arbitrary[], + private falseStmts?: fc.Arbitrary[], + private elseif?: fc.Arbitrary, type: Type = STMT_TY, ) { super(type); } - generate(): fc.Arbitrary { + generate(): fc.Arbitrary { const condition = new Expression(this.parentScope, { kind: "stdlib", type: StdlibType.Bool, }).generate(); - return fc.record({ + return fc.record({ kind: fc.constant(`statement_condition`), condition, trueStatements: packArbitraries(this.trueStmts), @@ -270,16 +252,16 @@ export class ConditionStatement extends GenerativeEntity /** * Generates try-catch statements. */ -export class TryCatch extends GenerativeEntity { +export class TryCatch extends GenerativeEntity { constructor( - private tryStmts: fc.Arbitrary[], - private catchBlock?: AstCatchBlock, + private tryStmts: fc.Arbitrary[], + private catchBlock?: Ast.CatchBlock, type: Type = STMT_TY, ) { super(type); } - generate(): fc.Arbitrary { - return fc.record({ + generate(): fc.Arbitrary { + return fc.record({ kind: fc.constant("statement_try"), id: fc.constant(this.idx), statements: packArbitraries(this.tryStmts), @@ -293,15 +275,15 @@ export class TryCatch extends GenerativeEntity { * Generates expression statements. * The return value of the function/method calls generated by this is never used. */ -export class StatementExpression extends GenerativeEntity { +export class StatementExpression extends GenerativeEntity { constructor( - private expr: fc.Arbitrary, + private expr: fc.Arbitrary, type: Type = STMT_TY, ) { super(type); } - generate(): fc.Arbitrary { - return fc.record({ + generate(): fc.Arbitrary { + return fc.record({ kind: fc.constant("statement_expression"), id: fc.constant(this.idx), expression: this.expr, @@ -327,7 +309,7 @@ export interface StatementParameters { /** * The generator that creates statements in the given block which mutate global or local state. */ -export class Statement extends GenerativeEntity { +export class Statement extends GenerativeEntity { private nestedBlocksNum: number; private stmtsInBlock: number; private params: Partial; @@ -358,7 +340,7 @@ export class Statement extends GenerativeEntity { this.params = params; } - generate(): fc.Arbitrary { + generate(): fc.Arbitrary { const varAssign = this.makeVarAssign(); const fieldAssign = this.makeFieldAssign(); const loopStmt = randomBool() @@ -387,7 +369,7 @@ export class Statement extends GenerativeEntity { /** * Creates statements that mutate local variables, including assignments and augmented assignments. */ - private makeVarAssign(): fc.Arbitrary | undefined { + private makeVarAssign(): fc.Arbitrary | undefined { const varEntries: [string, Type][] = this.parentScope.getNamedEntriesRecursive("let"); if (varEntries.length === 0) { @@ -407,7 +389,7 @@ export class Statement extends GenerativeEntity { /** * Creates statements that mutate contract fields, including assignments and augmented assignments. */ - private makeFieldAssign(): fc.Arbitrary | undefined { + private makeFieldAssign(): fc.Arbitrary | undefined { if (!this.parentScope.definedIn("method")) { return undefined; } @@ -434,7 +416,7 @@ export class Statement extends GenerativeEntity { /** * Creates either while or until loops. */ - private makeWhileUntil(): fc.Arbitrary | undefined { + private makeWhileUntil(): fc.Arbitrary | undefined { if (this.recursionLevel >= this.nestedBlocksNum) { return undefined; } @@ -454,7 +436,7 @@ export class Statement extends GenerativeEntity { /** * Generates repeat loops. */ - private makeRepeat(): fc.Arbitrary | undefined { + private makeRepeat(): fc.Arbitrary | undefined { if (this.recursionLevel >= this.nestedBlocksNum) { return undefined; } @@ -463,9 +445,9 @@ export class Statement extends GenerativeEntity { } /** - * Collects all local map AstIds in parent scope. + * Collects all local map Ast.Ids in parent scope. */ - private collectLocalMapIds(entryKinds: NamedScopeItemKind[]): AstId[] { + private collectLocalMapIds(entryKinds: NamedScopeItemKind[]): Ast.Id[] { return this.parentScope .getNamedEntriesRecursive(...entryKinds) .filter(([_, mapTy]: [string, Type]) => mapTy.kind === "map") @@ -475,11 +457,11 @@ export class Statement extends GenerativeEntity { } /** - * Collects all field map AstIds in parent scope. + * Collects all field map Ast.Ids in parent scope. */ private collectFieldMapIds( entryKinds: NamedScopeItemKind[], - ): AstFieldAccess[] { + ): Ast.FieldAccess[] { return this.parentScope .getNamedEntriesRecursive(...entryKinds) .filter(([_, mapTy]: [string, Type]) => mapTy.kind === "map") @@ -491,7 +473,7 @@ export class Statement extends GenerativeEntity { /** * Generates foreach loops. */ - private makeForEach(): fc.Arbitrary | undefined { + private makeForEach(): fc.Arbitrary | undefined { if (this.recursionLevel >= this.nestedBlocksNum) { return undefined; } @@ -509,7 +491,7 @@ export class Statement extends GenerativeEntity { if (mapIds.length === 0) { return undefined; } - const map: fc.Arbitrary = fc.oneof(...mapIds); + const map: fc.Arbitrary = fc.oneof(...mapIds); const keyVarName = createSample(generateName(scope)); const valueVarName = createSample(generateName(scope)); const body = this.makeStmtsBlock(scope); @@ -524,7 +506,7 @@ export class Statement extends GenerativeEntity { /** * Generates conditional statements. */ - private makeCondition(): fc.Arbitrary | undefined { + private makeCondition(): fc.Arbitrary | undefined { if (this.recursionLevel >= this.nestedBlocksNum) { return undefined; } @@ -542,7 +524,7 @@ export class Statement extends GenerativeEntity { /** * Generates try and try-catch statements */ - private makeTryCatch(): fc.Arbitrary | undefined { + private makeTryCatch(): fc.Arbitrary | undefined { if (this.recursionLevel >= this.nestedBlocksNum) { return undefined; } @@ -565,7 +547,7 @@ export class Statement extends GenerativeEntity { /** * Generates function or method calls without using the return value. */ - private makeCall(): fc.Arbitrary | undefined { + private makeCall(): fc.Arbitrary | undefined { if (this.recursionLevel >= this.nestedBlocksNum) { return undefined; } @@ -606,9 +588,9 @@ export class Statement extends GenerativeEntity { /** * Creates a block of statements nested in curly braces in concrete syntax. */ - private makeStmtsBlock(blockScope?: Scope): fc.Arbitrary[] { + private makeStmtsBlock(blockScope?: Scope): fc.Arbitrary[] { const scope = blockScope ?? new Scope("block", this.parentScope); - const block: fc.Arbitrary[] = []; + const block: fc.Arbitrary[] = []; Array.from({ length: this.stmtsInBlock }).forEach(() => { const stmt = new Statement( scope, @@ -624,7 +606,7 @@ export class Statement extends GenerativeEntity { * Generates a dummy statement which doesn't have affect on control-flow nor state: * `while (false) { }` */ - private makeDummyStmt(): fc.Arbitrary { + private makeDummyStmt(): fc.Arbitrary { const falseExpr = generateBoolean(false); return new WhileUntilStatement(falseExpr, [], "while").generate(); } diff --git a/fuzzer/src/generators/struct.ts b/fuzzer/src/generators/struct.ts index b24276efc4..7f87e1f554 100644 --- a/fuzzer/src/generators/struct.ts +++ b/fuzzer/src/generators/struct.ts @@ -1,7 +1,4 @@ -import type { - MessageDecl as AstMessageDecl, - StructDecl as AstStructDecl, -} from "../../../src/ast/ast"; +import type * as Ast from "../../../src/ast/ast"; import { tyToString, throwTyError } from "../types"; import type { Type, StructField } from "../types"; import type { Scope } from "../scope"; @@ -16,9 +13,9 @@ import { NamedGenerativeEntity } from "./generator"; import fc from "fast-check"; /** - * An object that generates AstStructDecl object. + * An object that generates Ast.StructDecl object. */ -export class Struct extends NamedGenerativeEntity { +export class Struct extends NamedGenerativeEntity { /** * @param programScope A program scope the structure defined in. */ @@ -39,7 +36,7 @@ export class Struct extends NamedGenerativeEntity { super(type, generateAstIdFromName(type.name)); } - generate(): fc.Arbitrary { + generate(): fc.Arbitrary { if (this.type.kind !== "struct") { throwTyError(this.type); } @@ -51,7 +48,7 @@ export class Struct extends NamedGenerativeEntity { generateAstIdFromName(fieldTy.name), ).generate(); }); - return fc.record({ + return fc.record({ kind: fc.constant("struct_decl"), id: fc.constant(this.idx), name: fc.constant(this.name), @@ -62,9 +59,9 @@ export class Struct extends NamedGenerativeEntity { } /** - * An object that generates AstMessageDecl object messages. + * An object that generates Ast.MessageDecl object messages. */ -export class Message extends NamedGenerativeEntity { +export class Message extends NamedGenerativeEntity { /** * @param programScope A program scope the structure defined in. */ @@ -85,7 +82,7 @@ export class Message extends NamedGenerativeEntity { super(type, generateAstIdFromName(type.name)); } - generate(): fc.Arbitrary { + generate(): fc.Arbitrary { if (this.type.kind !== "message") { throwTyError(this.type); } @@ -97,7 +94,7 @@ export class Message extends NamedGenerativeEntity { generateAstIdFromName(fieldTy.name), ).generate(); }); - return fc.record({ + return fc.record({ kind: fc.constant("message_decl"), id: fc.constant(this.idx), name: fc.constant(this.name!), diff --git a/fuzzer/src/generators/trait.ts b/fuzzer/src/generators/trait.ts index 39024aa6e9..b878d49ec9 100644 --- a/fuzzer/src/generators/trait.ts +++ b/fuzzer/src/generators/trait.ts @@ -1,7 +1,4 @@ -import type { - Trait as AstTrait, - Expression as AstExpression, -} from "../../../src/ast/ast"; +import type * as Ast from "../../../src/ast/ast"; import { createSample, dummySrcInfoPrintable, @@ -40,9 +37,9 @@ export interface TraitParameters { } /** - * An object that encapsulates a randomly generated AstTrait. + * An object that encapsulates a randomly generated Ast.Trait. */ -export class Trait extends NamedGenerativeEntity { +export class Trait extends NamedGenerativeEntity { /** Trait scope. */ private scope: Scope; @@ -80,7 +77,7 @@ export class Trait extends NamedGenerativeEntity { /** * Randomly generates init expressions for constants. */ - private makeInit(ty: Type): fc.Arbitrary | undefined { + private makeInit(ty: Type): fc.Arbitrary | undefined { return ty.kind === "map" || randomBool() ? undefined : new Expression(this.scope, ty, { @@ -124,7 +121,7 @@ export class Trait extends NamedGenerativeEntity { }); } - public generate(): fc.Arbitrary { + public generate(): fc.Arbitrary { // NOTE: It doesn't implement any receive functions, to don't clutter the top-level with them. const constants = ( this.constantDeclarations as (ConstantDecl | ConstantDef)[] @@ -133,7 +130,7 @@ export class Trait extends NamedGenerativeEntity { .map((c) => c.generate()); const fields = this.fieldDeclarations.map((f) => f.generate()); const methods = this.methodDeclarations.map((m) => m.generate()); - return fc.record({ + return fc.record({ kind: fc.constant("trait"), id: fc.constant(this.idx), name: fc.constant(this.name), diff --git a/fuzzer/src/scope.ts b/fuzzer/src/scope.ts index e0123cfc19..0b3ad259d8 100644 --- a/fuzzer/src/scope.ts +++ b/fuzzer/src/scope.ts @@ -2,20 +2,7 @@ import type { Type } from "./types"; import { getReturnType } from "./types"; import type { IDIdx } from "./id"; import type { GenerativeEntity } from "./generators"; -import type { - FunctionDef as AstFunctionDef, - TypedParameter as AstTypedParameter, - Trait as AstTrait, - Statement as AstStatement, - StructDecl as AstStructDecl, - FieldDecl as AstFieldDecl, - Receiver as AstReceiver, - Contract as AstContract, - ConstantDecl as AstConstantDecl, - ConstantDef as AstConstantDef, - FunctionDecl as AstFunctionDecl, - MessageDecl as AstMessageDecl, -} from "../../src/ast/ast"; +import type * as Ast from "../../src/ast/ast"; import type { NamedGenerativeEntity } from "./generators/generator"; export type ScopeKind = @@ -55,23 +42,23 @@ export type ScopeItemKind = NamedScopeItemKind | UnnamedScopeItemKind; /** Maps each ScopeItemKind to its respective GenerativeEntity specialization. */ type NamedGenerativeEntityMap = { - let: NamedGenerativeEntity; - parameter: NamedGenerativeEntity; - struct: NamedGenerativeEntity; - message: NamedGenerativeEntity; - constantDecl: NamedGenerativeEntity; - constantDef: NamedGenerativeEntity; - functionDecl: NamedGenerativeEntity; - functionDef: NamedGenerativeEntity; - methodDecl: NamedGenerativeEntity; - methodDef: NamedGenerativeEntity; - field: NamedGenerativeEntity; - contract: NamedGenerativeEntity; - trait: NamedGenerativeEntity; + let: NamedGenerativeEntity; + parameter: NamedGenerativeEntity; + struct: NamedGenerativeEntity; + message: NamedGenerativeEntity; + constantDecl: NamedGenerativeEntity; + constantDef: NamedGenerativeEntity; + functionDecl: NamedGenerativeEntity; + functionDef: NamedGenerativeEntity; + methodDecl: NamedGenerativeEntity; + methodDef: NamedGenerativeEntity; + field: NamedGenerativeEntity; + contract: NamedGenerativeEntity; + trait: NamedGenerativeEntity; }; type GenerativeEntityMap = { - statement: GenerativeEntity; - receive: GenerativeEntity; + statement: GenerativeEntity; + receive: GenerativeEntity; }; /** diff --git a/fuzzer/src/stdlib.ts b/fuzzer/src/stdlib.ts index 2ab0172866..1d0f7b78aa 100644 --- a/fuzzer/src/stdlib.ts +++ b/fuzzer/src/stdlib.ts @@ -1,4 +1,4 @@ -import type { TypeDecl as AstTypeDecl } from "../../src/ast/ast"; +import type * as Ast from "../../src/ast/ast"; import { nextId } from "./id"; import * as path from "path"; @@ -24,7 +24,7 @@ export const StdlibCode = StdlibVFS.readFile(StdlibPath).toString(); * Returns traits defined in stdlib. * TODO: We should parse its sources instead */ -export function getStdlibTraits(): AstTypeDecl[] { +export function getStdlibTraits(): Ast.TypeDecl[] { return [ { kind: "trait", diff --git a/fuzzer/src/types.ts b/fuzzer/src/types.ts index c48975c2fa..16aa757ac8 100644 --- a/fuzzer/src/types.ts +++ b/fuzzer/src/types.ts @@ -1,10 +1,4 @@ -import type { - PrimitiveTypeDecl as AstPrimitiveTypeDecl, - Type as AstType, - Expression as AstExpression, - TypeId as AstTypeId, - TypeDecl as AstTypeDecl, -} from "../../src/ast/ast"; +import type * as Ast from "../../src/ast/ast"; import { createSample, generateName, @@ -44,7 +38,7 @@ export type MapType = { export type StructField = { name: string; type: Type; - default?: fc.Arbitrary; + default?: fc.Arbitrary; }; /** Utility types used internally in the generator. */ @@ -127,7 +121,7 @@ export const SUPPORTED_STDLIB_TYPES: StdlibType[] = [ StdlibType.Int, ]; -function makePrimitiveType(name: string): AstPrimitiveTypeDecl { +function makePrimitiveType(name: string): Ast.PrimitiveTypeDecl { return { kind: "primitive_type_decl", id: nextId(), @@ -135,7 +129,7 @@ function makePrimitiveType(name: string): AstPrimitiveTypeDecl { loc: dummySrcInfoPrintable, }; } -function makeASTTypeRef(name: string): AstTypeId { +function makeASTTypeRef(name: string): Ast.TypeId { return { kind: "type_id", id: nextId(), @@ -154,12 +148,12 @@ function makeTypeRef(name: string): TypeRef { /** * Cache for Stdlib types. */ -const StdlibTypeCache: Map = +const StdlibTypeCache: Map = new Map(); Object.values(StdlibType).forEach((ty) => { StdlibTypeCache.set(ty, [ - transformTy(ty, makePrimitiveType), - transformTy(ty, makeASTTypeRef), + transformTy(ty, makePrimitiveType), + transformTy(ty, makeASTTypeRef), transformTy(ty, makeTypeRef), ]); }); @@ -173,7 +167,7 @@ function transformTy(ty: StdlibType, transform: (type: StdlibType) => T): T { } return transform(ty); } -export function tyToAstTypeDecl(ty: Type): AstTypeDecl { +export function tyToAstTypeDecl(ty: Type): Ast.TypeDecl { switch (ty.kind) { case "stdlib": { const result = StdlibTypeCache.get(ty.type); @@ -186,14 +180,14 @@ export function tyToAstTypeDecl(ty: Type): AstTypeDecl { throwTyError(ty); } } -export function tyToAstType(ty: Type, isBounced = false): AstType { +export function tyToAstType(ty: Type, isBounced = false): Ast.Type { const generateAstTypeId = (text: string) => ({ kind: "type_id", text, id: nextId(), loc: dummySrcInfoPrintable, - }) as AstTypeId; + }) as Ast.TypeId; switch (ty.kind) { case "stdlib": { @@ -205,7 +199,7 @@ export function tyToAstType(ty: Type, isBounced = false): AstType { } case "struct": case "message": { - const simpleType: AstTypeId = { + const simpleType: Ast.TypeId = { kind: "type_id", text: ty.name, id: nextId(), @@ -262,7 +256,7 @@ export function getReturnType(ty: FunctionType): Type { /** * Returns mock AST entries for types defined in standard library. */ -export function getStdlibTypes(): AstTypeDecl[] { +export function getStdlibTypes(): Ast.TypeDecl[] { return [...Object.values(StdlibType)].map((type) => makePrimitiveType(type), ); diff --git a/fuzzer/src/util.ts b/fuzzer/src/util.ts index 6f43bb5542..12d41c4d64 100644 --- a/fuzzer/src/util.ts +++ b/fuzzer/src/util.ts @@ -9,7 +9,7 @@ import fc from "fast-check"; import type { NamedScopeItemKind, Scope } from "./scope"; import { GlobalContext } from "./context"; import type { Type } from "./types"; -import type { Id as AstId, AstNode } from "../../src/ast/ast"; +import type * as Ast from "../../src/ast/ast"; import { nextId } from "./id"; import { getSrcInfo } from "../../src/grammar/src-info"; @@ -51,7 +51,7 @@ export function createProperty( // eslint-disable-next-line @typescript-eslint/no-invalid-void-type const enhancedPredicate = (...args: Ts): boolean | void => { args.forEach((arg) => { - GlobalContext.printSample(arg as AstNode); + GlobalContext.printSample(arg as Ast.AstNode); }); return originalPredicate(...args); }; @@ -153,9 +153,9 @@ export function generateName( } /** - * Generates AstId from string name and with new id. + * Generates Ast.Id from string name and with new id. */ -export function generateAstIdFromName(name: string): AstId { +export function generateAstIdFromName(name: string): Ast.Id { return { kind: "id", text: name, @@ -165,15 +165,15 @@ export function generateAstIdFromName(name: string): AstId { } /** - * Generates AstId. - * @param scope Current scope, from which AstId.text will be generated. + * Generates Ast.Id. + * @param scope Current scope, from which Ast.Id.text will be generated. * @param shadowing Allow shadowing (using names available in parent scopes) */ export function generateAstId( scope: Scope, shadowing: boolean = true, isType: boolean = false, -): fc.Arbitrary { +): fc.Arbitrary { return fc.record({ kind: fc.constant("id"), text: generateName(scope, shadowing, isType), diff --git a/fuzzer/test/compilation.spec.ts b/fuzzer/test/compilation.spec.ts index 74b03c2f80..537417198a 100644 --- a/fuzzer/test/compilation.spec.ts +++ b/fuzzer/test/compilation.spec.ts @@ -1,9 +1,6 @@ import { funcCompile } from "../../src/func/funcCompile"; import { posixNormalize } from "../../src/utils/filePath"; -import type { - Module as AstModule, - Contract as AstContract, -} from "../../src/ast/ast"; +import type * as Ast from "../../src/ast/ast"; import { writeFileSync } from "fs"; import * as path from "path"; import fc from "fast-check"; @@ -20,7 +17,7 @@ import { import { GlobalContext } from "../src/context"; import { getAstFactory } from "../../src/ast/ast-helpers"; -function getContract(program: AstModule): AstContract | undefined { +function getContract(program: Ast.Module): Ast.Contract | undefined { for (const entry of program.items) { if (entry.kind === "contract") { return entry; @@ -29,7 +26,7 @@ function getContract(program: AstModule): AstContract | undefined { return undefined; } -async function compileProgram(program: AstModule) { +async function compileProgram(program: Ast.Module) { await withNodeFS(async (vfs) => { const factoryAst = getAstFactory(); let ctx = createContext(program, factoryAst); diff --git a/fuzzer/test/testUtils.ts b/fuzzer/test/testUtils.ts index 042a3c0dba..e7a5f73918 100644 --- a/fuzzer/test/testUtils.ts +++ b/fuzzer/test/testUtils.ts @@ -1,7 +1,7 @@ import { CompilerContext } from "../../src/context/context"; import { createABI } from "../../src/generator/createABI"; import { writeProgram } from "../../src/generator/writeProgram"; -import type { Module as AstModule } from "../../src/ast/ast"; +import type * as Ast from "../../src/ast/ast"; import { openContext } from "../../src/context/store"; import { resolveAllocations } from "../../src/storage/resolveAllocation"; import { featureEnable } from "../../src/config/features"; @@ -14,7 +14,7 @@ import type { FactoryAst } from "../../src/ast/ast-helpers"; import { getParser } from "../../src/grammar"; export function createContext( - program: AstModule, + program: Ast.Module, factoryAst: FactoryAst, ): CompilerContext { let ctx = new CompilerContext(); From 6eb5e6f7bf13f3a508cdadcca66997c460297e3b Mon Sep 17 00:00:00 2001 From: jeshecdom Date: Fri, 4 Apr 2025 12:45:35 +0200 Subject: [PATCH 17/44] tests: Added expression stats script. --- fuzzer/src/formatter.ts | 599 ------------------ fuzzer/src/generators/index.ts | 8 - package.json | 1 + spell/cspell-list.txt | 1 + {fuzzer => src/test/fuzzer}/src/config.ts | 0 {fuzzer => src/test/fuzzer}/src/context.ts | 13 +- .../test/fuzzer}/src/generators/constant.ts | 12 +- .../test/fuzzer}/src/generators/contract.ts | 26 +- .../test/fuzzer}/src/generators/expression.ts | 51 +- .../test/fuzzer}/src/generators/field.ts | 16 +- .../test/fuzzer}/src/generators/function.ts | 19 +- .../test/fuzzer}/src/generators/generator.ts | 8 +- src/test/fuzzer/src/generators/index.ts | 17 + .../test/fuzzer}/src/generators/parameter.ts | 16 +- .../test/fuzzer}/src/generators/program.ts | 18 +- .../test/fuzzer}/src/generators/receiver.ts | 35 +- .../test/fuzzer}/src/generators/statement.ts | 19 +- .../test/fuzzer}/src/generators/struct.ts | 14 +- .../test/fuzzer}/src/generators/trait.ts | 23 +- {fuzzer => src/test/fuzzer}/src/id.ts | 0 {fuzzer => src/test/fuzzer}/src/scope.ts | 12 +- {fuzzer => src/test/fuzzer}/src/stdlib.ts | 13 +- {fuzzer => src/test/fuzzer}/src/types.ts | 30 +- {fuzzer => src/test/fuzzer}/src/util.ts | 49 +- .../test/fuzzer}/test/compilation.spec.ts | 20 +- src/test/fuzzer/test/expression-stats.ts | 276 ++++++++ .../test/fuzzer}/test/expression.spec.ts | 24 +- .../test/fuzzer}/test/program.spec.ts | 16 +- {fuzzer => src/test/fuzzer}/test/testUtils.ts | 34 +- tsconfig.eslint.json | 2 +- 30 files changed, 554 insertions(+), 818 deletions(-) delete mode 100644 fuzzer/src/formatter.ts delete mode 100644 fuzzer/src/generators/index.ts rename {fuzzer => src/test/fuzzer}/src/config.ts (100%) rename {fuzzer => src/test/fuzzer}/src/context.ts (88%) rename {fuzzer => src/test/fuzzer}/src/generators/constant.ts (92%) rename {fuzzer => src/test/fuzzer}/src/generators/contract.ts (86%) rename {fuzzer => src/test/fuzzer}/src/generators/expression.ts (96%) rename {fuzzer => src/test/fuzzer}/src/generators/field.ts (78%) rename {fuzzer => src/test/fuzzer}/src/generators/function.ts (92%) rename {fuzzer => src/test/fuzzer}/src/generators/generator.ts (82%) create mode 100644 src/test/fuzzer/src/generators/index.ts rename {fuzzer => src/test/fuzzer}/src/generators/parameter.ts (74%) rename {fuzzer => src/test/fuzzer}/src/generators/program.ts (91%) rename {fuzzer => src/test/fuzzer}/src/generators/receiver.ts (86%) rename {fuzzer => src/test/fuzzer}/src/generators/statement.ts (97%) rename {fuzzer => src/test/fuzzer}/src/generators/struct.ts (88%) rename {fuzzer => src/test/fuzzer}/src/generators/trait.ts (87%) rename {fuzzer => src/test/fuzzer}/src/id.ts (100%) rename {fuzzer => src/test/fuzzer}/src/scope.ts (97%) rename {fuzzer => src/test/fuzzer}/src/stdlib.ts (75%) rename {fuzzer => src/test/fuzzer}/src/types.ts (93%) rename {fuzzer => src/test/fuzzer}/src/util.ts (82%) rename {fuzzer => src/test/fuzzer}/test/compilation.spec.ts (87%) create mode 100644 src/test/fuzzer/test/expression-stats.ts rename {fuzzer => src/test/fuzzer}/test/expression.spec.ts (77%) rename {fuzzer => src/test/fuzzer}/test/program.spec.ts (81%) rename {fuzzer => src/test/fuzzer}/test/testUtils.ts (54%) diff --git a/fuzzer/src/formatter.ts b/fuzzer/src/formatter.ts deleted file mode 100644 index 4b185edcb0..0000000000 --- a/fuzzer/src/formatter.ts +++ /dev/null @@ -1,599 +0,0 @@ -import type * as Ast from "../../src/ast/ast"; - -/** - * PrettyPrinter class provides methods to format and indent Tact code. - */ -class PrettyPrinter { - /** - * @param indentLevel Initial level of indentation. - * @param indentSpaces Number of spaces per indentation level. - */ - constructor( - private indentLevel: number = 0, - private readonly indentSpaces: number = 2, - ) {} - - private increaseIndent() { - this.indentLevel += 1; - } - - private decreaseIndent() { - this.indentLevel -= 1; - } - - private indent(): string { - return " ".repeat(this.indentLevel * this.indentSpaces); - } - - ppAstPrimitive(primitive: Ast.PrimitiveTypeDecl): string { - return `${this.indent()}primitive ${primitive.name.text};`; - } - - // - // Types - // - - ppAstType(typeRef: Ast.Type): string { - switch (typeRef.kind) { - case "type_id": - return typeRef.text; - case "optional_type": - return `${this.ppAstType(typeRef.typeArg)}?`; - case "map_type": - return this.ppAstTypeRefMap(typeRef); - case "bounced_message_type": - return this.ppAstBouncedMessageType(typeRef); - } - } - - ppAstTypeRefMap(typeRef: Ast.MapType): string { - const keyAlias = typeRef.keyStorageType - ? ` as ${typeRef.keyStorageType.text}` - : ""; - const valueAlias = typeRef.valueStorageType - ? ` as ${typeRef.valueStorageType.text}` - : ""; - return `map<${typeRef.keyType.text}${keyAlias}, ${typeRef.valueType.text}${valueAlias}>`; - } - - ppAstBouncedMessageType(type: Ast.BouncedMessageType): string { - return `bounced<${type.messageType.text}>`; - } - - // - // Expressions - // - - ppAstOptionalId(id: Ast.OptionalId): string { - return "text" in id ? id.text : "_"; - } - - /** - * Returns precedence used in unary/binary operations. - * Lower number means higher precedence - */ - getPrecedence(kind: string, op?: string): number { - switch (kind) { - case "op_binary": - switch (op) { - case "||": - return 1; - case "&&": - return 2; - case "|": - return 3; - case "^": - return 4; - case "&": - return 5; - case "==": - case "!=": - return 6; - case "<": - case ">": - case "<=": - case ">=": - return 7; - case "+": - case "-": - return 8; - case "*": - case "/": - case "%": - return 9; - default: - return 11; - } - case "conditional": - case "op_call": - case "op_static_call": - return 0; - case "op_unary": - return 10; - default: - return 11; - } - } - - ppAstExpression( - expr: Ast.Expression, - parentPrecedence: number = 0, - ): string { - let result: string; - let currentPrecedence = this.getPrecedence(expr.kind); - - switch (expr.kind) { - case "op_binary": - currentPrecedence = this.getPrecedence(expr.kind, expr.op); - result = `${this.ppAstExpression(expr.left, currentPrecedence)} ${expr.op} ${this.ppAstExpression(expr.right, currentPrecedence)}`; - break; - case "op_unary": - currentPrecedence = this.getPrecedence(expr.kind, expr.op); - result = `${expr.op}${this.ppAstExpression(expr.operand, currentPrecedence)}`; - break; - case "field_access": - result = `${this.ppAstExpression(expr.aggregate, currentPrecedence)}.${expr.field.text}`; - break; - case "method_call": - result = `${this.ppAstExpression(expr.self, currentPrecedence)}.${expr.method.text}(${expr.args.map((arg) => this.ppAstExpression(arg, currentPrecedence)).join(", ")})`; - break; - case "static_call": - result = `${expr.function.text}(${expr.args.map((arg) => this.ppAstExpression(arg, currentPrecedence)).join(", ")})`; - break; - case "struct_instance": - result = `${expr.type.text}{${expr.args.map((x) => this.ppAstStructFieldInitializer(x)).join(", ")}}`; - break; - case "init_of": - result = `initOf ${expr.contract.text}(${expr.args.map((arg) => this.ppAstExpression(arg, currentPrecedence)).join(", ")})`; - break; - case "conditional": - result = `${this.ppAstExpression(expr.condition, currentPrecedence)} ? ${this.ppAstExpression(expr.thenBranch, currentPrecedence)} : ${this.ppAstExpression(expr.elseBranch, currentPrecedence)}`; - break; - case "number": - result = expr.value.toString(); - break; - case "id": - result = expr.text; - break; - case "boolean": - result = expr.value.toString(); - break; - case "simplified_string": - case "string": - result = `"${expr.value}"`; - break; - case "null": - result = "null"; - break; - default: - throw new Error(`Unsupported expression type: ${expr.kind}`); - } - - // Set parens when needed - if ( - parentPrecedence > 0 && - currentPrecedence > 0 && - currentPrecedence < parentPrecedence - ) { - result = `(${result})`; - } - - return result; - } - - ppAstStructFieldInitializer(param: Ast.StructFieldInitializer): string { - return `${param.field.text}: ${this.ppAstExpression(param.initializer)}`; - } - - // - // Program - // - - ppAstProgram(program: Ast.Module): string { - const entriesFormatted = program.items - .map((entry, index, array) => { - const formattedEntry = this.ppProgramItem(entry); - const nextEntry = array[index + 1]; - if ( - entry.kind === "constant_def" && - nextEntry.kind === "constant_def" - ) { - return formattedEntry; - } - return formattedEntry + "\n"; - }) - .join("\n"); - return entriesFormatted.trim(); - } - - ppProgramItem(item: Ast.ModuleItem): string { - switch (item.kind) { - case "struct_decl": - case "message_decl": - return this.ppAstStruct(item); - case "contract": - return this.ppAstContract(item); - case "primitive_type_decl": - return this.ppAstPrimitive(item); - case "function_def": - return this.ppAstFunction(item); - case "native_function_decl": - return this.ppAstNativeFunction(item); - case "trait": - return this.ppAstTrait(item); - case "constant_def": - return this.ppAstConstant(item); - default: - return `Unknown Program Item Type: ${item.kind}`; - } - } - - ppAstProgramImport(importItem: Ast.Import): string { - return `${this.indent()}import "${importItem.importPath.path.segments.join()}";`; - } - - ppAstStruct(struct: Ast.StructDecl | Ast.MessageDecl): string { - const typePrefix = - struct.kind === "message_decl" ? "message" : "struct"; - const prefixFormatted = - struct.kind === "message_decl" && struct.opcode !== undefined - ? this.ppAstExpression(struct.opcode) - : ""; - this.increaseIndent(); - const fieldsFormatted = struct.fields - .map((field) => this.ppAstField(field)) - .join("\n"); - this.decreaseIndent(); - return `${this.indent()}${typePrefix} ${prefixFormatted}${struct.name.text} {\n${fieldsFormatted}\n}`; - } - - ppAstTrait(trait: Ast.Trait): string { - const traitsFormatted = trait.traits.map((t) => t.text).join(", "); - const attrsRaw = trait.attributes - .map((attr) => `@${attr.type}("${attr.name.value}")`) - .join(" "); - const attrsFormatted = attrsRaw ? `${attrsRaw} ` : ""; - this.increaseIndent(); - const bodyFormatted = trait.declarations - .map((dec, index, array) => { - const formattedDec = this.ppTraitBody(dec); - const nextDec = array[index + 1]; - if ( - (dec.kind === "constant_def" && - nextDec.kind === "constant_def") || - (dec.kind === "constant_decl" && - nextDec.kind === "constant_decl") || - (dec.kind === "field_decl" && nextDec.kind === "field_decl") - ) { - return formattedDec; - } - return formattedDec + "\n"; - }) - .join("\n"); - const header = traitsFormatted - ? `trait ${trait.name.text} with ${traitsFormatted}` - : `trait ${trait.name.text}`; - this.decreaseIndent(); - return `${this.indent()}${attrsFormatted}${header} {\n${bodyFormatted}${this.indent()}}`; - } - - ppTraitBody(item: Ast.TraitDeclaration): string { - switch (item.kind) { - case "field_decl": - return this.ppAstField(item); - case "function_decl": - case "function_def": - return this.ppAstFunction(item); - case "receiver": - return this.ppAstReceive(item); - case "constant_decl": - case "constant_def": - return this.ppAstConstant(item); - default: - return `Unknown Trait Body Type: ${item.kind}`; - } - } - - ppAstField(field: Ast.FieldDecl): string { - const typeFormatted = this.ppAstType(field.type); - const initializer = field.initializer - ? ` = ${this.ppAstExpression(field.initializer)}` - : ""; - const asAlias = field.as ? ` as ${field.as.text}` : ""; - return `${this.indent()}${field.name.text}: ${typeFormatted}${asAlias}${initializer};`; - } - - ppAstConstant(constant: Ast.ConstantDecl | Ast.ConstantDef): string { - const valueFormatted = - constant.kind === "constant_def" - ? ` = ${this.ppAstExpression(constant.initializer)}` - : ""; - const attrsRaw = constant.attributes.map((attr) => attr.type).join(" "); - const attrsFormatted = attrsRaw ? `${attrsRaw} ` : ""; - return `${this.indent()}${attrsFormatted}const ${constant.name.text}: ${this.ppAstType(constant.type)}${valueFormatted};`; - } - - ppAstContract(contract: Ast.Contract): string { - const traitsFormatted = contract.traits - .map((trait) => trait.text) - .join(", "); - this.increaseIndent(); - const bodyFormatted = contract.declarations - .map((dec, index, array) => { - const formattedDec = this.ppContractBody(dec); - const nextDec = array[index + 1]; - if ( - (dec.kind === "constant_def" && - nextDec.kind === "constant_def") || - (dec.kind === "field_decl" && nextDec.kind === "field_decl") - ) { - return formattedDec; - } - return formattedDec + "\n"; - }) - .join("\n"); - this.decreaseIndent(); - const header = traitsFormatted - ? `contract ${contract.name.text} with ${traitsFormatted}` - : `contract ${contract.name.text}`; - const attrsRaw = contract.attributes - .map((attr) => `@interface("${attr.name.value}")`) - .join(" "); - const attrsFormatted = attrsRaw ? `${attrsRaw} ` : ""; - return `${this.indent()}${attrsFormatted}${header} {\n${bodyFormatted}${this.indent()}}`; - } - - ppContractBody(declaration: Ast.ContractDeclaration): string { - switch (declaration.kind) { - case "field_decl": - return this.ppAstField(declaration); - case "function_def": - return this.ppAstFunction(declaration); - case "contract_init": - return this.ppAstInitFunction(declaration); - case "receiver": - return this.ppAstReceive(declaration); - case "constant_def": - return this.ppAstConstant(declaration); - default: - return `Unknown Contract Body Type: ${declaration.kind}`; - } - } - - public ppAstFunction(func: Ast.FunctionDecl | Ast.FunctionDef): string { - const argsFormatted = func.params - .map( - (arg) => - `${this.ppAstOptionalId(arg.name)}: ${this.ppAstType(arg.type)}`, - ) - .join(", "); - const attrsRaw = func.attributes.map((attr) => attr.type).join(" "); - const attrsFormatted = attrsRaw ? `${attrsRaw} ` : ""; - const returnType = func.return - ? `: ${this.ppAstType(func.return)}` - : ""; - this.increaseIndent(); - const stmtsFormatted = - func.kind === "function_def" - ? func.statements - .map((stmt) => this.ppAstStatement(stmt)) - .join("\n") - : ""; - const body = - func.kind === "function_def" - ? ` {\n${stmtsFormatted}\n${this.indent()}}` - : ";"; - this.decreaseIndent(); - return `${this.indent()}${attrsFormatted}fun ${func.name.text}(${argsFormatted})${returnType}${body}`; - } - - ppAstReceive(receive: Ast.Receiver): string { - const header = this.ppAstReceiveHeader(receive); - const stmtsFormatted = this.ppStatementBlock(receive.statements); - return `${this.indent()}${header} ${stmtsFormatted}`; - } - - ppAstReceiveHeader(receive: Ast.Receiver): string { - if (receive.selector.kind === "bounce") - return `bounced(${this.ppAstOptionalId(receive.selector.param.name)}: ${this.ppAstType(receive.selector.param.type)})`; - const prefix = - receive.selector.kind === "internal" ? "receive" : "external"; - const suffix = - receive.selector.subKind.kind === "simple" - ? `(${this.ppAstOptionalId(receive.selector.subKind.param.name)}: ${this.ppAstType(receive.selector.subKind.param.type)})` - : receive.selector.subKind.kind === "fallback" - ? "()" - : `("${receive.selector.subKind.comment.value}")`; - return prefix + suffix; - } - - ppAstNativeFunction(func: Ast.NativeFunctionDecl): string { - const argsFormatted = func.params - .map( - (arg) => - `${this.ppAstOptionalId(arg.name)}: ${this.ppAstType(arg.type)}`, - ) - .join(", "); - const returnType = func.return - ? `: ${this.ppAstType(func.return)}` - : ""; - let attrs = func.attributes.map((attr) => attr.type).join(" "); - attrs = attrs ? attrs + " " : ""; - return `${this.indent()}@name(${func.nativeName.text})\n${this.indent()}${attrs}native ${func.name.text}(${argsFormatted})${returnType};`; - } - - ppAstInitFunction(initFunc: Ast.ContractInit): string { - const argsFormatted = initFunc.params - .map( - (arg) => - `${this.ppAstOptionalId(arg.name)}: ${this.ppAstType(arg.type)}`, - ) - .join(", "); - - this.increaseIndent(); - const stmtsFormatted = initFunc.statements - .map((stmt) => this.ppAstStatement(stmt)) - .join("\n"); - this.decreaseIndent(); - - return `${this.indent()}init(${argsFormatted}) {${stmtsFormatted === "" ? "" : "\n"}${stmtsFormatted}${stmtsFormatted === "" ? "" : "\n" + this.indent()}}`; - } - - // - // Statements - // - - ppAstStatement(stmt: Ast.Statement): string { - switch (stmt.kind) { - case "statement_let": - return this.ppAstStatementLet(stmt); - case "statement_return": - return this.ppAstStatementReturn(stmt); - case "statement_expression": - return this.ppAstStatementExpression(stmt); - case "statement_assign": - return this.ppAstStatementAssign(stmt); - case "statement_augmentedassign": - return this.ppAstStatementAugmentedAssign(stmt); - case "statement_condition": - return this.ppAstCondition(stmt); - case "statement_while": - return this.ppAstStatementWhile(stmt); - case "statement_until": - return this.ppAstStatementUntil(stmt); - case "statement_repeat": - return this.ppAstStatementRepeat(stmt); - case "statement_foreach": - return this.ppAstStatementForEach(stmt); - case "statement_try": - return this.ppAstStatementTry(stmt); - default: - return `Unsupported statement kind: ${stmt.kind}`; - } - } - - ppStatementBlock(statements: readonly Ast.Statement[]): string { - this.increaseIndent(); - const statementsFormatted = statements - .map((stmt) => this.ppAstStatement(stmt)) - .join("\n"); - this.decreaseIndent(); - const result = `{\n${statementsFormatted}\n${this.indent()}}`; - return result; - } - - ppAstStatementLet(statement: Ast.StatementLet): string { - const expression = this.ppAstExpression(statement.expression); - const tyAnnotation = - statement.type === undefined - ? "" - : `: ${this.ppAstType(statement.type)}`; - return `${this.indent()}let ${this.ppAstOptionalId(statement.name)}${tyAnnotation} = ${expression};`; - } - - ppAstStatementReturn(statement: Ast.StatementReturn): string { - const expression = statement.expression - ? this.ppAstExpression(statement.expression) - : ""; - return `${this.indent()}return ${expression};`; - } - - ppAstStatementExpression(statement: Ast.StatementExpression): string { - return `${this.indent()}${this.ppAstExpression(statement.expression)};`; - } - - ppAstStatementAssign(statement: Ast.StatementAssign): string { - return `${this.indent()}${this.ppAstExpression(statement.path)} = ${this.ppAstExpression(statement.expression)};`; - } - - ppAstStatementAugmentedAssign( - statement: Ast.StatementAugmentedAssign, - ): string { - return `${this.indent()}${this.ppAstExpression(statement.path)} ${statement.op}= ${this.ppAstExpression(statement.expression)};`; - } - - ppAstCondition(statement: Ast.StatementCondition): string { - const condition = this.ppAstExpression(statement.condition); - const trueBranch = this.ppStatementBlock(statement.trueStatements); - const falseBranch = statement.falseStatements - ? ` else ${this.ppStatementBlock(statement.falseStatements)}` - : ""; - return `${this.indent()}if (${condition}) ${trueBranch}${falseBranch}`; - } - - ppAstStatementWhile(statement: Ast.StatementWhile): string { - const condition = this.ppAstExpression(statement.condition); - const stmts = this.ppStatementBlock(statement.statements); - return `${this.indent()}while (${condition}) ${stmts}`; - } - - ppAstStatementRepeat(statement: Ast.StatementRepeat): string { - const condition = this.ppAstExpression(statement.iterations); - const stmts = this.ppStatementBlock(statement.statements); - return `${this.indent()}repeat (${condition}) ${stmts}`; - } - - ppAstStatementUntil(statement: Ast.StatementUntil): string { - const condition = this.ppAstExpression(statement.condition); - const stmts = this.ppStatementBlock(statement.statements); - return `${this.indent()}do ${stmts} until (${condition});`; - } - - ppAstStatementForEach(statement: Ast.StatementForEach): string { - const header = `foreach (${this.ppAstOptionalId(statement.keyName)}, ${(statement.valueName as Ast.Id).text} in ${this.ppAstExpression(statement.map)})`; - const body = this.ppStatementBlock(statement.statements); - return `${this.indent()}${header} ${body}`; - } - - ppAstStatementTry(statement: Ast.StatementTry): string { - const tryBody = this.ppStatementBlock(statement.statements); - const tryPrefix = `${this.indent()}try ${tryBody}`; - const catchSuffix = statement.catchBlock - ? ` catch (${this.ppAstOptionalId(statement.catchBlock.catchName)}) ${this.ppStatementBlock(statement.catchBlock.catchStatements)}` - : ""; - return tryPrefix + catchSuffix; - } -} - -/** - * Formats an Ast. node into a pretty-printed string representation. - * @param input The Ast. node to format. - * @returns A string that represents the formatted Ast. node. - */ -// eslint-disable-next-line @typescript-eslint/no-explicit-any -export function formatAst(input: Ast.AstNode): string { - const pp = new PrettyPrinter(); - switch (input.kind) { - case "module": - return pp.ppAstProgram(input); - case "op_binary": - case "op_unary": - case "field_access": - case "method_call": - case "static_call": - case "struct_instance": - case "init_of": - case "conditional": - case "number": - case "id": - case "boolean": - case "string": - case "null": - return pp.ppAstExpression(input); - case "struct_decl": - case "message_decl": - return pp.ppAstStruct(input); - case "constant_decl": - case "constant_def": - return pp.ppAstConstant(input); - case "function_decl": - case "function_def": - return pp.ppAstFunction(input); - case "contract": - return pp.ppAstContract(input); - case "trait": - return pp.ppAstTrait(input); - default: - throw new Error(`Unsupported Ast. type: ${input.kind}`); - } -} diff --git a/fuzzer/src/generators/index.ts b/fuzzer/src/generators/index.ts deleted file mode 100644 index 04e7240026..0000000000 --- a/fuzzer/src/generators/index.ts +++ /dev/null @@ -1,8 +0,0 @@ -export { ConstantDef, ConstantDecl } from "./constant"; -export { Field } from "./field"; -export { Contract } from "./contract"; -export { FunctionDef, FunctionDecl } from "./function"; -export { Program } from "./program"; -export { Expression, NonGenerativeExpressionParams } from "./expression"; -export { Statement } from "./statement"; -export { GenerativeEntity } from "./generator"; diff --git a/package.json b/package.json index 71fc5aee84..d2b2b058c4 100644 --- a/package.json +++ b/package.json @@ -34,6 +34,7 @@ "gen:contracts:test:map": "ts-node ./src/test/e2e-emulated/map-property-tests/generate.ts", "gen:contracts:all": "yarn gen:contracts:examples && yarn gen:contracts:test && yarn gen:contracts:benchmarks && yarn gen:contracts:test:map", "gen": "yarn gen:grammar && yarn gen:stdlib && yarn gen:func-js && yarn gen:contracts:all", + "fuzz:expressions:stats": "ts-node src/test/fuzzer/test/expression-stats.ts", "clean": "rm -fr dist", "cleanall": "rm -fr dist node_modules", "copy:stdlib": "ts-node src/stdlib/copy.build.ts", diff --git a/spell/cspell-list.txt b/spell/cspell-list.txt index ea19881718..cdf8561ed9 100644 --- a/spell/cspell-list.txt +++ b/spell/cspell-list.txt @@ -138,6 +138,7 @@ pinst POSIX postpack prando +preorder quadtree quadtrees RANDU diff --git a/fuzzer/src/config.ts b/src/test/fuzzer/src/config.ts similarity index 100% rename from fuzzer/src/config.ts rename to src/test/fuzzer/src/config.ts diff --git a/fuzzer/src/context.ts b/src/test/fuzzer/src/context.ts similarity index 88% rename from fuzzer/src/context.ts rename to src/test/fuzzer/src/context.ts index 60a5952e44..b2630654e9 100644 --- a/fuzzer/src/context.ts +++ b/src/test/fuzzer/src/context.ts @@ -1,8 +1,7 @@ -import JSONbig from "json-bigint"; - -import { formatAst } from "./formatter"; -import { FuzzConfig } from "./config"; -import type { AstNode } from "../../src/ast/ast"; +import { prettyPrint } from "@/ast/ast-printer"; +import { FuzzConfig } from "@/test/fuzzer/src/config"; +import type { AstNode } from "@/ast/ast"; +import { stringify } from "@/test/fuzzer/src/util"; /** * FuzzContext represents a stateful context that handles AST generation. @@ -53,9 +52,9 @@ export class FuzzContext { public format(value: AstNode, fmt = this.config.samplesFormat): string { switch (fmt) { case "json": - return JSONbig.stringify(value, null, 2); + return stringify(value, 2); case "ast": - return formatAst(value); + return prettyPrint(value); default: throw new Error( `Unsupported sample format: ${this.config.samplesFormat}`, diff --git a/fuzzer/src/generators/constant.ts b/src/test/fuzzer/src/generators/constant.ts similarity index 92% rename from fuzzer/src/generators/constant.ts rename to src/test/fuzzer/src/generators/constant.ts index 15c5e07607..2a5bd1264a 100644 --- a/fuzzer/src/generators/constant.ts +++ b/src/test/fuzzer/src/generators/constant.ts @@ -1,15 +1,15 @@ -import type * as Ast from "../../../src/ast/ast"; +import type * as Ast from "@/ast/ast"; import { generateAstIdFromName, createSample, generateAstId, generateName, dummySrcInfoPrintable, -} from "../util"; -import { tyToAstType } from "../types"; -import type { Type } from "../types"; -import type { Scope } from "../scope"; -import { NamedGenerativeEntity } from "./generator"; +} from "@/test/fuzzer/src/util"; +import { tyToAstType } from "@/test/fuzzer/src/types"; +import type { Type } from "@/test/fuzzer/src/types"; +import type { Scope } from "@/test/fuzzer/src/scope"; +import { NamedGenerativeEntity } from "@/test/fuzzer/src/generators/generator"; import fc from "fast-check"; diff --git a/fuzzer/src/generators/contract.ts b/src/test/fuzzer/src/generators/contract.ts similarity index 86% rename from fuzzer/src/generators/contract.ts rename to src/test/fuzzer/src/generators/contract.ts index b0b0ab06f1..19523c481b 100644 --- a/fuzzer/src/generators/contract.ts +++ b/src/test/fuzzer/src/generators/contract.ts @@ -1,16 +1,20 @@ -import type * as Ast from "../../../src/ast/ast"; -import { createSample, dummySrcInfoPrintable, generateAstId } from "../util"; -import { FunctionDef } from "./function"; -import type { Trait } from "./trait"; -import { Expression } from "./expression"; -import { Receive } from "./receiver"; -import { UtilType } from "../types"; -import type { FunctionType } from "../types"; -import { Scope } from "../scope"; -import { NamedGenerativeEntity } from "./generator"; +import type * as Ast from "@/ast/ast"; +import { + createSample, + dummySrcInfoPrintable, + generateAstId, +} from "@/test/fuzzer/src/util"; +import { FunctionDef } from "@/test/fuzzer/src/generators/function"; +import type { Trait } from "@/test/fuzzer/src/generators/trait"; +import { Expression } from "@/test/fuzzer/src/generators/expression"; +import { Receive } from "@/test/fuzzer/src/generators/receiver"; +import { UtilType } from "@/test/fuzzer/src/types"; +import type { FunctionType } from "@/test/fuzzer/src/types"; +import { Scope } from "@/test/fuzzer/src/scope"; +import { NamedGenerativeEntity } from "@/test/fuzzer/src/generators/generator"; import fc from "fast-check"; -import { Field } from "./field"; +import { Field } from "@/test/fuzzer/src/generators/field"; export interface ContractParameters { /** diff --git a/fuzzer/src/generators/expression.ts b/src/test/fuzzer/src/generators/expression.ts similarity index 96% rename from fuzzer/src/generators/expression.ts rename to src/test/fuzzer/src/generators/expression.ts index 2c5fc5f99f..abd959d4b9 100644 --- a/fuzzer/src/generators/expression.ts +++ b/src/test/fuzzer/src/generators/expression.ts @@ -1,23 +1,26 @@ -import type * as Ast from "../../../src/ast/ast"; -import JSONbig from "json-bigint"; +import type * as Ast from "@/ast/ast"; import fc from "fast-check"; -import { ConstantDecl, ConstantDef } from "./constant"; -import { Let, Statement } from "./statement"; -import { Field } from "./field"; +import { + ConstantDecl, + ConstantDef, +} from "@/test/fuzzer/src/generators/constant"; +import { Let, Statement } from "@/test/fuzzer/src/generators/statement"; +import { Field } from "@/test/fuzzer/src/generators/field"; import { randomBool, randomElement, packArbitraries, generateAstIdFromName, dummySrcInfoPrintable, -} from "../util"; + stringify, +} from "@/test/fuzzer/src/util"; import { GenerativeEntity, NamedGenerativeEntity, GenerativeEntityOpt, -} from "./generator"; -import { nextId } from "../id"; +} from "@/test/fuzzer/src/generators/generator"; +import { nextId } from "@/test/fuzzer/src/id"; import { StdlibType, tyToString, @@ -25,11 +28,11 @@ import { UtilType, throwTyError, makeFunctionTy, -} from "../types"; -import type { StructField, Type } from "../types"; -import { GlobalContext } from "../context"; -import type { Scope } from "../scope"; -import { FunctionDef } from "./function"; +} from "@/test/fuzzer/src/types"; +import type { StructField, Type } from "@/test/fuzzer/src/types"; +import { GlobalContext } from "@/test/fuzzer/src/context"; +import type { Scope } from "@/test/fuzzer/src/scope"; +import { FunctionDef } from "@/test/fuzzer/src/generators/function"; export function generateNumber( base?: Ast.NumberBase, @@ -70,18 +73,6 @@ function generateStringValue( : fc.constantFrom(constValue); } -export function generateSimplifiedString( - nonEmpty: boolean = false, - constValue?: string, -): fc.Arbitrary { - return fc.record({ - kind: fc.constant("simplified_string"), - id: fc.constant(nextId()), - value: generateStringValue(nonEmpty, constValue), - loc: fc.constant(dummySrcInfoPrintable), - }); -} - export function generateString( nonEmpty: boolean = false, constValue?: string, @@ -178,9 +169,7 @@ export function generateFunctionCallArgs( funScope: Scope, ): fc.Arbitrary[] { if (funTy.kind !== "function") { - throw new Error( - `Incorrect type for function: ${JSONbig.stringify(funTy)}`, - ); + throw new Error(`Incorrect type for function: ${stringify(funTy, 0)}`); } if (funTy.signature.length === 1) { return []; @@ -200,9 +189,7 @@ export function generateMethodCallArgs( methodScope: Scope, ): fc.Arbitrary[] { if (methodTy.kind !== "function") { - throw new Error( - `Incorrect type for method: ${JSONbig.stringify(methodTy)}`, - ); + throw new Error(`Incorrect type for method: ${stringify(methodTy, 0)}`); } if (methodTy.signature.length === 2) { return []; @@ -982,7 +969,7 @@ export class Expression extends GenerativeEntity { break; case "function": throw new Error( - `Cannot generate an expression from type: ${JSONbig.stringify(this.type)}`, + `Cannot generate an expression from type: ${stringify(this.type, 0)}`, ); } return expr; diff --git a/fuzzer/src/generators/field.ts b/src/test/fuzzer/src/generators/field.ts similarity index 78% rename from fuzzer/src/generators/field.ts rename to src/test/fuzzer/src/generators/field.ts index 764d049240..f09a3d5094 100644 --- a/fuzzer/src/generators/field.ts +++ b/src/test/fuzzer/src/generators/field.ts @@ -1,9 +1,13 @@ -import type * as Ast from "../../../src/ast/ast"; -import { createSample, dummySrcInfoPrintable, generateAstId } from "../util"; -import { tyToAstType } from "../types"; -import type { Type } from "../types"; -import type { Scope } from "../scope"; -import { NamedGenerativeEntity } from "./generator"; +import type * as Ast from "@/ast/ast"; +import { + createSample, + dummySrcInfoPrintable, + generateAstId, +} from "@/test/fuzzer/src/util"; +import { tyToAstType } from "@/test/fuzzer/src/types"; +import type { Type } from "@/test/fuzzer/src/types"; +import type { Scope } from "@/test/fuzzer/src/scope"; +import { NamedGenerativeEntity } from "@/test/fuzzer/src/generators/generator"; import fc from "fast-check"; diff --git a/fuzzer/src/generators/function.ts b/src/test/fuzzer/src/generators/function.ts similarity index 92% rename from fuzzer/src/generators/function.ts rename to src/test/fuzzer/src/generators/function.ts index b6d0348141..bf1f3f8010 100644 --- a/fuzzer/src/generators/function.ts +++ b/src/test/fuzzer/src/generators/function.ts @@ -1,4 +1,4 @@ -import type * as Ast from "../../../src/ast/ast"; +import type * as Ast from "@/ast/ast"; import { tyToAstType, StdlibType, @@ -6,18 +6,18 @@ import { getReturnType, isUnit, UtilType, -} from "../types"; -import type { FunctionType, Type } from "../types"; -import { Return } from "./statement"; -import { Parameter } from "./parameter"; -import { Scope } from "../scope"; +} from "@/test/fuzzer/src/types"; +import type { FunctionType, Type } from "@/test/fuzzer/src/types"; +import { Return } from "@/test/fuzzer/src/generators/statement"; +import { Parameter } from "@/test/fuzzer/src/generators/parameter"; +import { Scope } from "@/test/fuzzer/src/scope"; import { createSample, dummySrcInfoPrintable, generateAstId, generateAstIdFromName, -} from "../util"; -import { NamedGenerativeEntity } from "./generator"; +} from "@/test/fuzzer/src/util"; +import { NamedGenerativeEntity } from "@/test/fuzzer/src/generators/generator"; import fc from "fast-check"; @@ -37,6 +37,9 @@ function notHaveArguments(kind: FunctionKind, type: FunctionType): boolean { return type.signature.length === 1; } else { const firstArg = type.signature[0]; + if (typeof firstArg === "undefined") { + throw new Error(`unexpected 'undefined'`); + } return isThis(firstArg) && type.signature.length === 2; } } diff --git a/fuzzer/src/generators/generator.ts b/src/test/fuzzer/src/generators/generator.ts similarity index 82% rename from fuzzer/src/generators/generator.ts rename to src/test/fuzzer/src/generators/generator.ts index faae6579d8..cd34404ec9 100644 --- a/fuzzer/src/generators/generator.ts +++ b/src/test/fuzzer/src/generators/generator.ts @@ -1,7 +1,7 @@ -import type * as Ast from "../../../src/ast/ast"; -import { nextId } from "../id"; -import type { IDIdx } from "../id"; -import type { Type } from "../types"; +import type * as Ast from "@/ast/ast"; +import { nextId } from "@/test/fuzzer/src/id"; +import type { IDIdx } from "@/test/fuzzer/src/id"; +import type { Type } from "@/test/fuzzer/src/types"; import type fc from "fast-check"; diff --git a/src/test/fuzzer/src/generators/index.ts b/src/test/fuzzer/src/generators/index.ts new file mode 100644 index 0000000000..511a08ddfa --- /dev/null +++ b/src/test/fuzzer/src/generators/index.ts @@ -0,0 +1,17 @@ +export { + ConstantDef, + ConstantDecl, +} from "@/test/fuzzer/src/generators/constant"; +export { Field } from "@/test/fuzzer/src/generators/field"; +export { Contract } from "@/test/fuzzer/src/generators/contract"; +export { + FunctionDef, + FunctionDecl, +} from "@/test/fuzzer/src/generators/function"; +export { Program } from "@/test/fuzzer/src/generators/program"; +export { + Expression, + NonGenerativeExpressionParams, +} from "@/test/fuzzer/src/generators/expression"; +export { Statement } from "@/test/fuzzer/src/generators/statement"; +export { GenerativeEntity } from "@/test/fuzzer/src/generators/generator"; diff --git a/fuzzer/src/generators/parameter.ts b/src/test/fuzzer/src/generators/parameter.ts similarity index 74% rename from fuzzer/src/generators/parameter.ts rename to src/test/fuzzer/src/generators/parameter.ts index 7fa544cf46..e50895d065 100644 --- a/fuzzer/src/generators/parameter.ts +++ b/src/test/fuzzer/src/generators/parameter.ts @@ -1,9 +1,13 @@ -import type * as Ast from "../../../src/ast/ast"; -import { createSample, dummySrcInfoPrintable, generateAstId } from "../util"; -import { tyToAstType } from "../types"; -import type { Type } from "../types"; -import type { Scope } from "../scope"; -import { NamedGenerativeEntity } from "./generator"; +import type * as Ast from "@/ast/ast"; +import { + createSample, + dummySrcInfoPrintable, + generateAstId, +} from "@/test/fuzzer/src/util"; +import { tyToAstType } from "@/test/fuzzer/src/types"; +import type { Type } from "@/test/fuzzer/src/types"; +import type { Scope } from "@/test/fuzzer/src/scope"; +import { NamedGenerativeEntity } from "@/test/fuzzer/src/generators/generator"; import fc from "fast-check"; diff --git a/fuzzer/src/generators/program.ts b/src/test/fuzzer/src/generators/program.ts similarity index 91% rename from fuzzer/src/generators/program.ts rename to src/test/fuzzer/src/generators/program.ts index c468082a44..bfa93bd87c 100644 --- a/fuzzer/src/generators/program.ts +++ b/src/test/fuzzer/src/generators/program.ts @@ -1,4 +1,4 @@ -import type * as Ast from "../../../src/ast/ast"; +import type * as Ast from "@/ast/ast"; import { createSamplesArray, createSample, @@ -6,14 +6,14 @@ import { randomBool, randomElement, generateAstIdFromName, -} from "../util"; -import { TypeGen, UtilType, getStdlibTypes } from "../types"; -import { Contract } from "./contract"; -import { Message, Struct } from "./struct"; -import { Trait } from "./trait"; -import { Scope } from "../scope"; -import { NamedGenerativeEntity } from "./generator"; -import { getStdlibTraits } from "../stdlib"; +} from "@/test/fuzzer/src/util"; +import { TypeGen, UtilType, getStdlibTypes } from "@/test/fuzzer/src/types"; +import { Contract } from "@/test/fuzzer/src/generators/contract"; +import { Message, Struct } from "@/test/fuzzer/src/generators/struct"; +import { Trait } from "@/test/fuzzer/src/generators/trait"; +import { Scope } from "@/test/fuzzer/src/scope"; +import { NamedGenerativeEntity } from "@/test/fuzzer/src/generators/generator"; +import { getStdlibTraits } from "@/test/fuzzer/src/stdlib"; import fc from "fast-check"; diff --git a/fuzzer/src/generators/receiver.ts b/src/test/fuzzer/src/generators/receiver.ts similarity index 86% rename from fuzzer/src/generators/receiver.ts rename to src/test/fuzzer/src/generators/receiver.ts index c779687c86..4c93359280 100644 --- a/fuzzer/src/generators/receiver.ts +++ b/src/test/fuzzer/src/generators/receiver.ts @@ -1,20 +1,27 @@ -import type * as Ast from "../../../src/ast/ast"; -import { UtilType, StdlibType, isBouncedMessage } from "../types"; -import type { Type } from "../types"; -import { Scope } from "../scope"; -import { GenerativeEntity } from "./generator"; +import type * as Ast from "@/ast/ast"; +import { + UtilType, + StdlibType, + isBouncedMessage, +} from "@/test/fuzzer/src/types"; +import type { Type } from "@/test/fuzzer/src/types"; +import { Scope } from "@/test/fuzzer/src/scope"; +import { GenerativeEntity } from "@/test/fuzzer/src/generators/generator"; import { createSample, dummySrcInfoPrintable, randomBool, randomElement, -} from "../util"; -import { Expression, generateString } from "./expression"; -import { Parameter } from "./parameter"; -import { StatementExpression } from "./statement"; +} from "@/test/fuzzer/src/util"; +import { + Expression, + generateString, +} from "@/test/fuzzer/src/generators/expression"; +import { Parameter } from "@/test/fuzzer/src/generators/parameter"; +import { StatementExpression } from "@/test/fuzzer/src/generators/statement"; import fc from "fast-check"; -import { nextId } from "../id"; +import { nextId } from "@/test/fuzzer/src/id"; const RECEIVE_RETURN_TY: Type = { kind: "util", type: UtilType.Unit }; @@ -51,7 +58,7 @@ function generateInternalReceiverKind( subKind, id: fc.constant(nextId()), loc: fc.constant(dummySrcInfoPrintable), - }); + }) as fc.Arbitrary; } function generateExternalReceiverKind( @@ -62,7 +69,7 @@ function generateExternalReceiverKind( subKind, id: fc.constant(nextId()), loc: fc.constant(dummySrcInfoPrintable), - }); + }) as fc.Arbitrary; } /** @@ -90,7 +97,7 @@ export class Receive extends GenerativeEntity { StdlibType.String, ), }), - ); + ) as Type; const param = new Parameter(this.scope, ty); this.scope.addNamed("parameter", param); const internalSimple = generateInternalReceiverKind( @@ -117,7 +124,7 @@ export class Receive extends GenerativeEntity { param: param.generate(), id: fc.constant(nextId()), loc: fc.constant(dummySrcInfoPrintable), - }); + }) as fc.Arbitrary; } const internalFallback = generateInternalReceiverKind( diff --git a/fuzzer/src/generators/statement.ts b/src/test/fuzzer/src/generators/statement.ts similarity index 97% rename from fuzzer/src/generators/statement.ts rename to src/test/fuzzer/src/generators/statement.ts index 011e88ed4e..bf2a0a8af8 100644 --- a/fuzzer/src/generators/statement.ts +++ b/src/test/fuzzer/src/generators/statement.ts @@ -1,4 +1,4 @@ -import type * as Ast from "../../../src/ast/ast"; +import type * as Ast from "@/ast/ast"; import fc from "fast-check"; import { @@ -11,7 +11,7 @@ import { generateMethodCallArgs, generateThisID, generateFieldAccess, -} from "./expression"; +} from "@/test/fuzzer/src/generators/expression"; import { randomBool, createSample, @@ -21,12 +21,15 @@ import { generateAstId, generateAstIdFromName, dummySrcInfoPrintable, -} from "../util"; -import { GenerativeEntity, NamedGenerativeEntity } from "./generator"; -import { StdlibType, UtilType, tyToAstType } from "../types"; -import type { Type } from "../types"; -import { Scope } from "../scope"; -import type { NamedScopeItemKind } from "../scope"; +} from "@/test/fuzzer/src/util"; +import { + GenerativeEntity, + NamedGenerativeEntity, +} from "@/test/fuzzer/src/generators/generator"; +import { StdlibType, UtilType, tyToAstType } from "@/test/fuzzer/src/types"; +import type { Type } from "@/test/fuzzer/src/types"; +import { Scope } from "@/test/fuzzer/src/scope"; +import type { NamedScopeItemKind } from "@/test/fuzzer/src/scope"; /** Type all the imperative constructions have. */ const STMT_TY: Type = { kind: "util", type: UtilType.Unit }; diff --git a/fuzzer/src/generators/struct.ts b/src/test/fuzzer/src/generators/struct.ts similarity index 88% rename from fuzzer/src/generators/struct.ts rename to src/test/fuzzer/src/generators/struct.ts index 7f87e1f554..373278f331 100644 --- a/fuzzer/src/generators/struct.ts +++ b/src/test/fuzzer/src/generators/struct.ts @@ -1,14 +1,14 @@ -import type * as Ast from "../../../src/ast/ast"; -import { tyToString, throwTyError } from "../types"; -import type { Type, StructField } from "../types"; -import type { Scope } from "../scope"; -import { Field } from "./field"; +import type * as Ast from "@/ast/ast"; +import { tyToString, throwTyError } from "@/test/fuzzer/src/types"; +import type { Type, StructField } from "@/test/fuzzer/src/types"; +import type { Scope } from "@/test/fuzzer/src/scope"; +import { Field } from "@/test/fuzzer/src/generators/field"; import { dummySrcInfoPrintable, generateAstIdFromName, packArbitraries, -} from "../util"; -import { NamedGenerativeEntity } from "./generator"; +} from "@/test/fuzzer/src/util"; +import { NamedGenerativeEntity } from "@/test/fuzzer/src/generators/generator"; import fc from "fast-check"; diff --git a/fuzzer/src/generators/trait.ts b/src/test/fuzzer/src/generators/trait.ts similarity index 87% rename from fuzzer/src/generators/trait.ts rename to src/test/fuzzer/src/generators/trait.ts index b878d49ec9..0947116026 100644 --- a/fuzzer/src/generators/trait.ts +++ b/src/test/fuzzer/src/generators/trait.ts @@ -1,18 +1,21 @@ -import type * as Ast from "../../../src/ast/ast"; +import type * as Ast from "@/ast/ast"; import { createSample, dummySrcInfoPrintable, generateAstId, randomBool, -} from "../util"; -import { FunctionDecl } from "./function"; -import { Field } from "./field"; -import { ConstantDecl, ConstantDef } from "./constant"; -import { Expression } from "./expression"; -import { TypeGen, makeFunctionTy, UtilType } from "../types"; -import type { Type } from "../types"; -import { Scope } from "../scope"; -import { NamedGenerativeEntity } from "./generator"; +} from "@/test/fuzzer/src/util"; +import { FunctionDecl } from "@/test/fuzzer/src/generators/function"; +import { Field } from "@/test/fuzzer/src/generators/field"; +import { + ConstantDecl, + ConstantDef, +} from "@/test/fuzzer/src/generators/constant"; +import { Expression } from "@/test/fuzzer/src/generators/expression"; +import { TypeGen, makeFunctionTy, UtilType } from "@/test/fuzzer/src/types"; +import type { Type } from "@/test/fuzzer/src/types"; +import { Scope } from "@/test/fuzzer/src/scope"; +import { NamedGenerativeEntity } from "@/test/fuzzer/src/generators/generator"; import fc from "fast-check"; diff --git a/fuzzer/src/id.ts b/src/test/fuzzer/src/id.ts similarity index 100% rename from fuzzer/src/id.ts rename to src/test/fuzzer/src/id.ts diff --git a/fuzzer/src/scope.ts b/src/test/fuzzer/src/scope.ts similarity index 97% rename from fuzzer/src/scope.ts rename to src/test/fuzzer/src/scope.ts index 0b3ad259d8..6609f89357 100644 --- a/fuzzer/src/scope.ts +++ b/src/test/fuzzer/src/scope.ts @@ -1,9 +1,9 @@ -import type { Type } from "./types"; -import { getReturnType } from "./types"; -import type { IDIdx } from "./id"; -import type { GenerativeEntity } from "./generators"; -import type * as Ast from "../../src/ast/ast"; -import type { NamedGenerativeEntity } from "./generators/generator"; +import type { Type } from "@/test/fuzzer/src/types"; +import { getReturnType } from "@/test/fuzzer/src/types"; +import type { IDIdx } from "@/test/fuzzer/src/id"; +import type { GenerativeEntity } from "@/test/fuzzer/src/generators"; +import type * as Ast from "@/ast/ast"; +import type { NamedGenerativeEntity } from "@/test/fuzzer/src/generators/generator"; export type ScopeKind = | "program" diff --git a/fuzzer/src/stdlib.ts b/src/test/fuzzer/src/stdlib.ts similarity index 75% rename from fuzzer/src/stdlib.ts rename to src/test/fuzzer/src/stdlib.ts index 1d0f7b78aa..7c15de2a32 100644 --- a/fuzzer/src/stdlib.ts +++ b/src/test/fuzzer/src/stdlib.ts @@ -1,10 +1,13 @@ -import type * as Ast from "../../src/ast/ast"; -import { nextId } from "./id"; +import type * as Ast from "@/ast/ast"; +import { nextId } from "@/test/fuzzer/src/id"; import * as path from "path"; -import files from "../../src/stdlib/stdlib"; -import { createVirtualFileSystem } from "../../src/vfs/createVirtualFileSystem"; -import { dummySrcInfoPrintable, generateAstIdFromName } from "./util"; +import files from "@/stdlib/stdlib"; +import { createVirtualFileSystem } from "@/vfs/createVirtualFileSystem"; +import { + dummySrcInfoPrintable, + generateAstIdFromName, +} from "@/test/fuzzer/src/util"; const StdlibFilePath = path.join( __dirname, diff --git a/fuzzer/src/types.ts b/src/test/fuzzer/src/types.ts similarity index 93% rename from fuzzer/src/types.ts rename to src/test/fuzzer/src/types.ts index 16aa757ac8..a8048fdc62 100644 --- a/fuzzer/src/types.ts +++ b/src/test/fuzzer/src/types.ts @@ -1,4 +1,4 @@ -import type * as Ast from "../../src/ast/ast"; +import type * as Ast from "@/ast/ast"; import { createSample, generateName, @@ -6,12 +6,12 @@ import { randomBool, generateAstIdFromName, dummySrcInfoPrintable, -} from "./util"; -import type { Scope } from "./scope"; -import type { TypeRef } from "../../src/types/types"; -import JSONbig from "json-bigint"; + stringify, +} from "@/test/fuzzer/src/util"; +import type { Scope } from "@/test/fuzzer/src/scope"; +import type { TypeRef } from "@/types/types"; -import { nextId } from "./id"; +import { nextId } from "@/test/fuzzer/src/id"; import fc from "fast-check"; /** @@ -91,7 +91,7 @@ export type Type = // eslint-disable-next-line @typescript-eslint/no-explicit-any export function throwTyError(ty: any): never { - throw new Error(`Unsupported type: ${JSONbig.stringify(ty)}`); + throw new Error(`Unsupported type: ${stringify(ty, 0)}`); } export function tyToString(ty: Type): string { @@ -250,7 +250,11 @@ export function getReturnType(ty: FunctionType): Type { if (ty.signature.length === 0) { throw new Error("Empty function signature"); } - return ty.signature[ty.signature.length - 1]; + const result = ty.signature[ty.signature.length - 1]; + if (typeof result === "undefined") { + throw new Error("Unexpected 'undefined'"); + } + return result; } /** @@ -388,13 +392,13 @@ export class TypeGen { kind: fc.constant("message"), name: fc.constant(structName), fields: fields, - }); + }) as fc.Arbitrary; } else { return fc.record({ kind: fc.constant("struct"), name: fc.constant(structName), fields: fields, - }); + }) as fc.Arbitrary; } } @@ -424,7 +428,11 @@ export function makeFunctionTy( kind === "method" ? [{ kind: "util", type: UtilType.This }] : []; const args: Type[] = Array.from({ length: argsLength }, () => { const idx = randomInt(0, SUPPORTED_STDLIB_TYPES.length - 1); - return { kind: "stdlib", type: SUPPORTED_STDLIB_TYPES[idx] }; + const selectedType = SUPPORTED_STDLIB_TYPES[idx]; + if (typeof selectedType === "undefined") { + throw new Error("Unexpected 'undefined'"); + } + return { kind: "stdlib", type: selectedType }; }); return { kind: "function", signature: [...thisArg, ...args, returnTy] }; } diff --git a/fuzzer/src/util.ts b/src/test/fuzzer/src/util.ts similarity index 82% rename from fuzzer/src/util.ts rename to src/test/fuzzer/src/util.ts index 12d41c4d64..b267d54d66 100644 --- a/fuzzer/src/util.ts +++ b/src/test/fuzzer/src/util.ts @@ -1,17 +1,17 @@ import os from "os"; -import { createNodeFileSystem } from "../../src/vfs/createNodeFileSystem"; -import type { VirtualFileSystem } from "../../src/vfs/VirtualFileSystem"; +import { createNodeFileSystem } from "@/vfs/createNodeFileSystem"; +import type { VirtualFileSystem } from "@/vfs/VirtualFileSystem"; import { mkdtemp } from "fs/promises"; import fs from "fs/promises"; import * as path from "path"; import fc from "fast-check"; -import type { NamedScopeItemKind, Scope } from "./scope"; -import { GlobalContext } from "./context"; -import type { Type } from "./types"; -import type * as Ast from "../../src/ast/ast"; -import { nextId } from "./id"; -import { getSrcInfo } from "../../src/grammar/src-info"; +import type { NamedScopeItemKind, Scope } from "@/test/fuzzer/src/scope"; +import { GlobalContext } from "@/test/fuzzer/src/context"; +import type { Type } from "@/test/fuzzer/src/types"; +import type * as Ast from "@/ast/ast"; +import { nextId } from "@/test/fuzzer/src/id"; +import { getSrcInfo } from "@/grammar/src-info"; export const VALID_ID = /^[a-zA-Z_]+[a-zA-Z_0-9]$/; export const VALID_TYPE_ID = /^[A-Z]+[a-zA-Z_0-9]$/; @@ -67,13 +67,16 @@ function makeParams(numRuns: number | undefined): fc.Parameters { seed: GlobalContext.config.seed, reporter(out) { if (out.failed) { - if (out.counterexample !== null && out.error !== null) { + if ( + out.counterexample !== null && + out.errorInstance instanceof Error + ) { // eslint-disable-next-line @typescript-eslint/no-explicit-any let generated: any = out.counterexample; if (!generated.kind && generated[0]?.kind) { generated = generated[0]; } - out.error += `\n-----\nGenerated program:\n${GlobalContext.format(generated)}\n-----\n`; + out.errorInstance.message += `\n-----\nGenerated program:\n${GlobalContext.format(generated)}\n-----\n`; } throw new Error(fc.defaultReportMessage(out)); } @@ -107,10 +110,14 @@ export async function checkAsyncProperty( * @throws If the arbitrary cannot generate any elements. */ export function createSample(gen: fc.Arbitrary): T { - return fc.sample(gen, { + const result = fc.sample(gen, { seed: GlobalContext.config.seed, numRuns: 1, })[0]; + if (typeof result === "undefined") { + throw new Error("Unexpected 'undefined'"); + } + return result; } /** @@ -220,9 +227,17 @@ export function randomElement(list: T[]): T { throw new Error("Empty list"); } if (list.length === 1) { - return list[0]; + const result = list[0]; + if (typeof result === "undefined") { + throw new Error("Unexpected 'undefined'"); + } + return result; + } + const result = list[randomInt(1, list.length - 1)]; + if (typeof result === "undefined") { + throw new Error("Unexpected 'undefined'"); } - return list[randomInt(1, list.length - 1)]; + return result; } export function packArbitraries( @@ -232,3 +247,11 @@ export function packArbitraries( } export const dummySrcInfoPrintable = getSrcInfo(" ", 0, 0, null, "user"); + +export function stringify(obj: unknown, space: number): string { + return JSON.stringify( + obj, + (_, value) => (typeof value === "bigint" ? value.toString() : value), + space, + ); +} diff --git a/fuzzer/test/compilation.spec.ts b/src/test/fuzzer/test/compilation.spec.ts similarity index 87% rename from fuzzer/test/compilation.spec.ts rename to src/test/fuzzer/test/compilation.spec.ts index 537417198a..256acf47fc 100644 --- a/fuzzer/test/compilation.spec.ts +++ b/src/test/fuzzer/test/compilation.spec.ts @@ -1,21 +1,21 @@ -import { funcCompile } from "../../src/func/funcCompile"; -import { posixNormalize } from "../../src/utils/filePath"; -import type * as Ast from "../../src/ast/ast"; +import { funcCompile } from "@/func/funcCompile"; +import { posixNormalize } from "@/utils/filePath"; +import type * as Ast from "@/ast/ast"; import { writeFileSync } from "fs"; import * as path from "path"; import fc from "fast-check"; -import { Program } from "../src/generators"; -import { StdlibCode, StdlibPath } from "../src/stdlib"; -import { withNodeFS, checkAsyncProperty } from "../src/util"; +import { Program } from "@/test/fuzzer/src/generators"; +import { StdlibCode, StdlibPath } from "@/test/fuzzer/src/stdlib"; +import { withNodeFS, checkAsyncProperty } from "@/test/fuzzer/src/util"; import { compile, precompile, createContext, enableFeatures, -} from "./testUtils"; -import { GlobalContext } from "../src/context"; -import { getAstFactory } from "../../src/ast/ast-helpers"; +} from "@/test/fuzzer/test/testUtils"; +import { GlobalContext } from "@/test/fuzzer/src/context"; +import { getAstFactory } from "@/ast/ast-helpers"; function getContract(program: Ast.Module): Ast.Contract | undefined { for (const entry of program.items) { @@ -29,7 +29,7 @@ function getContract(program: Ast.Module): Ast.Contract | undefined { async function compileProgram(program: Ast.Module) { await withNodeFS(async (vfs) => { const factoryAst = getAstFactory(); - let ctx = createContext(program, factoryAst); + let ctx = createContext(program); ctx = enableFeatures(ctx, "external"); ctx = precompile(ctx, factoryAst); const compilationOutput = vfs.root; diff --git a/src/test/fuzzer/test/expression-stats.ts b/src/test/fuzzer/test/expression-stats.ts new file mode 100644 index 0000000000..0a4c81f25d --- /dev/null +++ b/src/test/fuzzer/test/expression-stats.ts @@ -0,0 +1,276 @@ +import type * as Ast from "@/ast/ast"; +import * as fc from "fast-check"; +import * as fs from "fs"; +import { Scope } from "@/test/fuzzer/src/scope"; +import { SUPPORTED_STDLIB_TYPES } from "@/test/fuzzer/src/types"; +import type { Type } from "@/test/fuzzer/src/types"; +import { + Expression, + NonGenerativeExpressionParams, +} from "@/test/fuzzer/src/generators"; +import path from "path"; + +/** + * AST utility functions + */ + +function getHeight(tree: Ast.Expression): number { + switch (tree.kind) { + case "address": + case "boolean": + case "cell": + case "id": + case "null": + case "number": + case "string": + case "slice": + case "code_of": + return 0; + case "init_of": { + const children = tree.args.map((arg) => getHeight(arg)); + return children.length === 0 ? 0 : Math.max(...children) + 1; + } + case "field_access": + return getHeight(tree.aggregate) + 1; + case "conditional": + return ( + Math.max( + getHeight(tree.condition), + getHeight(tree.thenBranch), + getHeight(tree.elseBranch), + ) + 1 + ); + case "method_call": + return ( + Math.max( + getHeight(tree.self), + ...tree.args.map((arg) => getHeight(arg)), + ) + 1 + ); + case "static_call": { + const children = tree.args.map((arg) => getHeight(arg)); + return children.length === 0 ? 0 : Math.max(...children) + 1; + } + case "struct_instance": { + const children = tree.args.map((init) => + getHeight(init.initializer), + ); + return children.length === 0 ? 0 : Math.max(...children) + 1; + } + case "struct_value": { + const children = tree.args.map((init) => + getHeight(init.initializer), + ); + return children.length === 0 ? 0 : Math.max(...children) + 1; + } + case "op_unary": + return getHeight(tree.operand) + 1; + case "op_binary": + return Math.max(getHeight(tree.left), getHeight(tree.right)) + 1; + } +} + +function countNodes(tree: Ast.Expression): number { + switch (tree.kind) { + case "address": + case "boolean": + case "cell": + case "id": + case "null": + case "number": + case "string": + case "slice": + case "code_of": + return 1; + case "init_of": + return sum(tree.args.map((arg) => countNodes(arg))) + 1; + case "field_access": + return countNodes(tree.aggregate) + 1; + case "conditional": + return ( + countNodes(tree.condition) + + countNodes(tree.thenBranch) + + countNodes(tree.elseBranch) + + 1 + ); + case "method_call": + return ( + countNodes(tree.self) + + sum(tree.args.map((arg) => countNodes(arg))) + + 1 + ); + case "static_call": + return sum(tree.args.map((arg) => countNodes(arg))) + 1; + case "struct_instance": + return ( + sum(tree.args.map((init) => countNodes(init.initializer))) + 1 + ); + case "struct_value": + return ( + sum(tree.args.map((init) => countNodes(init.initializer))) + 1 + ); + case "op_unary": + return countNodes(tree.operand) + 1; + case "op_binary": + return countNodes(tree.left) + countNodes(tree.right) + 1; + } +} + +function sum(items: number[]): number { + return items.reduce((prev, curr) => prev + curr, 0); +} + +function preorderTraversal(tree: Ast.Expression, accumulator: string[]) { + switch (tree.kind) { + case "address": + case "boolean": + case "cell": + case "id": + case "null": + case "number": + case "string": + case "slice": + case "code_of": { + accumulator.push(tree.kind); + break; + } + case "init_of": { + accumulator.push(tree.kind + "_" + tree.contract.text); + tree.args.forEach((arg) => { + preorderTraversal(arg, accumulator); + }); + break; + } + case "field_access": { + accumulator.push(tree.kind); + preorderTraversal(tree.aggregate, accumulator); + break; + } + case "conditional": { + accumulator.push(tree.kind); + preorderTraversal(tree.condition, accumulator); + preorderTraversal(tree.thenBranch, accumulator); + preorderTraversal(tree.elseBranch, accumulator); + break; + } + case "method_call": { + accumulator.push(tree.kind + "_" + tree.method.text); + preorderTraversal(tree.self, accumulator); + tree.args.forEach((arg) => { + preorderTraversal(arg, accumulator); + }); + break; + } + case "static_call": { + accumulator.push(tree.kind + "_" + tree.function.text); + tree.args.forEach((arg) => { + preorderTraversal(arg, accumulator); + }); + break; + } + case "struct_instance": { + accumulator.push( + tree.kind + "_" + tree.args.length + "_" + tree.type.text, + ); + tree.args.forEach((arg) => { + preorderTraversal(arg.initializer, accumulator); + }); + break; + } + case "struct_value": { + accumulator.push( + tree.kind + "_" + tree.args.length + "_" + tree.type.text, + ); + tree.args.forEach((arg) => { + preorderTraversal(arg.initializer, accumulator); + }); + break; + } + case "op_unary": { + accumulator.push(tree.kind + "_" + tree.op); + preorderTraversal(tree.operand, accumulator); + break; + } + case "op_binary": { + accumulator.push(tree.kind + "_" + tree.op); + preorderTraversal(tree.left, accumulator); + preorderTraversal(tree.right, accumulator); + break; + } + } +} + +function incrementKey( + key: K, + map: Map, + height: number, + size: number, +) { + const value = map.get(key); + if (value) { + const newVal = { + count: value.count + 1, + height: value.height, + size: value.size, + }; + map.set(key, newVal); + } else { + map.set(key, { + count: 1, + height, + size, + }); + } +} + +type TreeStats = { + count: number; + height: number; + size: number; +}; + +function getRows(dist: Map): string[] { + const rows: string[] = []; + for (const [_, stats] of dist) { + rows.push(`${stats.count} ${stats.height} ${stats.size}`); + } + return rows; +} + +function statistics( + gen: fc.Arbitrary, + numberOfSamples: number, + fileName: string, +) { + const trees = fc.sample(gen, numberOfSamples); + + const totalPreTraversals: Map = new Map(); + + for (const tree of trees) { + const preTraversal: string[] = []; + preorderTraversal(tree, preTraversal); + const treeName = preTraversal.join("@"); + const height = getHeight(tree); + const size = countNodes(tree); + incrementKey(treeName, totalPreTraversals, height, size); + } + + fs.writeFileSync(fileName, getRows(totalPreTraversals).join("\n")); +} + +function main() { + const globalScope = new Scope("program", undefined); + const generator = fc + .constantFrom(...SUPPORTED_STDLIB_TYPES) + .chain((type) => { + const ty: Type = { kind: "stdlib", type }; + return new Expression( + globalScope, + ty, + NonGenerativeExpressionParams, + ).generate(); + }); + statistics(generator, 50000, path.join(__dirname, "counts.txt")); +} + +main(); diff --git a/fuzzer/test/expression.spec.ts b/src/test/fuzzer/test/expression.spec.ts similarity index 77% rename from fuzzer/test/expression.spec.ts rename to src/test/fuzzer/test/expression.spec.ts index 5f3a8e643a..b655aadd49 100644 --- a/fuzzer/test/expression.spec.ts +++ b/src/test/fuzzer/test/expression.spec.ts @@ -1,21 +1,21 @@ -import { CompilerContext } from "../../src/context/context"; -import { - resolveExpression, - getExpType, -} from "../../src/types/resolveExpression"; -import type { StatementContext } from "../../src/types/resolveStatements"; -import type { TypeRef } from "../../src/types/types"; +import { CompilerContext } from "@/context/context"; +import { resolveExpression, getExpType } from "@/types/resolveExpression"; +import type { StatementContext } from "@/types/resolveStatements"; +import type { TypeRef } from "@/types/types"; import assert from "assert"; -import { Expression, NonGenerativeExpressionParams } from "../src/generators"; -import { Scope } from "../src/scope"; -import { SUPPORTED_STDLIB_TYPES } from "../src/types"; -import type { Type } from "../src/types"; +import { + Expression, + NonGenerativeExpressionParams, +} from "@/test/fuzzer/src/generators"; +import { Scope } from "@/test/fuzzer/src/scope"; +import { SUPPORTED_STDLIB_TYPES } from "@/test/fuzzer/src/types"; +import type { Type } from "@/test/fuzzer/src/types"; import { createProperty, checkProperty, dummySrcInfoPrintable, -} from "../src/util"; +} from "@/test/fuzzer/src/util"; function emptyContext(): StatementContext { return { diff --git a/fuzzer/test/program.spec.ts b/src/test/fuzzer/test/program.spec.ts similarity index 81% rename from fuzzer/test/program.spec.ts rename to src/test/fuzzer/test/program.spec.ts index 2e197d113f..63c6386545 100644 --- a/fuzzer/test/program.spec.ts +++ b/src/test/fuzzer/test/program.spec.ts @@ -1,10 +1,14 @@ -import { Program } from "../src/generators"; +import { Program } from "@/test/fuzzer/src/generators"; import assert from "assert"; -import { precompile, createContext, enableFeatures } from "./testUtils"; -import { createProperty, checkProperty } from "../src/util"; -import { GlobalContext } from "../src/context"; -import { getAstFactory } from "../../src/ast/ast-helpers"; +import { + precompile, + createContext, + enableFeatures, +} from "@/test/fuzzer/test/testUtils"; +import { createProperty, checkProperty } from "@/test/fuzzer/src/util"; +import { GlobalContext } from "@/test/fuzzer/src/context"; +import { getAstFactory } from "@/ast/ast-helpers"; describe("properties", () => { it("generates well-typed programs", () => { @@ -12,7 +16,7 @@ describe("properties", () => { new Program({ addStdlib: true }).generate(), (program) => { const factoryAst = getAstFactory(); - let ctx = createContext(program, factoryAst); + let ctx = createContext(program); ctx = enableFeatures(ctx, "external"); precompile(ctx, factoryAst); GlobalContext.resetDepth(); diff --git a/fuzzer/test/testUtils.ts b/src/test/fuzzer/test/testUtils.ts similarity index 54% rename from fuzzer/test/testUtils.ts rename to src/test/fuzzer/test/testUtils.ts index e7a5f73918..86e0d94fa1 100644 --- a/fuzzer/test/testUtils.ts +++ b/src/test/fuzzer/test/testUtils.ts @@ -1,28 +1,24 @@ -import { CompilerContext } from "../../src/context/context"; -import { createABI } from "../../src/generator/createABI"; -import { writeProgram } from "../../src/generator/writeProgram"; -import type * as Ast from "../../src/ast/ast"; -import { openContext } from "../../src/context/store"; -import { resolveAllocations } from "../../src/storage/resolveAllocation"; -import { featureEnable } from "../../src/config/features"; -import { resolveDescriptors } from "../../src/types/resolveDescriptors"; -import { resolveSignatures } from "../../src/types/resolveSignatures"; -import { resolveStatements } from "../../src/types/resolveStatements"; -import { evalComptimeExpressions } from "../../src/types/evalComptimeExpressions"; -import { resolveErrors } from "../../src/types/resolveErrors"; -import type { FactoryAst } from "../../src/ast/ast-helpers"; -import { getParser } from "../../src/grammar"; +import { CompilerContext } from "@/context/context"; +import { createABI } from "@/generator/createABI"; +import { writeProgram } from "@/generator/writeProgram"; +import type * as Ast from "@/ast/ast"; +import { openContext } from "@/context/store"; +import { resolveAllocations } from "@/storage/resolveAllocation"; +import { featureEnable } from "@/config/features"; +import { resolveDescriptors } from "@/types/resolveDescriptors"; +import { resolveSignatures } from "@/types/resolveSignatures"; +import { resolveStatements } from "@/types/resolveStatements"; +import { evalComptimeExpressions } from "@/types/evalComptimeExpressions"; +import { resolveErrors } from "@/types/resolveErrors"; +import type { FactoryAst } from "@/ast/ast-helpers"; -export function createContext( - program: Ast.Module, - factoryAst: FactoryAst, -): CompilerContext { +export function createContext(program: Ast.Module): CompilerContext { let ctx = new CompilerContext(); ctx = openContext( ctx, /*sources=*/ [], /*funcSources=*/ [], - getParser(factoryAst), + //getParser(factoryAst), [program], ); return ctx; diff --git a/tsconfig.eslint.json b/tsconfig.eslint.json index 38efeeb25e..851c8fd4a7 100644 --- a/tsconfig.eslint.json +++ b/tsconfig.eslint.json @@ -4,6 +4,6 @@ "noImplicitReturns": false /* Report error when not all code paths in function return a value. */, "noUncheckedIndexedAccess": false /* Include 'undefined' in index signature results */ }, - "include": ["src/", "examples/", "scripts/", "fuzzer/"], + "include": ["src/", "examples/", "scripts/"], "exclude": ["**/*.bind.ts", "src/test/**/output/**/*"] } From ac21810df0b3bf4b2225c649ecd5b47a04b68570 Mon Sep 17 00:00:00 2001 From: jeshecdom Date: Fri, 4 Apr 2025 14:17:15 +0200 Subject: [PATCH 18/44] tests: added column titles in counts file. --- src/test/fuzzer/test/expression-stats.ts | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/src/test/fuzzer/test/expression-stats.ts b/src/test/fuzzer/test/expression-stats.ts index 0a4c81f25d..4f7504345d 100644 --- a/src/test/fuzzer/test/expression-stats.ts +++ b/src/test/fuzzer/test/expression-stats.ts @@ -255,7 +255,10 @@ function statistics( incrementKey(treeName, totalPreTraversals, height, size); } - fs.writeFileSync(fileName, getRows(totalPreTraversals).join("\n")); + fs.writeFileSync( + fileName, + `count height size\n${getRows(totalPreTraversals).join("\n")}`, + ); } function main() { From fa1296295e7983dee36e0bd037e10606bcd7f65d Mon Sep 17 00:00:00 2001 From: jeshecdom Date: Tue, 8 Apr 2025 19:05:47 +0200 Subject: [PATCH 19/44] tests: build functions for contracts. --- cspell.json | 1 + .../fuzzer/src/minimal-fc-stdlib/stdlib.fc | 61 ++++ src/test/fuzzer/src/util.ts | 273 +++++++++++++++++- 3 files changed, 333 insertions(+), 2 deletions(-) create mode 100644 src/test/fuzzer/src/minimal-fc-stdlib/stdlib.fc diff --git a/cspell.json b/cspell.json index 275dd7138c..29b53a9988 100644 --- a/cspell.json +++ b/cspell.json @@ -53,6 +53,7 @@ "src/test/exit-codes/contracts/compute-phase-errors.tact", "src/test/e2e-emulated/map-property-tests/map-properties-key-value-types.ts", "src/test/e2e-emulated/map-property-tests/build", + "src/test/fuzzer/src/minimal-fc-stdlib/stdlib.fc", "/docs", "src/benchmarks/contracts/func/notcoin/stdlib-custom.fc", "src/benchmarks/contracts/func/notcoin/gas.fc", diff --git a/src/test/fuzzer/src/minimal-fc-stdlib/stdlib.fc b/src/test/fuzzer/src/minimal-fc-stdlib/stdlib.fc new file mode 100644 index 0000000000..95acd5b2c5 --- /dev/null +++ b/src/test/fuzzer/src/minimal-fc-stdlib/stdlib.fc @@ -0,0 +1,61 @@ +cell get_data() asm "c4 PUSH"; + +slice begin_parse(cell c) asm "CTOS"; + +slice skip_bits(slice s, int len) asm "SDSKIPFIRST"; +(slice, ()) ~skip_bits(slice s, int len) asm "SDSKIPFIRST"; + +int slice_bits(slice s) asm "SBITS"; + +(slice, slice) load_msg_addr(slice s) asm(-> 1 0) "LDMSGADDR"; + +forall X -> X null() asm "PUSHNULL"; + +(slice, cell) load_ref(slice s) asm(-> 1 0) "LDREF"; + +builder begin_cell() asm "NEWC"; + +() set_data(cell c) impure asm "c4 POP"; + +cell end_cell(builder b) asm "ENDC"; + +builder store_dict(builder b, cell c) asm(c b) "STDICT"; + +(slice, cell) load_dict(slice s) asm(-> 1 0) "LDDICT"; + +(cell, int) idict_delete?(cell dict, int key_len, int index) asm(index dict key_len) "DICTIDEL"; +(slice, int) idict_get?(cell dict, int key_len, int index) asm(index dict key_len) "DICTIGET" "NULLSWAPIFNOT"; + +cell idict_set(cell dict, int key_len, int index, slice value) asm(value index dict key_len) "DICTISET"; +(cell, ()) ~idict_set(cell dict, int key_len, int index, slice value) asm(value index dict key_len) "DICTISET"; + +cell idict_set_ref(cell dict, int key_len, int index, cell value) asm(value index dict key_len) "DICTISETREF"; +(cell, ()) ~idict_set_ref(cell dict, int key_len, int index, cell value) asm(value index dict key_len) "DICTISETREF"; + +(cell, int) idict_get_ref?(cell dict, int key_len, int index) asm(index dict key_len) "DICTIGETREF" "NULLSWAPIFNOT"; + +cell idict_set_builder(cell dict, int key_len, int index, builder value) asm(value index dict key_len) "DICTISETB"; +(cell, ()) ~idict_set_builder(cell dict, int key_len, int index, builder value) asm(value index dict key_len) "DICTISETB"; +cell dict_set_builder(cell dict, int key_len, slice index, builder value) asm(value index dict key_len) "DICTSETB"; +(cell, ()) ~dict_set_builder(cell dict, int key_len, slice index, builder value) asm(value index dict key_len) "DICTSETB"; + +(slice, int) load_coins(slice s) asm(-> 1 0) "LDVARUINT16"; +builder store_coins(builder b, int x) asm "STVARUINT16"; + +(slice, int) load_varuint16(slice s) asm(-> 1 0) "LDVARUINT16"; + +builder store_slice(builder b, slice s) asm "STSLICER"; + +(slice, int) udict_get?(cell dict, int key_len, int index) asm(index dict key_len) "DICTUGET" "NULLSWAPIFNOT"; +(cell, int) udict_delete?(cell dict, int key_len, int index) asm(index dict key_len) "DICTUDEL"; + +cell udict_set_builder(cell dict, int key_len, int index, builder value) asm(value index dict key_len) "DICTUSETB"; +(cell, ()) ~udict_set_builder(cell dict, int key_len, int index, builder value) asm(value index dict key_len) "DICTUSETB"; + +cell udict_set(cell dict, int key_len, int index, slice value) asm(value index dict key_len) "DICTUSET"; +(cell, ()) ~udict_set(cell dict, int key_len, int index, slice value) asm(value index dict key_len) "DICTUSET"; + +(cell, int) udict_get_ref?(cell dict, int key_len, int index) asm(index dict key_len) "DICTUGETREF" "NULLSWAPIFNOT"; + +cell udict_set_ref(cell dict, int key_len, int index, cell value) asm(value index dict key_len) "DICTUSETREF"; +(cell, ()) ~udict_set_ref(cell dict, int key_len, int index, cell value) asm(value index dict key_len) "DICTUSETREF"; \ No newline at end of file diff --git a/src/test/fuzzer/src/util.ts b/src/test/fuzzer/src/util.ts index b267d54d66..9d87349ee1 100644 --- a/src/test/fuzzer/src/util.ts +++ b/src/test/fuzzer/src/util.ts @@ -2,7 +2,7 @@ import os from "os"; import { createNodeFileSystem } from "@/vfs/createNodeFileSystem"; import type { VirtualFileSystem } from "@/vfs/VirtualFileSystem"; import { mkdtemp } from "fs/promises"; -import fs from "fs/promises"; +import * as fs from "fs"; import * as path from "path"; import fc from "fast-check"; @@ -12,6 +12,33 @@ import type { Type } from "@/test/fuzzer/src/types"; import type * as Ast from "@/ast/ast"; import { nextId } from "@/test/fuzzer/src/id"; import { getSrcInfo } from "@/grammar/src-info"; +import type { FactoryAst } from "@/ast/ast-helpers"; +import { idText } from "@/ast/ast-helpers"; +import { CompilerContext } from "@/context/context"; +import { getParser } from "@/grammar"; +import { createVirtualFileSystem } from "@/vfs/createVirtualFileSystem"; +import files from "@/stdlib/stdlib"; +import { resolveImports } from "@/imports/resolveImports"; +import { getRawAST, openContext, parseModules } from "@/context/store"; +import type { MakeAstFactory } from "@/ast/generated/make-factory"; +import { precompile } from "@/pipeline/precompile"; +import { getAllTypes } from "@/types/resolveDescriptors"; +import { topSortContracts } from "@/pipeline/utils"; +import { featureEnable } from "@/config/features"; +import { posixNormalize } from "@/utils/filePath"; +import { compile } from "@/pipeline/compile"; +import { funcCompile } from "@/func/funcCompile"; +import { Logger } from "@/context/logger"; +import { beginCell, Cell, contractAddress, TupleBuilder } from "@ton/core"; +import type { + StateInit, + Address, + Contract, + ContractProvider, + Sender, + TupleItem, +} from "@ton/core"; +import type { Blockchain, SandboxContract } from "@ton/sandbox"; export const VALID_ID = /^[a-zA-Z_]+[a-zA-Z_0-9]$/; export const VALID_TYPE_ID = /^[A-Z]+[a-zA-Z_0-9]$/; @@ -28,7 +55,7 @@ export async function withNodeFS(f: (vfs: VirtualFileSystem) => Promise) { await f(vfs); } finally { if (GlobalContext.config.compileDir == os.tmpdir()) { - await fs.rm(tempDir, { recursive: true }); + await fs.promises.rm(tempDir, { recursive: true }); } } } @@ -255,3 +282,245 @@ export function stringify(obj: unknown, space: number): string { space, ); } + +/*** + * Utility functions for compiling contracts and sandbox them + */ + +export function parseStandardLibrary(astF: FactoryAst): CompilerContext { + let ctx = new CompilerContext(); + const parser = getParser(astF); + const fileSystem = { + [`contracts/empty.tact`]: "", + }; + const project = createVirtualFileSystem("/", fileSystem, false); + const stdlib = createVirtualFileSystem("@stdlib", files); + + const imported = resolveImports({ + entrypoint: "contracts/empty.tact", + project, + stdlib, + parser, + }); + + // Add information about all the source code entries to the context + ctx = openContext( + ctx, + imported.tact, + imported.func, + parseModules(imported.tact, getParser(astF)), + ); + + return ctx; +} + +export function filterStdlib( + ctx: CompilerContext, + mF: MakeAstFactory, + names: Set, +): CustomStdlib { + const result: Ast.ModuleItem[] = []; + + const rawAst = getRawAST(ctx); + + for (const c of rawAst.constants) { + if (names.has(idText(c.name))) { + result.push(c); + } + } + + for (const f of rawAst.functions) { + if (names.has(idText(f.name))) { + result.push(f); + } + } + + for (const t of rawAst.types) { + if (names.has(idText(t.name))) { + result.push(t); + } + } + + const customTactStdlib = mF.makeModule([], result); + const stdlib_fc = fs + .readFileSync(path.join(__dirname, "minimal-fc-stdlib", "stdlib.fc")) + .toString("base64"); + + return { + modules: [customTactStdlib], + stdlib_fc: stdlib_fc, + stdlib_ex_fc: "", + }; +} + +export type CustomStdlib = { + // Parsed modules of Tact stdlib + modules: Ast.Module[]; + // Contents of the stdlib.fc file + stdlib_fc: string; + // Contents of the stdlib_ex.fc file + stdlib_ex_fc: string; +}; + +// If flag useCustomStdlib is false, it will parse the entire stdlib. Otherwise, +// it will use the provided data in CustomStdlib. +export async function buildModule( + astF: FactoryAst, + module: Ast.Module, + customStdlib: CustomStdlib, + blockchain: Blockchain, +): Promise>> { + let ctx = new CompilerContext(); + const parser = getParser(astF); + // We need an entrypoint for precompile, even if it is empty + const fileSystem = { + [`contracts/empty.tact`]: "", + }; + const minimalStdlib = { + // Needed by precompile, but we set its contents to be empty + ["std/stdlib.tact"]: "", + // These two func files are needed during tvm compilation + ["std/stdlib_ex.fc"]: customStdlib.stdlib_ex_fc, + ["std/stdlib.fc"]: customStdlib.stdlib_fc, + }; + + const project = createVirtualFileSystem("/", fileSystem, false); + const stdlib = createVirtualFileSystem("@stdlib", minimalStdlib); + + const config = { + name: "test", + path: "contracts/empty.tact", + output: ".", + }; + + const contractsToTest: Map< + string, + SandboxContract + > = new Map(); + + ctx = precompile(ctx, project, stdlib, config.path, parser, astF, [ + module, + ...customStdlib.modules, + ]); + + const built: Record< + string, + | { + codeBoc: Buffer; + abi: string; + } + | undefined + > = {}; + + const allContracts = getAllTypes(ctx).filter((v) => v.kind === "contract"); + + // Sort contracts in topological order + // If a cycle is found, return undefined + const sortedContracts = topSortContracts(allContracts); + if (sortedContracts !== undefined) { + ctx = featureEnable(ctx, "optimizedChildCode"); + } + for (const contract of sortedContracts ?? allContracts) { + const contractName = contract.name; + + // Compiling contract to func + const res = await compile( + ctx, + contractName, + `${config.name}_${contractName}`, + built, + ); + const codeFc = res.output.files.map((v) => ({ + path: posixNormalize(project.resolve(config.output, v.name)), + content: v.code, + })); + const codeEntrypoint = res.output.entrypoint; + + // Compiling contract to TVM + const stdlibPath = stdlib.resolve("std/stdlib.fc"); + const stdlibCode = stdlib.readFile(stdlibPath).toString(); + const stdlibExPath = stdlib.resolve("std/stdlib_ex.fc"); + const stdlibExCode = stdlib.readFile(stdlibExPath).toString(); + + const c = await funcCompile({ + entries: [ + stdlibPath, + stdlibExPath, + posixNormalize(project.resolve(config.output, codeEntrypoint)), + ], + sources: [ + { + path: stdlibPath, + content: stdlibCode, + }, + { + path: stdlibExPath, + content: stdlibExCode, + }, + ...codeFc, + ], + logger: new Logger(), + }); + + if (!c.ok) { + throw new Error(c.log); + } + + // Add to built map + built[contractName] = { + codeBoc: c.output, + abi: "", + }; + + contractsToTest.set( + contractName, + blockchain.openContract( + new ProxyContract(getContractStateInit(c.output)), + ), + ); + } + + return contractsToTest; +} + +function getContractStateInit(contractCode: Buffer): StateInit { + const data = beginCell().storeUint(0, 1).endCell(); + const code = Cell.fromBoc(contractCode)[0]; + if (typeof code === "undefined") { + throw new Error("Code cell expected"); + } + return { code, data }; +} + +export class ProxyContract implements Contract { + address: Address; + init: StateInit; + + constructor(stateInit: StateInit) { + this.address = contractAddress(0, stateInit); + this.init = stateInit; + } + + async send( + provider: ContractProvider, + via: Sender, + args: { value: bigint; bounce?: boolean | null | undefined }, + body: Cell, + ) { + await provider.internal(via, { ...args, body: body }); + } + + async getInt(provider: ContractProvider) { + const builder = new TupleBuilder(); + const result = (await provider.get("getInt", builder.build())).stack; + return result.readBigNumber(); + } + + async getGeneric( + provider: ContractProvider, + getterName: string, + params: TupleItem[], + ) { + return (await provider.get(getterName, params)).stack; + } +} From fbc54f65b90f638835cef279900d7a8376d13699 Mon Sep 17 00:00:00 2001 From: Mell0r Date: Wed, 9 Apr 2025 02:29:39 +0300 Subject: [PATCH 20/44] feat: wip: added expression equality testing with stubs for now --- src/test/fuzzer/test/expression.spec.ts | 110 +++++++++++++++++++++++- 1 file changed, 109 insertions(+), 1 deletion(-) diff --git a/src/test/fuzzer/test/expression.spec.ts b/src/test/fuzzer/test/expression.spec.ts index b655aadd49..8b998bbeb8 100644 --- a/src/test/fuzzer/test/expression.spec.ts +++ b/src/test/fuzzer/test/expression.spec.ts @@ -3,6 +3,7 @@ import { resolveExpression, getExpType } from "@/types/resolveExpression"; import type { StatementContext } from "@/types/resolveStatements"; import type { TypeRef } from "@/types/types"; import assert from "assert"; +import * as Ast from "@/ast/ast"; import { Expression, @@ -15,7 +16,18 @@ import { createProperty, checkProperty, dummySrcInfoPrintable, + filterStdlib, + parseStandardLibrary, + CustomStdlib, + checkAsyncProperty, + buildModule, } from "@/test/fuzzer/src/util"; +import { FactoryAst, getAstFactory } from "@/ast/ast-helpers"; +import { getMakeAst, MakeAstFactory } from "@/ast/generated/make-factory"; +import { Blockchain, SandboxContract } from "@ton/sandbox"; +import fc from "fast-check"; +import { evalConstantExpression } from "@/optimizer/constEval"; +import { AstUtil, getAstUtil } from "@/ast/util"; function emptyContext(): StatementContext { return { @@ -33,7 +45,7 @@ function setupContexts(): [CompilerContext, StatementContext] { return [ctx, sctx]; } -describe("properties", () => { +describe("generation properties", () => { it("generates well-typed expressions", () => { const results = setupContexts(); let compilerCtx = results[0]; @@ -65,3 +77,99 @@ describe("properties", () => { } }); }); + +function getExprGenerator(): fc.Arbitrary { // TODO: replace this function with the actual one when it is ready + throw new Error("getExprGenerator is not implemented yet"); +} + +function createContractWithExpressionGetter( + makeF: MakeAstFactory, + contractName: string, + expr: Ast.Expression, +): Ast.Contract { + throw new Error("createContract is not implemented yet"); // TODO: implement, probably should place this function in a different file + // makeF.makeContract(contractName, [], [], [], ) +} + +describe("evaluation properties", () => { + let astF: FactoryAst; + let makeF: MakeAstFactory; + let customStdlib: CustomStdlib; + let blockchain: Blockchain; + let emptyCompileContext: CompilerContext; + let astUtil: AstUtil; + + beforeAll(async () => { + astF = getAstFactory(); + makeF = getMakeAst(astF); + customStdlib = filterStdlib( + parseStandardLibrary(astF), + makeF, + new Set([ + "Int", + "Bool", + "Address", + "Cell", + "Context", + "Slice", + //"Builder", + //"String", + "StateInit", + "SendParameters", + "BaseTrait", + "SendDefaultMode", + "SendRemainingValue", + "SendIgnoreErrors", + "SendRemainingBalance", + "ReserveExact", + "sender", + "context", + "myBalance", + "nativeReserve", + //"contractAddress", + //"contractAddressExt", + //"storeUint", + //"storeInt", + //"contractHash", + //"newAddress", + //"beginCell", + //"endCell", + "send", + //"asSlice", + //"asAddressUnsafe", + //"beginParse", + ]), + ); + blockchain = await Blockchain.create(); + emptyCompileContext = new CompilerContext(); + astUtil = getAstUtil(astF); + }); + + test("compiler and interpreter evaluate pure generated expressions equally", async () => { + const contractName = "pureExpressionContract"; + const property = fc.asyncProperty(getExprGenerator(), async (expr) => { + const contractModule = makeF.makeModule( + [], + [createContractWithExpressionGetter(makeF, contractName, expr)], + ); + const contractMap = await buildModule( + astF, + contractModule, + customStdlib, + blockchain, + ); + const contract = contractMap.get(contractName)!; + const compiledValue = await contract.getInt(); + + const intrepretedValue = evalConstantExpression( + expr, + emptyCompileContext, + astUtil, + ); + expect(intrepretedValue.kind).toBe("number"); + + expect(compiledValue).toBe((intrepretedValue as Ast.Number).value); + }); + await checkAsyncProperty(property); + }); +}); From 1c517ce1d93f8f4ec73393b29974971032ad7b63 Mon Sep 17 00:00:00 2001 From: jeshecdom Date: Wed, 9 Apr 2025 19:52:43 +0200 Subject: [PATCH 21/44] test: expression generator. --- spell/cspell-list.txt | 1 + .../fuzzer/src/generators/uniform-expr-gen.ts | 1509 +++++++++++++++++ src/test/fuzzer/test/expression-stats.ts | 10 +- 3 files changed, 1515 insertions(+), 5 deletions(-) create mode 100644 src/test/fuzzer/src/generators/uniform-expr-gen.ts diff --git a/spell/cspell-list.txt b/spell/cspell-list.txt index cdf8561ed9..0cd5196c8c 100644 --- a/spell/cspell-list.txt +++ b/spell/cspell-list.txt @@ -114,6 +114,7 @@ mintable misparse misparsed mktemp +mult multiformats nanoton nanotons diff --git a/src/test/fuzzer/src/generators/uniform-expr-gen.ts b/src/test/fuzzer/src/generators/uniform-expr-gen.ts new file mode 100644 index 0000000000..14a3806350 --- /dev/null +++ b/src/test/fuzzer/src/generators/uniform-expr-gen.ts @@ -0,0 +1,1509 @@ +import type * as Ast from "@/ast/ast"; +import { getAstFactory } from "@/ast/ast-helpers"; +import { getMakeAst } from "@/ast/generated/make-factory"; +import type { MakeAstFactory } from "@/ast/generated/make-factory"; +import { statistics } from "@/test/fuzzer/test/expression-stats"; +import { beginCell } from "@ton/core"; +import type { Address, Cell } from "@ton/core"; +import { sha256_sync } from "@ton/crypto"; +import { TreasuryContract } from "@ton/sandbox"; +import * as fc from "fast-check"; + +const AllowedType = { + Int: "Int", + OptInt: "Int?", + Bool: "Bool", + OptBool: "Bool?", + Cell: "Cell", + OptCell: "Cell?", + Slice: "Slice", + OptSlice: "Slice?", + Address: "Address", + OptAddress: "Address?", + String: "String", + OptString: "String?", +} as const; + +type AllowedTypeEnum = (typeof AllowedType)[keyof typeof AllowedType]; + +type GenContext = { + // Identifier names to choose from, by type + identifiers: Map; + + // Contract names to choose from + contractNames: string[]; +}; + +const NonTerminal = { + Initial: { terminal: false, literal: false, index: 0 }, + Int: { terminal: false, literal: false, index: 1 }, + OptInt: { terminal: false, literal: false, index: 2 }, + LiteralInt: { terminal: false, literal: true, index: 3 }, + LiteralOptInt: { terminal: false, literal: true, index: 4 }, + Bool: { terminal: false, literal: false, index: 5 }, + OptBool: { terminal: false, literal: false, index: 6 }, + LiteralBool: { terminal: false, literal: true, index: 7 }, + LiteralOptBool: { terminal: false, literal: true, index: 8 }, + Cell: { terminal: false, literal: false, index: 9 }, + OptCell: { terminal: false, literal: false, index: 10 }, + LiteralCell: { terminal: false, literal: true, index: 11 }, + LiteralOptCell: { terminal: false, literal: true, index: 12 }, + Slice: { terminal: false, literal: false, index: 13 }, + OptSlice: { terminal: false, literal: false, index: 14 }, + LiteralSlice: { terminal: false, literal: true, index: 15 }, + LiteralOptSlice: { terminal: false, literal: true, index: 16 }, + Address: { terminal: false, literal: false, index: 17 }, + OptAddress: { terminal: false, literal: false, index: 18 }, + LiteralAddress: { terminal: false, literal: true, index: 19 }, + LiteralOptAddress: { terminal: false, literal: true, index: 20 }, + String: { terminal: false, literal: false, index: 21 }, + OptString: { terminal: false, literal: false, index: 22 }, + LiteralString: { terminal: false, literal: true, index: 23 }, + LiteralOptString: { terminal: false, literal: true, index: 24 }, +} as const; + +type NonTerminalEnum = (typeof NonTerminal)[keyof typeof NonTerminal]; + +const Terminal = { + integer: { terminal: true, id: 1 }, + add: { terminal: true, id: 2 }, + minus: { terminal: true, id: 3 }, + mult: { terminal: true, id: 4 }, + div: { terminal: true, id: 5 }, + mod: { terminal: true, id: 6 }, + shift_r: { terminal: true, id: 7 }, + shift_l: { terminal: true, id: 8 }, + bit_and: { terminal: true, id: 9 }, + bit_or: { terminal: true, id: 10 }, + bit_xor: { terminal: true, id: 11 }, + unary_plus: { terminal: true, id: 12 }, + unary_minus: { terminal: true, id: 13 }, + bit_not: { terminal: true, id: 14 }, + + bool: { terminal: true, id: 15 }, + eq: { terminal: true, id: 16 }, + neq: { terminal: true, id: 17 }, + lt: { terminal: true, id: 18 }, + le: { terminal: true, id: 19 }, + gt: { terminal: true, id: 20 }, + ge: { terminal: true, id: 21 }, + and: { terminal: true, id: 22 }, + or: { terminal: true, id: 23 }, + not: { terminal: true, id: 24 }, + + cell: { terminal: true, id: 25 }, + code_of: { terminal: true, id: 26 }, + + slice: { terminal: true, id: 27 }, + + address: { terminal: true, id: 28 }, + + string: { terminal: true, id: 29 }, + + opt_inj: { terminal: true, id: 30 }, + null: { terminal: true, id: 31 }, + non_null_assert: { terminal: true, id: 32 }, + + cond: { terminal: true, id: 33 }, + + id_int: { terminal: true, id: 34 }, + id_opt_int: { terminal: true, id: 35 }, + id_bool: { terminal: true, id: 36 }, + id_opt_bool: { terminal: true, id: 37 }, + id_cell: { terminal: true, id: 38 }, + id_opt_cell: { terminal: true, id: 39 }, + id_slice: { terminal: true, id: 40 }, + id_opt_slice: { terminal: true, id: 41 }, + id_address: { terminal: true, id: 42 }, + id_opt_address: { terminal: true, id: 43 }, + id_string: { terminal: true, id: 44 }, + id_opt_string: { terminal: true, id: 45 }, +} as const; + +type TerminalEnum = (typeof Terminal)[keyof typeof Terminal]; + +type Token = TerminalEnum | NonTerminalEnum; + +type ExprProduction = { + tokens: Token[]; + index: number; +}; + +const productions: ExprProduction[][] = [ + [ + // Productions for Initial + { index: 0, tokens: [NonTerminal.Int] }, + { index: 1, tokens: [NonTerminal.OptInt] }, + { index: 2, tokens: [NonTerminal.LiteralInt] }, + { index: 3, tokens: [NonTerminal.LiteralOptInt] }, + { index: 4, tokens: [NonTerminal.Bool] }, + { index: 5, tokens: [NonTerminal.OptBool] }, + { index: 6, tokens: [NonTerminal.LiteralBool] }, + { index: 7, tokens: [NonTerminal.LiteralOptBool] }, + { index: 8, tokens: [NonTerminal.Cell] }, + { index: 9, tokens: [NonTerminal.OptCell] }, + { index: 10, tokens: [NonTerminal.LiteralCell] }, + { index: 11, tokens: [NonTerminal.LiteralOptCell] }, + { index: 12, tokens: [NonTerminal.Slice] }, + { index: 13, tokens: [NonTerminal.OptSlice] }, + { index: 14, tokens: [NonTerminal.LiteralSlice] }, + { index: 15, tokens: [NonTerminal.LiteralOptSlice] }, + { index: 16, tokens: [NonTerminal.Address] }, + { index: 17, tokens: [NonTerminal.OptAddress] }, + { index: 18, tokens: [NonTerminal.LiteralAddress] }, + { index: 19, tokens: [NonTerminal.LiteralOptAddress] }, + { index: 20, tokens: [NonTerminal.String] }, + { index: 21, tokens: [NonTerminal.LiteralString] }, + { index: 22, tokens: [NonTerminal.OptString] }, + { index: 23, tokens: [NonTerminal.LiteralOptString] }, + ], + [ + // Productions for Int + { index: 0, tokens: [Terminal.add, NonTerminal.Int, NonTerminal.Int] }, + { + index: 1, + tokens: [Terminal.minus, NonTerminal.Int, NonTerminal.Int], + }, + { index: 2, tokens: [Terminal.mult, NonTerminal.Int, NonTerminal.Int] }, + { index: 3, tokens: [Terminal.div, NonTerminal.Int, NonTerminal.Int] }, + { index: 4, tokens: [Terminal.mod, NonTerminal.Int, NonTerminal.Int] }, + { + index: 5, + tokens: [Terminal.shift_r, NonTerminal.Int, NonTerminal.Int], + }, + { + index: 6, + tokens: [Terminal.shift_l, NonTerminal.Int, NonTerminal.Int], + }, + { + index: 7, + tokens: [Terminal.bit_and, NonTerminal.Int, NonTerminal.Int], + }, + { + index: 8, + tokens: [Terminal.bit_or, NonTerminal.Int, NonTerminal.Int], + }, + { + index: 9, + tokens: [Terminal.bit_xor, NonTerminal.Int, NonTerminal.Int], + }, + { index: 10, tokens: [Terminal.unary_plus, NonTerminal.Int] }, + { index: 11, tokens: [Terminal.unary_minus, NonTerminal.Int] }, + { index: 12, tokens: [Terminal.bit_not, NonTerminal.Int] }, + + { index: 13, tokens: [Terminal.non_null_assert, NonTerminal.OptInt] }, + { + index: 14, + tokens: [ + Terminal.cond, + NonTerminal.Bool, + NonTerminal.Int, + NonTerminal.Int, + ], + }, + { index: 15, tokens: [Terminal.id_int] }, + { index: 16, tokens: [NonTerminal.LiteralInt] }, + ], + [ + // Productions for OptInt + { index: 0, tokens: [Terminal.opt_inj, NonTerminal.Int] }, + { + index: 1, + tokens: [ + Terminal.cond, + NonTerminal.Bool, + NonTerminal.OptInt, + NonTerminal.OptInt, + ], + }, + { index: 2, tokens: [Terminal.id_opt_int] }, + { index: 3, tokens: [NonTerminal.LiteralOptInt] }, + ], + [ + // Productions for LiteralInt + { index: 0, tokens: [Terminal.integer] }, + ], + [ + // Productions for LiteralOptInt + { index: 0, tokens: [Terminal.null] }, + { index: 1, tokens: [Terminal.opt_inj, NonTerminal.LiteralInt] }, + ], + [ + // Productions for Bool + { index: 0, tokens: [Terminal.eq, NonTerminal.Int, NonTerminal.Int] }, + { + index: 1, + tokens: [Terminal.eq, NonTerminal.OptInt, NonTerminal.OptInt], + }, + { index: 2, tokens: [Terminal.eq, NonTerminal.Bool, NonTerminal.Bool] }, + { + index: 3, + tokens: [Terminal.eq, NonTerminal.OptBool, NonTerminal.OptBool], + }, + { + index: 4, + tokens: [Terminal.eq, NonTerminal.Address, NonTerminal.Address], + }, + { + index: 5, + tokens: [ + Terminal.eq, + NonTerminal.OptAddress, + NonTerminal.OptAddress, + ], + }, + { index: 6, tokens: [Terminal.eq, NonTerminal.Cell, NonTerminal.Cell] }, + { + index: 7, + tokens: [Terminal.eq, NonTerminal.OptCell, NonTerminal.OptCell], + }, + { + index: 8, + tokens: [Terminal.eq, NonTerminal.Slice, NonTerminal.Slice], + }, + { + index: 9, + tokens: [Terminal.eq, NonTerminal.OptSlice, NonTerminal.OptSlice], + }, + { + index: 10, + tokens: [Terminal.eq, NonTerminal.String, NonTerminal.String], + }, + { + index: 11, + tokens: [Terminal.eq, NonTerminal.OptString, NonTerminal.OptString], + }, + + { index: 12, tokens: [Terminal.neq, NonTerminal.Int, NonTerminal.Int] }, + { + index: 13, + tokens: [Terminal.neq, NonTerminal.OptInt, NonTerminal.OptInt], + }, + { + index: 14, + tokens: [Terminal.neq, NonTerminal.Bool, NonTerminal.Bool], + }, + { + index: 15, + tokens: [Terminal.neq, NonTerminal.OptBool, NonTerminal.OptBool], + }, + { + index: 16, + tokens: [Terminal.neq, NonTerminal.Address, NonTerminal.Address], + }, + { + index: 17, + tokens: [ + Terminal.neq, + NonTerminal.OptAddress, + NonTerminal.OptAddress, + ], + }, + { + index: 18, + tokens: [Terminal.neq, NonTerminal.Cell, NonTerminal.Cell], + }, + { + index: 19, + tokens: [Terminal.neq, NonTerminal.OptCell, NonTerminal.OptCell], + }, + { + index: 20, + tokens: [Terminal.neq, NonTerminal.Slice, NonTerminal.Slice], + }, + { + index: 21, + tokens: [Terminal.neq, NonTerminal.OptSlice, NonTerminal.OptSlice], + }, + { + index: 22, + tokens: [Terminal.neq, NonTerminal.String, NonTerminal.String], + }, + { + index: 23, + tokens: [ + Terminal.neq, + NonTerminal.OptString, + NonTerminal.OptString, + ], + }, + + { index: 24, tokens: [Terminal.lt, NonTerminal.Int, NonTerminal.Int] }, + { index: 25, tokens: [Terminal.le, NonTerminal.Int, NonTerminal.Int] }, + { index: 26, tokens: [Terminal.gt, NonTerminal.Int, NonTerminal.Int] }, + { index: 27, tokens: [Terminal.ge, NonTerminal.Int, NonTerminal.Int] }, + { + index: 28, + tokens: [Terminal.and, NonTerminal.Bool, NonTerminal.Bool], + }, + { + index: 29, + tokens: [Terminal.or, NonTerminal.Bool, NonTerminal.Bool], + }, + { index: 30, tokens: [Terminal.not, NonTerminal.Bool] }, + + { index: 31, tokens: [Terminal.non_null_assert, NonTerminal.OptBool] }, + { + index: 32, + tokens: [ + Terminal.cond, + NonTerminal.Bool, + NonTerminal.Bool, + NonTerminal.Bool, + ], + }, + { index: 33, tokens: [Terminal.id_bool] }, + { index: 34, tokens: [NonTerminal.LiteralBool] }, + ], + [ + // Productions for OptBool + { index: 0, tokens: [Terminal.opt_inj, NonTerminal.Bool] }, + { + index: 1, + tokens: [ + Terminal.cond, + NonTerminal.Bool, + NonTerminal.OptBool, + NonTerminal.OptBool, + ], + }, + { index: 2, tokens: [Terminal.id_opt_bool] }, + { index: 3, tokens: [NonTerminal.LiteralOptBool] }, + ], + [ + // Productions for LiteralBool + { index: 0, tokens: [Terminal.bool] }, + ], + [ + // Productions for LiteralOptBool + { index: 0, tokens: [Terminal.null] }, + { index: 1, tokens: [Terminal.opt_inj, NonTerminal.LiteralBool] }, + ], + [ + // Productions for Cell + { index: 0, tokens: [Terminal.code_of] }, + + { index: 1, tokens: [Terminal.non_null_assert, NonTerminal.OptCell] }, + { + index: 2, + tokens: [ + Terminal.cond, + NonTerminal.Bool, + NonTerminal.Cell, + NonTerminal.Cell, + ], + }, + { index: 3, tokens: [Terminal.id_cell] }, + { index: 4, tokens: [NonTerminal.LiteralCell] }, + ], + [ + // Productions for OptCell + { index: 0, tokens: [Terminal.opt_inj, NonTerminal.Cell] }, + { + index: 1, + tokens: [ + Terminal.cond, + NonTerminal.Bool, + NonTerminal.OptCell, + NonTerminal.OptCell, + ], + }, + { index: 2, tokens: [Terminal.id_opt_cell] }, + { index: 3, tokens: [NonTerminal.LiteralOptCell] }, + ], + [ + // Productions for LiteralCell + { index: 0, tokens: [Terminal.cell] }, + ], + [ + // Productions for LiteralOptCell + { index: 0, tokens: [Terminal.null] }, + { index: 1, tokens: [Terminal.opt_inj, NonTerminal.LiteralCell] }, + ], + [ + // Productions for Slice + { index: 0, tokens: [Terminal.non_null_assert, NonTerminal.OptSlice] }, + { + index: 1, + tokens: [ + Terminal.cond, + NonTerminal.Bool, + NonTerminal.Slice, + NonTerminal.Slice, + ], + }, + { index: 2, tokens: [Terminal.id_slice] }, + { index: 3, tokens: [NonTerminal.LiteralSlice] }, + ], + [ + // Productions for OptSlice + { index: 0, tokens: [Terminal.opt_inj, NonTerminal.Slice] }, + { + index: 1, + tokens: [ + Terminal.cond, + NonTerminal.Bool, + NonTerminal.OptSlice, + NonTerminal.OptSlice, + ], + }, + { index: 2, tokens: [Terminal.id_opt_slice] }, + { index: 3, tokens: [NonTerminal.LiteralOptSlice] }, + ], + [ + // Productions for LiteralSlice + { index: 0, tokens: [Terminal.slice] }, + ], + [ + // Productions for LiteralOptSlice + { index: 0, tokens: [Terminal.null] }, + { index: 1, tokens: [Terminal.opt_inj, NonTerminal.LiteralSlice] }, + ], + [ + // Productions for Address + { + index: 0, + tokens: [Terminal.non_null_assert, NonTerminal.OptAddress], + }, + { + index: 1, + tokens: [ + Terminal.cond, + NonTerminal.Bool, + NonTerminal.Address, + NonTerminal.Address, + ], + }, + { index: 2, tokens: [Terminal.id_address] }, + { index: 3, tokens: [NonTerminal.LiteralAddress] }, + ], + [ + // Productions for OptAddress + { index: 0, tokens: [Terminal.opt_inj, NonTerminal.Address] }, + { + index: 1, + tokens: [ + Terminal.cond, + NonTerminal.Bool, + NonTerminal.OptAddress, + NonTerminal.OptAddress, + ], + }, + { index: 2, tokens: [Terminal.id_opt_address] }, + { index: 3, tokens: [NonTerminal.LiteralOptAddress] }, + ], + [ + // Productions for LiteralAddress + { index: 0, tokens: [Terminal.address] }, + ], + [ + // Productions for LiteralOptAddress + { index: 0, tokens: [Terminal.null] }, + { index: 1, tokens: [Terminal.opt_inj, NonTerminal.LiteralAddress] }, + ], + [ + // Productions for String + { index: 0, tokens: [Terminal.non_null_assert, NonTerminal.OptString] }, + { + index: 1, + tokens: [ + Terminal.cond, + NonTerminal.Bool, + NonTerminal.String, + NonTerminal.String, + ], + }, + { index: 2, tokens: [Terminal.id_string] }, + { index: 3, tokens: [NonTerminal.LiteralString] }, + ], + [ + // Productions for OptString + { index: 0, tokens: [Terminal.opt_inj, NonTerminal.String] }, + { + index: 1, + tokens: [ + Terminal.cond, + NonTerminal.Bool, + NonTerminal.OptString, + NonTerminal.OptString, + ], + }, + { index: 2, tokens: [Terminal.id_opt_string] }, + { index: 3, tokens: [NonTerminal.LiteralOptString] }, + ], + [ + // Productions for LiteralString + { index: 0, tokens: [Terminal.string] }, + ], + [ + // Productions for LiteralOptString + { index: 0, tokens: [Terminal.null] }, + { index: 1, tokens: [Terminal.opt_inj, NonTerminal.LiteralString] }, + ], +]; + +function sum(counts: number[]): number { + return counts.reduce((prev, curr) => prev + curr, 0); +} + +function computeCountTables( + minSize: number, + maxSize: number, +): { + nonTerminalCounts: number[][][]; + sizeSplitCounts: number[][][][][]; + totalCounts: number[][]; +} { + const nonTerminalCounts: number[][][] = []; + const sizeSplitCounts: number[][][][][] = []; + const totalCounts: number[][] = []; + + function updateTotalCounts(idx: number, size: number, count: number) { + if (typeof totalCounts[idx] === "undefined") { + totalCounts[idx] = Array(maxSize + 1); + totalCounts[idx][size] = count; + } else { + totalCounts[idx][size] = count; + } + } + + function updateNonTerminalCounts( + idx: number, + size: number, + counts: number[], + ) { + if (typeof nonTerminalCounts[idx] === "undefined") { + nonTerminalCounts[idx] = Array(maxSize + 1); + nonTerminalCounts[idx][size] = counts; + } else { + nonTerminalCounts[idx][size] = counts; + } + } + + function peekNonTerminalCounts( + idx: number, + size: number, + ): number[] | undefined { + if (typeof nonTerminalCounts[idx] !== "undefined") { + return nonTerminalCounts[idx][size]; + } else { + return undefined; + } + } + + function updateSizeSplitCounts( + nonTerminalIndex: number, + prodIndex: number, + tokenIndex: number, + size: number, + counts: number[], + ) { + const prods = getProductions(nonTerminalIndex); + const prod = getProductionAt(prods, prodIndex); + + if (typeof sizeSplitCounts[nonTerminalIndex] === "undefined") { + sizeSplitCounts[nonTerminalIndex] = Array(prods.length); + sizeSplitCounts[nonTerminalIndex][prodIndex] = Array( + prod.tokens.length, + ); + sizeSplitCounts[nonTerminalIndex][prodIndex][tokenIndex] = Array( + maxSize + 1, + ); + sizeSplitCounts[nonTerminalIndex][prodIndex][tokenIndex][size] = + counts; + return; + } else { + if ( + typeof sizeSplitCounts[nonTerminalIndex][prodIndex] === + "undefined" + ) { + sizeSplitCounts[nonTerminalIndex][prodIndex] = Array( + prod.tokens.length, + ); + sizeSplitCounts[nonTerminalIndex][prodIndex][tokenIndex] = + Array(maxSize + 1); + sizeSplitCounts[nonTerminalIndex][prodIndex][tokenIndex][size] = + counts; + return; + } + if ( + typeof sizeSplitCounts[nonTerminalIndex][prodIndex][ + tokenIndex + ] === "undefined" + ) { + sizeSplitCounts[nonTerminalIndex][prodIndex][tokenIndex] = + Array(maxSize + 1); + sizeSplitCounts[nonTerminalIndex][prodIndex][tokenIndex][size] = + counts; + return; + } + sizeSplitCounts[nonTerminalIndex][prodIndex][tokenIndex][size] = + counts; + } + } + + function peekSizeSplitCounts( + nonTerminalIndex: number, + prodIndex: number, + tokenIndex: number, + size: number, + ): number[] | undefined { + return sizeSplitCounts[nonTerminalIndex]?.[prodIndex]?.[tokenIndex]?.[ + size + ]; + } + + function countFromNonTerminal(index: number, size: number): number[] { + const peekedCounts = peekNonTerminalCounts(index, size); + if (typeof peekedCounts !== "undefined") { + return peekedCounts; + } + const prods = getProductions(index); + return prods.map((prod) => + sum(countFromProduction(index, prod, 0, size)), + ); + } + + function countFromProduction( + nonTerminalIndex: number, + production: ExprProduction, + tokenIndex: number, + size: number, + ): number[] { + if (size === 0) { + return []; + } + const peekedCounts = peekSizeSplitCounts( + nonTerminalIndex, + production.index, + tokenIndex, + size, + ); + if (typeof peekedCounts !== "undefined") { + return peekedCounts; + } + const head = getTokenAt(production.tokens, tokenIndex); + if (head.terminal) { + if (tokenIndex === production.tokens.length - 1) { + // i.e., the head is the last symbol in the production + return size === 1 ? [1] : [0]; + } else { + return [ + sum( + countFromProduction( + nonTerminalIndex, + production, + tokenIndex + 1, + size - 1, + ), + ), + ]; + } + } + // head is not a terminal + if (tokenIndex === production.tokens.length - 1) { + // i.e., the head is the last symbol in the production + return [sum(countFromNonTerminal(head.index, size))]; + } else { + const result: number[] = []; + + for ( + let l = 1; + l <= size - production.tokens.length + tokenIndex + 1; + l++ + ) { + const partition1 = sum(countFromNonTerminal(head.index, l)); + const partition2 = sum( + countFromProduction( + nonTerminalIndex, + production, + tokenIndex + 1, + size - l, + ), + ); + result.push(partition1 * partition2); + } + return result; + } + } + + function doCountsForNonTerminals(nonTerminals: NonTerminalEnum[]) { + // First, compute the counts of all the non-terminals that produce literals + + // The first step is to initialize the tables for size 0 + for (const nonTerminal of nonTerminals) { + const nonTerminalIdx = nonTerminal.index; + + const productions = getProductions(nonTerminalIdx); + + updateNonTerminalCounts( + nonTerminalIdx, + 0, + productions.map((_) => 0), + ); + + for (const prod of productions) { + for ( + let tokenIndx = 0; + tokenIndx < prod.tokens.length; + tokenIndx++ + ) { + updateSizeSplitCounts( + nonTerminalIdx, + prod.index, + tokenIndx, + 0, + [], + ); + } + } + } + + // Now, for the rest of sizes + for (let size = 1; size <= maxSize; size++) { + for (const nonTerminal of nonTerminals) { + const nonTerminalIdx = nonTerminal.index; + + const productions = getProductions(nonTerminalIdx); + + for (const prod of productions) { + for ( + let tokenIndx = 0; + tokenIndx < prod.tokens.length; + tokenIndx++ + ) { + updateSizeSplitCounts( + nonTerminalIdx, + prod.index, + tokenIndx, + size, + countFromProduction( + nonTerminalIdx, + prod, + tokenIndx, + size, + ), + ); + } + } + + updateNonTerminalCounts( + nonTerminalIdx, + size, + countFromNonTerminal(nonTerminalIdx, size), + ); + } + } + } + + function doTotalCounts() { + // From 0 to minSize-1, set counts to 0, since we are not going to choose those sizes + for (let size = 0; size < minSize; size++) { + for (const nonTerminal of Object.values(NonTerminal)) { + updateTotalCounts(nonTerminal.index, size, 0); + } + } + + for (let size = minSize; size <= maxSize; size++) { + for (const nonTerminal of Object.values(NonTerminal)) { + updateTotalCounts( + nonTerminal.index, + size, + sum( + lookupNonTerminalCounts( + nonTerminalCounts, + nonTerminal.index, + size, + ), + ), + ); + } + } + } + + function accumulateArray(counts: number[]): number[] { + if (counts.length === 0) { + return counts; + } + const result: number[] = [counts[0]!]; + for (let i = 1; i < counts.length; i++) { + result[i] = counts[i]! + result[i - 1]!; + } + return result; + } + + function accumulateCounts() { + // The total counts + for (const nonTerminal of Object.values(NonTerminal)) { + const counts = totalCounts[nonTerminal.index]; + if (typeof counts === "undefined") { + throw new Error(`Index ${nonTerminal.index} out of bounds`); + } + const newCounts = accumulateArray(counts); + totalCounts[nonTerminal.index] = newCounts; + } + + // The non-terminal counts + for (const nonTerminal of Object.values(NonTerminal)) { + for (let size = 0; size <= maxSize; size++) { + const counts = lookupNonTerminalCounts( + nonTerminalCounts, + nonTerminal.index, + size, + ); + const newCounts = accumulateArray(counts); + updateNonTerminalCounts(nonTerminal.index, size, newCounts); + } + } + + // Split size counts + for (const nonTerminal of Object.values(NonTerminal)) { + const nonTerminalIdx = nonTerminal.index; + + const productions = getProductions(nonTerminalIdx); + + for (const prod of productions) { + for ( + let tokenIndx = 0; + tokenIndx < prod.tokens.length; + tokenIndx++ + ) { + for (let size = 0; size <= maxSize; size++) { + const counts = lookupSizeSplitCounts( + sizeSplitCounts, + nonTerminal.index, + prod.index, + tokenIndx, + size, + ); + const newCounts = accumulateArray(counts); + updateSizeSplitCounts( + nonTerminal.index, + prod.index, + tokenIndx, + size, + newCounts, + ); + } + } + } + } + } + + // First, fill the non-terminals that compute literals + doCountsForNonTerminals( + Object.values(NonTerminal).filter((nonTerminal) => nonTerminal.literal), + ); + + // Now the rest of non-terminals, but not the initial non-terminal + doCountsForNonTerminals( + Object.values(NonTerminal).filter( + (nonTerminal) => !nonTerminal.literal && nonTerminal.index !== 0, + ), + ); + + // Finally, the initial non-terminal + doCountsForNonTerminals([NonTerminal.Initial]); + + doTotalCounts(); + + accumulateCounts(); + + return { + nonTerminalCounts, + sizeSplitCounts, + totalCounts, + }; +} + +function lookupSizeSplitCounts( + sizeSplitCounts: number[][][][][], + nonTerminalIndex: number, + prodIndex: number, + tokenIndex: number, + size: number, +): number[] { + const nTCounts = sizeSplitCounts[nonTerminalIndex]; + if (typeof nTCounts === "undefined") { + throw new Error(`Index ${nonTerminalIndex} out of bounds`); + } + const prodCounts = nTCounts[prodIndex]; + if (typeof prodCounts === "undefined") { + throw new Error(`Index ${prodIndex} out of bounds`); + } + const tokenCounts = prodCounts[tokenIndex]; + if (typeof tokenCounts === "undefined") { + throw new Error(`Index ${tokenIndex} out of bounds`); + } + const result = tokenCounts[size]; + if (typeof result === "undefined") { + throw new Error(`Index ${size} out of bounds`); + } + return result; +} + +function lookupNonTerminalCounts( + nonTerminalCounts: number[][][], + nonTerminalIndex: number, + size: number, +): number[] { + const nTCounts = nonTerminalCounts[nonTerminalIndex]; + if (typeof nTCounts === "undefined") { + throw new Error(`Index ${nonTerminalIndex} out of bounds`); + } + const result = nTCounts[size]; + if (typeof result === "undefined") { + throw new Error(`Index ${size} out of bounds`); + } + return result; +} + +function lookupTotalCounts( + totalCounts: number[][], + nonTerminalIndex: number, +): number[] { + const nTCounts = totalCounts[nonTerminalIndex]; + if (typeof nTCounts === "undefined") { + throw new Error(`Index ${nonTerminalIndex} out of bounds`); + } + return nTCounts; +} + +function getProductions(idx: number): ExprProduction[] { + const prods = productions[idx]; + if (typeof prods === "undefined") { + throw new Error(`${idx} is not a valid index for a non-terminal`); + } + return prods; +} + +function getTokenAt(tokens: Token[], index: number): Token { + const token = tokens[index]; + if (typeof token === "undefined") { + throw new Error(`Index ${index} is out of bounds`); + } + return token; +} + +function getNonTerminalAt(tokens: Token[], index: number): NonTerminalEnum { + const token = getTokenAt(tokens, index); + if (token.terminal) { + throw new Error(`Was expecting a non-terminal`); + } + return token; +} + +function getProductionAt( + prods: ExprProduction[], + index: number, +): ExprProduction { + const prod = prods[index]; + if (typeof prod === "undefined") { + throw new Error(`Index ${index} out of bounds in productions array`); + } + return prod; +} + +function makeExpression( + makeF: MakeAstFactory, + type: NonTerminalEnum, + ctx: GenContext, + nonTerminalCounts: number[][][], + sizeSplitCounts: number[][][][][], + size: number, +): Ast.Expression { + function genFromNonTerminal(index: number, size: number): Ast.Expression { + const prods = getProductions(index); + const nonTerminalOptions = lookupNonTerminalCounts( + nonTerminalCounts, + index, + size, + ); + + const chosenProdIndex = randomlyChooseIndex(nonTerminalOptions); + const production = getProductionAt(prods, chosenProdIndex); + return genFromProduction(index, production, size); + } + + function genFromProduction( + nonTerminalIndex: number, + production: ExprProduction, + size: number, + ): Ast.Expression { + const head = getTokenAt(production.tokens, 0); + if (head.terminal) { + // The production must have the form: N -> head list_of_non_terminals + // where head indicates the kind of tree we need to produce + return makeTree( + nonTerminalIndex, + production.index, + head, + production.tokens.slice(1), + size, + ); + } + // head is not a terminal + // The production must have the form N -> head + return genFromNonTerminal(head.index, size); + } + + function chooseSizeSplit( + nonTerminalIndex: number, + prodIndex: number, + tokenIndex: number, + size: number, + ): number { + const sizeSplits = lookupSizeSplitCounts( + sizeSplitCounts, + nonTerminalIndex, + prodIndex, + tokenIndex, + size, + ); + return randomlyChooseIndex(sizeSplits) + 1; + } + + function makeBinaryOperatorTree( + op: Ast.BinaryOperation, + nonTerminalIndex: number, + prodIndex: number, + rest: Token[], + size: number, + ): Ast.Expression { + const currSize = size - 1; + // Choose a single split for the size + const sizeSplit = chooseSizeSplit( + nonTerminalIndex, + prodIndex, + 1, + currSize, + ); + + const leftNonTerminal = getNonTerminalAt(rest, 0); + const rightNonTerminal = getNonTerminalAt(rest, 1); + const leftOperand = genFromNonTerminal( + leftNonTerminal.index, + sizeSplit, + ); + const rightOperand = genFromNonTerminal( + rightNonTerminal.index, + currSize - sizeSplit, + ); + return makeF.makeDummyOpBinary(op, leftOperand, rightOperand); + } + + function makeUnaryOperatorTree( + op: Ast.UnaryOperation, + rest: Token[], + size: number, + ): Ast.Expression { + const currSize = size - 1; + + const operandNonTerminal = getNonTerminalAt(rest, 0); + const operand = genFromNonTerminal(operandNonTerminal.index, currSize); + return makeF.makeDummyOpUnary(op, operand); + } + + function makeIdentifier(t: AllowedTypeEnum): Ast.Expression { + const names = ctx.identifiers.get(t); + if (typeof names === "undefined" || names.length === 0) { + throw new Error( + `There must exist at least one identifier for type ${t}`, + ); + } + return makeF.makeDummyId(fc.sample(fc.constantFrom(...names))[0]!); + } + + function makeTree( + nonTerminalIndex: number, + prodIndex: number, + head: TerminalEnum, + rest: Token[], + size: number, + ): Ast.Expression { + switch (head.id) { + case Terminal.integer.id: { + return fc.sample( + fc.bigInt().map((i) => makeF.makeDummyNumber(10, i)), + 1, + )[0]!; + } + case Terminal.add.id: { + return makeBinaryOperatorTree( + "+", + nonTerminalIndex, + prodIndex, + rest, + size, + ); + } + case Terminal.minus.id: { + return makeBinaryOperatorTree( + "-", + nonTerminalIndex, + prodIndex, + rest, + size, + ); + } + case Terminal.mult.id: { + return makeBinaryOperatorTree( + "*", + nonTerminalIndex, + prodIndex, + rest, + size, + ); + } + case Terminal.div.id: { + return makeBinaryOperatorTree( + "/", + nonTerminalIndex, + prodIndex, + rest, + size, + ); + } + case Terminal.mod.id: { + return makeBinaryOperatorTree( + "%", + nonTerminalIndex, + prodIndex, + rest, + size, + ); + } + case Terminal.shift_r.id: { + return makeBinaryOperatorTree( + ">>", + nonTerminalIndex, + prodIndex, + rest, + size, + ); + } + case Terminal.shift_l.id: { + return makeBinaryOperatorTree( + "<<", + nonTerminalIndex, + prodIndex, + rest, + size, + ); + } + case Terminal.bit_and.id: { + return makeBinaryOperatorTree( + "&", + nonTerminalIndex, + prodIndex, + rest, + size, + ); + } + case Terminal.bit_or.id: { + return makeBinaryOperatorTree( + "|", + nonTerminalIndex, + prodIndex, + rest, + size, + ); + } + case Terminal.bit_xor.id: { + return makeBinaryOperatorTree( + "^", + nonTerminalIndex, + prodIndex, + rest, + size, + ); + } + case Terminal.unary_plus.id: { + return makeUnaryOperatorTree("+", rest, size); + } + case Terminal.unary_minus.id: { + return makeUnaryOperatorTree("-", rest, size); + } + case Terminal.bit_not.id: { + return makeUnaryOperatorTree("~", rest, size); + } + case Terminal.bool.id: { + return fc.sample( + fc.boolean().map((b) => makeF.makeDummyBoolean(b)), + 1, + )[0]!; + } + case Terminal.eq.id: { + return makeBinaryOperatorTree( + "==", + nonTerminalIndex, + prodIndex, + rest, + size, + ); + } + case Terminal.neq.id: { + return makeBinaryOperatorTree( + "!=", + nonTerminalIndex, + prodIndex, + rest, + size, + ); + } + case Terminal.lt.id: { + return makeBinaryOperatorTree( + "<", + nonTerminalIndex, + prodIndex, + rest, + size, + ); + } + case Terminal.le.id: { + return makeBinaryOperatorTree( + "<=", + nonTerminalIndex, + prodIndex, + rest, + size, + ); + } + case Terminal.gt.id: { + return makeBinaryOperatorTree( + ">", + nonTerminalIndex, + prodIndex, + rest, + size, + ); + } + case Terminal.ge.id: { + return makeBinaryOperatorTree( + ">=", + nonTerminalIndex, + prodIndex, + rest, + size, + ); + } + case Terminal.and.id: { + return makeBinaryOperatorTree( + "&&", + nonTerminalIndex, + prodIndex, + rest, + size, + ); + } + case Terminal.or.id: { + return makeBinaryOperatorTree( + "||", + nonTerminalIndex, + prodIndex, + rest, + size, + ); + } + case Terminal.not.id: { + return makeUnaryOperatorTree("!", rest, size); + } + case Terminal.cell.id: { + return makeF.makeDummyCell(fc.sample(_generateCell(), 1)[0]!); + } + case Terminal.code_of.id: { + if (ctx.contractNames.length === 0) { + throw new Error( + "There must exist at least one contract name in generator context", + ); + } + return makeF.makeDummyCodeOf( + makeF.makeDummyId( + fc.sample(fc.constantFrom(...ctx.contractNames), 1)[0]!, + ), + ); + } + case Terminal.slice.id: { + return makeF.makeDummySlice( + fc.sample(_generateCell(), 1)[0]!.asSlice(), + ); + } + case Terminal.address.id: { + return makeF.makeDummyAddress( + fc.sample(_generateAddress(), 1)[0]!, + ); + } + case Terminal.string.id: { + return makeF.makeDummyString(fc.sample(fc.string(), 1)[0]!); + } + case Terminal.opt_inj.id: { + const currSize = size - 1; + const operandNonTerminal = getNonTerminalAt(rest, 0); + return genFromNonTerminal(operandNonTerminal.index, currSize); + } + case Terminal.null.id: { + return makeF.makeDummyNull(); + } + case Terminal.non_null_assert.id: { + return makeUnaryOperatorTree("!!", rest, size); + } + case Terminal.cond.id: { + const currSize = size - 1; + // Choose two splits for the size + const sizeSplit1 = chooseSizeSplit( + nonTerminalIndex, + prodIndex, + 1, + currSize, + ); + const sizeSplit2 = chooseSizeSplit( + nonTerminalIndex, + prodIndex, + 2, + currSize - sizeSplit1, + ); + + const condNonTerminal = getNonTerminalAt(rest, 0); + const thenNonTerminal = getNonTerminalAt(rest, 1); + const elseNonTerminal = getNonTerminalAt(rest, 2); + const condOperand = genFromNonTerminal( + condNonTerminal.index, + sizeSplit1, + ); + const thenOperand = genFromNonTerminal( + thenNonTerminal.index, + sizeSplit2, + ); + const elseOperand = genFromNonTerminal( + elseNonTerminal.index, + currSize - sizeSplit1 - sizeSplit2, + ); + return makeF.makeDummyConditional( + condOperand, + thenOperand, + elseOperand, + ); + } + case Terminal.id_int.id: { + return makeIdentifier("Int"); + } + case Terminal.id_opt_int.id: { + return makeIdentifier("Int?"); + } + case Terminal.id_bool.id: { + return makeIdentifier("Bool"); + } + case Terminal.id_opt_bool.id: { + return makeIdentifier("Bool?"); + } + case Terminal.id_cell.id: { + return makeIdentifier("Cell"); + } + case Terminal.id_opt_cell.id: { + return makeIdentifier("Cell?"); + } + case Terminal.id_slice.id: { + return makeIdentifier("Slice"); + } + case Terminal.id_opt_slice.id: { + return makeIdentifier("Slice?"); + } + case Terminal.id_address.id: { + return makeIdentifier("Address"); + } + case Terminal.id_opt_address.id: { + return makeIdentifier("Address?"); + } + case Terminal.id_string.id: { + return makeIdentifier("String"); + } + case Terminal.id_opt_string.id: { + return makeIdentifier("String?"); + } + } + } + + return genFromNonTerminal(type.index, size); +} + +export function initializeGenerator( + minSize: number, + maxSize: number, + ctx: GenContext, +): (type: NonTerminalEnum) => fc.Arbitrary { + const { nonTerminalCounts, sizeSplitCounts, totalCounts } = + computeCountTables(minSize, maxSize); + const makeF = getMakeAst(getAstFactory()); + + return (type: NonTerminalEnum) => { + const sizes = lookupTotalCounts(totalCounts, type.index); + return fc.constant(0).map((_) => { + const size = randomlyChooseIndex(sizes); + return makeExpression( + makeF, + type, + ctx, + nonTerminalCounts, + sizeSplitCounts, + size, + ); + }); + }; +} + +function randomlyChooseIndex(array: number[]): number { + const random = Math.random() * array[array.length - 1]!; + for (let i = 0; i < array.length; i++) { + if (array[i]! > random) { + return i; + } + } + throw new Error("There must exist at least one element in the array"); +} + +function testSubwalletId(seed: string): bigint { + return BigInt("0x" + sha256_sync("TEST_SEED" + seed).toString("hex")); +} + +function _generateAddress(): fc.Arbitrary
{ + return fc.string().map((str) => { + const subwalletId = testSubwalletId(str); + const wallet = TreasuryContract.create(0, subwalletId); + return wallet.address; + }); +} + +function _generateCell(): fc.Arbitrary { + return fc.int8Array().map((buf) => { + return beginCell().storeBuffer(Buffer.from(buf.buffer)).endCell(); + }); +} + +// Uncomment this to show the bug in fast-check +//console.log(genFromNonTerminal(0,66)); + +//statistics(heightGenerator(10), false); + +// Create a GenContext with allowed identifiers and contracts +const ids: Map = new Map(); +ids.set(AllowedType.Int, ["intV1", "intV2", "intV3"]); +ids.set(AllowedType.OptInt, ["o_intV1", "o_intV2", "o_intV3"]); +ids.set(AllowedType.Bool, ["boolV1", "boolV2", "boolV3"]); +ids.set(AllowedType.OptBool, ["o_boolV1", "o_boolV2", "o_boolV3"]); +ids.set(AllowedType.Cell, ["cellV1", "cellV2", "cellV3"]); +ids.set(AllowedType.OptCell, ["o_cellV1", "o_cellV2", "o_cellV3"]); +ids.set(AllowedType.Slice, ["sliceV1", "sliceV2", "sliceV3"]); +ids.set(AllowedType.OptSlice, ["o_sliceV1", "o_sliceV2", "o_sliceV3"]); +ids.set(AllowedType.Address, ["addressV1", "addressV2", "addressV3"]); +ids.set(AllowedType.OptAddress, ["o_addressV1", "o_addressV2", "o_addressV3"]); +ids.set(AllowedType.String, ["stringV1", "stringV2", "stringV3"]); +ids.set(AllowedType.OptString, ["o_stringV1", "o_stringV2", "o_stringV3"]); + +const ctx: GenContext = { + identifiers: ids, + contractNames: ["C1", "C2"], +}; + +const initialized = initializeGenerator(4, 5, ctx); + +statistics(initialized(NonTerminal.Int), 100, "stats.txt"); diff --git a/src/test/fuzzer/test/expression-stats.ts b/src/test/fuzzer/test/expression-stats.ts index 4f7504345d..54afa6cc35 100644 --- a/src/test/fuzzer/test/expression-stats.ts +++ b/src/test/fuzzer/test/expression-stats.ts @@ -229,15 +229,15 @@ type TreeStats = { size: number; }; -function getRows(dist: Map): string[] { +function getRows(dist: Map): string[] { const rows: string[] = []; - for (const [_, stats] of dist) { - rows.push(`${stats.count} ${stats.height} ${stats.size}`); + for (const [tree, stats] of dist) { + rows.push(`${tree} ${stats.count} ${stats.height} ${stats.size}`); } return rows; } -function statistics( +export function statistics( gen: fc.Arbitrary, numberOfSamples: number, fileName: string, @@ -257,7 +257,7 @@ function statistics( fs.writeFileSync( fileName, - `count height size\n${getRows(totalPreTraversals).join("\n")}`, + `tree count height size\n${getRows(totalPreTraversals).join("\n")}`, ); } From 972f182e60c550d80ae167b68359f2a823deadf5 Mon Sep 17 00:00:00 2001 From: Mell0r Date: Thu, 10 Apr 2025 20:15:06 +0300 Subject: [PATCH 22/44] feat: simple test using the expression generator implemented --- .../fuzzer/src/generators/uniform-expr-gen.ts | 8 +- src/test/fuzzer/src/util.ts | 2 +- src/test/fuzzer/test/expression.spec.ts | 179 +++++++++++++++--- 3 files changed, 153 insertions(+), 36 deletions(-) diff --git a/src/test/fuzzer/src/generators/uniform-expr-gen.ts b/src/test/fuzzer/src/generators/uniform-expr-gen.ts index 14a3806350..ee9a1a61c3 100644 --- a/src/test/fuzzer/src/generators/uniform-expr-gen.ts +++ b/src/test/fuzzer/src/generators/uniform-expr-gen.ts @@ -9,7 +9,7 @@ import { sha256_sync } from "@ton/crypto"; import { TreasuryContract } from "@ton/sandbox"; import * as fc from "fast-check"; -const AllowedType = { +export const AllowedType = { Int: "Int", OptInt: "Int?", Bool: "Bool", @@ -24,9 +24,9 @@ const AllowedType = { OptString: "String?", } as const; -type AllowedTypeEnum = (typeof AllowedType)[keyof typeof AllowedType]; +export type AllowedTypeEnum = (typeof AllowedType)[keyof typeof AllowedType]; -type GenContext = { +export type GenContext = { // Identifier names to choose from, by type identifiers: Map; @@ -34,7 +34,7 @@ type GenContext = { contractNames: string[]; }; -const NonTerminal = { +export const NonTerminal = { Initial: { terminal: false, literal: false, index: 0 }, Int: { terminal: false, literal: false, index: 1 }, OptInt: { terminal: false, literal: false, index: 2 }, diff --git a/src/test/fuzzer/src/util.ts b/src/test/fuzzer/src/util.ts index 9d87349ee1..b4059fcc7b 100644 --- a/src/test/fuzzer/src/util.ts +++ b/src/test/fuzzer/src/util.ts @@ -505,7 +505,7 @@ export class ProxyContract implements Contract { provider: ContractProvider, via: Sender, args: { value: bigint; bounce?: boolean | null | undefined }, - body: Cell, + body?: Cell, ) { await provider.internal(via, { ...args, body: body }); } diff --git a/src/test/fuzzer/test/expression.spec.ts b/src/test/fuzzer/test/expression.spec.ts index 8b998bbeb8..4813cf0c25 100644 --- a/src/test/fuzzer/test/expression.spec.ts +++ b/src/test/fuzzer/test/expression.spec.ts @@ -24,12 +24,20 @@ import { } from "@/test/fuzzer/src/util"; import { FactoryAst, getAstFactory } from "@/ast/ast-helpers"; import { getMakeAst, MakeAstFactory } from "@/ast/generated/make-factory"; -import { Blockchain, SandboxContract } from "@ton/sandbox"; +import { Blockchain } from "@ton/sandbox"; import fc from "fast-check"; import { evalConstantExpression } from "@/optimizer/constEval"; import { AstUtil, getAstUtil } from "@/ast/util"; +import { + AllowedType, + AllowedTypeEnum, + GenContext, + initializeGenerator, + NonTerminal, +} from "../src/generators/uniform-expr-gen"; +import { Sender, toNano } from "@ton/core"; -function emptyContext(): StatementContext { +function emptyStatementContext(): StatementContext { return { root: dummySrcInfoPrintable, returns: { kind: "void" }, @@ -41,7 +49,7 @@ function emptyContext(): StatementContext { function setupContexts(): [CompilerContext, StatementContext] { const ctx: CompilerContext = new CompilerContext(); - const sctx = emptyContext(); + const sctx = emptyStatementContext(); return [ctx, sctx]; } @@ -78,19 +86,68 @@ describe("generation properties", () => { }); }); -function getExprGenerator(): fc.Arbitrary { // TODO: replace this function with the actual one when it is ready - throw new Error("getExprGenerator is not implemented yet"); +type Binding = { + name: string; + type: string; + expr: Ast.Expression; +}; + +function makeExpressionGetter( + makeF: MakeAstFactory, + getterName: string, + bindings: Binding[], + returnExpr: Ast.Expression, +): Ast.FunctionDef { + return makeF.makeDummyFunctionDef( + [makeF.makeDummyFunctionAttributeGet(undefined)], + makeF.makeDummyId(getterName), + makeF.makeDummyTypeId("Int"), + [], + bindings + .map( + ({ name, type, expr }): Ast.Statement => + makeF.makeDummyStatementLet( + makeF.makeDummyId(name), + makeF.makeDummyTypeId(type), + expr, + ), + ) + .concat([makeF.makeDummyStatementReturn(returnExpr)]), + ); } function createContractWithExpressionGetter( makeF: MakeAstFactory, contractName: string, - expr: Ast.Expression, + getterName: string, + bindings: Binding[], + returnExpr: Ast.Expression, ): Ast.Contract { - throw new Error("createContract is not implemented yet"); // TODO: implement, probably should place this function in a different file - // makeF.makeContract(contractName, [], [], [], ) + // throw new Error("createContract is not implemented yet"); // TODO: implement, probably should place this function in a different file + return makeF.makeDummyContract( + makeF.makeDummyId(contractName), + [], + [], + [], + [makeExpressionGetter(makeF, getterName, bindings, returnExpr)], + ); } +const initializersMapping = { + Int: NonTerminal.LiteralInt, + "Int?": NonTerminal.LiteralInt, + Bool: NonTerminal.LiteralBool, + "Bool?": NonTerminal.LiteralBool, + Cell: NonTerminal.LiteralCell, + "Cell?": NonTerminal.LiteralCell, + Address: NonTerminal.LiteralAddress, + "Address?": NonTerminal.LiteralAddress, + Slice: NonTerminal.LiteralSlice, + "Slice?": NonTerminal.LiteralSlice, + String: NonTerminal.LiteralString, + "String?": NonTerminal.LiteralString, +} as const; + describe("evaluation properties", () => { let astF: FactoryAst; let makeF: MakeAstFactory; @@ -98,6 +155,7 @@ describe("evaluation properties", () => { let blockchain: Blockchain; let emptyCompileContext: CompilerContext; let astUtil: AstUtil; + let sender: Sender; beforeAll(async () => { astF = getAstFactory(); @@ -143,33 +201,92 @@ describe("evaluation properties", () => { blockchain = await Blockchain.create(); emptyCompileContext = new CompilerContext(); astUtil = getAstUtil(astF); + sender = (await blockchain.treasury("treasury")).getSender(); }); - test("compiler and interpreter evaluate pure generated expressions equally", async () => { - const contractName = "pureExpressionContract"; - const property = fc.asyncProperty(getExprGenerator(), async (expr) => { - const contractModule = makeF.makeModule( - [], - [createContractWithExpressionGetter(makeF, contractName, expr)], - ); - const contractMap = await buildModule( - astF, - contractModule, - customStdlib, - blockchain, + test( + "compiler and interpreter evaluate generated expressions equally", + async () => { + const contractName = "PureExpressionContract"; + + const expressionGenerationIds: Map = + new Map(); + expressionGenerationIds.set(AllowedType.Int, ["int1"]); + expressionGenerationIds.set(AllowedType.OptInt, ["o_int1"]); + expressionGenerationIds.set(AllowedType.Bool, ["bool1"]); + expressionGenerationIds.set(AllowedType.OptBool, ["o_bool1"]); + expressionGenerationIds.set(AllowedType.Cell, ["cell1"]); + expressionGenerationIds.set(AllowedType.OptCell, ["o_cell1"]); + expressionGenerationIds.set(AllowedType.Slice, ["slice1"]); + expressionGenerationIds.set(AllowedType.OptSlice, ["o_slice1"]); + expressionGenerationIds.set(AllowedType.Address, ["address1"]); + expressionGenerationIds.set(AllowedType.OptAddress, ["o_address1"]); + expressionGenerationIds.set(AllowedType.String, ["string1"]); + expressionGenerationIds.set(AllowedType.OptString, ["o_string1"]); + + const expressionGenerationCtx: GenContext = { + identifiers: expressionGenerationIds, + contractNames: [contractName], + }; + const generator = initializeGenerator( + 1, + 10, + expressionGenerationCtx, ); - const contract = contractMap.get(contractName)!; - const compiledValue = await contract.getInt(); - const intrepretedValue = evalConstantExpression( - expr, - emptyCompileContext, - astUtil, + const bindingsGenretor = fc.tuple( + ...expressionGenerationIds.entries().flatMap(([type, names]) => + names.map((name) => + fc.record({ + type: fc.constant(type), + name: fc.constant(name), + expr: generator(initializersMapping[type]), + }), + ), + ), ); - expect(intrepretedValue.kind).toBe("number"); - expect(compiledValue).toBe((intrepretedValue as Ast.Number).value); - }); - await checkAsyncProperty(property); - }); + const property = fc.asyncProperty( + bindingsGenretor, + generator(NonTerminal.Int), + async (initExprs, expr) => { + const contractModule = makeF.makeModule( + [], + [ + createContractWithExpressionGetter( + makeF, + contractName, + "getInt", + initExprs, + expr, + ), + ], + ); + const contractMap = await buildModule( + astF, + contractModule, + customStdlib, + blockchain, + ); + const contract = contractMap.get(contractName)!; + await contract.send(sender, { value: toNano(1) }); + + const compiledValue = await contract.getInt(); + + const intrepretedValue = evalConstantExpression( + expr, + emptyCompileContext, + astUtil, + ); + expect(intrepretedValue.kind).toBe("number"); + + expect(compiledValue).toBe( + (intrepretedValue as Ast.Number).value, + ); + }, + ); + await checkAsyncProperty(property); + }, + 20 * 1000, + ); }); From 6611366078057a94e258e8276eba59c16ed2fbf9 Mon Sep 17 00:00:00 2001 From: Mell0r Date: Thu, 10 Apr 2025 23:54:52 +0300 Subject: [PATCH 23/44] fix: types in util functions specified more clearly, removed any cast --- src/test/fuzzer/src/util.ts | 19 ++++++++++--------- 1 file changed, 10 insertions(+), 9 deletions(-) diff --git a/src/test/fuzzer/src/util.ts b/src/test/fuzzer/src/util.ts index b4059fcc7b..0aea0011d5 100644 --- a/src/test/fuzzer/src/util.ts +++ b/src/test/fuzzer/src/util.ts @@ -88,7 +88,9 @@ export function createProperty( /** * Create parameters for custom property checking. */ -function makeParams(numRuns: number | undefined): fc.Parameters { +function makeParams( + numRuns: number | undefined, +): fc.Parameters { return { numRuns: numRuns ?? GlobalContext.config.numRuns, seed: GlobalContext.config.seed, @@ -98,11 +100,10 @@ function makeParams(numRuns: number | undefined): fc.Parameters { out.counterexample !== null && out.errorInstance instanceof Error ) { - // eslint-disable-next-line @typescript-eslint/no-explicit-any - let generated: any = out.counterexample; - if (!generated.kind && generated[0]?.kind) { - generated = generated[0]; - } + const generated = + "kind" in out.counterexample + ? out.counterexample + : out.counterexample[0]!; out.errorInstance.message += `\n-----\nGenerated program:\n${GlobalContext.format(generated)}\n-----\n`; } throw new Error(fc.defaultReportMessage(out)); @@ -114,8 +115,8 @@ function makeParams(numRuns: number | undefined): fc.Parameters { /** * Checks the given property enhancing `fc.assert` with additional functionality. */ -export function checkProperty( - property: fc.IPropertyWithHooks, +export function checkProperty( + property: fc.IPropertyWithHooks, numRuns: number | undefined = undefined, ) { fc.assert(property, makeParams(numRuns)); @@ -125,7 +126,7 @@ export function checkProperty( * Checks the given async property enhancing `fc.assert` with additional functionality. */ export async function checkAsyncProperty( - property: fc.IAsyncPropertyWithHooks, + property: fc.IAsyncPropertyWithHooks, numRuns: number | undefined = undefined, ) { await fc.assert(property, makeParams(numRuns)); From 34fd4e86990f7246779fe7c7610987e6a46194f4 Mon Sep 17 00:00:00 2001 From: jeshecdom Date: Fri, 11 Apr 2025 11:17:32 +0200 Subject: [PATCH 24/44] tests: Added logarithmic counts. --- .../fuzzer/src/generators/uniform-expr-gen.ts | 553 ++++++++++-------- 1 file changed, 293 insertions(+), 260 deletions(-) diff --git a/src/test/fuzzer/src/generators/uniform-expr-gen.ts b/src/test/fuzzer/src/generators/uniform-expr-gen.ts index 14a3806350..fd0da8850a 100644 --- a/src/test/fuzzer/src/generators/uniform-expr-gen.ts +++ b/src/test/fuzzer/src/generators/uniform-expr-gen.ts @@ -2,7 +2,6 @@ import type * as Ast from "@/ast/ast"; import { getAstFactory } from "@/ast/ast-helpers"; import { getMakeAst } from "@/ast/generated/make-factory"; import type { MakeAstFactory } from "@/ast/generated/make-factory"; -import { statistics } from "@/test/fuzzer/test/expression-stats"; import { beginCell } from "@ton/core"; import type { Address, Cell } from "@ton/core"; import { sha256_sync } from "@ton/crypto"; @@ -35,31 +34,31 @@ type GenContext = { }; const NonTerminal = { - Initial: { terminal: false, literal: false, index: 0 }, - Int: { terminal: false, literal: false, index: 1 }, - OptInt: { terminal: false, literal: false, index: 2 }, - LiteralInt: { terminal: false, literal: true, index: 3 }, - LiteralOptInt: { terminal: false, literal: true, index: 4 }, - Bool: { terminal: false, literal: false, index: 5 }, - OptBool: { terminal: false, literal: false, index: 6 }, - LiteralBool: { terminal: false, literal: true, index: 7 }, - LiteralOptBool: { terminal: false, literal: true, index: 8 }, - Cell: { terminal: false, literal: false, index: 9 }, - OptCell: { terminal: false, literal: false, index: 10 }, - LiteralCell: { terminal: false, literal: true, index: 11 }, - LiteralOptCell: { terminal: false, literal: true, index: 12 }, - Slice: { terminal: false, literal: false, index: 13 }, - OptSlice: { terminal: false, literal: false, index: 14 }, - LiteralSlice: { terminal: false, literal: true, index: 15 }, - LiteralOptSlice: { terminal: false, literal: true, index: 16 }, - Address: { terminal: false, literal: false, index: 17 }, - OptAddress: { terminal: false, literal: false, index: 18 }, - LiteralAddress: { terminal: false, literal: true, index: 19 }, - LiteralOptAddress: { terminal: false, literal: true, index: 20 }, - String: { terminal: false, literal: false, index: 21 }, - OptString: { terminal: false, literal: false, index: 22 }, - LiteralString: { terminal: false, literal: true, index: 23 }, - LiteralOptString: { terminal: false, literal: true, index: 24 }, + Initial: { terminal: false, literal: false, id: 0 }, + Int: { terminal: false, literal: false, id: 1 }, + OptInt: { terminal: false, literal: false, id: 2 }, + LiteralInt: { terminal: false, literal: true, id: 3 }, + LiteralOptInt: { terminal: false, literal: true, id: 4 }, + Bool: { terminal: false, literal: false, id: 5 }, + OptBool: { terminal: false, literal: false, id: 6 }, + LiteralBool: { terminal: false, literal: true, id: 7 }, + LiteralOptBool: { terminal: false, literal: true, id: 8 }, + Cell: { terminal: false, literal: false, id: 9 }, + OptCell: { terminal: false, literal: false, id: 10 }, + LiteralCell: { terminal: false, literal: true, id: 11 }, + LiteralOptCell: { terminal: false, literal: true, id: 12 }, + Slice: { terminal: false, literal: false, id: 13 }, + OptSlice: { terminal: false, literal: false, id: 14 }, + LiteralSlice: { terminal: false, literal: true, id: 15 }, + LiteralOptSlice: { terminal: false, literal: true, id: 16 }, + Address: { terminal: false, literal: false, id: 17 }, + OptAddress: { terminal: false, literal: false, id: 18 }, + LiteralAddress: { terminal: false, literal: true, id: 19 }, + LiteralOptAddress: { terminal: false, literal: true, id: 20 }, + String: { terminal: false, literal: false, id: 21 }, + OptString: { terminal: false, literal: false, id: 22 }, + LiteralString: { terminal: false, literal: true, id: 23 }, + LiteralOptString: { terminal: false, literal: true, id: 24 }, } as const; type NonTerminalEnum = (typeof NonTerminal)[keyof typeof NonTerminal]; @@ -126,74 +125,74 @@ type Token = TerminalEnum | NonTerminalEnum; type ExprProduction = { tokens: Token[]; - index: number; + id: number; }; -const productions: ExprProduction[][] = [ +const allProductions: ExprProduction[][] = [ [ // Productions for Initial - { index: 0, tokens: [NonTerminal.Int] }, - { index: 1, tokens: [NonTerminal.OptInt] }, - { index: 2, tokens: [NonTerminal.LiteralInt] }, - { index: 3, tokens: [NonTerminal.LiteralOptInt] }, - { index: 4, tokens: [NonTerminal.Bool] }, - { index: 5, tokens: [NonTerminal.OptBool] }, - { index: 6, tokens: [NonTerminal.LiteralBool] }, - { index: 7, tokens: [NonTerminal.LiteralOptBool] }, - { index: 8, tokens: [NonTerminal.Cell] }, - { index: 9, tokens: [NonTerminal.OptCell] }, - { index: 10, tokens: [NonTerminal.LiteralCell] }, - { index: 11, tokens: [NonTerminal.LiteralOptCell] }, - { index: 12, tokens: [NonTerminal.Slice] }, - { index: 13, tokens: [NonTerminal.OptSlice] }, - { index: 14, tokens: [NonTerminal.LiteralSlice] }, - { index: 15, tokens: [NonTerminal.LiteralOptSlice] }, - { index: 16, tokens: [NonTerminal.Address] }, - { index: 17, tokens: [NonTerminal.OptAddress] }, - { index: 18, tokens: [NonTerminal.LiteralAddress] }, - { index: 19, tokens: [NonTerminal.LiteralOptAddress] }, - { index: 20, tokens: [NonTerminal.String] }, - { index: 21, tokens: [NonTerminal.LiteralString] }, - { index: 22, tokens: [NonTerminal.OptString] }, - { index: 23, tokens: [NonTerminal.LiteralOptString] }, + { id: 0, tokens: [NonTerminal.Int] }, + { id: 1, tokens: [NonTerminal.OptInt] }, + { id: 2, tokens: [NonTerminal.LiteralInt] }, + { id: 3, tokens: [NonTerminal.LiteralOptInt] }, + { id: 4, tokens: [NonTerminal.Bool] }, + { id: 5, tokens: [NonTerminal.OptBool] }, + { id: 6, tokens: [NonTerminal.LiteralBool] }, + { id: 7, tokens: [NonTerminal.LiteralOptBool] }, + { id: 8, tokens: [NonTerminal.Cell] }, + { id: 9, tokens: [NonTerminal.OptCell] }, + { id: 10, tokens: [NonTerminal.LiteralCell] }, + { id: 11, tokens: [NonTerminal.LiteralOptCell] }, + { id: 12, tokens: [NonTerminal.Slice] }, + { id: 13, tokens: [NonTerminal.OptSlice] }, + { id: 14, tokens: [NonTerminal.LiteralSlice] }, + { id: 15, tokens: [NonTerminal.LiteralOptSlice] }, + { id: 16, tokens: [NonTerminal.Address] }, + { id: 17, tokens: [NonTerminal.OptAddress] }, + { id: 18, tokens: [NonTerminal.LiteralAddress] }, + { id: 19, tokens: [NonTerminal.LiteralOptAddress] }, + { id: 20, tokens: [NonTerminal.String] }, + { id: 21, tokens: [NonTerminal.LiteralString] }, + { id: 22, tokens: [NonTerminal.OptString] }, + { id: 23, tokens: [NonTerminal.LiteralOptString] }, ], [ // Productions for Int - { index: 0, tokens: [Terminal.add, NonTerminal.Int, NonTerminal.Int] }, + { id: 0, tokens: [Terminal.add, NonTerminal.Int, NonTerminal.Int] }, { - index: 1, + id: 1, tokens: [Terminal.minus, NonTerminal.Int, NonTerminal.Int], }, - { index: 2, tokens: [Terminal.mult, NonTerminal.Int, NonTerminal.Int] }, - { index: 3, tokens: [Terminal.div, NonTerminal.Int, NonTerminal.Int] }, - { index: 4, tokens: [Terminal.mod, NonTerminal.Int, NonTerminal.Int] }, + { id: 2, tokens: [Terminal.mult, NonTerminal.Int, NonTerminal.Int] }, + { id: 3, tokens: [Terminal.div, NonTerminal.Int, NonTerminal.Int] }, + { id: 4, tokens: [Terminal.mod, NonTerminal.Int, NonTerminal.Int] }, { - index: 5, + id: 5, tokens: [Terminal.shift_r, NonTerminal.Int, NonTerminal.Int], }, { - index: 6, + id: 6, tokens: [Terminal.shift_l, NonTerminal.Int, NonTerminal.Int], }, { - index: 7, + id: 7, tokens: [Terminal.bit_and, NonTerminal.Int, NonTerminal.Int], }, { - index: 8, + id: 8, tokens: [Terminal.bit_or, NonTerminal.Int, NonTerminal.Int], }, { - index: 9, + id: 9, tokens: [Terminal.bit_xor, NonTerminal.Int, NonTerminal.Int], }, - { index: 10, tokens: [Terminal.unary_plus, NonTerminal.Int] }, - { index: 11, tokens: [Terminal.unary_minus, NonTerminal.Int] }, - { index: 12, tokens: [Terminal.bit_not, NonTerminal.Int] }, + { id: 10, tokens: [Terminal.unary_plus, NonTerminal.Int] }, + { id: 11, tokens: [Terminal.unary_minus, NonTerminal.Int] }, + { id: 12, tokens: [Terminal.bit_not, NonTerminal.Int] }, - { index: 13, tokens: [Terminal.non_null_assert, NonTerminal.OptInt] }, + { id: 13, tokens: [Terminal.non_null_assert, NonTerminal.OptInt] }, { - index: 14, + id: 14, tokens: [ Terminal.cond, NonTerminal.Bool, @@ -201,14 +200,14 @@ const productions: ExprProduction[][] = [ NonTerminal.Int, ], }, - { index: 15, tokens: [Terminal.id_int] }, - { index: 16, tokens: [NonTerminal.LiteralInt] }, + { id: 15, tokens: [Terminal.id_int] }, + { id: 16, tokens: [NonTerminal.LiteralInt] }, ], [ // Productions for OptInt - { index: 0, tokens: [Terminal.opt_inj, NonTerminal.Int] }, + { id: 0, tokens: [Terminal.opt_inj, NonTerminal.Int] }, { - index: 1, + id: 1, tokens: [ Terminal.cond, NonTerminal.Bool, @@ -216,83 +215,83 @@ const productions: ExprProduction[][] = [ NonTerminal.OptInt, ], }, - { index: 2, tokens: [Terminal.id_opt_int] }, - { index: 3, tokens: [NonTerminal.LiteralOptInt] }, + { id: 2, tokens: [Terminal.id_opt_int] }, + { id: 3, tokens: [NonTerminal.LiteralOptInt] }, ], [ // Productions for LiteralInt - { index: 0, tokens: [Terminal.integer] }, + { id: 0, tokens: [Terminal.integer] }, ], [ // Productions for LiteralOptInt - { index: 0, tokens: [Terminal.null] }, - { index: 1, tokens: [Terminal.opt_inj, NonTerminal.LiteralInt] }, + { id: 0, tokens: [Terminal.null] }, + { id: 1, tokens: [Terminal.opt_inj, NonTerminal.LiteralInt] }, ], [ // Productions for Bool - { index: 0, tokens: [Terminal.eq, NonTerminal.Int, NonTerminal.Int] }, + { id: 0, tokens: [Terminal.eq, NonTerminal.Int, NonTerminal.Int] }, { - index: 1, + id: 1, tokens: [Terminal.eq, NonTerminal.OptInt, NonTerminal.OptInt], }, - { index: 2, tokens: [Terminal.eq, NonTerminal.Bool, NonTerminal.Bool] }, + { id: 2, tokens: [Terminal.eq, NonTerminal.Bool, NonTerminal.Bool] }, { - index: 3, + id: 3, tokens: [Terminal.eq, NonTerminal.OptBool, NonTerminal.OptBool], }, { - index: 4, + id: 4, tokens: [Terminal.eq, NonTerminal.Address, NonTerminal.Address], }, { - index: 5, + id: 5, tokens: [ Terminal.eq, NonTerminal.OptAddress, NonTerminal.OptAddress, ], }, - { index: 6, tokens: [Terminal.eq, NonTerminal.Cell, NonTerminal.Cell] }, + { id: 6, tokens: [Terminal.eq, NonTerminal.Cell, NonTerminal.Cell] }, { - index: 7, + id: 7, tokens: [Terminal.eq, NonTerminal.OptCell, NonTerminal.OptCell], }, { - index: 8, + id: 8, tokens: [Terminal.eq, NonTerminal.Slice, NonTerminal.Slice], }, { - index: 9, + id: 9, tokens: [Terminal.eq, NonTerminal.OptSlice, NonTerminal.OptSlice], }, { - index: 10, + id: 10, tokens: [Terminal.eq, NonTerminal.String, NonTerminal.String], }, { - index: 11, + id: 11, tokens: [Terminal.eq, NonTerminal.OptString, NonTerminal.OptString], }, - { index: 12, tokens: [Terminal.neq, NonTerminal.Int, NonTerminal.Int] }, + { id: 12, tokens: [Terminal.neq, NonTerminal.Int, NonTerminal.Int] }, { - index: 13, + id: 13, tokens: [Terminal.neq, NonTerminal.OptInt, NonTerminal.OptInt], }, { - index: 14, + id: 14, tokens: [Terminal.neq, NonTerminal.Bool, NonTerminal.Bool], }, { - index: 15, + id: 15, tokens: [Terminal.neq, NonTerminal.OptBool, NonTerminal.OptBool], }, { - index: 16, + id: 16, tokens: [Terminal.neq, NonTerminal.Address, NonTerminal.Address], }, { - index: 17, + id: 17, tokens: [ Terminal.neq, NonTerminal.OptAddress, @@ -300,27 +299,27 @@ const productions: ExprProduction[][] = [ ], }, { - index: 18, + id: 18, tokens: [Terminal.neq, NonTerminal.Cell, NonTerminal.Cell], }, { - index: 19, + id: 19, tokens: [Terminal.neq, NonTerminal.OptCell, NonTerminal.OptCell], }, { - index: 20, + id: 20, tokens: [Terminal.neq, NonTerminal.Slice, NonTerminal.Slice], }, { - index: 21, + id: 21, tokens: [Terminal.neq, NonTerminal.OptSlice, NonTerminal.OptSlice], }, { - index: 22, + id: 22, tokens: [Terminal.neq, NonTerminal.String, NonTerminal.String], }, { - index: 23, + id: 23, tokens: [ Terminal.neq, NonTerminal.OptString, @@ -328,23 +327,23 @@ const productions: ExprProduction[][] = [ ], }, - { index: 24, tokens: [Terminal.lt, NonTerminal.Int, NonTerminal.Int] }, - { index: 25, tokens: [Terminal.le, NonTerminal.Int, NonTerminal.Int] }, - { index: 26, tokens: [Terminal.gt, NonTerminal.Int, NonTerminal.Int] }, - { index: 27, tokens: [Terminal.ge, NonTerminal.Int, NonTerminal.Int] }, + { id: 24, tokens: [Terminal.lt, NonTerminal.Int, NonTerminal.Int] }, + { id: 25, tokens: [Terminal.le, NonTerminal.Int, NonTerminal.Int] }, + { id: 26, tokens: [Terminal.gt, NonTerminal.Int, NonTerminal.Int] }, + { id: 27, tokens: [Terminal.ge, NonTerminal.Int, NonTerminal.Int] }, { - index: 28, + id: 28, tokens: [Terminal.and, NonTerminal.Bool, NonTerminal.Bool], }, { - index: 29, + id: 29, tokens: [Terminal.or, NonTerminal.Bool, NonTerminal.Bool], }, - { index: 30, tokens: [Terminal.not, NonTerminal.Bool] }, + { id: 30, tokens: [Terminal.not, NonTerminal.Bool] }, - { index: 31, tokens: [Terminal.non_null_assert, NonTerminal.OptBool] }, + { id: 31, tokens: [Terminal.non_null_assert, NonTerminal.OptBool] }, { - index: 32, + id: 32, tokens: [ Terminal.cond, NonTerminal.Bool, @@ -352,14 +351,14 @@ const productions: ExprProduction[][] = [ NonTerminal.Bool, ], }, - { index: 33, tokens: [Terminal.id_bool] }, - { index: 34, tokens: [NonTerminal.LiteralBool] }, + { id: 33, tokens: [Terminal.id_bool] }, + { id: 34, tokens: [NonTerminal.LiteralBool] }, ], [ // Productions for OptBool - { index: 0, tokens: [Terminal.opt_inj, NonTerminal.Bool] }, + { id: 0, tokens: [Terminal.opt_inj, NonTerminal.Bool] }, { - index: 1, + id: 1, tokens: [ Terminal.cond, NonTerminal.Bool, @@ -367,25 +366,25 @@ const productions: ExprProduction[][] = [ NonTerminal.OptBool, ], }, - { index: 2, tokens: [Terminal.id_opt_bool] }, - { index: 3, tokens: [NonTerminal.LiteralOptBool] }, + { id: 2, tokens: [Terminal.id_opt_bool] }, + { id: 3, tokens: [NonTerminal.LiteralOptBool] }, ], [ // Productions for LiteralBool - { index: 0, tokens: [Terminal.bool] }, + { id: 0, tokens: [Terminal.bool] }, ], [ // Productions for LiteralOptBool - { index: 0, tokens: [Terminal.null] }, - { index: 1, tokens: [Terminal.opt_inj, NonTerminal.LiteralBool] }, + { id: 0, tokens: [Terminal.null] }, + { id: 1, tokens: [Terminal.opt_inj, NonTerminal.LiteralBool] }, ], [ // Productions for Cell - { index: 0, tokens: [Terminal.code_of] }, + { id: 0, tokens: [Terminal.code_of] }, - { index: 1, tokens: [Terminal.non_null_assert, NonTerminal.OptCell] }, + { id: 1, tokens: [Terminal.non_null_assert, NonTerminal.OptCell] }, { - index: 2, + id: 2, tokens: [ Terminal.cond, NonTerminal.Bool, @@ -393,14 +392,14 @@ const productions: ExprProduction[][] = [ NonTerminal.Cell, ], }, - { index: 3, tokens: [Terminal.id_cell] }, - { index: 4, tokens: [NonTerminal.LiteralCell] }, + { id: 3, tokens: [Terminal.id_cell] }, + { id: 4, tokens: [NonTerminal.LiteralCell] }, ], [ // Productions for OptCell - { index: 0, tokens: [Terminal.opt_inj, NonTerminal.Cell] }, + { id: 0, tokens: [Terminal.opt_inj, NonTerminal.Cell] }, { - index: 1, + id: 1, tokens: [ Terminal.cond, NonTerminal.Bool, @@ -408,23 +407,23 @@ const productions: ExprProduction[][] = [ NonTerminal.OptCell, ], }, - { index: 2, tokens: [Terminal.id_opt_cell] }, - { index: 3, tokens: [NonTerminal.LiteralOptCell] }, + { id: 2, tokens: [Terminal.id_opt_cell] }, + { id: 3, tokens: [NonTerminal.LiteralOptCell] }, ], [ // Productions for LiteralCell - { index: 0, tokens: [Terminal.cell] }, + { id: 0, tokens: [Terminal.cell] }, ], [ // Productions for LiteralOptCell - { index: 0, tokens: [Terminal.null] }, - { index: 1, tokens: [Terminal.opt_inj, NonTerminal.LiteralCell] }, + { id: 0, tokens: [Terminal.null] }, + { id: 1, tokens: [Terminal.opt_inj, NonTerminal.LiteralCell] }, ], [ // Productions for Slice - { index: 0, tokens: [Terminal.non_null_assert, NonTerminal.OptSlice] }, + { id: 0, tokens: [Terminal.non_null_assert, NonTerminal.OptSlice] }, { - index: 1, + id: 1, tokens: [ Terminal.cond, NonTerminal.Bool, @@ -432,14 +431,14 @@ const productions: ExprProduction[][] = [ NonTerminal.Slice, ], }, - { index: 2, tokens: [Terminal.id_slice] }, - { index: 3, tokens: [NonTerminal.LiteralSlice] }, + { id: 2, tokens: [Terminal.id_slice] }, + { id: 3, tokens: [NonTerminal.LiteralSlice] }, ], [ // Productions for OptSlice - { index: 0, tokens: [Terminal.opt_inj, NonTerminal.Slice] }, + { id: 0, tokens: [Terminal.opt_inj, NonTerminal.Slice] }, { - index: 1, + id: 1, tokens: [ Terminal.cond, NonTerminal.Bool, @@ -447,26 +446,26 @@ const productions: ExprProduction[][] = [ NonTerminal.OptSlice, ], }, - { index: 2, tokens: [Terminal.id_opt_slice] }, - { index: 3, tokens: [NonTerminal.LiteralOptSlice] }, + { id: 2, tokens: [Terminal.id_opt_slice] }, + { id: 3, tokens: [NonTerminal.LiteralOptSlice] }, ], [ // Productions for LiteralSlice - { index: 0, tokens: [Terminal.slice] }, + { id: 0, tokens: [Terminal.slice] }, ], [ // Productions for LiteralOptSlice - { index: 0, tokens: [Terminal.null] }, - { index: 1, tokens: [Terminal.opt_inj, NonTerminal.LiteralSlice] }, + { id: 0, tokens: [Terminal.null] }, + { id: 1, tokens: [Terminal.opt_inj, NonTerminal.LiteralSlice] }, ], [ // Productions for Address { - index: 0, + id: 0, tokens: [Terminal.non_null_assert, NonTerminal.OptAddress], }, { - index: 1, + id: 1, tokens: [ Terminal.cond, NonTerminal.Bool, @@ -474,14 +473,14 @@ const productions: ExprProduction[][] = [ NonTerminal.Address, ], }, - { index: 2, tokens: [Terminal.id_address] }, - { index: 3, tokens: [NonTerminal.LiteralAddress] }, + { id: 2, tokens: [Terminal.id_address] }, + { id: 3, tokens: [NonTerminal.LiteralAddress] }, ], [ // Productions for OptAddress - { index: 0, tokens: [Terminal.opt_inj, NonTerminal.Address] }, + { id: 0, tokens: [Terminal.opt_inj, NonTerminal.Address] }, { - index: 1, + id: 1, tokens: [ Terminal.cond, NonTerminal.Bool, @@ -489,23 +488,23 @@ const productions: ExprProduction[][] = [ NonTerminal.OptAddress, ], }, - { index: 2, tokens: [Terminal.id_opt_address] }, - { index: 3, tokens: [NonTerminal.LiteralOptAddress] }, + { id: 2, tokens: [Terminal.id_opt_address] }, + { id: 3, tokens: [NonTerminal.LiteralOptAddress] }, ], [ // Productions for LiteralAddress - { index: 0, tokens: [Terminal.address] }, + { id: 0, tokens: [Terminal.address] }, ], [ // Productions for LiteralOptAddress - { index: 0, tokens: [Terminal.null] }, - { index: 1, tokens: [Terminal.opt_inj, NonTerminal.LiteralAddress] }, + { id: 0, tokens: [Terminal.null] }, + { id: 1, tokens: [Terminal.opt_inj, NonTerminal.LiteralAddress] }, ], [ // Productions for String - { index: 0, tokens: [Terminal.non_null_assert, NonTerminal.OptString] }, + { id: 0, tokens: [Terminal.non_null_assert, NonTerminal.OptString] }, { - index: 1, + id: 1, tokens: [ Terminal.cond, NonTerminal.Bool, @@ -513,14 +512,14 @@ const productions: ExprProduction[][] = [ NonTerminal.String, ], }, - { index: 2, tokens: [Terminal.id_string] }, - { index: 3, tokens: [NonTerminal.LiteralString] }, + { id: 2, tokens: [Terminal.id_string] }, + { id: 3, tokens: [NonTerminal.LiteralString] }, ], [ // Productions for OptString - { index: 0, tokens: [Terminal.opt_inj, NonTerminal.String] }, + { id: 0, tokens: [Terminal.opt_inj, NonTerminal.String] }, { - index: 1, + id: 1, tokens: [ Terminal.cond, NonTerminal.Bool, @@ -528,22 +527,81 @@ const productions: ExprProduction[][] = [ NonTerminal.OptString, ], }, - { index: 2, tokens: [Terminal.id_opt_string] }, - { index: 3, tokens: [NonTerminal.LiteralOptString] }, + { id: 2, tokens: [Terminal.id_opt_string] }, + { id: 3, tokens: [NonTerminal.LiteralOptString] }, ], [ // Productions for LiteralString - { index: 0, tokens: [Terminal.string] }, + { id: 0, tokens: [Terminal.string] }, ], [ // Productions for LiteralOptString - { index: 0, tokens: [Terminal.null] }, - { index: 1, tokens: [Terminal.opt_inj, NonTerminal.LiteralString] }, + { id: 0, tokens: [Terminal.null] }, + { id: 1, tokens: [Terminal.opt_inj, NonTerminal.LiteralString] }, ], ]; function sum(counts: number[]): number { - return counts.reduce((prev, curr) => prev + curr, 0); + // If at least one array element (which are counts represented as logarithms) is -Inf, it means that they represent the count 0. + // therefore, they can be filtered out from the array, because they will not affect the final sum + const filteredCounts = counts.filter((n) => n !== Number.NEGATIVE_INFINITY); + + if (filteredCounts.length === 0) { + // The sum would be 0. So, return -Inf + return Number.NEGATIVE_INFINITY; + } + if (filteredCounts.length === 1) { + return filteredCounts[0]!; + } + const first = filteredCounts[0]!; + // For the general case, we reduce the array thanks to the following formula: + // log(x + y) = log x + log(1 + 2^(log y - log x)) + // which tells us how we should add counts when they are represented as logarithms + const bla = filteredCounts + .slice(1) + .reduce( + (prev, curr) => prev + Math.log2(1 + 2 ** (curr - prev)), + first, + ); + return bla; +} + +function normalizeArray(counts: number[]): number[] { + // Any -Inf represents a count of 0, which means that such index should never get selected. + // So, it is enough to transform -Inf back to 0. + // Any 0 represents a count of 1. Since such index has a non-zero probability to be selected, + // we change the 0s to 1s. The rest of numbers we take their ceil to transform them into integers. + const bla = counts.map((n) => { + if (n === Number.NEGATIVE_INFINITY) { + return 0; + } + if (n === 0) { + return 1; + } + return Math.ceil(n); + }); + return bla; +} + +function multiply(first: number, second: number): number { + // If at least one input (which are counts represented as logarithms) is -Inf, it means that they represent the count 0. + // therefore, their multiplication is also 0 (or -Inf in the logarithm representation) + if ( + first === Number.NEGATIVE_INFINITY || + second === Number.NEGATIVE_INFINITY + ) { + return Number.NEGATIVE_INFINITY; + } else { + // To multiply two counts represented as logarithms, it is enough to add their representations + // thanks to this formula: + // log(x * y) = log(x) + log(y) + return first + second; + } +} + +function transform(n: number): number { + // We transform counts into their base-2 logarithmic representation + return Math.log2(n); } function computeCountTables( @@ -653,15 +711,13 @@ function computeCountTables( ]; } - function countFromNonTerminal(index: number, size: number): number[] { - const peekedCounts = peekNonTerminalCounts(index, size); + function countFromNonTerminal(id: number, size: number): number[] { + const peekedCounts = peekNonTerminalCounts(id, size); if (typeof peekedCounts !== "undefined") { return peekedCounts; } - const prods = getProductions(index); - return prods.map((prod) => - sum(countFromProduction(index, prod, 0, size)), - ); + const prods = getProductions(id); + return prods.map((prod) => sum(countFromProduction(id, prod, 0, size))); } function countFromProduction( @@ -675,7 +731,7 @@ function computeCountTables( } const peekedCounts = peekSizeSplitCounts( nonTerminalIndex, - production.index, + production.id, tokenIndex, size, ); @@ -686,7 +742,8 @@ function computeCountTables( if (head.terminal) { if (tokenIndex === production.tokens.length - 1) { // i.e., the head is the last symbol in the production - return size === 1 ? [1] : [0]; + // Transform the values 1 and 0 to whatever representation of counts we are currently using + return size === 1 ? [transform(1)] : [transform(0)]; } else { return [ sum( @@ -703,7 +760,7 @@ function computeCountTables( // head is not a terminal if (tokenIndex === production.tokens.length - 1) { // i.e., the head is the last symbol in the production - return [sum(countFromNonTerminal(head.index, size))]; + return [sum(countFromNonTerminal(head.id, size))]; } else { const result: number[] = []; @@ -712,7 +769,7 @@ function computeCountTables( l <= size - production.tokens.length + tokenIndex + 1; l++ ) { - const partition1 = sum(countFromNonTerminal(head.index, l)); + const partition1 = sum(countFromNonTerminal(head.id, l)); const partition2 = sum( countFromProduction( nonTerminalIndex, @@ -721,7 +778,7 @@ function computeCountTables( size - l, ), ); - result.push(partition1 * partition2); + result.push(multiply(partition1, partition2)); } return result; } @@ -732,14 +789,15 @@ function computeCountTables( // The first step is to initialize the tables for size 0 for (const nonTerminal of nonTerminals) { - const nonTerminalIdx = nonTerminal.index; + const nonTerminalIdx = nonTerminal.id; const productions = getProductions(nonTerminalIdx); + // Transform count 0 to whatever representation of counts we are currently using updateNonTerminalCounts( nonTerminalIdx, 0, - productions.map((_) => 0), + productions.map((_) => transform(0)), ); for (const prod of productions) { @@ -750,7 +808,7 @@ function computeCountTables( ) { updateSizeSplitCounts( nonTerminalIdx, - prod.index, + prod.id, tokenIndx, 0, [], @@ -762,7 +820,7 @@ function computeCountTables( // Now, for the rest of sizes for (let size = 1; size <= maxSize; size++) { for (const nonTerminal of nonTerminals) { - const nonTerminalIdx = nonTerminal.index; + const nonTerminalIdx = nonTerminal.id; const productions = getProductions(nonTerminalIdx); @@ -774,7 +832,7 @@ function computeCountTables( ) { updateSizeSplitCounts( nonTerminalIdx, - prod.index, + prod.id, tokenIndx, size, countFromProduction( @@ -798,21 +856,22 @@ function computeCountTables( function doTotalCounts() { // From 0 to minSize-1, set counts to 0, since we are not going to choose those sizes + // Transform the count 0 to whatever representation we are currently using for (let size = 0; size < minSize; size++) { for (const nonTerminal of Object.values(NonTerminal)) { - updateTotalCounts(nonTerminal.index, size, 0); + updateTotalCounts(nonTerminal.id, size, transform(0)); } } for (let size = minSize; size <= maxSize; size++) { for (const nonTerminal of Object.values(NonTerminal)) { updateTotalCounts( - nonTerminal.index, + nonTerminal.id, size, sum( lookupNonTerminalCounts( nonTerminalCounts, - nonTerminal.index, + nonTerminal.id, size, ), ), @@ -821,7 +880,7 @@ function computeCountTables( } } - function accumulateArray(counts: number[]): number[] { + function computePartialSums(counts: number[]): number[] { if (counts.length === 0) { return counts; } @@ -832,15 +891,15 @@ function computeCountTables( return result; } - function accumulateCounts() { + function normalizeCounts() { // The total counts for (const nonTerminal of Object.values(NonTerminal)) { - const counts = totalCounts[nonTerminal.index]; + const counts = totalCounts[nonTerminal.id]; if (typeof counts === "undefined") { - throw new Error(`Index ${nonTerminal.index} out of bounds`); + throw new Error(`Index ${nonTerminal.id} out of bounds`); } - const newCounts = accumulateArray(counts); - totalCounts[nonTerminal.index] = newCounts; + const newCounts = computePartialSums(normalizeArray(counts)); + totalCounts[nonTerminal.id] = newCounts; } // The non-terminal counts @@ -848,17 +907,17 @@ function computeCountTables( for (let size = 0; size <= maxSize; size++) { const counts = lookupNonTerminalCounts( nonTerminalCounts, - nonTerminal.index, + nonTerminal.id, size, ); - const newCounts = accumulateArray(counts); - updateNonTerminalCounts(nonTerminal.index, size, newCounts); + const newCounts = computePartialSums(normalizeArray(counts)); + updateNonTerminalCounts(nonTerminal.id, size, newCounts); } } // Split size counts for (const nonTerminal of Object.values(NonTerminal)) { - const nonTerminalIdx = nonTerminal.index; + const nonTerminalIdx = nonTerminal.id; const productions = getProductions(nonTerminalIdx); @@ -871,15 +930,17 @@ function computeCountTables( for (let size = 0; size <= maxSize; size++) { const counts = lookupSizeSplitCounts( sizeSplitCounts, - nonTerminal.index, - prod.index, + nonTerminal.id, + prod.id, tokenIndx, size, ); - const newCounts = accumulateArray(counts); + const newCounts = computePartialSums( + normalizeArray(counts), + ); updateSizeSplitCounts( - nonTerminal.index, - prod.index, + nonTerminal.id, + prod.id, tokenIndx, size, newCounts, @@ -898,7 +959,7 @@ function computeCountTables( // Now the rest of non-terminals, but not the initial non-terminal doCountsForNonTerminals( Object.values(NonTerminal).filter( - (nonTerminal) => !nonTerminal.literal && nonTerminal.index !== 0, + (nonTerminal) => !nonTerminal.literal && nonTerminal.id !== 0, ), ); @@ -907,7 +968,14 @@ function computeCountTables( doTotalCounts(); - accumulateCounts(); + // Now that the tables are filled, we need to normalize the counts + // into non-negative integers (because they may be currently encoded + // in a different way. For example, when using logarithms to represent + // counts, the numbers have fractional part, and may also include -Inf). + // Also, once they are normalized into non-negative integers, + // we need to compute their partial sums, in preparation for the generation + // process. + normalizeCounts(); return { nonTerminalCounts, @@ -970,36 +1038,33 @@ function lookupTotalCounts( } function getProductions(idx: number): ExprProduction[] { - const prods = productions[idx]; + const prods = allProductions[idx]; if (typeof prods === "undefined") { - throw new Error(`${idx} is not a valid index for a non-terminal`); + throw new Error(`${idx} is not a valid id for a non-terminal`); } return prods; } -function getTokenAt(tokens: Token[], index: number): Token { - const token = tokens[index]; +function getTokenAt(tokens: Token[], id: number): Token { + const token = tokens[id]; if (typeof token === "undefined") { - throw new Error(`Index ${index} is out of bounds`); + throw new Error(`Index ${id} is out of bounds`); } return token; } -function getNonTerminalAt(tokens: Token[], index: number): NonTerminalEnum { - const token = getTokenAt(tokens, index); +function getNonTerminalAt(tokens: Token[], id: number): NonTerminalEnum { + const token = getTokenAt(tokens, id); if (token.terminal) { throw new Error(`Was expecting a non-terminal`); } return token; } -function getProductionAt( - prods: ExprProduction[], - index: number, -): ExprProduction { - const prod = prods[index]; +function getProductionAt(prods: ExprProduction[], id: number): ExprProduction { + const prod = prods[id]; if (typeof prod === "undefined") { - throw new Error(`Index ${index} out of bounds in productions array`); + throw new Error(`Index ${id} out of bounds in productions array`); } return prod; } @@ -1012,17 +1077,17 @@ function makeExpression( sizeSplitCounts: number[][][][][], size: number, ): Ast.Expression { - function genFromNonTerminal(index: number, size: number): Ast.Expression { - const prods = getProductions(index); + function genFromNonTerminal(id: number, size: number): Ast.Expression { + const prods = getProductions(id); const nonTerminalOptions = lookupNonTerminalCounts( nonTerminalCounts, - index, + id, size, ); const chosenProdIndex = randomlyChooseIndex(nonTerminalOptions); const production = getProductionAt(prods, chosenProdIndex); - return genFromProduction(index, production, size); + return genFromProduction(id, production, size); } function genFromProduction( @@ -1036,7 +1101,7 @@ function makeExpression( // where head indicates the kind of tree we need to produce return makeTree( nonTerminalIndex, - production.index, + production.id, head, production.tokens.slice(1), size, @@ -1044,7 +1109,7 @@ function makeExpression( } // head is not a terminal // The production must have the form N -> head - return genFromNonTerminal(head.index, size); + return genFromNonTerminal(head.id, size); } function chooseSizeSplit( @@ -1081,12 +1146,9 @@ function makeExpression( const leftNonTerminal = getNonTerminalAt(rest, 0); const rightNonTerminal = getNonTerminalAt(rest, 1); - const leftOperand = genFromNonTerminal( - leftNonTerminal.index, - sizeSplit, - ); + const leftOperand = genFromNonTerminal(leftNonTerminal.id, sizeSplit); const rightOperand = genFromNonTerminal( - rightNonTerminal.index, + rightNonTerminal.id, currSize - sizeSplit, ); return makeF.makeDummyOpBinary(op, leftOperand, rightOperand); @@ -1100,7 +1162,7 @@ function makeExpression( const currSize = size - 1; const operandNonTerminal = getNonTerminalAt(rest, 0); - const operand = genFromNonTerminal(operandNonTerminal.index, currSize); + const operand = genFromNonTerminal(operandNonTerminal.id, currSize); return makeF.makeDummyOpUnary(op, operand); } @@ -1339,7 +1401,7 @@ function makeExpression( case Terminal.opt_inj.id: { const currSize = size - 1; const operandNonTerminal = getNonTerminalAt(rest, 0); - return genFromNonTerminal(operandNonTerminal.index, currSize); + return genFromNonTerminal(operandNonTerminal.id, currSize); } case Terminal.null.id: { return makeF.makeDummyNull(); @@ -1367,15 +1429,15 @@ function makeExpression( const thenNonTerminal = getNonTerminalAt(rest, 1); const elseNonTerminal = getNonTerminalAt(rest, 2); const condOperand = genFromNonTerminal( - condNonTerminal.index, + condNonTerminal.id, sizeSplit1, ); const thenOperand = genFromNonTerminal( - thenNonTerminal.index, + thenNonTerminal.id, sizeSplit2, ); const elseOperand = genFromNonTerminal( - elseNonTerminal.index, + elseNonTerminal.id, currSize - sizeSplit1 - sizeSplit2, ); return makeF.makeDummyConditional( @@ -1423,7 +1485,7 @@ function makeExpression( } } - return genFromNonTerminal(type.index, size); + return genFromNonTerminal(type.id, size); } export function initializeGenerator( @@ -1436,7 +1498,7 @@ export function initializeGenerator( const makeF = getMakeAst(getAstFactory()); return (type: NonTerminalEnum) => { - const sizes = lookupTotalCounts(totalCounts, type.index); + const sizes = lookupTotalCounts(totalCounts, type.id); return fc.constant(0).map((_) => { const size = randomlyChooseIndex(sizes); return makeExpression( @@ -1478,32 +1540,3 @@ function _generateCell(): fc.Arbitrary { return beginCell().storeBuffer(Buffer.from(buf.buffer)).endCell(); }); } - -// Uncomment this to show the bug in fast-check -//console.log(genFromNonTerminal(0,66)); - -//statistics(heightGenerator(10), false); - -// Create a GenContext with allowed identifiers and contracts -const ids: Map = new Map(); -ids.set(AllowedType.Int, ["intV1", "intV2", "intV3"]); -ids.set(AllowedType.OptInt, ["o_intV1", "o_intV2", "o_intV3"]); -ids.set(AllowedType.Bool, ["boolV1", "boolV2", "boolV3"]); -ids.set(AllowedType.OptBool, ["o_boolV1", "o_boolV2", "o_boolV3"]); -ids.set(AllowedType.Cell, ["cellV1", "cellV2", "cellV3"]); -ids.set(AllowedType.OptCell, ["o_cellV1", "o_cellV2", "o_cellV3"]); -ids.set(AllowedType.Slice, ["sliceV1", "sliceV2", "sliceV3"]); -ids.set(AllowedType.OptSlice, ["o_sliceV1", "o_sliceV2", "o_sliceV3"]); -ids.set(AllowedType.Address, ["addressV1", "addressV2", "addressV3"]); -ids.set(AllowedType.OptAddress, ["o_addressV1", "o_addressV2", "o_addressV3"]); -ids.set(AllowedType.String, ["stringV1", "stringV2", "stringV3"]); -ids.set(AllowedType.OptString, ["o_stringV1", "o_stringV2", "o_stringV3"]); - -const ctx: GenContext = { - identifiers: ids, - contractNames: ["C1", "C2"], -}; - -const initialized = initializeGenerator(4, 5, ctx); - -statistics(initialized(NonTerminal.Int), 100, "stats.txt"); From 7959b7ec8184e179d5a8093db02452ab977310c2 Mon Sep 17 00:00:00 2001 From: Mell0r Date: Fri, 11 Apr 2025 12:59:37 +0300 Subject: [PATCH 25/44] fix: error formatted correctly now, fixed interpreter context specification --- src/test/fuzzer/src/util.ts | 32 +++++--- src/test/fuzzer/test/compilation.spec.ts | 12 ++- src/test/fuzzer/test/expression.spec.ts | 95 ++++++++++++++---------- src/test/fuzzer/test/program.spec.ts | 12 ++- 4 files changed, 92 insertions(+), 59 deletions(-) diff --git a/src/test/fuzzer/src/util.ts b/src/test/fuzzer/src/util.ts index 0aea0011d5..5d1e092c27 100644 --- a/src/test/fuzzer/src/util.ts +++ b/src/test/fuzzer/src/util.ts @@ -88,9 +88,10 @@ export function createProperty( /** * Create parameters for custom property checking. */ -function makeParams( +function makeParams( + counterexamplePrinter: (generated: T) => string, numRuns: number | undefined, -): fc.Parameters { +): fc.Parameters { return { numRuns: numRuns ?? GlobalContext.config.numRuns, seed: GlobalContext.config.seed, @@ -100,11 +101,9 @@ function makeParams( out.counterexample !== null && out.errorInstance instanceof Error ) { - const generated = - "kind" in out.counterexample - ? out.counterexample - : out.counterexample[0]!; - out.errorInstance.message += `\n-----\nGenerated program:\n${GlobalContext.format(generated)}\n-----\n`; + out.errorInstance.message += counterexamplePrinter( + out.counterexample, + ); } throw new Error(fc.defaultReportMessage(out)); } @@ -115,21 +114,30 @@ function makeParams( /** * Checks the given property enhancing `fc.assert` with additional functionality. */ -export function checkProperty( - property: fc.IPropertyWithHooks, +export function checkProperty( + property: fc.IPropertyWithHooks, + counterexamplePrinter: (generated: T) => string, numRuns: number | undefined = undefined, ) { - fc.assert(property, makeParams(numRuns)); + fc.assert(property, makeParams(counterexamplePrinter, numRuns)); } /** * Checks the given async property enhancing `fc.assert` with additional functionality. */ export async function checkAsyncProperty( - property: fc.IAsyncPropertyWithHooks, + property: fc.IAsyncPropertyWithHooks, + counterexamplePrinter: (generated: T) => string, numRuns: number | undefined = undefined, ) { - await fc.assert(property, makeParams(numRuns)); + await fc.assert(property, makeParams(counterexamplePrinter, numRuns)); +} + +export function astNodeCounterexamplePrinter( + generated: Ast.AstNode | Ast.AstNode[], +) { + const node = "kind" in generated ? generated : generated[0]!; + return `\n-----\nGenerated ${node.kind}:\n${GlobalContext.format(node)}\n-----\n`; } /** diff --git a/src/test/fuzzer/test/compilation.spec.ts b/src/test/fuzzer/test/compilation.spec.ts index 256acf47fc..3c6f178767 100644 --- a/src/test/fuzzer/test/compilation.spec.ts +++ b/src/test/fuzzer/test/compilation.spec.ts @@ -7,7 +7,11 @@ import fc from "fast-check"; import { Program } from "@/test/fuzzer/src/generators"; import { StdlibCode, StdlibPath } from "@/test/fuzzer/src/stdlib"; -import { withNodeFS, checkAsyncProperty } from "@/test/fuzzer/src/util"; +import { + withNodeFS, + checkAsyncProperty, + astNodeCounterexamplePrinter, +} from "@/test/fuzzer/src/util"; import { compile, precompile, @@ -108,7 +112,11 @@ describe("properties", () => { new Program({ addStdlib: true }).generate(), compileProgram, ); - await checkAsyncProperty(property, /*numRuns=*/ 1); + await checkAsyncProperty( + property, + astNodeCounterexamplePrinter, + /*numRuns=*/ 1, + ); }; if (numRuns === Infinity) { diff --git a/src/test/fuzzer/test/expression.spec.ts b/src/test/fuzzer/test/expression.spec.ts index 4813cf0c25..97b97e7230 100644 --- a/src/test/fuzzer/test/expression.spec.ts +++ b/src/test/fuzzer/test/expression.spec.ts @@ -21,12 +21,12 @@ import { CustomStdlib, checkAsyncProperty, buildModule, + astNodeCounterexamplePrinter, } from "@/test/fuzzer/src/util"; import { FactoryAst, getAstFactory } from "@/ast/ast-helpers"; import { getMakeAst, MakeAstFactory } from "@/ast/generated/make-factory"; import { Blockchain } from "@ton/sandbox"; import fc from "fast-check"; -import { evalConstantExpression } from "@/optimizer/constEval"; import { AstUtil, getAstUtil } from "@/ast/util"; import { AllowedType, @@ -36,6 +36,8 @@ import { NonTerminal, } from "../src/generators/uniform-expr-gen"; import { Sender, toNano } from "@ton/core"; +import { GlobalContext } from "../src/context"; +import { Interpreter } from "@/optimizer/interpreter"; function emptyStatementContext(): StatementContext { return { @@ -81,21 +83,15 @@ describe("generation properties", () => { assert.fail(`Unexpected type: ${resolvedTy.kind}`); } }); - checkProperty(property); + checkProperty(property, astNodeCounterexamplePrinter); } }); }); -type Binding = { - name: string; - type: string; - expr: Ast.Expression; -}; - function makeExpressionGetter( makeF: MakeAstFactory, getterName: string, - bindings: Binding[], + bindings: Ast.Statement[], returnExpr: Ast.Expression, ): Ast.FunctionDef { return makeF.makeDummyFunctionDef( @@ -103,16 +99,7 @@ function makeExpressionGetter( makeF.makeDummyId(getterName), makeF.makeDummyTypeId("Int"), [], - bindings - .map( - ({ name, type, expr }): Ast.Statement => - makeF.makeDummyStatementLet( - makeF.makeDummyId(name), - makeF.makeDummyTypeId(type), - expr, - ), - ) - .concat([makeF.makeDummyStatementReturn(returnExpr)]), + bindings.concat([makeF.makeDummyStatementReturn(returnExpr)]), ); } @@ -120,7 +107,7 @@ function createContractWithExpressionGetter( makeF: MakeAstFactory, contractName: string, getterName: string, - bindings: Binding[], + bindings: Ast.Statement[], returnExpr: Ast.Expression, ): Ast.Contract { // throw new Error("createContract is not implemented yet"); // TODO: implement, probably should place this function in a different file @@ -153,7 +140,7 @@ describe("evaluation properties", () => { let makeF: MakeAstFactory; let customStdlib: CustomStdlib; let blockchain: Blockchain; - let emptyCompileContext: CompilerContext; + const emptyCompilerContext: CompilerContext = new CompilerContext(); let astUtil: AstUtil; let sender: Sender; @@ -170,8 +157,9 @@ describe("evaluation properties", () => { "Cell", "Context", "Slice", - //"Builder", - //"String", + "Slice?", + "String", + "String?", "StateInit", "SendParameters", "BaseTrait", @@ -199,7 +187,6 @@ describe("evaluation properties", () => { ]), ); blockchain = await Blockchain.create(); - emptyCompileContext = new CompilerContext(); astUtil = getAstUtil(astF); sender = (await blockchain.treasury("treasury")).getSender(); }); @@ -207,7 +194,7 @@ describe("evaluation properties", () => { test( "compiler and interpreter evaluate generated expressions equally", async () => { - const contractName = "PureExpressionContract"; + const contractName = "ExpressionContract"; const expressionGenerationIds: Map = new Map(); @@ -235,21 +222,31 @@ describe("evaluation properties", () => { ); const bindingsGenretor = fc.tuple( - ...expressionGenerationIds.entries().flatMap(([type, names]) => - names.map((name) => - fc.record({ - type: fc.constant(type), - name: fc.constant(name), - expr: generator(initializersMapping[type]), - }), + ...expressionGenerationIds + .entries() + .flatMap(([type, names]) => + names.map((name) => + generator(initializersMapping[type]).map((expr) => + makeF.makeDummyStatementLet( + makeF.makeDummyId(name), + type.slice(-1) === "?" + ? makeF.makeDummyOptionalType( + makeF.makeDummyTypeId( + type.slice(0, -1), + ), + ) + : makeF.makeDummyTypeId(type), + expr, + ), + ), + ), ), - ), ); const property = fc.asyncProperty( bindingsGenretor, generator(NonTerminal.Int), - async (initExprs, expr) => { + async (bindings, expr) => { const contractModule = makeF.makeModule( [], [ @@ -257,35 +254,51 @@ describe("evaluation properties", () => { makeF, contractName, "getInt", - initExprs, + bindings, expr, ), ], ); - const contractMap = await buildModule( + + let contractMapPromise = buildModule( astF, contractModule, customStdlib, blockchain, ); + + const contractMap = await contractMapPromise; const contract = contractMap.get(contractName)!; await contract.send(sender, { value: toNano(1) }); const compiledValue = await contract.getInt(); - const intrepretedValue = evalConstantExpression( - expr, - emptyCompileContext, + const interpreter = new Interpreter( astUtil, + emptyCompilerContext, ); - expect(intrepretedValue.kind).toBe("number"); + bindings.forEach((bind) => { + interpreter.interpretStatement(bind); + }); + const intrepretedValue = + interpreter.interpretExpression(expr); + expect(intrepretedValue.kind).toBe("number"); expect(compiledValue).toBe( (intrepretedValue as Ast.Number).value, ); }, ); - await checkAsyncProperty(property); + checkAsyncProperty(property, ([bindings, expr]) => { + return ( + `\n-----\nGenerated bindings:\n` + + bindings + .map((bind) => GlobalContext.format(bind)) + .join("\n") + + `Generated expression:\n` + + GlobalContext.format(expr) + ); + }); }, 20 * 1000, ); diff --git a/src/test/fuzzer/test/program.spec.ts b/src/test/fuzzer/test/program.spec.ts index 63c6386545..c2b996ab16 100644 --- a/src/test/fuzzer/test/program.spec.ts +++ b/src/test/fuzzer/test/program.spec.ts @@ -6,7 +6,11 @@ import { createContext, enableFeatures, } from "@/test/fuzzer/test/testUtils"; -import { createProperty, checkProperty } from "@/test/fuzzer/src/util"; +import { + createProperty, + checkProperty, + astNodeCounterexamplePrinter, +} from "@/test/fuzzer/src/util"; import { GlobalContext } from "@/test/fuzzer/src/context"; import { getAstFactory } from "@/ast/ast-helpers"; @@ -22,7 +26,7 @@ describe("properties", () => { GlobalContext.resetDepth(); }, ); - checkProperty(property); + checkProperty(property, astNodeCounterexamplePrinter); }); it("generates reproducible AST", () => { @@ -44,8 +48,8 @@ describe("properties", () => { }); // Execute property twice - checkProperty(property, /*numRuns=*/ 1); - checkProperty(property, /*numRuns=*/ 1); + checkProperty(property, astNodeCounterexamplePrinter, /*numRuns=*/ 1); + checkProperty(property, astNodeCounterexamplePrinter, /*numRuns=*/ 1); assert.notEqual( program1, From b4394e9366be959ca9a41854576fc21b3653fc9e Mon Sep 17 00:00:00 2001 From: jeshecdom Date: Fri, 11 Apr 2025 13:30:38 +0200 Subject: [PATCH 26/44] fix: shift operator checks in range [0..256] --- .../fuzzer/src/generators/uniform-expr-gen.ts | 71 +++++++++++++++++-- 1 file changed, 65 insertions(+), 6 deletions(-) diff --git a/src/test/fuzzer/src/generators/uniform-expr-gen.ts b/src/test/fuzzer/src/generators/uniform-expr-gen.ts index fd0da8850a..07b81b7488 100644 --- a/src/test/fuzzer/src/generators/uniform-expr-gen.ts +++ b/src/test/fuzzer/src/generators/uniform-expr-gen.ts @@ -1,7 +1,9 @@ import type * as Ast from "@/ast/ast"; import { getAstFactory } from "@/ast/ast-helpers"; +import type { FactoryAst } from "@/ast/ast-helpers"; import { getMakeAst } from "@/ast/generated/make-factory"; -import type { MakeAstFactory } from "@/ast/generated/make-factory"; +import { getAstUtil } from "@/ast/util"; +import { Interpreter } from "@/optimizer/interpreter"; import { beginCell } from "@ton/core"; import type { Address, Cell } from "@ton/core"; import { sha256_sync } from "@ton/crypto"; @@ -1070,13 +1072,16 @@ function getProductionAt(prods: ExprProduction[], id: number): ExprProduction { } function makeExpression( - makeF: MakeAstFactory, + astF: FactoryAst, type: NonTerminalEnum, ctx: GenContext, nonTerminalCounts: number[][][], sizeSplitCounts: number[][][][][], size: number, ): Ast.Expression { + const makeF = getMakeAst(astF); + const interpreter = new Interpreter(getAstUtil(astF)); + function genFromNonTerminal(id: number, size: number): Ast.Expression { const prods = getProductions(id); const nonTerminalOptions = lookupNonTerminalCounts( @@ -1128,6 +1133,41 @@ function makeExpression( return randomlyChooseIndex(sizeSplits) + 1; } + function handleShiftOperators( + op: Ast.BinaryOperation, + expr: Ast.Expression, + ): Ast.Expression { + if (op === "<<" || op === ">>") { + try { + const literal = interpreter.interpretExpression(expr); + if (literal.kind !== "number") { + // Generate an integer of size 8 bits, unsigned + return fc.sample( + _generateIntBitLength(8, false).map((n) => + makeF.makeDummyNumber(10, n), + ), + 1, + )[0]!; + } + if (literal.value >= 0n && literal.value <= 256n) { + return expr; + } else { + // Generate an integer of size 8 bits, unsigned + return fc.sample( + _generateIntBitLength(8, false).map((n) => + makeF.makeDummyNumber(10, n), + ), + 1, + )[0]!; + } + } catch (_) { + // Any kind of error, leave the expr as is + return expr; + } + } + return expr; + } + function makeBinaryOperatorTree( op: Ast.BinaryOperation, nonTerminalIndex: number, @@ -1151,7 +1191,10 @@ function makeExpression( rightNonTerminal.id, currSize - sizeSplit, ); - return makeF.makeDummyOpBinary(op, leftOperand, rightOperand); + // We need special logic to handle the shift operators, because they check + // at compile time if their right-hand side is within the range [0..256]. + const squashedRightOperand = handleShiftOperators(op, rightOperand); + return makeF.makeDummyOpBinary(op, leftOperand, squashedRightOperand); } function makeUnaryOperatorTree( @@ -1186,7 +1229,9 @@ function makeExpression( switch (head.id) { case Terminal.integer.id: { return fc.sample( - fc.bigInt().map((i) => makeF.makeDummyNumber(10, i)), + _generateIntBitLength(257, true).map((i) => + makeF.makeDummyNumber(10, i), + ), 1, )[0]!; } @@ -1495,14 +1540,13 @@ export function initializeGenerator( ): (type: NonTerminalEnum) => fc.Arbitrary { const { nonTerminalCounts, sizeSplitCounts, totalCounts } = computeCountTables(minSize, maxSize); - const makeF = getMakeAst(getAstFactory()); return (type: NonTerminalEnum) => { const sizes = lookupTotalCounts(totalCounts, type.id); return fc.constant(0).map((_) => { const size = randomlyChooseIndex(sizes); return makeExpression( - makeF, + getAstFactory(), type, ctx, nonTerminalCounts, @@ -1540,3 +1584,18 @@ function _generateCell(): fc.Arbitrary { return beginCell().storeBuffer(Buffer.from(buf.buffer)).endCell(); }); } + +function _generateIntBitLength( + bitLength: number, + signed: boolean, +): fc.Arbitrary { + const maxUnsigned = (1n << BigInt(bitLength)) - 1n; + + if (signed) { + const minSigned = -maxUnsigned / 2n - 1n; + const maxSigned = maxUnsigned / 2n; + return fc.bigInt(minSigned, maxSigned); + } else { + return fc.bigInt(0n, maxUnsigned); + } +} From abd7d3e6a55aa6aca76fb710eb516f1c60a73403 Mon Sep 17 00:00:00 2001 From: jeshecdom Date: Fri, 11 Apr 2025 13:41:15 +0200 Subject: [PATCH 27/44] tests: Added indexed getters to ProxyContract. --- src/test/fuzzer/src/util.ts | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/src/test/fuzzer/src/util.ts b/src/test/fuzzer/src/util.ts index 9d87349ee1..b6249eb910 100644 --- a/src/test/fuzzer/src/util.ts +++ b/src/test/fuzzer/src/util.ts @@ -516,6 +516,13 @@ export class ProxyContract implements Contract { return result.readBigNumber(); } + async getIndexed(provider: ContractProvider, index: number) { + const builder = new TupleBuilder(); + const result = (await provider.get(`getInt${index}`, builder.build())) + .stack; + return result.readBigNumber(); + } + async getGeneric( provider: ContractProvider, getterName: string, From bf285c85e22ddd1d471d86f40db826ae89b148c7 Mon Sep 17 00:00:00 2001 From: Mell0r Date: Fri, 11 Apr 2025 15:28:21 +0300 Subject: [PATCH 28/44] fix: checkProperty error printing --- .../fuzzer/src/generators/uniform-expr-gen.ts | 104 +++++++++--------- src/test/fuzzer/src/util.ts | 39 +++++-- src/test/fuzzer/test/expression.spec.ts | 67 ++++++----- 3 files changed, 121 insertions(+), 89 deletions(-) diff --git a/src/test/fuzzer/src/generators/uniform-expr-gen.ts b/src/test/fuzzer/src/generators/uniform-expr-gen.ts index ee9a1a61c3..77be85073a 100644 --- a/src/test/fuzzer/src/generators/uniform-expr-gen.ts +++ b/src/test/fuzzer/src/generators/uniform-expr-gen.ts @@ -76,48 +76,48 @@ const Terminal = { bit_and: { terminal: true, id: 9 }, bit_or: { terminal: true, id: 10 }, bit_xor: { terminal: true, id: 11 }, - unary_plus: { terminal: true, id: 12 }, - unary_minus: { terminal: true, id: 13 }, - bit_not: { terminal: true, id: 14 }, - - bool: { terminal: true, id: 15 }, - eq: { terminal: true, id: 16 }, - neq: { terminal: true, id: 17 }, - lt: { terminal: true, id: 18 }, - le: { terminal: true, id: 19 }, - gt: { terminal: true, id: 20 }, - ge: { terminal: true, id: 21 }, - and: { terminal: true, id: 22 }, - or: { terminal: true, id: 23 }, - not: { terminal: true, id: 24 }, - - cell: { terminal: true, id: 25 }, - code_of: { terminal: true, id: 26 }, - - slice: { terminal: true, id: 27 }, - - address: { terminal: true, id: 28 }, - - string: { terminal: true, id: 29 }, - - opt_inj: { terminal: true, id: 30 }, - null: { terminal: true, id: 31 }, - non_null_assert: { terminal: true, id: 32 }, - - cond: { terminal: true, id: 33 }, - - id_int: { terminal: true, id: 34 }, - id_opt_int: { terminal: true, id: 35 }, - id_bool: { terminal: true, id: 36 }, - id_opt_bool: { terminal: true, id: 37 }, - id_cell: { terminal: true, id: 38 }, - id_opt_cell: { terminal: true, id: 39 }, - id_slice: { terminal: true, id: 40 }, - id_opt_slice: { terminal: true, id: 41 }, - id_address: { terminal: true, id: 42 }, - id_opt_address: { terminal: true, id: 43 }, - id_string: { terminal: true, id: 44 }, - id_opt_string: { terminal: true, id: 45 }, + // unary_plus: { terminal: true, id: 12 }, + unary_minus: { terminal: true, id: 12 }, + bit_not: { terminal: true, id: 13 }, + + bool: { terminal: true, id: 14 }, + eq: { terminal: true, id: 15 }, + neq: { terminal: true, id: 16 }, + lt: { terminal: true, id: 17 }, + le: { terminal: true, id: 18 }, + gt: { terminal: true, id: 19 }, + ge: { terminal: true, id: 20 }, + and: { terminal: true, id: 21 }, + or: { terminal: true, id: 22 }, + not: { terminal: true, id: 23 }, + + cell: { terminal: true, id: 24 }, + code_of: { terminal: true, id: 25 }, + + slice: { terminal: true, id: 26 }, + + address: { terminal: true, id: 27 }, + + string: { terminal: true, id: 28 }, + + opt_inj: { terminal: true, id: 29 }, + null: { terminal: true, id: 30 }, + non_null_assert: { terminal: true, id: 31 }, + + cond: { terminal: true, id: 32 }, + + id_int: { terminal: true, id: 33 }, + id_opt_int: { terminal: true, id: 34 }, + id_bool: { terminal: true, id: 35 }, + id_opt_bool: { terminal: true, id: 36 }, + id_cell: { terminal: true, id: 37 }, + id_opt_cell: { terminal: true, id: 38 }, + id_slice: { terminal: true, id: 39 }, + id_opt_slice: { terminal: true, id: 40 }, + id_address: { terminal: true, id: 41 }, + id_opt_address: { terminal: true, id: 42 }, + id_string: { terminal: true, id: 43 }, + id_opt_string: { terminal: true, id: 44 }, } as const; type TerminalEnum = (typeof Terminal)[keyof typeof Terminal]; @@ -187,13 +187,13 @@ const productions: ExprProduction[][] = [ index: 9, tokens: [Terminal.bit_xor, NonTerminal.Int, NonTerminal.Int], }, - { index: 10, tokens: [Terminal.unary_plus, NonTerminal.Int] }, - { index: 11, tokens: [Terminal.unary_minus, NonTerminal.Int] }, - { index: 12, tokens: [Terminal.bit_not, NonTerminal.Int] }, + // { index: 10, tokens: [Terminal.unary_plus, NonTerminal.Int] }, + { index: 10, tokens: [Terminal.unary_minus, NonTerminal.Int] }, + { index: 11, tokens: [Terminal.bit_not, NonTerminal.Int] }, - { index: 13, tokens: [Terminal.non_null_assert, NonTerminal.OptInt] }, + { index: 12, tokens: [Terminal.non_null_assert, NonTerminal.OptInt] }, { - index: 14, + index: 13, tokens: [ Terminal.cond, NonTerminal.Bool, @@ -201,8 +201,8 @@ const productions: ExprProduction[][] = [ NonTerminal.Int, ], }, - { index: 15, tokens: [Terminal.id_int] }, - { index: 16, tokens: [NonTerminal.LiteralInt] }, + { index: 14, tokens: [Terminal.id_int] }, + { index: 15, tokens: [NonTerminal.LiteralInt] }, ], [ // Productions for OptInt @@ -1218,9 +1218,9 @@ function makeExpression( size, ); } - case Terminal.unary_plus.id: { - return makeUnaryOperatorTree("+", rest, size); - } + // case Terminal.unary_plus.id: { + // return makeUnaryOperatorTree("+", rest, size); + // } case Terminal.unary_minus.id: { return makeUnaryOperatorTree("-", rest, size); } diff --git a/src/test/fuzzer/src/util.ts b/src/test/fuzzer/src/util.ts index 5d1e092c27..6f147b9374 100644 --- a/src/test/fuzzer/src/util.ts +++ b/src/test/fuzzer/src/util.ts @@ -97,15 +97,36 @@ function makeParams( seed: GlobalContext.config.seed, reporter(out) { if (out.failed) { - if ( - out.counterexample !== null && - out.errorInstance instanceof Error - ) { - out.errorInstance.message += counterexamplePrinter( - out.counterexample, - ); + let errorSufffix = ""; + if (out.counterexample !== null) { + errorSufffix = counterexamplePrinter(out.counterexample); } - throw new Error(fc.defaultReportMessage(out)); + throw new Error(fc.defaultReportMessage(out) + errorSufffix); + } + }, + }; +} +/** + * Create parameters for custom property checking. + */ +function makeAsyncParams( + counterexamplePrinter: (generated: T) => string, + numRuns: number | undefined, +): fc.Parameters { + return { + numRuns: numRuns ?? GlobalContext.config.numRuns, + seed: GlobalContext.config.seed, + reporter: undefined, + async asyncReporter(out) { + if (out.failed) { + let errorSuffix = ""; + if (out.counterexample !== null) { + errorSuffix = counterexamplePrinter(out.counterexample); + out.error; + } + throw new Error( + (await fc.asyncDefaultReportMessage(out)) + errorSuffix, + ); } }, }; @@ -130,7 +151,7 @@ export async function checkAsyncProperty( counterexamplePrinter: (generated: T) => string, numRuns: number | undefined = undefined, ) { - await fc.assert(property, makeParams(counterexamplePrinter, numRuns)); + await fc.assert(property, makeAsyncParams(counterexamplePrinter, numRuns)); } export function astNodeCounterexamplePrinter( diff --git a/src/test/fuzzer/test/expression.spec.ts b/src/test/fuzzer/test/expression.spec.ts index 97b97e7230..d9a86423eb 100644 --- a/src/test/fuzzer/test/expression.spec.ts +++ b/src/test/fuzzer/test/expression.spec.ts @@ -260,43 +260,54 @@ describe("evaluation properties", () => { ], ); - let contractMapPromise = buildModule( - astF, - contractModule, - customStdlib, - blockchain, - ); - - const contractMap = await contractMapPromise; - const contract = contractMap.get(contractName)!; - await contract.send(sender, { value: toNano(1) }); + let compiledValue: bigint | undefined; + let compilationError: Error | undefined; + try { + let contractMapPromise = buildModule( + astF, + contractModule, + customStdlib, + blockchain, + ); + + const contractMap = await contractMapPromise; + const contract = contractMap.get(contractName)!; + await contract.send(sender, { value: toNano(1) }); + compiledValue = await contract.getInt(); + } catch (e: any) { + compilationError = e; + } - const compiledValue = await contract.getInt(); + let interpretedValue: bigint | undefined; + let interpretationError: Error | undefined; + try { + const interpreter = new Interpreter( + astUtil, + emptyCompilerContext, + ); + bindings.forEach((bind) => { + interpreter.interpretStatement(bind); + }); + const result = interpreter.interpretExpression(expr); + expect(result.kind).toBe("number"); + interpretedValue = (result as Ast.Number).value; + } catch (e: any) { + interpretationError = e; + } - const interpreter = new Interpreter( - astUtil, - emptyCompilerContext, - ); - bindings.forEach((bind) => { - interpreter.interpretStatement(bind); - }); - const intrepretedValue = - interpreter.interpretExpression(expr); - - expect(intrepretedValue.kind).toBe("number"); - expect(compiledValue).toBe( - (intrepretedValue as Ast.Number).value, - ); + expect(compiledValue).toBe(interpretedValue); + expect(compilationError).toBe(interpretationError); }, ); - checkAsyncProperty(property, ([bindings, expr]) => { + await checkAsyncProperty(property, ([bindings, expr]) => { return ( `\n-----\nGenerated bindings:\n` + bindings .map((bind) => GlobalContext.format(bind)) .join("\n") + - `Generated expression:\n` + - GlobalContext.format(expr) + `\nGenerated expression:\n` + + GlobalContext.format(expr) + + `\n-----\n` ); }); }, From 53d4eca693aa3cdc409b3f3571f87168b2ae7103 Mon Sep 17 00:00:00 2001 From: Mell0r Date: Fri, 11 Apr 2025 15:57:13 +0300 Subject: [PATCH 29/44] fix: added export from expression generation, swapped expects in test --- src/test/fuzzer/src/generators/uniform-expr-gen.ts | 2 +- src/test/fuzzer/test/expression.spec.ts | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/src/test/fuzzer/src/generators/uniform-expr-gen.ts b/src/test/fuzzer/src/generators/uniform-expr-gen.ts index dd34d63ca8..bb523395e0 100644 --- a/src/test/fuzzer/src/generators/uniform-expr-gen.ts +++ b/src/test/fuzzer/src/generators/uniform-expr-gen.ts @@ -35,7 +35,7 @@ export type GenContext = { contractNames: string[]; }; -const NonTerminal = { +export const NonTerminal = { Initial: { terminal: false, literal: false, id: 0 }, Int: { terminal: false, literal: false, id: 1 }, OptInt: { terminal: false, literal: false, id: 2 }, diff --git a/src/test/fuzzer/test/expression.spec.ts b/src/test/fuzzer/test/expression.spec.ts index d9a86423eb..5c9bc235eb 100644 --- a/src/test/fuzzer/test/expression.spec.ts +++ b/src/test/fuzzer/test/expression.spec.ts @@ -295,8 +295,8 @@ describe("evaluation properties", () => { interpretationError = e; } - expect(compiledValue).toBe(interpretedValue); expect(compilationError).toBe(interpretationError); + expect(compiledValue).toBe(interpretedValue); }, ); await checkAsyncProperty(property, ([bindings, expr]) => { From 81431a015247ed0f374fa3606d058eb23f7a89e7 Mon Sep 17 00:00:00 2001 From: jeshecdom Date: Fri, 11 Apr 2025 16:35:54 +0200 Subject: [PATCH 30/44] fix: initializeGenerator function must receive the AstFactory object --- src/test/fuzzer/src/generators/uniform-expr-gen.ts | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/src/test/fuzzer/src/generators/uniform-expr-gen.ts b/src/test/fuzzer/src/generators/uniform-expr-gen.ts index 07b81b7488..f1771b6b9d 100644 --- a/src/test/fuzzer/src/generators/uniform-expr-gen.ts +++ b/src/test/fuzzer/src/generators/uniform-expr-gen.ts @@ -1,5 +1,4 @@ import type * as Ast from "@/ast/ast"; -import { getAstFactory } from "@/ast/ast-helpers"; import type { FactoryAst } from "@/ast/ast-helpers"; import { getMakeAst } from "@/ast/generated/make-factory"; import { getAstUtil } from "@/ast/util"; @@ -10,7 +9,7 @@ import { sha256_sync } from "@ton/crypto"; import { TreasuryContract } from "@ton/sandbox"; import * as fc from "fast-check"; -const AllowedType = { +export const AllowedType = { Int: "Int", OptInt: "Int?", Bool: "Bool", @@ -25,9 +24,9 @@ const AllowedType = { OptString: "String?", } as const; -type AllowedTypeEnum = (typeof AllowedType)[keyof typeof AllowedType]; +export type AllowedTypeEnum = (typeof AllowedType)[keyof typeof AllowedType]; -type GenContext = { +export type GenContext = { // Identifier names to choose from, by type identifiers: Map; @@ -35,7 +34,7 @@ type GenContext = { contractNames: string[]; }; -const NonTerminal = { +export const NonTerminal = { Initial: { terminal: false, literal: false, id: 0 }, Int: { terminal: false, literal: false, id: 1 }, OptInt: { terminal: false, literal: false, id: 2 }, @@ -1537,6 +1536,7 @@ export function initializeGenerator( minSize: number, maxSize: number, ctx: GenContext, + astF: FactoryAst, ): (type: NonTerminalEnum) => fc.Arbitrary { const { nonTerminalCounts, sizeSplitCounts, totalCounts } = computeCountTables(minSize, maxSize); @@ -1546,7 +1546,7 @@ export function initializeGenerator( return fc.constant(0).map((_) => { const size = randomlyChooseIndex(sizes); return makeExpression( - getAstFactory(), + astF, type, ctx, nonTerminalCounts, From c891808a0875b6891a77e7c38b0cabc366a8b907 Mon Sep 17 00:00:00 2001 From: Mell0r Date: Fri, 11 Apr 2025 20:05:41 +0300 Subject: [PATCH 31/44] fix: nullable bindings is now generated differently, no longer can generate null as a literal value --- .../fuzzer/src/generators/uniform-expr-gen.ts | 67 ++++++++++--------- src/test/fuzzer/test/expression.spec.ts | 55 +++++++++------ 2 files changed, 70 insertions(+), 52 deletions(-) diff --git a/src/test/fuzzer/src/generators/uniform-expr-gen.ts b/src/test/fuzzer/src/generators/uniform-expr-gen.ts index bb523395e0..8336a3817f 100644 --- a/src/test/fuzzer/src/generators/uniform-expr-gen.ts +++ b/src/test/fuzzer/src/generators/uniform-expr-gen.ts @@ -102,23 +102,23 @@ const Terminal = { string: { terminal: true, id: 28 }, opt_inj: { terminal: true, id: 29 }, - null: { terminal: true, id: 30 }, - non_null_assert: { terminal: true, id: 31 }, - - cond: { terminal: true, id: 32 }, - - id_int: { terminal: true, id: 33 }, - id_opt_int: { terminal: true, id: 34 }, - id_bool: { terminal: true, id: 35 }, - id_opt_bool: { terminal: true, id: 36 }, - id_cell: { terminal: true, id: 37 }, - id_opt_cell: { terminal: true, id: 38 }, - id_slice: { terminal: true, id: 39 }, - id_opt_slice: { terminal: true, id: 40 }, - id_address: { terminal: true, id: 41 }, - id_opt_address: { terminal: true, id: 42 }, - id_string: { terminal: true, id: 43 }, - id_opt_string: { terminal: true, id: 44 }, + // null: { terminal: true, id: 30 }, + non_null_assert: { terminal: true, id: 30 }, + + cond: { terminal: true, id: 31 }, + + id_int: { terminal: true, id: 32 }, + id_opt_int: { terminal: true, id: 33 }, + id_bool: { terminal: true, id: 34 }, + id_opt_bool: { terminal: true, id: 35 }, + id_cell: { terminal: true, id: 36 }, + id_opt_cell: { terminal: true, id: 37 }, + id_slice: { terminal: true, id: 38 }, + id_opt_slice: { terminal: true, id: 39 }, + id_address: { terminal: true, id: 40 }, + id_opt_address: { terminal: true, id: 41 }, + id_string: { terminal: true, id: 42 }, + id_opt_string: { terminal: true, id: 43 }, } as const; type TerminalEnum = (typeof Terminal)[keyof typeof Terminal]; @@ -226,8 +226,8 @@ const allProductions: ExprProduction[][] = [ ], [ // Productions for LiteralOptInt - { id: 0, tokens: [Terminal.null] }, - { id: 1, tokens: [Terminal.opt_inj, NonTerminal.LiteralInt] }, + // { id: 0, tokens: [Terminal.null] }, + { id: 0, tokens: [Terminal.opt_inj, NonTerminal.LiteralInt] }, ], [ // Productions for Bool @@ -377,8 +377,8 @@ const allProductions: ExprProduction[][] = [ ], [ // Productions for LiteralOptBool - { id: 0, tokens: [Terminal.null] }, - { id: 1, tokens: [Terminal.opt_inj, NonTerminal.LiteralBool] }, + // { id: 0, tokens: [Terminal.null] }, + { id: 0, tokens: [Terminal.opt_inj, NonTerminal.LiteralBool] }, ], [ // Productions for Cell @@ -418,8 +418,8 @@ const allProductions: ExprProduction[][] = [ ], [ // Productions for LiteralOptCell - { id: 0, tokens: [Terminal.null] }, - { id: 1, tokens: [Terminal.opt_inj, NonTerminal.LiteralCell] }, + // { id: 0, tokens: [Terminal.null] }, + { id: 0, tokens: [Terminal.opt_inj, NonTerminal.LiteralCell] }, ], [ // Productions for Slice @@ -457,8 +457,8 @@ const allProductions: ExprProduction[][] = [ ], [ // Productions for LiteralOptSlice - { id: 0, tokens: [Terminal.null] }, - { id: 1, tokens: [Terminal.opt_inj, NonTerminal.LiteralSlice] }, + // { id: 0, tokens: [Terminal.null] }, + { id: 0, tokens: [Terminal.opt_inj, NonTerminal.LiteralSlice] }, ], [ // Productions for Address @@ -499,8 +499,8 @@ const allProductions: ExprProduction[][] = [ ], [ // Productions for LiteralOptAddress - { id: 0, tokens: [Terminal.null] }, - { id: 1, tokens: [Terminal.opt_inj, NonTerminal.LiteralAddress] }, + // { id: 0, tokens: [Terminal.null] }, + { id: 0, tokens: [Terminal.opt_inj, NonTerminal.LiteralAddress] }, ], [ // Productions for String @@ -538,8 +538,8 @@ const allProductions: ExprProduction[][] = [ ], [ // Productions for LiteralOptString - { id: 0, tokens: [Terminal.null] }, - { id: 1, tokens: [Terminal.opt_inj, NonTerminal.LiteralString] }, + // { id: 0, tokens: [Terminal.null] }, + { id: 0, tokens: [Terminal.opt_inj, NonTerminal.LiteralString] }, ], ]; @@ -1448,9 +1448,9 @@ function makeExpression( const operandNonTerminal = getNonTerminalAt(rest, 0); return genFromNonTerminal(operandNonTerminal.id, currSize); } - case Terminal.null.id: { - return makeF.makeDummyNull(); - } + // case Terminal.null.id: { + // return makeF.makeDummyNull(); + // } case Terminal.non_null_assert.id: { return makeUnaryOperatorTree("!!", rest, size); } @@ -1536,6 +1536,7 @@ function makeExpression( export function initializeGenerator( minSize: number, maxSize: number, + astF: FactoryAst, ctx: GenContext, ): (type: NonTerminalEnum) => fc.Arbitrary { const { nonTerminalCounts, sizeSplitCounts, totalCounts } = @@ -1546,7 +1547,7 @@ export function initializeGenerator( return fc.constant(0).map((_) => { const size = randomlyChooseIndex(sizes); return makeExpression( - getAstFactory(), + astF, type, ctx, nonTerminalCounts, diff --git a/src/test/fuzzer/test/expression.spec.ts b/src/test/fuzzer/test/expression.spec.ts index 5c9bc235eb..ac7d075299 100644 --- a/src/test/fuzzer/test/expression.spec.ts +++ b/src/test/fuzzer/test/expression.spec.ts @@ -199,17 +199,19 @@ describe("evaluation properties", () => { const expressionGenerationIds: Map = new Map(); expressionGenerationIds.set(AllowedType.Int, ["int1"]); - expressionGenerationIds.set(AllowedType.OptInt, ["o_int1"]); + expressionGenerationIds.set(AllowedType.OptInt, ["int_null"]); expressionGenerationIds.set(AllowedType.Bool, ["bool1"]); - expressionGenerationIds.set(AllowedType.OptBool, ["o_bool1"]); + expressionGenerationIds.set(AllowedType.OptBool, ["bool_null"]); expressionGenerationIds.set(AllowedType.Cell, ["cell1"]); - expressionGenerationIds.set(AllowedType.OptCell, ["o_cell1"]); + expressionGenerationIds.set(AllowedType.OptCell, ["cell_null"]); expressionGenerationIds.set(AllowedType.Slice, ["slice1"]); - expressionGenerationIds.set(AllowedType.OptSlice, ["o_slice1"]); + expressionGenerationIds.set(AllowedType.OptSlice, ["slice_null"]); expressionGenerationIds.set(AllowedType.Address, ["address1"]); - expressionGenerationIds.set(AllowedType.OptAddress, ["o_address1"]); + expressionGenerationIds.set(AllowedType.OptAddress, [ + "address_null", + ]); expressionGenerationIds.set(AllowedType.String, ["string1"]); - expressionGenerationIds.set(AllowedType.OptString, ["o_string1"]); + expressionGenerationIds.set(AllowedType.OptString, ["string_null"]); const expressionGenerationCtx: GenContext = { identifiers: expressionGenerationIds, @@ -218,6 +220,7 @@ describe("evaluation properties", () => { const generator = initializeGenerator( 1, 10, + astF, expressionGenerationCtx, ); @@ -226,19 +229,26 @@ describe("evaluation properties", () => { .entries() .flatMap(([type, names]) => names.map((name) => - generator(initializersMapping[type]).map((expr) => - makeF.makeDummyStatementLet( - makeF.makeDummyId(name), - type.slice(-1) === "?" - ? makeF.makeDummyOptionalType( + type.slice(-1) === "?" + ? fc.constant( + makeF.makeDummyStatementLet( + makeF.makeDummyId(name), + makeF.makeDummyOptionalType( makeF.makeDummyTypeId( type.slice(0, -1), ), - ) - : makeF.makeDummyTypeId(type), - expr, - ), - ), + ), + makeF.makeDummyNull(), + ), + ) + : generator(initializersMapping[type]).map( + (expr) => + makeF.makeDummyStatementLet( + makeF.makeDummyId(name), + makeF.makeDummyTypeId(type), + expr, + ), + ), ), ), ); @@ -269,7 +279,7 @@ describe("evaluation properties", () => { customStdlib, blockchain, ); - + const contractMap = await contractMapPromise; const contract = contractMap.get(contractName)!; await contract.send(sender, { value: toNano(1) }); @@ -295,7 +305,14 @@ describe("evaluation properties", () => { interpretationError = e; } - expect(compilationError).toBe(interpretationError); + if ( + (compilationError && !interpretationError) || + (!compilationError && interpretationError) + ) { + expect(compilationError).toEqual(interpretationError); + } else if (compilationError && interpretationError) { + + } expect(compiledValue).toBe(interpretedValue); }, ); @@ -311,6 +328,6 @@ describe("evaluation properties", () => { ); }); }, - 20 * 1000, + 60 * 1000, // 1 minute ); }); From a15c9c95a2bb52114b8b78bec0a69e281184b66f Mon Sep 17 00:00:00 2001 From: Mell0r Date: Sat, 12 Apr 2025 00:22:10 +0300 Subject: [PATCH 32/44] refactor: moved test logic to separate file --- .../fuzzer/src/generators/uniform-expr-gen.ts | 2 +- src/test/fuzzer/test/expression.spec.ts | 333 ------------------ .../{ => expressions}/expression-stats.ts | 0 .../test/expressions/expression.spec.ts | 162 +++++++++ src/test/fuzzer/test/expressions/utils.ts | 249 +++++++++++++ 5 files changed, 412 insertions(+), 334 deletions(-) delete mode 100644 src/test/fuzzer/test/expression.spec.ts rename src/test/fuzzer/test/{ => expressions}/expression-stats.ts (100%) create mode 100644 src/test/fuzzer/test/expressions/expression.spec.ts create mode 100644 src/test/fuzzer/test/expressions/utils.ts diff --git a/src/test/fuzzer/src/generators/uniform-expr-gen.ts b/src/test/fuzzer/src/generators/uniform-expr-gen.ts index 8336a3817f..f8d41fb602 100644 --- a/src/test/fuzzer/src/generators/uniform-expr-gen.ts +++ b/src/test/fuzzer/src/generators/uniform-expr-gen.ts @@ -63,7 +63,7 @@ export const NonTerminal = { LiteralOptString: { terminal: false, literal: true, id: 24 }, } as const; -type NonTerminalEnum = (typeof NonTerminal)[keyof typeof NonTerminal]; +export type NonTerminalEnum = (typeof NonTerminal)[keyof typeof NonTerminal]; const Terminal = { integer: { terminal: true, id: 1 }, diff --git a/src/test/fuzzer/test/expression.spec.ts b/src/test/fuzzer/test/expression.spec.ts deleted file mode 100644 index ac7d075299..0000000000 --- a/src/test/fuzzer/test/expression.spec.ts +++ /dev/null @@ -1,333 +0,0 @@ -import { CompilerContext } from "@/context/context"; -import { resolveExpression, getExpType } from "@/types/resolveExpression"; -import type { StatementContext } from "@/types/resolveStatements"; -import type { TypeRef } from "@/types/types"; -import assert from "assert"; -import * as Ast from "@/ast/ast"; - -import { - Expression, - NonGenerativeExpressionParams, -} from "@/test/fuzzer/src/generators"; -import { Scope } from "@/test/fuzzer/src/scope"; -import { SUPPORTED_STDLIB_TYPES } from "@/test/fuzzer/src/types"; -import type { Type } from "@/test/fuzzer/src/types"; -import { - createProperty, - checkProperty, - dummySrcInfoPrintable, - filterStdlib, - parseStandardLibrary, - CustomStdlib, - checkAsyncProperty, - buildModule, - astNodeCounterexamplePrinter, -} from "@/test/fuzzer/src/util"; -import { FactoryAst, getAstFactory } from "@/ast/ast-helpers"; -import { getMakeAst, MakeAstFactory } from "@/ast/generated/make-factory"; -import { Blockchain } from "@ton/sandbox"; -import fc from "fast-check"; -import { AstUtil, getAstUtil } from "@/ast/util"; -import { - AllowedType, - AllowedTypeEnum, - GenContext, - initializeGenerator, - NonTerminal, -} from "../src/generators/uniform-expr-gen"; -import { Sender, toNano } from "@ton/core"; -import { GlobalContext } from "../src/context"; -import { Interpreter } from "@/optimizer/interpreter"; - -function emptyStatementContext(): StatementContext { - return { - root: dummySrcInfoPrintable, - returns: { kind: "void" }, - vars: new Map(), - requiredFields: [], - funName: null, - }; -} - -function setupContexts(): [CompilerContext, StatementContext] { - const ctx: CompilerContext = new CompilerContext(); - const sctx = emptyStatementContext(); - return [ctx, sctx]; -} - -describe("generation properties", () => { - it("generates well-typed expressions", () => { - const results = setupContexts(); - let compilerCtx = results[0]; - const stmtCtx = results[1]; - const globalScope = new Scope("program", undefined); - for (const type of SUPPORTED_STDLIB_TYPES) { - const ty: Type = { kind: "stdlib", type }; - // NOTE: This test checks only pure expressions, without introducing new - // entries to any scopes. - const exprGen = new Expression( - globalScope, - ty, - NonGenerativeExpressionParams, - ).generate(); - const property = createProperty(exprGen, (expr) => { - compilerCtx = resolveExpression(expr, stmtCtx, compilerCtx); - const resolvedTy = getExpType(compilerCtx, expr); - if (resolvedTy.kind == "ref") { - assert.strictEqual( - resolvedTy.name, - ty.type, - `The resolved type ${resolvedTy.name} does not match the expected type ${ty.type}`, - ); - } else { - assert.fail(`Unexpected type: ${resolvedTy.kind}`); - } - }); - checkProperty(property, astNodeCounterexamplePrinter); - } - }); -}); - -function makeExpressionGetter( - makeF: MakeAstFactory, - getterName: string, - bindings: Ast.Statement[], - returnExpr: Ast.Expression, -): Ast.FunctionDef { - return makeF.makeDummyFunctionDef( - [makeF.makeDummyFunctionAttributeGet(undefined)], - makeF.makeDummyId(getterName), - makeF.makeDummyTypeId("Int"), - [], - bindings.concat([makeF.makeDummyStatementReturn(returnExpr)]), - ); -} - -function createContractWithExpressionGetter( - makeF: MakeAstFactory, - contractName: string, - getterName: string, - bindings: Ast.Statement[], - returnExpr: Ast.Expression, -): Ast.Contract { - // throw new Error("createContract is not implemented yet"); // TODO: implement, probably should place this function in a different file - return makeF.makeDummyContract( - makeF.makeDummyId(contractName), - [], - [], - [], - [makeExpressionGetter(makeF, getterName, bindings, returnExpr)], - ); -} - -const initializersMapping = { - Int: NonTerminal.LiteralInt, - "Int?": NonTerminal.LiteralInt, - Bool: NonTerminal.LiteralBool, - "Bool?": NonTerminal.LiteralBool, - Cell: NonTerminal.LiteralCell, - "Cell?": NonTerminal.LiteralCell, - Address: NonTerminal.LiteralAddress, - "Address?": NonTerminal.LiteralAddress, - Slice: NonTerminal.LiteralSlice, - "Slice?": NonTerminal.LiteralSlice, - String: NonTerminal.LiteralString, - "String?": NonTerminal.LiteralString, -} as const; - -describe("evaluation properties", () => { - let astF: FactoryAst; - let makeF: MakeAstFactory; - let customStdlib: CustomStdlib; - let blockchain: Blockchain; - const emptyCompilerContext: CompilerContext = new CompilerContext(); - let astUtil: AstUtil; - let sender: Sender; - - beforeAll(async () => { - astF = getAstFactory(); - makeF = getMakeAst(astF); - customStdlib = filterStdlib( - parseStandardLibrary(astF), - makeF, - new Set([ - "Int", - "Bool", - "Address", - "Cell", - "Context", - "Slice", - "Slice?", - "String", - "String?", - "StateInit", - "SendParameters", - "BaseTrait", - "SendDefaultMode", - "SendRemainingValue", - "SendIgnoreErrors", - "SendRemainingBalance", - "ReserveExact", - "sender", - "context", - "myBalance", - "nativeReserve", - //"contractAddress", - //"contractAddressExt", - //"storeUint", - //"storeInt", - //"contractHash", - //"newAddress", - //"beginCell", - //"endCell", - "send", - //"asSlice", - //"asAddressUnsafe", - //"beginParse", - ]), - ); - blockchain = await Blockchain.create(); - astUtil = getAstUtil(astF); - sender = (await blockchain.treasury("treasury")).getSender(); - }); - - test( - "compiler and interpreter evaluate generated expressions equally", - async () => { - const contractName = "ExpressionContract"; - - const expressionGenerationIds: Map = - new Map(); - expressionGenerationIds.set(AllowedType.Int, ["int1"]); - expressionGenerationIds.set(AllowedType.OptInt, ["int_null"]); - expressionGenerationIds.set(AllowedType.Bool, ["bool1"]); - expressionGenerationIds.set(AllowedType.OptBool, ["bool_null"]); - expressionGenerationIds.set(AllowedType.Cell, ["cell1"]); - expressionGenerationIds.set(AllowedType.OptCell, ["cell_null"]); - expressionGenerationIds.set(AllowedType.Slice, ["slice1"]); - expressionGenerationIds.set(AllowedType.OptSlice, ["slice_null"]); - expressionGenerationIds.set(AllowedType.Address, ["address1"]); - expressionGenerationIds.set(AllowedType.OptAddress, [ - "address_null", - ]); - expressionGenerationIds.set(AllowedType.String, ["string1"]); - expressionGenerationIds.set(AllowedType.OptString, ["string_null"]); - - const expressionGenerationCtx: GenContext = { - identifiers: expressionGenerationIds, - contractNames: [contractName], - }; - const generator = initializeGenerator( - 1, - 10, - astF, - expressionGenerationCtx, - ); - - const bindingsGenretor = fc.tuple( - ...expressionGenerationIds - .entries() - .flatMap(([type, names]) => - names.map((name) => - type.slice(-1) === "?" - ? fc.constant( - makeF.makeDummyStatementLet( - makeF.makeDummyId(name), - makeF.makeDummyOptionalType( - makeF.makeDummyTypeId( - type.slice(0, -1), - ), - ), - makeF.makeDummyNull(), - ), - ) - : generator(initializersMapping[type]).map( - (expr) => - makeF.makeDummyStatementLet( - makeF.makeDummyId(name), - makeF.makeDummyTypeId(type), - expr, - ), - ), - ), - ), - ); - - const property = fc.asyncProperty( - bindingsGenretor, - generator(NonTerminal.Int), - async (bindings, expr) => { - const contractModule = makeF.makeModule( - [], - [ - createContractWithExpressionGetter( - makeF, - contractName, - "getInt", - bindings, - expr, - ), - ], - ); - - let compiledValue: bigint | undefined; - let compilationError: Error | undefined; - try { - let contractMapPromise = buildModule( - astF, - contractModule, - customStdlib, - blockchain, - ); - - const contractMap = await contractMapPromise; - const contract = contractMap.get(contractName)!; - await contract.send(sender, { value: toNano(1) }); - compiledValue = await contract.getInt(); - } catch (e: any) { - compilationError = e; - } - - let interpretedValue: bigint | undefined; - let interpretationError: Error | undefined; - try { - const interpreter = new Interpreter( - astUtil, - emptyCompilerContext, - ); - bindings.forEach((bind) => { - interpreter.interpretStatement(bind); - }); - const result = interpreter.interpretExpression(expr); - expect(result.kind).toBe("number"); - interpretedValue = (result as Ast.Number).value; - } catch (e: any) { - interpretationError = e; - } - - if ( - (compilationError && !interpretationError) || - (!compilationError && interpretationError) - ) { - expect(compilationError).toEqual(interpretationError); - } else if (compilationError && interpretationError) { - - } - expect(compiledValue).toBe(interpretedValue); - }, - ); - await checkAsyncProperty(property, ([bindings, expr]) => { - return ( - `\n-----\nGenerated bindings:\n` + - bindings - .map((bind) => GlobalContext.format(bind)) - .join("\n") + - `\nGenerated expression:\n` + - GlobalContext.format(expr) + - `\n-----\n` - ); - }); - }, - 60 * 1000, // 1 minute - ); -}); diff --git a/src/test/fuzzer/test/expression-stats.ts b/src/test/fuzzer/test/expressions/expression-stats.ts similarity index 100% rename from src/test/fuzzer/test/expression-stats.ts rename to src/test/fuzzer/test/expressions/expression-stats.ts diff --git a/src/test/fuzzer/test/expressions/expression.spec.ts b/src/test/fuzzer/test/expressions/expression.spec.ts new file mode 100644 index 0000000000..be0f5abdf5 --- /dev/null +++ b/src/test/fuzzer/test/expressions/expression.spec.ts @@ -0,0 +1,162 @@ +import { CompilerContext } from "@/context/context"; +import { resolveExpression, getExpType } from "@/types/resolveExpression"; +import type { StatementContext } from "@/types/resolveStatements"; +import type { TypeRef } from "@/types/types"; +import assert from "assert"; + +import { + Expression, + NonGenerativeExpressionParams, +} from "@/test/fuzzer/src/generators"; +import { Scope } from "@/test/fuzzer/src/scope"; +import { SUPPORTED_STDLIB_TYPES } from "@/test/fuzzer/src/types"; +import type { Type } from "@/test/fuzzer/src/types"; +import { + createProperty, + checkProperty, + dummySrcInfoPrintable, + checkAsyncProperty, + astNodeCounterexamplePrinter, +} from "@/test/fuzzer/src/util"; +import fc from "fast-check"; +import { + AllowedType, + AllowedTypeEnum, + GenContext, + initializeGenerator, + NonTerminal, +} from "../../src/generators/uniform-expr-gen"; +import { + bindingsAndExpressionPrtinter, + compileExpression, + ExpressionTestingEnvironment, + generateBindings, + interpretExpression, + setupEnvironment, +} from "./utils"; + +function emptyStatementContext(): StatementContext { + return { + root: dummySrcInfoPrintable, + returns: { kind: "void" }, + vars: new Map(), + requiredFields: [], + funName: null, + }; +} + +function setupContexts(): [CompilerContext, StatementContext] { + const ctx: CompilerContext = new CompilerContext(); + const sctx = emptyStatementContext(); + return [ctx, sctx]; +} + +describe("generation properties", () => { + it("generates well-typed expressions", () => { + const results = setupContexts(); + let compilerCtx = results[0]; + const stmtCtx = results[1]; + const globalScope = new Scope("program", undefined); + for (const type of SUPPORTED_STDLIB_TYPES) { + const ty: Type = { kind: "stdlib", type }; + // NOTE: This test checks only pure expressions, without introducing new + // entries to any scopes. + const exprGen = new Expression( + globalScope, + ty, + NonGenerativeExpressionParams, + ).generate(); + const property = createProperty(exprGen, (expr) => { + compilerCtx = resolveExpression(expr, stmtCtx, compilerCtx); + const resolvedTy = getExpType(compilerCtx, expr); + if (resolvedTy.kind == "ref") { + assert.strictEqual( + resolvedTy.name, + ty.type, + `The resolved type ${resolvedTy.name} does not match the expected type ${ty.type}`, + ); + } else { + assert.fail(`Unexpected type: ${resolvedTy.kind}`); + } + }); + checkProperty(property, astNodeCounterexamplePrinter); + } + }); +}); + +describe("evaluation properties", () => { + let expressionTestingEnvironment: ExpressionTestingEnvironment; + + beforeAll(async () => { + expressionTestingEnvironment = await setupEnvironment(); + }); + + test( + "compiler and interpreter evaluate generated expressions equally", + async () => { + const expressionGenerationIds: Map = + new Map(); + expressionGenerationIds.set(AllowedType.Int, ["int1"]); + expressionGenerationIds.set(AllowedType.OptInt, ["int_null"]); + expressionGenerationIds.set(AllowedType.Bool, ["bool1"]); + expressionGenerationIds.set(AllowedType.OptBool, ["bool_null"]); + expressionGenerationIds.set(AllowedType.Cell, ["cell1"]); + expressionGenerationIds.set(AllowedType.OptCell, ["cell_null"]); + expressionGenerationIds.set(AllowedType.Slice, ["slice1"]); + expressionGenerationIds.set(AllowedType.OptSlice, ["slice_null"]); + expressionGenerationIds.set(AllowedType.Address, ["address1"]); + expressionGenerationIds.set(AllowedType.OptAddress, [ + "address_null", + ]); + expressionGenerationIds.set(AllowedType.String, ["string1"]); + expressionGenerationIds.set(AllowedType.OptString, ["string_null"]); + + const expressionGenerationCtx: GenContext = { + identifiers: expressionGenerationIds, + contractNames: [ + expressionTestingEnvironment.contractNameToCompile, + ], + }; + const generator = initializeGenerator( + 1, + 10, + expressionTestingEnvironment.astF, + expressionGenerationCtx, + ); + + const property = fc.asyncProperty( + generateBindings( + expressionTestingEnvironment, + expressionGenerationIds, + generator, + ), + generator(NonTerminal.Int), + async (bindings, expr) => { + const compilationResult = await compileExpression( + expressionTestingEnvironment, + bindings, + expr, + ); + + const interpretationResult = interpretExpression( + expressionTestingEnvironment, + bindings, + expr, + ); + if ( + (compilationResult instanceof Error && + interpretationResult instanceof BigInt) || + (interpretationResult instanceof Error && + compilationResult instanceof BigInt) + ) { + expect(compilationResult).toEqual(interpretationResult); + } else { + expect(compilationResult).toBe(interpretationResult); + } + }, + ); + await checkAsyncProperty(property, bindingsAndExpressionPrtinter); + }, + 60 * 1000, // 1 minute + ); +}); diff --git a/src/test/fuzzer/test/expressions/utils.ts b/src/test/fuzzer/test/expressions/utils.ts new file mode 100644 index 0000000000..f95267cee5 --- /dev/null +++ b/src/test/fuzzer/test/expressions/utils.ts @@ -0,0 +1,249 @@ +import * as Ast from "@/ast/ast"; +import { getMakeAst, MakeAstFactory } from "@/ast/generated/make-factory"; +import { + AllowedTypeEnum, + NonTerminal, + NonTerminalEnum, +} from "../../src/generators/uniform-expr-gen"; +import { GlobalContext } from "../../src/context"; +import { Interpreter } from "@/optimizer/interpreter"; +import { CompilerContext } from "@/context/context"; +import { AstUtil, getAstUtil } from "@/ast/util"; +import { FactoryAst, getAstFactory } from "@/ast/ast-helpers"; +import { + buildModule, + CustomStdlib, + filterStdlib, + parseStandardLibrary, +} from "../../src/util"; +import { Blockchain } from "@ton/sandbox"; +import { Sender, toNano } from "@ton/core"; +import fc from "fast-check"; + +export function bindingsAndExpressionPrtinter([bindings, expr]: [ + Ast.StatementLet[], + Ast.Expression, +]) { + return ( + `\n-----\nGenerated bindings:\n` + + bindings.map((bind) => GlobalContext.format(bind)).join("\n") + + `\nGenerated expression:\n` + + GlobalContext.format(expr) + + `\n-----\n` + ); +} + +export function makeExpressionGetter( + makeF: MakeAstFactory, + getterName: string, + bindings: Ast.Statement[], + returnExpr: Ast.Expression, +): Ast.FunctionDef { + return makeF.makeDummyFunctionDef( + [makeF.makeDummyFunctionAttributeGet(undefined)], + makeF.makeDummyId(getterName), + makeF.makeDummyTypeId("Int"), + [], + bindings.concat([makeF.makeDummyStatementReturn(returnExpr)]), + ); +} + +export function createModuleWithExpressionGetter( + makeF: MakeAstFactory, + contractName: string, + getterName: string, + bindings: Ast.Statement[], + returnExpr: Ast.Expression, +): Ast.Module { + // throw new Error("createContract is not implemented yet"); // TODO: implement, probably should place this function in a different file + return makeF.makeModule( + [], + [ + makeF.makeDummyContract( + makeF.makeDummyId(contractName), + [], + [], + [], + [makeExpressionGetter(makeF, getterName, bindings, returnExpr)], + ), + ], + ); +} + +export const initializersMapping = { + Int: NonTerminal.LiteralInt, + "Int?": NonTerminal.LiteralInt, + Bool: NonTerminal.LiteralBool, + "Bool?": NonTerminal.LiteralBool, + Cell: NonTerminal.LiteralCell, + "Cell?": NonTerminal.LiteralCell, + Address: NonTerminal.LiteralAddress, + "Address?": NonTerminal.LiteralAddress, + Slice: NonTerminal.LiteralSlice, + "Slice?": NonTerminal.LiteralSlice, + String: NonTerminal.LiteralString, + "String?": NonTerminal.LiteralString, +} as const; + +export type ExpressionTestingEnvironment = { + astF: FactoryAst; + makeF: MakeAstFactory; + customStdlib: CustomStdlib; + blockchain: Blockchain; + emptyCompilerContext: CompilerContext; + astUtil: AstUtil; + sender: Sender; + contractNameToCompile: string; +}; + +export async function setupEnvironment(): Promise { + const astF = getAstFactory(); + const makeF = getMakeAst(astF); + const customStdlib = filterStdlib( + parseStandardLibrary(astF), + makeF, + new Set([ + "Int", + "Bool", + "Address", + "Cell", + "Context", + "Slice", + "Slice?", + "String", + "String?", + "StateInit", + "SendParameters", + "BaseTrait", + "SendDefaultMode", + "SendRemainingValue", + "SendIgnoreErrors", + "SendRemainingBalance", + "ReserveExact", + "sender", + "context", + "myBalance", + "nativeReserve", + //"contractAddress", + //"contractAddressExt", + //"storeUint", + //"storeInt", + //"contractHash", + //"newAddress", + //"beginCell", + //"endCell", + "send", + //"asSlice", + //"asAddressUnsafe", + //"beginParse", + ]), + ); + const blockchain = await Blockchain.create(); + const astUtil = getAstUtil(astF); + const sender = (await blockchain.treasury("treasury")).getSender(); + return { + astF, + makeF, + customStdlib, + blockchain, + astUtil, + sender, + emptyCompilerContext: new CompilerContext(), + contractNameToCompile: "ExpressionContract", + }; +} + +export function interpretExpression( + { astUtil, emptyCompilerContext }: ExpressionTestingEnvironment, + bindings: Ast.StatementLet[], + expr: Ast.Expression, +): bigint | Error { + try { + const interpreter = new Interpreter(astUtil, emptyCompilerContext); + bindings.forEach((bind) => { + interpreter.interpretStatement(bind); + }); + const result = interpreter.interpretExpression(expr); + expect(result.kind).toBe("number"); + return (result as Ast.Number).value; + } catch (e: any) { + return e as Error; + } +} + +export async function compileExpression( + { + makeF, + contractNameToCompile, + astF, + customStdlib, + blockchain, + sender, + }: ExpressionTestingEnvironment, + bindings: Ast.StatementLet[], + expr: Ast.Expression, +): Promise { + const contractModule = createModuleWithExpressionGetter( + makeF, + contractNameToCompile, + "getInt", + bindings, + expr, + ); + + try { + let contractMapPromise = buildModule( + astF, + contractModule, + customStdlib, + blockchain, + ); + + const contractMap = await contractMapPromise; + const contract = contractMap.get(contractNameToCompile)!; + await contract.send(sender, { value: toNano(1) }); + return await contract.getInt(); + } catch (e: any) { + return e; + } +} + +export function generateBindings( + expressionTestingEnvironment: ExpressionTestingEnvironment, + expressionGenerationIds: Map, + generator: (type: NonTerminalEnum) => fc.Arbitrary, +): fc.Arbitrary { + return fc.tuple( + ...expressionGenerationIds + .entries() + .flatMap(([type, names]) => + names.map((name) => + type.slice(-1) === "?" + ? fc.constant( + expressionTestingEnvironment.makeF.makeDummyStatementLet( + expressionTestingEnvironment.makeF.makeDummyId( + name, + ), + expressionTestingEnvironment.makeF.makeDummyOptionalType( + expressionTestingEnvironment.makeF.makeDummyTypeId( + type.slice(0, -1), + ), + ), + expressionTestingEnvironment.makeF.makeDummyNull(), + ), + ) + : generator(initializersMapping[type]).map((expr) => + expressionTestingEnvironment.makeF.makeDummyStatementLet( + expressionTestingEnvironment.makeF.makeDummyId( + name, + ), + expressionTestingEnvironment.makeF.makeDummyTypeId( + type, + ), + expr, + ), + ), + ), + ), + ); +} From 5e513dbd7a8f456db6bc7e8df7772fdcf5b568d8 Mon Sep 17 00:00:00 2001 From: jeshecdom Date: Sat, 12 Apr 2025 12:50:41 +0200 Subject: [PATCH 33/44] refactor: fully port generator to fast-check. --- .../fuzzer/src/generators/uniform-expr-gen.ts | 260 +++++++++--------- 1 file changed, 136 insertions(+), 124 deletions(-) diff --git a/src/test/fuzzer/src/generators/uniform-expr-gen.ts b/src/test/fuzzer/src/generators/uniform-expr-gen.ts index f1771b6b9d..3cc9f62b1c 100644 --- a/src/test/fuzzer/src/generators/uniform-expr-gen.ts +++ b/src/test/fuzzer/src/generators/uniform-expr-gen.ts @@ -1077,11 +1077,14 @@ function makeExpression( nonTerminalCounts: number[][][], sizeSplitCounts: number[][][][][], size: number, -): Ast.Expression { +): fc.Arbitrary { const makeF = getMakeAst(astF); const interpreter = new Interpreter(getAstUtil(astF)); - function genFromNonTerminal(id: number, size: number): Ast.Expression { + function genFromNonTerminal( + id: number, + size: number, + ): fc.Arbitrary { const prods = getProductions(id); const nonTerminalOptions = lookupNonTerminalCounts( nonTerminalCounts, @@ -1089,16 +1092,23 @@ function makeExpression( size, ); - const chosenProdIndex = randomlyChooseIndex(nonTerminalOptions); - const production = getProductionAt(prods, chosenProdIndex); - return genFromProduction(id, production, size); + const weightedNonTerminalOptions: fc.WeightedArbitrary[] = + nonTerminalOptions.map((w, i) => { + return { arbitrary: fc.constant(i), weight: w }; + }); + return fc + .oneof(...weightedNonTerminalOptions) + .chain((chosenProdIndex) => { + const production = getProductionAt(prods, chosenProdIndex); + return genFromProduction(id, production, size); + }); } function genFromProduction( nonTerminalIndex: number, production: ExprProduction, size: number, - ): Ast.Expression { + ): fc.Arbitrary { const head = getTokenAt(production.tokens, 0); if (head.terminal) { // The production must have the form: N -> head list_of_non_terminals @@ -1121,7 +1131,7 @@ function makeExpression( prodIndex: number, tokenIndex: number, size: number, - ): number { + ): fc.Arbitrary { const sizeSplits = lookupSizeSplitCounts( sizeSplitCounts, nonTerminalIndex, @@ -1129,42 +1139,43 @@ function makeExpression( tokenIndex, size, ); - return randomlyChooseIndex(sizeSplits) + 1; + // We need to add 1 to the result because sizes + // in splits are always positive. So, index 0 + // represents size 1, and so on. + const weightedSizeSplits: fc.WeightedArbitrary[] = + sizeSplits.map((w, i) => { + return { arbitrary: fc.constant(i + 1), weight: w }; + }); + return fc.oneof(...weightedSizeSplits); } function handleShiftOperators( op: Ast.BinaryOperation, expr: Ast.Expression, - ): Ast.Expression { - if (op === "<<" || op === ">>") { - try { - const literal = interpreter.interpretExpression(expr); - if (literal.kind !== "number") { - // Generate an integer of size 8 bits, unsigned - return fc.sample( - _generateIntBitLength(8, false).map((n) => - makeF.makeDummyNumber(10, n), - ), - 1, - )[0]!; - } - if (literal.value >= 0n && literal.value <= 256n) { - return expr; - } else { - // Generate an integer of size 8 bits, unsigned - return fc.sample( - _generateIntBitLength(8, false).map((n) => - makeF.makeDummyNumber(10, n), - ), - 1, - )[0]!; - } - } catch (_) { - // Any kind of error, leave the expr as is - return expr; + ): fc.Arbitrary { + if (op !== "<<" && op !== ">>") { + return fc.constant(expr); + } + try { + const literal = interpreter.interpretExpression(expr); + if (literal.kind !== "number") { + // Generate an integer in range [0..256] + return fc + .bigInt(0n, 256n) + .map((n) => makeF.makeDummyNumber(10, n)); + } + if (literal.value >= 0n && literal.value <= 256n) { + return fc.constant(expr); + } else { + // Generate an integer in range [0..256] + return fc + .bigInt(0n, 256n) + .map((n) => makeF.makeDummyNumber(10, n)); } + } catch (_) { + // Any kind of error, leave the expr as is + return fc.constant(expr); } - return expr; } function makeBinaryOperatorTree( @@ -1173,49 +1184,58 @@ function makeExpression( prodIndex: number, rest: Token[], size: number, - ): Ast.Expression { + ): fc.Arbitrary { const currSize = size - 1; // Choose a single split for the size - const sizeSplit = chooseSizeSplit( - nonTerminalIndex, - prodIndex, - 1, - currSize, - ); - - const leftNonTerminal = getNonTerminalAt(rest, 0); - const rightNonTerminal = getNonTerminalAt(rest, 1); - const leftOperand = genFromNonTerminal(leftNonTerminal.id, sizeSplit); - const rightOperand = genFromNonTerminal( - rightNonTerminal.id, - currSize - sizeSplit, + return chooseSizeSplit(nonTerminalIndex, prodIndex, 1, currSize).chain( + (sizeSplit) => { + const leftNonTerminal = getNonTerminalAt(rest, 0); + const rightNonTerminal = getNonTerminalAt(rest, 1); + + return genFromNonTerminal(leftNonTerminal.id, sizeSplit).chain( + (leftOperand) => { + return genFromNonTerminal( + rightNonTerminal.id, + currSize - sizeSplit, + ).chain((rightOperand) => { + // We need special logic to handle the shift operators, because they check + // at compile time if their right-hand side is within the range [0..256]. + return handleShiftOperators(op, rightOperand).map( + (squashedRightOperand) => + makeF.makeDummyOpBinary( + op, + leftOperand, + squashedRightOperand, + ), + ); + }); + }, + ); + }, ); - // We need special logic to handle the shift operators, because they check - // at compile time if their right-hand side is within the range [0..256]. - const squashedRightOperand = handleShiftOperators(op, rightOperand); - return makeF.makeDummyOpBinary(op, leftOperand, squashedRightOperand); } function makeUnaryOperatorTree( op: Ast.UnaryOperation, rest: Token[], size: number, - ): Ast.Expression { + ): fc.Arbitrary { const currSize = size - 1; const operandNonTerminal = getNonTerminalAt(rest, 0); - const operand = genFromNonTerminal(operandNonTerminal.id, currSize); - return makeF.makeDummyOpUnary(op, operand); + return genFromNonTerminal(operandNonTerminal.id, currSize).map( + (operand) => makeF.makeDummyOpUnary(op, operand), + ); } - function makeIdentifier(t: AllowedTypeEnum): Ast.Expression { + function makeIdentifier(t: AllowedTypeEnum): fc.Arbitrary { const names = ctx.identifiers.get(t); if (typeof names === "undefined" || names.length === 0) { throw new Error( `There must exist at least one identifier for type ${t}`, ); } - return makeF.makeDummyId(fc.sample(fc.constantFrom(...names))[0]!); + return fc.constantFrom(...names).map((id) => makeF.makeDummyId(id)); } function makeTree( @@ -1224,15 +1244,12 @@ function makeExpression( head: TerminalEnum, rest: Token[], size: number, - ): Ast.Expression { + ): fc.Arbitrary { switch (head.id) { case Terminal.integer.id: { - return fc.sample( - _generateIntBitLength(257, true).map((i) => - makeF.makeDummyNumber(10, i), - ), - 1, - )[0]!; + return _generateIntBitLength(257, true).map((i) => + makeF.makeDummyNumber(10, i), + ); } case Terminal.add.id: { return makeBinaryOperatorTree( @@ -1334,10 +1351,7 @@ function makeExpression( return makeUnaryOperatorTree("~", rest, size); } case Terminal.bool.id: { - return fc.sample( - fc.boolean().map((b) => makeF.makeDummyBoolean(b)), - 1, - )[0]!; + return fc.boolean().map((b) => makeF.makeDummyBoolean(b)); } case Terminal.eq.id: { return makeBinaryOperatorTree( @@ -1415,7 +1429,7 @@ function makeExpression( return makeUnaryOperatorTree("!", rest, size); } case Terminal.cell.id: { - return makeF.makeDummyCell(fc.sample(_generateCell(), 1)[0]!); + return _generateCell().map((c) => makeF.makeDummyCell(c)); } case Terminal.code_of.id: { if (ctx.contractNames.length === 0) { @@ -1423,24 +1437,22 @@ function makeExpression( "There must exist at least one contract name in generator context", ); } - return makeF.makeDummyCodeOf( - makeF.makeDummyId( - fc.sample(fc.constantFrom(...ctx.contractNames), 1)[0]!, - ), - ); + return fc + .constantFrom(...ctx.contractNames) + .map((name) => + makeF.makeDummyCodeOf(makeF.makeDummyId(name)), + ); } case Terminal.slice.id: { - return makeF.makeDummySlice( - fc.sample(_generateCell(), 1)[0]!.asSlice(), + return _generateCell().map((c) => + makeF.makeDummySlice(c.asSlice()), ); } case Terminal.address.id: { - return makeF.makeDummyAddress( - fc.sample(_generateAddress(), 1)[0]!, - ); + return _generateAddress().map((a) => makeF.makeDummyAddress(a)); } case Terminal.string.id: { - return makeF.makeDummyString(fc.sample(fc.string(), 1)[0]!); + return fc.string().map((s) => makeF.makeDummyString(s)); } case Terminal.opt_inj.id: { const currSize = size - 1; @@ -1448,7 +1460,7 @@ function makeExpression( return genFromNonTerminal(operandNonTerminal.id, currSize); } case Terminal.null.id: { - return makeF.makeDummyNull(); + return fc.constant(makeF.makeDummyNull()); } case Terminal.non_null_assert.id: { return makeUnaryOperatorTree("!!", rest, size); @@ -1456,39 +1468,44 @@ function makeExpression( case Terminal.cond.id: { const currSize = size - 1; // Choose two splits for the size - const sizeSplit1 = chooseSizeSplit( + return chooseSizeSplit( nonTerminalIndex, prodIndex, 1, currSize, - ); - const sizeSplit2 = chooseSizeSplit( - nonTerminalIndex, - prodIndex, - 2, - currSize - sizeSplit1, - ); - - const condNonTerminal = getNonTerminalAt(rest, 0); - const thenNonTerminal = getNonTerminalAt(rest, 1); - const elseNonTerminal = getNonTerminalAt(rest, 2); - const condOperand = genFromNonTerminal( - condNonTerminal.id, - sizeSplit1, - ); - const thenOperand = genFromNonTerminal( - thenNonTerminal.id, - sizeSplit2, - ); - const elseOperand = genFromNonTerminal( - elseNonTerminal.id, - currSize - sizeSplit1 - sizeSplit2, - ); - return makeF.makeDummyConditional( - condOperand, - thenOperand, - elseOperand, - ); + ).chain((sizeSplit1) => { + return chooseSizeSplit( + nonTerminalIndex, + prodIndex, + 2, + currSize - sizeSplit1, + ).chain((sizeSplit2) => { + const condNonTerminal = getNonTerminalAt(rest, 0); + const thenNonTerminal = getNonTerminalAt(rest, 1); + const elseNonTerminal = getNonTerminalAt(rest, 2); + + return genFromNonTerminal( + condNonTerminal.id, + sizeSplit1, + ).chain((condOperand) => { + return genFromNonTerminal( + thenNonTerminal.id, + sizeSplit2, + ).chain((thenOperand) => { + return genFromNonTerminal( + elseNonTerminal.id, + currSize - sizeSplit1 - sizeSplit2, + ).map((elseOperand) => + makeF.makeDummyConditional( + condOperand, + thenOperand, + elseOperand, + ), + ); + }); + }); + }); + }); } case Terminal.id_int.id: { return makeIdentifier("Int"); @@ -1543,8 +1560,13 @@ export function initializeGenerator( return (type: NonTerminalEnum) => { const sizes = lookupTotalCounts(totalCounts, type.id); - return fc.constant(0).map((_) => { - const size = randomlyChooseIndex(sizes); + const weightedSizes: fc.WeightedArbitrary[] = sizes.map( + (w, i) => { + return { arbitrary: fc.constant(i), weight: w }; + }, + ); + + return fc.oneof(...weightedSizes).chain((size) => { return makeExpression( astF, type, @@ -1557,16 +1579,6 @@ export function initializeGenerator( }; } -function randomlyChooseIndex(array: number[]): number { - const random = Math.random() * array[array.length - 1]!; - for (let i = 0; i < array.length; i++) { - if (array[i]! > random) { - return i; - } - } - throw new Error("There must exist at least one element in the array"); -} - function testSubwalletId(seed: string): bigint { return BigInt("0x" + sha256_sync("TEST_SEED" + seed).toString("hex")); } From 54f210fc61e939c73e95f9115123a8a0280a7284 Mon Sep 17 00:00:00 2001 From: jeshecdom Date: Sat, 12 Apr 2025 14:18:16 +0200 Subject: [PATCH 34/44] fix: add cell_hash, slice_hash, string_hash missing functions in minimal stdlib. --- src/test/fuzzer/src/minimal-fc-stdlib/stdlib.fc | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/src/test/fuzzer/src/minimal-fc-stdlib/stdlib.fc b/src/test/fuzzer/src/minimal-fc-stdlib/stdlib.fc index 95acd5b2c5..10989a9191 100644 --- a/src/test/fuzzer/src/minimal-fc-stdlib/stdlib.fc +++ b/src/test/fuzzer/src/minimal-fc-stdlib/stdlib.fc @@ -58,4 +58,10 @@ cell udict_set(cell dict, int key_len, int index, slice value) asm(value index d (cell, int) udict_get_ref?(cell dict, int key_len, int index) asm(index dict key_len) "DICTUGETREF" "NULLSWAPIFNOT"; cell udict_set_ref(cell dict, int key_len, int index, cell value) asm(value index dict key_len) "DICTUSETREF"; -(cell, ()) ~udict_set_ref(cell dict, int key_len, int index, cell value) asm(value index dict key_len) "DICTUSETREF"; \ No newline at end of file +(cell, ()) ~udict_set_ref(cell dict, int key_len, int index, cell value) asm(value index dict key_len) "DICTUSETREF"; + +int cell_hash(cell c) asm "HASHCU"; + +int slice_hash(slice s) asm "HASHSU"; + +int string_hash(slice s) asm "SHA256U"; \ No newline at end of file From 7abb57b89e69b705b4bef62f35e0e030810d6e8e Mon Sep 17 00:00:00 2001 From: Mell0r Date: Sat, 12 Apr 2025 12:33:45 +0300 Subject: [PATCH 35/44] feat: added interpratation and compilation failing tests saving to the file --- .../fuzzer/test/expressions/expression.spec.ts | 14 ++++++++++++++ src/test/fuzzer/test/expressions/utils.ts | 18 ++++++++++++++++++ 2 files changed, 32 insertions(+) diff --git a/src/test/fuzzer/test/expressions/expression.spec.ts b/src/test/fuzzer/test/expressions/expression.spec.ts index be0f5abdf5..1d51515978 100644 --- a/src/test/fuzzer/test/expressions/expression.spec.ts +++ b/src/test/fuzzer/test/expressions/expression.spec.ts @@ -32,6 +32,7 @@ import { ExpressionTestingEnvironment, generateBindings, interpretExpression, + saveExpressionTest, setupEnvironment, } from "./utils"; @@ -91,6 +92,8 @@ describe("evaluation properties", () => { expressionTestingEnvironment = await setupEnvironment(); }); + afterAll(() => expressionTestingEnvironment.outputStream.close()); + test( "compiler and interpreter evaluate generated expressions equally", async () => { @@ -150,6 +153,17 @@ describe("evaluation properties", () => { compilationResult instanceof BigInt) ) { expect(compilationResult).toEqual(interpretationResult); + } else if ( + compilationResult instanceof Error && + interpretationResult instanceof Error + ) { + saveExpressionTest( + bindings, + expr, + compilationResult, + interpretationResult, + expressionTestingEnvironment.outputStream, + ); } else { expect(compilationResult).toBe(interpretationResult); } diff --git a/src/test/fuzzer/test/expressions/utils.ts b/src/test/fuzzer/test/expressions/utils.ts index f95267cee5..e797e87cfc 100644 --- a/src/test/fuzzer/test/expressions/utils.ts +++ b/src/test/fuzzer/test/expressions/utils.ts @@ -19,6 +19,7 @@ import { import { Blockchain } from "@ton/sandbox"; import { Sender, toNano } from "@ton/core"; import fc from "fast-check"; +import * as fs from "node:fs"; export function bindingsAndExpressionPrtinter([bindings, expr]: [ Ast.StatementLet[], @@ -94,6 +95,7 @@ export type ExpressionTestingEnvironment = { astUtil: AstUtil; sender: Sender; contractNameToCompile: string; + outputStream: fs.WriteStream; }; export async function setupEnvironment(): Promise { @@ -150,6 +152,9 @@ export async function setupEnvironment(): Promise sender, emptyCompilerContext: new CompilerContext(), contractNameToCompile: "ExpressionContract", + outputStream: fs.createWriteStream("interesting-failing-tests.txt", { + flags: "a", + }), }; } @@ -247,3 +252,16 @@ export function generateBindings( ), ); } + +export function saveExpressionTest( + bindings: Ast.StatementLet[], + expr: Ast.Expression, + compilationResult: Error, + interpretationResult: Error, + outputStream: fs.WriteStream, +): void { + outputStream.write( + bindingsAndExpressionPrtinter([bindings, expr]) + + `\nCompilation error: ${compilationResult}\nInterpretation error: ${interpretationResult}\n`, + ); +} From ff735d22f0fa4b837272e9f1b27fb6029464ff02 Mon Sep 17 00:00:00 2001 From: Mell0r Date: Sat, 12 Apr 2025 16:19:51 +0300 Subject: [PATCH 36/44] wip: feat: merge with parent branch --- .../fuzzer/src/generators/uniform-expr-gen.ts | 245 +++++++++--------- .../test/expressions/expression.spec.ts | 2 +- 2 files changed, 123 insertions(+), 124 deletions(-) diff --git a/src/test/fuzzer/src/generators/uniform-expr-gen.ts b/src/test/fuzzer/src/generators/uniform-expr-gen.ts index 18707e9b0b..4d707830b2 100644 --- a/src/test/fuzzer/src/generators/uniform-expr-gen.ts +++ b/src/test/fuzzer/src/generators/uniform-expr-gen.ts @@ -39,27 +39,27 @@ export const NonTerminal = { Int: { terminal: false, literal: false, id: 1 }, OptInt: { terminal: false, literal: false, id: 2 }, LiteralInt: { terminal: false, literal: true, id: 3 }, - LiteralOptInt: { terminal: false, literal: true, id: 4 }, - Bool: { terminal: false, literal: false, id: 5 }, - OptBool: { terminal: false, literal: false, id: 6 }, - LiteralBool: { terminal: false, literal: true, id: 7 }, - LiteralOptBool: { terminal: false, literal: true, id: 8 }, - Cell: { terminal: false, literal: false, id: 9 }, - OptCell: { terminal: false, literal: false, id: 10 }, - LiteralCell: { terminal: false, literal: true, id: 11 }, - LiteralOptCell: { terminal: false, literal: true, id: 12 }, - Slice: { terminal: false, literal: false, id: 13 }, - OptSlice: { terminal: false, literal: false, id: 14 }, - LiteralSlice: { terminal: false, literal: true, id: 15 }, - LiteralOptSlice: { terminal: false, literal: true, id: 16 }, - Address: { terminal: false, literal: false, id: 17 }, - OptAddress: { terminal: false, literal: false, id: 18 }, - LiteralAddress: { terminal: false, literal: true, id: 19 }, - LiteralOptAddress: { terminal: false, literal: true, id: 20 }, - String: { terminal: false, literal: false, id: 21 }, - OptString: { terminal: false, literal: false, id: 22 }, - LiteralString: { terminal: false, literal: true, id: 23 }, - LiteralOptString: { terminal: false, literal: true, id: 24 }, + // LiteralOptInt: { terminal: false, literal: true, id: 4 }, + Bool: { terminal: false, literal: false, id: 4 }, + OptBool: { terminal: false, literal: false, id: 5 }, + LiteralBool: { terminal: false, literal: true, id: 6 }, + // LiteralOptBool: { terminal: false, literal: true, id: 8 }, + Cell: { terminal: false, literal: false, id: 7 }, + OptCell: { terminal: false, literal: false, id: 8 }, + LiteralCell: { terminal: false, literal: true, id: 9 }, + // LiteralOptCell: { terminal: false, literal: true, id: 12 }, + Slice: { terminal: false, literal: false, id: 10 }, + OptSlice: { terminal: false, literal: false, id: 11 }, + LiteralSlice: { terminal: false, literal: true, id: 12 }, + // LiteralOptSlice: { terminal: false, literal: true, id: 16 }, + Address: { terminal: false, literal: false, id: 13 }, + OptAddress: { terminal: false, literal: false, id: 14 }, + LiteralAddress: { terminal: false, literal: true, id: 15 }, + // LiteralOptAddress: { terminal: false, literal: true, id: 20 }, + String: { terminal: false, literal: false, id: 16 }, + OptString: { terminal: false, literal: false, id: 17 }, + LiteralString: { terminal: false, literal: true, id: 18 }, + // LiteralOptString: { terminal: false, literal: true, id: 24 }, } as const; export type NonTerminalEnum = (typeof NonTerminal)[keyof typeof NonTerminal]; @@ -100,24 +100,24 @@ const Terminal = { string: { terminal: true, id: 28 }, - opt_inj: { terminal: true, id: 29 }, + // opt_inj: { terminal: true, id: 30 }, // null: { terminal: true, id: 30 }, - non_null_assert: { terminal: true, id: 30 }, - - cond: { terminal: true, id: 31 }, - - id_int: { terminal: true, id: 32 }, - id_opt_int: { terminal: true, id: 33 }, - id_bool: { terminal: true, id: 34 }, - id_opt_bool: { terminal: true, id: 35 }, - id_cell: { terminal: true, id: 36 }, - id_opt_cell: { terminal: true, id: 37 }, - id_slice: { terminal: true, id: 38 }, - id_opt_slice: { terminal: true, id: 39 }, - id_address: { terminal: true, id: 40 }, - id_opt_address: { terminal: true, id: 41 }, - id_string: { terminal: true, id: 42 }, - id_opt_string: { terminal: true, id: 43 }, + non_null_assert: { terminal: true, id: 29 }, + + cond: { terminal: true, id: 30 }, + + id_int: { terminal: true, id: 31 }, + id_opt_int: { terminal: true, id: 32 }, + id_bool: { terminal: true, id: 33 }, + id_opt_bool: { terminal: true, id: 34 }, + id_cell: { terminal: true, id: 35 }, + id_opt_cell: { terminal: true, id: 36 }, + id_slice: { terminal: true, id: 37 }, + id_opt_slice: { terminal: true, id: 38 }, + id_address: { terminal: true, id: 39 }, + id_opt_address: { terminal: true, id: 40 }, + id_string: { terminal: true, id: 41 }, + id_opt_string: { terminal: true, id: 42 }, } as const; type TerminalEnum = (typeof Terminal)[keyof typeof Terminal]; @@ -135,27 +135,27 @@ const allProductions: ExprProduction[][] = [ { id: 0, tokens: [NonTerminal.Int] }, { id: 1, tokens: [NonTerminal.OptInt] }, { id: 2, tokens: [NonTerminal.LiteralInt] }, - { id: 3, tokens: [NonTerminal.LiteralOptInt] }, - { id: 4, tokens: [NonTerminal.Bool] }, - { id: 5, tokens: [NonTerminal.OptBool] }, - { id: 6, tokens: [NonTerminal.LiteralBool] }, - { id: 7, tokens: [NonTerminal.LiteralOptBool] }, - { id: 8, tokens: [NonTerminal.Cell] }, - { id: 9, tokens: [NonTerminal.OptCell] }, - { id: 10, tokens: [NonTerminal.LiteralCell] }, - { id: 11, tokens: [NonTerminal.LiteralOptCell] }, - { id: 12, tokens: [NonTerminal.Slice] }, - { id: 13, tokens: [NonTerminal.OptSlice] }, - { id: 14, tokens: [NonTerminal.LiteralSlice] }, - { id: 15, tokens: [NonTerminal.LiteralOptSlice] }, - { id: 16, tokens: [NonTerminal.Address] }, - { id: 17, tokens: [NonTerminal.OptAddress] }, - { id: 18, tokens: [NonTerminal.LiteralAddress] }, - { id: 19, tokens: [NonTerminal.LiteralOptAddress] }, - { id: 20, tokens: [NonTerminal.String] }, - { id: 21, tokens: [NonTerminal.LiteralString] }, - { id: 22, tokens: [NonTerminal.OptString] }, - { id: 23, tokens: [NonTerminal.LiteralOptString] }, + // { id: 3, tokens: [NonTerminal.LiteralOptInt] }, + { id: 3, tokens: [NonTerminal.Bool] }, + { id: 4, tokens: [NonTerminal.OptBool] }, + { id: 5, tokens: [NonTerminal.LiteralBool] }, + // { id: 7, tokens: [NonTerminal.LiteralOptBool] }, + { id: 6, tokens: [NonTerminal.Cell] }, + { id: 7, tokens: [NonTerminal.OptCell] }, + { id: 8, tokens: [NonTerminal.LiteralCell] }, + // { id: 11, tokens: [NonTerminal.LiteralOptCell] }, + { id: 9, tokens: [NonTerminal.Slice] }, + { id: 10, tokens: [NonTerminal.OptSlice] }, + { id: 11, tokens: [NonTerminal.LiteralSlice] }, + // { id: 15, tokens: [NonTerminal.LiteralOptSlice] }, + { id: 12, tokens: [NonTerminal.Address] }, + { id: 13, tokens: [NonTerminal.OptAddress] }, + { id: 14, tokens: [NonTerminal.LiteralAddress] }, + // { id: 19, tokens: [NonTerminal.LiteralOptAddress] }, + { id: 15, tokens: [NonTerminal.String] }, + { id: 16, tokens: [NonTerminal.LiteralString] }, + { id: 17, tokens: [NonTerminal.OptString] }, + // { id: 23, tokens: [NonTerminal.LiteralOptString] }, ], [ // Productions for Int @@ -206,9 +206,9 @@ const allProductions: ExprProduction[][] = [ ], [ // Productions for OptInt - { id: 0, tokens: [Terminal.opt_inj, NonTerminal.Int] }, + // { id: 0, tokens: [Terminal.opt_inj, NonTerminal.Int] }, { - id: 1, + id: 0, tokens: [ Terminal.cond, NonTerminal.Bool, @@ -216,18 +216,18 @@ const allProductions: ExprProduction[][] = [ NonTerminal.OptInt, ], }, - { id: 2, tokens: [Terminal.id_opt_int] }, - { id: 3, tokens: [NonTerminal.LiteralOptInt] }, + { id: 1, tokens: [Terminal.id_opt_int] }, + // { id: 2, tokens: [NonTerminal.LiteralOptInt] }, ], [ // Productions for LiteralInt { id: 0, tokens: [Terminal.integer] }, ], - [ - // Productions for LiteralOptInt - // { id: 0, tokens: [Terminal.null] }, - { id: 0, tokens: [Terminal.opt_inj, NonTerminal.LiteralInt] }, - ], + // [ + // // Productions for LiteralOptInt + // // { id: 0, tokens: [Terminal.null] }, + // // { id: 1, tokens: [Terminal.opt_inj, NonTerminal.LiteralInt] }, + // ], [ // Productions for Bool { id: 0, tokens: [Terminal.eq, NonTerminal.Int, NonTerminal.Int] }, @@ -357,9 +357,9 @@ const allProductions: ExprProduction[][] = [ ], [ // Productions for OptBool - { id: 0, tokens: [Terminal.opt_inj, NonTerminal.Bool] }, + // { id: 0, tokens: [Terminal.opt_inj, NonTerminal.Bool] }, { - id: 1, + id: 0, tokens: [ Terminal.cond, NonTerminal.Bool, @@ -367,18 +367,18 @@ const allProductions: ExprProduction[][] = [ NonTerminal.OptBool, ], }, - { id: 2, tokens: [Terminal.id_opt_bool] }, - { id: 3, tokens: [NonTerminal.LiteralOptBool] }, + { id: 1, tokens: [Terminal.id_opt_bool] }, + // { id: 3, tokens: [NonTerminal.LiteralOptBool] }, ], [ // Productions for LiteralBool { id: 0, tokens: [Terminal.bool] }, ], - [ - // Productions for LiteralOptBool - // { id: 0, tokens: [Terminal.null] }, - { id: 0, tokens: [Terminal.opt_inj, NonTerminal.LiteralBool] }, - ], + // [ + // // Productions for LiteralOptBool + // // { id: 0, tokens: [Terminal.null] }, + // // { id: 1, tokens: [Terminal.opt_inj, NonTerminal.LiteralBool] }, + // ], [ // Productions for Cell { id: 0, tokens: [Terminal.code_of] }, @@ -398,9 +398,9 @@ const allProductions: ExprProduction[][] = [ ], [ // Productions for OptCell - { id: 0, tokens: [Terminal.opt_inj, NonTerminal.Cell] }, + // { id: 0, tokens: [Terminal.opt_inj, NonTerminal.Cell] }, { - id: 1, + id: 0, tokens: [ Terminal.cond, NonTerminal.Bool, @@ -408,18 +408,18 @@ const allProductions: ExprProduction[][] = [ NonTerminal.OptCell, ], }, - { id: 2, tokens: [Terminal.id_opt_cell] }, - { id: 3, tokens: [NonTerminal.LiteralOptCell] }, + { id: 1, tokens: [Terminal.id_opt_cell] }, + // { id: 2, tokens: [NonTerminal.LiteralOptCell] }, ], [ // Productions for LiteralCell { id: 0, tokens: [Terminal.cell] }, ], - [ - // Productions for LiteralOptCell - // { id: 0, tokens: [Terminal.null] }, - { id: 0, tokens: [Terminal.opt_inj, NonTerminal.LiteralCell] }, - ], + // [ + // // Productions for LiteralOptCell + // // { id: 0, tokens: [Terminal.null] }, + // // { id: 1, tokens: [Terminal.opt_inj, NonTerminal.LiteralCell] }, + // ], [ // Productions for Slice { id: 0, tokens: [Terminal.non_null_assert, NonTerminal.OptSlice] }, @@ -437,9 +437,9 @@ const allProductions: ExprProduction[][] = [ ], [ // Productions for OptSlice - { id: 0, tokens: [Terminal.opt_inj, NonTerminal.Slice] }, + // { id: 0, tokens: [Terminal.opt_inj, NonTerminal.Slice] }, { - id: 1, + id: 0, tokens: [ Terminal.cond, NonTerminal.Bool, @@ -447,18 +447,18 @@ const allProductions: ExprProduction[][] = [ NonTerminal.OptSlice, ], }, - { id: 2, tokens: [Terminal.id_opt_slice] }, - { id: 3, tokens: [NonTerminal.LiteralOptSlice] }, + { id: 1, tokens: [Terminal.id_opt_slice] }, + // { id: 2, tokens: [NonTerminal.LiteralOptSlice] }, ], [ // Productions for LiteralSlice { id: 0, tokens: [Terminal.slice] }, ], - [ - // Productions for LiteralOptSlice - // { id: 0, tokens: [Terminal.null] }, - { id: 0, tokens: [Terminal.opt_inj, NonTerminal.LiteralSlice] }, - ], + // [ + // // Productions for LiteralOptSlice + // // { id: 0, tokens: [Terminal.null] }, + // // { id: 1, tokens: [Terminal.opt_inj, NonTerminal.LiteralSlice] }, + // ], [ // Productions for Address { @@ -479,9 +479,9 @@ const allProductions: ExprProduction[][] = [ ], [ // Productions for OptAddress - { id: 0, tokens: [Terminal.opt_inj, NonTerminal.Address] }, + // { id: 0, tokens: [Terminal.opt_inj, NonTerminal.Address] }, { - id: 1, + id: 0, tokens: [ Terminal.cond, NonTerminal.Bool, @@ -489,18 +489,18 @@ const allProductions: ExprProduction[][] = [ NonTerminal.OptAddress, ], }, - { id: 2, tokens: [Terminal.id_opt_address] }, - { id: 3, tokens: [NonTerminal.LiteralOptAddress] }, + { id: 1, tokens: [Terminal.id_opt_address] }, + // { id: 3, tokens: [NonTerminal.LiteralOptAddress] }, ], [ // Productions for LiteralAddress { id: 0, tokens: [Terminal.address] }, ], - [ - // Productions for LiteralOptAddress - // { id: 0, tokens: [Terminal.null] }, - { id: 0, tokens: [Terminal.opt_inj, NonTerminal.LiteralAddress] }, - ], + // [ + // // Productions for LiteralOptAddress + // // { id: 0, tokens: [Terminal.null] }, + // // { id: 1, tokens: [Terminal.opt_inj, NonTerminal.LiteralAddress] }, + // ], [ // Productions for String { id: 0, tokens: [Terminal.non_null_assert, NonTerminal.OptString] }, @@ -518,9 +518,9 @@ const allProductions: ExprProduction[][] = [ ], [ // Productions for OptString - { id: 0, tokens: [Terminal.opt_inj, NonTerminal.String] }, + // { id: 0, tokens: [Terminal.opt_inj, NonTerminal.String] }, { - id: 1, + id: 0, tokens: [ Terminal.cond, NonTerminal.Bool, @@ -528,18 +528,18 @@ const allProductions: ExprProduction[][] = [ NonTerminal.OptString, ], }, - { id: 2, tokens: [Terminal.id_opt_string] }, - { id: 3, tokens: [NonTerminal.LiteralOptString] }, + { id: 1, tokens: [Terminal.id_opt_string] }, + // { id: 2, tokens: [NonTerminal.LiteralOptString] }, ], [ // Productions for LiteralString { id: 0, tokens: [Terminal.string] }, ], - [ - // Productions for LiteralOptString - // { id: 0, tokens: [Terminal.null] }, - { id: 0, tokens: [Terminal.opt_inj, NonTerminal.LiteralString] }, - ], + // [ + // // Productions for LiteralOptString + // // { id: 0, tokens: [Terminal.null] }, + // // { id: 1, tokens: [Terminal.opt_inj, NonTerminal.LiteralString] }, + // ], ]; function sum(counts: number[]): number { @@ -1454,14 +1454,14 @@ function makeExpression( case Terminal.string.id: { return fc.string().map((s) => makeF.makeDummyString(s)); } - case Terminal.opt_inj.id: { - const currSize = size - 1; - const operandNonTerminal = getNonTerminalAt(rest, 0); - return genFromNonTerminal(operandNonTerminal.id, currSize); - } - case Terminal.null.id: { - return fc.constant(makeF.makeDummyNull()); - } + // case Terminal.opt_inj.id: { + // const currSize = size - 1; + // const operandNonTerminal = getNonTerminalAt(rest, 0); + // return genFromNonTerminal(operandNonTerminal.id, currSize); + // } + // case Terminal.null.id: { + // return fc.constant(makeF.makeDummyNull()); + // } case Terminal.non_null_assert.id: { return makeUnaryOperatorTree("!!", rest, size); } @@ -1552,7 +1552,6 @@ function makeExpression( export function initializeGenerator( minSize: number, maxSize: number, - astF: FactoryAst, ctx: GenContext, astF: FactoryAst, ): (type: NonTerminalEnum) => fc.Arbitrary { @@ -1611,4 +1610,4 @@ function _generateIntBitLength( } else { return fc.bigInt(0n, maxUnsigned); } -} +} \ No newline at end of file diff --git a/src/test/fuzzer/test/expressions/expression.spec.ts b/src/test/fuzzer/test/expressions/expression.spec.ts index 1d51515978..a49e5ae41a 100644 --- a/src/test/fuzzer/test/expressions/expression.spec.ts +++ b/src/test/fuzzer/test/expressions/expression.spec.ts @@ -123,8 +123,8 @@ describe("evaluation properties", () => { const generator = initializeGenerator( 1, 10, - expressionTestingEnvironment.astF, expressionGenerationCtx, + expressionTestingEnvironment.astF, ); const property = fc.asyncProperty( From d9353f43de0e6b0e9808ad4c3ae76af7c0953dfa Mon Sep 17 00:00:00 2001 From: jeshecdom Date: Sat, 12 Apr 2025 16:17:27 +0200 Subject: [PATCH 37/44] fix: removed partial sums from counting. --- .../fuzzer/src/generators/uniform-expr-gen.ts | 27 +++++-------------- 1 file changed, 6 insertions(+), 21 deletions(-) diff --git a/src/test/fuzzer/src/generators/uniform-expr-gen.ts b/src/test/fuzzer/src/generators/uniform-expr-gen.ts index 4d707830b2..0958f855ab 100644 --- a/src/test/fuzzer/src/generators/uniform-expr-gen.ts +++ b/src/test/fuzzer/src/generators/uniform-expr-gen.ts @@ -558,13 +558,12 @@ function sum(counts: number[]): number { // For the general case, we reduce the array thanks to the following formula: // log(x + y) = log x + log(1 + 2^(log y - log x)) // which tells us how we should add counts when they are represented as logarithms - const bla = filteredCounts + return filteredCounts .slice(1) .reduce( (prev, curr) => prev + Math.log2(1 + 2 ** (curr - prev)), first, ); - return bla; } function normalizeArray(counts: number[]): number[] { @@ -572,7 +571,7 @@ function normalizeArray(counts: number[]): number[] { // So, it is enough to transform -Inf back to 0. // Any 0 represents a count of 1. Since such index has a non-zero probability to be selected, // we change the 0s to 1s. The rest of numbers we take their ceil to transform them into integers. - const bla = counts.map((n) => { + return counts.map((n) => { if (n === Number.NEGATIVE_INFINITY) { return 0; } @@ -581,7 +580,6 @@ function normalizeArray(counts: number[]): number[] { } return Math.ceil(n); }); - return bla; } function multiply(first: number, second: number): number { @@ -881,17 +879,6 @@ function computeCountTables( } } - function computePartialSums(counts: number[]): number[] { - if (counts.length === 0) { - return counts; - } - const result: number[] = [counts[0]!]; - for (let i = 1; i < counts.length; i++) { - result[i] = counts[i]! + result[i - 1]!; - } - return result; - } - function normalizeCounts() { // The total counts for (const nonTerminal of Object.values(NonTerminal)) { @@ -899,7 +886,7 @@ function computeCountTables( if (typeof counts === "undefined") { throw new Error(`Index ${nonTerminal.id} out of bounds`); } - const newCounts = computePartialSums(normalizeArray(counts)); + const newCounts = normalizeArray(counts); totalCounts[nonTerminal.id] = newCounts; } @@ -911,7 +898,7 @@ function computeCountTables( nonTerminal.id, size, ); - const newCounts = computePartialSums(normalizeArray(counts)); + const newCounts = normalizeArray(counts); updateNonTerminalCounts(nonTerminal.id, size, newCounts); } } @@ -936,9 +923,7 @@ function computeCountTables( tokenIndx, size, ); - const newCounts = computePartialSums( - normalizeArray(counts), - ); + const newCounts = normalizeArray(counts); updateSizeSplitCounts( nonTerminal.id, prod.id, @@ -1610,4 +1595,4 @@ function _generateIntBitLength( } else { return fc.bigInt(0n, maxUnsigned); } -} \ No newline at end of file +} From 2a12aff3363801e5fafa5fb8a2f53302ec86bca1 Mon Sep 17 00:00:00 2001 From: jeshecdom Date: Sat, 12 Apr 2025 16:26:17 +0200 Subject: [PATCH 38/44] refactor: updated some wrong comments --- src/test/fuzzer/src/generators/uniform-expr-gen.ts | 3 --- 1 file changed, 3 deletions(-) diff --git a/src/test/fuzzer/src/generators/uniform-expr-gen.ts b/src/test/fuzzer/src/generators/uniform-expr-gen.ts index 0958f855ab..e1360ea39b 100644 --- a/src/test/fuzzer/src/generators/uniform-expr-gen.ts +++ b/src/test/fuzzer/src/generators/uniform-expr-gen.ts @@ -958,9 +958,6 @@ function computeCountTables( // into non-negative integers (because they may be currently encoded // in a different way. For example, when using logarithms to represent // counts, the numbers have fractional part, and may also include -Inf). - // Also, once they are normalized into non-negative integers, - // we need to compute their partial sums, in preparation for the generation - // process. normalizeCounts(); return { From 24ee6a4cd9ca0308807fb2d882a62e59fec301b8 Mon Sep 17 00:00:00 2001 From: jeshecdom Date: Tue, 15 Apr 2025 17:52:22 +0200 Subject: [PATCH 39/44] tests: partial functionality: testing configurable terminals and non-terminals. --- src/func/funcCompile.ts | 71 ++++++ .../fuzzer/src/generators/uniform-expr-gen.ts | 204 +++++++++++++++--- .../fuzzer/src/minimal-fc-stdlib/funcplusfift | Bin 0 -> 5051536 bytes .../fuzzer/src/minimal-fc-stdlib/stdlib_ex.fc | 1 + src/test/fuzzer/src/util.ts | 47 ++-- .../test/expressions/expression.spec.ts | 5 +- src/test/fuzzer/test/expressions/utils.ts | 4 +- 7 files changed, 273 insertions(+), 59 deletions(-) create mode 100755 src/test/fuzzer/src/minimal-fc-stdlib/funcplusfift create mode 100644 src/test/fuzzer/src/minimal-fc-stdlib/stdlib_ex.fc diff --git a/src/func/funcCompile.ts b/src/func/funcCompile.ts index 56801437bd..8d388bc506 100644 --- a/src/func/funcCompile.ts +++ b/src/func/funcCompile.ts @@ -1,4 +1,6 @@ import type { ILogger } from "@/context/logger"; +import { execSync } from "child_process"; +import path from "path"; // Wasm Imports // eslint-disable-next-line @typescript-eslint/no-require-imports @@ -56,10 +58,79 @@ type CompileResult = warnings: string; }; + + export async function funcCompile(args: { entries: string[]; sources: { path: string; content: string }[]; logger: ILogger; +}): Promise { + const USE_NATIVE = process.env.USE_NATIVE === "true"; + if (USE_NATIVE) { + return funcCompileNative(args); + } + return funcCompileWasm(args); +} + +export function funcCompileNative(args: { + entries: string[]; + sources: { path: string; content: string }[]; + logger: ILogger; +}): FuncCompilationResult { + const FC_STDLIB_PATH = process.env.FC_STDLIB_PATH; + if (typeof FC_STDLIB_PATH === "undefined") { + throw new Error("FC_STDLIB_PATH is not set"); + } + const FIFT_LIBS_PATH = process.env.FIFT_LIBS_PATH; + if (typeof FIFT_LIBS_PATH === "undefined") { + throw new Error("FIFT_LIBS_PATH is not set"); + } + const FUNC_FIFT_COMPILER_PATH = process.env.FUNC_FIFT_COMPILER_PATH; + if (typeof FUNC_FIFT_COMPILER_PATH === "undefined") { + throw new Error("FUNC_FIFT_COMPILER_PATH is not set"); + } + + const files: string[] = args.entries; + const configStr = JSON.stringify({ + sources: files.map((f) => + f.replace("@stdlib/", FC_STDLIB_PATH), + ), + optLevel: 2, + fiftPath: FIFT_LIBS_PATH, + }); + + const retJson = execSync( + [FUNC_FIFT_COMPILER_PATH, `'${configStr}'`].join(" "), + ); + + const result = JSON.parse(retJson.toString()) as CompileResult; + + switch (result.status) { + case "error": { + return { + ok: false, + log: "", + fift: null, + output: null, + }; + } + case "ok": { + return { + ok: true, + log: "", + fift: cutFirstLine(result.fiftCode.replaceAll("\\n", "\n")), + output: Buffer.from(result.codeBoc, "base64"), + }; + } + } + + throw Error("Unexpected compiler response"); +} + +export async function funcCompileWasm(args: { + entries: string[]; + sources: { path: string; content: string }[]; + logger: ILogger; }): Promise { // Parameters const files: string[] = args.entries; diff --git a/src/test/fuzzer/src/generators/uniform-expr-gen.ts b/src/test/fuzzer/src/generators/uniform-expr-gen.ts index e1360ea39b..a41961f4a1 100644 --- a/src/test/fuzzer/src/generators/uniform-expr-gen.ts +++ b/src/test/fuzzer/src/generators/uniform-expr-gen.ts @@ -1,13 +1,16 @@ import type * as Ast from "@/ast/ast"; -import type { FactoryAst } from "@/ast/ast-helpers"; +import { getAstFactory, type FactoryAst } from "@/ast/ast-helpers"; import { getMakeAst } from "@/ast/generated/make-factory"; import { getAstUtil } from "@/ast/util"; import { Interpreter } from "@/optimizer/interpreter"; +import { statistics } from "@/test/fuzzer/test/expressions/expression-stats"; import { beginCell } from "@ton/core"; import type { Address, Cell } from "@ton/core"; import { sha256_sync } from "@ton/crypto"; import { TreasuryContract } from "@ton/sandbox"; +import { terminal } from "@tonstudio/parser-runtime"; import * as fc from "fast-check"; +import { literal } from "zod"; export const AllowedType = { Int: "Int", @@ -32,6 +35,14 @@ export type GenContext = { // Contract names to choose from contractNames: string[]; + + // The non-terminals to choose from. Non-terminals not listed here will + // be dissallowed during generation + allowedNonTerminals: NonTerminalEnum[]; + + // The terminals to choose from. Terminals not listed here will + // be dissallowed during generation + allowedTerminals: TerminalEnum[]; }; export const NonTerminal = { @@ -64,7 +75,13 @@ export const NonTerminal = { export type NonTerminalEnum = (typeof NonTerminal)[keyof typeof NonTerminal]; -const Terminal = { +type GenericNonTerminal = { + id: number; + literal: boolean; + terminal: false; +} + +export const Terminal = { integer: { terminal: true, id: 1 }, add: { terminal: true, id: 2 }, minus: { terminal: true, id: 3 }, @@ -122,7 +139,7 @@ const Terminal = { type TerminalEnum = (typeof Terminal)[keyof typeof Terminal]; -type Token = TerminalEnum | NonTerminalEnum; +type Token = TerminalEnum | GenericNonTerminal; type ExprProduction = { tokens: Token[]; @@ -570,7 +587,10 @@ function normalizeArray(counts: number[]): number[] { // Any -Inf represents a count of 0, which means that such index should never get selected. // So, it is enough to transform -Inf back to 0. // Any 0 represents a count of 1. Since such index has a non-zero probability to be selected, - // we change the 0s to 1s. The rest of numbers we take their ceil to transform them into integers. + // we change the 0s to 1s. + // Also, 1 represents a count of 2. So, we transform 1s to 2s, to avoid + // squashing counts 1s and 2s together. + // The rest of numbers we take their ceil to transform them into integers. return counts.map((n) => { if (n === Number.NEGATIVE_INFINITY) { return 0; @@ -578,6 +598,9 @@ function normalizeArray(counts: number[]): number[] { if (n === 0) { return 1; } + if (n === 1) { + return 2; + } return Math.ceil(n); }); } @@ -603,9 +626,87 @@ function transform(n: number): number { return Math.log2(n); } +function filterProductions(nonTerminalsToInclude: NonTerminalEnum[], terminalsToInclude: TerminalEnum[]): { + productions: ExprProduction[][], + nonTerminals: GenericNonTerminal[] +} { + const nonTerminalIdsToInclude: Set = new Set(nonTerminalsToInclude.map(e => e.id)); + const terminalIdsToInclude: Set = new Set(terminalsToInclude.map(e => e.id)); + + // Make a copy of all the productions + let productions: ExprProduction[][] = []; + for (let i = 0; i < allProductions.length; i++) { + productions[i] = allProductions[i]!.map(prod => { + return {id: prod.id, tokens: prod.tokens}; + }); + } + + // Remove productions that use terminals and non-terminals not listed in the provided argument lists. + let initialNonTerminalsCount; + do { + initialNonTerminalsCount = nonTerminalIdsToInclude.size; + + for (let i = 0; i < productions.length; i++) { + productions[i] = productions[i]!.filter(prod => prod.tokens.every(t => { + if (t.terminal) { + return terminalIdsToInclude.has(t.id); + } else { + return nonTerminalIdsToInclude.has(t.id); + } + })); + // If non-terminal i has no productions at the end, we need + // to remove i from the final non-terminals + // and go again through the process of removing productions + if (productions[i]!.length === 0) { + nonTerminalIdsToInclude.delete(i); + } + } + } while (initialNonTerminalsCount !== nonTerminalIdsToInclude.size); + + // Remove unused non-terminals, and reindex them + const reindexMap: Map = new Map(); + const nonTerminalsFiltered = Object.values(NonTerminal).filter(n => nonTerminalIdsToInclude.has(n.id)); + nonTerminalsFiltered.forEach((n, newIndex) => { + reindexMap.set(n.id, newIndex); + }); + const nonTerminals = nonTerminalsFiltered.map((n, newIndex) => { + return {id: newIndex, literal: n.literal, terminal: n.terminal}; + }); + + // Remove productions belonging to removed non-terminals. + productions = productions.filter((_, index) => nonTerminalIdsToInclude.has(index)); + + // Reindex all the productions, including non-terminal tokens occurring inside the production + for (let i = 0; i < productions.length; i++) { + productions[i] = productions[i]!.map((prod, newIndex) => { + return {id: newIndex, tokens: prod.tokens.map(t => { + if (t.terminal) { + return t; + } else { + const newIndex = reindexMap.get(t.id); + if (typeof newIndex === "undefined") { + throw new Error(`Invalid old index ${t.id}: it does not have a reindexing`); + } + return {id: newIndex, + literal: t.literal, + terminal: t.terminal + } + } + })}; + }); + } + + return { + productions, + nonTerminals + }; +} + function computeCountTables( minSize: number, maxSize: number, + finalProductions: ExprProduction[][], + nonTerminals: GenericNonTerminal[] ): { nonTerminalCounts: number[][][]; sizeSplitCounts: number[][][][][]; @@ -655,7 +756,7 @@ function computeCountTables( size: number, counts: number[], ) { - const prods = getProductions(nonTerminalIndex); + const prods = getProductions(finalProductions, nonTerminalIndex); const prod = getProductionAt(prods, prodIndex); if (typeof sizeSplitCounts[nonTerminalIndex] === "undefined") { @@ -715,7 +816,7 @@ function computeCountTables( if (typeof peekedCounts !== "undefined") { return peekedCounts; } - const prods = getProductions(id); + const prods = getProductions(finalProductions, id); return prods.map((prod) => sum(countFromProduction(id, prod, 0, size))); } @@ -783,14 +884,14 @@ function computeCountTables( } } - function doCountsForNonTerminals(nonTerminals: NonTerminalEnum[]) { + function doCountsForNonTerminals(nonTerminals: GenericNonTerminal[]) { // First, compute the counts of all the non-terminals that produce literals // The first step is to initialize the tables for size 0 for (const nonTerminal of nonTerminals) { const nonTerminalIdx = nonTerminal.id; - const productions = getProductions(nonTerminalIdx); + const productions = getProductions(finalProductions, nonTerminalIdx); // Transform count 0 to whatever representation of counts we are currently using updateNonTerminalCounts( @@ -821,7 +922,7 @@ function computeCountTables( for (const nonTerminal of nonTerminals) { const nonTerminalIdx = nonTerminal.id; - const productions = getProductions(nonTerminalIdx); + const productions = getProductions(finalProductions, nonTerminalIdx); for (const prod of productions) { for ( @@ -857,13 +958,13 @@ function computeCountTables( // From 0 to minSize-1, set counts to 0, since we are not going to choose those sizes // Transform the count 0 to whatever representation we are currently using for (let size = 0; size < minSize; size++) { - for (const nonTerminal of Object.values(NonTerminal)) { + for (const nonTerminal of nonTerminals) { updateTotalCounts(nonTerminal.id, size, transform(0)); } } for (let size = minSize; size <= maxSize; size++) { - for (const nonTerminal of Object.values(NonTerminal)) { + for (const nonTerminal of nonTerminals) { updateTotalCounts( nonTerminal.id, size, @@ -881,7 +982,7 @@ function computeCountTables( function normalizeCounts() { // The total counts - for (const nonTerminal of Object.values(NonTerminal)) { + for (const nonTerminal of nonTerminals) { const counts = totalCounts[nonTerminal.id]; if (typeof counts === "undefined") { throw new Error(`Index ${nonTerminal.id} out of bounds`); @@ -891,7 +992,7 @@ function computeCountTables( } // The non-terminal counts - for (const nonTerminal of Object.values(NonTerminal)) { + for (const nonTerminal of nonTerminals) { for (let size = 0; size <= maxSize; size++) { const counts = lookupNonTerminalCounts( nonTerminalCounts, @@ -904,10 +1005,10 @@ function computeCountTables( } // Split size counts - for (const nonTerminal of Object.values(NonTerminal)) { + for (const nonTerminal of nonTerminals) { const nonTerminalIdx = nonTerminal.id; - const productions = getProductions(nonTerminalIdx); + const productions = getProductions(finalProductions, nonTerminalIdx); for (const prod of productions) { for ( @@ -939,19 +1040,16 @@ function computeCountTables( // First, fill the non-terminals that compute literals doCountsForNonTerminals( - Object.values(NonTerminal).filter((nonTerminal) => nonTerminal.literal), + nonTerminals.filter((nonTerminal) => nonTerminal.literal), ); - // Now the rest of non-terminals, but not the initial non-terminal + // Now the rest of non-terminals doCountsForNonTerminals( - Object.values(NonTerminal).filter( - (nonTerminal) => !nonTerminal.literal && nonTerminal.id !== 0, + nonTerminals.filter( + (nonTerminal) => !nonTerminal.literal, ), ); - // Finally, the initial non-terminal - doCountsForNonTerminals([NonTerminal.Initial]); - doTotalCounts(); // Now that the tables are filled, we need to normalize the counts @@ -1020,8 +1118,8 @@ function lookupTotalCounts( return nTCounts; } -function getProductions(idx: number): ExprProduction[] { - const prods = allProductions[idx]; +function getProductions(productions: ExprProduction[][], idx: number): ExprProduction[] { + const prods = productions[idx]; if (typeof prods === "undefined") { throw new Error(`${idx} is not a valid id for a non-terminal`); } @@ -1036,7 +1134,7 @@ function getTokenAt(tokens: Token[], id: number): Token { return token; } -function getNonTerminalAt(tokens: Token[], id: number): NonTerminalEnum { +function getNonTerminalAt(tokens: Token[], id: number): GenericNonTerminal { const token = getTokenAt(tokens, id); if (token.terminal) { throw new Error(`Was expecting a non-terminal`); @@ -1054,10 +1152,11 @@ function getProductionAt(prods: ExprProduction[], id: number): ExprProduction { function makeExpression( astF: FactoryAst, - type: NonTerminalEnum, + nonTerminalId: number, ctx: GenContext, nonTerminalCounts: number[][][], sizeSplitCounts: number[][][][][], + finalProductions: ExprProduction[][], size: number, ): fc.Arbitrary { const makeF = getMakeAst(astF); @@ -1067,7 +1166,7 @@ function makeExpression( id: number, size: number, ): fc.Arbitrary { - const prods = getProductions(id); + const prods = getProductions(finalProductions, id); const nonTerminalOptions = lookupNonTerminalCounts( nonTerminalCounts, id, @@ -1528,7 +1627,7 @@ function makeExpression( } } - return genFromNonTerminal(type.id, size); + return genFromNonTerminal(nonTerminalId, size); } export function initializeGenerator( @@ -1536,12 +1635,21 @@ export function initializeGenerator( maxSize: number, ctx: GenContext, astF: FactoryAst, -): (type: NonTerminalEnum) => fc.Arbitrary { +): (nonTerminalId: number) => fc.Arbitrary { + + const { productions, nonTerminals } = filterProductions(ctx.allowedNonTerminals, ctx.allowedTerminals); + const { nonTerminalCounts, sizeSplitCounts, totalCounts } = - computeCountTables(minSize, maxSize); + computeCountTables(minSize, maxSize, productions, nonTerminals); - return (type: NonTerminalEnum) => { - const sizes = lookupTotalCounts(totalCounts, type.id); + return (nonTerminalId: number) => { + if (nonTerminals.every(n => n.id !== nonTerminalId)) { + throw new Error(`Non-terminal ${nonTerminalId} is not among the allowed non-terminals`); + } + const sizes = lookupTotalCounts(totalCounts, nonTerminalId); + if (sizes.every(s => s === 0)) { + throw new Error(`There are no trees for non-terminal ${nonTerminalId}`); + } const weightedSizes: fc.WeightedArbitrary[] = sizes.map( (w, i) => { return { arbitrary: fc.constant(i), weight: w }; @@ -1551,10 +1659,11 @@ export function initializeGenerator( return fc.oneof(...weightedSizes).chain((size) => { return makeExpression( astF, - type, + nonTerminalId, ctx, nonTerminalCounts, sizeSplitCounts, + productions, size, ); }); @@ -1593,3 +1702,32 @@ function _generateIntBitLength( return fc.bigInt(0n, maxUnsigned); } } + +// Create a GenContext with allowed identifiers and contracts +const ids: Map = new Map(); +ids.set(AllowedType.Int, ["intV1", "intV2", "intV3"]); +ids.set(AllowedType.OptInt, ["o_intV1", "o_intV2", "o_intV3"]); +ids.set(AllowedType.Bool, ["boolV1", "boolV2", "boolV3"]); +ids.set(AllowedType.OptBool, ["o_boolV1", "o_boolV2", "o_boolV3"]); +ids.set(AllowedType.Cell, ["cellV1", "cellV2", "cellV3"]); +ids.set(AllowedType.OptCell, ["o_cellV1", "o_cellV2", "o_cellV3"]); +ids.set(AllowedType.Slice, ["sliceV1", "sliceV2", "sliceV3"]); +ids.set(AllowedType.OptSlice, ["o_sliceV1", "o_sliceV2", "o_sliceV3"]); +ids.set(AllowedType.Address, ["addressV1", "addressV2", "addressV3"]); +ids.set(AllowedType.OptAddress, ["o_addressV1", "o_addressV2", "o_addressV3"]); +ids.set(AllowedType.String, ["stringV1", "stringV2", "stringV3"]); +ids.set(AllowedType.OptString, ["o_stringV1", "o_stringV2", "o_stringV3"]); + +const ctx: GenContext = { + identifiers: ids, + contractNames: ["C1", "C2"], + allowedNonTerminals: Object.values(NonTerminal), + allowedTerminals: Object.values(Terminal), +}; + +const initialized = initializeGenerator(4, 10, ctx, getAstFactory()); + +statistics(initialized(NonTerminal.Int.id), 10000, "stats.txt"); + +//console.log(2n ** 255n - 57896044618658097711785492504343953926634992332820282019728792003956564819968n); + diff --git a/src/test/fuzzer/src/minimal-fc-stdlib/funcplusfift b/src/test/fuzzer/src/minimal-fc-stdlib/funcplusfift new file mode 100755 index 0000000000000000000000000000000000000000..77e0449436ea9de7066f0892228b15ed00cecc22 GIT binary patch literal 5051536 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

Qj@LO}=Xjmtb&l`mz9L@dc%9>QjvuCTy!(oO`aQ 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 z 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

Yf{~CV90`q~&G6rf&($b0{I>;; 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­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

K8G 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�hU@VE+rW*hk%c2Ng$GS`zk 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

cPV-GkHZMxMb7qqmuM?EVA` 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

sU{4)-kWfM^^r3cSi|@7P-taL(WbT0dc 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%0DE#x_+yBHr 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૓u<`4moc95=0F6 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

<1wZ1L$$|D| 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

pgl`-HiA z{~N}?|L^qvBlwTvKdSkUXZiOZt=o(L`)5ApKiB6!8~=$B>FHYV{e*pis=0B9>``=gz>p#NzKau0}zlDG2tn~ha__y#M(EKOH zWq16?UnqY4hmX-7Ft;opaUQ}>_c{5vlezy1@qGXIMt=IZ<( zz`yxxdjB!}8~FEW{=->*|Ic}>c>m#JH2)_4jc)1v@4$bep3H-x`Onq*caD+�BEZ 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

c`uUs?q>bowulZ=;XN*mCo)6mXO3;lEPA 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�TS(^ zhfIlubeAff9V*y<5#W7!`TmPojG6?SPmG$~6_86@*(3Tih!erLMFW33zuE0;%rM5J zca8hdY)7ome2b)?!Bg;2a?MNuLvLDwT8xBcL~|2C3-XMl*b^7^#G1NP+fS&K$clzI_SPW&vDOueBLQ(7dE(@rm|dp;G^o)b^xchV2vy5J_)B-NDDU zX18ML)561D-(f_NDKH@}7fk8hBFIdPB$_YDm1HcH9qcI@6Qino^(C-+0i&`jf$Dk4h&8j0SC3x`McX0t!NmyRP71ElO4csY57sg>};AzQxpI9HKmkK zz=|bkgJEaKqZ_$fZZRTdt0__K= z)VvzVdl+_){3bCa^pzdgRLT*bm>{fXPyV|Z(@sXP#_`s;c*!aEfla*LqZxW%NlxJg zYoD>}U!!9HS5-zTg}=jkpu>+nVkoph@s*+-k~|uu6CdM0$z1cA{NXgl1svG8ocQ3=dwrPaUJQ~~M-Q8pWnMq2}pGwju2+FVj` z{d)&I5}4a$AQ*`E%sgD#7=ytxb$dxLchr7OM{P|~&Wu=jG%4L-$hVBqbty`ck?7K6 z{c5Jxm$F?*9)9{9^3K ziYgYJb*c)4t}D;8WmCw~5v~N^b8LT{)Upgn6~h()>U+l``a^~70B0WaYEiE^Jz@#a zgquTI=WYPvVQ`gpzK*V*r%$4qUgv|}16aWHDp|IJJ1#vDZiS;W07NR19UkM3>twy8 zM9crAcQmV7B&uA^$p*I$`LP8VL;BX#o#cXjlNFRbNO3K|L4lr$r(HPF0hiD3KSmPQ z#^pP^e29>&i|%?7-OUh9OVz-}c9u?A0sSg{b8RlW8HreqM(!l&6~=-MKd*0@7&6J< ze}Cy=wVUx32eMGvqVSqZQ+YB}YG`jiv63wr|9O}OnjSU&HvIasIGqaI! zqxRCR+~G_(J~(-i9HXfVp{#<pfC7 z`dH49u#QfNBDk8#GXZ79Vv^*Bw{HDh671s_4uD*pM`7tn-cUgkdT%&N11TEL;@#qY zKey4F1_@mfsgE}Ifj-!Tp#4`fX$jnIm~!6F_nH@L9jP!)iX`L}WC9g0&SnMpQ!9QnK& zpED2<&fk@DOJ*b4VGzARt3AiIXyA8~L$1&Ql`9@T7FkVt3Sa~UOSw|qo_~5T0Frx2f%

_9PS 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

  • 9X}pRM&A+PJcV;p32Qm<E-qFk_}}Z-!TNC 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 KxFGxI*8c;$D*^-n literal 0 HcmV?d00001 diff --git a/src/test/fuzzer/src/minimal-fc-stdlib/stdlib_ex.fc b/src/test/fuzzer/src/minimal-fc-stdlib/stdlib_ex.fc new file mode 100644 index 0000000000..8b13789179 --- /dev/null +++ b/src/test/fuzzer/src/minimal-fc-stdlib/stdlib_ex.fc @@ -0,0 +1 @@ + diff --git a/src/test/fuzzer/src/util.ts b/src/test/fuzzer/src/util.ts index 1ccfe46606..dae1e66a8d 100644 --- a/src/test/fuzzer/src/util.ts +++ b/src/test/fuzzer/src/util.ts @@ -122,7 +122,6 @@ function makeAsyncParams( let errorSuffix = ""; if (out.counterexample !== null) { errorSuffix = counterexamplePrinter(out.counterexample); - out.error; } throw new Error( (await fc.asyncDefaultReportMessage(out)) + errorSuffix, @@ -372,13 +371,13 @@ export function filterStdlib( } const customTactStdlib = mF.makeModule([], result); - const stdlib_fc = fs - .readFileSync(path.join(__dirname, "minimal-fc-stdlib", "stdlib.fc")) - .toString("base64"); + //const stdlib_fc = fs + // .readFileSync(path.join(__dirname, "minimal-fc-stdlib", "stdlib.fc")) + // .toString("base64"); return { modules: [customTactStdlib], - stdlib_fc: stdlib_fc, + stdlib_fc: "", stdlib_ex_fc: "", }; } @@ -410,8 +409,8 @@ export async function buildModule( // Needed by precompile, but we set its contents to be empty ["std/stdlib.tact"]: "", // These two func files are needed during tvm compilation - ["std/stdlib_ex.fc"]: customStdlib.stdlib_ex_fc, - ["std/stdlib.fc"]: customStdlib.stdlib_fc, + ["stdlib_ex.fc"]: customStdlib.stdlib_ex_fc, + ["stdlib.fc"]: customStdlib.stdlib_fc, }; const project = createVirtualFileSystem("/", fileSystem, false); @@ -467,28 +466,30 @@ export async function buildModule( const codeEntrypoint = res.output.entrypoint; // Compiling contract to TVM - const stdlibPath = stdlib.resolve("std/stdlib.fc"); - const stdlibCode = stdlib.readFile(stdlibPath).toString(); - const stdlibExPath = stdlib.resolve("std/stdlib_ex.fc"); - const stdlibExCode = stdlib.readFile(stdlibExPath).toString(); + const stdlibPath = stdlib.resolve("stdlib.fc"); + //const stdlibCode = stdlib.readFile(stdlibPath).toString(); + const stdlibExPath = stdlib.resolve("stdlib_ex.fc"); + //const stdlibExCode = stdlib.readFile(stdlibExPath).toString(); + + process.env.USE_NATIVE = "true"; + process.env.FC_STDLIB_PATH = path.join(__dirname, "/minimal-fc-stdlib/"); + process.env.FUNC_FIFT_COMPILER_PATH = path.join(__dirname, "/minimal-fc-stdlib/funcplusfift"); + process.env.FIFT_LIBS_PATH = ""; + + const contractFilePath = path.join(__dirname, "/minimal-fc-stdlib/", codeEntrypoint); + + fs.writeFileSync( + contractFilePath, + codeFc[0]!.content, + ); const c = await funcCompile({ entries: [ stdlibPath, stdlibExPath, - posixNormalize(project.resolve(config.output, codeEntrypoint)), - ], - sources: [ - { - path: stdlibPath, - content: stdlibCode, - }, - { - path: stdlibExPath, - content: stdlibExCode, - }, - ...codeFc, + contractFilePath, ], + sources: [], logger: new Logger(), }); diff --git a/src/test/fuzzer/test/expressions/expression.spec.ts b/src/test/fuzzer/test/expressions/expression.spec.ts index a49e5ae41a..2753a81533 100644 --- a/src/test/fuzzer/test/expressions/expression.spec.ts +++ b/src/test/fuzzer/test/expressions/expression.spec.ts @@ -25,6 +25,7 @@ import { GenContext, initializeGenerator, NonTerminal, + Terminal } from "../../src/generators/uniform-expr-gen"; import { bindingsAndExpressionPrtinter, @@ -119,6 +120,8 @@ describe("evaluation properties", () => { contractNames: [ expressionTestingEnvironment.contractNameToCompile, ], + allowedNonTerminals: Object.values(NonTerminal), + allowedTerminals: Object.values(Terminal), }; const generator = initializeGenerator( 1, @@ -133,7 +136,7 @@ describe("evaluation properties", () => { expressionGenerationIds, generator, ), - generator(NonTerminal.Int), + generator(NonTerminal.Int.id), async (bindings, expr) => { const compilationResult = await compileExpression( expressionTestingEnvironment, diff --git a/src/test/fuzzer/test/expressions/utils.ts b/src/test/fuzzer/test/expressions/utils.ts index e797e87cfc..d84db4aefd 100644 --- a/src/test/fuzzer/test/expressions/utils.ts +++ b/src/test/fuzzer/test/expressions/utils.ts @@ -216,7 +216,7 @@ export async function compileExpression( export function generateBindings( expressionTestingEnvironment: ExpressionTestingEnvironment, expressionGenerationIds: Map, - generator: (type: NonTerminalEnum) => fc.Arbitrary, + generator: (nonTerminalId: number) => fc.Arbitrary, ): fc.Arbitrary { return fc.tuple( ...expressionGenerationIds @@ -237,7 +237,7 @@ export function generateBindings( expressionTestingEnvironment.makeF.makeDummyNull(), ), ) - : generator(initializersMapping[type]).map((expr) => + : generator(initializersMapping[type].id).map((expr) => expressionTestingEnvironment.makeF.makeDummyStatementLet( expressionTestingEnvironment.makeF.makeDummyId( name, From 87f1ee30e9c06ab923b84d81d971857d3da2bcd7 Mon Sep 17 00:00:00 2001 From: jeshecdom Date: Wed, 16 Apr 2025 03:37:57 +0200 Subject: [PATCH 40/44] tests: Finished configurable terminals and non-terminals. Also, finished native compilation. --- src/func/funcCompile.ts | 7 +- .../fuzzer/src/generators/uniform-expr-gen.ts | 179 +- .../src/minimal-fc-stdlib/fift-lib/Asm.fif | 1661 +++++++++++++++++ .../src/minimal-fc-stdlib/fift-lib/Color.fif | 21 + .../src/minimal-fc-stdlib/fift-lib/Disasm.fif | 141 ++ .../src/minimal-fc-stdlib/fift-lib/Fift.fif | 142 ++ .../minimal-fc-stdlib/fift-lib/FiftExt.fif | 118 ++ .../src/minimal-fc-stdlib/fift-lib/GetOpt.fif | 131 ++ .../src/minimal-fc-stdlib/fift-lib/Lisp.fif | 436 +++++ .../src/minimal-fc-stdlib/fift-lib/Lists.fif | 220 +++ .../src/minimal-fc-stdlib/fift-lib/Stack.fif | 266 +++ .../minimal-fc-stdlib/fift-lib/TonUtil.fif | 381 ++++ .../fuzzer/src/minimal-fc-stdlib/stdlib.fc | 6 +- src/test/fuzzer/src/stdlib.ts | 2 +- src/test/fuzzer/src/util.ts | 79 +- .../test/expressions/expression.spec.ts | 2 +- src/test/fuzzer/test/expressions/utils.ts | 27 +- 17 files changed, 3681 insertions(+), 138 deletions(-) create mode 100644 src/test/fuzzer/src/minimal-fc-stdlib/fift-lib/Asm.fif create mode 100644 src/test/fuzzer/src/minimal-fc-stdlib/fift-lib/Color.fif create mode 100644 src/test/fuzzer/src/minimal-fc-stdlib/fift-lib/Disasm.fif create mode 100644 src/test/fuzzer/src/minimal-fc-stdlib/fift-lib/Fift.fif create mode 100644 src/test/fuzzer/src/minimal-fc-stdlib/fift-lib/FiftExt.fif create mode 100644 src/test/fuzzer/src/minimal-fc-stdlib/fift-lib/GetOpt.fif create mode 100644 src/test/fuzzer/src/minimal-fc-stdlib/fift-lib/Lisp.fif create mode 100644 src/test/fuzzer/src/minimal-fc-stdlib/fift-lib/Lists.fif create mode 100644 src/test/fuzzer/src/minimal-fc-stdlib/fift-lib/Stack.fif create mode 100644 src/test/fuzzer/src/minimal-fc-stdlib/fift-lib/TonUtil.fif diff --git a/src/func/funcCompile.ts b/src/func/funcCompile.ts index 8d388bc506..bd357e25d5 100644 --- a/src/func/funcCompile.ts +++ b/src/func/funcCompile.ts @@ -1,6 +1,5 @@ import type { ILogger } from "@/context/logger"; import { execSync } from "child_process"; -import path from "path"; // Wasm Imports // eslint-disable-next-line @typescript-eslint/no-require-imports @@ -58,8 +57,6 @@ type CompileResult = warnings: string; }; - - export async function funcCompile(args: { entries: string[]; sources: { path: string; content: string }[]; @@ -92,9 +89,7 @@ export function funcCompileNative(args: { const files: string[] = args.entries; const configStr = JSON.stringify({ - sources: files.map((f) => - f.replace("@stdlib/", FC_STDLIB_PATH), - ), + sources: files.map((f) => f.replace("@stdlib/", FC_STDLIB_PATH)), optLevel: 2, fiftPath: FIFT_LIBS_PATH, }); diff --git a/src/test/fuzzer/src/generators/uniform-expr-gen.ts b/src/test/fuzzer/src/generators/uniform-expr-gen.ts index a41961f4a1..29bdb17449 100644 --- a/src/test/fuzzer/src/generators/uniform-expr-gen.ts +++ b/src/test/fuzzer/src/generators/uniform-expr-gen.ts @@ -1,16 +1,13 @@ import type * as Ast from "@/ast/ast"; -import { getAstFactory, type FactoryAst } from "@/ast/ast-helpers"; +import type { FactoryAst } from "@/ast/ast-helpers"; import { getMakeAst } from "@/ast/generated/make-factory"; import { getAstUtil } from "@/ast/util"; import { Interpreter } from "@/optimizer/interpreter"; -import { statistics } from "@/test/fuzzer/test/expressions/expression-stats"; import { beginCell } from "@ton/core"; import type { Address, Cell } from "@ton/core"; import { sha256_sync } from "@ton/crypto"; import { TreasuryContract } from "@ton/sandbox"; -import { terminal } from "@tonstudio/parser-runtime"; import * as fc from "fast-check"; -import { literal } from "zod"; export const AllowedType = { Int: "Int", @@ -37,11 +34,11 @@ export type GenContext = { contractNames: string[]; // The non-terminals to choose from. Non-terminals not listed here will - // be dissallowed during generation + // be disallowed during generation allowedNonTerminals: NonTerminalEnum[]; // The terminals to choose from. Terminals not listed here will - // be dissallowed during generation + // be disallowed during generation allowedTerminals: TerminalEnum[]; }; @@ -79,7 +76,7 @@ type GenericNonTerminal = { id: number; literal: boolean; terminal: false; -} +}; export const Terminal = { integer: { terminal: true, id: 1 }, @@ -587,8 +584,8 @@ function normalizeArray(counts: number[]): number[] { // Any -Inf represents a count of 0, which means that such index should never get selected. // So, it is enough to transform -Inf back to 0. // Any 0 represents a count of 1. Since such index has a non-zero probability to be selected, - // we change the 0s to 1s. - // Also, 1 represents a count of 2. So, we transform 1s to 2s, to avoid + // we change the 0s to 1s. + // Also, 1 represents a count of 2. So, we transform 1s to 2s, to avoid // squashing counts 1s and 2s together. // The rest of numbers we take their ceil to transform them into integers. return counts.map((n) => { @@ -626,18 +623,25 @@ function transform(n: number): number { return Math.log2(n); } -function filterProductions(nonTerminalsToInclude: NonTerminalEnum[], terminalsToInclude: TerminalEnum[]): { - productions: ExprProduction[][], - nonTerminals: GenericNonTerminal[] +function filterProductions( + nonTerminalsToInclude: NonTerminalEnum[], + terminalsToInclude: TerminalEnum[], +): { + productions: ExprProduction[][]; + nonTerminals: GenericNonTerminal[]; } { - const nonTerminalIdsToInclude: Set = new Set(nonTerminalsToInclude.map(e => e.id)); - const terminalIdsToInclude: Set = new Set(terminalsToInclude.map(e => e.id)); + const nonTerminalIdsToInclude: Set = new Set( + nonTerminalsToInclude.map((e) => e.id), + ); + const terminalIdsToInclude: Set = new Set( + terminalsToInclude.map((e) => e.id), + ); // Make a copy of all the productions let productions: ExprProduction[][] = []; for (let i = 0; i < allProductions.length; i++) { - productions[i] = allProductions[i]!.map(prod => { - return {id: prod.id, tokens: prod.tokens}; + productions[i] = allProductions[i]!.map((prod) => { + return { id: prod.id, tokens: prod.tokens }; }); } @@ -647,14 +651,16 @@ function filterProductions(nonTerminalsToInclude: NonTerminalEnum[], terminalsTo initialNonTerminalsCount = nonTerminalIdsToInclude.size; for (let i = 0; i < productions.length; i++) { - productions[i] = productions[i]!.filter(prod => prod.tokens.every(t => { - if (t.terminal) { - return terminalIdsToInclude.has(t.id); - } else { - return nonTerminalIdsToInclude.has(t.id); - } - })); - // If non-terminal i has no productions at the end, we need + productions[i] = productions[i]!.filter((prod) => + prod.tokens.every((t) => { + if (t.terminal) { + return terminalIdsToInclude.has(t.id); + } else { + return nonTerminalIdsToInclude.has(t.id); + } + }), + ); + // If non-terminal i has no productions at the end, we need // to remove i from the final non-terminals // and go again through the process of removing productions if (productions[i]!.length === 0) { @@ -662,43 +668,53 @@ function filterProductions(nonTerminalsToInclude: NonTerminalEnum[], terminalsTo } } } while (initialNonTerminalsCount !== nonTerminalIdsToInclude.size); - + // Remove unused non-terminals, and reindex them - const reindexMap: Map = new Map(); - const nonTerminalsFiltered = Object.values(NonTerminal).filter(n => nonTerminalIdsToInclude.has(n.id)); - nonTerminalsFiltered.forEach((n, newIndex) => { + const reindexMap: Map = new Map(); + const nonTerminalsFiltered = Object.values(NonTerminal).filter((n) => + nonTerminalIdsToInclude.has(n.id), + ); + nonTerminalsFiltered.forEach((n, newIndex) => { reindexMap.set(n.id, newIndex); }); const nonTerminals = nonTerminalsFiltered.map((n, newIndex) => { - return {id: newIndex, literal: n.literal, terminal: n.terminal}; + return { id: newIndex, literal: n.literal, terminal: n.terminal }; }); - + // Remove productions belonging to removed non-terminals. - productions = productions.filter((_, index) => nonTerminalIdsToInclude.has(index)); + productions = productions.filter((_, index) => + nonTerminalIdsToInclude.has(index), + ); // Reindex all the productions, including non-terminal tokens occurring inside the production for (let i = 0; i < productions.length; i++) { productions[i] = productions[i]!.map((prod, newIndex) => { - return {id: newIndex, tokens: prod.tokens.map(t => { - if (t.terminal) { - return t; - } else { - const newIndex = reindexMap.get(t.id); - if (typeof newIndex === "undefined") { - throw new Error(`Invalid old index ${t.id}: it does not have a reindexing`); - } - return {id: newIndex, - literal: t.literal, - terminal: t.terminal + return { + id: newIndex, + tokens: prod.tokens.map((t) => { + if (t.terminal) { + return t; + } else { + const newIndex = reindexMap.get(t.id); + if (typeof newIndex === "undefined") { + throw new Error( + `Invalid old index ${t.id}: it does not have a re-indexing`, + ); + } + return { + id: newIndex, + literal: t.literal, + terminal: t.terminal, + }; } - } - })}; + }), + }; }); } return { productions, - nonTerminals + nonTerminals, }; } @@ -706,7 +722,7 @@ function computeCountTables( minSize: number, maxSize: number, finalProductions: ExprProduction[][], - nonTerminals: GenericNonTerminal[] + nonTerminals: GenericNonTerminal[], ): { nonTerminalCounts: number[][][]; sizeSplitCounts: number[][][][][]; @@ -891,7 +907,10 @@ function computeCountTables( for (const nonTerminal of nonTerminals) { const nonTerminalIdx = nonTerminal.id; - const productions = getProductions(finalProductions, nonTerminalIdx); + const productions = getProductions( + finalProductions, + nonTerminalIdx, + ); // Transform count 0 to whatever representation of counts we are currently using updateNonTerminalCounts( @@ -922,7 +941,10 @@ function computeCountTables( for (const nonTerminal of nonTerminals) { const nonTerminalIdx = nonTerminal.id; - const productions = getProductions(finalProductions, nonTerminalIdx); + const productions = getProductions( + finalProductions, + nonTerminalIdx, + ); for (const prod of productions) { for ( @@ -1008,7 +1030,10 @@ function computeCountTables( for (const nonTerminal of nonTerminals) { const nonTerminalIdx = nonTerminal.id; - const productions = getProductions(finalProductions, nonTerminalIdx); + const productions = getProductions( + finalProductions, + nonTerminalIdx, + ); for (const prod of productions) { for ( @@ -1045,9 +1070,7 @@ function computeCountTables( // Now the rest of non-terminals doCountsForNonTerminals( - nonTerminals.filter( - (nonTerminal) => !nonTerminal.literal, - ), + nonTerminals.filter((nonTerminal) => !nonTerminal.literal), ); doTotalCounts(); @@ -1118,7 +1141,10 @@ function lookupTotalCounts( return nTCounts; } -function getProductions(productions: ExprProduction[][], idx: number): ExprProduction[] { +function getProductions( + productions: ExprProduction[][], + idx: number, +): ExprProduction[] { const prods = productions[idx]; if (typeof prods === "undefined") { throw new Error(`${idx} is not a valid id for a non-terminal`); @@ -1636,19 +1662,25 @@ export function initializeGenerator( ctx: GenContext, astF: FactoryAst, ): (nonTerminalId: number) => fc.Arbitrary { - - const { productions, nonTerminals } = filterProductions(ctx.allowedNonTerminals, ctx.allowedTerminals); + const { productions, nonTerminals } = filterProductions( + ctx.allowedNonTerminals, + ctx.allowedTerminals, + ); const { nonTerminalCounts, sizeSplitCounts, totalCounts } = computeCountTables(minSize, maxSize, productions, nonTerminals); return (nonTerminalId: number) => { - if (nonTerminals.every(n => n.id !== nonTerminalId)) { - throw new Error(`Non-terminal ${nonTerminalId} is not among the allowed non-terminals`); + if (nonTerminals.every((n) => n.id !== nonTerminalId)) { + throw new Error( + `Non-terminal ${nonTerminalId} is not among the allowed non-terminals`, + ); } const sizes = lookupTotalCounts(totalCounts, nonTerminalId); - if (sizes.every(s => s === 0)) { - throw new Error(`There are no trees for non-terminal ${nonTerminalId}`); + if (sizes.every((s) => s === 0)) { + throw new Error( + `There are no trees for non-terminal ${nonTerminalId}`, + ); } const weightedSizes: fc.WeightedArbitrary[] = sizes.map( (w, i) => { @@ -1702,32 +1734,3 @@ function _generateIntBitLength( return fc.bigInt(0n, maxUnsigned); } } - -// Create a GenContext with allowed identifiers and contracts -const ids: Map = new Map(); -ids.set(AllowedType.Int, ["intV1", "intV2", "intV3"]); -ids.set(AllowedType.OptInt, ["o_intV1", "o_intV2", "o_intV3"]); -ids.set(AllowedType.Bool, ["boolV1", "boolV2", "boolV3"]); -ids.set(AllowedType.OptBool, ["o_boolV1", "o_boolV2", "o_boolV3"]); -ids.set(AllowedType.Cell, ["cellV1", "cellV2", "cellV3"]); -ids.set(AllowedType.OptCell, ["o_cellV1", "o_cellV2", "o_cellV3"]); -ids.set(AllowedType.Slice, ["sliceV1", "sliceV2", "sliceV3"]); -ids.set(AllowedType.OptSlice, ["o_sliceV1", "o_sliceV2", "o_sliceV3"]); -ids.set(AllowedType.Address, ["addressV1", "addressV2", "addressV3"]); -ids.set(AllowedType.OptAddress, ["o_addressV1", "o_addressV2", "o_addressV3"]); -ids.set(AllowedType.String, ["stringV1", "stringV2", "stringV3"]); -ids.set(AllowedType.OptString, ["o_stringV1", "o_stringV2", "o_stringV3"]); - -const ctx: GenContext = { - identifiers: ids, - contractNames: ["C1", "C2"], - allowedNonTerminals: Object.values(NonTerminal), - allowedTerminals: Object.values(Terminal), -}; - -const initialized = initializeGenerator(4, 10, ctx, getAstFactory()); - -statistics(initialized(NonTerminal.Int.id), 10000, "stats.txt"); - -//console.log(2n ** 255n - 57896044618658097711785492504343953926634992332820282019728792003956564819968n); - diff --git a/src/test/fuzzer/src/minimal-fc-stdlib/fift-lib/Asm.fif b/src/test/fuzzer/src/minimal-fc-stdlib/fift-lib/Asm.fif new file mode 100644 index 0000000000..976093f809 --- /dev/null +++ b/src/test/fuzzer/src/minimal-fc-stdlib/fift-lib/Asm.fif @@ -0,0 +1,1661 @@ +library TVM_Asm +// simple TVM Assembler +namespace Asm +Asm definitions +"0.4.5" constant asm-fif-version + +variable @atend +variable @was-split +false @was-split ! +{ "not in asm context" abort } @atend ! +{ `normal eq? not abort"must be terminated by }>" } : @normal? +{ context@ @atend @ 2 { @atend ! context! @normal? } does @atend ! } : @pushatend +{ @pushatend Asm +{ }> b> } : }>c +{ }>c s +{ @atend @ 2 { true @was-split ! @atend ! rot b> ref, swap @endblk } does @atend ! = -rot <= and } : 2x<= +{ 2 pick brembitrefs 1- 2x<= } : @havebitrefs +{ @havebits ' @| ifnot } : @ensurebits +{ @havebitrefs ' @| ifnot } : @ensurebitrefs +{ rot over @ensurebits -rot u, } : @simpleuop +{ tuck sbitrefs @ensurebitrefs swap s, } : @addop +{ tuck bbitrefs @ensurebitrefs swap b+ } : @addopb +' @addopb : @inline +{ 1 ' @addop does create } : @Defop +{ 1 { } : si() +// x mi ma -- ? +{ rot tuck >= -rot <= and } : @range +{ rot tuck < -rot > or } : @-range +{ @-range abort"Out of range" } : @rangechk +{ dup 0 < over 255 > or abort"Invalid stack register number" si() } : s() +{ si() constant } : @Sreg +-2 @Sreg s(-2) +-1 @Sreg s(-1) +0 @Sreg s0 +1 @Sreg s1 +2 @Sreg s2 +3 @Sreg s3 +4 @Sreg s4 +5 @Sreg s5 +6 @Sreg s6 +7 @Sreg s7 +8 @Sreg s8 +9 @Sreg s9 +10 @Sreg s10 +11 @Sreg s11 +12 @Sreg s12 +13 @Sreg s13 +14 @Sreg s14 +15 @Sreg s15 +{ dup 0 < over 7 > or abort"Invalid control register number" } : c() +{ c() constant } : @Creg +0 @Creg c0 +1 @Creg c1 +2 @Creg c2 +3 @Creg c3 +4 @Creg c4 +5 @Creg c5 +7 @Creg c7 +{ abort"not a stack register" 12 i@+ s> } : @bigsridx +{ @bigsridx dup 16 >= over 0< or abort"stack register s0..s15 expected" } : @sridx +{ rot @bigsridx tuck < -rot tuck > rot or abort"stack register out of range" } : @sridxrange +{ swap @bigsridx + dup 16 >= over 0< or abort"stack register out of range" } : @sridx+ +{ swap 0xcc <> over 7 > or over 6 = or abort"not a control register c0..c5 or c7" } : @cridx +{ = + { tuck 16 >= + { = and + { 15 and abort"integer too large" 8 + 2dup fits } until + > 2- 5 u, -rot i, + } cond + } cond + } cond + @addopb } dup : PUSHINT : INT +{ dup 256 = abort"use PUSHNAN instead of 256 PUSHPOW2" = or abort"invalid slice padding" + swap 1 1 u, 0 rot u, } : @scomplete +{ tuck sbitrefs swap 26 + swap @havebitrefs not + { PUSHREFSLICE } + { over sbitrefs 2dup 123 0 2x<= + { drop tuck 4 + 3 >> swap x{8B} s, over 4 u, 3 roll s, + -rot 3 << 4 + swap - @scomplete } + { 2dup 1 >= swap 248 <= and + { rot x{8C} s, swap 1- 2 u, over 7 + 3 >> tuck 5 u, 3 roll s, + -rot 3 << 1 + swap - @scomplete } + { rot x{8D} s, swap 3 u, over 2 + 3 >> tuck 7 u, 3 roll s, + -rot 3 << 6 + swap - @scomplete + } cond + } cond + } cond +} dup : PUSHSLICE : SLICE +// ( b' -- ? ) +{ bbitrefs or 0= } : @cont-empty? +{ bbits 7 and 0= } : @cont-aligned? +// ( b b' -- ? ) +{ bbitrefs over 7 and { 2drop drop false } { + swap 16 + swap @havebitrefs nip + } cond +} : @cont-fits? +// ( b b' -- ? ) +{ bbitrefs over 7 and { 2drop drop false } { + 32 1 pair+ @havebitrefs nip + } cond +} : @cont-ref-fit? +// ( b b' b'' -- ? ) +{ over @cont-aligned? over @cont-aligned? and not { 2drop drop false } { + bbitrefs rot bbitrefs pair+ swap 32 + swap @havebitrefs nip + } cond +} : @two-cont-fit? +{ 2dup @cont-fits? not + { b> PUSHREFCONT } + { swap over bbitrefs 2dup 120 0 2x<= + { drop swap x{9} s, swap 3 >> 4 u, swap b+ } + { rot x{8F_} s, swap 2 u, swap 3 >> 7 u, swap b+ } cond + } cond +} dup : PUSHCONT : CONT +{ }> PUSHCONT } : }>CONT +{ { @normal? PUSHCONT } @doafter<{ } : CONT:<{ + +// arithmetic operations +{ 2 { rot dup 8 fits + { nip = { rot drop -rot PUSHINT swap LSHIFT# } { + { drop PUSHINT } { + not pow2decomp swap -1 = { nip PUSHPOW2DEC } { + drop PUSHINT + } cond } cond } cond } cond } cond } cond +} dup : PUSHINTX : INTX + +// integer comparison +x{B8} @Defop SGN +x{B9} @Defop LESS +x{BA} @Defop EQUAL +x{BB} @Defop LEQ +x{BC} @Defop GREATER +x{BD} @Defop NEQ +x{BE} @Defop GEQ +x{BF} @Defop CMP +x{C0} x{BA} @Defop(8i,alt) EQINT +x{C000} @Defop ISZERO +x{C1} x{B9} @Defop(8i,alt) LESSINT +{ 1+ LESSINT } : LEQINT +x{C100} @Defop ISNEG +x{C101} @Defop ISNPOS +x{C2} x{BC} @Defop(8i,alt) GTINT +{ 1- GTINT } : GEQINT +x{C200} @Defop ISPOS +x{C2FF} @Defop ISNNEG +x{C3} x{BD} @Defop(8i,alt) NEQINT +x{C300} @Defop ISNZERO +x{C4} @Defop ISNAN +x{C5} @Defop CHKNAN + +// other comparison +x{C700} @Defop SEMPTY +x{C701} @Defop SDEMPTY +x{C702} @Defop SREMPTY +x{C703} @Defop SDFIRST +x{C704} @Defop SDLEXCMP +x{C705} @Defop SDEQ +x{C708} @Defop SDPFX +x{C709} @Defop SDPFXREV +x{C70A} @Defop SDPPFX +x{C70B} @Defop SDPPFXREV +x{C70C} @Defop SDSFX +x{C70D} @Defop SDSFXREV +x{C70E} @Defop SDPSFX +x{C70F} @Defop SDPSFXREV +x{C710} @Defop SDCNTLEAD0 +x{C711} @Defop SDCNTLEAD1 +x{C712} @Defop SDCNTTRAIL0 +x{C713} @Defop SDCNTTRAIL1 + +// cell serialization (Builder manipulation primitives) +x{C8} @Defop NEWC +x{C9} @Defop ENDC +x{CA} @Defop(8u+1) STI +x{CB} @Defop(8u+1) STU +x{CC} @Defop STREF +x{CD} dup @Defop STBREFR @Defop ENDCST +x{CE} @Defop STSLICE +x{CF00} @Defop STIX +x{CF01} @Defop STUX +x{CF02} @Defop STIXR +x{CF03} @Defop STUXR +x{CF04} @Defop STIXQ +x{CF05} @Defop STUXQ +x{CF06} @Defop STIXRQ +x{CF07} @Defop STUXRQ +x{CF08} @Defop(8u+1) STI_l +x{CF09} @Defop(8u+1) STU_l +x{CF0A} @Defop(8u+1) STIR +x{CF0B} @Defop(8u+1) STUR +x{CF0C} @Defop(8u+1) STIQ +x{CF0D} @Defop(8u+1) STUQ +x{CF0E} @Defop(8u+1) STIRQ +x{CF0F} @Defop(8u+1) STURQ +x{CF10} @Defop STREF_l +x{CF11} @Defop STBREF +x{CF12} @Defop STSLICE_l +x{CF13} @Defop STB +x{CF14} @Defop STREFR +x{CF15} @Defop STBREFR_l +x{CF16} @Defop STSLICER +x{CF17} dup @Defop STBR @Defop BCONCAT +x{CF18} @Defop STREFQ +x{CF19} @Defop STBREFQ +x{CF1A} @Defop STSLICEQ +x{CF1B} @Defop STBQ +x{CF1C} @Defop STREFRQ +x{CF1D} @Defop STBREFRQ +x{CF1E} @Defop STSLICERQ +x{CF1F} dup @Defop STBRQ @Defop BCONCATQ +x{CF20} @Defop(ref) STREFCONST +{ > tuck 3 u, 3 roll s, + -rot 3 << 2 + swap - @scomplete } + { 2drop swap PUSHSLICE STSLICER } cond + } cond +} : STSLICECONST +x{CF81} @Defop STZERO +x{CF83} @Defop STONE + +// cell deserialization (CellSlice primitives) +x{D0} @Defop CTOS +x{D1} @Defop ENDS +x{D2} @Defop(8u+1) LDI +x{D3} @Defop(8u+1) LDU +x{D4} @Defop LDREF +x{D5} @Defop LDREFRTOS +x{D6} @Defop(8u+1) LDSLICE +x{D700} @Defop LDIX +x{D701} @Defop LDUX +x{D702} @Defop PLDIX +x{D703} @Defop PLDUX +x{D704} @Defop LDIXQ +x{D705} @Defop LDUXQ +x{D706} @Defop PLDIXQ +x{D707} @Defop PLDUXQ +x{D708} @Defop(8u+1) LDI_l +x{D709} @Defop(8u+1) LDU_l +x{D70A} @Defop(8u+1) PLDI +x{D70B} @Defop(8u+1) PLDU +x{D70C} @Defop(8u+1) LDIQ +x{D70D} @Defop(8u+1) LDUQ +x{D70E} @Defop(8u+1) PLDIQ +x{D70F} @Defop(8u+1) PLDUQ +{ dup 31 and abort"argument must be a multiple of 32" 5 >> 1- + > swap x{D72A_} s, over 7 u, 3 roll s, + -rot 3 << 3 + swap - @scomplete } : SDBEGINS:imm +{ tuck sbitrefs abort"no references allowed in slice" dup 26 <= + { drop > swap x{D72E_} s, over 7 u, 3 roll s, + -rot 3 << 3 + swap - @scomplete } : SDBEGINSQ:imm +{ tuck sbitrefs abort"no references allowed in slice" dup 26 <= + { drop rot 2 } { + swap @| swap 2dup @cont-fits? { rot 1 } { + b> rot 2 + } cond } cond } cond } cond + [] execute +} : @run-cont-op +{ triple 1 ' @run-cont-op does create } : @def-cont-op +{ DROP } { PUSHCONT IF } { IFREF } @def-cont-op IF-cont +{ IFRET } { PUSHCONT IFJMP } { IFJMPREF } @def-cont-op IFJMP-cont +{ DROP } { PUSHCONT IFNOT } { IFNOTREF } @def-cont-op IFNOT-cont +{ IFNOTRET } { PUSHCONT IFNOTJMP } { IFNOTJMPREF } @def-cont-op IFNOTJMP-cont +{ dup 2over rot } : 3dup + +recursive IFELSE-cont2 { + dup @cont-empty? { drop IF-cont } { + over @cont-empty? { nip IFNOT-cont } { + 3dup @two-cont-fit? { -rot PUSHCONT swap PUSHCONT IFELSE } { + 3dup nip @cont-ref-fit? { rot swap PUSHCONT swap b> IFREFELSE } { + 3dup drop @cont-ref-fit? { -rot PUSHCONT swap b> IFELSEREF } { + rot 32 2 @havebitrefs { rot b> rot b> IFREFELSEREF } { + @| -rot IFELSE-cont2 + } cond } cond } cond } cond } cond } cond +} swap ! + +{ }> IF-cont } : }>IF +{ }> IFNOT-cont } : }>IFNOT +{ }> IFJMP-cont } : }>IFJMP +{ }> IFNOTJMP-cont } : }>IFNOTJMP +{ { @normal? IFJMP-cont } @doafter<{ } : IFJMP:<{ +{ { @normal? IFNOTJMP-cont } @doafter<{ } : IFNOTJMP:<{ +{ `else @endblk } : }>ELSE<{ +{ `else: @endblk } : }>ELSE: +{ 1 { swap @normal? swap IFELSE-cont2 } does @doafter<{ } : @doifelse +{ 1 { swap @normal? IFELSE-cont2 } does @doafter<{ } : @doifnotelse +{ + { dup `else eq? + { drop @doifelse } + { dup `else: eq? + { drop IFJMP-cont } + { @normal? IF-cont + } cond + } cond + } @doafter<{ +} : IF:<{ +{ + { dup `else eq? + { drop @doifnotelse } + { dup `else: eq? + { drop IFNOTJMP-cont } + { @normal? IFNOT-cont + } cond + } cond + } @doafter<{ +} : IFNOT:<{ + +x{E304} @Defop CONDSEL +x{E305} @Defop CONDSELCHK +x{E308} @Defop IFRETALT +x{E309} @Defop IFNOTRETALT +{ DO<{ +{ `do: @endblk } : }>DO: +{ }> PUSHCONT REPEAT } : }>REPEAT +{ { @normal? PUSHCONT REPEAT } @doafter<{ } : REPEAT:<{ +{ }> PUSHCONT UNTIL } : }>UNTIL +{ { @normal? PUSHCONT UNTIL } @doafter<{ } : UNTIL:<{ +{ PUSHCONT { @normal? PUSHCONT WHILE } @doafter<{ } : @dowhile +{ + { dup `do eq? + { drop @dowhile } + { `do: eq? not abort"`}>DO<{` expected" PUSHCONT WHILEEND + } cond + } @doafter<{ +} : WHILE:<{ +{ }> PUSHCONT AGAIN } : }>AGAIN +{ { @normal? PUSHCONT AGAIN } @doafter<{ } : AGAIN:<{ + +x{E314} @Defop REPEATBRK +x{E315} @Defop REPEATENDBRK +x{E316} @Defop UNTILBRK +x{E317} dup @Defop UNTILENDBRK @Defop UNTILBRK: +x{E318} @Defop WHILEBRK +x{E319} @Defop WHILEENDBRK +x{E31A} @Defop AGAINBRK +x{E31B} dup @Defop AGAINENDBRK @Defop AGAINBRK: + +{ }> PUSHCONT REPEATBRK } : }>REPEATBRK +{ { @normal? PUSHCONT REPEATBRK } @doafter<{ } : REPEATBRK:<{ +{ }> PUSHCONT UNTILBRK } : }>UNTILBRK +{ { @normal? PUSHCONT UNTILBRK } @doafter<{ } : UNTILBRK:<{ +{ PUSHCONT { @normal? PUSHCONT WHILEBRK } @doafter<{ } : @dowhile +{ + { dup `do eq? + { drop @dowhile } + { `do: eq? not abort"`}>DO<{` expected" PUSHCONT WHILEENDBRK + } cond + } @doafter<{ +} : WHILEBRK:<{ +{ }> PUSHCONT AGAINBRK } : }>AGAINBRK +{ { @normal? PUSHCONT AGAINBRK } @doafter<{ } : AGAINBRK:<{ + + +// +// continuation stack manipulation and continuation creation +// +{ PUSHCONT ATEXIT } : }>ATEXIT +{ { @normal? PUSHCONT ATEXIT } @doafter<{ } : ATEXIT:<{ +x{EDF4} @Defop ATEXITALT +{ }> PUSHCONT ATEXITALT } : }>ATEXITALT +{ { @normal? PUSHCONT ATEXITALT } @doafter<{ } : ATEXITALT:<{ +x{EDF5} @Defop SETEXITALT +{ }> PUSHCONT SETEXITALT } : }>SETEXITALT +{ { @normal? PUSHCONT SETEXITALT } @doafter<{ } : SETEXITALT:<{ +x{EDF6} @Defop THENRET +x{EDF7} @Defop THENRETALT +x{EDF8} @Defop INVERT +x{EDF9} @Defop BOOLEVAL +x{EDFA} @Defop SAMEALT +x{EDFB} @Defop SAMEALTSAVE +// x{EE} is BLESSARGS +// +// dictionary subroutine call/jump primitives +{ c3 PUSH EXECUTE } : CALLVAR +{ c3 PUSH JMPX } : JMPVAR +{ c3 PUSH } : PREPAREVAR +{ dup 14 ufits { + dup 8 ufits { + CATCH<{ +{ PUSHCONT { @normal? PUSHCONT TRY } @doafter<{ } : @trycatch +{ + { `catch eq? not abort"`}>CATCH<{` expected" @trycatch + } @doafter<{ +} : TRY:<{ +// +// dictionary manipulation +' NULL : NEWDICT +' ISNULL : DICTEMPTY +' STSLICE : STDICTS +x{F400} dup @Defop STDICT @Defop STOPTREF +x{F401} dup @Defop SKIPDICT @Defop SKIPOPTREF +x{F402} @Defop LDDICTS +x{F403} @Defop PLDDICTS +x{F404} dup @Defop LDDICT @Defop LDOPTREF +x{F405} dup @Defop PLDDICT @Defop PLDOPTREF +x{F406} @Defop LDDICTQ +x{F407} @Defop PLDDICTQ + +x{F40A} @Defop DICTGET +x{F40B} @Defop DICTGETREF +x{F40C} @Defop DICTIGET +x{F40D} @Defop DICTIGETREF +x{F40E} @Defop DICTUGET +x{F40F} @Defop DICTUGETREF + +x{F412} @Defop DICTSET +x{F413} @Defop DICTSETREF +x{F414} @Defop DICTISET +x{F415} @Defop DICTISETREF +x{F416} @Defop DICTUSET +x{F417} @Defop DICTUSETREF +x{F41A} @Defop DICTSETGET +x{F41B} @Defop DICTSETGETREF +x{F41C} @Defop DICTISETGET +x{F41D} @Defop DICTISETGETREF +x{F41E} @Defop DICTUSETGET +x{F41F} @Defop DICTUSETGETREF + +x{F422} @Defop DICTREPLACE +x{F423} @Defop DICTREPLACEREF +x{F424} @Defop DICTIREPLACE +x{F425} @Defop DICTIREPLACEREF +x{F426} @Defop DICTUREPLACE +x{F427} @Defop DICTUREPLACEREF +x{F42A} @Defop DICTREPLACEGET +x{F42B} @Defop DICTREPLACEGETREF +x{F42C} @Defop DICTIREPLACEGET +x{F42D} @Defop DICTIREPLACEGETREF +x{F42E} @Defop DICTUREPLACEGET +x{F42F} @Defop DICTUREPLACEGETREF + +x{F432} @Defop DICTADD +x{F433} @Defop DICTADDREF +x{F434} @Defop DICTIADD +x{F435} @Defop DICTIADDREF +x{F436} @Defop DICTUADD +x{F437} @Defop DICTUADDREF +x{F43A} @Defop DICTADDGET +x{F43B} @Defop DICTADDGETREF +x{F43C} @Defop DICTIADDGET +x{F43D} @Defop DICTIADDGETREF +x{F43E} @Defop DICTUADDGET +x{F43F} @Defop DICTUADDGETREF + +x{F441} @Defop DICTSETB +x{F442} @Defop DICTISETB +x{F443} @Defop DICTUSETB +x{F445} @Defop DICTSETGETB +x{F446} @Defop DICTISETGETB +x{F447} @Defop DICTUSETGETB + +x{F449} @Defop DICTREPLACEB +x{F44A} @Defop DICTIREPLACEB +x{F44B} @Defop DICTUREPLACEB +x{F44D} @Defop DICTREPLACEGETB +x{F44E} @Defop DICTIREPLACEGETB +x{F44F} @Defop DICTUREPLACEGETB + +x{F451} @Defop DICTADDB +x{F452} @Defop DICTIADDB +x{F453} @Defop DICTUADDB +x{F455} @Defop DICTADDGETB +x{F456} @Defop DICTIADDGETB +x{F457} @Defop DICTUADDGETB + +x{F459} @Defop DICTDEL +x{F45A} @Defop DICTIDEL +x{F45B} @Defop DICTUDEL + +x{F462} @Defop DICTDELGET +x{F463} @Defop DICTDELGETREF +x{F464} @Defop DICTIDELGET +x{F465} @Defop DICTIDELGETREF +x{F466} @Defop DICTUDELGET +x{F467} @Defop DICTUDELGETREF + +x{F469} @Defop DICTGETOPTREF +x{F46A} @Defop DICTIGETOPTREF +x{F46B} @Defop DICTUGETOPTREF +x{F46D} @Defop DICTSETGETOPTREF +x{F46E} @Defop DICTISETGETOPTREF +x{F46F} @Defop DICTUSETGETOPTREF + +x{F470} @Defop PFXDICTSET +x{F471} @Defop PFXDICTREPLACE +x{F472} @Defop PFXDICTADD +x{F473} @Defop PFXDICTDEL + +x{F474} @Defop DICTGETNEXT +x{F475} @Defop DICTGETNEXTEQ +x{F476} @Defop DICTGETPREV +x{F477} @Defop DICTGETPREVEQ +x{F478} @Defop DICTIGETNEXT +x{F479} @Defop DICTIGETNEXTEQ +x{F47A} @Defop DICTIGETPREV +x{F47B} @Defop DICTIGETPREVEQ +x{F47C} @Defop DICTUGETNEXT +x{F47D} @Defop DICTUGETNEXTEQ +x{F47E} @Defop DICTUGETPREV +x{F47F} @Defop DICTUGETPREVEQ + +x{F482} @Defop DICTMIN +x{F483} @Defop DICTMINREF +x{F484} @Defop DICTIMIN +x{F485} @Defop DICTIMINREF +x{F486} @Defop DICTUMIN +x{F487} @Defop DICTUMINREF +x{F48A} @Defop DICTMAX +x{F48B} @Defop DICTMAXREF +x{F48C} @Defop DICTIMAX +x{F48D} @Defop DICTIMAXREF +x{F48E} @Defop DICTUMAX +x{F48F} @Defop DICTUMAXREF + +x{F492} @Defop DICTREMMIN +x{F493} @Defop DICTREMMINREF +x{F494} @Defop DICTIREMMIN +x{F495} @Defop DICTIREMMINREF +x{F496} @Defop DICTUREMMIN +x{F497} @Defop DICTUREMMINREF +x{F49A} @Defop DICTREMMAX +x{F49B} @Defop DICTREMMAXREF +x{F49C} @Defop DICTIREMMAX +x{F49D} @Defop DICTIREMMAXREF +x{F49E} @Defop DICTUREMMAX +x{F49F} @Defop DICTUREMMAXREF + +x{F4A0} @Defop DICTIGETJMP +x{F4A1} @Defop DICTUGETJMP +x{F4A2} @Defop DICTIGETEXEC +x{F4A3} @Defop DICTUGETEXEC +{ dup sbitrefs tuck 1 > swap 1 <> or abort"not a dictionary" swap 1 u@ over <> abort"not a dictionary" } : @chkdicts +{ dup null? tuck { idict! + not abort"cannot add key to procedure info dictionary" + @procinfo ! +} : @procinfo! +// ( x v1 v2 -- ) +{ not 2 pick @procinfo@ and xor swap @procinfo! } : @procinfo~! +// ( s i f -- ) +{ over @procdictkeylen fits not abort"procedure index out of range" + over swap dup @procinfo~! 2dup @proclistadd + 1 'nop does swap 0 (create) +} : @declproc +{ 1 'nop does swap 0 (create) } : @declglobvar +{ @proccnt @ 1+ dup @proccnt ! 1 @declproc } : @newproc +{ @gvarcnt @ 1+ dup @gvarcnt ! @declglobvar } : @newglobvar +variable @oldcurrent variable @oldctx +Fift-wordlist dup @oldcurrent ! @oldctx ! +{ current@ @oldcurrent ! context@ @oldctx ! Asm definitions + @proccnt @ @proclist @ @procdict @ @procinfo @ @gvarcnt @ @parent-state @ current@ @oldcurrent @ @oldctx @ + 9 tuple @parent-state ! + hole current! + 0 =: main @proclist null! @proccnt 0! @gvarcnt 0! + { bl word @newproc } : NEWPROC + { bl word dup (def?) ' drop ' @newproc cond } : DECLPROC + { bl word dup find + { nip execute <> abort"method redefined with different id" } + { swap 17 @declproc } + cond } : DECLMETHOD + { bl word @newglobvar } : DECLGLOBVAR + "main" 0 @proclistadd + dictnew dup @procdict ! + @procinfo ! 16 0 @procinfo! +} : PROGRAM{ +{ over sbits < { s>c } : }END> +{ }END> b> } : }END>c +{ }END>c s + +// This is the way how FunC assigns method_id for reserved functions. +// Note, that Tolk entrypoints have other names (`onInternalMessage`, etc.), +// but method_id is assigned not by Fift, but by Tolk code generation. +0 constant recv_internal +-1 constant recv_external +-2 constant run_ticktock +-3 constant split_prepare +-4 constant split_install + +{ asm-mode 0 3 ~! } : asm-no-remove-unused +{ asm-mode 1 1 ~! } : asm-remove-unused // enabled by default +{ asm-mode 3 3 ~! } : asm-warn-remove-unused +{ asm-mode 4 4 ~! } : asm-warn-inline-mix +{ asm-mode 0 4 ~! } : asm-no-warn-inline-mix // disabled by default +{ asm-mode 8 8 ~! } : asm-warn-unused +{ asm-mode 0 8 ~! } : asm-no-warn-unused // disabled by default + +// ( c -- ) add vm library for later use with runvmcode +{ spec } : hash>libref +// ( c -- c' ) +{ hash hash>libref } : >libref + +{ dup "." $pos dup -1 = + { drop 0 } + { $| 1 $| nip swap (number) 1- abort"invalid version" + dup dup 0 < swap 999 > or abort"invalid version" + } + cond +} : parse-version-level + +{ + 0 swap + "." $+ + { swap 1000 * swap parse-version-level rot + swap } 3 times + "" $= not abort"invalid version" +} : parse-asm-fif-version + +{ + dup =: required-version parse-asm-fif-version + asm-fif-version parse-asm-fif-version + = 1+ { + "Required Asm.fif version: " @' required-version "; actual Asm.fif version: " asm-fif-version $+ $+ $+ abort + } if +} : require-asm-fif-version + +{ + dup =: required-version parse-asm-fif-version + asm-fif-version parse-asm-fif-version + swap + >= 1+ { + "Required Asm.fif version: " @' required-version "; actual Asm.fif version: " asm-fif-version $+ $+ $+ abort + } if +} : require-asm-fif-version>= + + +Fift definitions Asm +' <{ : <{ +' PROGRAM{ : PROGRAM{ +' asm-fif-version : asm-fif-version +' require-asm-fif-version : require-asm-fif-version +' require-asm-fif-version>= : require-asm-fif-version>= +Fift diff --git a/src/test/fuzzer/src/minimal-fc-stdlib/fift-lib/Color.fif b/src/test/fuzzer/src/minimal-fc-stdlib/fift-lib/Color.fif new file mode 100644 index 0000000000..bd8ed7af6d --- /dev/null +++ b/src/test/fuzzer/src/minimal-fc-stdlib/fift-lib/Color.fif @@ -0,0 +1,21 @@ +library Color +{ 27 emit } : esc + { char " word 27 chr swap $+ 1 ' type does create } :_ make-esc" + make-esc"[0m" ^reset + make-esc"[30m" ^black + make-esc"[31m" ^red + make-esc"[32m" ^green +make-esc"[33m" ^yellow +make-esc"[34m" ^blue +make-esc"[35m" ^magenta +make-esc"[36m" ^cyan +make-esc"[37m" ^white + // bold +make-esc"[30;1m" ^Black +make-esc"[31;1m" ^Red +make-esc"[32;1m" ^Green +make-esc"[33;1m" ^Yellow +make-esc"[34;1m" ^Blue +make-esc"[35;1m" ^Magenta +make-esc"[36;1m" ^Cyan +make-esc"[37;1m" ^White diff --git a/src/test/fuzzer/src/minimal-fc-stdlib/fift-lib/Disasm.fif b/src/test/fuzzer/src/minimal-fc-stdlib/fift-lib/Disasm.fif new file mode 100644 index 0000000000..a46eb5b277 --- /dev/null +++ b/src/test/fuzzer/src/minimal-fc-stdlib/fift-lib/Disasm.fif @@ -0,0 +1,141 @@ +library TVM_Disasm +// simple TVM Disassembler +"Lists.fif" include + +variable 'disasm +{ 'disasm @ execute } : disasm // disassemble a slice +// usage: x{74B0} disasm + +variable @dismode @dismode 0! +{ rot over @ and rot xor swap ! } : andxor! +{ -2 0 @dismode andxor! } : stack-disasm // output 's1 s4 XCHG' +{ -2 1 @dismode andxor! } : std-disasm // output 'XCHG s1, s4' +{ -3 2 @dismode andxor! } : show-vm-code +{ -3 0 @dismode andxor! } : hide-vm-code +{ @dismode @ 1 and 0= } : stack-disasm? + +variable @indent @indent 0! +{ ' space @indent @ 2* times } : .indent +{ @indent 1+! } : +indent +{ @indent 1-! } : -indent + +{ " " $pos } : spc-pos +{ dup " " $pos swap "," $pos dup 0< { drop } { + over 0< { nip } { min } cond } cond +} : spc-comma-pos +{ { dup spc-pos 0= } { 1 $| nip } while } : -leading +{ -leading -trailing dup spc-pos dup 0< { + drop dup $len { atom single } { drop nil } cond } { + $| swap atom swap -leading 2 { over spc-comma-pos dup 0>= } { + swap 1+ -rot $| 1 $| nip -leading rot + } while drop tuple + } cond +} : parse-op +{ dup "s-1" $= { drop "s(-1)" true } { + dup "s-2" $= { drop "s(-2)" true } { + dup 1 $| swap "x" $= { nip "x{" swap $+ +"}" true } { + 2drop false } cond } cond } cond +} : adj-op-arg +{ over count over <= { drop } { 2dup [] adj-op-arg { swap []= } { drop } cond } cond } : adj-arg[] +{ 1 adj-arg[] 2 adj-arg[] 3 adj-arg[] + dup first + dup `XCHG eq? { + drop dup count 2 = { tpop swap "s0" , swap , } if } { + dup `LSHIFT eq? { + drop dup count 2 = stack-disasm? and { second `LSHIFT# swap pair } if } { + dup `RSHIFT eq? { + drop dup count 2 = stack-disasm? and { second `RSHIFT# swap pair } if } { + drop + } cond } cond } cond +} : adjust-op + +variable @cp @cp 0! +variable @curop +variable @contX variable @contY variable @cdict + +{ atom>$ type } : .atom +{ dup first .atom dup count 1 > { space 0 over count 2- { 1+ 2dup [] type .", " } swap times 1+ [] type } { drop } cond } : std-show-op +{ 0 over count 1- { 1+ 2dup [] type space } swap times drop first .atom } : stk-show-op +{ @dismode @ 2 and { .indent ."// " @curop @ csr. } if } : .curop? +{ .curop? .indent @dismode @ 1 and ' std-show-op ' stk-show-op cond cr +} : show-simple-op +{ dup 4 u@ 9 = { 8 u@+ swap 15 and 3 << s@ } { + dup 7 u@ 0x47 = { 7 u@+ nip 2 u@+ 7 u@+ -rot 3 << swap sr@ } { + dup 8 u@ 0x8A = { ref@ " cr } : show-cont-op +{ swap scont-swap ":<{" show-cont-bodyx scont-swap + "" show-cont-bodyx .indent ."}>" cr } : show-cont2-op + +{ @contX @ null? { "CONT" show-cont-op } ifnot +} : flush-contX +{ @contY @ null? { scont-swap "CONT" show-cont-op scont-swap } ifnot +} : flush-contY +{ flush-contY flush-contX } : flush-cont +{ @contX @ null? not } : have-cont? +{ @contY @ null? not } : have-cont2? +{ flush-contY @contY ! scont-swap } : save-cont-body + +{ @cdict ! } : save-const-dict +{ @cdict null! } : flush-dict +{ @cdict @ null? not } : have-dict? + +{ flush-cont .indent type .":<{" cr + @curop @ ref@ " cr +} : show-ref-op +{ flush-contY .indent rot type .":<{" cr + @curop @ ref@ " cr +} : show-cont-ref-op +{ flush-cont .indent swap type .":<{" cr + @curop @ ref@+ " cr +} : show-ref2-op + +{ flush-cont first atom>$ dup 5 $| drop "DICTI" $= swap + .indent type ." {" cr +indent @cdict @ @cdict null! unpair + rot { + swap .indent . ."=> <{" cr +indent disasm -indent .indent ."}>" cr true + } swap ' idictforeach ' dictforeach cond drop + -indent .indent ."}" cr +} : show-const-dict-op + +( `PUSHCONT `PUSHREFCONT ) constant @PushContL +( `REPEAT `UNTIL `IF `IFNOT `IFJMP `IFNOTJMP ) constant @CmdC1 +( `IFREF `IFNOTREF `IFJMPREF `IFNOTJMPREF `CALLREF `JMPREF ) constant @CmdR1 +( `DICTIGETJMP `DICTIGETJMPZ `DICTUGETJMP `DICTUGETJMPZ `DICTIGETEXEC `DICTUGETEXEC ) constant @JmpDictL +{ dup first `DICTPUSHCONST eq? { + flush-cont @curop @ get-const-dict save-const-dict show-simple-op } { + dup first @JmpDictL list-member? have-dict? and { + flush-cont show-const-dict-op } { + flush-dict + dup first @PushContL list-member? { + drop @curop @ get-cont-body save-cont-body } { + dup first @CmdC1 list-member? have-cont? and { + flush-contY first atom>$ .curop? show-cont-op } { + dup first @CmdR1 list-member? { + flush-cont first atom>$ dup $len 3 - $| drop .curop? show-ref-op } { + dup first `WHILE eq? have-cont2? and { + drop "WHILE" "}>DO<{" .curop? show-cont2-op } { + dup first `IFELSE eq? have-cont2? and { + drop "IF" "}>ELSE<{" .curop? show-cont2-op } { + dup first dup `IFREFELSE eq? swap `IFELSEREF eq? or have-cont? and { + first `IFREFELSE eq? "IF" "}>ELSE<{" rot .curop? show-cont-ref-op } { + dup first `IFREFELSEREF eq? { + drop "IF" "}>ELSE<{" .curop? show-ref2-op } { + flush-cont show-simple-op + } cond } cond } cond } cond } cond } cond } cond } cond } cond +} : show-op +{ dup @cp @ (vmoplen) dup 0> { 65536 /mod swap sr@+ swap dup @cp @ (vmopdump) parse-op swap s> true } { drop false } cond } : fetch-one-op +{ { fetch-one-op } { swap @curop ! adjust-op show-op } while } : disasm-slice +{ { disasm-slice dup sbitrefs 1- or 0= } { ref@ B 1 'nop } ::_ B{ +{ swap ({) over 2+ -roll swap (compile) (}) } : does +{ 1 'nop does create } : constant +{ 2 'nop does create } : 2constant +{ hole constant } : variable +10 constant ten +{ bl word 1 { find 0= abort"word not found" } } :: (') +{ bl word find not abort"-?" 0 swap } :: [compile] +{ bl word 1 { + dup find { " -?" $+ abort } ifnot nip execute +} } :: @' +{ bl word 1 { swap 1 'nop does swap 0 (create) } +} :: =: +{ bl word 1 { -rot 2 'nop does swap 0 (create) } +} :: 2=: +{ } : s>c +{ s>c hashB } : shash +// to be more efficiently re-implemented in C++ in the future +{ dup 0< ' negate if } : abs +{ 2dup > ' swap if } : minmax +{ minmax drop } : min +{ minmax nip } : max +"" constant <# +' $reverse : #> +{ swap 10 /mod char 0 + rot swap hold } : # +{ { # over 0<= } until } : #s +{ 0< { char - hold } if } : sign +// { dup abs <# #s rot sign #> nip } : (.) +// { (.) type } : ._ +// { ._ space } : . +{ dup 10 < { 48 } { 55 } cond + } : Digit +{ dup 10 < { 48 } { 87 } cond + } : digit +// x s b -- x' s' +{ rot swap /mod Digit rot swap hold } : B# +{ rot swap /mod digit rot swap hold } : b# +{ 16 B# } : X# +{ 16 b# } : x# +// x s b -- 0 s' +{ -rot { 2 pick B# over 0<= } until rot drop } : B#s +{ -rot { 2 pick b# over 0<= } until rot drop } : b#s +{ 16 B#s } : X#s +{ 16 b#s } : x#s +variable base +{ 10 base ! } : decimal +{ 16 base ! } : hex +{ 8 base ! } : octal +{ 2 base ! } : binary +{ base @ B# } : Base# +{ base @ b# } : base# +{ base @ B#s } : Base#s +{ base @ b#s } : base#s +// x w -- s +{ over abs <# rot 1- ' X# swap times X#s rot sign #> nip } : (0X.) +{ over abs <# rot 1- ' x# swap times x#s rot sign #> nip } : (0x.) +{ (0X.) type } : 0X._ +{ 0X._ space } : 0X. +{ (0x.) type } : 0x._ +{ 0x._ space } : 0x. +{ bl (-trailing) } : -trailing +{ char 0 (-trailing) } : -trailing0 +{ char " word 1 ' $+ } ::_ +" +{ find 0<> dup ' nip if } : (def?) +{ bl word 1 ' (def?) } :: def? +{ bl word 1 { (def?) not } } :: undef? +{ def? ' skip-to-eof if } : skip-ifdef +{ bl word dup (def?) { drop skip-to-eof } { 'nop swap 0 (create) } cond } : library +{ bl word dup (def?) { 2drop skip-to-eof } { swap 1 'nop does swap 0 (create) } cond } : library-version +{ hole dup 1 'nop does swap 1 { context! } does bl word tuck 0 (create) +"-wordlist" 0 (create) } : namespace +{ context@ current! } : definitions +{ char ) word "$" swap $+ 1 { find 0= abort"undefined parameter" execute } } ::_ $( +// b s -- ? +{ sbitrefs rot brembitrefs rot >= -rot <= and } : s-fits? +// b s x -- ? +{ swap sbitrefs -rot + rot brembitrefs -rot <= -rot <= and } : s-fits-with? +{ 0 swap ! } : 0! +{ tuck @ + swap ! } : +! +{ tuck @ swap - swap ! } : -! +{ 1 swap +! } : 1+! +{ -1 swap +! } : 1-! +{ null swap ! } : null! +{ not 2 pick @ and xor swap ! } : ~! +0 tuple constant nil +{ 1 tuple } : single +{ 2 tuple } : pair +{ 3 tuple } : triple +{ 1 untuple } : unsingle +{ 2 untuple } : unpair +{ 3 untuple } : untriple +{ over tuple? { swap count = } { 2drop false } cond } : tuple-len? +{ 0 tuple-len? } : nil? +{ 1 tuple-len? } : single? +{ 2 tuple-len? } : pair? +{ 3 tuple-len? } : triple? +{ 0 [] } : first +{ 1 [] } : second +{ 2 [] } : third +' pair : cons +' unpair : uncons +{ 0 [] } : car +{ 1 [] } : cdr +{ cdr car } : cadr +{ cdr cdr } : cddr +{ cdr cdr car } : caddr +{ null ' cons rot times } : list +{ -rot pair swap ! } : 2! +{ @ unpair } : 2@ +{ true (atom) drop } : atom +{ bl word atom 1 'nop } ::_ ` +{ hole dup 1 { @ execute } does create } : recursive +{ 0 { 1+ dup 1 ' $() does over (.) "$" swap $+ 0 (create) } rot times drop } : :$1..n +{ 10 hold } : +cr +{ 9 hold } : +tab +{ "" swap { 0 word 2dup $cmp } { rot swap $+ +cr swap } while 2drop } : scan-until-word +{ 0 word -trailing scan-until-word 1 'nop } ::_ $<< +{ 0x40 runvmx } : runvmcode +{ 0x48 runvmx } : gasrunvmcode +{ 0xc8 runvmx } : gas2runvmcode +{ 0x43 runvmx } : runvmdict +{ 0x4b runvmx } : gasrunvmdict +{ 0xcb runvmx } : gas2runvmdict +{ 0x45 runvmx } : runvm +{ 0x4d runvmx } : gasrunvm +{ 0xcd runvmx } : gas2runvm +{ 0x55 runvmx } : runvmctx +{ 0x5d runvmx } : gasrunvmctx +{ 0xdd runvmx } : gas2runvmctx +{ 0x75 runvmx } : runvmctxact +{ 0x7d runvmx } : gasrunvmctxact +{ 0xfd runvmx } : gas2runvmctxact +{ 0x35 runvmx } : runvmctxactq +{ 0x3d runvmx } : gasrunvmctxactq diff --git a/src/test/fuzzer/src/minimal-fc-stdlib/fift-lib/FiftExt.fif b/src/test/fuzzer/src/minimal-fc-stdlib/fift-lib/FiftExt.fif new file mode 100644 index 0000000000..6ed677d7f2 --- /dev/null +++ b/src/test/fuzzer/src/minimal-fc-stdlib/fift-lib/FiftExt.fif @@ -0,0 +1,118 @@ +{ ?dup { 1+ { execute } { 0 swap } cond } + { (number) ?dup 0= abort"-?" 'nop } cond +} : (interpret-prepare) +{ { include-depth 0= (seekeof?) not } { + (word-prefix-find) (interpret-prepare) (execute) + } while +} : interpret +{ ({) + { 0 (seekeof?) abort"no }" (word-prefix-find) (interpret-prepare) (compile) over atom? not } until + (}) swap execute +} : begin-block +{ swap 0 'nop } : end-block +{ { 1 'nop } `{ begin-block } +{ { swap `{ eq? not abort"} without {" swap execute } end-block } +:: } :: { + +// if{ ... }then{ ... }elseif{ ... }then{ ... }else{ ... } +{ eq? not abort"unexpected" } : ?pairs +{ dup `if eq? swap `ifnot eq? over or not abort"without if{" } : if-ifnot? +// cond then ? -- exec +{ { ' if } { ' ifnot } cond rot ({) 0 rot (compile) -rot 1 swap (compile) (}) +} : (make-if) +// cond then else -- exec +{ rot ({) 0 rot (compile) -rot 2 ' cond (compile) (}) +} : (make-cond) +{ `noelse `if begin-block } :: if{ +{ `noelse `ifnot begin-block } :: ifnot{ +{ 1 ' end-block does } : end-block-does +{ { over `else eq? } { + nip rot if-ifnot? ' swap ifnot (make-cond) + } while + swap `noelse ?pairs 0 swap +} : finish-else-chain +{ swap dup if-ifnot? drop `then { + swap `then ?pairs + swap if-ifnot? (make-if) finish-else-chain + } `{ begin-block +} end-block-does :: }then{ +{ swap `{ ?pairs nip + swap `then eq? not abort"without }then{" `else +} : ?else-ok +{ ?else-ok { finish-else-chain } `{ begin-block } end-block-does :: }else{ +{ ?else-ok `if begin-block } end-block-does :: }elseif{ +{ ?else-ok `ifnot begin-block } end-block-does :: }elseifnot{ + +// while{ ... }do{ ... } +{ 2 ' while does } : (make-while) +{ `while begin-block } :: while{ +{ swap `while eq? not abort"without while{" `while-do { + swap `while-do ?pairs (make-while) 0 swap + } `{ begin-block +} end-block-does :: }do{ + +// repeat{ ... }until{ ... } +{ swap ({) 0 rot (compile) 0 rot (compile) (}) 1 ' until does } : (make-until) +{ `repeat begin-block } :: repeat{ +{ swap `repeat eq? not abort"without repeat{" `until { + swap `until ?pairs (make-until) 0 swap + } `{ begin-block +} end-block-does :: }until{ + +// def { ... } instead of { ... } : +{ bl word swap bl word "{" $cmp abort"{ expected" `def { + swap `def ?pairs -rot 3 ' (create) + } `{ begin-block +} : (def) +{ 0 (def) } :: def +{ 1 (def) } :: def:: + +// defrec { ... } instead of recursive { ... } swap ! +{ recursive bl word "{" $cmp abort"{ expected" `defrec { + swap `defrec ?pairs swap ! 0 'nop + } `{ begin-block +} :: defrec + +def .sgn { + if{ ?dup 0= }then{ + ."zero" + }elseif{ 0> }then{ + ."positive" + }else{ + ."negative" + } + cr +} +// equivalent to: { ?dup 0= { ."zero" } { 0> { ."positive" } { ."negative" } cond } cond cr } : .sgn + +defrec fact { + if{ dup }then{ + dup 1- fact * + }else{ + drop 1 + } +} +// equivalent to: recursive fact { dup { dup 1- fact * } { drop 1 } cond } swap ! + +// [[ ... ]] computes arbitrary constants inside definitions +// { [[ 5 dup * ]] + } : add25 +// is equivalent to +// { 25 + } : add25 +{ "without [[" abort } box constant ']] +{ ']] @ execute } : ]] +{ { ']] @ 2 { ']] ! call/cc } does ']] ! + interpret 'nop ']] ! "]] not found" abort + } call/cc + drop 1 'nop +} :: [[ + +{ { over @ swap 2 { call/cc } does swap ! + interpret "literal to eof" abort + } call/cc + drop execute 1 'nop +} : interpret-literal-to +// use next line only if Lists.fif is loaded (or move it to Lists.fif if FiftExt.fif becomes part of Fift.fif) +// { ( ') interpret-literal-to } :: '( +// then you can use list literals '( a b c ... ) inside definitions: +// { '( 1 2 3 ) } : test +// { '( ( `a { ."A" } ) ( `b { ."B" } ) ) assoc { cadr execute } { ."???" } cond } : test2 diff --git a/src/test/fuzzer/src/minimal-fc-stdlib/fift-lib/GetOpt.fif b/src/test/fuzzer/src/minimal-fc-stdlib/fift-lib/GetOpt.fif new file mode 100644 index 0000000000..442552b636 --- /dev/null +++ b/src/test/fuzzer/src/minimal-fc-stdlib/fift-lib/GetOpt.fif @@ -0,0 +1,131 @@ +library GetOpt // Simple command-line options parser +"Lists.fif" include + +// May be used as follows: +// begin-options +// "h" { ."Help Message" 0 halt } short-option +// "v" { parse-int =: verbosity } short-option-arg +// "i" "--interactive" { true =: interactive } short-long-option +// parse-options + +// ( l -- l') computes tail of list l if non-empty; else () +{ dup null? ' cdr ifnot } : safe-cdr +// ( l c -- l') deletes first c elements from list l +{ ' safe-cdr swap times } : list-delete-first +// ( l n c -- l' ) deletes c elements starting from n-th in list l +recursive list-delete-range { + dup 0<= { 2drop } { + over 0<= { nip list-delete-first } { + swap 1- swap rot uncons 2swap list-delete-range cons + } cond } cond +} swap ! +// ( n c -- ) deletes $n .. $(n+c-1) from the argument list $* +{ swap 1- $* @ swap rot list-delete-range $* ! } : $*del.. +// ( s s' -- ? ) checks whether s' is a prefix of s +{ tuck $len over $len over >= { $| drop $= } { 2drop drop false } cond +} : $pfx? +// ( s -- ? ) checks whether s is an option (a string beginning with '-') +{ dup $len 1 > { "-" $pfx? } { drop false } cond } : is-opt? +// ( s -- ? ) checks whether s is a digit option +{ 2 $| drop 1 $| nip $>B 8 B>u@ dup 57 <= swap 48 >= and } : is-digit-opt? +0 box constant disable-digit-opts +// ( l -- s i or 0 ) finds first string in l beginning with '-' +{ 0 { 1+ over null? { 2drop 0 true } { + swap uncons over is-opt? + { disable-digit-opts @ { over is-digit-opt? not } { true } cond } { false } cond + { drop swap true } { nip swap false } cond + } cond } until +} : list-find-opt +// ( -- s i or 0 ) finds first option in cmdline args +{ $* @ list-find-opt } : first-opt +' second : get-opt-flags +' first : get-opt-exec +// ( s t -- ? ) checks whether short/long option s matches description t +{ third $= } : short-option-matches +{ dup get-opt-flags 4 and 0= 3 + [] $= +} : long-option-matches +// ( t -- s -1 or 0 ) extracts help message from description +{ dup get-opt-flags 4 and 0= 4 + over count over > + { [] true } { 2drop false } cond +} : get-opt-help +// ( s l -- t -1 or 0 ) finds short/long option s in list l +{ swap 1 { swap short-option-matches } does assoc-gen +} : lookup-short-option +{ swap 1 { swap long-option-matches } does assoc-gen +} : lookup-long-option +// ( s -- s' null or s' s'' ) Splits long option --opt=arg at '=' +{ dup "=" $pos 1+ ?dup { tuck $| swap rot 1- $| drop swap } { null } cond +} : split-longopt +// ( l -- f or 0 ) Extracts global option flags from first entry of l +{ dup null? { drop 0 } { car get-opt-flags -256 and } cond +} : get-global-option-flags +variable options-list +// ( l -- i or 0 ) +// parses command line arguments according to option description list l +// and returns index i of first incorrect option +{ dup options-list ! get-global-option-flags + 256 and disable-digit-opts ! + { first-opt dup 0= { true } { + swap dup "--" $pfx? { // i s + dup $len 2 = { drop dup 1 $*del.. 0 true } { + split-longopt swap options-list @ + lookup-long-option not { drop true } { // i s' t f + dup get-opt-exec swap get-opt-flags 3 and // i s' e f' + 2 pick null? { dup 1 = } { dup 0= negate } cond // i s' e f' f'' + dup 1 = { 2drop 2drop true } { + { drop nip over 1+ $() swap execute 2 $*del.. false } { + ' nip ifnot execute 1 $*del.. false + } cond } cond } cond } cond } { // i s + 1 $| nip { + dup $len 0= { drop 1 $*del.. false true } { + 1 $| swap options-list @ // i s' s l + lookup-short-option not { drop true true } { // i s' t + dup get-opt-exec swap get-opt-flags 3 and // i s' e f' + ?dup 0= { execute false } { + 2 pick $len { drop execute "" false } { + 2 = { nip null swap execute "" false } { // i e + nip over 1+ $() swap execute 2 $*del.. false true + } cond } cond } cond } cond } cond } until + } cond + } cond } until +} : getopt +// ( t -- ) Displays help message for one option +{ dup get-opt-flags dup 4 and 2 pick third swap { + ."-" type ."/" over 3 [] type } { + dup $len { dup "--" $pfx? { ."-" } ifnot type } { + drop ."usage: " $0 type + } cond } cond + dup 3 and ?dup { + 2 = { ."[=]" } { ."=" } cond + } if + 8 and { 9 emit } ifnot + get-opt-help { type } { ."No help available" } cond cr +} : show-opt-help +// ( -- ) Displays options help message according to options-list +{ options-list @ { dup null? not } { + uncons swap show-opt-help + } while drop +} : show-options-help +// ( l -- ) Parses options and throws an error on failure +{ getopt ?dup { + $() "cannot parse command line options near `" swap $+ +"`" + show-options-help abort } if +} : run-getopt +anon constant opt-list-marker +' opt-list-marker : begin-options +{ opt-list-marker list-until-marker } : end-options +{ end-options run-getopt } : parse-options +// ( s e -- o ) Creates short/long option s with execution token e +{ 0 rot triple } dup : short-option : long-option +// ( s s' e -- o ) Creates a combined short option s and long option s' with execution token e +{ 4 2swap 4 tuple } : short-long-option +{ 1 rot triple } dup : short-option-arg : long-option-arg +{ 2 rot triple } dup : short-option-?arg : long-option-?arg +{ 5 2swap 4 tuple } : short-long-option-arg +{ 6 2swap 4 tuple } : short-long-option-?arg +// ( o s -- s' ) Adds help message to option +' , : option-help +// ( s f -- o ) Creates a generic help message +{ swap 'nop rot "" 3 roll 4 tuple } : generic-help-setopt +{ 0 generic-help-setopt } : generic-help +256 constant disable-digit-options diff --git a/src/test/fuzzer/src/minimal-fc-stdlib/fift-lib/Lisp.fif b/src/test/fuzzer/src/minimal-fc-stdlib/fift-lib/Lisp.fif new file mode 100644 index 0000000000..fb91408d33 --- /dev/null +++ b/src/test/fuzzer/src/minimal-fc-stdlib/fift-lib/Lisp.fif @@ -0,0 +1,436 @@ +library Lisp // tiny Lisp (or rather Scheme) interpreter +"Lists.fif" include +variable lisp-dict +{ hole dup 1 { @ execute } does create } : recursive +{ atom>$ +" undefined" abort } : report-not-found +// a l -- d -1 or a 0 Look up definition d of atom a in dictionary l +{ { dup null? { drop false true } + { uncons -rot unpair -rot over eq? + { drop nip true true } { nip swap false } cond + } cond + } until +} : lookup-in +// a dict -- def +{ lookup-in ' report-not-found ifnot } : lookup-or-fail +{ lisp-dict @ lookup-or-fail } : lisp-dict-lookup +// a d -- Defines a with definition d in dictionary lisp-dict +{ pair lisp-dict @ cons lisp-dict ! } : lisp-dict-int-define +{ box lisp-dict-int-define } : lisp-dict-define +// a d -- Defines new a with defininition d +{ over lisp-dict @ lookup-in { 2drop atom>$ +" already defined" abort } + { drop lisp-dict-int-define } cond +} : lisp-dict-int-define-new +{ box lisp-dict-int-define-new } : lisp-dict-define-new +// a e -- Defines a with executable definition given by e +{ single lisp-dict-define-new } : lisp-dict-define-exec +// expr ctx def -- val +{ dup first execute } : run-definition +// expr ctx -- val +recursive lisp-ctx-eval { + over tuple? + { over first over lisp-ctx-eval run-definition } + { over atom? { lookup-or-fail @ } { drop } cond } + cond +} swap ! +// exp -- value +{ lisp-dict @ lisp-ctx-eval } : lisp-eval +// (exprs) ctx -- (vals) +recursive lisp-ctx-eval-list +{ over null? { drop } { + swap uncons -rot over lisp-ctx-eval -rot lisp-ctx-eval-list cons + } cond +} swap ! +// (exprs) ctx -- val +{ null rot { + dup null? { drop nip true } { + nip uncons swap 2 pick lisp-ctx-eval swap false + } cond } until +} : lisp-ctx-eval-list-last +// l c -- (args) +{ swap uncons nip swap lisp-ctx-eval-list } : extract-eval-arg-list +{ drop uncons nip } : extract-arg-list +// (x1 .. xn) e n -- x1 .. xn e +{ { swap uncons rot } swap times + swap null? not abort"invalid number of arguments" +} : unpack-list +// l c n e -- v +{ swap 2swap extract-eval-arg-list // e n (args) + -rot unpack-list execute +} : eval-exec-fixed +// l c n e -- v +{ 2 pick pair + swap 2swap extract-arg-list // [e c] n (args) + -rot unpack-list unpair swap execute +} : exec-fixed +// l c e -- v +{ -rot extract-eval-arg-list // e (args) + swap execute +} : eval-exec-list +{ -rot tuck extract-arg-list // e c (args) + swap rot execute +} : exec-list +// e a n -- +{ rot 2 { // expr ctx def n e + rot drop eval-exec-fixed } does + lisp-dict-define-exec +} : lisp-fixed-primitive +{ rot 2 { rot drop exec-fixed } does lisp-dict-define-exec +} : lisp-fixed-lazy-primitive +// e a -- +{ swap 1 { nip eval-exec-list } does lisp-dict-define-exec +} : lisp-primitive +{ swap 1 { nip exec-list } does lisp-dict-define-exec +} : lisp-lazy-primitive + +// Uncomment next line for Fift booleans +// false constant #f true constant #t null constant no-answer +// Uncomment next line for Scheme booleans +`#f constant #f `#t constant #t #f constant no-answer +{ #f eq? } : lisp-false? +{ lisp-false? 0= } : lisp-true? +{ ' #t ' #f cond } : lisp-bool + +// temp for defining a lot of primitives +{ bl word atom lisp-primitive } : L: +{ bl word atom swap lisp-dict-define } : L=: +{ bl word atom swap lisp-fixed-primitive } : #L: +{ 0 #L: } : 0L: +{ 1 #L: } : 1L: +{ 2 #L: } : 2L: + +// basic primitives +{ sum-list } L: + +{ - } 2L: - +{ dup null? { drop 1 } { ' * foldl-ne } cond } L: * +{ / } 2L: / +{ mod } 2L: modulo +{ abs } 1L: abs +{ ' min foldl-ne } L: min +{ ' max foldl-ne } L: max +{ true ' and foldl } L: integer-and +{ false ' or foldl } L: integer-or +{ 0 ' xor foldl } L: integer-xor +{ not } 1L: integer-not +{ = lisp-bool } 2L: = +{ <> lisp-bool } 2L: <> +{ < lisp-bool } 2L: < +{ <= lisp-bool } 2L: <= +{ > lisp-bool } 2L: > +{ >= lisp-bool } 2L: >= +{ eq? lisp-bool } 2L: eq? +{ eqv? lisp-bool } 2L: eqv? +{ equal? lisp-bool } 2L: equal? +{ cons } 2L: cons +{ car } 1L: car +{ cdr } 1L: cdr +{ cadr } 1L: cadr +{ cddr } 1L: cddr +{ caddr } 1L: caddr +{ cdr cddr } 1L: cdddr +{ concat-list-lists } L: append +{ list-reverse } 1L: reverse +{ list-tail } 2L: list-tail +{ list-ref } 2L: list-ref +{ list-member-eq } 2L: memq +{ list-member-eqv } 2L: memv +{ list-member-equal } 2L: member +{ assq ' #f ifnot } 2L: assq +{ assv ' #f ifnot } 2L: assv +{ assoc ' #f ifnot } 2L: assoc +{ list? lisp-bool } 1L: list? +{ pair? lisp-bool } 1L: pair? +{ tuple? lisp-bool } 1L: tuple? +{ string? lisp-bool } 1L: string? +{ integer? lisp-bool } 1L: integer? +{ integer? lisp-bool } 1L: number? +{ count } 1L: width +{ list-length } 1L: length +{ [] } 2L: tuple-ref +{ first } 1L: first +{ second } 1L: second +{ third } 1L: third +{ 3 [] } 1L: fourth +{ list>tuple } 1L: list->tuple +{ explode list } 1L: tuple->list +null L=: null +{ atom? lisp-bool } 1L: symbol? +{ atom } 1L: string->symbol +{ atom>$ } 1L: symbol->string +{ dup #f eq? swap #t eq? or lisp-bool } 1L: boolean? +#t L=: else +#f L=: #f +#t L=: #t +{ null? lisp-bool } 1L: null? +{ 0= lisp-bool } 1L: zero? +{ 0> lisp-bool } 1L: positive? +{ 0< lisp-bool } 1L: negative? +{ 1 and 0= lisp-bool } 1L: even? +{ 1 and 0<> lisp-bool } 1L: odd? +{ bye } 0L: exit +{ .l null } 1L: write +{ lisp-eval } 1L: eval +{ drop } `quote 1 lisp-fixed-lazy-primitive +'nop L: list +{ list>tuple } L: tuple +{ list-last } L: begin +{ $len } 1L: string-length +{ concat-string-list } L: string-append +{ $= lisp-bool } 2L: string=? +{ $cmp 0< lisp-bool } 2L: string lisp-bool } 2L: string>? +{ $cmp 0>= lisp-bool } 2L: string>=? +{ (number) dup 1 = { drop } { ' 2drop if no-answer } cond +} 1L: string->number +{ (.) } 1L: number->string +{ box? lisp-bool } 1L: box? +{ box } 1L: box +{ hole } 0L: new-box +{ @ } 1L: unbox +{ tuck swap ! } 2L: set-box! +{ abort } 1L: error +{ dup find { nip execute } { +" -?" abort } cond } : find-execute +{ explode-list 1- roll find-execute } L: fift-exec +{ explode-list dup 1- swap roll find-execute } L: fift-exec-cnt +{ uncons swap find-execute } L: fift-exec-list +// end of basic primitives +forget L: forget #L: forget L=: +forget 0L: forget 1L: forget 2L: + +{ { dup tuple? ' do-quote if } list-map } : map-quote +{ uncons ' cons foldr-ne map-quote + null swap cons lisp-dict @ rot run-definition +} `apply lisp-primitive // bad: should have preserved original context +// e1 e2 e3 ctx +{ 3 exch 3 pick lisp-ctx-eval lisp-true? ' swap if nip swap lisp-ctx-eval } +`if 3 lisp-fixed-lazy-primitive +// (e) ctx +{ #t -rot + { over null? { 2drop true } { + swap uncons swap 2 pick lisp-ctx-eval dup lisp-true? // v' c t v ? + { swap 2swap nip false } { -rot 2drop nip true } cond + } cond } until +} `and lisp-lazy-primitive +{ #f -rot + { over null? { 2drop true } { + swap uncons swap 2 pick lisp-ctx-eval dup lisp-false? // v' c t v ? + { swap 2swap nip false } { -rot 2drop nip true } cond + } cond } until +} `or lisp-lazy-primitive +{ lisp-false? lisp-bool } `not 1 lisp-fixed-primitive +// cond-clause ctx -- v -1 or 0 +{ swap uncons -rot dup `else eq? { + drop lisp-ctx-eval-list-last true } { + over lisp-ctx-eval lisp-true? { + lisp-ctx-eval-list-last true } { + 2drop false + } cond } cond +} : eval-cond-clause +// (clauses) ctx -- v +{ { over null? { no-answer true } { + swap uncons -rot over eval-cond-clause } cond + } until -rot 2drop +} `cond lisp-lazy-primitive +{ lisp-dict @ lookup-in { hole tuck lisp-dict-int-define } ifnot +} : lisp-create-global-var +// a e ctx -- old (simple) define +{ drop over atom? not abort"only a variable can be define'd" + over lisp-create-global-var swap lisp-eval swap ! +} drop // `define 2 lisp-fixed-lazy-primitive +{ tuck lisp-ctx-eval rot dup atom? not abort"only a variable can be set" + rot lookup-or-fail dup @ -rot ! +} `set! 2 lisp-fixed-lazy-primitive +// define lambda +{ { dup null? { drop true true } + { uncons swap atom? { false } { drop false true } cond } cond + } until +} : var-list? +{ { dup null? over atom? or { drop true true } + { uncons swap atom? { false } { drop false true } cond } cond + } until +} : lambda-var-list? +// (quote x) -- x -1 ; else 0 +{ dup pair? { uncons swap `quote eq? { car true } { drop false } cond } + { drop false } cond +} : is-quote? +recursive match-arg-list-acc +// l (vars) (args) -- ((var . arg) ...)+l -1 or ? 0 +{ over atom? { over `_ eq? { 2drop } { pair swap cons } cond true } { + over null? { nip null? } { // (vars) (args) + over tuple? not { 2drop false } { + over is-quote? { eq? nip } { // (v) (a) + dup tuple? not { 2drop false } { + over count over count over <> { drop 2drop false } { // l [v] [a] n + 3 roll 0 rot { // [v] [a] l i + dup 0< { + 3 pick over [] swap // [v] [a] l vi i + 3 pick over [] 2swap rot // [v] [a] i l vi ai + match-arg-list-acc { // [v] [a] i l' + swap 1+ } { nip -1 } cond + } ifnot + } swap times + 2swap 2drop 0>= + } cond } cond } cond } cond } cond } cond +} swap ! +{ null -rot match-arg-list-acc } : match-arg-list +// ((var . arg)...) ctx -- ctx' +{ { over null? not } + { swap uncons swap unpair box pair rot cons } while + nip +} : extend-ctx-by-list +// ((vars) body) ctx +{ swap uncons -rot + dup lambda-var-list? not abort"invalid formal parameter list" + { // l-expr ctx' [_ body ctx (vars)] + -rot 2 pick 3 [] swap rot // [_ body ...] (vars) ctx' l-expr + uncons nip swap lisp-ctx-eval-list // [_ body ...] (vars) (arg-vals) + match-arg-list not abort"invalid arguments to lambda" // [_ body ...] ((var arg)...) + over third extend-ctx-by-list // [_ body ctx (vars)] ctx'' + swap second swap lisp-ctx-eval-list-last + } 3 -roll 4 tuple +} : make-lambda +{ make-lambda } `lambda lisp-lazy-primitive +// (a e) ctx -- more sophisticated (define a e) +{ drop uncons swap dup atom? { // (e) a + tuck lisp-create-global-var + swap lisp-dict @ lisp-ctx-eval-list-last swap ! + } { // (e) (a v..) + uncons over atom? not abort"only variables can be define'd" // (e) a (v..) + rot cons over lisp-create-global-var // a ((v..) (e)) h + swap lisp-dict @ make-lambda swap ! + } cond +} `define lisp-lazy-primitive +// ((x e) ..) ctx -- ((x.v) ..) +recursive eval-assign-list +{ over null? { drop } { + swap uncons swap uncons // ctx t x (e) + over atom? not abort"invalid variable name in assignment list" + 3 pick lisp-ctx-eval-list-last // ctx t x v + pair swap rot eval-assign-list cons + } cond +} swap ! +// (((x v) ..) body) ctx -- let construct +{ swap uncons swap 2 pick eval-assign-list // ctx body ((x v)...) + rot extend-ctx-by-list lisp-ctx-eval-list-last +} `let lisp-lazy-primitive +// ((x e) ..) ctx -- ctx' +{ swap { + dup null? { drop true } { + uncons swap uncons // ctx t x (e) + over atom? not abort"invalid variable name in assignment list" + 3 pick lisp-ctx-eval-list-last // ctx t x v + box pair rot cons swap false + } cond } until +} : compute-let*-ctx +// (((x v) ..) body) ctx -- let* construct +{ swap uncons swap rot compute-let*-ctx lisp-ctx-eval-list-last +} `let* lisp-lazy-primitive +// ((x e) ..) ctx -- ((h e) ..) ctx' , with x bound to h in ctx' +recursive prepare-letrec-ctx { + over null? { + swap uncons swap uncons swap // ctx t (e) x + hole tuck pair swap rot cons // ctx t (x.h) (h e) + 3 -roll rot cons prepare-letrec-ctx // (h e) t ctx' + -rot cons swap + } ifnot +} swap ! +// (((x v) ..) body) ctx -- letrec construct +{ swap uncons swap rot prepare-letrec-ctx swap { // body ctx' ((h e)..) + dup null? { drop true } { + uncons -rot uncons 2 pick lisp-ctx-eval-list-last // body t ctx' h v + swap ! swap false + } cond } until + lisp-ctx-eval-list-last +} `letrec lisp-lazy-primitive +// (e (p e)...) ctx -- match construct +{ swap uncons swap 2 pick lisp-ctx-eval swap { // ctx v ((p e)..) + dup null? { drop 2drop no-answer true } { + uncons swap uncons swap 3 pick // ctx v t e p v + match-arg-list { // ctx v t e ((x' . v')...) + 2swap 2drop rot extend-ctx-by-list lisp-ctx-eval-list-last true } { + 2drop false + } cond } cond } until +} `match lisp-lazy-primitive +// +lisp-dict @ constant original-lisp-dict +{ original-lisp-dict lisp-dict ! } : reset-lisp +{ ' drop { lisp-eval .l cr } List-generic( } :_ LISP-EVAL-PRINT( +// LISP-EVAL-PRINT((+ 3 4) (* 5 6)) computes and prints 12 and 30 +{ hole dup 1 { @ nip } does swap + 1 { swap lisp-eval swap ! } does + List-generic( +} :_ LISP-EVAL( +// LISP-EVAL((+ 3 4) (* 5 6)) computes 12 and 30, returns only 30 +// /* +LISP-EVAL-PRINT( + (define succ (lambda (x) (+ x 1))) + (define (twice f) (lambda (x) (f (f x)))) + (define (fact n) (if (= n 0) 1 (* n (fact (- n 1))))) + (fact ((twice succ) 5)) + (define compare (lambda (x y) (cond ((< x y) 'less) ((= x y) 'equal) (else 'greater)))) + (compare 2 3) + (compare 7 (+ 2 3)) + (define next (let ((cnt 0)) (lambda () (set! cnt (+ cnt 1)) cnt))) + (list (next) (next)) + (define new-counter (lambda () (let ((x 0)) (lambda () (set! x (+ x 1)) x)))) + (define c1 (new-counter)) + (define c2 (new-counter)) + (list (c1) (c1) (c2) (c1) (c2) (c1) (c1) (c2) (c2)) + (let* ((x (+ 2 3)) (y (* x x)) (z (+ x y))) (list x y z)) + (letrec ((even? (lambda (n) (if (= n 0) #t (odd? (- n 1))))) + (odd? (lambda (n) (if (= n 0) #f (even? (- n 1)))))) + (even? 88)) + (define (len l) (if (null? l) 0 (+ 1 (len (cdr l))))) + (len '(2 3 9)) + (define (len2 l) (match l (() 0) ((x . t) (+ 1 (len2 t))))) + (len2 '(2 3 9)) + (define (foo x) (match x + (('zero) 0) + (('succ x) (+ (foo x) 1)) + (('plus x y) (+ (foo x) (foo y))) + (('minus x y) (- (foo x) (foo y))) + (x x))) + (foo '(plus (succ (zero)) (minus (succ (succ 5)) 3))) + (define (bar x) (match x + (['zero] 0) + (['succ x] (+ (bar x) 1)) + (['plus x y] (+ (bar x) (bar y))) + (['minus x y] (- (bar x) (bar y))) + (['const x] x))) + (bar '[plus [succ [zero]] [minus [succ [succ [const 5]]] [const 3]]]) + (define (map f l) (letrec + ((map-f (lambda (l) (match l + (() ()) + ((h . t) (cons (f h) (map-f t))))))) + (map-f l))) + (map (lambda (x) (* x (+ 2 x))) '(2 3 9)) + (define (make-promise proc) (let ((result-ready? #f) (result #f)) + (lambda () + (if result-ready? result + (let ((x (proc))) + (if result-ready? result + (begin (set! result x) (set! result-ready? #t) result))))))) + (define (force promise) (promise)) +) +// */ +// words for invoking Lisp definitions from Fift +// (args) def -- val +{ null rot map-quote cons lisp-dict @ rot run-definition +} : invoke-lisp-definition +{ atom lisp-dict-lookup 1 { @ invoke-lisp-definition } +} : (invoke-lisp) +{ bl word (invoke-lisp) } :: invoke-lisp +// ( 2 3 ) invoke-lisp compare .l +{ atom lisp-dict-lookup 2 { @ mklist-1 invoke-lisp-definition } +} : (invoke-lisp-fixed) +{ bl word (invoke-lisp-fixed) } :: invoke-lisp-fixed +// 9 8 2 invoke-lisp-fixed compare .l +{ bl word (invoke-lisp) does } : make-lisp-invoker +{ bl word (invoke-lisp-fixed) does } : make-lisp-fixed-invoker +// 2 make-lisp-fixed-invoker compare : compare +// 3 9 compare +// import Lisp definitions as Fift words +{ bl word dup (invoke-lisp) does swap 0 (create) } : import-lisp +{ bl word tuck (invoke-lisp-fixed) does swap 0 (create) } : import-lisp-fixed +// 1 import-lisp-fixed fact +// 7 fact . diff --git a/src/test/fuzzer/src/minimal-fc-stdlib/fift-lib/Lists.fif b/src/test/fuzzer/src/minimal-fc-stdlib/fift-lib/Lists.fif new file mode 100644 index 0000000000..b59e40a0d9 --- /dev/null +++ b/src/test/fuzzer/src/minimal-fc-stdlib/fift-lib/Lists.fif @@ -0,0 +1,220 @@ +library Lists // List utilities +// +{ hole dup 1 { @ execute } does create } : recursive +// x x' -- ? recursively compares two S-expressions +recursive equal? { + dup tuple? { + over tuple? { + over count over count over = { // t t' l ? + 0 { dup 0>= { 2dup [] 3 pick 2 pick [] equal? { 1+ } { drop -1 } cond + } if } rot times + nip nip 0>= + } { drop 2drop false } cond + } { 2drop false } cond + } { eqv? } cond +} swap ! +// (a1 .. an) -- (an .. a1) +{ null swap { dup null? not } { uncons swap rot cons swap } while drop } : list-reverse +// (a1 .. an) -- an Computes last element of non-empty list l +{ { uncons dup null? { drop true } { nip false } cond } until } : list-last +// l l' -- l++l' Concatenates two lists +recursive list+ { + over null? { nip } { swap uncons rot list+ cons } cond +} swap ! +// l l' -- l'' -1 or 0, where l = l' ++ l'' +// Removes prefix from list +{ { dup null? { drop true true } { + swap dup null? { 2drop false true } { // l' l + uncons swap rot uncons -rot equal? { false } { + 2drop false true + } cond } cond } cond } until +} : list- +// (a1 .. an) -- a1 .. an n Explodes a list +{ 0 { over null? not } { swap uncons rot 1+ } while nip } : explode-list +// (a1 .. an) x -- a1 .. an n x Explodes a list under the topmost element +{ swap explode-list dup 1+ roll } : explode-list-1 +// l -- t Transforms a list into a tuple with the same elements +{ explode-list tuple } : list>tuple +// a1 ... an n x -- (a1 .. an) x +{ null swap rot { -rot cons swap } swap times } : mklist-1 +// (s1 ... sn) -- s1+...+sn Concatenates a list of strings +{ "" { over null? not } { swap uncons -rot $+ } while nip +} : concat-string-list +// (x1 ... xn) -- x1+...+xn Sums a list of integers +{ 0 { over null? not } { swap uncons -rot + } while nip +} : sum-list +// (a1 ... an) a e -- e(...e(e(a,a1),a2),...),an) +{ -rot { over null? not } { swap uncons -rot 3 pick execute } while nip nip +} : foldl +// (a1 ... an) e -- e(...e(e(a1,a2),a3),...),an) +{ swap uncons swap rot foldl } : foldl-ne +// (a1 ... an) a e -- e(a1,e(a2,...,e(an,a)...)) +recursive foldr { + rot dup null? { 2drop } { + uncons -rot 2swap swap 3 pick foldr rot execute + } cond +} swap ! +// (a1 ... an) e -- e(a1,e(a2,...,e(a[n-1],an)...)) +recursive foldr-ne { + over cdr null? { drop car } { + swap uncons 2 pick foldr-ne rot execute + } cond +} swap ! +// (l1 ... ln) -- l1++...++ln Concatenates a list of lists +{ dup null? { ' list+ foldr-ne } ifnot } : concat-list-lists +// (a1 .. an . t) n -- t Computes the n-th tail of a list +{ ' cdr swap times } : list-tail +// (a0 .. an ..) n -- an Computes the n-th element of a list +{ list-tail car } : list-ref +// l -- ? +{ { dup null? { drop true true } { + dup pair? { cdr false } { + drop false true + } cond } cond } until +} : list? +// l -- n +{ 0 { over null? not } { 1+ swap uncons nip swap } while nip +} : list-length +// l e -- t // returns tail of l after first member that satisfies e +{ swap { + dup null? { nip true } { + tuck car over execute { drop true } { + swap cdr false + } cond } cond } until +} : list-tail-from +// a l -- t // tail of l after first occurence of a using eq? +{ swap 1 ' eq? does list-tail-from } : list-member-eq +{ swap 1 ' eqv? does list-tail-from } : list-member-eqv +{ swap 1 ' equal? does list-tail-from } : list-member-equal +// a l -- ? +{ list-member-eq null? not } : list-member? +{ list-member-eqv null? not } : list-member-eqv? +// l -- a -1 or 0 // returns car l if l is non-empty +{ dup null? { drop false } { car true } cond +} : safe-car +{ dup null? { drop false } { car second true } cond +} : get-first-value +// l e -- v -1 or 0 +{ list-tail-from safe-car } : assoc-gen +{ list-tail-from get-first-value } : assoc-gen-x +// a l -- (a.v) -1 or 0 -- returns first entry (a . v) in l +{ swap 1 { swap first eq? } does assoc-gen } : assq +{ swap 1 { swap first eqv? } does assoc-gen } : assv +{ swap 1 { swap first equal? } does assoc-gen } : assoc +// a l -- v -1 or 0 -- returns v from first entry (a . v) in l +{ swap 1 { swap first eq? } does assoc-gen-x } : assq-val +{ swap 1 { swap first eqv? } does assoc-gen-x } : assv-val +{ swap 1 { swap first equal? } does assoc-gen-x } : assoc-val +// (a1 .. an) e -- (e(a1) .. e(an)) +recursive list-map { + over null? { drop } { + swap uncons -rot over execute -rot list-map cons + } cond +} swap ! + +variable ctxdump variable curctx +// (a1 .. an) e -- executes e for a1, ..., an +{ ctxdump @ curctx @ ctxdump 2! curctx 2! + { curctx 2@ over null? not } { swap uncons rot tuck curctx 2! execute } + while 2drop ctxdump 2@ curctx ! ctxdump ! +} : list-foreach +forget ctxdump forget curctx + +// +// Experimental implementation of `for` loops with index +// +variable loopdump variable curloop +{ curloop @ loopdump @ loopdump 2! } : push-loop-ctx +{ loopdump 2@ loopdump ! curloop ! } : pop-loop-ctx +// ilast i0 e -- executes e for i=i0,i0+1,...,ilast-1 +{ -rot 2dup > { + push-loop-ctx { + triple dup curloop ! first execute curloop @ untriple 1+ 2dup <= + } until pop-loop-ctx + } if 2drop drop +} : for +// ilast i0 e -- same as 'for', but pushes current index i before executing e +{ -rot 2dup > { + push-loop-ctx { + triple dup curloop ! untriple nip swap execute curloop @ untriple 1+ 2dup <= + } until pop-loop-ctx + } if 2drop drop +} : for-i +// ( -- i ) Returns innermost loop index +{ curloop @ third } : i +// ( -- j ) Returns outer loop index +{ loopdump @ car third } : j +{ loopdump @ cadr third } : k +forget curloop forget loopdump + +// +// create Lisp-style lists using words "(" and ")" +// +variable ') +'nop box constant ', +{ ") without (" abort } ') ! +{ ') @ execute } : ) +anon constant dot-marker +// m x1 ... xn t m -- (x1 ... xn . t) +{ swap + { -rot 2dup eq? not } + { over dot-marker eq? abort"invalid dotted list" + swap rot cons } while 2drop +} : list-tail-until-marker +// m x1 ... xn m -- (x1 ... xn) +{ null swap list-tail-until-marker } : list-until-marker +{ over dot-marker eq? { nip 2dup eq? abort"invalid dotted list" } + { null swap } cond + list-tail-until-marker +} : list-until-marker-ext +{ ') @ ', @ } : ops-get +{ ', ! ') ! } : ops-set +{ anon dup ops-get 3 { ops-set list-until-marker-ext } does ') ! 'nop ', ! +} : ( +// test of Lisp-style lists +// ( 42 ( `+ 9 ( `* 3 4 ) ) "test" ) .l cr +// ( `eq? ( `* 3 4 ) 3 4 * ) .l cr +// `alpha ( `beta `gamma `delta ) cons .l cr +// { ( `eq? ( `* 3 5 pick ) 3 4 roll * ) } : 3*sample +// 17 3*sample .l cr + +// similar syntax _( x1 .. xn ) for tuples +{ 2 { 1+ 2dup pick eq? } until 3 - nip } : count-to-marker +{ count-to-marker tuple nip } : tuple-until-marker +{ anon dup ops-get 3 { ops-set tuple-until-marker } does ') ! 'nop ', ! } : _( +// test of tuples +// _( _( 2 "two" ) _( 3 "three" ) _( 4 "four" ) ) .dump cr + +// pseudo-Lisp tokenizer +"()[]'" 34 hold constant lisp-delims +{ lisp-delims 11 (word) } : lisp-token +{ null cons `quote swap cons } : do-quote +{ 1 { ', @ 2 { 2 { ', ! execute ', @ execute } does ', ! } + does ', ! } does +} : postpone-prefix +{ ', @ 1 { ', ! } does ', ! } : postpone-', +( `( ' ( pair + `) ' ) pair + `[ ' _( pair + `] ' ) pair + `' ' do-quote postpone-prefix pair + `. ' dot-marker postpone-prefix pair + `" { char " word } pair + `;; { 0 word drop postpone-', } pair +) constant lisp-token-dict +variable eol +{ eol @ eol 0! anon dup ') @ 'nop 3 + { ops-set list-until-marker-ext true eol ! } does ') ! rot ', ! + { lisp-token dup (number) dup { roll drop } { + drop atom dup lisp-token-dict assq { nip second execute } if + } cond + ', @ execute + eol @ + } until + -rot eol ! execute +} :_ List-generic( +{ 'nop 'nop List-generic( } :_ LIST( +// LIST((lambda (x) (+ x 1)) (* 3 4)) +// LIST('(+ 3 4)) +// LIST(2 3 "test" . 9) +// LIST((process '[plus 3 4])) diff --git a/src/test/fuzzer/src/minimal-fc-stdlib/fift-lib/Stack.fif b/src/test/fuzzer/src/minimal-fc-stdlib/fift-lib/Stack.fif new file mode 100644 index 0000000000..c7ef6f8e58 --- /dev/null +++ b/src/test/fuzzer/src/minimal-fc-stdlib/fift-lib/Stack.fif @@ -0,0 +1,266 @@ +library Stack // advanced stack manupulation library +"Lists.fif" include +// S(a b c - a c 2 a b) would compile to code performing the requested stack manipulation + +// interface to low-level stack manipulation primitives +{ (number) 1- abort"index expected" dup 0 < over 255 > or + abort"index 0..255 expected" +} : (idx) +// push(n) : a0 .. an - a0 .. an a0 equivalent to "n pick" +// push(0) = dup, push(1) = over +{ 0 char ) word (idx) } ::_ push( +// pop(n) : a0 a1 .. a(n-1) an - an a1 .. a(n-1) +// pop(0) = drop, pop(1) = nip +{ 0 char ) word (idx) } ::_ pop( +// xchg(i,j) : equivalent to "i j exch2" +{ 0 char , word (idx) char ) word (idx) } ::_ xchg( +// xchg0(i) : equivalent to "i exch" or "xchg(0,i)" +// xchg0(1) = swap +{ 0 char ) word (idx) 0 } ::_ xchg0( +forget (idx) + +// parser for stack notation expressions +")" 34 hold +" -" constant stk-delims +anon constant stk-start +anon constant stk-to +variable stk-mode +{ stk-delims 11 (word) } : stk-token +'nop : mk-lit +// stk-start vn ... v0 -- stk-start ... v0 i where v[i]=v0 +{ 0 { + 1+ 2dup 2+ pick dup stk-start eq? { 2drop drop 0 true } { eqv? } cond + } until +} : stk-lookup +// stk-start a1 .. an stk-to b1 .. bm -- [a1 .. an] [b1 .. bm] +{ stk-mode @ 0= abort"identifier expected" } : chk-lit +{ stk-to list-until-marker stk-mode ! + stk-start list-until-marker stk-mode @ + stk-mode 0! +} : build-stk-effect +{ stk-start stk-mode 0! { + stk-token dup ")" $= { drop true } { + dup "-" $= { + drop stk-mode @ abort"duplicate -" true stk-mode ! stk-to false } { + dup 34 chr $= { chk-lit drop char " word mk-lit false } { + dup (number) ?dup { chk-lit 1- { swap mk-lit -rot } if mk-lit nip false } { + atom dup `_ eq? { stk-mode @ abort"identifier expected" false } { + stk-lookup 0= stk-mode @ = { + stk-mode @ { atom>$ +" -?" } { atom>$ +" redefined" } cond abort } { + false + } cond } cond } cond } cond } cond } cond } until + stk-mode @ 0= abort"'-' expected" + build-stk-effect +} :_ parse-stk-list( + +// stack operation list construction +variable op-rlist +{ op-rlist null! } : clear-op-list +{ op-rlist @ list-reverse } : get-op-list +{ op-rlist @ cons op-rlist ! } : issue-op +{ minmax `xchg -rot triple } : op-xchg +{ `push swap pair } : op-push +{ `lit swap pair } : op-lit +{ `pop swap pair } : op-pop +0 op-pop constant op-drop +{ 2dup <> { op-xchg issue-op } if } : issue-xchg +{ op-push issue-op } : issue-push +{ op-lit issue-op } : issue-lit +{ op-pop issue-op } : issue-pop +{ op-drop issue-op } : issue-drop +{ ' issue-drop swap times } : issue-drop-# + +// emulated stack contents +variable emul-stk +{ emul-stk @ count } : emul-depth +{ emul-depth 1- swap - } : adj-i +{ emul-depth 1- tuck swap - swap rot - swap } : adj-ij +// i j -- +{ adj-ij 2dup emul-stk @ tuck swap [] swap rot [] rot // i sj si j + emul-stk @ -rot []= swap rot []= emul-stk ! +} : emul-xchg +{ emul-stk @ tpop drop emul-stk ! } : emul-drop +// i -- +{ 0 emul-xchg emul-drop } : emul-pop +// i -- s[i] +{ emul-stk @ swap [] } : emul-stk[] +// i -- si +{ adj-i emul-stk[] } : emul-get +{ 0 emul-get } : emul-tos +// v i -- ? Check whether s[i]=v +{ dup emul-depth < { emul-stk[] eqv? } { 2drop false } cond } : emul[]-eq? +// v -- i or -1 Returns maximum i with s[i]=v +{ emul-stk @ dup count { // v s i + ?dup 0= { -1 true } { 1- 2dup [] 3 pick eqv? } cond // v s i' ? + } until nip nip +} : emul-stk-lookup-rev +// i -- +{ emul-get emul-stk @ swap , emul-stk ! } : emul-push +{ emul-stk @ swap , emul-stk ! } : emul-lit +// show emulated stack contents similarly to .s +{ emul-stk @ explode dup 1 reverse ' .l swap times cr } : .e + +// both issue an operation and emulate it +{ 2dup issue-xchg emul-xchg } : issue-emul-xchg +{ dup issue-push emul-push } : issue-emul-push +{ dup issue-lit emul-lit } : issue-emul-lit +{ dup issue-pop emul-pop } : issue-emul-pop +{ issue-drop emul-drop } : issue-emul-drop +{ ' issue-emul-drop swap times } : issue-emul-drop-# + +// b.. s -- b.. s moves tos value to stk[s] +{ dup emul-stk[] 2 pick cdr list-member-eqv? { + dup adj-i 0 issue-emul-xchg } { dup adj-i issue-emul-pop } cond +} : move-tos-to + +// new s -- ops registered +{ { over null? not } { + // .sl .e get-op-list .l cr + // get-op-list list-length 100 > abort"too long" + emul-depth over > + { over emul-tos swap list-member-eqv? not } { false } cond { + // b.. s tos unneeded + issue-emul-drop } { + over car // b.. s b1 + 2dup swap emul[]-eq? { drop swap cdr swap 1+ } { + dup emul-stk-lookup-rev // b.. s b1 i + dup 0< { // b.. s b1 i not found, must be a literal + drop dup atom? abort"unavailable value" + issue-emul-lit } { + dup 3 pick < { // b.. s b1 i found in bottom s stack values + nip adj-i issue-emul-push // b.. s + dup emul-depth 1- < { move-tos-to } if + } { + emul-depth 1- over = { // b.. s b1 i found in tos + 2drop move-tos-to + } { // b.. s b1 i + nip over adj-ij issue-emul-xchg + } cond } cond } cond } cond } cond } while + nip emul-depth swap - issue-emul-drop-# +} : generate-reorder-ops + +// old new -- op-list +{ emul-stk @ op-rlist @ 2swap + swap list>tuple emul-stk ! clear-op-list + 0 generate-reorder-ops get-op-list + -rot op-rlist ! emul-stk ! +} : generate-reorder +{ parse-stk-list( generate-reorder } :_ SG( + +// op-list rewriting according to a ruleset +// l f l1 l2 -- l' -1 or l f with l' = l2 + (l - l1) +{ push(3) rot list- { list+ nip nip true } { drop } cond +} : try-rule +// l f ll -- l' -1 or l f +{ { dup null? not } { uncons 3 -roll unpair try-rule rot } while drop +} : try-ruleset +// l ll -- l' +{ swap { over false swap try-ruleset 0= } until nip +} : try-ruleset* +// l ruleset -- l' +recursive try-ruleset*-everywhere { + tuck try-ruleset* dup null? { nip } { + uncons rot try-ruleset*-everywhere cons } cond +} swap ! +LIST( + [([xchg 0 1] [xchg 0 2]) ([rot])] + [([xchg 0 1] [xchg 1 2]) ([-rot])] + [([xchg 0 2] [xchg 1 2]) ([rot])] + [([xchg 0 2] [xchg 0 1]) ([-rot])] + [([xchg 1 2] [xchg 0 1]) ([rot])] + [([xchg 1 2] [xchg 0 2]) ([-rot])] + [([xchg 0 1] [rot]) ([xchg 0 2])] + [([-rot] [xchg 0 1]) ([xchg 0 2])] + [([xchg 0 2] [xchg 1 3]) ([2swap])] + [([xchg 1 3] [xchg 0 2]) ([2swap])] + [([push 1] [push 1]) ([2dup])] + [([push 3] [push 3]) ([2over])] + [([pop 0] [pop 0]) ([2drop])] + [([pop 1] [pop 0]) ([2drop])] + [([xchg 0 1] [push 1]) ([tuck])] + [([rot] [-rot]) ()] + [([-rot] [rot]) ()] +) constant fift-stack-ruleset +{ fift-stack-ruleset try-ruleset*-everywhere } : fift-ops-rewrite +{ SG( fift-ops-rewrite } :_ SGF( + +// helpers for creating Fift source strings for one fift-op +// i j -- s +{ minmax over { "xchg(" rot (.) $+ +"," swap (.) $+ +")" } + { nip dup 1 = { drop "swap" } { + ?dup { "xchg0(" swap (.) $+ +")" } { "" } cond + } cond } cond +} : source- +// i -- s +{ dup 1 = { drop "over" } { + ?dup { "push(" swap (.) $+ +")" } { "dup" } cond + } cond +} : source- +// i -- s +{ dup 1 = { drop "nip" } { + ?dup { "pop(" swap (.) $+ +")" } { "drop" } cond + } cond +} : source- +// lit -- s +{ dup string? { char " chr swap $+ char " hold } { (.) } cond +} : source- + +// dictionary with all fift op compilation/source creation +{ 0 swap (compile) } : fop-compile +( _( `xchg 2 { fop-compile } { source- swap cons } ) + _( `push 1 { fop-compile } { source- swap cons } ) + _( `pop 1 { fop-compile } { source- swap cons } ) + _( `lit 1 { 1 'nop (compile) } { source- swap cons } ) + _( `rot 0 { ' rot fop-compile } { "rot" swap cons } ) + _( `-rot 0 { ' -rot fop-compile } { "-rot" swap cons } ) + _( `tuck 0 { ' tuck fop-compile } { "tuck" swap cons } ) + _( `2swap 0 { ' 2swap fop-compile } { "2swap" swap cons } ) + _( `2drop 0 { ' 2drop fop-compile } { "2drop" swap cons } ) + _( `2dup 0 { ' 2dup fop-compile } { "2dup" swap cons } ) + _( `2over 0 { ' 2over fop-compile } { "2over" swap cons } ) +) box constant fift-op-dict + +{ dup atom? { atom>$ } { drop "" } cond + "unknown operation " swap $+ abort +} : report-unknown-op +variable 'fop-entry-exec +// process fift-op according to 'fop-entry-exec +// ... op - ... +{ dup first dup fift-op-dict @ assq { report-unknown-op } ifnot + dup second 1+ push(3) count <> abort"incorrect param count" + nip swap explode dup roll drop 1- roll // o2 .. on entry + 'fop-entry-exec @ execute +} : process-fift-op + +// compile op-list into Fift wordlist +// wl op-list -- wl' +{ { third execute } 'fop-entry-exec ! + swap ' process-fift-op foldl } : compile-fift-op* +// op-list -- e +{ fift-ops-rewrite ({) swap compile-fift-op* (}) } : ops>wdef + +// S( - ) compiles a "word" performing required action +{ SG( ops>wdef 0 swap } ::_ S( +// 1 2 3 S(a b c - c a b a) .s would print 3 1 2 1 + +// transform op-list into Fift source +// ls op -- ls' +{ fift-ops-rewrite + { 3 [] execute } 'fop-entry-exec ! + null ' process-fift-op foldl + dup null? { drop "" } { { +" " swap $+ } foldr-ne } cond +} : ops>$ +{ SG( ops>$ 1 'nop } ::_ $S( +{ SG( ops>$ type } :_ .$S( +// $S(a b c - b c a c a c) => string "rot 2dup over" +// S(a b c - b c a c a c) => compile/execute block { rot 2dup over } +// $S(_ x y _ - y x) => string "drop pop(2)" +// .$S(x1 x2 - 17 x1) => print string "drop 17 swap" + +// simplify/transform sequences of stack manipulation operations +LIST(. [a b c d e f g h i j]) constant std-stack +{ stk-start std-stack explode drop stk-to std-stack explode drop +} : simplify<{ +{ build-stk-effect generate-reorder ops>$ } : }>stack +// simplify<{ drop drop over over -13 }>stack => string "2drop 2dup -13" +// simplify<{ 17 rot }>stack => string "swap 17 swap" +// simplify<{ 5 1 reverse }>stack => string "xchg(1,5) xchg(2,4)" diff --git a/src/test/fuzzer/src/minimal-fc-stdlib/fift-lib/TonUtil.fif b/src/test/fuzzer/src/minimal-fc-stdlib/fift-lib/TonUtil.fif new file mode 100644 index 0000000000..f31b591eb3 --- /dev/null +++ b/src/test/fuzzer/src/minimal-fc-stdlib/fift-lib/TonUtil.fif @@ -0,0 +1,381 @@ +library TonUtil // TON Blockchain Fift Library +"Lists.fif" include + +-1 constant Masterchain +0 constant Basechain + +// parse workchain id +// ( S -- workchain ) +{ (number) 1- abort"workchain id must be an integer" + dup 32 fits not abort"workchain id must fit in 32 bits" +} : parse-workchain-id + +{ (number) 1- abort"integer expected" } : parse-int + +{ over null? ' swap if drop } : replace-if-null + +// Private key load/generate +// ( fname -- pubkey privkey ) +{ dup ."Loading private key from file " type cr + file>B dup Blen 32 <> abort"Private key must be exactly 32 bytes long" + dup priv>pub swap +} : load-keypair +// ( fname -- pubkey privkey ) +{ dup file-exists? + { load-keypair } + { dup newkeypair swap rot over swap B>file + rot ."Saved new private key to file " type cr + } cond +} : load-generate-keypair + +// Parse smart-contract address +// ( S -- workchain addr bounce? ) +{ $>smca not abort"invalid smart-contract address" + 1 and 0= +} : parse-smc-addr + +// ( x -- ) Displays a 64-digit hex number +{ 64 0x. } : 64x. +{ 64 0X. } : 64X. +// ( wc addr -- ) Show address in : form +{ swap ._ .":" 64x. } : .addr +// ( wc addr flags -- ) Show address in base64url form +{ smca>$ type } : .Addr +// ( wc addr fname -- ) Save address to file in 36-byte format +{ -rot 256 u>B swap 32 i>B B+ swap B>file } : save-address +// ( wc addr fname -- ) Save address and print message +{ dup ."(Saving address to file " type .")" cr save-address +} : save-address-verbose + +// ( fname -- wc addr ) Load address from file +{ file>B 32 B| + dup Blen { 32 B>i@ } { drop Basechain } cond + swap 256 B>u@ +} : load-address +// ( fname -- wc addr ) Load address from file and print message +{ dup ."(Loading address from file " type .")" cr load-address +} : load-address-verbose +// Parse string as address or load address from file (if string is prefixed by @) +// ( S default-bounce -- workchain addr bounce? ) +{ over $len 0= abort"empty smart-contract address" + swap dup 1 $| swap "@" $= + { nip load-address rot } { drop nip parse-smc-addr } cond +} : parse-load-address + +// ( hex-str -- addr ) Parses ADNL address +{ dup $len 64 <> abort"ADNL address must consist of exactly 64 hexadecimal characters" + (hex-number) 1 <> abort"ADNL address must consist of 64 hexadecimal characters" + dup 256 ufits not abort"invalid ADNL address" +} : parse-adnl-address + +// ( b wc addr -- b' ) Serializes address into Builder b +{ -rot 8 i, swap 256 u, } : addr, +{ over 8 fits { rot b{100} s, -rot addr, } { + rot b{110} s, 256 9 u, rot 32 i, swap 256 u, } cond +} : Addr, + +// Gram utilities +1000000000 constant Gram +{ Gram swap */r } : Gram*/ +{ Gram * } : Gram* +{ (number) dup { 1- ' Gram*/ ' Gram* cond true } if +} : $>GR? +// ( S -- nanograms ) +{ $>GR? not abort"not a valid Gram amount" +} : $>GR +{ bl word $>GR 1 'nop } ::_ GR$ +// ( nanograms -- S ) +{ dup abs <# ' # 9 times char . hold #s rot sign #> +nip -trailing0 } : (.GR) +{ (.GR) ."GR$" type } : .GR_ +{ .GR_ space } : .GR + +// b x -- b' ( serializes a Gram amount ) +{ -1 { 1+ 2dup 8 * ufits } until + rot over 4 u, -rot 8 * u, } : Gram, +// s -- x s' ( deserializes a Gram amount ) +{ 4 u@+ swap 8 * u@+ } : Gram@+ +// s -- x +{ 4 u@+ swap 8 * u@ } : Gram@ + +// currency collections +// b x --> b' ( serializes a VarUInteger32 ) +{ -1 { 1+ 2dup 8 * ufits } until + rot over 5 u, -rot 8 * u, } : VarUInt32, +// s --> x ( deserializes a VarUInteger32 ) +{ 5 u@+ swap 8 * u@ } : VarUInt32@ +32 constant cc-key-bits +' VarUInt32, : val, +' VarUInt32@ : val@ +// d k v -- d' +{ cc +{ dup null? { ."(null)" drop } { val@ ._ } cond } dup : .maybeVarUInt32 : .val +{ swap cc-key-bits { rot { ."+" } if .val ."*$" ._ true true } idictforeach drop } : (.cc) +{ false (.cc) { ."0" } ifnot } : .cc_ +{ .cc_ space } : .cc +{ true (.cc) drop } : .+cc_ +{ .+cc_ space } : .+cc +{ cc-key-bits { rot . ."-> " swap .val .val ."; " true } dictdiff drop cr } : show-cc-diff +{ cc-key-bits { val@ swap val@ + val, true } dictmerge } : cc+ +{ null swap cc-key-bits { val@ pair swap cons true } idictforeach drop } : cc>list-rev +{ cc>list-rev list-reverse } : cc>list +forget val, forget val@ forget .val + +// ( S -- x -1 or 0 ) +{ (number) dup 2 = { -rot 2drop } if 1 = } : int? +{ int? dup { drop dup 0< { drop false } { true } cond } if } : pos-int? +// ( S -- k v -1 or 0 ) Parses expression * or *$ +{ dup "*" $pos dup 0< { 2drop false } { + $| dup $len 2 < { 2drop false } { + 1 $| nip dup 1 $| swap "$" $= { swap } if drop + int? dup { over 32 fits { 2drop false } ifnot } if + not { drop false } { + swap pos-int? not { drop false } { + true + } cond } cond } cond } cond +} : cc-key-value? +// ( S -- D -1 or 0 ) Parses an extra currency collection +// e.g. "10000*$3+7777*$-11" means "10000 units of currency #3 and 7777 units of currency #-11" +{ dictnew { // S D + swap dup "+" $pos dup 0< { drop null -rot } { $| 1 $| nip -rot } cond + cc-key-value? { +ccpair over null? dup { rot drop true } if } { 2drop false true } cond + } until +} : $>xcc? +{ $>xcc? not abort"invalid extra currency collection" } : $>xcc +{ char } word dup $len { $>xcc } { drop dictnew } cond 1 'nop } ::_ CX{ + +// complete currency collections +{ $>xcc? { true } { drop false } cond } : end-parse-cc +// ( S -- x D -1 or 0 ) Parses a currency collection +// e.g. "1.2+300*$2" means "1200000000ng plus 300 units of currency #2" +{ 0 swap dup "+" $pos dup 0< { drop dup + $>GR? { nip nip dictnew true } { end-parse-cc } cond + } { over swap $| swap $>GR? { 2swap 2drop swap 1 $| nip } { drop + } cond end-parse-cc } cond +} : $>cc? +{ $>cc? not abort"invalid currency collection" } : $>cc +{ char } word dup $len { $>cc } { drop 0 dictnew } cond 2 'nop } ::_ CC{ +// ( x D -- ) +{ swap ?dup { .GR_ .+cc_ } { .cc_ } cond } : .GR+cc_ +{ .GR+cc_ space } : .GR+cc +{ -rot Gram, swap dict, } : Gram+cc, + +// Libraries +// ( -- D ) New empty library collection +' dictnew : Libs{ +// ( D -- D ) Return library collection as dictionary +'nop : }Libs +// ( D c x -- D' ) Add a public/private library c to collection D +{ -rot B, swap ref, + } cond +} swap ! +// b S n -- b' +{ swap $>B swap append-long-bytes } : append-long-string +// S -- c +{ +} : simple-transfer-body + +// ( S -- x ) parse public key +{ dup $len 48 <> abort"public key must be 48 characters long" + base64url>B dup Blen 36 <> abort"public key must be 48 characters long" + 34 B| 16 B>u@ over crc16 <> abort"crc16 mismatch in public key" + 16 B>u@+ 0x3ee6 <> abort"invalid tag in public key" + 256 B>u@ +} : parse-pubkey +{ bl word parse-pubkey 1 'nop } ::_ PK' +// ( x -- S ) serialize public key +{ 256 u>B B{3ee6} swap B+ dup crc16 16 u>B B+ B>base64 } : pubkey>$ +{ pubkey>$ type } : .pubkey + +// ( S -- x ) parse validator-encoded public key +{ base64>B dup Blen 36 <> abort"public key with magic must be 36 bytes long" + 4 B| swap 32 B>u@ 0xC6B41348 <> abort"unknown magic for public key (not Ed25519)" +} : parse-val-pubkey +{ bl word parse-val-pubkey 1 'nop } ::_ VPK' +{ char } word base64>B 1 'nop } ::_ B64{ + +// adnl address parser +{ 256 u>B B{2D} swap B+ dup crc16 16 u>B B+ } : adnl-preconv +{ swap 32 /mod dup 26 < { 65 } { 24 } cond + rot swap hold } : Base32# +{ <# ' Base32# 8 times #> } : Base32#*8 +{ "" over Blen 5 / { swap 40 B>u@+ Base32#*8 nip rot swap $+ } swap times nip } : B>Base32 + +// ( x -- S ) Converts an adnl-address from a 256-bit integer to a string +{ adnl-preconv B>Base32 1 $| nip } : adnl>$ + +{ 65 - dup 0>= { -33 and dup 26 < } { 41 + dup 25 > over 32 < and } cond ?dup nip } : Base32-digit? +{ Base32-digit? not abort"not a Base32 digit" } : Base32-digit +{ 0 { over $len } { swap 1 $| -rot (char) Base32-digit swap 5 << + } while nip } : Base32-number +{ B{} { over $len } { swap 8 $| -rot Base32-number 40 u>B B+ } while nip } : Base32>B + +// ( S -- x ) Converts an adnl address from a string to 256-bit integer +{ dup $len 55 <> abort"not 55 alphanumeric characters" "F" swap $+ Base32>B + 33 B| 16 B>u@ over crc16 <> abort"crc16 checksum mismatch" + 8 B>u@+ 0x2D <> abort"not a valid adnl address" 256 B>u@ } : $>adnl + +{ 65 - dup 0>= { -33 and 10 + dup 16 < } { 17 + dup 0>= over 10 < and } cond ?dup nip } : hex-digit? +// ( S -- x -1 or 0 ) Parses a hexadecimal integer +{ dup $len { + 0 { + 4 << swap 1 $| -rot (char) hex-digit? // S a d -1 or S a 0 + { + over $len 0= } { drop -1 true } cond + } until + dup 0< { 2drop false } { nip true } cond + } { drop false } cond +} : hex$>u? +// ( S -- x ) +{ hex$>u? not abort"not a hexadecimal number" } : hex$>u + +{ dup $len 64 = { hex$>u } { + dup $len 55 = { $>adnl } { + true abort"invalid adnl address" + } cond } cond +} : parse-adnl-addr +{ adnl>$ type } : .adnl +{ bl word parse-adnl-addr 1 'nop } ::_ adnl: + +// ( x a b -- a<=x<=b ) +{ 2 pick >= -rot >= and } : in-range? + +// ( c i -- ? ) Checks whether c is a valid value for config param #i +def? config-valid? { + { nip 0>= { ."warning: cannot check validity of configuration parameter value, use create-state instead of fift to check validity" cr } if + true } : config-valid? +} ifnot + +{ dup -1000 = { drop + { + // anycast_info$_ depth:(#<= 30) { depth >= 1 } + // rewrite_pfx:(bits depth) = Anycast; + 30 u@+ swap // get depth + + dup 1 > { + dup 2 roll swap u@+ // get rewrite_pfx + // return depth, rewrite_pfx, slice + } + { + drop // drop depth (<=1) + 0 0 2 roll // set anycast to none + } cond + } + { + 0 0 2 roll // set anycast to none + } cond +} : maybe-anycast + +// Rewrite first bits of addr with anycast info +{ // input: anycast depth, rewrite_pfx, workchain, slice, address length + 4 -roll + 3 roll dup dup 0 = { 2drop 2 roll drop } + { + rot swap u@+ swap drop + 3 roll + // Get addr: addr_none$00 / addr_extern$01 / addr_std$10 / addr_var$11 + { // if greater that zero + dup 1 > + { + 2 = + { + // if addr_std$10 + // anycast:(Maybe Anycast) + // workchain_id:int8 + // address:bits256 = MsgAddressInt; + maybe-anycast // get anycast depth, bits, slice + 8 i@+ // get workchain + 256 parse-address-with-anycast + `addr-std swap + } + + { + // if addr_var$11 + // anycast:(Maybe Anycast) + // addr_len:(## 9) + // workchain_id:int32 + // address:(bits addr_len) = MsgAddressInt; + maybe-anycast // get anycast depth, bits, slice + 9 u@+ // get addr_len + 32 i@+ // get workchain + swap 2 -roll // move workchain to neede position + swap parse-address-with-anycast + `addr-var swap + } cond + + } + { + drop // drop header (dup for statment upper) + // if addr_extern$01 + // addr_extern$01 len:(## 9) + // external_address:(bits len) + 9 u@+ swap // bit len + u@+ // external_address + `addr-extern swap + } cond + } + { + swap + // if addr_none$00 + `addr-none swap + } cond +} : addr@+ + +{ addr@+ drop } : addr@ + +// User-friendly prints output of addr@ +// (0 A or addr A or wc addr A -- ) +{ + dup `addr-none eq? + { 2drop ."addr_none" } + { + `addr-extern eq? + { (dump) type } + { (x.) swap (dump) ":" $+ swap $+ type } + cond + } + cond +} : print-addr // print addr with workchain + +forget maybe-anycast +forget parse-address-with-anycast diff --git a/src/test/fuzzer/src/minimal-fc-stdlib/stdlib.fc b/src/test/fuzzer/src/minimal-fc-stdlib/stdlib.fc index 10989a9191..29dfb07a09 100644 --- a/src/test/fuzzer/src/minimal-fc-stdlib/stdlib.fc +++ b/src/test/fuzzer/src/minimal-fc-stdlib/stdlib.fc @@ -64,4 +64,8 @@ int cell_hash(cell c) asm "HASHCU"; int slice_hash(slice s) asm "HASHSU"; -int string_hash(slice s) asm "SHA256U"; \ No newline at end of file +int string_hash(slice s) asm "SHA256U"; + +int equal_slices_bits(slice a, slice b) asm "SDEQ"; + +cell my_code() asm "MYCODE"; \ No newline at end of file diff --git a/src/test/fuzzer/src/stdlib.ts b/src/test/fuzzer/src/stdlib.ts index 7c15de2a32..5293c096bb 100644 --- a/src/test/fuzzer/src/stdlib.ts +++ b/src/test/fuzzer/src/stdlib.ts @@ -2,7 +2,7 @@ import type * as Ast from "@/ast/ast"; import { nextId } from "@/test/fuzzer/src/id"; import * as path from "path"; -import files from "@/stdlib/stdlib"; +import { files } from "@/stdlib/stdlib"; import { createVirtualFileSystem } from "@/vfs/createVirtualFileSystem"; import { dummySrcInfoPrintable, diff --git a/src/test/fuzzer/src/util.ts b/src/test/fuzzer/src/util.ts index dae1e66a8d..f00349d5b4 100644 --- a/src/test/fuzzer/src/util.ts +++ b/src/test/fuzzer/src/util.ts @@ -17,7 +17,7 @@ import { idText } from "@/ast/ast-helpers"; import { CompilerContext } from "@/context/context"; import { getParser } from "@/grammar"; import { createVirtualFileSystem } from "@/vfs/createVirtualFileSystem"; -import files from "@/stdlib/stdlib"; +import { files } from "@/stdlib/stdlib"; import { resolveImports } from "@/imports/resolveImports"; import { getRawAST, openContext, parseModules } from "@/context/store"; import type { MakeAstFactory } from "@/ast/generated/make-factory"; @@ -26,7 +26,6 @@ import { getAllTypes } from "@/types/resolveDescriptors"; import { topSortContracts } from "@/pipeline/utils"; import { featureEnable } from "@/config/features"; import { posixNormalize } from "@/utils/filePath"; -import { compile } from "@/pipeline/compile"; import { funcCompile } from "@/func/funcCompile"; import { Logger } from "@/context/logger"; import { beginCell, Cell, contractAddress, TupleBuilder } from "@ton/core"; @@ -39,6 +38,8 @@ import type { TupleItem, } from "@ton/core"; import type { Blockchain, SandboxContract } from "@ton/sandbox"; +import { compileTact } from "@/pipeline/compile"; +import type { BuildContext } from "@/pipeline/build"; export const VALID_ID = /^[a-zA-Z_]+[a-zA-Z_0-9]$/; export const VALID_TYPE_ID = /^[A-Z]+[a-zA-Z_0-9]$/; @@ -400,7 +401,6 @@ export async function buildModule( blockchain: Blockchain, ): Promise>> { let ctx = new CompilerContext(); - const parser = getParser(astF); // We need an entrypoint for precompile, even if it is empty const fileSystem = { [`contracts/empty.tact`]: "", @@ -427,7 +427,7 @@ export async function buildModule( SandboxContract > = new Map(); - ctx = precompile(ctx, project, stdlib, config.path, parser, astF, [ + ctx = precompile(ctx, project, stdlib, config.path, [ module, ...customStdlib.modules, ]); @@ -441,6 +441,24 @@ export async function buildModule( | undefined > = {}; + const logger = new Logger(); + + const compilerInfo: string = JSON.stringify({ + entrypoint: posixNormalize(config.path), + options: {}, + }); + + const bCtx: BuildContext = { + config, + logger, + project, + stdlib, + compilerInfo, + ctx, + built: {}, + errorMessages: [], + }; + const allContracts = getAllTypes(ctx).filter((v) => v.kind === "contract"); // Sort contracts in topological order @@ -453,17 +471,14 @@ export async function buildModule( const contractName = contract.name; // Compiling contract to func - const res = await compile( - ctx, - contractName, - `${config.name}_${contractName}`, - built, - ); - const codeFc = res.output.files.map((v) => ({ - path: posixNormalize(project.resolve(config.output, v.name)), - content: v.code, - })); - const codeEntrypoint = res.output.entrypoint; + const res = await compileTact(bCtx, contractName); + if (!res) { + throw new Error( + "Tact compilation failed. " + + bCtx.errorMessages.map((error) => error.message).join("\n"), + ); + } + const codeEntrypoint = res.entrypointPath; // Compiling contract to TVM const stdlibPath = stdlib.resolve("stdlib.fc"); @@ -472,25 +487,31 @@ export async function buildModule( //const stdlibExCode = stdlib.readFile(stdlibExPath).toString(); process.env.USE_NATIVE = "true"; - process.env.FC_STDLIB_PATH = path.join(__dirname, "/minimal-fc-stdlib/"); - process.env.FUNC_FIFT_COMPILER_PATH = path.join(__dirname, "/minimal-fc-stdlib/funcplusfift"); - process.env.FIFT_LIBS_PATH = ""; + process.env.FC_STDLIB_PATH = path.join( + __dirname, + "/minimal-fc-stdlib/", + ); + process.env.FUNC_FIFT_COMPILER_PATH = path.join( + __dirname, + "/minimal-fc-stdlib/funcplusfift", + ); + process.env.FIFT_LIBS_PATH = path.join( + __dirname, + "/minimal-fc-stdlib/fift-lib/", + ); - const contractFilePath = path.join(__dirname, "/minimal-fc-stdlib/", codeEntrypoint); + const contractFilePath = path.join( + __dirname, + "/minimal-fc-stdlib/", + codeEntrypoint, + ); - fs.writeFileSync( - contractFilePath, - codeFc[0]!.content, - ); + fs.writeFileSync(contractFilePath, res.funcSource.content); const c = await funcCompile({ - entries: [ - stdlibPath, - stdlibExPath, - contractFilePath, - ], + entries: [stdlibPath, stdlibExPath, contractFilePath], sources: [], - logger: new Logger(), + logger, }); if (!c.ok) { diff --git a/src/test/fuzzer/test/expressions/expression.spec.ts b/src/test/fuzzer/test/expressions/expression.spec.ts index 2753a81533..f31849c6fd 100644 --- a/src/test/fuzzer/test/expressions/expression.spec.ts +++ b/src/test/fuzzer/test/expressions/expression.spec.ts @@ -25,7 +25,7 @@ import { GenContext, initializeGenerator, NonTerminal, - Terminal + Terminal, } from "../../src/generators/uniform-expr-gen"; import { bindingsAndExpressionPrtinter, diff --git a/src/test/fuzzer/test/expressions/utils.ts b/src/test/fuzzer/test/expressions/utils.ts index d84db4aefd..11736c7d47 100644 --- a/src/test/fuzzer/test/expressions/utils.ts +++ b/src/test/fuzzer/test/expressions/utils.ts @@ -1,23 +1,24 @@ -import * as Ast from "@/ast/ast"; -import { getMakeAst, MakeAstFactory } from "@/ast/generated/make-factory"; -import { - AllowedTypeEnum, - NonTerminal, - NonTerminalEnum, -} from "../../src/generators/uniform-expr-gen"; +import type * as Ast from "@/ast/ast"; +import type { MakeAstFactory } from "@/ast/generated/make-factory"; +import { getMakeAst } from "@/ast/generated/make-factory"; +import type { AllowedTypeEnum } from "../../src/generators/uniform-expr-gen"; +import { NonTerminal } from "../../src/generators/uniform-expr-gen"; import { GlobalContext } from "../../src/context"; import { Interpreter } from "@/optimizer/interpreter"; import { CompilerContext } from "@/context/context"; -import { AstUtil, getAstUtil } from "@/ast/util"; -import { FactoryAst, getAstFactory } from "@/ast/ast-helpers"; +import type { AstUtil } from "@/ast/util"; +import { getAstUtil } from "@/ast/util"; +import type { FactoryAst } from "@/ast/ast-helpers"; +import { getAstFactory } from "@/ast/ast-helpers"; +import type { CustomStdlib } from "../../src/util"; import { buildModule, - CustomStdlib, filterStdlib, parseStandardLibrary, } from "../../src/util"; import { Blockchain } from "@ton/sandbox"; -import { Sender, toNano } from "@ton/core"; +import type { Sender } from "@ton/core"; +import { toNano } from "@ton/core"; import fc from "fast-check"; import * as fs from "node:fs"; @@ -126,6 +127,8 @@ export async function setupEnvironment(): Promise "context", "myBalance", "nativeReserve", + "toString", + "StringBuilder", //"contractAddress", //"contractAddressExt", //"storeUint", @@ -197,7 +200,7 @@ export async function compileExpression( ); try { - let contractMapPromise = buildModule( + const contractMapPromise = buildModule( astF, contractModule, customStdlib, From 39e43790aa3f83c37e478ae3193975eac2cc2281 Mon Sep 17 00:00:00 2001 From: jeshecdom Date: Thu, 17 Apr 2025 16:34:17 +0200 Subject: [PATCH 41/44] fix: Added nullChecks: true flag, which was causing the discrepancies between command line and build script in fuzzer. --- .../fuzzer/src/generators/uniform-expr-gen.ts | 15 ++++++++++--- src/test/fuzzer/src/util.ts | 21 ++++++++++++++----- .../test/expressions/expression.spec.ts | 2 +- src/test/fuzzer/test/expressions/utils.ts | 9 +++++--- 4 files changed, 35 insertions(+), 12 deletions(-) diff --git a/src/test/fuzzer/src/generators/uniform-expr-gen.ts b/src/test/fuzzer/src/generators/uniform-expr-gen.ts index 29bdb17449..ac6865e73e 100644 --- a/src/test/fuzzer/src/generators/uniform-expr-gen.ts +++ b/src/test/fuzzer/src/generators/uniform-expr-gen.ts @@ -629,6 +629,7 @@ function filterProductions( ): { productions: ExprProduction[][]; nonTerminals: GenericNonTerminal[]; + reindexMap: Map; } { const nonTerminalIdsToInclude: Set = new Set( nonTerminalsToInclude.map((e) => e.id), @@ -715,6 +716,7 @@ function filterProductions( return { productions, nonTerminals, + reindexMap, }; } @@ -1661,8 +1663,8 @@ export function initializeGenerator( maxSize: number, ctx: GenContext, astF: FactoryAst, -): (nonTerminalId: number) => fc.Arbitrary { - const { productions, nonTerminals } = filterProductions( +): (nonTerminal: NonTerminalEnum) => fc.Arbitrary { + const { productions, nonTerminals, reindexMap } = filterProductions( ctx.allowedNonTerminals, ctx.allowedTerminals, ); @@ -1670,7 +1672,14 @@ export function initializeGenerator( const { nonTerminalCounts, sizeSplitCounts, totalCounts } = computeCountTables(minSize, maxSize, productions, nonTerminals); - return (nonTerminalId: number) => { + return (nonTerminal: NonTerminalEnum) => { + const nonTerminalId = reindexMap.get(nonTerminal.id); + if (typeof nonTerminalId === "undefined") { + throw new Error( + `Non-terminal ${nonTerminal.id} does not have a re-indexing`, + ); + } + if (nonTerminals.every((n) => n.id !== nonTerminalId)) { throw new Error( `Non-terminal ${nonTerminalId} is not among the allowed non-terminals`, diff --git a/src/test/fuzzer/src/util.ts b/src/test/fuzzer/src/util.ts index f00349d5b4..284edaa9e4 100644 --- a/src/test/fuzzer/src/util.ts +++ b/src/test/fuzzer/src/util.ts @@ -39,7 +39,7 @@ import type { } from "@ton/core"; import type { Blockchain, SandboxContract } from "@ton/sandbox"; import { compileTact } from "@/pipeline/compile"; -import type { BuildContext } from "@/pipeline/build"; +import { enableFeatures, type BuildContext } from "@/pipeline/build"; export const VALID_ID = /^[a-zA-Z_]+[a-zA-Z_0-9]$/; export const VALID_TYPE_ID = /^[A-Z]+[a-zA-Z_0-9]$/; @@ -400,7 +400,6 @@ export async function buildModule( customStdlib: CustomStdlib, blockchain: Blockchain, ): Promise>> { - let ctx = new CompilerContext(); // We need an entrypoint for precompile, even if it is empty const fileSystem = { [`contracts/empty.tact`]: "", @@ -420,6 +419,15 @@ export async function buildModule( name: "test", path: "contracts/empty.tact", output: ".", + options: { + debug: true, + external: true, + ipfsAbiGetter: false, + interfacesGetter: false, + safety: { + nullChecks: true, + }, + }, }; const contractsToTest: Map< @@ -427,6 +435,11 @@ export async function buildModule( SandboxContract > = new Map(); + const logger = new Logger(); + + let ctx = new CompilerContext(); + ctx = enableFeatures(ctx, logger, config); + ctx = precompile(ctx, project, stdlib, config.path, [ module, ...customStdlib.modules, @@ -441,11 +454,9 @@ export async function buildModule( | undefined > = {}; - const logger = new Logger(); - const compilerInfo: string = JSON.stringify({ entrypoint: posixNormalize(config.path), - options: {}, + options: config.options, }); const bCtx: BuildContext = { diff --git a/src/test/fuzzer/test/expressions/expression.spec.ts b/src/test/fuzzer/test/expressions/expression.spec.ts index f31849c6fd..4bd021c974 100644 --- a/src/test/fuzzer/test/expressions/expression.spec.ts +++ b/src/test/fuzzer/test/expressions/expression.spec.ts @@ -136,7 +136,7 @@ describe("evaluation properties", () => { expressionGenerationIds, generator, ), - generator(NonTerminal.Int.id), + generator(NonTerminal.Int), async (bindings, expr) => { const compilationResult = await compileExpression( expressionTestingEnvironment, diff --git a/src/test/fuzzer/test/expressions/utils.ts b/src/test/fuzzer/test/expressions/utils.ts index 11736c7d47..02a196c77d 100644 --- a/src/test/fuzzer/test/expressions/utils.ts +++ b/src/test/fuzzer/test/expressions/utils.ts @@ -1,7 +1,10 @@ import type * as Ast from "@/ast/ast"; import type { MakeAstFactory } from "@/ast/generated/make-factory"; import { getMakeAst } from "@/ast/generated/make-factory"; -import type { AllowedTypeEnum } from "../../src/generators/uniform-expr-gen"; +import type { + AllowedTypeEnum, + NonTerminalEnum, +} from "../../src/generators/uniform-expr-gen"; import { NonTerminal } from "../../src/generators/uniform-expr-gen"; import { GlobalContext } from "../../src/context"; import { Interpreter } from "@/optimizer/interpreter"; @@ -219,7 +222,7 @@ export async function compileExpression( export function generateBindings( expressionTestingEnvironment: ExpressionTestingEnvironment, expressionGenerationIds: Map, - generator: (nonTerminalId: number) => fc.Arbitrary, + generator: (nonTerminalId: NonTerminalEnum) => fc.Arbitrary, ): fc.Arbitrary { return fc.tuple( ...expressionGenerationIds @@ -240,7 +243,7 @@ export function generateBindings( expressionTestingEnvironment.makeF.makeDummyNull(), ), ) - : generator(initializersMapping[type].id).map((expr) => + : generator(initializersMapping[type]).map((expr) => expressionTestingEnvironment.makeF.makeDummyStatementLet( expressionTestingEnvironment.makeF.makeDummyId( name, From e0904efb128daea3aee88dfc52b18a097a62cb1a Mon Sep 17 00:00:00 2001 From: jeshecdom Date: Wed, 23 Apr 2025 13:54:48 +0200 Subject: [PATCH 42/44] tests: Integrate expression generator with rest of fuzzer. --- src/test/fuzzer/src/context.ts | 14 + src/test/fuzzer/src/generators/constant.ts | 33 +- src/test/fuzzer/src/generators/contract.ts | 30 +- src/test/fuzzer/src/generators/expression.ts | 980 +++--------------- src/test/fuzzer/src/generators/field.ts | 24 +- src/test/fuzzer/src/generators/function.ts | 33 +- src/test/fuzzer/src/generators/generator.ts | 6 - src/test/fuzzer/src/generators/index.ts | 5 +- src/test/fuzzer/src/generators/parameter.ts | 20 +- src/test/fuzzer/src/generators/program.ts | 13 +- src/test/fuzzer/src/generators/receiver.ts | 69 +- src/test/fuzzer/src/generators/statement.ts | 213 ++-- src/test/fuzzer/src/generators/struct.ts | 30 +- src/test/fuzzer/src/generators/trait.ts | 18 +- .../fuzzer/src/generators/uniform-expr-gen.ts | 244 +++-- src/test/fuzzer/src/id.ts | 8 - src/test/fuzzer/src/scope.ts | 46 +- src/test/fuzzer/src/stdlib.ts | 23 +- src/test/fuzzer/src/types.ts | 65 +- src/test/fuzzer/src/util.ts | 17 +- src/test/fuzzer/test/compilation.spec.ts | 113 +- .../test/expressions/expression-stats.ts | 11 +- .../test/expressions/expression.spec.ts | 150 ++- src/test/fuzzer/test/expressions/utils.ts | 13 +- 24 files changed, 761 insertions(+), 1417 deletions(-) delete mode 100644 src/test/fuzzer/src/id.ts diff --git a/src/test/fuzzer/src/context.ts b/src/test/fuzzer/src/context.ts index b2630654e9..622e46b77b 100644 --- a/src/test/fuzzer/src/context.ts +++ b/src/test/fuzzer/src/context.ts @@ -2,6 +2,10 @@ import { prettyPrint } from "@/ast/ast-printer"; import { FuzzConfig } from "@/test/fuzzer/src/config"; import type { AstNode } from "@/ast/ast"; import { stringify } from "@/test/fuzzer/src/util"; +import { getAstFactory } from "@/ast/ast-helpers"; +import type { FactoryAst } from "@/ast/ast-helpers"; +import { getMakeAst } from "@/ast/generated/make-factory"; +import type { MakeAstFactory } from "@/ast/generated/make-factory"; /** * FuzzContext represents a stateful context that handles AST generation. @@ -23,6 +27,16 @@ export class FuzzContext { */ private currentDepth: number = 0; + /** + * The generic AST Factory + */ + public astF: FactoryAst = getAstFactory(); + + /** + * The factory with the makeX methods + */ + public makeF: MakeAstFactory = getMakeAst(this.astF); + constructor() { this.config = new FuzzConfig(); } diff --git a/src/test/fuzzer/src/generators/constant.ts b/src/test/fuzzer/src/generators/constant.ts index 2a5bd1264a..850afdcdd0 100644 --- a/src/test/fuzzer/src/generators/constant.ts +++ b/src/test/fuzzer/src/generators/constant.ts @@ -12,6 +12,7 @@ import type { Scope } from "@/test/fuzzer/src/scope"; import { NamedGenerativeEntity } from "@/test/fuzzer/src/generators/generator"; import fc from "fast-check"; +import { GlobalContext } from "@/test/fuzzer/src/context"; /** * An object that encapsulates a generated Ast.ConstantDecl. @@ -32,14 +33,13 @@ export class ConstantDecl extends NamedGenerativeEntity { private generateImpl( extraAttrs: Ast.ConstantAttribute[], ): fc.Arbitrary { - return fc.record({ - kind: fc.constant("constant_decl"), - id: fc.constant(this.idx), - name: fc.constant(this.name), - type: fc.constant(tyToAstType(this.type)), - attributes: fc.constantFrom(this.getAttributes(extraAttrs)), - loc: fc.constant(dummySrcInfoPrintable), - }); + return fc.constant( + GlobalContext.makeF.makeDummyConstantDecl( + this.getAttributes(extraAttrs), + this.name, + tyToAstType(this.type), + ), + ); } /** @@ -93,15 +93,14 @@ export class ConstantDef extends NamedGenerativeEntity { init?: fc.Arbitrary, ): fc.Arbitrary { const chosenInit = init ?? this.init; - return fc.record({ - kind: fc.constant("constant_def"), - id: fc.constant(this.idx), - name: fc.constant(this.name), - type: fc.constant(tyToAstType(this.type)), - initializer: chosenInit, - attributes: fc.constantFrom(extraAttrs), - loc: fc.constant(dummySrcInfoPrintable), - }); + return chosenInit.map((init) => + GlobalContext.makeF.makeDummyConstantDef( + extraAttrs, + this.name, + tyToAstType(this.type), + init, + ), + ); } /** diff --git a/src/test/fuzzer/src/generators/contract.ts b/src/test/fuzzer/src/generators/contract.ts index 19523c481b..878bbd93ab 100644 --- a/src/test/fuzzer/src/generators/contract.ts +++ b/src/test/fuzzer/src/generators/contract.ts @@ -15,6 +15,7 @@ import { NamedGenerativeEntity } from "@/test/fuzzer/src/generators/generator"; import fc from "fast-check"; import { Field } from "@/test/fuzzer/src/generators/field"; +import { GlobalContext } from "@/test/fuzzer/src/context"; export interface ContractParameters { /** @@ -63,14 +64,14 @@ export class Contract extends NamedGenerativeEntity { if (this.trait !== undefined) { traitFields = this.trait.fieldDeclarations.map(({ type, name }) => { const init = new Expression(this.scope, type, { - compileTimeEval: true, + useIdentifiers: false, }).generate(); return new Field(this.scope, type, init, name).generate(); }); traitConstants = this.trait.constantDeclarations .map((decl) => { const init = new Expression(this.scope, decl.type, { - compileTimeEval: true, + useIdentifiers: false, }).generate(); return decl .createDefinition(init) @@ -117,15 +118,8 @@ export class Contract extends NamedGenerativeEntity { const generatedFields = Array.from(this.scope.getAllNamed("field")).map( (f) => f.generate(), ); - return fc.record({ - kind: fc.constant("contract"), - id: fc.constant(this.idx), - name: fc.constant(this.name), - traits: fc.constant( - this.trait === undefined ? [] : [this.trait.name], - ), - attributes: fc.constantFrom([]), - declarations: fc.tuple( + return fc + .tuple( ...traitConstants, ...generatedConstants, ...traitFields, @@ -134,9 +128,15 @@ export class Contract extends NamedGenerativeEntity { ...traitMethods, ...generatedMethods, ...requestedMethods, - ), - loc: fc.constant(dummySrcInfoPrintable), - params: fc.constant(undefined), - }); + ) + .map((decls) => + GlobalContext.makeF.makeDummyContract( + this.name, + this.trait === undefined ? [] : [this.trait.name], + [], + undefined, + decls, + ), + ); } } diff --git a/src/test/fuzzer/src/generators/expression.ts b/src/test/fuzzer/src/generators/expression.ts index abd959d4b9..99f967362e 100644 --- a/src/test/fuzzer/src/generators/expression.ts +++ b/src/test/fuzzer/src/generators/expression.ts @@ -1,162 +1,63 @@ import type * as Ast from "@/ast/ast"; -import fc from "fast-check"; - -import { - ConstantDecl, - ConstantDef, -} from "@/test/fuzzer/src/generators/constant"; -import { Let, Statement } from "@/test/fuzzer/src/generators/statement"; -import { Field } from "@/test/fuzzer/src/generators/field"; +import type fc from "fast-check"; import { - randomBool, - randomElement, - packArbitraries, generateAstIdFromName, - dummySrcInfoPrintable, + packArbitraries, stringify, } from "@/test/fuzzer/src/util"; import { GenerativeEntity, NamedGenerativeEntity, - GenerativeEntityOpt, } from "@/test/fuzzer/src/generators/generator"; -import { nextId } from "@/test/fuzzer/src/id"; +import { StdlibType } from "@/test/fuzzer/src/types"; +import type { Type } from "@/test/fuzzer/src/types"; +import type { Scope } from "@/test/fuzzer/src/scope"; import { - StdlibType, - tyToString, - tyEq, - UtilType, - throwTyError, - makeFunctionTy, -} from "@/test/fuzzer/src/types"; -import type { StructField, Type } from "@/test/fuzzer/src/types"; + initializeGenerator, + NonTerminal, + Terminal, +} from "@/test/fuzzer/src/generators/uniform-expr-gen"; +import type { + GenInitConfig, + NonTerminalEnum, + TerminalEnum, +} from "@/test/fuzzer/src/generators/uniform-expr-gen"; import { GlobalContext } from "@/test/fuzzer/src/context"; -import type { Scope } from "@/test/fuzzer/src/scope"; -import { FunctionDef } from "@/test/fuzzer/src/generators/function"; -export function generateNumber( - base?: Ast.NumberBase, - constValue?: bigint, -): fc.Arbitrary { - const value = - constValue === undefined ? fc.bigInt() : fc.constantFrom(constValue); - return fc.record({ - kind: fc.constant("number"), - id: fc.constant(nextId()), - value, - loc: fc.constant(dummySrcInfoPrintable), - base: base ? fc.constant(base) : fc.constantFrom(2, 8, 10, 16), - }); -} - -export function generateBoolean( - constValue?: boolean, -): fc.Arbitrary { - const value = - constValue === undefined ? fc.boolean() : fc.constantFrom(constValue); - return fc.record({ - kind: fc.constant("boolean"), - id: fc.constant(nextId()), - value, - loc: fc.constant(dummySrcInfoPrintable), - }); -} - -function generateStringValue( - nonEmpty: boolean = false, - constValue?: string, -): fc.Arbitrary { - return constValue === undefined - ? nonEmpty - ? fc.string({ minLength: 1 }) - : fc.string() - : fc.constantFrom(constValue); -} - -export function generateString( - nonEmpty: boolean = false, - constValue?: string, -): fc.Arbitrary { - return fc.record({ - kind: fc.constant("string"), - id: fc.constant(nextId()), - value: generateStringValue(nonEmpty, constValue), - loc: fc.constant(dummySrcInfoPrintable), - }); -} +export type ExpressionParameters = { + /** + * Indicates whether the generated expression could use identifiers declared in the scope. + * @default true + */ + useIdentifiers: boolean; -export function generateNull(): fc.Arbitrary { - return fc.record({ - kind: fc.constant("null"), - id: fc.constant(nextId()), - loc: fc.constant(dummySrcInfoPrintable), - }); -} + /** + * The minimum expression size. + * @default 1 + */ + minSize: number; -export function generateFieldAccess( - name: string, - aggregate?: Ast.Expression, -): Ast.FieldAccess { - return { - kind: "field_access", - aggregate: aggregate ?? generateThisID(), - field: generateAstIdFromName(name), - id: nextId(), - loc: dummySrcInfoPrintable, - }; -} + /** + * The maximum expression size. + * @default 5 + */ + maxSize: number; -export function generateThisID(): Ast.Id { - return { - kind: "id", - id: nextId(), - text: "self", - loc: dummySrcInfoPrintable, - }; -} + /** + * Lists the non-terminals that the generator is allowed to use. + * @default Object.values(NonTerminal) + */ + allowedNonTerminals: NonTerminalEnum[]; -/** - * Generates an value that could be assigned to any variable with the `Map` type. - */ -export function generateMapInit( - ty: Type, - scope: Scope, -): fc.Arbitrary { - if (scope.definedIn("block", "method", "function") && randomBool()) { - return new StaticCall(ty, "emptyMap", []).generate(); - } else { - return generateNull(); - } -} + /** + * Lists the terminals that the generator is allowed to use. + * @default Object.values(Terminal); + */ + allowedTerminals: TerminalEnum[]; +}; -/** - * Generates an value that could be assigned to a struct instance. - */ -export function generateStructInit( - ty: Type, - scope: Scope, -): fc.Arbitrary { - if (ty.kind !== "struct" && ty.kind !== "message") { - throwTyError(ty); - } - const args: fc.Arbitrary[] = ty.fields.map( - (field: StructField) => { - return fc.record({ - kind: fc.constant("struct_field_initializer"), - id: fc.constant(nextId()), - field: fc.constant(generateAstIdFromName(field.name)), - initializer: new Expression(scope, field.type).generate(), - loc: fc.constant(dummySrcInfoPrintable), - }); - }, - ); - return fc.record({ - kind: fc.constantFrom("struct_instance"), - id: fc.constantFrom(nextId()), - type: fc.constantFrom(generateAstIdFromName(tyToString(ty))), - args: packArbitraries(args), - loc: fc.constant(dummySrcInfoPrintable), - }); +export function makeSelfID(): Ast.Id { + return GlobalContext.makeF.makeDummyId("self"); } /** @@ -199,29 +100,6 @@ export function generateMethodCallArgs( .map((argTy) => new Expression(methodScope, argTy).generate()); } -/** - * Generates field and contract constants access operations. - */ -export class FieldAccess extends NamedGenerativeEntity { - constructor( - type: Type, - fieldName: string, - private src?: Ast.Id, - ) { - super(type, generateAstIdFromName(fieldName)); - } - - generate(): fc.Arbitrary { - return fc.record({ - kind: fc.constant("field_access"), - aggregate: fc.constant(this.src ?? generateThisID()), - field: fc.constant(this.name), - id: fc.constant(this.idx), - loc: fc.constant(dummySrcInfoPrintable), - }); - } -} - /** * Generates method calls. */ @@ -235,14 +113,9 @@ export class MethodCall extends NamedGenerativeEntity { super(type, generateAstIdFromName(name)); } generate(): fc.Arbitrary { - return fc.record({ - kind: fc.constant("method_call"), - self: fc.constant(this.src), - method: fc.constant(this.name), - args: packArbitraries(this.args), - id: fc.constant(this.idx), - loc: fc.constant(dummySrcInfoPrintable), - }); + return packArbitraries(this.args).map((args) => + GlobalContext.makeF.makeDummyMethodCall(this.src, this.name, args), + ); } } @@ -258,720 +131,135 @@ export class StaticCall extends NamedGenerativeEntity { super(type, generateAstIdFromName(name)); } generate(): fc.Arbitrary { - return fc.record({ - kind: fc.constant("static_call"), - function: fc.constantFrom(this.name), - args: packArbitraries(this.args), - id: fc.constant(this.idx), - loc: fc.constant(dummySrcInfoPrintable), - }); - } -} - -// export namespace OpUnary { -// function generate( -// args: fc.Arbitrary[], -// allowedOps: readonly UnaryOperation[], -// ): fc.Arbitrary { -// return fc.letrec((tie) => ({ -// astExpression: fc.oneof( -// { maxDepth: 1 }, -// ...args.map((gen) => ({ arbitrary: gen, weight: 1 })), -// { -// arbitrary: tie("astOpUnary"), -// weight: 1, -// }, -// ), -// astOpUnary: fc.record({ -// kind: fc.constant("op_unary"), -// id: fc.constant(nextId()), -// op: fc.constantFrom(...allowedOps), -// loc: fc.constant(dummySrcInfoPrintable), -// operand: tie("astExpression") as fc.Arbitrary, -// }), -// })).astOpUnary; -// } - -// // Generates numeric expressions -// // num -> num -// export const Num = generate([generateNumber()], ["+", "-"]); - -// // Generates boolean expressions -// // bool -> bool -// export const Bool = generate([generateBoolean()], ["!"]); - -// // TODO: Handle optionals (`!!`) -// } - -// export namespace OpBinary { -// export function generate( -// args: fc.Arbitrary[], -// allowedOps: readonly Ast.OpBinary["op"][], -// ): fc.Arbitrary { -// return fc.letrec((tie) => ({ -// astExpression: fc.oneof( -// { maxDepth: 1 }, -// ...args.map((gen) => ({ arbitrary: gen, weight: 1 })), -// { -// arbitrary: tie("astOpBinary"), -// weight: 1, -// }, -// ), -// astOpBinary: fc.record({ -// kind: fc.constant("op_binary"), -// id: fc.constant(nextId()), -// op: fc.constantFrom(...allowedOps), -// left: tie("astExpression") as fc.Arbitrary, -// right: tie("astExpression") as fc.Arbitrary, -// loc: fc.constant(dummySrcInfoPrintable), -// }), -// })).astOpBinary; -// } - -// // num -> num -> num -// export const NumOps: Ast.OpBinary["op"][] = [ -// "+", -// "-", -// "*", -// "/", -// "%", -// "<<", -// ">>", -// "&", -// "|", -// ]; -// export const NumGens = [generateNumber(), OpUnary.Num]; - -// // bool -> bool -> bool -// export const BoolOps: Ast.OpBinary["op"][] = ["&&", "||"]; -// export const BoolGens = [ -// generateBoolean(), -// OpUnary.Bool, -// // bool -> bool -> bool -// generate([generateBoolean()], BoolOps), -// // num -> num -> bool -// // mkAst.OpBinaryGen([ Primitive.NumberGen ], -// // ["==", "!=", "&&", "||"]), -// ]; -// } -// TODO: This part has to be rewritten and used in generation. - -/** - * Generates struct field access expressions, e.g., `myStruct.a`. - * This class wraps up the logic that finds an appropriate struct and field that match - * the desired type and creates an access expression. - */ -export class StructAccess extends GenerativeEntityOpt< - Ast.Expression | undefined -> { - constructor( - private parentScope: Scope, - private resultTy: Type, - ) { - super(resultTy); - } - - generate(): fc.Arbitrary | undefined { - const structEntries = this.findStructsWithMatchingFields(); - if (structEntries.size === 0) { - return undefined; // No suitable struct found - } - let structVarNames = this.findVariablesOfStructTypes(structEntries); - if (structVarNames.size === 0) { - structVarNames = this.createStructInstance(structEntries); - } - return this.createFieldAccessExpression(structEntries, structVarNames); - } - - /** - * Collects structs that have fields returning the desired `resultTy`. - */ - private findStructsWithMatchingFields(): Map { - return this.parentScope - .getItemsRecursive("struct") - .reduce((acc, struct) => { - if (struct.type.kind !== "struct") { - throwTyError(struct.type); - } - const matchingFieldNames = struct.type.fields.reduce( - (acc, field) => { - if (tyEq(field.type, this.resultTy)) { - acc.push(field.name); - } - return acc; - }, - [] as string[], - ); - if (matchingFieldNames.length > 0) { - acc.set(struct.name.text, [ - struct.type, - matchingFieldNames, - ]); - } - return acc; - }, new Map()); - } - - /** - * Finds local variables that have a type defined by `structEntries`. - */ - private findVariablesOfStructTypes( - structEntries: Map, - ): Map { - return Array.from(structEntries.keys()).reduce((acc, structName) => { - const structType = structEntries.get(structName)![0]; - const variableNames = this.parentScope.getNamesRecursive( - "let", - structType, - ); - if (variableNames.length > 0) { - acc.set(structName, [structType, variableNames]); - } - return acc; - }, new Map()); - } - - /** - * Defines a local variable with a struct type that has matching fields. - * @returns Updated variables map. - */ - private createStructInstance( - structEntries: Map, - ): Map { - const chosenStructName = randomElement( - Array.from(structEntries.keys()), - ); - const structType = structEntries.get(chosenStructName)![0]; - const initExpr = new Expression( - this.parentScope, - structType, - ).generate(); - const varStmt = new Let(this.parentScope, structType, initExpr); - this.parentScope.addNamed("let", varStmt); - return new Map([[chosenStructName, [structType, [varStmt.name.text]]]]); - } - - /** - * Creates a field access expression for one of the available variables of the struct types. - */ - private createFieldAccessExpression( - structEntries: Map, - structVarNames: Map, - ): fc.Arbitrary { - const chosenStructName = randomElement( - Array.from(structVarNames.keys()), + return packArbitraries(this.args).map((args) => + GlobalContext.makeF.makeDummyStaticCall(this.name, args), ); - const [_, varNames] = structVarNames.get(chosenStructName)!; - const varName = randomElement(varNames); - const fieldName = randomElement( - structEntries.get(chosenStructName)![1], - ); - return new FieldAccess( - this.resultTy, - fieldName, - generateAstIdFromName(varName), - ).generate(); } } -export interface ExpressionParameters { - /** - * Determines whether functions should be generated in this run. - * @default true - */ - generateFunctions: boolean; - - /** - * Determines whether contract methods should be generated in this run. - * @default true - */ - generateMethods: boolean; - - /** - * Determines whether constants should be generated in this run. - * @default true - */ - generateConstants: boolean; - - /** - * Determines whether contract fields should be generated in this run. - * @default true - */ - generateFields: boolean; - - /** - * Determines whether statements should be generated in this run. - * @default true - */ - generateStatements: boolean; - - /** - * Indicates whether the generated expression must be evaluable at compile time. // cspell:disable-line - * @default false - */ - compileTimeEval: boolean; - - /** - * Number of the generated linear-flow statements in the block. - * @default 2 - */ - generatedStatementsNum: number; -} - -export const NonGenerativeExpressionParams: Partial = { - generateFunctions: false, - generateMethods: false, - generateConstants: false, - generateFields: false, - generateStatements: false, -}; - /** * Contains the logic to generate expressions based on their types. - * AST generation proceeds from the bottom up, meaning the expression generator - * may recursively create additional constructs, such as functions and constants, - * in outer scopes. */ export class Expression extends GenerativeEntity { - private generateFunctions: boolean; - private generateMethods: boolean; - private generateConstants: boolean; - private generateFields: boolean; - private generateStatements: boolean; - private compileTimeEval: boolean; - private generatedStatementsNum: number; + private static initializedGens: Map< + string, + (scope: Scope, type: NonTerminalEnum) => fc.Arbitrary + > = new Map(); + private parentScope: Scope; + private exprGen: ( + scope: Scope, + type: NonTerminalEnum, + ) => fc.Arbitrary; /** - * @param parentScope Scope the generated expression belongs to. + * @param parentScope Scope to extract declarations from. * @param type Type of the generated expression. * @param params Optional parameters for expression generation. */ constructor( - private parentScope: Scope, + parentScope: Scope, type: Type, params: Partial = {}, ) { super(type); + this.parentScope = parentScope; const { - generateFunctions = true, - generateMethods = true, - generateConstants = true, - generateFields = true, - generateStatements = true, - compileTimeEval = false, - generatedStatementsNum = 2, + useIdentifiers = true, + minSize = 1, + maxSize = 5, + allowedNonTerminals = Object.values(NonTerminal), + allowedTerminals = Object.values(Terminal), } = params; - this.generateFunctions = generateFunctions; - this.generateMethods = generateMethods; - this.generateConstants = generateConstants; - this.generateFields = generateFields; - this.generateStatements = generateStatements; - this.compileTimeEval = compileTimeEval; - this.generatedStatementsNum = generatedStatementsNum; - - // Forcefully change the parameters based on the current context state to avoid endless recursion. - if (GlobalContext.getDepth() >= GlobalContext.config.maxDepth) { - this.generateFunctions = false; - this.generateMethods = false; - this.generateConstants = false; - this.generateFields = false; - this.generateStatements = false; + const config: GenInitConfig = { + minSize, + maxSize, + allowedNonTerminals, + allowedTerminals, + useIdentifiers, + }; + const configKey = JSON.stringify(config); + const initGen = Expression.initializedGens.get(configKey); + if (typeof initGen === "undefined") { + this.exprGen = initializeGenerator(config); + Expression.initializedGens.set(configKey, this.exprGen); + } else { + this.exprGen = initGen; } - GlobalContext.incDepth(); } - /** - * Generates or chooses an available constant and makes a "use" expression from it. - * @return Use of the generated constant, or `undefined` if that type is unsupported. - */ - private makeConstantUse( - ty: Type, - ): fc.Arbitrary | undefined { - if (this.compileTimeEval || !this.generateConstants) { - return undefined; - } - // Don't generate constants that cannot be initialized in compile time: https://github.com/tact-lang/tact/issues/284 - if ( - ty.kind === "map" || - ty.kind === "struct" || - ty.kind === "message" - ) { - return undefined; - } - - // Collect suitable constants names - let constantNames = this.parentScope - .getNamesRecursive("constantDef", ty) - .concat(this.parentScope.getNamesRecursive("constantDecl", ty)); - // Trait constants cannot be used within trait method definitions - const traitScope = this.parentScope.findParent("trait"); - if (traitScope !== undefined) { - const traitConstantNames = new Set( - traitScope - .getNames("constantDef", ty) - .concat(traitScope.getNames("constantDecl", ty)), - ); - constantNames = constantNames.filter( - (name) => !traitConstantNames.has(name), - ); - // Don't generate new constants inside traits, since they cannot be used - if (constantNames.length === 0) { - return undefined; + private getNonTerminalForType( + type: StdlibType, + optional: boolean, + ): NonTerminalEnum { + switch (type) { + case StdlibType.Int: { + return optional ? NonTerminal.OptInt : NonTerminal.Int; } - } - - let scope = this.parentScope; // scope to add/use a constant - if (constantNames.length === 0) { - scope = - this.parentScope.definedIn("program") || randomBool() - ? this.parentScope - : this.parentScope.parentScope!; - // NOTE: Mandatory for contracts; see: tact#332. - const init = - scope.definedIn("contract", "method") || randomBool() - ? new Expression(this.parentScope, ty, { - compileTimeEval: true, - }).generate() - : undefined; - if (init) { - const constant = ConstantDef.fromScope(scope, ty, init); - this.parentScope.addNamed("constantDef", constant); - constantNames.push(constant.name.text); - } else { - const constant = new ConstantDecl(scope, ty); - this.parentScope.addNamed("constantDecl", constant); - constantNames.push(constant.name.text); + case StdlibType.Bool: { + return optional ? NonTerminal.OptBool : NonTerminal.Bool; } - } - const arbs = scope.definedIn("contract", "method") - ? constantNames.map((name) => new FieldAccess(ty, name).generate()) - : constantNames.map((name) => - fc.constant(generateAstIdFromName(name)), - ); - return arbs.length > 0 ? fc.oneof(...arbs) : undefined; - } - - /** - * Generates or chooses an available field and makes a "use" expression from it. - * @return Use expression of the generated field, or `undefined` if cannot create it. - */ - private makeFieldUse(ty: Type): fc.Arbitrary | undefined { - if ( - this.compileTimeEval || - !this.generateFields || - !this.parentScope.definedIn("method") || - this.parentScope.hasParent("trait") - ) { - return undefined; - } - - // Struct fields cannot be initialized in compile time: https://github.com/tact-lang/tact/issues/284 - // TODO: Therefore they must be initialized in the init function. - if (ty.kind === "struct" || ty.kind === "message") { - return undefined; - } - - const fieldNames = this.parentScope.getNamesRecursive("field", ty); - if (fieldNames.length === 0) { - // NOTE: This init is mandatory since we don't generate init functions yet. - // Maps cannot be initialized in compile-time. - const init = - ty.kind === "map" - ? undefined - : new Expression(this.parentScope, ty, { - compileTimeEval: true, - }).generate(); - const field = new Field(this.parentScope, ty, init); - this.parentScope.addNamed("field", field); - fieldNames.push(field.name.text); - } - const arbs = fieldNames.map((name) => - new FieldAccess(ty, name).generate(), - ); - return arbs.length > 0 ? fc.oneof(...arbs) : undefined; - } - - /** - * Generates or chooses an available local variables and makes a "use" expression from it. - * The process of generating local variables involves creating new statements in the function/method body. - * @return Use expression of the generated local variable, or `undefined` if cannot create it. - */ - private makeLocalVarUse(ty: Type): fc.Arbitrary | undefined { - if ( - this.compileTimeEval || - !this.generateStatements || - !this.parentScope.definedIn("method", "function") - ) { - return undefined; - } - const varNames = this.parentScope.getNamesRecursive("let", ty); - if (varNames.length === 0) { - const init = new Expression(this.parentScope, ty).generate(); - const varStmt = new Let(this.parentScope, ty, init); - this.parentScope.addNamed("let", varStmt); - varNames.push(varStmt.name.text); - } - const arbs = varNames.map((name) => - fc.constant(generateAstIdFromName(name)), - ); - return arbs.length > 0 ? fc.oneof(...arbs) : undefined; - } - - /** - * Generates or chooses an available local variables of a struct type and makes an expression that accesses a struct field. - * The process of generating local variables involves creating new statements in the function/method body. - * @return Use expression of the generated local variable, or `undefined` if cannot create it. - */ - private makeStructFieldAccess( - ty: Type, - ): fc.Arbitrary | undefined { - if ( - this.compileTimeEval || - !this.generateStatements || - !this.parentScope.definedIn("method", "function") - ) { - return undefined; - } - return new StructAccess(this.parentScope, ty).generate(); - } - - /** - * Generates statements in the block that uses local and global variables. - */ - private generateStatementsInBlock(): void { - if ( - !this.generateStatements || - this.parentScope.definedIn("program", "contract") - ) { - return; - } - Array.from({ length: this.generatedStatementsNum }).forEach(() => { - const stmt = new Statement(this.parentScope); - this.parentScope.addUnnamed("statement", stmt); - }); - } - - /** - * Generates or chooses an available free function and makes a call expression from it. - * @return Use expression of the generated call, or `undefined` if it is not possible to create it. - */ - private makeFunCall( - returnTy: Type, - ): fc.Arbitrary | undefined { - if (this.compileTimeEval || !this.generateFunctions) { - return undefined; - } - const funNames = this.parentScope - .findFunction("functionDef", returnTy) - .concat(this.parentScope.findFunction("methodDef", returnTy)); - if (funNames.length === 0) { - const programScope = this.parentScope.getProgramScope(); - const funTy = makeFunctionTy("function", returnTy); - const fun = new FunctionDef(programScope, "function", funTy); - this.parentScope.addNamed("functionDef", fun); - funNames.push([fun.name.text, funTy]); - } - const arbs = funNames.map(([name, funTy]) => - new StaticCall( - returnTy, - name, - generateFunctionCallArgs(funTy, this.parentScope), - ).generate(), - ); - return arbs.length > 0 ? fc.oneof(...arbs) : undefined; - } - - /** - * Generates or chooses an available method and makes a call expression from it. - * @return Use expression of the generated call, or `undefined` if it is not possible to create it. - */ - private makeMethodCall( - returnTy: Type, - ): fc.Arbitrary | undefined { - if ( - this.compileTimeEval || - !this.generateMethods || - this.parentScope.definedIn("program", "function") || - this.parentScope.hasParent("trait") - ) { - return undefined; - } - - // Collect the available standard library methods - const stdlibArbs = [ - // self.map_field.get(key) - ...this.parentScope - .getNamedEntriesRecursive("field") - .reduce((acc, [mapName, mapTy]) => { - if ( - mapTy.kind === "map" && - tyEq(mapTy.type.value, returnTy) - ) { - const opCall = new MethodCall( - returnTy, - "get", - { - kind: "id", - id: nextId(), - text: mapName, - loc: dummySrcInfoPrintable, - }, - [ - fc.constantFrom(generateThisID()), - new Expression( - this.parentScope, - mapTy.type.key, - ).generate(), - ], - ).generate(); - acc.push(opCall); - } - return acc; - }, [] as fc.Arbitrary[]), - // map_var.get(key) - ...this.parentScope - .getNamedEntriesRecursive("let") - .reduce((acc, [mapName, mapTy]) => { - if ( - mapTy.kind === "map" && - tyEq(mapTy.type.value, returnTy) - ) { - const opCall = new MethodCall( - returnTy, - "get", - { - kind: "id", - id: nextId(), - text: mapName, - loc: dummySrcInfoPrintable, - }, - [ - new Expression( - this.parentScope, - mapTy.type.key, - ).generate(), - ], - ).generate(); - acc.push(opCall); - } - return acc; - }, [] as fc.Arbitrary[]), - ]; - - // Generate or collect the available user-defined methods - const userMethods: [string, Type][] = this.parentScope.findFunction( - "methodDef", - returnTy, - ); - if (userMethods.length === 0) { - const contractScope = this.parentScope.getContractScope(); - if (contractScope === undefined) { - return undefined; + case StdlibType.Cell: { + return optional ? NonTerminal.OptCell : NonTerminal.Cell; } - const methodTy = makeFunctionTy("method", returnTy); - const method = new FunctionDef(contractScope, "method", methodTy); - this.parentScope.addNamed("methodDef", method); - userMethods.push([method.name.text, methodTy]); - } - const userArbs = userMethods.map(([name, methodTy]) => - new MethodCall( - returnTy, - name, - generateThisID(), - generateMethodCallArgs(methodTy, this.parentScope), - ).generate(), - ); - return userArbs.length > 0 && stdlibArbs.length > 0 - ? fc.oneof(...userArbs, ...stdlibArbs) - : undefined; - } - - /** Generates `require` function call. */ - private generateRequireCall(): fc.Arbitrary { - const condition = new Expression(this.parentScope, { - kind: "stdlib", - type: StdlibType.Bool, - }).generate(); - const error = new Expression(this.parentScope, { - kind: "stdlib", - type: StdlibType.String, - }).generate(); - return new StaticCall( - { kind: "util", type: UtilType.Unit }, - "require", - [condition, error], - ).generate(); - } - - /** - * Generates expressions that returns the given standard type when evaluated. - */ - private generateExpressions(ty: Type): fc.Arbitrary { - const funCall = this.makeFunCall(ty); - const methodCall = this.makeMethodCall(ty); - const constant = this.makeConstantUse(ty); - const field = this.makeFieldUse(ty); - const localVarUse = this.makeLocalVarUse(ty); - const structVarAccess = this.makeStructFieldAccess(ty); - - // Add statements to bodies of functions/methods - this.generateStatementsInBlock(); - - const baseGenerator = (() => { - if (ty.kind === "stdlib") { - switch (ty.type) { - case StdlibType.Int: - return [generateNumber()]; - case StdlibType.Bool: - return [generateBoolean()]; - case StdlibType.String: - return [generateString()]; - default: - throwTyError(ty); - } - } else if (ty.kind === "map") { - return [generateMapInit(this.type, this.parentScope)]; - } else if (ty.kind === "struct") { - return [generateStructInit(this.type, this.parentScope)]; - } else if (ty.kind === "util" && ty.type === UtilType.Unit) { - return [this.generateRequireCall()]; - } else { - throwTyError(ty); + case StdlibType.Address: { + return optional ? NonTerminal.OptAddress : NonTerminal.Address; } - })(); - - return fc.oneof( - ...baseGenerator, - ...(funCall ? [funCall] : []), - ...(methodCall ? [methodCall] : []), - ...(constant ? [constant] : []), - ...(field ? [field] : []), - ...(localVarUse ? [localVarUse] : []), - ...(structVarAccess ? [structVarAccess] : []), - ); + case StdlibType.Slice: { + return optional ? NonTerminal.OptSlice : NonTerminal.Slice; + } + case StdlibType.String: { + return optional ? NonTerminal.OptString : NonTerminal.String; + } + case StdlibType.Builder: + case StdlibType.StringBuilder: + throw new Error( + `Generation of expressions of type ${stringify(type, 0)} is currently not supported.`, + ); + } } /** - * Generates an AST expression from the specified type. - * During expression generation, the generator creates new AST entries in the outer scopes, - * including functions and constants saving them to the given context. + * Generates an AST expression of the specified type. */ generate(): fc.Arbitrary { - let expr: fc.Arbitrary; switch (this.type.kind) { - case "stdlib": + case "stdlib": { + const nonTerminal = this.getNonTerminalForType( + this.type.type, + false, + ); + return this.exprGen(this.parentScope, nonTerminal); + } + case "optional": { + switch (this.type.type.kind) { + case "stdlib": { + const nonTerminal = this.getNonTerminalForType( + this.type.type.type, + true, + ); + return this.exprGen(this.parentScope, nonTerminal); + } + case "optional": + case "map": + case "struct": + case "message": + case "util": + case "function": + throw new Error( + `Generation of expressions of type ${stringify(this.type.type, 0)} is currently not supported.`, + ); + } + break; + } case "map": case "struct": case "message": case "util": - expr = this.generateExpressions(this.type); - break; case "function": throw new Error( - `Cannot generate an expression from type: ${stringify(this.type, 0)}`, + `Generation of expressions of type ${stringify(this.type, 0)} is currently not supported.`, ); } - return expr; } } diff --git a/src/test/fuzzer/src/generators/field.ts b/src/test/fuzzer/src/generators/field.ts index f09a3d5094..d90c5613b8 100644 --- a/src/test/fuzzer/src/generators/field.ts +++ b/src/test/fuzzer/src/generators/field.ts @@ -1,15 +1,12 @@ import type * as Ast from "@/ast/ast"; -import { - createSample, - dummySrcInfoPrintable, - generateAstId, -} from "@/test/fuzzer/src/util"; +import { createSample, generateAstId } from "@/test/fuzzer/src/util"; import { tyToAstType } from "@/test/fuzzer/src/types"; import type { Type } from "@/test/fuzzer/src/types"; import type { Scope } from "@/test/fuzzer/src/scope"; import { NamedGenerativeEntity } from "@/test/fuzzer/src/generators/generator"; import fc from "fast-check"; +import { GlobalContext } from "@/test/fuzzer/src/context"; /** * An object that encapsulates a generated Ast.FieldDecl. @@ -41,14 +38,13 @@ export class Field extends NamedGenerativeEntity { } generate(): fc.Arbitrary { - return fc.record({ - kind: fc.constant("field_decl"), - id: fc.constant(this.idx), - name: fc.constant(this.name), - type: fc.constant(tyToAstType(this.type)), - initializer: this.init ?? fc.constant(undefined), - as: fc.constantFrom(undefined), - loc: fc.constant(dummySrcInfoPrintable), - }); + return (this.init ?? fc.constant(undefined)).map((i) => + GlobalContext.makeF.makeDummyFieldDecl( + this.name, + tyToAstType(this.type), + i, + undefined, + ), + ); } } diff --git a/src/test/fuzzer/src/generators/function.ts b/src/test/fuzzer/src/generators/function.ts index bf1f3f8010..7b84c0c64d 100644 --- a/src/test/fuzzer/src/generators/function.ts +++ b/src/test/fuzzer/src/generators/function.ts @@ -20,6 +20,7 @@ import { import { NamedGenerativeEntity } from "@/test/fuzzer/src/generators/generator"; import fc from "fast-check"; +import { GlobalContext } from "@/test/fuzzer/src/context"; /** * Utility type, used inside function definition and declaration classes and in shared functions. @@ -154,26 +155,19 @@ export class FunctionDef extends NamedGenerativeEntity { extraAttrs: Ast.FunctionAttribute[], ): fc.Arbitrary { const returnTy = getReturnType(this.type as FunctionType); - return fc.record({ - kind: fc.constant("function_def"), - id: fc.constant(this.idx), - attributes: fc.constant( + return this.generateBody().map((stmt) => + GlobalContext.makeF.makeDummyFunctionDef( getAttributes(extraAttrs, this.kind, false), - ), - name: fc.constant(this.name), - return: fc.constant( + this.name, isUnit(returnTy) ? undefined : tyToAstType(returnTy), - ), - params: fc.constant( generateParameters( this.kind, this.type as FunctionType, this.scope, ), + stmt, ), - statements: this.generateBody(), - loc: fc.constant(dummySrcInfoPrintable), - }); + ); } /** @@ -205,23 +199,18 @@ export class FunctionDecl extends NamedGenerativeEntity { extraAttrs: Ast.FunctionAttribute[], ): fc.Arbitrary { const returnTy = getReturnType(this.type as FunctionType); - return fc.record({ - kind: fc.constant("function_decl"), - id: fc.constant(this.idx), - attributes: fc.constant(getAttributes(extraAttrs, this.kind, true)), - name: fc.constant(this.name), - return: fc.constant( + return fc.constant( + GlobalContext.makeF.makeDummyFunctionDecl( + getAttributes(extraAttrs, this.kind, true), + this.name, isUnit(returnTy) ? undefined : tyToAstType(returnTy), - ), - params: fc.constant( generateParameters( this.kind, this.type as FunctionType, this.scope, ), ), - loc: fc.constant(dummySrcInfoPrintable), - }); + ); } /** diff --git a/src/test/fuzzer/src/generators/generator.ts b/src/test/fuzzer/src/generators/generator.ts index cd34404ec9..1f7e190693 100644 --- a/src/test/fuzzer/src/generators/generator.ts +++ b/src/test/fuzzer/src/generators/generator.ts @@ -1,19 +1,13 @@ import type * as Ast from "@/ast/ast"; -import { nextId } from "@/test/fuzzer/src/id"; -import type { IDIdx } from "@/test/fuzzer/src/id"; import type { Type } from "@/test/fuzzer/src/types"; import type fc from "fast-check"; abstract class GenerativeEntityBase { - /** The unique index of the entity. */ - public idx: IDIdx; - /** The type of the entity. */ public type: Type; constructor(type: Type) { - this.idx = nextId(); this.type = type; } } diff --git a/src/test/fuzzer/src/generators/index.ts b/src/test/fuzzer/src/generators/index.ts index 511a08ddfa..8d3571a556 100644 --- a/src/test/fuzzer/src/generators/index.ts +++ b/src/test/fuzzer/src/generators/index.ts @@ -9,9 +9,6 @@ export { FunctionDecl, } from "@/test/fuzzer/src/generators/function"; export { Program } from "@/test/fuzzer/src/generators/program"; -export { - Expression, - NonGenerativeExpressionParams, -} from "@/test/fuzzer/src/generators/expression"; +export { Expression } from "@/test/fuzzer/src/generators/expression"; export { Statement } from "@/test/fuzzer/src/generators/statement"; export { GenerativeEntity } from "@/test/fuzzer/src/generators/generator"; diff --git a/src/test/fuzzer/src/generators/parameter.ts b/src/test/fuzzer/src/generators/parameter.ts index e50895d065..1835183b57 100644 --- a/src/test/fuzzer/src/generators/parameter.ts +++ b/src/test/fuzzer/src/generators/parameter.ts @@ -1,15 +1,12 @@ import type * as Ast from "@/ast/ast"; -import { - createSample, - dummySrcInfoPrintable, - generateAstId, -} from "@/test/fuzzer/src/util"; +import { createSample, generateAstId } from "@/test/fuzzer/src/util"; import { tyToAstType } from "@/test/fuzzer/src/types"; import type { Type } from "@/test/fuzzer/src/types"; import type { Scope } from "@/test/fuzzer/src/scope"; import { NamedGenerativeEntity } from "@/test/fuzzer/src/generators/generator"; import fc from "fast-check"; +import { GlobalContext } from "@/test/fuzzer/src/context"; /** * An object that encapsulates generated Ast.TypedParameter. @@ -33,12 +30,11 @@ export class Parameter extends NamedGenerativeEntity { } generate(): fc.Arbitrary { - return fc.record({ - kind: fc.constant("typed_parameter"), - id: fc.constant(this.idx), - name: fc.constant(this.name), - type: fc.constant(tyToAstType(this.type, this.isBounced)), - loc: fc.constant(dummySrcInfoPrintable), - }); + return fc.constant( + GlobalContext.makeF.makeDummyTypedParameter( + this.name, + tyToAstType(this.type, this.isBounced), + ), + ); } } diff --git a/src/test/fuzzer/src/generators/program.ts b/src/test/fuzzer/src/generators/program.ts index bfa93bd87c..0eef288a91 100644 --- a/src/test/fuzzer/src/generators/program.ts +++ b/src/test/fuzzer/src/generators/program.ts @@ -14,8 +14,8 @@ import { Trait } from "@/test/fuzzer/src/generators/trait"; import { Scope } from "@/test/fuzzer/src/scope"; import { NamedGenerativeEntity } from "@/test/fuzzer/src/generators/generator"; import { getStdlibTraits } from "@/test/fuzzer/src/stdlib"; - import fc from "fast-check"; +import { GlobalContext } from "@/test/fuzzer/src/context"; export interface ProgramParameters { /** Add definitions that mock stdlib ones to the generated program. */ @@ -123,10 +123,8 @@ export class Program extends NamedGenerativeEntity { const functions = Array.from(this.scope.getAllNamed("functionDef")).map( (f) => f.generate(), ); - return fc.record({ - kind: fc.constantFrom("module"), - id: fc.constantFrom(this.idx), - items: fc.tuple( + return fc + .tuple( ...stdlibEntries, ...structs, ...messages, @@ -134,9 +132,8 @@ export class Program extends NamedGenerativeEntity { ...functions, ...traits, ...contracts, - ), - imports: fc.constant([]), - }); + ) + .map((decls) => GlobalContext.makeF.makeModule([], decls)); } /** diff --git a/src/test/fuzzer/src/generators/receiver.ts b/src/test/fuzzer/src/generators/receiver.ts index 4c93359280..3afbf35afb 100644 --- a/src/test/fuzzer/src/generators/receiver.ts +++ b/src/test/fuzzer/src/generators/receiver.ts @@ -9,67 +9,47 @@ import { Scope } from "@/test/fuzzer/src/scope"; import { GenerativeEntity } from "@/test/fuzzer/src/generators/generator"; import { createSample, - dummySrcInfoPrintable, randomBool, randomElement, } from "@/test/fuzzer/src/util"; -import { - Expression, - generateString, -} from "@/test/fuzzer/src/generators/expression"; +import { Expression } from "@/test/fuzzer/src/generators/expression"; import { Parameter } from "@/test/fuzzer/src/generators/parameter"; import { StatementExpression } from "@/test/fuzzer/src/generators/statement"; import fc from "fast-check"; -import { nextId } from "@/test/fuzzer/src/id"; +import { GlobalContext } from "@/test/fuzzer/src/context"; +import { generateString } from "@/test/fuzzer/src/generators/uniform-expr-gen"; const RECEIVE_RETURN_TY: Type = { kind: "util", type: UtilType.Unit }; function generateReceiverSimpleSubKind( param: Parameter, ): fc.Arbitrary { - return fc.record({ - kind: fc.constant("simple"), - param: param.generate(), - id: fc.constant(nextId()), - }); + return param + .generate() + .map((p) => GlobalContext.makeF.makeReceiverSimple(p)); } function generateReceiverFallbackSubKind(): fc.Arbitrary { - return fc.record({ - kind: fc.constant("fallback"), - id: fc.constant(nextId()), - }); + return fc.constant(GlobalContext.makeF.makeReceiverFallback()); } function generateReceiverCommentSubKind(): fc.Arbitrary { - return fc.record({ - kind: fc.constant("comment"), - comment: generateString(/*nonEmpty=*/ true), - id: fc.constant(nextId()), - }); + return generateString(/*nonEmpty=*/ true).map((s) => + GlobalContext.makeF.makeReceiverComment(s), + ); } function generateInternalReceiverKind( subKind: fc.Arbitrary, -): fc.Arbitrary { - return fc.record({ - kind: fc.constant("internal"), - subKind, - id: fc.constant(nextId()), - loc: fc.constant(dummySrcInfoPrintable), - }) as fc.Arbitrary; +): fc.Arbitrary { + return subKind.map((k) => GlobalContext.makeF.makeDummyReceiverInternal(k)); } function generateExternalReceiverKind( subKind: fc.Arbitrary, -): fc.Arbitrary { - return fc.record({ - kind: fc.constant("external"), - subKind, - id: fc.constant(nextId()), - loc: fc.constant(dummySrcInfoPrintable), - }) as fc.Arbitrary; +): fc.Arbitrary { + return subKind.map((k) => GlobalContext.makeF.makeDummyReceiverExternal(k)); } /** @@ -119,12 +99,9 @@ export class Receive extends GenerativeEntity { isBouncedMessage(msg.type), ); this.scope.addNamed("parameter", param); - return fc.record({ - kind: fc.constantFrom("bounce"), - param: param.generate(), - id: fc.constant(nextId()), - loc: fc.constant(dummySrcInfoPrintable), - }) as fc.Arbitrary; + return param + .generate() + .map((p) => GlobalContext.makeF.makeDummyReceiverBounce(p)); } const internalFallback = generateInternalReceiverKind( @@ -164,12 +141,10 @@ export class Receive extends GenerativeEntity { } public generate(): fc.Arbitrary { - return fc.record({ - kind: fc.constant("receiver"), - id: fc.constant(this.idx), - selector: this.generateSelector(), - statements: this.generateBody(), - loc: fc.constant(dummySrcInfoPrintable), - }); + return fc + .tuple(this.generateSelector(), this.generateBody()) + .map(([sel, stmt]) => + GlobalContext.makeF.makeDummyReceiver(sel, stmt), + ); } } diff --git a/src/test/fuzzer/src/generators/statement.ts b/src/test/fuzzer/src/generators/statement.ts index bf2a0a8af8..8e5b60d562 100644 --- a/src/test/fuzzer/src/generators/statement.ts +++ b/src/test/fuzzer/src/generators/statement.ts @@ -3,14 +3,11 @@ import fc from "fast-check"; import { Expression, - generateBoolean, - NonGenerativeExpressionParams, - StaticCall, - MethodCall, generateFunctionCallArgs, generateMethodCallArgs, - generateThisID, - generateFieldAccess, + makeSelfID, + MethodCall, + StaticCall, } from "@/test/fuzzer/src/generators/expression"; import { randomBool, @@ -20,7 +17,6 @@ import { randomElement, generateAstId, generateAstIdFromName, - dummySrcInfoPrintable, } from "@/test/fuzzer/src/util"; import { GenerativeEntity, @@ -30,6 +26,7 @@ import { StdlibType, UtilType, tyToAstType } from "@/test/fuzzer/src/types"; import type { Type } from "@/test/fuzzer/src/types"; import { Scope } from "@/test/fuzzer/src/scope"; import type { NamedScopeItemKind } from "@/test/fuzzer/src/scope"; +import { GlobalContext } from "@/test/fuzzer/src/context"; /** Type all the imperative constructions have. */ const STMT_TY: Type = { kind: "util", type: UtilType.Unit }; @@ -48,15 +45,14 @@ export class Return extends GenerativeEntity { super(type); } generate(): fc.Arbitrary { - return fc.record({ - kind: fc.constant("statement_return"), - id: fc.constant(this.idx), - expression: - this.type.kind === "util" && this.type.type === UtilType.Unit - ? fc.constant(undefined) - : new Expression(this.parentScope, this.type).generate(), - loc: fc.constant(dummySrcInfoPrintable), - }); + const gen = + this.type.kind === "util" && this.type.type === UtilType.Unit + ? fc.constant(undefined) + : new Expression(this.parentScope, this.type).generate(); + + return gen.map((expr) => + GlobalContext.makeF.makeDummyStatementReturn(expr), + ); } } @@ -79,14 +75,13 @@ export class Let extends NamedGenerativeEntity { } generate(): fc.Arbitrary { - return fc.record({ - kind: fc.constant("statement_let"), - id: fc.constant(this.idx), - name: fc.constantFrom(this.name), - type: fc.constantFrom(tyToAstType(this.type)), - expression: this.expr, - loc: fc.constant(dummySrcInfoPrintable), - }); + return this.expr.map((expr) => + GlobalContext.makeF.makeDummyStatementLet( + this.name, + tyToAstType(this.type), + expr, + ), + ); } } @@ -111,13 +106,9 @@ export class AssignStatement extends GenerativeEntity { generate(): fc.Arbitrary { const assigns: fc.Arbitrary[] = [ - fc.record({ - kind: fc.constant("statement_assign"), - id: fc.constant(this.idx), - path: fc.constant(this.path), - expression: this.rhs, - loc: fc.constant(dummySrcInfoPrintable), - }), + this.rhs.map((expr) => + GlobalContext.makeF.makeDummyStatementAssign(this.path, expr), + ), ]; // Only integer types in augmented assignments are supported. // See: https://github.com/tact-lang/tact/issues/353. @@ -126,19 +117,22 @@ export class AssignStatement extends GenerativeEntity { this.rhsTy.type === StdlibType.Int ) { assigns.push( - fc.record({ - kind: fc.constant("statement_augmentedassign"), - id: fc.constant(this.idx), - op: fc.constantFrom( - "+=", - "-=", - "*=", - "/=", - "%=", - ), - path: fc.constantFrom(this.path), - expression: this.rhs, - loc: fc.constant(dummySrcInfoPrintable), + this.rhs.chain((expr) => { + return fc + .constantFrom( + "+=", + "-=", + "*=", + "/=", + "%=", + ) + .map((op) => + GlobalContext.makeF.makeDummyStatementAugmentedAssign( + op, + this.path, + expr, + ), + ); }), ); } @@ -159,13 +153,21 @@ export class WhileUntilStatement extends GenerativeEntity { super(type); } generate(): fc.Arbitrary { - return fc.record({ - kind: fc.constant(`statement_${this.kind}`), - id: fc.constant(this.idx), - condition: this.condition, - statements: packArbitraries(this.body), - loc: fc.constant(dummySrcInfoPrintable), - }) as fc.Arbitrary; + return packArbitraries(this.body).chain((stmts) => + this.condition.map((expr) => { + if (this.kind === "until") { + return GlobalContext.makeF.makeDummyStatementUntil( + expr, + stmts, + ); + } else { + return GlobalContext.makeF.makeDummyStatementWhile( + expr, + stmts, + ); + } + }), + ); } } @@ -185,13 +187,11 @@ export class RepeatStatement extends GenerativeEntity { kind: "stdlib", type: StdlibType.Int, }).generate(); - return fc.record({ - kind: fc.constant(`statement_repeat`), - id: fc.constant(this.idx), - iterations, - statements: packArbitraries(this.body), - loc: fc.constant(dummySrcInfoPrintable), - }) as fc.Arbitrary; + return iterations.chain((iter) => + packArbitraries(this.body).map((stmts) => + GlobalContext.makeF.makeDummyStatementRepeat(iter, stmts), + ), + ); } } @@ -209,15 +209,16 @@ export class ForeachStatement extends GenerativeEntity { super(type); } generate(): fc.Arbitrary { - return fc.record({ - kind: fc.constant("statement_foreach"), - keyName: fc.constant(generateAstIdFromName(this.keyName)), - valueName: fc.constant(generateAstIdFromName(this.valueName)), - map: this.map, - statements: packArbitraries(this.body), - id: fc.constant(this.idx), - loc: fc.constant(dummySrcInfoPrintable), - }); + return this.map.chain((map) => + packArbitraries(this.body).map((stmts) => + GlobalContext.makeF.makeDummyStatementForEach( + generateAstIdFromName(this.keyName), + generateAstIdFromName(this.valueName), + map, + stmts, + ), + ), + ); } } @@ -239,16 +240,21 @@ export class ConditionStatement extends GenerativeEntity kind: "stdlib", type: StdlibType.Bool, }).generate(); - return fc.record({ - kind: fc.constant(`statement_condition`), - condition, - trueStatements: packArbitraries(this.trueStmts), - falseStatements: this.falseStmts - ? packArbitraries(this.falseStmts) - : fc.constant(undefined), - id: fc.constant(this.idx), - loc: fc.constant(dummySrcInfoPrintable), - }); + const falseArb = this.falseStmts + ? packArbitraries(this.falseStmts) + : fc.constant(undefined); + + return condition.chain((cond) => + packArbitraries(this.trueStmts).chain((trueStmts) => + falseArb.map((falseStmts) => + GlobalContext.makeF.makeDummyStatementCondition( + cond, + trueStmts, + falseStmts, + ), + ), + ), + ); } } @@ -264,13 +270,9 @@ export class TryCatch extends GenerativeEntity { super(type); } generate(): fc.Arbitrary { - return fc.record({ - kind: fc.constant("statement_try"), - id: fc.constant(this.idx), - statements: packArbitraries(this.tryStmts), - catchBlock: fc.constant(this.catchBlock), - loc: fc.constant(dummySrcInfoPrintable), - }); + return packArbitraries(this.tryStmts).map((stmts) => + GlobalContext.makeF.makeDummyStatementTry(stmts, this.catchBlock), + ); } } @@ -286,12 +288,9 @@ export class StatementExpression extends GenerativeEntity { super(type); } generate(): fc.Arbitrary { - return fc.record({ - kind: fc.constant("statement_expression"), - id: fc.constant(this.idx), - expression: this.expr, - loc: fc.constant(dummySrcInfoPrintable), - }); + return this.expr.map((expr) => + GlobalContext.makeF.makeDummyStatementExpression(expr), + ); } } @@ -402,13 +401,12 @@ export class Statement extends GenerativeEntity { return undefined; } const arbs = fieldEntries.map(([name, ty]) => { - const expr = new Expression( - this.parentScope, - ty, - NonGenerativeExpressionParams, - ).generate(); + const expr = new Expression(this.parentScope, ty).generate(); return new AssignStatement( - generateFieldAccess(name), + GlobalContext.makeF.makeDummyFieldAccess( + makeSelfID(), + GlobalContext.makeF.makeDummyId(name), + ), expr, ty, ).generate(); @@ -423,11 +421,10 @@ export class Statement extends GenerativeEntity { if (this.recursionLevel >= this.nestedBlocksNum) { return undefined; } - const condition = new Expression( - this.parentScope, - { kind: "stdlib", type: StdlibType.Bool }, - NonGenerativeExpressionParams, - ).generate(); + const condition = new Expression(this.parentScope, { + kind: "stdlib", + type: StdlibType.Bool, + }).generate(); const body = this.makeStmtsBlock(); return new WhileUntilStatement( condition, @@ -469,7 +466,10 @@ export class Statement extends GenerativeEntity { .getNamedEntriesRecursive(...entryKinds) .filter(([_, mapTy]: [string, Type]) => mapTy.kind === "map") .map(([mapName, _]: [string, Type]) => - generateFieldAccess(mapName), + GlobalContext.makeF.makeDummyFieldAccess( + makeSelfID(), + GlobalContext.makeF.makeDummyId(mapName), + ), ); } @@ -566,7 +566,7 @@ export class Statement extends GenerativeEntity { new MethodCall( funTy, funName, - generateThisID(), + makeSelfID(), generateMethodCallArgs(funTy, this.parentScope), ).generate(), ).generate(); @@ -610,7 +610,10 @@ export class Statement extends GenerativeEntity { * `while (false) { }` */ private makeDummyStmt(): fc.Arbitrary { - const falseExpr = generateBoolean(false); - return new WhileUntilStatement(falseExpr, [], "while").generate(); + return new WhileUntilStatement( + fc.constant(GlobalContext.makeF.makeDummyBoolean(false)), + [], + "while", + ).generate(); } } diff --git a/src/test/fuzzer/src/generators/struct.ts b/src/test/fuzzer/src/generators/struct.ts index 373278f331..c934595b2c 100644 --- a/src/test/fuzzer/src/generators/struct.ts +++ b/src/test/fuzzer/src/generators/struct.ts @@ -3,14 +3,11 @@ import { tyToString, throwTyError } from "@/test/fuzzer/src/types"; import type { Type, StructField } from "@/test/fuzzer/src/types"; import type { Scope } from "@/test/fuzzer/src/scope"; import { Field } from "@/test/fuzzer/src/generators/field"; -import { - dummySrcInfoPrintable, - generateAstIdFromName, - packArbitraries, -} from "@/test/fuzzer/src/util"; +import { generateAstIdFromName, packArbitraries } from "@/test/fuzzer/src/util"; import { NamedGenerativeEntity } from "@/test/fuzzer/src/generators/generator"; -import fc from "fast-check"; +import type fc from "fast-check"; +import { GlobalContext } from "@/test/fuzzer/src/context"; /** * An object that generates Ast.StructDecl object. @@ -48,13 +45,9 @@ export class Struct extends NamedGenerativeEntity { generateAstIdFromName(fieldTy.name), ).generate(); }); - return fc.record({ - kind: fc.constant("struct_decl"), - id: fc.constant(this.idx), - name: fc.constant(this.name), - fields: packArbitraries(fields), - loc: fc.constant(dummySrcInfoPrintable), - }); + return packArbitraries(fields).map((f) => + GlobalContext.makeF.makeDummyStructDecl(this.name, f), + ); } } @@ -94,13 +87,8 @@ export class Message extends NamedGenerativeEntity { generateAstIdFromName(fieldTy.name), ).generate(); }); - return fc.record({ - kind: fc.constant("message_decl"), - id: fc.constant(this.idx), - name: fc.constant(this.name!), - opcode: fc.constant(undefined), - fields: packArbitraries(fields), - loc: fc.constant(dummySrcInfoPrintable), - }); + return packArbitraries(fields).map((f) => + GlobalContext.makeF.makeDummyMessageDecl(this.name, undefined, f), + ); } } diff --git a/src/test/fuzzer/src/generators/trait.ts b/src/test/fuzzer/src/generators/trait.ts index 0947116026..66180da022 100644 --- a/src/test/fuzzer/src/generators/trait.ts +++ b/src/test/fuzzer/src/generators/trait.ts @@ -1,7 +1,6 @@ import type * as Ast from "@/ast/ast"; import { createSample, - dummySrcInfoPrintable, generateAstId, randomBool, } from "@/test/fuzzer/src/util"; @@ -18,6 +17,7 @@ import { Scope } from "@/test/fuzzer/src/scope"; import { NamedGenerativeEntity } from "@/test/fuzzer/src/generators/generator"; import fc from "fast-check"; +import { GlobalContext } from "@/test/fuzzer/src/context"; export interface TraitParameters { /** @@ -84,7 +84,7 @@ export class Trait extends NamedGenerativeEntity { return ty.kind === "map" || randomBool() ? undefined : new Expression(this.scope, ty, { - compileTimeEval: true, + useIdentifiers: false, }).generate(); } @@ -133,14 +133,10 @@ export class Trait extends NamedGenerativeEntity { .map((c) => c.generate()); const fields = this.fieldDeclarations.map((f) => f.generate()); const methods = this.methodDeclarations.map((m) => m.generate()); - return fc.record({ - kind: fc.constant("trait"), - id: fc.constant(this.idx), - name: fc.constant(this.name), - traits: fc.constant([]), - attributes: fc.constant([]), - declarations: fc.tuple(...constants, ...fields, ...methods), - loc: fc.constant(dummySrcInfoPrintable), - }); + return fc + .tuple(...constants, ...fields, ...methods) + .map((decl) => + GlobalContext.makeF.makeDummyTrait(this.name, [], [], decl), + ); } } diff --git a/src/test/fuzzer/src/generators/uniform-expr-gen.ts b/src/test/fuzzer/src/generators/uniform-expr-gen.ts index ac6865e73e..cefd586577 100644 --- a/src/test/fuzzer/src/generators/uniform-expr-gen.ts +++ b/src/test/fuzzer/src/generators/uniform-expr-gen.ts @@ -3,13 +3,18 @@ import type { FactoryAst } from "@/ast/ast-helpers"; import { getMakeAst } from "@/ast/generated/make-factory"; import { getAstUtil } from "@/ast/util"; import { Interpreter } from "@/optimizer/interpreter"; +import { GlobalContext } from "@/test/fuzzer/src/context"; +import type { Scope } from "@/test/fuzzer/src/scope"; +import { StdlibType } from "@/test/fuzzer/src/types"; +import type { Type } from "@/test/fuzzer/src/types"; +import { stringify } from "@/test/fuzzer/src/util"; import { beginCell } from "@ton/core"; import type { Address, Cell } from "@ton/core"; import { sha256_sync } from "@ton/crypto"; import { TreasuryContract } from "@ton/sandbox"; import * as fc from "fast-check"; -export const AllowedType = { +/*export const AllowedType = { Int: "Int", OptInt: "Int?", Bool: "Bool", @@ -25,13 +30,14 @@ export const AllowedType = { } as const; export type AllowedTypeEnum = (typeof AllowedType)[keyof typeof AllowedType]; +*/ -export type GenContext = { - // Identifier names to choose from, by type - identifiers: Map; +export type GenInitConfig = { + // The minimum expression size + minSize: number; - // Contract names to choose from - contractNames: string[]; + // The maximum expression size + maxSize: number; // The non-terminals to choose from. Non-terminals not listed here will // be disallowed during generation @@ -40,6 +46,8 @@ export type GenContext = { // The terminals to choose from. Terminals not listed here will // be disallowed during generation allowedTerminals: TerminalEnum[]; + + useIdentifiers: boolean; }; export const NonTerminal = { @@ -106,35 +114,35 @@ export const Terminal = { not: { terminal: true, id: 23 }, cell: { terminal: true, id: 24 }, - code_of: { terminal: true, id: 25 }, + //code_of: { terminal: true, id: 25 }, - slice: { terminal: true, id: 26 }, + slice: { terminal: true, id: 25 }, - address: { terminal: true, id: 27 }, + address: { terminal: true, id: 26 }, - string: { terminal: true, id: 28 }, + string: { terminal: true, id: 27 }, // opt_inj: { terminal: true, id: 30 }, // null: { terminal: true, id: 30 }, - non_null_assert: { terminal: true, id: 29 }, - - cond: { terminal: true, id: 30 }, - - id_int: { terminal: true, id: 31 }, - id_opt_int: { terminal: true, id: 32 }, - id_bool: { terminal: true, id: 33 }, - id_opt_bool: { terminal: true, id: 34 }, - id_cell: { terminal: true, id: 35 }, - id_opt_cell: { terminal: true, id: 36 }, - id_slice: { terminal: true, id: 37 }, - id_opt_slice: { terminal: true, id: 38 }, - id_address: { terminal: true, id: 39 }, - id_opt_address: { terminal: true, id: 40 }, - id_string: { terminal: true, id: 41 }, - id_opt_string: { terminal: true, id: 42 }, + non_null_assert: { terminal: true, id: 28 }, + + cond: { terminal: true, id: 29 }, + + id_int: { terminal: true, id: 30 }, + id_opt_int: { terminal: true, id: 31 }, + id_bool: { terminal: true, id: 32 }, + id_opt_bool: { terminal: true, id: 33 }, + id_cell: { terminal: true, id: 34 }, + id_opt_cell: { terminal: true, id: 35 }, + id_slice: { terminal: true, id: 36 }, + id_opt_slice: { terminal: true, id: 37 }, + id_address: { terminal: true, id: 38 }, + id_opt_address: { terminal: true, id: 39 }, + id_string: { terminal: true, id: 40 }, + id_opt_string: { terminal: true, id: 41 }, } as const; -type TerminalEnum = (typeof Terminal)[keyof typeof Terminal]; +export type TerminalEnum = (typeof Terminal)[keyof typeof Terminal]; type Token = TerminalEnum | GenericNonTerminal; @@ -395,11 +403,10 @@ const allProductions: ExprProduction[][] = [ // ], [ // Productions for Cell - { id: 0, tokens: [Terminal.code_of] }, - - { id: 1, tokens: [Terminal.non_null_assert, NonTerminal.OptCell] }, + //{ id: 0, tokens: [Terminal.code_of] }, + { id: 0, tokens: [Terminal.non_null_assert, NonTerminal.OptCell] }, { - id: 2, + id: 1, tokens: [ Terminal.cond, NonTerminal.Bool, @@ -407,8 +414,8 @@ const allProductions: ExprProduction[][] = [ NonTerminal.Cell, ], }, - { id: 3, tokens: [Terminal.id_cell] }, - { id: 4, tokens: [NonTerminal.LiteralCell] }, + { id: 2, tokens: [Terminal.id_cell] }, + { id: 3, tokens: [NonTerminal.LiteralCell] }, ], [ // Productions for OptCell @@ -623,19 +630,16 @@ function transform(n: number): number { return Math.log2(n); } -function filterProductions( - nonTerminalsToInclude: NonTerminalEnum[], - terminalsToInclude: TerminalEnum[], -): { +function filterProductions(initConfig: GenInitConfig): { productions: ExprProduction[][]; nonTerminals: GenericNonTerminal[]; reindexMap: Map; } { const nonTerminalIdsToInclude: Set = new Set( - nonTerminalsToInclude.map((e) => e.id), + initConfig.allowedNonTerminals.map((e) => e.id), ); const terminalIdsToInclude: Set = new Set( - terminalsToInclude.map((e) => e.id), + initConfig.allowedTerminals.map((e) => e.id), ); // Make a copy of all the productions @@ -646,7 +650,27 @@ function filterProductions( }); } - // Remove productions that use terminals and non-terminals not listed in the provided argument lists. + // If flag useIdentifiers is off, remove generation of identifiers + if (!initConfig.useIdentifiers) { + [ + Terminal.id_address, + Terminal.id_bool, + Terminal.id_cell, + Terminal.id_int, + Terminal.id_opt_address, + Terminal.id_opt_bool, + Terminal.id_opt_cell, + Terminal.id_opt_int, + Terminal.id_opt_slice, + Terminal.id_opt_string, + Terminal.id_slice, + Terminal.id_string, + ].forEach((terminal) => { + terminalIdsToInclude.delete(terminal.id); + }); + } + + // Remove productions that use terminals and non-terminals not listed in the allowed lists. let initialNonTerminalsCount; do { initialNonTerminalsCount = nonTerminalIdsToInclude.size; @@ -1181,7 +1205,7 @@ function getProductionAt(prods: ExprProduction[], id: number): ExprProduction { function makeExpression( astF: FactoryAst, nonTerminalId: number, - ctx: GenContext, + scope: Scope, nonTerminalCounts: number[][][], sizeSplitCounts: number[][][][][], finalProductions: ExprProduction[][], @@ -1337,11 +1361,11 @@ function makeExpression( ); } - function makeIdentifier(t: AllowedTypeEnum): fc.Arbitrary { - const names = ctx.identifiers.get(t); - if (typeof names === "undefined" || names.length === 0) { + function makeIdentifier(ty: Type): fc.Arbitrary { + const names = scope.getNamesRecursive("let", ty); + if (names.length === 0) { throw new Error( - `There must exist at least one identifier for type ${t}`, + `There must exist at least one identifier for type ${stringify(ty, 0)}`, ); } return fc.constantFrom(...names).map((id) => makeF.makeDummyId(id)); @@ -1540,18 +1564,18 @@ function makeExpression( case Terminal.cell.id: { return _generateCell().map((c) => makeF.makeDummyCell(c)); } - case Terminal.code_of.id: { - if (ctx.contractNames.length === 0) { - throw new Error( - "There must exist at least one contract name in generator context", - ); - } - return fc - .constantFrom(...ctx.contractNames) - .map((name) => - makeF.makeDummyCodeOf(makeF.makeDummyId(name)), - ); - } + //case Terminal.code_of.id: { + // if (ctx.contractNames.length === 0) { + // throw new Error( + // "There must exist at least one contract name in generator context", + // ); + // } + // return fc + // .constantFrom(...ctx.contractNames) + // .map((name) => + // makeF.makeDummyCodeOf(makeF.makeDummyId(name)), + // ); + //} case Terminal.slice.id: { return _generateCell().map((c) => makeF.makeDummySlice(c.asSlice()), @@ -1617,40 +1641,73 @@ function makeExpression( }); } case Terminal.id_int.id: { - return makeIdentifier("Int"); + return makeIdentifier({ kind: "stdlib", type: StdlibType.Int }); } case Terminal.id_opt_int.id: { - return makeIdentifier("Int?"); + return makeIdentifier({ + kind: "optional", + type: { kind: "stdlib", type: StdlibType.Int }, + }); } case Terminal.id_bool.id: { - return makeIdentifier("Bool"); + return makeIdentifier({ + kind: "stdlib", + type: StdlibType.Bool, + }); } case Terminal.id_opt_bool.id: { - return makeIdentifier("Bool?"); + return makeIdentifier({ + kind: "optional", + type: { kind: "stdlib", type: StdlibType.Bool }, + }); } case Terminal.id_cell.id: { - return makeIdentifier("Cell"); + return makeIdentifier({ + kind: "stdlib", + type: StdlibType.Cell, + }); } case Terminal.id_opt_cell.id: { - return makeIdentifier("Cell?"); + return makeIdentifier({ + kind: "optional", + type: { kind: "stdlib", type: StdlibType.Cell }, + }); } case Terminal.id_slice.id: { - return makeIdentifier("Slice"); + return makeIdentifier({ + kind: "stdlib", + type: StdlibType.Slice, + }); } case Terminal.id_opt_slice.id: { - return makeIdentifier("Slice?"); + return makeIdentifier({ + kind: "optional", + type: { kind: "stdlib", type: StdlibType.Slice }, + }); } case Terminal.id_address.id: { - return makeIdentifier("Address"); + return makeIdentifier({ + kind: "stdlib", + type: StdlibType.Address, + }); } case Terminal.id_opt_address.id: { - return makeIdentifier("Address?"); + return makeIdentifier({ + kind: "optional", + type: { kind: "stdlib", type: StdlibType.Address }, + }); } case Terminal.id_string.id: { - return makeIdentifier("String"); + return makeIdentifier({ + kind: "stdlib", + type: StdlibType.String, + }); } case Terminal.id_opt_string.id: { - return makeIdentifier("String?"); + return makeIdentifier({ + kind: "optional", + type: { kind: "stdlib", type: StdlibType.String }, + }); } } } @@ -1659,20 +1716,23 @@ function makeExpression( } export function initializeGenerator( - minSize: number, - maxSize: number, - ctx: GenContext, - astF: FactoryAst, -): (nonTerminal: NonTerminalEnum) => fc.Arbitrary { - const { productions, nonTerminals, reindexMap } = filterProductions( - ctx.allowedNonTerminals, - ctx.allowedTerminals, - ); + initConfig: GenInitConfig, +): ( + scope: Scope, + nonTerminal: NonTerminalEnum, +) => fc.Arbitrary { + const { productions, nonTerminals, reindexMap } = + filterProductions(initConfig); const { nonTerminalCounts, sizeSplitCounts, totalCounts } = - computeCountTables(minSize, maxSize, productions, nonTerminals); + computeCountTables( + initConfig.minSize, + initConfig.maxSize, + productions, + nonTerminals, + ); - return (nonTerminal: NonTerminalEnum) => { + return (scope: Scope, nonTerminal: NonTerminalEnum) => { const nonTerminalId = reindexMap.get(nonTerminal.id); if (typeof nonTerminalId === "undefined") { throw new Error( @@ -1699,9 +1759,9 @@ export function initializeGenerator( return fc.oneof(...weightedSizes).chain((size) => { return makeExpression( - astF, + GlobalContext.astF, nonTerminalId, - ctx, + scope, nonTerminalCounts, sizeSplitCounts, productions, @@ -1743,3 +1803,23 @@ function _generateIntBitLength( return fc.bigInt(0n, maxUnsigned); } } + +function generateStringValue( + nonEmpty: boolean, + constValue?: string, +): fc.Arbitrary { + return constValue === undefined + ? nonEmpty + ? fc.string({ minLength: 1 }) + : fc.string() + : fc.constantFrom(constValue); +} + +export function generateString( + nonEmpty: boolean, + constValue?: string, +): fc.Arbitrary { + return generateStringValue(nonEmpty, constValue).map((s) => + GlobalContext.makeF.makeDummyString(s), + ); +} diff --git a/src/test/fuzzer/src/id.ts b/src/test/fuzzer/src/id.ts deleted file mode 100644 index 26c8786a42..0000000000 --- a/src/test/fuzzer/src/id.ts +++ /dev/null @@ -1,8 +0,0 @@ -export type IDIdx = number; - -let currentId: IDIdx = 0; - -export function nextId(): IDIdx { - currentId += 1; - return currentId; -} diff --git a/src/test/fuzzer/src/scope.ts b/src/test/fuzzer/src/scope.ts index 6609f89357..205252fdf0 100644 --- a/src/test/fuzzer/src/scope.ts +++ b/src/test/fuzzer/src/scope.ts @@ -1,6 +1,5 @@ import type { Type } from "@/test/fuzzer/src/types"; import { getReturnType } from "@/test/fuzzer/src/types"; -import type { IDIdx } from "@/test/fuzzer/src/id"; import type { GenerativeEntity } from "@/test/fuzzer/src/generators"; import type * as Ast from "@/ast/ast"; import type { NamedGenerativeEntity } from "@/test/fuzzer/src/generators/generator"; @@ -76,12 +75,12 @@ export class Scope { */ private mapUnnamed: Map< UnnamedScopeItemKind, - Map> // eslint-disable-line @typescript-eslint/no-explicit-any + Map> // eslint-disable-line @typescript-eslint/no-explicit-any > = new Map(); private mapNamed: Map< NamedScopeItemKind, - Map> // eslint-disable-line @typescript-eslint/no-explicit-any + Map> // eslint-disable-line @typescript-eslint/no-explicit-any > = new Map(); constructor(kind: ScopeKind, parentScope: Scope | undefined) { @@ -168,18 +167,19 @@ export class Scope { * Put a new entity in the scope according to the Tact semantics. */ public addUnnamed( - kind: T, - entity: GenerativeEntityMap[T], + _kind: T, + _entity: GenerativeEntityMap[T], ): void { - const targetScope = this.getTargetScopeToAdd(kind); - if (targetScope.mapUnnamed.has(kind)) { - targetScope.mapUnnamed.get(kind)!.set(entity.idx, entity); - } else { - targetScope.mapUnnamed - .set(kind, new Map()) - .get(kind)! - .set(entity.idx, entity); - } + throw new Error("Currently not supported"); + // const targetScope = this.getTargetScopeToAdd(kind); + // if (targetScope.mapUnnamed.has(kind)) { + // targetScope.mapUnnamed.get(kind)!.set(entity.idx, entity); + // } else { + // targetScope.mapUnnamed + // .set(kind, new Map()) + // .get(kind)! + // .set(entity.idx, entity); + // } } /** @@ -193,25 +193,27 @@ export class Scope { if (isNamedScopeItemKind(kind)) { if (targetScope.mapNamed.has(kind)) { - targetScope.mapNamed.get(kind)!.set(entity.idx, entity); + targetScope.mapNamed.get(kind)!.set(entity.name.text, entity); } else { targetScope.mapNamed .set(kind, new Map()) .get(kind)! - .set(entity.idx, entity); + .set(entity.name.text, entity); } } } public getAllUnnamed( - kind: T, + _kind: T, ): GenerativeEntityMap[T][] { - const kindMap = this.mapUnnamed.get(kind); - if (kindMap) { - return Array.from(kindMap.values()); - } - return []; + throw new Error("Currently not supported"); + // const kindMap = this.mapUnnamed.get(kind); + // if (kindMap) { + // return Array.from(kindMap.values()); + // } + // return []; } + public getAllNamed( kind: T, ): NamedGenerativeEntityMap[T][] { diff --git a/src/test/fuzzer/src/stdlib.ts b/src/test/fuzzer/src/stdlib.ts index 5293c096bb..684c1317c6 100644 --- a/src/test/fuzzer/src/stdlib.ts +++ b/src/test/fuzzer/src/stdlib.ts @@ -1,13 +1,9 @@ import type * as Ast from "@/ast/ast"; -import { nextId } from "@/test/fuzzer/src/id"; - import * as path from "path"; import { files } from "@/stdlib/stdlib"; import { createVirtualFileSystem } from "@/vfs/createVirtualFileSystem"; -import { - dummySrcInfoPrintable, - generateAstIdFromName, -} from "@/test/fuzzer/src/util"; +import { generateAstIdFromName } from "@/test/fuzzer/src/util"; +import { GlobalContext } from "@/test/fuzzer/src/context"; const StdlibFilePath = path.join( __dirname, @@ -29,14 +25,11 @@ export const StdlibCode = StdlibVFS.readFile(StdlibPath).toString(); */ export function getStdlibTraits(): Ast.TypeDecl[] { return [ - { - kind: "trait", - id: nextId(), - name: generateAstIdFromName("BaseTrait"), - traits: [], - attributes: [], - declarations: [], - loc: dummySrcInfoPrintable, - }, + GlobalContext.makeF.makeDummyTrait( + generateAstIdFromName("BaseTrait"), + [], + [], + [], + ), ]; } diff --git a/src/test/fuzzer/src/types.ts b/src/test/fuzzer/src/types.ts index a8048fdc62..463550ac88 100644 --- a/src/test/fuzzer/src/types.ts +++ b/src/test/fuzzer/src/types.ts @@ -5,14 +5,12 @@ import { randomInt, randomBool, generateAstIdFromName, - dummySrcInfoPrintable, stringify, } from "@/test/fuzzer/src/util"; import type { Scope } from "@/test/fuzzer/src/scope"; import type { TypeRef } from "@/types/types"; - -import { nextId } from "@/test/fuzzer/src/id"; import fc from "fast-check"; +import { GlobalContext } from "@/test/fuzzer/src/context"; /** * Types from Tact stdlib. @@ -55,6 +53,11 @@ export enum UtilType { Unit = "Unit", } +export type OptionalType = { + kind: "optional"; + type: Type; +}; + /** * Represents the signature of a function in a format typical for functional languages, such as Int -> Int -> Int. * The last element of the list means the return type, previous elements are types of the arguments. @@ -87,7 +90,8 @@ export type Type = kind: "util"; type: UtilType; } - | FunctionType; + | FunctionType + | OptionalType; // eslint-disable-next-line @typescript-eslint/no-explicit-any export function throwTyError(ty: any): never { @@ -122,21 +126,14 @@ export const SUPPORTED_STDLIB_TYPES: StdlibType[] = [ ]; function makePrimitiveType(name: string): Ast.PrimitiveTypeDecl { - return { - kind: "primitive_type_decl", - id: nextId(), - name: generateAstIdFromName(name), - loc: dummySrcInfoPrintable, - }; + return GlobalContext.makeF.makeDummyPrimitiveTypeDecl( + generateAstIdFromName(name), + ); } function makeASTTypeRef(name: string): Ast.TypeId { - return { - kind: "type_id", - id: nextId(), - text: name, - loc: dummySrcInfoPrintable, - }; + return GlobalContext.makeF.makeDummyTypeId(name); } + function makeTypeRef(name: string): TypeRef { return { kind: "ref", @@ -182,12 +179,7 @@ export function tyToAstTypeDecl(ty: Type): Ast.TypeDecl { } export function tyToAstType(ty: Type, isBounced = false): Ast.Type { const generateAstTypeId = (text: string) => - ({ - kind: "type_id", - text, - id: nextId(), - loc: dummySrcInfoPrintable, - }) as Ast.TypeId; + GlobalContext.makeF.makeDummyTypeId(text); switch (ty.kind) { case "stdlib": { @@ -199,31 +191,18 @@ export function tyToAstType(ty: Type, isBounced = false): Ast.Type { } case "struct": case "message": { - const simpleType: Ast.TypeId = { - kind: "type_id", - text: ty.name, - id: nextId(), - loc: dummySrcInfoPrintable, - }; + const simpleType = GlobalContext.makeF.makeDummyTypeId(ty.name); return isBounced - ? { - kind: "bounced_message_type", - messageType: simpleType, - id: nextId(), - loc: dummySrcInfoPrintable, - } + ? GlobalContext.makeF.makeDummyBouncedMessageType(simpleType) : simpleType; } case "map": - return { - kind: "map_type", - id: nextId(), - keyType: generateAstTypeId(tyToString(ty.type.key)), - keyStorageType: undefined, - valueType: generateAstTypeId(tyToString(ty.type.value)), - valueStorageType: undefined, - loc: dummySrcInfoPrintable, - }; + return GlobalContext.makeF.makeDummyMapType( + generateAstTypeId(tyToString(ty.type.key)), + undefined, + generateAstTypeId(tyToString(ty.type.value)), + undefined, + ); default: throwTyError(ty); } diff --git a/src/test/fuzzer/src/util.ts b/src/test/fuzzer/src/util.ts index 284edaa9e4..3b0f658813 100644 --- a/src/test/fuzzer/src/util.ts +++ b/src/test/fuzzer/src/util.ts @@ -10,7 +10,6 @@ import type { NamedScopeItemKind, Scope } from "@/test/fuzzer/src/scope"; import { GlobalContext } from "@/test/fuzzer/src/context"; import type { Type } from "@/test/fuzzer/src/types"; import type * as Ast from "@/ast/ast"; -import { nextId } from "@/test/fuzzer/src/id"; import { getSrcInfo } from "@/grammar/src-info"; import type { FactoryAst } from "@/ast/ast-helpers"; import { idText } from "@/ast/ast-helpers"; @@ -220,12 +219,7 @@ export function generateName( * Generates Ast.Id from string name and with new id. */ export function generateAstIdFromName(name: string): Ast.Id { - return { - kind: "id", - text: name, - id: nextId(), - loc: dummySrcInfoPrintable, - }; + return GlobalContext.makeF.makeDummyId(name); } /** @@ -238,12 +232,9 @@ export function generateAstId( shadowing: boolean = true, isType: boolean = false, ): fc.Arbitrary { - return fc.record({ - kind: fc.constant("id"), - text: generateName(scope, shadowing, isType), - id: fc.constant(nextId()), - loc: fc.constant(dummySrcInfoPrintable), - }); + return generateName(scope, shadowing, isType).map((s) => + GlobalContext.makeF.makeDummyId(s), + ); } /** diff --git a/src/test/fuzzer/test/compilation.spec.ts b/src/test/fuzzer/test/compilation.spec.ts index 3c6f178767..974f26a7ba 100644 --- a/src/test/fuzzer/test/compilation.spec.ts +++ b/src/test/fuzzer/test/compilation.spec.ts @@ -31,68 +31,69 @@ function getContract(program: Ast.Module): Ast.Contract | undefined { } async function compileProgram(program: Ast.Module) { - await withNodeFS(async (vfs) => { - const factoryAst = getAstFactory(); - let ctx = createContext(program); - ctx = enableFeatures(ctx, "external"); - ctx = precompile(ctx, factoryAst); - const compilationOutput = vfs.root; + throw new Error("Deprecated function"); + // await withNodeFS(async (vfs) => { + // const factoryAst = getAstFactory(); + // let ctx = createContext(program); + // ctx = enableFeatures(ctx, "external"); + // ctx = precompile(ctx, factoryAst); + // const compilationOutput = vfs.root; - const contract = getContract(program)!; + // const contract = getContract(program)!; - // Save the generated contract to a file - const contractCode = GlobalContext.format(contract, "ast"); - writeFileSync( - path.join(compilationOutput, "contract.tact"), - contractCode, - ); + // // Save the generated contract to a file + // const contractCode = GlobalContext.format(contract, "ast"); + // writeFileSync( + // path.join(compilationOutput, "contract.tact"), + // contractCode, + // ); - // Compile contracts to FunC - const res = await compile(ctx, contract.name.text); - for (const files of res.output.files) { - const ffc = vfs.resolve(compilationOutput, files.name); - vfs.writeFile(ffc, files.code); - } + // // Compile contracts to FunC + // const res = await compile(ctx, contract.name.text); + // for (const files of res.output.files) { + // const ffc = vfs.resolve(compilationOutput, files.name); + // vfs.writeFile(ffc, files.code); + // } - // Process compilation output - const codeFc = res.output.files.map((v) => ({ - path: posixNormalize(vfs.resolve(compilationOutput, v.name)), - content: v.code, - })); - const codeEntrypoint = res.output.entrypoint; + // // Process compilation output + // const codeFc = res.output.files.map((v) => ({ + // path: posixNormalize(vfs.resolve(compilationOutput, v.name)), + // content: v.code, + // })); + // const codeEntrypoint = res.output.entrypoint; - // Compile the resulted FunC code - // NOTE: We intentionally disabled stdlibEx, since the generated - // contracts currently don't use it. - const c = await funcCompile({ - entries: [ - StdlibPath, - // stdlibExPath, - posixNormalize(vfs.resolve(compilationOutput, codeEntrypoint)), - ], - sources: [ - { path: StdlibPath, content: StdlibCode }, - // { - // path: stdlibExPath, - // content: stdlibExCode, - // }, - ...codeFc, - ], - logger: { - info: (_) => {}, - debug: (_) => {}, - warn: (_) => {}, - error: (_) => {}, - }, - }); - try { - expect(c.ok).toBeTruthy(); - } catch (_error) { - throw new Error(`FunC compilation failed:\n${c.log}`); - } + // // Compile the resulted FunC code + // // NOTE: We intentionally disabled stdlibEx, since the generated + // // contracts currently don't use it. + // const c = await funcCompile({ + // entries: [ + // StdlibPath, + // // stdlibExPath, + // posixNormalize(vfs.resolve(compilationOutput, codeEntrypoint)), + // ], + // sources: [ + // { path: StdlibPath, content: StdlibCode }, + // // { + // // path: stdlibExPath, + // // content: stdlibExCode, + // // }, + // ...codeFc, + // ], + // logger: { + // info: (_) => {}, + // debug: (_) => {}, + // warn: (_) => {}, + // error: (_) => {}, + // }, + // }); + // try { + // expect(c.ok).toBeTruthy(); + // } catch (_error) { + // throw new Error(`FunC compilation failed:\n${c.log}`); + // } - GlobalContext.resetDepth(); - }); + // GlobalContext.resetDepth(); + // }); } describe("properties", () => { diff --git a/src/test/fuzzer/test/expressions/expression-stats.ts b/src/test/fuzzer/test/expressions/expression-stats.ts index 54afa6cc35..58c62b9b93 100644 --- a/src/test/fuzzer/test/expressions/expression-stats.ts +++ b/src/test/fuzzer/test/expressions/expression-stats.ts @@ -4,10 +4,7 @@ import * as fs from "fs"; import { Scope } from "@/test/fuzzer/src/scope"; import { SUPPORTED_STDLIB_TYPES } from "@/test/fuzzer/src/types"; import type { Type } from "@/test/fuzzer/src/types"; -import { - Expression, - NonGenerativeExpressionParams, -} from "@/test/fuzzer/src/generators"; +import { Expression } from "@/test/fuzzer/src/generators"; import path from "path"; /** @@ -267,11 +264,7 @@ function main() { .constantFrom(...SUPPORTED_STDLIB_TYPES) .chain((type) => { const ty: Type = { kind: "stdlib", type }; - return new Expression( - globalScope, - ty, - NonGenerativeExpressionParams, - ).generate(); + return new Expression(globalScope, ty).generate(); }); statistics(generator, 50000, path.join(__dirname, "counts.txt")); } diff --git a/src/test/fuzzer/test/expressions/expression.spec.ts b/src/test/fuzzer/test/expressions/expression.spec.ts index 4bd021c974..5e67f9fdc9 100644 --- a/src/test/fuzzer/test/expressions/expression.spec.ts +++ b/src/test/fuzzer/test/expressions/expression.spec.ts @@ -1,15 +1,13 @@ +import type * as Ast from "@/ast/ast"; import { CompilerContext } from "@/context/context"; import { resolveExpression, getExpType } from "@/types/resolveExpression"; import type { StatementContext } from "@/types/resolveStatements"; import type { TypeRef } from "@/types/types"; import assert from "assert"; -import { - Expression, - NonGenerativeExpressionParams, -} from "@/test/fuzzer/src/generators"; +import { Expression } from "@/test/fuzzer/src/generators"; import { Scope } from "@/test/fuzzer/src/scope"; -import { SUPPORTED_STDLIB_TYPES } from "@/test/fuzzer/src/types"; +import { StdlibType, SUPPORTED_STDLIB_TYPES } from "@/test/fuzzer/src/types"; import type { Type } from "@/test/fuzzer/src/types"; import { createProperty, @@ -17,25 +15,25 @@ import { dummySrcInfoPrintable, checkAsyncProperty, astNodeCounterexamplePrinter, + packArbitraries, } from "@/test/fuzzer/src/util"; import fc from "fast-check"; import { - AllowedType, - AllowedTypeEnum, - GenContext, initializeGenerator, NonTerminal, Terminal, } from "../../src/generators/uniform-expr-gen"; +import type { NonTerminalEnum } from "../../src/generators/uniform-expr-gen"; import { bindingsAndExpressionPrtinter, compileExpression, - ExpressionTestingEnvironment, - generateBindings, interpretExpression, saveExpressionTest, setupEnvironment, } from "./utils"; +import type { ExpressionTestingEnvironment } from "./utils"; +import { Let } from "@/test/fuzzer/src/generators/statement"; +import { GlobalContext } from "@/test/fuzzer/src/context"; function emptyStatementContext(): StatementContext { return { @@ -63,11 +61,7 @@ describe("generation properties", () => { const ty: Type = { kind: "stdlib", type }; // NOTE: This test checks only pure expressions, without introducing new // entries to any scopes. - const exprGen = new Expression( - globalScope, - ty, - NonGenerativeExpressionParams, - ).generate(); + const exprGen = new Expression(globalScope, ty).generate(); const property = createProperty(exprGen, (expr) => { compilerCtx = resolveExpression(expr, stmtCtx, compilerCtx); const resolvedTy = getExpType(compilerCtx, expr); @@ -93,12 +87,14 @@ describe("evaluation properties", () => { expressionTestingEnvironment = await setupEnvironment(); }); - afterAll(() => expressionTestingEnvironment.outputStream.close()); + afterAll(() => { + expressionTestingEnvironment.outputStream.close(); + }); test( "compiler and interpreter evaluate generated expressions equally", async () => { - const expressionGenerationIds: Map = + /*const expressionGenerationIds: Map = new Map(); expressionGenerationIds.set(AllowedType.Int, ["int1"]); expressionGenerationIds.set(AllowedType.OptInt, ["int_null"]); @@ -114,29 +110,34 @@ describe("evaluation properties", () => { ]); expressionGenerationIds.set(AllowedType.String, ["string1"]); expressionGenerationIds.set(AllowedType.OptString, ["string_null"]); + */ - const expressionGenerationCtx: GenContext = { - identifiers: expressionGenerationIds, - contractNames: [ - expressionTestingEnvironment.contractNameToCompile, - ], + const globalScope = new Scope("block", undefined); + const initializerCtx = { + minSize: 1, + maxSize: 1, + useIdentifiers: false, allowedNonTerminals: Object.values(NonTerminal), allowedTerminals: Object.values(Terminal), }; - const generator = initializeGenerator( - 1, - 10, + const bindingsGenerator = initializeGenerator(initializerCtx); + + const expressionGenerationCtx = { + minSize: 1, + maxSize: 10, + useIdentifiers: true, + allowedNonTerminals: Object.values(NonTerminal), + allowedTerminals: Object.values(Terminal), + }; + const exprGenerator = new Expression( + globalScope, + { kind: "stdlib", type: StdlibType.Int }, expressionGenerationCtx, - expressionTestingEnvironment.astF, ); const property = fc.asyncProperty( - generateBindings( - expressionTestingEnvironment, - expressionGenerationIds, - generator, - ), - generator(NonTerminal.Int), + generateBindings(globalScope, bindingsGenerator), + exprGenerator.generate(), async (bindings, expr) => { const compilationResult = await compileExpression( expressionTestingEnvironment, @@ -177,3 +178,88 @@ describe("evaluation properties", () => { 60 * 1000, // 1 minute ); }); + +function generateBindings( + scope: Scope, + bindingsGenerator: ( + scope: Scope, + nonTerminal: NonTerminalEnum, + ) => fc.Arbitrary, +): fc.Arbitrary { + // For each of the types, we create a let generator + const types: Type[] = [ + { kind: "stdlib", type: StdlibType.Int }, + { kind: "stdlib", type: StdlibType.Bool }, + { kind: "stdlib", type: StdlibType.Address }, + { kind: "stdlib", type: StdlibType.Cell }, + { kind: "stdlib", type: StdlibType.Slice }, + { kind: "stdlib", type: StdlibType.String }, + { kind: "optional", type: { kind: "stdlib", type: StdlibType.Int } }, + { kind: "optional", type: { kind: "stdlib", type: StdlibType.Bool } }, + { + kind: "optional", + type: { kind: "stdlib", type: StdlibType.Address }, + }, + { kind: "optional", type: { kind: "stdlib", type: StdlibType.Cell } }, + { kind: "optional", type: { kind: "stdlib", type: StdlibType.Slice } }, + { kind: "optional", type: { kind: "stdlib", type: StdlibType.String } }, + ]; + const result: fc.Arbitrary[] = []; + + for (const ty of types) { + result.push( + new Let( + scope, + ty, + bindingsGenerator(scope, typeToNonTerminal(ty)), + ).generate() as fc.Arbitrary, + ); + if (ty.kind === "optional") { + result.push( + new Let( + scope, + ty, + fc.constant(GlobalContext.makeF.makeDummyNull()), + ).generate() as fc.Arbitrary, + ); + } + } + + return packArbitraries(result); +} + +function typeToNonTerminal(ty: Type): NonTerminalEnum { + switch (ty.kind) { + case "optional": { + // Treat them as if they were non-optionals + return typeToNonTerminal(ty.type); + } + case "stdlib": { + switch (ty.type) { + case StdlibType.Int: + return NonTerminal.Int; + case StdlibType.Address: + return NonTerminal.Address; + case StdlibType.Bool: + return NonTerminal.Bool; + case StdlibType.Cell: + return NonTerminal.Cell; + case StdlibType.Slice: + return NonTerminal.Slice; + case StdlibType.String: + return NonTerminal.String; + case StdlibType.Builder: + throw new Error("Not supported"); + case StdlibType.StringBuilder: + throw new Error("Not supported"); + } + break; + } + case "function": + case "map": + case "message": + case "struct": + case "util": + throw new Error("Not supported."); + } +} diff --git a/src/test/fuzzer/test/expressions/utils.ts b/src/test/fuzzer/test/expressions/utils.ts index 02a196c77d..b867af71a4 100644 --- a/src/test/fuzzer/test/expressions/utils.ts +++ b/src/test/fuzzer/test/expressions/utils.ts @@ -1,10 +1,5 @@ import type * as Ast from "@/ast/ast"; import type { MakeAstFactory } from "@/ast/generated/make-factory"; -import { getMakeAst } from "@/ast/generated/make-factory"; -import type { - AllowedTypeEnum, - NonTerminalEnum, -} from "../../src/generators/uniform-expr-gen"; import { NonTerminal } from "../../src/generators/uniform-expr-gen"; import { GlobalContext } from "../../src/context"; import { Interpreter } from "@/optimizer/interpreter"; @@ -12,7 +7,6 @@ import { CompilerContext } from "@/context/context"; import type { AstUtil } from "@/ast/util"; import { getAstUtil } from "@/ast/util"; import type { FactoryAst } from "@/ast/ast-helpers"; -import { getAstFactory } from "@/ast/ast-helpers"; import type { CustomStdlib } from "../../src/util"; import { buildModule, @@ -22,7 +16,6 @@ import { import { Blockchain } from "@ton/sandbox"; import type { Sender } from "@ton/core"; import { toNano } from "@ton/core"; -import fc from "fast-check"; import * as fs from "node:fs"; export function bindingsAndExpressionPrtinter([bindings, expr]: [ @@ -103,8 +96,8 @@ export type ExpressionTestingEnvironment = { }; export async function setupEnvironment(): Promise { - const astF = getAstFactory(); - const makeF = getMakeAst(astF); + const astF = GlobalContext.astF; + const makeF = GlobalContext.makeF; const customStdlib = filterStdlib( parseStandardLibrary(astF), makeF, @@ -219,6 +212,7 @@ export async function compileExpression( } } +/* export function generateBindings( expressionTestingEnvironment: ExpressionTestingEnvironment, expressionGenerationIds: Map, @@ -258,6 +252,7 @@ export function generateBindings( ), ); } +*/ export function saveExpressionTest( bindings: Ast.StatementLet[], From 8680a2909b4b27043434da42faaa5df1635c6ced Mon Sep 17 00:00:00 2001 From: jeshecdom Date: Wed, 23 Apr 2025 16:03:16 +0200 Subject: [PATCH 43/44] small fixes. --- src/test/fuzzer/src/scope.ts | 4 +- src/test/fuzzer/src/types.ts | 8 +- .../test/expressions/expression.spec.ts | 81 ++++++++++--------- 3 files changed, 51 insertions(+), 42 deletions(-) diff --git a/src/test/fuzzer/src/scope.ts b/src/test/fuzzer/src/scope.ts index 205252fdf0..abd51e5392 100644 --- a/src/test/fuzzer/src/scope.ts +++ b/src/test/fuzzer/src/scope.ts @@ -1,5 +1,5 @@ import type { Type } from "@/test/fuzzer/src/types"; -import { getReturnType } from "@/test/fuzzer/src/types"; +import { getReturnType, tyEq } from "@/test/fuzzer/src/types"; import type { GenerativeEntity } from "@/test/fuzzer/src/generators"; import type * as Ast from "@/ast/ast"; import type { NamedGenerativeEntity } from "@/test/fuzzer/src/generators/generator"; @@ -279,7 +279,7 @@ export class Scope { */ public getNames(kind: NamedScopeItemKind, ty: Type): string[] { return this.getNamedEntries(kind) - .filter(([_name, type]) => type === ty) + .filter(([_name, type]) => tyEq(type, ty)) .map(([name, _type]) => name); } diff --git a/src/test/fuzzer/src/types.ts b/src/test/fuzzer/src/types.ts index 463550ac88..24bfdbaa60 100644 --- a/src/test/fuzzer/src/types.ts +++ b/src/test/fuzzer/src/types.ts @@ -9,7 +9,7 @@ import { } from "@/test/fuzzer/src/util"; import type { Scope } from "@/test/fuzzer/src/scope"; import type { TypeRef } from "@/types/types"; -import fc from "fast-check"; +import fc, { option } from "fast-check"; import { GlobalContext } from "@/test/fuzzer/src/context"; /** @@ -107,6 +107,8 @@ export function tyToString(ty: Type): string { return ty.name; case "map": return `map<${tyToString(ty.type.key)}, ${tyToString(ty.type.value)}>`; + case "optional": + return `${tyToString(ty.type)}?`; default: throwTyError(ty); } @@ -203,6 +205,10 @@ export function tyToAstType(ty: Type, isBounced = false): Ast.Type { generateAstTypeId(tyToString(ty.type.value)), undefined, ); + case "optional": + return GlobalContext.makeF.makeDummyOptionalType( + tyToAstType(ty.type, isBounced), + ); default: throwTyError(ty); } diff --git a/src/test/fuzzer/test/expressions/expression.spec.ts b/src/test/fuzzer/test/expressions/expression.spec.ts index 5e67f9fdc9..8a5aabc444 100644 --- a/src/test/fuzzer/test/expressions/expression.spec.ts +++ b/src/test/fuzzer/test/expressions/expression.spec.ts @@ -51,34 +51,34 @@ function setupContexts(): [CompilerContext, StatementContext] { return [ctx, sctx]; } -describe("generation properties", () => { - it("generates well-typed expressions", () => { - const results = setupContexts(); - let compilerCtx = results[0]; - const stmtCtx = results[1]; - const globalScope = new Scope("program", undefined); - for (const type of SUPPORTED_STDLIB_TYPES) { - const ty: Type = { kind: "stdlib", type }; - // NOTE: This test checks only pure expressions, without introducing new - // entries to any scopes. - const exprGen = new Expression(globalScope, ty).generate(); - const property = createProperty(exprGen, (expr) => { - compilerCtx = resolveExpression(expr, stmtCtx, compilerCtx); - const resolvedTy = getExpType(compilerCtx, expr); - if (resolvedTy.kind == "ref") { - assert.strictEqual( - resolvedTy.name, - ty.type, - `The resolved type ${resolvedTy.name} does not match the expected type ${ty.type}`, - ); - } else { - assert.fail(`Unexpected type: ${resolvedTy.kind}`); - } - }); - checkProperty(property, astNodeCounterexamplePrinter); - } - }); -}); +// describe("generation properties", () => { +// it("generates well-typed expressions", () => { +// const results = setupContexts(); +// let compilerCtx = results[0]; +// const stmtCtx = results[1]; +// const globalScope = new Scope("program", undefined); +// for (const type of SUPPORTED_STDLIB_TYPES) { +// const ty: Type = { kind: "stdlib", type }; +// // NOTE: This test checks only pure expressions, without introducing new +// // entries to any scopes. +// const exprGen = new Expression(globalScope, ty).generate(); +// const property = createProperty(exprGen, (expr) => { +// compilerCtx = resolveExpression(expr, stmtCtx, compilerCtx); +// const resolvedTy = getExpType(compilerCtx, expr); +// if (resolvedTy.kind == "ref") { +// assert.strictEqual( +// resolvedTy.name, +// ty.type, +// `The resolved type ${resolvedTy.name} does not match the expected type ${ty.type}`, +// ); +// } else { +// assert.fail(`Unexpected type: ${resolvedTy.kind}`); +// } +// }); +// checkProperty(property, astNodeCounterexamplePrinter); +// } +// }); +// }); describe("evaluation properties", () => { let expressionTestingEnvironment: ExpressionTestingEnvironment; @@ -207,20 +207,23 @@ function generateBindings( const result: fc.Arbitrary[] = []; for (const ty of types) { - result.push( - new Let( - scope, - ty, - bindingsGenerator(scope, typeToNonTerminal(ty)), - ).generate() as fc.Arbitrary, + const genBuilder = new Let( + scope, + ty, + bindingsGenerator(scope, typeToNonTerminal(ty)), ); + scope.addNamed("let", genBuilder); + result.push(genBuilder.generate() as fc.Arbitrary); + if (ty.kind === "optional") { + const genBuilder = new Let( + scope, + ty, + fc.constant(GlobalContext.makeF.makeDummyNull()), + ); + scope.addNamed("let", genBuilder); result.push( - new Let( - scope, - ty, - fc.constant(GlobalContext.makeF.makeDummyNull()), - ).generate() as fc.Arbitrary, + genBuilder.generate() as fc.Arbitrary, ); } } From 6d2c069ffecb9c934dc36f1cce225d873cbf14ab Mon Sep 17 00:00:00 2001 From: jeshecdom Date: Fri, 25 Apr 2025 14:39:32 +0200 Subject: [PATCH 44/44] tests: make imported fuzzer top-down. --- src/test/fuzzer/src/config.ts | 262 +++++++++++++++++++ src/test/fuzzer/src/generators/contract.ts | 158 ++++++++--- src/test/fuzzer/src/generators/expression.ts | 34 +-- src/test/fuzzer/src/generators/function.ts | 92 ++++++- src/test/fuzzer/src/generators/program.ts | 180 +++++++++++-- src/test/fuzzer/src/generators/receiver.ts | 91 ++++++- src/test/fuzzer/src/generators/statement.ts | 11 +- src/test/fuzzer/src/generators/trait.ts | 27 +- src/test/fuzzer/src/scope.ts | 69 ++--- src/test/fuzzer/src/types.ts | 2 +- 10 files changed, 783 insertions(+), 143 deletions(-) diff --git a/src/test/fuzzer/src/config.ts b/src/test/fuzzer/src/config.ts index e9374e8e3e..a62e5c6f77 100644 --- a/src/test/fuzzer/src/config.ts +++ b/src/test/fuzzer/src/config.ts @@ -1,5 +1,13 @@ import * as os from "os"; import { existsSync, mkdirSync } from "fs"; +import { + NonTerminal, + Terminal, +} from "@/test/fuzzer/src/generators/uniform-expr-gen"; +import type { + NonTerminalEnum, + TerminalEnum, +} from "@/test/fuzzer/src/generators/uniform-expr-gen"; /** * The default number of executions per test. Corresponds to fast-check defaults. @@ -41,6 +49,260 @@ export class FuzzConfig { */ public maxDepth: number = 5; + /** + * Default generation parameters. Used by entity constructors. + */ + + /** + * ------------------------------------- + * Parameters for contract generation + * ------------------------------------- + */ + + /** + * Minimum number of receivers generated within a contract. + * @default 1 + */ + public static receiveMinNum: number = 1; + + /** + * Maximum number of receivers generated within a contract. + * @default 5 + */ + public static receiveMaxNum: number = 5; + + /** + * Minimum number of constants generated within a contract. + * @default 1 + */ + public static contractConstantMinNum: number = 1; + + /** + * Maximum number of constants generated within a contract. + * @default 5 + */ + public static contractConstantMaxNum: number = 5; + + /** + * Minimum number of fields generated within a contract. + * @default 1 + */ + public static contractFieldMinNum: number = 1; + + /** + * Maximum number of fields generated within a contract. + * @default 5 + */ + public static contractFieldMaxNum: number = 5; + + /** + * ------------------------------------- + * Parameters for trait generation + * ------------------------------------- + * TODO: make this parameters into min and max + */ + + /** + * Number of fields generated within a trait. + * @default 1 + */ + public static traitFieldNum: number = 1; + + /** + * Number of method declarations generated within a trait. + * @default 1 + */ + public static traitMethodDeclarationsNum: number = 1; + + /** + * Number of constant declarations generated within a trait. + * @default 1 + */ + public static traitConstantNum: number = 1; + + /** + * ------------------------------------- + * Parameters for expression generation + * ------------------------------------- + */ + + /** + * Indicates whether generated expressions could use identifiers declared in the scope. + * @default true + */ + public static useIdentifiersInExpressions: boolean = true; + + /** + * The minimum expression size. + * @default 1 + */ + public static minExpressionSize: number = 1; + + /** + * The maximum expression size. + * @default 5 + */ + public static maxExpressionSize: number = 5; + + /** + * Non-terminals that the expression generator is allowed to use. + * @default Object.values(NonTerminal) + */ + public static allowedNonTerminalsInExpressions: NonTerminalEnum[] = + Object.values(NonTerminal); + + /** + * Terminals that the the expression generator is allowed to use. + * @default Object.values(Terminal); + */ + public static allowedTerminalsInExpressions: TerminalEnum[] = + Object.values(Terminal); + + /** + * ------------------------------------- + * Parameters for function generation + * ------------------------------------- + */ + + /** + * Minimum number of let statements at the start of function body. + * @default 1 + */ + public static letStatementsMinNum: number = 1; + + /** + * Maximum number of let statements at the start of function body. + * @default 5 + */ + public static letStatementsMaxNum: number = 5; + + /** + * Minimum number of sequential statements in the function body (not counting initial let statements and final return) + * @default 1 + */ + public static statementsMinLength: number = 1; + + /** + * Maximum number of sequential statements in the function body (not counting initial let statements and final return) + * @default 5 + */ + public static statementsMaxLength: number = 5; + + /** + * ------------------------------------- + * Parameters for module generation + * ------------------------------------- + */ + + /** + * Add definitions that mock stdlib ones to the generated program. + * @default false + */ + public static addStdlib: boolean = false; + + /** + * Minimum number of structures. + * @default 1 + */ + public static structsMinNum: number = 1; + + /** + * Maximum number of structures. + * @default 4 + */ + public static structsMaxNum: number = 4; + + /** + * Minimum number of messages. + * @default 1 + */ + public static messagesMinNum: number = 1; + + /** + * Maximum number of messages. + * @default 4 + */ + public static messagesMaxNum: number = 4; + + /** + * Minimum number of the generated traits. Some of them might be used by the generated contracts. + * @default 1 + */ + public static traitsMinNum: number = 1; + + /** + * Maximum number of the generated traits. Some of them might be used by the generated contracts. + * @default 4 + */ + public static traitsMaxNum: number = 4; + + /** + * Minimum number of generated contracts + * @default 1 + */ + public static contractsMinNum: number = 1; + + /** + * Maximum number of generated contracts + * @default 4 + */ + public static contractsMaxNum: number = 4; + + /** + * Minimum number of generated global functions + * @default 1 + */ + public static functionsMinNum: number = 1; + + /** + * Maximum number of generated global functions + * @default 4 + */ + public static functionsMaxNum: number = 4; + + /** + * Minimum number of global function arguments + * @default 0 + */ + public static functionArgsMinNum: number = 0; + + /** + * Maximum number of global function arguments + * @default 6 + */ + public static functionArgsMaxNum: number = 6; + + /** + * Minimum number of generated global constants + * @default 1 + */ + public static constantsMinNum: number = 1; + + /** + * Maximum number of generated global constants + * @default 4 + */ + public static constantsMaxNum: number = 4; + + /** + * ------------------------------------- + * Parameters for general statement generation + * ------------------------------------- + * TODO: Make these arguments into min and max parameters + */ + + /** + * Determines the maximum depth of nested statement blocks. + * @default 2 + */ + public static nestedBlocksNum: number = 2; + + /** + * Number of statements in each block. + * @default 3 + */ + public static stmtsInBlock: number = 3; + constructor() { this.samplesNum = process.env.SAMPLES_NUM ? parseInt(process.env.SAMPLES_NUM) diff --git a/src/test/fuzzer/src/generators/contract.ts b/src/test/fuzzer/src/generators/contract.ts index 878bbd93ab..470cd70f49 100644 --- a/src/test/fuzzer/src/generators/contract.ts +++ b/src/test/fuzzer/src/generators/contract.ts @@ -3,26 +3,59 @@ import { createSample, dummySrcInfoPrintable, generateAstId, + packArbitraries, } from "@/test/fuzzer/src/util"; import { FunctionDef } from "@/test/fuzzer/src/generators/function"; import type { Trait } from "@/test/fuzzer/src/generators/trait"; import { Expression } from "@/test/fuzzer/src/generators/expression"; import { Receive } from "@/test/fuzzer/src/generators/receiver"; -import { UtilType } from "@/test/fuzzer/src/types"; +import { SUPPORTED_STDLIB_TYPES, UtilType } from "@/test/fuzzer/src/types"; import type { FunctionType } from "@/test/fuzzer/src/types"; import { Scope } from "@/test/fuzzer/src/scope"; import { NamedGenerativeEntity } from "@/test/fuzzer/src/generators/generator"; import fc from "fast-check"; import { Field } from "@/test/fuzzer/src/generators/field"; +import { ConstantDef } from "@/test/fuzzer/src/generators/constant"; +import { FuzzConfig } from "@/test/fuzzer/src/config"; import { GlobalContext } from "@/test/fuzzer/src/context"; export interface ContractParameters { /** - * Number of receive method generated within a contract. - * @default 1 + * Minimum number of receivers generated within a contract. + * @default FuzzConfig.receiveMinNum */ - receiveNum: number; + receiveMinNum: number; + + /** + * Maximum number of receivers generated within a contract. + * @default FuzzConfig.receiveMaxNum + */ + receiveMaxNum: number; + + /** + * Minimum number of constants generated within a contract. + * @default FuzzConfig.contractConstantMinNum + */ + contractConstantMinNum: number; + + /** + * Maximum number of constants generated within a contract. + * @default FuzzConfig.contractConstantMaxNum + */ + contractConstantMaxNum: number; + + /** + * Minimum number of fields generated within a contract. + * @default FuzzConfig.contractFieldMinNum + */ + contractFieldMinNum: number; + + /** + * Maximum number of fields generated within a contract. + * @default FuzzConfig.contractFieldMaxNum + */ + contractFieldMaxNum: number; } /** @@ -33,7 +66,12 @@ export class Contract extends NamedGenerativeEntity { /** Scope used within the generated contract. */ private scope: Scope; - private receiveNum: number; + private receiveMinNum: number; + private receiveMaxNum: number; + private contractConstantMinNum: number; + private contractConstantMaxNum: number; + private contractFieldMinNum: number; + private contractFieldMaxNum: number; /** * @param methodSignatures Signatures of methods to be generated in the contract. @@ -52,8 +90,20 @@ export class Contract extends NamedGenerativeEntity { ); this.scope = scope; - const { receiveNum = 1 } = params; - this.receiveNum = receiveNum; + const { + receiveMinNum = FuzzConfig.receiveMinNum, + receiveMaxNum = FuzzConfig.receiveMaxNum, + contractConstantMinNum = FuzzConfig.contractConstantMinNum, + contractConstantMaxNum = FuzzConfig.contractConstantMaxNum, + contractFieldMinNum = FuzzConfig.contractFieldMinNum, + contractFieldMaxNum = FuzzConfig.contractFieldMaxNum, + } = params; + this.receiveMinNum = receiveMinNum; + this.receiveMaxNum = receiveMaxNum; + this.contractConstantMinNum = contractConstantMinNum; + this.contractConstantMaxNum = contractConstantMaxNum; + this.contractFieldMinNum = contractFieldMinNum; + this.contractFieldMaxNum = contractFieldMaxNum; } public generate(): fc.Arbitrary { @@ -64,14 +114,14 @@ export class Contract extends NamedGenerativeEntity { if (this.trait !== undefined) { traitFields = this.trait.fieldDeclarations.map(({ type, name }) => { const init = new Expression(this.scope, type, { - useIdentifiers: false, + useIdentifiersInExpressions: false, }).generate(); return new Field(this.scope, type, init, name).generate(); }); traitConstants = this.trait.constantDeclarations .map((decl) => { const init = new Expression(this.scope, decl.type, { - useIdentifiers: false, + useIdentifiersInExpressions: false, }).generate(); return decl .createDefinition(init) @@ -106,28 +156,76 @@ export class Contract extends NamedGenerativeEntity { const requestedMethods = this.methodSignatures.map((signature) => new FunctionDef(this.scope, "method", signature).generate(), ); - const generatedMethods = Array.from( - this.scope.getAllNamed("methodDef"), - ).map((m) => m.generate()); - const requestedReceives = Array.from({ length: this.receiveNum }).map( - (_) => new Receive(this.scope).generate(), - ); - const generatedConstants = Array.from( - this.scope.getAllNamed("constantDef"), - ).map((c) => c.generate()); - const generatedFields = Array.from(this.scope.getAllNamed("field")).map( - (f) => f.generate(), - ); + //const generatedMethods = Array.from( + // this.scope.getAllNamed("methodDef"), + //).map((m) => m.generate()); + + const requestedReceives = fc.array(new Receive(this.scope).generate(), { + minLength: this.receiveMinNum, + maxLength: this.receiveMaxNum, + }); + + // TODO: Augment the SUPPORTED_STDLIB_TYPES + const genConstantDefEntities = fc + .constantFrom(...SUPPORTED_STDLIB_TYPES) + .map((ty) => + ConstantDef.fromScope( + this.scope, + { kind: "stdlib", type: ty }, + new Expression( + this.scope, + { kind: "stdlib", type: ty }, + { useIdentifiersInExpressions: false }, + ).generate(), + ), + ) + .chain((d) => d.generate()); + + const generatedConstants = fc.array(genConstantDefEntities, { + minLength: this.contractConstantMinNum, + maxLength: this.contractConstantMaxNum, + }); + + //const generatedConstants = Array.from( + // this.scope.getAllNamed("constantDef"), + //).map((c) => c.generate()); + + //const generatedFields = Array.from(this.scope.getAllNamed("field")).map( + // (f) => f.generate(), + //); + + // TODO: Augment the SUPPORTED_STDLIB_TYPES + const genFieldEntities = fc + .constantFrom(...SUPPORTED_STDLIB_TYPES) + .map( + (ty) => + new Field( + this.scope, + { kind: "stdlib", type: ty }, + new Expression( + this.scope, + { kind: "stdlib", type: ty }, + { useIdentifiersInExpressions: false }, + ).generate(), + ), + ) + .chain((f) => f.generate()); + + const generatedFields = fc.array(genFieldEntities, { + minLength: this.contractFieldMinNum, + maxLength: this.contractFieldMaxNum, + }); + return fc .tuple( - ...traitConstants, - ...generatedConstants, - ...traitFields, - ...generatedFields, - ...requestedReceives, - ...traitMethods, - ...generatedMethods, - ...requestedMethods, + packArbitraries(traitConstants), + generatedConstants, + packArbitraries(traitFields), + generatedFields, + requestedReceives, + packArbitraries(traitMethods), + //...generatedMethods, + packArbitraries(requestedMethods), ) .map((decls) => GlobalContext.makeF.makeDummyContract( @@ -135,7 +233,7 @@ export class Contract extends NamedGenerativeEntity { this.trait === undefined ? [] : [this.trait.name], [], undefined, - decls, + decls.flat(), ), ); } diff --git a/src/test/fuzzer/src/generators/expression.ts b/src/test/fuzzer/src/generators/expression.ts index 99f967362e..af015d124b 100644 --- a/src/test/fuzzer/src/generators/expression.ts +++ b/src/test/fuzzer/src/generators/expression.ts @@ -15,7 +15,6 @@ import type { Scope } from "@/test/fuzzer/src/scope"; import { initializeGenerator, NonTerminal, - Terminal, } from "@/test/fuzzer/src/generators/uniform-expr-gen"; import type { GenInitConfig, @@ -23,35 +22,36 @@ import type { TerminalEnum, } from "@/test/fuzzer/src/generators/uniform-expr-gen"; import { GlobalContext } from "@/test/fuzzer/src/context"; +import { FuzzConfig } from "@/test/fuzzer/src/config"; export type ExpressionParameters = { /** * Indicates whether the generated expression could use identifiers declared in the scope. - * @default true + * @default FuzzConfig.useIdentifiersInExpressions */ - useIdentifiers: boolean; + useIdentifiersInExpressions: boolean; /** * The minimum expression size. - * @default 1 + * @default FuzzConfig.minExpressionSize */ - minSize: number; + minExpressionSize: number; /** * The maximum expression size. - * @default 5 + * @default FuzzConfig.maxExpressionSize */ - maxSize: number; + maxExpressionSize: number; /** * Lists the non-terminals that the generator is allowed to use. - * @default Object.values(NonTerminal) + * @default FuzzConfig.allowedNonTerminals */ allowedNonTerminals: NonTerminalEnum[]; /** * Lists the terminals that the generator is allowed to use. - * @default Object.values(Terminal); + * @default FuzzConfig.allowedTerminals */ allowedTerminals: TerminalEnum[]; }; @@ -165,18 +165,18 @@ export class Expression extends GenerativeEntity { this.parentScope = parentScope; const { - useIdentifiers = true, - minSize = 1, - maxSize = 5, - allowedNonTerminals = Object.values(NonTerminal), - allowedTerminals = Object.values(Terminal), + useIdentifiersInExpressions = FuzzConfig.useIdentifiersInExpressions, + minExpressionSize = FuzzConfig.minExpressionSize, + maxExpressionSize = FuzzConfig.maxExpressionSize, + allowedNonTerminals = FuzzConfig.allowedNonTerminalsInExpressions, + allowedTerminals = FuzzConfig.allowedTerminalsInExpressions, } = params; const config: GenInitConfig = { - minSize, - maxSize, + minSize: minExpressionSize, + maxSize: maxExpressionSize, allowedNonTerminals, allowedTerminals, - useIdentifiers, + useIdentifiers: useIdentifiersInExpressions, }; const configKey = JSON.stringify(config); const initGen = Expression.initializedGens.get(configKey); diff --git a/src/test/fuzzer/src/generators/function.ts b/src/test/fuzzer/src/generators/function.ts index 7b84c0c64d..4508a8b1d9 100644 --- a/src/test/fuzzer/src/generators/function.ts +++ b/src/test/fuzzer/src/generators/function.ts @@ -6,9 +6,10 @@ import { getReturnType, isUnit, UtilType, + SUPPORTED_STDLIB_TYPES, } from "@/test/fuzzer/src/types"; import type { FunctionType, Type } from "@/test/fuzzer/src/types"; -import { Return } from "@/test/fuzzer/src/generators/statement"; +import { Let, Return, Statement } from "@/test/fuzzer/src/generators/statement"; import { Parameter } from "@/test/fuzzer/src/generators/parameter"; import { Scope } from "@/test/fuzzer/src/scope"; import { @@ -21,6 +22,8 @@ import { NamedGenerativeEntity } from "@/test/fuzzer/src/generators/generator"; import fc from "fast-check"; import { GlobalContext } from "@/test/fuzzer/src/context"; +import { Expression } from "@/test/fuzzer/src/generators/expression"; +import { FuzzConfig } from "@/test/fuzzer/src/config"; /** * Utility type, used inside function definition and declaration classes and in shared functions. @@ -101,6 +104,32 @@ function getAttributes( return attrs; } +export interface FunctionParameters { + /** + * Minimum number of let statements at the start of function body. + * @default FuzzConfig.letStatementsMinNum + */ + letStatementsMinNum: number; + + /** + * Maximum number of let statements at the start of function body. + * @default FuzzConfig.letStatementsMaxNum + */ + letStatementsMaxNum: number; + + /** + * Minimum number of statements in the function body (not counting initial let statements and final return) + * @default FuzzConfig.statementsMinLength + */ + statementsMinLength: number; + + /** + * Maximum number of statements in the function body (not counting initial let statements and final return) + * @default FuzzConfig.statementsMaxLength + */ + statementsMaxLength: number; +} + /** * An object that encapsulates the generated free function or contract method definition including * its scope and nested elements. @@ -109,6 +138,11 @@ export class FunctionDef extends NamedGenerativeEntity { /** Generated body items. */ private body: fc.Arbitrary[] = []; + private letStatementsMinNum: number; + private letStatementsMaxNum: number; + private statementsMinLength: number; + private statementsMaxLength: number; + /** Scope used within the generated function. */ private scope: Scope; @@ -119,6 +153,7 @@ export class FunctionDef extends NamedGenerativeEntity { kind: FunctionKind, type: FunctionType, name?: string, + params: Partial = {}, ) { const scope = new Scope(kind, parentScope); super( @@ -129,6 +164,16 @@ export class FunctionDef extends NamedGenerativeEntity { ); this.scope = scope; this.kind = kind; + const { + letStatementsMinNum = FuzzConfig.letStatementsMinNum, + letStatementsMaxNum = FuzzConfig.letStatementsMaxNum, + statementsMinLength = FuzzConfig.statementsMinLength, + statementsMaxLength = FuzzConfig.statementsMaxLength, + } = params; + this.letStatementsMinNum = letStatementsMinNum; + this.letStatementsMaxNum = letStatementsMaxNum; + this.statementsMinLength = statementsMinLength; + this.statementsMaxLength = statementsMaxLength; } /** @@ -141,14 +186,43 @@ export class FunctionDef extends NamedGenerativeEntity { ? getReturnType(type) : { kind: "util", type: UtilType.Unit }; const returnStmt = new Return(this.scope, returnTy).generate(); - const generatedLetBindings = Array.from( - this.scope.getAllNamed("let"), - ).map((c) => c.generate()); - const generatedStmts = Array.from( - this.scope.getAllUnnamed("statement"), - ).map((c) => c.generate()); - this.body = [...generatedLetBindings, ...generatedStmts, returnStmt]; - return fc.tuple(...this.body); + //const generatedLetBindings = Array.from( + // this.scope.getAllNamed("let"), + //).map((c) => c.generate()); + + // TODO: Augment the SUPPORTED_STDLIB_TYPES + const generatedLetEntities = fc + .constantFrom(...SUPPORTED_STDLIB_TYPES) + .map( + (ty) => + new Let( + this.scope, + { kind: "stdlib", type: ty }, + new Expression(this.scope, { + kind: "stdlib", + type: ty, + }).generate(), + ), + ) + .chain((l) => l.generate()); + + const generatedLetBindings = fc.array(generatedLetEntities, { + minLength: this.letStatementsMinNum, + maxLength: this.letStatementsMaxNum, + }); + + const generatedStmts = fc.array(new Statement(this.scope).generate(), { + minLength: this.statementsMinLength, + maxLength: this.statementsMaxLength, + }); + + //const generatedStmts = Array.from( + // this.scope.getAllUnnamed("statement"), + //).map((c) => c.generate()); + + return fc + .tuple(generatedLetBindings, generatedStmts, returnStmt) + .map((tup) => tup.flat()); } public generateImpl( diff --git a/src/test/fuzzer/src/generators/program.ts b/src/test/fuzzer/src/generators/program.ts index 0eef288a91..dc390513c3 100644 --- a/src/test/fuzzer/src/generators/program.ts +++ b/src/test/fuzzer/src/generators/program.ts @@ -16,28 +16,98 @@ import { NamedGenerativeEntity } from "@/test/fuzzer/src/generators/generator"; import { getStdlibTraits } from "@/test/fuzzer/src/stdlib"; import fc from "fast-check"; import { GlobalContext } from "@/test/fuzzer/src/context"; +import { ConstantDef } from "@/test/fuzzer/src/generators/constant"; +import { Expression } from "@/test/fuzzer/src/generators/expression"; +import { FunctionDef } from "@/test/fuzzer/src/generators/function"; +import { FuzzConfig } from "@/test/fuzzer/src/config"; export interface ProgramParameters { /** Add definitions that mock stdlib ones to the generated program. */ addStdlib: boolean; /** - * Number of structures generated on the program level. - * @default Random: [1-3] + * Minimum number of structures generated on the program level. + * @default FuzzConfig.structsMinNum */ - structsNum: number; + structsMinNum: number; /** - * Number of messages generated on the program level. - * @default Random: [1-3] + * Maximum number of structures generated on the program level. + * @default FuzzConfig.structsMaxNum */ - messagesNum: number; + structsMaxNum: number; /** - * Number of the generated traits. Some of them might be used by the generated contracts. - * @default Random: [1-2] + * Minimum number of messages generated on the program level. + * @default FuzzConfig.messagesMinNum */ - traitsNum: number; + messagesMinNum: number; + + /** + * Maximum number of messages generated on the program level. + * @default FuzzConfig.messagesMaxNum + */ + messagesMaxNum: number; + + /** + * Minimum number of the generated traits. Some of them might be used by the generated contracts. + * @default FuzzConfig.traitsMinNum + */ + traitsMinNum: number; + + /** + * Maximum number of the generated traits. Some of them might be used by the generated contracts. + * @default FuzzConfig.traitsMaxNum + */ + traitsMaxNum: number; + + /** + * Minimum number of generated contracts + * @default FuzzConfig.contractsMinNum + */ + contractsMinNum: number; + + /** + * Maximum number of generated contracts + * @default FuzzConfig.contractsMaxNum + */ + contractsMaxNum: number; + + /** + * Minimum number of generated functions + * @default FuzzConfig.functionsMinNum + */ + functionsMinNum: number; + + /** + * Maximum number of generated functions + * @default FuzzConfig.functionsMaxNum + */ + functionsMaxNum: number; + + /** + * Minimum number of function arguments + * @default FuzzConfig.functionArgsMinNum + */ + functionArgsMinNum: number; + + /** + * Maximum number of function arguments + * @default FuzzConfig.functionArgsMaxNum + */ + functionArgsMaxNum: number; + + /** + * Minimum number of generated constants + * @default FuzzConfig.constantsMinNum + */ + constantsMinNum: number; + + /** + * Maximum number of generated constants + * @default FuzzConfig.constantsMaxNum + */ + constantsMaxNum: number; } /** @@ -57,10 +127,21 @@ export class Program extends NamedGenerativeEntity { ); const { - addStdlib = false, - structsNum = randomInt(1, 3), - messagesNum = randomInt(1, 3), - traitsNum = randomInt(1, 2), + addStdlib = FuzzConfig.addStdlib, + structsMinNum = FuzzConfig.structsMinNum, + structsMaxNum = FuzzConfig.structsMaxNum, + messagesMinNum = FuzzConfig.messagesMinNum, + messagesMaxNum = FuzzConfig.messagesMaxNum, + traitsMinNum = FuzzConfig.traitsMinNum, + traitsMaxNum = FuzzConfig.traitsMaxNum, + contractsMinNum = FuzzConfig.contractsMinNum, + contractsMaxNum = FuzzConfig.constantsMaxNum, + functionsMinNum = FuzzConfig.functionsMinNum, + functionsMaxNum = FuzzConfig.functionsMaxNum, + functionArgsMinNum = FuzzConfig.functionArgsMinNum, + functionArgsMaxNum = FuzzConfig.functionArgsMaxNum, + constantsMinNum = FuzzConfig.constantsMinNum, + constantsMaxNum = FuzzConfig.constantsMaxNum, } = params; this.addStdlib = addStdlib; @@ -68,26 +149,56 @@ export class Program extends NamedGenerativeEntity { // NOTE: Structures and messages must be generated prior to contracts in order // to add their entries to scopes for further reuse. - Array.from({ length: structsNum }).forEach((_) => { - this.scope.addNamed("struct", this.makeStruct()); - }); + Array.from({ length: randomInt(structsMinNum, structsMaxNum) }).forEach( + (_) => { + this.scope.addNamed("struct", this.makeStruct()); + }, + ); - Array.from({ length: messagesNum }).forEach((_) => { + Array.from({ + length: randomInt(messagesMinNum, messagesMaxNum), + }).forEach((_) => { this.scope.addNamed("message", this.makeMessage()); }); // NOTE: Traits must be generated prior to contracts to enable them implement them. const traits: Trait[] = []; - Array.from({ length: traitsNum }).forEach((_) => { - const trait = this.makeTrait(); - traits.push(trait); - this.scope.addNamed("trait", trait); + Array.from({ length: randomInt(traitsMinNum, traitsMaxNum) }).forEach( + (_) => { + const trait = this.makeTrait(); + traits.push(trait); + this.scope.addNamed("trait", trait); + }, + ); + + // One of the traits could be implemented by the generated contracts. + Array.from({ + length: randomInt(contractsMinNum, contractsMaxNum), + }).forEach((_) => { + const traitToImplement = + traits.length > 0 && randomBool() + ? randomElement(traits) + : undefined; + this.scope.addNamed( + "contract", + this.makeContract(traitToImplement), + ); + }); + + Array.from({ + length: randomInt(functionsMinNum, functionsMaxNum), + }).forEach((_) => { + this.scope.addNamed( + "functionDef", + this.makeFunction(functionArgsMinNum, functionArgsMaxNum), + ); }); - // One of the traits could be implemented by the main contract. - const traitToImplement = - traitsNum > 0 && randomBool() ? randomElement(traits) : undefined; - this.scope.addNamed("contract", this.makeContract(traitToImplement)); + Array.from({ + length: randomInt(constantsMinNum, constantsMaxNum), + }).forEach((_) => { + this.scope.addNamed("constantDef", this.makeConstant()); + }); } /** @@ -105,6 +216,7 @@ export class Program extends NamedGenerativeEntity { .concat(getStdlibTypes()) .map((entry) => fc.constant(entry)) : []; + const traits = Array.from(this.scope.getAllNamed("trait")).map((t) => t.generate(), ); @@ -175,4 +287,22 @@ export class Program extends NamedGenerativeEntity { private makeTrait(): Trait { return new Trait(this.scope); } + + private makeConstant(): ConstantDef { + const ty = createSample(TypeGen.fromScope(this.scope).generate()); + return ConstantDef.fromScope( + this.scope, + ty, + new Expression(this.scope, ty, { + useIdentifiersInExpressions: false, + }).generate(), + ); + } + + private makeFunction(minArgsNum: number, maxArgsNum: number): FunctionDef { + const ty = createSample( + TypeGen.fromScope(this.scope).generateFun(minArgsNum, maxArgsNum), + ); + return new FunctionDef(this.scope, "function", ty); + } } diff --git a/src/test/fuzzer/src/generators/receiver.ts b/src/test/fuzzer/src/generators/receiver.ts index 3afbf35afb..d832c386bf 100644 --- a/src/test/fuzzer/src/generators/receiver.ts +++ b/src/test/fuzzer/src/generators/receiver.ts @@ -14,11 +14,12 @@ import { } from "@/test/fuzzer/src/util"; import { Expression } from "@/test/fuzzer/src/generators/expression"; import { Parameter } from "@/test/fuzzer/src/generators/parameter"; -import { StatementExpression } from "@/test/fuzzer/src/generators/statement"; +import { Let, Statement } from "@/test/fuzzer/src/generators/statement"; import fc from "fast-check"; import { GlobalContext } from "@/test/fuzzer/src/context"; import { generateString } from "@/test/fuzzer/src/generators/uniform-expr-gen"; +import { FuzzConfig } from "@/test/fuzzer/src/config"; const RECEIVE_RETURN_TY: Type = { kind: "util", type: UtilType.Unit }; @@ -52,6 +53,32 @@ function generateExternalReceiverKind( return subKind.map((k) => GlobalContext.makeF.makeDummyReceiverExternal(k)); } +export interface ReceiveParameters { + /** + * Minimum number of let statements at the start of function body. + * @default FuzzConfig.letStatementsMinNum + */ + letStatementsMinNum: number; + + /** + * Maximum number of let statements at the start of function body. + * @default FuzzConfig.letStatementsMaxNum + */ + letStatementsMaxNum: number; + + /** + * Minimum number of statements in the function body (not counting initial let statements and final return) + * @default FuzzConfig.statementsMinLength + */ + statementsMinLength: number; + + /** + * Maximum number of statements in the function body (not counting initial let statements and final return) + * @default FuzzConfig.statementsMaxLength + */ + statementsMaxLength: number; +} + /** * An object that encapsulates an Ast.Receiver. */ @@ -62,9 +89,24 @@ export class Receive extends GenerativeEntity { /** Scope used within the generated receive method. */ private scope: Scope; - constructor(parentScope: Scope) { + private letStatementsMinNum: number; + private letStatementsMaxNum: number; + private statementsMinLength: number; + private statementsMaxLength: number; + + constructor(parentScope: Scope, params: Partial = {}) { super(RECEIVE_RETURN_TY); this.scope = new Scope("receive", parentScope); + const { + letStatementsMinNum = FuzzConfig.letStatementsMinNum, + letStatementsMaxNum = FuzzConfig.letStatementsMaxNum, + statementsMinLength = FuzzConfig.statementsMinLength, + statementsMaxLength = FuzzConfig.statementsMaxLength, + } = params; + this.letStatementsMinNum = letStatementsMinNum; + this.letStatementsMaxNum = letStatementsMaxNum; + this.statementsMinLength = statementsMinLength; + this.statementsMaxLength = statementsMaxLength; } private generateSelector(): fc.Arbitrary { @@ -127,17 +169,40 @@ export class Receive extends GenerativeEntity { private generateBody(): fc.Arbitrary { // Create a dummy expression to execute the bottom-up AST generation. - const expr = new Expression(this.scope, this.type).generate(); - const stmt = new StatementExpression(expr).generate(); - - const generatedLetBindings = Array.from( - this.scope.getAllNamed("let"), - ).map((c) => c.generate()); - const generatedStmts = Array.from( - this.scope.getAllUnnamed("statement"), - ).map((c) => c.generate()); - this.body = [...generatedLetBindings, ...generatedStmts, stmt]; - return fc.tuple(...this.body); + //const expr = new Expression(this.scope, this.type).generate(); + //const stmt = new StatementExpression(expr).generate(); + + //const generatedLetBindings = Array.from( + // this.scope.getAllNamed("let"), + //).map((c) => c.generate()); + //const generatedStmts = Array.from( + // this.scope.getAllUnnamed("statement"), + //).map((c) => c.generate()); + + // TODO: Make it generate arbitrary types + const generatedLetBindings = fc.array( + new Let( + this.scope, + { kind: "stdlib", type: StdlibType.Int }, + new Expression(this.scope, { + kind: "stdlib", + type: StdlibType.Int, + }).generate(), + ).generate(), + { + minLength: this.letStatementsMinNum, + maxLength: this.letStatementsMaxNum, + }, + ); + + const generatedStmts = fc.array(new Statement(this.scope).generate(), { + minLength: this.statementsMinLength, + maxLength: this.statementsMaxLength, + }); + + return fc + .tuple(generatedLetBindings, generatedStmts) + .map((tup) => tup.flat()); } public generate(): fc.Arbitrary { diff --git a/src/test/fuzzer/src/generators/statement.ts b/src/test/fuzzer/src/generators/statement.ts index 8e5b60d562..145641bae1 100644 --- a/src/test/fuzzer/src/generators/statement.ts +++ b/src/test/fuzzer/src/generators/statement.ts @@ -27,6 +27,7 @@ import type { Type } from "@/test/fuzzer/src/types"; import { Scope } from "@/test/fuzzer/src/scope"; import type { NamedScopeItemKind } from "@/test/fuzzer/src/scope"; import { GlobalContext } from "@/test/fuzzer/src/context"; +import { FuzzConfig } from "@/test/fuzzer/src/config"; /** Type all the imperative constructions have. */ const STMT_TY: Type = { kind: "util", type: UtilType.Unit }; @@ -230,7 +231,6 @@ export class ConditionStatement extends GenerativeEntity private parentScope: Scope, private trueStmts: fc.Arbitrary[], private falseStmts?: fc.Arbitrary[], - private elseif?: fc.Arbitrary, type: Type = STMT_TY, ) { super(type); @@ -297,13 +297,13 @@ export class StatementExpression extends GenerativeEntity { export interface StatementParameters { /** * Determines the maximum depth of nested statement blocks. - * @default 2 + * @default FuzzConfig.nestedBlocksNum */ nestedBlocksNum: number; /** * Number of statements in each block. - * @default 3 + * @default FuzzConfig.stmtsInBlock */ stmtsInBlock: number; } @@ -335,7 +335,10 @@ export class Statement extends GenerativeEntity { } super(type); - const { nestedBlocksNum = 2, stmtsInBlock = 3 } = params; + const { + nestedBlocksNum = FuzzConfig.nestedBlocksNum, + stmtsInBlock = FuzzConfig.stmtsInBlock, + } = params; this.nestedBlocksNum = nestedBlocksNum; this.stmtsInBlock = stmtsInBlock; diff --git a/src/test/fuzzer/src/generators/trait.ts b/src/test/fuzzer/src/generators/trait.ts index 66180da022..8cf7fb26b9 100644 --- a/src/test/fuzzer/src/generators/trait.ts +++ b/src/test/fuzzer/src/generators/trait.ts @@ -18,25 +18,26 @@ import { NamedGenerativeEntity } from "@/test/fuzzer/src/generators/generator"; import fc from "fast-check"; import { GlobalContext } from "@/test/fuzzer/src/context"; +import { FuzzConfig } from "@/test/fuzzer/src/config"; export interface TraitParameters { /** * Number of fields generated within a trait. - * @default 1 + * @default FuzzConfig.traitFieldNum */ - fieldNum: number; + traitFieldNum: number; /** * Number of method declarations generated within a trait. - * @default 1 + * @default FuzzConfig.traitMethodDeclarationsNum */ - methodDeclarationsNum: number; + traitMethodDeclarationsNum: number; /** * Number of constant declarations generated within a trait. - * @default 1 + * @default FuzzConfig.traitConstantNum */ - constantNum: number; + traitConstantNum: number; } /** @@ -66,13 +67,13 @@ export class Trait extends NamedGenerativeEntity { this.scope = scope; const { - fieldNum = 1, - methodDeclarationsNum = 1, - constantNum = 1, + traitFieldNum = FuzzConfig.traitFieldNum, + traitMethodDeclarationsNum = FuzzConfig.traitMethodDeclarationsNum, + traitConstantNum = FuzzConfig.traitConstantNum, } = params; - this.fieldNum = fieldNum; - this.methodDeclarationsNum = methodDeclarationsNum; - this.constantNum = constantNum; + this.fieldNum = traitFieldNum; + this.methodDeclarationsNum = traitMethodDeclarationsNum; + this.constantNum = traitConstantNum; this.prepareDeclarationTypes(); } @@ -84,7 +85,7 @@ export class Trait extends NamedGenerativeEntity { return ty.kind === "map" || randomBool() ? undefined : new Expression(this.scope, ty, { - useIdentifiers: false, + useIdentifiersInExpressions: false, }).generate(); } diff --git a/src/test/fuzzer/src/scope.ts b/src/test/fuzzer/src/scope.ts index abd51e5392..ab71e2a3fc 100644 --- a/src/test/fuzzer/src/scope.ts +++ b/src/test/fuzzer/src/scope.ts @@ -29,15 +29,18 @@ const namedScopeItemKinds = [ "parameter", ] as const; export type NamedScopeItemKind = (typeof namedScopeItemKinds)[number]; + +/* function isNamedScopeItemKind(val: string): val is NamedScopeItemKind { return namedScopeItemKinds.find((tpe) => tpe === val) ? true : false; } +*/ // eslint-disable-next-line @typescript-eslint/no-unused-vars -const unnamedScopeItemKinds = ["statement", "receive"] as const; -export type UnnamedScopeItemKind = (typeof unnamedScopeItemKinds)[number]; +//const unnamedScopeItemKinds = ["statement", "receive"] as const; +//export type UnnamedScopeItemKind = (typeof unnamedScopeItemKinds)[number]; -export type ScopeItemKind = NamedScopeItemKind | UnnamedScopeItemKind; +export type ScopeItemKind = NamedScopeItemKind; //| UnnamedScopeItemKind; /** Maps each ScopeItemKind to its respective GenerativeEntity specialization. */ type NamedGenerativeEntityMap = { @@ -55,10 +58,10 @@ type NamedGenerativeEntityMap = { contract: NamedGenerativeEntity; trait: NamedGenerativeEntity; }; -type GenerativeEntityMap = { +/*type GenerativeEntityMap = { statement: GenerativeEntity; receive: GenerativeEntity; -}; +};*/ /** * Scope contains AST entries generated during the bottom-up AST generation and @@ -72,11 +75,12 @@ export class Scope { /** * Contains AST entries generated during the bottom-up AST generation. - */ + * private mapUnnamed: Map< UnnamedScopeItemKind, Map> // eslint-disable-line @typescript-eslint/no-explicit-any > = new Map(); + */ private mapNamed: Map< NamedScopeItemKind, @@ -130,7 +134,7 @@ export class Scope { switch (kind) { case "let": case "parameter": - case "statement": + //case "statement": // eslint-disable-next-line @typescript-eslint/no-this-alias targetScope = this; break; @@ -146,7 +150,7 @@ export class Scope { case "methodDecl": case "methodDef": case "field": - case "receive": + //case "receive": targetScope = this.findParent("trait", "contract"); break; case "contract": @@ -165,7 +169,7 @@ export class Scope { /** * Put a new entity in the scope according to the Tact semantics. - */ + * public addUnnamed( _kind: T, _entity: GenerativeEntityMap[T], @@ -180,7 +184,7 @@ export class Scope { // .get(kind)! // .set(entity.idx, entity); // } - } + }*/ /** * Put a new entity in the scope according to the Tact semantics. @@ -191,18 +195,19 @@ export class Scope { ): void { const targetScope = this.getTargetScopeToAdd(kind); - if (isNamedScopeItemKind(kind)) { - if (targetScope.mapNamed.has(kind)) { - targetScope.mapNamed.get(kind)!.set(entity.name.text, entity); - } else { - targetScope.mapNamed - .set(kind, new Map()) - .get(kind)! - .set(entity.name.text, entity); - } + //if (isNamedScopeItemKind(kind)) { + if (targetScope.mapNamed.has(kind)) { + targetScope.mapNamed.get(kind)!.set(entity.name.text, entity); + } else { + targetScope.mapNamed + .set(kind, new Map()) + .get(kind)! + .set(entity.name.text, entity); } + //} } + /* public getAllUnnamed( _kind: T, ): GenerativeEntityMap[T][] { @@ -212,7 +217,7 @@ export class Scope { // return Array.from(kindMap.values()); // } // return []; - } + }*/ public getAllNamed( kind: T, @@ -325,9 +330,10 @@ export class Scope { */ // eslint-disable-next-line @typescript-eslint/no-explicit-any public getItems(kind: ScopeItemKind): GenerativeEntity[] { - const result = isNamedScopeItemKind(kind) - ? this.mapNamed.get(kind) - : this.mapUnnamed.get(kind); + //const result = isNamedScopeItemKind(kind) + // ? this.mapNamed.get(kind) + // : this.mapUnnamed.get(kind); + const result = this.mapNamed.get(kind); return result === undefined ? [] : Array.from(result.values()); } @@ -339,11 +345,11 @@ export class Scope { // eslint-disable-next-line @typescript-eslint/no-explicit-any acc?: GenerativeEntity[], // eslint-disable-next-line @typescript-eslint/no-explicit-any ): NamedGenerativeEntity[]; - public getItemsRecursive( - kind: UnnamedScopeItemKind, - // eslint-disable-next-line @typescript-eslint/no-explicit-any - acc?: GenerativeEntity[], // eslint-disable-next-line @typescript-eslint/no-explicit-any - ): GenerativeEntity[]; + //public getItemsRecursive( + // kind: UnnamedScopeItemKind, + // // eslint-disable-next-line @typescript-eslint/no-explicit-any + // acc?: GenerativeEntity[], // eslint-disable-next-line @typescript-eslint/no-explicit-any + //): GenerativeEntity[]; public getItemsRecursive( kind: ScopeItemKind, // eslint-disable-next-line @typescript-eslint/no-explicit-any @@ -353,9 +359,10 @@ export class Scope { const currentItems = this.getItems(kind); const accN = acc.concat(currentItems); if (!this.isProgramScope() && this.parentScope) - return isNamedScopeItemKind(kind) - ? this.parentScope.getItemsRecursive(kind, accN) - : this.parentScope.getItemsRecursive(kind, accN); + //return isNamedScopeItemKind(kind) + // ? this.parentScope.getItemsRecursive(kind, accN) + // : this.parentScope.getItemsRecursive(kind, accN); + return this.parentScope.getItemsRecursive(kind, accN); else { return accN; } diff --git a/src/test/fuzzer/src/types.ts b/src/test/fuzzer/src/types.ts index 24bfdbaa60..37ca2f5742 100644 --- a/src/test/fuzzer/src/types.ts +++ b/src/test/fuzzer/src/types.ts @@ -9,7 +9,7 @@ import { } from "@/test/fuzzer/src/util"; import type { Scope } from "@/test/fuzzer/src/scope"; import type { TypeRef } from "@/types/types"; -import fc, { option } from "fast-check"; +import fc from "fast-check"; import { GlobalContext } from "@/test/fuzzer/src/context"; /**