[Tolk] Replace "..."c postfixes with stringCrc32("...") functions

With the introduction function `ton("0.05")`, I decided to
remove old FunC-style string postfixes "..."c, "..."H, etc.
in favor of a clearer and more flexible approach.

"..."c -> stringCrc32("...")
no way -> stringCrc16("...")
"..."H -> stringSha256("...")
"..."h -> stringSha256_32("...")
"..."a -> stringAddressToSlice("...")
"..."s -> stringHexToSlice("...")
"..."u -> stringToBase256("...")

These functions are compile-time only.
They can be used in constant initialization.

Author: tolk-vm

crypto/smartcont/tolk-stdlib/common.tolk

@@ -194,6 +194,42 @@ fun commitContractDataAndActions(): void
   Signature checks, hashing, cryptography.
  */
 
+/// Compile-time function that calculates crc32 of a constant string.
+/// Example: `const op = stringCrc32("some_str")` = 4013618352 = 0xEF3AF4B0
+/// Note: stringCrc32(slice_var) does not work! It accepts a constant string and works at compile-time.
+@pure
+fun stringCrc32(constString: slice): int
+    builtin;
+
+/// Compile-time function that calculates crc16 (XMODEM) of a constant string.
+/// Example: `const op = stringCrc16("some_str")` = 53407 = 0xD09F
+/// Note: stringCrc16(slice_var) does not work! It accepts a constant string and works at compile-time.
+@pure
+fun stringCrc16(constString: slice): int
+    builtin;
+
+/// Compile-time function that calculates sha256 of a constant string and returns 256-bit integer.
+/// Example: `const hash = stringSha256("some_crypto_key")`
+/// Note: it's a compile-time function, `stringSha256(slice_var)` does not work.
+/// Use `sliceBitsHash` or `sliceHash` (declared below) to hash a slice without/with its refs at runtime.
+@pure
+fun stringSha256(constString: slice): int
+    builtin;
+
+/// Compile-time function that calculates sha256 of a constant string and takes the first 32 bits.
+/// Example: `const minihash = stringSha256_32("some_crypto_key")`
+/// Note: stringSha256_32(slice_var) does not work! It accepts a constant string and works at compile-time.
+@pure
+fun stringSha256_32(constString: slice): int
+    builtin;
+
+/// Compile-time function that takes N-chars ascii string and interprets it as a number in base 256.
+/// Example: `const value = stringToBase256("AB")` = 16706 (65*256 + 66)
+/// Note: stringToBase256(slice_var) does not work! It accepts a constant string and works at compile-time.
+@pure
+fun stringToBase256(constString: slice): int
+    builtin;
+
 /// Computes the representation hash of a `cell` [c] and returns it as a 256-bit unsigned integer `x`.
 /// Useful for signing and checking signatures of arbitrary entities represented by a tree of cells.
 @pure
@@ -210,7 +246,7 @@ fun sliceHash(s: slice): int
 /// Computes sha256 of the data bits of `slice` [s]. If the bit length of `s` is not divisible by eight,
 /// throws a cell underflow exception. The hash value is returned as a 256-bit unsigned integer `x`.
 @pure
-fun stringHash(s: slice): int
+fun sliceBitsHash(s: slice): int
     asm "SHA256U";
 
 /// Checks the Ed25519-`signature` of a `hash` (a 256-bit unsigned integer, usually computed as the hash of some data)
@@ -340,6 +376,22 @@ fun debugDumpStack(): void
   When you _preload_ some data, you just get the result without mutating the slice.
  */
 
+/// Compile-time function that converts a constant string to TL-encoded MsgAddressInt (TVM slice).
+/// Example: stringAddressToSlice("EQCRDM9h4k3UJdOePPuyX40mCgA4vxge5Dc5vjBR8djbEKC5")
+/// Example: stringAddressToSlice("0:527964d55cfa6eb731f4bfc07e9d025098097ef8505519e853986279bd8400d8")
+/// Note: it's a compile-time function, `stringAddressToSlice(slice_var)` does not work.
+/// Use `parseStandardAddress` to decode a slice at runtime into workchain and hash.
+@pure
+fun stringAddressToSlice(constStringAddress: slice): slice
+    builtin;
+
+/// Compile-time function that converts a constant hex-encoded string to N/2 bytes.
+/// Example: `const v = stringHexToSlice("abcdef")` = slice with 3 bytes `[ 0xAB, 0xCD, 0xEF ]`
+/// Note: stringHexToSlice(slice_var) does not work! It accepts a constant string and works at compile-time.
+@pure
+fun stringHexToSlice(constStringBytesHex: slice): slice
+    builtin;
+
 /// Converts a `cell` [c] into a `slice`. Notice that [c] must be either an ordinary cell,
 /// or an exotic cell (see [TVM.pdf](https://ton-blockchain.github.io/docs/tvm.pdf), 3.1.2)
 /// which is automatically loaded to yield an ordinary cell `c'`, converted into a `slice` afterwards.

