r325544 - [Sema] Fix some Clang-tidy modernize and Include What You Use warnings; other minor fixes (NFC).
Eugene Zelenko via cfe-commits
cfe-commits at lists.llvm.org
Mon Feb 19 18:16:28 PST 2018
Author: eugenezelenko
Date: Mon Feb 19 18:16:28 2018
New Revision: 325544
URL: http://llvm.org/viewvc/llvm-project?rev=325544&view=rev
Log:
[Sema] Fix some Clang-tidy modernize and Include What You Use warnings; other minor fixes (NFC).
Modified:
cfe/trunk/include/clang/Sema/AttributeList.h
cfe/trunk/include/clang/Sema/CodeCompleteConsumer.h
cfe/trunk/include/clang/Sema/Ownership.h
cfe/trunk/lib/Sema/AttributeList.cpp
cfe/trunk/lib/Sema/CodeCompleteConsumer.cpp
Modified: cfe/trunk/include/clang/Sema/AttributeList.h
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/include/clang/Sema/AttributeList.h?rev=325544&r1=325543&r2=325544&view=diff
==============================================================================
--- cfe/trunk/include/clang/Sema/AttributeList.h (original)
+++ cfe/trunk/include/clang/Sema/AttributeList.h Mon Feb 19 18:16:28 2018
@@ -1,4 +1,4 @@
-//===--- AttributeList.h - Parsed attribute sets ----------------*- C++ -*-===//
+//===- AttributeList.h - Parsed attribute sets ------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
@@ -24,11 +24,17 @@
#include "llvm/ADT/SmallVector.h"
#include "llvm/Support/Allocator.h"
#include <cassert>
+#include <cstddef>
+#include <cstring>
+#include <utility>
namespace clang {
- class ASTContext;
- class IdentifierInfo;
- class Expr;
+
+class ASTContext;
+class Decl;
+class Expr;
+class IdentifierInfo;
+class LangOptions;
/// \brief Represents information about a change in availability for
/// an entity, which is part of the encoding of the 'availability'
@@ -48,6 +54,7 @@ struct AvailabilityChange {
};
namespace {
+
enum AvailabilitySlot {
IntroducedSlot, DeprecatedSlot, ObsoletedSlot, NumAvailabilitySlots
};
@@ -57,6 +64,7 @@ struct AvailabilityData {
AvailabilityChange Changes[NumAvailabilitySlots];
SourceLocation StrictLoc;
const Expr *Replacement;
+
AvailabilityData(const AvailabilityChange &Introduced,
const AvailabilityChange &Deprecated,
const AvailabilityChange &Obsoleted,
@@ -67,7 +75,8 @@ struct AvailabilityData {
Changes[ObsoletedSlot] = Obsoleted;
}
};
-}
+
+} // namespace
/// \brief Wraps an identifier and optional source location for the identifier.
struct IdentifierLoc {
@@ -80,8 +89,8 @@ struct IdentifierLoc {
/// \brief A union of the various pointer types that can be passed to an
/// AttributeList as an argument.
-typedef llvm::PointerUnion<Expr*, IdentifierLoc*> ArgsUnion;
-typedef llvm::SmallVector<ArgsUnion, 12U> ArgsVector;
+using ArgsUnion = llvm::PointerUnion<Expr *, IdentifierLoc *>;
+using ArgsVector = llvm::SmallVector<ArgsUnion, 12U>;
/// AttributeList - Represents a syntactic attribute.
///
@@ -98,18 +107,25 @@ public:
enum Syntax {
/// __attribute__((...))
AS_GNU,
+
/// [[...]]
AS_CXX11,
+
/// [[...]]
AS_C2x,
+
/// __declspec(...)
AS_Declspec,
+
/// [uuid("...")] class Foo
AS_Microsoft,
+
/// __ptr16, alignas(...), etc.
AS_Keyword,
+
/// #pragma ...
AS_Pragma,
+
// Note TableGen depends on the order above. Do not add or change the order
// without adding related code to TableGen/ClangAttrEmitter.cpp.
/// Context-sensitive version of a keyword attribute.
@@ -166,10 +182,10 @@ private:
const Expr *MessageExpr;
/// The next attribute in the current position.
- AttributeList *NextInPosition;
+ AttributeList *NextInPosition = nullptr;
/// The next attribute allocated in the current Pool.
- AttributeList *NextInPool;
+ AttributeList *NextInPool = nullptr;
/// Arguments, if any, are stored immediately following the object.
ArgsUnion *getArgsBuffer() { return reinterpret_cast<ArgsUnion *>(this + 1); }
@@ -194,63 +210,25 @@ public:
};
struct PropertyData {
IdentifierInfo *GetterId, *SetterId;
+
PropertyData(IdentifierInfo *getterId, IdentifierInfo *setterId)
- : GetterId(getterId), SetterId(setterId) {}
+ : GetterId(getterId), SetterId(setterId) {}
};
private:
- /// Type tag information is stored immediately following the arguments, if
- /// any, at the end of the object. They are mutually exlusive with
- /// availability slots.
- TypeTagForDatatypeData &getTypeTagForDatatypeDataSlot() {
- return *reinterpret_cast<TypeTagForDatatypeData*>(getArgsBuffer()+NumArgs);
- }
-
- const TypeTagForDatatypeData &getTypeTagForDatatypeDataSlot() const {
- return *reinterpret_cast<const TypeTagForDatatypeData*>(getArgsBuffer()
- + NumArgs);
- }
-
- /// The type buffer immediately follows the object and are mutually exclusive
- /// with arguments.
- ParsedType &getTypeBuffer() {
- return *reinterpret_cast<ParsedType *>(this + 1);
- }
-
- const ParsedType &getTypeBuffer() const {
- return *reinterpret_cast<const ParsedType *>(this + 1);
- }
-
- /// The property data immediately follows the object is is mutually exclusive
- /// with arguments.
- PropertyData &getPropertyDataBuffer() {
- assert(IsProperty);
- return *reinterpret_cast<PropertyData*>(this + 1);
- }
-
- const PropertyData &getPropertyDataBuffer() const {
- assert(IsProperty);
- return *reinterpret_cast<const PropertyData*>(this + 1);
- }
-
- AttributeList(const AttributeList &) = delete;
- void operator=(const AttributeList &) = delete;
- void operator delete(void *) = delete;
- ~AttributeList() = delete;
-
- size_t allocated_size() const;
+ friend class AttributeFactory;
+ friend class AttributePool;
/// Constructor for attributes with expression arguments.
AttributeList(IdentifierInfo *attrName, SourceRange attrRange,
IdentifierInfo *scopeName, SourceLocation scopeLoc,
ArgsUnion *args, unsigned numArgs,
Syntax syntaxUsed, SourceLocation ellipsisLoc)
- : AttrName(attrName), ScopeName(scopeName), AttrRange(attrRange),
- ScopeLoc(scopeLoc), EllipsisLoc(ellipsisLoc), NumArgs(numArgs),
- SyntaxUsed(syntaxUsed), Invalid(false), UsedAsTypeAttr(false),
- IsAvailability(false), IsTypeTagForDatatype(false), IsProperty(false),
- HasParsedType(false), HasProcessingCache(false),
- NextInPosition(nullptr), NextInPool(nullptr) {
+ : AttrName(attrName), ScopeName(scopeName), AttrRange(attrRange),
+ ScopeLoc(scopeLoc), EllipsisLoc(ellipsisLoc), NumArgs(numArgs),
+ SyntaxUsed(syntaxUsed), Invalid(false), UsedAsTypeAttr(false),
+ IsAvailability(false), IsTypeTagForDatatype(false), IsProperty(false),
+ HasParsedType(false), HasProcessingCache(false) {
if (numArgs) memcpy(getArgsBuffer(), args, numArgs * sizeof(ArgsUnion));
AttrKind = getKind(getName(), getScopeName(), syntaxUsed);
}
@@ -265,12 +243,12 @@ private:
const Expr *messageExpr,
Syntax syntaxUsed, SourceLocation strict,
const Expr *replacementExpr)
- : AttrName(attrName), ScopeName(scopeName), AttrRange(attrRange),
- ScopeLoc(scopeLoc), EllipsisLoc(), NumArgs(1), SyntaxUsed(syntaxUsed),
- Invalid(false), UsedAsTypeAttr(false), IsAvailability(true),
- IsTypeTagForDatatype(false), IsProperty(false), HasParsedType(false),
- HasProcessingCache(false), UnavailableLoc(unavailable),
- MessageExpr(messageExpr), NextInPosition(nullptr), NextInPool(nullptr) {
+ : AttrName(attrName), ScopeName(scopeName), AttrRange(attrRange),
+ ScopeLoc(scopeLoc), NumArgs(1), SyntaxUsed(syntaxUsed), Invalid(false),
+ UsedAsTypeAttr(false), IsAvailability(true),
+ IsTypeTagForDatatype(false), IsProperty(false), HasParsedType(false),
+ HasProcessingCache(false), UnavailableLoc(unavailable),
+ MessageExpr(messageExpr) {
ArgsUnion PVal(Parm);
memcpy(getArgsBuffer(), &PVal, sizeof(ArgsUnion));
new (getAvailabilityData()) AvailabilityData(
@@ -285,11 +263,11 @@ private:
IdentifierLoc *Parm2,
IdentifierLoc *Parm3,
Syntax syntaxUsed)
- : AttrName(attrName), ScopeName(scopeName), AttrRange(attrRange),
- ScopeLoc(scopeLoc), EllipsisLoc(), NumArgs(3), SyntaxUsed(syntaxUsed),
- Invalid(false), UsedAsTypeAttr(false), IsAvailability(false),
- IsTypeTagForDatatype(false), IsProperty(false), HasParsedType(false),
- HasProcessingCache(false), NextInPosition(nullptr), NextInPool(nullptr) {
+ : AttrName(attrName), ScopeName(scopeName), AttrRange(attrRange),
+ ScopeLoc(scopeLoc), NumArgs(3), SyntaxUsed(syntaxUsed), Invalid(false),
+ UsedAsTypeAttr(false), IsAvailability(false),
+ IsTypeTagForDatatype(false), IsProperty(false), HasParsedType(false),
+ HasProcessingCache(false) {
ArgsUnion *Args = getArgsBuffer();
Args[0] = Parm1;
Args[1] = Parm2;
@@ -302,11 +280,11 @@ private:
IdentifierInfo *scopeName, SourceLocation scopeLoc,
IdentifierLoc *ArgKind, ParsedType matchingCType,
bool layoutCompatible, bool mustBeNull, Syntax syntaxUsed)
- : AttrName(attrName), ScopeName(scopeName), AttrRange(attrRange),
- ScopeLoc(scopeLoc), EllipsisLoc(), NumArgs(1), SyntaxUsed(syntaxUsed),
- Invalid(false), UsedAsTypeAttr(false), IsAvailability(false),
- IsTypeTagForDatatype(true), IsProperty(false), HasParsedType(false),
- HasProcessingCache(false), NextInPosition(nullptr), NextInPool(nullptr) {
+ : AttrName(attrName), ScopeName(scopeName), AttrRange(attrRange),
+ ScopeLoc(scopeLoc), NumArgs(1), SyntaxUsed(syntaxUsed), Invalid(false),
+ UsedAsTypeAttr(false), IsAvailability(false),
+ IsTypeTagForDatatype(true), IsProperty(false), HasParsedType(false),
+ HasProcessingCache(false) {
ArgsUnion PVal(ArgKind);
memcpy(getArgsBuffer(), &PVal, sizeof(ArgsUnion));
TypeTagForDatatypeData &ExtraData = getTypeTagForDatatypeDataSlot();
@@ -321,10 +299,10 @@ private:
IdentifierInfo *scopeName, SourceLocation scopeLoc,
ParsedType typeArg, Syntax syntaxUsed)
: AttrName(attrName), ScopeName(scopeName), AttrRange(attrRange),
- ScopeLoc(scopeLoc), EllipsisLoc(), NumArgs(0), SyntaxUsed(syntaxUsed),
- Invalid(false), UsedAsTypeAttr(false), IsAvailability(false),
+ ScopeLoc(scopeLoc), NumArgs(0), SyntaxUsed(syntaxUsed), Invalid(false),
+ UsedAsTypeAttr(false), IsAvailability(false),
IsTypeTagForDatatype(false), IsProperty(false), HasParsedType(true),
- HasProcessingCache(false), NextInPosition(nullptr), NextInPool(nullptr){
+ HasProcessingCache(false) {
new (&getTypeBuffer()) ParsedType(typeArg);
AttrKind = getKind(getName(), getScopeName(), syntaxUsed);
}
@@ -334,19 +312,55 @@ private:
IdentifierInfo *scopeName, SourceLocation scopeLoc,
IdentifierInfo *getterId, IdentifierInfo *setterId,
Syntax syntaxUsed)
- : AttrName(attrName), ScopeName(scopeName), AttrRange(attrRange),
- ScopeLoc(scopeLoc), EllipsisLoc(), NumArgs(0), SyntaxUsed(syntaxUsed),
- Invalid(false), UsedAsTypeAttr(false), IsAvailability(false),
- IsTypeTagForDatatype(false), IsProperty(true), HasParsedType(false),
- HasProcessingCache(false), NextInPosition(nullptr), NextInPool(nullptr) {
+ : AttrName(attrName), ScopeName(scopeName), AttrRange(attrRange),
+ ScopeLoc(scopeLoc), NumArgs(0), SyntaxUsed(syntaxUsed),
+ Invalid(false), UsedAsTypeAttr(false), IsAvailability(false),
+ IsTypeTagForDatatype(false), IsProperty(true), HasParsedType(false),
+ HasProcessingCache(false) {
new (&getPropertyDataBuffer()) PropertyData(getterId, setterId);
AttrKind = getKind(getName(), getScopeName(), syntaxUsed);
}
- friend class AttributePool;
- friend class AttributeFactory;
+ /// Type tag information is stored immediately following the arguments, if
+ /// any, at the end of the object. They are mutually exlusive with
+ /// availability slots.
+ TypeTagForDatatypeData &getTypeTagForDatatypeDataSlot() {
+ return *reinterpret_cast<TypeTagForDatatypeData*>(getArgsBuffer()+NumArgs);
+ }
+ const TypeTagForDatatypeData &getTypeTagForDatatypeDataSlot() const {
+ return *reinterpret_cast<const TypeTagForDatatypeData*>(getArgsBuffer()
+ + NumArgs);
+ }
+
+ /// The type buffer immediately follows the object and are mutually exclusive
+ /// with arguments.
+ ParsedType &getTypeBuffer() {
+ return *reinterpret_cast<ParsedType *>(this + 1);
+ }
+ const ParsedType &getTypeBuffer() const {
+ return *reinterpret_cast<const ParsedType *>(this + 1);
+ }
+
+ /// The property data immediately follows the object is is mutually exclusive
+ /// with arguments.
+ PropertyData &getPropertyDataBuffer() {
+ assert(IsProperty);
+ return *reinterpret_cast<PropertyData*>(this + 1);
+ }
+ const PropertyData &getPropertyDataBuffer() const {
+ assert(IsProperty);
+ return *reinterpret_cast<const PropertyData*>(this + 1);
+ }
+
+ size_t allocated_size() const;
public:
+ AttributeList(const AttributeList &) = delete;
+ AttributeList &operator=(const AttributeList &) = delete;
+ ~AttributeList() = delete;
+
+ void operator delete(void *) = delete;
+
enum Kind {
#define PARSED_ATTR(NAME) AT_##NAME,
#include "clang/Sema/AttrParsedAttrList.inc"
@@ -377,12 +391,15 @@ public:
bool isDeclspecAttribute() const { return SyntaxUsed == AS_Declspec; }
bool isMicrosoftAttribute() const { return SyntaxUsed == AS_Microsoft; }
+
bool isCXX11Attribute() const {
return SyntaxUsed == AS_CXX11 || isAlignasAttribute();
}
+
bool isC2xAttribute() const {
return SyntaxUsed == AS_C2x;
}
+
bool isKeywordAttribute() const {
return SyntaxUsed == AS_Keyword || SyntaxUsed == AS_ContextSensitiveKeyword;
}
@@ -395,10 +412,12 @@ public:
void setInvalid(bool b = true) const { Invalid = b; }
bool hasProcessingCache() const { return HasProcessingCache; }
+
unsigned getProcessingCache() const {
assert(hasProcessingCache());
return ProcessingCache;
}
+
void setProcessingCache(unsigned value) const {
ProcessingCache = value;
HasProcessingCache = true;
@@ -429,6 +448,7 @@ public:
bool isArgExpr(unsigned Arg) const {
return Arg < NumArgs && getArg(Arg).is<Expr*>();
}
+
Expr *getArgAsExpr(unsigned Arg) const {
return getArg(Arg).get<Expr*>();
}
@@ -436,6 +456,7 @@ public:
bool isArgIdent(unsigned Arg) const {
return Arg < NumArgs && getArg(Arg).is<IdentifierLoc*>();
}
+
IdentifierLoc *getArgAsIdent(unsigned Arg) const {
return getArg(Arg).get<IdentifierLoc*>();
}
@@ -596,7 +617,7 @@ public:
class AttributePool {
AttributeFactory &Factory;
- AttributeList *Head;
+ AttributeList *Head = nullptr;
void *allocate(size_t size) {
return Factory.allocate(size);
@@ -613,10 +634,14 @@ class AttributePool {
public:
/// Create a new pool for a factory.
- AttributePool(AttributeFactory &factory) : Factory(factory), Head(nullptr) {}
+ AttributePool(AttributeFactory &factory) : Factory(factory) {}
AttributePool(const AttributePool &) = delete;
+ ~AttributePool() {
+ if (Head) Factory.reclaimPool(Head);
+ }
+
/// Move the given pool's allocations to this pool.
AttributePool(AttributePool &&pool) : Factory(pool.Factory), Head(pool.Head) {
pool.Head = nullptr;
@@ -639,10 +664,6 @@ public:
}
}
- ~AttributePool() {
- if (Head) Factory.reclaimPool(Head);
- }
-
AttributeList *create(IdentifierInfo *attrName, SourceRange attrRange,
IdentifierInfo *scopeName, SourceLocation scopeLoc,
ArgsUnion *args, unsigned numArgs,
@@ -733,10 +754,7 @@ public:
/// is that this will become significantly more serious.
class ParsedAttributes {
public:
- ParsedAttributes(AttributeFactory &factory)
- : pool(factory), list(nullptr) {
- }
-
+ ParsedAttributes(AttributeFactory &factory) : pool(factory) {}
ParsedAttributes(const ParsedAttributes &) = delete;
AttributePool &getPool() const { return pool; }
@@ -882,7 +900,7 @@ public:
private:
mutable AttributePool pool;
- AttributeList *list;
+ AttributeList *list = nullptr;
};
/// These constants match the enumerated choices of
@@ -913,6 +931,6 @@ enum AttributeDeclKind {
ExpectedForMaybeUnused,
};
-} // end namespace clang
+} // namespace clang
-#endif
+#endif // LLVM_CLANG_SEMA_ATTRIBUTELIST_H
Modified: cfe/trunk/include/clang/Sema/CodeCompleteConsumer.h
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/include/clang/Sema/CodeCompleteConsumer.h?rev=325544&r1=325543&r2=325544&view=diff
==============================================================================
--- cfe/trunk/include/clang/Sema/CodeCompleteConsumer.h (original)
+++ cfe/trunk/include/clang/Sema/CodeCompleteConsumer.h Mon Feb 19 18:16:28 2018
@@ -1,4 +1,4 @@
-//===---- CodeCompleteConsumer.h - Code Completion Interface ----*- C++ -*-===//
+//===- CodeCompleteConsumer.h - Code Completion Interface -------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
@@ -10,25 +10,42 @@
// This file defines the CodeCompleteConsumer class.
//
//===----------------------------------------------------------------------===//
+
#ifndef LLVM_CLANG_SEMA_CODECOMPLETECONSUMER_H
#define LLVM_CLANG_SEMA_CODECOMPLETECONSUMER_H
#include "clang-c/Index.h"
-#include "clang/AST/CanonicalType.h"
-#include "clang/AST/DeclBase.h"
#include "clang/AST/Type.h"
+#include "clang/Basic/LLVM.h"
#include "clang/Sema/CodeCompleteOptions.h"
#include "clang/Sema/DeclSpec.h"
+#include "llvm/ADT/ArrayRef.h"
#include "llvm/ADT/DenseMap.h"
+#include "llvm/ADT/None.h"
+#include "llvm/ADT/Optional.h"
+#include "llvm/ADT/SmallPtrSet.h"
#include "llvm/ADT/SmallVector.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/Support/Allocator.h"
+#include "llvm/Support/type_traits.h"
+#include <cassert>
+#include <memory>
#include <string>
#include <utility>
namespace clang {
+class ASTContext;
class Decl;
+class DeclContext;
+class FunctionDecl;
+class FunctionTemplateDecl;
+class IdentifierInfo;
+class LangOptions;
+class NamedDecl;
+class NestedNameSpecifier;
+class Preprocessor;
+class Sema;
/// \brief Default priority values for code-completion results based
/// on their kind.
@@ -36,31 +53,43 @@ enum {
/// \brief Priority for the next initialization in a constructor initializer
/// list.
CCP_NextInitializer = 7,
+
/// \brief Priority for an enumeration constant inside a switch whose
/// condition is of the enumeration type.
CCP_EnumInCase = 7,
+
/// \brief Priority for a send-to-super completion.
CCP_SuperCompletion = 20,
+
/// \brief Priority for a declaration that is in the local scope.
CCP_LocalDeclaration = 34,
+
/// \brief Priority for a member declaration found from the current
/// method or member function.
CCP_MemberDeclaration = 35,
+
/// \brief Priority for a language keyword (that isn't any of the other
/// categories).
CCP_Keyword = 40,
+
/// \brief Priority for a code pattern.
CCP_CodePattern = 40,
+
/// \brief Priority for a non-type declaration.
CCP_Declaration = 50,
+
/// \brief Priority for a type.
CCP_Type = CCP_Declaration,
+
/// \brief Priority for a constant value (e.g., enumerator).
CCP_Constant = 65,
+
/// \brief Priority for a preprocessor macro.
CCP_Macro = 70,
+
/// \brief Priority for a nested-name-specifier.
CCP_NestedNameSpecifier = 75,
+
/// \brief Priority for a result that isn't likely to be what the user wants,
/// but is included for completeness.
CCP_Unlikely = 80,
@@ -74,9 +103,11 @@ enum {
enum {
/// \brief The result is in a base class.
CCD_InBaseClass = 2,
+
/// \brief The result is a C++ non-static member function whose qualifiers
/// exactly match the object type on which the member function can be called.
CCD_ObjectQualifierMatch = -1,
+
/// \brief The selector of the given message exactly matches the selector
/// of the current method, which might imply that some kind of delegation
/// is occurring.
@@ -104,6 +135,7 @@ enum {
/// \brief Divide by this factor when a code-completion result's type exactly
/// matches the type we expect.
CCF_ExactTypeMatch = 4,
+
/// \brief Divide by this factor when a code-completion result's type is
/// similar to the type we expect (e.g., both arithmetic types, both
/// Objective-C object pointer types).
@@ -148,14 +180,6 @@ unsigned getMacroUsagePriority(StringRef
/// declaration.
CXCursorKind getCursorKindForDecl(const Decl *D);
-class FunctionDecl;
-class FunctionType;
-class FunctionTemplateDecl;
-class IdentifierInfo;
-class NamedDecl;
-class NestedNameSpecifier;
-class Sema;
-
/// \brief The context in which code completion occurred, so that the
/// code-completion consumer can process the results accordingly.
class CodeCompletionContext {
@@ -163,31 +187,41 @@ public:
enum Kind {
/// \brief An unspecified code-completion context.
CCC_Other,
+
/// \brief An unspecified code-completion context where we should also add
/// macro completions.
CCC_OtherWithMacros,
+
/// \brief Code completion occurred within a "top-level" completion context,
/// e.g., at namespace or global scope.
CCC_TopLevel,
+
/// \brief Code completion occurred within an Objective-C interface,
/// protocol, or category interface.
CCC_ObjCInterface,
+
/// \brief Code completion occurred within an Objective-C implementation
/// or category implementation.
CCC_ObjCImplementation,
+
/// \brief Code completion occurred within the instance variable list of
/// an Objective-C interface, implementation, or category implementation.
CCC_ObjCIvarList,
+
/// \brief Code completion occurred within a class, struct, or union.
CCC_ClassStructUnion,
+
/// \brief Code completion occurred where a statement (or declaration) is
/// expected in a function, method, or block.
CCC_Statement,
+
/// \brief Code completion occurred where an expression is expected.
CCC_Expression,
+
/// \brief Code completion occurred where an Objective-C message receiver
/// is expected.
CCC_ObjCMessageReceiver,
+
/// \brief Code completion occurred on the right-hand side of a member
/// access expression using the dot operator.
///
@@ -195,6 +229,7 @@ public:
/// accessed. The type itself is available via
/// \c CodeCompletionContext::getType().
CCC_DotMemberAccess,
+
/// \brief Code completion occurred on the right-hand side of a member
/// access expression using the arrow operator.
///
@@ -202,6 +237,7 @@ public:
/// accessed. The type itself is available via
/// \c CodeCompletionContext::getType().
CCC_ArrowMemberAccess,
+
/// \brief Code completion occurred on the right-hand side of an Objective-C
/// property access expression.
///
@@ -209,66 +245,87 @@ public:
/// accessed. The type itself is available via
/// \c CodeCompletionContext::getType().
CCC_ObjCPropertyAccess,
+
/// \brief Code completion occurred after the "enum" keyword, to indicate
/// an enumeration name.
CCC_EnumTag,
+
/// \brief Code completion occurred after the "union" keyword, to indicate
/// a union name.
CCC_UnionTag,
+
/// \brief Code completion occurred after the "struct" or "class" keyword,
/// to indicate a struct or class name.
CCC_ClassOrStructTag,
+
/// \brief Code completion occurred where a protocol name is expected.
CCC_ObjCProtocolName,
+
/// \brief Code completion occurred where a namespace or namespace alias
/// is expected.
CCC_Namespace,
+
/// \brief Code completion occurred where a type name is expected.
CCC_Type,
+
/// \brief Code completion occurred where a new name is expected.
CCC_Name,
+
/// \brief Code completion occurred where a new name is expected and a
/// qualified name is permissible.
CCC_PotentiallyQualifiedName,
+
/// \brief Code completion occurred where an macro is being defined.
CCC_MacroName,
+
/// \brief Code completion occurred where a macro name is expected
/// (without any arguments, in the case of a function-like macro).
CCC_MacroNameUse,
+
/// \brief Code completion occurred within a preprocessor expression.
CCC_PreprocessorExpression,
+
/// \brief Code completion occurred where a preprocessor directive is
/// expected.
CCC_PreprocessorDirective,
+
/// \brief Code completion occurred in a context where natural language is
/// expected, e.g., a comment or string literal.
///
/// This context usually implies that no completions should be added,
/// unless they come from an appropriate natural-language dictionary.
CCC_NaturalLanguage,
+
/// \brief Code completion for a selector, as in an \@selector expression.
CCC_SelectorName,
+
/// \brief Code completion within a type-qualifier list.
CCC_TypeQualifiers,
+
/// \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
/// expected.
CCC_ObjCInstanceMessage,
+
/// \brief Code completion where an Objective-C class message is expected.
CCC_ObjCClassMessage,
+
/// \brief Code completion where the name of an Objective-C class is
/// expected.
CCC_ObjCInterfaceName,
+
/// \brief Code completion where an Objective-C category name is expected.
CCC_ObjCCategoryName,
+
/// \brief An unknown context, in which we are recovering from a parsing
/// error and don't know which completions we should give.
CCC_Recovery
};
- using VisitedContextSet = llvm::SmallPtrSet<DeclContext*, 8>;
+ using VisitedContextSet = llvm::SmallPtrSet<DeclContext *, 8>;
private:
Kind CCKind;
@@ -293,7 +350,7 @@ private:
public:
/// \brief Construct a new code-completion context of the given kind.
- CodeCompletionContext(Kind CCKind) : CCKind(CCKind), SelIdents(None) { }
+ CodeCompletionContext(Kind CCKind) : CCKind(CCKind), SelIdents(None) {}
/// \brief Construct a new code-completion context of the given kind.
CodeCompletionContext(Kind CCKind, QualType T,
@@ -334,7 +391,7 @@ public:
}
/// \brief Adds a visited context.
- void addVisitedContext(DeclContext* Ctx) {
+ void addVisitedContext(DeclContext *Ctx) {
VisitedContexts.insert(Ctx);
}
@@ -369,52 +426,71 @@ public:
/// match the code-completion string, typically a keyword or the name of a
/// declarator or macro.
CK_TypedText,
+
/// \brief A piece of text that should be placed in the buffer, e.g.,
/// parentheses or a comma in a function call.
CK_Text,
+
/// \brief A code completion string that is entirely optional. For example,
/// an optional code completion string that describes the default arguments
/// in a function call.
CK_Optional,
+
/// \brief A string that acts as a placeholder for, e.g., a function
/// call argument.
CK_Placeholder,
+
/// \brief A piece of text that describes something about the result but
/// should not be inserted into the buffer.
CK_Informative,
/// \brief A piece of text that describes the type of an entity or, for
/// functions and methods, the return type.
CK_ResultType,
+
/// \brief A piece of text that describes the parameter that corresponds
/// to the code-completion location within a function call, message send,
/// macro invocation, etc.
CK_CurrentParameter,
+
/// \brief A left parenthesis ('(').
CK_LeftParen,
+
/// \brief A right parenthesis (')').
CK_RightParen,
+
/// \brief A left bracket ('[').
CK_LeftBracket,
+
/// \brief A right bracket (']').
CK_RightBracket,
+
/// \brief A left brace ('{').
CK_LeftBrace,
+
/// \brief A right brace ('}').
CK_RightBrace,
+
/// \brief A left angle bracket ('<').
CK_LeftAngle,
+
/// \brief A right angle bracket ('>').
CK_RightAngle,
+
/// \brief A comma separator (',').
CK_Comma,
+
/// \brief A colon (':').
CK_Colon,
+
/// \brief A semicolon (';').
CK_SemiColon,
+
/// \brief An '=' sign.
CK_Equal,
+
/// \brief Horizontal whitespace (' ').
CK_HorizontalSpace,
+
/// \brief Vertical whitespace ('\\n' or '\\r\\n', depending on the
/// platform).
CK_VerticalSpace
@@ -424,7 +500,7 @@ public:
struct Chunk {
/// \brief The kind of data stored in this piece of the code completion
/// string.
- ChunkKind Kind;
+ ChunkKind Kind = CK_Text;
union {
/// \brief The text string associated with a CK_Text, CK_Placeholder,
@@ -439,7 +515,7 @@ public:
CodeCompletionString *Optional;
};
- Chunk() : Kind(CK_Text), Text(nullptr) { }
+ Chunk() : Text(nullptr) {}
explicit Chunk(ChunkKind Kind, const char *Text = "");
@@ -463,6 +539,9 @@ public:
};
private:
+ friend class CodeCompletionBuilder;
+ friend class CodeCompletionResult;
+
/// \brief The number of chunks stored in this string.
unsigned NumChunks : 16;
@@ -482,9 +561,6 @@ private:
/// entity being completed by this result.
const char *BriefComment;
- CodeCompletionString(const CodeCompletionString &) = delete;
- void operator=(const CodeCompletionString &) = delete;
-
CodeCompletionString(const Chunk *Chunks, unsigned NumChunks,
unsigned Priority, CXAvailabilityKind Availability,
const char **Annotations, unsigned NumAnnotations,
@@ -492,11 +568,12 @@ private:
const char *BriefComment);
~CodeCompletionString() = default;
- friend class CodeCompletionBuilder;
- friend class CodeCompletionResult;
-
public:
- typedef const Chunk *iterator;
+ CodeCompletionString(const CodeCompletionString &) = delete;
+ CodeCompletionString &operator=(const CodeCompletionString &) = delete;
+
+ using iterator = const Chunk *;
+
iterator begin() const { return reinterpret_cast<const Chunk *>(this + 1); }
iterator end() const { return begin() + NumChunks; }
bool empty() const { return NumChunks == 0; }
@@ -558,6 +635,7 @@ public:
std::shared_ptr<GlobalCodeCompletionAllocator> getAllocatorRef() const {
return AllocatorRef;
}
+
CodeCompletionAllocator &getAllocator() const {
assert(AllocatorRef);
return *AllocatorRef;
@@ -566,28 +644,30 @@ public:
StringRef getParentName(const DeclContext *DC);
};
-} // end namespace clang
+} // namespace clang
namespace llvm {
- template <> struct isPodLike<clang::CodeCompletionString::Chunk> {
- static const bool value = true;
- };
-}
+
+template <> struct isPodLike<clang::CodeCompletionString::Chunk> {
+ static const bool value = true;
+};
+
+} // namespace llvm
namespace clang {
/// \brief A builder class used to construct new code-completion strings.
class CodeCompletionBuilder {
public:
- typedef CodeCompletionString::Chunk Chunk;
+ using Chunk = CodeCompletionString::Chunk;
private:
CodeCompletionAllocator &Allocator;
CodeCompletionTUInfo &CCTUInfo;
- unsigned Priority;
- CXAvailabilityKind Availability;
+ unsigned Priority = 0;
+ CXAvailabilityKind Availability = CXAvailability_Available;
StringRef ParentName;
- const char *BriefComment;
+ const char *BriefComment = nullptr;
/// \brief The chunks stored in this string.
SmallVector<Chunk, 4> Chunks;
@@ -597,16 +677,13 @@ private:
public:
CodeCompletionBuilder(CodeCompletionAllocator &Allocator,
CodeCompletionTUInfo &CCTUInfo)
- : Allocator(Allocator), CCTUInfo(CCTUInfo),
- Priority(0), Availability(CXAvailability_Available),
- BriefComment(nullptr) { }
+ : Allocator(Allocator), CCTUInfo(CCTUInfo) {}
CodeCompletionBuilder(CodeCompletionAllocator &Allocator,
CodeCompletionTUInfo &CCTUInfo,
unsigned Priority, CXAvailabilityKind Availability)
- : Allocator(Allocator), CCTUInfo(CCTUInfo),
- Priority(Priority), Availability(Availability),
- BriefComment(nullptr) { }
+ : Allocator(Allocator), CCTUInfo(CCTUInfo), Priority(Priority),
+ Availability(Availability) {}
/// \brief Retrieve the allocator into which the code completion
/// strings should be allocated.
@@ -659,15 +736,22 @@ class CodeCompletionResult {
public:
/// \brief Describes the kind of result generated.
enum ResultKind {
- RK_Declaration = 0, ///< Refers to a declaration
- RK_Keyword, ///< Refers to a keyword or symbol.
- RK_Macro, ///< Refers to a macro
- RK_Pattern ///< Refers to a precomputed pattern.
+ /// Refers to a declaration.
+ RK_Declaration = 0,
+
+ /// Refers to a keyword or symbol.
+ RK_Keyword,
+
+ /// Refers to a macro.
+ RK_Macro,
+
+ /// Refers to a precomputed pattern.
+ RK_Pattern
};
/// \brief When Kind == RK_Declaration or RK_Pattern, the declaration we are
/// referring to. In the latter case, the declaration might be NULL.
- const NamedDecl *Declaration;
+ const NamedDecl *Declaration = nullptr;
union {
/// \brief When Kind == RK_Keyword, the string representing the keyword
@@ -687,7 +771,7 @@ public:
/// \brief Specifies which parameter (of a function, Objective-C method,
/// macro, etc.) we should start with when formatting the result.
- unsigned StartParameter;
+ unsigned StartParameter = 0;
/// \brief The kind of result stored here.
ResultKind Kind;
@@ -696,7 +780,7 @@ public:
CXCursorKind CursorKind;
/// \brief The availability of this result.
- CXAvailabilityKind Availability;
+ CXAvailabilityKind Availability = CXAvailability_Available;
/// \brief Whether this result is hidden by another name.
bool Hidden : 1;
@@ -719,7 +803,7 @@ public:
/// \brief If the result should have a nested-name-specifier, this is it.
/// When \c QualifierIsInformative, the nested-name-specifier is
/// informative rather than required.
- NestedNameSpecifier *Qualifier;
+ NestedNameSpecifier *Qualifier = nullptr;
/// \brief Build a result that refers to a declaration.
CodeCompletionResult(const NamedDecl *Declaration,
@@ -727,33 +811,27 @@ public:
NestedNameSpecifier *Qualifier = nullptr,
bool QualifierIsInformative = false,
bool Accessible = true)
- : Declaration(Declaration), Priority(Priority),
- StartParameter(0), Kind(RK_Declaration),
- Availability(CXAvailability_Available), Hidden(false),
- QualifierIsInformative(QualifierIsInformative),
- StartsNestedNameSpecifier(false), AllParametersAreInformative(false),
- DeclaringEntity(false), Qualifier(Qualifier) {
+ : Declaration(Declaration), Priority(Priority), Kind(RK_Declaration),
+ Hidden(false), QualifierIsInformative(QualifierIsInformative),
+ StartsNestedNameSpecifier(false), AllParametersAreInformative(false),
+ DeclaringEntity(false), Qualifier(Qualifier) {
computeCursorKindAndAvailability(Accessible);
}
/// \brief Build a result that refers to a keyword or symbol.
CodeCompletionResult(const char *Keyword, unsigned Priority = CCP_Keyword)
- : Declaration(nullptr), Keyword(Keyword), Priority(Priority),
- StartParameter(0), Kind(RK_Keyword), CursorKind(CXCursor_NotImplemented),
- Availability(CXAvailability_Available), Hidden(false),
- QualifierIsInformative(0), StartsNestedNameSpecifier(false),
- AllParametersAreInformative(false), DeclaringEntity(false),
- Qualifier(nullptr) {}
+ : Keyword(Keyword), Priority(Priority), Kind(RK_Keyword),
+ CursorKind(CXCursor_NotImplemented), Hidden(false),
+ QualifierIsInformative(false), StartsNestedNameSpecifier(false),
+ AllParametersAreInformative(false), DeclaringEntity(false) {}
/// \brief Build a result that refers to a macro.
CodeCompletionResult(const IdentifierInfo *Macro,
unsigned Priority = CCP_Macro)
- : Declaration(nullptr), Macro(Macro), Priority(Priority), StartParameter(0),
- Kind(RK_Macro), CursorKind(CXCursor_MacroDefinition),
- Availability(CXAvailability_Available), Hidden(false),
- QualifierIsInformative(0), StartsNestedNameSpecifier(false),
- AllParametersAreInformative(false), DeclaringEntity(false),
- Qualifier(nullptr) {}
+ : Macro(Macro), Priority(Priority), Kind(RK_Macro),
+ CursorKind(CXCursor_MacroDefinition), Hidden(false),
+ QualifierIsInformative(false), StartsNestedNameSpecifier(false),
+ AllParametersAreInformative(false), DeclaringEntity(false) {}
/// \brief Build a result that refers to a pattern.
CodeCompletionResult(CodeCompletionString *Pattern,
@@ -761,23 +839,19 @@ public:
CXCursorKind CursorKind = CXCursor_NotImplemented,
CXAvailabilityKind Availability = CXAvailability_Available,
const NamedDecl *D = nullptr)
- : Declaration(D), Pattern(Pattern), Priority(Priority), StartParameter(0),
- Kind(RK_Pattern), CursorKind(CursorKind), Availability(Availability),
- Hidden(false), QualifierIsInformative(0),
- StartsNestedNameSpecifier(false), AllParametersAreInformative(false),
- DeclaringEntity(false), Qualifier(nullptr)
- {
- }
+ : Declaration(D), Pattern(Pattern), Priority(Priority), Kind(RK_Pattern),
+ CursorKind(CursorKind), Availability(Availability), Hidden(false),
+ QualifierIsInformative(false), StartsNestedNameSpecifier(false),
+ AllParametersAreInformative(false), DeclaringEntity(false) {}
/// \brief Build a result that refers to a pattern with an associated
/// declaration.
CodeCompletionResult(CodeCompletionString *Pattern, const NamedDecl *D,
unsigned Priority)
- : Declaration(D), Pattern(Pattern), Priority(Priority), StartParameter(0),
- Kind(RK_Pattern), Availability(CXAvailability_Available), Hidden(false),
- QualifierIsInformative(false), StartsNestedNameSpecifier(false),
- AllParametersAreInformative(false), DeclaringEntity(false),
- Qualifier(nullptr) {
+ : Declaration(D), Pattern(Pattern), Priority(Priority), Kind(RK_Pattern),
+ Hidden(false), QualifierIsInformative(false),
+ StartsNestedNameSpecifier(false), AllParametersAreInformative(false),
+ DeclaringEntity(false) {
computeCursorKindAndAvailability();
}
@@ -839,7 +913,6 @@ inline bool operator>=(const CodeComplet
return !(X < Y);
}
-
raw_ostream &operator<<(raw_ostream &OS,
const CodeCompletionString &CCS);
@@ -860,8 +933,10 @@ public:
enum CandidateKind {
/// \brief The candidate is a function declaration.
CK_Function,
+
/// \brief The candidate is a function template.
CK_FunctionTemplate,
+
/// \brief The "candidate" is actually a variable, expression, or block
/// for which we only have a function prototype.
CK_FunctionType
@@ -887,13 +962,13 @@ public:
public:
OverloadCandidate(FunctionDecl *Function)
- : Kind(CK_Function), Function(Function) { }
+ : Kind(CK_Function), Function(Function) {}
OverloadCandidate(FunctionTemplateDecl *FunctionTemplateDecl)
- : Kind(CK_FunctionTemplate), FunctionTemplate(FunctionTemplateDecl) { }
+ : Kind(CK_FunctionTemplate), FunctionTemplate(FunctionTemplateDecl) {}
OverloadCandidate(const FunctionType *Type)
- : Kind(CK_FunctionType), Type(Type) { }
+ : Kind(CK_FunctionType), Type(Type) {}
/// \brief Determine the kind of overload candidate.
CandidateKind getKind() const { return Kind; }
@@ -923,8 +998,7 @@ public:
CodeCompleteConsumer(const CodeCompleteOptions &CodeCompleteOpts,
bool OutputIsBinary)
- : CodeCompleteOpts(CodeCompleteOpts), OutputIsBinary(OutputIsBinary)
- { }
+ : CodeCompleteOpts(CodeCompleteOpts), OutputIsBinary(OutputIsBinary) {}
/// \brief Whether the code-completion consumer wants to see macros.
bool includeMacros() const {
@@ -977,7 +1051,7 @@ public:
virtual void ProcessCodeCompleteResults(Sema &S,
CodeCompletionContext Context,
CodeCompletionResult *Results,
- unsigned NumResults) { }
+ unsigned NumResults) {}
/// \param S the semantic-analyzer object for which code-completion is being
/// done.
@@ -989,7 +1063,7 @@ public:
/// \param NumCandidates the number of overload candidates
virtual void ProcessOverloadCandidates(Sema &S, unsigned CurrentArg,
OverloadCandidate *Candidates,
- unsigned NumCandidates) { }
+ unsigned NumCandidates) {}
//@}
/// \brief Retrieve the allocator that will be used to allocate
@@ -1033,6 +1107,6 @@ public:
CodeCompletionTUInfo &getCodeCompletionTUInfo() override { return CCTUInfo; }
};
-} // end namespace clang
+} // namespace clang
#endif // LLVM_CLANG_SEMA_CODECOMPLETECONSUMER_H
Modified: cfe/trunk/include/clang/Sema/Ownership.h
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/include/clang/Sema/Ownership.h?rev=325544&r1=325543&r2=325544&view=diff
==============================================================================
--- cfe/trunk/include/clang/Sema/Ownership.h (original)
+++ cfe/trunk/include/clang/Sema/Ownership.h Mon Feb 19 18:16:28 2018
@@ -1,4 +1,4 @@
-//===--- Ownership.h - Parser ownership helpers -----------------*- C++ -*-===//
+//===- Ownership.h - Parser ownership helpers -------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
@@ -17,21 +17,27 @@
#include "clang/AST/Expr.h"
#include "clang/Basic/LLVM.h"
#include "llvm/ADT/ArrayRef.h"
+#include "llvm/Support/PointerLikeTypeTraits.h"
+#include "llvm/Support/type_traits.h"
+#include <cassert>
+#include <cstddef>
+#include <cstdint>
//===----------------------------------------------------------------------===//
// OpaquePtr
//===----------------------------------------------------------------------===//
namespace clang {
- class CXXCtorInitializer;
- class CXXBaseSpecifier;
- class Decl;
- class Expr;
- class ParsedTemplateArgument;
- class QualType;
- class Stmt;
- class TemplateName;
- class TemplateParameterList;
+
+class CXXBaseSpecifier;
+class CXXCtorInitializer;
+class Decl;
+class Expr;
+class ParsedTemplateArgument;
+class QualType;
+class Stmt;
+class TemplateName;
+class TemplateParameterList;
/// \brief Wrapper for void* pointer.
/// \tparam PtrTy Either a pointer type like 'T*' or a type that behaves like
@@ -44,9 +50,10 @@ namespace clang {
template <class PtrTy>
class OpaquePtr {
void *Ptr = nullptr;
+
explicit OpaquePtr(void *Ptr) : Ptr(Ptr) {}
- typedef llvm::PointerLikeTypeTraits<PtrTy> Traits;
+ using Traits = llvm::PointerLikeTypeTraits<PtrTy>;
public:
OpaquePtr(std::nullptr_t = nullptr) {}
@@ -103,26 +110,32 @@ namespace clang {
return *this;
}
};
-}
+
+} // namespace clang
namespace llvm {
+
template <class T>
- struct PointerLikeTypeTraits<clang::OpaquePtr<T> > {
+ struct PointerLikeTypeTraits<clang::OpaquePtr<T>> {
+ enum { NumLowBitsAvailable = 0 };
+
static inline void *getAsVoidPointer(clang::OpaquePtr<T> P) {
// FIXME: Doesn't work? return P.getAs< void >();
return P.getAsOpaquePtr();
}
+
static inline clang::OpaquePtr<T> getFromVoidPointer(void *P) {
return clang::OpaquePtr<T>::getFromOpaquePtr(P);
}
- enum { NumLowBitsAvailable = 0 };
};
template <class T>
- struct isPodLike<clang::OpaquePtr<T> > { static const bool value = true; };
-}
+ struct isPodLike<clang::OpaquePtr<T>> { static const bool value = true; };
+
+} // namespace llvm
namespace clang {
+
// Basic
class DiagnosticBuilder;
@@ -146,8 +159,7 @@ namespace clang {
bool Invalid;
public:
- ActionResult(bool Invalid = false)
- : Val(PtrTy()), Invalid(Invalid) {}
+ ActionResult(bool Invalid = false) : Val(PtrTy()), Invalid(Invalid) {}
ActionResult(PtrTy val) : Val(val), Invalid(false) {}
ActionResult(const DiagnosticBuilder &) : Val(PtrTy()), Invalid(true) {}
@@ -178,17 +190,20 @@ namespace clang {
// A pointer whose low bit is 1 if this result is invalid, 0
// otherwise.
uintptr_t PtrWithInvalid;
- typedef llvm::PointerLikeTypeTraits<PtrTy> PtrTraits;
+
+ using PtrTraits = llvm::PointerLikeTypeTraits<PtrTy>;
+
public:
ActionResult(bool Invalid = false)
- : PtrWithInvalid(static_cast<uintptr_t>(Invalid)) { }
+ : PtrWithInvalid(static_cast<uintptr_t>(Invalid)) {}
ActionResult(PtrTy V) {
void *VP = PtrTraits::getAsVoidPointer(V);
PtrWithInvalid = reinterpret_cast<uintptr_t>(VP);
assert((PtrWithInvalid & 0x01) == 0 && "Badly aligned pointer");
}
- ActionResult(const DiagnosticBuilder &) : PtrWithInvalid(0x01) { }
+
+ ActionResult(const DiagnosticBuilder &) : PtrWithInvalid(0x01) {}
// These two overloads prevent void* -> bool conversions.
ActionResult(const void *) = delete;
@@ -202,6 +217,7 @@ namespace clang {
void *VP = reinterpret_cast<void *>(PtrWithInvalid & ~0x01);
return PtrTraits::getFromVoidPointer(VP);
}
+
template <typename T> T *getAs() { return static_cast<T*>(get()); }
void set(PtrTy V) {
@@ -229,8 +245,8 @@ namespace clang {
/// An opaque type for threading parsed type information through the
/// parser.
- typedef OpaquePtr<QualType> ParsedType;
- typedef UnionOpaquePtr<QualType> UnionParsedType;
+ using ParsedType = OpaquePtr<QualType>;
+ using UnionParsedType = UnionOpaquePtr<QualType>;
// We can re-use the low bit of expression, statement, base, and
// member-initializer pointers for the "invalid" flag of
@@ -248,21 +264,21 @@ namespace clang {
static const bool value = true;
};
- typedef ActionResult<Expr*> ExprResult;
- typedef ActionResult<Stmt*> StmtResult;
- typedef ActionResult<ParsedType> TypeResult;
- typedef ActionResult<CXXBaseSpecifier*> BaseResult;
- typedef ActionResult<CXXCtorInitializer*> MemInitResult;
-
- typedef ActionResult<Decl*> DeclResult;
- typedef OpaquePtr<TemplateName> ParsedTemplateTy;
- typedef UnionOpaquePtr<TemplateName> UnionParsedTemplateTy;
-
- typedef MutableArrayRef<Expr*> MultiExprArg;
- typedef MutableArrayRef<Stmt*> MultiStmtArg;
- typedef MutableArrayRef<ParsedTemplateArgument> ASTTemplateArgsPtr;
- typedef MutableArrayRef<ParsedType> MultiTypeArg;
- typedef MutableArrayRef<TemplateParameterList*> MultiTemplateParamsArg;
+ using ExprResult = ActionResult<Expr *>;
+ using StmtResult = ActionResult<Stmt *>;
+ using TypeResult = ActionResult<ParsedType>;
+ using BaseResult = ActionResult<CXXBaseSpecifier *>;
+ using MemInitResult = ActionResult<CXXCtorInitializer *>;
+
+ using DeclResult = ActionResult<Decl *>;
+ using ParsedTemplateTy = OpaquePtr<TemplateName>;
+ using UnionParsedTemplateTy = UnionOpaquePtr<TemplateName>;
+
+ using MultiExprArg = MutableArrayRef<Expr *>;
+ using MultiStmtArg = MutableArrayRef<Stmt *>;
+ using ASTTemplateArgsPtr = MutableArrayRef<ParsedTemplateArgument>;
+ using MultiTypeArg = MutableArrayRef<ParsedType>;
+ using MultiTemplateParamsArg = MutableArrayRef<TemplateParameterList *>;
inline ExprResult ExprError() { return ExprResult(true); }
inline StmtResult StmtError() { return StmtResult(true); }
@@ -282,6 +298,7 @@ namespace clang {
assert(!R.isInvalid() && "operation was asserted to never fail!");
return R.get();
}
-}
-#endif
+} // namespace clang
+
+#endif // LLVM_CLANG_SEMA_OWNERSHIP_H
Modified: cfe/trunk/lib/Sema/AttributeList.cpp
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/Sema/AttributeList.cpp?rev=325544&r1=325543&r2=325544&view=diff
==============================================================================
--- cfe/trunk/lib/Sema/AttributeList.cpp (original)
+++ cfe/trunk/lib/Sema/AttributeList.cpp Mon Feb 19 18:16:28 2018
@@ -1,4 +1,4 @@
-//===--- AttributeList.cpp --------------------------------------*- C++ -*-===//
+//===- AttributeList.cpp --------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
@@ -13,14 +13,17 @@
#include "clang/Sema/AttributeList.h"
#include "clang/AST/ASTContext.h"
-#include "clang/AST/DeclCXX.h"
-#include "clang/AST/DeclTemplate.h"
-#include "clang/AST/Expr.h"
#include "clang/Basic/AttrSubjectMatchRules.h"
#include "clang/Basic/IdentifierTable.h"
#include "clang/Basic/TargetInfo.h"
#include "clang/Sema/SemaInternal.h"
#include "llvm/ADT/SmallString.h"
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/ADT/StringRef.h"
+#include <cassert>
+#include <cstddef>
+#include <utility>
+
using namespace clang;
IdentifierLoc *IdentifierLoc::create(ASTContext &Ctx, SourceLocation Loc,
@@ -44,7 +47,7 @@ AttributeFactory::AttributeFactory() {
// Go ahead and configure all the inline capacity. This is just a memset.
FreeLists.resize(InlineFreeListsCapacity);
}
-AttributeFactory::~AttributeFactory() {}
+AttributeFactory::~AttributeFactory() = default;
static size_t getFreeListIndexForSize(size_t size) {
assert(size >= sizeof(AttributeList));
@@ -175,8 +178,10 @@ struct ParsedAttrInfo {
};
namespace {
- #include "clang/Sema/AttrParsedAttrImpl.inc"
-}
+
+#include "clang/Sema/AttrParsedAttrImpl.inc"
+
+} // namespace
static const ParsedAttrInfo &getInfo(const AttributeList &A) {
return AttrInfoMap[A.getKind()];
Modified: cfe/trunk/lib/Sema/CodeCompleteConsumer.cpp
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/Sema/CodeCompleteConsumer.cpp?rev=325544&r1=325543&r2=325544&view=diff
==============================================================================
--- cfe/trunk/lib/Sema/CodeCompleteConsumer.cpp (original)
+++ cfe/trunk/lib/Sema/CodeCompleteConsumer.cpp Mon Feb 19 18:16:28 2018
@@ -1,4 +1,4 @@
-//===--- CodeCompleteConsumer.cpp - Code Completion Interface ---*- C++ -*-===//
+//===- CodeCompleteConsumer.cpp - Code Completion Interface ---------------===//
//
// The LLVM Compiler Infrastructure
//
@@ -10,21 +10,30 @@
// This file implements the CodeCompleteConsumer class.
//
//===----------------------------------------------------------------------===//
+
#include "clang/Sema/CodeCompleteConsumer.h"
#include "clang-c/Index.h"
-#include "clang/AST/DeclCXX.h"
+#include "clang/AST/Decl.h"
+#include "clang/AST/DeclBase.h"
#include "clang/AST/DeclObjC.h"
#include "clang/AST/DeclTemplate.h"
-#include "clang/Sema/Scope.h"
+#include "clang/AST/DeclarationName.h"
+#include "clang/AST/Type.h"
+#include "clang/Basic/IdentifierTable.h"
#include "clang/Sema/Sema.h"
#include "clang/Lex/Preprocessor.h"
-#include "llvm/ADT/STLExtras.h"
#include "llvm/ADT/SmallString.h"
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/ADT/StringRef.h"
#include "llvm/ADT/Twine.h"
+#include "llvm/Support/Casting.h"
+#include "llvm/Support/Compiler.h"
+#include "llvm/Support/ErrorHandling.h"
#include "llvm/Support/raw_ostream.h"
#include <algorithm>
-#include <cstring>
-#include <functional>
+#include <cassert>
+#include <cstdint>
+#include <string>
using namespace clang;
@@ -154,9 +163,9 @@ StringRef clang::getCompletionKindString
//===----------------------------------------------------------------------===//
// Code completion string implementation
//===----------------------------------------------------------------------===//
+
CodeCompletionString::Chunk::Chunk(ChunkKind Kind, const char *Text)
- : Kind(Kind), Text("")
-{
+ : Kind(Kind), Text("") {
switch (Kind) {
case CK_TypedText:
case CK_Text:
@@ -270,10 +279,9 @@ CodeCompletionString::CodeCompletionStri
unsigned NumAnnotations,
StringRef ParentName,
const char *BriefComment)
- : NumChunks(NumChunks), NumAnnotations(NumAnnotations),
- Priority(Priority), Availability(Availability),
- ParentName(ParentName), BriefComment(BriefComment)
-{
+ : NumChunks(NumChunks), NumAnnotations(NumAnnotations),
+ Priority(Priority), Availability(Availability),
+ ParentName(ParentName), BriefComment(BriefComment) {
assert(NumChunks <= 0xffff);
assert(NumAnnotations <= 0xffff);
@@ -297,7 +305,6 @@ const char *CodeCompletionString::getAnn
return nullptr;
}
-
std::string CodeCompletionString::getAsString() const {
std::string Result;
llvm::raw_string_ostream OS(Result);
@@ -342,7 +349,7 @@ const char *CodeCompletionAllocator::Cop
StringRef CodeCompletionTUInfo::getParentName(const DeclContext *DC) {
const NamedDecl *ND = dyn_cast<NamedDecl>(DC);
if (!ND)
- return StringRef();
+ return {};
// Check whether we've already cached the parent name.
StringRef &CachedParentName = ParentNames[DC];
@@ -352,7 +359,7 @@ StringRef CodeCompletionTUInfo::getParen
// If we already processed this DeclContext and assigned empty to it, the
// data pointer will be non-null.
if (CachedParentName.data() != nullptr)
- return StringRef();
+ return {};
// Find the interesting names.
SmallVector<const DeclContext *, 2> Contexts;
@@ -386,7 +393,7 @@ StringRef CodeCompletionTUInfo::getParen
// Assign an empty StringRef but with non-null data to distinguish
// between empty because we didn't process the DeclContext yet.
CachedParentName = StringRef((const char *)(uintptr_t)~0U, 0);
- return StringRef();
+ return {};
}
OS << Interface->getName() << '(' << Cat->getName() << ')';
@@ -450,9 +457,8 @@ void CodeCompletionBuilder::AddChunk(Cod
}
void CodeCompletionBuilder::addParentContext(const DeclContext *DC) {
- if (DC->isTranslationUnit()) {
+ if (DC->isTranslationUnit())
return;
- }
if (DC->isFunctionOrMethod())
return;
@@ -502,25 +508,21 @@ CodeCompleteConsumer::OverloadCandidate:
// Code completion consumer implementation
//===----------------------------------------------------------------------===//
-CodeCompleteConsumer::~CodeCompleteConsumer() { }
+CodeCompleteConsumer::~CodeCompleteConsumer() = default;
bool PrintingCodeCompleteConsumer::isResultFilteredOut(StringRef Filter,
CodeCompletionResult Result) {
switch (Result.Kind) {
- case CodeCompletionResult::RK_Declaration: {
+ case CodeCompletionResult::RK_Declaration:
return !(Result.Declaration->getIdentifier() &&
Result.Declaration->getIdentifier()->getName().startswith(Filter));
- }
- case CodeCompletionResult::RK_Keyword: {
+ case CodeCompletionResult::RK_Keyword:
return !StringRef(Result.Keyword).startswith(Filter);
- }
- case CodeCompletionResult::RK_Macro: {
+ case CodeCompletionResult::RK_Macro:
return !Result.Macro->getName().startswith(Filter);
- }
- case CodeCompletionResult::RK_Pattern: {
+ case CodeCompletionResult::RK_Pattern:
return !StringRef(Result.Pattern->getAsString()).startswith(Filter);
}
- }
llvm_unreachable("Unknown code completion result Kind.");
}
@@ -552,7 +554,6 @@ PrintingCodeCompleteConsumer::ProcessCod
if (const char *BriefComment = CCS->getBriefComment())
OS << " : " << BriefComment;
}
-
OS << '\n';
break;
@@ -560,7 +561,7 @@ PrintingCodeCompleteConsumer::ProcessCod
OS << Results[I].Keyword << '\n';
break;
- case CodeCompletionResult::RK_Macro: {
+ case CodeCompletionResult::RK_Macro:
OS << Results[I].Macro->getName();
if (CodeCompletionString *CCS
= Results[I].CreateCodeCompletionString(SemaRef, Context,
@@ -571,14 +572,12 @@ PrintingCodeCompleteConsumer::ProcessCod
}
OS << '\n';
break;
- }
- case CodeCompletionResult::RK_Pattern: {
+ case CodeCompletionResult::RK_Pattern:
OS << "Pattern : "
<< Results[I].Pattern->getAsString() << '\n';
break;
}
- }
}
}
More information about the cfe-commits
mailing list