forked from OSchip/llvm-project
[Sema] Fix some Clang-tidy modernize and Include What You Use warnings; other minor fixes (NFC).
llvm-svn: 325544
This commit is contained in:
Eugene Zelenko
parent
bab2d3e2b9
commit
711964ddc1
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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 MacroName,
|
|||
/// 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 CodeCompletionResult &X,
|
|||
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
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
using ExprResult = ActionResult<Expr *>;
|
||||
using StmtResult = ActionResult<Stmt *>;
|
||||
using TypeResult = ActionResult<ParsedType>;
|
||||
using BaseResult = ActionResult<CXXBaseSpecifier *>;
|
||||
using MemInitResult = ActionResult<CXXCtorInitializer *>;
|
||||
|
||||
typedef ActionResult<Decl*> DeclResult;
|
||||
typedef OpaquePtr<TemplateName> ParsedTemplateTy;
|
||||
typedef UnionOpaquePtr<TemplateName> UnionParsedTemplateTy;
|
||||
using DeclResult = ActionResult<Decl *>;
|
||||
using ParsedTemplateTy = OpaquePtr<TemplateName>;
|
||||
using UnionParsedTemplateTy = UnionOpaquePtr<TemplateName>;
|
||||
|
||||
typedef MutableArrayRef<Expr*> MultiExprArg;
|
||||
typedef MutableArrayRef<Stmt*> MultiStmtArg;
|
||||
typedef MutableArrayRef<ParsedTemplateArgument> ASTTemplateArgsPtr;
|
||||
typedef MutableArrayRef<ParsedType> MultiTypeArg;
|
||||
typedef MutableArrayRef<TemplateParameterList*> MultiTemplateParamsArg;
|
||||
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
|
||||
|
|
|
|||
|
|
@ -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()];
|
||||
|
|
|
|||
|
|
@ -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(CodeCompletionContext::Kind Kind) {
|
|||
//===----------------------------------------------------------------------===//
|
||||
// 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::CodeCompletionString(const Chunk *Chunks,
|
|||
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::getAnnotation(unsigned AnnotationNr) const {
|
|||
return nullptr;
|
||||
}
|
||||
|
||||
|
||||
std::string CodeCompletionString::getAsString() const {
|
||||
std::string Result;
|
||||
llvm::raw_string_ostream OS(Result);
|
||||
|
|
@ -342,7 +349,7 @@ const char *CodeCompletionAllocator::CopyString(const Twine &String) {
|
|||
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::getParentName(const DeclContext *DC) {
|
|||
// 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::getParentName(const DeclContext *DC) {
|
|||
// 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(CodeCompletionString::ChunkKind CK,
|
|||
}
|
||||
|
||||
void CodeCompletionBuilder::addParentContext(const DeclContext *DC) {
|
||||
if (DC->isTranslationUnit()) {
|
||||
if (DC->isTranslationUnit())
|
||||
return;
|
||||
}
|
||||
|
||||
if (DC->isFunctionOrMethod())
|
||||
return;
|
||||
|
|
@ -502,25 +508,21 @@ CodeCompleteConsumer::OverloadCandidate::getFunctionType() const {
|
|||
// 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::ProcessCodeCompleteResults(Sema &SemaRef,
|
|||
if (const char *BriefComment = CCS->getBriefComment())
|
||||
OS << " : " << BriefComment;
|
||||
}
|
||||
|
||||
OS << '\n';
|
||||
break;
|
||||
|
||||
|
|
@ -560,7 +561,7 @@ PrintingCodeCompleteConsumer::ProcessCodeCompleteResults(Sema &SemaRef,
|
|||
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::ProcessCodeCompleteResults(Sema &SemaRef,
|
|||
}
|
||||
OS << '\n';
|
||||
break;
|
||||
}
|
||||
|
||||
case CodeCompletionResult::RK_Pattern: {
|
||||
case CodeCompletionResult::RK_Pattern:
|
||||
OS << "Pattern : "
|
||||
<< Results[I].Pattern->getAsString() << '\n';
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
Loading…
Reference in New Issue