[clang][Interp] Ignore StaticAssertDecls

[tbaeder]

Summary

They have already been handled before, but we can't just return false
when we encounter one.

[tbaeder]

Ping

[aaron.ballman]

LGTM!

[shafik]

LGTM

clang/lib/AST/Interp/ByteCodeStmtGen.cpp

for (auto *InnerStmt : CompoundStmt->body())
     if (!visitStmt(InnerStmt))
       return false;
   return true;
 }
 
 template <class Emitter>
 bool ByteCodeStmtGen<Emitter>::visitDeclStmt(const DeclStmt *DS) {
   for (auto *D : DS->decls()) {
+    if (isa<StaticAssertDecl>(D))
+      continue;
+
     const auto *VD = dyn_cast<VarDecl>(D);
     if (!VD)
       return false;
     if (!this->visitVarDecl(VD))
       return false;
   }
 
   return true;

clang/test/AST/Interp/functions.cpp

 // RUN: %clang_cc1 -fexperimental-new-constant-interpreter -verify %s
 // RUN: %clang_cc1 -verify=ref %s
 
 constexpr void doNothing() {}
 constexpr int gimme5() {
   doNothing();
   return 5;
 }
 static_assert(gimme5() == 5, "");
 
 
-template<typename T> constexpr T identity(T t) { return t; }
+template<typename T> constexpr T identity(T t) {
+  static_assert(true);
+  return t;
+}
 static_assert(identity(true), "");
 static_assert(identity(true), ""); /// Compiled bytecode should be cached
 static_assert(!identity(false), "");
 
+template<typename A, typename B>
+constexpr bool sameSize() {
+  static_assert(sizeof(A) == sizeof(B), ""); // expected-error {{static assertion failed}} \
+                                             // ref-error {{static assertion failed}} \
+                                             // expected-note {{evaluates to}} \
+                                             // ref-note {{evaluates to}}
+  return true;
+}
+static_assert(sameSize<int, int>(), "");
+static_assert(sameSize<unsigned int, int>(), "");
+static_assert(sameSize<char, long>(), ""); // expected-note {{in instantiation of function template specialization}} \
+                                           // ref-note {{in instantiation of function template specialization}}
+
+
 constexpr auto add(int a, int b) -> int {
   return identity(a) + identity(b);
 }
 
 constexpr int sub(int a, int b) {
   return a - b;
 }
 static_assert(sub(5, 2) == 3, "");