blob: b88ff9dd64cde53e6399c4ef9aa9a509ad5cfd5c [file] [log] [blame]
Eugene Zelenko711964d2018-02-20 02:16:28 +00001//===- CodeCompleteConsumer.cpp - Code Completion Interface ---------------===//
Douglas Gregor2436e712009-09-17 21:32:03 +00002//
Chandler Carruth2946cd72019-01-19 08:50:56 +00003// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
Douglas Gregor2436e712009-09-17 21:32:03 +00006//
7//===----------------------------------------------------------------------===//
8//
9// This file implements the CodeCompleteConsumer class.
10//
11//===----------------------------------------------------------------------===//
Eugene Zelenko711964d2018-02-20 02:16:28 +000012
Douglas Gregor2436e712009-09-17 21:32:03 +000013#include "clang/Sema/CodeCompleteConsumer.h"
Chandler Carruth3a022472012-12-04 09:13:33 +000014#include "clang-c/Index.h"
Eugene Zelenko711964d2018-02-20 02:16:28 +000015#include "clang/AST/Decl.h"
16#include "clang/AST/DeclBase.h"
John McCallde6836a2010-08-24 07:21:54 +000017#include "clang/AST/DeclObjC.h"
John McCall19c1bfd2010-08-25 05:32:35 +000018#include "clang/AST/DeclTemplate.h"
Eugene Zelenko711964d2018-02-20 02:16:28 +000019#include "clang/AST/DeclarationName.h"
20#include "clang/AST/Type.h"
21#include "clang/Basic/IdentifierTable.h"
Vassil Vassilev644ea612016-07-27 14:56:59 +000022#include "clang/Lex/Preprocessor.h"
Ilya Biryukov2fab2352018-08-30 13:08:03 +000023#include "clang/Sema/Sema.h"
Chandler Carruth3a022472012-12-04 09:13:33 +000024#include "llvm/ADT/SmallString.h"
Eugene Zelenko711964d2018-02-20 02:16:28 +000025#include "llvm/ADT/SmallVector.h"
26#include "llvm/ADT/StringRef.h"
Douglas Gregor669a25a2011-02-17 00:22:45 +000027#include "llvm/ADT/Twine.h"
Eugene Zelenko711964d2018-02-20 02:16:28 +000028#include "llvm/Support/Casting.h"
29#include "llvm/Support/Compiler.h"
30#include "llvm/Support/ErrorHandling.h"
Ilya Biryukov2fab2352018-08-30 13:08:03 +000031#include "llvm/Support/FormatVariadic.h"
Douglas Gregor2436e712009-09-17 21:32:03 +000032#include "llvm/Support/raw_ostream.h"
33#include <algorithm>
Eugene Zelenko711964d2018-02-20 02:16:28 +000034#include <cassert>
35#include <cstdint>
36#include <string>
Douglas Gregorab6ccb52009-11-17 16:43:05 +000037
Douglas Gregor2436e712009-09-17 21:32:03 +000038using namespace clang;
39
Douglas Gregorfedc3282009-09-18 22:15:54 +000040//===----------------------------------------------------------------------===//
Douglas Gregor0212fd72010-09-21 16:06:22 +000041// Code completion context implementation
42//===----------------------------------------------------------------------===//
43
44bool CodeCompletionContext::wantConstructorResults() const {
Ilya Biryukov3289ab22018-02-19 13:53:49 +000045 switch (CCKind) {
Douglas Gregor0ac41382010-09-23 23:01:17 +000046 case CCC_Recovery:
Douglas Gregor0212fd72010-09-21 16:06:22 +000047 case CCC_Statement:
48 case CCC_Expression:
49 case CCC_ObjCMessageReceiver:
50 case CCC_ParenthesizedExpression:
Kadir Cetinkayab006e092018-10-24 15:23:49 +000051 case CCC_Symbol:
52 case CCC_SymbolOrNewName:
Douglas Gregor0212fd72010-09-21 16:06:22 +000053 return true;
Fangrui Song6907ce22018-07-30 19:24:48 +000054
Douglas Gregor0212fd72010-09-21 16:06:22 +000055 case CCC_TopLevel:
56 case CCC_ObjCInterface:
57 case CCC_ObjCImplementation:
58 case CCC_ObjCIvarList:
59 case CCC_ClassStructUnion:
Douglas Gregor21325842011-07-07 16:03:39 +000060 case CCC_DotMemberAccess:
61 case CCC_ArrowMemberAccess:
62 case CCC_ObjCPropertyAccess:
Douglas Gregor0212fd72010-09-21 16:06:22 +000063 case CCC_EnumTag:
64 case CCC_UnionTag:
65 case CCC_ClassOrStructTag:
66 case CCC_ObjCProtocolName:
67 case CCC_Namespace:
68 case CCC_Type:
Kadir Cetinkayab006e092018-10-24 15:23:49 +000069 case CCC_NewName:
Douglas Gregor0212fd72010-09-21 16:06:22 +000070 case CCC_MacroName:
71 case CCC_MacroNameUse:
72 case CCC_PreprocessorExpression:
73 case CCC_PreprocessorDirective:
74 case CCC_NaturalLanguage:
75 case CCC_SelectorName:
76 case CCC_TypeQualifiers:
Douglas Gregor0ac41382010-09-23 23:01:17 +000077 case CCC_Other:
Douglas Gregor3a69eaf2011-02-18 23:30:37 +000078 case CCC_OtherWithMacros:
Douglas Gregor21325842011-07-07 16:03:39 +000079 case CCC_ObjCInstanceMessage:
80 case CCC_ObjCClassMessage:
Douglas Gregor2c595ad2011-07-30 06:55:39 +000081 case CCC_ObjCInterfaceName:
Douglas Gregor21325842011-07-07 16:03:39 +000082 case CCC_ObjCCategoryName:
Sam McCall3d8051a2018-09-18 08:40:41 +000083 case CCC_IncludedFile:
Douglas Gregor0212fd72010-09-21 16:06:22 +000084 return false;
85 }
David Blaikie8a40f702012-01-17 06:56:22 +000086
87 llvm_unreachable("Invalid CodeCompletionContext::Kind!");
Douglas Gregor0212fd72010-09-21 16:06:22 +000088}
89
Ilya Biryukov3289ab22018-02-19 13:53:49 +000090StringRef clang::getCompletionKindString(CodeCompletionContext::Kind Kind) {
91 using CCKind = CodeCompletionContext::Kind;
Ilya Biryukov27d82582018-02-19 12:35:33 +000092 switch (Kind) {
93 case CCKind::CCC_Other:
94 return "Other";
95 case CCKind::CCC_OtherWithMacros:
96 return "OtherWithMacros";
97 case CCKind::CCC_TopLevel:
98 return "TopLevel";
99 case CCKind::CCC_ObjCInterface:
100 return "ObjCInterface";
101 case CCKind::CCC_ObjCImplementation:
102 return "ObjCImplementation";
103 case CCKind::CCC_ObjCIvarList:
104 return "ObjCIvarList";
105 case CCKind::CCC_ClassStructUnion:
106 return "ClassStructUnion";
107 case CCKind::CCC_Statement:
108 return "Statement";
109 case CCKind::CCC_Expression:
110 return "Expression";
111 case CCKind::CCC_ObjCMessageReceiver:
112 return "ObjCMessageReceiver";
113 case CCKind::CCC_DotMemberAccess:
114 return "DotMemberAccess";
115 case CCKind::CCC_ArrowMemberAccess:
116 return "ArrowMemberAccess";
117 case CCKind::CCC_ObjCPropertyAccess:
118 return "ObjCPropertyAccess";
119 case CCKind::CCC_EnumTag:
120 return "EnumTag";
121 case CCKind::CCC_UnionTag:
122 return "UnionTag";
123 case CCKind::CCC_ClassOrStructTag:
124 return "ClassOrStructTag";
125 case CCKind::CCC_ObjCProtocolName:
126 return "ObjCProtocolName";
127 case CCKind::CCC_Namespace:
128 return "Namespace";
129 case CCKind::CCC_Type:
130 return "Type";
Kadir Cetinkayab006e092018-10-24 15:23:49 +0000131 case CCKind::CCC_NewName:
132 return "NewName";
133 case CCKind::CCC_Symbol:
134 return "Symbol";
135 case CCKind::CCC_SymbolOrNewName:
136 return "SymbolOrNewName";
Ilya Biryukov27d82582018-02-19 12:35:33 +0000137 case CCKind::CCC_MacroName:
138 return "MacroName";
139 case CCKind::CCC_MacroNameUse:
140 return "MacroNameUse";
141 case CCKind::CCC_PreprocessorExpression:
142 return "PreprocessorExpression";
143 case CCKind::CCC_PreprocessorDirective:
144 return "PreprocessorDirective";
145 case CCKind::CCC_NaturalLanguage:
146 return "NaturalLanguage";
147 case CCKind::CCC_SelectorName:
148 return "SelectorName";
149 case CCKind::CCC_TypeQualifiers:
150 return "TypeQualifiers";
151 case CCKind::CCC_ParenthesizedExpression:
152 return "ParenthesizedExpression";
153 case CCKind::CCC_ObjCInstanceMessage:
154 return "ObjCInstanceMessage";
155 case CCKind::CCC_ObjCClassMessage:
156 return "ObjCClassMessage";
157 case CCKind::CCC_ObjCInterfaceName:
158 return "ObjCInterfaceName";
159 case CCKind::CCC_ObjCCategoryName:
160 return "ObjCCategoryName";
Sam McCall3d8051a2018-09-18 08:40:41 +0000161 case CCKind::CCC_IncludedFile:
162 return "IncludedFile";
Ilya Biryukov27d82582018-02-19 12:35:33 +0000163 case CCKind::CCC_Recovery:
164 return "Recovery";
165 }
166 llvm_unreachable("Invalid CodeCompletionContext::Kind!");
167}
168
Douglas Gregor0212fd72010-09-21 16:06:22 +0000169//===----------------------------------------------------------------------===//
Douglas Gregorfedc3282009-09-18 22:15:54 +0000170// Code completion string implementation
171//===----------------------------------------------------------------------===//
Eugene Zelenko711964d2018-02-20 02:16:28 +0000172
Fangrui Song6907ce22018-07-30 19:24:48 +0000173CodeCompletionString::Chunk::Chunk(ChunkKind Kind, const char *Text)
Eugene Zelenko711964d2018-02-20 02:16:28 +0000174 : Kind(Kind), Text("") {
Douglas Gregor9eb77012009-11-07 00:00:49 +0000175 switch (Kind) {
176 case CK_TypedText:
177 case CK_Text:
178 case CK_Placeholder:
179 case CK_Informative:
Douglas Gregorb3fa9192009-12-18 18:53:37 +0000180 case CK_ResultType:
Douglas Gregorb278aaf2011-02-01 19:23:04 +0000181 case CK_CurrentParameter:
182 this->Text = Text;
Douglas Gregor9eb77012009-11-07 00:00:49 +0000183 break;
Douglas Gregor9eb77012009-11-07 00:00:49 +0000184
185 case CK_Optional:
Jeffrey Yasskin1615d452009-12-12 05:05:38 +0000186 llvm_unreachable("Optional strings cannot be created from text");
Fangrui Song6907ce22018-07-30 19:24:48 +0000187
Douglas Gregor9eb77012009-11-07 00:00:49 +0000188 case CK_LeftParen:
189 this->Text = "(";
190 break;
191
192 case CK_RightParen:
193 this->Text = ")";
194 break;
195
196 case CK_LeftBracket:
197 this->Text = "[";
198 break;
Fangrui Song6907ce22018-07-30 19:24:48 +0000199
Douglas Gregor9eb77012009-11-07 00:00:49 +0000200 case CK_RightBracket:
201 this->Text = "]";
202 break;
Fangrui Song6907ce22018-07-30 19:24:48 +0000203
Douglas Gregor9eb77012009-11-07 00:00:49 +0000204 case CK_LeftBrace:
205 this->Text = "{";
206 break;
207
208 case CK_RightBrace:
209 this->Text = "}";
210 break;
211
212 case CK_LeftAngle:
213 this->Text = "<";
214 break;
Fangrui Song6907ce22018-07-30 19:24:48 +0000215
Douglas Gregor9eb77012009-11-07 00:00:49 +0000216 case CK_RightAngle:
217 this->Text = ">";
218 break;
Fangrui Song6907ce22018-07-30 19:24:48 +0000219
Douglas Gregor9eb77012009-11-07 00:00:49 +0000220 case CK_Comma:
221 this->Text = ", ";
222 break;
Douglas Gregor504a6ae2010-01-10 23:08:15 +0000223
224 case CK_Colon:
Douglas Gregor636a61e2010-04-07 00:21:17 +0000225 this->Text = ":";
Douglas Gregor504a6ae2010-01-10 23:08:15 +0000226 break;
227
228 case CK_SemiColon:
229 this->Text = ";";
230 break;
231
232 case CK_Equal:
233 this->Text = " = ";
234 break;
235
236 case CK_HorizontalSpace:
237 this->Text = " ";
238 break;
239
240 case CK_VerticalSpace:
241 this->Text = "\n";
242 break;
Douglas Gregor9eb77012009-11-07 00:00:49 +0000243 }
Douglas Gregor5bf52692009-09-22 23:15:58 +0000244}
245
246CodeCompletionString::Chunk
Douglas Gregorb278aaf2011-02-01 19:23:04 +0000247CodeCompletionString::Chunk::CreateText(const char *Text) {
Douglas Gregor5bf52692009-09-22 23:15:58 +0000248 return Chunk(CK_Text, Text);
Douglas Gregorfedc3282009-09-18 22:15:54 +0000249}
250
Fangrui Song6907ce22018-07-30 19:24:48 +0000251CodeCompletionString::Chunk
Douglas Gregorb278aaf2011-02-01 19:23:04 +0000252CodeCompletionString::Chunk::CreateOptional(CodeCompletionString *Optional) {
Douglas Gregorfedc3282009-09-18 22:15:54 +0000253 Chunk Result;
254 Result.Kind = CK_Optional;
Douglas Gregorb278aaf2011-02-01 19:23:04 +0000255 Result.Optional = Optional;
Douglas Gregorfedc3282009-09-18 22:15:54 +0000256 return Result;
257}
258
Fangrui Song6907ce22018-07-30 19:24:48 +0000259CodeCompletionString::Chunk
Douglas Gregorb278aaf2011-02-01 19:23:04 +0000260CodeCompletionString::Chunk::CreatePlaceholder(const char *Placeholder) {
Douglas Gregor5bf52692009-09-22 23:15:58 +0000261 return Chunk(CK_Placeholder, Placeholder);
262}
263
Fangrui Song6907ce22018-07-30 19:24:48 +0000264CodeCompletionString::Chunk
Douglas Gregorb278aaf2011-02-01 19:23:04 +0000265CodeCompletionString::Chunk::CreateInformative(const char *Informative) {
Douglas Gregor5bf52692009-09-22 23:15:58 +0000266 return Chunk(CK_Informative, Informative);
Douglas Gregorfedc3282009-09-18 22:15:54 +0000267}
268
Fangrui Song6907ce22018-07-30 19:24:48 +0000269CodeCompletionString::Chunk
Douglas Gregorb278aaf2011-02-01 19:23:04 +0000270CodeCompletionString::Chunk::CreateResultType(const char *ResultType) {
Douglas Gregorb3fa9192009-12-18 18:53:37 +0000271 return Chunk(CK_ResultType, ResultType);
272}
273
Fangrui Songde314b32018-11-25 20:57:05 +0000274CodeCompletionString::Chunk CodeCompletionString::Chunk::CreateCurrentParameter(
275 const char *CurrentParameter) {
Douglas Gregor9eb77012009-11-07 00:00:49 +0000276 return Chunk(CK_CurrentParameter, CurrentParameter);
277}
278
Fangrui Songde314b32018-11-25 20:57:05 +0000279CodeCompletionString::CodeCompletionString(
280 const Chunk *Chunks, unsigned NumChunks, unsigned Priority,
281 CXAvailabilityKind Availability, const char **Annotations,
282 unsigned NumAnnotations, StringRef ParentName, const char *BriefComment)
283 : NumChunks(NumChunks), NumAnnotations(NumAnnotations), Priority(Priority),
284 Availability(Availability), ParentName(ParentName),
285 BriefComment(BriefComment) {
Erik Verbruggen98ea7f62011-10-14 15:31:08 +0000286 assert(NumChunks <= 0xffff);
287 assert(NumAnnotations <= 0xffff);
288
Eugene Zelenko1e95bc02018-04-05 22:15:42 +0000289 Chunk *StoredChunks = reinterpret_cast<Chunk *>(this + 1);
Douglas Gregorb278aaf2011-02-01 19:23:04 +0000290 for (unsigned I = 0; I != NumChunks; ++I)
291 StoredChunks[I] = Chunks[I];
Erik Verbruggen98ea7f62011-10-14 15:31:08 +0000292
Fangrui Songde314b32018-11-25 20:57:05 +0000293 const char **StoredAnnotations =
294 reinterpret_cast<const char **>(StoredChunks + NumChunks);
Erik Verbruggen98ea7f62011-10-14 15:31:08 +0000295 for (unsigned I = 0; I != NumAnnotations; ++I)
296 StoredAnnotations[I] = Annotations[I];
Douglas Gregorfedc3282009-09-18 22:15:54 +0000297}
298
Erik Verbruggen98ea7f62011-10-14 15:31:08 +0000299unsigned CodeCompletionString::getAnnotationCount() const {
300 return NumAnnotations;
301}
302
303const char *CodeCompletionString::getAnnotation(unsigned AnnotationNr) const {
304 if (AnnotationNr < NumAnnotations)
Fangrui Songde314b32018-11-25 20:57:05 +0000305 return reinterpret_cast<const char *const *>(end())[AnnotationNr];
Erik Verbruggen98ea7f62011-10-14 15:31:08 +0000306 else
Craig Topperc3ec1492014-05-26 06:22:03 +0000307 return nullptr;
Erik Verbruggen98ea7f62011-10-14 15:31:08 +0000308}
309
Douglas Gregorfedc3282009-09-18 22:15:54 +0000310std::string CodeCompletionString::getAsString() const {
311 std::string Result;
312 llvm::raw_string_ostream OS(Result);
Fangrui Song6907ce22018-07-30 19:24:48 +0000313
Fangrui Songde314b32018-11-25 20:57:05 +0000314 for (const Chunk &C : *this) {
315 switch (C.Kind) {
316 case CK_Optional:
317 OS << "{#" << C.Optional->getAsString() << "#}";
318 break;
319 case CK_Placeholder:
320 OS << "<#" << C.Text << "#>";
321 break;
Fangrui Song6907ce22018-07-30 19:24:48 +0000322 case CK_Informative:
Douglas Gregorb3fa9192009-12-18 18:53:37 +0000323 case CK_ResultType:
Fangrui Songde314b32018-11-25 20:57:05 +0000324 OS << "[#" << C.Text << "#]";
Douglas Gregorb3fa9192009-12-18 18:53:37 +0000325 break;
Fangrui Songde314b32018-11-25 20:57:05 +0000326 case CK_CurrentParameter:
327 OS << "<#" << C.Text << "#>";
328 break;
329 default:
330 OS << C.Text;
331 break;
Douglas Gregorfedc3282009-09-18 22:15:54 +0000332 }
333 }
Dan Gohman4888f1a2010-07-26 21:33:22 +0000334 return OS.str();
Douglas Gregorfedc3282009-09-18 22:15:54 +0000335}
336
Douglas Gregor45f83ee2009-11-19 00:01:57 +0000337const char *CodeCompletionString::getTypedText() const {
Fangrui Songde314b32018-11-25 20:57:05 +0000338 for (const Chunk &C : *this)
339 if (C.Kind == CK_TypedText)
340 return C.Text;
Craig Topperc3ec1492014-05-26 06:22:03 +0000341
342 return nullptr;
Douglas Gregor45f83ee2009-11-19 00:01:57 +0000343}
344
Yaron Keren1ee89fc2015-03-17 09:51:17 +0000345const char *CodeCompletionAllocator::CopyString(const Twine &String) {
346 SmallString<128> Data;
347 StringRef Ref = String.toStringRef(Data);
Douglas Gregor669a25a2011-02-17 00:22:45 +0000348 // FIXME: It would be more efficient to teach Twine to tell us its size and
349 // then add a routine there to fill in an allocated char* with the contents
350 // of the string.
Eugene Zelenko1e95bc02018-04-05 22:15:42 +0000351 char *Mem = (char *)Allocate(Ref.size() + 1, 1);
Yaron Keren1ee89fc2015-03-17 09:51:17 +0000352 std::copy(Ref.begin(), Ref.end(), Mem);
353 Mem[Ref.size()] = 0;
354 return Mem;
Douglas Gregor669a25a2011-02-17 00:22:45 +0000355}
356
Dmitri Gribenkofe0483d2013-01-23 17:21:11 +0000357StringRef CodeCompletionTUInfo::getParentName(const DeclContext *DC) {
Eugene Zelenko1e95bc02018-04-05 22:15:42 +0000358 const NamedDecl *ND = dyn_cast<NamedDecl>(DC);
Argyrios Kyrtzidis9d7c0fe2012-04-10 17:23:48 +0000359 if (!ND)
Eugene Zelenko711964d2018-02-20 02:16:28 +0000360 return {};
Fangrui Song6907ce22018-07-30 19:24:48 +0000361
Argyrios Kyrtzidis9d7c0fe2012-04-10 17:23:48 +0000362 // Check whether we've already cached the parent name.
363 StringRef &CachedParentName = ParentNames[DC];
364 if (!CachedParentName.empty())
365 return CachedParentName;
366
367 // If we already processed this DeclContext and assigned empty to it, the
368 // data pointer will be non-null.
Craig Topperc3ec1492014-05-26 06:22:03 +0000369 if (CachedParentName.data() != nullptr)
Eugene Zelenko711964d2018-02-20 02:16:28 +0000370 return {};
Argyrios Kyrtzidis9d7c0fe2012-04-10 17:23:48 +0000371
372 // Find the interesting names.
Dmitri Gribenkofe0483d2013-01-23 17:21:11 +0000373 SmallVector<const DeclContext *, 2> Contexts;
Argyrios Kyrtzidis9d7c0fe2012-04-10 17:23:48 +0000374 while (DC && !DC->isFunctionOrMethod()) {
Fangrui Songde314b32018-11-25 20:57:05 +0000375 if (const auto *ND = dyn_cast<NamedDecl>(DC)) {
Argyrios Kyrtzidis9d7c0fe2012-04-10 17:23:48 +0000376 if (ND->getIdentifier())
377 Contexts.push_back(DC);
378 }
Fangrui Song6907ce22018-07-30 19:24:48 +0000379
Argyrios Kyrtzidis9d7c0fe2012-04-10 17:23:48 +0000380 DC = DC->getParent();
381 }
382
383 {
Dmitri Gribenkof8579502013-01-12 19:30:44 +0000384 SmallString<128> S;
Argyrios Kyrtzidis9d7c0fe2012-04-10 17:23:48 +0000385 llvm::raw_svector_ostream OS(S);
386 bool First = true;
387 for (unsigned I = Contexts.size(); I != 0; --I) {
388 if (First)
389 First = false;
390 else {
391 OS << "::";
392 }
Fangrui Song6907ce22018-07-30 19:24:48 +0000393
Fangrui Songde314b32018-11-25 20:57:05 +0000394 const DeclContext *CurDC = Contexts[I - 1];
395 if (const auto *CatImpl = dyn_cast<ObjCCategoryImplDecl>(CurDC))
Argyrios Kyrtzidis9d7c0fe2012-04-10 17:23:48 +0000396 CurDC = CatImpl->getCategoryDecl();
Fangrui Song6907ce22018-07-30 19:24:48 +0000397
Fangrui Songde314b32018-11-25 20:57:05 +0000398 if (const auto *Cat = dyn_cast<ObjCCategoryDecl>(CurDC)) {
Dmitri Gribenkofe0483d2013-01-23 17:21:11 +0000399 const ObjCInterfaceDecl *Interface = Cat->getClassInterface();
Argyrios Kyrtzidis9d7c0fe2012-04-10 17:23:48 +0000400 if (!Interface) {
401 // Assign an empty StringRef but with non-null data to distinguish
402 // between empty because we didn't process the DeclContext yet.
Reid Klecknerd16cebe2016-02-10 19:09:15 +0000403 CachedParentName = StringRef((const char *)(uintptr_t)~0U, 0);
Eugene Zelenko711964d2018-02-20 02:16:28 +0000404 return {};
Argyrios Kyrtzidis9d7c0fe2012-04-10 17:23:48 +0000405 }
Fangrui Song6907ce22018-07-30 19:24:48 +0000406
Argyrios Kyrtzidis9d7c0fe2012-04-10 17:23:48 +0000407 OS << Interface->getName() << '(' << Cat->getName() << ')';
408 } else {
409 OS << cast<NamedDecl>(CurDC)->getName();
410 }
411 }
Fangrui Song6907ce22018-07-30 19:24:48 +0000412
Argyrios Kyrtzidis9d7c0fe2012-04-10 17:23:48 +0000413 CachedParentName = AllocatorRef->CopyString(OS.str());
414 }
415
416 return CachedParentName;
417}
418
Douglas Gregorb278aaf2011-02-01 19:23:04 +0000419CodeCompletionString *CodeCompletionBuilder::TakeString() {
Argyrios Kyrtzidis9d7c0fe2012-04-10 17:23:48 +0000420 void *Mem = getAllocator().Allocate(
Benjamin Kramerc3f89252016-10-20 14:27:22 +0000421 sizeof(CodeCompletionString) + sizeof(Chunk) * Chunks.size() +
422 sizeof(const char *) * Annotations.size(),
423 alignof(CodeCompletionString));
Fangrui Songde314b32018-11-25 20:57:05 +0000424 CodeCompletionString *Result = new (Mem) CodeCompletionString(
425 Chunks.data(), Chunks.size(), Priority, Availability, Annotations.data(),
426 Annotations.size(), ParentName, BriefComment);
Douglas Gregorb278aaf2011-02-01 19:23:04 +0000427 Chunks.clear();
Douglas Gregor45f83ee2009-11-19 00:01:57 +0000428 return Result;
429}
Douglas Gregor9eb77012009-11-07 00:00:49 +0000430
Benjamin Kramerdb534a42012-03-26 16:57:36 +0000431void CodeCompletionBuilder::AddTypedTextChunk(const char *Text) {
432 Chunks.push_back(Chunk(CodeCompletionString::CK_TypedText, Text));
433}
434
435void CodeCompletionBuilder::AddTextChunk(const char *Text) {
436 Chunks.push_back(Chunk::CreateText(Text));
437}
438
439void CodeCompletionBuilder::AddOptionalChunk(CodeCompletionString *Optional) {
440 Chunks.push_back(Chunk::CreateOptional(Optional));
441}
442
443void CodeCompletionBuilder::AddPlaceholderChunk(const char *Placeholder) {
444 Chunks.push_back(Chunk::CreatePlaceholder(Placeholder));
445}
446
447void CodeCompletionBuilder::AddInformativeChunk(const char *Text) {
448 Chunks.push_back(Chunk::CreateInformative(Text));
449}
450
451void CodeCompletionBuilder::AddResultTypeChunk(const char *ResultType) {
452 Chunks.push_back(Chunk::CreateResultType(ResultType));
453}
454
Fangrui Songde314b32018-11-25 20:57:05 +0000455void CodeCompletionBuilder::AddCurrentParameterChunk(
456 const char *CurrentParameter) {
Benjamin Kramerdb534a42012-03-26 16:57:36 +0000457 Chunks.push_back(Chunk::CreateCurrentParameter(CurrentParameter));
458}
459
460void CodeCompletionBuilder::AddChunk(CodeCompletionString::ChunkKind CK,
461 const char *Text) {
462 Chunks.push_back(Chunk(CK, Text));
463}
464
Dmitri Gribenkofe0483d2013-01-23 17:21:11 +0000465void CodeCompletionBuilder::addParentContext(const DeclContext *DC) {
Eugene Zelenko711964d2018-02-20 02:16:28 +0000466 if (DC->isTranslationUnit())
Douglas Gregor78254c82012-03-27 23:34:16 +0000467 return;
Fangrui Song6907ce22018-07-30 19:24:48 +0000468
Douglas Gregor78254c82012-03-27 23:34:16 +0000469 if (DC->isFunctionOrMethod())
470 return;
Fangrui Song6907ce22018-07-30 19:24:48 +0000471
Eugene Zelenko1e95bc02018-04-05 22:15:42 +0000472 const NamedDecl *ND = dyn_cast<NamedDecl>(DC);
Douglas Gregor78254c82012-03-27 23:34:16 +0000473 if (!ND)
474 return;
Fangrui Song6907ce22018-07-30 19:24:48 +0000475
Argyrios Kyrtzidis9d7c0fe2012-04-10 17:23:48 +0000476 ParentName = getCodeCompletionTUInfo().getParentName(DC);
Douglas Gregor78254c82012-03-27 23:34:16 +0000477}
478
Dmitri Gribenko3292d062012-07-02 17:35:10 +0000479void CodeCompletionBuilder::addBriefComment(StringRef Comment) {
480 BriefComment = Allocator.CopyString(Comment);
481}
482
Douglas Gregorfedc3282009-09-18 22:15:54 +0000483//===----------------------------------------------------------------------===//
Douglas Gregor05f477c2009-09-23 00:16:58 +0000484// Code completion overload candidate implementation
485//===----------------------------------------------------------------------===//
Fangrui Songde314b32018-11-25 20:57:05 +0000486FunctionDecl *CodeCompleteConsumer::OverloadCandidate::getFunction() const {
Douglas Gregor05f477c2009-09-23 00:16:58 +0000487 if (getKind() == CK_Function)
488 return Function;
489 else if (getKind() == CK_FunctionTemplate)
490 return FunctionTemplate->getTemplatedDecl();
491 else
Craig Topperc3ec1492014-05-26 06:22:03 +0000492 return nullptr;
Douglas Gregor05f477c2009-09-23 00:16:58 +0000493}
494
495const FunctionType *
496CodeCompleteConsumer::OverloadCandidate::getFunctionType() const {
497 switch (Kind) {
498 case CK_Function:
499 return Function->getType()->getAs<FunctionType>();
Fangrui Song6907ce22018-07-30 19:24:48 +0000500
Douglas Gregor05f477c2009-09-23 00:16:58 +0000501 case CK_FunctionTemplate:
Fangrui Songde314b32018-11-25 20:57:05 +0000502 return FunctionTemplate->getTemplatedDecl()
503 ->getType()
504 ->getAs<FunctionType>();
Fangrui Song6907ce22018-07-30 19:24:48 +0000505
Douglas Gregor05f477c2009-09-23 00:16:58 +0000506 case CK_FunctionType:
507 return Type;
508 }
David Blaikie8a40f702012-01-17 06:56:22 +0000509
510 llvm_unreachable("Invalid CandidateKind!");
Douglas Gregor05f477c2009-09-23 00:16:58 +0000511}
512
513//===----------------------------------------------------------------------===//
Douglas Gregorfedc3282009-09-18 22:15:54 +0000514// Code completion consumer implementation
515//===----------------------------------------------------------------------===//
516
Eugene Zelenko711964d2018-02-20 02:16:28 +0000517CodeCompleteConsumer::~CodeCompleteConsumer() = default;
Douglas Gregorfedc3282009-09-18 22:15:54 +0000518
Fangrui Songde314b32018-11-25 20:57:05 +0000519bool PrintingCodeCompleteConsumer::isResultFilteredOut(
520 StringRef Filter, CodeCompletionResult Result) {
Vassil Vassilev644ea612016-07-27 14:56:59 +0000521 switch (Result.Kind) {
Eugene Zelenko711964d2018-02-20 02:16:28 +0000522 case CodeCompletionResult::RK_Declaration:
Vassil Vassilev644ea612016-07-27 14:56:59 +0000523 return !(Result.Declaration->getIdentifier() &&
Fangrui Songde314b32018-11-25 20:57:05 +0000524 Result.Declaration->getIdentifier()->getName().startswith(Filter));
Eugene Zelenko711964d2018-02-20 02:16:28 +0000525 case CodeCompletionResult::RK_Keyword:
Vassil Vassilev644ea612016-07-27 14:56:59 +0000526 return !StringRef(Result.Keyword).startswith(Filter);
Eugene Zelenko711964d2018-02-20 02:16:28 +0000527 case CodeCompletionResult::RK_Macro:
Vassil Vassilev644ea612016-07-27 14:56:59 +0000528 return !Result.Macro->getName().startswith(Filter);
Eugene Zelenko711964d2018-02-20 02:16:28 +0000529 case CodeCompletionResult::RK_Pattern:
Sam McCall3d8051a2018-09-18 08:40:41 +0000530 return !(Result.Pattern->getTypedText() &&
531 StringRef(Result.Pattern->getTypedText()).startswith(Filter));
Vassil Vassilev644ea612016-07-27 14:56:59 +0000532 }
Simon Pilgrime71a1f92016-07-27 16:41:56 +0000533 llvm_unreachable("Unknown code completion result Kind.");
Vassil Vassilev644ea612016-07-27 14:56:59 +0000534}
535
Fangrui Songde314b32018-11-25 20:57:05 +0000536void PrintingCodeCompleteConsumer::ProcessCodeCompleteResults(
537 Sema &SemaRef, CodeCompletionContext Context, CodeCompletionResult *Results,
538 unsigned NumResults) {
Douglas Gregor49f67ce2010-08-26 13:48:20 +0000539 std::stable_sort(Results, Results + NumResults);
Fangrui Song6907ce22018-07-30 19:24:48 +0000540
Ilya Biryukov41109672018-12-13 15:36:32 +0000541 if (!Context.getPreferredType().isNull())
542 OS << "PREFERRED-TYPE: " << Context.getPreferredType().getAsString()
543 << "\n";
Vassil Vassilev644ea612016-07-27 14:56:59 +0000544
Ilya Biryukov41109672018-12-13 15:36:32 +0000545 StringRef Filter = SemaRef.getPreprocessor().getCodeCompletionFilter();
546 // Print the completions.
Douglas Gregor2436e712009-09-17 21:32:03 +0000547 for (unsigned I = 0; I != NumResults; ++I) {
Fangrui Songde314b32018-11-25 20:57:05 +0000548 if (!Filter.empty() && isResultFilteredOut(Filter, Results[I]))
Vassil Vassilev644ea612016-07-27 14:56:59 +0000549 continue;
Douglas Gregor58acf322009-10-09 22:16:47 +0000550 OS << "COMPLETION: ";
Douglas Gregor2436e712009-09-17 21:32:03 +0000551 switch (Results[I].Kind) {
John McCall276321a2010-08-25 06:19:51 +0000552 case CodeCompletionResult::RK_Declaration:
Benjamin Kramerb89514a2011-10-14 18:45:37 +0000553 OS << *Results[I].Declaration;
Eric Liu4a7cd632018-10-24 12:57:27 +0000554 {
555 std::vector<std::string> Tags;
556 if (Results[I].Hidden)
557 Tags.push_back("Hidden");
558 if (Results[I].InBaseClass)
559 Tags.push_back("InBase");
Ilya Biryukovf1822ec2018-12-03 13:29:17 +0000560 if (Results[I].Availability ==
561 CXAvailabilityKind::CXAvailability_NotAccessible)
562 Tags.push_back("Inaccessible");
Eric Liu4a7cd632018-10-24 12:57:27 +0000563 if (!Tags.empty())
564 OS << " (" << llvm::join(Tags, ",") << ")";
565 }
566 if (CodeCompletionString *CCS = Results[I].CreateCodeCompletionString(
567 SemaRef, Context, getAllocator(), CCTUInfo,
568 includeBriefComments())) {
Douglas Gregorfedc3282009-09-18 22:15:54 +0000569 OS << " : " << CCS->getAsString();
Dmitri Gribenko3292d062012-07-02 17:35:10 +0000570 if (const char *BriefComment = CCS->getBriefComment())
571 OS << " : " << BriefComment;
Douglas Gregorfedc3282009-09-18 22:15:54 +0000572 }
Ivan Donchevskiib4670fc2018-05-25 12:56:26 +0000573 for (const FixItHint &FixIt : Results[I].FixIts) {
574 const SourceLocation BLoc = FixIt.RemoveRange.getBegin();
575 const SourceLocation ELoc = FixIt.RemoveRange.getEnd();
576
577 SourceManager &SM = SemaRef.SourceMgr;
578 std::pair<FileID, unsigned> BInfo = SM.getDecomposedLoc(BLoc);
579 std::pair<FileID, unsigned> EInfo = SM.getDecomposedLoc(ELoc);
580 // Adjust for token ranges.
581 if (FixIt.RemoveRange.isTokenRange())
582 EInfo.second += Lexer::MeasureTokenLength(ELoc, SM, SemaRef.LangOpts);
583
584 OS << " (requires fix-it:"
585 << " {" << SM.getLineNumber(BInfo.first, BInfo.second) << ':'
586 << SM.getColumnNumber(BInfo.first, BInfo.second) << '-'
587 << SM.getLineNumber(EInfo.first, EInfo.second) << ':'
588 << SM.getColumnNumber(EInfo.first, EInfo.second) << "}"
589 << " to \"" << FixIt.CodeToInsert << "\")";
590 }
Douglas Gregor2436e712009-09-17 21:32:03 +0000591 OS << '\n';
592 break;
Fangrui Song6907ce22018-07-30 19:24:48 +0000593
John McCall276321a2010-08-25 06:19:51 +0000594 case CodeCompletionResult::RK_Keyword:
Douglas Gregor52ce62f2010-01-13 23:24:38 +0000595 OS << Results[I].Keyword << '\n';
Douglas Gregor2436e712009-09-17 21:32:03 +0000596 break;
Fangrui Song6907ce22018-07-30 19:24:48 +0000597
Eugene Zelenko711964d2018-02-20 02:16:28 +0000598 case CodeCompletionResult::RK_Macro:
Douglas Gregor52ce62f2010-01-13 23:24:38 +0000599 OS << Results[I].Macro->getName();
Fangrui Songde314b32018-11-25 20:57:05 +0000600 if (CodeCompletionString *CCS = Results[I].CreateCodeCompletionString(
601 SemaRef, Context, getAllocator(), CCTUInfo,
602 includeBriefComments())) {
Douglas Gregorf329c7c2009-10-30 16:50:04 +0000603 OS << " : " << CCS->getAsString();
Douglas Gregorf329c7c2009-10-30 16:50:04 +0000604 }
605 OS << '\n';
606 break;
Fangrui Song6907ce22018-07-30 19:24:48 +0000607
Eugene Zelenko711964d2018-02-20 02:16:28 +0000608 case CodeCompletionResult::RK_Pattern:
Fangrui Songde314b32018-11-25 20:57:05 +0000609 OS << "Pattern : " << Results[I].Pattern->getAsString() << '\n';
Douglas Gregor45f83ee2009-11-19 00:01:57 +0000610 break;
611 }
Douglas Gregor2436e712009-09-17 21:32:03 +0000612 }
Douglas Gregor2436e712009-09-17 21:32:03 +0000613}
Douglas Gregor05f477c2009-09-23 00:16:58 +0000614
Francisco Lopes da Silva0c010cd2015-01-28 14:17:22 +0000615// This function is used solely to preserve the former presentation of overloads
616// by "clang -cc1 -code-completion-at", since CodeCompletionString::getAsString
617// needs to be improved for printing the newer and more detailed overload
618// chunks.
619static std::string getOverloadAsString(const CodeCompletionString &CCS) {
620 std::string Result;
621 llvm::raw_string_ostream OS(Result);
622
623 for (auto &C : CCS) {
624 switch (C.Kind) {
625 case CodeCompletionString::CK_Informative:
626 case CodeCompletionString::CK_ResultType:
627 OS << "[#" << C.Text << "#]";
628 break;
629
630 case CodeCompletionString::CK_CurrentParameter:
631 OS << "<#" << C.Text << "#>";
632 break;
633
Kadir Cetinkayaa32d2532018-09-10 13:46:28 +0000634 // FIXME: We can also print optional parameters of an overload.
635 case CodeCompletionString::CK_Optional:
636 break;
637
Fangrui Songde314b32018-11-25 20:57:05 +0000638 default:
639 OS << C.Text;
640 break;
Francisco Lopes da Silva0c010cd2015-01-28 14:17:22 +0000641 }
642 }
643 return OS.str();
644}
645
Ilya Biryukov2fab2352018-08-30 13:08:03 +0000646void PrintingCodeCompleteConsumer::ProcessOverloadCandidates(
647 Sema &SemaRef, unsigned CurrentArg, OverloadCandidate *Candidates,
648 unsigned NumCandidates, SourceLocation OpenParLoc) {
649 OS << "OPENING_PAREN_LOC: ";
650 OpenParLoc.print(OS, SemaRef.getSourceManager());
651 OS << "\n";
652
Douglas Gregor05f477c2009-09-23 00:16:58 +0000653 for (unsigned I = 0; I != NumCandidates; ++I) {
Ilya Biryukov2fab2352018-08-30 13:08:03 +0000654 if (CodeCompletionString *CCS = Candidates[I].CreateSignatureString(
655 CurrentArg, SemaRef, getAllocator(), CCTUInfo,
656 includeBriefComments())) {
Francisco Lopes da Silva0c010cd2015-01-28 14:17:22 +0000657 OS << "OVERLOAD: " << getOverloadAsString(*CCS) << "\n";
Douglas Gregor05f477c2009-09-23 00:16:58 +0000658 }
659 }
Douglas Gregor05f477c2009-09-23 00:16:58 +0000660}
Douglas Gregor9eb77012009-11-07 00:00:49 +0000661
Adrian Prantl9fc8faf2018-05-09 01:00:01 +0000662/// Retrieve the effective availability of the given declaration.
Dmitri Gribenkofe0483d2013-01-23 17:21:11 +0000663static AvailabilityResult getDeclAvailability(const Decl *D) {
Douglas Gregor7b316822012-03-17 06:39:06 +0000664 AvailabilityResult AR = D->getAvailability();
665 if (isa<EnumConstantDecl>(D))
666 AR = std::max(AR, cast<Decl>(D->getDeclContext())->getAvailability());
667 return AR;
668}
669
Erik Verbruggen2e657ff2011-10-06 07:27:49 +0000670void CodeCompletionResult::computeCursorKindAndAvailability(bool Accessible) {
Douglas Gregorb14904c2010-08-13 22:48:40 +0000671 switch (Kind) {
Douglas Gregor78254c82012-03-27 23:34:16 +0000672 case RK_Pattern:
673 if (!Declaration) {
674 // Do nothing: Patterns can come with cursor kinds!
675 break;
676 }
Adrian Prantlf3b3ccd2017-12-19 22:06:11 +0000677 LLVM_FALLTHROUGH;
Fangrui Song6907ce22018-07-30 19:24:48 +0000678
Douglas Gregor7b316822012-03-17 06:39:06 +0000679 case RK_Declaration: {
Douglas Gregorf757a122010-08-23 23:00:57 +0000680 // Set the availability based on attributes.
Douglas Gregor7b316822012-03-17 06:39:06 +0000681 switch (getDeclAvailability(Declaration)) {
Douglas Gregor20b2ebd2011-03-23 00:50:03 +0000682 case AR_Available:
683 case AR_NotYetIntroduced:
Fangrui Song6907ce22018-07-30 19:24:48 +0000684 Availability = CXAvailability_Available;
Douglas Gregor20b2ebd2011-03-23 00:50:03 +0000685 break;
Fangrui Song6907ce22018-07-30 19:24:48 +0000686
Douglas Gregor20b2ebd2011-03-23 00:50:03 +0000687 case AR_Deprecated:
688 Availability = CXAvailability_Deprecated;
689 break;
Fangrui Song6907ce22018-07-30 19:24:48 +0000690
Douglas Gregor20b2ebd2011-03-23 00:50:03 +0000691 case AR_Unavailable:
692 Availability = CXAvailability_NotAvailable;
693 break;
694 }
695
Fangrui Songde314b32018-11-25 20:57:05 +0000696 if (const auto *Function = dyn_cast<FunctionDecl>(Declaration))
Douglas Gregor09c0eb12010-09-03 23:30:36 +0000697 if (Function->isDeleted())
Douglas Gregorf757a122010-08-23 23:00:57 +0000698 Availability = CXAvailability_NotAvailable;
Fangrui Song6907ce22018-07-30 19:24:48 +0000699
Douglas Gregor09c0eb12010-09-03 23:30:36 +0000700 CursorKind = getCursorKindForDecl(Declaration);
Douglas Gregordeafd0b2011-12-27 22:43:10 +0000701 if (CursorKind == CXCursor_UnexposedDecl) {
Fangrui Song6907ce22018-07-30 19:24:48 +0000702 // FIXME: Forward declarations of Objective-C classes and protocols
703 // are not directly exposed, but we want code completion to treat them
Douglas Gregorf6102672012-01-01 21:23:57 +0000704 // like a definition.
Douglas Gregordeafd0b2011-12-27 22:43:10 +0000705 if (isa<ObjCInterfaceDecl>(Declaration))
706 CursorKind = CXCursor_ObjCInterfaceDecl;
Douglas Gregorf6102672012-01-01 21:23:57 +0000707 else if (isa<ObjCProtocolDecl>(Declaration))
708 CursorKind = CXCursor_ObjCProtocolDecl;
Douglas Gregordeafd0b2011-12-27 22:43:10 +0000709 else
710 CursorKind = CXCursor_NotImplemented;
711 }
Douglas Gregorb14904c2010-08-13 22:48:40 +0000712 break;
Douglas Gregor7b316822012-03-17 06:39:06 +0000713 }
Douglas Gregorb14904c2010-08-13 22:48:40 +0000714
John McCall276321a2010-08-25 06:19:51 +0000715 case RK_Macro:
John McCall276321a2010-08-25 06:19:51 +0000716 case RK_Keyword:
Benjamin Kramerc25c0b92012-05-20 14:19:46 +0000717 llvm_unreachable("Macro and keyword kinds are handled by the constructors");
Douglas Gregor8e984da2010-08-04 16:47:14 +0000718 }
Erik Verbruggen2e657ff2011-10-06 07:27:49 +0000719
720 if (!Accessible)
721 Availability = CXAvailability_NotAccessible;
Douglas Gregor8e984da2010-08-04 16:47:14 +0000722}
Douglas Gregorf09935f2009-12-01 05:55:20 +0000723
Adrian Prantl9fc8faf2018-05-09 01:00:01 +0000724/// Retrieve the name that should be used to order a result.
Douglas Gregor0de55ce2010-08-25 18:41:16 +0000725///
726/// If the name needs to be constructed as a string, that string will be
727/// saved into Saved and the returned StringRef will refer to it.
Sam McCall1102a862017-11-15 09:15:06 +0000728StringRef CodeCompletionResult::getOrderedName(std::string &Saved) const {
729 switch (Kind) {
Fangrui Songde314b32018-11-25 20:57:05 +0000730 case RK_Keyword:
731 return Keyword;
732 case RK_Pattern:
733 return Pattern->getTypedText();
734 case RK_Macro:
735 return Macro->getName();
736 case RK_Declaration:
737 // Handle declarations below.
738 break;
Douglas Gregor0de55ce2010-08-25 18:41:16 +0000739 }
Fangrui Song6907ce22018-07-30 19:24:48 +0000740
Sam McCall1102a862017-11-15 09:15:06 +0000741 DeclarationName Name = Declaration->getDeclName();
Fangrui Song6907ce22018-07-30 19:24:48 +0000742
Douglas Gregor0de55ce2010-08-25 18:41:16 +0000743 // If the name is a simple identifier (by far the common case), or a
744 // zero-argument selector, just return a reference to that identifier.
745 if (IdentifierInfo *Id = Name.getAsIdentifierInfo())
746 return Id->getName();
747 if (Name.isObjCZeroArgSelector())
Fangrui Songde314b32018-11-25 20:57:05 +0000748 if (IdentifierInfo *Id = Name.getObjCSelector().getIdentifierInfoForSlot(0))
Douglas Gregor0de55ce2010-08-25 18:41:16 +0000749 return Id->getName();
Fangrui Song6907ce22018-07-30 19:24:48 +0000750
Douglas Gregor0de55ce2010-08-25 18:41:16 +0000751 Saved = Name.getAsString();
752 return Saved;
753}
Fangrui Song6907ce22018-07-30 19:24:48 +0000754
755bool clang::operator<(const CodeCompletionResult &X,
Douglas Gregor0de55ce2010-08-25 18:41:16 +0000756 const CodeCompletionResult &Y) {
757 std::string XSaved, YSaved;
Sam McCall1102a862017-11-15 09:15:06 +0000758 StringRef XStr = X.getOrderedName(XSaved);
759 StringRef YStr = Y.getOrderedName(YSaved);
Douglas Gregor0de55ce2010-08-25 18:41:16 +0000760 int cmp = XStr.compare_lower(YStr);
761 if (cmp)
762 return cmp < 0;
Fangrui Song6907ce22018-07-30 19:24:48 +0000763
Douglas Gregor49f67ce2010-08-26 13:48:20 +0000764 // If case-insensitive comparison fails, try case-sensitive comparison.
Fangrui Songde314b32018-11-25 20:57:05 +0000765 return XStr.compare(YStr) < 0;
Douglas Gregor0de55ce2010-08-25 18:41:16 +0000766}