whether the initializer is value-dependent rather than whether we are in a
dependent context. This allows us to detect some errors sooner, and fixes a
crash-on-invalid if a dependent type leaks out to a non-dependent context in
error recovery.
llvm-svn: 166898
Expr *Init = var->getInit();
bool IsGlobal = var->hasGlobalStorage() && !var->isStaticLocal();
- if (!var->getDeclContext()->isDependentContext() && Init) {
+ if (Init && !Init->isValueDependent()) {
if (IsGlobal && !var->isConstexpr() &&
getDiagnostics().getDiagnosticLevel(diag::warn_global_constructor,
var->getLocation())
struct I { int n; typedef I V[10]; };
I::V x, y;
-template<bool B> struct S {
+int g(); // expected-note {{here}}
+template<bool B, typename T> struct S : T {
int k;
void f() {
I::V &cells = B ? x : y;
I &i = cells[k];
switch (i.n) {}
+
+ constexpr int n = g(); // \
+ // expected-error {{must be initialized by a constant expression}} \
+ // expected-note {{non-constexpr function 'g'}}
+
+ constexpr int m = this->g(); // ok, could be constexpr
}
};
}
}
+
+namespace b6981007 {
+ struct S {}; // expected-note 3{{candidate}}
+ void f() {
+ S s(1, 2, 3); // expected-error {{no matching}}
+ for (auto x : s) {
+ // We used to attempt to evaluate the initializer of this variable,
+ // and crash because it has an undeduced type.
+ const int &n(x);
+ }
+ }
+}