[clang][Interp] Diagnose unknown parameter values

[tbaeder]

Summary

Fixes #64195

[aaron.ballman]

clang/lib/AST/Interp/Interp.cpp

551–555

No need for this given all code paths return false.

However, what should we do for calls to this for something other than a ParmVarDecl? Should we issue a generic note so the constant expression fails but we get notified to the missing cases?

clang/test/AST/Interp/functions.cpp

316–323

I'd like another test along the lines of:

consteval void param(bool b) {
  static_assert(b); // Same error despite this being a consteval function where `b`'s value is always going to be known at compile time
}

[tbaeder]

clang/lib/AST/Interp/Interp.cpp

551–555

I think the return false; is basically fine, it will show the usual "is not an integral constant expression" error message, and if there's no other note, we can investigate and improve diagnostics.

[aaron.ballman]

LGTM!

clang/lib/AST/Interp/ByteCodeExprGen.cpp

if (!Ctx.getLangOpts().CPlusPlus) {
     if (const auto *VD = dyn_cast<VarDecl>(D);
         VD && VD->hasGlobalStorage() && VD->getAnyInitializer()) {
       if (!this->visitVarDecl(VD))
         return false;
       // Retry.
       return this->VisitDeclRefExpr(E);
     }
   }
-  return false;
+
+  return this->emitInvalidDeclRef(E, E);
 }
 
 template <class Emitter>
 void ByteCodeExprGen<Emitter>::emitCleanup() {
   for (VariableScope<Emitter> *C = VarScope; C; C = C->getParent())
     C->emitDestruction();
 }
 

clang/lib/AST/Interp/Interp.h

bool CheckDivRem(InterpState &S, CodePtr OpPC, const T &LHS, const T &RHS) {
   return true;
 }
 
 /// Checks if the result of a floating-point operation is valid
 /// in the current context.
 bool CheckFloatResult(InterpState &S, CodePtr OpPC, const Floating &Result,
                       APFloat::opStatus Status);
 
+/// Checks why the given DeclRefExpr is invalid.
+bool CheckDeclRef(InterpState &S, CodePtr OpPC, const DeclRefExpr *DR);
+
 /// Interpreter entry point.
 bool Interpret(InterpState &S, APValue &Result);
 
 /// Interpret a builtin function.
 bool InterpretBuiltin(InterpState &S, CodePtr OpPC, const Function *F,
                       const CallExpr *Call);
 
 /// Interpret an offsetof operation.

 /// Same here, but only for casts.
 inline bool InvalidCast(InterpState &S, CodePtr OpPC, CastKind Kind) {
   const SourceLocation &Loc = S.Current->getLocation(OpPC);
   S.FFDiag(Loc, diag::note_constexpr_invalid_cast)
       << static_cast<unsigned>(Kind) << S.Current->getRange(OpPC);
   return false;
 }
 
+inline bool InvalidDeclRef(InterpState &S, CodePtr OpPC,
+                           const DeclRefExpr *DR) {
+  assert(DR);
+  return CheckDeclRef(S, OpPC, DR);
+}
+
 template <PrimType Name, class T = typename PrimConv<Name>::T>
 inline bool OffsetOf(InterpState &S, CodePtr OpPC, const OffsetOfExpr *E) {
   llvm::SmallVector<int64_t> ArrayIndices;
   for (size_t I = 0; I != E->getNumExpressions(); ++I)
     ArrayIndices.emplace_back(S.Stk.pop<int64_t>());
 
   int64_t Result;
   if (!InterpretOffsetOf(S, OpPC, E, ArrayIndices, Result))

clang/lib/AST/Interp/Interp.cpp

if ((Status & APFloat::opStatus::opInvalidOp) &&
     // There is no usefully definable result.
     S.FFDiag(E);
     return false;
   }
 
   return true;
 }
 
