Douglas Gregor | 86d9a52 | 2009-09-21 16:56:56 +0000 | [diff] [blame] | 1 | //===--- CodeCompleteConsumer.cpp - Code Completion Interface ---*- C++ -*-===// |
Douglas Gregor | 81b747b | 2009-09-17 21:32:03 +0000 | [diff] [blame] | 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" |
John McCall | 1951085 | 2010-08-20 18:27:03 +0000 | [diff] [blame] | 14 | #include "clang/Sema/Scope.h" |
Douglas Gregor | e737f50 | 2010-08-12 20:07:10 +0000 | [diff] [blame] | 15 | #include "clang/Sema/Sema.h" |
Douglas Gregor | 75b7128 | 2009-09-18 17:54:00 +0000 | [diff] [blame] | 16 | #include "clang/AST/DeclCXX.h" |
John McCall | 7cd088e | 2010-08-24 07:21:54 +0000 | [diff] [blame] | 17 | #include "clang/AST/DeclObjC.h" |
John McCall | 2a7fb27 | 2010-08-25 05:32:35 +0000 | [diff] [blame] | 18 | #include "clang/AST/DeclTemplate.h" |
Douglas Gregor | 81b747b | 2009-09-17 21:32:03 +0000 | [diff] [blame] | 19 | #include "clang/Lex/Preprocessor.h" |
Douglas Gregor | 2b4074f | 2009-12-01 05:55:20 +0000 | [diff] [blame] | 20 | #include "clang-c/Index.h" |
Benjamin Kramer | 8fe83e1 | 2012-02-04 13:45:25 +0000 | [diff] [blame] | 21 | #include "llvm/ADT/SmallString.h" |
Douglas Gregor | 81b747b | 2009-09-17 21:32:03 +0000 | [diff] [blame] | 22 | #include "llvm/ADT/STLExtras.h" |
Douglas Gregor | 577cdfd | 2011-02-17 00:22:45 +0000 | [diff] [blame] | 23 | #include "llvm/ADT/Twine.h" |
Douglas Gregor | 81b747b | 2009-09-17 21:32:03 +0000 | [diff] [blame] | 24 | #include "llvm/Support/raw_ostream.h" |
| 25 | #include <algorithm> |
Douglas Gregor | e6e0361 | 2009-09-18 22:15:54 +0000 | [diff] [blame] | 26 | #include <cstring> |
| 27 | #include <functional> |
Douglas Gregor | 92eff46 | 2009-11-17 16:43:05 +0000 | [diff] [blame] | 28 | |
Douglas Gregor | 81b747b | 2009-09-17 21:32:03 +0000 | [diff] [blame] | 29 | using namespace clang; |
| 30 | |
Douglas Gregor | e6e0361 | 2009-09-18 22:15:54 +0000 | [diff] [blame] | 31 | //===----------------------------------------------------------------------===// |
Douglas Gregor | 6f942b2 | 2010-09-21 16:06:22 +0000 | [diff] [blame] | 32 | // Code completion context implementation |
| 33 | //===----------------------------------------------------------------------===// |
| 34 | |
| 35 | bool CodeCompletionContext::wantConstructorResults() const { |
| 36 | switch (Kind) { |
Douglas Gregor | 52779fb | 2010-09-23 23:01:17 +0000 | [diff] [blame] | 37 | case CCC_Recovery: |
Douglas Gregor | 6f942b2 | 2010-09-21 16:06:22 +0000 | [diff] [blame] | 38 | case CCC_Statement: |
| 39 | case CCC_Expression: |
| 40 | case CCC_ObjCMessageReceiver: |
| 41 | case CCC_ParenthesizedExpression: |
| 42 | return true; |
| 43 | |
| 44 | case CCC_TopLevel: |
| 45 | case CCC_ObjCInterface: |
| 46 | case CCC_ObjCImplementation: |
| 47 | case CCC_ObjCIvarList: |
| 48 | case CCC_ClassStructUnion: |
Douglas Gregor | 3da626b | 2011-07-07 16:03:39 +0000 | [diff] [blame] | 49 | case CCC_DotMemberAccess: |
| 50 | case CCC_ArrowMemberAccess: |
| 51 | case CCC_ObjCPropertyAccess: |
Douglas Gregor | 6f942b2 | 2010-09-21 16:06:22 +0000 | [diff] [blame] | 52 | case CCC_EnumTag: |
| 53 | case CCC_UnionTag: |
| 54 | case CCC_ClassOrStructTag: |
| 55 | case CCC_ObjCProtocolName: |
| 56 | case CCC_Namespace: |
| 57 | case CCC_Type: |
| 58 | case CCC_Name: |
| 59 | case CCC_PotentiallyQualifiedName: |
| 60 | case CCC_MacroName: |
| 61 | case CCC_MacroNameUse: |
| 62 | case CCC_PreprocessorExpression: |
| 63 | case CCC_PreprocessorDirective: |
| 64 | case CCC_NaturalLanguage: |
| 65 | case CCC_SelectorName: |
| 66 | case CCC_TypeQualifiers: |
Douglas Gregor | 52779fb | 2010-09-23 23:01:17 +0000 | [diff] [blame] | 67 | case CCC_Other: |
Douglas Gregor | 5c722c70 | 2011-02-18 23:30:37 +0000 | [diff] [blame] | 68 | case CCC_OtherWithMacros: |
Douglas Gregor | 3da626b | 2011-07-07 16:03:39 +0000 | [diff] [blame] | 69 | case CCC_ObjCInstanceMessage: |
| 70 | case CCC_ObjCClassMessage: |
Douglas Gregor | 0f91c8c | 2011-07-30 06:55:39 +0000 | [diff] [blame] | 71 | case CCC_ObjCInterfaceName: |
Douglas Gregor | 3da626b | 2011-07-07 16:03:39 +0000 | [diff] [blame] | 72 | case CCC_ObjCCategoryName: |
Douglas Gregor | 6f942b2 | 2010-09-21 16:06:22 +0000 | [diff] [blame] | 73 | return false; |
| 74 | } |
David Blaikie | 7530c03 | 2012-01-17 06:56:22 +0000 | [diff] [blame] | 75 | |
| 76 | llvm_unreachable("Invalid CodeCompletionContext::Kind!"); |
Douglas Gregor | 6f942b2 | 2010-09-21 16:06:22 +0000 | [diff] [blame] | 77 | } |
| 78 | |
| 79 | //===----------------------------------------------------------------------===// |
Douglas Gregor | e6e0361 | 2009-09-18 22:15:54 +0000 | [diff] [blame] | 80 | // Code completion string implementation |
| 81 | //===----------------------------------------------------------------------===// |
Douglas Gregor | 218937c | 2011-02-01 19:23:04 +0000 | [diff] [blame] | 82 | CodeCompletionString::Chunk::Chunk(ChunkKind Kind, const char *Text) |
Daniel Dunbar | ad5757f | 2009-11-12 18:40:12 +0000 | [diff] [blame] | 83 | : Kind(Kind), Text("") |
Douglas Gregor | 0563c26 | 2009-09-22 23:15:58 +0000 | [diff] [blame] | 84 | { |
Douglas Gregor | 0c8296d | 2009-11-07 00:00:49 +0000 | [diff] [blame] | 85 | switch (Kind) { |
| 86 | case CK_TypedText: |
| 87 | case CK_Text: |
| 88 | case CK_Placeholder: |
| 89 | case CK_Informative: |
Douglas Gregor | ff5ce6e | 2009-12-18 18:53:37 +0000 | [diff] [blame] | 90 | case CK_ResultType: |
Douglas Gregor | 218937c | 2011-02-01 19:23:04 +0000 | [diff] [blame] | 91 | case CK_CurrentParameter: |
| 92 | this->Text = Text; |
Douglas Gregor | 0c8296d | 2009-11-07 00:00:49 +0000 | [diff] [blame] | 93 | break; |
Douglas Gregor | 0c8296d | 2009-11-07 00:00:49 +0000 | [diff] [blame] | 94 | |
| 95 | case CK_Optional: |
Jeffrey Yasskin | 9f61aa9 | 2009-12-12 05:05:38 +0000 | [diff] [blame] | 96 | llvm_unreachable("Optional strings cannot be created from text"); |
Douglas Gregor | 0c8296d | 2009-11-07 00:00:49 +0000 | [diff] [blame] | 97 | |
| 98 | case CK_LeftParen: |
| 99 | this->Text = "("; |
| 100 | break; |
| 101 | |
| 102 | case CK_RightParen: |
| 103 | this->Text = ")"; |
| 104 | break; |
| 105 | |
| 106 | case CK_LeftBracket: |
| 107 | this->Text = "["; |
| 108 | break; |
| 109 | |
| 110 | case CK_RightBracket: |
| 111 | this->Text = "]"; |
| 112 | break; |
| 113 | |
| 114 | case CK_LeftBrace: |
| 115 | this->Text = "{"; |
| 116 | break; |
| 117 | |
| 118 | case CK_RightBrace: |
| 119 | this->Text = "}"; |
| 120 | break; |
| 121 | |
| 122 | case CK_LeftAngle: |
| 123 | this->Text = "<"; |
| 124 | break; |
| 125 | |
| 126 | case CK_RightAngle: |
| 127 | this->Text = ">"; |
| 128 | break; |
| 129 | |
| 130 | case CK_Comma: |
| 131 | this->Text = ", "; |
| 132 | break; |
Douglas Gregor | 01dfea0 | 2010-01-10 23:08:15 +0000 | [diff] [blame] | 133 | |
| 134 | case CK_Colon: |
Douglas Gregor | e8f5a17 | 2010-04-07 00:21:17 +0000 | [diff] [blame] | 135 | this->Text = ":"; |
Douglas Gregor | 01dfea0 | 2010-01-10 23:08:15 +0000 | [diff] [blame] | 136 | break; |
| 137 | |
| 138 | case CK_SemiColon: |
| 139 | this->Text = ";"; |
| 140 | break; |
| 141 | |
| 142 | case CK_Equal: |
| 143 | this->Text = " = "; |
| 144 | break; |
| 145 | |
| 146 | case CK_HorizontalSpace: |
| 147 | this->Text = " "; |
| 148 | break; |
| 149 | |
| 150 | case CK_VerticalSpace: |
| 151 | this->Text = "\n"; |
| 152 | break; |
Douglas Gregor | 0c8296d | 2009-11-07 00:00:49 +0000 | [diff] [blame] | 153 | } |
Douglas Gregor | 0563c26 | 2009-09-22 23:15:58 +0000 | [diff] [blame] | 154 | } |
| 155 | |
| 156 | CodeCompletionString::Chunk |
Douglas Gregor | 218937c | 2011-02-01 19:23:04 +0000 | [diff] [blame] | 157 | CodeCompletionString::Chunk::CreateText(const char *Text) { |
Douglas Gregor | 0563c26 | 2009-09-22 23:15:58 +0000 | [diff] [blame] | 158 | return Chunk(CK_Text, Text); |
Douglas Gregor | e6e0361 | 2009-09-18 22:15:54 +0000 | [diff] [blame] | 159 | } |
| 160 | |
| 161 | CodeCompletionString::Chunk |
Douglas Gregor | 218937c | 2011-02-01 19:23:04 +0000 | [diff] [blame] | 162 | CodeCompletionString::Chunk::CreateOptional(CodeCompletionString *Optional) { |
Douglas Gregor | e6e0361 | 2009-09-18 22:15:54 +0000 | [diff] [blame] | 163 | Chunk Result; |
| 164 | Result.Kind = CK_Optional; |
Douglas Gregor | 218937c | 2011-02-01 19:23:04 +0000 | [diff] [blame] | 165 | Result.Optional = Optional; |
Douglas Gregor | e6e0361 | 2009-09-18 22:15:54 +0000 | [diff] [blame] | 166 | return Result; |
| 167 | } |
| 168 | |
| 169 | CodeCompletionString::Chunk |
Douglas Gregor | 218937c | 2011-02-01 19:23:04 +0000 | [diff] [blame] | 170 | CodeCompletionString::Chunk::CreatePlaceholder(const char *Placeholder) { |
Douglas Gregor | 0563c26 | 2009-09-22 23:15:58 +0000 | [diff] [blame] | 171 | return Chunk(CK_Placeholder, Placeholder); |
| 172 | } |
| 173 | |
| 174 | CodeCompletionString::Chunk |
Douglas Gregor | 218937c | 2011-02-01 19:23:04 +0000 | [diff] [blame] | 175 | CodeCompletionString::Chunk::CreateInformative(const char *Informative) { |
Douglas Gregor | 0563c26 | 2009-09-22 23:15:58 +0000 | [diff] [blame] | 176 | return Chunk(CK_Informative, Informative); |
Douglas Gregor | e6e0361 | 2009-09-18 22:15:54 +0000 | [diff] [blame] | 177 | } |
| 178 | |
Douglas Gregor | 0c8296d | 2009-11-07 00:00:49 +0000 | [diff] [blame] | 179 | CodeCompletionString::Chunk |
Douglas Gregor | 218937c | 2011-02-01 19:23:04 +0000 | [diff] [blame] | 180 | CodeCompletionString::Chunk::CreateResultType(const char *ResultType) { |
Douglas Gregor | ff5ce6e | 2009-12-18 18:53:37 +0000 | [diff] [blame] | 181 | return Chunk(CK_ResultType, ResultType); |
| 182 | } |
| 183 | |
| 184 | CodeCompletionString::Chunk |
Douglas Gregor | 0c8296d | 2009-11-07 00:00:49 +0000 | [diff] [blame] | 185 | CodeCompletionString::Chunk::CreateCurrentParameter( |
Douglas Gregor | 218937c | 2011-02-01 19:23:04 +0000 | [diff] [blame] | 186 | const char *CurrentParameter) { |
Douglas Gregor | 0c8296d | 2009-11-07 00:00:49 +0000 | [diff] [blame] | 187 | return Chunk(CK_CurrentParameter, CurrentParameter); |
| 188 | } |
| 189 | |
Douglas Gregor | 218937c | 2011-02-01 19:23:04 +0000 | [diff] [blame] | 190 | CodeCompletionString::CodeCompletionString(const Chunk *Chunks, |
| 191 | unsigned NumChunks, |
| 192 | unsigned Priority, |
Erik Verbruggen | 6164ea1 | 2011-10-14 15:31:08 +0000 | [diff] [blame] | 193 | CXAvailabilityKind Availability, |
| 194 | const char **Annotations, |
Douglas Gregor | ba10306 | 2012-03-27 23:34:16 +0000 | [diff] [blame] | 195 | unsigned NumAnnotations, |
| 196 | CXCursorKind ParentKind, |
Dmitri Gribenko | d99ef53 | 2012-07-02 17:35:10 +0000 | [diff] [blame] | 197 | StringRef ParentName, |
| 198 | const char *BriefComment) |
Douglas Gregor | ba10306 | 2012-03-27 23:34:16 +0000 | [diff] [blame] | 199 | : NumChunks(NumChunks), NumAnnotations(NumAnnotations), |
| 200 | Priority(Priority), Availability(Availability), ParentKind(ParentKind), |
Dmitri Gribenko | d99ef53 | 2012-07-02 17:35:10 +0000 | [diff] [blame] | 201 | ParentName(ParentName), BriefComment(BriefComment) |
Douglas Gregor | 218937c | 2011-02-01 19:23:04 +0000 | [diff] [blame] | 202 | { |
Erik Verbruggen | 6164ea1 | 2011-10-14 15:31:08 +0000 | [diff] [blame] | 203 | assert(NumChunks <= 0xffff); |
| 204 | assert(NumAnnotations <= 0xffff); |
| 205 | |
Douglas Gregor | 218937c | 2011-02-01 19:23:04 +0000 | [diff] [blame] | 206 | Chunk *StoredChunks = reinterpret_cast<Chunk *>(this + 1); |
| 207 | for (unsigned I = 0; I != NumChunks; ++I) |
| 208 | StoredChunks[I] = Chunks[I]; |
Erik Verbruggen | 6164ea1 | 2011-10-14 15:31:08 +0000 | [diff] [blame] | 209 | |
| 210 | const char **StoredAnnotations = reinterpret_cast<const char **>(StoredChunks + NumChunks); |
| 211 | for (unsigned I = 0; I != NumAnnotations; ++I) |
| 212 | StoredAnnotations[I] = Annotations[I]; |
Douglas Gregor | e6e0361 | 2009-09-18 22:15:54 +0000 | [diff] [blame] | 213 | } |
| 214 | |
Erik Verbruggen | 6164ea1 | 2011-10-14 15:31:08 +0000 | [diff] [blame] | 215 | unsigned CodeCompletionString::getAnnotationCount() const { |
| 216 | return NumAnnotations; |
| 217 | } |
| 218 | |
| 219 | const char *CodeCompletionString::getAnnotation(unsigned AnnotationNr) const { |
| 220 | if (AnnotationNr < NumAnnotations) |
| 221 | return reinterpret_cast<const char * const*>(end())[AnnotationNr]; |
| 222 | else |
| 223 | return 0; |
| 224 | } |
| 225 | |
| 226 | |
Douglas Gregor | e6e0361 | 2009-09-18 22:15:54 +0000 | [diff] [blame] | 227 | std::string CodeCompletionString::getAsString() const { |
| 228 | std::string Result; |
| 229 | llvm::raw_string_ostream OS(Result); |
| 230 | |
| 231 | for (iterator C = begin(), CEnd = end(); C != CEnd; ++C) { |
| 232 | switch (C->Kind) { |
Douglas Gregor | e6e0361 | 2009-09-18 22:15:54 +0000 | [diff] [blame] | 233 | case CK_Optional: OS << "{#" << C->Optional->getAsString() << "#}"; break; |
Douglas Gregor | 0563c26 | 2009-09-22 23:15:58 +0000 | [diff] [blame] | 234 | case CK_Placeholder: OS << "<#" << C->Text << "#>"; break; |
Douglas Gregor | ff5ce6e | 2009-12-18 18:53:37 +0000 | [diff] [blame] | 235 | |
| 236 | case CK_Informative: |
| 237 | case CK_ResultType: |
| 238 | OS << "[#" << C->Text << "#]"; |
| 239 | break; |
| 240 | |
Douglas Gregor | 0c8296d | 2009-11-07 00:00:49 +0000 | [diff] [blame] | 241 | case CK_CurrentParameter: OS << "<#" << C->Text << "#>"; break; |
| 242 | default: OS << C->Text; break; |
Douglas Gregor | e6e0361 | 2009-09-18 22:15:54 +0000 | [diff] [blame] | 243 | } |
| 244 | } |
Dan Gohman | 6bdeb40 | 2010-07-26 21:33:22 +0000 | [diff] [blame] | 245 | return OS.str(); |
Douglas Gregor | e6e0361 | 2009-09-18 22:15:54 +0000 | [diff] [blame] | 246 | } |
| 247 | |
Douglas Gregor | 54f0161 | 2009-11-19 00:01:57 +0000 | [diff] [blame] | 248 | const char *CodeCompletionString::getTypedText() const { |
| 249 | for (iterator C = begin(), CEnd = end(); C != CEnd; ++C) |
| 250 | if (C->Kind == CK_TypedText) |
| 251 | return C->Text; |
| 252 | |
| 253 | return 0; |
| 254 | } |
| 255 | |
Chris Lattner | 5f9e272 | 2011-07-23 10:55:15 +0000 | [diff] [blame] | 256 | const char *CodeCompletionAllocator::CopyString(StringRef String) { |
Douglas Gregor | dae6875 | 2011-02-01 22:57:45 +0000 | [diff] [blame] | 257 | char *Mem = (char *)Allocate(String.size() + 1, 1); |
| 258 | std::copy(String.begin(), String.end(), Mem); |
| 259 | Mem[String.size()] = 0; |
| 260 | return Mem; |
| 261 | } |
| 262 | |
Chris Lattner | 5f9e272 | 2011-07-23 10:55:15 +0000 | [diff] [blame] | 263 | const char *CodeCompletionAllocator::CopyString(Twine String) { |
Douglas Gregor | 577cdfd | 2011-02-17 00:22:45 +0000 | [diff] [blame] | 264 | // FIXME: It would be more efficient to teach Twine to tell us its size and |
| 265 | // then add a routine there to fill in an allocated char* with the contents |
| 266 | // of the string. |
Dylan Noblesmith | f7ccbad | 2012-02-05 02:13:05 +0000 | [diff] [blame] | 267 | SmallString<128> Data; |
Douglas Gregor | 577cdfd | 2011-02-17 00:22:45 +0000 | [diff] [blame] | 268 | return CopyString(String.toStringRef(Data)); |
| 269 | } |
| 270 | |
Argyrios Kyrtzidis | 28a83f5 | 2012-04-10 17:23:48 +0000 | [diff] [blame] | 271 | StringRef CodeCompletionTUInfo::getParentName(DeclContext *DC) { |
| 272 | NamedDecl *ND = dyn_cast<NamedDecl>(DC); |
| 273 | if (!ND) |
| 274 | return StringRef(); |
| 275 | |
| 276 | // Check whether we've already cached the parent name. |
| 277 | StringRef &CachedParentName = ParentNames[DC]; |
| 278 | if (!CachedParentName.empty()) |
| 279 | return CachedParentName; |
| 280 | |
| 281 | // If we already processed this DeclContext and assigned empty to it, the |
| 282 | // data pointer will be non-null. |
| 283 | if (CachedParentName.data() != 0) |
| 284 | return StringRef(); |
| 285 | |
| 286 | // Find the interesting names. |
| 287 | llvm::SmallVector<DeclContext *, 2> Contexts; |
| 288 | while (DC && !DC->isFunctionOrMethod()) { |
| 289 | if (NamedDecl *ND = dyn_cast<NamedDecl>(DC)) { |
| 290 | if (ND->getIdentifier()) |
| 291 | Contexts.push_back(DC); |
| 292 | } |
| 293 | |
| 294 | DC = DC->getParent(); |
| 295 | } |
| 296 | |
| 297 | { |
| 298 | llvm::SmallString<128> S; |
| 299 | llvm::raw_svector_ostream OS(S); |
| 300 | bool First = true; |
| 301 | for (unsigned I = Contexts.size(); I != 0; --I) { |
| 302 | if (First) |
| 303 | First = false; |
| 304 | else { |
| 305 | OS << "::"; |
| 306 | } |
| 307 | |
| 308 | DeclContext *CurDC = Contexts[I-1]; |
| 309 | if (ObjCCategoryImplDecl *CatImpl = dyn_cast<ObjCCategoryImplDecl>(CurDC)) |
| 310 | CurDC = CatImpl->getCategoryDecl(); |
| 311 | |
| 312 | if (ObjCCategoryDecl *Cat = dyn_cast<ObjCCategoryDecl>(CurDC)) { |
| 313 | ObjCInterfaceDecl *Interface = Cat->getClassInterface(); |
| 314 | if (!Interface) { |
| 315 | // Assign an empty StringRef but with non-null data to distinguish |
| 316 | // between empty because we didn't process the DeclContext yet. |
| 317 | CachedParentName = StringRef((const char *)~0U, 0); |
| 318 | return StringRef(); |
| 319 | } |
| 320 | |
| 321 | OS << Interface->getName() << '(' << Cat->getName() << ')'; |
| 322 | } else { |
| 323 | OS << cast<NamedDecl>(CurDC)->getName(); |
| 324 | } |
| 325 | } |
| 326 | |
| 327 | CachedParentName = AllocatorRef->CopyString(OS.str()); |
| 328 | } |
| 329 | |
| 330 | return CachedParentName; |
| 331 | } |
| 332 | |
Douglas Gregor | 218937c | 2011-02-01 19:23:04 +0000 | [diff] [blame] | 333 | CodeCompletionString *CodeCompletionBuilder::TakeString() { |
Argyrios Kyrtzidis | 28a83f5 | 2012-04-10 17:23:48 +0000 | [diff] [blame] | 334 | void *Mem = getAllocator().Allocate( |
Erik Verbruggen | 6164ea1 | 2011-10-14 15:31:08 +0000 | [diff] [blame] | 335 | sizeof(CodeCompletionString) + sizeof(Chunk) * Chunks.size() |
| 336 | + sizeof(const char *) * Annotations.size(), |
Douglas Gregor | 218937c | 2011-02-01 19:23:04 +0000 | [diff] [blame] | 337 | llvm::alignOf<CodeCompletionString>()); |
| 338 | CodeCompletionString *Result |
| 339 | = new (Mem) CodeCompletionString(Chunks.data(), Chunks.size(), |
Erik Verbruggen | 6164ea1 | 2011-10-14 15:31:08 +0000 | [diff] [blame] | 340 | Priority, Availability, |
Douglas Gregor | ba10306 | 2012-03-27 23:34:16 +0000 | [diff] [blame] | 341 | Annotations.data(), Annotations.size(), |
Dmitri Gribenko | d99ef53 | 2012-07-02 17:35:10 +0000 | [diff] [blame] | 342 | ParentKind, ParentName, BriefComment); |
Douglas Gregor | 218937c | 2011-02-01 19:23:04 +0000 | [diff] [blame] | 343 | Chunks.clear(); |
Douglas Gregor | 54f0161 | 2009-11-19 00:01:57 +0000 | [diff] [blame] | 344 | return Result; |
| 345 | } |
Douglas Gregor | 0c8296d | 2009-11-07 00:00:49 +0000 | [diff] [blame] | 346 | |
Benjamin Kramer | 1eb18af | 2012-03-26 16:57:36 +0000 | [diff] [blame] | 347 | void CodeCompletionBuilder::AddTypedTextChunk(const char *Text) { |
| 348 | Chunks.push_back(Chunk(CodeCompletionString::CK_TypedText, Text)); |
| 349 | } |
| 350 | |
| 351 | void CodeCompletionBuilder::AddTextChunk(const char *Text) { |
| 352 | Chunks.push_back(Chunk::CreateText(Text)); |
| 353 | } |
| 354 | |
| 355 | void CodeCompletionBuilder::AddOptionalChunk(CodeCompletionString *Optional) { |
| 356 | Chunks.push_back(Chunk::CreateOptional(Optional)); |
| 357 | } |
| 358 | |
| 359 | void CodeCompletionBuilder::AddPlaceholderChunk(const char *Placeholder) { |
| 360 | Chunks.push_back(Chunk::CreatePlaceholder(Placeholder)); |
| 361 | } |
| 362 | |
| 363 | void CodeCompletionBuilder::AddInformativeChunk(const char *Text) { |
| 364 | Chunks.push_back(Chunk::CreateInformative(Text)); |
| 365 | } |
| 366 | |
| 367 | void CodeCompletionBuilder::AddResultTypeChunk(const char *ResultType) { |
| 368 | Chunks.push_back(Chunk::CreateResultType(ResultType)); |
| 369 | } |
| 370 | |
| 371 | void |
| 372 | CodeCompletionBuilder::AddCurrentParameterChunk(const char *CurrentParameter) { |
| 373 | Chunks.push_back(Chunk::CreateCurrentParameter(CurrentParameter)); |
| 374 | } |
| 375 | |
| 376 | void CodeCompletionBuilder::AddChunk(CodeCompletionString::ChunkKind CK, |
| 377 | const char *Text) { |
| 378 | Chunks.push_back(Chunk(CK, Text)); |
| 379 | } |
| 380 | |
Douglas Gregor | ba10306 | 2012-03-27 23:34:16 +0000 | [diff] [blame] | 381 | void CodeCompletionBuilder::addParentContext(DeclContext *DC) { |
| 382 | if (DC->isTranslationUnit()) { |
| 383 | ParentKind = CXCursor_TranslationUnit; |
| 384 | return; |
| 385 | } |
| 386 | |
| 387 | if (DC->isFunctionOrMethod()) |
| 388 | return; |
| 389 | |
| 390 | NamedDecl *ND = dyn_cast<NamedDecl>(DC); |
| 391 | if (!ND) |
| 392 | return; |
| 393 | |
| 394 | ParentKind = getCursorKindForDecl(ND); |
Argyrios Kyrtzidis | 28a83f5 | 2012-04-10 17:23:48 +0000 | [diff] [blame] | 395 | ParentName = getCodeCompletionTUInfo().getParentName(DC); |
Douglas Gregor | ba10306 | 2012-03-27 23:34:16 +0000 | [diff] [blame] | 396 | } |
| 397 | |
Dmitri Gribenko | d99ef53 | 2012-07-02 17:35:10 +0000 | [diff] [blame] | 398 | void CodeCompletionBuilder::addBriefComment(StringRef Comment) { |
| 399 | BriefComment = Allocator.CopyString(Comment); |
| 400 | } |
| 401 | |
John McCall | 0a2c5e2 | 2010-08-25 06:19:51 +0000 | [diff] [blame] | 402 | unsigned CodeCompletionResult::getPriorityFromDecl(NamedDecl *ND) { |
Douglas Gregor | 12e1313 | 2010-05-26 22:00:08 +0000 | [diff] [blame] | 403 | if (!ND) |
| 404 | return CCP_Unlikely; |
| 405 | |
| 406 | // Context-based decisions. |
Sebastian Redl | 7a126a4 | 2010-08-31 00:36:30 +0000 | [diff] [blame] | 407 | DeclContext *DC = ND->getDeclContext()->getRedeclContext(); |
Douglas Gregor | 97fe61c | 2010-09-18 15:16:27 +0000 | [diff] [blame] | 408 | if (DC->isFunctionOrMethod() || isa<BlockDecl>(DC)) { |
| 409 | // _cmd is relatively rare |
| 410 | if (ImplicitParamDecl *ImplicitParam = dyn_cast<ImplicitParamDecl>(ND)) |
| 411 | if (ImplicitParam->getIdentifier() && |
| 412 | ImplicitParam->getIdentifier()->isStr("_cmd")) |
| 413 | return CCP_ObjC_cmd; |
| 414 | |
Douglas Gregor | 12e1313 | 2010-05-26 22:00:08 +0000 | [diff] [blame] | 415 | return CCP_LocalDeclaration; |
Douglas Gregor | 97fe61c | 2010-09-18 15:16:27 +0000 | [diff] [blame] | 416 | } |
Douglas Gregor | 12e1313 | 2010-05-26 22:00:08 +0000 | [diff] [blame] | 417 | if (DC->isRecord() || isa<ObjCContainerDecl>(DC)) |
| 418 | return CCP_MemberDeclaration; |
| 419 | |
| 420 | // Content-based decisions. |
| 421 | if (isa<EnumConstantDecl>(ND)) |
| 422 | return CCP_Constant; |
| 423 | if (isa<TypeDecl>(ND) || isa<ObjCInterfaceDecl>(ND)) |
| 424 | return CCP_Type; |
Douglas Gregor | 97fe61c | 2010-09-18 15:16:27 +0000 | [diff] [blame] | 425 | |
Douglas Gregor | 12e1313 | 2010-05-26 22:00:08 +0000 | [diff] [blame] | 426 | return CCP_Declaration; |
| 427 | } |
| 428 | |
Douglas Gregor | e6e0361 | 2009-09-18 22:15:54 +0000 | [diff] [blame] | 429 | //===----------------------------------------------------------------------===// |
Douglas Gregor | 0594438 | 2009-09-23 00:16:58 +0000 | [diff] [blame] | 430 | // Code completion overload candidate implementation |
| 431 | //===----------------------------------------------------------------------===// |
| 432 | FunctionDecl * |
| 433 | CodeCompleteConsumer::OverloadCandidate::getFunction() const { |
| 434 | if (getKind() == CK_Function) |
| 435 | return Function; |
| 436 | else if (getKind() == CK_FunctionTemplate) |
| 437 | return FunctionTemplate->getTemplatedDecl(); |
| 438 | else |
| 439 | return 0; |
| 440 | } |
| 441 | |
| 442 | const FunctionType * |
| 443 | CodeCompleteConsumer::OverloadCandidate::getFunctionType() const { |
| 444 | switch (Kind) { |
| 445 | case CK_Function: |
| 446 | return Function->getType()->getAs<FunctionType>(); |
| 447 | |
| 448 | case CK_FunctionTemplate: |
| 449 | return FunctionTemplate->getTemplatedDecl()->getType() |
| 450 | ->getAs<FunctionType>(); |
| 451 | |
| 452 | case CK_FunctionType: |
| 453 | return Type; |
| 454 | } |
David Blaikie | 7530c03 | 2012-01-17 06:56:22 +0000 | [diff] [blame] | 455 | |
| 456 | llvm_unreachable("Invalid CandidateKind!"); |
Douglas Gregor | 0594438 | 2009-09-23 00:16:58 +0000 | [diff] [blame] | 457 | } |
| 458 | |
| 459 | //===----------------------------------------------------------------------===// |
Douglas Gregor | e6e0361 | 2009-09-18 22:15:54 +0000 | [diff] [blame] | 460 | // Code completion consumer implementation |
| 461 | //===----------------------------------------------------------------------===// |
| 462 | |
Douglas Gregor | 86d9a52 | 2009-09-21 16:56:56 +0000 | [diff] [blame] | 463 | CodeCompleteConsumer::~CodeCompleteConsumer() { } |
Douglas Gregor | e6e0361 | 2009-09-18 22:15:54 +0000 | [diff] [blame] | 464 | |
Douglas Gregor | 81b747b | 2009-09-17 21:32:03 +0000 | [diff] [blame] | 465 | void |
Daniel Dunbar | 3a2838d | 2009-11-13 08:58:20 +0000 | [diff] [blame] | 466 | PrintingCodeCompleteConsumer::ProcessCodeCompleteResults(Sema &SemaRef, |
Douglas Gregor | e6b1bb6 | 2010-08-11 21:23:17 +0000 | [diff] [blame] | 467 | CodeCompletionContext Context, |
John McCall | 0a2c5e2 | 2010-08-25 06:19:51 +0000 | [diff] [blame] | 468 | CodeCompletionResult *Results, |
Douglas Gregor | 81b747b | 2009-09-17 21:32:03 +0000 | [diff] [blame] | 469 | unsigned NumResults) { |
Douglas Gregor | 1e5e668 | 2010-08-26 13:48:20 +0000 | [diff] [blame] | 470 | std::stable_sort(Results, Results + NumResults); |
| 471 | |
Douglas Gregor | 81b747b | 2009-09-17 21:32:03 +0000 | [diff] [blame] | 472 | // Print the results. |
| 473 | for (unsigned I = 0; I != NumResults; ++I) { |
Douglas Gregor | f52cede | 2009-10-09 22:16:47 +0000 | [diff] [blame] | 474 | OS << "COMPLETION: "; |
Douglas Gregor | 81b747b | 2009-09-17 21:32:03 +0000 | [diff] [blame] | 475 | switch (Results[I].Kind) { |
John McCall | 0a2c5e2 | 2010-08-25 06:19:51 +0000 | [diff] [blame] | 476 | case CodeCompletionResult::RK_Declaration: |
Benjamin Kramer | b8989f2 | 2011-10-14 18:45:37 +0000 | [diff] [blame] | 477 | OS << *Results[I].Declaration; |
Douglas Gregor | 81b747b | 2009-09-17 21:32:03 +0000 | [diff] [blame] | 478 | if (Results[I].Hidden) |
| 479 | OS << " (Hidden)"; |
Douglas Gregor | 86d9a52 | 2009-09-21 16:56:56 +0000 | [diff] [blame] | 480 | if (CodeCompletionString *CCS |
Argyrios Kyrtzidis | 28a83f5 | 2012-04-10 17:23:48 +0000 | [diff] [blame] | 481 | = Results[I].CreateCodeCompletionString(SemaRef, getAllocator(), |
Dmitri Gribenko | d99ef53 | 2012-07-02 17:35:10 +0000 | [diff] [blame] | 482 | CCTUInfo, |
| 483 | includeBriefComments())) { |
Douglas Gregor | e6e0361 | 2009-09-18 22:15:54 +0000 | [diff] [blame] | 484 | OS << " : " << CCS->getAsString(); |
Dmitri Gribenko | d99ef53 | 2012-07-02 17:35:10 +0000 | [diff] [blame] | 485 | if (const char *BriefComment = CCS->getBriefComment()) |
| 486 | OS << " : " << BriefComment; |
Douglas Gregor | e6e0361 | 2009-09-18 22:15:54 +0000 | [diff] [blame] | 487 | } |
| 488 | |
Douglas Gregor | 81b747b | 2009-09-17 21:32:03 +0000 | [diff] [blame] | 489 | OS << '\n'; |
| 490 | break; |
| 491 | |
John McCall | 0a2c5e2 | 2010-08-25 06:19:51 +0000 | [diff] [blame] | 492 | case CodeCompletionResult::RK_Keyword: |
Douglas Gregor | ab0b4f1 | 2010-01-13 23:24:38 +0000 | [diff] [blame] | 493 | OS << Results[I].Keyword << '\n'; |
Douglas Gregor | 81b747b | 2009-09-17 21:32:03 +0000 | [diff] [blame] | 494 | break; |
Douglas Gregor | 3f7c7f4 | 2009-10-30 16:50:04 +0000 | [diff] [blame] | 495 | |
John McCall | 0a2c5e2 | 2010-08-25 06:19:51 +0000 | [diff] [blame] | 496 | case CodeCompletionResult::RK_Macro: { |
Douglas Gregor | ab0b4f1 | 2010-01-13 23:24:38 +0000 | [diff] [blame] | 497 | OS << Results[I].Macro->getName(); |
Douglas Gregor | 3f7c7f4 | 2009-10-30 16:50:04 +0000 | [diff] [blame] | 498 | if (CodeCompletionString *CCS |
Argyrios Kyrtzidis | 28a83f5 | 2012-04-10 17:23:48 +0000 | [diff] [blame] | 499 | = Results[I].CreateCodeCompletionString(SemaRef, getAllocator(), |
Dmitri Gribenko | d99ef53 | 2012-07-02 17:35:10 +0000 | [diff] [blame] | 500 | CCTUInfo, |
| 501 | includeBriefComments())) { |
Douglas Gregor | 3f7c7f4 | 2009-10-30 16:50:04 +0000 | [diff] [blame] | 502 | OS << " : " << CCS->getAsString(); |
Douglas Gregor | 3f7c7f4 | 2009-10-30 16:50:04 +0000 | [diff] [blame] | 503 | } |
| 504 | OS << '\n'; |
| 505 | break; |
| 506 | } |
Douglas Gregor | 54f0161 | 2009-11-19 00:01:57 +0000 | [diff] [blame] | 507 | |
John McCall | 0a2c5e2 | 2010-08-25 06:19:51 +0000 | [diff] [blame] | 508 | case CodeCompletionResult::RK_Pattern: { |
Douglas Gregor | ab0b4f1 | 2010-01-13 23:24:38 +0000 | [diff] [blame] | 509 | OS << "Pattern : " |
Douglas Gregor | 54f0161 | 2009-11-19 00:01:57 +0000 | [diff] [blame] | 510 | << Results[I].Pattern->getAsString() << '\n'; |
| 511 | break; |
| 512 | } |
Douglas Gregor | 81b747b | 2009-09-17 21:32:03 +0000 | [diff] [blame] | 513 | } |
| 514 | } |
Douglas Gregor | 81b747b | 2009-09-17 21:32:03 +0000 | [diff] [blame] | 515 | } |
Douglas Gregor | 0594438 | 2009-09-23 00:16:58 +0000 | [diff] [blame] | 516 | |
| 517 | void |
Daniel Dunbar | 3a2838d | 2009-11-13 08:58:20 +0000 | [diff] [blame] | 518 | PrintingCodeCompleteConsumer::ProcessOverloadCandidates(Sema &SemaRef, |
| 519 | unsigned CurrentArg, |
Douglas Gregor | 0594438 | 2009-09-23 00:16:58 +0000 | [diff] [blame] | 520 | OverloadCandidate *Candidates, |
| 521 | unsigned NumCandidates) { |
| 522 | for (unsigned I = 0; I != NumCandidates; ++I) { |
Douglas Gregor | 86d802e | 2009-09-23 00:34:09 +0000 | [diff] [blame] | 523 | if (CodeCompletionString *CCS |
Douglas Gregor | 218937c | 2011-02-01 19:23:04 +0000 | [diff] [blame] | 524 | = Candidates[I].CreateSignatureString(CurrentArg, SemaRef, |
Argyrios Kyrtzidis | 28a83f5 | 2012-04-10 17:23:48 +0000 | [diff] [blame] | 525 | getAllocator(), CCTUInfo)) { |
Douglas Gregor | f52cede | 2009-10-09 22:16:47 +0000 | [diff] [blame] | 526 | OS << "OVERLOAD: " << CCS->getAsString() << "\n"; |
Douglas Gregor | 0594438 | 2009-09-23 00:16:58 +0000 | [diff] [blame] | 527 | } |
| 528 | } |
Douglas Gregor | 0594438 | 2009-09-23 00:16:58 +0000 | [diff] [blame] | 529 | } |
Douglas Gregor | 0c8296d | 2009-11-07 00:00:49 +0000 | [diff] [blame] | 530 | |
Douglas Gregor | 8e42f27 | 2012-03-17 06:39:06 +0000 | [diff] [blame] | 531 | /// \brief Retrieve the effective availability of the given declaration. |
| 532 | static AvailabilityResult getDeclAvailability(Decl *D) { |
| 533 | AvailabilityResult AR = D->getAvailability(); |
| 534 | if (isa<EnumConstantDecl>(D)) |
| 535 | AR = std::max(AR, cast<Decl>(D->getDeclContext())->getAvailability()); |
| 536 | return AR; |
| 537 | } |
| 538 | |
Erik Verbruggen | d120596 | 2011-10-06 07:27:49 +0000 | [diff] [blame] | 539 | void CodeCompletionResult::computeCursorKindAndAvailability(bool Accessible) { |
Douglas Gregor | 87c08a5 | 2010-08-13 22:48:40 +0000 | [diff] [blame] | 540 | switch (Kind) { |
Douglas Gregor | ba10306 | 2012-03-27 23:34:16 +0000 | [diff] [blame] | 541 | case RK_Pattern: |
| 542 | if (!Declaration) { |
| 543 | // Do nothing: Patterns can come with cursor kinds! |
| 544 | break; |
| 545 | } |
| 546 | // Fall through |
| 547 | |
Douglas Gregor | 8e42f27 | 2012-03-17 06:39:06 +0000 | [diff] [blame] | 548 | case RK_Declaration: { |
Douglas Gregor | 58ddb60 | 2010-08-23 23:00:57 +0000 | [diff] [blame] | 549 | // Set the availability based on attributes. |
Douglas Gregor | 8e42f27 | 2012-03-17 06:39:06 +0000 | [diff] [blame] | 550 | switch (getDeclAvailability(Declaration)) { |
Douglas Gregor | 0a0d2b1 | 2011-03-23 00:50:03 +0000 | [diff] [blame] | 551 | case AR_Available: |
| 552 | case AR_NotYetIntroduced: |
| 553 | Availability = CXAvailability_Available; |
| 554 | break; |
Douglas Gregor | 58ddb60 | 2010-08-23 23:00:57 +0000 | [diff] [blame] | 555 | |
Douglas Gregor | 0a0d2b1 | 2011-03-23 00:50:03 +0000 | [diff] [blame] | 556 | case AR_Deprecated: |
| 557 | Availability = CXAvailability_Deprecated; |
| 558 | break; |
| 559 | |
| 560 | case AR_Unavailable: |
| 561 | Availability = CXAvailability_NotAvailable; |
| 562 | break; |
| 563 | } |
| 564 | |
Douglas Gregor | e8d7beb | 2010-09-03 23:30:36 +0000 | [diff] [blame] | 565 | if (FunctionDecl *Function = dyn_cast<FunctionDecl>(Declaration)) |
| 566 | if (Function->isDeleted()) |
Douglas Gregor | 58ddb60 | 2010-08-23 23:00:57 +0000 | [diff] [blame] | 567 | Availability = CXAvailability_NotAvailable; |
Douglas Gregor | e8d7beb | 2010-09-03 23:30:36 +0000 | [diff] [blame] | 568 | |
| 569 | CursorKind = getCursorKindForDecl(Declaration); |
Douglas Gregor | 375bb14 | 2011-12-27 22:43:10 +0000 | [diff] [blame] | 570 | if (CursorKind == CXCursor_UnexposedDecl) { |
Douglas Gregor | bd9482d | 2012-01-01 21:23:57 +0000 | [diff] [blame] | 571 | // FIXME: Forward declarations of Objective-C classes and protocols |
| 572 | // are not directly exposed, but we want code completion to treat them |
| 573 | // like a definition. |
Douglas Gregor | 375bb14 | 2011-12-27 22:43:10 +0000 | [diff] [blame] | 574 | if (isa<ObjCInterfaceDecl>(Declaration)) |
| 575 | CursorKind = CXCursor_ObjCInterfaceDecl; |
Douglas Gregor | bd9482d | 2012-01-01 21:23:57 +0000 | [diff] [blame] | 576 | else if (isa<ObjCProtocolDecl>(Declaration)) |
| 577 | CursorKind = CXCursor_ObjCProtocolDecl; |
Douglas Gregor | 375bb14 | 2011-12-27 22:43:10 +0000 | [diff] [blame] | 578 | else |
| 579 | CursorKind = CXCursor_NotImplemented; |
| 580 | } |
Douglas Gregor | 87c08a5 | 2010-08-13 22:48:40 +0000 | [diff] [blame] | 581 | break; |
Douglas Gregor | 8e42f27 | 2012-03-17 06:39:06 +0000 | [diff] [blame] | 582 | } |
Douglas Gregor | 87c08a5 | 2010-08-13 22:48:40 +0000 | [diff] [blame] | 583 | |
John McCall | 0a2c5e2 | 2010-08-25 06:19:51 +0000 | [diff] [blame] | 584 | case RK_Macro: |
John McCall | 0a2c5e2 | 2010-08-25 06:19:51 +0000 | [diff] [blame] | 585 | case RK_Keyword: |
Benjamin Kramer | e5f8372 | 2012-05-20 14:19:46 +0000 | [diff] [blame] | 586 | llvm_unreachable("Macro and keyword kinds are handled by the constructors"); |
Douglas Gregor | 1abc6bc | 2010-08-04 16:47:14 +0000 | [diff] [blame] | 587 | } |
Erik Verbruggen | d120596 | 2011-10-06 07:27:49 +0000 | [diff] [blame] | 588 | |
| 589 | if (!Accessible) |
| 590 | Availability = CXAvailability_NotAccessible; |
Douglas Gregor | 1abc6bc | 2010-08-04 16:47:14 +0000 | [diff] [blame] | 591 | } |
Douglas Gregor | 2b4074f | 2009-12-01 05:55:20 +0000 | [diff] [blame] | 592 | |
Douglas Gregor | 721f359 | 2010-08-25 18:41:16 +0000 | [diff] [blame] | 593 | /// \brief Retrieve the name that should be used to order a result. |
| 594 | /// |
| 595 | /// If the name needs to be constructed as a string, that string will be |
| 596 | /// saved into Saved and the returned StringRef will refer to it. |
Chris Lattner | 5f9e272 | 2011-07-23 10:55:15 +0000 | [diff] [blame] | 597 | static StringRef getOrderedName(const CodeCompletionResult &R, |
Douglas Gregor | 721f359 | 2010-08-25 18:41:16 +0000 | [diff] [blame] | 598 | std::string &Saved) { |
| 599 | switch (R.Kind) { |
| 600 | case CodeCompletionResult::RK_Keyword: |
| 601 | return R.Keyword; |
| 602 | |
| 603 | case CodeCompletionResult::RK_Pattern: |
| 604 | return R.Pattern->getTypedText(); |
| 605 | |
| 606 | case CodeCompletionResult::RK_Macro: |
| 607 | return R.Macro->getName(); |
| 608 | |
| 609 | case CodeCompletionResult::RK_Declaration: |
| 610 | // Handle declarations below. |
| 611 | break; |
| 612 | } |
| 613 | |
| 614 | DeclarationName Name = R.Declaration->getDeclName(); |
| 615 | |
| 616 | // If the name is a simple identifier (by far the common case), or a |
| 617 | // zero-argument selector, just return a reference to that identifier. |
| 618 | if (IdentifierInfo *Id = Name.getAsIdentifierInfo()) |
| 619 | return Id->getName(); |
| 620 | if (Name.isObjCZeroArgSelector()) |
| 621 | if (IdentifierInfo *Id |
| 622 | = Name.getObjCSelector().getIdentifierInfoForSlot(0)) |
| 623 | return Id->getName(); |
| 624 | |
| 625 | Saved = Name.getAsString(); |
| 626 | return Saved; |
| 627 | } |
| 628 | |
| 629 | bool clang::operator<(const CodeCompletionResult &X, |
| 630 | const CodeCompletionResult &Y) { |
| 631 | std::string XSaved, YSaved; |
Chris Lattner | 5f9e272 | 2011-07-23 10:55:15 +0000 | [diff] [blame] | 632 | StringRef XStr = getOrderedName(X, XSaved); |
| 633 | StringRef YStr = getOrderedName(Y, YSaved); |
Douglas Gregor | 721f359 | 2010-08-25 18:41:16 +0000 | [diff] [blame] | 634 | int cmp = XStr.compare_lower(YStr); |
| 635 | if (cmp) |
| 636 | return cmp < 0; |
| 637 | |
Douglas Gregor | 1e5e668 | 2010-08-26 13:48:20 +0000 | [diff] [blame] | 638 | // If case-insensitive comparison fails, try case-sensitive comparison. |
| 639 | cmp = XStr.compare(YStr); |
| 640 | if (cmp) |
| 641 | return cmp < 0; |
Douglas Gregor | 721f359 | 2010-08-25 18:41:16 +0000 | [diff] [blame] | 642 | |
| 643 | return false; |
| 644 | } |