[Tolk] Fire an error on using ++/-- operators

Before, `++i` was valid (and did nothing, --1 is 1), probably unexpected

Author: tolk-vm

tolk-tester/tests/invalid-syntax/err-3498.tolk

@@ -0,0 +1,12 @@
+
+fun main() {
+    var z = 5;
+    ++z;
+    return z;
+}
+
+/**
+@compilation_should_fail
+@stderr Tolk has no increment operator
+@stderr hint: use `i += 1`, not `i++`
+ */

tolk-tester/tests/invalid-syntax/err-3810.tolk

@@ -0,0 +1,14 @@
+
+struct A {
+    f: int;
+}
+
+fun main(a: A) {
+    a.f--;
+}
+
+/**
+@compilation_should_fail
+@stderr Tolk has no decrement operator
+@stderr hint: use `i -= 1`, not `i--`
+ */

tolk-tester/tests/no-spaces.tolk

@@ -4,27 +4,27 @@ fun just10(): int { return int10; }
 fun eq(v: int): int { return`v` }
 
 @method_id(101,) fun `get_-1`  (): int {return-1}
-@method_id(102,) fun `get_--1` (): int {return--1}
-@method_id(103,) fun `get_---1`(): int {return---1}
-@method_id(104,) fun `get_+++1`(): int {return+++1}
+@method_id(102,) fun `get_--1` (): int {return- -1}
+@method_id(103,) fun `get_---1`(): int {return-(-(-1))}
+@method_id(104,) fun `get_+++1`(): int {return+(+(+1))}
 @method_id(105,) fun `get_+-+1`(): int {return+-+1}
 
 global `some()var`:int;
 
 @method_id(110) fun `some_math`(): int {
-    `some()var`=--6;
-    return 1*-2*-3*-4*just10()*-5+-`some()var`+--`some()var`---`some()var`;
+    `some()var`=- -6;
+    return 1*-2*-3*-4*just10()*-5+-`some()var`+-(-`some()var`)-(-(-`some()var`));
 }
 
 @method_id(111) fun `negative_nums`(a:int):int {
     var m$0:int=1;
     var m1:int=-(+0x1)*m$0;
-    return `a`*-1*-(1)*---(1)*+just10()+-`just10`()*m1*-m1+-eq(m1)----0x1;
+    return `a`*-1*-(1)*-(1)*+just10()+-`just10`()*m1*-m1+-eq(m1)-(-0x1);
 }
 
 @method_id(112) fun `bitwise~ops`(flags:int):[bool,bool] {
     return[
-        (just10()-3==just10()-(4)--1)|((2==2)&(eq(eq(10)) -3==just10()--13)),
+        (just10()-3==just10()-(4)- -1)|((2==2)&(eq(eq(10)) -3==just10()-(-13))),
         ((flags&0xFF)!=0)
     ]
 }

tolk-tester/tests/numbers-tests.tolk

@@ -26,7 +26,7 @@ fun main() {
         0b0 == 0,
         -0b1010100001010101010-0b1+0b1 == -344746,
         0b00001 == 1,
-        --0b00101111101100 == 3052
+        -(-0b00101111101100) == 3052
     );
 }
 

tolk/ast-from-tokens.cpp

@@ -69,6 +69,16 @@ static void fire_error_mix_and_or_no_parenthesis(SrcLocation loc, std::string_vi
                                  "Use parenthesis to emphasize operator precedence.");
 }
 
+// fire an error "Tolk does not have ++i operator"
+GNU_ATTRIBUTE_NORETURN GNU_ATTRIBUTE_COLD
+static void fire_error_no_increment_operator(SrcLocation loc, bool is_increment) {
+  std::string op_name = is_increment ? "increment" : "decrement";
+  std::string op_wrong = is_increment ? "++" : "--";
+  std::string op_right = is_increment ? "+=" : "-=";
+  throw ParseError(loc, std::string("Tolk has no ") + op_name + " operator\n" +
+                        "hint: use `i " + op_right + " 1`, not `i" + op_wrong + "`");
+}
+
 // diagnose when bitwise operators are used in a probably wrong way due to tricky precedence
 // example: "flags & 0xFF != 0" is equivalent to "flags & 1", most likely it's unexpected
 // the only way to suppress this error for the programmer is to use parenthesis
@@ -847,14 +857,16 @@ static AnyExprV parse_expr100(Lexer& lex) {
   }
 }
 
-// parse E(...) and E! having parsed E already (left-to-right)
+// parse E(...) / E! / E++ / E-- having parsed E already (left-to-right)
 static AnyExprV parse_fun_call_postfix(Lexer& lex, AnyExprV lhs) {
   while (true) {
     if (lex.tok() == tok_oppar) {
       lhs = createV<ast_function_call>(lhs->loc, lhs, parse_argument_list(lex));
     } else if (lex.tok() == tok_logical_not) {
       lex.next();
       lhs = createV<ast_not_null_operator>(lhs->loc, lhs);
+    } else if (lex.tok() == tok_double_plus || lex.tok() == tok_double_minus) {
+      fire_error_no_increment_operator(lex.cur_location(), lex.tok() == tok_double_plus);
     } else {
       break;
     }
@@ -865,7 +877,7 @@ static AnyExprV parse_fun_call_postfix(Lexer& lex, AnyExprV lhs) {
 // parse E(...) and E! (left-to-right)
 static AnyExprV parse_expr90(Lexer& lex) {
   AnyExprV res = parse_expr100(lex);
-  if (lex.tok() == tok_oppar || lex.tok() == tok_logical_not) {
+  if (lex.tok() == tok_oppar || lex.tok() == tok_logical_not || lex.tok() == tok_double_plus || lex.tok() == tok_double_minus) {
     res = parse_fun_call_postfix(lex, res);
   }
   return res;
@@ -892,7 +904,7 @@ static AnyExprV parse_expr80(Lexer& lex) {
       lex.unexpected("method name");
     }
     lhs = createV<ast_dot_access>(loc, lhs, v_ident, v_instantiationTs);
-    if (lex.tok() == tok_oppar || lex.tok() == tok_logical_not) {
+    if (lex.tok() == tok_oppar || lex.tok() == tok_logical_not || lex.tok() == tok_double_plus || lex.tok() == tok_double_minus) {
       lhs = parse_fun_call_postfix(lex, lhs);
     }
   }
@@ -909,6 +921,12 @@ static AnyExprV parse_expr75(Lexer& lex) {
     AnyExprV rhs = parse_expr75(lex);
     return createV<ast_unary_operator>(loc, operator_name, t, rhs);
   }
+  if (t == tok_double_minus || t == tok_double_plus) {
+    SrcLocation loc = lex.cur_location();
+    lex.next();
+    parse_expr75(lex);
+    fire_error_no_increment_operator(loc, t == tok_double_plus);
+  }
   return parse_expr80(lex);
 }
 

tolk/lexer.cpp

@@ -523,6 +523,8 @@ struct TolkLanguageGrammar {
     register_token("^=", 2, tok_set_bitwise_xor);
     register_token("->", 2, tok_arrow);
     register_token("=>", 2, tok_double_arrow);
+    register_token("++", 2, tok_double_plus);
+    register_token("--", 2, tok_double_minus);
     register_token("<=>", 3, tok_spaceship);
     register_token("~>>", 3, tok_rshiftR);
     register_token("^>>", 3, tok_rshiftC);

tolk/lexer.h

@@ -64,6 +64,8 @@ enum TokenType {
   tok_set_div,
   tok_mod,
   tok_set_mod,
+  tok_double_plus,
+  tok_double_minus,
   tok_lshift,
   tok_set_lshift,
   tok_rshift,