2009-09-22 00:56:56 +08:00
|
|
|
//===--- CodeCompleteConsumer.cpp - Code Completion Interface ---*- C++ -*-===//
|
Initial implementation of a code-completion interface in Clang. In
essence, code completion is triggered by a magic "code completion"
token produced by the lexer [*], which the parser recognizes at
certain points in the grammar. The parser then calls into the Action
object with the appropriate CodeCompletionXXX action.
Sema implements the CodeCompletionXXX callbacks by performing minimal
translation, then forwarding them to a CodeCompletionConsumer
subclass, which uses the results of semantic analysis to provide
code-completion results. At present, only a single, "printing" code
completion consumer is available, for regression testing and
debugging. However, the design is meant to permit other
code-completion consumers.
This initial commit contains two code-completion actions: one for
member access, e.g., "x." or "p->", and one for
nested-name-specifiers, e.g., "std::". More code-completion actions
will follow, along with improved gathering of code-completion results
for the various contexts.
[*] In the current -code-completion-dump testing/debugging mode, the
file is truncated at the completion point and EOF is translated into
"code completion".
llvm-svn: 82166
2009-09-18 05:32:03 +08:00
|
|
|
//
|
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
//
|
|
|
|
// This file implements the CodeCompleteConsumer class.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "clang/Sema/CodeCompleteConsumer.h"
|
2010-08-21 02:27:03 +08:00
|
|
|
#include "clang/Sema/Scope.h"
|
2010-08-13 04:07:10 +08:00
|
|
|
#include "clang/Sema/Sema.h"
|
2009-09-19 01:54:00 +08:00
|
|
|
#include "clang/AST/DeclCXX.h"
|
2010-08-24 15:21:54 +08:00
|
|
|
#include "clang/AST/DeclObjC.h"
|
2010-08-25 13:32:35 +08:00
|
|
|
#include "clang/AST/DeclTemplate.h"
|
Initial implementation of a code-completion interface in Clang. In
essence, code completion is triggered by a magic "code completion"
token produced by the lexer [*], which the parser recognizes at
certain points in the grammar. The parser then calls into the Action
object with the appropriate CodeCompletionXXX action.
Sema implements the CodeCompletionXXX callbacks by performing minimal
translation, then forwarding them to a CodeCompletionConsumer
subclass, which uses the results of semantic analysis to provide
code-completion results. At present, only a single, "printing" code
completion consumer is available, for regression testing and
debugging. However, the design is meant to permit other
code-completion consumers.
This initial commit contains two code-completion actions: one for
member access, e.g., "x." or "p->", and one for
nested-name-specifiers, e.g., "std::". More code-completion actions
will follow, along with improved gathering of code-completion results
for the various contexts.
[*] In the current -code-completion-dump testing/debugging mode, the
file is truncated at the completion point and EOF is translated into
"code completion".
llvm-svn: 82166
2009-09-18 05:32:03 +08:00
|
|
|
#include "clang/Lex/Preprocessor.h"
|
2009-12-01 13:55:20 +08:00
|
|
|
#include "clang-c/Index.h"
|
Initial implementation of a code-completion interface in Clang. In
essence, code completion is triggered by a magic "code completion"
token produced by the lexer [*], which the parser recognizes at
certain points in the grammar. The parser then calls into the Action
object with the appropriate CodeCompletionXXX action.
Sema implements the CodeCompletionXXX callbacks by performing minimal
translation, then forwarding them to a CodeCompletionConsumer
subclass, which uses the results of semantic analysis to provide
code-completion results. At present, only a single, "printing" code
completion consumer is available, for regression testing and
debugging. However, the design is meant to permit other
code-completion consumers.
This initial commit contains two code-completion actions: one for
member access, e.g., "x." or "p->", and one for
nested-name-specifiers, e.g., "std::". More code-completion actions
will follow, along with improved gathering of code-completion results
for the various contexts.
[*] In the current -code-completion-dump testing/debugging mode, the
file is truncated at the completion point and EOF is translated into
"code completion".
llvm-svn: 82166
2009-09-18 05:32:03 +08:00
|
|
|
#include "llvm/ADT/STLExtras.h"
|
|
|
|
#include "llvm/Support/raw_ostream.h"
|
|
|
|
#include <algorithm>
|
2009-09-19 06:15:54 +08:00
|
|
|
#include <cstring>
|
|
|
|
#include <functional>
|
2009-11-18 00:43:05 +08:00
|
|
|
|
Initial implementation of a code-completion interface in Clang. In
essence, code completion is triggered by a magic "code completion"
token produced by the lexer [*], which the parser recognizes at
certain points in the grammar. The parser then calls into the Action
object with the appropriate CodeCompletionXXX action.
Sema implements the CodeCompletionXXX callbacks by performing minimal
translation, then forwarding them to a CodeCompletionConsumer
subclass, which uses the results of semantic analysis to provide
code-completion results. At present, only a single, "printing" code
completion consumer is available, for regression testing and
debugging. However, the design is meant to permit other
code-completion consumers.
This initial commit contains two code-completion actions: one for
member access, e.g., "x." or "p->", and one for
nested-name-specifiers, e.g., "std::". More code-completion actions
will follow, along with improved gathering of code-completion results
for the various contexts.
[*] In the current -code-completion-dump testing/debugging mode, the
file is truncated at the completion point and EOF is translated into
"code completion".
llvm-svn: 82166
2009-09-18 05:32:03 +08:00
|
|
|
using namespace clang;
|
2009-11-18 00:43:05 +08:00
|
|
|
using llvm::StringRef;
|
Initial implementation of a code-completion interface in Clang. In
essence, code completion is triggered by a magic "code completion"
token produced by the lexer [*], which the parser recognizes at
certain points in the grammar. The parser then calls into the Action
object with the appropriate CodeCompletionXXX action.
Sema implements the CodeCompletionXXX callbacks by performing minimal
translation, then forwarding them to a CodeCompletionConsumer
subclass, which uses the results of semantic analysis to provide
code-completion results. At present, only a single, "printing" code
completion consumer is available, for regression testing and
debugging. However, the design is meant to permit other
code-completion consumers.
This initial commit contains two code-completion actions: one for
member access, e.g., "x." or "p->", and one for
nested-name-specifiers, e.g., "std::". More code-completion actions
will follow, along with improved gathering of code-completion results
for the various contexts.
[*] In the current -code-completion-dump testing/debugging mode, the
file is truncated at the completion point and EOF is translated into
"code completion".
llvm-svn: 82166
2009-09-18 05:32:03 +08:00
|
|
|
|
2010-09-22 00:06:22 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Code completion context implementation
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
bool CodeCompletionContext::wantConstructorResults() const {
|
|
|
|
switch (Kind) {
|
|
|
|
case CCC_Other:
|
|
|
|
case CCC_Statement:
|
|
|
|
case CCC_Expression:
|
|
|
|
case CCC_ObjCMessageReceiver:
|
|
|
|
case CCC_ParenthesizedExpression:
|
|
|
|
return true;
|
|
|
|
|
|
|
|
case CCC_TopLevel:
|
|
|
|
case CCC_ObjCInterface:
|
|
|
|
case CCC_ObjCImplementation:
|
|
|
|
case CCC_ObjCIvarList:
|
|
|
|
case CCC_ClassStructUnion:
|
|
|
|
case CCC_MemberAccess:
|
|
|
|
case CCC_EnumTag:
|
|
|
|
case CCC_UnionTag:
|
|
|
|
case CCC_ClassOrStructTag:
|
|
|
|
case CCC_ObjCProtocolName:
|
|
|
|
case CCC_Namespace:
|
|
|
|
case CCC_Type:
|
|
|
|
case CCC_Name:
|
|
|
|
case CCC_PotentiallyQualifiedName:
|
|
|
|
case CCC_MacroName:
|
|
|
|
case CCC_MacroNameUse:
|
|
|
|
case CCC_PreprocessorExpression:
|
|
|
|
case CCC_PreprocessorDirective:
|
|
|
|
case CCC_NaturalLanguage:
|
|
|
|
case CCC_SelectorName:
|
|
|
|
case CCC_TypeQualifiers:
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2009-09-19 06:15:54 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Code completion string implementation
|
|
|
|
//===----------------------------------------------------------------------===//
|
2009-11-07 08:00:49 +08:00
|
|
|
CodeCompletionString::Chunk::Chunk(ChunkKind Kind, llvm::StringRef Text)
|
2009-11-13 02:40:12 +08:00
|
|
|
: Kind(Kind), Text("")
|
2009-09-23 07:15:58 +08:00
|
|
|
{
|
2009-11-07 08:00:49 +08:00
|
|
|
switch (Kind) {
|
|
|
|
case CK_TypedText:
|
|
|
|
case CK_Text:
|
|
|
|
case CK_Placeholder:
|
|
|
|
case CK_Informative:
|
2009-12-19 02:53:37 +08:00
|
|
|
case CK_ResultType:
|
2009-11-07 08:00:49 +08:00
|
|
|
case CK_CurrentParameter: {
|
|
|
|
char *New = new char [Text.size() + 1];
|
|
|
|
std::memcpy(New, Text.data(), Text.size());
|
|
|
|
New[Text.size()] = '\0';
|
|
|
|
this->Text = New;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
case CK_Optional:
|
2009-12-12 13:05:38 +08:00
|
|
|
llvm_unreachable("Optional strings cannot be created from text");
|
2009-11-07 08:00:49 +08:00
|
|
|
break;
|
|
|
|
|
|
|
|
case CK_LeftParen:
|
|
|
|
this->Text = "(";
|
|
|
|
break;
|
|
|
|
|
|
|
|
case CK_RightParen:
|
|
|
|
this->Text = ")";
|
|
|
|
break;
|
|
|
|
|
|
|
|
case CK_LeftBracket:
|
|
|
|
this->Text = "[";
|
|
|
|
break;
|
|
|
|
|
|
|
|
case CK_RightBracket:
|
|
|
|
this->Text = "]";
|
|
|
|
break;
|
|
|
|
|
|
|
|
case CK_LeftBrace:
|
|
|
|
this->Text = "{";
|
|
|
|
break;
|
|
|
|
|
|
|
|
case CK_RightBrace:
|
|
|
|
this->Text = "}";
|
|
|
|
break;
|
|
|
|
|
|
|
|
case CK_LeftAngle:
|
|
|
|
this->Text = "<";
|
|
|
|
break;
|
|
|
|
|
|
|
|
case CK_RightAngle:
|
|
|
|
this->Text = ">";
|
|
|
|
break;
|
|
|
|
|
|
|
|
case CK_Comma:
|
|
|
|
this->Text = ", ";
|
|
|
|
break;
|
Improve code completion by introducing patterns for the various C and
C++ grammatical constructs that show up in top-level (namespace-level)
declarations, member declarations, template declarations, statements,
expressions, conditions, etc. For example, we now provide a pattern
for
static_cast<type>(expr)
when we can have an expression, or
using namespace identifier;
when we can have a using directive.
Also, improves the results of code completion at the beginning of a
top-level declaration. Previously, we would see value names (function
names, global variables, etc.); now we see types, namespace names,
etc., but no values.
llvm-svn: 93134
2010-01-11 07:08:15 +08:00
|
|
|
|
|
|
|
case CK_Colon:
|
2010-04-07 08:21:17 +08:00
|
|
|
this->Text = ":";
|
Improve code completion by introducing patterns for the various C and
C++ grammatical constructs that show up in top-level (namespace-level)
declarations, member declarations, template declarations, statements,
expressions, conditions, etc. For example, we now provide a pattern
for
static_cast<type>(expr)
when we can have an expression, or
using namespace identifier;
when we can have a using directive.
Also, improves the results of code completion at the beginning of a
top-level declaration. Previously, we would see value names (function
names, global variables, etc.); now we see types, namespace names,
etc., but no values.
llvm-svn: 93134
2010-01-11 07:08:15 +08:00
|
|
|
break;
|
|
|
|
|
|
|
|
case CK_SemiColon:
|
|
|
|
this->Text = ";";
|
|
|
|
break;
|
|
|
|
|
|
|
|
case CK_Equal:
|
|
|
|
this->Text = " = ";
|
|
|
|
break;
|
|
|
|
|
|
|
|
case CK_HorizontalSpace:
|
|
|
|
this->Text = " ";
|
|
|
|
break;
|
|
|
|
|
|
|
|
case CK_VerticalSpace:
|
|
|
|
this->Text = "\n";
|
|
|
|
break;
|
2009-11-07 08:00:49 +08:00
|
|
|
}
|
2009-09-23 07:15:58 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
CodeCompletionString::Chunk
|
2009-11-18 00:43:05 +08:00
|
|
|
CodeCompletionString::Chunk::CreateText(StringRef Text) {
|
2009-09-23 07:15:58 +08:00
|
|
|
return Chunk(CK_Text, Text);
|
2009-09-19 06:15:54 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
CodeCompletionString::Chunk
|
|
|
|
CodeCompletionString::Chunk::CreateOptional(
|
|
|
|
std::auto_ptr<CodeCompletionString> Optional) {
|
|
|
|
Chunk Result;
|
|
|
|
Result.Kind = CK_Optional;
|
|
|
|
Result.Optional = Optional.release();
|
|
|
|
return Result;
|
|
|
|
}
|
|
|
|
|
|
|
|
CodeCompletionString::Chunk
|
2009-11-18 00:43:05 +08:00
|
|
|
CodeCompletionString::Chunk::CreatePlaceholder(StringRef Placeholder) {
|
2009-09-23 07:15:58 +08:00
|
|
|
return Chunk(CK_Placeholder, Placeholder);
|
|
|
|
}
|
|
|
|
|
|
|
|
CodeCompletionString::Chunk
|
2009-11-18 00:43:05 +08:00
|
|
|
CodeCompletionString::Chunk::CreateInformative(StringRef Informative) {
|
2009-09-23 07:15:58 +08:00
|
|
|
return Chunk(CK_Informative, Informative);
|
2009-09-19 06:15:54 +08:00
|
|
|
}
|
|
|
|
|
2009-12-19 02:53:37 +08:00
|
|
|
CodeCompletionString::Chunk
|
|
|
|
CodeCompletionString::Chunk::CreateResultType(StringRef ResultType) {
|
|
|
|
return Chunk(CK_ResultType, ResultType);
|
|
|
|
}
|
|
|
|
|
2009-11-07 08:00:49 +08:00
|
|
|
CodeCompletionString::Chunk
|
|
|
|
CodeCompletionString::Chunk::CreateCurrentParameter(
|
2009-11-18 00:43:05 +08:00
|
|
|
StringRef CurrentParameter) {
|
2009-11-07 08:00:49 +08:00
|
|
|
return Chunk(CK_CurrentParameter, CurrentParameter);
|
|
|
|
}
|
|
|
|
|
2009-11-19 08:01:57 +08:00
|
|
|
CodeCompletionString::Chunk CodeCompletionString::Chunk::Clone() const {
|
|
|
|
switch (Kind) {
|
|
|
|
case CK_TypedText:
|
|
|
|
case CK_Text:
|
|
|
|
case CK_Placeholder:
|
|
|
|
case CK_Informative:
|
2009-12-19 02:53:37 +08:00
|
|
|
case CK_ResultType:
|
2009-11-19 08:01:57 +08:00
|
|
|
case CK_CurrentParameter:
|
|
|
|
case CK_LeftParen:
|
|
|
|
case CK_RightParen:
|
|
|
|
case CK_LeftBracket:
|
|
|
|
case CK_RightBracket:
|
|
|
|
case CK_LeftBrace:
|
|
|
|
case CK_RightBrace:
|
|
|
|
case CK_LeftAngle:
|
|
|
|
case CK_RightAngle:
|
|
|
|
case CK_Comma:
|
Improve code completion by introducing patterns for the various C and
C++ grammatical constructs that show up in top-level (namespace-level)
declarations, member declarations, template declarations, statements,
expressions, conditions, etc. For example, we now provide a pattern
for
static_cast<type>(expr)
when we can have an expression, or
using namespace identifier;
when we can have a using directive.
Also, improves the results of code completion at the beginning of a
top-level declaration. Previously, we would see value names (function
names, global variables, etc.); now we see types, namespace names,
etc., but no values.
llvm-svn: 93134
2010-01-11 07:08:15 +08:00
|
|
|
case CK_Colon:
|
|
|
|
case CK_SemiColon:
|
|
|
|
case CK_Equal:
|
|
|
|
case CK_HorizontalSpace:
|
|
|
|
case CK_VerticalSpace:
|
2009-11-19 08:01:57 +08:00
|
|
|
return Chunk(Kind, Text);
|
|
|
|
|
|
|
|
case CK_Optional: {
|
|
|
|
std::auto_ptr<CodeCompletionString> Opt(Optional->Clone());
|
|
|
|
return CreateOptional(Opt);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Silence GCC warning.
|
|
|
|
return Chunk();
|
|
|
|
}
|
2009-11-07 08:00:49 +08:00
|
|
|
|
2009-09-19 06:15:54 +08:00
|
|
|
void
|
|
|
|
CodeCompletionString::Chunk::Destroy() {
|
|
|
|
switch (Kind) {
|
2009-09-23 07:15:58 +08:00
|
|
|
case CK_Optional:
|
|
|
|
delete Optional;
|
|
|
|
break;
|
|
|
|
|
2009-11-07 08:00:49 +08:00
|
|
|
case CK_TypedText:
|
2009-09-23 07:15:58 +08:00
|
|
|
case CK_Text:
|
|
|
|
case CK_Placeholder:
|
|
|
|
case CK_Informative:
|
2009-12-19 02:53:37 +08:00
|
|
|
case CK_ResultType:
|
2009-11-07 08:00:49 +08:00
|
|
|
case CK_CurrentParameter:
|
|
|
|
delete [] Text;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case CK_LeftParen:
|
|
|
|
case CK_RightParen:
|
|
|
|
case CK_LeftBracket:
|
|
|
|
case CK_RightBracket:
|
|
|
|
case CK_LeftBrace:
|
|
|
|
case CK_RightBrace:
|
|
|
|
case CK_LeftAngle:
|
|
|
|
case CK_RightAngle:
|
|
|
|
case CK_Comma:
|
Improve code completion by introducing patterns for the various C and
C++ grammatical constructs that show up in top-level (namespace-level)
declarations, member declarations, template declarations, statements,
expressions, conditions, etc. For example, we now provide a pattern
for
static_cast<type>(expr)
when we can have an expression, or
using namespace identifier;
when we can have a using directive.
Also, improves the results of code completion at the beginning of a
top-level declaration. Previously, we would see value names (function
names, global variables, etc.); now we see types, namespace names,
etc., but no values.
llvm-svn: 93134
2010-01-11 07:08:15 +08:00
|
|
|
case CK_Colon:
|
|
|
|
case CK_SemiColon:
|
|
|
|
case CK_Equal:
|
|
|
|
case CK_HorizontalSpace:
|
|
|
|
case CK_VerticalSpace:
|
2009-09-23 07:15:58 +08:00
|
|
|
break;
|
2009-09-19 06:15:54 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-05-27 06:00:08 +08:00
|
|
|
void CodeCompletionString::clear() {
|
2009-09-19 06:15:54 +08:00
|
|
|
std::for_each(Chunks.begin(), Chunks.end(),
|
|
|
|
std::mem_fun_ref(&Chunk::Destroy));
|
2010-05-27 06:00:08 +08:00
|
|
|
Chunks.clear();
|
2009-09-19 06:15:54 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
std::string CodeCompletionString::getAsString() const {
|
|
|
|
std::string Result;
|
|
|
|
llvm::raw_string_ostream OS(Result);
|
|
|
|
|
|
|
|
for (iterator C = begin(), CEnd = end(); C != CEnd; ++C) {
|
|
|
|
switch (C->Kind) {
|
|
|
|
case CK_Optional: OS << "{#" << C->Optional->getAsString() << "#}"; break;
|
2009-09-23 07:15:58 +08:00
|
|
|
case CK_Placeholder: OS << "<#" << C->Text << "#>"; break;
|
2009-12-19 02:53:37 +08:00
|
|
|
|
|
|
|
case CK_Informative:
|
|
|
|
case CK_ResultType:
|
|
|
|
OS << "[#" << C->Text << "#]";
|
|
|
|
break;
|
|
|
|
|
2009-11-07 08:00:49 +08:00
|
|
|
case CK_CurrentParameter: OS << "<#" << C->Text << "#>"; break;
|
|
|
|
default: OS << C->Text; break;
|
2009-09-19 06:15:54 +08:00
|
|
|
}
|
|
|
|
}
|
2010-07-27 05:33:22 +08:00
|
|
|
return OS.str();
|
2009-09-19 06:15:54 +08:00
|
|
|
}
|
|
|
|
|
2009-11-19 08:01:57 +08:00
|
|
|
const char *CodeCompletionString::getTypedText() const {
|
|
|
|
for (iterator C = begin(), CEnd = end(); C != CEnd; ++C)
|
|
|
|
if (C->Kind == CK_TypedText)
|
|
|
|
return C->Text;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-08-05 00:47:14 +08:00
|
|
|
CodeCompletionString *
|
|
|
|
CodeCompletionString::Clone(CodeCompletionString *Result) const {
|
|
|
|
if (!Result)
|
|
|
|
Result = new CodeCompletionString;
|
2009-11-19 08:01:57 +08:00
|
|
|
for (iterator C = begin(), CEnd = end(); C != CEnd; ++C)
|
|
|
|
Result->AddChunk(C->Clone());
|
|
|
|
return Result;
|
|
|
|
}
|
2009-11-07 08:00:49 +08:00
|
|
|
|
2009-12-01 13:55:20 +08:00
|
|
|
static void WriteUnsigned(llvm::raw_ostream &OS, unsigned Value) {
|
|
|
|
OS.write((const char *)&Value, sizeof(unsigned));
|
|
|
|
}
|
2009-11-07 08:00:49 +08:00
|
|
|
|
2009-12-01 13:55:20 +08:00
|
|
|
static bool ReadUnsigned(const char *&Memory, const char *MemoryEnd,
|
|
|
|
unsigned &Value) {
|
|
|
|
if (Memory + sizeof(unsigned) > MemoryEnd)
|
|
|
|
return true;
|
|
|
|
|
|
|
|
memmove(&Value, Memory, sizeof(unsigned));
|
|
|
|
Memory += sizeof(unsigned);
|
|
|
|
return false;
|
2009-11-07 08:00:49 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
void CodeCompletionString::Serialize(llvm::raw_ostream &OS) const {
|
2009-12-01 13:55:20 +08:00
|
|
|
// Write the number of chunks.
|
|
|
|
WriteUnsigned(OS, size());
|
|
|
|
|
2009-11-07 08:00:49 +08:00
|
|
|
for (iterator C = begin(), CEnd = end(); C != CEnd; ++C) {
|
2009-12-01 13:55:20 +08:00
|
|
|
WriteUnsigned(OS, C->Kind);
|
|
|
|
|
2009-11-07 08:00:49 +08:00
|
|
|
switch (C->Kind) {
|
|
|
|
case CK_TypedText:
|
|
|
|
case CK_Text:
|
|
|
|
case CK_Placeholder:
|
|
|
|
case CK_Informative:
|
2009-12-19 02:53:37 +08:00
|
|
|
case CK_ResultType:
|
2009-12-01 13:55:20 +08:00
|
|
|
case CK_CurrentParameter: {
|
|
|
|
const char *Text = C->Text;
|
|
|
|
unsigned StrLen = strlen(Text);
|
|
|
|
WriteUnsigned(OS, StrLen);
|
|
|
|
OS.write(Text, StrLen);
|
2009-11-07 08:00:49 +08:00
|
|
|
break;
|
2009-12-01 13:55:20 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
case CK_Optional:
|
|
|
|
C->Optional->Serialize(OS);
|
2009-11-07 08:00:49 +08:00
|
|
|
break;
|
2009-12-01 13:55:20 +08:00
|
|
|
|
2009-11-07 08:00:49 +08:00
|
|
|
case CK_LeftParen:
|
|
|
|
case CK_RightParen:
|
|
|
|
case CK_LeftBracket:
|
|
|
|
case CK_RightBracket:
|
|
|
|
case CK_LeftBrace:
|
|
|
|
case CK_RightBrace:
|
|
|
|
case CK_LeftAngle:
|
|
|
|
case CK_RightAngle:
|
|
|
|
case CK_Comma:
|
Improve code completion by introducing patterns for the various C and
C++ grammatical constructs that show up in top-level (namespace-level)
declarations, member declarations, template declarations, statements,
expressions, conditions, etc. For example, we now provide a pattern
for
static_cast<type>(expr)
when we can have an expression, or
using namespace identifier;
when we can have a using directive.
Also, improves the results of code completion at the beginning of a
top-level declaration. Previously, we would see value names (function
names, global variables, etc.); now we see types, namespace names,
etc., but no values.
llvm-svn: 93134
2010-01-11 07:08:15 +08:00
|
|
|
case CK_Colon:
|
|
|
|
case CK_SemiColon:
|
|
|
|
case CK_Equal:
|
|
|
|
case CK_HorizontalSpace:
|
|
|
|
case CK_VerticalSpace:
|
2009-11-07 08:00:49 +08:00
|
|
|
break;
|
2009-12-01 13:55:20 +08:00
|
|
|
}
|
2009-11-07 08:00:49 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-05-27 06:00:08 +08:00
|
|
|
bool CodeCompletionString::Deserialize(const char *&Str, const char *StrEnd) {
|
2009-12-01 13:55:20 +08:00
|
|
|
if (Str == StrEnd || *Str == 0)
|
2010-05-27 06:00:08 +08:00
|
|
|
return false;
|
2009-11-07 08:00:49 +08:00
|
|
|
|
2009-12-01 13:55:20 +08:00
|
|
|
unsigned NumBlocks;
|
|
|
|
if (ReadUnsigned(Str, StrEnd, NumBlocks))
|
2010-05-27 06:00:08 +08:00
|
|
|
return false;
|
2009-12-01 13:55:20 +08:00
|
|
|
|
|
|
|
for (unsigned I = 0; I != NumBlocks; ++I) {
|
|
|
|
if (Str + 1 >= StrEnd)
|
2009-11-07 08:00:49 +08:00
|
|
|
break;
|
2009-12-01 13:55:20 +08:00
|
|
|
|
|
|
|
// Parse the next kind.
|
|
|
|
unsigned KindValue;
|
|
|
|
if (ReadUnsigned(Str, StrEnd, KindValue))
|
2010-05-27 06:00:08 +08:00
|
|
|
return false;
|
2009-12-01 13:55:20 +08:00
|
|
|
|
|
|
|
switch (ChunkKind Kind = (ChunkKind)KindValue) {
|
|
|
|
case CK_TypedText:
|
|
|
|
case CK_Text:
|
|
|
|
case CK_Placeholder:
|
|
|
|
case CK_Informative:
|
2009-12-19 02:53:37 +08:00
|
|
|
case CK_ResultType:
|
2009-12-01 13:55:20 +08:00
|
|
|
case CK_CurrentParameter: {
|
|
|
|
unsigned StrLen;
|
|
|
|
if (ReadUnsigned(Str, StrEnd, StrLen) || (Str + StrLen > StrEnd))
|
2010-05-27 06:00:08 +08:00
|
|
|
return false;
|
2009-12-01 13:55:20 +08:00
|
|
|
|
2010-05-27 06:00:08 +08:00
|
|
|
AddChunk(Chunk(Kind, StringRef(Str, StrLen)));
|
2009-12-01 13:55:20 +08:00
|
|
|
Str += StrLen;
|
2009-11-07 08:00:49 +08:00
|
|
|
break;
|
|
|
|
}
|
2009-12-01 13:55:20 +08:00
|
|
|
|
|
|
|
case CK_Optional: {
|
2010-05-27 06:00:08 +08:00
|
|
|
std::auto_ptr<CodeCompletionString> Optional(new CodeCompletionString());
|
|
|
|
if (Optional->Deserialize(Str, StrEnd))
|
|
|
|
AddOptionalChunk(Optional);
|
2009-12-01 13:55:20 +08:00
|
|
|
break;
|
2009-11-07 08:00:49 +08:00
|
|
|
}
|
2009-12-01 13:55:20 +08:00
|
|
|
|
|
|
|
case CK_LeftParen:
|
|
|
|
case CK_RightParen:
|
|
|
|
case CK_LeftBracket:
|
|
|
|
case CK_RightBracket:
|
|
|
|
case CK_LeftBrace:
|
|
|
|
case CK_RightBrace:
|
|
|
|
case CK_LeftAngle:
|
|
|
|
case CK_RightAngle:
|
|
|
|
case CK_Comma:
|
Improve code completion by introducing patterns for the various C and
C++ grammatical constructs that show up in top-level (namespace-level)
declarations, member declarations, template declarations, statements,
expressions, conditions, etc. For example, we now provide a pattern
for
static_cast<type>(expr)
when we can have an expression, or
using namespace identifier;
when we can have a using directive.
Also, improves the results of code completion at the beginning of a
top-level declaration. Previously, we would see value names (function
names, global variables, etc.); now we see types, namespace names,
etc., but no values.
llvm-svn: 93134
2010-01-11 07:08:15 +08:00
|
|
|
case CK_Colon:
|
|
|
|
case CK_SemiColon:
|
|
|
|
case CK_Equal:
|
|
|
|
case CK_HorizontalSpace:
|
|
|
|
case CK_VerticalSpace:
|
2010-05-27 06:00:08 +08:00
|
|
|
AddChunk(Chunk(Kind));
|
2009-12-01 13:55:20 +08:00
|
|
|
break;
|
2009-11-07 08:00:49 +08:00
|
|
|
}
|
2009-12-01 13:55:20 +08:00
|
|
|
};
|
2009-11-07 08:00:49 +08:00
|
|
|
|
2010-05-27 06:00:08 +08:00
|
|
|
return true;
|
2009-11-07 08:00:49 +08:00
|
|
|
}
|
|
|
|
|
2010-08-25 14:19:51 +08:00
|
|
|
void CodeCompletionResult::Destroy() {
|
2009-11-19 08:01:57 +08:00
|
|
|
if (Kind == RK_Pattern) {
|
|
|
|
delete Pattern;
|
|
|
|
Pattern = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-08-25 14:19:51 +08:00
|
|
|
unsigned CodeCompletionResult::getPriorityFromDecl(NamedDecl *ND) {
|
2010-05-27 06:00:08 +08:00
|
|
|
if (!ND)
|
|
|
|
return CCP_Unlikely;
|
|
|
|
|
|
|
|
// Context-based decisions.
|
2010-08-31 08:36:30 +08:00
|
|
|
DeclContext *DC = ND->getDeclContext()->getRedeclContext();
|
2010-09-18 23:16:27 +08:00
|
|
|
if (DC->isFunctionOrMethod() || isa<BlockDecl>(DC)) {
|
|
|
|
// _cmd is relatively rare
|
|
|
|
if (ImplicitParamDecl *ImplicitParam = dyn_cast<ImplicitParamDecl>(ND))
|
|
|
|
if (ImplicitParam->getIdentifier() &&
|
|
|
|
ImplicitParam->getIdentifier()->isStr("_cmd"))
|
|
|
|
return CCP_ObjC_cmd;
|
|
|
|
|
2010-05-27 06:00:08 +08:00
|
|
|
return CCP_LocalDeclaration;
|
2010-09-18 23:16:27 +08:00
|
|
|
}
|
2010-05-27 06:00:08 +08:00
|
|
|
if (DC->isRecord() || isa<ObjCContainerDecl>(DC))
|
|
|
|
return CCP_MemberDeclaration;
|
|
|
|
|
|
|
|
// Content-based decisions.
|
|
|
|
if (isa<EnumConstantDecl>(ND))
|
|
|
|
return CCP_Constant;
|
|
|
|
if (isa<TypeDecl>(ND) || isa<ObjCInterfaceDecl>(ND))
|
|
|
|
return CCP_Type;
|
2010-09-18 23:16:27 +08:00
|
|
|
|
2010-05-27 06:00:08 +08:00
|
|
|
return CCP_Declaration;
|
|
|
|
}
|
|
|
|
|
2009-09-23 08:16:58 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Code completion overload candidate implementation
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
FunctionDecl *
|
|
|
|
CodeCompleteConsumer::OverloadCandidate::getFunction() const {
|
|
|
|
if (getKind() == CK_Function)
|
|
|
|
return Function;
|
|
|
|
else if (getKind() == CK_FunctionTemplate)
|
|
|
|
return FunctionTemplate->getTemplatedDecl();
|
|
|
|
else
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
const FunctionType *
|
|
|
|
CodeCompleteConsumer::OverloadCandidate::getFunctionType() const {
|
|
|
|
switch (Kind) {
|
|
|
|
case CK_Function:
|
|
|
|
return Function->getType()->getAs<FunctionType>();
|
|
|
|
|
|
|
|
case CK_FunctionTemplate:
|
|
|
|
return FunctionTemplate->getTemplatedDecl()->getType()
|
|
|
|
->getAs<FunctionType>();
|
|
|
|
|
|
|
|
case CK_FunctionType:
|
|
|
|
return Type;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-09-19 06:15:54 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Code completion consumer implementation
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2009-09-22 00:56:56 +08:00
|
|
|
CodeCompleteConsumer::~CodeCompleteConsumer() { }
|
2009-09-19 06:15:54 +08:00
|
|
|
|
Initial implementation of a code-completion interface in Clang. In
essence, code completion is triggered by a magic "code completion"
token produced by the lexer [*], which the parser recognizes at
certain points in the grammar. The parser then calls into the Action
object with the appropriate CodeCompletionXXX action.
Sema implements the CodeCompletionXXX callbacks by performing minimal
translation, then forwarding them to a CodeCompletionConsumer
subclass, which uses the results of semantic analysis to provide
code-completion results. At present, only a single, "printing" code
completion consumer is available, for regression testing and
debugging. However, the design is meant to permit other
code-completion consumers.
This initial commit contains two code-completion actions: one for
member access, e.g., "x." or "p->", and one for
nested-name-specifiers, e.g., "std::". More code-completion actions
will follow, along with improved gathering of code-completion results
for the various contexts.
[*] In the current -code-completion-dump testing/debugging mode, the
file is truncated at the completion point and EOF is translated into
"code completion".
llvm-svn: 82166
2009-09-18 05:32:03 +08:00
|
|
|
void
|
2009-11-13 16:58:20 +08:00
|
|
|
PrintingCodeCompleteConsumer::ProcessCodeCompleteResults(Sema &SemaRef,
|
2010-08-12 05:23:17 +08:00
|
|
|
CodeCompletionContext Context,
|
2010-08-25 14:19:51 +08:00
|
|
|
CodeCompletionResult *Results,
|
Initial implementation of a code-completion interface in Clang. In
essence, code completion is triggered by a magic "code completion"
token produced by the lexer [*], which the parser recognizes at
certain points in the grammar. The parser then calls into the Action
object with the appropriate CodeCompletionXXX action.
Sema implements the CodeCompletionXXX callbacks by performing minimal
translation, then forwarding them to a CodeCompletionConsumer
subclass, which uses the results of semantic analysis to provide
code-completion results. At present, only a single, "printing" code
completion consumer is available, for regression testing and
debugging. However, the design is meant to permit other
code-completion consumers.
This initial commit contains two code-completion actions: one for
member access, e.g., "x." or "p->", and one for
nested-name-specifiers, e.g., "std::". More code-completion actions
will follow, along with improved gathering of code-completion results
for the various contexts.
[*] In the current -code-completion-dump testing/debugging mode, the
file is truncated at the completion point and EOF is translated into
"code completion".
llvm-svn: 82166
2009-09-18 05:32:03 +08:00
|
|
|
unsigned NumResults) {
|
2010-08-26 21:48:20 +08:00
|
|
|
std::stable_sort(Results, Results + NumResults);
|
|
|
|
|
Initial implementation of a code-completion interface in Clang. In
essence, code completion is triggered by a magic "code completion"
token produced by the lexer [*], which the parser recognizes at
certain points in the grammar. The parser then calls into the Action
object with the appropriate CodeCompletionXXX action.
Sema implements the CodeCompletionXXX callbacks by performing minimal
translation, then forwarding them to a CodeCompletionConsumer
subclass, which uses the results of semantic analysis to provide
code-completion results. At present, only a single, "printing" code
completion consumer is available, for regression testing and
debugging. However, the design is meant to permit other
code-completion consumers.
This initial commit contains two code-completion actions: one for
member access, e.g., "x." or "p->", and one for
nested-name-specifiers, e.g., "std::". More code-completion actions
will follow, along with improved gathering of code-completion results
for the various contexts.
[*] In the current -code-completion-dump testing/debugging mode, the
file is truncated at the completion point and EOF is translated into
"code completion".
llvm-svn: 82166
2009-09-18 05:32:03 +08:00
|
|
|
// Print the results.
|
|
|
|
for (unsigned I = 0; I != NumResults; ++I) {
|
2009-10-10 06:16:47 +08:00
|
|
|
OS << "COMPLETION: ";
|
Initial implementation of a code-completion interface in Clang. In
essence, code completion is triggered by a magic "code completion"
token produced by the lexer [*], which the parser recognizes at
certain points in the grammar. The parser then calls into the Action
object with the appropriate CodeCompletionXXX action.
Sema implements the CodeCompletionXXX callbacks by performing minimal
translation, then forwarding them to a CodeCompletionConsumer
subclass, which uses the results of semantic analysis to provide
code-completion results. At present, only a single, "printing" code
completion consumer is available, for regression testing and
debugging. However, the design is meant to permit other
code-completion consumers.
This initial commit contains two code-completion actions: one for
member access, e.g., "x." or "p->", and one for
nested-name-specifiers, e.g., "std::". More code-completion actions
will follow, along with improved gathering of code-completion results
for the various contexts.
[*] In the current -code-completion-dump testing/debugging mode, the
file is truncated at the completion point and EOF is translated into
"code completion".
llvm-svn: 82166
2009-09-18 05:32:03 +08:00
|
|
|
switch (Results[I].Kind) {
|
2010-08-25 14:19:51 +08:00
|
|
|
case CodeCompletionResult::RK_Declaration:
|
2010-04-17 17:33:03 +08:00
|
|
|
OS << Results[I].Declaration;
|
Initial implementation of a code-completion interface in Clang. In
essence, code completion is triggered by a magic "code completion"
token produced by the lexer [*], which the parser recognizes at
certain points in the grammar. The parser then calls into the Action
object with the appropriate CodeCompletionXXX action.
Sema implements the CodeCompletionXXX callbacks by performing minimal
translation, then forwarding them to a CodeCompletionConsumer
subclass, which uses the results of semantic analysis to provide
code-completion results. At present, only a single, "printing" code
completion consumer is available, for regression testing and
debugging. However, the design is meant to permit other
code-completion consumers.
This initial commit contains two code-completion actions: one for
member access, e.g., "x." or "p->", and one for
nested-name-specifiers, e.g., "std::". More code-completion actions
will follow, along with improved gathering of code-completion results
for the various contexts.
[*] In the current -code-completion-dump testing/debugging mode, the
file is truncated at the completion point and EOF is translated into
"code completion".
llvm-svn: 82166
2009-09-18 05:32:03 +08:00
|
|
|
if (Results[I].Hidden)
|
|
|
|
OS << " (Hidden)";
|
2009-09-22 00:56:56 +08:00
|
|
|
if (CodeCompletionString *CCS
|
|
|
|
= Results[I].CreateCodeCompletionString(SemaRef)) {
|
2009-09-19 06:15:54 +08:00
|
|
|
OS << " : " << CCS->getAsString();
|
|
|
|
delete CCS;
|
|
|
|
}
|
|
|
|
|
Initial implementation of a code-completion interface in Clang. In
essence, code completion is triggered by a magic "code completion"
token produced by the lexer [*], which the parser recognizes at
certain points in the grammar. The parser then calls into the Action
object with the appropriate CodeCompletionXXX action.
Sema implements the CodeCompletionXXX callbacks by performing minimal
translation, then forwarding them to a CodeCompletionConsumer
subclass, which uses the results of semantic analysis to provide
code-completion results. At present, only a single, "printing" code
completion consumer is available, for regression testing and
debugging. However, the design is meant to permit other
code-completion consumers.
This initial commit contains two code-completion actions: one for
member access, e.g., "x." or "p->", and one for
nested-name-specifiers, e.g., "std::". More code-completion actions
will follow, along with improved gathering of code-completion results
for the various contexts.
[*] In the current -code-completion-dump testing/debugging mode, the
file is truncated at the completion point and EOF is translated into
"code completion".
llvm-svn: 82166
2009-09-18 05:32:03 +08:00
|
|
|
OS << '\n';
|
|
|
|
break;
|
|
|
|
|
2010-08-25 14:19:51 +08:00
|
|
|
case CodeCompletionResult::RK_Keyword:
|
2010-01-14 07:24:38 +08:00
|
|
|
OS << Results[I].Keyword << '\n';
|
Initial implementation of a code-completion interface in Clang. In
essence, code completion is triggered by a magic "code completion"
token produced by the lexer [*], which the parser recognizes at
certain points in the grammar. The parser then calls into the Action
object with the appropriate CodeCompletionXXX action.
Sema implements the CodeCompletionXXX callbacks by performing minimal
translation, then forwarding them to a CodeCompletionConsumer
subclass, which uses the results of semantic analysis to provide
code-completion results. At present, only a single, "printing" code
completion consumer is available, for regression testing and
debugging. However, the design is meant to permit other
code-completion consumers.
This initial commit contains two code-completion actions: one for
member access, e.g., "x." or "p->", and one for
nested-name-specifiers, e.g., "std::". More code-completion actions
will follow, along with improved gathering of code-completion results
for the various contexts.
[*] In the current -code-completion-dump testing/debugging mode, the
file is truncated at the completion point and EOF is translated into
"code completion".
llvm-svn: 82166
2009-09-18 05:32:03 +08:00
|
|
|
break;
|
2009-10-31 00:50:04 +08:00
|
|
|
|
2010-08-25 14:19:51 +08:00
|
|
|
case CodeCompletionResult::RK_Macro: {
|
2010-01-14 07:24:38 +08:00
|
|
|
OS << Results[I].Macro->getName();
|
2009-10-31 00:50:04 +08:00
|
|
|
if (CodeCompletionString *CCS
|
2010-01-14 07:24:38 +08:00
|
|
|
= Results[I].CreateCodeCompletionString(SemaRef)) {
|
2009-10-31 00:50:04 +08:00
|
|
|
OS << " : " << CCS->getAsString();
|
|
|
|
delete CCS;
|
|
|
|
}
|
|
|
|
OS << '\n';
|
|
|
|
break;
|
|
|
|
}
|
2009-11-19 08:01:57 +08:00
|
|
|
|
2010-08-25 14:19:51 +08:00
|
|
|
case CodeCompletionResult::RK_Pattern: {
|
2010-01-14 07:24:38 +08:00
|
|
|
OS << "Pattern : "
|
2009-11-19 08:01:57 +08:00
|
|
|
<< Results[I].Pattern->getAsString() << '\n';
|
|
|
|
break;
|
|
|
|
}
|
Initial implementation of a code-completion interface in Clang. In
essence, code completion is triggered by a magic "code completion"
token produced by the lexer [*], which the parser recognizes at
certain points in the grammar. The parser then calls into the Action
object with the appropriate CodeCompletionXXX action.
Sema implements the CodeCompletionXXX callbacks by performing minimal
translation, then forwarding them to a CodeCompletionConsumer
subclass, which uses the results of semantic analysis to provide
code-completion results. At present, only a single, "printing" code
completion consumer is available, for regression testing and
debugging. However, the design is meant to permit other
code-completion consumers.
This initial commit contains two code-completion actions: one for
member access, e.g., "x." or "p->", and one for
nested-name-specifiers, e.g., "std::". More code-completion actions
will follow, along with improved gathering of code-completion results
for the various contexts.
[*] In the current -code-completion-dump testing/debugging mode, the
file is truncated at the completion point and EOF is translated into
"code completion".
llvm-svn: 82166
2009-09-18 05:32:03 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2009-09-23 08:16:58 +08:00
|
|
|
|
|
|
|
void
|
2009-11-13 16:58:20 +08:00
|
|
|
PrintingCodeCompleteConsumer::ProcessOverloadCandidates(Sema &SemaRef,
|
|
|
|
unsigned CurrentArg,
|
2009-09-23 08:16:58 +08:00
|
|
|
OverloadCandidate *Candidates,
|
|
|
|
unsigned NumCandidates) {
|
|
|
|
for (unsigned I = 0; I != NumCandidates; ++I) {
|
2009-09-23 08:34:09 +08:00
|
|
|
if (CodeCompletionString *CCS
|
|
|
|
= Candidates[I].CreateSignatureString(CurrentArg, SemaRef)) {
|
2009-10-10 06:16:47 +08:00
|
|
|
OS << "OVERLOAD: " << CCS->getAsString() << "\n";
|
2009-09-23 08:34:09 +08:00
|
|
|
delete CCS;
|
2009-09-23 08:16:58 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2009-11-07 08:00:49 +08:00
|
|
|
|
2010-08-25 14:19:51 +08:00
|
|
|
void CodeCompletionResult::computeCursorKindAndAvailability() {
|
2010-08-14 06:48:40 +08:00
|
|
|
switch (Kind) {
|
|
|
|
case RK_Declaration:
|
2010-08-24 07:00:57 +08:00
|
|
|
// Set the availability based on attributes.
|
|
|
|
Availability = CXAvailability_Available;
|
|
|
|
if (Declaration->getAttr<UnavailableAttr>())
|
|
|
|
Availability = CXAvailability_NotAvailable;
|
|
|
|
else if (Declaration->getAttr<DeprecatedAttr>())
|
|
|
|
Availability = CXAvailability_Deprecated;
|
|
|
|
|
2010-09-04 07:30:36 +08:00
|
|
|
if (FunctionDecl *Function = dyn_cast<FunctionDecl>(Declaration))
|
|
|
|
if (Function->isDeleted())
|
2010-08-24 07:00:57 +08:00
|
|
|
Availability = CXAvailability_NotAvailable;
|
2010-09-04 07:30:36 +08:00
|
|
|
|
|
|
|
CursorKind = getCursorKindForDecl(Declaration);
|
|
|
|
if (CursorKind == CXCursor_UnexposedDecl)
|
2010-08-14 06:48:40 +08:00
|
|
|
CursorKind = CXCursor_NotImplemented;
|
|
|
|
break;
|
|
|
|
|
2010-08-25 14:19:51 +08:00
|
|
|
case RK_Macro:
|
2010-08-24 07:00:57 +08:00
|
|
|
Availability = CXAvailability_Available;
|
2010-08-14 06:48:40 +08:00
|
|
|
CursorKind = CXCursor_MacroDefinition;
|
|
|
|
break;
|
|
|
|
|
2010-08-25 14:19:51 +08:00
|
|
|
case RK_Keyword:
|
2010-08-24 07:00:57 +08:00
|
|
|
Availability = CXAvailability_Available;
|
2010-08-14 06:48:40 +08:00
|
|
|
CursorKind = CXCursor_NotImplemented;
|
|
|
|
break;
|
|
|
|
|
2010-08-25 14:19:51 +08:00
|
|
|
case RK_Pattern:
|
2010-08-14 06:48:40 +08:00
|
|
|
// Do nothing: Patterns can come with cursor kinds!
|
|
|
|
break;
|
2010-08-05 00:47:14 +08:00
|
|
|
}
|
|
|
|
}
|
2009-12-01 13:55:20 +08:00
|
|
|
|
2010-08-26 02:41:16 +08:00
|
|
|
/// \brief Retrieve the name that should be used to order a result.
|
|
|
|
///
|
|
|
|
/// If the name needs to be constructed as a string, that string will be
|
|
|
|
/// saved into Saved and the returned StringRef will refer to it.
|
|
|
|
static llvm::StringRef getOrderedName(const CodeCompletionResult &R,
|
|
|
|
std::string &Saved) {
|
|
|
|
switch (R.Kind) {
|
|
|
|
case CodeCompletionResult::RK_Keyword:
|
|
|
|
return R.Keyword;
|
|
|
|
|
|
|
|
case CodeCompletionResult::RK_Pattern:
|
|
|
|
return R.Pattern->getTypedText();
|
|
|
|
|
|
|
|
case CodeCompletionResult::RK_Macro:
|
|
|
|
return R.Macro->getName();
|
|
|
|
|
|
|
|
case CodeCompletionResult::RK_Declaration:
|
|
|
|
// Handle declarations below.
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
DeclarationName Name = R.Declaration->getDeclName();
|
|
|
|
|
|
|
|
// If the name is a simple identifier (by far the common case), or a
|
|
|
|
// zero-argument selector, just return a reference to that identifier.
|
|
|
|
if (IdentifierInfo *Id = Name.getAsIdentifierInfo())
|
|
|
|
return Id->getName();
|
|
|
|
if (Name.isObjCZeroArgSelector())
|
|
|
|
if (IdentifierInfo *Id
|
|
|
|
= Name.getObjCSelector().getIdentifierInfoForSlot(0))
|
|
|
|
return Id->getName();
|
|
|
|
|
|
|
|
Saved = Name.getAsString();
|
|
|
|
return Saved;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool clang::operator<(const CodeCompletionResult &X,
|
|
|
|
const CodeCompletionResult &Y) {
|
|
|
|
std::string XSaved, YSaved;
|
|
|
|
llvm::StringRef XStr = getOrderedName(X, XSaved);
|
|
|
|
llvm::StringRef YStr = getOrderedName(Y, YSaved);
|
|
|
|
int cmp = XStr.compare_lower(YStr);
|
|
|
|
if (cmp)
|
|
|
|
return cmp < 0;
|
|
|
|
|
2010-08-26 21:48:20 +08:00
|
|
|
// If case-insensitive comparison fails, try case-sensitive comparison.
|
|
|
|
cmp = XStr.compare(YStr);
|
|
|
|
if (cmp)
|
|
|
|
return cmp < 0;
|
2010-08-26 02:41:16 +08:00
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2010-08-05 00:47:14 +08:00
|
|
|
void
|
|
|
|
CIndexCodeCompleteConsumer::ProcessCodeCompleteResults(Sema &SemaRef,
|
2010-08-12 05:23:17 +08:00
|
|
|
CodeCompletionContext Context,
|
2010-08-25 14:19:51 +08:00
|
|
|
CodeCompletionResult *Results,
|
2010-08-05 00:47:14 +08:00
|
|
|
unsigned NumResults) {
|
|
|
|
// Print the results.
|
|
|
|
for (unsigned I = 0; I != NumResults; ++I) {
|
2010-08-14 06:48:40 +08:00
|
|
|
WriteUnsigned(OS, Results[I].CursorKind);
|
2010-05-27 06:00:08 +08:00
|
|
|
WriteUnsigned(OS, Results[I].Priority);
|
2010-08-24 07:00:57 +08:00
|
|
|
WriteUnsigned(OS, Results[I].Availability);
|
2009-12-01 13:55:20 +08:00
|
|
|
CodeCompletionString *CCS = Results[I].CreateCodeCompletionString(SemaRef);
|
|
|
|
assert(CCS && "No code-completion string?");
|
|
|
|
CCS->Serialize(OS);
|
|
|
|
delete CCS;
|
2009-11-07 08:00:49 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2009-11-13 16:58:20 +08:00
|
|
|
CIndexCodeCompleteConsumer::ProcessOverloadCandidates(Sema &SemaRef,
|
|
|
|
unsigned CurrentArg,
|
2009-11-07 08:00:49 +08:00
|
|
|
OverloadCandidate *Candidates,
|
|
|
|
unsigned NumCandidates) {
|
|
|
|
for (unsigned I = 0; I != NumCandidates; ++I) {
|
2009-12-01 13:55:20 +08:00
|
|
|
WriteUnsigned(OS, CXCursor_NotImplemented);
|
2010-08-26 21:48:20 +08:00
|
|
|
WriteUnsigned(OS, /*Priority=*/I);
|
2010-08-24 07:00:57 +08:00
|
|
|
WriteUnsigned(OS, /*Availability=*/CXAvailability_Available);
|
2009-12-01 13:55:20 +08:00
|
|
|
CodeCompletionString *CCS
|
|
|
|
= Candidates[I].CreateSignatureString(CurrentArg, SemaRef);
|
|
|
|
assert(CCS && "No code-completion string?");
|
|
|
|
CCS->Serialize(OS);
|
|
|
|
delete CCS;
|
2009-11-07 08:00:49 +08:00
|
|
|
}
|
|
|
|
}
|