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;
104 ShadowMapEntry() : SingleDeclIndex(0) {}
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()) {
230 if (Method->isInstanceMethod())
232 ObjCImplementation = Interface->getImplementation();
241 unsigned getBasePriority(
const NamedDecl *D);
245 bool includeCodePatterns()
const {
251 void setFilter(LookupFilter Filter) { this->Filter =
Filter; }
253 Result *data() {
return Results.empty() ? nullptr : &Results.front(); }
254 unsigned size()
const {
return Results.size(); }
255 bool empty()
const {
return Results.empty(); }
270 ObjectTypeQualifiers = Quals;
272 HasObjectTypeQualifiers =
true;
280 void setPreferredSelector(
Selector Sel) { PreferredSelector = Sel; }
285 return CompletionContext;
289 void allowNestedNameSpecifiers(
bool Allow =
true) {
290 AllowNestedNameSpecifiers = Allow;
295 Sema &getSema()
const {
return SemaRef; }
309 bool isInterestingDecl(
const NamedDecl *ND,
310 bool &AsNestedNameSpecifier)
const;
318 bool CheckHiddenResult(Result &R,
DeclContext *CurContext,
328 void MaybeAddResult(Result R,
DeclContext *CurContext =
nullptr);
345 void AddResult(Result R);
348 void EnterNewScope();
367 bool IsOrdinaryName(
const NamedDecl *ND)
const;
368 bool IsOrdinaryNonTypeName(
const NamedDecl *ND)
const;
369 bool IsIntegralConstantValue(
const NamedDecl *ND)
const;
370 bool IsOrdinaryNonValueName(
const NamedDecl *ND)
const;
371 bool IsNestedNameSpecifier(
const NamedDecl *ND)
const;
373 bool IsClassOrStruct(
const NamedDecl *ND)
const;
375 bool IsNamespace(
const NamedDecl *ND)
const;
376 bool IsNamespaceOrAlias(
const NamedDecl *ND)
const;
378 bool IsMember(
const NamedDecl *ND)
const;
379 bool IsObjCIvar(
const NamedDecl *ND)
const;
380 bool IsObjCMessageReceiver(
const NamedDecl *ND)
const;
381 bool IsObjCMessageReceiverOrLambdaCapture(
const NamedDecl *ND)
const;
382 bool IsObjCCollection(
const NamedDecl *ND)
const;
383 bool IsImpossibleToSatisfy(
const NamedDecl *ND)
const;
393 ComputeType =
nullptr;
394 Type = BSI->ReturnType;
397 }
else if (
const auto *Function = dyn_cast<FunctionDecl>(S.
CurContext)) {
398 ComputeType =
nullptr;
399 Type = Function->getReturnType();
401 }
else if (
const auto *Method = dyn_cast<ObjCMethodDecl>(S.
CurContext)) {
402 ComputeType =
nullptr;
403 Type = Method->getReturnType();
411 auto *VD = llvm::dyn_cast_or_null<ValueDecl>(D);
412 ComputeType =
nullptr;
424 ComputeType =
nullptr;
433 this->ComputeType = ComputeType;
443 if (ExpectedLoc == LParLoc)
454 if (Op == tok::plus || Op == tok::plusequal || Op == tok::minusequal)
457 if (Op == tok::minus)
470 case tok::minusequal:
472 case tok::percentequal:
474 case tok::slashequal:
480 case tok::equalequal:
481 case tok::exclaimequal:
485 case tok::greaterequal:
489 case tok::greatergreater:
490 case tok::greatergreaterequal:
492 case tok::lesslessequal:
499 case tok::caretcaret:
506 case tok::caretequal:
514 case tok::periodstar:
542 case tok::minusminus:
552 assert(
false &&
"unhandled unary op");
561 ComputeType =
nullptr;
568 if (!Enabled || !
Base)
571 if (ExpectedLoc !=
Base->getBeginLoc())
582 ComputeType =
nullptr;
591 ComputeType =
nullptr;
600 ComputeType =
nullptr;
608 ComputeType =
nullptr;
614 llvm::PointerUnion<const NamedDecl *, const DeclIndexPair *> DeclOrIterator;
615 unsigned SingleDeclIndex;
635 : DeclOrIterator(SingleDecl), SingleDeclIndex(Index) {}
638 : DeclOrIterator(Iterator), SingleDeclIndex(0) {}
641 if (DeclOrIterator.is<
const NamedDecl *>()) {
647 const DeclIndexPair *I = DeclOrIterator.get<
const DeclIndexPair *>();
663 return *DeclOrIterator.get<
const DeclIndexPair *>();
669 return X.DeclOrIterator.getOpaqueValue() ==
670 Y.DeclOrIterator.getOpaqueValue() &&
671 X.SingleDeclIndex == Y.SingleDeclIndex;
680ResultBuilder::ShadowMapEntry::begin()
const {
681 if (DeclOrVector.isNull())
685 return iterator(ND, SingleDeclIndex);
687 return iterator(DeclOrVector.get<DeclIndexPairVector *>()->begin());
691ResultBuilder::ShadowMapEntry::end()
const {
692 if (DeclOrVector.is<
const NamedDecl *>() || DeclOrVector.isNull())
695 return iterator(DeclOrVector.get<DeclIndexPairVector *>()->end());
716 for (
const DeclContext *CommonAncestor = TargetContext;
717 CommonAncestor && !CommonAncestor->
Encloses(CurContext);
718 CommonAncestor = CommonAncestor->getLookupParent()) {
719 if (CommonAncestor->isTransparentContext() ||
720 CommonAncestor->isFunctionOrMethod())
723 TargetParents.push_back(CommonAncestor);
727 while (!TargetParents.empty()) {
730 if (
const auto *Namespace = dyn_cast<NamespaceDecl>(
Parent)) {
731 if (!Namespace->getIdentifier())
735 }
else if (
const auto *TD = dyn_cast<TagDecl>(
Parent))
762bool ResultBuilder::isInterestingDecl(
const NamedDecl *ND,
763 bool &AsNestedNameSpecifier)
const {
764 AsNestedNameSpecifier =
false;
779 if (isa<ClassTemplateSpecializationDecl>(ND) ||
780 isa<ClassTemplatePartialSpecializationDecl>(ND))
784 if (isa<UsingDecl>(ND))
790 if (Filter == &ResultBuilder::IsNestedNameSpecifier ||
791 (isa<NamespaceDecl>(ND) && Filter != &ResultBuilder::IsNamespace &&
792 Filter != &ResultBuilder::IsNamespaceOrAlias && Filter !=
nullptr))
793 AsNestedNameSpecifier =
true;
796 if (Filter && !(this->*Filter)(Named)) {
798 if (AllowNestedNameSpecifiers && SemaRef.
getLangOpts().CPlusPlus &&
799 IsNestedNameSpecifier(ND) &&
800 (Filter != &ResultBuilder::IsMember ||
801 (isa<CXXRecordDecl>(ND) &&
802 cast<CXXRecordDecl>(ND)->isInjectedClassName()))) {
803 AsNestedNameSpecifier =
true;
833 R.QualifierIsInformative =
false;
837 R.Declaration->getDeclContext());
844 switch (T->getTypeClass()) {
846 switch (cast<BuiltinType>(T)->
getKind()) {
847 case BuiltinType::Void:
850 case BuiltinType::NullPtr:
853 case BuiltinType::Overload:
854 case BuiltinType::Dependent:
857 case BuiltinType::ObjCId:
858 case BuiltinType::ObjCClass:
859 case BuiltinType::ObjCSel:
872 case Type::BlockPointer:
875 case Type::LValueReference:
876 case Type::RValueReference:
879 case Type::ConstantArray:
880 case Type::IncompleteArray:
881 case Type::VariableArray:
882 case Type::DependentSizedArray:
885 case Type::DependentSizedExtVector:
887 case Type::ExtVector:
890 case Type::FunctionProto:
891 case Type::FunctionNoProto:
900 case Type::ObjCObject:
901 case Type::ObjCInterface:
902 case Type::ObjCObjectPointer:
915 if (
const auto *
Type = dyn_cast<TypeDecl>(ND))
916 return C.getTypeDeclType(
Type);
917 if (
const auto *Iface = dyn_cast<ObjCInterfaceDecl>(ND))
918 return C.getObjCInterfaceType(Iface);
922 T = Function->getCallResultType();
923 else if (
const auto *Method = dyn_cast<ObjCMethodDecl>(ND))
924 T = Method->getSendResultType();
925 else if (
const auto *Enumerator = dyn_cast<EnumConstantDecl>(ND))
926 T =
C.getTypeDeclType(cast<EnumDecl>(Enumerator->getDeclContext()));
927 else if (
const auto *
Property = dyn_cast<ObjCPropertyDecl>(ND))
929 else if (
const auto *
Value = dyn_cast<ValueDecl>(ND))
930 T =
Value->getType();
945 if (
Pointer->getPointeeType()->isFunctionType()) {
954 T =
Block->getPointeeType();
959 T = Function->getReturnType();
969unsigned ResultBuilder::getBasePriority(
const NamedDecl *ND) {
977 if (
const auto *ImplicitParam = dyn_cast<ImplicitParamDecl>(ND))
978 if (ImplicitParam->getIdentifier() &&
979 ImplicitParam->getIdentifier()->isStr(
"_cmd"))
986 if (DC->
isRecord() || isa<ObjCContainerDecl>(DC)) {
988 if (isa<CXXDestructorDecl>(ND))
1000 if (isa<EnumConstantDecl>(ND))
1006 if ((isa<TypeDecl>(ND) || isa<ObjCInterfaceDecl>(ND)) &&
1008 CompletionContext.
getKind() ==
1010 CompletionContext.
getKind() ==
1017void ResultBuilder::AdjustResultPriorityForDecl(
Result &R) {
1020 if (!PreferredSelector.
isNull())
1021 if (
const auto *Method = dyn_cast<ObjCMethodDecl>(R.Declaration))
1022 if (PreferredSelector == Method->getSelector())
1027 if (!PreferredType.
isNull()) {
1037 !(PreferredType->isEnumeralType() && TC->isEnumeralType()))
1049 return Record->lookup(ConstructorName);
1052void ResultBuilder::MaybeAddConstructorResults(
Result R) {
1053 if (!SemaRef.
getLangOpts().CPlusPlus || !R.Declaration ||
1060 Record = ClassTemplate->getTemplatedDecl();
1061 else if ((Record = dyn_cast<CXXRecordDecl>(D))) {
1063 if (isa<ClassTemplateSpecializationDecl>(Record))
1075 R.Declaration = Ctor;
1077 Results.push_back(R);
1082 if (
const auto *Tmpl = dyn_cast<FunctionTemplateDecl>(ND))
1083 ND = Tmpl->getTemplatedDecl();
1084 return isa<CXXConstructorDecl>(ND);
1088 assert(!ShadowMaps.empty() &&
"Must enter into a results scope");
1090 if (R.Kind != Result::RK_Declaration) {
1092 Results.push_back(R);
1097 if (
const UsingShadowDecl *Using = dyn_cast<UsingShadowDecl>(R.Declaration)) {
1099 getBasePriority(
Using->getTargetDecl()),
1103 std::move(R.FixIts));
1105 MaybeAddResult(
Result, CurContext);
1112 bool AsNestedNameSpecifier =
false;
1113 if (!isInterestingDecl(R.Declaration, AsNestedNameSpecifier))
1120 ShadowMap &
SMap = ShadowMaps.back();
1121 ShadowMapEntry::iterator I, IEnd;
1122 ShadowMap::iterator NamePos =
SMap.find(R.Declaration->getDeclName());
1123 if (NamePos !=
SMap.end()) {
1124 I = NamePos->second.begin();
1125 IEnd = NamePos->second.end();
1128 for (; I != IEnd; ++I) {
1130 unsigned Index = I->second;
1133 Results[Index].Declaration = R.Declaration;
1143 std::list<ShadowMap>::iterator
SM, SMEnd = ShadowMaps.end();
1145 for (
SM = ShadowMaps.begin();
SM != SMEnd; ++
SM) {
1146 ShadowMapEntry::iterator I, IEnd;
1147 ShadowMap::iterator NamePos =
SM->find(R.Declaration->getDeclName());
1148 if (NamePos !=
SM->end()) {
1149 I = NamePos->second.begin();
1150 IEnd = NamePos->second.end();
1152 for (; I != IEnd; ++I) {
1154 if (I->first->hasTagIdentifierNamespace() &&
1162 I->first->getIdentifierNamespace() != IDNS)
1166 if (CheckHiddenResult(R, CurContext, I->first))
1174 if (!AllDeclsFound.insert(CanonDecl).second)
1179 if (AsNestedNameSpecifier) {
1180 R.StartsNestedNameSpecifier =
true;
1183 AdjustResultPriorityForDecl(R);
1186 if (R.QualifierIsInformative && !R.Qualifier &&
1187 !R.StartsNestedNameSpecifier) {
1188 const DeclContext *Ctx = R.Declaration->getDeclContext();
1189 if (
const NamespaceDecl *Namespace = dyn_cast<NamespaceDecl>(Ctx))
1192 else if (
const TagDecl *Tag = dyn_cast<TagDecl>(Ctx))
1194 SemaRef.
Context,
nullptr,
false,
1197 R.QualifierIsInformative =
false;
1202 SMap[R.Declaration->getDeclName()].Add(R.Declaration, Results.size());
1203 Results.push_back(R);
1205 if (!AsNestedNameSpecifier)
1206 MaybeAddConstructorResults(R);
1225 return OverloadCompare::BothViable;
1230 return OverloadCompare::BothViable;
1231 for (
unsigned I = 0, E = Candidate.
getNumParams(); I != E; ++I)
1232 if (Candidate.
parameters()[I]->getType().getCanonicalType() !=
1233 Incumbent.
parameters()[I]->getType().getCanonicalType())
1234 return OverloadCompare::BothViable;
1237 return OverloadCompare::BothViable;
1242 if (CandidateRef != IncumbentRef) {
1249 return CandidateRef ==
RQ_RValue ? OverloadCompare::Dominates
1250 : OverloadCompare::Dominated;
1258 if (CandidateSuperset == IncumbentSuperset)
1259 return OverloadCompare::BothViable;
1260 return IncumbentSuperset ? OverloadCompare::Dominates
1261 : OverloadCompare::Dominated;
1265 NamedDecl *Hiding,
bool InBaseClass =
false) {
1266 if (R.Kind != Result::RK_Declaration) {
1268 Results.push_back(R);
1273 if (
const auto *Using = dyn_cast<UsingShadowDecl>(R.Declaration)) {
1275 getBasePriority(
Using->getTargetDecl()),
1279 std::move(R.FixIts));
1281 AddResult(
Result, CurContext, Hiding);
1285 bool AsNestedNameSpecifier =
false;
1286 if (!isInterestingDecl(R.Declaration, AsNestedNameSpecifier))
1293 if (Hiding && CheckHiddenResult(R, CurContext, Hiding))
1297 if (!AllDeclsFound.insert(R.Declaration->getCanonicalDecl()).second)
1302 if (AsNestedNameSpecifier) {
1303 R.StartsNestedNameSpecifier =
true;
1305 }
else if (Filter == &ResultBuilder::IsMember && !R.Qualifier &&
1308 R.Declaration->getDeclContext()->getRedeclContext()))
1309 R.QualifierIsInformative =
true;
1312 if (R.QualifierIsInformative && !R.Qualifier &&
1313 !R.StartsNestedNameSpecifier) {
1314 const DeclContext *Ctx = R.Declaration->getDeclContext();
1315 if (
const auto *Namespace = dyn_cast<NamespaceDecl>(Ctx))
1318 else if (
const auto *Tag = dyn_cast<TagDecl>(Ctx))
1320 SemaRef.
Context,
nullptr,
false,
1323 R.QualifierIsInformative =
false;
1330 AdjustResultPriorityForDecl(R);
1332 if (HasObjectTypeQualifiers)
1333 if (
const auto *Method = dyn_cast<CXXMethodDecl>(R.Declaration))
1334 if (Method->isInstance()) {
1335 Qualifiers MethodQuals = Method->getMethodQualifiers();
1336 if (ObjectTypeQualifiers == MethodQuals)
1338 else if (ObjectTypeQualifiers - MethodQuals) {
1344 switch (Method->getRefQualifier()) {
1360 auto &OverloadSet = OverloadMap[std::make_pair(
1361 CurContext, Method->getDeclName().getAsOpaqueInteger())];
1362 for (
const DeclIndexPair Entry : OverloadSet) {
1363 Result &Incumbent = Results[Entry.second];
1365 *cast<CXXMethodDecl>(Incumbent.Declaration),
1366 ObjectTypeQualifiers, ObjectKind)) {
1367 case OverloadCompare::Dominates:
1371 Incumbent = std::move(R);
1373 case OverloadCompare::Dominated:
1376 case OverloadCompare::BothViable:
1380 OverloadSet.Add(Method, Results.size());
1387 const auto *Method = dyn_cast<CXXMethodDecl>(R.getDeclaration());
1388 if (Method && !Method->isStatic()) {
1392 const auto *CurrentClassScope = [&]() ->
const CXXRecordDecl * {
1395 const auto *CtxMethod = llvm::dyn_cast<CXXMethodDecl>(Ctx);
1396 if (CtxMethod && !CtxMethod->getParent()->isLambda()) {
1397 return CtxMethod->getParent();
1403 R.FunctionCanBeCall =
1404 CurrentClassScope &&
1405 (CurrentClassScope == Method->getParent() ||
1406 CurrentClassScope->isDerivedFrom(Method->getParent()));
1411 Results.push_back(R);
1413 if (!AsNestedNameSpecifier)
1414 MaybeAddConstructorResults(R);
1417void ResultBuilder::AddResult(
Result R) {
1418 assert(R.Kind != Result::RK_Declaration &&
1419 "Declaration results need more context");
1420 Results.push_back(R);
1424void ResultBuilder::EnterNewScope() { ShadowMaps.emplace_back(); }
1427void ResultBuilder::ExitScope() {
1428 ShadowMaps.pop_back();
1433bool ResultBuilder::IsOrdinaryName(
const NamedDecl *ND)
const {
1442 if (isa<ObjCIvarDecl>(ND))
1451bool ResultBuilder::IsOrdinaryNonTypeName(
const NamedDecl *ND)
const {
1453 if (isa<TypeDecl>(ND))
1458 if (
const auto *ID = dyn_cast<ObjCInterfaceDecl>(ND)) {
1459 if (!
ID->getDefinition())
1467 if (isa<ObjCIvarDecl>(ND))
1474bool ResultBuilder::IsIntegralConstantValue(
const NamedDecl *ND)
const {
1475 if (!IsOrdinaryNonTypeName(ND))
1479 if (VD->getType()->isIntegralOrEnumerationType())
1487bool ResultBuilder::IsOrdinaryNonValueName(
const NamedDecl *ND)
const {
1495 !isa<FunctionTemplateDecl>(ND) && !isa<ObjCPropertyDecl>(ND);
1500bool ResultBuilder::IsNestedNameSpecifier(
const NamedDecl *ND)
const {
1502 if (
const auto *ClassTemplate = dyn_cast<ClassTemplateDecl>(ND))
1503 ND = ClassTemplate->getTemplatedDecl();
1509bool ResultBuilder::IsEnum(
const NamedDecl *ND)
const {
1510 return isa<EnumDecl>(ND);
1514bool ResultBuilder::IsClassOrStruct(
const NamedDecl *ND)
const {
1516 if (
const auto *ClassTemplate = dyn_cast<ClassTemplateDecl>(ND))
1517 ND = ClassTemplate->getTemplatedDecl();
1520 if (
const auto *RD = dyn_cast<RecordDecl>(ND))
1528bool ResultBuilder::IsUnion(
const NamedDecl *ND)
const {
1530 if (
const auto *ClassTemplate = dyn_cast<ClassTemplateDecl>(ND))
1531 ND = ClassTemplate->getTemplatedDecl();
1533 if (
const auto *RD = dyn_cast<RecordDecl>(ND))
1540bool ResultBuilder::IsNamespace(
const NamedDecl *ND)
const {
1541 return isa<NamespaceDecl>(ND);
1546bool ResultBuilder::IsNamespaceOrAlias(
const NamedDecl *ND)
const {
1551bool ResultBuilder::IsType(
const NamedDecl *ND)
const {
1553 return isa<TypeDecl>(ND) || isa<ObjCInterfaceDecl>(ND);
1559bool ResultBuilder::IsMember(
const NamedDecl *ND)
const {
1561 return isa<ValueDecl>(ND) || isa<FunctionTemplateDecl>(ND) ||
1562 isa<ObjCPropertyDecl>(ND);
1566 T =
C.getCanonicalType(T);
1568 case Type::ObjCObject:
1569 case Type::ObjCInterface:
1570 case Type::ObjCObjectPointer:
1574 switch (cast<BuiltinType>(T)->
getKind()) {
1575 case BuiltinType::ObjCId:
1576 case BuiltinType::ObjCClass:
1577 case BuiltinType::ObjCSel:
1589 if (!
C.getLangOpts().CPlusPlus)
1598bool ResultBuilder::IsObjCMessageReceiver(
const NamedDecl *ND)
const {
1607bool ResultBuilder::IsObjCMessageReceiverOrLambdaCapture(
1609 if (IsObjCMessageReceiver(ND))
1612 const auto *Var = dyn_cast<VarDecl>(ND);
1616 return Var->hasLocalStorage() && !Var->hasAttr<BlocksAttr>();
1619bool ResultBuilder::IsObjCCollection(
const NamedDecl *ND)
const {
1620 if ((SemaRef.
getLangOpts().CPlusPlus && !IsOrdinaryName(ND)) ||
1621 (!SemaRef.
getLangOpts().CPlusPlus && !IsOrdinaryNonTypeName(ND)))
1634bool ResultBuilder::IsImpossibleToSatisfy(
const NamedDecl *ND)
const {
1640bool ResultBuilder::IsObjCIvar(
const NamedDecl *ND)
const {
1641 return isa<ObjCIvarDecl>(ND);
1649 ResultBuilder &Results;
1655 std::vector<FixItHint> FixIts;
1658 CodeCompletionDeclConsumer(
1659 ResultBuilder &Results,
DeclContext *InitialLookupCtx,
1661 std::vector<FixItHint> FixIts = std::vector<FixItHint>())
1662 : Results(Results), InitialLookupCtx(InitialLookupCtx),
1663 FixIts(
std::move(FixIts)) {
1664 NamingClass = llvm::dyn_cast<CXXRecordDecl>(InitialLookupCtx);
1667 auto ThisType = Results.getSema().getCurrentThisType();
1668 if (!ThisType.isNull()) {
1669 assert(ThisType->isPointerType());
1675 this->BaseType = BaseType;
1679 bool InBaseClass)
override {
1682 Results.AddResult(Result, InitialLookupCtx, Hiding, InBaseClass);
1686 Results.addVisitedContext(Ctx);
1695 auto *NamingClass = this->NamingClass;
1696 QualType BaseType = this->BaseType;
1697 if (
auto *Cls = llvm::dyn_cast_or_null<CXXRecordDecl>(Ctx)) {
1712 NamingClass =
nullptr;
1715 return Results.getSema().IsSimplyAccessible(ND, NamingClass, BaseType);
1722 ResultBuilder &Results) {
1748 Results.getCodeCompletionTUInfo());
1749 if (LangOpts.CPlusPlus) {
1757 Builder.AddTypedTextChunk(
"typename");
1759 Builder.AddPlaceholderChunk(
"name");
1760 Results.AddResult(
Result(Builder.TakeString()));
1762 if (LangOpts.CPlusPlus11) {
1767 Builder.AddTypedTextChunk(
"decltype");
1769 Builder.AddPlaceholderChunk(
"expression");
1771 Results.AddResult(
Result(Builder.TakeString()));
1777 if (LangOpts.GNUKeywords) {
1783 Builder.AddTypedTextChunk(
"typeof");
1785 Builder.AddPlaceholderChunk(
"expression");
1786 Results.AddResult(
Result(Builder.TakeString()));
1788 Builder.AddTypedTextChunk(
"typeof");
1790 Builder.AddPlaceholderChunk(
"type");
1792 Results.AddResult(
Result(Builder.TakeString()));
1803 ResultBuilder &Results) {
1808 Results.AddResult(
Result(
"extern"));
1809 Results.AddResult(
Result(
"static"));
1811 if (LangOpts.CPlusPlus11) {
1816 Builder.AddTypedTextChunk(
"alignas");
1818 Builder.AddPlaceholderChunk(
"expression");
1820 Results.AddResult(
Result(Builder.TakeString()));
1822 Results.AddResult(
Result(
"constexpr"));
1823 Results.AddResult(
Result(
"thread_local"));
1829 ResultBuilder &Results) {
1834 if (LangOpts.CPlusPlus) {
1835 Results.AddResult(
Result(
"explicit"));
1836 Results.AddResult(
Result(
"friend"));
1837 Results.AddResult(
Result(
"mutable"));
1838 Results.AddResult(
Result(
"virtual"));
1846 if (LangOpts.CPlusPlus || LangOpts.C99)
1847 Results.AddResult(
Result(
"inline"));
1866 ResultBuilder &Results,
bool NeedAt);
1868 ResultBuilder &Results,
bool NeedAt);
1870 ResultBuilder &Results,
bool NeedAt);
1875 Results.getCodeCompletionTUInfo());
1876 Builder.AddTypedTextChunk(
"typedef");
1878 Builder.AddPlaceholderChunk(
"type");
1880 Builder.AddPlaceholderChunk(
"name");
1887 ResultBuilder &Results) {
1888 Builder.AddTypedTextChunk(
"using");
1890 Builder.AddPlaceholderChunk(
"name");
1892 Builder.AddPlaceholderChunk(
"type");
1914 return LangOpts.CPlusPlus;
1921 return LangOpts.CPlusPlus || LangOpts.ObjC || LangOpts.C99;
1924 llvm_unreachable(
"Invalid ParserCompletionContext!");
1953 if (
const BuiltinType *BT = dyn_cast<BuiltinType>(T))
1954 return BT->getNameAsCString(Policy);
1957 if (
const TagType *TagT = dyn_cast<TagType>(T))
1958 if (
TagDecl *Tag = TagT->getDecl())
1959 if (!Tag->hasNameForLinkage()) {
1960 switch (Tag->getTagKind()) {
1962 return "struct <anonymous>";
1964 return "__interface <anonymous>";
1966 return "class <anonymous>";
1968 return "union <anonymous>";
1970 return "enum <anonymous>";
1978 return Allocator.CopyString(
Result);
1990 Builder.AddResultTypeChunk(
1992 Builder.AddTypedTextChunk(
"this");
1997 ResultBuilder &Results,
1999 if (!LangOpts.CPlusPlus11)
2002 Builder.AddTypedTextChunk(
"static_assert");
2004 Builder.AddPlaceholderChunk(
"expression");
2006 Builder.AddPlaceholderChunk(
"message");
2015 Sema &S = Results.getSema();
2016 const auto *CR = llvm::dyn_cast<CXXRecordDecl>(S.
CurContext);
2022 llvm::StringMap<std::vector<FunctionDecl *>> Overrides;
2023 for (
auto *Method : CR->methods()) {
2024 if (!Method->isVirtual() || !Method->getIdentifier())
2026 Overrides[Method->getName()].push_back(Method);
2029 for (
const auto &
Base : CR->bases()) {
2030 const auto *BR =
Base.getType().getTypePtr()->getAsCXXRecordDecl();
2033 for (
auto *Method : BR->methods()) {
2034 if (!Method->isVirtual() || !Method->getIdentifier())
2036 const auto it = Overrides.find(Method->getName());
2037 bool IsOverriden =
false;
2038 if (it != Overrides.end()) {
2039 for (
auto *MD : it->second) {
2052 std::string OverrideSignature;
2053 llvm::raw_string_ostream OS(OverrideSignature);
2059 false, CCContext, Policy);
2068 Sema &SemaRef, ResultBuilder &Results) {
2076 if (Results.includeCodePatterns()) {
2078 Builder.AddTypedTextChunk(
"namespace");
2080 Builder.AddPlaceholderChunk(
"identifier");
2084 Builder.AddPlaceholderChunk(
"declarations");
2087 Results.AddResult(
Result(Builder.TakeString()));
2091 Builder.AddTypedTextChunk(
"namespace");
2093 Builder.AddPlaceholderChunk(
"name");
2095 Builder.AddPlaceholderChunk(
"namespace");
2097 Results.AddResult(
Result(Builder.TakeString()));
2100 Builder.AddTypedTextChunk(
"using namespace");
2102 Builder.AddPlaceholderChunk(
"identifier");
2104 Results.AddResult(
Result(Builder.TakeString()));
2107 Builder.AddTypedTextChunk(
"asm");
2109 Builder.AddPlaceholderChunk(
"string-literal");
2111 Results.AddResult(
Result(Builder.TakeString()));
2113 if (Results.includeCodePatterns()) {
2115 Builder.AddTypedTextChunk(
"template");
2117 Builder.AddPlaceholderChunk(
"declaration");
2118 Results.AddResult(
Result(Builder.TakeString()));
2133 Builder.AddTypedTextChunk(
"using");
2135 Builder.AddPlaceholderChunk(
"qualifier");
2136 Builder.AddTextChunk(
"::");
2137 Builder.AddPlaceholderChunk(
"name");
2139 Results.AddResult(
Result(Builder.TakeString()));
2146 Builder.AddTypedTextChunk(
"using typename");
2148 Builder.AddPlaceholderChunk(
"qualifier");
2149 Builder.AddTextChunk(
"::");
2150 Builder.AddPlaceholderChunk(
"name");
2152 Results.AddResult(
Result(Builder.TakeString()));
2160 bool IsNotInheritanceScope = !S->isClassInheritanceScope();
2162 Builder.AddTypedTextChunk(
"public");
2163 if (IsNotInheritanceScope && Results.includeCodePatterns())
2165 Results.AddResult(
Result(Builder.TakeString()));
2168 Builder.AddTypedTextChunk(
"protected");
2169 if (IsNotInheritanceScope && Results.includeCodePatterns())
2171 Results.AddResult(
Result(Builder.TakeString()));
2174 Builder.AddTypedTextChunk(
"private");
2175 if (IsNotInheritanceScope && Results.includeCodePatterns())
2177 Results.AddResult(
Result(Builder.TakeString()));
2190 if (SemaRef.
getLangOpts().CPlusPlus && Results.includeCodePatterns()) {
2192 Builder.AddTypedTextChunk(
"template");
2194 Builder.AddPlaceholderChunk(
"parameters");
2196 Results.AddResult(
Result(Builder.TakeString()));
2228 if (SemaRef.
getLangOpts().CPlusPlus && Results.includeCodePatterns() &&
2230 Builder.AddTypedTextChunk(
"try");
2234 Builder.AddPlaceholderChunk(
"statements");
2238 Builder.AddTextChunk(
"catch");
2241 Builder.AddPlaceholderChunk(
"declaration");
2246 Builder.AddPlaceholderChunk(
"statements");
2249 Results.AddResult(
Result(Builder.TakeString()));
2254 if (Results.includeCodePatterns()) {
2256 Builder.AddTypedTextChunk(
"if");
2260 Builder.AddPlaceholderChunk(
"condition");
2262 Builder.AddPlaceholderChunk(
"expression");
2267 Builder.AddPlaceholderChunk(
"statements");
2270 Results.AddResult(
Result(Builder.TakeString()));
2273 Builder.AddTypedTextChunk(
"switch");
2277 Builder.AddPlaceholderChunk(
"condition");
2279 Builder.AddPlaceholderChunk(
"expression");
2284 Builder.AddPlaceholderChunk(
"cases");
2287 Results.AddResult(
Result(Builder.TakeString()));
2294 Builder.AddTypedTextChunk(
"case");
2296 Builder.AddPlaceholderChunk(
"expression");
2298 Results.AddResult(
Result(Builder.TakeString()));
2301 Builder.AddTypedTextChunk(
"default");
2303 Results.AddResult(
Result(Builder.TakeString()));
2306 if (Results.includeCodePatterns()) {
2308 Builder.AddTypedTextChunk(
"while");
2312 Builder.AddPlaceholderChunk(
"condition");
2314 Builder.AddPlaceholderChunk(
"expression");
2319 Builder.AddPlaceholderChunk(
"statements");
2322 Results.AddResult(
Result(Builder.TakeString()));
2325 Builder.AddTypedTextChunk(
"do");
2329 Builder.AddPlaceholderChunk(
"statements");
2332 Builder.AddTextChunk(
"while");
2335 Builder.AddPlaceholderChunk(
"expression");
2337 Results.AddResult(
Result(Builder.TakeString()));
2340 Builder.AddTypedTextChunk(
"for");
2344 Builder.AddPlaceholderChunk(
"init-statement");
2346 Builder.AddPlaceholderChunk(
"init-expression");
2349 Builder.AddPlaceholderChunk(
"condition");
2352 Builder.AddPlaceholderChunk(
"inc-expression");
2357 Builder.AddPlaceholderChunk(
"statements");
2360 Results.AddResult(
Result(Builder.TakeString()));
2364 Builder.AddTypedTextChunk(
"for");
2367 Builder.AddPlaceholderChunk(
"range-declaration");
2370 Builder.AddTextChunk(
"in");
2374 Builder.AddPlaceholderChunk(
"range-expression");
2379 Builder.AddPlaceholderChunk(
"statements");
2382 Results.AddResult(
Result(Builder.TakeString()));
2386 if (S->getContinueParent()) {
2388 Builder.AddTypedTextChunk(
"continue");
2390 Results.AddResult(
Result(Builder.TakeString()));
2393 if (S->getBreakParent()) {
2395 Builder.AddTypedTextChunk(
"break");
2397 Results.AddResult(
Result(Builder.TakeString()));
2402 if (
const auto *Function = dyn_cast<FunctionDecl>(SemaRef.
CurContext))
2403 ReturnType = Function->getReturnType();
2404 else if (
const auto *Method = dyn_cast<ObjCMethodDecl>(SemaRef.
CurContext))
2405 ReturnType = Method->getReturnType();
2410 Builder.AddTypedTextChunk(
"return");
2412 Results.AddResult(
Result(Builder.TakeString()));
2414 assert(!ReturnType.
isNull());
2416 Builder.AddTypedTextChunk(
"return");
2418 Builder.AddPlaceholderChunk(
"expression");
2420 Results.AddResult(
Result(Builder.TakeString()));
2423 Builder.AddTypedTextChunk(
"return true");
2425 Results.AddResult(
Result(Builder.TakeString()));
2427 Builder.AddTypedTextChunk(
"return false");
2429 Results.AddResult(
Result(Builder.TakeString()));
2434 Builder.AddTypedTextChunk(
"return nullptr");
2436 Results.AddResult(
Result(Builder.TakeString()));
2441 Builder.AddTypedTextChunk(
"goto");
2443 Builder.AddPlaceholderChunk(
"label");
2445 Results.AddResult(
Result(Builder.TakeString()));
2448 Builder.AddTypedTextChunk(
"using namespace");
2450 Builder.AddPlaceholderChunk(
"identifier");
2452 Results.AddResult(
Result(Builder.TakeString()));
2469 Builder.AddTypedTextChunk(
"__bridge");
2471 Builder.AddPlaceholderChunk(
"type");
2473 Builder.AddPlaceholderChunk(
"expression");
2474 Results.AddResult(
Result(Builder.TakeString()));
2477 Builder.AddTypedTextChunk(
"__bridge_transfer");
2479 Builder.AddPlaceholderChunk(
"Objective-C type");
2481 Builder.AddPlaceholderChunk(
"expression");
2482 Results.AddResult(
Result(Builder.TakeString()));
2485 Builder.AddTypedTextChunk(
"__bridge_retained");
2487 Builder.AddPlaceholderChunk(
"CF type");
2489 Builder.AddPlaceholderChunk(
"expression");
2490 Results.AddResult(
Result(Builder.TakeString()));
2501 Builder.AddResultTypeChunk(
"bool");
2502 Builder.AddTypedTextChunk(
"true");
2503 Results.AddResult(
Result(Builder.TakeString()));
2506 Builder.AddResultTypeChunk(
"bool");
2507 Builder.AddTypedTextChunk(
"false");
2508 Results.AddResult(
Result(Builder.TakeString()));
2512 Builder.AddTypedTextChunk(
"dynamic_cast");
2514 Builder.AddPlaceholderChunk(
"type");
2517 Builder.AddPlaceholderChunk(
"expression");
2519 Results.AddResult(
Result(Builder.TakeString()));
2523 Builder.AddTypedTextChunk(
"static_cast");
2525 Builder.AddPlaceholderChunk(
"type");
2528 Builder.AddPlaceholderChunk(
"expression");
2530 Results.AddResult(
Result(Builder.TakeString()));
2533 Builder.AddTypedTextChunk(
"reinterpret_cast");
2535 Builder.AddPlaceholderChunk(
"type");
2538 Builder.AddPlaceholderChunk(
"expression");
2540 Results.AddResult(
Result(Builder.TakeString()));
2543 Builder.AddTypedTextChunk(
"const_cast");
2545 Builder.AddPlaceholderChunk(
"type");
2548 Builder.AddPlaceholderChunk(
"expression");
2550 Results.AddResult(
Result(Builder.TakeString()));
2554 Builder.AddResultTypeChunk(
"std::type_info");
2555 Builder.AddTypedTextChunk(
"typeid");
2557 Builder.AddPlaceholderChunk(
"expression-or-type");
2559 Results.AddResult(
Result(Builder.TakeString()));
2563 Builder.AddTypedTextChunk(
"new");
2565 Builder.AddPlaceholderChunk(
"type");
2567 Builder.AddPlaceholderChunk(
"expressions");
2569 Results.AddResult(
Result(Builder.TakeString()));
2572 Builder.AddTypedTextChunk(
"new");
2574 Builder.AddPlaceholderChunk(
"type");
2576 Builder.AddPlaceholderChunk(
"size");
2579 Builder.AddPlaceholderChunk(
"expressions");
2581 Results.AddResult(
Result(Builder.TakeString()));
2584 Builder.AddResultTypeChunk(
"void");
2585 Builder.AddTypedTextChunk(
"delete");
2587 Builder.AddPlaceholderChunk(
"expression");
2588 Results.AddResult(
Result(Builder.TakeString()));
2591 Builder.AddResultTypeChunk(
"void");
2592 Builder.AddTypedTextChunk(
"delete");
2597 Builder.AddPlaceholderChunk(
"expression");
2598 Results.AddResult(
Result(Builder.TakeString()));
2602 Builder.AddResultTypeChunk(
"void");
2603 Builder.AddTypedTextChunk(
"throw");
2605 Builder.AddPlaceholderChunk(
"expression");
2606 Results.AddResult(
Result(Builder.TakeString()));
2613 Builder.AddResultTypeChunk(
"std::nullptr_t");
2614 Builder.AddTypedTextChunk(
"nullptr");
2615 Results.AddResult(
Result(Builder.TakeString()));
2618 Builder.AddResultTypeChunk(
"size_t");
2619 Builder.AddTypedTextChunk(
"alignof");
2621 Builder.AddPlaceholderChunk(
"type");
2623 Results.AddResult(
Result(Builder.TakeString()));
2626 Builder.AddResultTypeChunk(
"bool");
2627 Builder.AddTypedTextChunk(
"noexcept");
2629 Builder.AddPlaceholderChunk(
"expression");
2631 Results.AddResult(
Result(Builder.TakeString()));
2634 Builder.AddResultTypeChunk(
"size_t");
2635 Builder.AddTypedTextChunk(
"sizeof...");
2637 Builder.AddPlaceholderChunk(
"parameter-pack");
2639 Results.AddResult(
Result(Builder.TakeString()));
2648 if (ID->getSuperClass()) {
2649 std::string SuperType;
2650 SuperType = ID->getSuperClass()->getNameAsString();
2651 if (Method->isInstanceMethod())
2654 Builder.AddResultTypeChunk(Allocator.CopyString(SuperType));
2655 Builder.AddTypedTextChunk(
"super");
2656 Results.AddResult(
Result(Builder.TakeString()));
2665 Builder.AddResultTypeChunk(
"size_t");
2667 Builder.AddTypedTextChunk(
"alignof");
2669 Builder.AddTypedTextChunk(
"_Alignof");
2671 Builder.AddPlaceholderChunk(
"type");
2673 Results.AddResult(
Result(Builder.TakeString()));
2678 Builder.AddResultTypeChunk(
"nullptr_t");
2679 Builder.AddTypedTextChunk(
"nullptr");
2680 Results.AddResult(
Result(Builder.TakeString()));
2684 Builder.AddResultTypeChunk(
"size_t");
2685 Builder.AddTypedTextChunk(
"sizeof");
2687 Builder.AddPlaceholderChunk(
"expression-or-type");
2689 Results.AddResult(
Result(Builder.TakeString()));
2702 Results.AddResult(
Result(
"operator"));
2722 T = Function->getReturnType();
2723 else if (
const auto *Method = dyn_cast<ObjCMethodDecl>(ND)) {
2725 T = Method->getSendResultType(BaseType);
2727 T = Method->getReturnType();
2728 }
else if (
const auto *Enumerator = dyn_cast<EnumConstantDecl>(ND)) {
2729 T = Context.
getTypeDeclType(cast<TypeDecl>(Enumerator->getDeclContext()));
2731 }
else if (isa<UnresolvedUsingValueDecl>(ND)) {
2733 }
else if (
const auto *Ivar = dyn_cast<ObjCIvarDecl>(ND)) {
2735 T = Ivar->getUsageType(BaseType);
2737 T = Ivar->getType();
2738 }
else if (
const auto *
Value = dyn_cast<ValueDecl>(ND)) {
2739 T =
Value->getType();
2740 }
else if (
const auto *
Property = dyn_cast<ObjCPropertyDecl>(ND)) {
2742 T =
Property->getUsageType(BaseType);
2750 Result.AddResultTypeChunk(
2757 if (SentinelAttr *Sentinel = FunctionOrMethod->
getAttr<SentinelAttr>())
2758 if (Sentinel->getSentinel() == 0) {
2760 Result.AddTextChunk(
", nil");
2762 Result.AddTextChunk(
", NULL");
2764 Result.AddTextChunk(
", (void*)0");
2785 switch (*nullability) {
2795 Result +=
"null_unspecified ";
2799 llvm_unreachable(
"Not supported as a context-sensitive keyword!");
2816 bool SuppressBlock =
false) {
2822 if (!SuppressBlock) {
2825 TypedefTL.getTypedefNameDecl()->getTypeSourceInfo()) {
2838 TL = AttrTL.getModifiedLoc();
2857 bool SuppressBlockName =
false,
bool SuppressBlock =
false,
2862 bool SuppressName =
false,
bool SuppressBlock =
false,
2870 if (
const auto *PVD = dyn_cast<ParmVarDecl>(Param))
2871 ObjCQual = PVD->getObjCDeclQualifier();
2872 bool ObjCMethodParam = isa<ObjCMethodDecl>(Param->
getDeclContext());
2879 if (Param->
getIdentifier() && !ObjCMethodParam && !SuppressName)
2886 if (ObjCMethodParam) {
2905 if (!
Block && ObjCMethodParam &&
2906 cast<ObjCMethodDecl>(Param->
getDeclContext())->isPropertyAccessor()) {
2907 if (
const auto *PD = cast<ObjCMethodDecl>(Param->
getDeclContext())
2908 ->findPropertyDecl(
false))
2922 if (ObjCMethodParam) {
2927 if (
Result.back() !=
')')
2941 false, SuppressBlock,
2957 bool SuppressBlockName,
bool SuppressBlock,
2965 if (!ResultType->
isVoidType() || SuppressBlock)
2970 if (!BlockProto ||
Block.getNumParams() == 0) {
2977 for (
unsigned I = 0, N =
Block.getNumParams(); I != N; ++I) {
2990 if (SuppressBlock) {
2993 if (!SuppressBlockName &&
BlockDecl->getIdentifier())
3002 if (!SuppressBlockName &&
BlockDecl->getIdentifier())
3022 if (srcText.empty() || srcText ==
"=") {
3028 std::string DefValue(srcText.str());
3031 if (DefValue.at(0) !=
'=') {
3035 return " = " + DefValue;
3037 return " " + DefValue;
3046 bool InOptional =
false) {
3047 bool FirstParameter =
true;
3049 for (
unsigned P = Start, N = Function->getNumParams();
P != N; ++
P) {
3056 Result.getCodeCompletionTUInfo());
3057 if (!FirstParameter)
3065 FirstParameter =
false;
3077 if (Function->isVariadic() &&
P == N - 1)
3078 PlaceholderStr +=
", ...";
3081 Result.AddPlaceholderChunk(
3082 Result.getAllocator().CopyString(PlaceholderStr));
3086 if (Proto->isVariadic()) {
3087 if (Proto->getNumParams() == 0)
3088 Result.AddPlaceholderChunk(
"...");
3098 unsigned MaxParameters = 0,
unsigned Start = 0,
bool InDefaultArg =
false) {
3099 bool FirstParameter =
true;
3108 PEnd = Params->
begin() + MaxParameters;
3111 bool HasDefaultArg =
false;
3112 std::string PlaceholderStr;
3114 if (TTP->wasDeclaredWithTypename())
3115 PlaceholderStr =
"typename";
3116 else if (
const auto *TC = TTP->getTypeConstraint()) {
3117 llvm::raw_string_ostream OS(PlaceholderStr);
3118 TC->print(OS, Policy);
3121 PlaceholderStr =
"class";
3123 if (TTP->getIdentifier()) {
3124 PlaceholderStr +=
' ';
3125 PlaceholderStr += TTP->getIdentifier()->deuglifiedName();
3128 HasDefaultArg = TTP->hasDefaultArgument();
3130 dyn_cast<NonTypeTemplateParmDecl>(*
P)) {
3131 if (NTTP->getIdentifier())
3132 PlaceholderStr = std::string(NTTP->getIdentifier()->deuglifiedName());
3133 NTTP->getType().getAsStringInternal(PlaceholderStr, Policy);
3134 HasDefaultArg = NTTP->hasDefaultArgument();
3136 assert(isa<TemplateTemplateParmDecl>(*
P));
3141 PlaceholderStr =
"template<...> class";
3143 PlaceholderStr +=
' ';
3150 if (HasDefaultArg && !InDefaultArg) {
3154 Result.getCodeCompletionTUInfo());
3155 if (!FirstParameter)
3158 P - Params->
begin(),
true);
3163 InDefaultArg =
false;
3166 FirstParameter =
false;
3171 Result.AddPlaceholderChunk(
3172 Result.getAllocator().CopyString(PlaceholderStr));
3180 bool QualifierIsInformative,
3186 std::string PrintedNNS;
3188 llvm::raw_string_ostream OS(PrintedNNS);
3189 Qualifier->print(OS, Policy);
3191 if (QualifierIsInformative)
3192 Result.AddInformativeChunk(
Result.getAllocator().CopyString(PrintedNNS));
3194 Result.AddTextChunk(
Result.getAllocator().CopyString(PrintedNNS));
3201 if (!Proto || !Proto->getMethodQuals())
3207 if (Proto->getMethodQuals().hasOnlyConst()) {
3208 Result.AddInformativeChunk(
" const");
3212 if (Proto->getMethodQuals().hasOnlyVolatile()) {
3213 Result.AddInformativeChunk(
" volatile");
3217 if (Proto->getMethodQuals().hasOnlyRestrict()) {
3218 Result.AddInformativeChunk(
" restrict");
3223 std::string QualsStr;
3224 if (Proto->isConst())
3225 QualsStr +=
" const";
3226 if (Proto->isVolatile())
3227 QualsStr +=
" volatile";
3228 if (Proto->isRestrict())
3229 QualsStr +=
" restrict";
3230 Result.AddInformativeChunk(
Result.getAllocator().CopyString(QualsStr));
3241 switch (Name.getNameKind()) {
3243 const char *OperatorName =
nullptr;
3244 switch (Name.getCXXOverloadedOperator()) {
3246 case OO_Conditional:
3248 OperatorName =
"operator";
3251#define OVERLOADED_OPERATOR(Name, Spelling, Token, Unary, Binary, MemberOnly) \
3253 OperatorName = "operator" Spelling; \
3255#define OVERLOADED_OPERATOR_MULTI(Name, Spelling, Unary, Binary, MemberOnly)
3256#include "clang/Basic/OperatorKinds.def"
3259 OperatorName =
"operator new";
3262 OperatorName =
"operator delete";
3265 OperatorName =
"operator new[]";
3267 case OO_Array_Delete:
3268 OperatorName =
"operator delete[]";
3271 OperatorName =
"operator()";
3274 OperatorName =
"operator[]";
3277 Result.AddTypedTextChunk(OperatorName);
3285 Result.AddTypedTextChunk(
3298 QualType Ty = Name.getCXXNameType();
3300 Record = cast<CXXRecordDecl>(RecordTy->getDecl());
3302 Record = InjectedTy->getDecl();
3304 Result.AddTypedTextChunk(
3309 Result.AddTypedTextChunk(
3310 Result.getAllocator().CopyString(Record->getNameAsString()));
3324 bool IncludeBriefComments) {
3326 CCTUInfo, IncludeBriefComments);
3338 return Result.TakeString();
3349 Result.AddPlaceholderChunk(
"...");
3363 Result.AddPlaceholderChunk(
Result.getAllocator().CopyString(Arg));
3368 Result.AddPlaceholderChunk(
3369 Result.getAllocator().CopyString((*A)->getName()));
3372 return Result.TakeString();
3384 bool IncludeBriefComments) {
3400 Result.addBriefComment(RC->getBriefText(Ctx));
3410 return Result.TakeString();
3414 PP, Ctx,
Result, IncludeBriefComments, CCContext, Policy);
3418 std::string &BeforeName,
3419 std::string &NameAndSignature) {
3420 bool SeenTypedChunk =
false;
3421 for (
auto &Chunk : CCS) {
3423 assert(SeenTypedChunk &&
"optional parameter before name");
3430 NameAndSignature += Chunk.Text;
3432 BeforeName += Chunk.Text;
3444 std::string BeforeName;
3445 std::string NameAndSignature;
3448 NameAndSignature +=
" override";
3450 Result.AddTextChunk(
Result.getAllocator().CopyString(BeforeName));
3452 Result.AddTypedTextChunk(
Result.getAllocator().CopyString(NameAndSignature));
3453 return Result.TakeString();
3459 const auto *VD = dyn_cast<VarDecl>(ND);
3462 const auto *
RecordDecl = VD->getType()->getAsCXXRecordDecl();
3475 if (IncludeBriefComments) {
3478 Result.addBriefComment(RC->getBriefText(Ctx));
3483 Result.AddTypedTextChunk(
3485 Result.AddTextChunk(
"::");
3486 return Result.TakeString();
3490 Result.AddAnnotation(
Result.getAllocator().CopyString(I->getAnnotation()));
3492 auto AddFunctionTypeAndResult = [&](
const FunctionDecl *Function) {
3503 if (
const auto *Function = dyn_cast<FunctionDecl>(ND)) {
3504 AddFunctionTypeAndResult(Function);
3505 return Result.TakeString();
3508 if (
const auto *CallOperator =
3510 AddFunctionTypeAndResult(CallOperator);
3511 return Result.TakeString();
3517 dyn_cast<FunctionTemplateDecl>(ND)) {
3525 llvm::SmallBitVector Deduced;
3527 unsigned LastDeducibleArgument;
3528 for (LastDeducibleArgument = Deduced.size(); LastDeducibleArgument > 0;
3529 --LastDeducibleArgument) {
3530 if (!Deduced[LastDeducibleArgument - 1]) {
3534 bool HasDefaultArg =
false;
3535 NamedDecl *Param = FunTmpl->getTemplateParameters()->getParam(
3536 LastDeducibleArgument - 1);
3538 HasDefaultArg = TTP->hasDefaultArgument();
3540 dyn_cast<NonTypeTemplateParmDecl>(Param))
3541 HasDefaultArg = NTTP->hasDefaultArgument();
3543 assert(isa<TemplateTemplateParmDecl>(Param));
3545 cast<TemplateTemplateParmDecl>(Param)->hasDefaultArgument();
3553 if (LastDeducibleArgument) {
3559 LastDeducibleArgument);
3568 return Result.TakeString();
3571 if (
const auto *Template = dyn_cast<TemplateDecl>(ND)) {
3574 Result.AddTypedTextChunk(
3575 Result.getAllocator().CopyString(Template->getNameAsString()));
3579 return Result.TakeString();
3582 if (
const auto *Method = dyn_cast<ObjCMethodDecl>(ND)) {
3583 Selector Sel = Method->getSelector();
3585 Result.AddTypedTextChunk(
3587 return Result.TakeString();
3593 Result.AddTypedTextChunk(
Result.getAllocator().CopyString(SelName));
3595 Result.AddInformativeChunk(
Result.getAllocator().CopyString(SelName));
3599 if (Method->param_size() == 1)
3600 Result.AddTypedTextChunk(
"");
3606 PEnd = Method->param_end();
3607 P != PEnd && Idx < Sel.
getNumArgs(); (
void)++
P, ++Idx) {
3626 QualType ParamType = (*P)->getType();
3627 std::optional<ArrayRef<QualType>> ObjCSubsts;
3643 Arg += II->getName();
3646 if (Method->isVariadic() && (
P + 1) == PEnd)
3650 Result.AddTextChunk(
Result.getAllocator().CopyString(Arg));
3652 Result.AddInformativeChunk(
Result.getAllocator().CopyString(Arg));
3654 Result.AddPlaceholderChunk(
Result.getAllocator().CopyString(Arg));
3657 if (Method->isVariadic()) {
3658 if (Method->param_size() == 0) {
3660 Result.AddTextChunk(
", ...");
3662 Result.AddInformativeChunk(
", ...");
3664 Result.AddPlaceholderChunk(
", ...");
3670 return Result.TakeString();
3677 Result.AddTypedTextChunk(
3679 return Result.TakeString();
3690 const auto *M = dyn_cast<ObjCMethodDecl>(ND);
3702 const auto *M = dyn_cast_or_null<ObjCMethodDecl>(ND);
3703 if (!M || !M->isPropertyAccessor())
3726 auto FDecl =
Result.getFunction();
3729 if (ArgIndex < FDecl->getNumParams())
3737 unsigned CurrentArg) {
3738 unsigned ChunkIndex = 0;
3739 auto AddChunk = [&](llvm::StringRef Placeholder) {
3742 const char *Copy =
Result.getAllocator().CopyString(Placeholder);
3743 if (ChunkIndex == CurrentArg)
3744 Result.AddCurrentParameterChunk(Copy);
3746 Result.AddPlaceholderChunk(Copy);
3751 if (
auto *CRD = llvm::dyn_cast<CXXRecordDecl>(RD)) {
3752 for (
const auto &
Base : CRD->bases())
3753 AddChunk(
Base.getType().getAsString(Policy));
3755 for (
const auto &Field : RD->
fields())
3765 unsigned CurrentArg,
unsigned Start = 0,
bool InOptional =
false) {
3771 bool FirstParameter =
true;
3772 unsigned NumParams =
3773 Function ? Function->getNumParams() :
Prototype->getNumParams();
3775 for (
unsigned P = Start;
P != NumParams; ++
P) {
3776 if (Function && Function->getParamDecl(
P)->hasDefaultArg() && !InOptional) {
3780 Result.getCodeCompletionTUInfo());
3781 if (!FirstParameter)
3785 PrototypeLoc, Opt, CurrentArg,
P,
3792 FirstParameter =
false;
3799 std::string Placeholder;
3800 assert(P < Prototype->getNumParams());
3801 if (Function || PrototypeLoc) {
3803 Function ? Function->getParamDecl(
P) : PrototypeLoc.
getParam(
P);
3809 Placeholder =
Prototype->getParamType(
P).getAsString(Policy);
3812 if (
P == CurrentArg)
3813 Result.AddCurrentParameterChunk(
3814 Result.getAllocator().CopyString(Placeholder));
3816 Result.AddPlaceholderChunk(
Result.getAllocator().CopyString(Placeholder));
3821 Result.getCodeCompletionTUInfo());
3822 if (!FirstParameter)
3825 if (CurrentArg < NumParams)
3837 if (
const auto *
Type = dyn_cast<TemplateTypeParmDecl>(Param)) {
3838 Optional =
Type->hasDefaultArgument();
3839 }
else if (
const auto *NonType = dyn_cast<NonTypeTemplateParmDecl>(Param)) {
3840 Optional = NonType->hasDefaultArgument();
3841 }
else if (
const auto *Template = dyn_cast<TemplateTemplateParmDecl>(Param)) {
3842 Optional = Template->hasDefaultArgument();
3845 llvm::raw_string_ostream OS(
Result);
3846 Param->
print(OS, Policy);
3852 if (
const auto *CTD = dyn_cast<ClassTemplateDecl>(TD))
3853 return CTD->getTemplatedDecl()->getKindName().str();
3854 if (
const auto *VTD = dyn_cast<VarTemplateDecl>(TD))
3855 return VTD->getTemplatedDecl()->getType().getAsString(Policy);
3856 if (
const auto *FTD = dyn_cast<FunctionTemplateDecl>(TD))
3857 return FTD->getTemplatedDecl()->getReturnType().getAsString(Policy);
3858 if (isa<TypeAliasTemplateDecl>(TD))
3860 if (isa<TemplateTemplateParmDecl>(TD))
3862 if (isa<ConceptDecl>(TD))
3872 Builder.getCodeCompletionTUInfo());
3874 if (!ResultType.empty())
3875 Builder.AddResultTypeChunk(Builder.getAllocator().CopyString(ResultType));
3876 Builder.AddTextChunk(
3882 for (
unsigned I = 0; I < Params.size(); ++I) {
3883 bool Optional =
false;
3884 std::string Placeholder =
3887 Current = &OptionalBuilder;
3890 Current->AddChunk(I == CurrentArg
3893 Current->getAllocator().CopyString(Placeholder));
3896 if (Current == &OptionalBuilder)
3897 Builder.AddOptionalChunk(OptionalBuilder.
TakeString());
3901 if (isa<FunctionTemplateDecl>(TD))
3902 Builder.AddInformativeChunk(
"()");
3903 return Builder.TakeString();
3910 bool Braced)
const {
3934 if (IncludeBriefComments) {
3941 llvm::raw_string_ostream OS(Name);
3943 Result.AddTextChunk(
Result.getAllocator().CopyString(OS.str()));
3946 Result.AddResultTypeChunk(
Result.getAllocator().CopyString(
3961 return Result.TakeString();
3966 bool PreferredTypeIsPointer) {
3970 if (MacroName.equals(
"nil") || MacroName.equals(
"NULL") ||
3971 MacroName.equals(
"Nil")) {
3973 if (PreferredTypeIsPointer)
3977 else if (MacroName.equals(
"YES") || MacroName.equals(
"NO") ||
3978 MacroName.equals(
"true") || MacroName.equals(
"false"))
3981 else if (MacroName.equals(
"bool"))
3994 case Decl::EnumConstant:
3998 case Decl::Function:
4000 case Decl::ObjCCategory:
4002 case Decl::ObjCCategoryImpl:
4004 case Decl::ObjCImplementation:
4007 case Decl::ObjCInterface:
4009 case Decl::ObjCIvar:
4011 case Decl::ObjCMethod:
4012 return cast<ObjCMethodDecl>(D)->isInstanceMethod()
4015 case Decl::CXXMethod:
4017 case Decl::CXXConstructor:
4019 case Decl::CXXDestructor:
4021 case Decl::CXXConversion:
4023 case Decl::ObjCProperty:
4025 case Decl::ObjCProtocol:
4031 case Decl::TypeAlias:
4033 case Decl::TypeAliasTemplate:
4037 case Decl::Namespace:
4039 case Decl::NamespaceAlias:
4041 case Decl::TemplateTypeParm:
4043 case Decl::NonTypeTemplateParm:
4045 case Decl::TemplateTemplateParm:
4047 case Decl::FunctionTemplate:
4049 case Decl::ClassTemplate:
4051 case Decl::AccessSpec:
4053 case Decl::ClassTemplatePartialSpecialization:
4055 case Decl::UsingDirective:
4057 case Decl::StaticAssert:
4061 case Decl::TranslationUnit:
4065 case Decl::UnresolvedUsingValue:
4066 case Decl::UnresolvedUsingTypename:
4069 case Decl::UsingEnum:
4072 case Decl::ObjCPropertyImpl:
4073 switch (cast<ObjCPropertyImplDecl>(D)->getPropertyImplementation()) {
4080 llvm_unreachable(
"Unexpected Kind!");
4085 case Decl::ObjCTypeParam:
4092 if (
const auto *TD = dyn_cast<TagDecl>(D)) {
4093 switch (TD->getTagKind()) {
4111 bool LoadExternal,
bool IncludeUndefined,
4112 bool TargetTypeIsPointer =
false) {
4115 Results.EnterNewScope();
4121 if (IncludeUndefined || MD) {
4129 TargetTypeIsPointer)));
4133 Results.ExitScope();
4137 ResultBuilder &Results) {
4140 Results.EnterNewScope();
4144 if (LangOpts.C99 || LangOpts.CPlusPlus11)
4146 Results.ExitScope();
4153 unsigned NumResults) {
4213 llvm_unreachable(
"Invalid ParserCompletionContext!");
4225 ResultBuilder &Results) {
4228 while (isa<BlockDecl>(CurContext))
4231 CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(CurContext);
4238 if (!
P->getDeclName())
4244 Results.getCodeCompletionTUInfo());
4251 S.
Context, CurContext, Overridden->getDeclContext());
4254 llvm::raw_string_ostream OS(Str);
4255 NNS->
print(OS, Policy);
4256 Builder.AddTextChunk(Results.getAllocator().CopyString(OS.str()));
4258 }
else if (!InContext->
Equals(Overridden->getDeclContext()))
4261 Builder.AddTypedTextChunk(
4262 Results.getAllocator().CopyString(Overridden->getNameAsString()));
4264 bool FirstParam =
true;
4271 Builder.AddPlaceholderChunk(
4272 Results.getAllocator().CopyString(
P->getIdentifier()->getName()));
4278 Results.Ignore(Overridden);
4285 ResultBuilder Results(*
this, CodeCompleter->getAllocator(),
4286 CodeCompleter->getCodeCompletionTUInfo(),
4288 Results.EnterNewScope();
4296 PP.getHeaderSearchInfo().collectAllModules(Modules);
4297 for (
unsigned I = 0, N = Modules.size(); I != N; ++I) {
4298 Builder.AddTypedTextChunk(
4299 Builder.getAllocator().CopyString(Modules[I]->Name));
4300 Results.AddResult(
Result(
4305 }
else if (getLangOpts().Modules) {
4314 Sub != SubEnd; ++Sub) {
4316 Builder.AddTypedTextChunk(
4317 Builder.getAllocator().CopyString((*Sub)->Name));
4318 Results.AddResult(
Result(
4325 Results.ExitScope();
4327 Results.data(), Results.size());
4332 ResultBuilder Results(*
this, CodeCompleter->getAllocator(),
4333 CodeCompleter->getCodeCompletionTUInfo(),
4335 Results.EnterNewScope();
4340 switch (CompletionContext) {
4343 case PCC_ObjCInterface:
4344 case PCC_ObjCImplementation:
4345 case PCC_ObjCInstanceVariableList:
4347 case PCC_MemberTemplate:
4349 case PCC_LocalDeclarationSpecifiers:
4350 Results.setFilter(&ResultBuilder::IsOrdinaryNonValueName);
4354 case PCC_ParenthesizedExpression:
4355 case PCC_Expression:
4359 Results.setFilter(&ResultBuilder::IsOrdinaryName);
4361 Results.setFilter(&ResultBuilder::IsOrdinaryNonTypeName);
4367 case PCC_RecoveryInFunction:
4374 auto ThisType = getCurrentThisType();
4375 if (!ThisType.isNull())
4376 Results.setObjectTypeQualifiers(ThisType->getPointeeType().getQualifiers(),
4379 CodeCompletionDeclConsumer Consumer(Results, CurContext);
4380 LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
4381 CodeCompleter->includeGlobals(),
4382 CodeCompleter->loadExternal());
4385 Results.ExitScope();
4387 switch (CompletionContext) {
4388 case PCC_ParenthesizedExpression:
4389 case PCC_Expression:
4391 case PCC_RecoveryInFunction:
4392 if (S->getFnParent())
4398 case PCC_ObjCInterface:
4399 case PCC_ObjCImplementation:
4400 case PCC_ObjCInstanceVariableList:
4402 case PCC_MemberTemplate:
4406 case PCC_LocalDeclarationSpecifiers:
4410 if (CodeCompleter->includeMacros())
4414 Results.data(), Results.size());
4420 bool AtArgumentExpression,
bool IsSuper,
4421 ResultBuilder &Results);
4424 bool AllowNonIdentifiers,
4425 bool AllowNestedNameSpecifiers) {
4427 ResultBuilder Results(
4428 *
this, CodeCompleter->getAllocator(),
4429 CodeCompleter->getCodeCompletionTUInfo(),
4430 AllowNestedNameSpecifiers
4435 Results.EnterNewScope();
4438 Results.AddResult(
Result(
"const"));
4439 Results.AddResult(
Result(
"volatile"));
4440 if (getLangOpts().
C99)
4441 Results.AddResult(
Result(
"restrict"));
4447 Results.AddResult(
"final");
4449 if (AllowNonIdentifiers) {
4450 Results.AddResult(
Result(
"operator"));
4454 if (AllowNestedNameSpecifiers) {
4455 Results.allowNestedNameSpecifiers();
4456 Results.setFilter(&ResultBuilder::IsImpossibleToSatisfy);
4457 CodeCompletionDeclConsumer Consumer(Results, CurContext);
4458 LookupVisibleDecls(S, LookupNestedNameSpecifierName, Consumer,
4459 CodeCompleter->includeGlobals(),
4460 CodeCompleter->loadExternal());
4461 Results.setFilter(
nullptr);
4464 Results.ExitScope();
4470 if (AllowNonIdentifiers && !AllowNestedNameSpecifiers &&
4490 Results.data(), Results.size());
4494 if (
Scope ==
"clang")
4502 if (
Scope ==
"_Clang")
4504 if (
Scope ==
"__gnu__")
4512 if (Completion == AttributeCompletion::None)
4514 ResultBuilder Results(*
this, CodeCompleter->getAllocator(),
4515 CodeCompleter->getCodeCompletionTUInfo(),
4528 llvm::StringRef InScopeName;
4529 bool InScopeUnderscore =
false;
4531 InScopeName = InScope->
getName();
4533 InScopeName = NoUnderscore;
4534 InScopeUnderscore =
true;
4543 if (A.IsTargetSpecific && !A.existsInTarget(Context.
getTargetInfo()))
4545 if (!A.acceptsLangOpts(getLangOpts()))
4547 for (
const auto &S : A.Spellings) {
4548 if (S.Syntax != Syntax)
4550 llvm::StringRef Name = S.NormalizedFullName;
4551 llvm::StringRef
Scope;
4554 std::tie(
Scope, Name) = Name.split(
"::");
4556 std::swap(Name,
Scope);
4560 if (Completion == AttributeCompletion::Scope) {
4562 if (!
Scope.empty() && FoundScopes.insert(
Scope).second) {
4573 if (!InScopeName.empty()) {
4574 if (
Scope != InScopeName)
4579 auto Add = [&](llvm::StringRef
Scope, llvm::StringRef Name,
4582 Results.getCodeCompletionTUInfo());
4584 if (!
Scope.empty()) {
4593 Builder.AddTypedTextChunk(Results.getAllocator().CopyString(
Text));
4595 if (!A.ArgNames.empty()) {
4598 for (
const char *Arg : A.ArgNames) {
4602 Builder.AddPlaceholderChunk(Arg);
4607 Results.AddResult(Builder.TakeString());
4614 if (!InScopeUnderscore)
4615 Add(
Scope, Name,
false);
4620 if (!(InScope && !InScopeUnderscore) && SyntaxSupportsGuards) {
4622 if (
Scope.empty()) {
4623 Add(
Scope, Name,
true);
4628 Add(GuardedScope, Name,
true);
4638 for (
const auto &Entry : ParsedAttrInfoRegistry::entries())
4639 AddCompletions(*Entry.instantiate());
4642 Results.data(), Results.size());
4647 bool IsParenthesized =
false)
4648 : PreferredType(PreferredType), IntegralConstantExpression(
false),
4649 ObjCCollection(
false), IsParenthesized(IsParenthesized) {}
4660struct CoveredEnumerators {
4668 const CoveredEnumerators &Enumerators) {
4670 if (Context.
getLangOpts().CPlusPlus && !Qualifier && Enumerators.Seen.empty()) {
4677 Results.EnterNewScope();
4678 for (
auto *E :
Enum->enumerators()) {
4679 if (Enumerators.Seen.count(E))
4683 Results.AddResult(R, CurContext,
nullptr,
false);
4685 Results.ExitScope();
4714 if (!Results.includeCodePatterns())
4717 Results.getCodeCompletionTUInfo());
4722 if (!Parameters.empty()) {
4731 constexpr llvm::StringLiteral NamePlaceholder =
"!#!NAME_GOES_HERE!#!";
4732 std::string
Type = std::string(NamePlaceholder);
4734 llvm::StringRef Prefix, Suffix;
4735 std::tie(Prefix, Suffix) = llvm::StringRef(
Type).split(NamePlaceholder);
4736 Prefix = Prefix.rtrim();
4737 Suffix = Suffix.ltrim();
4760 ResultBuilder Results(
4761 *
this, CodeCompleter->getAllocator(),
4762 CodeCompleter->getCodeCompletionTUInfo(),
4764 Data.IsParenthesized
4767 Data.PreferredType));
4769 Data.IsParenthesized ? PCC_ParenthesizedExpression : PCC_Expression;
4770 if (
Data.ObjCCollection)
4771 Results.setFilter(&ResultBuilder::IsObjCCollection);
4772 else if (
Data.IntegralConstantExpression)
4773 Results.setFilter(&ResultBuilder::IsIntegralConstantValue);
4775 Results.setFilter(&ResultBuilder::IsOrdinaryName);
4777 Results.setFilter(&ResultBuilder::IsOrdinaryNonTypeName);
4779 if (!
Data.PreferredType.isNull())
4780 Results.setPreferredType(
Data.PreferredType.getNonReferenceType());
4783 for (
unsigned I = 0, N =
Data.IgnoreDecls.size(); I != N; ++I)
4784 Results.Ignore(
Data.IgnoreDecls[I]);
4786 CodeCompletionDeclConsumer Consumer(Results, CurContext);
4787 LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
4788 CodeCompleter->includeGlobals(),
4789 CodeCompleter->loadExternal());
4791 Results.EnterNewScope();
4793 Results.ExitScope();
4795 bool PreferredTypeIsPointer =
false;
4796 if (!
Data.PreferredType.isNull()) {
4797 PreferredTypeIsPointer =
Data.PreferredType->isAnyPointerType() ||
4798 Data.PreferredType->isMemberPointerType() ||
4799 Data.PreferredType->isBlockPointerType();
4800 if (
Data.PreferredType->isEnumeralType()) {
4802 if (
auto *Def =
Enum->getDefinition())
4810 if (S->getFnParent() && !
Data.ObjCCollection &&
4811 !
Data.IntegralConstantExpression)
4814 if (CodeCompleter->includeMacros())
4816 PreferredTypeIsPointer);
4826 Results.data(), Results.size());
4830 bool IsParenthesized) {
4831 return CodeCompleteExpression(
4838 CodeCompleteExpression(S, PreferredType);
4839 else if (getLangOpts().
ObjC)
4840 CodeCompleteObjCInstanceMessage(S, E.
get(), std::nullopt,
false);
4850 if (Interface->hasDefinition())
4851 return Interface->getDefinition();
4857 if (Protocol->hasDefinition())
4858 return Protocol->getDefinition();
4872 Builder.AddResultTypeChunk(
4874 Policy, Builder.getAllocator()));
4880 Builder.AddPlaceholderChunk(
"...");
4882 for (
unsigned I = 0, N = BlockLoc.
getNumParams(); I != N; ++I) {
4887 std::string PlaceholderStr =
4890 if (I == N - 1 && BlockProtoLoc &&
4892 PlaceholderStr +=
", ...";
4895 Builder.AddPlaceholderChunk(
4896 Builder.getAllocator().CopyString(PlaceholderStr));
4906 bool AllowNullaryMethods,
DeclContext *CurContext,
4908 bool IsBaseExprStatement =
false,
4909 bool IsClassProperty =
false,
bool InOriginalClass =
true) {
4917 if (!AddedProperties.insert(
P->getIdentifier()).second)
4922 if (!
P->getType().getTypePtr()->isBlockPointerType() ||
4923 !IsBaseExprStatement) {
4925 if (!InOriginalClass)
4927 Results.MaybeAddResult(R, CurContext);
4939 if (!InOriginalClass)
4941 Results.MaybeAddResult(R, CurContext);
4948 Results.getCodeCompletionTUInfo());
4951 BlockLoc, BlockProtoLoc);
4952 Result R =
Result(Builder.TakeString(),
P, Results.getBasePriority(
P));
4953 if (!InOriginalClass)
4955 Results.MaybeAddResult(R, CurContext);
4959 if (!
P->isReadOnly()) {
4961 Results.getCodeCompletionTUInfo());
4965 Builder.AddTypedTextChunk(
4966 Results.getAllocator().CopyString(
P->getName()));
4971 BlockProtoLoc,
true);
4973 Builder.AddPlaceholderChunk(
4974 Builder.getAllocator().CopyString(PlaceholderStr));
4982 Result(Builder.TakeString(),
P,
4983 Results.getBasePriority(
P) +