728894340f
The warning warns on TypedefNameDecls -- typedefs and C++11 using aliases --
that are !isReferenced(). Since the isReferenced() bit on TypedefNameDecls
wasn't used for anything before this warning it wasn't always set correctly,
so this patch also adds a few missing MarkAnyDeclReferenced() calls in
various places for TypedefNameDecls.
This is made a bit complicated due to local typedefs possibly being used only
after their local scope has closed. Consider:
template <class T>
void template_fun(T t) {
typename T::Foo s3foo; // YYY
(void)s3foo;
}
void template_fun_user() {
struct Local {
typedef int Foo; // XXX
} p;
template_fun(p);
}
Here the typedef in XXX is only used at end-of-translation unit, when YYY in
template_fun() gets instantiated. To handle this, typedefs that are unused when
their scope exits are added to a set of potentially unused typedefs, and that
set gets checked at end-of-TU. Typedefs that are still unused at that point then
get warned on. There's also serialization code for this set, so that the
warning works with precompiled headers and modules. For modules, the warning
is emitted when the module is built, for precompiled headers each time the
header gets used.
Finally, consider a function using C++14 auto return types to return a local
type defined in a header:
auto f() {
struct S { typedef int a; };
return S();
}
Here, the typedef escapes its local scope and could be used by only some
translation units including the header. To not warn on this, add a
RecursiveASTVisitor that marks all delcs on local types returned from auto
functions as referenced. (Except if it's a function with internal linkage, or
the decls are private and the local type has no friends -- in these cases, it
_is_ safe to warn.)
Several of the included testcases (most of the interesting ones) were provided
by Richard Smith.
(gcc's spelling -Wunused-local-typedefs is supported as an alias for this
warning.)
llvm-svn: 217298
96 lines
3.1 KiB
C++
96 lines
3.1 KiB
C++
// RUN: %clang_cc1 -fsyntax-only -fcxx-exceptions -verify -std=c++11 -Wall -Wno-unused-local-typedefs %s
|
|
|
|
template<bool b> struct ExceptionIf { static int f(); };
|
|
template<> struct ExceptionIf<false> { typedef int f; };
|
|
|
|
// The exception specification of a defaulted default constructor depends on
|
|
// the contents of in-class member initializers. However, the in-class member
|
|
// initializers can depend on the exception specification of the constructor,
|
|
// since the class is considered complete within them. We reject any such cases.
|
|
namespace InClassInitializers {
|
|
// Noexcept::Noexcept() is implicitly declared as noexcept(false), because it
|
|
// directly invokes ThrowSomething(). However...
|
|
//
|
|
// If noexcept(Noexcept()) is false, then Noexcept() is a constant expression,
|
|
// so noexcept(Noexcept()) is true. But if noexcept(Noexcept()) is true, then
|
|
// Noexcept::Noexcept is not declared constexpr, therefore noexcept(Noexcept())
|
|
// is false.
|
|
bool ThrowSomething() noexcept(false);
|
|
struct ConstExpr {
|
|
bool b = noexcept(ConstExpr()) && ThrowSomething(); // expected-error {{cannot be used by non-static data member initializer}}
|
|
};
|
|
// We can use it now.
|
|
bool w = noexcept(ConstExpr());
|
|
|
|
// Much more obviously broken: we can't parse the initializer without already
|
|
// knowing whether it produces a noexcept expression.
|
|
struct TemplateArg {
|
|
int n = ExceptionIf<noexcept(TemplateArg())>::f(); // expected-error {{cannot be used by non-static data member initializer}}
|
|
};
|
|
bool x = noexcept(TemplateArg());
|
|
|
|
// And within a nested class.
|
|
struct Nested { // expected-error {{cannot be used by non-static data member initializer}}
|
|
struct Inner {
|
|
int n = ExceptionIf<noexcept(Nested())>::f(); // expected-note {{implicit default constructor for 'InClassInitializers::Nested' first required here}}
|
|
} inner;
|
|
};
|
|
|
|
struct Nested2 {
|
|
struct Inner;
|
|
int n = Inner().n; // expected-error {{cannot be used by non-static data member initializer}}
|
|
struct Inner {
|
|
int n = ExceptionIf<noexcept(Nested2())>::f();
|
|
} inner;
|
|
};
|
|
}
|
|
|
|
namespace ExceptionSpecification {
|
|
// A type is permitted to be used in a dynamic exception specification when it
|
|
// is still being defined, but isn't complete within such an exception
|
|
// specification.
|
|
struct Nested { // expected-note {{not complete}}
|
|
struct T {
|
|
T() noexcept(!noexcept(Nested())); // expected-error{{incomplete type}}
|
|
} t;
|
|
};
|
|
}
|
|
|
|
namespace DefaultArgument {
|
|
struct Default {
|
|
struct T {
|
|
T(int = ExceptionIf<noexcept(Default())::f()); // expected-error {{call to implicitly-deleted default constructor}}
|
|
} t; // expected-note {{has no default constructor}}
|
|
};
|
|
}
|
|
|
|
namespace ImplicitDtorExceptionSpec {
|
|
struct A {
|
|
virtual ~A();
|
|
|
|
struct Inner {
|
|
~Inner() throw();
|
|
};
|
|
Inner inner;
|
|
};
|
|
|
|
struct B {
|
|
virtual ~B() {} // expected-note {{here}}
|
|
};
|
|
|
|
struct C : B {
|
|
virtual ~C() {}
|
|
A a;
|
|
};
|
|
|
|
struct D : B {
|
|
~D(); // expected-error {{more lax than base}}
|
|
struct E {
|
|
~E();
|
|
struct F {
|
|
~F() throw(A);
|
|
} f;
|
|
} e;
|
|
};
|
|
}
|