diff options
Diffstat (limited to 'include/clang/Sema')
22 files changed, 860 insertions, 462 deletions
diff --git a/include/clang/Sema/AttributeList.h b/include/clang/Sema/AttributeList.h index 2e8b0c0..0f0d218 100644 --- a/include/clang/Sema/AttributeList.h +++ b/include/clang/Sema/AttributeList.h @@ -15,11 +15,11 @@ #ifndef LLVM_CLANG_SEMA_ATTRLIST_H #define LLVM_CLANG_SEMA_ATTRLIST_H -#include "llvm/Support/Allocator.h" -#include "llvm/ADT/SmallVector.h" #include "clang/Basic/SourceLocation.h" #include "clang/Basic/VersionTuple.h" #include "clang/Sema/Ownership.h" +#include "llvm/ADT/SmallVector.h" +#include "llvm/Support/Allocator.h" #include <cassert> namespace clang { @@ -44,8 +44,9 @@ struct AvailabilityChange { bool isValid() const { return !Version.empty(); } }; -/// AttributeList - Represents GCC's __attribute__ declaration. There are -/// 4 forms of this construct...they are: +/// AttributeList - Represents a syntactic attribute. +/// +/// For a GNU attribute, there are four forms of this construct: /// /// 1: __attribute__(( const )). ParmName/Args/NumArgs will all be unused. /// 2: __attribute__(( mode(byte) )). ParmName used, Args/NumArgs unused. @@ -56,12 +57,14 @@ class AttributeList { // TODO: This should really be called ParsedAttribute public: /// The style used to specify an attribute. enum Syntax { + /// __attribute__((...)) AS_GNU, + /// [[...]] AS_CXX11, + /// __declspec(...) AS_Declspec, - // eg) __w64, __ptr32, etc. It is implied that an MSTypespec is also - // a declspec. - AS_MSTypespec + /// __ptr16, alignas(...), etc. + AS_Keyword }; private: IdentifierInfo *AttrName; @@ -70,6 +73,7 @@ private: SourceRange AttrRange; SourceLocation ScopeLoc; SourceLocation ParmLoc; + SourceLocation EllipsisLoc; /// The number of expression arguments this attribute has. /// The expressions themselves are stored after the object. @@ -140,6 +144,14 @@ private: return *reinterpret_cast<const TypeTagForDatatypeData *>(this + 1); } + ParsedType &getTypeBuffer() { + return *reinterpret_cast<ParsedType *>(this + 1); + } + + const ParsedType &getTypeBuffer() const { + return *reinterpret_cast<const ParsedType *>(this + 1); + } + AttributeList(const AttributeList &) LLVM_DELETED_FUNCTION; void operator=(const AttributeList &) LLVM_DELETED_FUNCTION; void operator delete(void *) LLVM_DELETED_FUNCTION; @@ -152,11 +164,11 @@ private: IdentifierInfo *scopeName, SourceLocation scopeLoc, IdentifierInfo *parmName, SourceLocation parmLoc, Expr **args, unsigned numArgs, - Syntax syntaxUsed) + Syntax syntaxUsed, SourceLocation ellipsisLoc) : AttrName(attrName), ScopeName(scopeName), ParmName(parmName), AttrRange(attrRange), ScopeLoc(scopeLoc), ParmLoc(parmLoc), - NumArgs(numArgs), SyntaxUsed(syntaxUsed), Invalid(false), - UsedAsTypeAttr(false), IsAvailability(false), + EllipsisLoc(ellipsisLoc), NumArgs(numArgs), SyntaxUsed(syntaxUsed), + Invalid(false), UsedAsTypeAttr(false), IsAvailability(false), IsTypeTagForDatatype(false), NextInPosition(0), NextInPool(0) { if (numArgs) memcpy(getArgsBuffer(), args, numArgs * sizeof(Expr*)); AttrKind = getKind(getName(), getScopeName(), syntaxUsed); @@ -173,7 +185,7 @@ private: const Expr *messageExpr, Syntax syntaxUsed) : AttrName(attrName), ScopeName(scopeName), ParmName(parmName), - AttrRange(attrRange), ScopeLoc(scopeLoc), ParmLoc(parmLoc), + AttrRange(attrRange), ScopeLoc(scopeLoc), ParmLoc(parmLoc), EllipsisLoc(), NumArgs(0), SyntaxUsed(syntaxUsed), Invalid(false), UsedAsTypeAttr(false), IsAvailability(true), IsTypeTagForDatatype(false), @@ -194,7 +206,7 @@ private: bool mustBeNull, Syntax syntaxUsed) : AttrName(attrName), ScopeName(scopeName), ParmName(argumentKindName), AttrRange(attrRange), ScopeLoc(scopeLoc), ParmLoc(argumentKindLoc), - NumArgs(0), SyntaxUsed(syntaxUsed), + EllipsisLoc(), NumArgs(0), SyntaxUsed(syntaxUsed), Invalid(false), UsedAsTypeAttr(false), IsAvailability(false), IsTypeTagForDatatype(true), NextInPosition(NULL), NextInPool(NULL) { TypeTagForDatatypeData &ExtraData = getTypeTagForDatatypeDataSlot(); @@ -204,6 +216,20 @@ private: AttrKind = getKind(getName(), getScopeName(), syntaxUsed); } + /// Constructor for attributes with a single type argument. + AttributeList(IdentifierInfo *attrName, SourceRange attrRange, + IdentifierInfo *scopeName, SourceLocation scopeLoc, + IdentifierInfo *parmName, SourceLocation parmLoc, + ParsedType typeArg, Syntax syntaxUsed) + : AttrName(attrName), ScopeName(scopeName), ParmName(parmName), + AttrRange(attrRange), ScopeLoc(scopeLoc), ParmLoc(parmLoc), + EllipsisLoc(), NumArgs(1), SyntaxUsed(syntaxUsed), Invalid(false), + UsedAsTypeAttr(false), IsAvailability(false), + IsTypeTagForDatatype(false), NextInPosition(0), NextInPool(0) { + new (&getTypeBuffer()) ParsedType(typeArg); + AttrKind = getKind(getName(), getScopeName(), syntaxUsed); + } + friend class AttributePool; friend class AttributeFactory; @@ -227,12 +253,16 @@ public: IdentifierInfo *getParameterName() const { return ParmName; } SourceLocation getParameterLoc() const { return ParmLoc; } - /// Returns true if the attribute is a pure __declspec or a synthesized - /// declspec representing a type specification (like __w64 or __ptr32). - bool isDeclspecAttribute() const { return SyntaxUsed == AS_Declspec || - SyntaxUsed == AS_MSTypespec; } - bool isCXX0XAttribute() const { return SyntaxUsed == AS_CXX11; } - bool isMSTypespecAttribute() const { return SyntaxUsed == AS_MSTypespec; } + bool isAlignasAttribute() const { + // FIXME: Use a better mechanism to determine this. + return getKind() == AT_Aligned && SyntaxUsed == AS_Keyword; + } + + bool isDeclspecAttribute() const { return SyntaxUsed == AS_Declspec; } + bool isCXX11Attribute() const { + return SyntaxUsed == AS_CXX11 || isAlignasAttribute(); + } + bool isKeywordAttribute() const { return SyntaxUsed == AS_Keyword; } bool isInvalid() const { return Invalid; } void setInvalid(bool b = true) const { Invalid = b; } @@ -240,6 +270,9 @@ public: bool isUsedAsTypeAttr() const { return UsedAsTypeAttr; } void setUsedAsTypeAttr() { UsedAsTypeAttr = true; } + bool isPackExpansion() const { return EllipsisLoc.isValid(); } + SourceLocation getEllipsisLoc() const { return EllipsisLoc; } + Kind getKind() const { return Kind(AttrKind); } static Kind getKind(const IdentifierInfo *Name, const IdentifierInfo *Scope, Syntax SyntaxUsed); @@ -340,6 +373,16 @@ public: "Not a type_tag_for_datatype attribute"); return getTypeTagForDatatypeDataSlot().MustBeNull; } + + const ParsedType &getTypeArg() const { + assert(getKind() == AT_VecTypeHint && "Not a type attribute"); + return getTypeBuffer(); + } + + /// \brief Get an index into the attribute spelling list + /// defined in Attr.td. This index is used by an attribute + /// to pretty print itself. + unsigned getAttributeSpellingListIndex() const; }; /// A factory, from which one makes pools, from which one creates @@ -448,13 +491,15 @@ public: IdentifierInfo *scopeName, SourceLocation scopeLoc, IdentifierInfo *parmName, SourceLocation parmLoc, Expr **args, unsigned numArgs, - AttributeList::Syntax syntax) { + AttributeList::Syntax syntax, + SourceLocation ellipsisLoc = SourceLocation()) { void *memory = allocate(sizeof(AttributeList) + numArgs * sizeof(Expr*)); return add(new (memory) AttributeList(attrName, attrRange, scopeName, scopeLoc, parmName, parmLoc, - args, numArgs, syntax)); + args, numArgs, syntax, + ellipsisLoc)); } AttributeList *create(IdentifierInfo *attrName, SourceRange attrRange, @@ -491,6 +536,18 @@ public: matchingCType, layoutCompatible, mustBeNull, syntax)); } + + AttributeList *createTypeAttribute( + IdentifierInfo *attrName, SourceRange attrRange, + IdentifierInfo *scopeName, SourceLocation scopeLoc, + IdentifierInfo *parmName, SourceLocation parmLoc, + ParsedType typeArg, AttributeList::Syntax syntaxUsed) { + void *memory = allocate(sizeof(AttributeList) + sizeof(void *)); + return add(new (memory) AttributeList(attrName, attrRange, + scopeName, scopeLoc, + parmName, parmLoc, + typeArg, syntaxUsed)); + } }; /// addAttributeLists - Add two AttributeLists together @@ -511,18 +568,18 @@ inline AttributeList *addAttributeLists(AttributeList *Left, return Left; } -/// CXX0XAttributeList - A wrapper around a C++0x attribute list. +/// CXX11AttributeList - A wrapper around a C++11 attribute list. /// Stores, in addition to the list proper, whether or not an actual list was /// (as opposed to an empty list, which may be ill-formed in some places) and /// the source range of the list. -struct CXX0XAttributeList { +struct CXX11AttributeList { AttributeList *AttrList; SourceRange Range; bool HasAttr; - CXX0XAttributeList (AttributeList *attrList, SourceRange range, bool hasAttr) + CXX11AttributeList (AttributeList *attrList, SourceRange range, bool hasAttr) : AttrList(attrList), Range(range), HasAttr (hasAttr) { } - CXX0XAttributeList () + CXX11AttributeList () : AttrList(0), Range(), HasAttr(false) { } }; @@ -588,10 +645,11 @@ public: IdentifierInfo *scopeName, SourceLocation scopeLoc, IdentifierInfo *parmName, SourceLocation parmLoc, Expr **args, unsigned numArgs, - AttributeList::Syntax syntax) { + AttributeList::Syntax syntax, + SourceLocation ellipsisLoc = SourceLocation()) { AttributeList *attr = pool.create(attrName, attrRange, scopeName, scopeLoc, parmName, parmLoc, - args, numArgs, syntax); + args, numArgs, syntax, ellipsisLoc); add(attr); return attr; } @@ -632,6 +690,19 @@ public: return attr; } + /// Add an attribute with a single type argument. + AttributeList * + addNewTypeAttr(IdentifierInfo *attrName, SourceRange attrRange, + IdentifierInfo *scopeName, SourceLocation scopeLoc, + IdentifierInfo *parmName, SourceLocation parmLoc, + ParsedType typeArg, AttributeList::Syntax syntaxUsed) { + AttributeList *attr = + pool.createTypeAttribute(attrName, attrRange, scopeName, scopeLoc, + parmName, parmLoc, typeArg, syntaxUsed); + add(attr); + return attr; + } + AttributeList *addNewInteger(ASTContext &C, IdentifierInfo *name, SourceLocation loc, int arg) { AttributeList *attr = diff --git a/include/clang/Sema/CMakeLists.txt b/include/clang/Sema/CMakeLists.txt index 03f99a3..6b5d222 100644 --- a/include/clang/Sema/CMakeLists.txt +++ b/include/clang/Sema/CMakeLists.txt @@ -11,4 +11,9 @@ clang_tablegen(AttrParsedAttrList.inc -gen-clang-attr-parsed-attr-list clang_tablegen(AttrParsedAttrKinds.inc -gen-clang-attr-parsed-attr-kinds -I ${CMAKE_CURRENT_SOURCE_DIR}/../../ SOURCE ../Basic/Attr.td - TARGET ClangAttrParsedAttrKinds)
\ No newline at end of file + TARGET ClangAttrParsedAttrKinds) + +clang_tablegen(AttrSpellingListIndex.inc -gen-clang-attr-spelling-index + -I ${CMAKE_CURRENT_SOURCE_DIR}/../../ + SOURCE ../Basic/Attr.td + TARGET ClangAttrSpellingListIndex) diff --git a/include/clang/Sema/CXXFieldCollector.h b/include/clang/Sema/CXXFieldCollector.h index 6f3c0b4..6685751 100644 --- a/include/clang/Sema/CXXFieldCollector.h +++ b/include/clang/Sema/CXXFieldCollector.h @@ -15,6 +15,7 @@ #ifndef LLVM_CLANG_SEMA_CXXFIELDCOLLECTOR_H #define LLVM_CLANG_SEMA_CXXFIELDCOLLECTOR_H +#include "clang/Basic/LLVM.h" #include "llvm/ADT/SmallVector.h" namespace clang { diff --git a/include/clang/Sema/CodeCompleteConsumer.h b/include/clang/Sema/CodeCompleteConsumer.h index b128bd8..a1ddec7 100644 --- a/include/clang/Sema/CodeCompleteConsumer.h +++ b/include/clang/Sema/CodeCompleteConsumer.h @@ -13,13 +13,13 @@ #ifndef LLVM_CLANG_SEMA_CODECOMPLETECONSUMER_H #define LLVM_CLANG_SEMA_CODECOMPLETECONSUMER_H -#include "clang/AST/Type.h" +#include "clang-c/Index.h" #include "clang/AST/CanonicalType.h" +#include "clang/AST/Type.h" #include "clang/Sema/CodeCompleteOptions.h" #include "llvm/ADT/SmallVector.h" #include "llvm/ADT/StringRef.h" #include "llvm/Support/Allocator.h" -#include "clang-c/Index.h" #include <string> namespace clang { @@ -121,7 +121,7 @@ SimplifiedTypeClass getSimplifiedTypeClass(CanQualType T); /// \brief Determine the type that this declaration will have if it is used /// as a type or in an expression. -QualType getDeclUsageType(ASTContext &C, NamedDecl *ND); +QualType getDeclUsageType(ASTContext &C, const NamedDecl *ND); /// \brief Determine the priority to be given to a macro code completion result /// with the given name. @@ -138,7 +138,7 @@ unsigned getMacroUsagePriority(StringRef MacroName, /// \brief Determine the libclang cursor kind associated with the given /// declaration. -CXCursorKind getCursorKindForDecl(Decl *D); +CXCursorKind getCursorKindForDecl(const Decl *D); class FunctionDecl; class FunctionType; @@ -245,7 +245,8 @@ public: /// \brief Code completion in a parenthesized expression, which means that /// we may also have types here in C and Objective-C (as well as in C++). CCC_ParenthesizedExpression, - /// \brief Code completion where an Objective-C instance message is expcted. + /// \brief Code completion where an Objective-C instance message is + /// expected. CCC_ObjCInstanceMessage, /// \brief Code completion where an Objective-C class message is expected. CCC_ObjCClassMessage, @@ -530,7 +531,7 @@ class GlobalCodeCompletionAllocator }; class CodeCompletionTUInfo { - llvm::DenseMap<DeclContext *, StringRef> ParentNames; + llvm::DenseMap<const DeclContext *, StringRef> ParentNames; IntrusiveRefCntPtr<GlobalCodeCompletionAllocator> AllocatorRef; public: @@ -546,7 +547,7 @@ public: return *AllocatorRef; } - StringRef getParentName(DeclContext *DC); + StringRef getParentName(const DeclContext *DC); }; } // end namespace clang @@ -629,8 +630,9 @@ public: void AddAnnotation(const char *A) { Annotations.push_back(A); } /// \brief Add the parent context information to this code completion. - void addParentContext(DeclContext *DC); + void addParentContext(const DeclContext *DC); + const char *getBriefComment() const { return BriefComment; } void addBriefComment(StringRef Comment); StringRef getParentName() const { return ParentName; } @@ -649,7 +651,7 @@ public: /// \brief When Kind == RK_Declaration or RK_Pattern, the declaration we are /// referring to. In the latter case, the declaration might be NULL. - NamedDecl *Declaration; + const NamedDecl *Declaration; union { /// \brief When Kind == RK_Keyword, the string representing the keyword @@ -661,7 +663,7 @@ public: CodeCompletionString *Pattern; /// \brief When Kind == RK_Macro, the identifier that refers to a macro. - IdentifierInfo *Macro; + const IdentifierInfo *Macro; }; /// \brief The priority of this particular code-completion result. @@ -704,11 +706,12 @@ public: NestedNameSpecifier *Qualifier; /// \brief Build a result that refers to a declaration. - CodeCompletionResult(NamedDecl *Declaration, + CodeCompletionResult(const NamedDecl *Declaration, + unsigned Priority, NestedNameSpecifier *Qualifier = 0, bool QualifierIsInformative = false, bool Accessible = true) - : Declaration(Declaration), Priority(getPriorityFromDecl(Declaration)), + : Declaration(Declaration), Priority(Priority), StartParameter(0), Kind(RK_Declaration), Availability(CXAvailability_Available), Hidden(false), QualifierIsInformative(QualifierIsInformative), @@ -728,7 +731,8 @@ public: } /// \brief Build a result that refers to a macro. - CodeCompletionResult(IdentifierInfo *Macro, unsigned Priority = CCP_Macro) + CodeCompletionResult(const IdentifierInfo *Macro, + unsigned Priority = CCP_Macro) : Declaration(0), Macro(Macro), Priority(Priority), StartParameter(0), Kind(RK_Macro), CursorKind(CXCursor_MacroDefinition), Availability(CXAvailability_Available), Hidden(false), @@ -742,7 +746,7 @@ public: unsigned Priority = CCP_CodePattern, CXCursorKind CursorKind = CXCursor_NotImplemented, CXAvailabilityKind Availability = CXAvailability_Available, - NamedDecl *D = 0) + const NamedDecl *D = 0) : Declaration(D), Pattern(Pattern), Priority(Priority), StartParameter(0), Kind(RK_Pattern), CursorKind(CursorKind), Availability(Availability), Hidden(false), QualifierIsInformative(0), @@ -763,7 +767,7 @@ public: } /// \brief Retrieve the declaration stored in this result. - NamedDecl *getDeclaration() const { + const NamedDecl *getDeclaration() const { assert(Kind == RK_Declaration && "Not a declaration result"); return Declaration; } @@ -791,9 +795,6 @@ public: CodeCompletionTUInfo &CCTUInfo, bool IncludeBriefComments); - /// \brief Determine a base priority for the given declaration. - static unsigned getPriorityFromDecl(NamedDecl *ND); - private: void computeCursorKindAndAvailability(bool Accessible = true); }; diff --git a/include/clang/Sema/CodeCompleteOptions.h b/include/clang/Sema/CodeCompleteOptions.h index 30712db..e43496f 100644 --- a/include/clang/Sema/CodeCompleteOptions.h +++ b/include/clang/Sema/CodeCompleteOptions.h @@ -13,16 +13,16 @@ /// Options controlling the behavior of code completion. class CodeCompleteOptions { public: - ///< Show macros in code completion results. + /// Show macros in code completion results. unsigned IncludeMacros : 1; - ///< Show code patterns in code completion results. + /// Show code patterns in code completion results. unsigned IncludeCodePatterns : 1; - ///< Show top-level decls in code completion results. + /// Show top-level decls in code completion results. unsigned IncludeGlobals : 1; - ///< Show brief documentation comments in code completion results. + /// Show brief documentation comments in code completion results. unsigned IncludeBriefComments : 1; CodeCompleteOptions() : diff --git a/include/clang/Sema/DeclSpec.h b/include/clang/Sema/DeclSpec.h index 0728e87..5b90784 100644 --- a/include/clang/Sema/DeclSpec.h +++ b/include/clang/Sema/DeclSpec.h @@ -23,14 +23,14 @@ #ifndef LLVM_CLANG_SEMA_DECLSPEC_H #define LLVM_CLANG_SEMA_DECLSPEC_H -#include "clang/Sema/AttributeList.h" -#include "clang/Sema/Ownership.h" #include "clang/AST/NestedNameSpecifier.h" -#include "clang/Lex/Token.h" #include "clang/Basic/ExceptionSpecificationType.h" #include "clang/Basic/Lambda.h" #include "clang/Basic/OperatorKinds.h" #include "clang/Basic/Specifiers.h" +#include "clang/Lex/Token.h" +#include "clang/Sema/AttributeList.h" +#include "clang/Sema/Ownership.h" #include "llvm/ADT/SmallVector.h" #include "llvm/Support/Compiler.h" #include "llvm/Support/ErrorHandling.h" @@ -276,6 +276,14 @@ public: static const TST TST_auto = clang::TST_auto; static const TST TST_unknown_anytype = clang::TST_unknown_anytype; static const TST TST_atomic = clang::TST_atomic; + static const TST TST_image1d_t = clang::TST_image1d_t; + static const TST TST_image1d_array_t = clang::TST_image1d_array_t; + static const TST TST_image1d_buffer_t = clang::TST_image1d_buffer_t; + static const TST TST_image2d_t = clang::TST_image2d_t; + static const TST TST_image2d_array_t = clang::TST_image2d_array_t; + static const TST TST_image3d_t = clang::TST_image3d_t; + static const TST TST_sampler_t = clang::TST_sampler_t; + static const TST TST_event_t = clang::TST_event_t; static const TST TST_error = clang::TST_error; // type-qualifiers @@ -283,7 +291,10 @@ public: TQ_unspecified = 0, TQ_const = 1, TQ_restrict = 2, - TQ_volatile = 4 + TQ_volatile = 4, + // This has no corresponding Qualifiers::TQ value, because it's not treated + // as a qualifier in our type system. + TQ_atomic = 8 }; /// ParsedSpecifiers - Flags to query which specifiers were applied. This is @@ -306,19 +317,20 @@ private: /*TSW*/unsigned TypeSpecWidth : 2; /*TSC*/unsigned TypeSpecComplex : 2; /*TSS*/unsigned TypeSpecSign : 2; - /*TST*/unsigned TypeSpecType : 5; + /*TST*/unsigned TypeSpecType : 6; unsigned TypeAltiVecVector : 1; unsigned TypeAltiVecPixel : 1; unsigned TypeAltiVecBool : 1; unsigned TypeSpecOwned : 1; // type-qualifiers - unsigned TypeQualifiers : 3; // Bitwise OR of TQ. + unsigned TypeQualifiers : 4; // Bitwise OR of TQ. // function-specifier unsigned FS_inline_specified : 1; unsigned FS_virtual_specified : 1; unsigned FS_explicit_specified : 1; + unsigned FS_noreturn_specified : 1; // friend-specifier unsigned Friend_specified : 1; @@ -326,8 +338,6 @@ private: // constexpr-specifier unsigned Constexpr_specified : 1; - /*SCS*/unsigned StorageClassSpecAsWritten : 3; - union { UnionParsedType TypeRep; Decl *DeclRep; @@ -360,13 +370,12 @@ private: /// TSTNameLoc provides source range info for tag types. SourceLocation TSTNameLoc; SourceRange TypeofParensRange; - SourceLocation TQ_constLoc, TQ_restrictLoc, TQ_volatileLoc; - SourceLocation FS_inlineLoc, FS_virtualLoc, FS_explicitLoc; + SourceLocation TQ_constLoc, TQ_restrictLoc, TQ_volatileLoc, TQ_atomicLoc; + SourceLocation FS_inlineLoc, FS_virtualLoc, FS_explicitLoc, FS_noreturnLoc; SourceLocation FriendLoc, ModulePrivateLoc, ConstexprLoc; WrittenBuiltinSpecs writtenBS; void SaveWrittenBuiltinSpecs(); - void SaveStorageSpecifierAsWritten(); ObjCDeclSpec *ObjCQualifiers; @@ -377,16 +386,16 @@ private: static bool isExprRep(TST T) { return (T == TST_typeofExpr || T == TST_decltype); } + + DeclSpec(const DeclSpec &) LLVM_DELETED_FUNCTION; + void operator=(const DeclSpec &) LLVM_DELETED_FUNCTION; +public: static bool isDeclRep(TST T) { return (T == TST_enum || T == TST_struct || T == TST_interface || T == TST_union || T == TST_class); } - DeclSpec(const DeclSpec &) LLVM_DELETED_FUNCTION; - void operator=(const DeclSpec &) LLVM_DELETED_FUNCTION; -public: - DeclSpec(AttributeFactory &attrFactory) : StorageClassSpec(SCS_unspecified), SCS_thread_specified(false), @@ -403,9 +412,9 @@ public: FS_inline_specified(false), FS_virtual_specified(false), FS_explicit_specified(false), + FS_noreturn_specified(false), Friend_specified(false), Constexpr_specified(false), - StorageClassSpecAsWritten(SCS_unspecified), Attrs(attrFactory), ProtocolQualifiers(0), NumProtocolQualifiers(0), @@ -493,6 +502,7 @@ public: SourceLocation getConstSpecLoc() const { return TQ_constLoc; } SourceLocation getRestrictSpecLoc() const { return TQ_restrictLoc; } SourceLocation getVolatileSpecLoc() const { return TQ_volatileLoc; } + SourceLocation getAtomicSpecLoc() const { return TQ_atomicLoc; } /// \brief Clear out all of the type qualifiers. void ClearTypeQualifiers() { @@ -500,6 +510,7 @@ public: TQ_constLoc = SourceLocation(); TQ_restrictLoc = SourceLocation(); TQ_volatileLoc = SourceLocation(); + TQ_atomicLoc = SourceLocation(); } // function-specifier @@ -512,6 +523,9 @@ public: bool isExplicitSpecified() const { return FS_explicit_specified; } SourceLocation getExplicitSpecLoc() const { return FS_explicitLoc; } + bool isNoreturnSpecified() const { return FS_noreturn_specified; } + SourceLocation getNoreturnSpecLoc() const { return FS_noreturnLoc; } + void ClearFunctionSpecs() { FS_inline_specified = false; FS_inlineLoc = SourceLocation(); @@ -519,6 +533,8 @@ public: FS_virtualLoc = SourceLocation(); FS_explicit_specified = false; FS_explicitLoc = SourceLocation(); + FS_noreturn_specified = false; + FS_noreturnLoc = SourceLocation(); } /// \brief Return true if any type-specifier has been found. @@ -533,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 { @@ -602,12 +614,10 @@ public: bool SetTypeQual(TQ T, SourceLocation Loc, const char *&PrevSpec, unsigned &DiagID, const LangOptions &Lang); - bool SetFunctionSpecInline(SourceLocation Loc, const char *&PrevSpec, - unsigned &DiagID); - bool SetFunctionSpecVirtual(SourceLocation Loc, const char *&PrevSpec, - unsigned &DiagID); - bool SetFunctionSpecExplicit(SourceLocation Loc, const char *&PrevSpec, - unsigned &DiagID); + bool setFunctionSpecInline(SourceLocation Loc); + bool setFunctionSpecVirtual(SourceLocation Loc); + bool setFunctionSpecExplicit(SourceLocation Loc); + bool setFunctionSpecNoreturn(SourceLocation Loc); bool SetFriendSpec(SourceLocation Loc, const char *&PrevSpec, unsigned &DiagID); @@ -808,6 +818,20 @@ public: IK_ImplicitSelfParam } Kind; + struct OFI { + /// \brief The kind of overloaded operator. + OverloadedOperatorKind Operator; + + /// \brief The source locations of the individual tokens that name + /// the operator, e.g., the "new", "[", and "]" tokens in + /// operator new []. + /// + /// Different operators have different numbers of tokens in their name, + /// up to three. Any remaining source locations in this array will be + /// set to an invalid value for operators with fewer than three tokens. + unsigned SymbolLocations[3]; + }; + /// \brief Anonymous union that holds extra data associated with the /// parsed unqualified-id. union { @@ -817,19 +841,7 @@ public: /// \brief When Kind == IK_OperatorFunctionId, the overloaded operator /// that we parsed. - struct { - /// \brief The kind of overloaded operator. - OverloadedOperatorKind Operator; - - /// \brief The source locations of the individual tokens that name - /// the operator, e.g., the "new", "[", and "]" tokens in - /// operator new []. - /// - /// Different operators have different numbers of tokens in their name, - /// up to three. Any remaining source locations in this array will be - /// set to an invalid value for operators with fewer than three tokens. - unsigned SymbolLocations[3]; - } OperatorFunctionId; + struct OFI OperatorFunctionId; /// \brief When Kind == IK_ConversionFunctionId, the type that the /// conversion function names. @@ -1010,8 +1022,8 @@ struct DeclaratorChunk { }; struct PointerTypeInfo : TypeInfoCommon { - /// The type qualifiers: const/volatile/restrict. - unsigned TypeQuals : 3; + /// The type qualifiers: const/volatile/restrict/atomic. + unsigned TypeQuals : 4; /// The location of the const-qualifier, if any. unsigned ConstQualLoc; @@ -1022,6 +1034,9 @@ struct DeclaratorChunk { /// The location of the restrict-qualifier, if any. unsigned RestrictQualLoc; + /// The location of the _Atomic-qualifier, if any. + unsigned AtomicQualLoc; + void destroy() { } }; @@ -1036,8 +1051,8 @@ struct DeclaratorChunk { }; struct ArrayTypeInfo : TypeInfoCommon { - /// The type qualifiers for the array: const/volatile/restrict. - unsigned TypeQuals : 3; + /// The type qualifiers for the array: const/volatile/restrict/_Atomic. + unsigned TypeQuals : 4; /// True if this dimension included the 'static' keyword. bool hasStatic : 1; @@ -1259,16 +1274,16 @@ struct DeclaratorChunk { struct BlockPointerTypeInfo : TypeInfoCommon { /// For now, sema will catch these as invalid. - /// The type qualifiers: const/volatile/restrict. - unsigned TypeQuals : 3; + /// The type qualifiers: const/volatile/restrict/_Atomic. + unsigned TypeQuals : 4; void destroy() { } }; struct MemberPointerTypeInfo : TypeInfoCommon { - /// The type qualifiers: const/volatile/restrict. - unsigned TypeQuals : 3; + /// The type qualifiers: const/volatile/restrict/_Atomic. + unsigned TypeQuals : 4; // CXXScopeSpec has a constructor, so it can't be a direct member. // So we need some pointer-aligned storage and a bit of trickery. union { @@ -1422,6 +1437,9 @@ struct DeclaratorChunk { return I; } + bool isParen() const { + return Kind == Paren; + } }; /// \brief Described the kind of function definition (if any) provided for @@ -1783,33 +1801,41 @@ public: return DeclTypeInfo[i]; } - void DropFirstTypeObject() - { + void DropFirstTypeObject() { assert(!DeclTypeInfo.empty() && "No type chunks to drop."); DeclTypeInfo.front().destroy(); DeclTypeInfo.erase(DeclTypeInfo.begin()); } + /// Return the innermost (closest to the declarator) chunk of this + /// declarator that is not a parens chunk, or null if there are no + /// non-parens chunks. + const DeclaratorChunk *getInnermostNonParenChunk() const { + for (unsigned i = 0, i_end = DeclTypeInfo.size(); i < i_end; ++i) { + if (!DeclTypeInfo[i].isParen()) + return &DeclTypeInfo[i]; + } + return 0; + } + + /// Return the outermost (furthest from the declarator) chunk of + /// this declarator that is not a parens chunk, or null if there are + /// no non-parens chunks. + const DeclaratorChunk *getOutermostNonParenChunk() const { + for (unsigned i = DeclTypeInfo.size(), i_end = 0; i != i_end; --i) { + if (!DeclTypeInfo[i-1].isParen()) + return &DeclTypeInfo[i-1]; + } + return 0; + } + /// isArrayOfUnknownBound - This method returns true if the declarator /// is a declarator for an array of unknown bound (looking through /// parentheses). bool isArrayOfUnknownBound() const { - for (unsigned i = 0, i_end = DeclTypeInfo.size(); i < i_end; ++i) { - switch (DeclTypeInfo[i].Kind) { - case DeclaratorChunk::Paren: - continue; - case DeclaratorChunk::Function: - case DeclaratorChunk::Pointer: - case DeclaratorChunk::Reference: - case DeclaratorChunk::BlockPointer: - case DeclaratorChunk::MemberPointer: - return false; - case DeclaratorChunk::Array: - return !DeclTypeInfo[i].Arr.NumElts; - } - llvm_unreachable("Invalid type chunk"); - } - return false; + const DeclaratorChunk *chunk = getInnermostNonParenChunk(); + return (chunk && chunk->Kind == DeclaratorChunk::Array && + !chunk->Arr.NumElts); } /// isFunctionDeclarator - This method returns true if the declarator @@ -1866,7 +1892,54 @@ public: /// isn't a function declarator, if the type specifier refers to a function /// type. This routine checks for both cases. bool isDeclarationOfFunction() const; + + /// \brief Return true if this declaration appears in a context where a + /// function declarator would be a function declaration. + bool isFunctionDeclarationContext() const { + if (getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_typedef) + return false; + + switch (Context) { + case FileContext: + case MemberContext: + case BlockContext: + return true; + + case ForContext: + case ConditionContext: + case KNRTypeListContext: + case TypeNameContext: + case AliasDeclContext: + case AliasTemplateContext: + case PrototypeContext: + case ObjCParameterContext: + case ObjCResultContext: + case TemplateParamContext: + case CXXNewContext: + case CXXCatchContext: + case ObjCCatchContext: + case BlockLiteralContext: + case LambdaExprContext: + case TemplateTypeArgContext: + case TrailingReturnContext: + return false; + } + llvm_unreachable("unknown context kind!"); + } + /// \brief Return true if a function declarator at this position would be a + /// function declaration. + bool isFunctionDeclaratorAFunctionDeclaration() const { + if (!isFunctionDeclarationContext()) + return false; + + for (unsigned I = 0, N = getNumTypeObjects(); I != N; ++I) + if (getTypeObject(I).Kind != DeclaratorChunk::Paren) + return false; + + return true; + } + /// takeAttributes - Takes attributes from the given parsed-attributes /// set and add them to this declarator. /// @@ -1897,6 +1970,17 @@ public: return false; } + /// \brief Return a source range list of C++11 attributes associated + /// with the declarator. + void getCXX11AttributeRanges(SmallVector<SourceRange, 4> &Ranges) { + AttributeList *AttrList = Attrs.getList(); + while (AttrList) { + if (AttrList->isCXX11Attribute()) + Ranges.push_back(AttrList->getRange()); + AttrList = AttrList->getNext(); + } + } + void setAsmLabel(Expr *E) { AsmLabel = E; } Expr *getAsmLabel() const { return AsmLabel; } @@ -1996,7 +2080,7 @@ struct LambdaIntroducer { SourceRange Range; SourceLocation DefaultLoc; LambdaCaptureDefault Default; - llvm::SmallVector<LambdaCapture, 4> Captures; + SmallVector<LambdaCapture, 4> Captures; LambdaIntroducer() : Default(LCD_None) {} diff --git a/include/clang/Sema/DelayedDiagnostic.h b/include/clang/Sema/DelayedDiagnostic.h index a20480c..3704e09 100644 --- a/include/clang/Sema/DelayedDiagnostic.h +++ b/include/clang/Sema/DelayedDiagnostic.h @@ -199,21 +199,25 @@ public: } private: + + struct DD { + const NamedDecl *Decl; + const ObjCInterfaceDecl *UnknownObjCClass; + const ObjCPropertyDecl *ObjCProperty; + const char *Message; + size_t MessageLen; + }; + + struct FTD { + unsigned Diagnostic; + unsigned Argument; + void *OperandType; + }; + union { - /// Deprecation. - struct { - const NamedDecl *Decl; - const ObjCInterfaceDecl *UnknownObjCClass; - const ObjCPropertyDecl *ObjCProperty; - const char *Message; - size_t MessageLen; - } DeprecationData; - - struct { - unsigned Diagnostic; - unsigned Argument; - void *OperandType; - } ForbiddenTypeData; + /// Deprecation + struct DD DeprecationData; + struct FTD ForbiddenTypeData; /// Access control. char AccessData[sizeof(AccessedEntity)]; @@ -224,14 +228,14 @@ private: /// delayed. class DelayedDiagnosticPool { const DelayedDiagnosticPool *Parent; - llvm::SmallVector<DelayedDiagnostic, 4> Diagnostics; + SmallVector<DelayedDiagnostic, 4> Diagnostics; DelayedDiagnosticPool(const DelayedDiagnosticPool &) LLVM_DELETED_FUNCTION; void operator=(const DelayedDiagnosticPool &) LLVM_DELETED_FUNCTION; public: DelayedDiagnosticPool(const DelayedDiagnosticPool *parent) : Parent(parent) {} ~DelayedDiagnosticPool() { - for (llvm::SmallVectorImpl<DelayedDiagnostic>::iterator + for (SmallVectorImpl<DelayedDiagnostic>::iterator i = Diagnostics.begin(), e = Diagnostics.end(); i != e; ++i) i->Destroy(); } @@ -260,8 +264,7 @@ public: pool.Diagnostics.clear(); } - typedef llvm::SmallVectorImpl<DelayedDiagnostic>::const_iterator - pool_iterator; + typedef SmallVectorImpl<DelayedDiagnostic>::const_iterator pool_iterator; pool_iterator pool_begin() const { return Diagnostics.begin(); } pool_iterator pool_end() const { return Diagnostics.end(); } bool pool_empty() const { return Diagnostics.empty(); } diff --git a/include/clang/Sema/ExternalSemaSource.h b/include/clang/Sema/ExternalSemaSource.h index 7a59849..cbce757 100644 --- a/include/clang/Sema/ExternalSemaSource.h +++ b/include/clang/Sema/ExternalSemaSource.h @@ -15,6 +15,7 @@ #include "clang/AST/ExternalASTSource.h" #include "clang/Sema/Weak.h" +#include "llvm/ADT/MapVector.h" #include <utility> namespace clang { @@ -65,7 +66,12 @@ public: /// which will be used during typo correction. virtual void ReadKnownNamespaces( SmallVectorImpl<NamespaceDecl *> &Namespaces); - + + /// \brief Load the set of used but not defined functions or variables with + /// internal linkage, or used but not defined internal functions. + virtual void ReadUndefinedButUsed( + llvm::DenseMap<NamedDecl*, SourceLocation> &Undefined); + /// \brief Do last resort, unqualified lookup on a LookupResult that /// Sema cannot find. /// @@ -130,7 +136,7 @@ public: /// declarations to the given vector of declarations. Note that this routine /// may be invoked multiple times; the external source should take care not /// to introduce the same declarations repeatedly. - virtual void ReadLocallyScopedExternalDecls( + virtual void ReadLocallyScopedExternCDecls( SmallVectorImpl<NamedDecl *> &Decls) {} /// \brief Read the set of referenced selectors known to the diff --git a/include/clang/Sema/IdentifierResolver.h b/include/clang/Sema/IdentifierResolver.h index dff0134..0b1b74a 100644 --- a/include/clang/Sema/IdentifierResolver.h +++ b/include/clang/Sema/IdentifierResolver.h @@ -158,8 +158,7 @@ public: /// \param ExplicitInstantiationOrSpecialization When true, we are checking /// whether the declaration is in scope for the purposes of explicit template /// instantiation or specialization. The default is false. - bool isDeclInScope(Decl *D, DeclContext *Ctx, ASTContext &Context, - Scope *S = 0, + bool isDeclInScope(Decl *D, DeclContext *Ctx, Scope *S = 0, bool ExplicitInstantiationOrSpecialization = false) const; /// AddDecl - Link the decl to its shadowed decl chain. diff --git a/include/clang/Sema/Initialization.h b/include/clang/Sema/Initialization.h index 0b0af0c..8459be1 100644 --- a/include/clang/Sema/Initialization.h +++ b/include/clang/Sema/Initialization.h @@ -13,12 +13,13 @@ #ifndef LLVM_CLANG_SEMA_INITIALIZATION_H #define LLVM_CLANG_SEMA_INITIALIZATION_H -#include "clang/Sema/Ownership.h" -#include "clang/Sema/Overload.h" #include "clang/AST/ASTContext.h" +#include "clang/AST/Attr.h" #include "clang/AST/Type.h" #include "clang/AST/UnresolvedSet.h" #include "clang/Basic/SourceLocation.h" +#include "clang/Sema/Overload.h" +#include "clang/Sema/Ownership.h" #include "llvm/ADT/PointerIntPair.h" #include "llvm/ADT/SmallVector.h" #include <cassert> @@ -87,7 +88,27 @@ private: /// \brief The type of the object or reference being initialized. QualType Type; - + + struct LN { + /// \brief When Kind == EK_Result, EK_Exception, EK_New, the + /// location of the 'return', 'throw', or 'new' keyword, + /// respectively. When Kind == EK_Temporary, the location where + /// the temporary is being created. + unsigned Location; + + /// \brief Whether the entity being initialized may end up using the + /// named return value optimization (NRVO). + bool NRVO; + }; + + struct C { + /// \brief The variable being captured by an EK_LambdaCapture. + VarDecl *Var; + + /// \brief The source location at which the capture occurs. + unsigned Location; + }; + union { /// \brief When Kind == EK_Variable, or EK_Member, the VarDecl or /// FieldDecl, respectively. @@ -100,18 +121,8 @@ private: /// \brief When Kind == EK_Temporary, the type source information for /// the temporary. TypeSourceInfo *TypeInfo; - - struct { - /// \brief When Kind == EK_Result, EK_Exception, EK_New, the - /// location of the 'return', 'throw', or 'new' keyword, - /// respectively. When Kind == EK_Temporary, the location where - /// the temporary is being created. - unsigned Location; - - /// \brief Whether the entity being initialized may end up using the - /// named return value optimization (NRVO). - bool NRVO; - } LocAndNRVO; + + struct LN LocAndNRVO; /// \brief When Kind == EK_Base, the base specifier that provides the /// base class. The lower bit specifies whether the base is an inherited @@ -122,14 +133,8 @@ private: /// EK_ComplexElement, the index of the array or vector element being /// initialized. unsigned Index; - - struct { - /// \brief The variable being captured by an EK_LambdaCapture. - VarDecl *Var; - - /// \brief The source location at which the capture occurs. - unsigned Location; - } Capture; + + struct C Capture; }; InitializedEntity() { } @@ -172,17 +177,25 @@ public: static InitializedEntity InitializeVariable(VarDecl *Var) { return InitializedEntity(Var); } - + /// \brief Create the initialization entity for a parameter. static InitializedEntity InitializeParameter(ASTContext &Context, ParmVarDecl *Parm) { + return InitializeParameter(Context, Parm, Parm->getType()); + } + + /// \brief Create the initialization entity for a parameter, but use + /// another type. + static InitializedEntity InitializeParameter(ASTContext &Context, + ParmVarDecl *Parm, + QualType Type) { bool Consumed = (Context.getLangOpts().ObjCAutoRefCount && Parm->hasAttr<NSConsumedAttr>()); InitializedEntity Entity; Entity.Kind = EK_Parameter; - Entity.Type = Context.getVariableArrayDecayedType( - Parm->getType().getUnqualifiedType()); + Entity.Type = + Context.getVariableArrayDecayedType(Type.getUnqualifiedType()); Entity.Parent = 0; Entity.Parameter = (static_cast<uintptr_t>(Consumed) | reinterpret_cast<uintptr_t>(Parm)); @@ -615,7 +628,11 @@ public: /// \brief Produce an Objective-C object pointer. SK_ProduceObjCObject, /// \brief Construct a std::initializer_list from an initializer list. - SK_StdInitializerList + SK_StdInitializerList, + /// \brief Initialize an OpenCL sampler from an integer. + SK_OCLSamplerInit, + /// \brief Passing zero to a function where OpenCL event_t is expected. + SK_OCLZeroEvent }; /// \brief A single step in the initialization sequence. @@ -626,7 +643,13 @@ public: // \brief The type that results from this initialization. QualType Type; - + + struct F { + bool HadMultipleCandidates; + FunctionDecl *Function; + DeclAccessPair FoundDecl; + }; + union { /// \brief When Kind == SK_ResolvedOverloadedFunction or Kind == /// SK_UserConversion, the function that the expression should be @@ -638,11 +661,7 @@ public: /// selected from an overloaded set having size greater than 1. /// For conversion decls, the naming class is the source type. /// For construct decls, the naming class is the target type. - struct { - bool HadMultipleCandidates; - FunctionDecl *Function; - DeclAccessPair FoundDecl; - } Function; + struct F Function; /// \brief When Kind = SK_ConversionSequence, the implicit conversion /// sequence. @@ -944,6 +963,14 @@ public: /// initializer list. void AddStdInitializerListConstructionStep(QualType T); + /// \brief Add a step to initialize an OpenCL sampler from an integer + /// constant. + void AddOCLSamplerInitStep(QualType T); + + /// \brief Add a step to initialize an OpenCL event_t from a NULL + /// constant. + void AddOCLZeroEventStep(QualType T); + /// \brief Add steps to unwrap a initializer list for a reference around a /// single element and rewrap it at the end. void RewrapReferenceInitList(QualType T, InitListExpr *Syntactic); diff --git a/include/clang/Sema/Lookup.h b/include/clang/Sema/Lookup.h index fe5d262..3e7e3a1 100644 --- a/include/clang/Sema/Lookup.h +++ b/include/clang/Sema/Lookup.h @@ -15,8 +15,8 @@ #ifndef LLVM_CLANG_SEMA_LOOKUP_H #define LLVM_CLANG_SEMA_LOOKUP_H -#include "clang/Sema/Sema.h" #include "clang/AST/DeclCXX.h" +#include "clang/Sema/Sema.h" namespace clang { @@ -138,7 +138,8 @@ public: IDNS(0), Redecl(Redecl != Sema::NotForRedeclaration), HideTags(true), - Diagnose(Redecl == Sema::NotForRedeclaration) + Diagnose(Redecl == Sema::NotForRedeclaration), + AllowHidden(Redecl == Sema::ForRedeclaration) { configure(); } @@ -158,7 +159,8 @@ public: IDNS(0), Redecl(Redecl != Sema::NotForRedeclaration), HideTags(true), - Diagnose(Redecl == Sema::NotForRedeclaration) + Diagnose(Redecl == Sema::NotForRedeclaration), + AllowHidden(Redecl == Sema::ForRedeclaration) { configure(); } @@ -176,7 +178,8 @@ public: IDNS(Other.IDNS), Redecl(Other.Redecl), HideTags(Other.HideTags), - Diagnose(false) + Diagnose(false), + AllowHidden(Other.AllowHidden) {} ~LookupResult() { @@ -214,10 +217,16 @@ public: return Redecl; } + /// \brief Specify whether hidden declarations are visible, e.g., + /// for recovery reasons. + void setAllowHidden(bool AH) { + AllowHidden = AH; + } + /// \brief Determine whether this lookup is permitted to see hidden /// declarations, such as those in modules that have not yet been imported. bool isHiddenDeclarationVisible() const { - return Redecl || LookupKind == Sema::LookupTagName; + return AllowHidden || LookupKind == Sema::LookupTagName; } /// Sets whether tag declarations should be hidden by non-tag @@ -483,6 +492,7 @@ public: /// \brief Change this lookup's redeclaration kind. void setRedeclarationKind(Sema::RedeclarationKind RK) { Redecl = RK; + AllowHidden = (RK == Sema::ForRedeclaration); configure(); } @@ -615,7 +625,7 @@ private: bool sanityCheckUnresolved() const { for (iterator I = begin(), E = end(); I != E; ++I) - if (isa<UnresolvedUsingValueDecl>(*I)) + if (isa<UnresolvedUsingValueDecl>((*I)->getUnderlyingDecl())) return true; return false; } @@ -644,6 +654,9 @@ private: bool HideTags; bool Diagnose; + + /// \brief True if we should allow hidden declarations to be 'visible'. + bool AllowHidden; }; /// \brief Consumes visible declarations found when searching for diff --git a/include/clang/Sema/Makefile b/include/clang/Sema/Makefile index f6662d6..7d658a7 100644 --- a/include/clang/Sema/Makefile +++ b/include/clang/Sema/Makefile @@ -1,6 +1,7 @@ CLANG_LEVEL := ../../.. TD_SRC_DIR = $(PROJ_SRC_DIR)/../Basic -BUILT_SOURCES = AttrTemplateInstantiate.inc AttrParsedAttrList.inc AttrParsedAttrKinds.inc +BUILT_SOURCES = AttrTemplateInstantiate.inc AttrParsedAttrList.inc AttrParsedAttrKinds.inc \ + AttrSpellingListIndex.inc TABLEGEN_INC_FILES_COMMON = 1 @@ -24,4 +25,10 @@ $(ObjDir)/AttrParsedAttrKinds.inc.tmp : $(TD_SRC_DIR)/Attr.td \ $(Verb) $(ClangTableGen) -gen-clang-attr-parsed-attr-kinds -o \ $(call SYSPATH, $@) -I $(PROJ_SRC_DIR)/../../ $< +$(ObjDir)/AttrSpellingListIndex.inc.tmp : $(TD_SRC_DIR)/Attr.td \ + $(CLANG_TBLGEN) $(ObjDir)/.dir + $(Echo) "Building Clang attribute spelling list index with tablegen" + $(Verb) $(ClangTableGen) -gen-clang-attr-spelling-index -o \ + $(call SYSPATH, $@) -I $(PROJ_SRC_DIR)/../../ $< + diff --git a/include/clang/Sema/MultiplexExternalSemaSource.h b/include/clang/Sema/MultiplexExternalSemaSource.h index 1513aeb..ff87d05 100644 --- a/include/clang/Sema/MultiplexExternalSemaSource.h +++ b/include/clang/Sema/MultiplexExternalSemaSource.h @@ -15,9 +15,7 @@ #include "clang/Sema/ExternalSemaSource.h" #include "clang/Sema/Weak.h" - #include "llvm/ADT/SmallVector.h" - #include <utility> namespace clang { @@ -41,7 +39,7 @@ namespace clang { class MultiplexExternalSemaSource : public ExternalSemaSource { private: - llvm::SmallVector<ExternalSemaSource*, 2> Sources; // doesn't own them. + SmallVector<ExternalSemaSource *, 2> Sources; // doesn't own them. public: @@ -67,58 +65,30 @@ public: /// \brief Resolve a declaration ID into a declaration, potentially /// building a new declaration. - /// - /// This method only needs to be implemented if the AST source ever - /// passes back decl sets as VisibleDeclaration objects. - /// - /// The default implementation of this method is a no-op. virtual Decl *GetExternalDecl(uint32_t ID); /// \brief Resolve a selector ID into a selector. - /// - /// This operation only needs to be implemented if the AST source - /// returns non-zero for GetNumKnownSelectors(). - /// - /// The default implementation of this method is a no-op. virtual Selector GetExternalSelector(uint32_t ID); /// \brief Returns the number of selectors known to the external AST /// source. - /// - /// The default implementation of this method is a no-op. virtual uint32_t GetNumExternalSelectors(); /// \brief Resolve the offset of a statement in the decl stream into /// a statement. - /// - /// This operation is meant to be used via a LazyOffsetPtr. It only - /// needs to be implemented if the AST source uses methods like - /// FunctionDecl::setLazyBody when building decls. - /// - /// The default implementation of this method is a no-op. virtual Stmt *GetExternalDeclStmt(uint64_t Offset); /// \brief Resolve the offset of a set of C++ base specifiers in the decl /// stream into an array of specifiers. - /// - /// The default implementation of this method is a no-op. virtual CXXBaseSpecifier *GetExternalCXXBaseSpecifiers(uint64_t Offset); - /// \brief Finds all declarations with the given name in the + /// \brief Find all declarations with the given name in the /// given context. - /// - /// Generally the final step of this method is either to call - /// SetExternalVisibleDeclsForName or to recursively call lookup on - /// the DeclContext after calling SetExternalVisibleDecls. - /// - /// The default implementation of this method is a no-op. - virtual DeclContextLookupResult + virtual bool FindExternalVisibleDeclsByName(const DeclContext *DC, DeclarationName Name); /// \brief Ensures that the table of all visible declarations inside this /// context is up to date. - /// - /// The default implementation of this functino is a no-op. virtual void completeVisibleDeclsMap(const DeclContext *DC); /// \brief Finds all declarations lexically contained within the given @@ -129,8 +99,6 @@ public: /// are returned. /// /// \return an indication of whether the load succeeded or failed. - /// - /// The default implementation of this method is a no-op. virtual ExternalLoadResult FindExternalLexicalDecls(const DeclContext *DC, bool (*isKindWeWant)(Decl::Kind), SmallVectorImpl<Decl*> &Result); @@ -174,26 +142,18 @@ public: /// \brief Notify ExternalASTSource that we started deserialization of /// a decl or type so until FinishedDeserializing is called there may be /// decls that are initializing. Must be paired with FinishedDeserializing. - /// - /// The default implementation of this method is a no-op. virtual void StartedDeserializing(); /// \brief Notify ExternalASTSource that we finished the deserialization of /// a decl or type. Must be paired with StartedDeserializing. - /// - /// The default implementation of this method is a no-op. virtual void FinishedDeserializing(); /// \brief Function that will be invoked when we begin parsing a new /// translation unit involving this external AST source. - /// - /// The default implementation of this method is a no-op. virtual void StartTranslationUnit(ASTConsumer *Consumer); /// \brief Print any statistics that have been gathered regarding /// the external AST source. - /// - /// The default implementation of this method is a no-op. virtual void PrintStats(); @@ -254,6 +214,11 @@ public: /// \brief Load the set of namespaces that are known to the external source, /// which will be used during typo correction. virtual void ReadKnownNamespaces(SmallVectorImpl<NamespaceDecl*> &Namespaces); + + /// \brief Load the set of used but not defined functions or variables with + /// internal linkage, or used but not defined inline functions. + virtual void ReadUndefinedButUsed( + llvm::DenseMap<NamedDecl*, SourceLocation> &Undefined); /// \brief Do last resort, unqualified lookup on a LookupResult that /// Sema cannot find. @@ -311,14 +276,14 @@ public: /// introduce the same declarations repeatedly. virtual void ReadDynamicClasses(SmallVectorImpl<CXXRecordDecl*> &Decls); - /// \brief Read the set of locally-scoped external declarations known to the + /// \brief Read the set of locally-scoped extern "C" declarations known to the /// external Sema source. /// /// The external source should append its own locally-scoped external - /// declarations to the given vector of declarations. Note that this routine - /// may be invoked multiple times; the external source should take care not + /// declarations to the given vector of declarations. Note that this routine + /// may be invoked multiple times; the external source should take care not /// to introduce the same declarations repeatedly. - virtual void ReadLocallyScopedExternalDecls(SmallVectorImpl<NamedDecl*>&Decls); + virtual void ReadLocallyScopedExternCDecls(SmallVectorImpl<NamedDecl*>&Decls); /// \brief Read the set of referenced selectors known to the /// external Sema source. diff --git a/include/clang/Sema/Overload.h b/include/clang/Sema/Overload.h index 65ed781..c685843 100644 --- a/include/clang/Sema/Overload.h +++ b/include/clang/Sema/Overload.h @@ -78,8 +78,9 @@ namespace clang { ICK_Vector_Splat, ///< A vector splat from an arithmetic type ICK_Complex_Real, ///< Complex-real conversions (C99 6.3.1.7) ICK_Block_Pointer_Conversion, ///< Block Pointer conversions - ICK_TransparentUnionConversion, /// Transparent Union Conversions + ICK_TransparentUnionConversion, ///< Transparent Union Conversions ICK_Writeback_Conversion, ///< Objective-C ARC writeback conversion + ICK_Zero_Event_Conversion, ///< Zero constant to event (OpenCL1.2 6.12.10) ICK_Num_Conversion_Kinds ///< The number of conversion kinds }; @@ -694,6 +695,10 @@ namespace clang { /// \brief Return the second template argument this deduction failure /// refers to, if any. const TemplateArgument *getSecondArg(); + + /// \brief Return the expression this deduction failure refers to, + /// if any. + Expr *getExpr(); /// \brief Free any memory associated with this deduction failure. void Destroy(); @@ -809,7 +814,7 @@ namespace clang { void NoteCandidates(Sema &S, OverloadCandidateDisplayKind OCD, - llvm::ArrayRef<Expr *> Args, + ArrayRef<Expr *> Args, StringRef Opc = "", SourceLocation Loc = SourceLocation()); }; diff --git a/include/clang/Sema/Ownership.h b/include/clang/Sema/Ownership.h index e59fb3f..e064b91 100644 --- a/include/clang/Sema/Ownership.h +++ b/include/clang/Sema/Ownership.h @@ -23,13 +23,10 @@ //===----------------------------------------------------------------------===// namespace clang { - class Attr; class CXXCtorInitializer; class CXXBaseSpecifier; class Decl; - class DeclGroupRef; class Expr; - class NestedNameSpecifier; class ParsedTemplateArgument; class QualType; class Stmt; diff --git a/include/clang/Sema/Scope.h b/include/clang/Sema/Scope.h index 1329f97..d016b9b 100644 --- a/include/clang/Sema/Scope.h +++ b/include/clang/Sema/Scope.h @@ -32,70 +32,66 @@ public: /// ScopeFlags - These are bitfields that are or'd together when creating a /// scope, which defines the sorts of things the scope contains. enum ScopeFlags { - /// FnScope - This indicates that the scope corresponds to a function, which + /// \brief This indicates that the scope corresponds to a function, which /// means that labels are set here. FnScope = 0x01, - /// BreakScope - This is a while,do,switch,for, etc that can have break - /// stmts embedded into it. + /// \brief This is a while, do, switch, for, etc that can have break + /// statements embedded into it. BreakScope = 0x02, - /// ContinueScope - This is a while,do,for, which can have continue - /// stmt embedded into it. + /// \brief This is a while, do, for, which can have continue statements + /// embedded into it. ContinueScope = 0x04, - /// DeclScope - This is a scope that can contain a declaration. Some scopes + /// \brief This is a scope that can contain a declaration. Some scopes /// just contain loop constructs but don't contain decls. DeclScope = 0x08, - /// ControlScope - The controlling scope in a if/switch/while/for statement. + /// \brief The controlling scope in a if/switch/while/for statement. ControlScope = 0x10, - /// ClassScope - The scope of a struct/union/class definition. + /// \brief The scope of a struct/union/class definition. ClassScope = 0x20, - /// BlockScope - This is a scope that corresponds to a block/closure object. + /// \brief This is a scope that corresponds to a block/closure object. /// Blocks serve as top-level scopes for some objects like labels, they /// also prevent things like break and continue. BlockScopes always have /// the FnScope and DeclScope flags set as well. BlockScope = 0x40, - /// TemplateParamScope - This is a scope that corresponds to the + /// \brief This is a scope that corresponds to the /// template parameters of a C++ template. Template parameter /// scope starts at the 'template' keyword and ends when the /// template declaration ends. TemplateParamScope = 0x80, - /// FunctionPrototypeScope - This is a scope that corresponds to the + /// \brief This is a scope that corresponds to the /// parameters within a function prototype. FunctionPrototypeScope = 0x100, - /// AtCatchScope - This is a scope that corresponds to the Objective-C + /// \brief This is a scope that corresponds to the parameters within + /// a function prototype for a function declaration (as opposed to any + /// other kind of function declarator). Always has FunctionPrototypeScope + /// set as well. + FunctionDeclarationScope = 0x200, + + /// \brief This is a scope that corresponds to the Objective-C /// \@catch statement. - AtCatchScope = 0x200, + AtCatchScope = 0x400, - /// ObjCMethodScope - This scope corresponds to an Objective-C method body. + /// \brief This scope corresponds to an Objective-C method body. /// It always has FnScope and DeclScope set as well. - ObjCMethodScope = 0x400, - - /// SwitchScope - This is a scope that corresponds to a switch statement. - SwitchScope = 0x800, - - /// TryScope - This is the scope of a C++ try statement. - TryScope = 0x1000, - - /// CatchScope - This is the scope of a C++ catch statement. - CatchScope = 0x2000, + ObjCMethodScope = 0x800, - /// FnTryCatchScope - This is the scope for a function-level C++ try or - /// catch scope. - FnTryCatchScope = 0x4000, + /// \brief This is a scope that corresponds to a switch statement. + SwitchScope = 0x1000, - /// FnTryScope - This is the scope of a function-level C++ try scope. - FnTryScope = TryScope | FnTryCatchScope, + /// \brief This is the scope of a C++ try statement. + TryScope = 0x2000, - /// FnCatchScope - This is the scope of a function-level C++ catch scope. - FnCatchScope = CatchScope | FnTryCatchScope + /// \brief This is the scope for a function-level C++ try or catch scope. + FnTryCatchScope = 0x4000 }; private: /// The parent scope for this scope. This is null for the translation-unit @@ -244,7 +240,11 @@ public: void setEntity(void *E) { Entity = E; } bool hasErrorOccurred() const { return ErrorTrap.hasErrorOccurred(); } - + + bool hasUnrecoverableErrorOccurred() const { + return ErrorTrap.hasUnrecoverableErrorOccurred(); + } + /// isClassScope - Return true if this scope is a class/struct/union scope. bool isClassScope() const { return (getFlags() & Scope::ClassScope); diff --git a/include/clang/Sema/ScopeInfo.h b/include/clang/Sema/ScopeInfo.h index feda9c9..2295bf4 100644 --- a/include/clang/Sema/ScopeInfo.h +++ b/include/clang/Sema/ScopeInfo.h @@ -91,6 +91,9 @@ public: /// \brief Whether this function contains any indirect gotos. bool HasIndirectGoto; + /// \brief Whether a statement was dropped because it was invalid. + bool HasDroppedStmt; + /// A flag that is set when parsing a method that must call super's /// implementation, such as \c -dealloc, \c -finalize, or any method marked /// with \c __attribute__((objc_requires_super)). @@ -287,9 +290,14 @@ public: HasIndirectGoto = true; } + void setHasDroppedStmt() { + HasDroppedStmt = true; + } + bool NeedsScopeChecking() const { - return HasIndirectGoto || - (HasBranchProtectedScope && HasBranchIntoScope); + return !HasDroppedStmt && + (HasIndirectGoto || + (HasBranchProtectedScope && HasBranchIntoScope)); } FunctionScopeInfo(DiagnosticsEngine &Diag) @@ -297,6 +305,7 @@ public: HasBranchProtectedScope(false), HasBranchIntoScope(false), HasIndirectGoto(false), + HasDroppedStmt(false), ObjCShouldCallSuper(false), ErrorTrap(Diag) { } @@ -511,11 +520,11 @@ public: bool ContainsUnexpandedParameterPack; /// \brief Variables used to index into by-copy array captures. - llvm::SmallVector<VarDecl *, 4> ArrayIndexVars; + SmallVector<VarDecl *, 4> ArrayIndexVars; /// \brief Offsets into the ArrayIndexVars array at which each capture starts /// its list of array index variables. - llvm::SmallVector<unsigned, 4> ArrayIndexStarts; + SmallVector<unsigned, 4> ArrayIndexStarts; LambdaScopeInfo(DiagnosticsEngine &Diag, CXXRecordDecl *Lambda, CXXMethodDecl *CallOperator) diff --git a/include/clang/Sema/Sema.h b/include/clang/Sema/Sema.h index 9b572d8..5b93e51 100644 --- a/include/clang/Sema/Sema.h +++ b/include/clang/Sema/Sema.h @@ -15,27 +15,30 @@ #ifndef LLVM_CLANG_SEMA_SEMA_H #define LLVM_CLANG_SEMA_SEMA_H -#include "clang/Sema/Ownership.h" -#include "clang/Sema/AnalysisBasedWarnings.h" -#include "clang/Sema/IdentifierResolver.h" -#include "clang/Sema/ObjCMethodList.h" -#include "clang/Sema/DeclSpec.h" -#include "clang/Sema/ExternalSemaSource.h" -#include "clang/Sema/LocInfoType.h" -#include "clang/Sema/TypoCorrection.h" -#include "clang/Sema/Weak.h" +#include "clang/AST/Attr.h" +#include "clang/AST/DeclarationName.h" #include "clang/AST/Expr.h" #include "clang/AST/ExprObjC.h" -#include "clang/AST/DeclarationName.h" #include "clang/AST/ExternalASTSource.h" #include "clang/AST/LambdaMangleContext.h" -#include "clang/AST/TypeLoc.h" #include "clang/AST/NSAPI.h" -#include "clang/Lex/ModuleLoader.h" +#include "clang/AST/PrettyPrinter.h" +#include "clang/AST/TypeLoc.h" +#include "clang/Basic/ExpressionTraits.h" +#include "clang/Basic/LangOptions.h" #include "clang/Basic/Specifiers.h" #include "clang/Basic/TemplateKinds.h" #include "clang/Basic/TypeTraits.h" -#include "clang/Basic/ExpressionTraits.h" +#include "clang/Lex/ModuleLoader.h" +#include "clang/Sema/AnalysisBasedWarnings.h" +#include "clang/Sema/DeclSpec.h" +#include "clang/Sema/ExternalSemaSource.h" +#include "clang/Sema/IdentifierResolver.h" +#include "clang/Sema/LocInfoType.h" +#include "clang/Sema/ObjCMethodList.h" +#include "clang/Sema/Ownership.h" +#include "clang/Sema/TypoCorrection.h" +#include "clang/Sema/Weak.h" #include "llvm/ADT/ArrayRef.h" #include "llvm/ADT/Optional.h" #include "llvm/ADT/OwningPtr.h" @@ -129,6 +132,7 @@ namespace clang { class ObjCMethodDecl; class ObjCPropertyDecl; class ObjCProtocolDecl; + class OMPThreadPrivateDecl; class OverloadCandidateSet; class OverloadExpr; class ParenListExpr; @@ -197,6 +201,8 @@ class Sema { ///\brief Whether Sema has generated a multiplexer and has to delete it. bool isMultiplexExternalSource; + static bool mightHaveNonExternalLinkage(const DeclaratorDecl *FD); + public: typedef OpaquePtr<DeclGroupRef> DeclGroupPtrTy; typedef OpaquePtr<TemplateName> TemplateTy; @@ -253,7 +259,7 @@ public: /// element type here is ExprWithCleanups::Object. SmallVector<BlockDecl*, 8> ExprCleanupObjects; - llvm::SmallPtrSet<Expr*, 8> MaybeODRUseExprs; + llvm::SmallPtrSet<Expr*, 2> MaybeODRUseExprs; /// \brief Stack containing information about each of the nested /// function, block, and method scopes that are currently active. @@ -272,12 +278,6 @@ public: /// This is only necessary for issuing pretty diagnostics. ExtVectorDeclsType ExtVectorDecls; - /// \brief The set of types for which we have already complained about the - /// definitions being hidden. - /// - /// This set is used to suppress redundant diagnostics. - llvm::SmallPtrSet<NamedDecl *, 4> HiddenDefinitions; - /// FieldCollector - Collects CXXFieldDecls during parsing of C++ classes. OwningPtr<CXXFieldCollector> FieldCollector; @@ -298,35 +298,35 @@ public: llvm::SmallPtrSet<const Decl*, 4> ParsingInitForAutoVars; /// \brief A mapping from external names to the most recent - /// locally-scoped external declaration with that name. + /// locally-scoped extern "C" declaration with that name. /// /// This map contains external declarations introduced in local - /// scoped, e.g., + /// scopes, e.g., /// /// \code - /// void f() { + /// extern "C" void f() { /// void foo(int, int); /// } /// \endcode /// - /// Here, the name "foo" will be associated with the declaration on + /// Here, the name "foo" will be associated with the declaration of /// "foo" within f. This name is not visible outside of /// "f". However, we still find it in two cases: /// - /// - If we are declaring another external with the name "foo", we - /// can find "foo" as a previous declaration, so that the types - /// of this external declaration can be checked for - /// compatibility. + /// - If we are declaring another global or extern "C" entity with + /// the name "foo", we can find "foo" as a previous declaration, + /// so that the types of this external declaration can be checked + /// for compatibility. /// /// - If we would implicitly declare "foo" (e.g., due to a call to /// "foo" in C when no prototype or definition is visible), then /// we find this declaration of "foo" and complain that it is /// not visible. - llvm::DenseMap<DeclarationName, NamedDecl *> LocallyScopedExternalDecls; + llvm::DenseMap<DeclarationName, NamedDecl *> LocallyScopedExternCDecls; - /// \brief Look for a locally scoped external declaration by the given name. + /// \brief Look for a locally scoped extern "C" declaration by the given name. llvm::DenseMap<DeclarationName, NamedDecl *>::iterator - findLocallyScopedExternalDecl(DeclarationName Name); + findLocallyScopedExternCDecl(DeclarationName Name); typedef LazyVector<VarDecl *, ExternalSemaSource, &ExternalSemaSource::ReadTentativeDefinitions, 2, 2> @@ -363,6 +363,16 @@ public: const CXXDestructorDecl*>, 2> DelayedDestructorExceptionSpecChecks; + /// \brief All the members seen during a class definition which were both + /// explicitly defaulted and had explicitly-specified exception + /// specifications, along with the function type containing their + /// user-specified exception specification. Those exception specifications + /// were overridden with the default specifications, but we still need to + /// check whether they are compatible with the default specification, and + /// we can't do that until the nesting set of class definitions is complete. + SmallVector<std::pair<CXXMethodDecl*, const FunctionProtoType*>, 2> + DelayedDefaultedMemberExceptionSpecs; + /// \brief Callback to the parser to parse templated functions when needed. typedef void LateTemplateParserCB(void *P, const FunctionDecl *FD); LateTemplateParserCB *LateTemplateParser; @@ -533,7 +543,7 @@ public: RecordDecl *MSVCGuidDecl; /// \brief Caches identifiers/selectors for NSFoundation APIs. - llvm::OwningPtr<NSAPI> NSAPIObj; + OwningPtr<NSAPI> NSAPIObj; /// \brief The declaration of the Objective-C NSNumber class. ObjCInterfaceDecl *NSNumberDecl; @@ -568,6 +578,9 @@ public: /// \brief id<NSCopying> type. QualType QIDNSCopying; + /// \brief will hold 'respondsToSelector:' + Selector RespondsToSelectorSel; + /// A flag to remember whether the implicit forms of operator new and delete /// have been declared. bool GlobalNewDeleteDeclared; @@ -619,11 +632,11 @@ public: /// this expression evaluation context. unsigned NumCleanupObjects; - llvm::SmallPtrSet<Expr*, 8> SavedMaybeODRUseExprs; + llvm::SmallPtrSet<Expr*, 2> SavedMaybeODRUseExprs; /// \brief The lambdas that are present within this context, if it /// is indeed an unevaluated context. - llvm::SmallVector<LambdaExpr *, 2> Lambdas; + SmallVector<LambdaExpr *, 2> Lambdas; /// \brief The declaration that provides context for the lambda expression /// if the normal declaration context does not suffice, e.g., in a @@ -635,15 +648,15 @@ public: /// /// This mangling information is allocated lazily, since most contexts /// do not have lambda expressions. - LambdaMangleContext *LambdaMangle; + IntrusiveRefCntPtr<LambdaMangleContext> LambdaMangle; /// \brief If we are processing a decltype type, a set of call expressions /// for which we have deferred checking the completeness of the return type. - llvm::SmallVector<CallExpr*, 8> DelayedDecltypeCalls; + SmallVector<CallExpr *, 8> DelayedDecltypeCalls; /// \brief If we are processing a decltype type, a set of temporary binding /// expressions for which we have deferred checking the destructor. - llvm::SmallVector<CXXBindTemporaryExpr*, 8> DelayedDecltypeBinds; + SmallVector<CXXBindTemporaryExpr *, 8> DelayedDecltypeBinds; ExpressionEvaluationContextRecord(ExpressionEvaluationContext Context, unsigned NumCleanupObjects, @@ -654,10 +667,6 @@ public: IsDecltype(IsDecltype), NumCleanupObjects(NumCleanupObjects), LambdaContextDecl(LambdaContextDecl), LambdaMangle() { } - ~ExpressionEvaluationContextRecord() { - delete LambdaMangle; - } - /// \brief Retrieve the mangling context for lambdas. LambdaMangleContext &getLambdaMangleContext() { assert(LambdaContextDecl && "Need to have a lambda context declaration"); @@ -730,11 +739,15 @@ public: // Contains the locations of the beginning of unparsed default // argument locations. - llvm::DenseMap<ParmVarDecl *,SourceLocation> UnparsedDefaultArgLocs; + llvm::DenseMap<ParmVarDecl *, SourceLocation> UnparsedDefaultArgLocs; + + /// UndefinedInternals - all the used, undefined objects which require a + /// definition in this translation unit. + llvm::DenseMap<NamedDecl *, SourceLocation> UndefinedButUsed; - /// UndefinedInternals - all the used, undefined objects with - /// internal linkage in this translation unit. - llvm::DenseMap<NamedDecl*, SourceLocation> UndefinedInternals; + /// Obtain a sorted list of functions that are undefined but ODR-used. + void getUndefinedButUsed( + llvm::SmallVectorImpl<std::pair<NamedDecl *, SourceLocation> > &Undefined); typedef std::pair<ObjCMethodList, ObjCMethodList> GlobalMethods; typedef llvm::DenseMap<Selector, GlobalMethods> GlobalMethodPool; @@ -749,6 +762,24 @@ public: /// of -Wselector. llvm::DenseMap<Selector, SourceLocation> ReferencedSelectors; + /// Kinds of C++ special members. + enum CXXSpecialMember { + CXXDefaultConstructor, + CXXCopyConstructor, + CXXMoveConstructor, + CXXCopyAssignment, + CXXMoveAssignment, + CXXDestructor, + CXXInvalid + }; + + typedef std::pair<CXXRecordDecl*, CXXSpecialMember> SpecialMemberDecl; + + /// The C++ special members which we are currently in the process of + /// declaring. If this process recursively triggers the declaration of the + /// same special member, we should act as if it is not yet declared. + llvm::SmallSet<SpecialMemberDecl, 4> SpecialMembersBeingDeclared; + void ReadMethodPool(Selector Sel); /// Private Helper predicate to check for 'self'. @@ -903,10 +934,10 @@ public: // Type Analysis / Processing: SemaType.cpp. // - QualType BuildQualifiedType(QualType T, SourceLocation Loc, Qualifiers Qs); - QualType BuildQualifiedType(QualType T, SourceLocation Loc, unsigned CVR) { - return BuildQualifiedType(T, Loc, Qualifiers::fromCVRMask(CVR)); - } + QualType BuildQualifiedType(QualType T, SourceLocation Loc, Qualifiers Qs, + const DeclSpec *DS = 0); + QualType BuildQualifiedType(QualType T, SourceLocation Loc, unsigned CVRA, + const DeclSpec *DS = 0); QualType BuildPointerType(QualType T, SourceLocation Loc, DeclarationName Entity); QualType BuildReferenceType(QualType T, bool LValueRef, @@ -916,12 +947,39 @@ public: SourceRange Brackets, DeclarationName Entity); QualType BuildExtVectorType(QualType T, Expr *ArraySize, SourceLocation AttrLoc); + + /// \brief Build a function type. + /// + /// This routine checks the function type according to C++ rules and + /// under the assumption that the result type and parameter types have + /// just been instantiated from a template. It therefore duplicates + /// some of the behavior of GetTypeForDeclarator, but in a much + /// simpler form that is only suitable for this narrow use case. + /// + /// \param T The return type of the function. + /// + /// \param ParamTypes The parameter types of the function. This array + /// will be modified to account for adjustments to the types of the + /// function parameters. + /// + /// \param Loc The location of the entity whose type involves this + /// function type or, if there is no such entity, the location of the + /// type that will have function type. + /// + /// \param Entity The name of the entity that involves the function + /// type, if known. + /// + /// \param EPI Extra information about the function type. Usually this will + /// be taken from an existing function with the same prototype. + /// + /// \returns A suitable function type, if there are no errors. The + /// unqualified type will always be a FunctionProtoType. + /// Otherwise, returns a NULL type. QualType BuildFunctionType(QualType T, - QualType *ParamTypes, unsigned NumParamTypes, - bool Variadic, bool HasTrailingReturn, - unsigned Quals, RefQualifierKind RefQualifier, + llvm::MutableArrayRef<QualType> ParamTypes, SourceLocation Loc, DeclarationName Entity, - FunctionType::ExtInfo Info); + const FunctionProtoType::ExtProtoInfo &EPI); + QualType BuildMemberPointerType(QualType T, QualType Class, SourceLocation Loc, DeclarationName Entity); @@ -943,7 +1001,7 @@ public: CanThrowResult canThrow(const Expr *E); const FunctionProtoType *ResolveExceptionSpec(SourceLocation Loc, const FunctionProtoType *FPT); - bool CheckSpecifiedExceptionType(QualType T, const SourceRange &Range); + bool CheckSpecifiedExceptionType(QualType &T, const SourceRange &Range); bool CheckDistantExceptionSpec(QualType T); bool CheckEquivalentExceptionSpec(FunctionDecl *Old, FunctionDecl *New); bool CheckEquivalentExceptionSpec( @@ -1291,8 +1349,8 @@ public: Decl *ActOnDeclarator(Scope *S, Declarator &D); - Decl *HandleDeclarator(Scope *S, Declarator &D, - MultiTemplateParamsArg TemplateParameterLists); + NamedDecl *HandleDeclarator(Scope *S, Declarator &D, + MultiTemplateParamsArg TemplateParameterLists); void RegisterLocallyScopedExternCDecl(NamedDecl *ND, const LookupResult &Previous, Scope *S); @@ -1300,7 +1358,7 @@ public: bool diagnoseQualifiedDeclaration(CXXScopeSpec &SS, DeclContext *DC, DeclarationName Name, SourceLocation Loc); - void DiagnoseFunctionSpecifiers(Declarator& D); + void DiagnoseFunctionSpecifiers(const DeclSpec &DS); void CheckShadow(Scope *S, VarDecl *D, const LookupResult& R); void CheckShadow(Scope *S, VarDecl *D); void CheckCastAlign(Expr *Op, QualType T, SourceRange TRange); @@ -1317,6 +1375,7 @@ public: // Returns true if the variable declaration is a redeclaration bool CheckVariableDeclaration(VarDecl *NewVD, LookupResult &Previous); void CheckCompleteVariableDeclaration(VarDecl *var); + void MaybeSuggestAddingStaticToDecl(const FunctionDecl *D); void ActOnStartFunctionDeclarator(); void ActOnEndFunctionDeclarator(); NamedDecl* ActOnFunctionDeclarator(Scope* S, Declarator& D, DeclContext* DC, @@ -1343,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); @@ -1383,9 +1442,19 @@ public: return D && isa<ObjCMethodDecl>(D); } + /// \brief Determine whether we can skip parsing the body of a function + /// definition, assuming we don't care about analyzing its body or emitting + /// code for that function. + /// + /// This will be \c false only if we may need the body of the function in + /// order to parse the rest of the program (for instance, if it is + /// \c constexpr in C++11 or has an 'auto' return type in C++14). + bool canSkipFunctionBody(Decl *D); + void computeNRVO(Stmt *Body, sema::FunctionScopeInfo *Scope); Decl *ActOnFinishFunctionBody(Decl *Decl, Stmt *Body); Decl *ActOnFinishFunctionBody(Decl *Decl, Stmt *Body, bool IsInstantiation); + Decl *ActOnSkippedFunctionBody(Decl *Decl); /// ActOnFinishDelayedAttribute - Invoked when we have finished parsing an /// attribute for which parsing is delayed. @@ -1409,6 +1478,11 @@ public: SourceLocation AsmLoc, SourceLocation RParenLoc); + /// \brief Handle a C++11 empty-declaration and attribute-declaration. + Decl *ActOnEmptyDeclaration(Scope *S, + AttributeList *AttrList, + SourceLocation SemiLoc); + /// \brief The parser has processed a module import declaration. /// /// \param AtLoc The location of the '@' symbol, if any. @@ -1419,6 +1493,14 @@ public: DeclResult ActOnModuleImport(SourceLocation AtLoc, SourceLocation ImportLoc, ModuleIdPath Path); + /// \brief Create an implicit import of the given module at the given + /// source location. + /// + /// This routine is typically used for error recovery, when the entity found + /// by name lookup is actually hidden within a module that we know about but + /// the user has forgotten to import. + void createImplicitModuleImport(SourceLocation Loc, Module *Mod); + /// \brief Retrieve a suitable printing policy. PrintingPolicy getPrintingPolicy() const { return getPrintingPolicy(Context, PP); @@ -1436,7 +1518,8 @@ public: DeclSpec &DS); Decl *ParsedFreeStandingDeclSpec(Scope *S, AccessSpecifier AS, DeclSpec &DS, - MultiTemplateParamsArg TemplateParams); + MultiTemplateParamsArg TemplateParams, + bool IsExplicitInstantiation = false); Decl *BuildAnonymousStructOrUnion(Scope *S, DeclSpec &DS, AccessSpecifier AS, @@ -1502,17 +1585,10 @@ public: AccessSpecifier AS, NamedDecl *PrevDecl, Declarator *D = 0); - enum CXXSpecialMember { - CXXDefaultConstructor, - CXXCopyConstructor, - CXXMoveConstructor, - CXXCopyAssignment, - CXXMoveAssignment, - CXXDestructor, - CXXInvalid - }; bool CheckNontrivialField(FieldDecl *FD); - void DiagnoseNontrivial(const RecordType* Record, CXXSpecialMember mem); + void DiagnoseNontrivial(const CXXRecordDecl *Record, CXXSpecialMember CSM); + bool SpecialMemberIsTrivial(CXXMethodDecl *MD, CXXSpecialMember CSM, + bool Diagnose = false); CXXSpecialMember getSpecialMember(const CXXMethodDecl *MD); void ActOnLastBitfield(SourceLocation DeclStart, SmallVectorImpl<Decl *> &AllIvarDecls); @@ -1522,7 +1598,7 @@ public: // This is used for both record definitions and ObjC interface declarations. void ActOnFields(Scope* S, SourceLocation RecLoc, Decl *TagDecl, - llvm::ArrayRef<Decl *> Fields, + ArrayRef<Decl *> Fields, SourceLocation LBrac, SourceLocation RBrac, AttributeList *AttrList); @@ -1639,30 +1715,54 @@ public: bool isIncompatibleTypedef(TypeDecl *Old, TypedefNameDecl *New); /// Attribute merging methods. Return true if a new attribute was added. - AvailabilityAttr *mergeAvailabilityAttr(Decl *D, SourceRange Range, + AvailabilityAttr *mergeAvailabilityAttr(NamedDecl *D, SourceRange Range, IdentifierInfo *Platform, VersionTuple Introduced, VersionTuple Deprecated, VersionTuple Obsoleted, bool IsUnavailable, - StringRef Message); + StringRef Message, + bool Override, + unsigned AttrSpellingListIndex); + TypeVisibilityAttr *mergeTypeVisibilityAttr(Decl *D, SourceRange Range, + TypeVisibilityAttr::VisibilityType Vis, + unsigned AttrSpellingListIndex); VisibilityAttr *mergeVisibilityAttr(Decl *D, SourceRange Range, - VisibilityAttr::VisibilityType Vis); - DLLImportAttr *mergeDLLImportAttr(Decl *D, SourceRange Range); - DLLExportAttr *mergeDLLExportAttr(Decl *D, SourceRange Range); + VisibilityAttr::VisibilityType Vis, + unsigned AttrSpellingListIndex); + DLLImportAttr *mergeDLLImportAttr(Decl *D, SourceRange Range, + unsigned AttrSpellingListIndex); + DLLExportAttr *mergeDLLExportAttr(Decl *D, SourceRange Range, + unsigned AttrSpellingListIndex); FormatAttr *mergeFormatAttr(Decl *D, SourceRange Range, StringRef Format, - int FormatIdx, int FirstArg); - SectionAttr *mergeSectionAttr(Decl *D, SourceRange Range, StringRef Name); - bool mergeDeclAttribute(Decl *New, InheritableAttr *Attr); + int FormatIdx, int FirstArg, + unsigned AttrSpellingListIndex); + SectionAttr *mergeSectionAttr(Decl *D, SourceRange Range, StringRef Name, + unsigned AttrSpellingListIndex); + + /// \brief Describes the kind of merge to perform for availability + /// attributes (including "deprecated", "unavailable", and "availability"). + enum AvailabilityMergeKind { + /// \brief Don't merge availability attributes at all. + AMK_None, + /// \brief Merge availability attributes for a redeclaration, which requires + /// an exact match. + AMK_Redeclaration, + /// \brief Merge availability attributes for an override, which requires + /// an exact match or a weakening of constraints. + AMK_Override + }; - void mergeDeclAttributes(Decl *New, Decl *Old, bool MergeDeprecation = true); + void mergeDeclAttributes(NamedDecl *New, Decl *Old, + AvailabilityMergeKind AMK = AMK_Redeclaration); void MergeTypedefNameDecl(TypedefNameDecl *New, LookupResult &OldDecls); bool MergeFunctionDecl(FunctionDecl *New, Decl *Old, Scope *S); bool MergeCompatibleFunctionDecls(FunctionDecl *New, FunctionDecl *Old, Scope *S); void mergeObjCMethodDecls(ObjCMethodDecl *New, ObjCMethodDecl *Old); - void MergeVarDecl(VarDecl *New, LookupResult &OldDecls); - void MergeVarDeclTypes(VarDecl *New, VarDecl *Old); + void MergeVarDecl(VarDecl *New, LookupResult &OldDecls, + bool OldDeclsWereHidden); + void MergeVarDeclTypes(VarDecl *New, VarDecl *Old, bool OldIsHidden); void MergeVarDeclExceptionSpecs(VarDecl *New, VarDecl *Old); bool MergeCXXFunctionDecl(FunctionDecl *New, FunctionDecl *Old, Scope *S); @@ -1841,6 +1941,19 @@ public: }; ObjCSubscriptKind CheckSubscriptingKind(Expr *FromE); + // Note that LK_String is intentionally after the other literals, as + // this is used for diagnostics logic. + enum ObjCLiteralKind { + LK_Array, + LK_Dictionary, + LK_Numeric, + LK_Boxed, + LK_String, + LK_Block, + LK_None + }; + ObjCLiteralKind CheckLiteralKind(Expr *FromE); + ExprResult PerformObjectMemberConversion(Expr *From, NestedNameSpecifier *Qualifier, NamedDecl *FoundDecl, @@ -1853,13 +1966,13 @@ public: void AddOverloadCandidate(FunctionDecl *Function, DeclAccessPair FoundDecl, - llvm::ArrayRef<Expr *> Args, + ArrayRef<Expr *> Args, OverloadCandidateSet& CandidateSet, bool SuppressUserConversions = false, bool PartialOverloading = false, bool AllowExplicit = false); void AddFunctionCandidates(const UnresolvedSetImpl &Functions, - llvm::ArrayRef<Expr *> Args, + ArrayRef<Expr *> Args, OverloadCandidateSet& CandidateSet, bool SuppressUserConversions = false, TemplateArgumentListInfo *ExplicitTemplateArgs = 0); @@ -1873,7 +1986,7 @@ public: DeclAccessPair FoundDecl, CXXRecordDecl *ActingContext, QualType ObjectType, Expr::Classification ObjectClassification, - llvm::ArrayRef<Expr *> Args, + ArrayRef<Expr *> Args, OverloadCandidateSet& CandidateSet, bool SuppressUserConversions = false); void AddMethodTemplateCandidate(FunctionTemplateDecl *MethodTmpl, @@ -1882,13 +1995,13 @@ public: TemplateArgumentListInfo *ExplicitTemplateArgs, QualType ObjectType, Expr::Classification ObjectClassification, - llvm::ArrayRef<Expr *> Args, + ArrayRef<Expr *> Args, OverloadCandidateSet& CandidateSet, bool SuppressUserConversions = false); void AddTemplateOverloadCandidate(FunctionTemplateDecl *FunctionTemplate, DeclAccessPair FoundDecl, TemplateArgumentListInfo *ExplicitTemplateArgs, - llvm::ArrayRef<Expr *> Args, + ArrayRef<Expr *> Args, OverloadCandidateSet& CandidateSet, bool SuppressUserConversions = false); void AddConversionCandidate(CXXConversionDecl *Conversion, @@ -1905,7 +2018,7 @@ public: DeclAccessPair FoundDecl, CXXRecordDecl *ActingContext, const FunctionProtoType *Proto, - Expr *Object, llvm::ArrayRef<Expr*> Args, + Expr *Object, ArrayRef<Expr *> Args, OverloadCandidateSet& CandidateSet); void AddMemberOperatorCandidates(OverloadedOperatorKind Op, SourceLocation OpLoc, @@ -1923,7 +2036,7 @@ public: OverloadCandidateSet& CandidateSet); void AddArgumentDependentLookupCandidates(DeclarationName Name, bool Operator, SourceLocation Loc, - llvm::ArrayRef<Expr *> Args, + ArrayRef<Expr *> Args, TemplateArgumentListInfo *ExplicitTemplateArgs, OverloadCandidateSet& CandidateSet, bool PartialOverloading = false); @@ -1971,7 +2084,7 @@ public: FunctionDecl *Fn); void AddOverloadedCallCandidates(UnresolvedLookupExpr *ULE, - llvm::ArrayRef<Expr *> Args, + ArrayRef<Expr *> Args, OverloadCandidateSet &CandidateSet, bool PartialOverloading = false); @@ -2164,7 +2277,7 @@ private: // // The boolean value will be true to indicate that the namespace was loaded // from an AST/PCH file, or false otherwise. - llvm::DenseMap<NamespaceDecl*, bool> KnownNamespaces; + llvm::MapVector<NamespaceDecl*, bool> KnownNamespaces; /// \brief Whether we have already loaded known namespaces from an extenal /// source. @@ -2218,7 +2331,7 @@ public: void ArgumentDependentLookup(DeclarationName Name, bool Operator, SourceLocation Loc, - llvm::ArrayRef<Expr *> Args, + ArrayRef<Expr *> Args, ADLResult &Functions); void LookupVisibleDecls(Scope *S, LookupNameKind Kind, @@ -2237,7 +2350,7 @@ public: const ObjCObjectPointerType *OPT = 0); void FindAssociatedClassesAndNamespaces(SourceLocation InstantiationLoc, - llvm::ArrayRef<Expr *> Args, + ArrayRef<Expr *> Args, AssociatedNamespaceSet &AssociatedNamespaces, AssociatedClassSet &AssociatedClasses); @@ -2260,19 +2373,25 @@ public: // More parsing and symbol table subroutines. + void ProcessPragmaWeak(Scope *S, Decl *D); // Decl attributes - this routine is the top level dispatcher. void ProcessDeclAttributes(Scope *S, Decl *D, const Declarator &PD, - bool NonInheritable = true, bool Inheritable = true); + bool NonInheritable = true, + bool Inheritable = true); void ProcessDeclAttributeList(Scope *S, Decl *D, const AttributeList *AL, - bool NonInheritable = true, bool Inheritable = true); + bool NonInheritable = true, + bool Inheritable = true, + bool IncludeCXX11Attributes = true); bool ProcessAccessDeclAttributeList(AccessSpecDecl *ASDecl, const AttributeList *AttrList); void checkUnusedDeclAttributes(Declarator &D); bool CheckRegparmAttr(const AttributeList &attr, unsigned &value); - bool CheckCallingConvAttr(const AttributeList &attr, CallingConv &CC); + bool CheckCallingConvAttr(const AttributeList &attr, CallingConv &CC, + const FunctionDecl *FD = 0); bool CheckNoReturnAttr(const AttributeList &attr); + void CheckAlignasUnderalignment(Decl *D); /// \brief Stmt attributes - this routine is the top level dispatcher. StmtResult ProcessStmtAttributes(Stmt *Stmt, AttributeList *Attrs, @@ -2339,21 +2458,27 @@ public: llvm::DenseMap<IdentifierInfo *, ObjCPropertyDecl*>& PropMap, llvm::DenseMap<IdentifierInfo *, ObjCPropertyDecl*>& SuperPropMap); + /// IvarBacksCurrentMethodAccessor - This routine returns 'true' if 'IV' is + /// an ivar synthesized for 'Method' and 'Method' is a property accessor + /// declared in class 'IFace'. + bool IvarBacksCurrentMethodAccessor(ObjCInterfaceDecl *IFace, + ObjCMethodDecl *Method, ObjCIvarDecl *IV); + /// Called by ActOnProperty to handle \@property declarations in /// class extensions. - Decl *HandlePropertyInClassExtension(Scope *S, - SourceLocation AtLoc, - SourceLocation LParenLoc, - FieldDeclarator &FD, - Selector GetterSel, - Selector SetterSel, - const bool isAssign, - const bool isReadWrite, - const unsigned Attributes, - const unsigned AttributesAsWritten, - bool *isOverridingProperty, - TypeSourceInfo *T, - tok::ObjCKeywordKind MethodImplKind); + ObjCPropertyDecl *HandlePropertyInClassExtension(Scope *S, + SourceLocation AtLoc, + SourceLocation LParenLoc, + FieldDeclarator &FD, + Selector GetterSel, + Selector SetterSel, + const bool isAssign, + const bool isReadWrite, + const unsigned Attributes, + const unsigned AttributesAsWritten, + bool *isOverridingProperty, + TypeSourceInfo *T, + tok::ObjCKeywordKind MethodImplKind); /// Called by ActOnProperty and HandlePropertyInClassExtension to /// handle creating the ObjcPropertyDecl for a category or \@interface. @@ -2507,8 +2632,15 @@ public: FullExprArg MakeFullExpr(Expr *Arg, SourceLocation CC) { return FullExprArg(ActOnFinishFullExpr(Arg, CC).release()); } + FullExprArg MakeFullDiscardedValueExpr(Expr *Arg) { + ExprResult FE = + ActOnFinishFullExpr(Arg, Arg ? Arg->getExprLoc() : SourceLocation(), + /*DiscardedValue*/ true); + return FullExprArg(FE.release()); + } - StmtResult ActOnExprStmt(FullExprArg Expr); + StmtResult ActOnExprStmt(ExprResult Arg); + StmtResult ActOnExprStmtError(); StmtResult ActOnNullStmt(SourceLocation SemiLoc, bool HasLeadingEmptyMacro = false); @@ -2616,7 +2748,7 @@ public: SourceLocation StarLoc, Expr *DestExp); StmtResult ActOnContinueStmt(SourceLocation ContinueLoc, Scope *CurScope); - StmtResult ActOnBreakStmt(SourceLocation GotoLoc, Scope *CurScope); + StmtResult ActOnBreakStmt(SourceLocation BreakLoc, Scope *CurScope); const VarDecl *getCopyElisionCandidate(QualType ReturnType, Expr *E, bool AllowFunctionParameters); @@ -2632,7 +2764,8 @@ public: SourceLocation RParenLoc); NamedDecl *LookupInlineAsmIdentifier(StringRef Name, SourceLocation Loc, - unsigned &Size); + unsigned &Length, unsigned &Size, + unsigned &Type, bool &IsVarDecl); bool LookupInlineAsmField(StringRef Base, StringRef Member, unsigned &Offset, SourceLocation AsmLoc); StmtResult ActOnMSAsmStmt(SourceLocation AsmLoc, SourceLocation LBraceLoc, @@ -2766,7 +2899,7 @@ public: void DiscardCleanupsInEvaluationContext(); - ExprResult TranformToPotentiallyEvaluated(Expr *E); + ExprResult TransformToPotentiallyEvaluated(Expr *E); ExprResult HandleExprEvaluationContextForTypeof(Expr *E); ExprResult ActOnConstantExpression(ExprResult Res); @@ -2777,7 +2910,7 @@ public: // for expressions referring to a decl; these exist because odr-use marking // needs to be delayed for some constant variables when we build one of the // named expressions. - void MarkAnyDeclReferenced(SourceLocation Loc, Decl *D); + void MarkAnyDeclReferenced(SourceLocation Loc, Decl *D, bool OdrUse); void MarkFunctionReferenced(SourceLocation Loc, FunctionDecl *Func); void MarkVariableReferenced(SourceLocation Loc, VarDecl *Var); void MarkDeclRefReferenced(DeclRefExpr *E); @@ -2873,7 +3006,7 @@ public: bool DiagnoseEmptyLookup(Scope *S, CXXScopeSpec &SS, LookupResult &R, CorrectionCandidateCallback &CCC, TemplateArgumentListInfo *ExplicitTemplateArgs = 0, - llvm::ArrayRef<Expr *> Args = llvm::ArrayRef<Expr *>()); + ArrayRef<Expr *> Args = ArrayRef<Expr *>()); ExprResult LookupInObjCMethod(LookupResult &LookUp, Scope *S, IdentifierInfo *II, @@ -2892,7 +3025,8 @@ public: ExprResult BuildDeclRefExpr(ValueDecl *D, QualType Ty, ExprValueKind VK, const DeclarationNameInfo &NameInfo, - const CXXScopeSpec *SS = 0); + const CXXScopeSpec *SS = 0, + NamedDecl *FoundD = 0); ExprResult BuildAnonymousStructUnionMemberReference(const CXXScopeSpec &SS, SourceLocation nameLoc, @@ -2925,7 +3059,7 @@ public: bool NeedsADL); ExprResult BuildDeclarationNameExpr(const CXXScopeSpec &SS, const DeclarationNameInfo &NameInfo, - NamedDecl *D); + NamedDecl *D, NamedDecl *FoundD = 0); ExprResult BuildLiteralOperatorCall(LookupResult &R, DeclarationNameInfo &SuffixInfo, @@ -3334,15 +3468,9 @@ public: MultiTemplateParamsArg TemplateParams, SourceLocation UsingLoc, UnqualifiedId &Name, + AttributeList *AttrList, TypeResult Type); - /// InitializeVarWithConstructor - Creates an CXXConstructExpr - /// and sets it as the initializer for the passed in VarDecl. - bool InitializeVarWithConstructor(VarDecl *VD, - CXXConstructorDecl *Constructor, - MultiExprArg Exprs, - bool HadMultipleCandidates); - /// BuildCXXConstructExpr - Creates a complete call to a constructor, /// including handling of its default argument expressions. /// @@ -3350,8 +3478,9 @@ public: ExprResult BuildCXXConstructExpr(SourceLocation ConstructLoc, QualType DeclInitType, CXXConstructorDecl *Constructor, MultiExprArg Exprs, - bool HadMultipleCandidates, bool RequiresZeroInit, - unsigned ConstructKind, SourceRange ParenRange); + bool HadMultipleCandidates, bool IsListInitialization, + bool RequiresZeroInit, unsigned ConstructKind, + SourceRange ParenRange); // FIXME: Can re remove this and have the above BuildCXXConstructExpr check if // the constructor can be elidable? @@ -3359,8 +3488,8 @@ public: BuildCXXConstructExpr(SourceLocation ConstructLoc, QualType DeclInitType, CXXConstructorDecl *Constructor, bool Elidable, MultiExprArg Exprs, bool HadMultipleCandidates, - bool RequiresZeroInit, unsigned ConstructKind, - SourceRange ParenRange); + bool IsListInitialization, bool RequiresZeroInit, + unsigned ConstructKind, SourceRange ParenRange); /// BuildCXXDefaultArgExpr - Creates a CXXDefaultArgExpr, instantiating /// the default expr if needed. @@ -3395,7 +3524,7 @@ public: public: explicit ImplicitExceptionSpecification(Sema &Self) : Self(&Self), ComputedEST(EST_BasicNoexcept) { - if (!Self.getLangOpts().CPlusPlus0x) + if (!Self.getLangOpts().CPlusPlus11) ComputedEST = EST_DynamicNone; } @@ -3474,6 +3603,11 @@ public: ImplicitExceptionSpecification ComputeDefaultedDtorExceptionSpec(CXXMethodDecl *MD); + /// \brief Determine what sort of exception specification an inheriting + /// constructor of a class will have. + ImplicitExceptionSpecification + ComputeInheritingCtorExceptionSpec(CXXMethodDecl *MD); + /// \brief Evaluate the implicit exception specification for a defaulted /// special member function. void EvaluateImplicitExceptionSpec(SourceLocation Loc, CXXMethodDecl *MD); @@ -3484,7 +3618,7 @@ public: ArrayRef<ParsedType> DynamicExceptions, ArrayRef<SourceRange> DynamicExceptionRanges, Expr *NoexceptExpr, - llvm::SmallVectorImpl<QualType> &Exceptions, + SmallVectorImpl<QualType> &Exceptions, FunctionProtoType::ExtProtoInfo &EPI); /// \brief Determine if a special member function should have a deleted @@ -3526,11 +3660,15 @@ public: void AdjustDestructorExceptionSpec(CXXRecordDecl *ClassDecl, CXXDestructorDecl *Destructor); - /// \brief Declare all inherited constructors for the given class. + /// \brief Declare all inheriting constructors for the given class. /// - /// \param ClassDecl The class declaration into which the inherited + /// \param ClassDecl The class declaration into which the inheriting /// constructors will be added. - void DeclareInheritedConstructors(CXXRecordDecl *ClassDecl); + void DeclareInheritingConstructors(CXXRecordDecl *ClassDecl); + + /// \brief Define the specified inheriting constructor. + void DefineInheritingConstructor(SourceLocation UseLoc, + CXXConstructorDecl *Constructor); /// \brief Declare the implicit copy constructor for the given class. /// @@ -3617,7 +3755,12 @@ public: MultiExprArg ArgsPtr, SourceLocation Loc, SmallVectorImpl<Expr*> &ConvertedArgs, - bool AllowExplicit = false); + bool AllowExplicit = false, + bool IsListInitialization = false); + + ParsedType getInheritingConstructorName(CXXScopeSpec &SS, + SourceLocation NameLoc, + IdentifierInfo &Name); ParsedType getDestructorName(SourceLocation TildeLoc, IdentifierInfo &II, SourceLocation NameLoc, @@ -3917,7 +4060,9 @@ public: return ActOnFinishFullExpr(Expr, Expr ? Expr->getExprLoc() : SourceLocation()); } - ExprResult ActOnFinishFullExpr(Expr *Expr, SourceLocation CC); + ExprResult ActOnFinishFullExpr(Expr *Expr, SourceLocation CC, + bool DiscardedValue = false, + bool IsConstexpr = false); StmtResult ActOnFinishFullStmt(Stmt *Stmt); // Marks SS invalid if it represents an incomplete type. @@ -3943,7 +4088,7 @@ public: bool ActOnCXXGlobalScopeSpecifier(Scope *S, SourceLocation CCLoc, CXXScopeSpec &SS); - bool isAcceptableNestedNameSpecifier(NamedDecl *SD); + bool isAcceptableNestedNameSpecifier(const NamedDecl *SD); NamedDecl *FindFirstQualifierInScope(Scope *S, NestedNameSpecifier *NNS); bool isNonTypeNestedNameSpecifier(Scope *S, CXXScopeSpec &SS, @@ -4100,7 +4245,7 @@ public: SourceRange IntroducerRange, TypeSourceInfo *MethodType, SourceLocation EndLoc, - llvm::ArrayRef<ParmVarDecl *> Params); + ArrayRef<ParmVarDecl *> Params); /// \brief Introduce the scope for a lambda expression. sema::LambdaScopeInfo *enterLambdaScope(CXXMethodDecl *CallOperator, @@ -4247,7 +4392,7 @@ public: SourceLocation ColonLoc, AttributeList *Attrs = 0); - Decl *ActOnCXXMemberDeclarator(Scope *S, AccessSpecifier AS, + NamedDecl *ActOnCXXMemberDeclarator(Scope *S, AccessSpecifier AS, Declarator &D, MultiTemplateParamsArg TemplateParameterLists, Expr *BitfieldWidth, const VirtSpecifiers &VS, @@ -4304,9 +4449,9 @@ public: bool SetDelegatingInitializer(CXXConstructorDecl *Constructor, CXXCtorInitializer *Initializer); - bool SetCtorInitializers(CXXConstructorDecl *Constructor, - CXXCtorInitializer **Initializers, - unsigned NumInitializers, bool AnyErrors); + bool SetCtorInitializers(CXXConstructorDecl *Constructor, bool AnyErrors, + ArrayRef<CXXCtorInitializer *> Initializers = + ArrayRef<CXXCtorInitializer *>()); void SetIvarInitializers(ObjCImplementationDecl *ObjCImplementation); @@ -4369,8 +4514,7 @@ public: void ActOnMemInitializers(Decl *ConstructorDecl, SourceLocation ColonLoc, - CXXCtorInitializer **MemInits, - unsigned NumMemInits, + ArrayRef<CXXCtorInitializer*> MemInits, bool AnyErrors); void CheckCompletedCXXClass(CXXRecordDecl *Record); @@ -4407,8 +4551,8 @@ public: TypeSourceInfo *TSInfo); Decl *ActOnFriendTypeDecl(Scope *S, const DeclSpec &DS, MultiTemplateParamsArg TemplateParams); - Decl *ActOnFriendFunctionDecl(Scope *S, Declarator &D, - MultiTemplateParamsArg TemplateParams); + NamedDecl *ActOnFriendFunctionDecl(Scope *S, Declarator &D, + MultiTemplateParamsArg TemplateParams); QualType CheckConstructorDeclarator(Declarator &D, QualType R, StorageClass& SC); @@ -4420,8 +4564,10 @@ public: StorageClass& SC); Decl *ActOnConversionDeclarator(CXXConversionDecl *Conversion); - void CheckExplicitlyDefaultedMethods(CXXRecordDecl *Record); void CheckExplicitlyDefaultedSpecialMember(CXXMethodDecl *MD); + void CheckExplicitlyDefaultedMemberExceptionSpec(CXXMethodDecl *MD, + const FunctionProtoType *T); + void CheckDelayedExplicitlyDefaultedMemberExceptionSpecs(); //===--------------------------------------------------------------------===// // C++ Derived Classes @@ -4436,6 +4582,7 @@ public: BaseResult ActOnBaseSpecifier(Decl *classdecl, SourceRange SpecifierRange, + ParsedAttributes &Attrs, bool Virtual, AccessSpecifier Access, ParsedType basetype, SourceLocation BaseLoc, @@ -4467,6 +4614,9 @@ public: std::string getAmbiguousPathsDisplayString(CXXBasePaths &Paths); + bool CheckOverridingFunctionAttributes(const CXXMethodDecl *New, + const CXXMethodDecl *Old); + /// CheckOverridingFunctionReturnType - Checks whether the return types are /// covariant, according to C++ [class.virtual]p5. bool CheckOverridingFunctionReturnType(const CXXMethodDecl *New, @@ -5234,14 +5384,14 @@ public: /// expansion. TypeSourceInfo *CheckPackExpansion(TypeSourceInfo *Pattern, SourceLocation EllipsisLoc, - llvm::Optional<unsigned> NumExpansions); + Optional<unsigned> NumExpansions); /// \brief Construct a pack expansion type from the pattern of the pack /// expansion. QualType CheckPackExpansion(QualType Pattern, SourceRange PatternRange, SourceLocation EllipsisLoc, - llvm::Optional<unsigned> NumExpansions); + Optional<unsigned> NumExpansions); /// \brief Invoked when parsing an expression followed by an ellipsis, which /// creates a pack expansion. @@ -5260,7 +5410,7 @@ public: /// /// \param EllipsisLoc The location of the ellipsis. ExprResult CheckPackExpansion(Expr *Pattern, SourceLocation EllipsisLoc, - llvm::Optional<unsigned> NumExpansions); + Optional<unsigned> NumExpansions); /// \brief Determine whether we could expand a pack expansion with the /// given set of parameter packs into separate arguments by repeatedly @@ -5298,11 +5448,11 @@ public: /// must be set. bool CheckParameterPacksForExpansion(SourceLocation EllipsisLoc, SourceRange PatternRange, - llvm::ArrayRef<UnexpandedParameterPack> Unexpanded, + ArrayRef<UnexpandedParameterPack> Unexpanded, const MultiLevelTemplateArgumentList &TemplateArgs, bool &ShouldExpand, bool &RetainExpansion, - llvm::Optional<unsigned> &NumExpansions); + Optional<unsigned> &NumExpansions); /// \brief Determine the number of arguments in the given pack expansion /// type. @@ -5311,8 +5461,8 @@ public: /// consistent across all of the unexpanded parameter packs in its pattern. /// /// Returns an empty Optional if the type can't be expanded. - llvm::Optional<unsigned> getNumArgumentsInExpansion(QualType T, - const MultiLevelTemplateArgumentList &TemplateArgs); + Optional<unsigned> getNumArgumentsInExpansion(QualType T, + const MultiLevelTemplateArgumentList &TemplateArgs); /// \brief Determine whether the given declarator contains any unexpanded /// parameter packs. @@ -5366,10 +5516,8 @@ public: /// \brief Substitution of the deduced template argument values /// resulted in an error. TDK_SubstitutionFailure, - /// \brief Substitution of the deduced template argument values - /// into a non-deduced context produced a type or value that - /// produces a type that does not match the original template - /// arguments provided. + /// \brief A non-depnedent component of the parameter did not match the + /// corresponding component of the argument. TDK_NonDeducedMismatch, /// \brief When performing template argument deduction for a function /// template, there were too many call arguments. @@ -5382,7 +5530,9 @@ public: TDK_InvalidExplicitArguments, /// \brief The arguments included an overloaded function name that could /// not be resolved to a suitable function. - TDK_FailedOverloadResolution + TDK_FailedOverloadResolution, + /// \brief Deduction failed; that's all we know. + TDK_MiscellaneousDeductionFailure }; TemplateDeductionResult @@ -5423,7 +5573,7 @@ public: TemplateDeductionResult DeduceTemplateArguments(FunctionTemplateDecl *FunctionTemplate, TemplateArgumentListInfo *ExplicitTemplateArgs, - llvm::ArrayRef<Expr *> Args, + ArrayRef<Expr *> Args, FunctionDecl *&Specialization, sema::TemplateDeductionInfo &Info); @@ -5483,13 +5633,14 @@ public: bool OnlyDeduced, unsigned Depth, llvm::SmallBitVector &Used); - void MarkDeducedTemplateParameters(FunctionTemplateDecl *FunctionTemplate, - llvm::SmallBitVector &Deduced) { + void MarkDeducedTemplateParameters( + const FunctionTemplateDecl *FunctionTemplate, + llvm::SmallBitVector &Deduced) { return MarkDeducedTemplateParameters(Context, FunctionTemplate, Deduced); } static void MarkDeducedTemplateParameters(ASTContext &Ctx, - FunctionTemplateDecl *FunctionTemplate, - llvm::SmallBitVector &Deduced); + const FunctionTemplateDecl *FunctionTemplate, + llvm::SmallBitVector &Deduced); //===--------------------------------------------------------------------===// // C++ Template Instantiation @@ -5554,7 +5705,7 @@ public: NamedDecl *Template; /// \brief The entity that is being instantiated. - uintptr_t Entity; + Decl *Entity; /// \brief The list of template arguments we are substituting, if they /// are not part of the entity. @@ -5796,11 +5947,11 @@ public: /// template argument substitution failures are not considered /// errors. /// - /// \returns An empty \c llvm::Optional if we're not in a SFINAE context. + /// \returns An empty \c Optional if we're not in a SFINAE context. /// Otherwise, contains a pointer that, if non-NULL, contains the nearest /// template-deduction context object, which can be used to capture /// diagnostics that will be suppressed. - llvm::Optional<sema::TemplateDeductionInfo *> isSFINAEContext() const; + Optional<sema::TemplateDeductionInfo *> isSFINAEContext() const; /// \brief Determines whether we are currently in a context that /// is not evaluated as per C++ [expr] p5. @@ -5911,7 +6062,7 @@ public: ParmVarDecl *SubstParmVarDecl(ParmVarDecl *D, const MultiLevelTemplateArgumentList &TemplateArgs, int indexAdjustment, - llvm::Optional<unsigned> NumExpansions, + Optional<unsigned> NumExpansions, bool ExpectParameterPack); bool SubstParmTypes(SourceLocation Loc, ParmVarDecl **Params, unsigned NumParams, @@ -6141,10 +6292,6 @@ public: void DiagnosePropertyMismatch(ObjCPropertyDecl *Property, ObjCPropertyDecl *SuperProperty, const IdentifierInfo *Name); - void ComparePropertiesInBaseAndSuper(ObjCInterfaceDecl *IDecl); - - - void CompareProperties(Decl *CDecl, Decl *MergeProtocols); void DiagnoseClassExtensionDupMethods(ObjCCategoryDecl *CAT, ObjCInterfaceDecl *ID); @@ -6214,6 +6361,7 @@ public: ObjCMethodDecl *LookupMethodInObjectType(Selector Sel, QualType Ty, bool IsInstance); + bool CheckARCMethodDecl(ObjCMethodDecl *method); bool inferObjCARCLifetime(ValueDecl *decl); ExprResult @@ -6324,14 +6472,13 @@ public: ParsedType Type, SourceLocation RParenLoc, Expr *SubExpr); - + bool checkInitMethod(ObjCMethodDecl *method, QualType receiverTypeIfCall); /// \brief Check whether the given new method is a valid override of the /// given overridden method, and set any properties that should be inherited. void CheckObjCMethodOverride(ObjCMethodDecl *NewMethod, - const ObjCMethodDecl *Overridden, - bool IsImplementation); + const ObjCMethodDecl *Overridden); /// \brief Describes the compatibility of a result type with its method. enum ResultTypeCompatibilityKind { @@ -6450,9 +6597,21 @@ public: /// AddAlignedAttr - Adds an aligned attribute to a particular declaration. void AddAlignedAttr(SourceRange AttrRange, Decl *D, Expr *E, - bool isDeclSpec); + unsigned SpellingListIndex, bool IsPackExpansion); void AddAlignedAttr(SourceRange AttrRange, Decl *D, TypeSourceInfo *T, - bool isDeclSpec); + unsigned SpellingListIndex, bool IsPackExpansion); + + // OpenMP directives and clauses. + + /// \brief Called on well-formed '#pragma omp threadprivate'. + DeclGroupPtrTy ActOnOpenMPThreadprivateDirective( + SourceLocation Loc, + Scope *CurScope, + ArrayRef<DeclarationNameInfo> IdList); + /// \brief Build a new OpenMPThreadPrivateDecl and check its correctness. + OMPThreadPrivateDecl *CheckOMPThreadPrivateDecl( + SourceLocation Loc, + ArrayRef<DeclRefExpr *> VarList); /// \brief The kind of conversion being performed. enum CheckedConversionKind { @@ -6541,7 +6700,8 @@ public: Expr **Args, unsigned NumArgs, SmallVector<Expr *, 8> &AllArgs, VariadicCallType CallType = VariadicDoesNotApply, - bool AllowExplicit = false); + bool AllowExplicit = false, + bool IsListInitialization = false); // DefaultVariadicArgumentPromotion - Like DefaultArgumentPromotion, but // will create a runtime trap if the resulting type is not a POD type. @@ -6812,6 +6972,11 @@ public: /// given type. ExprResult forceUnknownAnyToType(Expr *E, QualType ToType); + /// \brief Type-check an expression that's being passed to an + /// __unknown_anytype parameter. + ExprResult checkUnknownAnyArg(SourceLocation callLoc, + Expr *result, QualType ¶mType); + // CheckVectorCast - check type constraints for vectors. // Since vectors are an extension, there are no C standard reference for this. // We allow casting between vectors and integer datatypes of the same size. @@ -6883,6 +7048,11 @@ public: /// with a related result type, emit a note describing what happened. void EmitRelatedResultTypeNote(const Expr *E); + /// \brief Given that we had incompatible pointer types in a return + /// statement, check whether we're in a method with a related result + /// type, and if so, emit a note describing what happened. + void EmitRelatedResultTypeNoteForReturn(QualType destType); + /// CheckBooleanCondition - Diagnose problems involving the use of /// the given expression as a boolean condition (e.g. in an if /// statement). Also performs the standard function and array @@ -7033,7 +7203,7 @@ public: void CodeCompleteTag(Scope *S, unsigned TagSpec); void CodeCompleteTypeQualifiers(DeclSpec &DS); void CodeCompleteCase(Scope *S); - void CodeCompleteCall(Scope *S, Expr *Fn, llvm::ArrayRef<Expr *> Args); + void CodeCompleteCall(Scope *S, Expr *Fn, ArrayRef<Expr *> Args); void CodeCompleteInitializer(Scope *S, Decl *D); void CodeCompleteReturn(Scope *S); void CodeCompleteAfterIf(Scope *S); @@ -7150,12 +7320,11 @@ private: bool CheckBlockCall(NamedDecl *NDecl, CallExpr *TheCall, const FunctionProtoType *Proto); void CheckConstructorCall(FunctionDecl *FDecl, - Expr **Args, - unsigned NumArgs, + ArrayRef<const Expr *> Args, const FunctionProtoType *Proto, SourceLocation Loc); - void checkCall(NamedDecl *FDecl, Expr **Args, unsigned NumArgs, + void checkCall(NamedDecl *FDecl, ArrayRef<const Expr *> Args, unsigned NumProtoArgs, bool IsMemberFunction, SourceLocation Loc, SourceRange Range, VariadicCallType CallType); @@ -7203,7 +7372,7 @@ private: }; StringLiteralCheckType checkFormatStringExpr(const Expr *E, - Expr **Args, unsigned NumArgs, + ArrayRef<const Expr *> Args, bool HasVAListArg, unsigned format_idx, unsigned firstDataArg, @@ -7212,16 +7381,17 @@ private: bool inFunctionCall = true); void CheckFormatString(const StringLiteral *FExpr, const Expr *OrigFormatExpr, - Expr **Args, unsigned NumArgs, bool HasVAListArg, + ArrayRef<const Expr *> Args, bool HasVAListArg, unsigned format_idx, unsigned firstDataArg, FormatStringType Type, bool inFunctionCall, VariadicCallType CallType); - bool CheckFormatArguments(const FormatAttr *Format, Expr **Args, - unsigned NumArgs, bool IsCXXMember, + bool CheckFormatArguments(const FormatAttr *Format, + ArrayRef<const Expr *> Args, + bool IsCXXMember, VariadicCallType CallType, SourceLocation Loc, SourceRange Range); - bool CheckFormatArguments(Expr **Args, unsigned NumArgs, + bool CheckFormatArguments(ArrayRef<const Expr *> Args, bool HasVAListArg, unsigned format_idx, unsigned firstDataArg, FormatStringType Type, VariadicCallType CallType, @@ -7245,6 +7415,13 @@ private: SourceLocation ReturnLoc); void CheckFloatComparison(SourceLocation Loc, Expr* LHS, Expr* RHS); void CheckImplicitConversions(Expr *E, SourceLocation CC = SourceLocation()); + void CheckForIntOverflow(Expr *E); + void CheckUnsequencedOperations(Expr *E); + + /// \brief Perform semantic checks on a completed expression. This will either + /// be a full-expression or a default argument expression. + void CheckCompletedExpr(Expr *E, SourceLocation CheckLoc = SourceLocation(), + bool IsConstexpr = false); void CheckBitFieldInitialization(SourceLocation InitLoc, FieldDecl *Field, Expr *Init); @@ -7290,6 +7467,8 @@ private: /// The parser maintains this state here. Scope *CurScope; + mutable IdentifierInfo *Ident_super; + protected: friend class Parser; friend class InitializationSequence; @@ -7307,6 +7486,8 @@ public: /// template substitution or instantiation. Scope *getCurScope() const { return CurScope; } + IdentifierInfo *getSuperIdentifier() const; + Decl *getObjCDeclContext() const; DeclContext *getCurLexicalContext() const { diff --git a/include/clang/Sema/SemaInternal.h b/include/clang/Sema/SemaInternal.h index 64b83e3..bbf4272 100644 --- a/include/clang/Sema/SemaInternal.h +++ b/include/clang/Sema/SemaInternal.h @@ -15,9 +15,9 @@ #ifndef LLVM_CLANG_SEMA_SEMA_INTERNAL_H #define LLVM_CLANG_SEMA_SEMA_INTERNAL_H +#include "clang/AST/ASTContext.h" #include "clang/Sema/Sema.h" #include "clang/Sema/SemaDiagnostic.h" -#include "clang/AST/ASTContext.h" namespace clang { diff --git a/include/clang/Sema/Template.h b/include/clang/Sema/Template.h index bbccd25..492e580 100644 --- a/include/clang/Sema/Template.h +++ b/include/clang/Sema/Template.h @@ -14,6 +14,7 @@ #include "clang/AST/DeclTemplate.h" #include "clang/AST/DeclVisitor.h" +#include "clang/Sema/Sema.h" #include "llvm/ADT/SmallVector.h" #include <cassert> #include <utility> @@ -344,7 +345,16 @@ namespace clang { void SetPartiallySubstitutedPack(NamedDecl *Pack, const TemplateArgument *ExplicitArgs, unsigned NumExplicitArgs); - + + /// \brief Reset the partially-substituted pack when it is no longer of + /// interest. + void ResetPartiallySubstitutedPack() { + assert(PartiallySubstitutedPack && "No partially-substituted pack"); + PartiallySubstitutedPack = 0; + ArgsInPartiallySubstitutedPack = 0; + NumArgsInPartiallySubstitutedPack = 0; + } + /// \brief Retrieve the partially-substitued template parameter pack. /// /// If there is no partially-substituted parameter pack, returns NULL. @@ -420,6 +430,7 @@ namespace clang { Decl *VisitUnresolvedUsingTypenameDecl(UnresolvedUsingTypenameDecl *D); Decl *VisitClassScopeFunctionSpecializationDecl( ClassScopeFunctionSpecializationDecl *D); + Decl *VisitOMPThreadPrivateDecl(OMPThreadPrivateDecl *D); // Base case. FIXME: Remove once we can instantiate everything. Decl *VisitDecl(Decl *D) { diff --git a/include/clang/Sema/TemplateDeduction.h b/include/clang/Sema/TemplateDeduction.h index 251a659..3abb8f1 100644 --- a/include/clang/Sema/TemplateDeduction.h +++ b/include/clang/Sema/TemplateDeduction.h @@ -13,8 +13,8 @@ #ifndef LLVM_CLANG_SEMA_TEMPLATE_DEDUCTION_H #define LLVM_CLANG_SEMA_TEMPLATE_DEDUCTION_H -#include "clang/Basic/PartialDiagnostic.h" #include "clang/AST/DeclTemplate.h" +#include "clang/Basic/PartialDiagnostic.h" #include "llvm/ADT/SmallVector.h" namespace clang { @@ -47,7 +47,7 @@ class TemplateDeductionInfo { public: TemplateDeductionInfo(SourceLocation Loc) - : Deduced(0), Loc(Loc), HasSFINAEDiagnostic(false) { } + : Deduced(0), Loc(Loc), HasSFINAEDiagnostic(false), Expression(0) { } /// \brief Returns the location at which template argument is /// occurring. @@ -141,15 +141,25 @@ public: /// TDK_SubstitutionFailure: this argument is the template /// argument we were instantiating when we encountered an error. /// - /// TDK_NonDeducedMismatch: this is the template argument - /// provided in the source code. + /// TDK_NonDeducedMismatch: this is the component of the 'parameter' + /// of the deduction, directly provided in the source code. TemplateArgument FirstArg; /// \brief The second template argument to which the template /// argument deduction failure refers. /// + /// TDK_NonDeducedMismatch: this is the mismatching component of the + /// 'argument' of the deduction, from which we are deducing arguments. + /// /// FIXME: Finish documenting this. TemplateArgument SecondArg; + + /// \brief The expression which caused a deduction failure. + /// + /// TDK_FailedOverloadResolution: this argument is the reference to + // an overloaded function which could not be resolved to a specific + // function. + Expr *Expression; }; } diff --git a/include/clang/Sema/TypoCorrection.h b/include/clang/Sema/TypoCorrection.h index 2b4a9e6..cdd71c8 100644 --- a/include/clang/Sema/TypoCorrection.h +++ b/include/clang/Sema/TypoCorrection.h @@ -16,6 +16,7 @@ #define LLVM_CLANG_SEMA_TYPOCORRECTION_H #include "clang/AST/DeclCXX.h" +#include "clang/Sema/DeclSpec.h" #include "llvm/ADT/SmallVector.h" namespace clang { @@ -181,12 +182,12 @@ public: return CorrectionRange; } - typedef llvm::SmallVector<NamedDecl*, 1>::iterator decl_iterator; + typedef SmallVector<NamedDecl *, 1>::iterator decl_iterator; decl_iterator begin() { return isKeyword() ? CorrectionDecls.end() : CorrectionDecls.begin(); } decl_iterator end() { return CorrectionDecls.end(); } - typedef llvm::SmallVector<NamedDecl*, 1>::const_iterator const_decl_iterator; + typedef SmallVector<NamedDecl *, 1>::const_iterator const_decl_iterator; const_decl_iterator begin() const { return isKeyword() ? CorrectionDecls.end() : CorrectionDecls.begin(); } @@ -200,7 +201,7 @@ private: // Results. DeclarationName CorrectionName; NestedNameSpecifier *CorrectionNameSpec; - llvm::SmallVector<NamedDecl*, 1> CorrectionDecls; + SmallVector<NamedDecl *, 1> CorrectionDecls; unsigned CharDistance; unsigned QualifierDistance; unsigned CallbackDistance; @@ -227,9 +228,11 @@ class CorrectionCandidateCallback { /// candidate is viable, without ranking potentially viable candidates. /// Only ValidateCandidate or RankCandidate need to be overriden by a /// callback wishing to check the viability of correction candidates. - virtual bool ValidateCandidate(const TypoCorrection &candidate) { - return true; - } + /// The default predicate always returns true if the candidate is not a type + /// name or keyword, true for types if WantTypeSpecifiers is true, and true + /// for keywords if WantTypeSpecifiers, WantExpressionKeywords, + /// WantCXXNamedCasts, WantRemainingKeywords, or WantObjCSuper is true. + virtual bool ValidateCandidate(const TypoCorrection &candidate); /// \brief Method used by Sema::CorrectTypo to assign an "edit distance" rank /// to a candidate (where a lower value represents a better candidate), or |
