xref: /llvm-project/clang/lib/Index/USRGeneration.cpp (revision 4ba623f24479879fb7100988f6ad5d9a62c19842) 
1 //===- USRGeneration.cpp - Routines for USR generation --------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 
9 #include "clang/Index/USRGeneration.h"
10 #include "clang/AST/ASTContext.h"
11 #include "clang/AST/Attr.h"
12 #include "clang/AST/DeclCXX.h"
13 #include "clang/AST/DeclTemplate.h"
14 #include "clang/AST/DeclVisitor.h"
15 #include "clang/AST/ODRHash.h"
16 #include "clang/Basic/FileManager.h"
17 #include "clang/Lex/PreprocessingRecord.h"
18 #include "llvm/Support/Path.h"
19 #include "llvm/Support/raw_ostream.h"
20 
21 using namespace clang;
22 using namespace clang::index;
23 
24 //===----------------------------------------------------------------------===//
25 // USR generation.
26 //===----------------------------------------------------------------------===//
27 
28 /// \returns true on error.
29 static bool printLoc(llvm::raw_ostream &OS, SourceLocation Loc,
30                      const SourceManager &SM, bool IncludeOffset) {
31   if (Loc.isInvalid()) {
32     return true;
33   }
34   Loc = SM.getExpansionLoc(Loc);
35   const std::pair<FileID, unsigned> &Decomposed = SM.getDecomposedLoc(Loc);
36   OptionalFileEntryRef FE = SM.getFileEntryRefForID(Decomposed.first);
37   if (FE) {
38     OS << llvm::sys::path::filename(FE->getName());
39   } else {
40     // This case really isn't interesting.
41     return true;
42   }
43   if (IncludeOffset) {
44     // Use the offest into the FileID to represent the location.  Using
45     // a line/column can cause us to look back at the original source file,
46     // which is expensive.
47     OS << '@' << Decomposed.second;
48   }
49   return false;
50 }
51 
52 static StringRef GetExternalSourceContainer(const NamedDecl *D) {
53   if (!D)
54     return StringRef();
55   if (auto *attr = D->getExternalSourceSymbolAttr()) {
56     return attr->getDefinedIn();
57   }
58   return StringRef();
59 }
60 
61 namespace {
62 class USRGenerator : public ConstDeclVisitor<USRGenerator> {
63   SmallVectorImpl<char> &Buf;
64   llvm::raw_svector_ostream Out;
65   ASTContext *Context;
66   const LangOptions &LangOpts;
67   bool IgnoreResults = false;
68   bool generatedLoc = false;
69 
70   llvm::DenseMap<const Type *, unsigned> TypeSubstitutions;
71 
72 public:
73   USRGenerator(ASTContext *Ctx, SmallVectorImpl<char> &Buf,
74                const LangOptions &LangOpts)
75       : Buf(Buf), Out(Buf), Context(Ctx), LangOpts(LangOpts) {
76     // Add the USR space prefix.
77     Out << getUSRSpacePrefix();
78   }
79 
80   bool ignoreResults() const { return IgnoreResults; }
81 
82   // Visitation methods from generating USRs from AST elements.
83   void VisitDeclContext(const DeclContext *D);
84   void VisitFieldDecl(const FieldDecl *D);
85   void VisitFunctionDecl(const FunctionDecl *D);
86   void VisitNamedDecl(const NamedDecl *D);
87   void VisitNamespaceDecl(const NamespaceDecl *D);
88   void VisitNamespaceAliasDecl(const NamespaceAliasDecl *D);
89   void VisitFunctionTemplateDecl(const FunctionTemplateDecl *D);
90   void VisitClassTemplateDecl(const ClassTemplateDecl *D);
91   void VisitObjCContainerDecl(const ObjCContainerDecl *CD,
92                               const ObjCCategoryDecl *CatD = nullptr);
93   void VisitObjCMethodDecl(const ObjCMethodDecl *MD);
94   void VisitObjCPropertyDecl(const ObjCPropertyDecl *D);
95   void VisitObjCPropertyImplDecl(const ObjCPropertyImplDecl *D);
96   void VisitTagDecl(const TagDecl *D);
97   void VisitTypedefDecl(const TypedefDecl *D);
98   void VisitTemplateTypeParmDecl(const TemplateTypeParmDecl *D);
99   void VisitVarDecl(const VarDecl *D);
100   void VisitBindingDecl(const BindingDecl *D);
101   void VisitNonTypeTemplateParmDecl(const NonTypeTemplateParmDecl *D);
102   void VisitTemplateTemplateParmDecl(const TemplateTemplateParmDecl *D);
103   void VisitUnresolvedUsingValueDecl(const UnresolvedUsingValueDecl *D);
104   void VisitUnresolvedUsingTypenameDecl(const UnresolvedUsingTypenameDecl *D);
105   void VisitConceptDecl(const ConceptDecl *D);
106 
107   void VisitLinkageSpecDecl(const LinkageSpecDecl *D) {
108     IgnoreResults = true; // No USRs for linkage specs themselves.
109   }
110 
111   void VisitUsingDirectiveDecl(const UsingDirectiveDecl *D) {
112     IgnoreResults = true;
113   }
114 
115   void VisitUsingDecl(const UsingDecl *D) {
116     VisitDeclContext(D->getDeclContext());
117     Out << "@UD@";
118 
119     bool EmittedDeclName = !EmitDeclName(D);
120     assert(EmittedDeclName && "EmitDeclName can not fail for UsingDecls");
121     (void)EmittedDeclName;
122   }
123 
124   bool ShouldGenerateLocation(const NamedDecl *D);
125 
126   bool isLocal(const NamedDecl *D) {
127     return D->getParentFunctionOrMethod() != nullptr;
128   }
129 
130   void GenExtSymbolContainer(const NamedDecl *D);
131 
132   /// Generate the string component containing the location of the
133   ///  declaration.
134   bool GenLoc(const Decl *D, bool IncludeOffset);
135 
136   /// String generation methods used both by the visitation methods
137   /// and from other clients that want to directly generate USRs.  These
138   /// methods do not construct complete USRs (which incorporate the parents
139   /// of an AST element), but only the fragments concerning the AST element
140   /// itself.
141 
142   /// Generate a USR for an Objective-C class.
143   void GenObjCClass(StringRef cls, StringRef ExtSymDefinedIn,
144                     StringRef CategoryContextExtSymbolDefinedIn) {
145     generateUSRForObjCClass(cls, Out, ExtSymDefinedIn,
146                             CategoryContextExtSymbolDefinedIn);
147   }
148 
149   /// Generate a USR for an Objective-C class category.
150   void GenObjCCategory(StringRef cls, StringRef cat,
151                        StringRef clsExt, StringRef catExt) {
152     generateUSRForObjCCategory(cls, cat, Out, clsExt, catExt);
153   }
154 
155   /// Generate a USR fragment for an Objective-C property.
156   void GenObjCProperty(StringRef prop, bool isClassProp) {
157     generateUSRForObjCProperty(prop, isClassProp, Out);
158   }
159 
160   /// Generate a USR for an Objective-C protocol.
161   void GenObjCProtocol(StringRef prot, StringRef ext) {
162     generateUSRForObjCProtocol(prot, Out, ext);
163   }
164 
165   void VisitType(QualType T);
166   void VisitTemplateParameterList(const TemplateParameterList *Params);
167   void VisitTemplateName(TemplateName Name);
168   void VisitTemplateArgument(const TemplateArgument &Arg);
169 
170   void VisitMSGuidDecl(const MSGuidDecl *D);
171 
172   /// Emit a Decl's name using NamedDecl::printName() and return true if
173   ///  the decl had no name.
174   bool EmitDeclName(const NamedDecl *D);
175 };
176 } // end anonymous namespace
177 
178 //===----------------------------------------------------------------------===//
179 // Generating USRs from ASTS.
180 //===----------------------------------------------------------------------===//
181 
182 bool USRGenerator::EmitDeclName(const NamedDecl *D) {
183   DeclarationName N = D->getDeclName();
184   if (N.isEmpty())
185     return true;
186   Out << N;
187   return false;
188 }
189 
190 bool USRGenerator::ShouldGenerateLocation(const NamedDecl *D) {
191   if (D->isExternallyVisible())
192     return false;
193   if (D->getParentFunctionOrMethod())
194     return true;
195   SourceLocation Loc = D->getLocation();
196   if (Loc.isInvalid())
197     return false;
198   const SourceManager &SM = Context->getSourceManager();
199   return !SM.isInSystemHeader(Loc);
200 }
201 
202 void USRGenerator::VisitDeclContext(const DeclContext *DC) {
203   if (const NamedDecl *D = dyn_cast<NamedDecl>(DC))
204     Visit(D);
205   else if (isa<LinkageSpecDecl>(DC)) // Linkage specs are transparent in USRs.
206     VisitDeclContext(DC->getParent());
207 }
208 
209 void USRGenerator::VisitFieldDecl(const FieldDecl *D) {
210   // The USR for an ivar declared in a class extension is based on the
211   // ObjCInterfaceDecl, not the ObjCCategoryDecl.
212   if (const ObjCInterfaceDecl *ID = Context->getObjContainingInterface(D))
213     Visit(ID);
214   else
215     VisitDeclContext(D->getDeclContext());
216   Out << (isa<ObjCIvarDecl>(D) ? "@" : "@FI@");
217   if (EmitDeclName(D)) {
218     // Bit fields can be anonymous.
219     IgnoreResults = true;
220     return;
221   }
222 }
223 
224 void USRGenerator::VisitFunctionDecl(const FunctionDecl *D) {
225   if (ShouldGenerateLocation(D) && GenLoc(D, /*IncludeOffset=*/isLocal(D)))
226     return;
227 
228   if (D->getType().isNull()) {
229     IgnoreResults = true;
230     return;
231   }
232 
233   const unsigned StartSize = Buf.size();
234   VisitDeclContext(D->getDeclContext());
235   if (Buf.size() == StartSize)
236     GenExtSymbolContainer(D);
237 
238   bool IsTemplate = false;
239   if (FunctionTemplateDecl *FunTmpl = D->getDescribedFunctionTemplate()) {
240     IsTemplate = true;
241     Out << "@FT@";
242     VisitTemplateParameterList(FunTmpl->getTemplateParameters());
243   } else
244     Out << "@F@";
245 
246   PrintingPolicy Policy(LangOpts);
247   // Forward references can have different template argument names. Suppress the
248   // template argument names in constructors to make their USR more stable.
249   Policy.SuppressTemplateArgsInCXXConstructors = true;
250   D->getDeclName().print(Out, Policy);
251 
252   if ((!LangOpts.CPlusPlus || D->isExternC()) &&
253       !D->hasAttr<OverloadableAttr>())
254     return;
255 
256   if (D->isFunctionTemplateSpecialization()) {
257     Out << '<';
258     if (const TemplateArgumentList *SpecArgs =
259             D->getTemplateSpecializationArgs()) {
260       for (const auto &Arg : SpecArgs->asArray()) {
261         Out << '#';
262         VisitTemplateArgument(Arg);
263       }
264     } else if (const ASTTemplateArgumentListInfo *SpecArgsWritten =
265                    D->getTemplateSpecializationArgsAsWritten()) {
266       for (const auto &ArgLoc : SpecArgsWritten->arguments()) {
267         Out << '#';
268         VisitTemplateArgument(ArgLoc.getArgument());
269       }
270     }
271     Out << '>';
272   }
273 
274   QualType CanonicalType = D->getType().getCanonicalType();
275   // Mangle in type information for the arguments.
276   if (const auto *FPT = CanonicalType->getAs<FunctionProtoType>()) {
277     for (QualType PT : FPT->param_types()) {
278       Out << '#';
279       VisitType(PT);
280     }
281   }
282   if (D->isVariadic())
283     Out << '.';
284   if (IsTemplate) {
285     // Function templates can be overloaded by return type, for example:
286     // \code
287     //   template <class T> typename T::A foo() {}
288     //   template <class T> typename T::B foo() {}
289     // \endcode
290     Out << '#';
291     VisitType(D->getReturnType());
292   }
293   Out << '#';
294   if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(D)) {
295     if (MD->isStatic())
296       Out << 'S';
297     // FIXME: OpenCL: Need to consider address spaces
298     if (unsigned quals = MD->getMethodQualifiers().getCVRUQualifiers())
299       Out << (char)('0' + quals);
300     switch (MD->getRefQualifier()) {
301     case RQ_None: break;
302     case RQ_LValue: Out << '&'; break;
303     case RQ_RValue: Out << "&&"; break;
304     }
305   }
306 }
307 
308 void USRGenerator::VisitNamedDecl(const NamedDecl *D) {
309   VisitDeclContext(D->getDeclContext());
310   Out << "@";
311 
312   if (EmitDeclName(D)) {
313     // The string can be empty if the declaration has no name; e.g., it is
314     // the ParmDecl with no name for declaration of a function pointer type,
315     // e.g.: void  (*f)(void *);
316     // In this case, don't generate a USR.
317     IgnoreResults = true;
318   }
319 }
320 
321 void USRGenerator::VisitVarDecl(const VarDecl *D) {
322   // VarDecls can be declared 'extern' within a function or method body,
323   // but their enclosing DeclContext is the function, not the TU.  We need
324   // to check the storage class to correctly generate the USR.
325   if (ShouldGenerateLocation(D) && GenLoc(D, /*IncludeOffset=*/isLocal(D)))
326     return;
327 
328   VisitDeclContext(D->getDeclContext());
329 
330   if (VarTemplateDecl *VarTmpl = D->getDescribedVarTemplate()) {
331     Out << "@VT";
332     VisitTemplateParameterList(VarTmpl->getTemplateParameters());
333   } else if (const VarTemplatePartialSpecializationDecl *PartialSpec
334              = dyn_cast<VarTemplatePartialSpecializationDecl>(D)) {
335     Out << "@VP";
336     VisitTemplateParameterList(PartialSpec->getTemplateParameters());
337   }
338 
339   // Variables always have simple names.
340   StringRef s = D->getName();
341 
342   // The string can be empty if the declaration has no name; e.g., it is
343   // the ParmDecl with no name for declaration of a function pointer type, e.g.:
344   //    void  (*f)(void *);
345   // In this case, don't generate a USR.
346   if (s.empty())
347     IgnoreResults = true;
348   else
349     Out << '@' << s;
350 
351   // For a template specialization, mangle the template arguments.
352   if (const VarTemplateSpecializationDecl *Spec
353                               = dyn_cast<VarTemplateSpecializationDecl>(D)) {
354     const TemplateArgumentList &Args = Spec->getTemplateArgs();
355     Out << '>';
356     for (unsigned I = 0, N = Args.size(); I != N; ++I) {
357       Out << '#';
358       VisitTemplateArgument(Args.get(I));
359     }
360   }
361 }
362 
363 void USRGenerator::VisitBindingDecl(const BindingDecl *D) {
364   if (isLocal(D) && GenLoc(D, /*IncludeOffset=*/true))
365     return;
366   VisitNamedDecl(D);
367 }
368 
369 void USRGenerator::VisitNonTypeTemplateParmDecl(
370                                         const NonTypeTemplateParmDecl *D) {
371   GenLoc(D, /*IncludeOffset=*/true);
372 }
373 
374 void USRGenerator::VisitTemplateTemplateParmDecl(
375                                         const TemplateTemplateParmDecl *D) {
376   GenLoc(D, /*IncludeOffset=*/true);
377 }
378 
379 void USRGenerator::VisitNamespaceDecl(const NamespaceDecl *D) {
380   if (IgnoreResults)
381     return;
382   VisitDeclContext(D->getDeclContext());
383   if (D->isAnonymousNamespace()) {
384     Out << "@aN";
385     return;
386   }
387   Out << "@N@" << D->getName();
388 }
389 
390 void USRGenerator::VisitFunctionTemplateDecl(const FunctionTemplateDecl *D) {
391   VisitFunctionDecl(D->getTemplatedDecl());
392 }
393 
394 void USRGenerator::VisitClassTemplateDecl(const ClassTemplateDecl *D) {
395   VisitTagDecl(D->getTemplatedDecl());
396 }
397 
398 void USRGenerator::VisitNamespaceAliasDecl(const NamespaceAliasDecl *D) {
399   VisitDeclContext(D->getDeclContext());
400   if (!IgnoreResults)
401     Out << "@NA@" << D->getName();
402 }
403 
404 static const ObjCCategoryDecl *getCategoryContext(const NamedDecl *D) {
405   if (auto *CD = dyn_cast<ObjCCategoryDecl>(D->getDeclContext()))
406     return CD;
407   if (auto *ICD = dyn_cast<ObjCCategoryImplDecl>(D->getDeclContext()))
408     return ICD->getCategoryDecl();
409   return nullptr;
410 }
411 
412 void USRGenerator::VisitObjCMethodDecl(const ObjCMethodDecl *D) {
413   const DeclContext *container = D->getDeclContext();
414   if (const ObjCProtocolDecl *pd = dyn_cast<ObjCProtocolDecl>(container)) {
415     Visit(pd);
416   }
417   else {
418     // The USR for a method declared in a class extension or category is based on
419     // the ObjCInterfaceDecl, not the ObjCCategoryDecl.
420     const ObjCInterfaceDecl *ID = D->getClassInterface();
421     if (!ID) {
422       IgnoreResults = true;
423       return;
424     }
425     auto *CD = getCategoryContext(D);
426     VisitObjCContainerDecl(ID, CD);
427   }
428   // Ideally we would use 'GenObjCMethod', but this is such a hot path
429   // for Objective-C code that we don't want to use
430   // DeclarationName::getAsString().
431   Out << (D->isInstanceMethod() ? "(im)" : "(cm)")
432       << DeclarationName(D->getSelector());
433 }
434 
435 void USRGenerator::VisitObjCContainerDecl(const ObjCContainerDecl *D,
436                                           const ObjCCategoryDecl *CatD) {
437   switch (D->getKind()) {
438     default:
439       llvm_unreachable("Invalid ObjC container.");
440     case Decl::ObjCInterface:
441     case Decl::ObjCImplementation:
442       GenObjCClass(D->getName(), GetExternalSourceContainer(D),
443                    GetExternalSourceContainer(CatD));
444       break;
445     case Decl::ObjCCategory: {
446       const ObjCCategoryDecl *CD = cast<ObjCCategoryDecl>(D);
447       const ObjCInterfaceDecl *ID = CD->getClassInterface();
448       if (!ID) {
449         // Handle invalid code where the @interface might not
450         // have been specified.
451         // FIXME: We should be able to generate this USR even if the
452         // @interface isn't available.
453         IgnoreResults = true;
454         return;
455       }
456       // Specially handle class extensions, which are anonymous categories.
457       // We want to mangle in the location to uniquely distinguish them.
458       if (CD->IsClassExtension()) {
459         Out << "objc(ext)" << ID->getName() << '@';
460         GenLoc(CD, /*IncludeOffset=*/true);
461       }
462       else
463         GenObjCCategory(ID->getName(), CD->getName(),
464                         GetExternalSourceContainer(ID),
465                         GetExternalSourceContainer(CD));
466 
467       break;
468     }
469     case Decl::ObjCCategoryImpl: {
470       const ObjCCategoryImplDecl *CD = cast<ObjCCategoryImplDecl>(D);
471       const ObjCInterfaceDecl *ID = CD->getClassInterface();
472       if (!ID) {
473         // Handle invalid code where the @interface might not
474         // have been specified.
475         // FIXME: We should be able to generate this USR even if the
476         // @interface isn't available.
477         IgnoreResults = true;
478         return;
479       }
480       GenObjCCategory(ID->getName(), CD->getName(),
481                       GetExternalSourceContainer(ID),
482                       GetExternalSourceContainer(CD));
483       break;
484     }
485     case Decl::ObjCProtocol: {
486       const ObjCProtocolDecl *PD = cast<ObjCProtocolDecl>(D);
487       GenObjCProtocol(PD->getName(), GetExternalSourceContainer(PD));
488       break;
489     }
490   }
491 }
492 
493 void USRGenerator::VisitObjCPropertyDecl(const ObjCPropertyDecl *D) {
494   // The USR for a property declared in a class extension or category is based
495   // on the ObjCInterfaceDecl, not the ObjCCategoryDecl.
496   if (const ObjCInterfaceDecl *ID = Context->getObjContainingInterface(D))
497     VisitObjCContainerDecl(ID, getCategoryContext(D));
498   else
499     Visit(cast<Decl>(D->getDeclContext()));
500   GenObjCProperty(D->getName(), D->isClassProperty());
501 }
502 
503 void USRGenerator::VisitObjCPropertyImplDecl(const ObjCPropertyImplDecl *D) {
504   if (ObjCPropertyDecl *PD = D->getPropertyDecl()) {
505     VisitObjCPropertyDecl(PD);
506     return;
507   }
508 
509   IgnoreResults = true;
510 }
511 
512 void USRGenerator::VisitTagDecl(const TagDecl *D) {
513   // Add the location of the tag decl to handle resolution across
514   // translation units.
515   if (!isa<EnumDecl>(D) &&
516       ShouldGenerateLocation(D) && GenLoc(D, /*IncludeOffset=*/isLocal(D)))
517     return;
518 
519   GenExtSymbolContainer(D);
520 
521   D = D->getCanonicalDecl();
522   VisitDeclContext(D->getDeclContext());
523 
524   bool AlreadyStarted = false;
525   if (const CXXRecordDecl *CXXRecord = dyn_cast<CXXRecordDecl>(D)) {
526     if (ClassTemplateDecl *ClassTmpl = CXXRecord->getDescribedClassTemplate()) {
527       AlreadyStarted = true;
528 
529       switch (D->getTagKind()) {
530       case TagTypeKind::Interface:
531       case TagTypeKind::Class:
532       case TagTypeKind::Struct:
533         Out << "@ST";
534         break;
535       case TagTypeKind::Union:
536         Out << "@UT";
537         break;
538       case TagTypeKind::Enum:
539         llvm_unreachable("enum template");
540       }
541       VisitTemplateParameterList(ClassTmpl->getTemplateParameters());
542     } else if (const ClassTemplatePartialSpecializationDecl *PartialSpec
543                 = dyn_cast<ClassTemplatePartialSpecializationDecl>(CXXRecord)) {
544       AlreadyStarted = true;
545 
546       switch (D->getTagKind()) {
547       case TagTypeKind::Interface:
548       case TagTypeKind::Class:
549       case TagTypeKind::Struct:
550         Out << "@SP";
551         break;
552       case TagTypeKind::Union:
553         Out << "@UP";
554         break;
555       case TagTypeKind::Enum:
556         llvm_unreachable("enum partial specialization");
557       }
558       VisitTemplateParameterList(PartialSpec->getTemplateParameters());
559     }
560   }
561 
562   if (!AlreadyStarted) {
563     switch (D->getTagKind()) {
564     case TagTypeKind::Interface:
565     case TagTypeKind::Class:
566     case TagTypeKind::Struct:
567       Out << "@S";
568       break;
569     case TagTypeKind::Union:
570       Out << "@U";
571       break;
572     case TagTypeKind::Enum:
573       Out << "@E";
574       break;
575     }
576   }
577 
578   Out << '@';
579   assert(Buf.size() > 0);
580   const unsigned off = Buf.size() - 1;
581 
582   if (EmitDeclName(D)) {
583     if (const TypedefNameDecl *TD = D->getTypedefNameForAnonDecl()) {
584       Buf[off] = 'A';
585       Out << '@' << *TD;
586     } else {
587       if (D->isEmbeddedInDeclarator() && !D->isFreeStanding()) {
588         printLoc(Out, D->getLocation(), Context->getSourceManager(), true);
589       } else {
590         Buf[off] = 'a';
591         if (auto *ED = dyn_cast<EnumDecl>(D)) {
592           // Distinguish USRs of anonymous enums by using their first
593           // enumerator.
594           auto enum_range = ED->enumerators();
595           if (enum_range.begin() != enum_range.end()) {
596             Out << '@' << **enum_range.begin();
597           }
598         }
599       }
600     }
601   }
602 
603   // For a class template specialization, mangle the template arguments.
604   if (const ClassTemplateSpecializationDecl *Spec
605                               = dyn_cast<ClassTemplateSpecializationDecl>(D)) {
606     const TemplateArgumentList &Args = Spec->getTemplateArgs();
607     Out << '>';
608     for (unsigned I = 0, N = Args.size(); I != N; ++I) {
609       Out << '#';
610       VisitTemplateArgument(Args.get(I));
611     }
612   }
613 }
614 
615 void USRGenerator::VisitTypedefDecl(const TypedefDecl *D) {
616   if (ShouldGenerateLocation(D) && GenLoc(D, /*IncludeOffset=*/isLocal(D)))
617     return;
618   const DeclContext *DC = D->getDeclContext();
619   if (const NamedDecl *DCN = dyn_cast<NamedDecl>(DC))
620     Visit(DCN);
621   Out << "@T@";
622   Out << D->getName();
623 }
624 
625 void USRGenerator::VisitTemplateTypeParmDecl(const TemplateTypeParmDecl *D) {
626   GenLoc(D, /*IncludeOffset=*/true);
627 }
628 
629 void USRGenerator::GenExtSymbolContainer(const NamedDecl *D) {
630   StringRef Container = GetExternalSourceContainer(D);
631   if (!Container.empty())
632     Out << "@M@" << Container;
633 }
634 
635 bool USRGenerator::GenLoc(const Decl *D, bool IncludeOffset) {
636   if (generatedLoc)
637     return IgnoreResults;
638   generatedLoc = true;
639 
640   // Guard against null declarations in invalid code.
641   if (!D) {
642     IgnoreResults = true;
643     return true;
644   }
645 
646   // Use the location of canonical decl.
647   D = D->getCanonicalDecl();
648 
649   IgnoreResults =
650       IgnoreResults || printLoc(Out, D->getBeginLoc(),
651                                 Context->getSourceManager(), IncludeOffset);
652 
653   return IgnoreResults;
654 }
655 
656 static void printQualifier(llvm::raw_ostream &Out, const LangOptions &LangOpts,
657                            NestedNameSpecifier *NNS) {
658   // FIXME: Encode the qualifier, don't just print it.
659   PrintingPolicy PO(LangOpts);
660   PO.SuppressTagKeyword = true;
661   PO.SuppressUnwrittenScope = true;
662   PO.ConstantArraySizeAsWritten = false;
663   PO.AnonymousTagLocations = false;
664   NNS->print(Out, PO);
665 }
666 
667 void USRGenerator::VisitType(QualType T) {
668   // This method mangles in USR information for types.  It can possibly
669   // just reuse the naming-mangling logic used by codegen, although the
670   // requirements for USRs might not be the same.
671   ASTContext &Ctx = *Context;
672 
673   do {
674     T = Ctx.getCanonicalType(T);
675     Qualifiers Q = T.getQualifiers();
676     unsigned qVal = 0;
677     if (Q.hasConst())
678       qVal |= 0x1;
679     if (Q.hasVolatile())
680       qVal |= 0x2;
681     if (Q.hasRestrict())
682       qVal |= 0x4;
683     if(qVal)
684       Out << ((char) ('0' + qVal));
685 
686     // Mangle in ObjC GC qualifiers?
687 
688     if (const PackExpansionType *Expansion = T->getAs<PackExpansionType>()) {
689       Out << 'P';
690       T = Expansion->getPattern();
691     }
692 
693     if (const BuiltinType *BT = T->getAs<BuiltinType>()) {
694       switch (BT->getKind()) {
695         case BuiltinType::Void:
696           Out << 'v'; break;
697         case BuiltinType::Bool:
698           Out << 'b'; break;
699         case BuiltinType::UChar:
700           Out << 'c'; break;
701         case BuiltinType::Char8:
702           Out << 'u'; break;
703         case BuiltinType::Char16:
704           Out << 'q'; break;
705         case BuiltinType::Char32:
706           Out << 'w'; break;
707         case BuiltinType::UShort:
708           Out << 's'; break;
709         case BuiltinType::UInt:
710           Out << 'i'; break;
711         case BuiltinType::ULong:
712           Out << 'l'; break;
713         case BuiltinType::ULongLong:
714           Out << 'k'; break;
715         case BuiltinType::UInt128:
716           Out << 'j'; break;
717         case BuiltinType::Char_U:
718         case BuiltinType::Char_S:
719           Out << 'C'; break;
720         case BuiltinType::SChar:
721           Out << 'r'; break;
722         case BuiltinType::WChar_S:
723         case BuiltinType::WChar_U:
724           Out << 'W'; break;
725         case BuiltinType::Short:
726           Out << 'S'; break;
727         case BuiltinType::Int:
728           Out << 'I'; break;
729         case BuiltinType::Long:
730           Out << 'L'; break;
731         case BuiltinType::LongLong:
732           Out << 'K'; break;
733         case BuiltinType::Int128:
734           Out << 'J'; break;
735         case BuiltinType::Float16:
736         case BuiltinType::Half:
737           Out << 'h'; break;
738         case BuiltinType::Float:
739           Out << 'f'; break;
740         case BuiltinType::Double:
741           Out << 'd'; break;
742         case BuiltinType::LongDouble:
743           Out << 'D'; break;
744         case BuiltinType::Float128:
745           Out << 'Q'; break;
746         case BuiltinType::NullPtr:
747           Out << 'n'; break;
748 #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
749         case BuiltinType::Id: \
750           Out << "@BT@" << #Suffix << "_" << #ImgType; break;
751 #include "clang/Basic/OpenCLImageTypes.def"
752 #define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
753         case BuiltinType::Id: \
754           Out << "@BT@" << #ExtType; break;
755 #include "clang/Basic/OpenCLExtensionTypes.def"
756         case BuiltinType::OCLEvent:
757           Out << "@BT@OCLEvent"; break;
758         case BuiltinType::OCLClkEvent:
759           Out << "@BT@OCLClkEvent"; break;
760         case BuiltinType::OCLQueue:
761           Out << "@BT@OCLQueue"; break;
762         case BuiltinType::OCLReserveID:
763           Out << "@BT@OCLReserveID"; break;
764         case BuiltinType::OCLSampler:
765           Out << "@BT@OCLSampler"; break;
766 #define SVE_TYPE(Name, Id, SingletonId) \
767         case BuiltinType::Id: \
768           Out << "@BT@" << Name; break;
769 #include "clang/Basic/AArch64SVEACLETypes.def"
770 #define PPC_VECTOR_TYPE(Name, Id, Size) \
771         case BuiltinType::Id: \
772           Out << "@BT@" << #Name; break;
773 #include "clang/Basic/PPCTypes.def"
774 #define RVV_TYPE(Name, Id, SingletonId) \
775         case BuiltinType::Id: \
776           Out << "@BT@" << Name; break;
777 #include "clang/Basic/RISCVVTypes.def"
778 #define WASM_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
779 #include "clang/Basic/WebAssemblyReferenceTypes.def"
780 #define AMDGPU_TYPE(Name, Id, SingletonId, Width, Align)                       \
781   case BuiltinType::Id:                                                        \
782     Out << "@BT@" << #Name;                                                    \
783     break;
784 #include "clang/Basic/AMDGPUTypes.def"
785 #define HLSL_INTANGIBLE_TYPE(Name, Id, SingletonId)                            \
786   case BuiltinType::Id:                                                        \
787     Out << "@BT@" << #Name;                                                    \
788     break;
789 #include "clang/Basic/HLSLIntangibleTypes.def"
790         case BuiltinType::ShortAccum:
791           Out << "@BT@ShortAccum"; break;
792         case BuiltinType::Accum:
793           Out << "@BT@Accum"; break;
794         case BuiltinType::LongAccum:
795           Out << "@BT@LongAccum"; break;
796         case BuiltinType::UShortAccum:
797           Out << "@BT@UShortAccum"; break;
798         case BuiltinType::UAccum:
799           Out << "@BT@UAccum"; break;
800         case BuiltinType::ULongAccum:
801           Out << "@BT@ULongAccum"; break;
802         case BuiltinType::ShortFract:
803           Out << "@BT@ShortFract"; break;
804         case BuiltinType::Fract:
805           Out << "@BT@Fract"; break;
806         case BuiltinType::LongFract:
807           Out << "@BT@LongFract"; break;
808         case BuiltinType::UShortFract:
809           Out << "@BT@UShortFract"; break;
810         case BuiltinType::UFract:
811           Out << "@BT@UFract"; break;
812         case BuiltinType::ULongFract:
813           Out << "@BT@ULongFract"; break;
814         case BuiltinType::SatShortAccum:
815           Out << "@BT@SatShortAccum"; break;
816         case BuiltinType::SatAccum:
817           Out << "@BT@SatAccum"; break;
818         case BuiltinType::SatLongAccum:
819           Out << "@BT@SatLongAccum"; break;
820         case BuiltinType::SatUShortAccum:
821           Out << "@BT@SatUShortAccum"; break;
822         case BuiltinType::SatUAccum:
823           Out << "@BT@SatUAccum"; break;
824         case BuiltinType::SatULongAccum:
825           Out << "@BT@SatULongAccum"; break;
826         case BuiltinType::SatShortFract:
827           Out << "@BT@SatShortFract"; break;
828         case BuiltinType::SatFract:
829           Out << "@BT@SatFract"; break;
830         case BuiltinType::SatLongFract:
831           Out << "@BT@SatLongFract"; break;
832         case BuiltinType::SatUShortFract:
833           Out << "@BT@SatUShortFract"; break;
834         case BuiltinType::SatUFract:
835           Out << "@BT@SatUFract"; break;
836         case BuiltinType::SatULongFract:
837           Out << "@BT@SatULongFract"; break;
838         case BuiltinType::BFloat16:
839           Out << "@BT@__bf16"; break;
840         case BuiltinType::Ibm128:
841           Out << "@BT@__ibm128"; break;
842         case BuiltinType::ObjCId:
843           Out << 'o'; break;
844         case BuiltinType::ObjCClass:
845           Out << 'O'; break;
846         case BuiltinType::ObjCSel:
847           Out << 'e'; break;
848 #define BUILTIN_TYPE(Id, SingletonId)
849 #define PLACEHOLDER_TYPE(Id, SingletonId) case BuiltinType::Id:
850 #include "clang/AST/BuiltinTypes.def"
851         case BuiltinType::Dependent:
852           // If you're adding a new builtin type, please add its name prefixed
853           // with "@BT@" to `Out` (see cases above).
854           IgnoreResults = true;
855           break;
856       }
857       return;
858     }
859 
860     // If we have already seen this (non-built-in) type, use a substitution
861     // encoding.
862     llvm::DenseMap<const Type *, unsigned>::iterator Substitution
863       = TypeSubstitutions.find(T.getTypePtr());
864     if (Substitution != TypeSubstitutions.end()) {
865       Out << 'S' << Substitution->second << '_';
866       return;
867     } else {
868       // Record this as a substitution.
869       unsigned Number = TypeSubstitutions.size();
870       TypeSubstitutions[T.getTypePtr()] = Number;
871     }
872 
873     if (const PointerType *PT = T->getAs<PointerType>()) {
874       Out << '*';
875       T = PT->getPointeeType();
876       continue;
877     }
878     if (const ObjCObjectPointerType *OPT = T->getAs<ObjCObjectPointerType>()) {
879       Out << '*';
880       T = OPT->getPointeeType();
881       continue;
882     }
883     if (const RValueReferenceType *RT = T->getAs<RValueReferenceType>()) {
884       Out << "&&";
885       T = RT->getPointeeType();
886       continue;
887     }
888     if (const ReferenceType *RT = T->getAs<ReferenceType>()) {
889       Out << '&';
890       T = RT->getPointeeType();
891       continue;
892     }
893     if (const FunctionProtoType *FT = T->getAs<FunctionProtoType>()) {
894       Out << 'F';
895       VisitType(FT->getReturnType());
896       Out << '(';
897       for (const auto &I : FT->param_types()) {
898         Out << '#';
899         VisitType(I);
900       }
901       Out << ')';
902       if (FT->isVariadic())
903         Out << '.';
904       return;
905     }
906     if (const BlockPointerType *BT = T->getAs<BlockPointerType>()) {
907       Out << 'B';
908       T = BT->getPointeeType();
909       continue;
910     }
911     if (const ComplexType *CT = T->getAs<ComplexType>()) {
912       Out << '<';
913       T = CT->getElementType();
914       continue;
915     }
916     if (const TagType *TT = T->getAs<TagType>()) {
917       Out << '$';
918       VisitTagDecl(TT->getDecl());
919       return;
920     }
921     if (const ObjCInterfaceType *OIT = T->getAs<ObjCInterfaceType>()) {
922       Out << '$';
923       VisitObjCInterfaceDecl(OIT->getDecl());
924       return;
925     }
926     if (const ObjCObjectType *OIT = T->getAs<ObjCObjectType>()) {
927       Out << 'Q';
928       VisitType(OIT->getBaseType());
929       for (auto *Prot : OIT->getProtocols())
930         VisitObjCProtocolDecl(Prot);
931       return;
932     }
933     if (const TemplateTypeParmType *TTP = T->getAs<TemplateTypeParmType>()) {
934       Out << 't' << TTP->getDepth() << '.' << TTP->getIndex();
935       return;
936     }
937     if (const TemplateSpecializationType *Spec
938                                     = T->getAs<TemplateSpecializationType>()) {
939       Out << '>';
940       VisitTemplateName(Spec->getTemplateName());
941       Out << Spec->template_arguments().size();
942       for (const auto &Arg : Spec->template_arguments())
943         VisitTemplateArgument(Arg);
944       return;
945     }
946     if (const DependentNameType *DNT = T->getAs<DependentNameType>()) {
947       Out << '^';
948       printQualifier(Out, LangOpts, DNT->getQualifier());
949       Out << ':' << DNT->getIdentifier()->getName();
950       return;
951     }
952     if (const InjectedClassNameType *InjT = T->getAs<InjectedClassNameType>()) {
953       T = InjT->getInjectedSpecializationType();
954       continue;
955     }
956     if (const auto *VT = T->getAs<VectorType>()) {
957       Out << (T->isExtVectorType() ? ']' : '[');
958       Out << VT->getNumElements();
959       T = VT->getElementType();
960       continue;
961     }
962     if (const auto *const AT = dyn_cast<ArrayType>(T)) {
963       Out << '{';
964       switch (AT->getSizeModifier()) {
965       case ArraySizeModifier::Static:
966         Out << 's';
967         break;
968       case ArraySizeModifier::Star:
969         Out << '*';
970         break;
971       case ArraySizeModifier::Normal:
972         Out << 'n';
973         break;
974       }
975       if (const auto *const CAT = dyn_cast<ConstantArrayType>(T))
976         Out << CAT->getSize();
977 
978       T = AT->getElementType();
979       continue;
980     }
981 
982     // Unhandled type.
983     Out << ' ';
984     break;
985   } while (true);
986 }
987 
988 void USRGenerator::VisitTemplateParameterList(
989                                          const TemplateParameterList *Params) {
990   if (!Params)
991     return;
992   Out << '>' << Params->size();
993   for (TemplateParameterList::const_iterator P = Params->begin(),
994                                           PEnd = Params->end();
995        P != PEnd; ++P) {
996     Out << '#';
997     if (isa<TemplateTypeParmDecl>(*P)) {
998       if (cast<TemplateTypeParmDecl>(*P)->isParameterPack())
999         Out<< 'p';
1000       Out << 'T';
1001       continue;
1002     }
1003 
1004     if (NonTypeTemplateParmDecl *NTTP = dyn_cast<NonTypeTemplateParmDecl>(*P)) {
1005       if (NTTP->isParameterPack())
1006         Out << 'p';
1007       Out << 'N';
1008       VisitType(NTTP->getType());
1009       continue;
1010     }
1011 
1012     TemplateTemplateParmDecl *TTP = cast<TemplateTemplateParmDecl>(*P);
1013     if (TTP->isParameterPack())
1014       Out << 'p';
1015     Out << 't';
1016     VisitTemplateParameterList(TTP->getTemplateParameters());
1017   }
1018 }
1019 
1020 void USRGenerator::VisitTemplateName(TemplateName Name) {
1021   if (TemplateDecl *Template = Name.getAsTemplateDecl()) {
1022     if (TemplateTemplateParmDecl *TTP
1023                               = dyn_cast<TemplateTemplateParmDecl>(Template)) {
1024       Out << 't' << TTP->getDepth() << '.' << TTP->getIndex();
1025       return;
1026     }
1027 
1028     Visit(Template);
1029     return;
1030   }
1031 
1032   // FIXME: Visit dependent template names.
1033 }
1034 
1035 void USRGenerator::VisitTemplateArgument(const TemplateArgument &Arg) {
1036   switch (Arg.getKind()) {
1037   case TemplateArgument::Null:
1038     break;
1039 
1040   case TemplateArgument::Declaration:
1041     Visit(Arg.getAsDecl());
1042     break;
1043 
1044   case TemplateArgument::NullPtr:
1045     break;
1046 
1047   case TemplateArgument::TemplateExpansion:
1048     Out << 'P'; // pack expansion of...
1049     [[fallthrough]];
1050   case TemplateArgument::Template:
1051     VisitTemplateName(Arg.getAsTemplateOrTemplatePattern());
1052     break;
1053 
1054   case TemplateArgument::Expression:
1055     // FIXME: Visit expressions.
1056     break;
1057 
1058   case TemplateArgument::Pack:
1059     Out << 'p' << Arg.pack_size();
1060     for (const auto &P : Arg.pack_elements())
1061       VisitTemplateArgument(P);
1062     break;
1063 
1064   case TemplateArgument::Type:
1065     VisitType(Arg.getAsType());
1066     break;
1067 
1068   case TemplateArgument::Integral:
1069     Out << 'V';
1070     VisitType(Arg.getIntegralType());
1071     Out << Arg.getAsIntegral();
1072     break;
1073 
1074   case TemplateArgument::StructuralValue: {
1075     Out << 'S';
1076     VisitType(Arg.getStructuralValueType());
1077     ODRHash Hash{};
1078     Hash.AddStructuralValue(Arg.getAsStructuralValue());
1079     Out << Hash.CalculateHash();
1080     break;
1081   }
1082   }
1083 }
1084 
1085 void USRGenerator::VisitUnresolvedUsingValueDecl(const UnresolvedUsingValueDecl *D) {
1086   if (ShouldGenerateLocation(D) && GenLoc(D, /*IncludeOffset=*/isLocal(D)))
1087     return;
1088   VisitDeclContext(D->getDeclContext());
1089   Out << "@UUV@";
1090   printQualifier(Out, LangOpts, D->getQualifier());
1091   EmitDeclName(D);
1092 }
1093 
1094 void USRGenerator::VisitUnresolvedUsingTypenameDecl(const UnresolvedUsingTypenameDecl *D) {
1095   if (ShouldGenerateLocation(D) && GenLoc(D, /*IncludeOffset=*/isLocal(D)))
1096     return;
1097   VisitDeclContext(D->getDeclContext());
1098   Out << "@UUT@";
1099   printQualifier(Out, LangOpts, D->getQualifier());
1100   Out << D->getName(); // Simple name.
1101 }
1102 
1103 void USRGenerator::VisitConceptDecl(const ConceptDecl *D) {
1104   if (ShouldGenerateLocation(D) && GenLoc(D, /*IncludeOffset=*/isLocal(D)))
1105     return;
1106   VisitDeclContext(D->getDeclContext());
1107   Out << "@CT@";
1108   EmitDeclName(D);
1109 }
1110 
1111 void USRGenerator::VisitMSGuidDecl(const MSGuidDecl *D) {
1112   VisitDeclContext(D->getDeclContext());
1113   Out << "@MG@";
1114   D->NamedDecl::printName(Out);
1115 }
1116 
1117 //===----------------------------------------------------------------------===//
1118 // USR generation functions.
1119 //===----------------------------------------------------------------------===//
1120 
1121 static void combineClassAndCategoryExtContainers(StringRef ClsSymDefinedIn,
1122                                                  StringRef CatSymDefinedIn,
1123                                                  raw_ostream &OS) {
1124   if (ClsSymDefinedIn.empty() && CatSymDefinedIn.empty())
1125     return;
1126   if (CatSymDefinedIn.empty()) {
1127     OS << "@M@" << ClsSymDefinedIn << '@';
1128     return;
1129   }
1130   OS << "@CM@" << CatSymDefinedIn << '@';
1131   if (ClsSymDefinedIn != CatSymDefinedIn) {
1132     OS << ClsSymDefinedIn << '@';
1133   }
1134 }
1135 
1136 void clang::index::generateUSRForObjCClass(StringRef Cls, raw_ostream &OS,
1137                                            StringRef ExtSymDefinedIn,
1138                                   StringRef CategoryContextExtSymbolDefinedIn) {
1139   combineClassAndCategoryExtContainers(ExtSymDefinedIn,
1140                                        CategoryContextExtSymbolDefinedIn, OS);
1141   OS << "objc(cs)" << Cls;
1142 }
1143 
1144 void clang::index::generateUSRForObjCCategory(StringRef Cls, StringRef Cat,
1145                                               raw_ostream &OS,
1146                                               StringRef ClsSymDefinedIn,
1147                                               StringRef CatSymDefinedIn) {
1148   combineClassAndCategoryExtContainers(ClsSymDefinedIn, CatSymDefinedIn, OS);
1149   OS << "objc(cy)" << Cls << '@' << Cat;
1150 }
1151 
1152 void clang::index::generateUSRForObjCIvar(StringRef Ivar, raw_ostream &OS) {
1153   OS << '@' << Ivar;
1154 }
1155 
1156 void clang::index::generateUSRForObjCMethod(StringRef Sel,
1157                                             bool IsInstanceMethod,
1158                                             raw_ostream &OS) {
1159   OS << (IsInstanceMethod ? "(im)" : "(cm)") << Sel;
1160 }
1161 
1162 void clang::index::generateUSRForObjCProperty(StringRef Prop, bool isClassProp,
1163                                               raw_ostream &OS) {
1164   OS << (isClassProp ? "(cpy)" : "(py)") << Prop;
1165 }
1166 
1167 void clang::index::generateUSRForObjCProtocol(StringRef Prot, raw_ostream &OS,
1168                                               StringRef ExtSymDefinedIn) {
1169   if (!ExtSymDefinedIn.empty())
1170     OS << "@M@" << ExtSymDefinedIn << '@';
1171   OS << "objc(pl)" << Prot;
1172 }
1173 
1174 void clang::index::generateUSRForGlobalEnum(StringRef EnumName, raw_ostream &OS,
1175                                             StringRef ExtSymDefinedIn) {
1176   if (!ExtSymDefinedIn.empty())
1177     OS << "@M@" << ExtSymDefinedIn;
1178   OS << "@E@" << EnumName;
1179 }
1180 
1181 void clang::index::generateUSRForEnumConstant(StringRef EnumConstantName,
1182                                               raw_ostream &OS) {
1183   OS << '@' << EnumConstantName;
1184 }
1185 
1186 bool clang::index::generateUSRForDecl(const Decl *D,
1187                                       SmallVectorImpl<char> &Buf) {
1188   if (!D)
1189     return true;
1190   return generateUSRForDecl(D, Buf, D->getASTContext().getLangOpts());
1191 }
1192 
1193 bool clang::index::generateUSRForDecl(const Decl *D, SmallVectorImpl<char> &Buf,
1194                                       const LangOptions &LangOpts) {
1195   if (!D)
1196     return true;
1197   // We don't ignore decls with invalid source locations. Implicit decls, like
1198   // C++'s operator new function, can have invalid locations but it is fine to
1199   // create USRs that can identify them.
1200 
1201   // Check if the declaration has explicit external USR specified.
1202   auto *CD = D->getCanonicalDecl();
1203   if (auto *ExternalSymAttr = CD->getAttr<ExternalSourceSymbolAttr>()) {
1204     if (!ExternalSymAttr->getUSR().empty()) {
1205       llvm::raw_svector_ostream Out(Buf);
1206       Out << ExternalSymAttr->getUSR();
1207       return false;
1208     }
1209   }
1210   USRGenerator UG(&D->getASTContext(), Buf, LangOpts);
1211   UG.Visit(D);
1212   return UG.ignoreResults();
1213 }
1214 
1215 bool clang::index::generateUSRForMacro(const MacroDefinitionRecord *MD,
1216                                        const SourceManager &SM,
1217                                        SmallVectorImpl<char> &Buf) {
1218   if (!MD)
1219     return true;
1220   return generateUSRForMacro(MD->getName()->getName(), MD->getLocation(),
1221                              SM, Buf);
1222 
1223 }
1224 
1225 bool clang::index::generateUSRForMacro(StringRef MacroName, SourceLocation Loc,
1226                                        const SourceManager &SM,
1227                                        SmallVectorImpl<char> &Buf) {
1228   if (MacroName.empty())
1229     return true;
1230 
1231   llvm::raw_svector_ostream Out(Buf);
1232 
1233   // Assume that system headers are sane.  Don't put source location
1234   // information into the USR if the macro comes from a system header.
1235   bool ShouldGenerateLocation = Loc.isValid() && !SM.isInSystemHeader(Loc);
1236 
1237   Out << getUSRSpacePrefix();
1238   if (ShouldGenerateLocation)
1239     printLoc(Out, Loc, SM, /*IncludeOffset=*/true);
1240   Out << "@macro@";
1241   Out << MacroName;
1242   return false;
1243 }
1244 
1245 bool clang::index::generateUSRForType(QualType T, ASTContext &Ctx,
1246                                       SmallVectorImpl<char> &Buf) {
1247   return generateUSRForType(T, Ctx, Buf, Ctx.getLangOpts());
1248 }
1249 
1250 bool clang::index::generateUSRForType(QualType T, ASTContext &Ctx,
1251                                       SmallVectorImpl<char> &Buf,
1252                                       const LangOptions &LangOpts) {
1253   if (T.isNull())
1254     return true;
1255   T = T.getCanonicalType();
1256 
1257   USRGenerator UG(&Ctx, Buf, LangOpts);
1258   UG.VisitType(T);
1259   return UG.ignoreResults();
1260 }
1261 
1262 bool clang::index::generateFullUSRForModule(const Module *Mod,
1263                                             raw_ostream &OS) {
1264   if (!Mod->Parent)
1265     return generateFullUSRForTopLevelModuleName(Mod->Name, OS);
1266   if (generateFullUSRForModule(Mod->Parent, OS))
1267     return true;
1268   return generateUSRFragmentForModule(Mod, OS);
1269 }
1270 
1271 bool clang::index::generateFullUSRForTopLevelModuleName(StringRef ModName,
1272                                                         raw_ostream &OS) {
1273   OS << getUSRSpacePrefix();
1274   return generateUSRFragmentForModuleName(ModName, OS);
1275 }
1276 
1277 bool clang::index::generateUSRFragmentForModule(const Module *Mod,
1278                                                 raw_ostream &OS) {
1279   return generateUSRFragmentForModuleName(Mod->Name, OS);
1280 }
1281 
1282 bool clang::index::generateUSRFragmentForModuleName(StringRef ModName,
1283                                                     raw_ostream &OS) {
1284   OS << "@M@" << ModName;
1285   return false;
1286 }
1287