17 #include "clang/AST/Decl.h"
18 #include "clang/AST/DeclBase.h"
19 #include "clang/AST/DeclarationName.h"
20 #include "clang/AST/NestedNameSpecifier.h"
21 #include "clang/AST/Type.h"
22 #include "clang/Basic/Diagnostic.h"
23 #include "clang/Basic/DiagnosticParse.h"
24 #include "clang/Basic/DiagnosticSema.h"
25 #include "clang/Basic/LangOptions.h"
26 #include "clang/Basic/SourceLocation.h"
27 #include "clang/Basic/SourceManager.h"
28 #include "clang/Basic/TokenKinds.h"
29 #include "clang/Lex/Lexer.h"
30 #include "clang/Sema/DeclSpec.h"
31 #include "clang/Sema/Lookup.h"
32 #include "clang/Sema/Scope.h"
33 #include "clang/Sema/Sema.h"
34 #include "clang/Sema/TypoCorrection.h"
35 #include "llvm/ADT/DenseMap.h"
36 #include "llvm/ADT/None.h"
37 #include "llvm/ADT/Optional.h"
38 #include "llvm/ADT/StringExtras.h"
39 #include "llvm/ADT/StringRef.h"
40 #include "llvm/ADT/StringSet.h"
41 #include "llvm/Support/Error.h"
42 #include "llvm/Support/FormatVariadic.h"
55 case DiagnosticsEngine::ak_c_string:
56 return llvm::StringRef(
Info.getArgCStr(
Index));
57 case DiagnosticsEngine::ak_std_string:
58 return llvm::StringRef(
Info.getArgStdStr(
Index));
64 std::vector<Fix> only(llvm::Optional<Fix> F) {
66 return {std::move(*F)};
74 switch (
Info.getID()) {
84 case diag::err_array_incomplete_or_sizeless_type:
85 case diag::err_array_size_incomplete_type:
86 case diag::err_asm_incomplete_type:
87 case diag::err_assoc_type_incomplete:
88 case diag::err_bad_cast_incomplete:
89 case diag::err_call_function_incomplete_return:
90 case diag::err_call_incomplete_argument:
91 case diag::err_call_incomplete_return:
92 case diag::err_capture_of_incomplete_or_sizeless_type:
93 case diag::err_catch_incomplete:
94 case diag::err_catch_incomplete_ptr:
95 case diag::err_catch_incomplete_ref:
96 case diag::err_cconv_incomplete_param_type:
97 case diag::err_coroutine_promise_type_incomplete:
98 case diag::err_covariant_return_incomplete:
100 case diag::err_delete_incomplete_class_type:
101 case diag::err_dereference_incomplete_type:
102 case diag::err_exception_spec_incomplete_type:
103 case diag::err_field_incomplete_or_sizeless:
104 case diag::err_for_range_incomplete_type:
105 case diag::err_func_def_incomplete_result:
106 case diag::err_ice_incomplete_type:
107 case diag::err_illegal_message_expr_incomplete_type:
108 case diag::err_incomplete_base_class:
109 case diag::err_incomplete_enum:
110 case diag::err_incomplete_in_exception_spec:
111 case diag::err_incomplete_member_access:
112 case diag::err_incomplete_nested_name_spec:
113 case diag::err_incomplete_object_call:
114 case diag::err_incomplete_receiver_type:
115 case diag::err_incomplete_synthesized_property:
116 case diag::err_incomplete_type:
117 case diag::err_incomplete_type_objc_at_encode:
118 case diag::err_incomplete_type_used_in_type_trait_expr:
119 case diag::err_incomplete_typeid:
120 case diag::err_init_incomplete_type:
121 case diag::err_invalid_incomplete_type_use:
122 case diag::err_lambda_incomplete_result:
125 case diag::err_memptr_incomplete:
126 case diag::err_new_incomplete_or_sizeless_type:
127 case diag::err_objc_incomplete_boxed_expression_type:
128 case diag::err_objc_index_incomplete_class_type:
129 case diag::err_offsetof_incomplete_type:
130 case diag::err_omp_firstprivate_incomplete_type:
131 case diag::err_omp_incomplete_type:
132 case diag::err_omp_lastprivate_incomplete_type:
133 case diag::err_omp_linear_incomplete_type:
134 case diag::err_omp_private_incomplete_type:
135 case diag::err_omp_reduction_incomplete_type:
136 case diag::err_omp_section_incomplete_type:
137 case diag::err_omp_threadprivate_incomplete_type:
138 case diag::err_second_parameter_to_va_arg_incomplete:
139 case diag::err_sizeof_alignof_incomplete_or_sizeless_type:
140 case diag::err_subscript_incomplete_or_sizeless_type:
141 case diag::err_switch_incomplete_class_type:
142 case diag::err_temp_copy_incomplete:
144 case diag::err_template_nontype_parm_incomplete:
146 case diag::err_throw_incomplete:
147 case diag::err_throw_incomplete_ptr:
148 case diag::err_typecheck_arithmetic_incomplete_or_sizeless_type:
149 case diag::err_typecheck_cast_to_incomplete:
150 case diag::err_typecheck_decl_incomplete_type:
152 case diag::err_typecheck_incomplete_tag:
153 case diag::err_typecheck_incomplete_type_not_modifiable_lvalue:
154 case diag::err_typecheck_nonviable_condition_incomplete:
155 case diag::err_underlying_type_of_incomplete_enum:
156 case diag::ext_incomplete_in_exception_spec:
158 case diag::ext_typecheck_decl_incomplete_type:
159 case diag::warn_delete_incomplete:
160 case diag::warn_incomplete_encoded_type:
162 case diag::warn_return_value_udt_incomplete:
168 for (
unsigned Idx = 0; Idx <
Info.getNumArgs(); ++Idx) {
169 if (
Info.getArgKind(Idx) == DiagnosticsEngine::ak_qualtype) {
170 auto QT = QualType::getFromOpaquePtr((
void *)
Info.getRawArg(Idx));
171 if (
const Type *T = QT.getTypePtrOrNull()) {
172 if (T->isIncompleteType())
173 return fixIncompleteType(*T);
176 if (
auto * ET = llvm::dyn_cast<EnumType>(T))
177 if (!ET->getDecl()->getDefinition())
178 return fixIncompleteType(*T);
184 case diag::err_unknown_typename:
185 case diag::err_unknown_typename_suggest:
186 case diag::err_unknown_type_or_class_name_suggest:
187 case diag::err_expected_class_name:
188 case diag::err_typename_nested_not_found:
189 case diag::err_no_template:
190 case diag::err_no_template_suggest:
191 case diag::err_undeclared_use:
192 case diag::err_undeclared_use_suggest:
193 case diag::err_undeclared_var_use:
194 case diag::err_undeclared_var_use_suggest:
195 case diag::err_no_member:
196 case diag::err_no_member_suggest:
197 case diag::err_no_member_template:
198 case diag::err_no_member_template_suggest:
199 case diag::warn_implicit_function_decl:
200 case diag::ext_implicit_function_decl_c99:
201 dlog(
"Unresolved name at {0}, last typo was {1}",
202 Info.getLocation().printToString(
Info.getSourceManager()),
204 ? LastUnresolvedName->Loc.printToString(
Info.getSourceManager())
206 if (LastUnresolvedName) {
218 if (LastUnresolvedName->Loc ==
Info.getLocation())
219 return fixUnresolvedName();
225 case diag::err_implied_std_initializer_list_not_found:
226 return only(insertHeader(
"<initializer_list>"));
227 case diag::err_need_header_before_typeid:
228 return only(insertHeader(
"<typeid>"));
229 case diag::err_need_header_before_placement_new:
230 case diag::err_implicit_coroutine_std_nothrow_type_not_found:
231 return only(insertHeader(
"<new>"));
232 case diag::err_omp_implied_type_not_found:
233 case diag::err_omp_interop_type_not_found:
234 return only(insertHeader(
"<omp.h>"));
235 case diag::err_implied_coroutine_type_not_found:
236 return only(insertHeader(
"<coroutine>"));
237 case diag::err_implied_comparison_category_type_not_found:
238 return only(insertHeader(
"<compare>"));
239 case diag::note_include_header_or_declare:
240 if (
Info.getNumArgs() > 0)
241 if (
auto Header = getArgStr(
Info, 0))
242 return only(insertHeader((
"<" + *Header +
">").str(),
243 getArgStr(
Info, 1).value_or(
"")));
250 llvm::Optional<Fix> IncludeFixer::insertHeader(llvm::StringRef Spelled,
251 llvm::StringRef
Symbol)
const {
254 if (
auto Edit = Inserter->insert(Spelled))
255 F.Edits.push_back(std::move(*
Edit));
260 F.Message = llvm::formatv(
"Include {0}", Spelled);
262 F.Message = llvm::formatv(
"Include {0} for symbol {1}", Spelled,
Symbol);
267 std::vector<Fix> IncludeFixer::fixIncompleteType(
const Type &T)
const {
269 const TagDecl *TD = T.getAsTagDecl();
273 trace::Span
Tracer(
"Fix include for incomplete type");
275 vlog(
"Trying to fix include for incomplete type {0}", TypeName);
280 llvm::Optional<const SymbolSlab *> Symbols = lookupCached(
ID);
283 const SymbolSlab &Syms = **Symbols;
284 std::vector<Fix> Fixes;
286 auto &Matched = *Syms.begin();
287 if (!Matched.IncludeHeaders.empty() && Matched.Definition &&
288 Matched.CanonicalDeclaration.FileURI == Matched.Definition.FileURI)
289 Fixes = fixesForSymbols(Syms);
294 std::vector<Fix> IncludeFixer::fixesForSymbols(
const SymbolSlab &Syms)
const {
295 auto Inserted = [&](
const Symbol &Sym, llvm::StringRef Header)
297 auto ResolvedDeclaring =
299 if (!ResolvedDeclaring)
300 return ResolvedDeclaring.takeError();
302 if (!ResolvedInserted)
303 return ResolvedInserted.takeError();
304 auto Spelled = Inserter->calculateIncludePath(*ResolvedInserted, File);
306 return error(
"Header not on include path");
307 return std::make_pair(
309 Inserter->shouldInsertInclude(*ResolvedDeclaring, *ResolvedInserted));
312 std::vector<Fix> Fixes;
316 llvm::StringSet<> InsertedHeaders;
317 for (
const auto &Sym : Syms) {
319 if (
auto ToInclude = Inserted(Sym, Inc)) {
320 if (ToInclude->second) {
321 if (!InsertedHeaders.try_emplace(ToInclude->first).second)
324 insertHeader(ToInclude->first, (Sym.Scope + Sym.Name).str()))
325 Fixes.push_back(std::move(*
Fix));
328 vlog(
"Failed to calculate include insertion for {0} into {1}: {2}", Inc,
329 File, ToInclude.takeError());
346 SourceLocation NextLoc = SM.getTopMacroCallerLoc(
Loc);
347 while (
auto CCTok = Lexer::findNextToken(NextLoc, SM,
LangOpts)) {
348 if (!CCTok->is(tok::coloncolon))
350 auto IDTok = Lexer::findNextToken(CCTok->getLocation(), SM,
LangOpts);
351 if (!IDTok || !IDTok->is(tok::raw_identifier))
353 Result.append((
"::" + IDTok->getRawIdentifier()).str());
354 NextLoc = IDTok->getLocation();
376 const SourceManager &SM) {
378 if (!SM.isWrittenInSameFile(SS.getBeginLoc(), SS.getEndLoc()))
380 SourceRange
Range(SM.getTopMacroCallerLoc(SS.getBeginLoc()), SM.getTopMacroCallerLoc(SS.getEndLoc()));
381 if (
Range.getBegin().isMacroID() ||
Range.getEnd().isMacroID())
390 const SourceManager &SM,
const DeclarationNameInfo &Unresolved,
391 CXXScopeSpec *SS,
const LangOptions &
LangOpts,
bool UnresolvedIsSpecifier) {
393 Result.Name = Unresolved.getAsString();
394 if (SS && SS->isNotEmpty()) {
395 if (
auto *Nested = SS->getScopeRep()) {
396 if (Nested->getKind() == NestedNameSpecifier::Global) {
397 Result.ResolvedScope =
"";
398 }
else if (
const auto *NS = Nested->getAsNamespace()) {
410 if (!Spelling || llvm::StringRef(SpecifiedNS).endswith(*Spelling)) {
411 Result.ResolvedScope = std::move(SpecifiedNS);
413 Result.UnresolvedScope = std::move(*Spelling);
415 }
else if (
const auto *ANS = Nested->getAsNamespaceAlias()) {
425 if (UnresolvedIsSpecifier) {
436 if (
auto QualifiedByUnresolved =
439 if (!Result.UnresolvedScope)
440 Result.UnresolvedScope.emplace();
449 Result.UnresolvedScope->append((Result.Name + Split.first).str());
450 Result.Name = std::string(Split.second);
457 std::vector<std::string>
459 Sema::LookupNameKind LookupKind) {
461 struct VisitedContextCollector :
public VisibleDeclConsumer {
462 VisitedContextCollector(std::vector<std::string> &
Out) :
Out(
Out) {}
463 void EnteredContext(DeclContext *
Ctx)
override {
464 if (llvm::isa<NamespaceDecl>(
Ctx))
467 void FoundDecl(NamedDecl *ND, NamedDecl *Hiding, DeclContext *
Ctx,
468 bool InBaseClass)
override {}
469 std::vector<std::string> &
Out;
472 std::vector<std::string> Scopes;
473 Scopes.push_back(
"");
474 VisitedContextCollector
Collector(Scopes);
475 Sem.LookupVisibleDecls(S, LookupKind,
Collector,
478 std::sort(Scopes.begin(), Scopes.end());
479 Scopes.erase(std::unique(Scopes.begin(), Scopes.end()), Scopes.end());
486 : LastUnresolvedName(LastUnresolvedName) {}
492 TypoCorrection
CorrectTypo(
const DeclarationNameInfo &Typo,
int LookupKind,
493 Scope *S, CXXScopeSpec *SS,
494 CorrectionCandidateCallback &CCC,
495 DeclContext *MemberContext,
bool EnteringContext,
496 const ObjCObjectPointerType *OPT)
override {
497 dlog(
"CorrectTypo: {0}", Typo.getAsString());
498 assert(SemaPtr &&
"Sema must have been set.");
499 if (SemaPtr->isSFINAEContext())
500 return TypoCorrection();
502 return clang::TypoCorrection();
505 SemaPtr->SourceMgr, Typo, SS, SemaPtr->LangOpts,
506 static_cast<Sema::LookupNameKind
>(LookupKind) ==
507 Sema::LookupNameKind::LookupNestedNameSpecifierName);
509 return TypoCorrection();
511 UnresolvedName Unresolved;
512 Unresolved.Name = Extracted->Name;
513 Unresolved.Loc = Typo.getBeginLoc();
514 if (!Extracted->ResolvedScope && !S)
515 return TypoCorrection();
517 if (Extracted->ResolvedScope)
518 Unresolved.Scopes.push_back(*Extracted->ResolvedScope);
521 *SemaPtr, Typo, S,
static_cast<Sema::LookupNameKind
>(LookupKind));
523 if (Extracted->UnresolvedScope) {
524 for (std::string &Scope : Unresolved.Scopes)
525 Scope += *Extracted->UnresolvedScope;
528 LastUnresolvedName = std::move(Unresolved);
532 return TypoCorrection();
536 Sema *SemaPtr =
nullptr;
538 llvm::Optional<UnresolvedName> &LastUnresolvedName;
541 llvm::IntrusiveRefCntPtr<ExternalSemaSource>
546 std::vector<Fix> IncludeFixer::fixUnresolvedName()
const {
547 assert(LastUnresolvedName);
548 auto &Unresolved = *LastUnresolvedName;
549 vlog(
"Trying to fix unresolved name \"{0}\" in scopes: [{1}]",
550 Unresolved.Name,
llvm::join(Unresolved.Scopes,
", "));
554 Req.
Query = Unresolved.Name;
555 Req.
Scopes = Unresolved.Scopes;
559 if (llvm::Optional<const SymbolSlab *> Syms = fuzzyFindCached(Req))
560 return fixesForSymbols(**Syms);
565 llvm::Optional<const SymbolSlab *>
566 IncludeFixer::fuzzyFindCached(
const FuzzyFindRequest &Req)
const {
567 auto ReqStr = llvm::formatv(
"{0}",
toJSON(Req)).str();
568 auto I = FuzzyFindCache.find(ReqStr);
569 if (I != FuzzyFindCache.end())
572 if (IndexRequestCount >= IndexRequestLimit)
577 Index.fuzzyFind(Req, [&](
const Symbol &Sym) {
578 if (Sym.Name != Req.Query)
580 if (!Sym.IncludeHeaders.empty())
583 auto Syms = std::move(Matches).build();
584 auto E = FuzzyFindCache.try_emplace(ReqStr, std::move(Syms));
585 return &
E.first->second;
588 llvm::Optional<const SymbolSlab *>
589 IncludeFixer::lookupCached(
const SymbolID &
ID)
const {
593 auto I = LookupCache.find(
ID);
594 if (I != LookupCache.end())
597 if (IndexRequestCount >= IndexRequestLimit)
603 Index.lookup(Req, [&](
const Symbol &Sym) { Matches.insert(Sym); });
604 auto Syms = std::move(Matches).build();
606 std::vector<Fix> Fixes;
608 auto &Matched = *Syms.begin();
609 if (!Matched.IncludeHeaders.empty() && Matched.Definition &&
610 Matched.CanonicalDeclaration.FileURI == Matched.Definition.FileURI)
611 Fixes = fixesForSymbols(Syms);
613 auto E = LookupCache.try_emplace(
ID, std::move(Syms));
614 return &
E.first->second;