 |
|
 |
|
| Files: |
1 |
|
Branches Taken: |
61.8% |
102 / 165 |
| Generated: |
2010-02-10 01:31 |
|
Branches Executed: |
84.8% |
140 / 165 |
| |
|
Line Coverage: |
89.0% |
218 / 245 |
| |
 |
|
 |
1 : //===--- CodeCompleteConsumer.cpp - Code Completion Interface ---*- C++ -*-===//
2 : //
3 : // The LLVM Compiler Infrastructure
4 : //
5 : // This file is distributed under the University of Illinois Open Source
6 : // License. See LICENSE.TXT for details.
7 : //
8 : //===----------------------------------------------------------------------===//
9 : //
10 : // This file implements the CodeCompleteConsumer class.
11 : //
12 : //===----------------------------------------------------------------------===//
13 : #include "clang/Sema/CodeCompleteConsumer.h"
14 : #include "clang/AST/DeclCXX.h"
15 : #include "clang/Parse/Scope.h"
16 : #include "clang/Lex/Preprocessor.h"
17 : #include "clang-c/Index.h"
18 : #include "Sema.h"
19 : #include "llvm/ADT/STLExtras.h"
20 : #include "llvm/ADT/StringSwitch.h"
21 : #include "llvm/Support/raw_ostream.h"
22 : #include <algorithm>
23 : #include <cstring>
24 : #include <functional>
25 :
26 : using namespace clang;
27 : using llvm::StringRef;
28 :
29 : //===----------------------------------------------------------------------===//
30 : // Code completion string implementation
31 : //===----------------------------------------------------------------------===//
32 6189: CodeCompletionString::Chunk::Chunk(ChunkKind Kind, llvm::StringRef Text)
33 6189: : Kind(Kind), Text("")
34 : {
5190: branch 0 taken
0: branch 1 not taken
243: branch 2 taken
243: branch 3 taken
4: branch 4 taken
4: branch 5 taken
82: branch 6 taken
82: branch 7 taken
15: branch 8 taken
15: branch 9 taken
25: branch 10 taken
3: branch 11 taken
84: branch 12 taken
1: branch 13 taken
140: branch 14 taken
58: branch 15 taken
0: branch 16 not taken
0: branch 17 not taken
0: branch 18 not taken
0: branch 19 not taken
0: branch 20 not taken
0: branch 21 not taken
0: branch 22 not taken
0: branch 23 not taken
0: branch 24 not taken
0: branch 25 not taken
0: branch 26 not taken
0: branch 27 not taken
0: branch 28 not taken
0: branch 29 not taken
0: branch 30 not taken
0: branch 31 not taken
0: branch 32 not taken
0: branch 33 not taken
35 6189: switch (Kind) {
36 : case CK_TypedText:
37 : case CK_Text:
38 : case CK_Placeholder:
39 : case CK_Informative:
40 : case CK_ResultType:
41 : case CK_CurrentParameter: {
42 5190: char *New = new char [Text.size() + 1];
43 5190: std::memcpy(New, Text.data(), Text.size());
44 5190: New[Text.size()] = '\0';
45 5190: this->Text = New;
46 5190: break;
47 : }
48 :
49 : case CK_Optional:
50 0: llvm_unreachable("Optional strings cannot be created from text");
51 : break;
52 :
53 : case CK_LeftParen:
54 243: this->Text = "(";
55 243: break;
56 :
57 : case CK_RightParen:
58 243: this->Text = ")";
59 243: break;
60 :
61 : case CK_LeftBracket:
62 4: this->Text = "[";
63 4: break;
64 :
65 : case CK_RightBracket:
66 4: this->Text = "]";
67 4: break;
68 :
69 : case CK_LeftBrace:
70 82: this->Text = "{";
71 82: break;
72 :
73 : case CK_RightBrace:
74 82: this->Text = "}";
75 82: break;
76 :
77 : case CK_LeftAngle:
78 15: this->Text = "<";
79 15: break;
80 :
81 : case CK_RightAngle:
82 15: this->Text = ">";
83 15: break;
84 :
85 : case CK_Comma:
86 25: this->Text = ", ";
87 25: break;
88 :
89 : case CK_Colon:
90 3: this->Text = ": ";
91 3: break;
92 :
93 : case CK_SemiColon:
94 84: this->Text = ";";
95 84: break;
96 :
97 : case CK_Equal:
98 1: this->Text = " = ";
99 1: break;
100 :
101 : case CK_HorizontalSpace:
102 140: this->Text = " ";
103 140: break;
104 :
105 : case CK_VerticalSpace:
106 58: this->Text = "\n";
107 : break;
108 : }
109 6189: }
110 :
111 : CodeCompletionString::Chunk
112 91: CodeCompletionString::Chunk::CreateText(StringRef Text) {
113 91: return Chunk(CK_Text, Text);
114 : }
115 :
116 : CodeCompletionString::Chunk
117 : CodeCompletionString::Chunk::CreateOptional(
118 5: std::auto_ptr<CodeCompletionString> Optional) {
119 5: Chunk Result;
120 5: Result.Kind = CK_Optional;
121 5: Result.Optional = Optional.release();
122 : return Result;
123 : }
124 :
125 : CodeCompletionString::Chunk
126 271: CodeCompletionString::Chunk::CreatePlaceholder(StringRef Placeholder) {
127 271: return Chunk(CK_Placeholder, Placeholder);
128 : }
129 :
130 : CodeCompletionString::Chunk
131 33: CodeCompletionString::Chunk::CreateInformative(StringRef Informative) {
132 33: return Chunk(CK_Informative, Informative);
133 : }
134 :
135 : CodeCompletionString::Chunk
136 180: CodeCompletionString::Chunk::CreateResultType(StringRef ResultType) {
137 180: return Chunk(CK_ResultType, ResultType);
138 : }
139 :
140 : CodeCompletionString::Chunk
141 : CodeCompletionString::Chunk::CreateCurrentParameter(
142 0: StringRef CurrentParameter) {
143 0: return Chunk(CK_CurrentParameter, CurrentParameter);
144 : }
145 :
146 372: CodeCompletionString::Chunk CodeCompletionString::Chunk::Clone() const {
372: branch 0 taken
0: branch 1 not taken
0: branch 2 not taken
147 372: switch (Kind) {
148 : case CK_TypedText:
149 : case CK_Text:
150 : case CK_Placeholder:
151 : case CK_Informative:
152 : case CK_ResultType:
153 : case CK_CurrentParameter:
154 : case CK_LeftParen:
155 : case CK_RightParen:
156 : case CK_LeftBracket:
157 : case CK_RightBracket:
158 : case CK_LeftBrace:
159 : case CK_RightBrace:
160 : case CK_LeftAngle:
161 : case CK_RightAngle:
162 : case CK_Comma:
163 : case CK_Colon:
164 : case CK_SemiColon:
165 : case CK_Equal:
166 : case CK_HorizontalSpace:
167 : case CK_VerticalSpace:
168 372: return Chunk(Kind, Text);
169 :
170 : case CK_Optional: {
171 0: std::auto_ptr<CodeCompletionString> Opt(Optional->Clone());
172 0: return CreateOptional(Opt);
173 : }
174 : }
175 :
176 : // Silence GCC warning.
177 0: return Chunk();
178 : }
179 :
180 : void
181 3931: CodeCompletionString::Chunk::Destroy() {
4: branch 0 taken
3171: branch 1 taken
756: branch 2 taken
182 3931: switch (Kind) {
183 : case CK_Optional:
4: branch 0 taken
0: branch 1 not taken
184 4: delete Optional;
185 4: break;
186 :
187 : case CK_TypedText:
188 : case CK_Text:
189 : case CK_Placeholder:
190 : case CK_Informative:
191 : case CK_ResultType:
192 : case CK_CurrentParameter:
3171: branch 0 taken
0: branch 1 not taken
193 3171: delete [] Text;
194 : break;
195 :
196 : case CK_LeftParen:
197 : case CK_RightParen:
198 : case CK_LeftBracket:
199 : case CK_RightBracket:
200 : case CK_LeftBrace:
201 : case CK_RightBrace:
202 : case CK_LeftAngle:
203 : case CK_RightAngle:
204 : case CK_Comma:
205 : case CK_Colon:
206 : case CK_SemiColon:
207 : case CK_Equal:
208 : case CK_HorizontalSpace:
209 : case CK_VerticalSpace:
210 : break;
211 : }
212 3931: }
213 :
214 2492: CodeCompletionString::~CodeCompletionString() {
215 : std::for_each(Chunks.begin(), Chunks.end(),
216 2492: std::mem_fun_ref(&Chunk::Destroy));
217 2492: }
218 :
219 691: std::string CodeCompletionString::getAsString() const {
220 691: std::string Result;
221 691: llvm::raw_string_ostream OS(Result);
222 :
1296: branch 2 taken
691: branch 3 taken
223 1987: for (iterator C = begin(), CEnd = end(); C != CEnd; ++C) {
3: branch 0 taken
135: branch 1 taken
103: branch 2 taken
6: branch 3 taken
1049: branch 4 taken
224 1296: switch (C->Kind) {
225 3: case CK_Optional: OS << "{#" << C->Optional->getAsString() << "#}"; break;
226 135: case CK_Placeholder: OS << "<#" << C->Text << "#>"; break;
227 :
228 : case CK_Informative:
229 : case CK_ResultType:
230 103: OS << "[#" << C->Text << "#]";
231 103: break;
232 :
233 6: case CK_CurrentParameter: OS << "<#" << C->Text << "#>"; break;
234 1049: default: OS << C->Text; break;
235 : }
236 : }
237 691: OS.flush();
238 691: return Result;
239 : }
240 :
241 1173: const char *CodeCompletionString::getTypedText() const {
1173: branch 2 taken
0: branch 3 not taken
242 1173: for (iterator C = begin(), CEnd = end(); C != CEnd; ++C)
1173: branch 0 taken
0: branch 1 not taken
243 1173: if (C->Kind == CK_TypedText)
244 1173: return C->Text;
245 :
246 0: return 0;
247 : }
248 :
249 69: CodeCompletionString *CodeCompletionString::Clone() const {
250 69: CodeCompletionString *Result = new CodeCompletionString;
372: branch 2 taken
69: branch 3 taken
251 441: for (iterator C = begin(), CEnd = end(); C != CEnd; ++C)
252 372: Result->AddChunk(C->Clone());
253 69: return Result;
254 : }
255 :
256 7745: static void WriteUnsigned(llvm::raw_ostream &OS, unsigned Value) {
257 7745: OS.write((const char *)&Value, sizeof(unsigned));
258 7745: }
259 :
260 : static bool ReadUnsigned(const char *&Memory, const char *MemoryEnd,
261 6014: unsigned &Value) {
0: branch 0 not taken
6014: branch 1 taken
262 6014: if (Memory + sizeof(unsigned) > MemoryEnd)
263 0: return true;
264 :
265 6014: memmove(&Value, Memory, sizeof(unsigned));
266 6014: Memory += sizeof(unsigned);
267 6014: return false;
268 : }
269 :
270 1732: void CodeCompletionString::Serialize(llvm::raw_ostream &OS) const {
271 : // Write the number of chunks.
272 1732: WriteUnsigned(OS, size());
273 :
2263: branch 2 taken
1732: branch 3 taken
274 3995: for (iterator C = begin(), CEnd = end(); C != CEnd; ++C) {
275 2263: WriteUnsigned(OS, C->Kind);
276 :
2019: branch 0 taken
1: branch 1 taken
243: branch 2 taken
277 2263: switch (C->Kind) {
278 : case CK_TypedText:
279 : case CK_Text:
280 : case CK_Placeholder:
281 : case CK_Informative:
282 : case CK_ResultType:
283 : case CK_CurrentParameter: {
284 2019: const char *Text = C->Text;
285 2019: unsigned StrLen = strlen(Text);
286 2019: WriteUnsigned(OS, StrLen);
287 2019: OS.write(Text, StrLen);
288 2019: break;
289 : }
290 :
291 : case CK_Optional:
292 1: C->Optional->Serialize(OS);
293 : break;
294 :
295 : case CK_LeftParen:
296 : case CK_RightParen:
297 : case CK_LeftBracket:
298 : case CK_RightBracket:
299 : case CK_LeftBrace:
300 : case CK_RightBrace:
301 : case CK_LeftAngle:
302 : case CK_RightAngle:
303 : case CK_Comma:
304 : case CK_Colon:
305 : case CK_SemiColon:
306 : case CK_Equal:
307 : case CK_HorizontalSpace:
308 : case CK_VerticalSpace:
309 : break;
310 : }
311 : }
312 1732: }
313 :
314 : CodeCompletionString *CodeCompletionString::Deserialize(const char *&Str,
315 1732: const char *StrEnd) {
1732: branch 0 taken
0: branch 1 not taken
0: branch 2 not taken
1732: branch 3 taken
316 1732: if (Str == StrEnd || *Str == 0)
317 0: return 0;
318 :
319 1732: CodeCompletionString *Result = new CodeCompletionString;
320 : unsigned NumBlocks;
0: branch 1 not taken
1732: branch 2 taken
321 1732: if (ReadUnsigned(Str, StrEnd, NumBlocks))
322 0: return Result;
323 :
2263: branch 0 taken
1732: branch 1 taken
324 3995: for (unsigned I = 0; I != NumBlocks; ++I) {
0: branch 0 not taken
2263: branch 1 taken
325 2263: if (Str + 1 >= StrEnd)
326 0: break;
327 :
328 : // Parse the next kind.
329 : unsigned KindValue;
0: branch 1 not taken
2263: branch 2 taken
330 2263: if (ReadUnsigned(Str, StrEnd, KindValue))
331 0: return Result;
332 :
2019: branch 0 taken
1: branch 1 taken
243: branch 2 taken
0: branch 3 not taken
333 2263: switch (ChunkKind Kind = (ChunkKind)KindValue) {
334 : case CK_TypedText:
335 : case CK_Text:
336 : case CK_Placeholder:
337 : case CK_Informative:
338 : case CK_ResultType:
339 : case CK_CurrentParameter: {
340 : unsigned StrLen;
2019: branch 1 taken
0: branch 2 not taken
0: branch 3 not taken
2019: branch 4 taken
0: branch 5 not taken
2019: branch 6 taken
341 2019: if (ReadUnsigned(Str, StrEnd, StrLen) || (Str + StrLen > StrEnd))
342 0: return Result;
343 :
344 2019: Result->AddChunk(Chunk(Kind, StringRef(Str, StrLen)));
345 2019: Str += StrLen;
346 2019: break;
347 : }
348 :
349 : case CK_Optional: {
350 1: std::auto_ptr<CodeCompletionString> Optional(Deserialize(Str, StrEnd));
351 1: Result->AddOptionalChunk(Optional);
352 1: break;
353 : }
354 :
355 : case CK_LeftParen:
356 : case CK_RightParen:
357 : case CK_LeftBracket:
358 : case CK_RightBracket:
359 : case CK_LeftBrace:
360 : case CK_RightBrace:
361 : case CK_LeftAngle:
362 : case CK_RightAngle:
363 : case CK_Comma:
364 : case CK_Colon:
365 : case CK_SemiColon:
366 : case CK_Equal:
367 : case CK_HorizontalSpace:
368 : case CK_VerticalSpace:
369 243: Result->AddChunk(Chunk(Kind));
370 : break;
371 : }
372 : };
373 :
374 1732: return Result;
375 : }
376 :
377 2581: void CodeCompleteConsumer::Result::Destroy() {
132: branch 0 taken
2449: branch 1 taken
378 2581: if (Kind == RK_Pattern) {
132: branch 0 taken
0: branch 1 not taken
379 132: delete Pattern;
380 132: Pattern = 0;
381 : }
382 2581: }
383 :
384 : //===----------------------------------------------------------------------===//
385 : // Code completion overload candidate implementation
386 : //===----------------------------------------------------------------------===//
387 : FunctionDecl *
388 10: CodeCompleteConsumer::OverloadCandidate::getFunction() const {
10: branch 1 taken
0: branch 2 not taken
389 10: if (getKind() == CK_Function)
390 10: return Function;
0: branch 1 not taken
0: branch 2 not taken
391 0: else if (getKind() == CK_FunctionTemplate)
392 0: return FunctionTemplate->getTemplatedDecl();
393 : else
394 0: return 0;
395 : }
396 :
397 : const FunctionType *
398 10: CodeCompleteConsumer::OverloadCandidate::getFunctionType() const {
10: branch 0 taken
0: branch 1 not taken
0: branch 2 not taken
0: branch 3 not taken
399 10: switch (Kind) {
400 : case CK_Function:
401 10: return Function->getType()->getAs<FunctionType>();
402 :
403 : case CK_FunctionTemplate:
404 : return FunctionTemplate->getTemplatedDecl()->getType()
405 0: ->getAs<FunctionType>();
406 :
407 : case CK_FunctionType:
408 0: return Type;
409 : }
410 :
411 0: return 0;
412 : }
413 :
414 : //===----------------------------------------------------------------------===//
415 : // Code completion consumer implementation
416 : //===----------------------------------------------------------------------===//
417 :
87: branch 0 taken
87: branch 1 taken
0: branch 3 not taken
0: branch 4 not taken
0: branch 6 not taken
87: branch 7 taken
418 87: CodeCompleteConsumer::~CodeCompleteConsumer() { }
419 :
420 : void
421 : PrintingCodeCompleteConsumer::ProcessCodeCompleteResults(Sema &SemaRef,
422 : Result *Results,
423 31: unsigned NumResults) {
424 : // Print the results.
853: branch 0 taken
31: branch 1 taken
425 884: for (unsigned I = 0; I != NumResults; ++I) {
426 853: OS << "COMPLETION: ";
142: branch 0 taken
172: branch 1 taken
476: branch 2 taken
63: branch 3 taken
0: branch 4 not taken
427 853: switch (Results[I].Kind) {
428 : case Result::RK_Declaration:
429 142: OS << Results[I].Declaration->getNameAsString() ;
7: branch 0 taken
135: branch 1 taken
430 142: if (Results[I].Hidden)
431 7: OS << " (Hidden)";
142: branch 0 taken
0: branch 1 not taken
432 142: if (CodeCompletionString *CCS
433 142: = Results[I].CreateCodeCompletionString(SemaRef)) {
434 142: OS << " : " << CCS->getAsString();
142: branch 0 taken
0: branch 1 not taken
435 142: delete CCS;
436 : }
437 :
438 142: OS << '\n';
439 142: break;
440 :
441 : case Result::RK_Keyword:
442 172: OS << Results[I].Keyword << '\n';
443 172: break;
444 :
445 : case Result::RK_Macro: {
446 476: OS << Results[I].Macro->getName();
476: branch 0 taken
0: branch 1 not taken
447 476: if (CodeCompletionString *CCS
448 476: = Results[I].CreateCodeCompletionString(SemaRef)) {
449 476: OS << " : " << CCS->getAsString();
476: branch 0 taken
0: branch 1 not taken
450 476: delete CCS;
451 : }
452 476: OS << '\n';
453 476: break;
454 : }
455 :
456 : case Result::RK_Pattern: {
457 : OS << "Pattern : "
458 63: << Results[I].Pattern->getAsString() << '\n';
459 : break;
460 : }
461 : }
462 : }
463 :
464 : // Once we've printed the code-completion results, suppress remaining
465 : // diagnostics.
466 : // FIXME: Move this somewhere else!
467 31: SemaRef.PP.getDiagnostics().setSuppressAllDiagnostics();
468 31: }
469 :
470 : void
471 : PrintingCodeCompleteConsumer::ProcessOverloadCandidates(Sema &SemaRef,
472 : unsigned CurrentArg,
473 : OverloadCandidate *Candidates,
474 5: unsigned NumCandidates) {
7: branch 0 taken
5: branch 1 taken
475 12: for (unsigned I = 0; I != NumCandidates; ++I) {
7: branch 0 taken
0: branch 1 not taken
476 7: if (CodeCompletionString *CCS
477 7: = Candidates[I].CreateSignatureString(CurrentArg, SemaRef)) {
478 7: OS << "OVERLOAD: " << CCS->getAsString() << "\n";
7: branch 0 taken
0: branch 1 not taken
479 7: delete CCS;
480 : }
481 : }
482 :
483 : // Once we've printed the code-completion results, suppress remaining
484 : // diagnostics.
485 : // FIXME: Move this somewhere else!
486 5: SemaRef.PP.getDiagnostics().setSuppressAllDiagnostics();
487 5: }
488 :
489 : void
490 : CIndexCodeCompleteConsumer::ProcessCodeCompleteResults(Sema &SemaRef,
491 : Result *Results,
492 50: unsigned NumResults) {
493 : // Print the results.
1728: branch 0 taken
50: branch 1 taken
494 1778: for (unsigned I = 0; I != NumResults; ++I) {
495 1728: CXCursorKind Kind = CXCursor_NotImplemented;
496 :
151: branch 0 taken
1577: branch 1 taken
0: branch 2 not taken
497 1728: switch (Results[I].Kind) {
498 : case Result::RK_Declaration:
3: branch 1 taken
44: branch 2 taken
15: branch 3 taken
0: branch 4 not taken
5: branch 5 taken
1: branch 6 taken
12: branch 7 taken
2: branch 8 taken
1: branch 9 taken
28: branch 10 taken
13: branch 11 taken
5: branch 12 taken
13: branch 13 taken
5: branch 14 taken
0: branch 15 not taken
0: branch 16 not taken
4: branch 17 taken
499 151: switch (Results[I].Declaration->getKind()) {
500 : case Decl::Record:
501 : case Decl::CXXRecord:
502 : case Decl::ClassTemplateSpecialization: {
503 3: RecordDecl *Record = cast<RecordDecl>(Results[I].Declaration);
3: branch 1 taken
0: branch 2 not taken
504 3: if (Record->isStruct())
505 3: Kind = CXCursor_StructDecl;
0: branch 1 not taken
0: branch 2 not taken
506 0: else if (Record->isUnion())
507 0: Kind = CXCursor_UnionDecl;
508 : else
509 0: Kind = CXCursor_ClassDecl;
510 3: break;
511 : }
512 :
513 : case Decl::ObjCMethod: {
514 44: ObjCMethodDecl *Method = cast<ObjCMethodDecl>(Results[I].Declaration);
37: branch 1 taken
7: branch 2 taken
515 44: if (Method->isInstanceMethod())
516 37: Kind = CXCursor_ObjCInstanceMethodDecl;
517 : else
518 7: Kind = CXCursor_ObjCClassMethodDecl;
519 44: break;
520 : }
521 :
522 : case Decl::Typedef:
523 15: Kind = CXCursor_TypedefDecl;
524 15: break;
525 :
526 : case Decl::Enum:
527 0: Kind = CXCursor_EnumDecl;
528 0: break;
529 :
530 : case Decl::Field:
531 5: Kind = CXCursor_FieldDecl;
532 5: break;
533 :
534 : case Decl::EnumConstant:
535 1: Kind = CXCursor_EnumConstantDecl;
536 1: break;
537 :
538 : case Decl::Function:
539 : case Decl::CXXMethod:
540 : case Decl::CXXConstructor:
541 : case Decl::CXXDestructor:
542 : case Decl::CXXConversion:
543 12: Kind = CXCursor_FunctionDecl;
544 12: break;
545 :
546 : case Decl::Var:
547 2: Kind = CXCursor_VarDecl;
548 2: break;
549 :
550 : case Decl::ParmVar:
551 1: Kind = CXCursor_ParmDecl;
552 1: break;
553 :
554 : case Decl::ObjCInterface:
555 28: Kind = CXCursor_ObjCInterfaceDecl;
556 28: break;
557 :
558 : case Decl::ObjCCategory:
559 13: Kind = CXCursor_ObjCCategoryDecl;
560 13: break;
561 :
562 : case Decl::ObjCProtocol:
563 5: Kind = CXCursor_ObjCProtocolDecl;
564 5: break;
565 :
566 : case Decl::ObjCProperty:
567 13: Kind = CXCursor_ObjCPropertyDecl;
568 13: break;
569 :
570 : case Decl::ObjCIvar:
571 5: Kind = CXCursor_ObjCIvarDecl;
572 5: break;
573 :
574 : case Decl::ObjCImplementation:
575 0: Kind = CXCursor_ObjCImplementationDecl;
576 0: break;
577 :
578 : case Decl::ObjCCategoryImpl:
579 0: Kind = CXCursor_ObjCCategoryImplDecl;
580 : break;
581 :
582 : default:
583 : break;
584 : }
585 151: break;
586 :
587 : case Result::RK_Keyword:
588 : case Result::RK_Macro:
589 : case Result::RK_Pattern:
590 1577: Kind = CXCursor_NotImplemented;
591 : break;
592 : }
593 :
594 1728: WriteUnsigned(OS, Kind);
595 1728: CodeCompletionString *CCS = Results[I].CreateCodeCompletionString(SemaRef);
0: branch 0 not taken
1728: branch 1 taken
596 1728: assert(CCS && "No code-completion string?");
597 1728: CCS->Serialize(OS);
1728: branch 0 taken
0: branch 1 not taken
598 1728: delete CCS;
599 : }
600 :
601 : // Once we've printed the code-completion results, suppress remaining
602 : // diagnostics.
603 : // FIXME: Move this somewhere else!
604 50: SemaRef.PP.getDiagnostics().setSuppressAllDiagnostics();
605 50: }
606 :
607 : void
608 : CIndexCodeCompleteConsumer::ProcessOverloadCandidates(Sema &SemaRef,
609 : unsigned CurrentArg,
610 : OverloadCandidate *Candidates,
611 1: unsigned NumCandidates) {
3: branch 0 taken
1: branch 1 taken
612 4: for (unsigned I = 0; I != NumCandidates; ++I) {
613 3: WriteUnsigned(OS, CXCursor_NotImplemented);
614 : CodeCompletionString *CCS
615 3: = Candidates[I].CreateSignatureString(CurrentArg, SemaRef);
0: branch 0 not taken
3: branch 1 taken
616 3: assert(CCS && "No code-completion string?");
617 3: CCS->Serialize(OS);
3: branch 0 taken
0: branch 1 not taken
618 3: delete CCS;
619 : }
620 :
621 : // Once we've printed the code-completion results, suppress remaining
622 : // diagnostics.
623 : // FIXME: Move this somewhere else!
624 1: SemaRef.PP.getDiagnostics().setSuppressAllDiagnostics();
625 1: }
Generated: 2010-02-10 01:31 by zcov