forked from OSchip/llvm-project
Add 178663 back.
http://lab.llvm.org:8011/builders/clang-x86_64-darwin10-gdb went back green before it processed the reverted 178663, so it could not have been the culprit. Revert "Revert 178663." This reverts commit 4f8a3eb2ce5d4ba422483439e20c8cbb4d953a41. llvm-svn: 178682
This commit is contained in:
parent
985a3abee4
commit
6ae7e50be4
|
@ -111,9 +111,14 @@ succeeded). Essentially all previous 'cast' usage should be replaced with
|
|||
'castAs' and 'dyn_cast' should be replaced with 'getAs'. See r175462 for the
|
||||
first example of such a change along with many examples of how code was
|
||||
migrated to the new API.
|
||||
|
||||
API change 1
|
||||
^^^^^^^^^^^^
|
||||
|
||||
Storage Class
|
||||
^^^^^^^^^^^^^
|
||||
|
||||
For each variable and function Clang used to keep the storage class as written
|
||||
in the source, the linkage and a semantic storage class. This was a bit
|
||||
redundant and the semantic storage class has been removed. The method
|
||||
getStorageClass now returns what is written it the source code for that decl.
|
||||
|
||||
...
|
||||
|
||||
|
|
|
@ -660,7 +660,6 @@ private:
|
|||
friend class ASTDeclReader;
|
||||
|
||||
unsigned SClass : 3;
|
||||
unsigned SClassAsWritten : 3;
|
||||
unsigned ThreadSpecified : 1;
|
||||
unsigned InitStyle : 2;
|
||||
|
||||
|
@ -727,14 +726,12 @@ protected:
|
|||
|
||||
VarDecl(Kind DK, DeclContext *DC, SourceLocation StartLoc,
|
||||
SourceLocation IdLoc, IdentifierInfo *Id,
|
||||
QualType T, TypeSourceInfo *TInfo, StorageClass SC,
|
||||
StorageClass SCAsWritten)
|
||||
QualType T, TypeSourceInfo *TInfo, StorageClass SC)
|
||||
: DeclaratorDecl(DK, DC, IdLoc, Id, T, TInfo, StartLoc), Init() {
|
||||
assert(sizeof(VarDeclBitfields) <= sizeof(unsigned));
|
||||
assert(sizeof(ParmVarDeclBitfields) <= sizeof(unsigned));
|
||||
AllBits = 0;
|
||||
VarDeclBits.SClass = SC;
|
||||
VarDeclBits.SClassAsWritten = SCAsWritten;
|
||||
// Everything else is implicitly initialized to false.
|
||||
}
|
||||
|
||||
|
@ -757,23 +754,18 @@ public:
|
|||
static VarDecl *Create(ASTContext &C, DeclContext *DC,
|
||||
SourceLocation StartLoc, SourceLocation IdLoc,
|
||||
IdentifierInfo *Id, QualType T, TypeSourceInfo *TInfo,
|
||||
StorageClass S, StorageClass SCAsWritten);
|
||||
StorageClass S);
|
||||
|
||||
static VarDecl *CreateDeserialized(ASTContext &C, unsigned ID);
|
||||
|
||||
virtual SourceRange getSourceRange() const LLVM_READONLY;
|
||||
|
||||
/// \brief Returns the storage class as written in the source. For the
|
||||
/// computed linkage of symbol, see getLinkage.
|
||||
StorageClass getStorageClass() const {
|
||||
return (StorageClass) VarDeclBits.SClass;
|
||||
}
|
||||
StorageClass getStorageClassAsWritten() const {
|
||||
return (StorageClass) VarDeclBits.SClassAsWritten;
|
||||
}
|
||||
void setStorageClass(StorageClass SC);
|
||||
void setStorageClassAsWritten(StorageClass SC) {
|
||||
assert(isLegalForVariable(SC));
|
||||
VarDeclBits.SClassAsWritten = SC;
|
||||
}
|
||||
|
||||
void setThreadSpecified(bool T) { VarDeclBits.ThreadSpecified = T; }
|
||||
bool isThreadSpecified() const {
|
||||
|
@ -805,13 +797,6 @@ public:
|
|||
getStorageClass() == SC_PrivateExtern;
|
||||
}
|
||||
|
||||
/// \brief Returns true if a variable was written with extern or
|
||||
/// __private_extern__ storage.
|
||||
bool hasExternalStorageAsWritten() const {
|
||||
return getStorageClassAsWritten() == SC_Extern ||
|
||||
getStorageClassAsWritten() == SC_PrivateExtern;
|
||||
}
|
||||
|
||||
/// hasGlobalStorage - Returns true for all variables that do not
|
||||
/// have local storage. This includs all global variables as well
|
||||
/// as static variables declared within a function.
|
||||
|
@ -1145,7 +1130,7 @@ public:
|
|||
ImplicitParamDecl(DeclContext *DC, SourceLocation IdLoc,
|
||||
IdentifierInfo *Id, QualType Type)
|
||||
: VarDecl(ImplicitParam, DC, IdLoc, IdLoc, Id, Type,
|
||||
/*tinfo*/ 0, SC_None, SC_None) {
|
||||
/*tinfo*/ 0, SC_None) {
|
||||
setImplicit();
|
||||
}
|
||||
|
||||
|
@ -1164,8 +1149,8 @@ protected:
|
|||
ParmVarDecl(Kind DK, DeclContext *DC, SourceLocation StartLoc,
|
||||
SourceLocation IdLoc, IdentifierInfo *Id,
|
||||
QualType T, TypeSourceInfo *TInfo,
|
||||
StorageClass S, StorageClass SCAsWritten, Expr *DefArg)
|
||||
: VarDecl(DK, DC, StartLoc, IdLoc, Id, T, TInfo, S, SCAsWritten) {
|
||||
StorageClass S, Expr *DefArg)
|
||||
: VarDecl(DK, DC, StartLoc, IdLoc, Id, T, TInfo, S) {
|
||||
assert(ParmVarDeclBits.HasInheritedDefaultArg == false);
|
||||
assert(ParmVarDeclBits.IsKNRPromoted == false);
|
||||
assert(ParmVarDeclBits.IsObjCMethodParam == false);
|
||||
|
@ -1177,8 +1162,7 @@ public:
|
|||
SourceLocation StartLoc,
|
||||
SourceLocation IdLoc, IdentifierInfo *Id,
|
||||
QualType T, TypeSourceInfo *TInfo,
|
||||
StorageClass S, StorageClass SCAsWritten,
|
||||
Expr *DefArg);
|
||||
StorageClass S, Expr *DefArg);
|
||||
|
||||
static ParmVarDecl *CreateDeserialized(ASTContext &C, unsigned ID);
|
||||
|
||||
|
@ -1383,7 +1367,6 @@ private:
|
|||
// FIXME: This can be packed into the bitfields in Decl.
|
||||
// NOTE: VC++ treats enums as signed, avoid using the StorageClass enum
|
||||
unsigned SClass : 2;
|
||||
unsigned SClassAsWritten : 2;
|
||||
bool IsInline : 1;
|
||||
bool IsInlineSpecified : 1;
|
||||
bool IsVirtualAsWritten : 1;
|
||||
|
@ -1473,13 +1456,13 @@ protected:
|
|||
FunctionDecl(Kind DK, DeclContext *DC, SourceLocation StartLoc,
|
||||
const DeclarationNameInfo &NameInfo,
|
||||
QualType T, TypeSourceInfo *TInfo,
|
||||
StorageClass S, StorageClass SCAsWritten, bool isInlineSpecified,
|
||||
StorageClass S, bool isInlineSpecified,
|
||||
bool isConstexprSpecified)
|
||||
: DeclaratorDecl(DK, DC, NameInfo.getLoc(), NameInfo.getName(), T, TInfo,
|
||||
StartLoc),
|
||||
DeclContext(DK),
|
||||
ParamInfo(0), Body(),
|
||||
SClass(S), SClassAsWritten(SCAsWritten),
|
||||
SClass(S),
|
||||
IsInline(isInlineSpecified), IsInlineSpecified(isInlineSpecified),
|
||||
IsVirtualAsWritten(false), IsPure(false), HasInheritedPrototype(false),
|
||||
HasWrittenPrototype(true), IsDeleted(false), IsTrivial(false),
|
||||
|
@ -1511,13 +1494,12 @@ public:
|
|||
DeclarationName N, QualType T,
|
||||
TypeSourceInfo *TInfo,
|
||||
StorageClass SC,
|
||||
StorageClass SCAsWritten,
|
||||
bool isInlineSpecified = false,
|
||||
bool hasWrittenPrototype = true,
|
||||
bool isConstexprSpecified = false) {
|
||||
DeclarationNameInfo NameInfo(N, NLoc);
|
||||
return FunctionDecl::Create(C, DC, StartLoc, NameInfo, T, TInfo,
|
||||
SC, SCAsWritten,
|
||||
SC,
|
||||
isInlineSpecified, hasWrittenPrototype,
|
||||
isConstexprSpecified);
|
||||
}
|
||||
|
@ -1527,7 +1509,6 @@ public:
|
|||
const DeclarationNameInfo &NameInfo,
|
||||
QualType T, TypeSourceInfo *TInfo,
|
||||
StorageClass SC,
|
||||
StorageClass SCAsWritten,
|
||||
bool isInlineSpecified,
|
||||
bool hasWrittenPrototype,
|
||||
bool isConstexprSpecified = false);
|
||||
|
@ -1779,12 +1760,9 @@ public:
|
|||
return getType()->getAs<FunctionType>()->getCallResultType(getASTContext());
|
||||
}
|
||||
|
||||
/// \brief Returns the storage class as written in the source. For the
|
||||
/// computed linkage of symbol, see getLinkage.
|
||||
StorageClass getStorageClass() const { return StorageClass(SClass); }
|
||||
void setStorageClass(StorageClass SC);
|
||||
|
||||
StorageClass getStorageClassAsWritten() const {
|
||||
return StorageClass(SClassAsWritten);
|
||||
}
|
||||
|
||||
/// \brief Determine whether the "inline" keyword was specified for this
|
||||
/// function.
|
||||
|
|
|
@ -1573,11 +1573,10 @@ protected:
|
|||
CXXMethodDecl(Kind DK, CXXRecordDecl *RD, SourceLocation StartLoc,
|
||||
const DeclarationNameInfo &NameInfo,
|
||||
QualType T, TypeSourceInfo *TInfo,
|
||||
bool isStatic, StorageClass SCAsWritten, bool isInline,
|
||||
StorageClass SC, bool isInline,
|
||||
bool isConstexpr, SourceLocation EndLocation)
|
||||
: FunctionDecl(DK, RD, StartLoc, NameInfo, T, TInfo,
|
||||
(isStatic ? SC_Static : SC_None),
|
||||
SCAsWritten, isInline, isConstexpr) {
|
||||
SC, isInline, isConstexpr) {
|
||||
if (EndLocation.isValid())
|
||||
setRangeEnd(EndLocation);
|
||||
}
|
||||
|
@ -1587,15 +1586,14 @@ public:
|
|||
SourceLocation StartLoc,
|
||||
const DeclarationNameInfo &NameInfo,
|
||||
QualType T, TypeSourceInfo *TInfo,
|
||||
bool isStatic,
|
||||
StorageClass SCAsWritten,
|
||||
StorageClass SC,
|
||||
bool isInline,
|
||||
bool isConstexpr,
|
||||
SourceLocation EndLocation);
|
||||
|
||||
static CXXMethodDecl *CreateDeserialized(ASTContext &C, unsigned ID);
|
||||
|
||||
bool isStatic() const { return getStorageClass() == SC_Static; }
|
||||
|
||||
bool isStatic() const;
|
||||
bool isInstance() const { return !isStatic(); }
|
||||
|
||||
bool isConst() const { return getType()->castAs<FunctionType>()->isConst(); }
|
||||
|
@ -2003,7 +2001,7 @@ class CXXConstructorDecl : public CXXMethodDecl {
|
|||
QualType T, TypeSourceInfo *TInfo,
|
||||
bool isExplicitSpecified, bool isInline,
|
||||
bool isImplicitlyDeclared, bool isConstexpr)
|
||||
: CXXMethodDecl(CXXConstructor, RD, StartLoc, NameInfo, T, TInfo, false,
|
||||
: CXXMethodDecl(CXXConstructor, RD, StartLoc, NameInfo, T, TInfo,
|
||||
SC_None, isInline, isConstexpr, SourceLocation()),
|
||||
IsExplicitSpecified(isExplicitSpecified), ImplicitlyDefined(false),
|
||||
CtorInitializers(0), NumCtorInitializers(0) {
|
||||
|
@ -2222,7 +2220,7 @@ class CXXDestructorDecl : public CXXMethodDecl {
|
|||
const DeclarationNameInfo &NameInfo,
|
||||
QualType T, TypeSourceInfo *TInfo,
|
||||
bool isInline, bool isImplicitlyDeclared)
|
||||
: CXXMethodDecl(CXXDestructor, RD, StartLoc, NameInfo, T, TInfo, false,
|
||||
: CXXMethodDecl(CXXDestructor, RD, StartLoc, NameInfo, T, TInfo,
|
||||
SC_None, isInline, /*isConstexpr=*/false, SourceLocation()),
|
||||
ImplicitlyDefined(false), OperatorDelete(0) {
|
||||
setImplicit(isImplicitlyDeclared);
|
||||
|
@ -2289,7 +2287,7 @@ class CXXConversionDecl : public CXXMethodDecl {
|
|||
QualType T, TypeSourceInfo *TInfo,
|
||||
bool isInline, bool isExplicitSpecified,
|
||||
bool isConstexpr, SourceLocation EndLocation)
|
||||
: CXXMethodDecl(CXXConversion, RD, StartLoc, NameInfo, T, TInfo, false,
|
||||
: CXXMethodDecl(CXXConversion, RD, StartLoc, NameInfo, T, TInfo,
|
||||
SC_None, isInline, isConstexpr, EndLocation),
|
||||
IsExplicitSpecified(isExplicitSpecified) { }
|
||||
|
||||
|
|
|
@ -338,8 +338,6 @@ private:
|
|||
// constexpr-specifier
|
||||
unsigned Constexpr_specified : 1;
|
||||
|
||||
/*SCS*/unsigned StorageClassSpecAsWritten : 3;
|
||||
|
||||
union {
|
||||
UnionParsedType TypeRep;
|
||||
Decl *DeclRep;
|
||||
|
@ -378,7 +376,6 @@ private:
|
|||
|
||||
WrittenBuiltinSpecs writtenBS;
|
||||
void SaveWrittenBuiltinSpecs();
|
||||
void SaveStorageSpecifierAsWritten();
|
||||
|
||||
ObjCDeclSpec *ObjCQualifiers;
|
||||
|
||||
|
@ -418,7 +415,6 @@ public:
|
|||
FS_noreturn_specified(false),
|
||||
Friend_specified(false),
|
||||
Constexpr_specified(false),
|
||||
StorageClassSpecAsWritten(SCS_unspecified),
|
||||
Attrs(attrFactory),
|
||||
ProtocolQualifiers(0),
|
||||
NumProtocolQualifiers(0),
|
||||
|
@ -553,10 +549,6 @@ public:
|
|||
/// DeclSpec includes.
|
||||
unsigned getParsedSpecifiers() const;
|
||||
|
||||
SCS getStorageClassSpecAsWritten() const {
|
||||
return (SCS)StorageClassSpecAsWritten;
|
||||
}
|
||||
|
||||
/// isEmpty - Return true if this declaration specifier is completely empty:
|
||||
/// no tokens were parsed in the production of it.
|
||||
bool isEmpty() const {
|
||||
|
|
|
@ -1402,7 +1402,7 @@ public:
|
|||
ParmVarDecl *CheckParameter(DeclContext *DC, SourceLocation StartLoc,
|
||||
SourceLocation NameLoc, IdentifierInfo *Name,
|
||||
QualType T, TypeSourceInfo *TSInfo,
|
||||
StorageClass SC, StorageClass SCAsWritten);
|
||||
StorageClass SC);
|
||||
void ActOnParamDefaultArgument(Decl *param,
|
||||
SourceLocation EqualLoc,
|
||||
Expr *defarg);
|
||||
|
|
|
@ -749,7 +749,7 @@ void ASTDumper::VisitFunctionDecl(const FunctionDecl *D) {
|
|||
dumpName(D);
|
||||
dumpType(D->getType());
|
||||
|
||||
StorageClass SC = D->getStorageClassAsWritten();
|
||||
StorageClass SC = D->getStorageClass();
|
||||
if (SC != SC_None)
|
||||
OS << ' ' << VarDecl::getStorageClassSpecifierString(SC);
|
||||
if (D->isInlineSpecified())
|
||||
|
@ -850,7 +850,7 @@ void ASTDumper::VisitFieldDecl(const FieldDecl *D) {
|
|||
void ASTDumper::VisitVarDecl(const VarDecl *D) {
|
||||
dumpName(D);
|
||||
dumpType(D->getType());
|
||||
StorageClass SC = D->getStorageClassAsWritten();
|
||||
StorageClass SC = D->getStorageClass();
|
||||
if (SC != SC_None)
|
||||
OS << ' ' << VarDecl::getStorageClassSpecifierString(SC);
|
||||
if (D->isThreadSpecified())
|
||||
|
|
|
@ -2716,8 +2716,7 @@ Decl *ASTNodeImporter::VisitFunctionDecl(FunctionDecl *D) {
|
|||
cast<CXXRecordDecl>(DC),
|
||||
D->getInnerLocStart(),
|
||||
NameInfo, T, TInfo,
|
||||
Method->isStatic(),
|
||||
Method->getStorageClassAsWritten(),
|
||||
Method->getStorageClass(),
|
||||
Method->isInlineSpecified(),
|
||||
D->isConstexpr(),
|
||||
Importer.Import(D->getLocEnd()));
|
||||
|
@ -2725,7 +2724,6 @@ Decl *ASTNodeImporter::VisitFunctionDecl(FunctionDecl *D) {
|
|||
ToFunction = FunctionDecl::Create(Importer.getToContext(), DC,
|
||||
D->getInnerLocStart(),
|
||||
NameInfo, T, TInfo, D->getStorageClass(),
|
||||
D->getStorageClassAsWritten(),
|
||||
D->isInlineSpecified(),
|
||||
D->hasWrittenPrototype(),
|
||||
D->isConstexpr());
|
||||
|
@ -3076,8 +3074,7 @@ Decl *ASTNodeImporter::VisitVarDecl(VarDecl *D) {
|
|||
Importer.Import(D->getInnerLocStart()),
|
||||
Loc, Name.getAsIdentifierInfo(),
|
||||
T, TInfo,
|
||||
D->getStorageClass(),
|
||||
D->getStorageClassAsWritten());
|
||||
D->getStorageClass());
|
||||
ToVar->setQualifierInfo(Importer.Import(D->getQualifierLoc()));
|
||||
ToVar->setAccess(D->getAccess());
|
||||
ToVar->setLexicalDeclContext(LexicalDC);
|
||||
|
@ -3145,7 +3142,6 @@ Decl *ASTNodeImporter::VisitParmVarDecl(ParmVarDecl *D) {
|
|||
Importer.Import(D->getInnerLocStart()),
|
||||
Loc, Name.getAsIdentifierInfo(),
|
||||
T, TInfo, D->getStorageClass(),
|
||||
D->getStorageClassAsWritten(),
|
||||
/*FIXME: Default argument*/ 0);
|
||||
ToParm->setHasInheritedDefaultArg(D->hasInheritedDefaultArg());
|
||||
return Importer.Imported(D, ToParm);
|
||||
|
|
|
@ -498,26 +498,24 @@ static LinkageInfo getLVForNamespaceScopeDecl(const NamedDecl *D,
|
|||
// declared to have external linkage; or (there is no equivalent in C99)
|
||||
if (Context.getLangOpts().CPlusPlus &&
|
||||
Var->getType().isConstQualified() &&
|
||||
!Var->getType().isVolatileQualified() &&
|
||||
Var->getStorageClass() != SC_Extern &&
|
||||
Var->getStorageClass() != SC_PrivateExtern) {
|
||||
bool FoundExtern = false;
|
||||
for (const VarDecl *PrevVar = Var->getPreviousDecl();
|
||||
PrevVar && !FoundExtern;
|
||||
PrevVar = PrevVar->getPreviousDecl())
|
||||
if (isExternalLinkage(PrevVar->getLinkage()))
|
||||
FoundExtern = true;
|
||||
|
||||
if (!FoundExtern)
|
||||
return LinkageInfo::internal();
|
||||
}
|
||||
if (Var->getStorageClass() == SC_None) {
|
||||
!Var->getType().isVolatileQualified()) {
|
||||
const VarDecl *PrevVar = Var->getPreviousDecl();
|
||||
for (; PrevVar; PrevVar = PrevVar->getPreviousDecl())
|
||||
if (PrevVar->getStorageClass() == SC_PrivateExtern)
|
||||
break;
|
||||
if (PrevVar)
|
||||
return PrevVar->getLinkageAndVisibility();
|
||||
|
||||
if (Var->getStorageClass() != SC_Extern &&
|
||||
Var->getStorageClass() != SC_PrivateExtern)
|
||||
return LinkageInfo::internal();
|
||||
}
|
||||
|
||||
for (const VarDecl *PrevVar = Var->getPreviousDecl(); PrevVar;
|
||||
PrevVar = PrevVar->getPreviousDecl()) {
|
||||
if (PrevVar->getStorageClass() == SC_PrivateExtern &&
|
||||
Var->getStorageClass() == SC_None)
|
||||
return PrevVar->getLinkageAndVisibility();
|
||||
// Explicitly declared static.
|
||||
if (PrevVar->getStorageClass() == SC_Static)
|
||||
return LinkageInfo::internal();
|
||||
}
|
||||
} else if (isa<FunctionDecl>(D) || isa<FunctionTemplateDecl>(D)) {
|
||||
// C++ [temp]p4:
|
||||
|
@ -531,7 +529,7 @@ static LinkageInfo getLVForNamespaceScopeDecl(const NamedDecl *D,
|
|||
Function = cast<FunctionDecl>(D);
|
||||
|
||||
// Explicitly declared static.
|
||||
if (Function->getStorageClass() == SC_Static)
|
||||
if (Function->getCanonicalDecl()->getStorageClass() == SC_Static)
|
||||
return LinkageInfo(InternalLinkage, DefaultVisibility, false);
|
||||
} else if (const FieldDecl *Field = dyn_cast<FieldDecl>(D)) {
|
||||
// - a data member of an anonymous union.
|
||||
|
@ -995,7 +993,7 @@ static LinkageInfo getLVForLocalDecl(const NamedDecl *D,
|
|||
return LinkageInfo::uniqueExternal();
|
||||
|
||||
// This is a "void f();" which got merged with a file static.
|
||||
if (Function->getStorageClass() == SC_Static)
|
||||
if (Function->getCanonicalDecl()->getStorageClass() == SC_Static)
|
||||
return LinkageInfo::internal();
|
||||
|
||||
LinkageInfo LV;
|
||||
|
@ -1013,15 +1011,11 @@ static LinkageInfo getLVForLocalDecl(const NamedDecl *D,
|
|||
}
|
||||
|
||||
if (const VarDecl *Var = dyn_cast<VarDecl>(D)) {
|
||||
if (Var->hasExternalStorageAsWritten()) {
|
||||
if (Var->hasExternalStorage()) {
|
||||
if (Var->isInAnonymousNamespace() &&
|
||||
!Var->getDeclContext()->isExternCContext())
|
||||
return LinkageInfo::uniqueExternal();
|
||||
|
||||
// This is an "extern int foo;" which got merged with a file static.
|
||||
if (Var->getStorageClass() == SC_Static)
|
||||
return LinkageInfo::internal();
|
||||
|
||||
LinkageInfo LV;
|
||||
if (Var->getStorageClass() == SC_PrivateExtern)
|
||||
LV.mergeVisibility(HiddenVisibility, true);
|
||||
|
@ -1030,9 +1024,13 @@ static LinkageInfo getLVForLocalDecl(const NamedDecl *D,
|
|||
LV.mergeVisibility(*Vis, true);
|
||||
}
|
||||
|
||||
// Note that Sema::MergeVarDecl already takes care of implementing
|
||||
// C99 6.2.2p4 and propagating the visibility attribute, so we don't
|
||||
// have to do it here.
|
||||
if (const VarDecl *Prev = Var->getPreviousDecl()) {
|
||||
LinkageInfo PrevLV = getLVForDecl(Prev, computation);
|
||||
if (PrevLV.getLinkage())
|
||||
LV.setLinkage(PrevLV.getLinkage());
|
||||
LV.mergeVisibility(PrevLV);
|
||||
}
|
||||
|
||||
return LV;
|
||||
}
|
||||
}
|
||||
|
@ -1467,21 +1465,18 @@ const char *VarDecl::getStorageClassSpecifierString(StorageClass SC) {
|
|||
VarDecl *VarDecl::Create(ASTContext &C, DeclContext *DC,
|
||||
SourceLocation StartL, SourceLocation IdL,
|
||||
IdentifierInfo *Id, QualType T, TypeSourceInfo *TInfo,
|
||||
StorageClass S, StorageClass SCAsWritten) {
|
||||
return new (C) VarDecl(Var, DC, StartL, IdL, Id, T, TInfo, S, SCAsWritten);
|
||||
StorageClass S) {
|
||||
return new (C) VarDecl(Var, DC, StartL, IdL, Id, T, TInfo, S);
|
||||
}
|
||||
|
||||
VarDecl *VarDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
|
||||
void *Mem = AllocateDeserializedDecl(C, ID, sizeof(VarDecl));
|
||||
return new (Mem) VarDecl(Var, 0, SourceLocation(), SourceLocation(), 0,
|
||||
QualType(), 0, SC_None, SC_None);
|
||||
QualType(), 0, SC_None);
|
||||
}
|
||||
|
||||
void VarDecl::setStorageClass(StorageClass SC) {
|
||||
assert(isLegalForVariable(SC));
|
||||
if (getStorageClass() != SC)
|
||||
assert(isLinkageValid());
|
||||
|
||||
VarDeclBits.SClass = SC;
|
||||
}
|
||||
|
||||
|
@ -1581,7 +1576,7 @@ VarDecl::DefinitionKind VarDecl::isThisDeclarationADefinition(
|
|||
if (hasExternalStorage())
|
||||
return DeclarationOnly;
|
||||
|
||||
if (hasExternalStorageAsWritten()) {
|
||||
if (hasExternalStorage()) {
|
||||
for (const VarDecl *PrevVar = getPreviousDecl();
|
||||
PrevVar; PrevVar = PrevVar->getPreviousDecl()) {
|
||||
if (PrevVar->getLinkage() == InternalLinkage)
|
||||
|
@ -1879,16 +1874,15 @@ ParmVarDecl *ParmVarDecl::Create(ASTContext &C, DeclContext *DC,
|
|||
SourceLocation StartLoc,
|
||||
SourceLocation IdLoc, IdentifierInfo *Id,
|
||||
QualType T, TypeSourceInfo *TInfo,
|
||||
StorageClass S, StorageClass SCAsWritten,
|
||||
Expr *DefArg) {
|
||||
StorageClass S, Expr *DefArg) {
|
||||
return new (C) ParmVarDecl(ParmVar, DC, StartLoc, IdLoc, Id, T, TInfo,
|
||||
S, SCAsWritten, DefArg);
|
||||
S, DefArg);
|
||||
}
|
||||
|
||||
ParmVarDecl *ParmVarDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
|
||||
void *Mem = AllocateDeserializedDecl(C, ID, sizeof(ParmVarDecl));
|
||||
return new (Mem) ParmVarDecl(ParmVar, 0, SourceLocation(), SourceLocation(),
|
||||
0, QualType(), 0, SC_None, SC_None, 0);
|
||||
0, QualType(), 0, SC_None, 0);
|
||||
}
|
||||
|
||||
SourceRange ParmVarDecl::getSourceRange() const {
|
||||
|
@ -2067,7 +2061,7 @@ bool FunctionDecl::isGlobal() const {
|
|||
if (const CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(this))
|
||||
return Method->isStatic();
|
||||
|
||||
if (getStorageClass() == SC_Static)
|
||||
if (getCanonicalDecl()->getStorageClass() == SC_Static)
|
||||
return false;
|
||||
|
||||
for (const DeclContext *DC = getDeclContext();
|
||||
|
@ -2112,14 +2106,6 @@ FunctionDecl *FunctionDecl::getCanonicalDecl() {
|
|||
return getFirstDeclaration();
|
||||
}
|
||||
|
||||
void FunctionDecl::setStorageClass(StorageClass SC) {
|
||||
assert(isLegalForFunction(SC));
|
||||
if (getStorageClass() != SC)
|
||||
assert(isLinkageValid());
|
||||
|
||||
SClass = SC;
|
||||
}
|
||||
|
||||
/// \brief Returns a value indicating whether this function
|
||||
/// corresponds to a builtin function.
|
||||
///
|
||||
|
@ -2270,7 +2256,7 @@ bool FunctionDecl::doesDeclarationForceExternallyVisibleDefinition() const {
|
|||
//
|
||||
// FIXME: What happens if gnu_inline gets added on after the first
|
||||
// declaration?
|
||||
if (!isInlineSpecified() || getStorageClassAsWritten() == SC_Extern)
|
||||
if (!isInlineSpecified() || getStorageClass() == SC_Extern)
|
||||
return false;
|
||||
|
||||
const FunctionDecl *Prev = this;
|
||||
|
@ -2282,10 +2268,10 @@ bool FunctionDecl::doesDeclarationForceExternallyVisibleDefinition() const {
|
|||
// If it's not the case that both 'inline' and 'extern' are
|
||||
// specified on the definition, then it is always externally visible.
|
||||
if (!Prev->isInlineSpecified() ||
|
||||
Prev->getStorageClassAsWritten() != SC_Extern)
|
||||
Prev->getStorageClass() != SC_Extern)
|
||||
return false;
|
||||
} else if (Prev->isInlineSpecified() &&
|
||||
Prev->getStorageClassAsWritten() != SC_Extern) {
|
||||
Prev->getStorageClass() != SC_Extern) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
@ -2340,7 +2326,7 @@ bool FunctionDecl::isInlineDefinitionExternallyVisible() const {
|
|||
// If it's not the case that both 'inline' and 'extern' are
|
||||
// specified on the definition, then this inline definition is
|
||||
// externally visible.
|
||||
if (!(isInlineSpecified() && getStorageClassAsWritten() == SC_Extern))
|
||||
if (!(isInlineSpecified() && getStorageClass() == SC_Extern))
|
||||
return true;
|
||||
|
||||
// If any declaration is 'inline' but not 'extern', then this definition
|
||||
|
@ -2349,7 +2335,7 @@ bool FunctionDecl::isInlineDefinitionExternallyVisible() const {
|
|||
Redecl != RedeclEnd;
|
||||
++Redecl) {
|
||||
if (Redecl->isInlineSpecified() &&
|
||||
Redecl->getStorageClassAsWritten() != SC_Extern)
|
||||
Redecl->getStorageClass() != SC_Extern)
|
||||
return true;
|
||||
}
|
||||
|
||||
|
@ -3212,12 +3198,12 @@ FunctionDecl *FunctionDecl::Create(ASTContext &C, DeclContext *DC,
|
|||
SourceLocation StartLoc,
|
||||
const DeclarationNameInfo &NameInfo,
|
||||
QualType T, TypeSourceInfo *TInfo,
|
||||
StorageClass SC, StorageClass SCAsWritten,
|
||||
StorageClass SC,
|
||||
bool isInlineSpecified,
|
||||
bool hasWrittenPrototype,
|
||||
bool isConstexprSpecified) {
|
||||
FunctionDecl *New = new (C) FunctionDecl(Function, DC, StartLoc, NameInfo,
|
||||
T, TInfo, SC, SCAsWritten,
|
||||
T, TInfo, SC,
|
||||
isInlineSpecified,
|
||||
isConstexprSpecified);
|
||||
New->HasWrittenPrototype = hasWrittenPrototype;
|
||||
|
@ -3228,7 +3214,7 @@ FunctionDecl *FunctionDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
|
|||
void *Mem = AllocateDeserializedDecl(C, ID, sizeof(FunctionDecl));
|
||||
return new (Mem) FunctionDecl(Function, 0, SourceLocation(),
|
||||
DeclarationNameInfo(), QualType(), 0,
|
||||
SC_None, SC_None, false, false);
|
||||
SC_None, false, false);
|
||||
}
|
||||
|
||||
BlockDecl *BlockDecl::Create(ASTContext &C, DeclContext *DC, SourceLocation L) {
|
||||
|
|
|
@ -435,7 +435,7 @@ bool Decl::canBeWeakImported(bool &IsDefinition) const {
|
|||
|
||||
// Variables, if they aren't definitions.
|
||||
if (const VarDecl *Var = dyn_cast<VarDecl>(this)) {
|
||||
if (!Var->hasExternalStorage() || Var->getInit()) {
|
||||
if (Var->isThisDeclarationADefinition()) {
|
||||
IsDefinition = true;
|
||||
return false;
|
||||
}
|
||||
|
|
|
@ -1251,6 +1251,42 @@ bool CXXRecordDecl::mayBeAbstract() const {
|
|||
|
||||
void CXXMethodDecl::anchor() { }
|
||||
|
||||
bool CXXMethodDecl::isStatic() const {
|
||||
const CXXMethodDecl *MD = this;
|
||||
for (;;) {
|
||||
const CXXMethodDecl *C = MD->getCanonicalDecl();
|
||||
if (C != MD) {
|
||||
MD = C;
|
||||
continue;
|
||||
}
|
||||
|
||||
FunctionTemplateSpecializationInfo *Info =
|
||||
MD->getTemplateSpecializationInfo();
|
||||
if (!Info)
|
||||
break;
|
||||
MD = cast<CXXMethodDecl>(Info->getTemplate()->getTemplatedDecl());
|
||||
}
|
||||
|
||||
if (MD->getStorageClass() == SC_Static)
|
||||
return true;
|
||||
|
||||
DeclarationName Name = getDeclName();
|
||||
// [class.free]p1:
|
||||
// Any allocation function for a class T is a static member
|
||||
// (even if not explicitly declared static).
|
||||
if (Name.getCXXOverloadedOperator() == OO_New ||
|
||||
Name.getCXXOverloadedOperator() == OO_Array_New)
|
||||
return true;
|
||||
|
||||
// [class.free]p6 Any deallocation function for a class X is a static member
|
||||
// (even if not explicitly declared static).
|
||||
if (Name.getCXXOverloadedOperator() == OO_Delete ||
|
||||
Name.getCXXOverloadedOperator() == OO_Array_Delete)
|
||||
return true;
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
static bool recursivelyOverrides(const CXXMethodDecl *DerivedMD,
|
||||
const CXXMethodDecl *BaseMD) {
|
||||
for (CXXMethodDecl::method_iterator I = DerivedMD->begin_overridden_methods(),
|
||||
|
@ -1312,10 +1348,10 @@ CXXMethodDecl::Create(ASTContext &C, CXXRecordDecl *RD,
|
|||
SourceLocation StartLoc,
|
||||
const DeclarationNameInfo &NameInfo,
|
||||
QualType T, TypeSourceInfo *TInfo,
|
||||
bool isStatic, StorageClass SCAsWritten, bool isInline,
|
||||
StorageClass SC, bool isInline,
|
||||
bool isConstexpr, SourceLocation EndLocation) {
|
||||
return new (C) CXXMethodDecl(CXXMethod, RD, StartLoc, NameInfo, T, TInfo,
|
||||
isStatic, SCAsWritten, isInline, isConstexpr,
|
||||
SC, isInline, isConstexpr,
|
||||
EndLocation);
|
||||
}
|
||||
|
||||
|
@ -1323,7 +1359,7 @@ CXXMethodDecl *CXXMethodDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
|
|||
void *Mem = AllocateDeserializedDecl(C, ID, sizeof(CXXMethodDecl));
|
||||
return new (Mem) CXXMethodDecl(CXXMethod, 0, SourceLocation(),
|
||||
DeclarationNameInfo(), QualType(),
|
||||
0, false, SC_None, false, false,
|
||||
0, SC_None, false, false,
|
||||
SourceLocation());
|
||||
}
|
||||
|
||||
|
|
|
@ -393,7 +393,7 @@ void DeclPrinter::VisitEnumConstantDecl(EnumConstantDecl *D) {
|
|||
void DeclPrinter::VisitFunctionDecl(FunctionDecl *D) {
|
||||
CXXConstructorDecl *CDecl = dyn_cast<CXXConstructorDecl>(D);
|
||||
if (!Policy.SuppressSpecifiers) {
|
||||
switch (D->getStorageClassAsWritten()) {
|
||||
switch (D->getStorageClass()) {
|
||||
case SC_None: break;
|
||||
case SC_Extern: Out << "extern "; break;
|
||||
case SC_Static: Out << "static "; break;
|
||||
|
@ -641,9 +641,9 @@ void DeclPrinter::VisitLabelDecl(LabelDecl *D) {
|
|||
|
||||
|
||||
void DeclPrinter::VisitVarDecl(VarDecl *D) {
|
||||
StorageClass SCAsWritten = D->getStorageClassAsWritten();
|
||||
if (!Policy.SuppressSpecifiers && SCAsWritten != SC_None)
|
||||
Out << VarDecl::getStorageClassSpecifierString(SCAsWritten) << " ";
|
||||
StorageClass SC = D->getStorageClass();
|
||||
if (!Policy.SuppressSpecifiers && SC != SC_None)
|
||||
Out << VarDecl::getStorageClassSpecifierString(SC) << " ";
|
||||
|
||||
if (!Policy.SuppressSpecifiers && D->isThreadSpecified())
|
||||
Out << "__thread ";
|
||||
|
|
|
@ -1316,7 +1316,6 @@ CodeGenFunction::GenerateCopyHelperFunction(const CGBlockInfo &blockInfo) {
|
|||
SourceLocation(),
|
||||
SourceLocation(), II, C.VoidTy, 0,
|
||||
SC_Static,
|
||||
SC_None,
|
||||
false,
|
||||
false);
|
||||
StartFunction(FD, C.VoidTy, Fn, FI, args, SourceLocation());
|
||||
|
@ -1491,7 +1490,6 @@ CodeGenFunction::GenerateDestroyHelperFunction(const CGBlockInfo &blockInfo) {
|
|||
SourceLocation(),
|
||||
SourceLocation(), II, C.VoidTy, 0,
|
||||
SC_Static,
|
||||
SC_None,
|
||||
false, false);
|
||||
StartFunction(FD, C.VoidTy, Fn, FI, args, SourceLocation());
|
||||
|
||||
|
@ -1782,7 +1780,6 @@ generateByrefCopyHelper(CodeGenFunction &CGF,
|
|||
SourceLocation(),
|
||||
SourceLocation(), II, R, 0,
|
||||
SC_Static,
|
||||
SC_None,
|
||||
false, false);
|
||||
|
||||
// Initialize debug info if necessary.
|
||||
|
@ -1857,7 +1854,6 @@ generateByrefDisposeHelper(CodeGenFunction &CGF,
|
|||
SourceLocation(),
|
||||
SourceLocation(), II, R, 0,
|
||||
SC_Static,
|
||||
SC_None,
|
||||
false, false);
|
||||
// Initialize debug info if necessary.
|
||||
CGF.maybeInitializeDebugInfo();
|
||||
|
|
|
@ -109,7 +109,7 @@ void CodeGenFunction::EmitDecl(const Decl &D) {
|
|||
/// EmitVarDecl - This method handles emission of any variable declaration
|
||||
/// inside a function, including static vars etc.
|
||||
void CodeGenFunction::EmitVarDecl(const VarDecl &D) {
|
||||
switch (D.getStorageClassAsWritten()) {
|
||||
switch (D.getStorageClass()) {
|
||||
case SC_None:
|
||||
case SC_Auto:
|
||||
case SC_Register:
|
||||
|
|
|
@ -2848,7 +2848,6 @@ CodeGenFunction::GenerateObjCAtomicSetterCopyHelperFunction(
|
|||
SourceLocation(),
|
||||
SourceLocation(), II, C.VoidTy, 0,
|
||||
SC_Static,
|
||||
SC_None,
|
||||
false,
|
||||
false);
|
||||
|
||||
|
@ -2933,7 +2932,6 @@ CodeGenFunction::GenerateObjCAtomicGetterCopyHelperFunction(
|
|||
SourceLocation(),
|
||||
SourceLocation(), II, C.VoidTy, 0,
|
||||
SC_Static,
|
||||
SC_None,
|
||||
false,
|
||||
false);
|
||||
|
||||
|
|
|
@ -1602,7 +1602,7 @@ CodeGenModule::MaybeEmitGlobalStdInitializerListInitializer(const VarDecl *D,
|
|||
D->getDeclContext()),
|
||||
D->getLocStart(), D->getLocation(),
|
||||
name, arrayType, sourceInfo,
|
||||
SC_Static, SC_Static);
|
||||
SC_Static);
|
||||
|
||||
// Now clone the InitListExpr to initialize the array instead.
|
||||
// Incredible hack: we want to use the existing InitListExpr here, so we need
|
||||
|
|
|
@ -2365,7 +2365,7 @@ void RewriteModernObjC::SynthSelGetUidFunctionDecl() {
|
|||
SourceLocation(),
|
||||
SourceLocation(),
|
||||
SelGetUidIdent, getFuncType, 0,
|
||||
SC_Extern, SC_None);
|
||||
SC_Extern);
|
||||
}
|
||||
|
||||
void RewriteModernObjC::RewriteFunctionDecl(FunctionDecl *FD) {
|
||||
|
@ -2463,7 +2463,7 @@ void RewriteModernObjC::SynthSuperContructorFunctionDecl() {
|
|||
SourceLocation(),
|
||||
SourceLocation(),
|
||||
msgSendIdent, msgSendType,
|
||||
0, SC_Extern, SC_None);
|
||||
0, SC_Extern);
|
||||
}
|
||||
|
||||
// SynthMsgSendFunctionDecl - id objc_msgSend(id self, SEL op, ...);
|
||||
|
@ -2482,7 +2482,7 @@ void RewriteModernObjC::SynthMsgSendFunctionDecl() {
|
|||
SourceLocation(),
|
||||
SourceLocation(),
|
||||
msgSendIdent, msgSendType, 0,
|
||||
SC_Extern, SC_None);
|
||||
SC_Extern);
|
||||
}
|
||||
|
||||
// SynthMsgSendSuperFunctionDecl - id objc_msgSendSuper(void);
|
||||
|
@ -2496,7 +2496,7 @@ void RewriteModernObjC::SynthMsgSendSuperFunctionDecl() {
|
|||
SourceLocation(),
|
||||
SourceLocation(),
|
||||
msgSendIdent, msgSendType, 0,
|
||||
SC_Extern, SC_None);
|
||||
SC_Extern);
|
||||
}
|
||||
|
||||
// SynthMsgSendStretFunctionDecl - id objc_msgSend_stret(id self, SEL op, ...);
|
||||
|
@ -2515,7 +2515,7 @@ void RewriteModernObjC::SynthMsgSendStretFunctionDecl() {
|
|||
SourceLocation(),
|
||||
SourceLocation(),
|
||||
msgSendIdent, msgSendType, 0,
|
||||
SC_Extern, SC_None);
|
||||
SC_Extern);
|
||||
}
|
||||
|
||||
// SynthMsgSendSuperStretFunctionDecl -
|
||||
|
@ -2532,7 +2532,7 @@ void RewriteModernObjC::SynthMsgSendSuperStretFunctionDecl() {
|
|||
SourceLocation(),
|
||||
msgSendIdent,
|
||||
msgSendType, 0,
|
||||
SC_Extern, SC_None);
|
||||
SC_Extern);
|
||||
}
|
||||
|
||||
// SynthMsgSendFpretFunctionDecl - double objc_msgSend_fpret(id self, SEL op, ...);
|
||||
|
@ -2551,7 +2551,7 @@ void RewriteModernObjC::SynthMsgSendFpretFunctionDecl() {
|
|||
SourceLocation(),
|
||||
SourceLocation(),
|
||||
msgSendIdent, msgSendType, 0,
|
||||
SC_Extern, SC_None);
|
||||
SC_Extern);
|
||||
}
|
||||
|
||||
// SynthGetClassFunctionDecl - Class objc_getClass(const char *name);
|
||||
|
@ -2565,7 +2565,7 @@ void RewriteModernObjC::SynthGetClassFunctionDecl() {
|
|||
SourceLocation(),
|
||||
SourceLocation(),
|
||||
getClassIdent, getClassType, 0,
|
||||
SC_Extern, SC_None);
|
||||
SC_Extern);
|
||||
}
|
||||
|
||||
// SynthGetSuperClassFunctionDecl - Class class_getSuperclass(Class cls);
|
||||
|
@ -2581,7 +2581,7 @@ void RewriteModernObjC::SynthGetSuperClassFunctionDecl() {
|
|||
SourceLocation(),
|
||||
getSuperClassIdent,
|
||||
getClassType, 0,
|
||||
SC_Extern, SC_None);
|
||||
SC_Extern);
|
||||
}
|
||||
|
||||
// SynthGetMetaClassFunctionDecl - Class objc_getMetaClass(const char *name);
|
||||
|
@ -2595,7 +2595,7 @@ void RewriteModernObjC::SynthGetMetaClassFunctionDecl() {
|
|||
SourceLocation(),
|
||||
SourceLocation(),
|
||||
getClassIdent, getClassType,
|
||||
0, SC_Extern, SC_None);
|
||||
0, SC_Extern);
|
||||
}
|
||||
|
||||
Stmt *RewriteModernObjC::RewriteObjCStringLiteral(ObjCStringLiteral *Exp) {
|
||||
|
@ -2628,7 +2628,7 @@ Stmt *RewriteModernObjC::RewriteObjCStringLiteral(ObjCStringLiteral *Exp) {
|
|||
|
||||
VarDecl *NewVD = VarDecl::Create(*Context, TUDecl, SourceLocation(),
|
||||
SourceLocation(), &Context->Idents.get(S),
|
||||
strType, 0, SC_Static, SC_None);
|
||||
strType, 0, SC_Static);
|
||||
DeclRefExpr *DRE = new (Context) DeclRefExpr(NewVD, false, strType, VK_LValue,
|
||||
SourceLocation());
|
||||
Expr *Unop = new (Context) UnaryOperator(DRE, UO_AddrOf,
|
||||
|
@ -3139,7 +3139,7 @@ static SourceLocation getFunctionSourceLocation (RewriteModernObjC &R,
|
|||
if (!LSD->getRBraceLoc().isValid())
|
||||
return LSD->getExternLoc();
|
||||
}
|
||||
if (FD->getStorageClassAsWritten() != SC_None)
|
||||
if (FD->getStorageClass() != SC_None)
|
||||
R.RewriteBlockLiteralFunctionDecl(FD);
|
||||
return FD->getTypeSpecStartLoc();
|
||||
}
|
||||
|
@ -3250,7 +3250,7 @@ Expr *RewriteModernObjC::SynthMsgSendStretCallExpr(FunctionDecl *MsgSendStretFla
|
|||
IdentifierInfo *ID = &Context->Idents.get(name);
|
||||
FunctionDecl *FD = FunctionDecl::Create(*Context, TUDecl, SourceLocation(),
|
||||
SourceLocation(), ID, castType, 0,
|
||||
SC_Extern, SC_None, false, false);
|
||||
SC_Extern, false, false);
|
||||
DeclRefExpr *DRE = new (Context) DeclRefExpr(FD, false, castType, VK_RValue,
|
||||
SourceLocation());
|
||||
CallExpr *STCE = new (Context) CallExpr(*Context, DRE, MsgExprs,
|
||||
|
@ -3723,7 +3723,7 @@ Stmt *RewriteModernObjC::RewriteObjCProtocolExpr(ObjCProtocolExpr *Exp) {
|
|||
IdentifierInfo *ID = &Context->Idents.get(Name);
|
||||
VarDecl *VD = VarDecl::Create(*Context, TUDecl, SourceLocation(),
|
||||
SourceLocation(), ID, getProtocolType(), 0,
|
||||
SC_Extern, SC_None);
|
||||
SC_Extern);
|
||||
DeclRefExpr *DRE = new (Context) DeclRefExpr(VD, false, getProtocolType(),
|
||||
VK_LValue, SourceLocation());
|
||||
Expr *DerefExpr = new (Context) UnaryOperator(DRE, UO_AddrOf,
|
||||
|
@ -5403,7 +5403,7 @@ FunctionDecl *RewriteModernObjC::SynthBlockInitFunctionDecl(StringRef name) {
|
|||
QualType FType = Context->getFunctionNoProtoType(Context->VoidPtrTy);
|
||||
return FunctionDecl::Create(*Context, TUDecl, SourceLocation(),
|
||||
SourceLocation(), ID, FType, 0, SC_Extern,
|
||||
SC_None, false, false);
|
||||
false, false);
|
||||
}
|
||||
|
||||
Stmt *RewriteModernObjC::SynthBlockInitExpr(BlockExpr *Exp,
|
||||
|
@ -5504,7 +5504,7 @@ Stmt *RewriteModernObjC::SynthBlockInitExpr(BlockExpr *Exp,
|
|||
SourceLocation(), SourceLocation(),
|
||||
&Context->Idents.get(DescData.c_str()),
|
||||
Context->VoidPtrTy, 0,
|
||||
SC_Static, SC_None);
|
||||
SC_Static);
|
||||
UnaryOperator *DescRefExpr =
|
||||
new (Context) UnaryOperator(new (Context) DeclRefExpr(NewVD, false,
|
||||
Context->VoidPtrTy,
|
||||
|
@ -7768,7 +7768,7 @@ Stmt *RewriteModernObjC::RewriteObjCIvarRefExpr(ObjCIvarRefExpr *IV) {
|
|||
BaseExpr);
|
||||
VarDecl *NewVD = VarDecl::Create(*Context, TUDecl, SourceLocation(),
|
||||
SourceLocation(), &Context->Idents.get(IvarOffsetName),
|
||||
Context->UnsignedLongTy, 0, SC_Extern, SC_None);
|
||||
Context->UnsignedLongTy, 0, SC_Extern);
|
||||
DeclRefExpr *DRE = new (Context) DeclRefExpr(NewVD, false,
|
||||
Context->UnsignedLongTy, VK_LValue,
|
||||
SourceLocation());
|
||||
|
|
|
@ -2267,7 +2267,7 @@ void RewriteObjC::SynthSelGetUidFunctionDecl() {
|
|||
SourceLocation(),
|
||||
SourceLocation(),
|
||||
SelGetUidIdent, getFuncType, 0,
|
||||
SC_Extern, SC_None);
|
||||
SC_Extern);
|
||||
}
|
||||
|
||||
void RewriteObjC::RewriteFunctionDecl(FunctionDecl *FD) {
|
||||
|
@ -2363,7 +2363,7 @@ void RewriteObjC::SynthSuperContructorFunctionDecl() {
|
|||
SourceLocation(),
|
||||
SourceLocation(),
|
||||
msgSendIdent, msgSendType,
|
||||
0, SC_Extern, SC_None);
|
||||
0, SC_Extern);
|
||||
}
|
||||
|
||||
// SynthMsgSendFunctionDecl - id objc_msgSend(id self, SEL op, ...);
|
||||
|
@ -2382,7 +2382,7 @@ void RewriteObjC::SynthMsgSendFunctionDecl() {
|
|||
SourceLocation(),
|
||||
SourceLocation(),
|
||||
msgSendIdent, msgSendType, 0,
|
||||
SC_Extern, SC_None);
|
||||
SC_Extern);
|
||||
}
|
||||
|
||||
// SynthMsgSendSuperFunctionDecl - id objc_msgSendSuper(struct objc_super *, SEL op, ...);
|
||||
|
@ -2404,7 +2404,7 @@ void RewriteObjC::SynthMsgSendSuperFunctionDecl() {
|
|||
SourceLocation(),
|
||||
SourceLocation(),
|
||||
msgSendIdent, msgSendType, 0,
|
||||
SC_Extern, SC_None);
|
||||
SC_Extern);
|
||||
}
|
||||
|
||||
// SynthMsgSendStretFunctionDecl - id objc_msgSend_stret(id self, SEL op, ...);
|
||||
|
@ -2423,7 +2423,7 @@ void RewriteObjC::SynthMsgSendStretFunctionDecl() {
|
|||
SourceLocation(),
|
||||
SourceLocation(),
|
||||
msgSendIdent, msgSendType, 0,
|
||||
SC_Extern, SC_None);
|
||||
SC_Extern);
|
||||
}
|
||||
|
||||
// SynthMsgSendSuperStretFunctionDecl -
|
||||
|
@ -2448,7 +2448,7 @@ void RewriteObjC::SynthMsgSendSuperStretFunctionDecl() {
|
|||
SourceLocation(),
|
||||
msgSendIdent,
|
||||
msgSendType, 0,
|
||||
SC_Extern, SC_None);
|
||||
SC_Extern);
|
||||
}
|
||||
|
||||
// SynthMsgSendFpretFunctionDecl - double objc_msgSend_fpret(id self, SEL op, ...);
|
||||
|
@ -2467,7 +2467,7 @@ void RewriteObjC::SynthMsgSendFpretFunctionDecl() {
|
|||
SourceLocation(),
|
||||
SourceLocation(),
|
||||
msgSendIdent, msgSendType, 0,
|
||||
SC_Extern, SC_None);
|
||||
SC_Extern);
|
||||
}
|
||||
|
||||
// SynthGetClassFunctionDecl - id objc_getClass(const char *name);
|
||||
|
@ -2481,7 +2481,7 @@ void RewriteObjC::SynthGetClassFunctionDecl() {
|
|||
SourceLocation(),
|
||||
SourceLocation(),
|
||||
getClassIdent, getClassType, 0,
|
||||
SC_Extern, SC_None);
|
||||
SC_Extern);
|
||||
}
|
||||
|
||||
// SynthGetSuperClassFunctionDecl - Class class_getSuperclass(Class cls);
|
||||
|
@ -2497,7 +2497,7 @@ void RewriteObjC::SynthGetSuperClassFunctionDecl() {
|
|||
SourceLocation(),
|
||||
getSuperClassIdent,
|
||||
getClassType, 0,
|
||||
SC_Extern, SC_None);
|
||||
SC_Extern);
|
||||
}
|
||||
|
||||
// SynthGetMetaClassFunctionDecl - id objc_getMetaClass(const char *name);
|
||||
|
@ -2511,7 +2511,7 @@ void RewriteObjC::SynthGetMetaClassFunctionDecl() {
|
|||
SourceLocation(),
|
||||
SourceLocation(),
|
||||
getClassIdent, getClassType,
|
||||
0, SC_Extern, SC_None);
|
||||
0, SC_Extern);
|
||||
}
|
||||
|
||||
Stmt *RewriteObjC::RewriteObjCStringLiteral(ObjCStringLiteral *Exp) {
|
||||
|
@ -2544,7 +2544,7 @@ Stmt *RewriteObjC::RewriteObjCStringLiteral(ObjCStringLiteral *Exp) {
|
|||
|
||||
VarDecl *NewVD = VarDecl::Create(*Context, TUDecl, SourceLocation(),
|
||||
SourceLocation(), &Context->Idents.get(S),
|
||||
strType, 0, SC_Static, SC_None);
|
||||
strType, 0, SC_Static);
|
||||
DeclRefExpr *DRE = new (Context) DeclRefExpr(NewVD, false, strType, VK_LValue,
|
||||
SourceLocation());
|
||||
Expr *Unop = new (Context) UnaryOperator(DRE, UO_AddrOf,
|
||||
|
@ -3112,7 +3112,7 @@ Stmt *RewriteObjC::RewriteObjCProtocolExpr(ObjCProtocolExpr *Exp) {
|
|||
IdentifierInfo *ID = &Context->Idents.get(Name);
|
||||
VarDecl *VD = VarDecl::Create(*Context, TUDecl, SourceLocation(),
|
||||
SourceLocation(), ID, getProtocolType(), 0,
|
||||
SC_Extern, SC_None);
|
||||
SC_Extern);
|
||||
DeclRefExpr *DRE = new (Context) DeclRefExpr(VD, false, getProtocolType(),
|
||||
VK_LValue, SourceLocation());
|
||||
Expr *DerefExpr = new (Context) UnaryOperator(DRE, UO_AddrOf,
|
||||
|
@ -4448,7 +4448,7 @@ FunctionDecl *RewriteObjC::SynthBlockInitFunctionDecl(StringRef name) {
|
|||
QualType FType = Context->getFunctionNoProtoType(Context->VoidPtrTy);
|
||||
return FunctionDecl::Create(*Context, TUDecl, SourceLocation(),
|
||||
SourceLocation(), ID, FType, 0, SC_Extern,
|
||||
SC_None, false, false);
|
||||
false, false);
|
||||
}
|
||||
|
||||
Stmt *RewriteObjC::SynthBlockInitExpr(BlockExpr *Exp,
|
||||
|
@ -4532,7 +4532,7 @@ Stmt *RewriteObjC::SynthBlockInitExpr(BlockExpr *Exp,
|
|||
SourceLocation(), SourceLocation(),
|
||||
&Context->Idents.get(DescData.c_str()),
|
||||
Context->VoidPtrTy, 0,
|
||||
SC_Static, SC_None);
|
||||
SC_Static);
|
||||
UnaryOperator *DescRefExpr =
|
||||
new (Context) UnaryOperator(new (Context) DeclRefExpr(NewVD, false,
|
||||
Context->VoidPtrTy,
|
||||
|
|
|
@ -815,15 +815,6 @@ void DeclSpec::SaveWrittenBuiltinSpecs() {
|
|||
}
|
||||
}
|
||||
|
||||
void DeclSpec::SaveStorageSpecifierAsWritten() {
|
||||
if (SCS_extern_in_linkage_spec && StorageClassSpec == SCS_extern)
|
||||
// If 'extern' is part of a linkage specification,
|
||||
// then it is not a storage class "as written".
|
||||
StorageClassSpecAsWritten = SCS_unspecified;
|
||||
else
|
||||
StorageClassSpecAsWritten = StorageClassSpec;
|
||||
}
|
||||
|
||||
/// Finish - This does final analysis of the declspec, rejecting things like
|
||||
/// "_Imaginary" (lacking an FP type). This returns a diagnostic to issue or
|
||||
/// diag::NUM_DIAGNOSTICS if there is no error. After calling this method,
|
||||
|
@ -831,7 +822,6 @@ void DeclSpec::SaveStorageSpecifierAsWritten() {
|
|||
void DeclSpec::Finish(DiagnosticsEngine &D, Preprocessor &PP) {
|
||||
// Before possibly changing their values, save specs as written.
|
||||
SaveWrittenBuiltinSpecs();
|
||||
SaveStorageSpecifierAsWritten();
|
||||
|
||||
// Check the type specifier components first.
|
||||
|
||||
|
@ -941,7 +931,7 @@ void DeclSpec::Finish(DiagnosticsEngine &D, Preprocessor &PP) {
|
|||
if (PP.getLangOpts().CPlusPlus && !PP.getLangOpts().MicrosoftExt &&
|
||||
TypeSpecType == TST_unspecified && StorageClassSpec == SCS_auto) {
|
||||
TypeSpecType = TST_auto;
|
||||
StorageClassSpec = StorageClassSpecAsWritten = SCS_unspecified;
|
||||
StorageClassSpec = SCS_unspecified;
|
||||
TSTLoc = TSTNameLoc = StorageClassSpecLoc;
|
||||
StorageClassSpecLoc = SourceLocation();
|
||||
}
|
||||
|
|
|
@ -728,7 +728,7 @@ void Sema::ActOnEndOfTranslationUnit() {
|
|||
Diag(DiagD->getLocation(), diag::warn_unneeded_member_function)
|
||||
<< DiagD->getDeclName();
|
||||
else {
|
||||
if (FD->getStorageClassAsWritten() == SC_Static &&
|
||||
if (FD->getStorageClass() == SC_Static &&
|
||||
!FD->isInlineSpecified() &&
|
||||
!SourceMgr.isFromMainFile(
|
||||
SourceMgr.getExpansionLoc(FD->getLocation())))
|
||||
|
|
|
@ -3349,7 +3349,7 @@ void Sema::CodeCompleteDeclSpec(Scope *S, DeclSpec &DS,
|
|||
// the initial opening bracket '[' missing. Add appropriate completions.
|
||||
if (AllowNonIdentifiers && !AllowNestedNameSpecifiers &&
|
||||
DS.getTypeSpecType() == DeclSpec::TST_typename &&
|
||||
DS.getStorageClassSpecAsWritten() == DeclSpec::SCS_unspecified &&
|
||||
DS.getStorageClassSpec() == DeclSpec::SCS_unspecified &&
|
||||
!DS.isThreadSpecified() && !DS.isExternInLinkageSpec() &&
|
||||
DS.getTypeSpecComplex() == DeclSpec::TSC_unspecified &&
|
||||
DS.getTypeSpecSign() == DeclSpec::TSS_unspecified &&
|
||||
|
|
|
@ -1557,7 +1557,7 @@ NamedDecl *Sema::LazilyCreateBuiltin(IdentifierInfo *II, unsigned bid,
|
|||
Context.getTranslationUnitDecl(),
|
||||
Loc, Loc, II, R, /*TInfo=*/0,
|
||||
SC_Extern,
|
||||
SC_None, false,
|
||||
false,
|
||||
/*hasPrototype=*/true);
|
||||
New->setImplicit();
|
||||
|
||||
|
@ -1570,7 +1570,7 @@ NamedDecl *Sema::LazilyCreateBuiltin(IdentifierInfo *II, unsigned bid,
|
|||
ParmVarDecl::Create(Context, New, SourceLocation(),
|
||||
SourceLocation(), 0,
|
||||
FT->getArgType(i), /*TInfo=*/0,
|
||||
SC_None, SC_None, 0);
|
||||
SC_None, 0);
|
||||
parm->setScopeInfo(0, i);
|
||||
Params.push_back(parm);
|
||||
}
|
||||
|
@ -2306,9 +2306,12 @@ bool Sema::MergeFunctionDecl(FunctionDecl *New, Decl *OldD, Scope *S) {
|
|||
|
||||
// Don't complain about this if we're in GNU89 mode and the old function
|
||||
// is an extern inline function.
|
||||
// Don't complain about specializations. They are not supposed to have
|
||||
// storage classes.
|
||||
if (!isa<CXXMethodDecl>(New) && !isa<CXXMethodDecl>(Old) &&
|
||||
New->getStorageClass() == SC_Static &&
|
||||
Old->getStorageClass() != SC_Static &&
|
||||
!New->getTemplateSpecializationInfo() &&
|
||||
!canRedefineFunction(Old, getLangOpts())) {
|
||||
if (getLangOpts().MicrosoftExt) {
|
||||
Diag(New->getLocation(), diag::warn_static_non_static) << New;
|
||||
|
@ -2600,7 +2603,7 @@ bool Sema::MergeFunctionDecl(FunctionDecl *New, Decl *OldD, Scope *S) {
|
|||
SourceLocation(),
|
||||
SourceLocation(), 0,
|
||||
*ParamType, /*TInfo=*/0,
|
||||
SC_None, SC_None,
|
||||
SC_None,
|
||||
0);
|
||||
Param->setScopeInfo(0, Params.size());
|
||||
Param->setImplicit();
|
||||
|
@ -2716,11 +2719,6 @@ bool Sema::MergeCompatibleFunctionDecls(FunctionDecl *New, FunctionDecl *Old,
|
|||
// Merge the attributes
|
||||
mergeDeclAttributes(New, Old);
|
||||
|
||||
// Merge the storage class.
|
||||
if (Old->getStorageClass() != SC_Extern &&
|
||||
Old->getStorageClass() != SC_None)
|
||||
New->setStorageClass(Old->getStorageClass());
|
||||
|
||||
// Merge "pure" flag.
|
||||
if (Old->isPure())
|
||||
New->setPure();
|
||||
|
@ -2898,8 +2896,8 @@ void Sema::MergeVarDecl(VarDecl *New, LookupResult &Previous,
|
|||
// identifier has external linkage.
|
||||
if (New->hasExternalStorage() && Old->hasLinkage())
|
||||
/* Okay */;
|
||||
else if (New->getStorageClass() != SC_Static &&
|
||||
Old->getStorageClass() == SC_Static) {
|
||||
else if (New->getCanonicalDecl()->getStorageClass() != SC_Static &&
|
||||
Old->getCanonicalDecl()->getStorageClass() == SC_Static) {
|
||||
Diag(New->getLocation(), diag::err_non_static_static) << New->getDeclName();
|
||||
Diag(Old->getLocation(), diag::note_previous_definition);
|
||||
return New->setInvalidDecl();
|
||||
|
@ -2959,17 +2957,6 @@ void Sema::MergeVarDecl(VarDecl *New, LookupResult &Previous,
|
|||
return;
|
||||
}
|
||||
|
||||
// c99 6.2.2 P4.
|
||||
// For an identifier declared with the storage-class specifier extern in a
|
||||
// scope in which a prior declaration of that identifier is visible, if
|
||||
// the prior declaration specifies internal or external linkage, the linkage
|
||||
// of the identifier at the later declaration is the same as the linkage
|
||||
// specified at the prior declaration.
|
||||
// FIXME. revisit this code.
|
||||
if (New->hasExternalStorage() &&
|
||||
Old->getLinkage() == InternalLinkage)
|
||||
New->setStorageClass(Old->getStorageClass());
|
||||
|
||||
// Merge "used" flag.
|
||||
if (Old->isUsed(false))
|
||||
New->setUsed();
|
||||
|
@ -3341,25 +3328,6 @@ StorageClassSpecToVarDeclStorageClass(DeclSpec::SCS StorageClassSpec) {
|
|||
llvm_unreachable("unknown storage class specifier");
|
||||
}
|
||||
|
||||
/// StorageClassSpecToFunctionDeclStorageClass - Maps a DeclSpec::SCS to
|
||||
/// a StorageClass. Any error reporting is up to the caller:
|
||||
/// illegal input values are mapped to SC_None.
|
||||
static StorageClass
|
||||
StorageClassSpecToFunctionDeclStorageClass(DeclSpec::SCS StorageClassSpec) {
|
||||
switch (StorageClassSpec) {
|
||||
case DeclSpec::SCS_unspecified: return SC_None;
|
||||
case DeclSpec::SCS_extern: return SC_Extern;
|
||||
case DeclSpec::SCS_static: return SC_Static;
|
||||
case DeclSpec::SCS_private_extern: return SC_PrivateExtern;
|
||||
// Illegal SCSs map to None: error reporting is up to the caller.
|
||||
case DeclSpec::SCS_auto: // Fall through.
|
||||
case DeclSpec::SCS_mutable: // Fall through.
|
||||
case DeclSpec::SCS_register: // Fall through.
|
||||
case DeclSpec::SCS_typedef: return SC_None;
|
||||
}
|
||||
llvm_unreachable("unknown storage class specifier");
|
||||
}
|
||||
|
||||
/// BuildAnonymousStructOrUnion - Handle the declaration of an
|
||||
/// anonymous structure or union. Anonymous unions are a C++ feature
|
||||
/// (C++ [class.union]) and a C11 feature; anonymous structures
|
||||
|
@ -3556,15 +3524,12 @@ Decl *Sema::BuildAnonymousStructOrUnion(Scope *S, DeclSpec &DS,
|
|||
Invalid = true;
|
||||
SC = SC_None;
|
||||
}
|
||||
SCSpec = DS.getStorageClassSpecAsWritten();
|
||||
VarDecl::StorageClass SCAsWritten
|
||||
= StorageClassSpecToVarDeclStorageClass(SCSpec);
|
||||
|
||||
Anon = VarDecl::Create(Context, Owner,
|
||||
DS.getLocStart(),
|
||||
Record->getLocation(), /*IdentifierInfo=*/0,
|
||||
Context.getTypeDeclType(Record),
|
||||
TInfo, SC, SCAsWritten);
|
||||
TInfo, SC);
|
||||
|
||||
// Default-initialize the implicit variable. This initialization will be
|
||||
// trivial in almost all cases, except if a union member has an in-class
|
||||
|
@ -4679,7 +4644,7 @@ static bool isFunctionDefinitionDiscarded(Sema &S, FunctionDecl *FD) {
|
|||
static bool shouldConsiderLinkage(const VarDecl *VD) {
|
||||
const DeclContext *DC = VD->getDeclContext()->getRedeclContext();
|
||||
if (DC->isFunctionOrMethod())
|
||||
return VD->hasExternalStorageAsWritten();
|
||||
return VD->hasExternalStorage();
|
||||
if (DC->isFileContext())
|
||||
return true;
|
||||
if (DC->isRecord())
|
||||
|
@ -4726,10 +4691,6 @@ Sema::ActOnVariableDeclarator(Scope *S, Declarator &D, DeclContext *DC,
|
|||
SC = SC_None;
|
||||
}
|
||||
|
||||
SCSpec = D.getDeclSpec().getStorageClassSpecAsWritten();
|
||||
VarDecl::StorageClass SCAsWritten
|
||||
= StorageClassSpecToVarDeclStorageClass(SCSpec);
|
||||
|
||||
IdentifierInfo *II = Name.getAsIdentifierInfo();
|
||||
if (!II) {
|
||||
Diag(D.getIdentifierLoc(), diag::err_bad_variable_name)
|
||||
|
@ -4759,7 +4720,6 @@ Sema::ActOnVariableDeclarator(Scope *S, Declarator &D, DeclContext *DC,
|
|||
// OpenCL __local address space.
|
||||
if (R.getAddressSpace() == LangAS::opencl_local) {
|
||||
SC = SC_OpenCLWorkGroupLocal;
|
||||
SCAsWritten = SC_OpenCLWorkGroupLocal;
|
||||
}
|
||||
|
||||
// OpenCL v1.2 s6.9.b p4:
|
||||
|
@ -4792,7 +4752,7 @@ Sema::ActOnVariableDeclarator(Scope *S, Declarator &D, DeclContext *DC,
|
|||
if (!getLangOpts().CPlusPlus) {
|
||||
NewVD = VarDecl::Create(Context, DC, D.getLocStart(),
|
||||
D.getIdentifierLoc(), II,
|
||||
R, TInfo, SC, SCAsWritten);
|
||||
R, TInfo, SC);
|
||||
|
||||
if (D.isInvalidType())
|
||||
NewVD->setInvalidDecl();
|
||||
|
@ -4862,7 +4822,7 @@ Sema::ActOnVariableDeclarator(Scope *S, Declarator &D, DeclContext *DC,
|
|||
|
||||
NewVD = VarDecl::Create(Context, DC, D.getLocStart(),
|
||||
D.getIdentifierLoc(), II,
|
||||
R, TInfo, SC, SCAsWritten);
|
||||
R, TInfo, SC);
|
||||
|
||||
// If this decl has an auto type in need of deduction, make a note of the
|
||||
// Decl so we can diagnose uses of it in its own initializer.
|
||||
|
@ -4944,7 +4904,6 @@ Sema::ActOnVariableDeclarator(Scope *S, Declarator &D, DeclContext *DC,
|
|||
(NewVD->hasAttr<CUDASharedAttr>() ||
|
||||
NewVD->hasAttr<CUDAConstantAttr>())) {
|
||||
NewVD->setStorageClass(SC_Static);
|
||||
NewVD->setStorageClassAsWritten(SC_Static);
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -5684,9 +5643,6 @@ static FunctionDecl* CreateNewFunctionDecl(Sema &SemaRef, Declarator &D,
|
|||
|
||||
FunctionDecl *NewFD = 0;
|
||||
bool isInline = D.getDeclSpec().isInlineSpecified();
|
||||
DeclSpec::SCS SCSpec = D.getDeclSpec().getStorageClassSpecAsWritten();
|
||||
FunctionDecl::StorageClass SCAsWritten
|
||||
= StorageClassSpecToFunctionDeclStorageClass(SCSpec);
|
||||
|
||||
if (!SemaRef.getLangOpts().CPlusPlus) {
|
||||
// Determine whether the function was written with a
|
||||
|
@ -5700,8 +5656,8 @@ static FunctionDecl* CreateNewFunctionDecl(Sema &SemaRef, Declarator &D,
|
|||
|
||||
NewFD = FunctionDecl::Create(SemaRef.Context, DC,
|
||||
D.getLocStart(), NameInfo, R,
|
||||
TInfo, SC, SCAsWritten, isInline,
|
||||
HasPrototype);
|
||||
TInfo, SC, isInline,
|
||||
HasPrototype, false);
|
||||
if (D.isInvalidType())
|
||||
NewFD->setInvalidDecl();
|
||||
|
||||
|
@ -5768,7 +5724,7 @@ static FunctionDecl* CreateNewFunctionDecl(Sema &SemaRef, Declarator &D,
|
|||
return FunctionDecl::Create(SemaRef.Context, DC,
|
||||
D.getLocStart(),
|
||||
D.getIdentifierLoc(), Name, R, TInfo,
|
||||
SC, SCAsWritten, isInline,
|
||||
SC, isInline,
|
||||
/*hasPrototype=*/true, isConstexpr);
|
||||
}
|
||||
|
||||
|
@ -5799,36 +5755,21 @@ static FunctionDecl* CreateNewFunctionDecl(Sema &SemaRef, Declarator &D,
|
|||
return 0;
|
||||
}
|
||||
|
||||
bool isStatic = SC == SC_Static;
|
||||
|
||||
// [class.free]p1:
|
||||
// Any allocation function for a class T is a static member
|
||||
// (even if not explicitly declared static).
|
||||
if (Name.getCXXOverloadedOperator() == OO_New ||
|
||||
Name.getCXXOverloadedOperator() == OO_Array_New)
|
||||
isStatic = true;
|
||||
|
||||
// [class.free]p6 Any deallocation function for a class X is a static member
|
||||
// (even if not explicitly declared static).
|
||||
if (Name.getCXXOverloadedOperator() == OO_Delete ||
|
||||
Name.getCXXOverloadedOperator() == OO_Array_Delete)
|
||||
isStatic = true;
|
||||
|
||||
IsVirtualOkay = !isStatic;
|
||||
|
||||
// This is a C++ method declaration.
|
||||
return CXXMethodDecl::Create(SemaRef.Context, cast<CXXRecordDecl>(DC),
|
||||
D.getLocStart(), NameInfo, R,
|
||||
TInfo, isStatic, SCAsWritten, isInline,
|
||||
isConstexpr, SourceLocation());
|
||||
|
||||
CXXMethodDecl *Ret = CXXMethodDecl::Create(SemaRef.Context,
|
||||
cast<CXXRecordDecl>(DC),
|
||||
D.getLocStart(), NameInfo, R,
|
||||
TInfo, SC, isInline,
|
||||
isConstexpr, SourceLocation());
|
||||
IsVirtualOkay = !Ret->isStatic();
|
||||
return Ret;
|
||||
} else {
|
||||
// Determine whether the function was written with a
|
||||
// prototype. This true when:
|
||||
// - we're in C++ (where every function has a prototype),
|
||||
return FunctionDecl::Create(SemaRef.Context, DC,
|
||||
D.getLocStart(),
|
||||
NameInfo, R, TInfo, SC, SCAsWritten, isInline,
|
||||
NameInfo, R, TInfo, SC, isInline,
|
||||
true/*HasPrototype*/, isConstexpr);
|
||||
}
|
||||
}
|
||||
|
@ -6394,7 +6335,7 @@ Sema::ActOnFunctionDeclarator(Scope *S, Declarator &D, DeclContext *DC,
|
|||
// A storage-class-specifier shall not be specified in an explicit
|
||||
// specialization (14.7.3)
|
||||
if (SC != SC_None) {
|
||||
if (SC != NewFD->getStorageClass())
|
||||
if (SC != NewFD->getTemplateSpecializationInfo()->getTemplate()->getTemplatedDecl()->getStorageClass())
|
||||
Diag(NewFD->getLocation(),
|
||||
diag::err_explicit_specialization_inconsistent_storage_class)
|
||||
<< SC
|
||||
|
@ -7647,7 +7588,7 @@ void Sema::AddInitializerToDecl(Decl *RealDecl, Expr *Init,
|
|||
VDecl->setInvalidDecl();
|
||||
}
|
||||
} else if (VDecl->isFileVarDecl()) {
|
||||
if (VDecl->getStorageClassAsWritten() == SC_Extern &&
|
||||
if (VDecl->getStorageClass() == SC_Extern &&
|
||||
(!getLangOpts().CPlusPlus ||
|
||||
!(Context.getBaseElementType(VDecl->getType()).isConstQualified() ||
|
||||
VDecl->isExternC())))
|
||||
|
@ -7937,7 +7878,7 @@ void Sema::ActOnCXXForRangeDecl(Decl *D) {
|
|||
|
||||
// for-range-declaration cannot be given a storage class specifier.
|
||||
int Error = -1;
|
||||
switch (VD->getStorageClassAsWritten()) {
|
||||
switch (VD->getStorageClass()) {
|
||||
case SC_None:
|
||||
break;
|
||||
case SC_Extern:
|
||||
|
@ -8251,14 +8192,11 @@ Decl *Sema::ActOnParamDeclarator(Scope *S, Declarator &D) {
|
|||
// Verify C99 6.7.5.3p2: The only SCS allowed is 'register'.
|
||||
// C++03 [dcl.stc]p2 also permits 'auto'.
|
||||
VarDecl::StorageClass StorageClass = SC_None;
|
||||
VarDecl::StorageClass StorageClassAsWritten = SC_None;
|
||||
if (DS.getStorageClassSpec() == DeclSpec::SCS_register) {
|
||||
StorageClass = SC_Register;
|
||||
StorageClassAsWritten = SC_Register;
|
||||
} else if (getLangOpts().CPlusPlus &&
|
||||
DS.getStorageClassSpec() == DeclSpec::SCS_auto) {
|
||||
StorageClass = SC_Auto;
|
||||
StorageClassAsWritten = SC_Auto;
|
||||
} else if (DS.getStorageClassSpec() != DeclSpec::SCS_unspecified) {
|
||||
Diag(DS.getStorageClassSpecLoc(),
|
||||
diag::err_invalid_storage_class_in_func_decl);
|
||||
|
@ -8331,7 +8269,7 @@ Decl *Sema::ActOnParamDeclarator(Scope *S, Declarator &D) {
|
|||
D.getLocStart(),
|
||||
D.getIdentifierLoc(), II,
|
||||
parmDeclType, TInfo,
|
||||
StorageClass, StorageClassAsWritten);
|
||||
StorageClass);
|
||||
|
||||
if (D.isInvalidType())
|
||||
New->setInvalidDecl();
|
||||
|
@ -8370,7 +8308,7 @@ ParmVarDecl *Sema::BuildParmVarDeclForTypedef(DeclContext *DC,
|
|||
location for the unnamed parameters, embedding the parameter's type? */
|
||||
ParmVarDecl *Param = ParmVarDecl::Create(Context, DC, Loc, Loc, 0,
|
||||
T, Context.getTrivialTypeSourceInfo(T, Loc),
|
||||
SC_None, SC_None, 0);
|
||||
SC_None, 0);
|
||||
Param->setImplicit();
|
||||
return Param;
|
||||
}
|
||||
|
@ -8423,8 +8361,7 @@ void Sema::DiagnoseSizeOfParametersAndReturnValue(ParmVarDecl * const *Param,
|
|||
ParmVarDecl *Sema::CheckParameter(DeclContext *DC, SourceLocation StartLoc,
|
||||
SourceLocation NameLoc, IdentifierInfo *Name,
|
||||
QualType T, TypeSourceInfo *TSInfo,
|
||||
VarDecl::StorageClass StorageClass,
|
||||
VarDecl::StorageClass StorageClassAsWritten) {
|
||||
VarDecl::StorageClass StorageClass) {
|
||||
// In ARC, infer a lifetime qualifier for appropriate parameter types.
|
||||
if (getLangOpts().ObjCAutoRefCount &&
|
||||
T.getObjCLifetime() == Qualifiers::OCL_None &&
|
||||
|
@ -8451,8 +8388,7 @@ ParmVarDecl *Sema::CheckParameter(DeclContext *DC, SourceLocation StartLoc,
|
|||
ParmVarDecl *New = ParmVarDecl::Create(Context, DC, StartLoc, NameLoc, Name,
|
||||
Context.getAdjustedParameterType(T),
|
||||
TSInfo,
|
||||
StorageClass, StorageClassAsWritten,
|
||||
0);
|
||||
StorageClass, 0);
|
||||
|
||||
// Parameters can not be abstract class types.
|
||||
// For record types, this is done by the AbstractClassUsageDiagnoser once
|
||||
|
|
|
@ -5092,8 +5092,7 @@ NamedDecl * Sema::DeclClonePragmaWeak(NamedDecl *ND, IdentifierInfo *II,
|
|||
NewFD = FunctionDecl::Create(FD->getASTContext(), FD->getDeclContext(),
|
||||
Loc, Loc, DeclarationName(II),
|
||||
FD->getType(), FD->getTypeSourceInfo(),
|
||||
SC_None, SC_None,
|
||||
false/*isInlineSpecified*/,
|
||||
SC_None, false/*isInlineSpecified*/,
|
||||
FD->hasPrototype(),
|
||||
false/*isConstexprSpecified*/);
|
||||
NewD = NewFD;
|
||||
|
@ -5118,8 +5117,7 @@ NamedDecl * Sema::DeclClonePragmaWeak(NamedDecl *ND, IdentifierInfo *II,
|
|||
NewD = VarDecl::Create(VD->getASTContext(), VD->getDeclContext(),
|
||||
VD->getInnerLocStart(), VD->getLocation(), II,
|
||||
VD->getType(), VD->getTypeSourceInfo(),
|
||||
VD->getStorageClass(),
|
||||
VD->getStorageClassAsWritten());
|
||||
VD->getStorageClass());
|
||||
if (VD->getQualifier()) {
|
||||
VarDecl *NewVD = cast<VarDecl>(NewD);
|
||||
NewVD->setQualifierInfo(VD->getQualifierLoc());
|
||||
|
|
|
@ -2852,7 +2852,7 @@ BuildImplicitMemberInitializer(Sema &SemaRef, CXXConstructorDecl *Constructor,
|
|||
= VarDecl::Create(SemaRef.Context, SemaRef.CurContext, Loc, Loc,
|
||||
IterationVarName, SizeType,
|
||||
SemaRef.Context.getTrivialTypeSourceInfo(SizeType, Loc),
|
||||
SC_None, SC_None);
|
||||
SC_None);
|
||||
IndexVariables.push_back(IterationVar);
|
||||
|
||||
// Create a reference to the iteration variable.
|
||||
|
@ -7822,7 +7822,7 @@ void Sema::DeclareInheritingConstructors(CXXRecordDecl *ClassDecl) {
|
|||
/*IdentifierInfo=*/0,
|
||||
BaseCtorType->getArgType(i),
|
||||
/*TInfo=*/0, SC_None,
|
||||
SC_None, /*DefaultArg=*/0);
|
||||
/*DefaultArg=*/0);
|
||||
PD->setScopeInfo(0, i);
|
||||
PD->setImplicit();
|
||||
ParamDecls.push_back(PD);
|
||||
|
@ -8275,7 +8275,7 @@ buildSingleCopyAssignRecursively(Sema &S, SourceLocation Loc, QualType T,
|
|||
VarDecl *IterationVar = VarDecl::Create(S.Context, S.CurContext, Loc, Loc,
|
||||
IterationVarName, SizeType,
|
||||
S.Context.getTrivialTypeSourceInfo(SizeType, Loc),
|
||||
SC_None, SC_None);
|
||||
SC_None);
|
||||
|
||||
// Initialize the iteration variable to zero.
|
||||
llvm::APInt Zero(S.Context.getTypeSize(SizeType), 0);
|
||||
|
@ -8439,8 +8439,8 @@ CXXMethodDecl *Sema::DeclareImplicitCopyAssignment(CXXRecordDecl *ClassDecl) {
|
|||
DeclarationNameInfo NameInfo(Name, ClassLoc);
|
||||
CXXMethodDecl *CopyAssignment
|
||||
= CXXMethodDecl::Create(Context, ClassDecl, ClassLoc, NameInfo, QualType(),
|
||||
/*TInfo=*/0, /*isStatic=*/false,
|
||||
/*StorageClassAsWritten=*/SC_None,
|
||||
/*TInfo=*/0,
|
||||
/*StorageClass=*/SC_None,
|
||||
/*isInline=*/true, /*isConstexpr=*/false,
|
||||
SourceLocation());
|
||||
CopyAssignment->setAccess(AS_public);
|
||||
|
@ -8457,7 +8457,6 @@ CXXMethodDecl *Sema::DeclareImplicitCopyAssignment(CXXRecordDecl *ClassDecl) {
|
|||
ParmVarDecl *FromParam = ParmVarDecl::Create(Context, CopyAssignment,
|
||||
ClassLoc, ClassLoc, /*Id=*/0,
|
||||
ArgType, /*TInfo=*/0,
|
||||
SC_None,
|
||||
SC_None, 0);
|
||||
CopyAssignment->setParams(FromParam);
|
||||
|
||||
|
@ -8888,8 +8887,8 @@ CXXMethodDecl *Sema::DeclareImplicitMoveAssignment(CXXRecordDecl *ClassDecl) {
|
|||
DeclarationNameInfo NameInfo(Name, ClassLoc);
|
||||
CXXMethodDecl *MoveAssignment
|
||||
= CXXMethodDecl::Create(Context, ClassDecl, ClassLoc, NameInfo, QualType(),
|
||||
/*TInfo=*/0, /*isStatic=*/false,
|
||||
/*StorageClassAsWritten=*/SC_None,
|
||||
/*TInfo=*/0,
|
||||
/*StorageClass=*/SC_None,
|
||||
/*isInline=*/true,
|
||||
/*isConstexpr=*/false,
|
||||
SourceLocation());
|
||||
|
@ -8907,7 +8906,6 @@ CXXMethodDecl *Sema::DeclareImplicitMoveAssignment(CXXRecordDecl *ClassDecl) {
|
|||
ParmVarDecl *FromParam = ParmVarDecl::Create(Context, MoveAssignment,
|
||||
ClassLoc, ClassLoc, /*Id=*/0,
|
||||
ArgType, /*TInfo=*/0,
|
||||
SC_None,
|
||||
SC_None, 0);
|
||||
MoveAssignment->setParams(FromParam);
|
||||
|
||||
|
@ -9262,7 +9260,6 @@ CXXConstructorDecl *Sema::DeclareImplicitCopyConstructor(
|
|||
ClassLoc, ClassLoc,
|
||||
/*IdentifierInfo=*/0,
|
||||
ArgType, /*TInfo=*/0,
|
||||
SC_None,
|
||||
SC_None, 0);
|
||||
CopyConstructor->setParams(FromParam);
|
||||
|
||||
|
@ -9449,7 +9446,6 @@ CXXConstructorDecl *Sema::DeclareImplicitMoveConstructor(
|
|||
ClassLoc, ClassLoc,
|
||||
/*IdentifierInfo=*/0,
|
||||
ArgType, /*TInfo=*/0,
|
||||
SC_None,
|
||||
SC_None, 0);
|
||||
MoveConstructor->setParams(FromParam);
|
||||
|
||||
|
@ -10281,7 +10277,7 @@ VarDecl *Sema::BuildExceptionDeclaration(Scope *S,
|
|||
}
|
||||
|
||||
VarDecl *ExDecl = VarDecl::Create(Context, CurContext, StartLoc, Loc, Name,
|
||||
ExDeclType, TInfo, SC_None, SC_None);
|
||||
ExDeclType, TInfo, SC_None);
|
||||
ExDecl->setExceptionVariable(true);
|
||||
|
||||
// In ARC, infer 'retaining' for variables of retainable type.
|
||||
|
|
|
@ -2930,7 +2930,7 @@ Decl *Sema::ActOnMethodDeclaration(
|
|||
|
||||
ParmVarDecl* Param = CheckParameter(ObjCMethod, StartLoc,
|
||||
ArgInfo[i].NameLoc, ArgInfo[i].Name,
|
||||
ArgType, DI, SC_None, SC_None);
|
||||
ArgType, DI, SC_None);
|
||||
|
||||
Param->setObjCMethodScopeInfo(i);
|
||||
|
||||
|
@ -3161,7 +3161,7 @@ VarDecl *Sema::BuildObjCExceptionDecl(TypeSourceInfo *TInfo, QualType T,
|
|||
}
|
||||
|
||||
VarDecl *New = VarDecl::Create(Context, CurContext, StartLoc, IdLoc, Id,
|
||||
T, TInfo, SC_None, SC_None);
|
||||
T, TInfo, SC_None);
|
||||
New->setExceptionVariable(true);
|
||||
|
||||
// In ARC, infer 'retaining' for variables of retainable type.
|
||||
|
|
|
@ -162,7 +162,7 @@ static bool hasAnyExplicitStorageClass(const FunctionDecl *D) {
|
|||
for (FunctionDecl::redecl_iterator I = D->redecls_begin(),
|
||||
E = D->redecls_end();
|
||||
I != E; ++I) {
|
||||
if (I->getStorageClassAsWritten() != SC_None)
|
||||
if (I->getStorageClass() != SC_None)
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
|
@ -10854,7 +10854,7 @@ static ExprResult captureInLambda(Sema &S, LambdaScopeInfo *LSI,
|
|||
= VarDecl::Create(S.Context, S.CurContext, Loc, Loc,
|
||||
IterationVarName, SizeType,
|
||||
S.Context.getTrivialTypeSourceInfo(SizeType, Loc),
|
||||
SC_None, SC_None);
|
||||
SC_None);
|
||||
IndexVariables.push_back(IterationVar);
|
||||
LSI->ArrayIndexVars.push_back(IterationVar);
|
||||
|
||||
|
|
|
@ -1946,8 +1946,7 @@ void Sema::DeclareGlobalAllocationFunction(DeclarationName Name,
|
|||
FunctionDecl *Alloc =
|
||||
FunctionDecl::Create(Context, GlobalCtx, SourceLocation(),
|
||||
SourceLocation(), Name,
|
||||
FnType, /*TInfo=*/0, SC_None,
|
||||
SC_None, false, true);
|
||||
FnType, /*TInfo=*/0, SC_None, false, true);
|
||||
Alloc->setImplicit();
|
||||
|
||||
if (AddMallocAttr)
|
||||
|
@ -1956,7 +1955,7 @@ void Sema::DeclareGlobalAllocationFunction(DeclarationName Name,
|
|||
ParmVarDecl *Param = ParmVarDecl::Create(Context, Alloc, SourceLocation(),
|
||||
SourceLocation(), 0,
|
||||
Argument, /*TInfo=*/0,
|
||||
SC_None, SC_None, 0);
|
||||
SC_None, 0);
|
||||
Alloc->setParams(Param);
|
||||
|
||||
// FIXME: Also add this declaration to the IdentifierResolver, but
|
||||
|
|
|
@ -238,7 +238,7 @@ static ObjCMethodDecl *getNSNumberFactoryMethod(Sema &S, SourceLocation Loc,
|
|||
SourceLocation(), SourceLocation(),
|
||||
&CX.Idents.get("value"),
|
||||
NumberType, /*TInfo=*/0, SC_None,
|
||||
SC_None, 0);
|
||||
0);
|
||||
Method->setMethodParams(S.Context, value, ArrayRef<SourceLocation>());
|
||||
}
|
||||
|
||||
|
@ -489,7 +489,7 @@ ExprResult Sema::BuildObjCBoxedExpr(SourceRange SR, Expr *ValueExpr) {
|
|||
&Context.Idents.get("value"),
|
||||
Context.getPointerType(ConstCharType),
|
||||
/*TInfo=*/0,
|
||||
SC_None, SC_None, 0);
|
||||
SC_None, 0);
|
||||
M->setMethodParams(Context, value, ArrayRef<SourceLocation>());
|
||||
BoxingMethod = M;
|
||||
}
|
||||
|
@ -656,16 +656,14 @@ ExprResult Sema::BuildObjCArrayLiteral(SourceRange SR, MultiExprArg Elements) {
|
|||
SourceLocation(),
|
||||
&Context.Idents.get("objects"),
|
||||
Context.getPointerType(IdT),
|
||||
/*TInfo=*/0, SC_None, SC_None,
|
||||
0);
|
||||
/*TInfo=*/0, SC_None, 0);
|
||||
Params.push_back(objects);
|
||||
ParmVarDecl *cnt = ParmVarDecl::Create(Context, Method,
|
||||
SourceLocation(),
|
||||
SourceLocation(),
|
||||
&Context.Idents.get("cnt"),
|
||||
Context.UnsignedLongTy,
|
||||
/*TInfo=*/0, SC_None, SC_None,
|
||||
0);
|
||||
/*TInfo=*/0, SC_None, 0);
|
||||
Params.push_back(cnt);
|
||||
Method->setMethodParams(Context, Params, ArrayRef<SourceLocation>());
|
||||
}
|
||||
|
@ -774,24 +772,21 @@ ExprResult Sema::BuildObjCDictionaryLiteral(SourceRange SR,
|
|||
SourceLocation(),
|
||||
&Context.Idents.get("objects"),
|
||||
Context.getPointerType(IdT),
|
||||
/*TInfo=*/0, SC_None, SC_None,
|
||||
0);
|
||||
/*TInfo=*/0, SC_None, 0);
|
||||
Params.push_back(objects);
|
||||
ParmVarDecl *keys = ParmVarDecl::Create(Context, Method,
|
||||
SourceLocation(),
|
||||
SourceLocation(),
|
||||
&Context.Idents.get("keys"),
|
||||
Context.getPointerType(IdT),
|
||||
/*TInfo=*/0, SC_None, SC_None,
|
||||
0);
|
||||
/*TInfo=*/0, SC_None, 0);
|
||||
Params.push_back(keys);
|
||||
ParmVarDecl *cnt = ParmVarDecl::Create(Context, Method,
|
||||
SourceLocation(),
|
||||
SourceLocation(),
|
||||
&Context.Idents.get("cnt"),
|
||||
Context.UnsignedLongTy,
|
||||
/*TInfo=*/0, SC_None, SC_None,
|
||||
0);
|
||||
/*TInfo=*/0, SC_None, 0);
|
||||
Params.push_back(cnt);
|
||||
Method->setMethodParams(Context, Params, ArrayRef<SourceLocation>());
|
||||
}
|
||||
|
|
|
@ -74,7 +74,6 @@ CXXMethodDecl *Sema::startLambdaDefinition(CXXRecordDecl *Class,
|
|||
IntroducerRange.getBegin(),
|
||||
MethodNameLoc),
|
||||
MethodType->getType(), MethodType,
|
||||
/*isStatic=*/false,
|
||||
SC_None,
|
||||
/*isInline=*/true,
|
||||
/*isConstExpr=*/false,
|
||||
|
@ -738,7 +737,7 @@ static void addFunctionPointerConversion(Sema &S,
|
|||
= CXXMethodDecl::Create(S.Context, Class, Loc,
|
||||
DeclarationNameInfo(Name, Loc), FunctionTy,
|
||||
CallOperator->getTypeSourceInfo(),
|
||||
/*IsStatic=*/true, SC_Static, /*IsInline=*/true,
|
||||
SC_Static, /*IsInline=*/true,
|
||||
/*IsConstexpr=*/false,
|
||||
CallOperator->getBody()->getLocEnd());
|
||||
SmallVector<ParmVarDecl *, 4> InvokeParams;
|
||||
|
@ -751,7 +750,6 @@ static void addFunctionPointerConversion(Sema &S,
|
|||
From->getType(),
|
||||
From->getTypeSourceInfo(),
|
||||
From->getStorageClass(),
|
||||
From->getStorageClassAsWritten(),
|
||||
/*DefaultArg=*/0));
|
||||
}
|
||||
Invoke->setParams(InvokeParams);
|
||||
|
@ -1010,7 +1008,6 @@ ExprResult Sema::BuildBlockForLambdaConversion(SourceLocation CurrentLocation,
|
|||
From->getType(),
|
||||
From->getTypeSourceInfo(),
|
||||
From->getStorageClass(),
|
||||
From->getStorageClassAsWritten(),
|
||||
/*DefaultArg=*/0));
|
||||
}
|
||||
Block->setParams(BlockParams);
|
||||
|
@ -1025,7 +1022,7 @@ ExprResult Sema::BuildBlockForLambdaConversion(SourceLocation CurrentLocation,
|
|||
VarDecl *CapVar = VarDecl::Create(Context, Block, ConvLocation,
|
||||
ConvLocation, 0,
|
||||
Src->getType(), CapVarTSI,
|
||||
SC_None, SC_None);
|
||||
SC_None);
|
||||
BlockDecl::Capture Capture(/*Variable=*/CapVar, /*ByRef=*/false,
|
||||
/*Nested=*/false, /*Copy=*/Init.take());
|
||||
Block->setCaptures(Context, &Capture, &Capture + 1,
|
||||
|
|
|
@ -1973,7 +1973,6 @@ void Sema::ProcessPropertyDecl(ObjCPropertyDecl *property,
|
|||
property->getType().getUnqualifiedType(),
|
||||
/*TInfo=*/0,
|
||||
SC_None,
|
||||
SC_None,
|
||||
0);
|
||||
SetterMethod->setMethodParams(Context, Argument,
|
||||
ArrayRef<SourceLocation>());
|
||||
|
|
|
@ -1087,7 +1087,6 @@ bool ObjCSubscriptOpBuilder::findAtIndexGetter() {
|
|||
: S.Context.getObjCIdType(),
|
||||
/*TInfo=*/0,
|
||||
SC_None,
|
||||
SC_None,
|
||||
0);
|
||||
AtIndexGetter->setMethodParams(S.Context, Argument,
|
||||
ArrayRef<SourceLocation>());
|
||||
|
@ -1202,7 +1201,6 @@ bool ObjCSubscriptOpBuilder::findAtIndexSetter() {
|
|||
S.Context.getObjCIdType(),
|
||||
/*TInfo=*/0,
|
||||
SC_None,
|
||||
SC_None,
|
||||
0);
|
||||
Params.push_back(object);
|
||||
ParmVarDecl *key = ParmVarDecl::Create(S.Context, AtIndexSetter,
|
||||
|
@ -1213,7 +1211,6 @@ bool ObjCSubscriptOpBuilder::findAtIndexSetter() {
|
|||
: S.Context.getObjCIdType(),
|
||||
/*TInfo=*/0,
|
||||
SC_None,
|
||||
SC_None,
|
||||
0);
|
||||
Params.push_back(key);
|
||||
AtIndexSetter->setMethodParams(S.Context, Params, ArrayRef<SourceLocation>());
|
||||
|
|
|
@ -1665,7 +1665,7 @@ VarDecl *BuildForRangeVarDecl(Sema &SemaRef, SourceLocation Loc,
|
|||
IdentifierInfo *II = &SemaRef.PP.getIdentifierTable().get(Name);
|
||||
TypeSourceInfo *TInfo = SemaRef.Context.getTrivialTypeSourceInfo(Type, Loc);
|
||||
VarDecl *Decl = VarDecl::Create(SemaRef.Context, DC, Loc, Loc, II, Type,
|
||||
TInfo, SC_Auto, SC_None);
|
||||
TInfo, SC_None);
|
||||
Decl->setImplicit();
|
||||
return Decl;
|
||||
}
|
||||
|
|
|
@ -6057,8 +6057,7 @@ Sema::CheckFunctionTemplateSpecialization(FunctionDecl *FD,
|
|||
TemplArgs, /*InsertPos=*/0,
|
||||
SpecInfo->getTemplateSpecializationKind(),
|
||||
ExplicitTemplateArgs);
|
||||
FD->setStorageClass(Specialization->getStorageClass());
|
||||
|
||||
|
||||
// The "previous declaration" for this function template specialization is
|
||||
// the prior function template specialization.
|
||||
Previous.clear();
|
||||
|
|
|
@ -1682,8 +1682,7 @@ ParmVarDecl *Sema::SubstParmVarDecl(ParmVarDecl *OldParm,
|
|||
OldParm->getLocation(),
|
||||
OldParm->getIdentifier(),
|
||||
NewDI->getType(), NewDI,
|
||||
OldParm->getStorageClass(),
|
||||
OldParm->getStorageClassAsWritten());
|
||||
OldParm->getStorageClass());
|
||||
if (!NewParm)
|
||||
return 0;
|
||||
|
||||
|
|
|
@ -338,8 +338,7 @@ Decl *TemplateDeclInstantiator::VisitVarDecl(VarDecl *D) {
|
|||
D->getInnerLocStart(),
|
||||
D->getLocation(), D->getIdentifier(),
|
||||
DI->getType(), DI,
|
||||
D->getStorageClass(),
|
||||
D->getStorageClassAsWritten());
|
||||
D->getStorageClass());
|
||||
Var->setThreadSpecified(D->isThreadSpecified());
|
||||
Var->setInitStyle(D->getInitStyle());
|
||||
Var->setCXXForRangeDecl(D->isCXXForRangeDecl());
|
||||
|
@ -1163,7 +1162,7 @@ Decl *TemplateDeclInstantiator::VisitFunctionDecl(FunctionDecl *D,
|
|||
FunctionDecl *Function =
|
||||
FunctionDecl::Create(SemaRef.Context, DC, D->getInnerLocStart(),
|
||||
D->getNameInfo(), T, TInfo,
|
||||
D->getStorageClass(), D->getStorageClassAsWritten(),
|
||||
D->getStorageClass(),
|
||||
D->isInlineSpecified(), D->hasWrittenPrototype(),
|
||||
D->isConstexpr());
|
||||
|
||||
|
@ -1529,8 +1528,7 @@ TemplateDeclInstantiator::VisitCXXMethodDecl(CXXMethodDecl *D,
|
|||
} else {
|
||||
Method = CXXMethodDecl::Create(SemaRef.Context, Record,
|
||||
StartLoc, NameInfo, T, TInfo,
|
||||
D->isStatic(),
|
||||
D->getStorageClassAsWritten(),
|
||||
D->getStorageClass(),
|
||||
D->isInlineSpecified(),
|
||||
D->isConstexpr(), D->getLocEnd());
|
||||
}
|
||||
|
|
|
@ -2301,7 +2301,7 @@ static void warnAboutAmbiguousFunction(Sema &S, Declarator &D,
|
|||
if (!D.isFunctionDeclarator() ||
|
||||
D.getFunctionDefinitionKind() != FDK_Declaration ||
|
||||
!S.CurContext->isFunctionOrMethod() ||
|
||||
D.getDeclSpec().getStorageClassSpecAsWritten()
|
||||
D.getDeclSpec().getStorageClassSpec()
|
||||
!= DeclSpec::SCS_unspecified)
|
||||
return;
|
||||
|
||||
|
|
|
@ -3994,7 +3994,6 @@ ParmVarDecl *TreeTransform<Derived>::TransformFunctionTypeParam(
|
|||
NewDI->getType(),
|
||||
NewDI,
|
||||
OldParm->getStorageClass(),
|
||||
OldParm->getStorageClassAsWritten(),
|
||||
/* DefArg */ NULL);
|
||||
newParm->setScopeInfo(OldParm->getFunctionScopeDepth(),
|
||||
OldParm->getFunctionScopeIndex() + indexAdjustment);
|
||||
|
|
|
@ -504,9 +504,8 @@ void ASTDeclReader::VisitFunctionDecl(FunctionDecl *FD) {
|
|||
|
||||
// FunctionDecl's body is handled last at ASTDeclReader::Visit,
|
||||
// after everything else is read.
|
||||
|
||||
|
||||
FD->SClass = (StorageClass)Record[Idx++];
|
||||
FD->SClassAsWritten = (StorageClass)Record[Idx++];
|
||||
FD->IsInline = Record[Idx++];
|
||||
FD->IsInlineSpecified = Record[Idx++];
|
||||
FD->IsVirtualAsWritten = Record[Idx++];
|
||||
|
@ -894,9 +893,8 @@ void ASTDeclReader::VisitIndirectFieldDecl(IndirectFieldDecl *FD) {
|
|||
void ASTDeclReader::VisitVarDecl(VarDecl *VD) {
|
||||
RedeclarableResult Redecl = VisitRedeclarable(VD);
|
||||
VisitDeclaratorDecl(VD);
|
||||
|
||||
|
||||
VD->VarDeclBits.SClass = (StorageClass)Record[Idx++];
|
||||
VD->VarDeclBits.SClassAsWritten = (StorageClass)Record[Idx++];
|
||||
VD->VarDeclBits.ThreadSpecified = Record[Idx++];
|
||||
VD->VarDeclBits.InitStyle = Record[Idx++];
|
||||
VD->VarDeclBits.ExceptionVar = Record[Idx++];
|
||||
|
|
|
@ -319,7 +319,6 @@ void ASTDeclWriter::VisitFunctionDecl(FunctionDecl *D) {
|
|||
// after everything else is written.
|
||||
|
||||
Record.push_back(D->getStorageClass()); // FIXME: stable encoding
|
||||
Record.push_back(D->getStorageClassAsWritten());
|
||||
Record.push_back(D->IsInline);
|
||||
Record.push_back(D->isInlineSpecified());
|
||||
Record.push_back(D->isVirtualAsWritten());
|
||||
|
@ -677,8 +676,7 @@ void ASTDeclWriter::VisitIndirectFieldDecl(IndirectFieldDecl *D) {
|
|||
void ASTDeclWriter::VisitVarDecl(VarDecl *D) {
|
||||
VisitRedeclarable(D);
|
||||
VisitDeclaratorDecl(D);
|
||||
Record.push_back(D->getStorageClass()); // FIXME: stable encoding
|
||||
Record.push_back(D->getStorageClassAsWritten());
|
||||
Record.push_back(D->getStorageClass());
|
||||
Record.push_back(D->isThreadSpecified());
|
||||
Record.push_back(D->getInitStyle());
|
||||
Record.push_back(D->isExceptionVariable());
|
||||
|
@ -1517,7 +1515,6 @@ void ASTWriter::WriteDeclsBlockAbbrevs() {
|
|||
Abv->Add(BitCodeAbbrevOp(0)); // hasExtInfo
|
||||
// VarDecl
|
||||
Abv->Add(BitCodeAbbrevOp(0)); // StorageClass
|
||||
Abv->Add(BitCodeAbbrevOp(0)); // StorageClassAsWritten
|
||||
Abv->Add(BitCodeAbbrevOp(0)); // isThreadSpecified
|
||||
Abv->Add(BitCodeAbbrevOp(0)); // hasCXXDirectInitializer
|
||||
Abv->Add(BitCodeAbbrevOp(0)); // isExceptionVariable
|
||||
|
@ -1597,7 +1594,6 @@ void ASTWriter::WriteDeclsBlockAbbrevs() {
|
|||
Abv->Add(BitCodeAbbrevOp(0)); // hasExtInfo
|
||||
// VarDecl
|
||||
Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // StorageClass
|
||||
Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // StorageClassAsWritten
|
||||
Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isThreadSpecified
|
||||
Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // CXXDirectInitializer
|
||||
Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isExceptionVariable
|
||||
|
|
Loading…
Reference in New Issue