[Tolk] Types bytesN and bitsN backed by TVM slice

Their purpose is exactly like `intN`: future serialization,
to specify fixed-size binary fields (like TL/B bits256).

Note, that unlike intN, explicit casting is required.
> fun calcHash(raw: bits512) { }
> calcHash(someSlice); // error
> calcHash(someSlice as bits512); // ok

Author: tolk-vm

tolk-tester/tests/bytesN-tests.tolk

@@ -0,0 +1,48 @@
+fun takeAnySlice(slice: slice) {}
+fun getSomeSlice() { return beginCell().endCell().beginParse(); }
+fun getNullableBytes16(): bytes16? { return getSomeSlice() as bytes16; }
+
+const someBytes = "asdf" as bytes16;
+const anotherBytes: bytes16 = "asdf" as bytes16;
+
+fun autoInferBytes16() {
+    if (random()) { return someBytes; }
+    else if (random()) { return true ? "" as bytes16 : anotherBytes; }
+    else { return someBytes!; }
+}
+
+@method_id(101)
+fun test1() {
+    var ss = beginCell().storeInt(1, 32).storeInt(2, 32).endCell().beginParse() as bits32;
+    __expect_type(ss, "bits32");
+    __expect_type(ss as slice, "slice");
+    __expect_type(ss as slice?, "slice?");
+    __expect_type(ss as bytes128, "bytes128");
+    __expect_type(someBytes, "bytes16");
+    __expect_type(10>3 ? (null, ss as bits1) : (ss as bytes1, null), "(bytes1?, bits1?)");
+    return (getRemainingBitsCount(ss as slice), loadInt(mutate ss as slice, 32), (ss as slice).loadInt(32));
+}
+
+fun test2(a: bytes8, b: bits64) {
+    a = b as bytes8;
+    b = a as bits64;
+    (a as slice).loadRef();
+    (b as slice?)!.loadRef();
+}
+
+@method_id(103)
+fun test3() {
+    var slice = beginCell().storeInt(1, 32).storeInt(2, 32).endCell().beginParse();
+    var bq = slice as bits16?;
+    if (bq != null) {
+        return (bq as slice).loadInt(32 as uint8) + (slice = bq as slice).getRemainingBitsCount();
+    }
+    return -1;
+}
+
+fun main() {}
+
+/**
+@testcase | 101 |    | 64 1 2
+@testcase | 103 |    | 33
+ */

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

@@ -0,0 +1,9 @@
+fun cantUnifyBytesNAndBytesM(n: bytes8, c: bytes16) {
+    __expect_type(random() ? n : c as bytes8, "bytes8");
+    random() ? n : c;
+}
+
+/**
+@compilation_should_fail
+@stderr types of ternary branches are incompatible: `bytes8` and `bytes16`
+ */

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

@@ -0,0 +1,10 @@
+fun cantUnifyBytesNAndSlice(n: slice, c: bytes16) {
+    __expect_type(random() ? n : c as slice, "slice");
+    __expect_type(random() ? n : c as slice?, "slice?");
+    random() ? n : c;
+}
+
+/**
+@compilation_should_fail
+@stderr types of ternary branches are incompatible: `slice` and `bytes16`
+ */

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

@@ -0,0 +1,12 @@
+fun takeAnySlice(s: slice) {}
+
+fun cantPassBytesNToSlice(c: bits16) {
+    takeAnySlice(c as slice);    // ok
+    takeAnySlice(c);
+}
+
+/**
+@compilation_should_fail
+@stderr can not pass `bits16` to `slice`
+@stderr takeAnySlice(c);
+ */

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

@@ -0,0 +1,12 @@
+fun getAnySlice() { return beginCell().endCell().beginParse(); }
+
+fun cantAssignSliceToBytesN() {
+    var c1: bytes16 = getAnySlice() as bytes16;    // ok
+    var c2: bytes16 = getAnySlice();
+}
+
+/**
+@compilation_should_fail
+@stderr can not assign `slice` to variable of type `bytes16`
+@stderr var c2: bytes16 = getAnySlice();
+ */

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

