Improve type checking of the builitn increment operators

Author: robertoraggi

src/parser/cxx/parser.cc

@@ -10733,6 +10733,7 @@ void Parser::completeFunctionDefinition(FunctionDefinitionAST* ast) {
 }
 
 void Parser::check(ExpressionAST* ast) {
+  if (inTemplate_) return;
   TypeChecker check{unit};
   check.setScope(scope_);
   check.setReportErrors(config_.checkTypes);

src/parser/cxx/type_checker.cc

@@ -448,6 +448,9 @@ void TypeChecker::Visitor::operator()(UnaryExpressionAST* ast) {
       }
 
       if (!is_glvalue(ast->expression)) {
+        error(ast->opLoc,
+              std::format("cannot take the address of an rvalue of type '{}'",
+                          to_string(ast->expression->type)));
         break;
       }
 
@@ -542,6 +545,8 @@ void TypeChecker::Visitor::operator()(UnaryExpressionAST* ast) {
 
     case TokenKind::T_PLUS_PLUS: {
       if (!is_glvalue(ast->expression)) {
+        error(ast->opLoc, std::format("cannot increment an rvalue of type '{}'",
+                                      to_string(ast->expression->type)));
         break;
       }
 
@@ -554,18 +559,23 @@ void TypeChecker::Visitor::operator()(UnaryExpressionAST* ast) {
       }
 
       if (auto ptrTy = type_cast<PointerType>(ty)) {
-        if (ptrTy && !control()->is_void(ptrTy->elementType())) {
+        if (!control()->is_void(ptrTy->elementType())) {
           ast->type = ptrTy;
           ast->valueCategory = ValueCategory::kLValue;
+          break;
         }
       }
 
+      error(ast->opLoc, std::format("cannot increment a value of type '{}'",
+                                    to_string(ast->expression->type)));
       break;
     }
 
     case TokenKind::T_MINUS_MINUS: {
       if (!is_glvalue(ast->expression)) {
-        break;
+        error(ast->opLoc, std::format("cannot decrement an rvalue of type '{}'",
+                                      to_string(ast->expression->type)));
+         break;
       }
 
       auto ty = ast->expression->type;
@@ -580,9 +590,12 @@ void TypeChecker::Visitor::operator()(UnaryExpressionAST* ast) {
         if (ptrTy && !control()->is_void(ptrTy->elementType())) {
           ast->type = ptrTy;
           ast->valueCategory = ValueCategory::kLValue;
+          break;
         }
       }
 
+      error(ast->opLoc, std::format("cannot decrement a value of type '{}'",
+                                    to_string(ast->expression->type)));
       break;
     }
 

tests/unit_tests/ast/template_lambda_01.cc

@@ -83,13 +83,9 @@ struct S {
 // CHECK-NEXT:                                      return-statement
 // CHECK-NEXT:                                        expression: binary-expression
 // CHECK-NEXT:                                          op: +
-// CHECK-NEXT:                                          left-expression: implicit-cast-expression [prvalue T1]
-// CHECK-NEXT:                                            cast-kind: lvalue-to-rvalue-conversion
-// CHECK-NEXT:                                            expression: id-expression [lvalue T1]
-// CHECK-NEXT:                                              unqualified-id: name-id
-// CHECK-NEXT:                                                identifier: a
-// CHECK-NEXT:                                          right-expression: implicit-cast-expression [prvalue T2]
-// CHECK-NEXT:                                            cast-kind: lvalue-to-rvalue-conversion
-// CHECK-NEXT:                                            expression: id-expression [lvalue T2]
-// CHECK-NEXT:                                              unqualified-id: name-id
-// CHECK-NEXT:                                                identifier: b
+// CHECK-NEXT:                                          left-expression: id-expression [lvalue T1]
+// CHECK-NEXT:                                            unqualified-id: name-id
+// CHECK-NEXT:                                              identifier: a
+// CHECK-NEXT:                                          right-expression: id-expression [lvalue T2]
+// CHECK-NEXT:                                            unqualified-id: name-id
+// CHECK-NEXT:                                              identifier: b

tests/unit_tests/sema/incr_01.cc

@@ -37,5 +37,18 @@ auto main() -> int {
   static_assert(__is_lvalue_reference(decltype(++pr)));
   static_assert(__is_lvalue_reference(decltype(--pr)));
 
+  // clang-format off
+
+  int a[10];
+
+  ++(+a); // expected-error {{cannot increment an rvalue of type 'int*'}}
+
+  ++a; // expected-error {{cannot increment a value of type 'int [10]'}}
+
+  --(+a); // expected-error {{cannot decrement an rvalue of type 'int*'}}
+
+  --a; // expected-error {{cannot decrement a value of type 'int [10]'}}
+
+  // clang-format on
   return 0;
-}
+}