[Tolk] Support intN and bool constants

Constant evaluator has been rewritten to utilize
type inferring mechanism. Now,
> const a = 1 as int8;
is valid, and constants can not only be int/slice, but
also intN/uintN and bool.

Author: tolk-vm

tolk-tester/tests/co1.tolk

@@ -16,6 +16,16 @@ const str2int = 0xAABBCC;
 
 const nibbles: int = 4;
 
+const strange_zero = (!10 as int);
+const strange_minus_1: int = (!0 as int);
+
+const true1 = true;
+const true2 = !!true;
+const true3 = true1 && true2;
+
+const false1 = !true;
+const false2 = false1 || false;
+
 fun iget1(): int { return int1; }
 fun iget2(): int { return int2; }
 fun iget3(): int { return int1+int2; }
@@ -43,6 +53,21 @@ asm "SDEQ";
 fun stslicer(b: builder, s: slice): builder
 asm "STSLICER";
 
+@method_id(101)
+fun test1() {
+    return (strange_zero, strange_minus_1);
+}
+
+@method_id(102)
+fun test2() {
+    return (true1, true2, true3);
+}
+
+@method_id(103)
+fun test3() {
+    return (false1, false2);
+}
+
 fun main() {
     var i1: int = iget1();
     var i2: int = iget2();
@@ -66,7 +91,10 @@ fun main() {
 }
 
 /**
-@testcase | 0 | | 0
+@testcase | 0   |   | 0
+@testcase | 101 |   | 0 -1
+@testcase | 102 |   | -1 -1 -1
+@testcase | 103 |   | 0 0
 
-@code_hash 61273295789179921867241079778489100375537711211918844448475493726205774530743
+@code_hash 28102194299745406750019953961984060488024870092664444642078578246708959881688
 */

tolk-tester/tests/intN-tests.tolk

@@ -3,6 +3,9 @@ fun getAnyInt(): int { return 0; }
 fun getNullableInt32(): int32? { return 32; }
 fun getNullableVarInt32(): varint32? { return 32; }
 
+const someN_u128: uint128 = 128;
+const someN_i32: int32 = 20 + (12 as int32) * (1 as uint8);
+
 
 fun autoInferInt8(x: int8) {
     if (random()) { return x; }
@@ -50,7 +53,8 @@ fun test1(x: int8) {
 
     var z = x + y;
     __expect_type(z, "int");
-    return x / y;
+    __expect_type(someN_u128, "uint128");
+    return x / y + someN_u128;
 }
 
 fun test2(): (uint8, uint8, uint8) {
@@ -60,6 +64,7 @@ fun test2(): (uint8, uint8, uint8) {
 
 fun test3(op: int32, qid: uint64) {
     op = qid as int32;
+    op = someN_i32;
 
     op + qid;
     op = op + qid;
@@ -166,7 +171,7 @@ fun main() {
 
 /**
 @testcase | 0 |        | [ 0 0 0 ]
-@testcase | 101 | 0    | 1
+@testcase | 101 | 0    | 129
 @testcase | 104 |      | 64 64 -1 0
 @testcase | 105 |      | 3 -1 0
 @testcase | 114 | 5    | (null) (null) 0

tolk-tester/tests/invalid-cyclic-1.tolk

@@ -3,6 +3,5 @@ const TWO = ONE + 1;
 
 /**
 @compilation_should_fail
-@stderr const ONE
-@stderr undefined symbol `TWO`
+@stderr const `TWO` appears, directly or indirectly, in its own initializer
  */

tolk-tester/tests/invalid-declaration-13.tolk

@@ -2,6 +2,6 @@ const c: slice = 123 + 456;
 
 /**
 @compilation_should_fail
-@stderr expression type does not match declared type
+@stderr can not assign `int` to `slice`
 @stderr const c
  */

tolk-tester/tests/invalid-declaration-14.tolk

@@ -0,0 +1,7 @@
+const ttt = 1;
+const asdf = ttt<int>;
+
+/**
+@compilation_should_fail
+@stderr generic T not expected here
+ */

tolk-tester/tests/invalid-declaration-15.tolk

@@ -0,0 +1,6 @@
+const asdf = ttt;
+
+/**
+@compilation_should_fail
+@stderr undefined symbol `ttt`
+ */

tolk-tester/tests/invalid-declaration-16.tolk

@@ -0,0 +1,9 @@
+fun foo() { return 1; }
+
+const asdf = 1 + foo();
+
+/**
+@compilation_should_fail
+@stderr not a constant expression
+@stderr const asdf
+ */

tolk-tester/tests/invalid-typing-35.tolk

@@ -0,0 +1,6 @@
+const asdf = 1 + "";
+
+/**
+@compilation_should_fail
+@stderr can not apply operator `+` to `int` and `slice`
+ */

tolk/ast-replacer.h

@@ -187,6 +187,7 @@ class ASTReplacerInFunctionBody : public ASTReplacer {
 
 
 const std::vector<FunctionPtr>& get_all_not_builtin_functions();
+const std::vector<GlobalConstPtr>& get_all_declared_constants();
 
 template<class BodyReplacerT>
 void replace_ast_of_all_functions() {

tolk/ast-visitor.h

@@ -180,6 +180,7 @@ class ASTVisitorFunctionBody : public ASTVisitor {
 
 
 const std::vector<FunctionPtr>& get_all_not_builtin_functions();
+const std::vector<GlobalConstPtr>& get_all_declared_constants();
 
 template<class BodyVisitorT>
 void visit_ast_of_all_functions() {

tolk/compiler-state.cpp

@@ -70,4 +70,8 @@ const std::vector<FunctionPtr>& get_all_not_builtin_functions() {
   return G.all_functions;
 }
 
+const std::vector<GlobalConstPtr>& get_all_declared_constants() {
+  return G.all_constants;
+}
+
 } // namespace tolk

tolk/constant-evaluator.cpp

@@ -147,17 +147,21 @@ static td::RefInt256 parse_vertex_string_const_as_int(V<ast_string_const> v) {
   }
 }
 
+static ConstantValue parse_vertex_string_const(V<ast_string_const> v) {
+  return v->is_bitslice()
+    ? ConstantValue(parse_vertex_string_const_as_slice(v))
+    : ConstantValue(parse_vertex_string_const_as_int(v));
+}
+
 
 struct ConstantEvaluator {
   static bool is_overflow(const td::RefInt256& intval) {
     return intval.is_null() || !intval->signed_fits_bits(257);
   }
 
   static ConstantValue handle_unary_operator(V<ast_unary_operator> v, const ConstantValue& rhs) {
-    if (!rhs.is_int()) {
-      v->error("invalid operator, expecting integer");
-    }
-    td::RefInt256 intval = std::get<td::RefInt256>(rhs.value);
+    tolk_assert(rhs.is_int());   // type inferring has passed before, so it's int/bool
+    td::RefInt256 intval = rhs.as_int();
 
     switch (v->tok) {
       case tok_minus:
@@ -167,7 +171,7 @@ struct ConstantEvaluator {
         break;
       case tok_bitwise_not:
         intval = ~intval;
-      break;
+        break;
       case tok_logical_not:
         intval = td::make_refint(intval == 0 ? -1 : 0);
         break;
@@ -178,15 +182,13 @@ struct ConstantEvaluator {
     if (is_overflow(intval)) {
       v->error("integer overflow");
     }
-    return ConstantValue::from_int(std::move(intval));
+    return ConstantValue(std::move(intval));
   }
 
   static ConstantValue handle_binary_operator(V<ast_binary_operator> v, const ConstantValue& lhs, const ConstantValue& rhs) {
-    if (!lhs.is_int() || !rhs.is_int()) {
-      v->error("invalid operator, expecting integer");
-    }
-    td::RefInt256 lhs_intval = std::get<td::RefInt256>(lhs.value);
-    td::RefInt256 rhs_intval = std::get<td::RefInt256>(rhs.value);
+    tolk_assert(lhs.is_int() && rhs.is_int());   // type inferring has passed before, so they are int/bool
+    td::RefInt256 lhs_intval = lhs.as_int();
+    td::RefInt256 rhs_intval = rhs.as_int();
     td::RefInt256 intval;
 
     switch (v->tok) {
@@ -238,39 +240,41 @@ struct ConstantEvaluator {
       case tok_neq:
         intval = td::make_refint(lhs_intval != rhs_intval ? -1 : 0);
         break;
+      case tok_logical_and:
+        intval = td::make_refint(lhs_intval != 0 && rhs_intval != 0 ? -1 : 0);
+        break;
+      case tok_logical_or:
+        intval = td::make_refint(lhs_intval != 0 || rhs_intval != 0 ? -1 : 0);
+        break;
       default:
         v->error("unsupported binary operator in constant expression");
     }
 
     if (is_overflow(intval)) {
       v->error("integer overflow");
     }
-    return ConstantValue::from_int(std::move(intval));
+    return ConstantValue(std::move(intval));
   }
 
+  // `const a = 1 + b`, we met `b`
   static ConstantValue handle_reference(V<ast_reference> v) {
-    // todo better handle "appears, directly or indirectly, in its own initializer"
-    std::string_view name = v->get_name();
-    const Symbol* sym = lookup_global_symbol(name);
-    if (!sym) {
-      v->error("undefined symbol `" + static_cast<std::string>(name) + "`");
-    }
-    GlobalConstPtr const_ref = sym->try_as<GlobalConstPtr>();
+    GlobalConstPtr const_ref = v->sym->try_as<GlobalConstPtr>();
     if (!const_ref) {
-      v->error("symbol `" + static_cast<std::string>(name) + "` is not a constant");
+      v->error("symbol `" + static_cast<std::string>(v->get_name()) + "` is not a constant");
     }
-    if (v->has_instantiationTs()) {   // SOME_CONST<int>
-      v->error("constant is not a generic");
+
+    if (!const_ref->value.initialized()) {          // maybe, `b` was already calculated
+      eval_and_assign_const_init_value(const_ref);  // if not, dig recursively into `b`
     }
-    return {const_ref->value};
+    return const_ref->value;
   }
 
   static ConstantValue visit(AnyExprV v) {
     if (auto v_int = v->try_as<ast_int_const>()) {
-      return ConstantValue::from_int(v_int->intval);
+      return ConstantValue(v_int->intval);
     }
     if (auto v_bool = v->try_as<ast_bool_const>()) {
-      return ConstantValue::from_int(v_bool->bool_val ? -1 : 0);
+      return ConstantValue(v_bool->bool_val ? -1 : 0);
     }
     if (auto v_unop = v->try_as<ast_unary_operator>()) {
       return handle_unary_operator(v_unop, visit(v_unop->get_rhs()));
@@ -284,34 +288,32 @@ struct ConstantEvaluator {
     if (auto v_par = v->try_as<ast_parenthesized_expression>()) {
       return visit(v_par->get_expr());
     }
-    if (v->try_as<ast_string_const>()) {
-      return eval_const_init_value(v);
+    if (auto v_cast_to = v->try_as<ast_cast_as_operator>()) {
+      return visit(v_cast_to->get_expr());
+    }
+    if (auto v_string = v->try_as<ast_string_const>()) {
+      return parse_vertex_string_const(v_string);
     }
     v->error("not a constant expression");
   }
 
-  static ConstantValue eval_const_init_value(AnyExprV init_value) {
-    // it init_value is incorrect, an exception is thrown
-    return visit(init_value);
+  // evaluate `const a = 2 + 3` into 5
+  // type inferring has already passed, to types are correct, `const a = 1 + ""` can not occur
+  // recursive initializers `const a = b; const b = a` also 100% don't exist, checked on type inferring
+  // if init_value is not a constant expression like `const a = foo()`, an exception is thrown
+  static ConstantValue eval_const_init_value(GlobalConstPtr const_ref) {
+    return visit(const_ref->init_value);
   }
 };
 
-ConstantValue eval_const_init_value(AnyExprV init_value) {
-  // at first, handle most simple cases, not to launch heavy computation algorithm: just a number, just a string
-  // just `c = 1` or `c = 0xFF`
-  if (auto v_int = init_value->try_as<ast_int_const>()) {
-    return {v_int->intval};
-  }
-  // just `c = "strval"`, probably with modifier (address, etc.)
-  if (auto v_string = init_value->try_as<ast_string_const>()) {
-    if (v_string->is_bitslice()) {
-      return {parse_vertex_string_const_as_slice(v_string)};
-    } else {
-      return {parse_vertex_string_const_as_int(v_string)};
-    }
-  }
-  // something more complex, like `c = anotherC` or `c = 1 << 8`
-  return ConstantEvaluator::eval_const_init_value(init_value);
+ConstantValue eval_string_const_considering_modifier(AnyExprV v_string) {
+  tolk_assert(v_string->type == ast_string_const);
+  return parse_vertex_string_const(v_string->as<ast_string_const>());
+}
+
+void eval_and_assign_const_init_value(GlobalConstPtr const_ref) {
+  ConstantValue init_value = ConstantEvaluator::eval_const_init_value(const_ref);
+  const_ref->mutate()->assign_const_value(std::move(init_value));
 }
 
 } // namespace tolk

tolk/constant-evaluator.h

@@ -22,24 +22,32 @@
 
 namespace tolk {
 
-struct ConstantValue {
-  std::variant<td::RefInt256, std::string> value;
+class ConstantValue {
+  std::variant<
+    td::RefInt256,    // is set for int, intN, coins, bool
+    std::string       // is set for slice, bytesN
+  > value;
+
+public:
+  ConstantValue() = default;    // by default, not initialized
+
+  explicit ConstantValue(int value)
+    : value(td::make_refint(value)) {}
+  explicit ConstantValue(td::RefInt256 value)
+    : value(std::move(value)) {}
+  explicit ConstantValue(std::string value)
+    : value(std::move(value)) {}
+
+  bool initialized() const { return is_slice() || std::get<td::RefInt256>(value).not_null(); }
 
   bool is_int() const { return std::holds_alternative<td::RefInt256>(value); }
   bool is_slice() const { return std::holds_alternative<std::string>(value); }
 
   td::RefInt256 as_int() const { return std::get<td::RefInt256>(value); }
   const std::string& as_slice() const { return std::get<std::string>(value); }
-
-  static ConstantValue from_int(int value) {
-    return {td::make_refint(value)};
-  }
-
-  static ConstantValue from_int(td::RefInt256 value) {
-    return {std::move(value)};
-  }
 };
 
-ConstantValue eval_const_init_value(AnyExprV init_value);
+ConstantValue eval_string_const_considering_modifier(AnyExprV v_string);
+void eval_and_assign_const_init_value(GlobalConstPtr const_ref);
 
 } // namespace tolk

tolk/pipe-ast-to-legacy.cpp

@@ -644,13 +644,13 @@ std::vector<var_idx_t> pre_compile_symbol(SrcLocation loc, const Symbol* sym, Co
     return local_ir_idx;
   }
   if (GlobalConstPtr const_ref = sym->try_as<GlobalConstPtr>()) {
-    if (const_ref->is_int_const()) {
+    if (const_ref->value.is_int()) {
       std::vector<var_idx_t> rvect = code.create_tmp_var(TypeDataInt::create(), loc, "(glob-const)");
-      code.emplace_back(loc, Op::_IntConst, rvect, const_ref->as_int_const());
+      code.emplace_back(loc, Op::_IntConst, rvect, const_ref->value.as_int());
       return rvect;
     } else {
       std::vector<var_idx_t> rvect = code.create_tmp_var(TypeDataSlice::create(), loc, "(glob-const)");
-      code.emplace_back(loc, Op::_SliceConst, rvect, const_ref->as_slice_const());
+      code.emplace_back(loc, Op::_SliceConst, rvect, const_ref->value.as_slice());
       return rvect;
     }
   }
@@ -1013,7 +1013,7 @@ static std::vector<var_idx_t> process_int_const(V<ast_int_const> v, CodeBlob& co
 }
 
 static std::vector<var_idx_t> process_string_const(V<ast_string_const> v, CodeBlob& code, TypePtr target_type) {
-  ConstantValue value = eval_const_init_value(v);
+  ConstantValue value = eval_string_const_considering_modifier(v);
   std::vector<var_idx_t> rvect = code.create_tmp_var(v->inferred_type, v->loc, "(str-const)");
   if (value.is_int()) {
     code.emplace_back(v->loc, Op::_IntConst, rvect, value.as_int());