Merge pull request #8287 from tautschnig/bugfixes/c++-nodiscard

tautschnig · web-flow · commit 3e5bf8145a15 · 2024-05-11T19:48:25.000+02:00
C++ front-end: support [[__nodiscard__]] and [[nodiscard]]
diff --git a/regression/cpp/nodiscard1/main.cpp b/regression/cpp/nodiscard1/main.cpp
@@ -0,0 +1,17 @@
+[[nodiscard]] int foo(void)
+{
+  return 1;
+}
+
+#ifndef _MSC_VER
+[[__nodiscard__]]
+#endif
+int bar(void)
+{
+  return 2;
+}
+
+int main()
+{
+  return foo() + bar();
+}
diff --git a/regression/cpp/nodiscard1/test.desc b/regression/cpp/nodiscard1/test.desc
@@ -0,0 +1,8 @@
+CORE
+main.cpp
+-std=c++11
+^EXIT=0$
+^SIGNAL=0$
+--
+^warning: ignoring
+^CONVERSION ERROR$
diff --git a/src/ansi-c/ansi_c_convert_type.cpp b/src/ansi-c/ansi_c_convert_type.cpp
@@ -216,6 +216,8 @@ void ansi_c_convert_typet::read_rec(const typet &type)
       }
     }
   }
+  else if(type.id() == ID_nodiscard)
+    c_qualifiers.is_nodiscard = true;
   else if(type.id()==ID_noreturn)
     c_qualifiers.is_noreturn=true;
   else if(type.id()==ID_constructor)
diff --git a/src/ansi-c/c_qualifiers.cpp b/src/ansi-c/c_qualifiers.cpp
@@ -16,6 +16,7 @@ c_qualifierst &c_qualifierst::operator=(const c_qualifierst &other)
   is_volatile = other.is_volatile;
   is_restricted = other.is_restricted;
   is_atomic = other.is_atomic;
+  is_nodiscard = other.is_nodiscard;
   is_noreturn = other.is_noreturn;
   is_ptr32 = other.is_ptr32;
   is_ptr64 = other.is_ptr64;
@@ -52,6 +53,9 @@ std::string c_qualifierst::as_string() const
   if(is_ptr64)
     qualifiers+="__ptr64 ";
 
+  if(is_nodiscard)
+    qualifiers += "[[nodiscard]] ";
+
   if(is_noreturn)
     qualifiers+="_Noreturn ";
 
@@ -81,6 +85,9 @@ void c_qualifierst::read(const typet &src)
   if(src.get_bool(ID_C_transparent_union))
     is_transparent_union=true;
 
+  if(src.get_bool(ID_C_nodiscard))
+    is_nodiscard = true;
+
   if(src.get_bool(ID_C_noreturn))
     is_noreturn=true;
 }
@@ -122,6 +129,11 @@ void c_qualifierst::write(typet &dest) const
   else
     dest.remove(ID_C_transparent_union);
 
+  if(is_nodiscard)
+    dest.set(ID_C_nodiscard, true);
+  else
+    dest.remove(ID_C_nodiscard);
+
   if(is_noreturn)
     dest.set(ID_C_noreturn, true);
   else
@@ -136,6 +148,7 @@ void c_qualifierst::clear(typet &dest)
   dest.remove(ID_C_ptr32);
   dest.remove(ID_C_ptr64);
   dest.remove(ID_C_transparent_union);
+  dest.remove(ID_C_nodiscard);
   dest.remove(ID_C_noreturn);
 }
 
diff --git a/src/ansi-c/c_qualifiers.h b/src/ansi-c/c_qualifiers.h
@@ -85,11 +85,13 @@ class c_qualifierst : public qualifierst
     is_atomic=false;
     is_ptr32=is_ptr64=false;
     is_transparent_union=false;
+    is_nodiscard = false;
     is_noreturn=false;
   }
 
   // standard ones
-  bool is_constant, is_volatile, is_restricted, is_atomic, is_noreturn;
+  bool is_constant, is_volatile, is_restricted, is_atomic, is_noreturn,
+    is_nodiscard;
 
   // MS Visual Studio extension
   bool is_ptr32, is_ptr64;
