FunC v0.5.0: syntax, refactoring, bugfixes, and a testing framework

.gitignore

@@ -13,6 +13,8 @@ test/regression-tests.cache/
 **/*build*/
 .idea
 .vscode
+dev/
+.DS_Store
 zlib/
 libsodium/
 libmicrohttpd-0.9.77-w32-bin/

crypto/CMakeLists.txt

@@ -390,6 +390,10 @@ target_link_libraries(func PUBLIC ton_crypto src_parser git ton_block)
 if (WINGETOPT_FOUND)
   target_link_libraries_system(func wingetopt)
 endif()
+if (${FUNC_DEBUG}) # -DFUNC_DEBUG=1 in CMake options => #define FUNC_DEBUG (for development purposes)
+  message(STATUS "FUNC_DEBUG is ON")
+  target_compile_definitions(func PRIVATE FUNC_DEBUG=1)
+endif()
 
 if (USE_EMSCRIPTEN)
   add_executable(funcfiftlib funcfiftlib/funcfiftlib.cpp ${FUNC_LIB_SOURCE})

crypto/fift/utils.cpp

@@ -112,7 +112,7 @@ class MemoryFileLoader : public fift::FileLoader {
   std::map<std::string, std::string, std::less<>> files_;
 };
 
-td::Result<fift::SourceLookup> create_source_lookup(std::string main, bool need_preamble = true, bool need_asm = true,
+td::Result<fift::SourceLookup> create_source_lookup(std::string&& main, bool need_preamble = true, bool need_asm = true,
                                                     bool need_ton_util = true, bool need_lisp = true,
                                                     bool need_w3_code = true, bool need_fift_ext = true,
                                                     bool need_disasm = true, std::string dir = "") {
@@ -187,7 +187,7 @@ td::Result<fift::SourceLookup> run_fift(fift::SourceLookup source_lookup, std::o
 }  // namespace
 td::Result<FiftOutput> mem_run_fift(std::string source, std::vector<std::string> args, std::string fift_dir) {
   std::stringstream ss;
-  TRY_RESULT(source_lookup, create_source_lookup(source, true, true, true, true, true, true, true, fift_dir));
+  TRY_RESULT(source_lookup, create_source_lookup(std::move(source), true, true, true, true, true, true, true, fift_dir));
   TRY_RESULT_ASSIGN(source_lookup, run_fift(std::move(source_lookup), &ss, true, std::move(args)));
   FiftOutput res;
   res.source_lookup = std::move(source_lookup);
@@ -205,16 +205,21 @@ td::Result<FiftOutput> mem_run_fift(SourceLookup source_lookup, std::vector<std:
 td::Result<fift::SourceLookup> create_mem_source_lookup(std::string main, std::string fift_dir, bool need_preamble,
                                                         bool need_asm, bool need_ton_util, bool need_lisp,
                                                         bool need_w3_code) {
-  return create_source_lookup(main, need_preamble, need_asm, need_ton_util, need_lisp, need_w3_code, false, false,
+  return create_source_lookup(std::move(main), need_preamble, need_asm, need_ton_util, need_lisp, need_w3_code, false, false,
                               fift_dir);
 }
 
 td::Result<td::Ref<vm::Cell>> compile_asm(td::Slice asm_code, std::string fift_dir, bool is_raw) {
   std::stringstream ss;
-  TRY_RESULT(source_lookup,
-             create_source_lookup(PSTRING() << "\"Asm.fif\" include\n " << (is_raw ? "<{" : "") << asm_code << "\n"
-                                            << (is_raw ? "}>c" : "") << " boc>B \"res\" B>file",
-                                  true, true, true, false, false, false, false, fift_dir));
+  std::string sb;
+  sb.reserve(asm_code.size() + 100);
+  sb.append("\"Asm.fif\" include\n ");
+  sb.append(is_raw ? "<{" : "");
+  sb.append(asm_code.data(), asm_code.size());
+  sb.append(is_raw ? "}>c" : "");
+  sb.append(" boc>B \"res\" B>file");
+
+  TRY_RESULT(source_lookup, create_source_lookup(std::move(sb), true, true, true, false, false, false, false, fift_dir));
   TRY_RESULT(res, run_fift(std::move(source_lookup), &ss));
   TRY_RESULT(boc, res.read_file("res"));
   return vm::std_boc_deserialize(std::move(boc.data));

crypto/func/abscode.cpp

@@ -223,15 +223,6 @@ void VarDescrList::show(std::ostream& os) const {
   os << " ]\n";
 }
 
-void Op::flags_set_clear(int set, int clear) {
-  flags = (flags | set) & ~clear;
-  for (auto& op : block0) {
-    op.flags_set_clear(set, clear);
-  }
-  for (auto& op : block1) {
-    op.flags_set_clear(set, clear);
-  }
-}
 void Op::split_vars(const std::vector<TmpVar>& vars) {
   split_var_list(left, vars);
   split_var_list(right, vars);
@@ -296,7 +287,7 @@ void Op::show(std::ostream& os, const std::vector<TmpVar>& vars, std::string pfx
   if (noreturn()) {
     dis += "<noret> ";
   }
-  if (!is_pure()) {
+  if (impure()) {
     dis += "<impure> ";
   }
   switch (cl) {
@@ -469,12 +460,6 @@ void Op::show_block(std::ostream& os, const Op* block, const std::vector<TmpVar>
   os << pfx << "}";
 }
 
-void CodeBlob::flags_set_clear(int set, int clear) {
-  for (auto& op : ops) {
-    op.flags_set_clear(set, clear);
-  }
-}
-
 std::ostream& operator<<(std::ostream& os, const CodeBlob& code) {
   code.print(os);
   return os;

crypto/func/analyzer.cpp

@@ -360,10 +360,10 @@ bool Op::compute_used_vars(const CodeBlob& code, bool edit) {
     case _Tuple:
     case _UnTuple: {
       // left = EXEC right;
-      if (!next_var_info.count_used(left) && is_pure()) {
+      if (!next_var_info.count_used(left) && !impure()) {
         // all variables in `left` are not needed
         if (edit) {
-          disable();
+          set_disabled();
         }
         return std_compute_used_vars(true);
       }
@@ -372,7 +372,7 @@ bool Op::compute_used_vars(const CodeBlob& code, bool edit) {
     case _SetGlob: {
       // GLOB = right
       if (right.empty() && edit) {
-        disable();
+        set_disabled();
       }
       return std_compute_used_vars(right.empty());
     }
@@ -399,7 +399,7 @@ bool Op::compute_used_vars(const CodeBlob& code, bool edit) {
       }
       if (!cnt && edit) {
         // all variables in `left` are not needed
-        disable();
+        set_disabled();
       }
       return set_var_info(std::move(new_var_info));
     }
@@ -860,15 +860,45 @@ VarDescrList Op::fwd_analyze(VarDescrList values) {
   }
 }
 
-bool Op::set_noreturn(bool nr) {
-  if (nr) {
+void Op::set_disabled(bool flag) {
+  if (flag) {
+    flags |= _Disabled;
+  } else {
+    flags &= ~_Disabled;
+  }
+}
+
+
+bool Op::set_noreturn(bool flag) {
+  if (flag) {
     flags |= _NoReturn;
   } else {
     flags &= ~_NoReturn;
   }
-  return nr;
+  return flag;
+}
+
+void Op::set_impure(const CodeBlob &code) {
+  // todo calling this function with `code` is a bad design (flags are assigned after Op is constructed)
+  // later it's better to check this somewhere in code.emplace_back()
+  if (code.flags & CodeBlob::_ForbidImpure) {
+    throw src::ParseError(where, "An impure operation in a pure function");
+  }
+  flags |= _Impure;
 }
 
+void Op::set_impure(const CodeBlob &code, bool flag) {
+  if (flag) {
+    if (code.flags & CodeBlob::_ForbidImpure) {
+      throw src::ParseError(where, "An impure operation in a pure function");
+    }
+    flags |= _Impure;
+  } else {
+    flags &= ~_Impure;
+  }
+}
+
+
 bool Op::mark_noreturn() {
   switch (cl) {
     case _Nop:
@@ -888,13 +918,14 @@ bool Op::mark_noreturn() {
     case _Call:
       return set_noreturn(next->mark_noreturn());
     case _Return:
-      return set_noreturn(true);
+      return set_noreturn();
     case _If:
     case _TryCatch:
+      // note, that & | (not && ||) here and below is mandatory to invoke both left and right calls
       return set_noreturn((block0->mark_noreturn() & (block1 && block1->mark_noreturn())) | next->mark_noreturn());
     case _Again:
       block0->mark_noreturn();
-      return set_noreturn(true);
+      return set_noreturn();
     case _Until:
       return set_noreturn(block0->mark_noreturn() | next->mark_noreturn());
     case _While:

crypto/func/asmops.cpp

@@ -320,6 +320,9 @@ void AsmOpList::show_var_ext(std::ostream& os, std::pair<var_idx_t, const_idx_t>
     os << '_' << i;
   } else {
     var_names_->at(i).show(os, 2);
+    // if (!var_names_->at(i).v_type->is_int()) {
+    //   os << '<'; var_names_->at(i).v_type->print(os); os << '>';
+    // }
   }
   if ((unsigned)j < constants_.size() && constants_[j].not_null()) {
     os << '=' << constants_[j];

crypto/func/auto-tests/legacy_tester.js

@@ -1,27 +1,68 @@
-const fs = require('fs/promises');
+// Usage: `node legacy_tests.js` from current dir, providing some env (see getenv() calls).
+// This is a JS version of legacy_tester.py to test FunC compiled to WASM.
+
+const fs = require('fs');
+const path = require('path')
+const process = require('process');
 const { compileWasm, compileFile } = require('./wasm_tests_common');
 
+
+/** @return {string} */
+function getenv(name, def = null) {
+    if (name in process.env)
+        return process.env[name]
+    if (def === null) {
+        console.log(`Environment variable ${name} is not set`)
+        process.exit(1)
+    }
+    return def
+}
+
+const FUNCFIFTLIB_MODULE = getenv('FUNCFIFTLIB_MODULE')
+const FUNCFIFTLIB_WASM = getenv('FUNCFIFTLIB_WASM')
+const TESTS_DIR = "legacy_tests"
+
+/**
+ * @return {{filename: string, code_hash: BigInt}[]}
+ */
+function load_legacy_tests_list(jsonl_filename) {
+    let contents = fs.readFileSync(jsonl_filename)
+    let results = [...contents.toString().matchAll(/^\[\s*"(.*?)"\s*,\s*(.*?)\s*]/gms)]
+    return results.map((line) => ({
+        filename: line[1].trim(),
+        code_hash: BigInt(line[2]),
+    }))
+}
+
 async function main() {
-    const tests = JSON.parse((await fs.readFile('../legacy_tests.json')).toString('utf-8'))
+    const tests = load_legacy_tests_list('legacy_tests.jsonl')
 
-    for (const [filename, hashstr] of tests) {
-        if (filename.includes('storage-provider')) continue;
+    for (let ti = 0; ti < tests.length; ++ti) {
+        const {filename: filename_rel, code_hash} = tests[ti]
+        const filename = path.join(TESTS_DIR, filename_rel)
+        console.log(`Running test ${ti + 1}/${tests.length}: ${filename_rel}`)
 
-        const mod = await compileWasm()
+        if (filename.includes('storage-provider')) {
+            console.log("  Skip");
+            continue;
+        }
 
-        const response = await compileFile(mod, filename);
+        const wasmModule = await compileWasm(FUNCFIFTLIB_MODULE, FUNCFIFTLIB_WASM)
+        const response = compileFile(wasmModule, filename);
 
         if (response.status !== 'ok') {
             console.error(response);
-            throw new Error('Could not compile ' + filename);
+            throw new Error(`Could not compile ${filename}`);
         }
 
-        if (BigInt('0x' + response.codeHashHex) !== BigInt(hashstr)) {
-            throw new Error('Compilation result is different for ' + filename);
+        if (BigInt('0x' + response.codeHashHex) !== code_hash) {
+            throw new Error(`Code hash is different for ${filename}`);
         }
 
-        console.log(filename, 'ok');
+        console.log('  OK  ');
     }
+
+    console.log(`Done ${tests.length}`)
 }
 
-main()
+main().catch(console.error)