From ba49d05a74f4b435787d294c2bb383cfc4bd0168 Mon Sep 17 00:00:00 2001 From: Eugene Zelenko Date: Thu, 22 Feb 2018 22:35:17 +0000 Subject: [PATCH] [Sema] Fix some Clang-tidy modernize and Include What You Use warnings; other minor fixes (NFC). git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@325834 91177308-0d34-0410-b5e6-96231b3b80d8 --- include/clang/Sema/Scope.h | 37 +++-- include/clang/Sema/ScopeInfo.h | 173 +++++++++++++----------- include/clang/Sema/Template.h | 105 ++++++++------ include/clang/Sema/TemplateDeduction.h | 54 ++++---- include/clang/Sema/TypoCorrection.h | 95 +++++++------ include/clang/Serialization/ASTReader.h | 33 ++--- lib/Sema/SemaTemplateDeduction.cpp | 99 ++++++++++---- 7 files changed, 341 insertions(+), 255 deletions(-) diff --git a/include/clang/Sema/Scope.h b/include/clang/Sema/Scope.h index 1dd1675561..ba3278424b 100644 --- a/include/clang/Sema/Scope.h +++ b/include/clang/Sema/Scope.h @@ -1,4 +1,4 @@ -//===--- Scope.h - Scope interface ------------------------------*- C++ -*-===// +//===- Scope.h - Scope interface --------------------------------*- C++ -*-===// // // The LLVM Compiler Infrastructure // @@ -14,28 +14,29 @@ #ifndef LLVM_CLANG_SEMA_SCOPE_H #define LLVM_CLANG_SEMA_SCOPE_H -#include "clang/AST/Decl.h" #include "clang/Basic/Diagnostic.h" #include "llvm/ADT/PointerIntPair.h" #include "llvm/ADT/SmallPtrSet.h" #include "llvm/ADT/SmallVector.h" +#include "llvm/ADT/iterator_range.h" +#include namespace llvm { class raw_ostream; -} +} // namespace llvm namespace clang { class Decl; +class DeclContext; class UsingDirectiveDecl; class VarDecl; /// Scope - A scope is a transient data structure that is used while parsing the /// program. It assists with resolving identifiers to the appropriate /// declaration. -/// class Scope { public: /// ScopeFlags - These are bitfields that are or'd together when creating a @@ -131,6 +132,7 @@ public: /// We are between inheritance colon and the real class/struct definition scope. ClassInheritanceScope = 0x800000, }; + private: /// The parent scope for this scope. This is null for the translation-unit /// scope. @@ -185,7 +187,7 @@ private: /// popped, these declarations are removed from the IdentifierTable's notion /// of current declaration. It is up to the current Action implementation to /// implement these semantics. - typedef llvm::SmallPtrSet DeclSetTy; + using DeclSetTy = llvm::SmallPtrSet; DeclSetTy DeclsInScope; /// The DeclContext with which this scope is associated. For @@ -193,7 +195,7 @@ private: /// entity of a function scope is a function, etc. DeclContext *Entity; - typedef SmallVector UsingDirectivesTy; + using UsingDirectivesTy = SmallVector; UsingDirectivesTy UsingDirectives; /// \brief Used to determine if errors occurred in this scope. @@ -207,25 +209,23 @@ private: public: Scope(Scope *Parent, unsigned ScopeFlags, DiagnosticsEngine &Diag) - : ErrorTrap(Diag) { + : ErrorTrap(Diag) { Init(Parent, ScopeFlags); } /// getFlags - Return the flags for this scope. - /// unsigned getFlags() const { return Flags; } + void setFlags(unsigned F) { setFlags(getParent(), F); } /// isBlockScope - Return true if this scope correspond to a closure. bool isBlockScope() const { return Flags & BlockScope; } /// getParent - Return the scope that this is nested in. - /// const Scope *getParent() const { return AnyParent; } Scope *getParent() { return AnyParent; } /// getFnParent - Return the closest scope that is a function body. - /// const Scope *getFnParent() const { return FnParent; } Scope *getFnParent() { return FnParent; } @@ -275,10 +275,12 @@ public: return PrototypeIndex++; } - typedef llvm::iterator_range decl_range; + using decl_range = llvm::iterator_range; + decl_range decls() const { return decl_range(DeclsInScope.begin(), DeclsInScope.end()); } + bool decl_empty() const { return DeclsInScope.empty(); } void AddDecl(Decl *D) { @@ -368,7 +370,6 @@ public: return false; } - /// isTemplateParamScope - Return true if this scope is a C++ /// template parameter scope. bool isTemplateParamScope() const { @@ -457,8 +458,8 @@ public: UsingDirectives.push_back(UDir); } - typedef llvm::iterator_range - using_directives_range; + using using_directives_range = + llvm::iterator_range; using_directives_range using_directives() { return using_directives_range(UsingDirectives.begin(), @@ -477,25 +478,23 @@ public: } void setNoNRVO() { - NRVO.setInt(1); + NRVO.setInt(true); NRVO.setPointer(nullptr); } void mergeNRVOIntoParent(); /// Init - This is used by the parser to implement scope caching. - /// void Init(Scope *parent, unsigned flags); /// \brief Sets up the specified scope flags and adjusts the scope state /// variables accordingly. - /// void AddFlags(unsigned Flags); void dumpImpl(raw_ostream &OS) const; void dump() const; }; -} // end namespace clang +} // namespace clang -#endif +#endif // LLVM_CLANG_SEMA_SCOPE_H diff --git a/include/clang/Sema/ScopeInfo.h b/include/clang/Sema/ScopeInfo.h index eedc5013b8..35fdd74b15 100644 --- a/include/clang/Sema/ScopeInfo.h +++ b/include/clang/Sema/ScopeInfo.h @@ -1,4 +1,4 @@ -//===--- ScopeInfo.h - Information about a semantic context -----*- C++ -*-===// +//===- ScopeInfo.h - Information about a semantic context -------*- C++ -*-===// // // The LLVM Compiler Infrastructure // @@ -18,36 +18,46 @@ #include "clang/AST/Expr.h" #include "clang/AST/Type.h" #include "clang/Basic/CapturedStmt.h" +#include "clang/Basic/LLVM.h" #include "clang/Basic/PartialDiagnostic.h" +#include "clang/Basic/SourceLocation.h" #include "clang/Sema/CleanupInfo.h" -#include "clang/Sema/Ownership.h" #include "llvm/ADT/DenseMap.h" +#include "llvm/ADT/DenseMapInfo.h" #include "llvm/ADT/MapVector.h" +#include "llvm/ADT/PointerIntPair.h" +#include "llvm/ADT/SmallPtrSet.h" #include "llvm/ADT/SmallSet.h" #include "llvm/ADT/SmallVector.h" +#include "llvm/ADT/StringRef.h" #include "llvm/ADT/StringSwitch.h" +#include "llvm/Support/Casting.h" +#include "llvm/Support/ErrorHandling.h" #include +#include +#include namespace clang { -class Decl; class BlockDecl; class CapturedDecl; class CXXMethodDecl; -class FieldDecl; -class ObjCPropertyDecl; -class IdentifierInfo; +class CXXRecordDecl; class ImplicitParamDecl; -class LabelDecl; +class NamedDecl; +class ObjCIvarRefExpr; +class ObjCMessageExpr; +class ObjCPropertyDecl; +class ObjCPropertyRefExpr; +class ParmVarDecl; +class RecordDecl; class ReturnStmt; class Scope; +class Stmt; class SwitchStmt; -class TemplateTypeParmDecl; class TemplateParameterList; +class TemplateTypeParmDecl; class VarDecl; -class ObjCIvarRefExpr; -class ObjCPropertyRefExpr; -class ObjCMessageExpr; namespace sema { @@ -55,17 +65,16 @@ namespace sema { /// parsed. class CompoundScopeInfo { public: - CompoundScopeInfo(bool IsStmtExpr) - : HasEmptyLoopBodies(false), IsStmtExpr(IsStmtExpr) { } - /// \brief Whether this compound stamement contains `for' or `while' loops /// with empty bodies. - bool HasEmptyLoopBodies; + bool HasEmptyLoopBodies = false; /// \brief Whether this compound statement corresponds to a GNU statement /// expression. bool IsStmtExpr; + CompoundScopeInfo(bool IsStmtExpr) : IsStmtExpr(IsStmtExpr) {} + void setHasEmptyLoopBodies() { HasEmptyLoopBodies = true; } @@ -79,7 +88,7 @@ public: PossiblyUnreachableDiag(const PartialDiagnostic &PD, SourceLocation Loc, const Stmt *stmt) - : PD(PD), Loc(Loc), stmt(stmt) {} + : PD(PD), Loc(Loc), stmt(stmt) {} }; /// \brief Retains information about a function, method, or block that is @@ -95,7 +104,6 @@ protected: public: /// \brief What kind of scope we are describing. - /// ScopeKind Kind : 3; /// \brief Whether this function contains a VLA, \@try, try, C++ @@ -128,6 +136,7 @@ public: /// True when this is a method marked as a designated initializer. bool ObjCIsDesignatedInit : 1; + /// This starts true for a method marked as designated initializer and will /// be set to false if there is an invocation to a designated initializer of /// the super class. @@ -137,6 +146,7 @@ public: /// initializer within a class that has at least one initializer marked as a /// designated initializer. bool ObjCIsSecondaryInit : 1; + /// This starts true for a secondary initializer method and will be set to /// false if there is an invocation of an initializer on 'self'. bool ObjCWarnForNoInitDelegation : 1; @@ -195,7 +205,7 @@ public: /// \brief A list of parameters which have the nonnull attribute and are /// modified in the function. - llvm::SmallPtrSet ModifiedNonNullParams; + llvm::SmallPtrSet ModifiedNonNullParams; public: /// Represents a simple identification of a weak object. @@ -227,14 +237,14 @@ public: /// identify the object in memory. /// /// \sa isExactProfile() - typedef llvm::PointerIntPair BaseInfoTy; + using BaseInfoTy = llvm::PointerIntPair; BaseInfoTy Base; /// The "property" decl, as described in the class documentation. /// /// Note that this may not actually be an ObjCPropertyDecl, e.g. in the /// case of "implicit" properties (regular methods accessed via dot syntax). - const NamedDecl *Property; + const NamedDecl *Property = nullptr; /// Used to find the proper base profile for a given base expression. static BaseInfoTy getBaseInfo(const Expr *BaseE); @@ -279,12 +289,14 @@ public: static inline WeakObjectProfileTy getEmptyKey() { return WeakObjectProfileTy(); } + static inline WeakObjectProfileTy getTombstoneKey() { return WeakObjectProfileTy::getSentinel(); } static unsigned getHashValue(const WeakObjectProfileTy &Val) { - typedef std::pair Pair; + using Pair = std::pair; + return llvm::DenseMapInfo::getHashValue(Pair(Val.Base, Val.Property)); } @@ -304,6 +316,7 @@ public: /// Part of the implementation of -Wrepeated-use-of-weak. class WeakUseTy { llvm::PointerIntPair Rep; + public: WeakUseTy(const Expr *Use, bool IsRead) : Rep(Use, IsRead) {} @@ -319,14 +332,14 @@ public: /// Used to collect uses of a particular weak object in a function body. /// /// Part of the implementation of -Wrepeated-use-of-weak. - typedef SmallVector WeakUseVector; + using WeakUseVector = SmallVector; /// Used to collect all uses of weak objects in a function body. /// /// Part of the implementation of -Wrepeated-use-of-weak. - typedef llvm::SmallDenseMap - WeakObjectUseMap; + using WeakObjectUseMap = + llvm::SmallDenseMap; private: /// Used to collect all uses of weak objects in this function body. @@ -338,6 +351,18 @@ protected: FunctionScopeInfo(const FunctionScopeInfo&) = default; public: + FunctionScopeInfo(DiagnosticsEngine &Diag) + : Kind(SK_Function), HasBranchProtectedScope(false), + HasBranchIntoScope(false), HasIndirectGoto(false), + HasDroppedStmt(false), HasOMPDeclareReductionCombiner(false), + HasFallthroughStmt(false), HasPotentialAvailabilityViolations(false), + ObjCShouldCallSuper(false), ObjCIsDesignatedInit(false), + ObjCWarnForNoDesignatedInitChain(false), ObjCIsSecondaryInit(false), + ObjCWarnForNoInitDelegation(false), NeedsCoroutineSuspends(true), + ErrorTrap(Diag) {} + + virtual ~FunctionScopeInfo(); + /// Record that a weak object was accessed. /// /// Part of the implementation of -Wrepeated-use-of-weak. @@ -439,25 +464,6 @@ public: CoroutineSuspends.second = Final; } - FunctionScopeInfo(DiagnosticsEngine &Diag) - : Kind(SK_Function), - HasBranchProtectedScope(false), - HasBranchIntoScope(false), - HasIndirectGoto(false), - HasDroppedStmt(false), - HasOMPDeclareReductionCombiner(false), - HasFallthroughStmt(false), - HasPotentialAvailabilityViolations(false), - ObjCShouldCallSuper(false), - ObjCIsDesignatedInit(false), - ObjCWarnForNoDesignatedInitChain(false), - ObjCIsSecondaryInit(false), - ObjCWarnForNoInitDelegation(false), - NeedsCoroutineSuspends(true), - ErrorTrap(Diag) { } - - virtual ~FunctionScopeInfo(); - /// \brief Clear out the information in this function scope, making it /// suitable for reuse. void Clear(); @@ -496,9 +502,11 @@ public: IsNestedCapture = 0x1, IsThisCaptured = 0x2 }; + /// The variable being captured (if we are not capturing 'this') and whether /// this is a nested capture, and whether we are capturing 'this' llvm::PointerIntPair VarAndNestedAndThis; + /// Expression to initialize a field of the given type, and the kind of /// capture (if this is a capture and not an init-capture). The expression /// is only required if we are capturing ByVal and the variable's type has @@ -517,11 +525,11 @@ public: /// \brief Whether an explicit capture has been odr-used in the body of the /// lambda. - bool ODRUsed; + bool ODRUsed = false; /// \brief Whether an explicit capture has been non-odr-used in the body of /// the lambda. - bool NonODRUsed; + bool NonODRUsed = false; public: Capture(VarDecl *Var, bool Block, bool ByRef, bool IsNested, @@ -531,8 +539,7 @@ public: InitExprAndCaptureKind( Cpy, !Var ? Cap_VLA : Block ? Cap_Block : ByRef ? Cap_ByRef : Cap_ByCopy), - Loc(Loc), EllipsisLoc(EllipsisLoc), CaptureType(CaptureType), - ODRUsed(false), NonODRUsed(false) {} + Loc(Loc), EllipsisLoc(EllipsisLoc), CaptureType(CaptureType) {} enum IsThisCapture { ThisCapture }; Capture(IsThisCapture, bool IsNested, SourceLocation Loc, @@ -540,30 +547,36 @@ public: : VarAndNestedAndThis( nullptr, (IsThisCaptured | (IsNested ? IsNestedCapture : 0))), InitExprAndCaptureKind(Cpy, ByCopy ? Cap_ByCopy : Cap_ByRef), - Loc(Loc), EllipsisLoc(), CaptureType(CaptureType), ODRUsed(false), - NonODRUsed(false) {} + Loc(Loc), CaptureType(CaptureType) {} bool isThisCapture() const { return VarAndNestedAndThis.getInt() & IsThisCaptured; } + bool isVariableCapture() const { return !isThisCapture() && !isVLATypeCapture(); } + bool isCopyCapture() const { return InitExprAndCaptureKind.getInt() == Cap_ByCopy; } + bool isReferenceCapture() const { return InitExprAndCaptureKind.getInt() == Cap_ByRef; } + bool isBlockCapture() const { return InitExprAndCaptureKind.getInt() == Cap_Block; } + bool isVLATypeCapture() const { return InitExprAndCaptureKind.getInt() == Cap_VLA; } + bool isNested() const { return VarAndNestedAndThis.getInt() & IsNestedCapture; } + bool isODRUsed() const { return ODRUsed; } bool isNonODRUsed() const { return NonODRUsed; } void markUsed(bool IsODRUse) { (IsODRUse ? ODRUsed : NonODRUsed) = true; } @@ -595,23 +608,21 @@ public: }; CapturingScopeInfo(DiagnosticsEngine &Diag, ImplicitCaptureStyle Style) - : FunctionScopeInfo(Diag), ImpCaptureStyle(Style), CXXThisCaptureIndex(0), - HasImplicitReturnType(false) - {} + : FunctionScopeInfo(Diag), ImpCaptureStyle(Style) {} /// CaptureMap - A map of captured variables to (index+1) into Captures. llvm::DenseMap CaptureMap; /// CXXThisCaptureIndex - The (index+1) of the capture of 'this'; /// zero if 'this' is not captured. - unsigned CXXThisCaptureIndex; + unsigned CXXThisCaptureIndex = 0; /// Captures - The captures. SmallVector Captures; /// \brief - Whether the target type of return statements in this context /// is deduced (e.g. a lambda or block with omitted return type). - bool HasImplicitReturnType; + bool HasImplicitReturnType = false; /// ReturnType - The target type of return statements in this context, /// or null if unknown. @@ -689,9 +700,8 @@ public: QualType FunctionType; BlockScopeInfo(DiagnosticsEngine &Diag, Scope *BlockScope, BlockDecl *Block) - : CapturingScopeInfo(Diag, ImpCap_Block), TheDecl(Block), - TheScope(BlockScope) - { + : CapturingScopeInfo(Diag, ImpCap_Block), TheDecl(Block), + TheScope(BlockScope) { Kind = SK_Block; } @@ -707,23 +717,27 @@ class CapturedRegionScopeInfo final : public CapturingScopeInfo { public: /// \brief The CapturedDecl for this statement. CapturedDecl *TheCapturedDecl; + /// \brief The captured record type. RecordDecl *TheRecordDecl; + /// \brief This is the enclosing scope of the captured region. Scope *TheScope; + /// \brief The implicit parameter for the captured variables. ImplicitParamDecl *ContextParam; + /// \brief The kind of captured region. unsigned short CapRegionKind; + unsigned short OpenMPLevel; CapturedRegionScopeInfo(DiagnosticsEngine &Diag, Scope *S, CapturedDecl *CD, RecordDecl *RD, ImplicitParamDecl *Context, CapturedRegionKind K, unsigned OpenMPLevel) - : CapturingScopeInfo(Diag, ImpCap_CapturedRegion), - TheCapturedDecl(CD), TheRecordDecl(RD), TheScope(S), - ContextParam(Context), CapRegionKind(K), OpenMPLevel(OpenMPLevel) - { + : CapturingScopeInfo(Diag, ImpCap_CapturedRegion), + TheCapturedDecl(CD), TheRecordDecl(RD), TheScope(S), + ContextParam(Context), CapRegionKind(K), OpenMPLevel(OpenMPLevel) { Kind = SK_CapturedRegion; } @@ -748,10 +762,10 @@ public: class LambdaScopeInfo final : public CapturingScopeInfo { public: /// \brief The class that describes the lambda. - CXXRecordDecl *Lambda; + CXXRecordDecl *Lambda = nullptr; /// \brief The lambda's compiler-generated \c operator(). - CXXMethodDecl *CallOperator; + CXXMethodDecl *CallOperator = nullptr; /// \brief Source range covering the lambda introducer [...]. SourceRange IntroducerRange; @@ -762,23 +776,23 @@ public: /// \brief The number of captures in the \c Captures list that are /// explicit captures. - unsigned NumExplicitCaptures; + unsigned NumExplicitCaptures = 0; /// \brief Whether this is a mutable lambda. - bool Mutable; + bool Mutable = false; /// \brief Whether the (empty) parameter list is explicit. - bool ExplicitParams; + bool ExplicitParams = false; /// \brief Whether any of the capture expressions requires cleanups. CleanupInfo Cleanup; /// \brief Whether the lambda contains an unexpanded parameter pack. - bool ContainsUnexpandedParameterPack; + bool ContainsUnexpandedParameterPack = false; /// \brief If this is a generic lambda, use this as the depth of /// each 'auto' parameter, during initial AST construction. - unsigned AutoTemplateParameterDepth; + unsigned AutoTemplateParameterDepth = 0; /// \brief Store the list of the auto parameters for a generic lambda. /// If this is a generic lambda, store the list of the auto @@ -790,7 +804,7 @@ public: /// If this is a generic lambda, and the template parameter /// list has been created (from the AutoTemplateParams) then /// store a reference to it (cache it to avoid reconstructing it). - TemplateParameterList *GLTemplateParameterList; + TemplateParameterList *GLTemplateParameterList = nullptr; /// \brief Contains all variable-referring-expressions (i.e. DeclRefExprs /// or MemberExprs) that refer to local variables in a generic lambda @@ -805,7 +819,6 @@ public: /// will truly be odr-used (i.e. need to be captured) by that nested lambda, /// until its instantiation. But we still need to capture it in the /// enclosing lambda if all intervening lambdas can capture the variable. - llvm::SmallVector PotentiallyCapturingExprs; /// \brief Contains all variable-referring-expressions that refer @@ -826,11 +839,7 @@ public: SourceLocation PotentialThisCaptureLocation; LambdaScopeInfo(DiagnosticsEngine &Diag) - : CapturingScopeInfo(Diag, ImpCap_None), Lambda(nullptr), - CallOperator(nullptr), NumExplicitCaptures(0), Mutable(false), - ExplicitParams(false), Cleanup{}, - ContainsUnexpandedParameterPack(false), AutoTemplateParameterDepth(0), - GLTemplateParameterList(nullptr) { + : CapturingScopeInfo(Diag, ImpCap_None) { Kind = SK_Lambda; } @@ -849,7 +858,6 @@ public: return !AutoTemplateParams.empty() || GLTemplateParameterList; } - /// /// \brief Add a variable that might potentially be captured by the /// lambda and therefore the enclosing lambdas. /// @@ -875,6 +883,7 @@ public: void addPotentialThisCapture(SourceLocation Loc) { PotentialThisCaptureLocation = Loc; } + bool hasPotentialThisCapture() const { return PotentialThisCaptureLocation.isValid(); } @@ -918,7 +927,6 @@ public: /// seemingly harmless change elsewhere in Sema could cause us to start or stop /// building such a node. So we need a rule that anyone can implement and get /// exactly the same result". - /// void markVariableExprAsNonODRUsed(Expr *CapturingVarExpr) { assert(isa(CapturingVarExpr) || isa(CapturingVarExpr)); @@ -954,7 +962,7 @@ public: }; FunctionScopeInfo::WeakObjectProfileTy::WeakObjectProfileTy() - : Base(nullptr, false), Property(nullptr) {} + : Base(nullptr, false) {} FunctionScopeInfo::WeakObjectProfileTy FunctionScopeInfo::WeakObjectProfileTy::getSentinel() { @@ -979,7 +987,8 @@ CapturingScopeInfo::addThisCapture(bool isNested, SourceLocation Loc, CXXThisCaptureIndex = Captures.size(); } -} // end namespace sema -} // end namespace clang +} // namespace sema + +} // namespace clang -#endif +#endif // LLVM_CLANG_SEMA_SCOPEINFO_H diff --git a/include/clang/Sema/Template.h b/include/clang/Sema/Template.h index 644d55b93f..4dbb947bd7 100644 --- a/include/clang/Sema/Template.h +++ b/include/clang/Sema/Template.h @@ -1,25 +1,48 @@ -//===------- SemaTemplate.h - C++ Templates ---------------------*- C++ -*-===/ +//===- SemaTemplate.h - C++ Templates ---------------------------*- C++ -*-===// // // The LLVM Compiler Infrastructure // // This file is distributed under the University of Illinois Open Source // License. See LICENSE.TXT for details. -//===----------------------------------------------------------------------===/ +//===----------------------------------------------------------------------===// // -// This file provides types used in the semantic analysis of C++ templates. +// This file provides types used in the semantic analysis of C++ templates. // -//===----------------------------------------------------------------------===/ +//===----------------------------------------------------------------------===// + #ifndef LLVM_CLANG_SEMA_TEMPLATE_H #define LLVM_CLANG_SEMA_TEMPLATE_H #include "clang/AST/DeclTemplate.h" #include "clang/AST/DeclVisitor.h" +#include "clang/AST/TemplateBase.h" +#include "clang/AST/Type.h" +#include "clang/Basic/LLVM.h" #include "clang/Sema/Sema.h" +#include "llvm/ADT/ArrayRef.h" +#include "llvm/ADT/DenseMap.h" +#include "llvm/ADT/PointerUnion.h" #include "llvm/ADT/SmallVector.h" #include #include namespace clang { + +class ASTContext; +class BindingDecl; +class CXXMethodDecl; +class Decl; +class DeclaratorDecl; +class DeclContext; +class EnumDecl; +class FunctionDecl; +class NamedDecl; +class ParmVarDecl; +class TagDecl; +class TypedefNameDecl; +class TypeSourceInfo; +class VarDecl; + /// \brief Data structure that captures multiple levels of template argument /// lists for use in template instantiation. /// @@ -41,7 +64,7 @@ namespace clang { /// template argument list (17) at depth 1. class MultiLevelTemplateArgumentList { /// \brief The template argument list at a certain template depth - typedef ArrayRef ArgList; + using ArgList = ArrayRef; /// \brief The template argument lists, stored from the innermost template /// argument list (first) to the outermost template argument list (last). @@ -53,7 +76,7 @@ namespace clang { public: /// \brief Construct an empty set of template argument lists. - MultiLevelTemplateArgumentList() { } + MultiLevelTemplateArgumentList() = default; /// \brief Construct a single-level template argument list. explicit @@ -129,7 +152,7 @@ namespace clang { } /// \brief Retrieve the innermost template argument list. - const ArgList &getInnermost() const { + const ArgList &getInnermost() const { return TemplateArgumentLists.front(); } }; @@ -138,9 +161,11 @@ namespace clang { enum TPOC { /// \brief Partial ordering of function templates for a function call. TPOC_Call, + /// \brief Partial ordering of function templates for a call to a /// conversion function. TPOC_Conversion, + /// \brief Partial ordering of function templates in other contexts, e.g., /// taking the address of a function template or matching a function /// template specialization to a function template. @@ -153,8 +178,10 @@ namespace clang { // making Sema.h declare things as enums). class TemplatePartialOrderingContext { TPOC Value; + public: TemplatePartialOrderingContext(TPOC Value) : Value(Value) {} + operator TPOC() const { return Value; } }; @@ -163,15 +190,14 @@ namespace clang { class DeducedTemplateArgument : public TemplateArgument { /// \brief For a non-type template argument, whether the value was /// deduced from an array bound. - bool DeducedFromArrayBound; + bool DeducedFromArrayBound = false; public: - DeducedTemplateArgument() - : TemplateArgument(), DeducedFromArrayBound(false) { } + DeducedTemplateArgument() = default; DeducedTemplateArgument(const TemplateArgument &Arg, bool DeducedFromArrayBound = false) - : TemplateArgument(Arg), DeducedFromArrayBound(DeducedFromArrayBound) { } + : TemplateArgument(Arg), DeducedFromArrayBound(DeducedFromArrayBound) {} /// \brief Construct an integral non-type template argument that /// has been deduced, possibly from an array bound. @@ -179,8 +205,8 @@ namespace clang { const llvm::APSInt &Value, QualType ValueType, bool DeducedFromArrayBound) - : TemplateArgument(Ctx, Value, ValueType), - DeducedFromArrayBound(DeducedFromArrayBound) { } + : TemplateArgument(Ctx, Value, ValueType), + DeducedFromArrayBound(DeducedFromArrayBound) {} /// \brief For a non-type template argument, determine whether the /// template argument was deduced from an array bound. @@ -202,16 +228,16 @@ namespace clang { class LocalInstantiationScope { public: /// \brief A set of declarations. - typedef SmallVector DeclArgumentPack; + using DeclArgumentPack = SmallVector; private: /// \brief Reference to the semantic analysis that is performing /// this template instantiation. Sema &SemaRef; - typedef llvm::SmallDenseMap< - const Decl *, llvm::PointerUnion, 4> - LocalDeclsMap; + using LocalDeclsMap = + llvm::SmallDenseMap, 4>; /// \brief A mapping from local declarations that occur /// within a template to their instantiations. @@ -242,7 +268,7 @@ namespace clang { LocalInstantiationScope *Outer; /// \brief Whether we have already exited this scope. - bool Exited; + bool Exited = false; /// \brief Whether to combine this scope with the outer scope, such that /// lookup will search our outer scope. @@ -250,7 +276,7 @@ namespace clang { /// \brief If non-NULL, the template parameter pack that has been /// partially substituted per C++0x [temp.arg.explicit]p9. - NamedDecl *PartiallySubstitutedPack; + NamedDecl *PartiallySubstitutedPack = nullptr; /// \brief If \c PartiallySubstitutedPack is non-null, the set of /// explicitly-specified template arguments in that pack. @@ -261,20 +287,17 @@ namespace clang { /// ArgsInPartiallySubstitutedPack. unsigned NumArgsInPartiallySubstitutedPack; - // This class is non-copyable - LocalInstantiationScope( - const LocalInstantiationScope &) = delete; - void operator=(const LocalInstantiationScope &) = delete; - public: LocalInstantiationScope(Sema &SemaRef, bool CombineWithOuterScope = false) - : SemaRef(SemaRef), Outer(SemaRef.CurrentInstantiationScope), - Exited(false), CombineWithOuterScope(CombineWithOuterScope), - PartiallySubstitutedPack(nullptr) - { + : SemaRef(SemaRef), Outer(SemaRef.CurrentInstantiationScope), + CombineWithOuterScope(CombineWithOuterScope) { SemaRef.CurrentInstantiationScope = this; } + LocalInstantiationScope(const LocalInstantiationScope &) = delete; + LocalInstantiationScope & + operator=(const LocalInstantiationScope &) = delete; + ~LocalInstantiationScope() { Exit(); } @@ -399,8 +422,8 @@ namespace clang { Sema::ArgumentPackSubstitutionIndexRAII SubstIndex; DeclContext *Owner; const MultiLevelTemplateArgumentList &TemplateArgs; - Sema::LateInstantiatedAttrVec* LateAttrs; - LocalInstantiationScope *StartingScope; + Sema::LateInstantiatedAttrVec* LateAttrs = nullptr; + LocalInstantiationScope *StartingScope = nullptr; /// \brief A list of out-of-line class template partial /// specializations that will need to be instantiated after the @@ -420,10 +443,9 @@ namespace clang { public: TemplateDeclInstantiator(Sema &SemaRef, DeclContext *Owner, const MultiLevelTemplateArgumentList &TemplateArgs) - : SemaRef(SemaRef), - SubstIndex(SemaRef, SemaRef.ArgumentPackSubstitutionIndex), - Owner(Owner), TemplateArgs(TemplateArgs), LateAttrs(nullptr), - StartingScope(nullptr) {} + : SemaRef(SemaRef), + SubstIndex(SemaRef, SemaRef.ArgumentPackSubstitutionIndex), + Owner(Owner), TemplateArgs(TemplateArgs) {} // Define all the decl visitors using DeclNodes.inc #define DECL(DERIVED, BASE) \ @@ -476,15 +498,11 @@ namespace clang { LocalInstantiationScope *getStartingScope() const { return StartingScope; } - typedef - SmallVectorImpl > - ::iterator - delayed_partial_spec_iterator; + using delayed_partial_spec_iterator = SmallVectorImpl>::iterator; - typedef SmallVectorImpl >::iterator - delayed_var_partial_spec_iterator; + using delayed_var_partial_spec_iterator = SmallVectorImpl>::iterator; /// \brief Return an iterator to the beginning of the set of /// "delayed" partial specializations, which must be passed to @@ -545,6 +563,7 @@ namespace clang { Decl *instantiateUnresolvedUsingDecl(T *D, bool InstantiatingPackElement = false); }; -} + +} // namespace clang #endif // LLVM_CLANG_SEMA_TEMPLATE_H diff --git a/include/clang/Sema/TemplateDeduction.h b/include/clang/Sema/TemplateDeduction.h index cd9ed6abfa..41e175bdcf 100644 --- a/include/clang/Sema/TemplateDeduction.h +++ b/include/clang/Sema/TemplateDeduction.h @@ -1,26 +1,35 @@ -//===- TemplateDeduction.h - C++ template argument deduction ----*- C++ -*-===/ +//===- TemplateDeduction.h - C++ template argument deduction ----*- C++ -*-===// // // The LLVM Compiler Infrastructure // // This file is distributed under the University of Illinois Open Source // License. See LICENSE.TXT for details. -//===----------------------------------------------------------------------===/ // -// This file provides types used with Sema's template argument deduction +//===----------------------------------------------------------------------===// +// +// This file provides types used with Sema's template argument deduction // routines. // -//===----------------------------------------------------------------------===/ +//===----------------------------------------------------------------------===// + #ifndef LLVM_CLANG_SEMA_TEMPLATEDEDUCTION_H #define LLVM_CLANG_SEMA_TEMPLATEDEDUCTION_H +#include "clang/AST/DeclAccessPair.h" #include "clang/AST/DeclTemplate.h" +#include "clang/AST/TemplateBase.h" #include "clang/Basic/PartialDiagnostic.h" +#include "clang/Basic/SourceLocation.h" +#include "llvm/ADT/Optional.h" #include "llvm/ADT/SmallVector.h" +#include +#include +#include namespace clang { +class Decl; struct DeducedPack; -class TemplateArgumentList; class Sema; namespace sema { @@ -30,15 +39,14 @@ namespace sema { /// TemplateDeductionResult value. class TemplateDeductionInfo { /// \brief The deduced template argument list. - /// - TemplateArgumentList *Deduced; + TemplateArgumentList *Deduced = nullptr; /// \brief The source location at which template argument /// deduction is occurring. SourceLocation Loc; /// \brief Have we suppressed an error during deduction? - bool HasSFINAEDiagnostic; + bool HasSFINAEDiagnostic = false; /// \brief The template parameter depth for which we're performing deduction. unsigned DeducedDepth; @@ -47,13 +55,11 @@ class TemplateDeductionInfo { /// SFINAE while performing template argument deduction. SmallVector SuppressedDiagnostics; - TemplateDeductionInfo(const TemplateDeductionInfo &) = delete; - void operator=(const TemplateDeductionInfo &) = delete; - public: TemplateDeductionInfo(SourceLocation Loc, unsigned DeducedDepth = 0) - : Deduced(nullptr), Loc(Loc), HasSFINAEDiagnostic(false), - DeducedDepth(DeducedDepth), CallArgIndex(0) {} + : Loc(Loc), DeducedDepth(DeducedDepth) {} + TemplateDeductionInfo(const TemplateDeductionInfo &) = delete; + TemplateDeductionInfo &operator=(const TemplateDeductionInfo &) = delete; /// \brief Returns the location at which template argument is /// occurring. @@ -124,8 +130,7 @@ public: } /// \brief Iterator over the set of suppressed diagnostics. - typedef SmallVectorImpl::const_iterator - diag_iterator; + using diag_iterator = SmallVectorImpl::const_iterator; /// \brief Returns an iterator at the beginning of the sequence of suppressed /// diagnostics. @@ -186,7 +191,7 @@ public: /// /// TDK_DeducedMismatch: this is the index of the argument that had a /// different argument type from its substituted parameter type. - unsigned CallArgIndex; + unsigned CallArgIndex = 0; /// \brief Information on packs that we're currently expanding. /// @@ -194,7 +199,7 @@ public: SmallVector PendingDeducedPacks; }; -} // end namespace sema +} // namespace sema /// A structure used to record information about a failed /// template argument deduction, for diagnosis. @@ -276,20 +281,20 @@ struct TemplateSpecCandidate { class TemplateSpecCandidateSet { SmallVector Candidates; SourceLocation Loc; + // Stores whether we're taking the address of these candidates. This helps us // produce better error messages when dealing with the pass_object_size // attribute on parameters. bool ForTakingAddress; - TemplateSpecCandidateSet( - const TemplateSpecCandidateSet &) = delete; - void operator=(const TemplateSpecCandidateSet &) = delete; - void destroyCandidates(); public: TemplateSpecCandidateSet(SourceLocation Loc, bool ForTakingAddress = false) : Loc(Loc), ForTakingAddress(ForTakingAddress) {} + TemplateSpecCandidateSet(const TemplateSpecCandidateSet &) = delete; + TemplateSpecCandidateSet & + operator=(const TemplateSpecCandidateSet &) = delete; ~TemplateSpecCandidateSet() { destroyCandidates(); } SourceLocation getLocation() const { return Loc; } @@ -298,7 +303,8 @@ public: /// TODO: This may be unnecessary. void clear(); - typedef SmallVector::iterator iterator; + using iterator = SmallVector::iterator; + iterator begin() { return Candidates.begin(); } iterator end() { return Candidates.end(); } @@ -319,6 +325,6 @@ public: } }; -} // end namespace clang +} // namespace clang -#endif +#endif // LLVM_CLANG_SEMA_TEMPLATEDEDUCTION_H diff --git a/include/clang/Sema/TypoCorrection.h b/include/clang/Sema/TypoCorrection.h index 5bebe52325..a5cd5f924b 100644 --- a/include/clang/Sema/TypoCorrection.h +++ b/include/clang/Sema/TypoCorrection.h @@ -1,4 +1,4 @@ -//===--- TypoCorrection.h - Class for typo correction results ---*- C++ -*-===// +//===- TypoCorrection.h - Class for typo correction results -----*- C++ -*-===// // // The LLVM Compiler Infrastructure // @@ -15,18 +15,36 @@ #ifndef LLVM_CLANG_SEMA_TYPOCORRECTION_H #define LLVM_CLANG_SEMA_TYPOCORRECTION_H -#include "clang/AST/DeclCXX.h" +#include "clang/AST/Decl.h" +#include "clang/AST/DeclarationName.h" +#include "clang/Basic/LLVM.h" +#include "clang/Basic/PartialDiagnostic.h" +#include "clang/Basic/SourceLocation.h" #include "clang/Sema/DeclSpec.h" -#include "clang/Sema/Ownership.h" +#include "llvm/ADT/ArrayRef.h" #include "llvm/ADT/SmallVector.h" +#include "llvm/Support/Casting.h" +#include +#include +#include +#include +#include namespace clang { +class DeclContext; +class IdentifierInfo; +class LangOptions; +class MemberExpr; +class NestedNameSpecifier; +class Sema; + /// @brief Simple class containing the result of Sema::CorrectTypo class TypoCorrection { public: // "Distance" for unusable corrections - static const unsigned InvalidDistance = ~0U; + static const unsigned InvalidDistance = std::numeric_limits::max(); + // The largest distance still considered valid (larger edit distances are // mapped to InvalidDistance by getEditDistance). static const unsigned MaximumDistance = 10000U; @@ -43,9 +61,7 @@ public: NestedNameSpecifier *NNS = nullptr, unsigned CharDistance = 0, unsigned QualifierDistance = 0) : CorrectionName(Name), CorrectionNameSpec(NNS), - CharDistance(CharDistance), QualifierDistance(QualifierDistance), - CallbackDistance(0), ForceSpecifierReplacement(false), - RequiresImport(false) { + CharDistance(CharDistance), QualifierDistance(QualifierDistance) { if (NameDecl) CorrectionDecls.push_back(NameDecl); } @@ -53,8 +69,7 @@ public: TypoCorrection(NamedDecl *Name, NestedNameSpecifier *NNS = nullptr, unsigned CharDistance = 0) : CorrectionName(Name->getDeclName()), CorrectionNameSpec(NNS), - CharDistance(CharDistance), QualifierDistance(0), CallbackDistance(0), - ForceSpecifierReplacement(false), RequiresImport(false) { + CharDistance(CharDistance) { if (Name) CorrectionDecls.push_back(Name); } @@ -62,16 +77,13 @@ public: TypoCorrection(DeclarationName Name, NestedNameSpecifier *NNS = nullptr, unsigned CharDistance = 0) : CorrectionName(Name), CorrectionNameSpec(NNS), - CharDistance(CharDistance), QualifierDistance(0), CallbackDistance(0), - ForceSpecifierReplacement(false), RequiresImport(false) {} + CharDistance(CharDistance) {} - TypoCorrection() - : CorrectionNameSpec(nullptr), CharDistance(0), QualifierDistance(0), - CallbackDistance(0), ForceSpecifierReplacement(false), - RequiresImport(false) {} + TypoCorrection() = default; /// \brief Gets the DeclarationName of the typo correction DeclarationName getCorrection() const { return CorrectionName; } + IdentifierInfo *getCorrectionAsIdentifierInfo() const { return CorrectionName.getAsIdentifierInfo(); } @@ -80,6 +92,7 @@ public: NestedNameSpecifier *getCorrectionSpecifier() const { return CorrectionNameSpec; } + void setCorrectionSpecifier(NestedNameSpecifier *NNS) { CorrectionNameSpec = NNS; ForceSpecifierReplacement = (NNS != nullptr); @@ -167,6 +180,7 @@ public: void addCorrectionDecl(NamedDecl *CDecl); std::string getAsString(const LangOptions &LO) const; + std::string getQuoted(const LangOptions &LO) const { return "'" + getAsString(LO) + "'"; } @@ -214,15 +228,20 @@ public: return CorrectionRange; } - typedef SmallVectorImpl::iterator decl_iterator; + using decl_iterator = SmallVectorImpl::iterator; + decl_iterator begin() { return isKeyword() ? CorrectionDecls.end() : CorrectionDecls.begin(); } + decl_iterator end() { return CorrectionDecls.end(); } - typedef SmallVectorImpl::const_iterator const_decl_iterator; + + using const_decl_iterator = SmallVectorImpl::const_iterator; + const_decl_iterator begin() const { return isKeyword() ? CorrectionDecls.end() : CorrectionDecls.begin(); } + const_decl_iterator end() const { return CorrectionDecls.end(); } /// \brief Returns whether this typo correction is correcting to a @@ -246,14 +265,14 @@ private: // Results. DeclarationName CorrectionName; - NestedNameSpecifier *CorrectionNameSpec; + NestedNameSpecifier *CorrectionNameSpec = nullptr; SmallVector CorrectionDecls; - unsigned CharDistance; - unsigned QualifierDistance; - unsigned CallbackDistance; + unsigned CharDistance = 0; + unsigned QualifierDistance = 0; + unsigned CallbackDistance = 0; SourceRange CorrectionRange; - bool ForceSpecifierReplacement; - bool RequiresImport; + bool ForceSpecifierReplacement = false; + bool RequiresImport = false; std::vector ExtraDiagnostics; }; @@ -266,13 +285,9 @@ public: explicit CorrectionCandidateCallback(IdentifierInfo *Typo = nullptr, NestedNameSpecifier *TypoNNS = nullptr) - : WantTypeSpecifiers(true), WantExpressionKeywords(true), - WantCXXNamedCasts(true), WantFunctionLikeCasts(true), - WantRemainingKeywords(true), WantObjCSuper(false), - IsObjCIvarLookup(false), IsAddressOfOperand(false), Typo(Typo), - TypoNNS(TypoNNS) {} + : Typo(Typo), TypoNNS(TypoNNS) {} - virtual ~CorrectionCandidateCallback() {} + virtual ~CorrectionCandidateCallback() = default; /// \brief Simple predicate used by the default RankCandidate to /// determine whether to return an edit distance of 0 or InvalidDistance. @@ -304,16 +319,16 @@ public: // Flags for context-dependent keywords. WantFunctionLikeCasts is only // used/meaningful when WantCXXNamedCasts is false. // TODO: Expand these to apply to non-keywords or possibly remove them. - bool WantTypeSpecifiers; - bool WantExpressionKeywords; - bool WantCXXNamedCasts; - bool WantFunctionLikeCasts; - bool WantRemainingKeywords; - bool WantObjCSuper; + bool WantTypeSpecifiers = true; + bool WantExpressionKeywords = true; + bool WantCXXNamedCasts = true; + bool WantFunctionLikeCasts = true; + bool WantRemainingKeywords = true; + bool WantObjCSuper = false; // Temporary hack for the one case where a CorrectTypoContext enum is used // when looking up results. - bool IsObjCIvarLookup; - bool IsAddressOfOperand; + bool IsObjCIvarLookup = false; + bool IsAddressOfOperand = false; protected: bool MatchesTypo(const TypoCorrection &candidate) { @@ -349,7 +364,7 @@ public: bool ValidateCandidate(const TypoCorrection &candidate) override; - private: +private: unsigned NumArgs; bool HasExplicitTemplateArgs; DeclContext *CurContext; @@ -372,6 +387,6 @@ public: } }; -} +} // namespace clang -#endif +#endif // LLVM_CLANG_SEMA_TYPOCORRECTION_H diff --git a/include/clang/Serialization/ASTReader.h b/include/clang/Serialization/ASTReader.h index ed1f4cbc68..01cd055e76 100644 --- a/include/clang/Serialization/ASTReader.h +++ b/include/clang/Serialization/ASTReader.h @@ -14,14 +14,15 @@ #ifndef LLVM_CLANG_SERIALIZATION_ASTREADER_H #define LLVM_CLANG_SERIALIZATION_ASTREADER_H +#include "clang/AST/DeclCXX.h" #include "clang/AST/DeclObjC.h" #include "clang/AST/DeclarationName.h" +#include "clang/AST/NestedNameSpecifier.h" #include "clang/AST/TemplateBase.h" #include "clang/AST/TemplateName.h" #include "clang/AST/Type.h" #include "clang/Basic/Diagnostic.h" #include "clang/Basic/DiagnosticOptions.h" -#include "clang/Basic/FileSystemOptions.h" #include "clang/Basic/IdentifierTable.h" #include "clang/Basic/Module.h" #include "clang/Basic/OpenCLOptions.h" @@ -79,9 +80,6 @@ class ASTContext; class ASTDeserializationListener; class ASTReader; class ASTRecordReader; -class CXXBaseSpecifier; -class CXXConstructorDecl; -class CXXCtorInitializer; class CXXTemporary; class Decl; class DeclaratorDecl; @@ -102,7 +100,6 @@ class MacroInfo; class MemoryBufferCache; class NamedDecl; class NamespaceDecl; -class NestedNameSpecifier; class ObjCCategoryDecl; class ObjCInterfaceDecl; class PCHContainerReader; @@ -294,7 +291,7 @@ class PCHValidator : public ASTReaderListener { public: PCHValidator(Preprocessor &PP, ASTReader &Reader) - : PP(PP), Reader(Reader) {} + : PP(PP), Reader(Reader) {} bool ReadLanguageOptions(const LangOptions &LangOpts, bool Complain, bool AllowCompatibleDifferences) override; @@ -321,8 +318,7 @@ class SimpleASTReaderListener : public ASTReaderListener { Preprocessor &PP; public: - SimpleASTReaderListener(Preprocessor &PP) - : PP(PP) {} + SimpleASTReaderListener(Preprocessor &PP) : PP(PP) {} bool ReadPreprocessorOptions(const PreprocessorOptions &PPOpts, bool Complain, std::string &SuggestedPredefines) override; @@ -559,7 +555,7 @@ private: FileDeclsInfo() = default; FileDeclsInfo(ModuleFile *Mod, ArrayRef Decls) - : Mod(Mod), Decls(Decls) {} + : Mod(Mod), Decls(Decls) {} }; /// \brief Map from a FileID to the file-level declarations that it contains. @@ -753,8 +749,8 @@ private: /// added to the global preprocessing entity ID to produce a local ID. GlobalPreprocessedEntityMapType GlobalPreprocessedEntityMap; - typedef ContinuousRangeMap - GlobalSkippedRangeMapType; + using GlobalSkippedRangeMapType = + ContinuousRangeMap; /// \brief Mapping from global skipped range base IDs to the module in which /// the skipped ranges reside. @@ -905,7 +901,7 @@ public: SourceLocation ImportLoc; ImportedSubmodule(serialization::SubmoduleID ID, SourceLocation ImportLoc) - : ID(ID), ImportLoc(ImportLoc) {} + : ID(ID), ImportLoc(ImportLoc) {} }; private: @@ -1152,7 +1148,7 @@ private: public: ReadingKindTracker(enum ReadingKind newKind, ASTReader &reader) - : Reader(reader), PrevKind(Reader.ReadingKind) { + : Reader(reader), PrevKind(Reader.ReadingKind) { Reader.ReadingKind = newKind; } @@ -1168,7 +1164,7 @@ private: public: ProcessingUpdatesRAIIObj(ASTReader &reader) - : Reader(reader), PrevState(Reader.ProcessingUpdateRecords) { + : Reader(reader), PrevState(Reader.ProcessingUpdateRecords) { Reader.ProcessingUpdateRecords = true; } @@ -1257,7 +1253,7 @@ private: ImportedModule(ModuleFile *Mod, ModuleFile *ImportedBy, SourceLocation ImportLoc) - : Mod(Mod), ImportedBy(ImportedBy), ImportLoc(ImportLoc) {} + : Mod(Mod), ImportedBy(ImportedBy), ImportLoc(ImportLoc) {} }; ASTReadResult ReadASTCore(StringRef FileName, ModuleKind Type, @@ -1321,8 +1317,7 @@ private: ModuleFile *F; uint64_t Offset; - RecordLocation(ModuleFile *M, uint64_t O) - : F(M), Offset(O) {} + RecordLocation(ModuleFile *M, uint64_t O) : F(M), Offset(O) {} }; QualType readTypeRecord(unsigned Index); @@ -1785,7 +1780,7 @@ public: /// was read from the given AST file. QualType readType(ModuleFile &F, const RecordData &Record, unsigned &Idx) { if (Idx >= Record.size()) - return QualType(); + return {}; return getLocalType(F, Record[Idx++]); } @@ -2628,7 +2623,7 @@ public: /// then restores it when destroyed. struct SavedStreamPosition { explicit SavedStreamPosition(llvm::BitstreamCursor &Cursor) - : Cursor(Cursor), Offset(Cursor.GetCurrentBitNo()) {} + : Cursor(Cursor), Offset(Cursor.GetCurrentBitNo()) {} ~SavedStreamPosition() { Cursor.JumpToBit(Offset); diff --git a/lib/Sema/SemaTemplateDeduction.cpp b/lib/Sema/SemaTemplateDeduction.cpp index 53fa8745ee..182325955b 100644 --- a/lib/Sema/SemaTemplateDeduction.cpp +++ b/lib/Sema/SemaTemplateDeduction.cpp @@ -1,33 +1,64 @@ -//===------- SemaTemplateDeduction.cpp - Template Argument Deduction ------===/ +//===- SemaTemplateDeduction.cpp - Template Argument Deduction ------------===// // // The LLVM Compiler Infrastructure // // This file is distributed under the University of Illinois Open Source // License. See LICENSE.TXT for details. -//===----------------------------------------------------------------------===/ // -// This file implements C++ template argument deduction. +//===----------------------------------------------------------------------===// // -//===----------------------------------------------------------------------===/ +// This file implements C++ template argument deduction. +// +//===----------------------------------------------------------------------===// #include "clang/Sema/TemplateDeduction.h" #include "TreeTransform.h" +#include "TypeLocBuilder.h" #include "clang/AST/ASTContext.h" #include "clang/AST/ASTLambda.h" -#include "clang/AST/DeclObjC.h" +#include "clang/AST/Decl.h" +#include "clang/AST/DeclAccessPair.h" +#include "clang/AST/DeclBase.h" +#include "clang/AST/DeclCXX.h" #include "clang/AST/DeclTemplate.h" +#include "clang/AST/DeclarationName.h" #include "clang/AST/Expr.h" #include "clang/AST/ExprCXX.h" -#include "clang/AST/StmtVisitor.h" -#include "clang/AST/TypeOrdering.h" -#include "clang/Sema/DeclSpec.h" +#include "clang/AST/NestedNameSpecifier.h" +#include "clang/AST/TemplateBase.h" +#include "clang/AST/TemplateName.h" +#include "clang/AST/Type.h" +#include "clang/AST/TypeLoc.h" +#include "clang/AST/UnresolvedSet.h" +#include "clang/Basic/AddressSpaces.h" +#include "clang/Basic/ExceptionSpecificationType.h" +#include "clang/Basic/LLVM.h" +#include "clang/Basic/LangOptions.h" +#include "clang/Basic/PartialDiagnostic.h" +#include "clang/Basic/SourceLocation.h" +#include "clang/Basic/Specifiers.h" +#include "clang/Sema/Ownership.h" #include "clang/Sema/Sema.h" #include "clang/Sema/Template.h" +#include "llvm/ADT/APInt.h" +#include "llvm/ADT/APSInt.h" +#include "llvm/ADT/ArrayRef.h" +#include "llvm/ADT/DenseMap.h" +#include "llvm/ADT/FoldingSet.h" +#include "llvm/ADT/Optional.h" #include "llvm/ADT/SmallBitVector.h" +#include "llvm/ADT/SmallPtrSet.h" +#include "llvm/ADT/SmallVector.h" +#include "llvm/Support/Casting.h" +#include "llvm/Support/Compiler.h" +#include "llvm/Support/ErrorHandling.h" #include +#include +#include +#include namespace clang { - using namespace sema; + /// \brief Various flags that control template argument deduction. /// /// These flags can be bitwise-OR'd together. @@ -36,24 +67,30 @@ namespace clang { /// strictest results for template argument deduction (as used for, e.g., /// matching class template partial specializations). TDF_None = 0, + /// \brief Within template argument deduction from a function call, we are /// matching with a parameter type for which the original parameter was /// a reference. TDF_ParamWithReferenceType = 0x1, + /// \brief Within template argument deduction from a function call, we /// are matching in a case where we ignore cv-qualifiers. TDF_IgnoreQualifiers = 0x02, + /// \brief Within template argument deduction from a function call, /// we are matching in a case where we can perform template argument /// deduction from a template-id of a derived class of the argument type. TDF_DerivedClass = 0x04, + /// \brief Allow non-dependent types to differ, e.g., when performing /// template argument deduction from a function call where conversions /// may apply. TDF_SkipNonDependent = 0x08, + /// \brief Whether we are performing template argument deduction for /// parameters and arguments in a top-level template argument TDF_TopLevelParameterTypeList = 0x10, + /// \brief Within template argument deduction from overload resolution per /// C++ [over.over] allow matching function types that are compatible in /// terms of noreturn and default calling convention adjustments, or @@ -66,6 +103,7 @@ namespace clang { } using namespace clang; +using namespace sema; /// \brief Compare two APSInts, extending and switching the sign as /// necessary to compare their values regardless of underlying type. @@ -132,7 +170,7 @@ static NonTypeTemplateParmDecl * getDeducedParameterFromExpr(TemplateDeductionInfo &Info, Expr *E) { // If we are within an alias template, the expression may have undergone // any number of parameter substitutions already. - while (1) { + while (true) { if (ImplicitCastExpr *IC = dyn_cast(E)) E = IC->getSubExpr(); else if (SubstNonTypeTemplateParmExpr *Subst = @@ -297,7 +335,7 @@ checkDeducedTemplateArguments(ASTContext &Context, // All other combinations are incompatible. return DeducedTemplateArgument(); - case TemplateArgument::Pack: + case TemplateArgument::Pack: { if (Y.getKind() != TemplateArgument::Pack || X.pack_size() != Y.pack_size()) return DeducedTemplateArgument(); @@ -319,6 +357,7 @@ checkDeducedTemplateArguments(ASTContext &Context, TemplateArgument::CreatePackCopy(Context, NewPack), X.wasDeducedFromArrayBound() && Y.wasDeducedFromArrayBound()); } + } llvm_unreachable("Invalid TemplateArgument Kind!"); } @@ -620,8 +659,6 @@ static TemplateParameter makeTemplateParameter(Decl *D) { /// A pack that we're currently deducing. struct clang::DeducedPack { - DeducedPack(unsigned Index) : Index(Index), Outer(nullptr) {} - // The index of the pack. unsigned Index; @@ -636,10 +673,13 @@ struct clang::DeducedPack { SmallVector New; // The outer deduction for this pack, if any. - DeducedPack *Outer; + DeducedPack *Outer = nullptr; + + DeducedPack(unsigned Index) : Index(Index) {} }; namespace { + /// A scope in which we're performing pack deduction. class PackDeductionScope { public: @@ -854,6 +894,7 @@ private: SmallVector Packs; }; + } // namespace /// \brief Deduce the template arguments by comparing the list of parameter @@ -1357,7 +1398,7 @@ DeduceTemplateArgumentsByTypeMatch(Sema &S, case Type::Enum: case Type::ObjCObject: case Type::ObjCInterface: - case Type::ObjCObjectPointer: { + case Type::ObjCObjectPointer: if (TDF & TDF_SkipNonDependent) return Sema::TDK_Success; @@ -1367,7 +1408,6 @@ DeduceTemplateArgumentsByTypeMatch(Sema &S, } return Param == Arg? Sema::TDK_Success : Sema::TDK_NonDeducedMismatch; - } // _Complex T [placeholder extension] case Type::Complex: @@ -1586,7 +1626,7 @@ DeduceTemplateArgumentsByTypeMatch(Sema &S, return Sema::TDK_Success; } - case Type::InjectedClassName: { + case Type::InjectedClassName: // Treat a template's injected-class-name as if the template // specialization type had been used. Param = cast(Param) @@ -1594,7 +1634,6 @@ DeduceTemplateArgumentsByTypeMatch(Sema &S, assert(isa(Param) && "injected class name is not a template specialization type"); LLVM_FALLTHROUGH; - } // template-name (where template-name refers to a class template) // template-name @@ -1996,7 +2035,7 @@ DeduceTemplateArguments(Sema &S, Info.SecondArg = Arg; return Sema::TDK_NonDeducedMismatch; - case TemplateArgument::Expression: { + case TemplateArgument::Expression: if (NonTypeTemplateParmDecl *NTTP = getDeducedParameterFromExpr(Info, Param.getAsExpr())) { if (Arg.getKind() == TemplateArgument::Integral) @@ -2025,7 +2064,7 @@ DeduceTemplateArguments(Sema &S, // Can't deduce anything, but that's okay. return Sema::TDK_Success; - } + case TemplateArgument::Pack: llvm_unreachable("Argument packs should be expanded by the caller!"); } @@ -2307,7 +2346,6 @@ Sema::getTrivialTemplateArgumentLoc(const TemplateArgument &Arg, llvm_unreachable("Invalid TemplateArgument Kind!"); } - /// \brief Convert the given deduced template argument and add it to the set of /// fully-converted template arguments. static bool @@ -3271,13 +3309,14 @@ static QualType GetTypeOfFunction(Sema &S, const OverloadExpr::FindResult &R, // We may need to deduce the return type of the function now. if (S.getLangOpts().CPlusPlus14 && Fn->getReturnType()->isUndeducedType() && S.DeduceReturnType(Fn, R.Expression->getExprLoc(), /*Diagnose*/ false)) - return QualType(); + return {}; if (CXXMethodDecl *Method = dyn_cast(Fn)) if (Method->isInstance()) { // An instance method that's referenced in a form that doesn't // look like a member pointer is just invalid. - if (!R.HasFormOfMemberPointer) return QualType(); + if (!R.HasFormOfMemberPointer) + return {}; return S.Context.getMemberPointerType(Fn->getType(), S.Context.getTypeDeclType(Method->getParent()).getTypePtr()); @@ -3326,7 +3365,7 @@ ResolveOverloadForDeduction(Sema &S, TemplateParameterList *TemplateParams, S.resolveAddressOfOnlyViableOverloadCandidate(Arg, DAP)) return GetTypeOfFunction(S, R, Viable); - return QualType(); + return {}; } // Gather the explicit template arguments, if any. @@ -3343,7 +3382,7 @@ ResolveOverloadForDeduction(Sema &S, TemplateParameterList *TemplateParams, // function templates, the parameter is treated as a // non-deduced context. if (!Ovl->hasExplicitTemplateArgs()) - return QualType(); + return {}; // Otherwise, see if we can resolve a function type FunctionDecl *Specialization = nullptr; @@ -3383,7 +3422,8 @@ ResolveOverloadForDeduction(Sema &S, TemplateParameterList *TemplateParams, = DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, ParamType, ArgType, Info, Deduced, TDF); if (Result) continue; - if (!Match.isNull()) return QualType(); + if (!Match.isNull()) + return {}; Match = ArgType; } @@ -4089,12 +4129,14 @@ Sema::TemplateDeductionResult Sema::DeduceTemplateArguments( } namespace { + /// Substitute the 'auto' specifier or deduced template specialization type /// specifier within a type for a given replacement type. class SubstituteDeducedTypeTransform : public TreeTransform { QualType Replacement; bool UseTypeSugar; + public: SubstituteDeducedTypeTransform(Sema &SemaRef, QualType Replacement, bool UseTypeSugar = true) @@ -4156,7 +4198,8 @@ namespace { return TransformType(TLB, TL); } }; -} + +} // namespace Sema::DeduceAutoResult Sema::DeduceAutoType(TypeSourceInfo *Type, Expr *&Init, QualType &Result, @@ -5029,7 +5072,7 @@ MarkUsedTemplateParameters(ASTContext &Ctx, // Skip through any implicit casts we added while type-checking, and any // substitutions performed by template alias expansion. - while (1) { + while (true) { if (const ImplicitCastExpr *ICE = dyn_cast(E)) E = ICE->getSubExpr(); else if (const SubstNonTypeTemplateParmExpr *Subst = -- 2.40.0