+/// We aleady know the given DeclRefExpr is invalid for some reason,
+/// now figure out why and print appropriate diagnostics.
+bool CheckDeclRef(InterpState &S, CodePtr OpPC, const DeclRefExpr *DR) {
+  const ValueDecl *D = DR->getDecl();
+  const SourceInfo &E = S.Current->getSource(OpPC);
+
+  if (isa<ParmVarDecl>(D)) {
+    S.FFDiag(E, diag::note_constexpr_function_param_value_unknown) << D;
+    S.Note(D->getLocation(), diag::note_declared_at) << D->getSourceRange();
+  } else if (const auto *VD = dyn_cast<VarDecl>(D)) {
+    if (!VD->getType().isConstQualified()) {
+      S.FFDiag(E,
+               VD->getType()->isIntegralOrEnumerationType()
+                   ? diag::note_constexpr_ltor_non_const_int
+                   : diag::note_constexpr_ltor_non_constexpr,
+               1)
+          << VD;
+      S.Note(VD->getLocation(), diag::note_declared_at) << VD->getSourceRange();
+      return false;
+    }
+
+    // const, but no initializer.
+    if (!VD->getAnyInitializer()) {
+      S.FFDiag(E, diag::note_constexpr_var_init_unknown, 1) << VD;
+      S.Note(VD->getLocation(), diag::note_declared_at) << VD->getSourceRange();
+      return false;
+    }
+  }
+
+  return false;
+}
+
 bool Interpret(InterpState &S, APValue &Result) {
   // The current stack frame when we started Interpret().
   // This is being used by the ops to determine wheter
   // to return from this function and thus terminate
   // interpretation.
   const InterpFrame *StartFrame = S.Current;
   assert(!S.Current->isRoot());
   CodePtr PC = S.Current->getPC();

clang/lib/AST/Interp/Opcodes.td

 def ArgRecordDecl : ArgType { let Name = "const RecordDecl *"; }
 def ArgRecordField : ArgType { let Name = "const Record::Field *"; }
 def ArgFltSemantics : ArgType { let Name = "const llvm::fltSemantics *"; }
 def ArgRoundingMode : ArgType { let Name = "llvm::RoundingMode"; }
 def ArgLETD: ArgType { let Name = "const LifetimeExtendedTemporaryDecl *"; }
 def ArgCastKind : ArgType { let Name = "CastKind"; }
 def ArgCallExpr : ArgType { let Name = "const CallExpr *"; }
 def ArgOffsetOfExpr : ArgType { let Name = "const OffsetOfExpr *"; }
+def ArgDeclRef : ArgType { let Name = "const DeclRefExpr *"; }
 
 //===----------------------------------------------------------------------===//
 // Classes of types instructions operate on.
 //===----------------------------------------------------------------------===//
 
 class TypeClass {
   list<Type> Types;
 }
def Dup : Opcode {
   let HasGroup = 1;
 }
 
 // [] -> []
 def Invalid : Opcode {}
 def InvalidCast : Opcode {
   let Args = [ArgCastKind];
 }
+
+def InvalidDeclRef : Opcode {
+  let Args = [ArgDeclRef];
+}

clang/test/AST/Interp/c.c

 // RUN: %clang_cc1 -fexperimental-new-constant-interpreter -verify -std=c11 %s
 // RUN: %clang_cc1 -fexperimental-new-constant-interpreter -pedantic -verify=pedantic-expected -std=c11 %s
 // RUN: %clang_cc1 -verify=ref -std=c11 %s
 // RUN: %clang_cc1 -pedantic -verify=pedantic-ref -std=c11 %s
 
-/// expected-no-diagnostics
-
 _Static_assert(1, "");
 _Static_assert(0 != 1, "");
 _Static_assert(1.0 == 1.0, ""); // pedantic-ref-warning {{not an integer constant expression}} \
                                 // pedantic-expected-warning {{not an integer constant expression}}
 _Static_assert(1 && 1.0, ""); // pedantic-ref-warning {{not an integer constant expression}} \
                               // pedantic-expected-warning {{not an integer constant expression}}
 _Static_assert( (5 > 4) + (3 > 2) == 2, "");
 _Static_assert(!!1.0, ""); // pedantic-ref-warning {{not an integer constant expression}} \
                            // pedantic-expected-warning {{not an integer constant expression}}
 _Static_assert(!!1, "");
 
 /// FIXME: Should also be rejected in the new interpreter
 int a = (1 == 1 ? 5 : 3);
 _Static_assert(a == 5, ""); // ref-error {{not an integral constant expression}} \
                             // pedantic-ref-error {{not an integral constant expression}} \
                             // pedantic-expected-warning {{not an integer constant expression}}
 
 const int b = 3;
 _Static_assert(b == 3, ""); // pedantic-ref-warning {{not an integer constant expression}} \
                             // pedantic-expected-warning {{not an integer constant expression}}
 
+const int c; // ref-note {{declared here}} \
+             // pedantic-ref-note {{declared here}} \
+             // expected-note {{declared here}} \
+             // pedantic-expected-note {{declared here}}
+_Static_assert(c == 0, ""); // ref-error {{not an integral constant expression}} \
+                            // ref-note {{initializer of 'c' is unknown}} \
+                            // pedantic-ref-error {{not an integral constant expression}} \
+                            // pedantic-ref-note {{initializer of 'c' is unknown}} \
+                            // expected-error {{not an integral constant expression}} \
+                            // expected-note {{initializer of 'c' is unknown}} \
+                            // pedantic-expected-error {{not an integral constant expression}} \
+                            // pedantic-expected-note {{initializer of 'c' is unknown}}

clang/test/AST/Interp/functions.cpp

 // RUN: %clang_cc1 -fexperimental-new-constant-interpreter -verify %s
+// RUN: %clang_cc1 -std=c++14 -fexperimental-new-constant-interpreter -verify %s
+// RUN: %clang_cc1 -std=c++20 -fexperimental-new-constant-interpreter -verify %s
 // RUN: %clang_cc1 -verify=ref %s
+// RUN: %clang_cc1 -std=c++14 -verify=ref %s
+// RUN: %clang_cc1 -std=c++20 -verify=ref %s
 
 constexpr void doNothing() {}
 constexpr int gimme5() {
   doNothing();
   return 5;
 }
 static_assert(gimme5() == 5, "");
 

 namespace VoidReturn {
   /// ReturnStmt with an expression in a void function used to cause problems.
   constexpr void bar() {}
   constexpr void foo() {
     return bar();
   }
   static_assert((foo(),1) == 1, "");
 }
+
+namespace InvalidReclRefs {
+  void param(bool b) { // ref-note {{declared here}} \
+                       // expected-note {{declared here}}
+    static_assert(b, ""); // ref-error {{not an integral constant expression}} \
+                          // ref-note {{function parameter 'b' with unknown value}} \
+                          // expected-error {{not an integral constant expression}} \
+                          // expected-note {{function parameter 'b' with unknown value}}
+    static_assert(true ? true : b, "");
+  }
+
+#if __cplusplus >= 202002L
+  consteval void param2(bool b) { // ref-note {{declared here}} \
+                                 // expected-note {{declared here}}
+    static_assert(b, ""); // ref-error {{not an integral constant expression}} \
+                          // ref-note {{function parameter 'b' with unknown value}} \
+                          // expected-error {{not an integral constant expression}} \
+                          // expected-note {{function parameter 'b' with unknown value}}
+  }
+#endif
+}

clang/test/AST/Interp/literals.cpp

namespace PointerCasts {
   constexpr intptr_t A = (intptr_t)P; // ref-error {{must be initialized by a constant expression}} \
                                       // ref-note {{cast that performs the conversions of a reinterpret_cast}} \
                                       // expected-error {{must be initialized by a constant expression}} \
                                       // expected-note {{cast that performs the conversions of a reinterpret_cast}}
 
   int array[(intptr_t)(char*)0]; // ref-warning {{variable length array folded to constant array}} \
                                  // expected-warning {{variable length array folded to constant array}}
 }
+
+namespace InvalidDeclRefs {
+  bool b00; // ref-note {{declared here}} \
+            // expected-note {{declared here}}
+  static_assert(b00, ""); // ref-error {{not an integral constant expression}} \
+                          // ref-note {{read of non-const variable}} \
+                          // expected-error {{not an integral constant expression}} \
+                          // expected-note {{read of non-const variable}}
+
+  float b01; // ref-note {{declared here}} \
+             // expected-note {{declared here}}
+  static_assert(b01, ""); // ref-error {{not an integral constant expression}} \
+                          // ref-note {{read of non-constexpr variable}} \
+                          // expected-error {{not an integral constant expression}} \
+                          // expected-note {{read of non-constexpr variable}}
+
+  extern const int b02; // ref-note {{declared here}} \
+                        // expected-note {{declared here}}
+  static_assert(b02, ""); // ref-error {{not an integral constant expression}} \
+                          // ref-note {{initializer of 'b02' is unknown}} \
+                          // expected-error {{not an integral constant expression}} \
+                          // expected-note {{initializer of 'b02' is unknown}}
+
+  /// FIXME: This should also be diagnosed in the new interpreter.
+  int b03 = 3; // ref-note {{declared here}}
+  static_assert(b03, ""); // ref-error {{not an integral constant expression}} \
+                          // ref-note {{read of non-const variable}}
+}