@@ -108,30 +110,24 @@ class c_qualifierst : public qualifierst
   virtual bool is_subset_of(const qualifierst &other) const override
   {
     const c_qualifierst *cq = dynamic_cast<const c_qualifierst *>(&other);
-    return
-      (!is_constant || cq->is_constant) &&
-      (!is_volatile || cq->is_volatile) &&
-      (!is_restricted || cq->is_restricted) &&
-      (!is_atomic || cq->is_atomic) &&
-      (!is_ptr32 || cq->is_ptr32) &&
-      (!is_ptr64 || cq->is_ptr64) &&
-      (!is_noreturn || cq->is_noreturn);
+    return (!is_constant || cq->is_constant) &&
+           (!is_volatile || cq->is_volatile) &&
+           (!is_restricted || cq->is_restricted) &&
+           (!is_atomic || cq->is_atomic) && (!is_ptr32 || cq->is_ptr32) &&
+           (!is_ptr64 || cq->is_ptr64) && (!is_nodiscard || cq->is_nodiscard) &&
+           (!is_noreturn || cq->is_noreturn);
 
     // is_transparent_union isn't checked
   }
 
   virtual bool operator==(const qualifierst &other) const override
   {
     const c_qualifierst *cq = dynamic_cast<const c_qualifierst *>(&other);
-    return
-      is_constant == cq->is_constant &&
-      is_volatile == cq->is_volatile &&
-      is_restricted == cq->is_restricted &&
-      is_atomic == cq->is_atomic &&
-      is_ptr32 == cq->is_ptr32 &&
-      is_ptr64 == cq->is_ptr64 &&
-      is_transparent_union == cq->is_transparent_union &&
-      is_noreturn == cq->is_noreturn;
+    return is_constant == cq->is_constant && is_volatile == cq->is_volatile &&
+           is_restricted == cq->is_restricted && is_atomic == cq->is_atomic &&
+           is_ptr32 == cq->is_ptr32 && is_ptr64 == cq->is_ptr64 &&
+           is_transparent_union == cq->is_transparent_union &&
+           is_nodiscard == cq->is_nodiscard && is_noreturn == cq->is_noreturn;
   }
 
   virtual qualifierst &operator+=(const qualifierst &other) override
@@ -144,14 +140,15 @@ class c_qualifierst : public qualifierst
     is_ptr32 |= cq->is_ptr32;
     is_ptr64 |= cq->is_ptr64;
     is_transparent_union |= cq->is_transparent_union;
+    is_nodiscard |= cq->is_nodiscard;
     is_noreturn |= cq->is_noreturn;
     return *this;
   }
 
   virtual std::size_t count() const override
   {
-    return is_constant+is_volatile+is_restricted+is_atomic+
-           is_ptr32+is_ptr64+is_noreturn;
+    return is_constant + is_volatile + is_restricted + is_atomic + is_ptr32 +
+           is_ptr64 + is_nodiscard + is_noreturn;
   }
 };
 
diff --git a/src/ansi-c/parser.y b/src/ansi-c/parser.y
@@ -255,6 +255,7 @@ int yyansi_cerror(const std::string &error);
 %token TOK_MUTABLE     "mutable"
 %token TOK_NAMESPACE   "namespace"
 %token TOK_NEW         "new"
+%token TOK_NODISCARD   "nodiscard"
 %token TOK_NOEXCEPT    "noexcept"
 %token TOK_OPERATOR    "operator"
 %token TOK_PRIVATE     "private"
diff --git a/src/ansi-c/scanner.l b/src/ansi-c/scanner.l
@@ -864,6 +864,7 @@ friend              { return cpp98_keyword(TOK_FRIEND); }
 mutable             { return cpp98_keyword(TOK_MUTABLE); }
 namespace           { return cpp98_keyword(TOK_NAMESPACE); }
 new                 { return cpp98_keyword(TOK_NEW); }
+nodiscard           { return cpp11_keyword(TOK_NODISCARD); } // C++11
 noexcept            { return cpp11_keyword(TOK_NOEXCEPT); } // C++11
 noreturn            { return cpp11_keyword(TOK_NORETURN); } // C++11
 not                 { return cpp98_keyword('!'); }