@@ -0,0 +1,9 @@
+fun cantAutoCastBytesNToSlice() {
+    var b = beginCell().storeInt(1, 32).endCell().beginParse() as bits32;
+    return b.loadInt(32);
+}
+
+/**
+@compilation_should_fail
+@stderr can not call method for `slice` with object of type `bits32`
+ */

tolk/pipe-ast-to-legacy.cpp

@@ -581,6 +581,22 @@ static std::vector<var_idx_t> transition_expr_to_runtime_type_impl(std::vector<v
   if (original_type == TypeDataCoins::create() && target_type->try_as<TypeDataIntN>()) {
     return rvect;
   }
+  // pass `bytes32` to `slice`
+  // in code, it's probably done with `as` operator
+  // no changes in rvect, since bytesN is slice at TVM level
+  if (target_type == TypeDataSlice::create() && original_type->try_as<TypeDataBytesN>()) {
+    return rvect;
+  }
+  // pass `slice` to `bytes32`
+  // same as above
+  if (original_type == TypeDataSlice::create() && target_type->try_as<TypeDataBytesN>()) {
+    return rvect;
+  }
+  // pass `bytes32` to `bytes64` / `bits128` to `bytes16`
+  // no changes in rvect
+  if (original_type->try_as<TypeDataBytesN>() && target_type->try_as<TypeDataBytesN>()) {
+    return rvect;
+  }
   // pass something to `unknown`
   // probably, it comes from `_ = rhs`, type of `_` is unknown, it's target_type of rhs
   // no changes in rvect

tolk/type-system.cpp

@@ -193,6 +193,17 @@ TypePtr TypeDataIntN::create(bool is_unsigned, bool is_variadic, int n_bits) {
   return hash.register_unique(new TypeDataIntN(hash.type_id(), is_unsigned, is_variadic, n_bits));
 }
 
+TypePtr TypeDataBytesN::create(bool is_bits, int n_width) {
+  TypeDataTypeIdCalculation hash(7810988137199333041ULL);
+  hash.feed_hash(is_bits);
+  hash.feed_hash(n_width);
+
+  if (TypePtr existing = hash.get_existing()) {
+    return existing;
+  }
+  return hash.register_unique(new TypeDataBytesN(hash.type_id(), is_bits, n_width));
+}
+
 TypePtr TypeDataUnresolved::create(std::string&& text, SrcLocation loc) {
   TypeDataTypeIdCalculation hash(3680147223540048162ULL);
   hash.feed_string(text);
@@ -262,6 +273,11 @@ std::string TypeDataIntN::as_human_readable() const {
   return s_int + std::to_string(n_bits);
 }
 
+std::string TypeDataBytesN::as_human_readable() const {
+  std::string s_bytes = is_bits ? "bits" : "bytes";
+  return s_bytes + std::to_string(n_width);
+}
+
 
 // --------------------------------------------
 //    traverse()
@@ -376,7 +392,7 @@ bool TypeDataSlice::can_rhs_be_assigned(TypePtr rhs) const {
   if (rhs == this) {
     return true;
   }
-  return rhs == TypeDataNever::create();
+  return rhs == TypeDataNever::create();   // note, that bytesN is NOT automatically cast to slice without `as` operator
 }
 
 bool TypeDataBuilder::can_rhs_be_assigned(TypePtr rhs) const {
@@ -469,6 +485,15 @@ bool TypeDataIntN::can_rhs_be_assigned(TypePtr rhs) const {
   return rhs == TypeDataNever::create();   // `int8` is NOT assignable to `int32` without `as`
 }
 
+bool TypeDataBytesN::can_rhs_be_assigned(TypePtr rhs) const {
+  // `slice` is NOT assignable to bytesN without `as`
+  // `bytes32` is NOT assignable to `bytes256` and even to `bits256` without `as`
+  if (rhs == this) {
+    return true;
+  }
+  return rhs == TypeDataNever::create();
+}
+
 bool TypeDataCoins::can_rhs_be_assigned(TypePtr rhs) const {
   if (rhs == this) {
     return true;
@@ -541,6 +566,9 @@ bool TypeDataCell::can_be_casted_with_as_operator(TypePtr cast_to) const {
 }
 
 bool TypeDataSlice::can_be_casted_with_as_operator(TypePtr cast_to) const {
+  if (cast_to->try_as<TypeDataBytesN>()) {  // `slice` to `bytes32` / `slice` to `bits8`
+    return true;
+  }
   if (const auto* to_nullable = cast_to->try_as<TypeDataNullable>()) {
     return can_be_casted_with_as_operator(to_nullable->inner);
   }
@@ -630,6 +658,16 @@ bool TypeDataIntN::can_be_casted_with_as_operator(TypePtr cast_to) const {
   return cast_to == TypeDataInt::create() || cast_to == TypeDataCoins::create();
 }
 
+bool TypeDataBytesN::can_be_casted_with_as_operator(TypePtr cast_to) const {
+  if (cast_to->try_as<TypeDataBytesN>()) {  // `bytes256` as `bytes512`, `bits1` as `bytes8`
+    return true;
+  }
+  if (const auto* to_nullable = cast_to->try_as<TypeDataNullable>()) {  // `bytes8` as `slice?`
+    return can_be_casted_with_as_operator(to_nullable->inner);
+  }
+  return cast_to == TypeDataSlice::create();
+}
+
 bool TypeDataCoins::can_be_casted_with_as_operator(TypePtr cast_to) const {
   if (cast_to->try_as<TypeDataIntN>()) {    // `coins` as `int8`
     return true;
@@ -750,6 +788,16 @@ static TypePtr parse_intN(std::string_view strN, bool is_unsigned) {
   return TypeDataIntN::create(is_unsigned, false, n);
 }
 
+static TypePtr parse_bytesN(std::string_view strN, bool is_bits) {
+  int n;
+  auto result = std::from_chars(strN.data() + 5  - static_cast<int>(is_bits), strN.data() + strN.size(), n);
+  bool parsed = result.ec == std::errc() && result.ptr == strN.data() + strN.size();
+  if (!parsed || n <= 0 || n > 1024) {
+    return nullptr;   // `bytes9999`, maybe it's user-defined alias, let it be unresolved
+  }
+  return TypeDataBytesN::create(is_bits, n);
+}
+
 static TypePtr parse_simple_type(Lexer& lex) {
   switch (lex.tok()) {
     case tok_self:
@@ -795,6 +843,16 @@ static TypePtr parse_simple_type(Lexer& lex) {
           return uintN;
         }
       }
+      if (str.size() > 4 && str.starts_with("bits")) {
+        if (TypePtr bitsN = parse_bytesN(str, true)) {
+          return bitsN;
+        }
+      }
+      if (str.size() > 5 && str.starts_with("bytes")) {
+        if (TypePtr bytesN = parse_bytesN(str, false)) {
+          return bytesN;
+        }
+      }
       return TypeDataUnresolved::create(std::string(str), loc);
     }
     case tok_null:

tolk/type-system.h

@@ -409,6 +409,29 @@ class TypeDataCoins final : public TypeData {
   bool can_be_casted_with_as_operator(TypePtr cast_to) const override;
 };
 
+/*
+ * `bytes256`, `bits512`, `bytes8` are TypeDataBytesN. At TVM level, it's just slice.
+ * The purpose of bytesN is to be used in struct fields, describing the way of serialization (n bytes / n bits).
+ * In this essence, bytesN is very similar to intN.
+ * Note, that unlike intN automatically cast to/from int, bytesN does NOT auto cast to slice (without `as`).
+ */
+class TypeDataBytesN final : public TypeData {
+  TypeDataBytesN(uint64_t type_id, bool is_bits, int n_width)
+    : TypeData(type_id, 0, 1)
+    , is_bits(is_bits)
+    , n_width(n_width) {}
+
+public:
+  const bool is_bits;
+  const int n_width;
+
+  static TypePtr create(bool is_bits, int n_width);
+
+  std::string as_human_readable() const override;
+  bool can_rhs_be_assigned(TypePtr rhs) const override;
+  bool can_be_casted_with_as_operator(TypePtr cast_to) const override;
+};
+
 /*
  * `unknown` is a special type, which can appear in corner cases.
  * The type of exception argument (which can hold any TVM value at runtime) is unknown.