tolk-tester/tests/constants-tests.tolk

@@ -7,7 +7,7 @@ const int111: int = 111;
 const int1r = int1;
 
 const str1 = "const1";
-const str2 = "aabbcc"s;
+const str2 = stringHexToSlice("aabbcc");
 
 const str2r: slice = str2;
 

tolk-tester/tests/inference-tests.tolk

@@ -5,7 +5,7 @@ fun eq<X>(value: X): X { return value; }
 
 fun test1(x: int, y: int) {
     __expect_type(0, "int");
-    __expect_type("0"c, "int");
+    __expect_type(stringCrc32("0"), "int");
     __expect_type(x, "int");
     __expect_type(x + y, "int");
     __expect_type(x * y, "int");

tolk-tester/tests/parse-address.tolk

@@ -3,27 +3,31 @@ get ascii_slice(): slice {
 }
 
 get raw_slice(): slice {
-  return "abcdef"s;
+  return stringHexToSlice("abcdef");
 }
 
 get addr_slice(): slice {
-  return "Ef8zMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzM0vF"a;
+  return stringAddressToSlice("Ef8zMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzM0vF");
 }
 
 get string_hex(): int {
-  return "ABCDEFGHIJKLMNOPQRSTUVWXYZ012345"u;
+  return stringToBase256("ABCDEFGHIJKLMNOPQRSTUVWXYZ012345");
 }
 
 get fun string_minihash(): int {    // 'get' and 'get fun' both possible
-  return "transfer(slice, int)"h;
+  return stringSha256_32("transfer(slice, int)");
 }
 
 get fun string_maxihash(): int {
-  return "transfer(slice, int)"H;
+  return stringSha256("transfer(slice, int)");
 }
 
 get fun string_crc32(): int {
-  return "transfer(slice, int)"c;
+  return stringCrc32("transfer(slice, int)");
+}
+
+get fun string_crc16(): int {
+  return stringCrc16("transfer(slice, int)");
 }
 
 @pure
@@ -35,27 +39,44 @@ asm "ENDC" "CTOS";
 fun sdeq(s1: slice, s2: slice): int
 asm "SDEQ";
 
+fun calcSliceBytes(slice: slice): tuple {
+  var t = createEmptyTuple();
+  var n = 0;
+  while (n = slice.getRemainingBitsCount()) {
+    t.tuplePush(slice.loadUint(min(8, n)));
+  }
+  return t;
+}
+
 fun main() {
   var s_ascii: slice = ascii_slice();
   var s_raw: slice = raw_slice();
   var s_addr: slice = addr_slice();
   var i_hex: int = string_hex();
   var i_mini: int = string_minihash();
   var i_maxi: int = string_maxihash();
-  var i_crc: int = string_crc32();
+  var i_crc32: int = string_crc32();
+  var i_crc16: int = string_crc16();
   assert(sdeq(s_ascii, newc().storeUint(0x737472696E67, 12 * 4).endcs())) throw 101;
   assert(sdeq(s_raw, newc().storeUint(0xABCDEF, 6 * 4).endcs())) throw 102;
   assert(sdeq(s_addr, newc().storeUint(4, 3).storeInt(-1, 8)
     .storeUint(0x3333333333333333333333333333333333333333333333333333333333333333, 256).endcs()), 103);
   assert(i_hex == 0x4142434445464748494A4B4C4D4E4F505152535455565758595A303132333435) throw 104;
   assert(i_mini == 0x7a62e8a8) throw 105;
   assert(i_maxi == 0x7a62e8a8ebac41bd6de16c65e7be363bc2d2cbc6a0873778dead4795c13db979) throw 106;
-  assert(i_crc == 2235694568) throw 107;
+  assert(i_crc32 == 2235694568 && i_crc32 == 0x8541fde8) throw 107;
+  assert(i_crc16 == 52550 && i_crc16 == 0xCD46) throw 108;
   return 0;
 }
 
+@method_id(101)
+fun test1() {
+  return calcSliceBytes("ABCD");
+}
+
 /**
-@testcase | 0 | | 0
+@testcase | 0   | | 0
+@testcase | 101 | | [ 65 66 67 68 ]
 
-@code_hash 13830542019509784148027107880226447201604257839069192762244575629978154217223
+@code_hash 38184847030631877916087987911699475358017315230885358090110033079289166112584
 */

tolk-tester/tests/strings-tests.tolk

@@ -357,12 +357,7 @@ static AnyExprV parse_expr100(Lexer& lex) {
     case tok_string_const: {
       std::string_view str_val = lex.cur_str();
       lex.next();
-      char modifier = 0;
-      if (lex.tok() == tok_string_modifier) {
-        modifier = lex.cur_str()[0];
-        lex.next();
-      }
-      return createV<ast_string_const>(loc, str_val, modifier);
+      return createV<ast_string_const>(loc, str_val);
     }
     case tok_underscore: {
       lex.next();
@@ -927,7 +922,7 @@ static AnyV parse_asm_func_body(Lexer& lex, V<ast_parameter_list> param_list) {
   lex.check(tok_string_const, "\"ASM COMMAND\"");
   while (lex.tok() == tok_string_const) {
     std::string_view asm_command = lex.cur_str();
-    asm_commands.push_back(createV<ast_string_const>(lex.cur_location(), asm_command, 0));
+    asm_commands.push_back(createV<ast_string_const>(lex.cur_location(), asm_command));
     lex.next();
   }
   lex.expect(tok_semicolon, "`;`");
@@ -1142,7 +1137,7 @@ static AnyV parse_import_directive(Lexer& lex) {
   if (rel_filename.empty()) {
     lex.error("imported file name is an empty string");
   }
-  auto v_str = createV<ast_string_const>(lex.cur_location(), rel_filename, 0);
+  auto v_str = createV<ast_string_const>(lex.cur_location(), rel_filename);
   lex.next();
   return createV<ast_import_directive>(loc, v_str); // semicolon is not necessary
 }

tolk/ast-from-tokens.cpp

@@ -80,7 +80,7 @@ class ASTReplicatorFunction : public ASTReplicator {
     return createV<ast_int_const>(v->loc, v->intval, v->orig_str);
   }
   virtual V<ast_string_const> clone(V<ast_string_const> v) {
-    return createV<ast_string_const>(v->loc, v->str_val, v->modifier);
+    return createV<ast_string_const>(v->loc, v->str_val);
   }
   virtual V<ast_bool_const> clone(V<ast_bool_const> v) {
     return createV<ast_bool_const>(v->loc, v->bool_val);

tolk/ast-replicator.h

@@ -136,11 +136,7 @@ class ASTStringifier final : public ASTVisitor {
       case ast_int_const:
         return static_cast<std::string>(v->as<ast_int_const>()->orig_str);
       case ast_string_const:
-        if (char modifier = v->as<ast_string_const>()->modifier) {
-          return "\"" + static_cast<std::string>(v->as<ast_string_const>()->str_val) + "\"" + std::string(1, modifier);
-        } else {
-          return "\"" + static_cast<std::string>(v->as<ast_string_const>()->str_val) + "\"";
-        }
+        return "\"" + static_cast<std::string>(v->as<ast_string_const>()->str_val) + "\"";
       case ast_bool_const:
         return v->as<ast_bool_const>()->bool_val ? "true" : "false";
       case ast_dot_access: {

tolk/ast-stringifier.h

@@ -126,6 +126,10 @@ void Vertex<ast_reference>::assign_sym(const Symbol* sym) {
   this->sym = sym;
 }
 
+void Vertex<ast_string_const>::assign_literal_value(ConstantValue&& literal_value) {
+  this->literal_value = std::move(literal_value);
+}
+
 void Vertex<ast_function_call>::assign_fun_ref(FunctionPtr fun_ref) {
   this->fun_maybe = fun_ref;
 }

tolk/ast.cpp

@@ -458,25 +458,18 @@ struct Vertex<ast_int_const> final : ASTExprLeaf {
 
 template<>
 // ast_string_const is a string literal in double quotes or """ when multiline
-// examples: "asdf" / "Ef8zMz..."a / "to_calc_crc32_from"c
-// an optional modifier specifies how a string is parsed (probably, like an integer)
+// examples: "asdf" / "LTIME" (in asm body) / stringCrc32("asdf") (as an argument)
 // note, that TVM doesn't have strings, it has only slices, so "hello" has type slice
 struct Vertex<ast_string_const> final : ASTExprLeaf {
   std::string_view str_val;
-  char modifier;
+  ConstantValue literal_value;      // value of type `slice`, calculated after type inferring, at constants evaluation
 
-  bool is_bitslice() const {
-    char m = modifier;
-    return m == 0 || m == 's' || m == 'a';
-  }
-  bool is_intval() const {
-    char m = modifier;
-    return m == 'u' || m == 'h' || m == 'H' || m == 'c';
-  }
+  Vertex* mutate() const { return const_cast<Vertex*>(this); }
+  void assign_literal_value(ConstantValue&& literal_value);
 
-  Vertex(SrcLocation loc, std::string_view str_val, char modifier)
+  Vertex(SrcLocation loc, std::string_view str_val)
     : ASTExprLeaf(ast_string_const, loc)
-    , str_val(str_val), modifier(modifier) {}
+    , str_val(str_val) {}
 };
 
 template<>