@@ -1291,6 +1292,14 @@ __decltype          { if(PARSER.cpp98 &&
                     return make_identifier();
                 }
 
+"__nodiscard__" { if(PARSER.mode==configt::ansi_ct::flavourt::GCC ||
+                     PARSER.mode==configt::ansi_ct::flavourt::CLANG ||
+                     PARSER.mode==configt::ansi_ct::flavourt::ARM)
+                    { loc(); return TOK_NODISCARD; }
+                  else
+                    return make_identifier();
+                }
+
 {CPROVER_PREFIX}"atomic"       { loc(); return TOK_CPROVER_ATOMIC; }
 {CPROVER_PREFIX}"forall"       { loc(); return TOK_FORALL; }
 {CPROVER_PREFIX}"exists"       { loc(); return TOK_EXISTS; }
diff --git a/src/cpp/parse.cpp b/src/cpp/parse.cpp
@@ -2420,6 +2420,8 @@ bool Parser::optAttribute(typet &t)
     switch(tk.kind)
     {
     case ']':
+      if(lex.LookAhead(0) != ']')
+        return false;
       lex.get_token();
       return true;
 
@@ -2431,7 +2433,17 @@ bool Parser::optAttribute(typet &t)
         break;
       }
 
+      case TOK_NODISCARD:
+      {
+        typet attr(ID_nodiscard);
+        set_location(attr, tk);
+        merge_types(attr, t);
+        break;
+      }
+
     default:
+      // TODO: way may wish to change this: GCC, Clang, Visual Studio merely
+      // warn when they see an attribute that they don't recognize
       return false;
     }
   }
diff --git a/src/util/irep_ids.def b/src/util/irep_ids.def
@@ -574,6 +574,8 @@ IREP_ID_ONE(onehot)
 IREP_ID_ONE(onehot0)
 IREP_ID_ONE(popcount)
 IREP_ID_ONE(function_type)
+IREP_ID_ONE(nodiscard)
+IREP_ID_TWO(C_nodiscard, #nodiscard)
 IREP_ID_ONE(noreturn)
 IREP_ID_TWO(C_noreturn, #noreturn)
 IREP_ID_ONE(weak)

Original file line number	Diff line number	Diff line change
`@@ -216,6 +216,8 @@ void ansi_c_convert_typet::read_rec(const typet &type)`
`216`	`216`	`}`
`217`	`217`	`}`
`218`	`218`	`}`
	`219`	`+ else if(type.id() == ID_nodiscard)`
	`220`	`+ c_qualifiers.is_nodiscard = true;`
`219`	`221`	`else if(type.id()==ID_noreturn)`
`220`	`222`	`c_qualifiers.is_noreturn=true;`
`221`	`223`	`else if(type.id()==ID_constructor)`
Original file line number	Diff line number	Diff line change
`@@ -2420,6 +2420,8 @@ bool Parser::optAttribute(typet &t)`
`2420`	`2420`	`switch(tk.kind)`
`2421`	`2421`	`{`
`2422`	`2422`	`case ']':`
	`2423`	`+ if(lex.LookAhead(0) != ']')`
	`2424`	`+ return false;`
`2423`	`2425`	`lex.get_token();`
`2424`	`2426`	`return true;`
`2425`	`2427`
`@@ -2431,7 +2433,17 @@ bool Parser::optAttribute(typet &t)`
`2431`	`2433`	`break;`
`2432`	`2434`	`}`
`2433`	`2435`
	`2436`	`+ case TOK_NODISCARD:`
	`2437`	`+ {`
	`2438`	`+ typet attr(ID_nodiscard);`
	`2439`	`+ set_location(attr, tk);`
	`2440`	`+ merge_types(attr, t);`
	`2441`	`+ break;`
	`2442`	`+ }`
	`2443`	`+`
`2434`	`2444`	`default:`
	`2445`	`+ // TODO: way may wish to change this: GCC, Clang, Visual Studio merely`
	`2446`	`+ // warn when they see an attribute that they don't recognize`
`2435`	`2447`	`return false;`
`2436`	`2448`	`}`
`2437`	`2449`	`}`