2008-06-08 00:52:53 +08:00
|
|
|
//===--- DeclBase.cpp - Declaration AST Node Implementation ---------------===//
|
|
|
|
//
|
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
//
|
|
|
|
// This file implements the Decl and DeclContext classes.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
#include "clang/AST/DeclBase.h"
|
2012-12-04 17:13:33 +08:00
|
|
|
#include "clang/AST/ASTContext.h"
|
|
|
|
#include "clang/AST/ASTMutationListener.h"
|
|
|
|
#include "clang/AST/Attr.h"
|
2009-02-03 07:39:07 +08:00
|
|
|
#include "clang/AST/Decl.h"
|
2008-06-10 05:05:31 +08:00
|
|
|
#include "clang/AST/DeclCXX.h"
|
2012-12-04 17:13:33 +08:00
|
|
|
#include "clang/AST/DeclContextInternals.h"
|
2010-03-11 15:50:04 +08:00
|
|
|
#include "clang/AST/DeclFriend.h"
|
2009-02-05 03:02:06 +08:00
|
|
|
#include "clang/AST/DeclObjC.h"
|
2013-03-22 14:34:35 +08:00
|
|
|
#include "clang/AST/DeclOpenMP.h"
|
2009-02-05 03:02:06 +08:00
|
|
|
#include "clang/AST/DeclTemplate.h"
|
2010-03-24 13:22:00 +08:00
|
|
|
#include "clang/AST/DependentDiagnostic.h"
|
2012-12-01 23:09:41 +08:00
|
|
|
#include "clang/AST/ExternalASTSource.h"
|
2009-04-27 04:35:05 +08:00
|
|
|
#include "clang/AST/Stmt.h"
|
|
|
|
#include "clang/AST/StmtCXX.h"
|
2012-12-01 23:09:41 +08:00
|
|
|
#include "clang/AST/Type.h"
|
Implement a new 'availability' attribute, that allows one to specify
which versions of an OS provide a certain facility. For example,
void foo()
__attribute__((availability(macosx,introduced=10.2,deprecated=10.4,obsoleted=10.6)));
says that the function "foo" was introduced in 10.2, deprecated in
10.4, and completely obsoleted in 10.6. This attribute ties in with
the deployment targets (e.g., -mmacosx-version-min=10.1 specifies that
we want to deploy back to Mac OS X 10.1). There are several concrete
behaviors that this attribute enables, as illustrated with the
function foo() above:
- If we choose a deployment target >= Mac OS X 10.4, uses of "foo"
will result in a deprecation warning, as if we had placed
attribute((deprecated)) on it (but with a better diagnostic)
- If we choose a deployment target >= Mac OS X 10.6, uses of "foo"
will result in an "unavailable" warning (in C)/error (in C++), as
if we had placed attribute((unavailable)) on it
- If we choose a deployment target prior to 10.2, foo() is
weak-imported (if it is a kind of entity that can be weak
imported), as if we had placed the weak_import attribute on it.
Naturally, there can be multiple availability attributes on a
declaration, for different platforms; only the current platform
matters when checking availability attributes.
The only platforms this attribute currently works for are "ios" and
"macosx", since we already have -mxxxx-version-min flags for them and we
have experience there with macro tricks translating down to the
deprecated/unavailable/weak_import attributes. The end goal is to open
this up to other platforms, and even extension to other "platforms"
that are really libraries (say, through a #pragma clang
define_system), but that hasn't yet been designed and we may want to
shake out more issues with this narrower problem first.
Addresses <rdar://problem/6690412>.
As a drive-by bug-fix, if an entity is both deprecated and
unavailable, we only emit the "unavailable" diagnostic.
llvm-svn: 128127
2011-03-23 08:50:03 +08:00
|
|
|
#include "clang/Basic/TargetInfo.h"
|
2008-06-08 00:52:53 +08:00
|
|
|
#include "llvm/ADT/DenseMap.h"
|
2009-03-05 16:00:35 +08:00
|
|
|
#include "llvm/Support/raw_ostream.h"
|
2008-12-24 05:05:05 +08:00
|
|
|
#include <algorithm>
|
2008-06-08 00:52:53 +08:00
|
|
|
using namespace clang;
|
|
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Statistics
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2010-05-30 15:21:58 +08:00
|
|
|
#define DECL(DERIVED, BASE) static int n##DERIVED##s = 0;
|
|
|
|
#define ABSTRACT_DECL(DECL)
|
|
|
|
#include "clang/AST/DeclNodes.inc"
|
2008-06-08 00:52:53 +08:00
|
|
|
|
Ensure that type definitions present in just-loaded modules are
visible.
The basic problem here is that a given translation unit can use
forward declarations to form pointers to a given type, say,
class X;
X *x;
and then import a module that includes a definition of X:
import XDef;
We will then fail when attempting to access a member of X, e.g.,
x->method()
because the AST reader did not know to look for a default of a class
named X within the new module.
This implementation is a bit of a C-centric hack, because the only
definitions that can have this property are enums, structs, unions,
Objective-C classes, and Objective-C protocols, and all of those are
either visible at the top-level or can't be defined later. Hence, we
can use the out-of-date-ness of the name and the identifier-update
mechanism to force the update.
In C++, we will not be so lucky, and will need a more advanced
solution, because the definitions could be in namespaces defined in
two different modules, e.g.,
// module 1
namespace N { struct X; }
// module 2
namespace N { struct X { /* ... */ }; }
One possible implementation here is for C++ to extend the information
associated with each identifier table to include the declaration IDs
of any definitions associated with that name, regardless of
context. We would have to eagerly load those definitions.
llvm-svn: 174794
2013-02-09 09:35:03 +08:00
|
|
|
void Decl::updateOutOfDate(IdentifierInfo &II) const {
|
|
|
|
getASTContext().getExternalSource()->updateOutOfDateIdentifier(II);
|
|
|
|
}
|
|
|
|
|
2012-01-06 05:55:30 +08:00
|
|
|
void *Decl::AllocateDeserializedDecl(const ASTContext &Context,
|
|
|
|
unsigned ID,
|
|
|
|
unsigned Size) {
|
2012-01-06 07:49:36 +08:00
|
|
|
// Allocate an extra 8 bytes worth of storage, which ensures that the
|
2012-01-10 01:30:44 +08:00
|
|
|
// resulting pointer will still be 8-byte aligned.
|
2012-01-06 07:49:36 +08:00
|
|
|
void *Start = Context.Allocate(Size + 8);
|
|
|
|
void *Result = (char*)Start + 8;
|
2012-01-06 06:27:05 +08:00
|
|
|
|
2012-01-10 01:30:44 +08:00
|
|
|
unsigned *PrefixPtr = (unsigned *)Result - 2;
|
|
|
|
|
|
|
|
// Zero out the first 4 bytes; this is used to store the owning module ID.
|
|
|
|
PrefixPtr[0] = 0;
|
|
|
|
|
|
|
|
// Store the global declaration ID in the second 4 bytes.
|
|
|
|
PrefixPtr[1] = ID;
|
2012-01-06 06:27:05 +08:00
|
|
|
|
|
|
|
return Result;
|
2012-01-06 05:55:30 +08:00
|
|
|
}
|
|
|
|
|
2013-01-12 09:29:50 +08:00
|
|
|
Module *Decl::getOwningModuleSlow() const {
|
|
|
|
assert(isFromASTFile() && "Not from AST file?");
|
|
|
|
return getASTContext().getExternalSource()->getModule(getOwningModuleID());
|
|
|
|
}
|
|
|
|
|
2008-06-08 00:52:53 +08:00
|
|
|
const char *Decl::getDeclKindName() const {
|
|
|
|
switch (DeclKind) {
|
2011-09-23 13:06:16 +08:00
|
|
|
default: llvm_unreachable("Declaration not in DeclNodes.inc!");
|
2010-05-30 15:21:58 +08:00
|
|
|
#define DECL(DERIVED, BASE) case DERIVED: return #DERIVED;
|
|
|
|
#define ABSTRACT_DECL(DECL)
|
|
|
|
#include "clang/AST/DeclNodes.inc"
|
2008-06-08 00:52:53 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-03-05 08:26:45 +08:00
|
|
|
void Decl::setInvalidDecl(bool Invalid) {
|
|
|
|
InvalidDecl = Invalid;
|
2012-03-10 05:09:04 +08:00
|
|
|
if (Invalid && !isa<ParmVarDecl>(this)) {
|
2010-03-05 08:26:45 +08:00
|
|
|
// Defensive maneuver for ill-formed code: we're likely not to make it to
|
|
|
|
// a point where we set the access specifier, so default it to "public"
|
|
|
|
// to avoid triggering asserts elsewhere in the front end.
|
|
|
|
setAccess(AS_public);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-01-21 03:53:53 +08:00
|
|
|
const char *DeclContext::getDeclKindName() const {
|
|
|
|
switch (DeclKind) {
|
2011-09-23 13:06:16 +08:00
|
|
|
default: llvm_unreachable("Declaration context not in DeclNodes.inc!");
|
2010-05-30 15:21:58 +08:00
|
|
|
#define DECL(DERIVED, BASE) case Decl::DERIVED: return #DERIVED;
|
|
|
|
#define ABSTRACT_DECL(DECL)
|
|
|
|
#include "clang/AST/DeclNodes.inc"
|
2009-01-21 03:53:53 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-03-06 05:42:49 +08:00
|
|
|
bool Decl::StatisticsEnabled = false;
|
|
|
|
void Decl::EnableStatistics() {
|
|
|
|
StatisticsEnabled = true;
|
2008-06-08 00:52:53 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
void Decl::PrintStats() {
|
2011-07-04 14:13:27 +08:00
|
|
|
llvm::errs() << "\n*** Decl Stats:\n";
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2009-02-03 07:39:07 +08:00
|
|
|
int totalDecls = 0;
|
2010-05-30 15:21:58 +08:00
|
|
|
#define DECL(DERIVED, BASE) totalDecls += n##DERIVED##s;
|
|
|
|
#define ABSTRACT_DECL(DECL)
|
|
|
|
#include "clang/AST/DeclNodes.inc"
|
2011-07-04 14:13:27 +08:00
|
|
|
llvm::errs() << " " << totalDecls << " decls total.\n";
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2009-02-03 07:39:07 +08:00
|
|
|
int totalBytes = 0;
|
2010-05-30 15:21:58 +08:00
|
|
|
#define DECL(DERIVED, BASE) \
|
|
|
|
if (n##DERIVED##s > 0) { \
|
|
|
|
totalBytes += (int)(n##DERIVED##s * sizeof(DERIVED##Decl)); \
|
2011-07-04 14:13:27 +08:00
|
|
|
llvm::errs() << " " << n##DERIVED##s << " " #DERIVED " decls, " \
|
|
|
|
<< sizeof(DERIVED##Decl) << " each (" \
|
|
|
|
<< n##DERIVED##s * sizeof(DERIVED##Decl) \
|
|
|
|
<< " bytes)\n"; \
|
2009-02-03 07:39:07 +08:00
|
|
|
}
|
2010-05-30 15:21:58 +08:00
|
|
|
#define ABSTRACT_DECL(DECL)
|
|
|
|
#include "clang/AST/DeclNodes.inc"
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2011-07-04 14:13:27 +08:00
|
|
|
llvm::errs() << "Total bytes = " << totalBytes << "\n";
|
2008-06-08 00:52:53 +08:00
|
|
|
}
|
|
|
|
|
2010-05-30 15:21:58 +08:00
|
|
|
void Decl::add(Kind k) {
|
2008-06-08 00:52:53 +08:00
|
|
|
switch (k) {
|
2010-05-30 15:21:58 +08:00
|
|
|
#define DECL(DERIVED, BASE) case DERIVED: ++n##DERIVED##s; break;
|
|
|
|
#define ABSTRACT_DECL(DECL)
|
|
|
|
#include "clang/AST/DeclNodes.inc"
|
2008-06-08 00:52:53 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-06-13 08:08:58 +08:00
|
|
|
bool Decl::isTemplateParameterPack() const {
|
|
|
|
if (const TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(this))
|
|
|
|
return TTP->isParameterPack();
|
2010-12-24 07:51:58 +08:00
|
|
|
if (const NonTypeTemplateParmDecl *NTTP
|
2011-01-05 23:48:55 +08:00
|
|
|
= dyn_cast<NonTypeTemplateParmDecl>(this))
|
2010-12-24 07:51:58 +08:00
|
|
|
return NTTP->isParameterPack();
|
2011-01-05 23:48:55 +08:00
|
|
|
if (const TemplateTemplateParmDecl *TTP
|
|
|
|
= dyn_cast<TemplateTemplateParmDecl>(this))
|
|
|
|
return TTP->isParameterPack();
|
2009-06-13 08:08:58 +08:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2011-01-06 05:11:38 +08:00
|
|
|
bool Decl::isParameterPack() const {
|
|
|
|
if (const ParmVarDecl *Parm = dyn_cast<ParmVarDecl>(this))
|
|
|
|
return Parm->isParameterPack();
|
|
|
|
|
|
|
|
return isTemplateParameterPack();
|
|
|
|
}
|
|
|
|
|
2009-06-26 06:08:12 +08:00
|
|
|
bool Decl::isFunctionOrFunctionTemplate() const {
|
2009-11-17 13:59:44 +08:00
|
|
|
if (const UsingShadowDecl *UD = dyn_cast<UsingShadowDecl>(this))
|
2009-06-26 13:26:50 +08:00
|
|
|
return UD->getTargetDecl()->isFunctionOrFunctionTemplate();
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2009-06-26 06:08:12 +08:00
|
|
|
return isa<FunctionDecl>(this) || isa<FunctionTemplateDecl>(this);
|
|
|
|
}
|
|
|
|
|
2011-09-09 01:42:31 +08:00
|
|
|
bool Decl::isTemplateDecl() const {
|
|
|
|
return isa<TemplateDecl>(this);
|
|
|
|
}
|
|
|
|
|
2011-09-28 10:45:33 +08:00
|
|
|
const DeclContext *Decl::getParentFunctionOrMethod() const {
|
|
|
|
for (const DeclContext *DC = getDeclContext();
|
|
|
|
DC && !DC->isTranslationUnit() && !DC->isNamespace();
|
2010-01-17 04:21:20 +08:00
|
|
|
DC = DC->getParent())
|
|
|
|
if (DC->isFunctionOrMethod())
|
2011-09-28 10:45:33 +08:00
|
|
|
return DC;
|
2010-01-17 04:21:20 +08:00
|
|
|
|
2011-09-28 10:45:33 +08:00
|
|
|
return 0;
|
2010-01-17 04:21:20 +08:00
|
|
|
}
|
|
|
|
|
2011-02-17 16:47:29 +08:00
|
|
|
|
2009-03-05 16:00:35 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// PrettyStackTraceDecl Implementation
|
|
|
|
//===----------------------------------------------------------------------===//
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2011-07-23 18:55:15 +08:00
|
|
|
void PrettyStackTraceDecl::print(raw_ostream &OS) const {
|
2009-03-05 16:00:35 +08:00
|
|
|
SourceLocation TheLoc = Loc;
|
|
|
|
if (TheLoc.isInvalid() && TheDecl)
|
|
|
|
TheLoc = TheDecl->getLocation();
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2009-03-05 16:00:35 +08:00
|
|
|
if (TheLoc.isValid()) {
|
|
|
|
TheLoc.print(OS, SM);
|
|
|
|
OS << ": ";
|
|
|
|
}
|
|
|
|
|
|
|
|
OS << Message;
|
|
|
|
|
2013-02-23 21:53:57 +08:00
|
|
|
if (const NamedDecl *DN = dyn_cast_or_null<NamedDecl>(TheDecl)) {
|
|
|
|
OS << " '";
|
|
|
|
DN->printQualifiedName(OS);
|
|
|
|
OS << '\'';
|
|
|
|
}
|
2009-03-05 16:00:35 +08:00
|
|
|
OS << '\n';
|
|
|
|
}
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2008-06-08 00:52:53 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Decl Implementation
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2011-02-20 02:51:44 +08:00
|
|
|
// Out-of-line virtual method providing a home for Decl.
|
|
|
|
Decl::~Decl() { }
|
2011-02-17 15:02:32 +08:00
|
|
|
|
2009-01-20 09:17:11 +08:00
|
|
|
void Decl::setDeclContext(DeclContext *DC) {
|
2009-03-29 14:06:59 +08:00
|
|
|
DeclCtx = DC;
|
2009-01-20 09:17:11 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
void Decl::setLexicalDeclContext(DeclContext *DC) {
|
|
|
|
if (DC == getLexicalDeclContext())
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (isInSemaDC()) {
|
2012-02-09 10:44:08 +08:00
|
|
|
setDeclContextsImpl(getDeclContext(), DC, getASTContext());
|
2009-01-20 09:17:11 +08:00
|
|
|
} else {
|
|
|
|
getMultipleDC()->LexicalDC = DC;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-02-09 10:44:08 +08:00
|
|
|
void Decl::setDeclContextsImpl(DeclContext *SemaDC, DeclContext *LexicalDC,
|
|
|
|
ASTContext &Ctx) {
|
|
|
|
if (SemaDC == LexicalDC) {
|
|
|
|
DeclCtx = SemaDC;
|
|
|
|
} else {
|
|
|
|
Decl::MultipleDC *MDC = new (Ctx) Decl::MultipleDC();
|
|
|
|
MDC->SemanticDC = SemaDC;
|
|
|
|
MDC->LexicalDC = LexicalDC;
|
|
|
|
DeclCtx = MDC;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-10-01 08:25:31 +08:00
|
|
|
bool Decl::isInAnonymousNamespace() const {
|
|
|
|
const DeclContext *DC = getDeclContext();
|
|
|
|
do {
|
|
|
|
if (const NamespaceDecl *ND = dyn_cast<NamespaceDecl>(DC))
|
|
|
|
if (ND->isAnonymousNamespace())
|
|
|
|
return true;
|
|
|
|
} while ((DC = DC->getParent()));
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2009-06-30 01:38:40 +08:00
|
|
|
TranslationUnitDecl *Decl::getTranslationUnitDecl() {
|
2009-06-30 10:34:53 +08:00
|
|
|
if (TranslationUnitDecl *TUD = dyn_cast<TranslationUnitDecl>(this))
|
|
|
|
return TUD;
|
|
|
|
|
2009-06-30 01:38:40 +08:00
|
|
|
DeclContext *DC = getDeclContext();
|
|
|
|
assert(DC && "This decl is not contained in a translation unit!");
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2009-06-30 01:38:40 +08:00
|
|
|
while (!DC->isTranslationUnit()) {
|
|
|
|
DC = DC->getParent();
|
|
|
|
assert(DC && "This decl is not contained in a translation unit!");
|
|
|
|
}
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2009-06-30 01:38:40 +08:00
|
|
|
return cast<TranslationUnitDecl>(DC);
|
|
|
|
}
|
|
|
|
|
|
|
|
ASTContext &Decl::getASTContext() const {
|
2009-09-09 23:08:12 +08:00
|
|
|
return getTranslationUnitDecl()->getASTContext();
|
2009-06-30 01:38:40 +08:00
|
|
|
}
|
|
|
|
|
2010-10-25 01:26:36 +08:00
|
|
|
ASTMutationListener *Decl::getASTMutationListener() const {
|
|
|
|
return getASTContext().getASTMutationListener();
|
|
|
|
}
|
|
|
|
|
2012-12-01 23:09:41 +08:00
|
|
|
unsigned Decl::getMaxAlignment() const {
|
|
|
|
if (!hasAttrs())
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
unsigned Align = 0;
|
|
|
|
const AttrVec &V = getAttrs();
|
|
|
|
ASTContext &Ctx = getASTContext();
|
|
|
|
specific_attr_iterator<AlignedAttr> I(V.begin()), E(V.end());
|
|
|
|
for (; I != E; ++I)
|
|
|
|
Align = std::max(Align, I->getAlignment(Ctx));
|
|
|
|
return Align;
|
|
|
|
}
|
|
|
|
|
2010-06-18 07:14:26 +08:00
|
|
|
bool Decl::isUsed(bool CheckUsedAttr) const {
|
2010-02-17 10:17:21 +08:00
|
|
|
if (Used)
|
|
|
|
return true;
|
|
|
|
|
|
|
|
// Check for used attribute.
|
2010-06-18 07:14:26 +08:00
|
|
|
if (CheckUsedAttr && hasAttr<UsedAttr>())
|
2010-02-17 10:17:21 +08:00
|
|
|
return true;
|
2012-11-24 00:26:30 +08:00
|
|
|
|
2010-02-17 10:17:21 +08:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2011-04-20 03:51:10 +08:00
|
|
|
bool Decl::isReferenced() const {
|
|
|
|
if (Referenced)
|
|
|
|
return true;
|
|
|
|
|
|
|
|
// Check redeclarations.
|
|
|
|
for (redecl_iterator I = redecls_begin(), E = redecls_end(); I != E; ++I)
|
|
|
|
if (I->Referenced)
|
|
|
|
return true;
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
Implement a new 'availability' attribute, that allows one to specify
which versions of an OS provide a certain facility. For example,
void foo()
__attribute__((availability(macosx,introduced=10.2,deprecated=10.4,obsoleted=10.6)));
says that the function "foo" was introduced in 10.2, deprecated in
10.4, and completely obsoleted in 10.6. This attribute ties in with
the deployment targets (e.g., -mmacosx-version-min=10.1 specifies that
we want to deploy back to Mac OS X 10.1). There are several concrete
behaviors that this attribute enables, as illustrated with the
function foo() above:
- If we choose a deployment target >= Mac OS X 10.4, uses of "foo"
will result in a deprecation warning, as if we had placed
attribute((deprecated)) on it (but with a better diagnostic)
- If we choose a deployment target >= Mac OS X 10.6, uses of "foo"
will result in an "unavailable" warning (in C)/error (in C++), as
if we had placed attribute((unavailable)) on it
- If we choose a deployment target prior to 10.2, foo() is
weak-imported (if it is a kind of entity that can be weak
imported), as if we had placed the weak_import attribute on it.
Naturally, there can be multiple availability attributes on a
declaration, for different platforms; only the current platform
matters when checking availability attributes.
The only platforms this attribute currently works for are "ios" and
"macosx", since we already have -mxxxx-version-min flags for them and we
have experience there with macro tricks translating down to the
deprecated/unavailable/weak_import attributes. The end goal is to open
this up to other platforms, and even extension to other "platforms"
that are really libraries (say, through a #pragma clang
define_system), but that hasn't yet been designed and we may want to
shake out more issues with this narrower problem first.
Addresses <rdar://problem/6690412>.
As a drive-by bug-fix, if an entity is both deprecated and
unavailable, we only emit the "unavailable" diagnostic.
llvm-svn: 128127
2011-03-23 08:50:03 +08:00
|
|
|
/// \brief Determine the availability of the given declaration based on
|
|
|
|
/// the target platform.
|
|
|
|
///
|
|
|
|
/// When it returns an availability result other than \c AR_Available,
|
|
|
|
/// if the \p Message parameter is non-NULL, it will be set to a
|
|
|
|
/// string describing why the entity is unavailable.
|
|
|
|
///
|
|
|
|
/// FIXME: Make these strings localizable, since they end up in
|
|
|
|
/// diagnostics.
|
|
|
|
static AvailabilityResult CheckAvailability(ASTContext &Context,
|
|
|
|
const AvailabilityAttr *A,
|
|
|
|
std::string *Message) {
|
2011-09-02 08:18:52 +08:00
|
|
|
StringRef TargetPlatform = Context.getTargetInfo().getPlatformName();
|
2011-07-23 18:55:15 +08:00
|
|
|
StringRef PrettyPlatformName
|
Implement a new 'availability' attribute, that allows one to specify
which versions of an OS provide a certain facility. For example,
void foo()
__attribute__((availability(macosx,introduced=10.2,deprecated=10.4,obsoleted=10.6)));
says that the function "foo" was introduced in 10.2, deprecated in
10.4, and completely obsoleted in 10.6. This attribute ties in with
the deployment targets (e.g., -mmacosx-version-min=10.1 specifies that
we want to deploy back to Mac OS X 10.1). There are several concrete
behaviors that this attribute enables, as illustrated with the
function foo() above:
- If we choose a deployment target >= Mac OS X 10.4, uses of "foo"
will result in a deprecation warning, as if we had placed
attribute((deprecated)) on it (but with a better diagnostic)
- If we choose a deployment target >= Mac OS X 10.6, uses of "foo"
will result in an "unavailable" warning (in C)/error (in C++), as
if we had placed attribute((unavailable)) on it
- If we choose a deployment target prior to 10.2, foo() is
weak-imported (if it is a kind of entity that can be weak
imported), as if we had placed the weak_import attribute on it.
Naturally, there can be multiple availability attributes on a
declaration, for different platforms; only the current platform
matters when checking availability attributes.
The only platforms this attribute currently works for are "ios" and
"macosx", since we already have -mxxxx-version-min flags for them and we
have experience there with macro tricks translating down to the
deprecated/unavailable/weak_import attributes. The end goal is to open
this up to other platforms, and even extension to other "platforms"
that are really libraries (say, through a #pragma clang
define_system), but that hasn't yet been designed and we may want to
shake out more issues with this narrower problem first.
Addresses <rdar://problem/6690412>.
As a drive-by bug-fix, if an entity is both deprecated and
unavailable, we only emit the "unavailable" diagnostic.
llvm-svn: 128127
2011-03-23 08:50:03 +08:00
|
|
|
= AvailabilityAttr::getPrettyPlatformName(TargetPlatform);
|
|
|
|
if (PrettyPlatformName.empty())
|
|
|
|
PrettyPlatformName = TargetPlatform;
|
|
|
|
|
2011-09-02 08:18:52 +08:00
|
|
|
VersionTuple TargetMinVersion = Context.getTargetInfo().getPlatformMinVersion();
|
Implement a new 'availability' attribute, that allows one to specify
which versions of an OS provide a certain facility. For example,
void foo()
__attribute__((availability(macosx,introduced=10.2,deprecated=10.4,obsoleted=10.6)));
says that the function "foo" was introduced in 10.2, deprecated in
10.4, and completely obsoleted in 10.6. This attribute ties in with
the deployment targets (e.g., -mmacosx-version-min=10.1 specifies that
we want to deploy back to Mac OS X 10.1). There are several concrete
behaviors that this attribute enables, as illustrated with the
function foo() above:
- If we choose a deployment target >= Mac OS X 10.4, uses of "foo"
will result in a deprecation warning, as if we had placed
attribute((deprecated)) on it (but with a better diagnostic)
- If we choose a deployment target >= Mac OS X 10.6, uses of "foo"
will result in an "unavailable" warning (in C)/error (in C++), as
if we had placed attribute((unavailable)) on it
- If we choose a deployment target prior to 10.2, foo() is
weak-imported (if it is a kind of entity that can be weak
imported), as if we had placed the weak_import attribute on it.
Naturally, there can be multiple availability attributes on a
declaration, for different platforms; only the current platform
matters when checking availability attributes.
The only platforms this attribute currently works for are "ios" and
"macosx", since we already have -mxxxx-version-min flags for them and we
have experience there with macro tricks translating down to the
deprecated/unavailable/weak_import attributes. The end goal is to open
this up to other platforms, and even extension to other "platforms"
that are really libraries (say, through a #pragma clang
define_system), but that hasn't yet been designed and we may want to
shake out more issues with this narrower problem first.
Addresses <rdar://problem/6690412>.
As a drive-by bug-fix, if an entity is both deprecated and
unavailable, we only emit the "unavailable" diagnostic.
llvm-svn: 128127
2011-03-23 08:50:03 +08:00
|
|
|
if (TargetMinVersion.empty())
|
|
|
|
return AR_Available;
|
|
|
|
|
|
|
|
// Match the platform name.
|
|
|
|
if (A->getPlatform()->getName() != TargetPlatform)
|
|
|
|
return AR_Available;
|
2011-12-10 08:28:41 +08:00
|
|
|
|
|
|
|
std::string HintMessage;
|
|
|
|
if (!A->getMessage().empty()) {
|
|
|
|
HintMessage = " - ";
|
|
|
|
HintMessage += A->getMessage();
|
|
|
|
}
|
|
|
|
|
2011-03-26 11:35:55 +08:00
|
|
|
// Make sure that this declaration has not been marked 'unavailable'.
|
|
|
|
if (A->getUnavailable()) {
|
|
|
|
if (Message) {
|
|
|
|
Message->clear();
|
|
|
|
llvm::raw_string_ostream Out(*Message);
|
2011-12-10 08:28:41 +08:00
|
|
|
Out << "not available on " << PrettyPlatformName
|
|
|
|
<< HintMessage;
|
2011-03-26 11:35:55 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
return AR_Unavailable;
|
|
|
|
}
|
|
|
|
|
Implement a new 'availability' attribute, that allows one to specify
which versions of an OS provide a certain facility. For example,
void foo()
__attribute__((availability(macosx,introduced=10.2,deprecated=10.4,obsoleted=10.6)));
says that the function "foo" was introduced in 10.2, deprecated in
10.4, and completely obsoleted in 10.6. This attribute ties in with
the deployment targets (e.g., -mmacosx-version-min=10.1 specifies that
we want to deploy back to Mac OS X 10.1). There are several concrete
behaviors that this attribute enables, as illustrated with the
function foo() above:
- If we choose a deployment target >= Mac OS X 10.4, uses of "foo"
will result in a deprecation warning, as if we had placed
attribute((deprecated)) on it (but with a better diagnostic)
- If we choose a deployment target >= Mac OS X 10.6, uses of "foo"
will result in an "unavailable" warning (in C)/error (in C++), as
if we had placed attribute((unavailable)) on it
- If we choose a deployment target prior to 10.2, foo() is
weak-imported (if it is a kind of entity that can be weak
imported), as if we had placed the weak_import attribute on it.
Naturally, there can be multiple availability attributes on a
declaration, for different platforms; only the current platform
matters when checking availability attributes.
The only platforms this attribute currently works for are "ios" and
"macosx", since we already have -mxxxx-version-min flags for them and we
have experience there with macro tricks translating down to the
deprecated/unavailable/weak_import attributes. The end goal is to open
this up to other platforms, and even extension to other "platforms"
that are really libraries (say, through a #pragma clang
define_system), but that hasn't yet been designed and we may want to
shake out more issues with this narrower problem first.
Addresses <rdar://problem/6690412>.
As a drive-by bug-fix, if an entity is both deprecated and
unavailable, we only emit the "unavailable" diagnostic.
llvm-svn: 128127
2011-03-23 08:50:03 +08:00
|
|
|
// Make sure that this declaration has already been introduced.
|
|
|
|
if (!A->getIntroduced().empty() &&
|
|
|
|
TargetMinVersion < A->getIntroduced()) {
|
|
|
|
if (Message) {
|
|
|
|
Message->clear();
|
|
|
|
llvm::raw_string_ostream Out(*Message);
|
|
|
|
Out << "introduced in " << PrettyPlatformName << ' '
|
2011-12-10 08:28:41 +08:00
|
|
|
<< A->getIntroduced() << HintMessage;
|
Implement a new 'availability' attribute, that allows one to specify
which versions of an OS provide a certain facility. For example,
void foo()
__attribute__((availability(macosx,introduced=10.2,deprecated=10.4,obsoleted=10.6)));
says that the function "foo" was introduced in 10.2, deprecated in
10.4, and completely obsoleted in 10.6. This attribute ties in with
the deployment targets (e.g., -mmacosx-version-min=10.1 specifies that
we want to deploy back to Mac OS X 10.1). There are several concrete
behaviors that this attribute enables, as illustrated with the
function foo() above:
- If we choose a deployment target >= Mac OS X 10.4, uses of "foo"
will result in a deprecation warning, as if we had placed
attribute((deprecated)) on it (but with a better diagnostic)
- If we choose a deployment target >= Mac OS X 10.6, uses of "foo"
will result in an "unavailable" warning (in C)/error (in C++), as
if we had placed attribute((unavailable)) on it
- If we choose a deployment target prior to 10.2, foo() is
weak-imported (if it is a kind of entity that can be weak
imported), as if we had placed the weak_import attribute on it.
Naturally, there can be multiple availability attributes on a
declaration, for different platforms; only the current platform
matters when checking availability attributes.
The only platforms this attribute currently works for are "ios" and
"macosx", since we already have -mxxxx-version-min flags for them and we
have experience there with macro tricks translating down to the
deprecated/unavailable/weak_import attributes. The end goal is to open
this up to other platforms, and even extension to other "platforms"
that are really libraries (say, through a #pragma clang
define_system), but that hasn't yet been designed and we may want to
shake out more issues with this narrower problem first.
Addresses <rdar://problem/6690412>.
As a drive-by bug-fix, if an entity is both deprecated and
unavailable, we only emit the "unavailable" diagnostic.
llvm-svn: 128127
2011-03-23 08:50:03 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
return AR_NotYetIntroduced;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Make sure that this declaration hasn't been obsoleted.
|
|
|
|
if (!A->getObsoleted().empty() && TargetMinVersion >= A->getObsoleted()) {
|
|
|
|
if (Message) {
|
|
|
|
Message->clear();
|
|
|
|
llvm::raw_string_ostream Out(*Message);
|
|
|
|
Out << "obsoleted in " << PrettyPlatformName << ' '
|
2011-12-10 08:28:41 +08:00
|
|
|
<< A->getObsoleted() << HintMessage;
|
Implement a new 'availability' attribute, that allows one to specify
which versions of an OS provide a certain facility. For example,
void foo()
__attribute__((availability(macosx,introduced=10.2,deprecated=10.4,obsoleted=10.6)));
says that the function "foo" was introduced in 10.2, deprecated in
10.4, and completely obsoleted in 10.6. This attribute ties in with
the deployment targets (e.g., -mmacosx-version-min=10.1 specifies that
we want to deploy back to Mac OS X 10.1). There are several concrete
behaviors that this attribute enables, as illustrated with the
function foo() above:
- If we choose a deployment target >= Mac OS X 10.4, uses of "foo"
will result in a deprecation warning, as if we had placed
attribute((deprecated)) on it (but with a better diagnostic)
- If we choose a deployment target >= Mac OS X 10.6, uses of "foo"
will result in an "unavailable" warning (in C)/error (in C++), as
if we had placed attribute((unavailable)) on it
- If we choose a deployment target prior to 10.2, foo() is
weak-imported (if it is a kind of entity that can be weak
imported), as if we had placed the weak_import attribute on it.
Naturally, there can be multiple availability attributes on a
declaration, for different platforms; only the current platform
matters when checking availability attributes.
The only platforms this attribute currently works for are "ios" and
"macosx", since we already have -mxxxx-version-min flags for them and we
have experience there with macro tricks translating down to the
deprecated/unavailable/weak_import attributes. The end goal is to open
this up to other platforms, and even extension to other "platforms"
that are really libraries (say, through a #pragma clang
define_system), but that hasn't yet been designed and we may want to
shake out more issues with this narrower problem first.
Addresses <rdar://problem/6690412>.
As a drive-by bug-fix, if an entity is both deprecated and
unavailable, we only emit the "unavailable" diagnostic.
llvm-svn: 128127
2011-03-23 08:50:03 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
return AR_Unavailable;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Make sure that this declaration hasn't been deprecated.
|
|
|
|
if (!A->getDeprecated().empty() && TargetMinVersion >= A->getDeprecated()) {
|
|
|
|
if (Message) {
|
|
|
|
Message->clear();
|
|
|
|
llvm::raw_string_ostream Out(*Message);
|
|
|
|
Out << "first deprecated in " << PrettyPlatformName << ' '
|
2011-12-10 08:28:41 +08:00
|
|
|
<< A->getDeprecated() << HintMessage;
|
Implement a new 'availability' attribute, that allows one to specify
which versions of an OS provide a certain facility. For example,
void foo()
__attribute__((availability(macosx,introduced=10.2,deprecated=10.4,obsoleted=10.6)));
says that the function "foo" was introduced in 10.2, deprecated in
10.4, and completely obsoleted in 10.6. This attribute ties in with
the deployment targets (e.g., -mmacosx-version-min=10.1 specifies that
we want to deploy back to Mac OS X 10.1). There are several concrete
behaviors that this attribute enables, as illustrated with the
function foo() above:
- If we choose a deployment target >= Mac OS X 10.4, uses of "foo"
will result in a deprecation warning, as if we had placed
attribute((deprecated)) on it (but with a better diagnostic)
- If we choose a deployment target >= Mac OS X 10.6, uses of "foo"
will result in an "unavailable" warning (in C)/error (in C++), as
if we had placed attribute((unavailable)) on it
- If we choose a deployment target prior to 10.2, foo() is
weak-imported (if it is a kind of entity that can be weak
imported), as if we had placed the weak_import attribute on it.
Naturally, there can be multiple availability attributes on a
declaration, for different platforms; only the current platform
matters when checking availability attributes.
The only platforms this attribute currently works for are "ios" and
"macosx", since we already have -mxxxx-version-min flags for them and we
have experience there with macro tricks translating down to the
deprecated/unavailable/weak_import attributes. The end goal is to open
this up to other platforms, and even extension to other "platforms"
that are really libraries (say, through a #pragma clang
define_system), but that hasn't yet been designed and we may want to
shake out more issues with this narrower problem first.
Addresses <rdar://problem/6690412>.
As a drive-by bug-fix, if an entity is both deprecated and
unavailable, we only emit the "unavailable" diagnostic.
llvm-svn: 128127
2011-03-23 08:50:03 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
return AR_Deprecated;
|
|
|
|
}
|
|
|
|
|
|
|
|
return AR_Available;
|
|
|
|
}
|
|
|
|
|
|
|
|
AvailabilityResult Decl::getAvailability(std::string *Message) const {
|
|
|
|
AvailabilityResult Result = AR_Available;
|
|
|
|
std::string ResultMessage;
|
|
|
|
|
|
|
|
for (attr_iterator A = attr_begin(), AEnd = attr_end(); A != AEnd; ++A) {
|
|
|
|
if (DeprecatedAttr *Deprecated = dyn_cast<DeprecatedAttr>(*A)) {
|
|
|
|
if (Result >= AR_Deprecated)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (Message)
|
|
|
|
ResultMessage = Deprecated->getMessage();
|
|
|
|
|
|
|
|
Result = AR_Deprecated;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (UnavailableAttr *Unavailable = dyn_cast<UnavailableAttr>(*A)) {
|
|
|
|
if (Message)
|
|
|
|
*Message = Unavailable->getMessage();
|
|
|
|
return AR_Unavailable;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (AvailabilityAttr *Availability = dyn_cast<AvailabilityAttr>(*A)) {
|
|
|
|
AvailabilityResult AR = CheckAvailability(getASTContext(), Availability,
|
|
|
|
Message);
|
|
|
|
|
|
|
|
if (AR == AR_Unavailable)
|
|
|
|
return AR_Unavailable;
|
|
|
|
|
|
|
|
if (AR > Result) {
|
|
|
|
Result = AR;
|
|
|
|
if (Message)
|
|
|
|
ResultMessage.swap(*Message);
|
|
|
|
}
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (Message)
|
|
|
|
Message->swap(ResultMessage);
|
|
|
|
return Result;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool Decl::canBeWeakImported(bool &IsDefinition) const {
|
|
|
|
IsDefinition = false;
|
2012-06-20 14:18:46 +08:00
|
|
|
|
|
|
|
// Variables, if they aren't definitions.
|
Implement a new 'availability' attribute, that allows one to specify
which versions of an OS provide a certain facility. For example,
void foo()
__attribute__((availability(macosx,introduced=10.2,deprecated=10.4,obsoleted=10.6)));
says that the function "foo" was introduced in 10.2, deprecated in
10.4, and completely obsoleted in 10.6. This attribute ties in with
the deployment targets (e.g., -mmacosx-version-min=10.1 specifies that
we want to deploy back to Mac OS X 10.1). There are several concrete
behaviors that this attribute enables, as illustrated with the
function foo() above:
- If we choose a deployment target >= Mac OS X 10.4, uses of "foo"
will result in a deprecation warning, as if we had placed
attribute((deprecated)) on it (but with a better diagnostic)
- If we choose a deployment target >= Mac OS X 10.6, uses of "foo"
will result in an "unavailable" warning (in C)/error (in C++), as
if we had placed attribute((unavailable)) on it
- If we choose a deployment target prior to 10.2, foo() is
weak-imported (if it is a kind of entity that can be weak
imported), as if we had placed the weak_import attribute on it.
Naturally, there can be multiple availability attributes on a
declaration, for different platforms; only the current platform
matters when checking availability attributes.
The only platforms this attribute currently works for are "ios" and
"macosx", since we already have -mxxxx-version-min flags for them and we
have experience there with macro tricks translating down to the
deprecated/unavailable/weak_import attributes. The end goal is to open
this up to other platforms, and even extension to other "platforms"
that are really libraries (say, through a #pragma clang
define_system), but that hasn't yet been designed and we may want to
shake out more issues with this narrower problem first.
Addresses <rdar://problem/6690412>.
As a drive-by bug-fix, if an entity is both deprecated and
unavailable, we only emit the "unavailable" diagnostic.
llvm-svn: 128127
2011-03-23 08:50:03 +08:00
|
|
|
if (const VarDecl *Var = dyn_cast<VarDecl>(this)) {
|
2013-04-04 03:27:57 +08:00
|
|
|
if (Var->isThisDeclarationADefinition()) {
|
Implement a new 'availability' attribute, that allows one to specify
which versions of an OS provide a certain facility. For example,
void foo()
__attribute__((availability(macosx,introduced=10.2,deprecated=10.4,obsoleted=10.6)));
says that the function "foo" was introduced in 10.2, deprecated in
10.4, and completely obsoleted in 10.6. This attribute ties in with
the deployment targets (e.g., -mmacosx-version-min=10.1 specifies that
we want to deploy back to Mac OS X 10.1). There are several concrete
behaviors that this attribute enables, as illustrated with the
function foo() above:
- If we choose a deployment target >= Mac OS X 10.4, uses of "foo"
will result in a deprecation warning, as if we had placed
attribute((deprecated)) on it (but with a better diagnostic)
- If we choose a deployment target >= Mac OS X 10.6, uses of "foo"
will result in an "unavailable" warning (in C)/error (in C++), as
if we had placed attribute((unavailable)) on it
- If we choose a deployment target prior to 10.2, foo() is
weak-imported (if it is a kind of entity that can be weak
imported), as if we had placed the weak_import attribute on it.
Naturally, there can be multiple availability attributes on a
declaration, for different platforms; only the current platform
matters when checking availability attributes.
The only platforms this attribute currently works for are "ios" and
"macosx", since we already have -mxxxx-version-min flags for them and we
have experience there with macro tricks translating down to the
deprecated/unavailable/weak_import attributes. The end goal is to open
this up to other platforms, and even extension to other "platforms"
that are really libraries (say, through a #pragma clang
define_system), but that hasn't yet been designed and we may want to
shake out more issues with this narrower problem first.
Addresses <rdar://problem/6690412>.
As a drive-by bug-fix, if an entity is both deprecated and
unavailable, we only emit the "unavailable" diagnostic.
llvm-svn: 128127
2011-03-23 08:50:03 +08:00
|
|
|
IsDefinition = true;
|
|
|
|
return false;
|
|
|
|
}
|
2012-06-20 14:18:46 +08:00
|
|
|
return true;
|
|
|
|
|
|
|
|
// Functions, if they aren't definitions.
|
Implement a new 'availability' attribute, that allows one to specify
which versions of an OS provide a certain facility. For example,
void foo()
__attribute__((availability(macosx,introduced=10.2,deprecated=10.4,obsoleted=10.6)));
says that the function "foo" was introduced in 10.2, deprecated in
10.4, and completely obsoleted in 10.6. This attribute ties in with
the deployment targets (e.g., -mmacosx-version-min=10.1 specifies that
we want to deploy back to Mac OS X 10.1). There are several concrete
behaviors that this attribute enables, as illustrated with the
function foo() above:
- If we choose a deployment target >= Mac OS X 10.4, uses of "foo"
will result in a deprecation warning, as if we had placed
attribute((deprecated)) on it (but with a better diagnostic)
- If we choose a deployment target >= Mac OS X 10.6, uses of "foo"
will result in an "unavailable" warning (in C)/error (in C++), as
if we had placed attribute((unavailable)) on it
- If we choose a deployment target prior to 10.2, foo() is
weak-imported (if it is a kind of entity that can be weak
imported), as if we had placed the weak_import attribute on it.
Naturally, there can be multiple availability attributes on a
declaration, for different platforms; only the current platform
matters when checking availability attributes.
The only platforms this attribute currently works for are "ios" and
"macosx", since we already have -mxxxx-version-min flags for them and we
have experience there with macro tricks translating down to the
deprecated/unavailable/weak_import attributes. The end goal is to open
this up to other platforms, and even extension to other "platforms"
that are really libraries (say, through a #pragma clang
define_system), but that hasn't yet been designed and we may want to
shake out more issues with this narrower problem first.
Addresses <rdar://problem/6690412>.
As a drive-by bug-fix, if an entity is both deprecated and
unavailable, we only emit the "unavailable" diagnostic.
llvm-svn: 128127
2011-03-23 08:50:03 +08:00
|
|
|
} else if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(this)) {
|
|
|
|
if (FD->hasBody()) {
|
|
|
|
IsDefinition = true;
|
|
|
|
return false;
|
|
|
|
}
|
2012-06-20 14:18:46 +08:00
|
|
|
return true;
|
Implement a new 'availability' attribute, that allows one to specify
which versions of an OS provide a certain facility. For example,
void foo()
__attribute__((availability(macosx,introduced=10.2,deprecated=10.4,obsoleted=10.6)));
says that the function "foo" was introduced in 10.2, deprecated in
10.4, and completely obsoleted in 10.6. This attribute ties in with
the deployment targets (e.g., -mmacosx-version-min=10.1 specifies that
we want to deploy back to Mac OS X 10.1). There are several concrete
behaviors that this attribute enables, as illustrated with the
function foo() above:
- If we choose a deployment target >= Mac OS X 10.4, uses of "foo"
will result in a deprecation warning, as if we had placed
attribute((deprecated)) on it (but with a better diagnostic)
- If we choose a deployment target >= Mac OS X 10.6, uses of "foo"
will result in an "unavailable" warning (in C)/error (in C++), as
if we had placed attribute((unavailable)) on it
- If we choose a deployment target prior to 10.2, foo() is
weak-imported (if it is a kind of entity that can be weak
imported), as if we had placed the weak_import attribute on it.
Naturally, there can be multiple availability attributes on a
declaration, for different platforms; only the current platform
matters when checking availability attributes.
The only platforms this attribute currently works for are "ios" and
"macosx", since we already have -mxxxx-version-min flags for them and we
have experience there with macro tricks translating down to the
deprecated/unavailable/weak_import attributes. The end goal is to open
this up to other platforms, and even extension to other "platforms"
that are really libraries (say, through a #pragma clang
define_system), but that hasn't yet been designed and we may want to
shake out more issues with this narrower problem first.
Addresses <rdar://problem/6690412>.
As a drive-by bug-fix, if an entity is both deprecated and
unavailable, we only emit the "unavailable" diagnostic.
llvm-svn: 128127
2011-03-23 08:50:03 +08:00
|
|
|
|
2012-06-20 14:18:46 +08:00
|
|
|
// Objective-C classes, if this is the non-fragile runtime.
|
|
|
|
} else if (isa<ObjCInterfaceDecl>(this) &&
|
2012-06-21 05:58:02 +08:00
|
|
|
getASTContext().getLangOpts().ObjCRuntime.hasWeakClassImport()) {
|
2012-06-20 14:18:46 +08:00
|
|
|
return true;
|
|
|
|
|
|
|
|
// Nothing else.
|
|
|
|
} else {
|
|
|
|
return false;
|
|
|
|
}
|
Implement a new 'availability' attribute, that allows one to specify
which versions of an OS provide a certain facility. For example,
void foo()
__attribute__((availability(macosx,introduced=10.2,deprecated=10.4,obsoleted=10.6)));
says that the function "foo" was introduced in 10.2, deprecated in
10.4, and completely obsoleted in 10.6. This attribute ties in with
the deployment targets (e.g., -mmacosx-version-min=10.1 specifies that
we want to deploy back to Mac OS X 10.1). There are several concrete
behaviors that this attribute enables, as illustrated with the
function foo() above:
- If we choose a deployment target >= Mac OS X 10.4, uses of "foo"
will result in a deprecation warning, as if we had placed
attribute((deprecated)) on it (but with a better diagnostic)
- If we choose a deployment target >= Mac OS X 10.6, uses of "foo"
will result in an "unavailable" warning (in C)/error (in C++), as
if we had placed attribute((unavailable)) on it
- If we choose a deployment target prior to 10.2, foo() is
weak-imported (if it is a kind of entity that can be weak
imported), as if we had placed the weak_import attribute on it.
Naturally, there can be multiple availability attributes on a
declaration, for different platforms; only the current platform
matters when checking availability attributes.
The only platforms this attribute currently works for are "ios" and
"macosx", since we already have -mxxxx-version-min flags for them and we
have experience there with macro tricks translating down to the
deprecated/unavailable/weak_import attributes. The end goal is to open
this up to other platforms, and even extension to other "platforms"
that are really libraries (say, through a #pragma clang
define_system), but that hasn't yet been designed and we may want to
shake out more issues with this narrower problem first.
Addresses <rdar://problem/6690412>.
As a drive-by bug-fix, if an entity is both deprecated and
unavailable, we only emit the "unavailable" diagnostic.
llvm-svn: 128127
2011-03-23 08:50:03 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
bool Decl::isWeakImported() const {
|
|
|
|
bool IsDefinition;
|
|
|
|
if (!canBeWeakImported(IsDefinition))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
for (attr_iterator A = attr_begin(), AEnd = attr_end(); A != AEnd; ++A) {
|
|
|
|
if (isa<WeakImportAttr>(*A))
|
|
|
|
return true;
|
|
|
|
|
|
|
|
if (AvailabilityAttr *Availability = dyn_cast<AvailabilityAttr>(*A)) {
|
|
|
|
if (CheckAvailability(getASTContext(), Availability, 0)
|
|
|
|
== AR_NotYetIntroduced)
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
2010-02-17 10:17:21 +08:00
|
|
|
|
2009-03-28 04:18:19 +08:00
|
|
|
unsigned Decl::getIdentifierNamespaceForKind(Kind DeclKind) {
|
|
|
|
switch (DeclKind) {
|
2009-11-17 13:59:44 +08:00
|
|
|
case Function:
|
|
|
|
case CXXMethod:
|
|
|
|
case CXXConstructor:
|
|
|
|
case CXXDestructor:
|
|
|
|
case CXXConversion:
|
2009-03-28 04:18:19 +08:00
|
|
|
case EnumConstant:
|
|
|
|
case Var:
|
|
|
|
case ImplicitParam:
|
|
|
|
case ParmVar:
|
|
|
|
case NonTypeTemplateParm:
|
|
|
|
case ObjCMethod:
|
|
|
|
case ObjCProperty:
|
2013-04-16 15:28:30 +08:00
|
|
|
case MSProperty:
|
2010-04-23 21:07:39 +08:00
|
|
|
return IDNS_Ordinary;
|
2011-02-17 15:39:24 +08:00
|
|
|
case Label:
|
|
|
|
return IDNS_Label;
|
2010-11-21 14:08:52 +08:00
|
|
|
case IndirectField:
|
|
|
|
return IDNS_Ordinary | IDNS_Member;
|
|
|
|
|
2010-04-24 02:46:30 +08:00
|
|
|
case ObjCCompatibleAlias:
|
|
|
|
case ObjCInterface:
|
|
|
|
return IDNS_Ordinary | IDNS_Type;
|
|
|
|
|
|
|
|
case Typedef:
|
2011-04-15 22:24:37 +08:00
|
|
|
case TypeAlias:
|
2011-05-06 05:57:07 +08:00
|
|
|
case TypeAliasTemplate:
|
2010-04-24 02:46:30 +08:00
|
|
|
case UnresolvedUsingTypename:
|
|
|
|
case TemplateTypeParm:
|
|
|
|
return IDNS_Ordinary | IDNS_Type;
|
|
|
|
|
2009-11-17 13:59:44 +08:00
|
|
|
case UsingShadow:
|
|
|
|
return 0; // we'll actually overwrite this later
|
|
|
|
|
2009-11-18 10:36:19 +08:00
|
|
|
case UnresolvedUsingValue:
|
|
|
|
return IDNS_Ordinary | IDNS_Using;
|
2009-11-17 13:59:44 +08:00
|
|
|
|
|
|
|
case Using:
|
|
|
|
return IDNS_Using;
|
|
|
|
|
2009-03-28 04:18:19 +08:00
|
|
|
case ObjCProtocol:
|
2009-04-24 08:11:27 +08:00
|
|
|
return IDNS_ObjCProtocol;
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2009-03-28 04:18:19 +08:00
|
|
|
case Field:
|
|
|
|
case ObjCAtDefsField:
|
|
|
|
case ObjCIvar:
|
|
|
|
return IDNS_Member;
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2009-03-28 04:18:19 +08:00
|
|
|
case Record:
|
|
|
|
case CXXRecord:
|
|
|
|
case Enum:
|
2010-04-24 02:46:30 +08:00
|
|
|
return IDNS_Tag | IDNS_Type;
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2009-03-28 04:18:19 +08:00
|
|
|
case Namespace:
|
2010-04-24 02:46:30 +08:00
|
|
|
case NamespaceAlias:
|
|
|
|
return IDNS_Namespace;
|
|
|
|
|
2009-03-28 04:18:19 +08:00
|
|
|
case FunctionTemplate:
|
2010-04-24 02:46:30 +08:00
|
|
|
return IDNS_Ordinary;
|
|
|
|
|
2009-03-28 04:18:19 +08:00
|
|
|
case ClassTemplate:
|
|
|
|
case TemplateTemplateParm:
|
2010-04-24 02:46:30 +08:00
|
|
|
return IDNS_Ordinary | IDNS_Tag | IDNS_Type;
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2009-03-28 04:18:19 +08:00
|
|
|
// Never have names.
|
2009-08-28 15:59:38 +08:00
|
|
|
case Friend:
|
2009-09-17 06:47:08 +08:00
|
|
|
case FriendTemplate:
|
2010-06-05 13:09:32 +08:00
|
|
|
case AccessSpec:
|
2009-03-28 04:18:19 +08:00
|
|
|
case LinkageSpec:
|
|
|
|
case FileScopeAsm:
|
|
|
|
case StaticAssert:
|
|
|
|
case ObjCPropertyImpl:
|
|
|
|
case Block:
|
2013-04-17 03:37:38 +08:00
|
|
|
case Captured:
|
2009-03-28 04:18:19 +08:00
|
|
|
case TranslationUnit:
|
|
|
|
|
|
|
|
case UsingDirective:
|
|
|
|
case ClassTemplateSpecialization:
|
2009-05-31 17:31:02 +08:00
|
|
|
case ClassTemplatePartialSpecialization:
|
2011-08-14 11:52:19 +08:00
|
|
|
case ClassScopeFunctionSpecialization:
|
2010-04-23 07:19:50 +08:00
|
|
|
case ObjCImplementation:
|
|
|
|
case ObjCCategory:
|
|
|
|
case ObjCCategoryImpl:
|
2011-12-03 07:23:56 +08:00
|
|
|
case Import:
|
2013-03-22 14:34:35 +08:00
|
|
|
case OMPThreadPrivate:
|
2013-02-23 01:15:32 +08:00
|
|
|
case Empty:
|
2010-04-23 07:19:50 +08:00
|
|
|
// Never looked up by name.
|
2009-03-28 04:18:19 +08:00
|
|
|
return 0;
|
|
|
|
}
|
2009-11-17 13:59:44 +08:00
|
|
|
|
2012-01-21 05:50:17 +08:00
|
|
|
llvm_unreachable("Invalid DeclKind!");
|
2008-06-08 00:52:53 +08:00
|
|
|
}
|
|
|
|
|
2012-02-09 10:44:08 +08:00
|
|
|
void Decl::setAttrsImpl(const AttrVec &attrs, ASTContext &Ctx) {
|
2010-06-12 07:09:25 +08:00
|
|
|
assert(!HasAttrs && "Decl already contains attrs.");
|
|
|
|
|
2012-02-09 10:44:08 +08:00
|
|
|
AttrVec &AttrBlank = Ctx.getDeclAttrs(this);
|
2010-08-19 07:23:40 +08:00
|
|
|
assert(AttrBlank.empty() && "HasAttrs was wrong?");
|
2010-06-12 07:09:25 +08:00
|
|
|
|
|
|
|
AttrBlank = attrs;
|
|
|
|
HasAttrs = true;
|
|
|
|
}
|
|
|
|
|
2010-08-19 07:23:40 +08:00
|
|
|
void Decl::dropAttrs() {
|
2008-06-08 00:52:53 +08:00
|
|
|
if (!HasAttrs) return;
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2008-06-08 00:52:53 +08:00
|
|
|
HasAttrs = false;
|
2009-06-30 10:34:44 +08:00
|
|
|
getASTContext().eraseDeclAttrs(this);
|
2008-06-08 00:52:53 +08:00
|
|
|
}
|
|
|
|
|
2010-08-19 07:23:40 +08:00
|
|
|
const AttrVec &Decl::getAttrs() const {
|
|
|
|
assert(HasAttrs && "No attrs to get!");
|
2009-06-30 10:34:44 +08:00
|
|
|
return getASTContext().getDeclAttrs(this);
|
2008-06-08 00:52:53 +08:00
|
|
|
}
|
|
|
|
|
2008-10-13 00:14:48 +08:00
|
|
|
Decl *Decl::castFromDeclContext (const DeclContext *D) {
|
2009-02-16 22:29:28 +08:00
|
|
|
Decl::Kind DK = D->getDeclKind();
|
|
|
|
switch(DK) {
|
2010-05-30 15:21:58 +08:00
|
|
|
#define DECL(NAME, BASE)
|
|
|
|
#define DECL_CONTEXT(NAME) \
|
|
|
|
case Decl::NAME: \
|
|
|
|
return static_cast<NAME##Decl*>(const_cast<DeclContext*>(D));
|
|
|
|
#define DECL_CONTEXT_BASE(NAME)
|
|
|
|
#include "clang/AST/DeclNodes.inc"
|
2009-02-16 22:29:28 +08:00
|
|
|
default:
|
2010-05-30 15:21:58 +08:00
|
|
|
#define DECL(NAME, BASE)
|
|
|
|
#define DECL_CONTEXT_BASE(NAME) \
|
|
|
|
if (DK >= first##NAME && DK <= last##NAME) \
|
|
|
|
return static_cast<NAME##Decl*>(const_cast<DeclContext*>(D));
|
|
|
|
#include "clang/AST/DeclNodes.inc"
|
2011-09-23 13:06:16 +08:00
|
|
|
llvm_unreachable("a decl that inherits DeclContext isn't handled");
|
2009-02-16 22:29:28 +08:00
|
|
|
}
|
2008-10-13 00:14:48 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
DeclContext *Decl::castToDeclContext(const Decl *D) {
|
2009-02-16 22:29:28 +08:00
|
|
|
Decl::Kind DK = D->getKind();
|
|
|
|
switch(DK) {
|
2010-05-30 15:21:58 +08:00
|
|
|
#define DECL(NAME, BASE)
|
|
|
|
#define DECL_CONTEXT(NAME) \
|
|
|
|
case Decl::NAME: \
|
|
|
|
return static_cast<NAME##Decl*>(const_cast<Decl*>(D));
|
|
|
|
#define DECL_CONTEXT_BASE(NAME)
|
|
|
|
#include "clang/AST/DeclNodes.inc"
|
2009-02-16 22:29:28 +08:00
|
|
|
default:
|
2010-05-30 15:21:58 +08:00
|
|
|
#define DECL(NAME, BASE)
|
|
|
|
#define DECL_CONTEXT_BASE(NAME) \
|
|
|
|
if (DK >= first##NAME && DK <= last##NAME) \
|
|
|
|
return static_cast<NAME##Decl*>(const_cast<Decl*>(D));
|
|
|
|
#include "clang/AST/DeclNodes.inc"
|
2011-09-23 13:06:16 +08:00
|
|
|
llvm_unreachable("a decl that inherits DeclContext isn't handled");
|
2009-02-16 22:29:28 +08:00
|
|
|
}
|
2008-10-13 00:14:48 +08:00
|
|
|
}
|
|
|
|
|
2009-06-30 10:35:26 +08:00
|
|
|
SourceLocation Decl::getBodyRBrace() const {
|
2010-07-07 19:31:19 +08:00
|
|
|
// Special handling of FunctionDecl to avoid de-serializing the body from PCH.
|
|
|
|
// FunctionDecl stores EndRangeLoc for this purpose.
|
|
|
|
if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(this)) {
|
|
|
|
const FunctionDecl *Definition;
|
|
|
|
if (FD->hasBody(Definition))
|
|
|
|
return Definition->getSourceRange().getEnd();
|
|
|
|
return SourceLocation();
|
|
|
|
}
|
|
|
|
|
2010-07-07 19:31:27 +08:00
|
|
|
if (Stmt *Body = getBody())
|
|
|
|
return Body->getSourceRange().getEnd();
|
|
|
|
|
|
|
|
return SourceLocation();
|
2009-04-27 04:35:05 +08:00
|
|
|
}
|
|
|
|
|
2009-03-26 07:38:06 +08:00
|
|
|
void Decl::CheckAccessDeclContext() const {
|
2010-12-02 08:22:25 +08:00
|
|
|
#ifndef NDEBUG
|
2010-01-21 05:53:11 +08:00
|
|
|
// Suppress this check if any of the following hold:
|
|
|
|
// 1. this is the translation unit (and thus has no parent)
|
|
|
|
// 2. this is a template parameter (and thus doesn't belong to its context)
|
2010-09-09 05:58:42 +08:00
|
|
|
// 3. this is a non-type template parameter
|
|
|
|
// 4. the context is not a record
|
|
|
|
// 5. it's invalid
|
|
|
|
// 6. it's a C++0x static_assert.
|
2009-08-30 04:47:47 +08:00
|
|
|
if (isa<TranslationUnitDecl>(this) ||
|
2010-07-02 19:55:44 +08:00
|
|
|
isa<TemplateTypeParmDecl>(this) ||
|
2010-09-09 05:58:42 +08:00
|
|
|
isa<NonTypeTemplateParmDecl>(this) ||
|
2010-02-23 01:53:38 +08:00
|
|
|
!isa<CXXRecordDecl>(getDeclContext()) ||
|
2010-09-09 05:32:35 +08:00
|
|
|
isInvalidDecl() ||
|
|
|
|
isa<StaticAssertDecl>(this) ||
|
|
|
|
// FIXME: a ParmVarDecl can have ClassTemplateSpecialization
|
|
|
|
// as DeclContext (?).
|
2010-09-09 05:58:42 +08:00
|
|
|
isa<ParmVarDecl>(this) ||
|
|
|
|
// FIXME: a ClassTemplateSpecialization or CXXRecordDecl can have
|
|
|
|
// AS_none as access specifier.
|
2011-08-17 09:06:54 +08:00
|
|
|
isa<CXXRecordDecl>(this) ||
|
|
|
|
isa<ClassScopeFunctionSpecializationDecl>(this))
|
2009-08-30 04:47:47 +08:00
|
|
|
return;
|
2009-09-09 23:08:12 +08:00
|
|
|
|
|
|
|
assert(Access != AS_none &&
|
2009-03-26 07:38:06 +08:00
|
|
|
"Access specifier is AS_none inside a record decl");
|
2010-12-02 08:22:25 +08:00
|
|
|
#endif
|
2009-03-26 07:38:06 +08:00
|
|
|
}
|
|
|
|
|
2013-05-03 15:33:41 +08:00
|
|
|
static Decl::Kind getKind(const Decl *D) { return D->getKind(); }
|
|
|
|
static Decl::Kind getKind(const DeclContext *DC) { return DC->getDeclKind(); }
|
|
|
|
|
|
|
|
/// Starting at a given context (a Decl or DeclContext), look for a
|
|
|
|
/// code context that is not a closure (a lambda, block, etc.).
|
|
|
|
template <class T> static Decl *getNonClosureContext(T *D) {
|
|
|
|
if (getKind(D) == Decl::CXXMethod) {
|
|
|
|
CXXMethodDecl *MD = cast<CXXMethodDecl>(D);
|
2013-05-04 01:11:14 +08:00
|
|
|
if (MD->getOverloadedOperator() == OO_Call &&
|
|
|
|
MD->getParent()->isLambda())
|
2013-05-03 15:33:41 +08:00
|
|
|
return getNonClosureContext(MD->getParent()->getParent());
|
|
|
|
return MD;
|
|
|
|
} else if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
|
|
|
|
return FD;
|
|
|
|
} else if (ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(D)) {
|
|
|
|
return MD;
|
|
|
|
} else if (BlockDecl *BD = dyn_cast<BlockDecl>(D)) {
|
|
|
|
return getNonClosureContext(BD->getParent());
|
|
|
|
} else if (CapturedDecl *CD = dyn_cast<CapturedDecl>(D)) {
|
|
|
|
return getNonClosureContext(CD->getParent());
|
|
|
|
} else {
|
|
|
|
return 0;
|
|
|
|
}
|
2011-11-06 17:01:30 +08:00
|
|
|
}
|
|
|
|
|
2013-05-03 15:33:41 +08:00
|
|
|
Decl *Decl::getNonClosureContext() {
|
|
|
|
return ::getNonClosureContext(this);
|
|
|
|
}
|
2011-02-23 06:25:23 +08:00
|
|
|
|
2013-05-03 15:33:41 +08:00
|
|
|
Decl *DeclContext::getNonClosureAncestor() {
|
|
|
|
return ::getNonClosureContext(this);
|
2011-02-23 06:25:23 +08:00
|
|
|
}
|
2009-03-26 07:38:06 +08:00
|
|
|
|
2008-06-08 00:52:53 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// DeclContext Implementation
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2009-02-16 22:29:28 +08:00
|
|
|
bool DeclContext::classof(const Decl *D) {
|
|
|
|
switch (D->getKind()) {
|
2010-05-30 15:21:58 +08:00
|
|
|
#define DECL(NAME, BASE)
|
|
|
|
#define DECL_CONTEXT(NAME) case Decl::NAME:
|
|
|
|
#define DECL_CONTEXT_BASE(NAME)
|
|
|
|
#include "clang/AST/DeclNodes.inc"
|
2009-02-16 22:29:28 +08:00
|
|
|
return true;
|
|
|
|
default:
|
2010-05-30 15:21:58 +08:00
|
|
|
#define DECL(NAME, BASE)
|
|
|
|
#define DECL_CONTEXT_BASE(NAME) \
|
|
|
|
if (D->getKind() >= Decl::first##NAME && \
|
|
|
|
D->getKind() <= Decl::last##NAME) \
|
2009-02-16 22:29:28 +08:00
|
|
|
return true;
|
2010-05-30 15:21:58 +08:00
|
|
|
#include "clang/AST/DeclNodes.inc"
|
2009-02-16 22:29:28 +08:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-07-26 02:38:02 +08:00
|
|
|
DeclContext::~DeclContext() { }
|
2008-12-12 00:49:14 +08:00
|
|
|
|
2009-09-11 00:57:35 +08:00
|
|
|
/// \brief Find the parent context of this context that will be
|
|
|
|
/// used for unqualified name lookup.
|
|
|
|
///
|
|
|
|
/// Generally, the parent lookup context is the semantic context. However, for
|
|
|
|
/// a friend function the parent lookup context is the lexical context, which
|
|
|
|
/// is the class in which the friend is declared.
|
|
|
|
DeclContext *DeclContext::getLookupParent() {
|
|
|
|
// FIXME: Find a better way to identify friends
|
|
|
|
if (isa<FunctionDecl>(this))
|
2010-08-31 08:36:30 +08:00
|
|
|
if (getParent()->getRedeclContext()->isFileContext() &&
|
|
|
|
getLexicalParent()->getRedeclContext()->isRecord())
|
2009-09-11 00:57:35 +08:00
|
|
|
return getLexicalParent();
|
|
|
|
|
|
|
|
return getParent();
|
|
|
|
}
|
|
|
|
|
2010-09-01 04:53:31 +08:00
|
|
|
bool DeclContext::isInlineNamespace() const {
|
|
|
|
return isNamespace() &&
|
|
|
|
cast<NamespaceDecl>(this)->isInline();
|
|
|
|
}
|
|
|
|
|
2009-05-29 00:34:51 +08:00
|
|
|
bool DeclContext::isDependentContext() const {
|
|
|
|
if (isFileContext())
|
|
|
|
return false;
|
2009-05-31 17:31:02 +08:00
|
|
|
|
|
|
|
if (isa<ClassTemplatePartialSpecializationDecl>(this))
|
|
|
|
return true;
|
2009-05-29 00:34:51 +08:00
|
|
|
|
2012-02-22 03:11:17 +08:00
|
|
|
if (const CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(this)) {
|
2009-05-29 00:34:51 +08:00
|
|
|
if (Record->getDescribedClassTemplate())
|
|
|
|
return true;
|
2012-02-22 03:11:17 +08:00
|
|
|
|
|
|
|
if (Record->isDependentLambda())
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2010-03-24 13:22:00 +08:00
|
|
|
if (const FunctionDecl *Function = dyn_cast<FunctionDecl>(this)) {
|
2009-05-29 00:34:51 +08:00
|
|
|
if (Function->getDescribedFunctionTemplate())
|
|
|
|
return true;
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2010-03-24 13:22:00 +08:00
|
|
|
// Friend function declarations are dependent if their *lexical*
|
|
|
|
// context is dependent.
|
|
|
|
if (cast<Decl>(this)->getFriendObjectKind())
|
|
|
|
return getLexicalParent()->isDependentContext();
|
|
|
|
}
|
|
|
|
|
2009-05-29 00:34:51 +08:00
|
|
|
return getParent() && getParent()->isDependentContext();
|
|
|
|
}
|
|
|
|
|
2009-01-06 03:45:36 +08:00
|
|
|
bool DeclContext::isTransparentContext() const {
|
|
|
|
if (DeclKind == Decl::Enum)
|
2010-10-09 07:50:27 +08:00
|
|
|
return !cast<EnumDecl>(this)->isScoped();
|
2009-01-06 03:45:36 +08:00
|
|
|
else if (DeclKind == Decl::LinkageSpec)
|
|
|
|
return true;
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2010-08-31 08:36:30 +08:00
|
|
|
bool DeclContext::Encloses(const DeclContext *DC) const {
|
2009-08-27 14:03:53 +08:00
|
|
|
if (getPrimaryContext() != this)
|
|
|
|
return getPrimaryContext()->Encloses(DC);
|
2009-09-09 23:08:12 +08:00
|
|
|
|
2009-08-27 14:03:53 +08:00
|
|
|
for (; DC; DC = DC->getParent())
|
|
|
|
if (DC->getPrimaryContext() == this)
|
|
|
|
return true;
|
2009-09-09 23:08:12 +08:00
|
|
|
return false;
|
2009-08-27 14:03:53 +08:00
|
|
|
}
|
|
|
|
|
2009-01-09 01:28:14 +08:00
|
|
|
DeclContext *DeclContext::getPrimaryContext() {
|
2008-12-12 00:49:14 +08:00
|
|
|
switch (DeclKind) {
|
|
|
|
case Decl::TranslationUnit:
|
2009-01-06 03:45:36 +08:00
|
|
|
case Decl::LinkageSpec:
|
2009-09-09 23:08:12 +08:00
|
|
|
case Decl::Block:
|
2013-04-17 03:37:38 +08:00
|
|
|
case Decl::Captured:
|
2008-12-12 00:49:14 +08:00
|
|
|
// There is only one DeclContext for these entities.
|
|
|
|
return this;
|
|
|
|
|
|
|
|
case Decl::Namespace:
|
|
|
|
// The original namespace is our primary context.
|
|
|
|
return static_cast<NamespaceDecl*>(this)->getOriginalNamespace();
|
|
|
|
|
|
|
|
case Decl::ObjCMethod:
|
|
|
|
return this;
|
|
|
|
|
|
|
|
case Decl::ObjCInterface:
|
2011-12-16 02:03:09 +08:00
|
|
|
if (ObjCInterfaceDecl *Def = cast<ObjCInterfaceDecl>(this)->getDefinition())
|
|
|
|
return Def;
|
|
|
|
|
|
|
|
return this;
|
|
|
|
|
2009-01-09 01:28:14 +08:00
|
|
|
case Decl::ObjCProtocol:
|
2012-01-02 03:51:50 +08:00
|
|
|
if (ObjCProtocolDecl *Def = cast<ObjCProtocolDecl>(this)->getDefinition())
|
|
|
|
return Def;
|
|
|
|
|
|
|
|
return this;
|
2011-12-16 02:03:09 +08:00
|
|
|
|
2009-01-09 01:28:14 +08:00
|
|
|
case Decl::ObjCCategory:
|
2008-12-12 00:49:14 +08:00
|
|
|
return this;
|
|
|
|
|
2009-01-09 01:28:14 +08:00
|
|
|
case Decl::ObjCImplementation:
|
|
|
|
case Decl::ObjCCategoryImpl:
|
|
|
|
return this;
|
|
|
|
|
2008-12-12 00:49:14 +08:00
|
|
|
default:
|
2010-05-30 15:21:58 +08:00
|
|
|
if (DeclKind >= Decl::firstTag && DeclKind <= Decl::lastTag) {
|
2009-02-18 07:15:12 +08:00
|
|
|
// If this is a tag type that has a definition or is currently
|
|
|
|
// being defined, that definition is our primary context.
|
2010-03-10 11:28:59 +08:00
|
|
|
TagDecl *Tag = cast<TagDecl>(this);
|
|
|
|
assert(isa<TagType>(Tag->TypeForDecl) ||
|
|
|
|
isa<InjectedClassNameType>(Tag->TypeForDecl));
|
|
|
|
|
|
|
|
if (TagDecl *Def = Tag->getDefinition())
|
|
|
|
return Def;
|
|
|
|
|
|
|
|
if (!isa<InjectedClassNameType>(Tag->TypeForDecl)) {
|
|
|
|
const TagType *TagTy = cast<TagType>(Tag->TypeForDecl);
|
|
|
|
if (TagTy->isBeingDefined())
|
|
|
|
// FIXME: is it necessarily being defined in the decl
|
|
|
|
// that owns the type?
|
|
|
|
return TagTy->getDecl();
|
|
|
|
}
|
|
|
|
|
|
|
|
return Tag;
|
2009-02-18 07:15:12 +08:00
|
|
|
}
|
|
|
|
|
2010-05-30 15:21:58 +08:00
|
|
|
assert(DeclKind >= Decl::firstFunction && DeclKind <= Decl::lastFunction &&
|
2008-12-12 00:49:14 +08:00
|
|
|
"Unknown DeclContext kind");
|
|
|
|
return this;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-01-07 17:11:48 +08:00
|
|
|
void
|
2013-01-13 03:30:44 +08:00
|
|
|
DeclContext::collectAllContexts(SmallVectorImpl<DeclContext *> &Contexts){
|
2012-01-07 17:11:48 +08:00
|
|
|
Contexts.clear();
|
|
|
|
|
|
|
|
if (DeclKind != Decl::Namespace) {
|
|
|
|
Contexts.push_back(this);
|
|
|
|
return;
|
2008-12-12 00:49:14 +08:00
|
|
|
}
|
2012-01-07 17:11:48 +08:00
|
|
|
|
|
|
|
NamespaceDecl *Self = static_cast<NamespaceDecl *>(this);
|
2012-01-15 00:38:05 +08:00
|
|
|
for (NamespaceDecl *N = Self->getMostRecentDecl(); N;
|
|
|
|
N = N->getPreviousDecl())
|
2012-01-07 17:11:48 +08:00
|
|
|
Contexts.push_back(N);
|
|
|
|
|
|
|
|
std::reverse(Contexts.begin(), Contexts.end());
|
2008-12-12 00:49:14 +08:00
|
|
|
}
|
|
|
|
|
2010-10-15 04:14:34 +08:00
|
|
|
std::pair<Decl *, Decl *>
|
2012-02-22 17:51:33 +08:00
|
|
|
DeclContext::BuildDeclChain(ArrayRef<Decl*> Decls,
|
2011-10-08 05:55:43 +08:00
|
|
|
bool FieldsAlreadyLoaded) {
|
2012-01-07 00:59:53 +08:00
|
|
|
// Build up a chain of declarations via the Decl::NextInContextAndBits field.
|
2010-10-15 04:14:34 +08:00
|
|
|
Decl *FirstNewDecl = 0;
|
|
|
|
Decl *PrevDecl = 0;
|
|
|
|
for (unsigned I = 0, N = Decls.size(); I != N; ++I) {
|
2011-10-08 05:55:43 +08:00
|
|
|
if (FieldsAlreadyLoaded && isa<FieldDecl>(Decls[I]))
|
|
|
|
continue;
|
|
|
|
|
2010-10-15 04:14:34 +08:00
|
|
|
Decl *D = Decls[I];
|
|
|
|
if (PrevDecl)
|
2012-01-07 00:59:53 +08:00
|
|
|
PrevDecl->NextInContextAndBits.setPointer(D);
|
2010-10-15 04:14:34 +08:00
|
|
|
else
|
|
|
|
FirstNewDecl = D;
|
|
|
|
|
|
|
|
PrevDecl = D;
|
|
|
|
}
|
|
|
|
|
|
|
|
return std::make_pair(FirstNewDecl, PrevDecl);
|
|
|
|
}
|
|
|
|
|
2013-02-07 11:37:08 +08:00
|
|
|
/// \brief We have just acquired external visible storage, and we already have
|
|
|
|
/// built a lookup map. For every name in the map, pull in the new names from
|
|
|
|
/// the external storage.
|
|
|
|
void DeclContext::reconcileExternalVisibleStorage() {
|
2013-02-12 06:02:16 +08:00
|
|
|
assert(NeedToReconcileExternalVisibleStorage && LookupPtr.getPointer());
|
2013-02-07 11:37:08 +08:00
|
|
|
NeedToReconcileExternalVisibleStorage = false;
|
|
|
|
|
|
|
|
StoredDeclsMap &Map = *LookupPtr.getPointer();
|
|
|
|
ExternalASTSource *Source = getParentASTContext().getExternalSource();
|
|
|
|
for (StoredDeclsMap::iterator I = Map.begin(); I != Map.end(); ++I) {
|
|
|
|
I->second.removeExternalDecls();
|
|
|
|
Source->FindExternalVisibleDeclsByName(this, I->first);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-04-10 06:27:44 +08:00
|
|
|
/// \brief Load the declarations within this lexical storage from an
|
|
|
|
/// external source.
|
2009-09-09 23:08:12 +08:00
|
|
|
void
|
2009-06-30 10:36:12 +08:00
|
|
|
DeclContext::LoadLexicalDeclsFromExternalStorage() const {
|
|
|
|
ExternalASTSource *Source = getParentASTContext().getExternalSource();
|
2009-04-10 06:27:44 +08:00
|
|
|
assert(hasExternalLexicalStorage() && Source && "No external storage?");
|
|
|
|
|
2010-07-30 18:03:23 +08:00
|
|
|
// Notify that we have a DeclContext that is initializing.
|
|
|
|
ExternalASTSource::Deserializing ADeclContext(Source);
|
2011-08-27 05:23:06 +08:00
|
|
|
|
2011-07-16 05:46:17 +08:00
|
|
|
// Load the external declarations, if any.
|
2011-07-23 18:55:15 +08:00
|
|
|
SmallVector<Decl*, 64> Decls;
|
2009-04-10 06:27:44 +08:00
|
|
|
ExternalLexicalStorage = false;
|
2011-07-16 05:46:17 +08:00
|
|
|
switch (Source->FindExternalLexicalDecls(this, Decls)) {
|
|
|
|
case ELR_Success:
|
|
|
|
break;
|
|
|
|
|
|
|
|
case ELR_Failure:
|
|
|
|
case ELR_AlreadyLoaded:
|
|
|
|
return;
|
|
|
|
}
|
2009-04-10 06:27:44 +08:00
|
|
|
|
|
|
|
if (Decls.empty())
|
|
|
|
return;
|
|
|
|
|
2011-10-08 05:55:43 +08:00
|
|
|
// We may have already loaded just the fields of this record, in which case
|
|
|
|
// we need to ignore them.
|
|
|
|
bool FieldsAlreadyLoaded = false;
|
|
|
|
if (const RecordDecl *RD = dyn_cast<RecordDecl>(this))
|
|
|
|
FieldsAlreadyLoaded = RD->LoadedFieldsFromExternalStorage;
|
|
|
|
|
2009-04-10 06:27:44 +08:00
|
|
|
// Splice the newly-read declarations into the beginning of the list
|
|
|
|
// of declarations.
|
2010-10-15 04:14:34 +08:00
|
|
|
Decl *ExternalFirst, *ExternalLast;
|
2011-10-08 05:55:43 +08:00
|
|
|
llvm::tie(ExternalFirst, ExternalLast) = BuildDeclChain(Decls,
|
|
|
|
FieldsAlreadyLoaded);
|
2012-01-07 00:59:53 +08:00
|
|
|
ExternalLast->NextInContextAndBits.setPointer(FirstDecl);
|
2010-10-15 04:14:34 +08:00
|
|
|
FirstDecl = ExternalFirst;
|
2009-04-10 06:27:44 +08:00
|
|
|
if (!LastDecl)
|
2010-10-15 04:14:34 +08:00
|
|
|
LastDecl = ExternalLast;
|
2009-04-10 06:27:44 +08:00
|
|
|
}
|
|
|
|
|
2010-06-01 17:23:16 +08:00
|
|
|
DeclContext::lookup_result
|
|
|
|
ExternalASTSource::SetNoExternalVisibleDeclsForName(const DeclContext *DC,
|
|
|
|
DeclarationName Name) {
|
|
|
|
ASTContext &Context = DC->getParentASTContext();
|
|
|
|
StoredDeclsMap *Map;
|
2012-03-16 14:12:59 +08:00
|
|
|
if (!(Map = DC->LookupPtr.getPointer()))
|
2010-06-01 17:23:16 +08:00
|
|
|
Map = DC->CreateStoredDeclsMap(Context);
|
|
|
|
|
2013-02-07 11:37:08 +08:00
|
|
|
// Add an entry to the map for this name, if it's not already present.
|
|
|
|
(*Map)[Name];
|
2010-06-01 17:23:16 +08:00
|
|
|
|
|
|
|
return DeclContext::lookup_result();
|
|
|
|
}
|
2009-04-10 06:27:44 +08:00
|
|
|
|
2010-06-01 17:23:16 +08:00
|
|
|
DeclContext::lookup_result
|
|
|
|
ExternalASTSource::SetExternalVisibleDeclsForName(const DeclContext *DC,
|
|
|
|
DeclarationName Name,
|
2011-09-09 14:44:14 +08:00
|
|
|
ArrayRef<NamedDecl*> Decls) {
|
2012-09-11 05:20:09 +08:00
|
|
|
ASTContext &Context = DC->getParentASTContext();
|
2010-06-01 17:23:16 +08:00
|
|
|
StoredDeclsMap *Map;
|
2012-03-16 14:12:59 +08:00
|
|
|
if (!(Map = DC->LookupPtr.getPointer()))
|
2010-06-01 17:23:16 +08:00
|
|
|
Map = DC->CreateStoredDeclsMap(Context);
|
2009-04-10 06:27:44 +08:00
|
|
|
|
2010-06-01 17:23:16 +08:00
|
|
|
StoredDeclsList &List = (*Map)[Name];
|
2013-06-24 09:46:41 +08:00
|
|
|
|
|
|
|
// Clear out any old external visible declarations, to avoid quadratic
|
|
|
|
// performance in the redeclaration checks below.
|
|
|
|
List.removeExternalDecls();
|
|
|
|
|
|
|
|
if (!List.isNull()) {
|
|
|
|
// We have both existing declarations and new declarations for this name.
|
|
|
|
// Some of the declarations may simply replace existing ones. Handle those
|
|
|
|
// first.
|
|
|
|
llvm::SmallVector<unsigned, 8> Skip;
|
|
|
|
for (unsigned I = 0, N = Decls.size(); I != N; ++I)
|
|
|
|
if (List.HandleRedeclaration(Decls[I]))
|
|
|
|
Skip.push_back(I);
|
|
|
|
Skip.push_back(Decls.size());
|
|
|
|
|
|
|
|
// Add in any new declarations.
|
|
|
|
unsigned SkipPos = 0;
|
|
|
|
for (unsigned I = 0, N = Decls.size(); I != N; ++I) {
|
|
|
|
if (I == Skip[SkipPos])
|
|
|
|
++SkipPos;
|
|
|
|
else
|
|
|
|
List.AddSubsequentDecl(Decls[I]);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
// Convert the array to a StoredDeclsList.
|
|
|
|
for (ArrayRef<NamedDecl*>::iterator
|
|
|
|
I = Decls.begin(), E = Decls.end(); I != E; ++I) {
|
|
|
|
if (List.isNull())
|
|
|
|
List.setOnlyValue(*I);
|
|
|
|
else
|
|
|
|
List.AddSubsequentDecl(*I);
|
|
|
|
}
|
2010-06-01 17:23:16 +08:00
|
|
|
}
|
|
|
|
|
2010-08-21 00:04:35 +08:00
|
|
|
return List.getLookupResult();
|
2010-06-01 17:23:16 +08:00
|
|
|
}
|
|
|
|
|
2010-07-27 08:17:23 +08:00
|
|
|
DeclContext::decl_iterator DeclContext::noload_decls_begin() const {
|
|
|
|
return decl_iterator(FirstDecl);
|
|
|
|
}
|
|
|
|
|
2009-06-30 10:36:12 +08:00
|
|
|
DeclContext::decl_iterator DeclContext::decls_begin() const {
|
2009-04-10 06:27:44 +08:00
|
|
|
if (hasExternalLexicalStorage())
|
2009-06-30 10:36:12 +08:00
|
|
|
LoadLexicalDeclsFromExternalStorage();
|
2009-04-10 06:27:44 +08:00
|
|
|
|
2009-09-09 23:08:12 +08:00
|
|
|
return decl_iterator(FirstDecl);
|
2009-04-10 05:40:53 +08:00
|
|
|
}
|
|
|
|
|
2009-06-30 10:36:12 +08:00
|
|
|
bool DeclContext::decls_empty() const {
|
2009-04-11 01:25:41 +08:00
|
|
|
if (hasExternalLexicalStorage())
|
2009-06-30 10:36:12 +08:00
|
|
|
LoadLexicalDeclsFromExternalStorage();
|
2009-04-11 01:25:41 +08:00
|
|
|
|
|
|
|
return !FirstDecl;
|
|
|
|
}
|
|
|
|
|
2013-05-04 10:04:27 +08:00
|
|
|
bool DeclContext::containsDecl(Decl *D) const {
|
|
|
|
return (D->getLexicalDeclContext() == this &&
|
|
|
|
(D->NextInContextAndBits.getPointer() || D == LastDecl));
|
|
|
|
}
|
|
|
|
|
2009-12-10 17:41:52 +08:00
|
|
|
void DeclContext::removeDecl(Decl *D) {
|
|
|
|
assert(D->getLexicalDeclContext() == this &&
|
|
|
|
"decl being removed from non-lexical context");
|
2012-01-07 00:59:53 +08:00
|
|
|
assert((D->NextInContextAndBits.getPointer() || D == LastDecl) &&
|
2009-12-10 17:41:52 +08:00
|
|
|
"decl is not in decls list");
|
|
|
|
|
|
|
|
// Remove D from the decl chain. This is O(n) but hopefully rare.
|
|
|
|
if (D == FirstDecl) {
|
|
|
|
if (D == LastDecl)
|
|
|
|
FirstDecl = LastDecl = 0;
|
|
|
|
else
|
2012-01-07 00:59:53 +08:00
|
|
|
FirstDecl = D->NextInContextAndBits.getPointer();
|
2009-12-10 17:41:52 +08:00
|
|
|
} else {
|
2012-01-07 00:59:53 +08:00
|
|
|
for (Decl *I = FirstDecl; true; I = I->NextInContextAndBits.getPointer()) {
|
2009-12-10 17:41:52 +08:00
|
|
|
assert(I && "decl not found in linked list");
|
2012-01-07 00:59:53 +08:00
|
|
|
if (I->NextInContextAndBits.getPointer() == D) {
|
|
|
|
I->NextInContextAndBits.setPointer(D->NextInContextAndBits.getPointer());
|
2009-12-10 17:41:52 +08:00
|
|
|
if (D == LastDecl) LastDecl = I;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Mark that D is no longer in the decl chain.
|
2012-01-07 00:59:53 +08:00
|
|
|
D->NextInContextAndBits.setPointer(0);
|
2009-12-10 17:41:52 +08:00
|
|
|
|
|
|
|
// Remove D from the lookup table if necessary.
|
|
|
|
if (isa<NamedDecl>(D)) {
|
|
|
|
NamedDecl *ND = cast<NamedDecl>(D);
|
|
|
|
|
2011-08-26 22:06:12 +08:00
|
|
|
// Remove only decls that have a name
|
|
|
|
if (!ND->getDeclName()) return;
|
|
|
|
|
2012-03-16 14:12:59 +08:00
|
|
|
StoredDeclsMap *Map = getPrimaryContext()->LookupPtr.getPointer();
|
2010-03-24 13:22:00 +08:00
|
|
|
if (!Map) return;
|
2009-12-10 17:41:52 +08:00
|
|
|
|
|
|
|
StoredDeclsMap::iterator Pos = Map->find(ND->getDeclName());
|
|
|
|
assert(Pos != Map->end() && "no lookup entry for decl");
|
2011-11-09 02:21:06 +08:00
|
|
|
if (Pos->second.getAsVector() || Pos->second.getAsDecl() == ND)
|
|
|
|
Pos->second.remove(ND);
|
2009-12-10 17:41:52 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-08-11 14:59:38 +08:00
|
|
|
void DeclContext::addHiddenDecl(Decl *D) {
|
2009-02-20 08:56:18 +08:00
|
|
|
assert(D->getLexicalDeclContext() == this &&
|
|
|
|
"Decl inserted into wrong lexical context");
|
2009-09-09 23:08:12 +08:00
|
|
|
assert(!D->getNextDeclInContext() && D != LastDecl &&
|
2009-01-10 03:42:16 +08:00
|
|
|
"Decl already inserted into a DeclContext");
|
|
|
|
|
|
|
|
if (FirstDecl) {
|
2012-01-07 00:59:53 +08:00
|
|
|
LastDecl->NextInContextAndBits.setPointer(D);
|
2009-01-10 03:42:16 +08:00
|
|
|
LastDecl = D;
|
|
|
|
} else {
|
|
|
|
FirstDecl = LastDecl = D;
|
|
|
|
}
|
2010-09-28 06:06:20 +08:00
|
|
|
|
|
|
|
// Notify a C++ record declaration that we've added a member, so it can
|
|
|
|
// update it's class-specific state.
|
|
|
|
if (CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(this))
|
|
|
|
Record->addedMember(D);
|
2011-12-03 08:30:27 +08:00
|
|
|
|
|
|
|
// If this is a newly-created (not de-serialized) import declaration, wire
|
|
|
|
// it in to the list of local import declarations.
|
|
|
|
if (!D->isFromASTFile()) {
|
|
|
|
if (ImportDecl *Import = dyn_cast<ImportDecl>(D))
|
|
|
|
D->getASTContext().addedLocalImportDecl(Import);
|
|
|
|
}
|
2009-08-11 14:59:38 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
void DeclContext::addDecl(Decl *D) {
|
|
|
|
addHiddenDecl(D);
|
2009-01-20 09:17:11 +08:00
|
|
|
|
|
|
|
if (NamedDecl *ND = dyn_cast<NamedDecl>(D))
|
2012-03-16 14:12:59 +08:00
|
|
|
ND->getDeclContext()->getPrimaryContext()->
|
|
|
|
makeDeclVisibleInContextWithFlags(ND, false, true);
|
2008-12-12 00:49:14 +08:00
|
|
|
}
|
|
|
|
|
2011-10-21 10:57:43 +08:00
|
|
|
void DeclContext::addDeclInternal(Decl *D) {
|
|
|
|
addHiddenDecl(D);
|
|
|
|
|
|
|
|
if (NamedDecl *ND = dyn_cast<NamedDecl>(D))
|
2012-03-16 14:12:59 +08:00
|
|
|
ND->getDeclContext()->getPrimaryContext()->
|
|
|
|
makeDeclVisibleInContextWithFlags(ND, true, true);
|
|
|
|
}
|
|
|
|
|
|
|
|
/// shouldBeHidden - Determine whether a declaration which was declared
|
|
|
|
/// within its semantic context should be invisible to qualified name lookup.
|
|
|
|
static bool shouldBeHidden(NamedDecl *D) {
|
|
|
|
// Skip unnamed declarations.
|
|
|
|
if (!D->getDeclName())
|
|
|
|
return true;
|
|
|
|
|
|
|
|
// Skip entities that can't be found by name lookup into a particular
|
|
|
|
// context.
|
|
|
|
if ((D->getIdentifierNamespace() == 0 && !isa<UsingDirectiveDecl>(D)) ||
|
|
|
|
D->isTemplateParameter())
|
|
|
|
return true;
|
|
|
|
|
|
|
|
// Skip template specializations.
|
|
|
|
// FIXME: This feels like a hack. Should DeclarationName support
|
|
|
|
// template-ids, or is there a better way to keep specializations
|
|
|
|
// from being visible?
|
|
|
|
if (isa<ClassTemplateSpecializationDecl>(D))
|
|
|
|
return true;
|
|
|
|
if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D))
|
|
|
|
if (FD->isFunctionTemplateSpecialization())
|
|
|
|
return true;
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// buildLookup - Build the lookup data structure with all of the
|
|
|
|
/// declarations in this DeclContext (and any other contexts linked
|
|
|
|
/// to it or transparent contexts nested within it) and return it.
|
|
|
|
StoredDeclsMap *DeclContext::buildLookup() {
|
|
|
|
assert(this == getPrimaryContext() && "buildLookup called on non-primary DC");
|
|
|
|
|
2013-02-12 06:02:16 +08:00
|
|
|
// FIXME: Should we keep going if hasExternalVisibleStorage?
|
2012-03-16 14:12:59 +08:00
|
|
|
if (!LookupPtr.getInt())
|
|
|
|
return LookupPtr.getPointer();
|
|
|
|
|
2013-01-13 03:30:44 +08:00
|
|
|
SmallVector<DeclContext *, 2> Contexts;
|
2012-03-16 14:12:59 +08:00
|
|
|
collectAllContexts(Contexts);
|
|
|
|
for (unsigned I = 0, N = Contexts.size(); I != N; ++I)
|
|
|
|
buildLookupImpl(Contexts[I]);
|
|
|
|
|
|
|
|
// We no longer have any lazy decls.
|
|
|
|
LookupPtr.setInt(false);
|
2013-02-12 06:02:16 +08:00
|
|
|
NeedToReconcileExternalVisibleStorage = false;
|
2012-03-16 14:12:59 +08:00
|
|
|
return LookupPtr.getPointer();
|
|
|
|
}
|
|
|
|
|
|
|
|
/// buildLookupImpl - Build part of the lookup data structure for the
|
|
|
|
/// declarations contained within DCtx, which will either be this
|
|
|
|
/// DeclContext, a DeclContext linked to it, or a transparent context
|
|
|
|
/// nested within it.
|
|
|
|
void DeclContext::buildLookupImpl(DeclContext *DCtx) {
|
|
|
|
for (decl_iterator I = DCtx->decls_begin(), E = DCtx->decls_end();
|
|
|
|
I != E; ++I) {
|
|
|
|
Decl *D = *I;
|
|
|
|
|
|
|
|
// Insert this declaration into the lookup structure, but only if
|
|
|
|
// it's semantically within its decl context. Any other decls which
|
|
|
|
// should be found in this context are added eagerly.
|
2013-06-24 15:20:36 +08:00
|
|
|
//
|
|
|
|
// If it's from an AST file, don't add it now. It'll get handled by
|
|
|
|
// FindExternalVisibleDeclsByName if needed. Exception: if we're not
|
|
|
|
// in C++, we do not track external visible decls for the TU, so in
|
|
|
|
// that case we need to collect them all here.
|
2012-03-16 14:12:59 +08:00
|
|
|
if (NamedDecl *ND = dyn_cast<NamedDecl>(D))
|
2013-06-24 15:20:36 +08:00
|
|
|
if (ND->getDeclContext() == DCtx && !shouldBeHidden(ND) &&
|
|
|
|
(!ND->isFromASTFile() ||
|
|
|
|
(isTranslationUnit() &&
|
|
|
|
!getParentASTContext().getLangOpts().CPlusPlus)))
|
2012-03-16 14:12:59 +08:00
|
|
|
makeDeclVisibleInContextImpl(ND, false);
|
|
|
|
|
|
|
|
// If this declaration is itself a transparent declaration context
|
|
|
|
// or inline namespace, add the members of this declaration of that
|
|
|
|
// context (recursively).
|
|
|
|
if (DeclContext *InnerCtx = dyn_cast<DeclContext>(D))
|
|
|
|
if (InnerCtx->isTransparentContext() || InnerCtx->isInlineNamespace())
|
|
|
|
buildLookupImpl(InnerCtx);
|
|
|
|
}
|
2011-10-21 10:57:43 +08:00
|
|
|
}
|
|
|
|
|
2009-09-09 23:08:12 +08:00
|
|
|
DeclContext::lookup_result
|
2009-06-30 10:36:12 +08:00
|
|
|
DeclContext::lookup(DeclarationName Name) {
|
2012-03-13 12:12:34 +08:00
|
|
|
assert(DeclKind != Decl::LinkageSpec &&
|
|
|
|
"Should not perform lookups into linkage specs!");
|
|
|
|
|
2009-01-09 01:28:14 +08:00
|
|
|
DeclContext *PrimaryContext = getPrimaryContext();
|
2008-12-12 00:49:14 +08:00
|
|
|
if (PrimaryContext != this)
|
2009-06-30 10:36:12 +08:00
|
|
|
return PrimaryContext->lookup(Name);
|
2008-12-12 00:49:14 +08:00
|
|
|
|
2012-03-13 11:12:56 +08:00
|
|
|
if (hasExternalVisibleStorage()) {
|
2013-02-07 11:37:08 +08:00
|
|
|
StoredDeclsMap *Map = LookupPtr.getPointer();
|
|
|
|
if (LookupPtr.getInt())
|
|
|
|
Map = buildLookup();
|
2013-02-12 06:02:16 +08:00
|
|
|
else if (NeedToReconcileExternalVisibleStorage)
|
|
|
|
reconcileExternalVisibleStorage();
|
2013-02-07 11:37:08 +08:00
|
|
|
|
2013-02-08 08:37:45 +08:00
|
|
|
if (!Map)
|
|
|
|
Map = CreateStoredDeclsMap(getParentASTContext());
|
|
|
|
|
2013-02-07 11:37:08 +08:00
|
|
|
// If a PCH/module has a result for this name, and we have a local
|
|
|
|
// declaration, we will have imported the PCH/module result when adding the
|
|
|
|
// local declaration or when reconciling the module.
|
2013-02-08 08:37:45 +08:00
|
|
|
std::pair<StoredDeclsMap::iterator, bool> R =
|
|
|
|
Map->insert(std::make_pair(Name, StoredDeclsList()));
|
|
|
|
if (!R.second)
|
|
|
|
return R.first->second.getLookupResult();
|
2012-03-16 14:12:59 +08:00
|
|
|
|
2010-06-01 17:23:16 +08:00
|
|
|
ExternalASTSource *Source = getParentASTContext().getExternalSource();
|
2013-02-07 11:30:24 +08:00
|
|
|
if (Source->FindExternalVisibleDeclsByName(this, Name)) {
|
|
|
|
if (StoredDeclsMap *Map = LookupPtr.getPointer()) {
|
|
|
|
StoredDeclsMap::iterator I = Map->find(Name);
|
|
|
|
if (I != Map->end())
|
|
|
|
return I->second.getLookupResult();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return lookup_result(lookup_iterator(0), lookup_iterator(0));
|
2010-06-01 17:23:16 +08:00
|
|
|
}
|
2009-04-10 06:27:44 +08:00
|
|
|
|
2012-03-16 14:12:59 +08:00
|
|
|
StoredDeclsMap *Map = LookupPtr.getPointer();
|
|
|
|
if (LookupPtr.getInt())
|
|
|
|
Map = buildLookup();
|
|
|
|
|
|
|
|
if (!Map)
|
|
|
|
return lookup_result(lookup_iterator(0), lookup_iterator(0));
|
|
|
|
|
|
|
|
StoredDeclsMap::iterator I = Map->find(Name);
|
|
|
|
if (I == Map->end())
|
|
|
|
return lookup_result(lookup_iterator(0), lookup_iterator(0));
|
|
|
|
|
|
|
|
return I->second.getLookupResult();
|
2008-12-12 00:49:14 +08:00
|
|
|
}
|
|
|
|
|
2013-01-13 03:30:44 +08:00
|
|
|
void DeclContext::localUncachedLookup(DeclarationName Name,
|
|
|
|
SmallVectorImpl<NamedDecl *> &Results) {
|
2011-10-15 08:10:27 +08:00
|
|
|
Results.clear();
|
|
|
|
|
|
|
|
// If there's no external storage, just perform a normal lookup and copy
|
|
|
|
// the results.
|
2012-07-18 05:16:27 +08:00
|
|
|
if (!hasExternalVisibleStorage() && !hasExternalLexicalStorage() && Name) {
|
2011-10-15 08:10:27 +08:00
|
|
|
lookup_result LookupResults = lookup(Name);
|
2012-12-19 08:45:41 +08:00
|
|
|
Results.insert(Results.end(), LookupResults.begin(), LookupResults.end());
|
2011-10-15 08:10:27 +08:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
// If we have a lookup table, check there first. Maybe we'll get lucky.
|
2013-02-07 11:37:08 +08:00
|
|
|
if (Name && !LookupPtr.getInt()) {
|
2012-07-18 05:16:27 +08:00
|
|
|
if (StoredDeclsMap *Map = LookupPtr.getPointer()) {
|
|
|
|
StoredDeclsMap::iterator Pos = Map->find(Name);
|
|
|
|
if (Pos != Map->end()) {
|
|
|
|
Results.insert(Results.end(),
|
2012-12-19 08:45:41 +08:00
|
|
|
Pos->second.getLookupResult().begin(),
|
|
|
|
Pos->second.getLookupResult().end());
|
2012-07-18 05:16:27 +08:00
|
|
|
return;
|
|
|
|
}
|
2011-10-15 08:10:27 +08:00
|
|
|
}
|
|
|
|
}
|
2012-07-18 05:16:27 +08:00
|
|
|
|
2011-10-15 08:10:27 +08:00
|
|
|
// Slow case: grovel through the declarations in our chain looking for
|
|
|
|
// matches.
|
|
|
|
for (Decl *D = FirstDecl; D; D = D->getNextDeclInContext()) {
|
|
|
|
if (NamedDecl *ND = dyn_cast<NamedDecl>(D))
|
|
|
|
if (ND->getDeclName() == Name)
|
|
|
|
Results.push_back(ND);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-08-31 08:36:30 +08:00
|
|
|
DeclContext *DeclContext::getRedeclContext() {
|
2009-03-28 03:19:59 +08:00
|
|
|
DeclContext *Ctx = this;
|
2010-09-01 04:53:31 +08:00
|
|
|
// Skip through transparent contexts.
|
|
|
|
while (Ctx->isTransparentContext())
|
2009-01-07 07:51:29 +08:00
|
|
|
Ctx = Ctx->getParent();
|
|
|
|
return Ctx;
|
|
|
|
}
|
|
|
|
|
2009-02-26 06:02:03 +08:00
|
|
|
DeclContext *DeclContext::getEnclosingNamespaceContext() {
|
|
|
|
DeclContext *Ctx = this;
|
|
|
|
// Skip through non-namespace, non-translation-unit contexts.
|
2010-08-31 08:36:23 +08:00
|
|
|
while (!Ctx->isFileContext())
|
2009-02-26 06:02:03 +08:00
|
|
|
Ctx = Ctx->getParent();
|
|
|
|
return Ctx->getPrimaryContext();
|
|
|
|
}
|
|
|
|
|
2010-08-31 08:36:30 +08:00
|
|
|
bool DeclContext::InEnclosingNamespaceSetOf(const DeclContext *O) const {
|
|
|
|
// For non-file contexts, this is equivalent to Equals.
|
|
|
|
if (!isFileContext())
|
|
|
|
return O->Equals(this);
|
|
|
|
|
|
|
|
do {
|
|
|
|
if (O->Equals(this))
|
|
|
|
return true;
|
|
|
|
|
|
|
|
const NamespaceDecl *NS = dyn_cast<NamespaceDecl>(O);
|
|
|
|
if (!NS || !NS->isInline())
|
|
|
|
break;
|
|
|
|
O = NS->getParent();
|
|
|
|
} while (O);
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2012-03-16 14:12:59 +08:00
|
|
|
void DeclContext::makeDeclVisibleInContext(NamedDecl *D) {
|
|
|
|
DeclContext *PrimaryDC = this->getPrimaryContext();
|
|
|
|
DeclContext *DeclDC = D->getDeclContext()->getPrimaryContext();
|
|
|
|
// If the decl is being added outside of its semantic decl context, we
|
|
|
|
// need to ensure that we eagerly build the lookup information for it.
|
|
|
|
PrimaryDC->makeDeclVisibleInContextWithFlags(D, false, PrimaryDC == DeclDC);
|
2011-10-21 10:57:43 +08:00
|
|
|
}
|
|
|
|
|
2012-03-16 14:12:59 +08:00
|
|
|
void DeclContext::makeDeclVisibleInContextWithFlags(NamedDecl *D, bool Internal,
|
|
|
|
bool Recoverable) {
|
|
|
|
assert(this == getPrimaryContext() && "expected a primary DC");
|
2008-12-12 00:49:14 +08:00
|
|
|
|
2012-03-13 11:12:56 +08:00
|
|
|
// Skip declarations within functions.
|
|
|
|
// FIXME: We shouldn't need to build lookup tables for function declarations
|
|
|
|
// ever, and we can't do so correctly because we can't model the nesting of
|
|
|
|
// scopes which occurs within functions. We use "qualified" lookup into
|
|
|
|
// function declarations when handling friend declarations inside nested
|
|
|
|
// classes, and consequently accept the following invalid code:
|
|
|
|
//
|
|
|
|
// void f() { void g(); { int g; struct S { friend void g(); }; } }
|
|
|
|
if (isFunctionOrMethod() && !isa<FunctionDecl>(D))
|
2009-02-18 07:15:12 +08:00
|
|
|
return;
|
|
|
|
|
2012-03-16 14:12:59 +08:00
|
|
|
// Skip declarations which should be invisible to name lookup.
|
|
|
|
if (shouldBeHidden(D))
|
|
|
|
return;
|
|
|
|
|
|
|
|
// If we already have a lookup data structure, perform the insertion into
|
|
|
|
// it. If we might have externally-stored decls with this name, look them
|
|
|
|
// up and perform the insertion. If this decl was declared outside its
|
|
|
|
// semantic context, buildLookup won't add it, so add it now.
|
|
|
|
//
|
|
|
|
// FIXME: As a performance hack, don't add such decls into the translation
|
|
|
|
// unit unless we're in C++, since qualified lookup into the TU is never
|
|
|
|
// performed.
|
|
|
|
if (LookupPtr.getPointer() || hasExternalVisibleStorage() ||
|
|
|
|
((!Recoverable || D->getDeclContext() != D->getLexicalDeclContext()) &&
|
|
|
|
(getParentASTContext().getLangOpts().CPlusPlus ||
|
|
|
|
!isTranslationUnit()))) {
|
|
|
|
// If we have lazily omitted any decls, they might have the same name as
|
|
|
|
// the decl which we are adding, so build a full lookup table before adding
|
|
|
|
// this decl.
|
|
|
|
buildLookup();
|
|
|
|
makeDeclVisibleInContextImpl(D, Internal);
|
|
|
|
} else {
|
|
|
|
LookupPtr.setInt(true);
|
|
|
|
}
|
|
|
|
|
|
|
|
// If we are a transparent context or inline namespace, insert into our
|
|
|
|
// parent context, too. This operation is recursive.
|
|
|
|
if (isTransparentContext() || isInlineNamespace())
|
|
|
|
getParent()->getPrimaryContext()->
|
|
|
|
makeDeclVisibleInContextWithFlags(D, Internal, Recoverable);
|
|
|
|
|
|
|
|
Decl *DCAsDecl = cast<Decl>(this);
|
|
|
|
// Notify that a decl was made visible unless we are a Tag being defined.
|
|
|
|
if (!(isa<TagDecl>(DCAsDecl) && cast<TagDecl>(DCAsDecl)->isBeingDefined()))
|
|
|
|
if (ASTMutationListener *L = DCAsDecl->getASTMutationListener())
|
|
|
|
L->AddedVisibleDecl(this, D);
|
|
|
|
}
|
|
|
|
|
|
|
|
void DeclContext::makeDeclVisibleInContextImpl(NamedDecl *D, bool Internal) {
|
|
|
|
// Find or create the stored declaration map.
|
|
|
|
StoredDeclsMap *Map = LookupPtr.getPointer();
|
|
|
|
if (!Map) {
|
|
|
|
ASTContext *C = &getParentASTContext();
|
|
|
|
Map = CreateStoredDeclsMap(*C);
|
2010-07-05 05:44:25 +08:00
|
|
|
}
|
|
|
|
|
2010-08-21 00:04:35 +08:00
|
|
|
// If there is an external AST source, load any declarations it knows about
|
|
|
|
// with this declaration's name.
|
|
|
|
// If the lookup table contains an entry about this name it means that we
|
|
|
|
// have already checked the external source.
|
2011-10-21 10:57:43 +08:00
|
|
|
if (!Internal)
|
|
|
|
if (ExternalASTSource *Source = getParentASTContext().getExternalSource())
|
|
|
|
if (hasExternalVisibleStorage() &&
|
2012-03-16 14:12:59 +08:00
|
|
|
Map->find(D->getDeclName()) == Map->end())
|
2011-10-21 10:57:43 +08:00
|
|
|
Source->FindExternalVisibleDeclsByName(this, D->getDeclName());
|
2010-08-21 00:04:35 +08:00
|
|
|
|
2008-12-12 00:49:14 +08:00
|
|
|
// Insert this declaration into the map.
|
2012-03-16 14:12:59 +08:00
|
|
|
StoredDeclsList &DeclNameEntries = (*Map)[D->getDeclName()];
|
2009-02-20 09:44:05 +08:00
|
|
|
if (DeclNameEntries.isNull()) {
|
|
|
|
DeclNameEntries.setOnlyValue(D);
|
2012-03-16 14:12:59 +08:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (DeclNameEntries.HandleRedeclaration(D)) {
|
2012-03-13 11:12:56 +08:00
|
|
|
// This declaration has replaced an existing one for which
|
|
|
|
// declarationReplaces returns true.
|
2012-03-16 14:12:59 +08:00
|
|
|
return;
|
2008-12-12 00:49:14 +08:00
|
|
|
}
|
2009-02-20 08:55:03 +08:00
|
|
|
|
2012-03-16 14:12:59 +08:00
|
|
|
// Put this declaration into the appropriate slot.
|
|
|
|
DeclNameEntries.AddSubsequentDecl(D);
|
2008-12-12 00:49:14 +08:00
|
|
|
}
|
2009-02-04 03:21:40 +08:00
|
|
|
|
|
|
|
/// Returns iterator range [First, Last) of UsingDirectiveDecls stored within
|
|
|
|
/// this context.
|
2009-09-09 23:08:12 +08:00
|
|
|
DeclContext::udir_iterator_range
|
2009-06-30 10:36:12 +08:00
|
|
|
DeclContext::getUsingDirectives() const {
|
2012-03-13 11:12:56 +08:00
|
|
|
// FIXME: Use something more efficient than normal lookup for using
|
|
|
|
// directives. In C++, using directives are looked up more than anything else.
|
2009-06-30 10:36:12 +08:00
|
|
|
lookup_const_result Result = lookup(UsingDirectiveDecl::getName());
|
2012-12-19 08:45:41 +08:00
|
|
|
return udir_iterator_range(reinterpret_cast<udir_iterator>(Result.begin()),
|
|
|
|
reinterpret_cast<udir_iterator>(Result.end()));
|
2009-02-04 03:21:40 +08:00
|
|
|
}
|
2009-04-10 06:27:44 +08:00
|
|
|
|
2010-02-11 15:12:28 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Creation and Destruction of StoredDeclsMaps. //
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2010-03-24 13:22:00 +08:00
|
|
|
StoredDeclsMap *DeclContext::CreateStoredDeclsMap(ASTContext &C) const {
|
2012-03-16 14:12:59 +08:00
|
|
|
assert(!LookupPtr.getPointer() && "context already has a decls map");
|
2010-03-24 13:22:00 +08:00
|
|
|
assert(getPrimaryContext() == this &&
|
|
|
|
"creating decls map on non-primary context");
|
|
|
|
|
|
|
|
StoredDeclsMap *M;
|
|
|
|
bool Dependent = isDependentContext();
|
|
|
|
if (Dependent)
|
|
|
|
M = new DependentStoredDeclsMap();
|
|
|
|
else
|
|
|
|
M = new StoredDeclsMap();
|
|
|
|
M->Previous = C.LastSDM;
|
|
|
|
C.LastSDM = llvm::PointerIntPair<StoredDeclsMap*,1>(M, Dependent);
|
2012-03-16 14:12:59 +08:00
|
|
|
LookupPtr.setPointer(M);
|
2010-02-11 15:12:28 +08:00
|
|
|
return M;
|
|
|
|
}
|
|
|
|
|
|
|
|
void ASTContext::ReleaseDeclContextMaps() {
|
2010-03-24 13:22:00 +08:00
|
|
|
// It's okay to delete DependentStoredDeclsMaps via a StoredDeclsMap
|
|
|
|
// pointer because the subclass doesn't add anything that needs to
|
|
|
|
// be deleted.
|
|
|
|
StoredDeclsMap::DestroyAll(LastSDM.getPointer(), LastSDM.getInt());
|
|
|
|
}
|
|
|
|
|
|
|
|
void StoredDeclsMap::DestroyAll(StoredDeclsMap *Map, bool Dependent) {
|
|
|
|
while (Map) {
|
|
|
|
// Advance the iteration before we invalidate memory.
|
|
|
|
llvm::PointerIntPair<StoredDeclsMap*,1> Next = Map->Previous;
|
|
|
|
|
|
|
|
if (Dependent)
|
|
|
|
delete static_cast<DependentStoredDeclsMap*>(Map);
|
|
|
|
else
|
|
|
|
delete Map;
|
|
|
|
|
|
|
|
Map = Next.getPointer();
|
|
|
|
Dependent = Next.getInt();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
DependentDiagnostic *DependentDiagnostic::Create(ASTContext &C,
|
|
|
|
DeclContext *Parent,
|
|
|
|
const PartialDiagnostic &PDiag) {
|
|
|
|
assert(Parent->isDependentContext()
|
|
|
|
&& "cannot iterate dependent diagnostics of non-dependent context");
|
|
|
|
Parent = Parent->getPrimaryContext();
|
2012-03-16 14:12:59 +08:00
|
|
|
if (!Parent->LookupPtr.getPointer())
|
2010-03-24 13:22:00 +08:00
|
|
|
Parent->CreateStoredDeclsMap(C);
|
|
|
|
|
|
|
|
DependentStoredDeclsMap *Map
|
2012-03-16 14:12:59 +08:00
|
|
|
= static_cast<DependentStoredDeclsMap*>(Parent->LookupPtr.getPointer());
|
2010-03-24 13:22:00 +08:00
|
|
|
|
2010-03-30 07:56:53 +08:00
|
|
|
// Allocate the copy of the PartialDiagnostic via the ASTContext's
|
2010-03-30 07:34:08 +08:00
|
|
|
// BumpPtrAllocator, rather than the ASTContext itself.
|
2010-03-30 07:56:53 +08:00
|
|
|
PartialDiagnostic::Storage *DiagStorage = 0;
|
|
|
|
if (PDiag.hasStorage())
|
|
|
|
DiagStorage = new (C) PartialDiagnostic::Storage;
|
|
|
|
|
|
|
|
DependentDiagnostic *DD = new (C) DependentDiagnostic(PDiag, DiagStorage);
|
2010-03-24 13:22:00 +08:00
|
|
|
|
|
|
|
// TODO: Maybe we shouldn't reverse the order during insertion.
|
|
|
|
DD->NextDiagnostic = Map->FirstDiagnostic;
|
|
|
|
Map->FirstDiagnostic = DD;
|
|
|
|
|
|
|
|
return DD;
|
2010-02-11 15:12:28 +08:00
|
|
|
}
|