44#include "llvm/ADT/ArrayRef.h"
45#include "llvm/ADT/DenseSet.h"
46#include "llvm/ADT/SmallBitVector.h"
47#include "llvm/ADT/SmallPtrSet.h"
48#include "llvm/ADT/SmallString.h"
49#include "llvm/ADT/StringExtras.h"
50#include "llvm/ADT/StringSwitch.h"
51#include "llvm/ADT/Twine.h"
52#include "llvm/ADT/iterator_range.h"
53#include "llvm/Support/Casting.h"
54#include "llvm/Support/Path.h"
55#include "llvm/Support/raw_ostream.h"
74 typedef bool (ResultBuilder::*LookupFilter)(
const NamedDecl *)
const;
80 std::vector<Result> Results;
87 typedef std::pair<const NamedDecl *, unsigned> DeclIndexPair;
92 class ShadowMapEntry {
97 llvm::PointerUnion<const NamedDecl *, DeclIndexPairVector *> DeclOrVector;
101 unsigned SingleDeclIndex = 0;
104 ShadowMapEntry() =
default;
105 ShadowMapEntry(
const ShadowMapEntry &) =
delete;
106 ShadowMapEntry(ShadowMapEntry &&Move) { *
this = std::move(Move); }
107 ShadowMapEntry &operator=(
const ShadowMapEntry &) =
delete;
108 ShadowMapEntry &operator=(ShadowMapEntry &&Move) {
109 SingleDeclIndex =
Move.SingleDeclIndex;
110 DeclOrVector =
Move.DeclOrVector;
111 Move.DeclOrVector =
nullptr;
116 if (DeclOrVector.isNull()) {
119 SingleDeclIndex = Index;
124 DeclOrVector.dyn_cast<
const NamedDecl *>()) {
127 DeclIndexPairVector *Vec =
new DeclIndexPairVector;
128 Vec->push_back(DeclIndexPair(PrevND, SingleDeclIndex));
133 DeclOrVector.get<DeclIndexPairVector *>()->push_back(
134 DeclIndexPair(ND, Index));
138 if (DeclIndexPairVector *Vec =
139 DeclOrVector.dyn_cast<DeclIndexPairVector *>()) {
147 iterator begin()
const;
148 iterator end()
const;
154 typedef llvm::DenseMap<DeclarationName, ShadowMapEntry> ShadowMap;
171 bool AllowNestedNameSpecifiers;
182 std::list<ShadowMap> ShadowMaps;
196 bool HasObjectTypeQualifiers;
208 void AdjustResultPriorityForDecl(Result &R);
210 void MaybeAddConstructorResults(Result R);
216 LookupFilter Filter =
nullptr)
217 : SemaRef(SemaRef), Allocator(Allocator), CCTUInfo(CCTUInfo),
219 HasObjectTypeQualifiers(
false), CompletionContext(CompletionContext),
220 ObjCImplementation(nullptr) {
223 switch (CompletionContext.
getKind()) {
231 if (Method->isInstanceMethod())
233 ObjCImplementation = Interface->getImplementation();
242 unsigned getBasePriority(
const NamedDecl *D);
246 bool includeCodePatterns()
const {
252 void setFilter(LookupFilter Filter) { this->Filter =
Filter; }
254 Result *data() {
return Results.empty() ? nullptr : &Results.front(); }
255 unsigned size()
const {
return Results.size(); }
256 bool empty()
const {
return Results.empty(); }
271 ObjectTypeQualifiers = Quals;
273 HasObjectTypeQualifiers =
true;
281 void setPreferredSelector(
Selector Sel) { PreferredSelector = Sel; }
286 return CompletionContext;
290 void allowNestedNameSpecifiers(
bool Allow =
true) {
291 AllowNestedNameSpecifiers = Allow;
296 Sema &getSema()
const {
return SemaRef; }
310 bool isInterestingDecl(
const NamedDecl *ND,
311 bool &AsNestedNameSpecifier)
const;
319 bool CheckHiddenResult(Result &R,
DeclContext *CurContext,
329 void MaybeAddResult(Result R,
DeclContext *CurContext =
nullptr);
346 void AddResult(Result R);
349 void EnterNewScope();
368 bool IsOrdinaryName(
const NamedDecl *ND)
const;
369 bool IsOrdinaryNonTypeName(
const NamedDecl *ND)
const;
370 bool IsIntegralConstantValue(
const NamedDecl *ND)
const;
371 bool IsOrdinaryNonValueName(
const NamedDecl *ND)
const;
372 bool IsNestedNameSpecifier(
const NamedDecl *ND)
const;
374 bool IsClassOrStruct(
const NamedDecl *ND)
const;
376 bool IsNamespace(
const NamedDecl *ND)
const;
377 bool IsNamespaceOrAlias(
const NamedDecl *ND)
const;
379 bool IsMember(
const NamedDecl *ND)
const;
380 bool IsObjCIvar(
const NamedDecl *ND)
const;
381 bool IsObjCMessageReceiver(
const NamedDecl *ND)
const;
382 bool IsObjCMessageReceiverOrLambdaCapture(
const NamedDecl *ND)
const;
383 bool IsObjCCollection(
const NamedDecl *ND)
const;
384 bool IsImpossibleToSatisfy(
const NamedDecl *ND)
const;
394 ComputeType =
nullptr;
395 Type = BSI->ReturnType;
398 }
else if (
const auto *Function = dyn_cast<FunctionDecl>(S.
CurContext)) {
399 ComputeType =
nullptr;
400 Type = Function->getReturnType();
402 }
else if (
const auto *Method = dyn_cast<ObjCMethodDecl>(S.
CurContext)) {
403 ComputeType =
nullptr;
404 Type = Method->getReturnType();
412 auto *VD = llvm::dyn_cast_or_null<ValueDecl>(D);
413 ComputeType =
nullptr;
425 ComputeType =
nullptr;
434 this->ComputeType = ComputeType;
444 if (ExpectedLoc == LParLoc)
455 if (Op == tok::plus || Op == tok::plusequal || Op == tok::minusequal)
458 if (Op == tok::minus)
471 case tok::minusequal:
473 case tok::percentequal:
475 case tok::slashequal:
481 case tok::equalequal:
482 case tok::exclaimequal:
486 case tok::greaterequal:
490 case tok::greatergreater:
491 case tok::greatergreaterequal:
493 case tok::lesslessequal:
500 case tok::caretcaret:
507 case tok::caretequal:
515 case tok::periodstar:
543 case tok::minusminus:
553 assert(
false &&
"unhandled unary op");
562 ComputeType =
nullptr;
569 if (!Enabled || !
Base)
572 if (ExpectedLoc !=
Base->getBeginLoc())
583 ComputeType =
nullptr;
592 ComputeType =
nullptr;
601 ComputeType =
nullptr;
609 ComputeType =
nullptr;
615 llvm::PointerUnion<const NamedDecl *, const DeclIndexPair *> DeclOrIterator;
616 unsigned SingleDeclIndex;
636 : DeclOrIterator(SingleDecl), SingleDeclIndex(Index) {}
639 : DeclOrIterator(Iterator), SingleDeclIndex(0) {}
642 if (DeclOrIterator.is<
const NamedDecl *>()) {
648 const DeclIndexPair *I = DeclOrIterator.get<
const DeclIndexPair *>();
664 return *DeclOrIterator.get<
const DeclIndexPair *>();
670 return X.DeclOrIterator.getOpaqueValue() ==
671 Y.DeclOrIterator.getOpaqueValue() &&
672 X.SingleDeclIndex == Y.SingleDeclIndex;
681ResultBuilder::ShadowMapEntry::begin()
const {
682 if (DeclOrVector.isNull())
686 return iterator(ND, SingleDeclIndex);
688 return iterator(DeclOrVector.get<DeclIndexPairVector *>()->begin());
692ResultBuilder::ShadowMapEntry::end()
const {
693 if (DeclOrVector.is<
const NamedDecl *>() || DeclOrVector.isNull())
696 return iterator(DeclOrVector.get<DeclIndexPairVector *>()->end());
717 for (
const DeclContext *CommonAncestor = TargetContext;
718 CommonAncestor && !CommonAncestor->
Encloses(CurContext);
719 CommonAncestor = CommonAncestor->getLookupParent()) {
720 if (CommonAncestor->isTransparentContext() ||
721 CommonAncestor->isFunctionOrMethod())
724 TargetParents.push_back(CommonAncestor);
728 while (!TargetParents.empty()) {
731 if (
const auto *Namespace = dyn_cast<NamespaceDecl>(
Parent)) {
732 if (!Namespace->getIdentifier())
736 }
else if (
const auto *TD = dyn_cast<TagDecl>(
Parent))
763bool ResultBuilder::isInterestingDecl(
const NamedDecl *ND,
764 bool &AsNestedNameSpecifier)
const {
765 AsNestedNameSpecifier =
false;
780 if (isa<ClassTemplateSpecializationDecl>(ND) ||
781 isa<ClassTemplatePartialSpecializationDecl>(ND))
785 if (isa<UsingDecl>(ND))
791 if (Filter == &ResultBuilder::IsNestedNameSpecifier ||
792 (isa<NamespaceDecl>(ND) && Filter != &ResultBuilder::IsNamespace &&
793 Filter != &ResultBuilder::IsNamespaceOrAlias && Filter !=
nullptr))
794 AsNestedNameSpecifier =
true;
797 if (Filter && !(this->*Filter)(Named)) {
799 if (AllowNestedNameSpecifiers && SemaRef.
getLangOpts().CPlusPlus &&
800 IsNestedNameSpecifier(ND) &&
801 (Filter != &ResultBuilder::IsMember ||
802 (isa<CXXRecordDecl>(ND) &&
803 cast<CXXRecordDecl>(ND)->isInjectedClassName()))) {
804 AsNestedNameSpecifier =
true;
834 R.QualifierIsInformative =
false;
838 R.Declaration->getDeclContext());
845 switch (T->getTypeClass()) {
847 switch (cast<BuiltinType>(T)->
getKind()) {
848 case BuiltinType::Void:
851 case BuiltinType::NullPtr:
854 case BuiltinType::Overload:
855 case BuiltinType::Dependent:
858 case BuiltinType::ObjCId:
859 case BuiltinType::ObjCClass:
860 case BuiltinType::ObjCSel:
873 case Type::BlockPointer:
876 case Type::LValueReference:
877 case Type::RValueReference:
880 case Type::ConstantArray:
881 case Type::IncompleteArray:
882 case Type::VariableArray:
883 case Type::DependentSizedArray:
886 case Type::DependentSizedExtVector:
888 case Type::ExtVector:
891 case Type::FunctionProto:
892 case Type::FunctionNoProto:
901 case Type::ObjCObject:
902 case Type::ObjCInterface:
903 case Type::ObjCObjectPointer:
916 if (
const auto *
Type = dyn_cast<TypeDecl>(ND))
917 return C.getTypeDeclType(
Type);
918 if (
const auto *Iface = dyn_cast<ObjCInterfaceDecl>(ND))
919 return C.getObjCInterfaceType(Iface);
923 T = Function->getCallResultType();
924 else if (
const auto *Method = dyn_cast<ObjCMethodDecl>(ND))
925 T = Method->getSendResultType();
926 else if (
const auto *Enumerator = dyn_cast<EnumConstantDecl>(ND))
927 T =
C.getTypeDeclType(cast<EnumDecl>(Enumerator->getDeclContext()));
928 else if (
const auto *
Property = dyn_cast<ObjCPropertyDecl>(ND))
930 else if (
const auto *
Value = dyn_cast<ValueDecl>(ND))
946 if (
Pointer->getPointeeType()->isFunctionType()) {
955 T =
Block->getPointeeType();
960 T = Function->getReturnType();
970unsigned ResultBuilder::getBasePriority(
const NamedDecl *ND) {
978 if (
const auto *ImplicitParam = dyn_cast<ImplicitParamDecl>(ND))
979 if (ImplicitParam->getIdentifier() &&
980 ImplicitParam->getIdentifier()->isStr(
"_cmd"))
987 if (DC->
isRecord() || isa<ObjCContainerDecl>(DC)) {
989 if (isa<CXXDestructorDecl>(ND))
1001 if (isa<EnumConstantDecl>(ND))
1007 if ((isa<TypeDecl>(ND) || isa<ObjCInterfaceDecl>(ND)) &&
1009 CompletionContext.
getKind() ==
1011 CompletionContext.
getKind() ==
1018void ResultBuilder::AdjustResultPriorityForDecl(
Result &R) {
1021 if (!PreferredSelector.
isNull())
1022 if (
const auto *Method = dyn_cast<ObjCMethodDecl>(R.Declaration))
1023 if (PreferredSelector == Method->getSelector())
1028 if (!PreferredType.
isNull()) {
1038 !(PreferredType->isEnumeralType() && TC->isEnumeralType()))
1050 return Record->lookup(ConstructorName);
1053void ResultBuilder::MaybeAddConstructorResults(
Result R) {
1054 if (!SemaRef.
getLangOpts().CPlusPlus || !R.Declaration ||
1061 Record = ClassTemplate->getTemplatedDecl();
1062 else if ((Record = dyn_cast<CXXRecordDecl>(D))) {
1064 if (isa<ClassTemplateSpecializationDecl>(Record))
1076 R.Declaration = Ctor;
1078 Results.push_back(R);
1083 if (
const auto *Tmpl = dyn_cast<FunctionTemplateDecl>(ND))
1084 ND = Tmpl->getTemplatedDecl();
1085 return isa<CXXConstructorDecl>(ND);
1089 assert(!ShadowMaps.empty() &&
"Must enter into a results scope");
1091 if (R.Kind != Result::RK_Declaration) {
1093 Results.push_back(R);
1098 if (
const UsingShadowDecl *Using = dyn_cast<UsingShadowDecl>(R.Declaration)) {
1100 getBasePriority(
Using->getTargetDecl()),
1104 std::move(R.FixIts));
1106 MaybeAddResult(
Result, CurContext);
1113 bool AsNestedNameSpecifier =
false;
1114 if (!isInterestingDecl(R.Declaration, AsNestedNameSpecifier))
1121 ShadowMap &
SMap = ShadowMaps.back();
1122 ShadowMapEntry::iterator I, IEnd;
1123 ShadowMap::iterator NamePos =
SMap.find(R.Declaration->getDeclName());
1124 if (NamePos !=
SMap.end()) {
1125 I = NamePos->second.begin();
1126 IEnd = NamePos->second.end();
1129 for (; I != IEnd; ++I) {
1131 unsigned Index = I->second;
1134 Results[Index].Declaration = R.Declaration;
1144 std::list<ShadowMap>::iterator
SM, SMEnd = ShadowMaps.end();
1146 for (
SM = ShadowMaps.begin();
SM != SMEnd; ++
SM) {
1147 ShadowMapEntry::iterator I, IEnd;
1148 ShadowMap::iterator NamePos =
SM->find(R.Declaration->getDeclName());
1149 if (NamePos !=
SM->end()) {
1150 I = NamePos->second.begin();
1151 IEnd = NamePos->second.end();
1153 for (; I != IEnd; ++I) {
1155 if (I->first->hasTagIdentifierNamespace() &&
1163 I->first->getIdentifierNamespace() != IDNS)
1167 if (CheckHiddenResult(R, CurContext, I->first))
1175 if (!AllDeclsFound.insert(CanonDecl).second)
1180 if (AsNestedNameSpecifier) {
1181 R.StartsNestedNameSpecifier =
true;
1184 AdjustResultPriorityForDecl(R);
1187 if (R.QualifierIsInformative && !R.Qualifier &&
1188 !R.StartsNestedNameSpecifier) {
1189 const DeclContext *Ctx = R.Declaration->getDeclContext();
1190 if (
const NamespaceDecl *Namespace = dyn_cast<NamespaceDecl>(Ctx))
1193 else if (
const TagDecl *Tag = dyn_cast<TagDecl>(Ctx))
1195 SemaRef.
Context,
nullptr,
false,
1198 R.QualifierIsInformative =
false;
1203 SMap[R.Declaration->getDeclName()].Add(R.Declaration, Results.size());
1204 Results.push_back(R);
1206 if (!AsNestedNameSpecifier)
1207 MaybeAddConstructorResults(R);
1226 return OverloadCompare::BothViable;
1231 return OverloadCompare::BothViable;
1232 for (
unsigned I = 0, E = Candidate.
getNumParams(); I != E; ++I)
1233 if (Candidate.
parameters()[I]->getType().getCanonicalType() !=
1234 Incumbent.
parameters()[I]->getType().getCanonicalType())
1235 return OverloadCompare::BothViable;
1238 return OverloadCompare::BothViable;
1243 if (CandidateRef != IncumbentRef) {
1250 return CandidateRef ==
RQ_RValue ? OverloadCompare::Dominates
1251 : OverloadCompare::Dominated;
1259 if (CandidateSuperset == IncumbentSuperset)
1260 return OverloadCompare::BothViable;
1261 return IncumbentSuperset ? OverloadCompare::Dominates
1262 : OverloadCompare::Dominated;
1266 NamedDecl *Hiding,
bool InBaseClass =
false) {
1267 if (R.Kind != Result::RK_Declaration) {
1269 Results.push_back(R);
1274 if (
const auto *Using = dyn_cast<UsingShadowDecl>(R.Declaration)) {
1276 getBasePriority(
Using->getTargetDecl()),
1280 std::move(R.FixIts));
1282 AddResult(
Result, CurContext, Hiding);
1286 bool AsNestedNameSpecifier =
false;
1287 if (!isInterestingDecl(R.Declaration, AsNestedNameSpecifier))
1294 if (Hiding && CheckHiddenResult(R, CurContext, Hiding))
1298 if (!AllDeclsFound.insert(R.Declaration->getCanonicalDecl()).second)
1303 if (AsNestedNameSpecifier) {
1304 R.StartsNestedNameSpecifier =
true;
1306 }
else if (Filter == &ResultBuilder::IsMember && !R.Qualifier &&
1309 R.Declaration->getDeclContext()->getRedeclContext()))
1310 R.QualifierIsInformative =
true;
1313 if (R.QualifierIsInformative && !R.Qualifier &&
1314 !R.StartsNestedNameSpecifier) {
1315 const DeclContext *Ctx = R.Declaration->getDeclContext();
1316 if (
const auto *Namespace = dyn_cast<NamespaceDecl>(Ctx))
1319 else if (
const auto *Tag = dyn_cast<TagDecl>(Ctx))
1321 SemaRef.
Context,
nullptr,
false,
1324 R.QualifierIsInformative =
false;
1331 AdjustResultPriorityForDecl(R);
1333 if (HasObjectTypeQualifiers)
1334 if (
const auto *Method = dyn_cast<CXXMethodDecl>(R.Declaration))
1335 if (Method->isInstance()) {
1336 Qualifiers MethodQuals = Method->getMethodQualifiers();
1337 if (ObjectTypeQualifiers == MethodQuals)
1339 else if (ObjectTypeQualifiers - MethodQuals) {
1345 switch (Method->getRefQualifier()) {
1361 auto &OverloadSet = OverloadMap[std::make_pair(
1362 CurContext, Method->getDeclName().getAsOpaqueInteger())];
1363 for (
const DeclIndexPair Entry : OverloadSet) {
1364 Result &Incumbent = Results[Entry.second];
1366 *cast<CXXMethodDecl>(Incumbent.Declaration),
1367 ObjectTypeQualifiers, ObjectKind)) {
1368 case OverloadCompare::Dominates:
1372 Incumbent = std::move(R);
1374 case OverloadCompare::Dominated:
1377 case OverloadCompare::BothViable:
1381 OverloadSet.Add(Method, Results.size());
1388 const auto *Method = dyn_cast<CXXMethodDecl>(R.getDeclaration());
1389 if (Method && !Method->isStatic()) {
1393 const auto *CurrentClassScope = [&]() ->
const CXXRecordDecl * {
1396 const auto *CtxMethod = llvm::dyn_cast<CXXMethodDecl>(Ctx);
1397 if (CtxMethod && !CtxMethod->getParent()->isLambda()) {
1398 return CtxMethod->getParent();
1404 R.FunctionCanBeCall =
1405 CurrentClassScope &&
1406 (CurrentClassScope == Method->getParent() ||
1407 CurrentClassScope->isDerivedFrom(Method->getParent()));
1412 Results.push_back(R);
1414 if (!AsNestedNameSpecifier)
1415 MaybeAddConstructorResults(R);
1418void ResultBuilder::AddResult(
Result R) {
1419 assert(R.Kind != Result::RK_Declaration &&
1420 "Declaration results need more context");
1421 Results.push_back(R);
1425void ResultBuilder::EnterNewScope() { ShadowMaps.emplace_back(); }
1428void ResultBuilder::ExitScope() {
1429 ShadowMaps.pop_back();
1434bool ResultBuilder::IsOrdinaryName(
const NamedDecl *ND)
const {
1443 if (isa<ObjCIvarDecl>(ND))
1452bool ResultBuilder::IsOrdinaryNonTypeName(
const NamedDecl *ND)
const {
1454 if (isa<TypeDecl>(ND))
1459 if (
const auto *ID = dyn_cast<ObjCInterfaceDecl>(ND)) {
1460 if (!
ID->getDefinition())
1468 if (isa<ObjCIvarDecl>(ND))
1475bool ResultBuilder::IsIntegralConstantValue(
const NamedDecl *ND)
const {
1476 if (!IsOrdinaryNonTypeName(ND))
1480 if (VD->getType()->isIntegralOrEnumerationType())
1488bool ResultBuilder::IsOrdinaryNonValueName(
const NamedDecl *ND)
const {
1496 !isa<FunctionTemplateDecl>(ND) && !isa<ObjCPropertyDecl>(ND);
1501bool ResultBuilder::IsNestedNameSpecifier(
const NamedDecl *ND)
const {
1503 if (
const auto *ClassTemplate = dyn_cast<ClassTemplateDecl>(ND))
1504 ND = ClassTemplate->getTemplatedDecl();
1510bool ResultBuilder::IsEnum(
const NamedDecl *ND)
const {
1511 return isa<EnumDecl>(ND);
1515bool ResultBuilder::IsClassOrStruct(
const NamedDecl *ND)
const {
1517 if (
const auto *ClassTemplate = dyn_cast<ClassTemplateDecl>(ND))
1518 ND = ClassTemplate->getTemplatedDecl();
1521 if (
const auto *RD = dyn_cast<RecordDecl>(ND))
1529bool ResultBuilder::IsUnion(
const NamedDecl *ND)
const {
1531 if (
const auto *ClassTemplate = dyn_cast<ClassTemplateDecl>(ND))
1532 ND = ClassTemplate->getTemplatedDecl();
1534 if (
const auto *RD = dyn_cast<RecordDecl>(ND))
1541bool ResultBuilder::IsNamespace(
const NamedDecl *ND)
const {
1542 return isa<NamespaceDecl>(ND);
1547bool ResultBuilder::IsNamespaceOrAlias(
const NamedDecl *ND)
const {
1552bool ResultBuilder::IsType(
const NamedDecl *ND)
const {
1554 return isa<TypeDecl>(ND) || isa<ObjCInterfaceDecl>(ND);
1560bool ResultBuilder::IsMember(
const NamedDecl *ND)
const {
1562 return isa<ValueDecl>(ND) || isa<FunctionTemplateDecl>(ND) ||
1563 isa<ObjCPropertyDecl>(ND);
1567 T =
C.getCanonicalType(T);
1569 case Type::ObjCObject:
1570 case Type::ObjCInterface:
1571 case Type::ObjCObjectPointer:
1575 switch (cast<BuiltinType>(T)->
getKind()) {
1576 case BuiltinType::ObjCId:
1577 case BuiltinType::ObjCClass:
1578 case BuiltinType::ObjCSel:
1590 if (!
C.getLangOpts().CPlusPlus)
1599bool ResultBuilder::IsObjCMessageReceiver(
const NamedDecl *ND)
const {
1608bool ResultBuilder::IsObjCMessageReceiverOrLambdaCapture(
1610 if (IsObjCMessageReceiver(ND))
1613 const auto *Var = dyn_cast<VarDecl>(ND);
1617 return Var->hasLocalStorage() && !Var->hasAttr<BlocksAttr>();
1620bool ResultBuilder::IsObjCCollection(
const NamedDecl *ND)
const {
1621 if ((SemaRef.
getLangOpts().CPlusPlus && !IsOrdinaryName(ND)) ||
1622 (!SemaRef.
getLangOpts().CPlusPlus && !IsOrdinaryNonTypeName(ND)))
1635bool ResultBuilder::IsImpossibleToSatisfy(
const NamedDecl *ND)
const {
1641bool ResultBuilder::IsObjCIvar(
const NamedDecl *ND)
const {
1642 return isa<ObjCIvarDecl>(ND);
1650 ResultBuilder &Results;
1656 std::vector<FixItHint> FixIts;
1659 CodeCompletionDeclConsumer(
1660 ResultBuilder &Results,
DeclContext *InitialLookupCtx,
1662 std::vector<FixItHint> FixIts = std::vector<FixItHint>())
1663 : Results(Results), InitialLookupCtx(InitialLookupCtx),
1664 FixIts(
std::move(FixIts)) {
1665 NamingClass = llvm::dyn_cast<CXXRecordDecl>(InitialLookupCtx);
1668 auto ThisType = Results.getSema().getCurrentThisType();
1669 if (!ThisType.isNull()) {
1670 assert(ThisType->isPointerType());
1676 this->BaseType = BaseType;
1680 bool InBaseClass)
override {
1683 Results.AddResult(Result, InitialLookupCtx, Hiding, InBaseClass);
1687 Results.addVisitedContext(Ctx);
1696 auto *NamingClass = this->NamingClass;
1697 QualType BaseType = this->BaseType;
1698 if (
auto *Cls = llvm::dyn_cast_or_null<CXXRecordDecl>(Ctx)) {
1713 NamingClass =
nullptr;
1716 return Results.getSema().IsSimplyAccessible(ND, NamingClass, BaseType);
1723 ResultBuilder &Results) {
1749 Results.getCodeCompletionTUInfo());
1750 if (LangOpts.CPlusPlus) {
1758 Builder.AddTypedTextChunk(
"typename");
1760 Builder.AddPlaceholderChunk(
"name");
1761 Results.AddResult(
Result(Builder.TakeString()));
1763 if (LangOpts.CPlusPlus11) {
1768 Builder.AddTypedTextChunk(
"decltype");
1770 Builder.AddPlaceholderChunk(
"expression");
1772 Results.AddResult(
Result(Builder.TakeString()));
1778 if (LangOpts.GNUKeywords) {
1784 Builder.AddTypedTextChunk(
"typeof");
1786 Builder.AddPlaceholderChunk(
"expression");
1787 Results.AddResult(
Result(Builder.TakeString()));
1789 Builder.AddTypedTextChunk(
"typeof");
1791 Builder.AddPlaceholderChunk(
"type");
1793 Results.AddResult(
Result(Builder.TakeString()));
1804 ResultBuilder &Results) {
1809 Results.AddResult(
Result(
"extern"));
1810 Results.AddResult(
Result(
"static"));
1812 if (LangOpts.CPlusPlus11) {
1817 Builder.AddTypedTextChunk(
"alignas");
1819 Builder.AddPlaceholderChunk(
"expression");
1821 Results.AddResult(
Result(Builder.TakeString()));
1823 Results.AddResult(
Result(
"constexpr"));
1824 Results.AddResult(
Result(
"thread_local"));
1830 ResultBuilder &Results) {
1835 if (LangOpts.CPlusPlus) {
1836 Results.AddResult(
Result(
"explicit"));
1837 Results.AddResult(
Result(
"friend"));
1838 Results.AddResult(
Result(
"mutable"));
1839 Results.AddResult(
Result(
"virtual"));
1847 if (LangOpts.CPlusPlus || LangOpts.C99)
1848 Results.AddResult(
Result(
"inline"));
1868 ResultBuilder &Results,
bool NeedAt);
1870 ResultBuilder &Results,
bool NeedAt);
1872 ResultBuilder &Results,
bool NeedAt);
1877 Results.getCodeCompletionTUInfo());
1878 Builder.AddTypedTextChunk(
"typedef");
1880 Builder.AddPlaceholderChunk(
"type");
1882 Builder.AddPlaceholderChunk(
"name");
1889 ResultBuilder &Results) {
1890 Builder.AddTypedTextChunk(
"using");
1892 Builder.AddPlaceholderChunk(
"name");
1894 Builder.AddPlaceholderChunk(
"type");
1917 return LangOpts.CPlusPlus;
1924 return LangOpts.CPlusPlus || LangOpts.ObjC || LangOpts.C99;
1927 llvm_unreachable(
"Invalid ParserCompletionContext!");
1956 if (
const BuiltinType *BT = dyn_cast<BuiltinType>(T))
1957 return BT->getNameAsCString(Policy);
1960 if (
const TagType *TagT = dyn_cast<TagType>(T))
1961 if (
TagDecl *Tag = TagT->getDecl())
1962 if (!Tag->hasNameForLinkage()) {
1963 switch (Tag->getTagKind()) {
1965 return "struct <anonymous>";
1967 return "__interface <anonymous>";
1969 return "class <anonymous>";
1971 return "union <anonymous>";
1973 return "enum <anonymous>";
1981 return Allocator.CopyString(
Result);
1993 Builder.AddResultTypeChunk(
1995 Builder.AddTypedTextChunk(
"this");
2000 ResultBuilder &Results,
2002 if (!LangOpts.CPlusPlus11)
2005 Builder.AddTypedTextChunk(
"static_assert");
2007 Builder.AddPlaceholderChunk(
"expression");
2009 Builder.AddPlaceholderChunk(
"message");
2018 Sema &S = Results.getSema();
2019 const auto *CR = llvm::dyn_cast<CXXRecordDecl>(S.
CurContext);
2025 llvm::StringMap<std::vector<FunctionDecl *>> Overrides;
2026 for (
auto *Method : CR->methods()) {
2027 if (!Method->isVirtual() || !Method->getIdentifier())
2029 Overrides[Method->getName()].push_back(Method);
2032 for (
const auto &
Base : CR->bases()) {
2033 const auto *BR =
Base.getType().getTypePtr()->getAsCXXRecordDecl();
2036 for (
auto *Method : BR->methods()) {
2037 if (!Method->isVirtual() || !Method->getIdentifier())
2039 const auto it = Overrides.find(Method->getName());
2040 bool IsOverriden =
false;
2041 if (it != Overrides.end()) {
2042 for (
auto *MD : it->second) {
2055 std::string OverrideSignature;
2056 llvm::raw_string_ostream OS(OverrideSignature);
2062 false, CCContext, Policy);
2071 Sema &SemaRef, ResultBuilder &Results) {
2079 if (Results.includeCodePatterns()) {
2081 Builder.AddTypedTextChunk(
"namespace");
2083 Builder.AddPlaceholderChunk(
"identifier");
2087 Builder.AddPlaceholderChunk(
"declarations");
2090 Results.AddResult(
Result(Builder.TakeString()));
2094 Builder.AddTypedTextChunk(
"namespace");
2096 Builder.AddPlaceholderChunk(
"name");
2098 Builder.AddPlaceholderChunk(
"namespace");
2100 Results.AddResult(
Result(Builder.TakeString()));
2103 Builder.AddTypedTextChunk(
"using namespace");
2105 Builder.AddPlaceholderChunk(
"identifier");
2107 Results.AddResult(
Result(Builder.TakeString()));
2110 Builder.AddTypedTextChunk(
"asm");
2112 Builder.AddPlaceholderChunk(
"string-literal");
2114 Results.AddResult(
Result(Builder.TakeString()));
2116 if (Results.includeCodePatterns()) {
2118 Builder.AddTypedTextChunk(
"template");
2120 Builder.AddPlaceholderChunk(
"declaration");
2121 Results.AddResult(
Result(Builder.TakeString()));
2136 Builder.AddTypedTextChunk(
"using");
2138 Builder.AddPlaceholderChunk(
"qualifier");
2139 Builder.AddTextChunk(
"::");
2140 Builder.AddPlaceholderChunk(
"name");
2142 Results.AddResult(
Result(Builder.TakeString()));
2149 Builder.AddTypedTextChunk(
"using typename");
2151 Builder.AddPlaceholderChunk(
"qualifier");
2152 Builder.AddTextChunk(
"::");
2153 Builder.AddPlaceholderChunk(
"name");
2155 Results.AddResult(
Result(Builder.TakeString()));
2163 bool IsNotInheritanceScope = !S->isClassInheritanceScope();
2165 Builder.AddTypedTextChunk(
"public");
2166 if (IsNotInheritanceScope && Results.includeCodePatterns())
2168 Results.AddResult(
Result(Builder.TakeString()));
2171 Builder.AddTypedTextChunk(
"protected");
2172 if (IsNotInheritanceScope && Results.includeCodePatterns())
2174 Results.AddResult(
Result(Builder.TakeString()));
2177 Builder.AddTypedTextChunk(
"private");
2178 if (IsNotInheritanceScope && Results.includeCodePatterns())
2180 Results.AddResult(
Result(Builder.TakeString()));
2193 if (SemaRef.
getLangOpts().CPlusPlus && Results.includeCodePatterns()) {
2195 Builder.AddTypedTextChunk(
"template");
2197 Builder.AddPlaceholderChunk(
"parameters");
2199 Results.AddResult(
Result(Builder.TakeString()));
2232 if (SemaRef.
getLangOpts().CPlusPlus && Results.includeCodePatterns() &&
2234 Builder.AddTypedTextChunk(
"try");
2238 Builder.AddPlaceholderChunk(
"statements");
2242 Builder.AddTextChunk(
"catch");
2245 Builder.AddPlaceholderChunk(
"declaration");
2250 Builder.AddPlaceholderChunk(
"statements");
2253 Results.AddResult(
Result(Builder.TakeString()));
2258 if (Results.includeCodePatterns()) {
2260 Builder.AddTypedTextChunk(
"if");
2264 Builder.AddPlaceholderChunk(
"condition");
2266 Builder.AddPlaceholderChunk(
"expression");
2271 Builder.AddPlaceholderChunk(
"statements");
2274 Results.AddResult(
Result(Builder.TakeString()));
2277 Builder.AddTypedTextChunk(
"switch");
2281 Builder.AddPlaceholderChunk(
"condition");
2283 Builder.AddPlaceholderChunk(
"expression");
2288 Builder.AddPlaceholderChunk(
"cases");
2291 Results.AddResult(
Result(Builder.TakeString()));
2298 Builder.AddTypedTextChunk(
"case");
2300 Builder.AddPlaceholderChunk(
"expression");
2302 Results.AddResult(
Result(Builder.TakeString()));
2305 Builder.AddTypedTextChunk(
"default");
2307 Results.AddResult(
Result(Builder.TakeString()));
2310 if (Results.includeCodePatterns()) {
2312 Builder.AddTypedTextChunk(
"while");
2316 Builder.AddPlaceholderChunk(
"condition");
2318 Builder.AddPlaceholderChunk(
"expression");
2323 Builder.AddPlaceholderChunk(
"statements");
2326 Results.AddResult(
Result(Builder.TakeString()));
2329 Builder.AddTypedTextChunk(
"do");
2333 Builder.AddPlaceholderChunk(
"statements");
2336 Builder.AddTextChunk(
"while");
2339 Builder.AddPlaceholderChunk(
"expression");
2341 Results.AddResult(
Result(Builder.TakeString()));
2344 Builder.AddTypedTextChunk(
"for");
2348 Builder.AddPlaceholderChunk(
"init-statement");
2350 Builder.AddPlaceholderChunk(
"init-expression");
2353 Builder.AddPlaceholderChunk(
"condition");
2356 Builder.AddPlaceholderChunk(
"inc-expression");
2361 Builder.AddPlaceholderChunk(
"statements");
2364 Results.AddResult(
Result(Builder.TakeString()));
2368 Builder.AddTypedTextChunk(
"for");
2371 Builder.AddPlaceholderChunk(
"range-declaration");
2374 Builder.AddTextChunk(
"in");
2378 Builder.AddPlaceholderChunk(
"range-expression");
2383 Builder.AddPlaceholderChunk(
"statements");
2386 Results.AddResult(
Result(Builder.TakeString()));
2390 if (S->getContinueParent()) {
2392 Builder.AddTypedTextChunk(
"continue");
2394 Results.AddResult(
Result(Builder.TakeString()));
2397 if (S->getBreakParent()) {
2399 Builder.AddTypedTextChunk(
"break");
2401 Results.AddResult(
Result(Builder.TakeString()));
2406 if (
const auto *Function = dyn_cast<FunctionDecl>(SemaRef.
CurContext))
2407 ReturnType = Function->getReturnType();
2408 else if (
const auto *Method = dyn_cast<ObjCMethodDecl>(SemaRef.
CurContext))
2409 ReturnType = Method->getReturnType();
2414 Builder.AddTypedTextChunk(
"return");
2416 Results.AddResult(
Result(Builder.TakeString()));
2418 assert(!ReturnType.
isNull());
2420 Builder.AddTypedTextChunk(
"return");
2422 Builder.AddPlaceholderChunk(
"expression");
2424 Results.AddResult(
Result(Builder.TakeString()));
2427 Builder.AddTypedTextChunk(
"return true");
2429 Results.AddResult(
Result(Builder.TakeString()));
2431 Builder.AddTypedTextChunk(
"return false");
2433 Results.AddResult(
Result(Builder.TakeString()));
2438 Builder.AddTypedTextChunk(
"return nullptr");
2440 Results.AddResult(
Result(Builder.TakeString()));
2445 Builder.AddTypedTextChunk(
"goto");
2447 Builder.AddPlaceholderChunk(
"label");
2449 Results.AddResult(
Result(Builder.TakeString()));
2452 Builder.AddTypedTextChunk(
"using namespace");
2454 Builder.AddPlaceholderChunk(
"identifier");
2456 Results.AddResult(
Result(Builder.TakeString()));
2473 Builder.AddTypedTextChunk(
"__bridge");
2475 Builder.AddPlaceholderChunk(
"type");
2477 Builder.AddPlaceholderChunk(
"expression");
2478 Results.AddResult(
Result(Builder.TakeString()));
2481 Builder.AddTypedTextChunk(
"__bridge_transfer");
2483 Builder.AddPlaceholderChunk(
"Objective-C type");
2485 Builder.AddPlaceholderChunk(
"expression");
2486 Results.AddResult(
Result(Builder.TakeString()));
2489 Builder.AddTypedTextChunk(
"__bridge_retained");
2491 Builder.AddPlaceholderChunk(
"CF type");
2493 Builder.AddPlaceholderChunk(
"expression");
2494 Results.AddResult(
Result(Builder.TakeString()));
2505 Builder.AddResultTypeChunk(
"bool");
2506 Builder.AddTypedTextChunk(
"true");
2507 Results.AddResult(
Result(Builder.TakeString()));
2510 Builder.AddResultTypeChunk(
"bool");
2511 Builder.AddTypedTextChunk(
"false");
2512 Results.AddResult(
Result(Builder.TakeString()));
2516 Builder.AddTypedTextChunk(
"dynamic_cast");
2518 Builder.AddPlaceholderChunk(
"type");
2521 Builder.AddPlaceholderChunk(
"expression");
2523 Results.AddResult(
Result(Builder.TakeString()));
2527 Builder.AddTypedTextChunk(
"static_cast");
2529 Builder.AddPlaceholderChunk(
"type");
2532 Builder.AddPlaceholderChunk(
"expression");
2534 Results.AddResult(
Result(Builder.TakeString()));
2537 Builder.AddTypedTextChunk(
"reinterpret_cast");
2539 Builder.AddPlaceholderChunk(
"type");
2542 Builder.AddPlaceholderChunk(
"expression");
2544 Results.AddResult(
Result(Builder.TakeString()));
2547 Builder.AddTypedTextChunk(
"const_cast");
2549 Builder.AddPlaceholderChunk(
"type");
2552 Builder.AddPlaceholderChunk(
"expression");
2554 Results.AddResult(
Result(Builder.TakeString()));
2558 Builder.AddResultTypeChunk(
"std::type_info");
2559 Builder.AddTypedTextChunk(
"typeid");
2561 Builder.AddPlaceholderChunk(
"expression-or-type");
2563 Results.AddResult(
Result(Builder.TakeString()));
2567 Builder.AddTypedTextChunk(
"new");
2569 Builder.AddPlaceholderChunk(
"type");
2571 Builder.AddPlaceholderChunk(
"expressions");
2573 Results.AddResult(
Result(Builder.TakeString()));
2576 Builder.AddTypedTextChunk(
"new");
2578 Builder.AddPlaceholderChunk(
"type");
2580 Builder.AddPlaceholderChunk(
"size");
2583 Builder.AddPlaceholderChunk(
"expressions");
2585 Results.AddResult(
Result(Builder.TakeString()));
2588 Builder.AddResultTypeChunk(
"void");
2589 Builder.AddTypedTextChunk(
"delete");
2591 Builder.AddPlaceholderChunk(
"expression");
2592 Results.AddResult(
Result(Builder.TakeString()));
2595 Builder.AddResultTypeChunk(
"void");
2596 Builder.AddTypedTextChunk(
"delete");
2601 Builder.AddPlaceholderChunk(
"expression");
2602 Results.AddResult(
Result(Builder.TakeString()));
2606 Builder.AddResultTypeChunk(
"void");
2607 Builder.AddTypedTextChunk(
"throw");
2609 Builder.AddPlaceholderChunk(
"expression");
2610 Results.AddResult(
Result(Builder.TakeString()));
2617 Builder.AddResultTypeChunk(
"std::nullptr_t");
2618 Builder.AddTypedTextChunk(
"nullptr");
2619 Results.AddResult(
Result(Builder.TakeString()));
2622 Builder.AddResultTypeChunk(
"size_t");
2623 Builder.AddTypedTextChunk(
"alignof");
2625 Builder.AddPlaceholderChunk(
"type");
2627 Results.AddResult(
Result(Builder.TakeString()));
2630 Builder.AddResultTypeChunk(
"bool");
2631 Builder.AddTypedTextChunk(
"noexcept");
2633 Builder.AddPlaceholderChunk(
"expression");
2635 Results.AddResult(
Result(Builder.TakeString()));
2638 Builder.AddResultTypeChunk(
"size_t");
2639 Builder.AddTypedTextChunk(
"sizeof...");
2641 Builder.AddPlaceholderChunk(
"parameter-pack");
2643 Results.AddResult(
Result(Builder.TakeString()));
2652 if (ID->getSuperClass()) {
2653 std::string SuperType;
2654 SuperType = ID->getSuperClass()->getNameAsString();
2655 if (Method->isInstanceMethod())
2658 Builder.AddResultTypeChunk(Allocator.CopyString(SuperType));
2659 Builder.AddTypedTextChunk(
"super");
2660 Results.AddResult(
Result(Builder.TakeString()));
2669 Builder.AddResultTypeChunk(
"size_t");
2671 Builder.AddTypedTextChunk(
"alignof");
2673 Builder.AddTypedTextChunk(
"_Alignof");
2675 Builder.AddPlaceholderChunk(
"type");
2677 Results.AddResult(
Result(Builder.TakeString()));
2682 Builder.AddResultTypeChunk(
"nullptr_t");
2683 Builder.AddTypedTextChunk(
"nullptr");
2684 Results.AddResult(
Result(Builder.TakeString()));
2688 Builder.AddResultTypeChunk(
"size_t");
2689 Builder.AddTypedTextChunk(
"sizeof");
2691 Builder.AddPlaceholderChunk(
"expression-or-type");
2693 Results.AddResult(
Result(Builder.TakeString()));
2706 Results.AddResult(
Result(
"operator"));
2726 T = Function->getReturnType();
2727 else if (
const auto *Method = dyn_cast<ObjCMethodDecl>(ND)) {
2729 T = Method->getSendResultType(BaseType);
2731 T = Method->getReturnType();
2732 }
else if (
const auto *Enumerator = dyn_cast<EnumConstantDecl>(ND)) {
2733 T = Context.
getTypeDeclType(cast<TypeDecl>(Enumerator->getDeclContext()));
2735 }
else if (isa<UnresolvedUsingValueDecl>(ND)) {
2737 }
else if (
const auto *Ivar = dyn_cast<ObjCIvarDecl>(ND)) {
2739 T = Ivar->getUsageType(BaseType);
2741 T = Ivar->getType();
2742 }
else if (
const auto *
Value = dyn_cast<ValueDecl>(ND)) {
2744 }
else if (
const auto *
Property = dyn_cast<ObjCPropertyDecl>(ND)) {
2746 T =
Property->getUsageType(BaseType);
2754 Result.AddResultTypeChunk(
2761 if (SentinelAttr *Sentinel = FunctionOrMethod->
getAttr<SentinelAttr>())
2762 if (Sentinel->getSentinel() == 0) {
2764 Result.AddTextChunk(
", nil");
2766 Result.AddTextChunk(
", NULL");
2768 Result.AddTextChunk(
", (void*)0");
2789 switch (*nullability) {
2799 Result +=
"null_unspecified ";
2803 llvm_unreachable(
"Not supported as a context-sensitive keyword!");
2820 bool SuppressBlock =
false) {
2826 if (!SuppressBlock) {
2829 TypedefTL.getTypedefNameDecl()->getTypeSourceInfo()) {
2842 TL = AttrTL.getModifiedLoc();
2861 bool SuppressBlockName =
false,
bool SuppressBlock =
false,
2866 bool SuppressName =
false,
bool SuppressBlock =
false,
2874 if (
const auto *PVD = dyn_cast<ParmVarDecl>(Param))
2875 ObjCQual = PVD->getObjCDeclQualifier();
2876 bool ObjCMethodParam = isa<ObjCMethodDecl>(Param->
getDeclContext());
2883 if (Param->
getIdentifier() && !ObjCMethodParam && !SuppressName)
2890 if (ObjCMethodParam) {
2909 if (!
Block && ObjCMethodParam &&
2910 cast<ObjCMethodDecl>(Param->
getDeclContext())->isPropertyAccessor()) {
2911 if (
const auto *PD = cast<ObjCMethodDecl>(Param->
getDeclContext())
2912 ->findPropertyDecl(
false))
2926 if (ObjCMethodParam) {
2931 if (
Result.back() !=
')')
2945 false, SuppressBlock,
2961 bool SuppressBlockName,
bool SuppressBlock,
2969 if (!ResultType->
isVoidType() || SuppressBlock)
2974 if (!BlockProto ||
Block.getNumParams() == 0) {
2981 for (
unsigned I = 0, N =
Block.getNumParams(); I != N; ++I) {
2994 if (SuppressBlock) {
2997 if (!SuppressBlockName &&
BlockDecl->getIdentifier())
3006 if (!SuppressBlockName &&
BlockDecl->getIdentifier())
3026 if (srcText.empty() || srcText ==
"=") {
3032 std::string DefValue(srcText.str());
3035 if (DefValue.at(0) !=
'=') {
3039 return " = " + DefValue;
3041 return " " + DefValue;
3050 bool InOptional =
false) {
3051 bool FirstParameter =
true;
3053 for (
unsigned P = Start, N = Function->getNumParams();
P != N; ++
P) {
3060 Result.getCodeCompletionTUInfo());
3061 if (!FirstParameter)
3069 FirstParameter =
false;
3081 if (Function->isVariadic() &&
P == N - 1)
3082 PlaceholderStr +=
", ...";
3085 Result.AddPlaceholderChunk(
3086 Result.getAllocator().CopyString(PlaceholderStr));
3090 if (Proto->isVariadic()) {
3091 if (Proto->getNumParams() == 0)
3092 Result.AddPlaceholderChunk(
"...");
3102 unsigned MaxParameters = 0,
unsigned Start = 0,
bool InDefaultArg =
false) {
3103 bool FirstParameter =
true;
3112 PEnd = Params->
begin() + MaxParameters;
3115 bool HasDefaultArg =
false;
3116 std::string PlaceholderStr;
3118 if (TTP->wasDeclaredWithTypename())
3119 PlaceholderStr =
"typename";
3120 else if (
const auto *TC = TTP->getTypeConstraint()) {
3121 llvm::raw_string_ostream OS(PlaceholderStr);
3122 TC->print(OS, Policy);
3125 PlaceholderStr =
"class";
3127 if (TTP->getIdentifier()) {
3128 PlaceholderStr +=
' ';
3129 PlaceholderStr += TTP->getIdentifier()->deuglifiedName();
3132 HasDefaultArg = TTP->hasDefaultArgument();
3134 dyn_cast<NonTypeTemplateParmDecl>(*
P)) {
3135 if (NTTP->getIdentifier())
3136 PlaceholderStr = std::string(NTTP->getIdentifier()->deuglifiedName());
3137 NTTP->getType().getAsStringInternal(PlaceholderStr, Policy);
3138 HasDefaultArg = NTTP->hasDefaultArgument();
3140 assert(isa<TemplateTemplateParmDecl>(*
P));
3145 PlaceholderStr =
"template<...> class";
3147 PlaceholderStr +=
' ';
3154 if (HasDefaultArg && !InDefaultArg) {
3158 Result.getCodeCompletionTUInfo());
3159 if (!FirstParameter)
3162 P - Params->
begin(),
true);
3167 InDefaultArg =
false;
3170 FirstParameter =
false;
3175 Result.AddPlaceholderChunk(
3176 Result.getAllocator().CopyString(PlaceholderStr));
3184 bool QualifierIsInformative,
3190 std::string PrintedNNS;
3192 llvm::raw_string_ostream OS(PrintedNNS);
3193 Qualifier->print(OS, Policy);
3195 if (QualifierIsInformative)
3196 Result.AddInformativeChunk(
Result.getAllocator().CopyString(PrintedNNS));
3198 Result.AddTextChunk(
Result.getAllocator().CopyString(PrintedNNS));
3205 if (!Proto || !Proto->getMethodQuals())
3211 if (Proto->getMethodQuals().hasOnlyConst()) {
3212 Result.AddInformativeChunk(
" const");
3216 if (Proto->getMethodQuals().hasOnlyVolatile()) {
3217 Result.AddInformativeChunk(
" volatile");
3221 if (Proto->getMethodQuals().hasOnlyRestrict()) {
3222 Result.AddInformativeChunk(
" restrict");
3227 std::string QualsStr;
3228 if (Proto->isConst())
3229 QualsStr +=
" const";
3230 if (Proto->isVolatile())
3231 QualsStr +=
" volatile";
3232 if (Proto->isRestrict())
3233 QualsStr +=
" restrict";
3234 Result.AddInformativeChunk(
Result.getAllocator().CopyString(QualsStr));
3245 switch (Name.getNameKind()) {
3247 const char *OperatorName =
nullptr;
3248 switch (Name.getCXXOverloadedOperator()) {
3250 case OO_Conditional:
3252 OperatorName =
"operator";
3255#define OVERLOADED_OPERATOR(Name, Spelling, Token, Unary, Binary, MemberOnly) \
3257 OperatorName = "operator" Spelling; \
3259#define OVERLOADED_OPERATOR_MULTI(Name, Spelling, Unary, Binary, MemberOnly)
3260#include "clang/Basic/OperatorKinds.def"
3263 OperatorName =
"operator new";
3266 OperatorName =
"operator delete";
3269 OperatorName =
"operator new[]";
3271 case OO_Array_Delete:
3272 OperatorName =
"operator delete[]";
3275 OperatorName =
"operator()";
3278 OperatorName =
"operator[]";
3281 Result.AddTypedTextChunk(OperatorName);
3289 Result.AddTypedTextChunk(
3302 QualType Ty = Name.getCXXNameType();
3304 Record = cast<CXXRecordDecl>(RecordTy->getDecl());
3306 Record = InjectedTy->getDecl();
3308 Result.AddTypedTextChunk(
3313 Result.AddTypedTextChunk(
3314 Result.getAllocator().CopyString(Record->getNameAsString()));
3328 bool IncludeBriefComments) {
3330 CCTUInfo, IncludeBriefComments);
3342 return Result.TakeString();
3353 Result.AddPlaceholderChunk(
"...");
3367 Result.AddPlaceholderChunk(
Result.getAllocator().CopyString(Arg));
3372 Result.AddPlaceholderChunk(
3373 Result.getAllocator().CopyString((*A)->getName()));
3376 return Result.TakeString();
3388 bool IncludeBriefComments) {
3404 Result.addBriefComment(RC->getBriefText(Ctx));
3414 return Result.TakeString();
3418 PP, Ctx,
Result, IncludeBriefComments, CCContext, Policy);
3422 std::string &BeforeName,
3423 std::string &NameAndSignature) {
3424 bool SeenTypedChunk =
false;
3425 for (
auto &Chunk : CCS) {
3427 assert(SeenTypedChunk &&
"optional parameter before name");
3434 NameAndSignature += Chunk.Text;
3436 BeforeName += Chunk.Text;
3448 std::string BeforeName;
3449 std::string NameAndSignature;
3452 NameAndSignature +=
" override";
3454 Result.AddTextChunk(
Result.getAllocator().CopyString(BeforeName));
3456 Result.AddTypedTextChunk(
Result.getAllocator().CopyString(NameAndSignature));
3457 return Result.TakeString();
3463 const auto *VD = dyn_cast<VarDecl>(ND);
3466 const auto *
RecordDecl = VD->getType()->getAsCXXRecordDecl();
3479 if (IncludeBriefComments) {
3482 Result.addBriefComment(RC->getBriefText(Ctx));
3487 Result.AddTypedTextChunk(
3489 Result.AddTextChunk(
"::");
3490 return Result.TakeString();
3494 Result.AddAnnotation(
Result.getAllocator().CopyString(I->getAnnotation()));
3496 auto AddFunctionTypeAndResult = [&](
const FunctionDecl *Function) {
3507 if (
const auto *Function = dyn_cast<FunctionDecl>(ND)) {
3508 AddFunctionTypeAndResult(Function);
3509 return Result.TakeString();
3512 if (
const auto *CallOperator =
3514 AddFunctionTypeAndResult(CallOperator);
3515 return Result.TakeString();
3521 dyn_cast<FunctionTemplateDecl>(ND)) {
3529 llvm::SmallBitVector Deduced;
3531 unsigned LastDeducibleArgument;
3532 for (LastDeducibleArgument = Deduced.size(); LastDeducibleArgument > 0;
3533 --LastDeducibleArgument) {
3534 if (!Deduced[LastDeducibleArgument - 1]) {
3538 bool HasDefaultArg =
false;
3539 NamedDecl *Param = FunTmpl->getTemplateParameters()->getParam(
3540 LastDeducibleArgument - 1);
3542 HasDefaultArg = TTP->hasDefaultArgument();
3544 dyn_cast<NonTypeTemplateParmDecl>(Param))
3545 HasDefaultArg = NTTP->hasDefaultArgument();
3547 assert(isa<TemplateTemplateParmDecl>(Param));
3549 cast<TemplateTemplateParmDecl>(Param)->hasDefaultArgument();
3557 if (LastDeducibleArgument) {
3563 LastDeducibleArgument);
3572 return Result.TakeString();
3575 if (
const auto *Template = dyn_cast<TemplateDecl>(ND)) {
3578 Result.AddTypedTextChunk(
3579 Result.getAllocator().CopyString(Template->getNameAsString()));
3583 return Result.TakeString();
3586 if (
const auto *Method = dyn_cast<ObjCMethodDecl>(ND)) {
3587 Selector Sel = Method->getSelector();
3589 Result.AddTypedTextChunk(
3591 return Result.TakeString();
3597 Result.AddTypedTextChunk(
Result.getAllocator().CopyString(SelName));
3599 Result.AddInformativeChunk(
Result.getAllocator().CopyString(SelName));
3603 if (Method->param_size() == 1)
3604 Result.AddTypedTextChunk(
"");
3610 PEnd = Method->param_end();
3611 P != PEnd && Idx < Sel.
getNumArgs(); (
void)++
P, ++Idx) {
3630 QualType ParamType = (*P)->getType();
3631 std::optional<ArrayRef<QualType>> ObjCSubsts;
3647 Arg += II->getName();
3650 if (Method->isVariadic() && (
P + 1) == PEnd)
3654 Result.AddTextChunk(
Result.getAllocator().CopyString(Arg));
3656 Result.AddInformativeChunk(
Result.getAllocator().CopyString(Arg));
3658 Result.AddPlaceholderChunk(
Result.getAllocator().CopyString(Arg));
3661 if (Method->isVariadic()) {
3662 if (Method->param_size() == 0) {
3664 Result.AddTextChunk(
", ...");
3666 Result.AddInformativeChunk(
", ...");
3668 Result.AddPlaceholderChunk(
", ...");
3674 return Result.TakeString();
3681 Result.AddTypedTextChunk(
3683 return Result.TakeString();
3694 const auto *M = dyn_cast<ObjCMethodDecl>(ND);
3706 const auto *M = dyn_cast_or_null<ObjCMethodDecl>(ND);
3707 if (!M || !M->isPropertyAccessor())
3730 auto FDecl =
Result.getFunction();
3733 if (ArgIndex < FDecl->getNumParams())
3741 unsigned CurrentArg) {
3742 unsigned ChunkIndex = 0;
3743 auto AddChunk = [&](llvm::StringRef Placeholder) {
3746 const char *
Copy =
Result.getAllocator().CopyString(Placeholder);
3747 if (ChunkIndex == CurrentArg)
3755 if (
auto *CRD = llvm::dyn_cast<CXXRecordDecl>(RD)) {
3756 for (
const auto &
Base : CRD->bases())
3757 AddChunk(
Base.getType().getAsString(Policy));
3759 for (
const auto &Field : RD->
fields())
3769 unsigned CurrentArg,
unsigned Start = 0,
bool InOptional =
false) {
3775 bool FirstParameter =
true;
3776 unsigned NumParams =
3777 Function ? Function->getNumParams() :
Prototype->getNumParams();
3779 for (
unsigned P = Start;
P != NumParams; ++
P) {
3780 if (Function && Function->getParamDecl(
P)->hasDefaultArg() && !InOptional) {
3784 Result.getCodeCompletionTUInfo());
3785 if (!FirstParameter)
3789 PrototypeLoc, Opt, CurrentArg,
P,
3796 FirstParameter =
false;
3803 std::string Placeholder;
3804 assert(P < Prototype->getNumParams());
3805 if (Function || PrototypeLoc) {
3807 Function ? Function->getParamDecl(
P) : PrototypeLoc.
getParam(
P);
3813 Placeholder =
Prototype->getParamType(
P).getAsString(Policy);
3816 if (
P == CurrentArg)
3817 Result.AddCurrentParameterChunk(
3818 Result.getAllocator().CopyString(Placeholder));
3820 Result.AddPlaceholderChunk(
Result.getAllocator().CopyString(Placeholder));
3825 Result.getCodeCompletionTUInfo());
3826 if (!FirstParameter)
3829 if (CurrentArg < NumParams)
3841 if (
const auto *
Type = dyn_cast<TemplateTypeParmDecl>(Param)) {
3842 Optional =
Type->hasDefaultArgument();
3843 }
else if (
const auto *NonType = dyn_cast<NonTypeTemplateParmDecl>(Param)) {
3844 Optional = NonType->hasDefaultArgument();
3845 }
else if (
const auto *Template = dyn_cast<TemplateTemplateParmDecl>(Param)) {
3846 Optional = Template->hasDefaultArgument();
3849 llvm::raw_string_ostream OS(
Result);
3850 Param->
print(OS, Policy);
3856 if (
const auto *CTD = dyn_cast<ClassTemplateDecl>(TD))
3857 return CTD->getTemplatedDecl()->getKindName().str();
3858 if (
const auto *VTD = dyn_cast<VarTemplateDecl>(TD))
3859 return VTD->getTemplatedDecl()->getType().getAsString(Policy);
3860 if (
const auto *FTD = dyn_cast<FunctionTemplateDecl>(TD))
3861 return FTD->getTemplatedDecl()->getReturnType().getAsString(Policy);
3862 if (isa<TypeAliasTemplateDecl>(TD))
3864 if (isa<TemplateTemplateParmDecl>(TD))
3866 if (isa<ConceptDecl>(TD))
3876 Builder.getCodeCompletionTUInfo());
3878 if (!ResultType.empty())
3879 Builder.AddResultTypeChunk(Builder.getAllocator().CopyString(ResultType));
3880 Builder.AddTextChunk(
3886 for (
unsigned I = 0; I < Params.size(); ++I) {
3887 bool Optional =
false;
3888 std::string Placeholder =
3891 Current = &OptionalBuilder;
3894 Current->AddChunk(I == CurrentArg
3897 Current->getAllocator().CopyString(Placeholder));
3900 if (Current == &OptionalBuilder)
3901 Builder.AddOptionalChunk(OptionalBuilder.
TakeString());
3905 if (isa<FunctionTemplateDecl>(TD))
3906 Builder.AddInformativeChunk(
"()");
3907 return Builder.TakeString();
3914 bool Braced)
const {
3938 if (IncludeBriefComments) {
3945 llvm::raw_string_ostream OS(Name);
3947 Result.AddTextChunk(
Result.getAllocator().CopyString(OS.str()));
3950 Result.AddResultTypeChunk(
Result.getAllocator().CopyString(
3965 return Result.TakeString();
3970 bool PreferredTypeIsPointer) {
3974 if (MacroName.equals(
"nil") || MacroName.equals(
"NULL") ||
3975 MacroName.equals(
"Nil")) {
3977 if (PreferredTypeIsPointer)
3981 else if (MacroName.equals(
"YES") || MacroName.equals(
"NO") ||
3982 MacroName.equals(
"true") || MacroName.equals(
"false"))
3985 else if (MacroName.equals(
"bool"))
3998 case Decl::EnumConstant:
4002 case Decl::Function:
4004 case Decl::ObjCCategory:
4006 case Decl::ObjCCategoryImpl:
4008 case Decl::ObjCImplementation:
4011 case Decl::ObjCInterface:
4013 case Decl::ObjCIvar:
4015 case Decl::ObjCMethod:
4016 return cast<ObjCMethodDecl>(D)->isInstanceMethod()
4019 case Decl::CXXMethod:
4021 case Decl::CXXConstructor:
4023 case Decl::CXXDestructor:
4025 case Decl::CXXConversion:
4027 case Decl::ObjCProperty:
4029 case Decl::ObjCProtocol:
4035 case Decl::TypeAlias:
4037 case Decl::TypeAliasTemplate:
4041 case Decl::Namespace:
4043 case Decl::NamespaceAlias:
4045 case Decl::TemplateTypeParm:
4047 case Decl::NonTypeTemplateParm:
4049 case Decl::TemplateTemplateParm:
4051 case Decl::FunctionTemplate:
4053 case Decl::ClassTemplate:
4055 case Decl::AccessSpec:
4057 case Decl::ClassTemplatePartialSpecialization:
4059 case Decl::UsingDirective:
4061 case Decl::StaticAssert:
4065 case Decl::TranslationUnit:
4069 case Decl::UnresolvedUsingValue:
4070 case Decl::UnresolvedUsingTypename:
4073 case Decl::UsingEnum:
4076 case Decl::ObjCPropertyImpl:
4077 switch (cast<ObjCPropertyImplDecl>(D)->getPropertyImplementation()) {
4084 llvm_unreachable(
"Unexpected Kind!");
4089 case Decl::ObjCTypeParam:
4096 if (
const auto *TD = dyn_cast<TagDecl>(D)) {
4097 switch (TD->getTagKind()) {
4115 bool LoadExternal,
bool IncludeUndefined,
4116 bool TargetTypeIsPointer =
false) {
4119 Results.EnterNewScope();
4125 if (IncludeUndefined || MD) {
4133 TargetTypeIsPointer)));
4137 Results.ExitScope();
4141 ResultBuilder &Results) {
4144 Results.EnterNewScope();
4148 if (LangOpts.C99 || LangOpts.CPlusPlus11)
4150 Results.ExitScope();
4157 unsigned NumResults) {
4219 llvm_unreachable(
"Invalid ParserCompletionContext!");
4231 ResultBuilder &Results) {
4234 while (isa<BlockDecl>(CurContext))
4237 CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(CurContext);
4244 if (!
P->getDeclName())
4250 Results.getCodeCompletionTUInfo());
4257 S.
Context, CurContext, Overridden->getDeclContext());
4260 llvm::raw_string_ostream OS(Str);
4261 NNS->
print(OS, Policy);
4262 Builder.AddTextChunk(Results.getAllocator().CopyString(OS.str()));
4264 }
else if (!InContext->
Equals(Overridden->getDeclContext()))
4267 Builder.AddTypedTextChunk(
4268 Results.getAllocator().CopyString(Overridden->getNameAsString()));
4270 bool FirstParam =
true;
4277 Builder.AddPlaceholderChunk(
4278 Results.getAllocator().CopyString(
P->getIdentifier()->getName()));
4284 Results.Ignore(Overridden);
4291 ResultBuilder Results(*
this, CodeCompleter->getAllocator(),
4292 CodeCompleter->getCodeCompletionTUInfo(),
4294 Results.EnterNewScope();
4302 PP.getHeaderSearchInfo().collectAllModules(Modules);
4303 for (
unsigned I = 0, N = Modules.size(); I != N; ++I) {
4304 Builder.AddTypedTextChunk(
4305 Builder.getAllocator().CopyString(Modules[I]->Name));
4306 Results.AddResult(
Result(
4311 }
else if (getLangOpts().Modules) {
4319 Builder.AddTypedTextChunk(
4320 Builder.getAllocator().CopyString(Submodule->Name));
4321 Results.AddResult(
Result(
4328 Results.ExitScope();
4330 Results.data(), Results.size());
4335 ResultBuilder Results(*
this, CodeCompleter->getAllocator(),
4336 CodeCompleter->getCodeCompletionTUInfo(),
4338 Results.EnterNewScope();
4343 switch (CompletionContext) {
4346 case PCC_ObjCInterface:
4347 case PCC_ObjCImplementation:
4348 case PCC_ObjCInstanceVariableList:
4350 case PCC_MemberTemplate:
4352 case PCC_LocalDeclarationSpecifiers:
4353 Results.setFilter(&ResultBuilder::IsOrdinaryNonValueName);
4357 case PCC_TopLevelOrExpression:
4358 case PCC_ParenthesizedExpression:
4359 case PCC_Expression:
4363 Results.setFilter(&ResultBuilder::IsOrdinaryName);
4365 Results.setFilter(&ResultBuilder::IsOrdinaryNonTypeName);
4371 case PCC_RecoveryInFunction:
4378 auto ThisType = getCurrentThisType();
4379 if (!ThisType.isNull())
4380 Results.setObjectTypeQualifiers(ThisType->getPointeeType().getQualifiers(),
4383 CodeCompletionDeclConsumer Consumer(Results, CurContext);
4384 LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
4385 CodeCompleter->includeGlobals(),
4386 CodeCompleter->loadExternal());
4389 Results.ExitScope();
4391 switch (CompletionContext) {
4392 case PCC_ParenthesizedExpression:
4393 case PCC_Expression:
4395 case PCC_TopLevelOrExpression:
4396 case PCC_RecoveryInFunction:
4397 if (S->getFnParent())
4403 case PCC_ObjCInterface:
4404 case PCC_ObjCImplementation:
4405 case PCC_ObjCInstanceVariableList:
4407 case PCC_MemberTemplate:
4411 case PCC_LocalDeclarationSpecifiers:
4415 if (CodeCompleter->includeMacros())
4419 Results.data(), Results.size());
4425 bool AtArgumentExpression,
bool IsSuper,
4426 ResultBuilder &Results);
4429 bool AllowNonIdentifiers,
4430 bool AllowNestedNameSpecifiers) {
4432 ResultBuilder Results(
4433 *
this, CodeCompleter->getAllocator(),
4434 CodeCompleter->getCodeCompletionTUInfo(),
4435 AllowNestedNameSpecifiers
4440 Results.EnterNewScope();
4443 Results.AddResult(
Result(
"const"));
4444 Results.AddResult(
Result(
"volatile"));
4445 if (getLangOpts().
C99)
4446 Results.AddResult(
Result(
"restrict"));
4452 Results.AddResult(
"final");
4454 if (AllowNonIdentifiers) {
4455 Results.AddResult(
Result(
"operator"));
4459 if (AllowNestedNameSpecifiers) {
4460 Results.allowNestedNameSpecifiers();
4461 Results.setFilter(&ResultBuilder::IsImpossibleToSatisfy);
4462 CodeCompletionDeclConsumer Consumer(Results, CurContext);
4463 LookupVisibleDecls(S, LookupNestedNameSpecifierName, Consumer,
4464 CodeCompleter->includeGlobals(),
4465 CodeCompleter->loadExternal());
4466 Results.setFilter(
nullptr);
4469 Results.ExitScope();
4475 if (AllowNonIdentifiers && !AllowNestedNameSpecifiers &&
4495 Results.data(), Results.size());
4499 if (
Scope ==
"clang")
4507 if (
Scope ==
"_Clang")
4509 if (
Scope ==
"__gnu__")
4517 if (Completion == AttributeCompletion::None)
4519 ResultBuilder Results(*
this, CodeCompleter->getAllocator(),
4520 CodeCompleter->getCodeCompletionTUInfo(),
4533 llvm::StringRef InScopeName;
4534 bool InScopeUnderscore =
false;
4536 InScopeName = InScope->
getName();
4538 InScopeName = NoUnderscore;
4539 InScopeUnderscore =
true;
4548 if (A.IsTargetSpecific && !A.existsInTarget(Context.
getTargetInfo()))
4550 if (!A.acceptsLangOpts(getLangOpts()))
4552 for (
const auto &S : A.Spellings) {
4553 if (S.Syntax != Syntax)
4555 llvm::StringRef Name = S.NormalizedFullName;
4556 llvm::StringRef
Scope;
4559 std::tie(
Scope, Name) = Name.split(
"::");
4561 std::swap(Name,
Scope);
4565 if (Completion == AttributeCompletion::Scope) {
4567 if (!
Scope.empty() && FoundScopes.insert(
Scope).second) {
4578 if (!InScopeName.empty()) {
4579 if (
Scope != InScopeName)
4584 auto Add = [&](llvm::StringRef
Scope, llvm::StringRef Name,
4587 Results.getCodeCompletionTUInfo());
4589 if (!
Scope.empty()) {
4598 Builder.AddTypedTextChunk(Results.getAllocator().CopyString(
Text));
4600 if (!A.ArgNames.empty()) {
4603 for (
const char *Arg : A.ArgNames) {
4607 Builder.AddPlaceholderChunk(Arg);
4612 Results.AddResult(Builder.TakeString());
4619 if (!InScopeUnderscore)
4620 Add(
Scope, Name,
false);
4625 if (!(InScope && !InScopeUnderscore) && SyntaxSupportsGuards) {
4627 if (
Scope.empty()) {
4628 Add(
Scope, Name,
true);
4633 Add(GuardedScope, Name,
true);
4643 for (
const auto &Entry : ParsedAttrInfoRegistry::entries())
4644 AddCompletions(*Entry.instantiate());
4647 Results.data(), Results.size());
4652 bool IsParenthesized =
false)
4653 : PreferredType(PreferredType), IntegralConstantExpression(
false),
4654 ObjCCollection(
false), IsParenthesized(IsParenthesized) {}
4665struct CoveredEnumerators {
4673 const CoveredEnumerators &Enumerators) {
4675 if (Context.
getLangOpts().CPlusPlus && !Qualifier && Enumerators.Seen.empty()) {
4682 Results.EnterNewScope();
4683 for (
auto *E :
Enum->enumerators()) {
4684 if (Enumerators.Seen.count(E))
4688 Results.AddResult(R, CurContext,
nullptr,
false);
4690 Results.ExitScope();
4719 if (!Results.includeCodePatterns())
4722 Results.getCodeCompletionTUInfo());
4727 if (!Parameters.empty()) {
4736 constexpr llvm::StringLiteral NamePlaceholder =
"!#!NAME_GOES_HERE!#!";
4737 std::string
Type = std::string(NamePlaceholder);
4739 llvm::StringRef Prefix, Suffix;
4740 std::tie(Prefix, Suffix) = llvm::StringRef(
Type).split(NamePlaceholder);
4741 Prefix = Prefix.rtrim();
4742 Suffix = Suffix.ltrim();
4765 ResultBuilder Results(
4766 *
this, CodeCompleter->getAllocator(),
4767 CodeCompleter->getCodeCompletionTUInfo(),
4769 Data.IsParenthesized
4772 Data.PreferredType));
4774 Data.IsParenthesized ? PCC_ParenthesizedExpression : PCC_Expression;
4775 if (
Data.ObjCCollection)
4776 Results.setFilter(&ResultBuilder::IsObjCCollection);
4777 else if (
Data.IntegralConstantExpression)
4778 Results.setFilter(&ResultBuilder::IsIntegralConstantValue);
4780 Results.setFilter(&ResultBuilder::IsOrdinaryName);
4782 Results.setFilter(&ResultBuilder::IsOrdinaryNonTypeName);
4784 if (!
Data.PreferredType.isNull())
4785 Results.setPreferredType(
Data.PreferredType.getNonReferenceType());
4788 for (
unsigned I = 0, N =
Data.IgnoreDecls.size(); I != N; ++I)
4789 Results.Ignore(
Data.IgnoreDecls[I]);
4791 CodeCompletionDeclConsumer Consumer(Results, CurContext);
4792 LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
4793 CodeCompleter->includeGlobals(),
4794 CodeCompleter->loadExternal());
4796 Results.EnterNewScope();
4798 Results.ExitScope();
4800 bool PreferredTypeIsPointer =
false;
4801 if (!
Data.PreferredType.isNull()) {
4802 PreferredTypeIsPointer =
Data.PreferredType->isAnyPointerType() ||
4803 Data.PreferredType->isMemberPointerType() ||
4804 Data.PreferredType->isBlockPointerType();
4805 if (
Data.PreferredType->isEnumeralType()) {
4807 if (
auto *Def =
Enum->getDefinition())
4815 if (S->getFnParent() && !
Data.ObjCCollection &&
4816 !
Data.IntegralConstantExpression)
4819 if (CodeCompleter->includeMacros())
4821 PreferredTypeIsPointer);
4831 Results.data(), Results.size());
4835 bool IsParenthesized) {
4836 return CodeCompleteExpression(
4843 CodeCompleteExpression(S, PreferredType);
4844 else if (getLangOpts().
ObjC)
4845 CodeCompleteObjCInstanceMessage(S, E.
get(), std::nullopt,
false);
4855 if (Interface->hasDefinition())
4856 return Interface->getDefinition();
4862 if (Protocol->hasDefinition())
4863 return Protocol->getDefinition();
4877 Builder.AddResultTypeChunk(
4879 Policy, Builder.getAllocator()));
4885 Builder.AddPlaceholderChunk(
"...");
4887 for (
unsigned I = 0, N = BlockLoc.
getNumParams(); I != N; ++I) {
4892 std::string PlaceholderStr =
4895 if (I == N - 1 && BlockProtoLoc &&
4897 PlaceholderStr +=
", ...";
4900 Builder.AddPlaceholderChunk(
4901 Builder.getAllocator().CopyString(PlaceholderStr));
4911 bool AllowNullaryMethods,
DeclContext *CurContext,
4913 bool IsBaseExprStatement =
false,
4914 bool IsClassProperty =
false,
bool InOriginalClass =
true) {
4922 if (!AddedProperties.insert(
P->getIdentifier()).second)
4927 if (!
P->getType().getTypePtr()->isBlockPointerType() ||
4928 !IsBaseExprStatement) {
4930 if (!InOriginalClass)
4932 Results.MaybeAddResult(R, CurContext);
4944 if (!InOriginalClass)
4946 Results.MaybeAddResult(R, CurContext);
4953 Results.getCodeCompletionTUInfo());
4956 BlockLoc, BlockProtoLoc);
4957 Result R =
Result(Builder.TakeString(),
P, Results.getBasePriority(
P));
4958 if (!InOriginalClass)
4960 Results.MaybeAddResult(R, CurContext);
4964 if (!
P->isReadOnly()) {
4966 Results.getCodeCompletionTUInfo());
4970 Builder.AddTypedTextChunk(
4971 Results.getAllocator().CopyString(
P->getName()));
4976 BlockProtoLoc,
true);
4978 Builder.AddPlaceholderChunk(
4979 Builder.getAllocator().CopyString(PlaceholderStr));