Ted Kremenek | 1b6869a | 2010-01-05 22:06:45 +0000 | [diff] [blame] | 1 | //===- CIndexUSR.cpp - Clang-C Source Indexing Library --------------------===// |
| 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 generation and use of USRs from CXEntities. |
| 11 | // |
| 12 | //===----------------------------------------------------------------------===// |
| 13 | |
| 14 | #include "CIndexer.h" |
Ted Kremenek | cf84aa4 | 2010-01-18 20:23:29 +0000 | [diff] [blame] | 15 | #include "CXCursor.h" |
Ted Kremenek | ed12273 | 2010-11-16 01:56:27 +0000 | [diff] [blame] | 16 | #include "CXString.h" |
Douglas Gregor | fe72e9c | 2010-08-31 17:01:39 +0000 | [diff] [blame] | 17 | #include "clang/AST/DeclTemplate.h" |
Benjamin Kramer | 9895c6a | 2010-01-12 11:32:40 +0000 | [diff] [blame] | 18 | #include "clang/AST/DeclVisitor.h" |
Ted Kremenek | 6f15395 | 2010-04-15 21:51:13 +0000 | [diff] [blame] | 19 | #include "clang/Frontend/ASTUnit.h" |
Benjamin Kramer | b846deb | 2010-04-12 19:45:50 +0000 | [diff] [blame] | 20 | #include "clang/Lex/PreprocessingRecord.h" |
Ted Kremenek | 8776382 | 2010-01-12 02:07:58 +0000 | [diff] [blame] | 21 | #include "llvm/ADT/SmallString.h" |
Benjamin Kramer | 9895c6a | 2010-01-12 11:32:40 +0000 | [diff] [blame] | 22 | #include "llvm/Support/raw_ostream.h" |
Ted Kremenek | 6f15395 | 2010-04-15 21:51:13 +0000 | [diff] [blame] | 23 | |
Benjamin Kramer | b846deb | 2010-04-12 19:45:50 +0000 | [diff] [blame] | 24 | using namespace clang; |
Ted Kremenek | ee4db4f | 2010-02-17 00:41:08 +0000 | [diff] [blame] | 25 | using namespace clang::cxstring; |
| 26 | |
Ted Kremenek | c50277f | 2010-01-12 23:33:42 +0000 | [diff] [blame] | 27 | //===----------------------------------------------------------------------===// |
| 28 | // USR generation. |
| 29 | //===----------------------------------------------------------------------===// |
| 30 | |
| 31 | namespace { |
Ted Kremenek | 2fee4e6 | 2010-01-14 01:50:21 +0000 | [diff] [blame] | 32 | class USRGenerator : public DeclVisitor<USRGenerator> { |
Ted Kremenek | f019943 | 2010-11-16 08:15:38 +0000 | [diff] [blame] | 33 | llvm::OwningPtr<llvm::SmallString<128> > OwnedBuf; |
Chris Lattner | 5f9e272 | 2011-07-23 10:55:15 +0000 | [diff] [blame] | 34 | SmallVectorImpl<char> &Buf; |
Ted Kremenek | 3ebd8dc | 2010-05-07 20:07:23 +0000 | [diff] [blame] | 35 | llvm::raw_svector_ostream Out; |
Ted Kremenek | 3adca6d | 2010-01-18 22:02:49 +0000 | [diff] [blame] | 36 | bool IgnoreResults; |
Argyrios Kyrtzidis | b6a4ac4 | 2011-10-12 07:07:36 +0000 | [diff] [blame] | 37 | ASTContext *Context; |
Ted Kremenek | cbd66f0 | 2010-05-06 23:38:28 +0000 | [diff] [blame] | 38 | bool generatedLoc; |
Douglas Gregor | 66b7fbf | 2010-09-20 20:37:39 +0000 | [diff] [blame] | 39 | |
| 40 | llvm::DenseMap<const Type *, unsigned> TypeSubstitutions; |
| 41 | |
Ted Kremenek | 2fee4e6 | 2010-01-14 01:50:21 +0000 | [diff] [blame] | 42 | public: |
Argyrios Kyrtzidis | b6a4ac4 | 2011-10-12 07:07:36 +0000 | [diff] [blame] | 43 | explicit USRGenerator(ASTContext *Ctx = 0, SmallVectorImpl<char> *extBuf = 0) |
Ted Kremenek | f019943 | 2010-11-16 08:15:38 +0000 | [diff] [blame] | 44 | : OwnedBuf(extBuf ? 0 : new llvm::SmallString<128>()), |
| 45 | Buf(extBuf ? *extBuf : *OwnedBuf.get()), |
| 46 | Out(Buf), |
| 47 | IgnoreResults(false), |
Argyrios Kyrtzidis | b6a4ac4 | 2011-10-12 07:07:36 +0000 | [diff] [blame] | 48 | Context(Ctx), |
Ted Kremenek | f019943 | 2010-11-16 08:15:38 +0000 | [diff] [blame] | 49 | generatedLoc(false) |
Ted Kremenek | 3ebd8dc | 2010-05-07 20:07:23 +0000 | [diff] [blame] | 50 | { |
| 51 | // Add the USR space prefix. |
| 52 | Out << "c:"; |
| 53 | } |
| 54 | |
Chris Lattner | 5f9e272 | 2011-07-23 10:55:15 +0000 | [diff] [blame] | 55 | StringRef str() { |
Ted Kremenek | 3ebd8dc | 2010-05-07 20:07:23 +0000 | [diff] [blame] | 56 | return Out.str(); |
| 57 | } |
| 58 | |
| 59 | USRGenerator* operator->() { return this; } |
| 60 | |
| 61 | template <typename T> |
| 62 | llvm::raw_svector_ostream &operator<<(const T &x) { |
| 63 | Out << x; |
| 64 | return Out; |
| 65 | } |
Ted Kremenek | 896b70f | 2010-03-13 02:50:34 +0000 | [diff] [blame] | 66 | |
Ted Kremenek | 3adca6d | 2010-01-18 22:02:49 +0000 | [diff] [blame] | 67 | bool ignoreResults() const { return IgnoreResults; } |
Ted Kremenek | 896b70f | 2010-03-13 02:50:34 +0000 | [diff] [blame] | 68 | |
| 69 | // Visitation methods from generating USRs from AST elements. |
Ted Kremenek | 2fee4e6 | 2010-01-14 01:50:21 +0000 | [diff] [blame] | 70 | void VisitDeclContext(DeclContext *D); |
Ted Kremenek | 3adca6d | 2010-01-18 22:02:49 +0000 | [diff] [blame] | 71 | void VisitFieldDecl(FieldDecl *D); |
Ted Kremenek | 2fee4e6 | 2010-01-14 01:50:21 +0000 | [diff] [blame] | 72 | void VisitFunctionDecl(FunctionDecl *D); |
| 73 | void VisitNamedDecl(NamedDecl *D); |
| 74 | void VisitNamespaceDecl(NamespaceDecl *D); |
Douglas Gregor | 6931900 | 2010-08-31 23:48:11 +0000 | [diff] [blame] | 75 | void VisitNamespaceAliasDecl(NamespaceAliasDecl *D); |
Douglas Gregor | fe72e9c | 2010-08-31 17:01:39 +0000 | [diff] [blame] | 76 | void VisitFunctionTemplateDecl(FunctionTemplateDecl *D); |
Douglas Gregor | 39d6f07 | 2010-08-31 19:02:00 +0000 | [diff] [blame] | 77 | void VisitClassTemplateDecl(ClassTemplateDecl *D); |
Ted Kremenek | 896b70f | 2010-03-13 02:50:34 +0000 | [diff] [blame] | 78 | void VisitObjCContainerDecl(ObjCContainerDecl *CD); |
Ted Kremenek | e542f77 | 2010-04-20 23:15:40 +0000 | [diff] [blame] | 79 | void VisitObjCMethodDecl(ObjCMethodDecl *MD); |
Ted Kremenek | 2fee4e6 | 2010-01-14 01:50:21 +0000 | [diff] [blame] | 80 | void VisitObjCPropertyDecl(ObjCPropertyDecl *D); |
Ted Kremenek | e542f77 | 2010-04-20 23:15:40 +0000 | [diff] [blame] | 81 | void VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D); |
Ted Kremenek | b82b3be | 2010-01-18 22:42:20 +0000 | [diff] [blame] | 82 | void VisitTagDecl(TagDecl *D); |
Ted Kremenek | 2fee4e6 | 2010-01-14 01:50:21 +0000 | [diff] [blame] | 83 | void VisitTypedefDecl(TypedefDecl *D); |
Douglas Gregor | fe72e9c | 2010-08-31 17:01:39 +0000 | [diff] [blame] | 84 | void VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D); |
Ted Kremenek | e542f77 | 2010-04-20 23:15:40 +0000 | [diff] [blame] | 85 | void VisitVarDecl(VarDecl *D); |
Douglas Gregor | fe72e9c | 2010-08-31 17:01:39 +0000 | [diff] [blame] | 86 | void VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D); |
| 87 | void VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D); |
Ted Kremenek | 8e67219 | 2010-05-07 01:04:32 +0000 | [diff] [blame] | 88 | void VisitLinkageSpecDecl(LinkageSpecDecl *D) { |
| 89 | IgnoreResults = true; |
Ted Kremenek | 8e67219 | 2010-05-07 01:04:32 +0000 | [diff] [blame] | 90 | } |
Douglas Gregor | 0a35bce | 2010-09-01 03:07:18 +0000 | [diff] [blame] | 91 | void VisitUsingDirectiveDecl(UsingDirectiveDecl *D) { |
| 92 | IgnoreResults = true; |
| 93 | } |
Douglas Gregor | 7e24256 | 2010-09-01 19:52:22 +0000 | [diff] [blame] | 94 | void VisitUsingDecl(UsingDecl *D) { |
| 95 | IgnoreResults = true; |
| 96 | } |
| 97 | void VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D) { |
| 98 | IgnoreResults = true; |
| 99 | } |
| 100 | void VisitUnresolvedUsingTypenameDecl(UnresolvedUsingTypenameDecl *D) { |
| 101 | IgnoreResults = true; |
| 102 | } |
Douglas Gregor | 0a35bce | 2010-09-01 03:07:18 +0000 | [diff] [blame] | 103 | |
Ted Kremenek | 6f15395 | 2010-04-15 21:51:13 +0000 | [diff] [blame] | 104 | /// Generate the string component containing the location of the |
| 105 | /// declaration. |
Ted Kremenek | cbd66f0 | 2010-05-06 23:38:28 +0000 | [diff] [blame] | 106 | bool GenLoc(const Decl *D); |
Ted Kremenek | 6f15395 | 2010-04-15 21:51:13 +0000 | [diff] [blame] | 107 | |
Ted Kremenek | 896b70f | 2010-03-13 02:50:34 +0000 | [diff] [blame] | 108 | /// String generation methods used both by the visitation methods |
| 109 | /// and from other clients that want to directly generate USRs. These |
| 110 | /// methods do not construct complete USRs (which incorporate the parents |
| 111 | /// of an AST element), but only the fragments concerning the AST element |
| 112 | /// itself. |
| 113 | |
Ted Kremenek | 896b70f | 2010-03-13 02:50:34 +0000 | [diff] [blame] | 114 | /// Generate a USR for an Objective-C class. |
Chris Lattner | 5f9e272 | 2011-07-23 10:55:15 +0000 | [diff] [blame] | 115 | void GenObjCClass(StringRef cls); |
Ted Kremenek | 896b70f | 2010-03-13 02:50:34 +0000 | [diff] [blame] | 116 | /// Generate a USR for an Objective-C class category. |
Chris Lattner | 5f9e272 | 2011-07-23 10:55:15 +0000 | [diff] [blame] | 117 | void GenObjCCategory(StringRef cls, StringRef cat); |
Ted Kremenek | 896b70f | 2010-03-13 02:50:34 +0000 | [diff] [blame] | 118 | /// Generate a USR fragment for an Objective-C instance variable. The |
| 119 | /// complete USR can be created by concatenating the USR for the |
| 120 | /// encompassing class with this USR fragment. |
Chris Lattner | 5f9e272 | 2011-07-23 10:55:15 +0000 | [diff] [blame] | 121 | void GenObjCIvar(StringRef ivar); |
Ted Kremenek | 896b70f | 2010-03-13 02:50:34 +0000 | [diff] [blame] | 122 | /// Generate a USR fragment for an Objective-C method. |
Chris Lattner | 5f9e272 | 2011-07-23 10:55:15 +0000 | [diff] [blame] | 123 | void GenObjCMethod(StringRef sel, bool isInstanceMethod); |
Ted Kremenek | 896b70f | 2010-03-13 02:50:34 +0000 | [diff] [blame] | 124 | /// Generate a USR fragment for an Objective-C property. |
Chris Lattner | 5f9e272 | 2011-07-23 10:55:15 +0000 | [diff] [blame] | 125 | void GenObjCProperty(StringRef prop); |
Ted Kremenek | 896b70f | 2010-03-13 02:50:34 +0000 | [diff] [blame] | 126 | /// Generate a USR for an Objective-C protocol. |
Chris Lattner | 5f9e272 | 2011-07-23 10:55:15 +0000 | [diff] [blame] | 127 | void GenObjCProtocol(StringRef prot); |
Ted Kremenek | 8e67219 | 2010-05-07 01:04:32 +0000 | [diff] [blame] | 128 | |
| 129 | void VisitType(QualType T); |
Douglas Gregor | fe72e9c | 2010-08-31 17:01:39 +0000 | [diff] [blame] | 130 | void VisitTemplateParameterList(const TemplateParameterList *Params); |
| 131 | void VisitTemplateName(TemplateName Name); |
| 132 | void VisitTemplateArgument(const TemplateArgument &Arg); |
| 133 | |
Ted Kremenek | 3ebd8dc | 2010-05-07 20:07:23 +0000 | [diff] [blame] | 134 | /// Emit a Decl's name using NamedDecl::printName() and return true if |
| 135 | /// the decl had no name. |
| 136 | bool EmitDeclName(const NamedDecl *D); |
Ted Kremenek | 896b70f | 2010-03-13 02:50:34 +0000 | [diff] [blame] | 137 | }; |
| 138 | |
Ted Kremenek | c50277f | 2010-01-12 23:33:42 +0000 | [diff] [blame] | 139 | } // end anonymous namespace |
| 140 | |
Ted Kremenek | 896b70f | 2010-03-13 02:50:34 +0000 | [diff] [blame] | 141 | //===----------------------------------------------------------------------===// |
| 142 | // Generating USRs from ASTS. |
| 143 | //===----------------------------------------------------------------------===// |
| 144 | |
Ted Kremenek | 3ebd8dc | 2010-05-07 20:07:23 +0000 | [diff] [blame] | 145 | bool USRGenerator::EmitDeclName(const NamedDecl *D) { |
| 146 | Out.flush(); |
| 147 | const unsigned startSize = Buf.size(); |
| 148 | D->printName(Out); |
| 149 | Out.flush(); |
| 150 | const unsigned endSize = Buf.size(); |
| 151 | return startSize == endSize; |
| 152 | } |
| 153 | |
Ted Kremenek | cbd66f0 | 2010-05-06 23:38:28 +0000 | [diff] [blame] | 154 | static bool InAnonymousNamespace(const Decl *D) { |
| 155 | if (const NamespaceDecl *ND = dyn_cast<NamespaceDecl>(D->getDeclContext())) |
| 156 | return ND->isAnonymousNamespace(); |
| 157 | return false; |
| 158 | } |
| 159 | |
| 160 | static inline bool ShouldGenerateLocation(const NamedDecl *D) { |
| 161 | return D->getLinkage() != ExternalLinkage && !InAnonymousNamespace(D); |
| 162 | } |
| 163 | |
Ted Kremenek | 2fee4e6 | 2010-01-14 01:50:21 +0000 | [diff] [blame] | 164 | void USRGenerator::VisitDeclContext(DeclContext *DC) { |
| 165 | if (NamedDecl *D = dyn_cast<NamedDecl>(DC)) |
| 166 | Visit(D); |
| 167 | } |
| 168 | |
Ted Kremenek | 3adca6d | 2010-01-18 22:02:49 +0000 | [diff] [blame] | 169 | void USRGenerator::VisitFieldDecl(FieldDecl *D) { |
Argyrios Kyrtzidis | 87ec9c2 | 2011-11-01 17:14:12 +0000 | [diff] [blame] | 170 | // The USR for an ivar declared in a class extension is based on the |
| 171 | // ObjCInterfaceDecl, not the ObjCCategoryDecl. |
| 172 | if (ObjCInterfaceDecl *ID = Context->getObjContainingInterface(D)) |
| 173 | Visit(ID); |
| 174 | else |
| 175 | VisitDeclContext(D->getDeclContext()); |
Ted Kremenek | 3ebd8dc | 2010-05-07 20:07:23 +0000 | [diff] [blame] | 176 | Out << (isa<ObjCIvarDecl>(D) ? "@" : "@FI@"); |
| 177 | if (EmitDeclName(D)) { |
Ted Kremenek | 3adca6d | 2010-01-18 22:02:49 +0000 | [diff] [blame] | 178 | // Bit fields can be anonymous. |
| 179 | IgnoreResults = true; |
| 180 | return; |
| 181 | } |
Ted Kremenek | 3adca6d | 2010-01-18 22:02:49 +0000 | [diff] [blame] | 182 | } |
| 183 | |
Ted Kremenek | 2fee4e6 | 2010-01-14 01:50:21 +0000 | [diff] [blame] | 184 | void USRGenerator::VisitFunctionDecl(FunctionDecl *D) { |
Ted Kremenek | cbd66f0 | 2010-05-06 23:38:28 +0000 | [diff] [blame] | 185 | if (ShouldGenerateLocation(D) && GenLoc(D)) |
| 186 | return; |
Ted Kremenek | cf99910 | 2010-04-29 17:43:29 +0000 | [diff] [blame] | 187 | |
Ted Kremenek | cbd66f0 | 2010-05-06 23:38:28 +0000 | [diff] [blame] | 188 | VisitDeclContext(D->getDeclContext()); |
Douglas Gregor | fe72e9c | 2010-08-31 17:01:39 +0000 | [diff] [blame] | 189 | if (FunctionTemplateDecl *FunTmpl = D->getDescribedFunctionTemplate()) { |
| 190 | Out << "@FT@"; |
| 191 | VisitTemplateParameterList(FunTmpl->getTemplateParameters()); |
| 192 | } else |
| 193 | Out << "@F@"; |
Ted Kremenek | 3ebd8dc | 2010-05-07 20:07:23 +0000 | [diff] [blame] | 194 | D->printName(Out); |
Ted Kremenek | 8e67219 | 2010-05-07 01:04:32 +0000 | [diff] [blame] | 195 | |
Argyrios Kyrtzidis | b6a4ac4 | 2011-10-12 07:07:36 +0000 | [diff] [blame] | 196 | ASTContext &Ctx = *Context; |
Ted Kremenek | 8e67219 | 2010-05-07 01:04:32 +0000 | [diff] [blame] | 197 | if (!Ctx.getLangOptions().CPlusPlus || D->isExternC()) |
| 198 | return; |
| 199 | |
| 200 | // Mangle in type information for the arguments. |
| 201 | for (FunctionDecl::param_iterator I = D->param_begin(), E = D->param_end(); |
| 202 | I != E; ++I) { |
| 203 | Out << '#'; |
| 204 | if (ParmVarDecl *PD = *I) |
| 205 | VisitType(PD->getType()); |
| 206 | } |
| 207 | if (D->isVariadic()) |
| 208 | Out << '.'; |
Ted Kremenek | 2ea5baf | 2010-05-07 20:39:40 +0000 | [diff] [blame] | 209 | Out << '#'; |
| 210 | if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(D)) { |
| 211 | if (MD->isStatic()) |
| 212 | Out << 'S'; |
| 213 | if (unsigned quals = MD->getTypeQualifiers()) |
| 214 | Out << (char)('0' + quals); |
| 215 | } |
Ted Kremenek | 2fee4e6 | 2010-01-14 01:50:21 +0000 | [diff] [blame] | 216 | } |
Ted Kremenek | c50277f | 2010-01-12 23:33:42 +0000 | [diff] [blame] | 217 | |
| 218 | void USRGenerator::VisitNamedDecl(NamedDecl *D) { |
Ted Kremenek | 2fee4e6 | 2010-01-14 01:50:21 +0000 | [diff] [blame] | 219 | VisitDeclContext(D->getDeclContext()); |
Ted Kremenek | 3ebd8dc | 2010-05-07 20:07:23 +0000 | [diff] [blame] | 220 | Out << "@"; |
| 221 | |
| 222 | if (EmitDeclName(D)) { |
| 223 | // The string can be empty if the declaration has no name; e.g., it is |
| 224 | // the ParmDecl with no name for declaration of a function pointer type, |
| 225 | // e.g.: void (*f)(void *); |
| 226 | // In this case, don't generate a USR. |
Ted Kremenek | e74ef12 | 2010-04-16 21:31:52 +0000 | [diff] [blame] | 227 | IgnoreResults = true; |
Ted Kremenek | 3ebd8dc | 2010-05-07 20:07:23 +0000 | [diff] [blame] | 228 | } |
Ted Kremenek | 2fee4e6 | 2010-01-14 01:50:21 +0000 | [diff] [blame] | 229 | } |
| 230 | |
Ted Kremenek | e542f77 | 2010-04-20 23:15:40 +0000 | [diff] [blame] | 231 | void USRGenerator::VisitVarDecl(VarDecl *D) { |
| 232 | // VarDecls can be declared 'extern' within a function or method body, |
| 233 | // but their enclosing DeclContext is the function, not the TU. We need |
| 234 | // to check the storage class to correctly generate the USR. |
Ted Kremenek | cbd66f0 | 2010-05-06 23:38:28 +0000 | [diff] [blame] | 235 | if (ShouldGenerateLocation(D) && GenLoc(D)) |
| 236 | return; |
| 237 | |
| 238 | VisitDeclContext(D->getDeclContext()); |
Ted Kremenek | e542f77 | 2010-04-20 23:15:40 +0000 | [diff] [blame] | 239 | |
Ted Kremenek | cf99910 | 2010-04-29 17:43:29 +0000 | [diff] [blame] | 240 | // Variables always have simple names. |
Chris Lattner | 5f9e272 | 2011-07-23 10:55:15 +0000 | [diff] [blame] | 241 | StringRef s = D->getName(); |
Ted Kremenek | cf99910 | 2010-04-29 17:43:29 +0000 | [diff] [blame] | 242 | |
Ted Kremenek | e542f77 | 2010-04-20 23:15:40 +0000 | [diff] [blame] | 243 | // The string can be empty if the declaration has no name; e.g., it is |
| 244 | // the ParmDecl with no name for declaration of a function pointer type, e.g.: |
Eli Friedman | a7e6845 | 2010-08-22 01:00:03 +0000 | [diff] [blame] | 245 | // void (*f)(void *); |
Ted Kremenek | e542f77 | 2010-04-20 23:15:40 +0000 | [diff] [blame] | 246 | // In this case, don't generate a USR. |
| 247 | if (s.empty()) |
| 248 | IgnoreResults = true; |
| 249 | else |
Ted Kremenek | 3ebd8dc | 2010-05-07 20:07:23 +0000 | [diff] [blame] | 250 | Out << '@' << s; |
Ted Kremenek | e542f77 | 2010-04-20 23:15:40 +0000 | [diff] [blame] | 251 | } |
| 252 | |
Douglas Gregor | fe72e9c | 2010-08-31 17:01:39 +0000 | [diff] [blame] | 253 | void USRGenerator::VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D) { |
| 254 | GenLoc(D); |
| 255 | return; |
| 256 | } |
| 257 | |
| 258 | void USRGenerator::VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D) { |
| 259 | GenLoc(D); |
| 260 | return; |
| 261 | } |
| 262 | |
Ted Kremenek | 2fee4e6 | 2010-01-14 01:50:21 +0000 | [diff] [blame] | 263 | void USRGenerator::VisitNamespaceDecl(NamespaceDecl *D) { |
Ted Kremenek | cbd66f0 | 2010-05-06 23:38:28 +0000 | [diff] [blame] | 264 | if (D->isAnonymousNamespace()) { |
| 265 | Out << "@aN"; |
| 266 | return; |
| 267 | } |
| 268 | |
Ted Kremenek | 2fee4e6 | 2010-01-14 01:50:21 +0000 | [diff] [blame] | 269 | VisitDeclContext(D->getDeclContext()); |
Ted Kremenek | cbd66f0 | 2010-05-06 23:38:28 +0000 | [diff] [blame] | 270 | if (!IgnoreResults) |
| 271 | Out << "@N@" << D->getName(); |
Ted Kremenek | c50277f | 2010-01-12 23:33:42 +0000 | [diff] [blame] | 272 | } |
| 273 | |
Douglas Gregor | fe72e9c | 2010-08-31 17:01:39 +0000 | [diff] [blame] | 274 | void USRGenerator::VisitFunctionTemplateDecl(FunctionTemplateDecl *D) { |
| 275 | VisitFunctionDecl(D->getTemplatedDecl()); |
| 276 | } |
| 277 | |
Douglas Gregor | 39d6f07 | 2010-08-31 19:02:00 +0000 | [diff] [blame] | 278 | void USRGenerator::VisitClassTemplateDecl(ClassTemplateDecl *D) { |
| 279 | VisitTagDecl(D->getTemplatedDecl()); |
| 280 | } |
| 281 | |
Douglas Gregor | 6931900 | 2010-08-31 23:48:11 +0000 | [diff] [blame] | 282 | void USRGenerator::VisitNamespaceAliasDecl(NamespaceAliasDecl *D) { |
| 283 | VisitDeclContext(D->getDeclContext()); |
| 284 | if (!IgnoreResults) |
| 285 | Out << "@NA@" << D->getName(); |
| 286 | } |
Douglas Gregor | 39d6f07 | 2010-08-31 19:02:00 +0000 | [diff] [blame] | 287 | |
Ted Kremenek | c50277f | 2010-01-12 23:33:42 +0000 | [diff] [blame] | 288 | void USRGenerator::VisitObjCMethodDecl(ObjCMethodDecl *D) { |
Ted Kremenek | 52d6bbe | 2011-02-05 01:10:26 +0000 | [diff] [blame] | 289 | DeclContext *container = D->getDeclContext(); |
| 290 | if (ObjCProtocolDecl *pd = dyn_cast<ObjCProtocolDecl>(container)) { |
| 291 | Visit(pd); |
Ted Kremenek | 28a7f25 | 2010-08-24 23:13:41 +0000 | [diff] [blame] | 292 | } |
Ted Kremenek | 52d6bbe | 2011-02-05 01:10:26 +0000 | [diff] [blame] | 293 | else { |
| 294 | // The USR for a method declared in a class extension or category is based on |
| 295 | // the ObjCInterfaceDecl, not the ObjCCategoryDecl. |
| 296 | ObjCInterfaceDecl *ID = D->getClassInterface(); |
| 297 | if (!ID) { |
| 298 | IgnoreResults = true; |
| 299 | return; |
| 300 | } |
| 301 | Visit(ID); |
| 302 | } |
Ted Kremenek | 3ebd8dc | 2010-05-07 20:07:23 +0000 | [diff] [blame] | 303 | // Ideally we would use 'GenObjCMethod', but this is such a hot path |
| 304 | // for Objective-C code that we don't want to use |
| 305 | // DeclarationName::getAsString(). |
| 306 | Out << (D->isInstanceMethod() ? "(im)" : "(cm)"); |
| 307 | DeclarationName N(D->getSelector()); |
| 308 | N.printName(Out); |
Ted Kremenek | c50277f | 2010-01-12 23:33:42 +0000 | [diff] [blame] | 309 | } |
| 310 | |
| 311 | void USRGenerator::VisitObjCContainerDecl(ObjCContainerDecl *D) { |
| 312 | switch (D->getKind()) { |
| 313 | default: |
David Blaikie | b219cfc | 2011-09-23 05:06:16 +0000 | [diff] [blame] | 314 | llvm_unreachable("Invalid ObjC container."); |
Ted Kremenek | c50277f | 2010-01-12 23:33:42 +0000 | [diff] [blame] | 315 | case Decl::ObjCInterface: |
| 316 | case Decl::ObjCImplementation: |
Ted Kremenek | 896b70f | 2010-03-13 02:50:34 +0000 | [diff] [blame] | 317 | GenObjCClass(D->getName()); |
Ted Kremenek | c50277f | 2010-01-12 23:33:42 +0000 | [diff] [blame] | 318 | break; |
| 319 | case Decl::ObjCCategory: { |
| 320 | ObjCCategoryDecl *CD = cast<ObjCCategoryDecl>(D); |
Ted Kremenek | ebfa339 | 2010-03-19 20:39:03 +0000 | [diff] [blame] | 321 | ObjCInterfaceDecl *ID = CD->getClassInterface(); |
| 322 | if (!ID) { |
| 323 | // Handle invalid code where the @interface might not |
| 324 | // have been specified. |
| 325 | // FIXME: We should be able to generate this USR even if the |
| 326 | // @interface isn't available. |
| 327 | IgnoreResults = true; |
| 328 | return; |
| 329 | } |
Argyrios Kyrtzidis | 87ec9c2 | 2011-11-01 17:14:12 +0000 | [diff] [blame] | 330 | // Specially handle class extensions, which are anonymous categories. |
| 331 | // We want to mangle in the location to uniquely distinguish them. |
Ted Kremenek | 28a7f25 | 2010-08-24 23:13:41 +0000 | [diff] [blame] | 332 | if (CD->IsClassExtension()) { |
Argyrios Kyrtzidis | 87ec9c2 | 2011-11-01 17:14:12 +0000 | [diff] [blame] | 333 | Out << "objc(ext)" << ID->getName() << '@'; |
| 334 | GenLoc(CD); |
Ted Kremenek | 28a7f25 | 2010-08-24 23:13:41 +0000 | [diff] [blame] | 335 | } |
| 336 | else |
| 337 | GenObjCCategory(ID->getName(), CD->getName()); |
| 338 | |
Ted Kremenek | c50277f | 2010-01-12 23:33:42 +0000 | [diff] [blame] | 339 | break; |
| 340 | } |
| 341 | case Decl::ObjCCategoryImpl: { |
| 342 | ObjCCategoryImplDecl *CD = cast<ObjCCategoryImplDecl>(D); |
Ted Kremenek | ebfa339 | 2010-03-19 20:39:03 +0000 | [diff] [blame] | 343 | ObjCInterfaceDecl *ID = CD->getClassInterface(); |
| 344 | if (!ID) { |
| 345 | // Handle invalid code where the @interface might not |
| 346 | // have been specified. |
| 347 | // FIXME: We should be able to generate this USR even if the |
| 348 | // @interface isn't available. |
| 349 | IgnoreResults = true; |
| 350 | return; |
| 351 | } |
| 352 | GenObjCCategory(ID->getName(), CD->getName()); |
Ted Kremenek | c50277f | 2010-01-12 23:33:42 +0000 | [diff] [blame] | 353 | break; |
| 354 | } |
| 355 | case Decl::ObjCProtocol: |
Ted Kremenek | 896b70f | 2010-03-13 02:50:34 +0000 | [diff] [blame] | 356 | GenObjCProtocol(cast<ObjCProtocolDecl>(D)->getName()); |
Ted Kremenek | c50277f | 2010-01-12 23:33:42 +0000 | [diff] [blame] | 357 | break; |
| 358 | } |
| 359 | } |
| 360 | |
| 361 | void USRGenerator::VisitObjCPropertyDecl(ObjCPropertyDecl *D) { |
Argyrios Kyrtzidis | 87ec9c2 | 2011-11-01 17:14:12 +0000 | [diff] [blame] | 362 | // The USR for a property declared in a class extension or category is based |
| 363 | // on the ObjCInterfaceDecl, not the ObjCCategoryDecl. |
| 364 | if (ObjCInterfaceDecl *ID = Context->getObjContainingInterface(D)) |
| 365 | Visit(ID); |
| 366 | else |
| 367 | Visit(cast<Decl>(D->getDeclContext())); |
Ted Kremenek | 896b70f | 2010-03-13 02:50:34 +0000 | [diff] [blame] | 368 | GenObjCProperty(D->getName()); |
Ted Kremenek | c50277f | 2010-01-12 23:33:42 +0000 | [diff] [blame] | 369 | } |
| 370 | |
Ted Kremenek | e542f77 | 2010-04-20 23:15:40 +0000 | [diff] [blame] | 371 | void USRGenerator::VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D) { |
| 372 | if (ObjCPropertyDecl *PD = D->getPropertyDecl()) { |
| 373 | VisitObjCPropertyDecl(PD); |
| 374 | return; |
| 375 | } |
| 376 | |
| 377 | IgnoreResults = true; |
| 378 | } |
| 379 | |
Ted Kremenek | b82b3be | 2010-01-18 22:42:20 +0000 | [diff] [blame] | 380 | void USRGenerator::VisitTagDecl(TagDecl *D) { |
Ted Kremenek | cbd66f0 | 2010-05-06 23:38:28 +0000 | [diff] [blame] | 381 | // Add the location of the tag decl to handle resolution across |
| 382 | // translation units. |
| 383 | if (ShouldGenerateLocation(D) && GenLoc(D)) |
| 384 | return; |
Ted Kremenek | 8e67219 | 2010-05-07 01:04:32 +0000 | [diff] [blame] | 385 | |
Ted Kremenek | 6f15395 | 2010-04-15 21:51:13 +0000 | [diff] [blame] | 386 | D = D->getCanonicalDecl(); |
Ted Kremenek | b82b3be | 2010-01-18 22:42:20 +0000 | [diff] [blame] | 387 | VisitDeclContext(D->getDeclContext()); |
Ted Kremenek | cbd66f0 | 2010-05-06 23:38:28 +0000 | [diff] [blame] | 388 | |
Douglas Gregor | 74dbe64 | 2010-08-31 19:31:58 +0000 | [diff] [blame] | 389 | bool AlreadyStarted = false; |
| 390 | if (CXXRecordDecl *CXXRecord = dyn_cast<CXXRecordDecl>(D)) { |
Douglas Gregor | 39d6f07 | 2010-08-31 19:02:00 +0000 | [diff] [blame] | 391 | if (ClassTemplateDecl *ClassTmpl = CXXRecord->getDescribedClassTemplate()) { |
Douglas Gregor | 74dbe64 | 2010-08-31 19:31:58 +0000 | [diff] [blame] | 392 | AlreadyStarted = true; |
Douglas Gregor | 39d6f07 | 2010-08-31 19:02:00 +0000 | [diff] [blame] | 393 | |
| 394 | switch (D->getTagKind()) { |
Douglas Gregor | 74dbe64 | 2010-08-31 19:31:58 +0000 | [diff] [blame] | 395 | case TTK_Struct: Out << "@ST"; break; |
| 396 | case TTK_Class: Out << "@CT"; break; |
| 397 | case TTK_Union: Out << "@UT"; break; |
| 398 | case TTK_Enum: llvm_unreachable("enum template"); break; |
Douglas Gregor | 39d6f07 | 2010-08-31 19:02:00 +0000 | [diff] [blame] | 399 | } |
| 400 | VisitTemplateParameterList(ClassTmpl->getTemplateParameters()); |
Douglas Gregor | 74dbe64 | 2010-08-31 19:31:58 +0000 | [diff] [blame] | 401 | } else if (ClassTemplatePartialSpecializationDecl *PartialSpec |
| 402 | = dyn_cast<ClassTemplatePartialSpecializationDecl>(CXXRecord)) { |
| 403 | AlreadyStarted = true; |
| 404 | |
| 405 | switch (D->getTagKind()) { |
| 406 | case TTK_Struct: Out << "@SP"; break; |
| 407 | case TTK_Class: Out << "@CP"; break; |
| 408 | case TTK_Union: Out << "@UP"; break; |
| 409 | case TTK_Enum: llvm_unreachable("enum partial specialization"); break; |
| 410 | } |
| 411 | VisitTemplateParameterList(PartialSpec->getTemplateParameters()); |
Douglas Gregor | 39d6f07 | 2010-08-31 19:02:00 +0000 | [diff] [blame] | 412 | } |
Douglas Gregor | 74dbe64 | 2010-08-31 19:31:58 +0000 | [diff] [blame] | 413 | } |
Douglas Gregor | 39d6f07 | 2010-08-31 19:02:00 +0000 | [diff] [blame] | 414 | |
Douglas Gregor | 74dbe64 | 2010-08-31 19:31:58 +0000 | [diff] [blame] | 415 | if (!AlreadyStarted) { |
Douglas Gregor | 39d6f07 | 2010-08-31 19:02:00 +0000 | [diff] [blame] | 416 | switch (D->getTagKind()) { |
| 417 | case TTK_Struct: Out << "@S"; break; |
| 418 | case TTK_Class: Out << "@C"; break; |
| 419 | case TTK_Union: Out << "@U"; break; |
| 420 | case TTK_Enum: Out << "@E"; break; |
| 421 | } |
Ted Kremenek | e74ef12 | 2010-04-16 21:31:52 +0000 | [diff] [blame] | 422 | } |
Douglas Gregor | 39d6f07 | 2010-08-31 19:02:00 +0000 | [diff] [blame] | 423 | |
Ted Kremenek | 3ebd8dc | 2010-05-07 20:07:23 +0000 | [diff] [blame] | 424 | Out << '@'; |
| 425 | Out.flush(); |
| 426 | assert(Buf.size() > 0); |
| 427 | const unsigned off = Buf.size() - 1; |
Ted Kremenek | 896b70f | 2010-03-13 02:50:34 +0000 | [diff] [blame] | 428 | |
Ted Kremenek | 3ebd8dc | 2010-05-07 20:07:23 +0000 | [diff] [blame] | 429 | if (EmitDeclName(D)) { |
Richard Smith | 162e1c1 | 2011-04-15 14:24:37 +0000 | [diff] [blame] | 430 | if (const TypedefNameDecl *TD = D->getTypedefNameForAnonDecl()) { |
Ted Kremenek | 3ebd8dc | 2010-05-07 20:07:23 +0000 | [diff] [blame] | 431 | Buf[off] = 'A'; |
Benjamin Kramer | b8989f2 | 2011-10-14 18:45:37 +0000 | [diff] [blame] | 432 | Out << '@' << *TD; |
Ted Kremenek | 3ebd8dc | 2010-05-07 20:07:23 +0000 | [diff] [blame] | 433 | } |
| 434 | else |
| 435 | Buf[off] = 'a'; |
Ted Kremenek | c5b48b3 | 2010-01-15 23:34:31 +0000 | [diff] [blame] | 436 | } |
Douglas Gregor | 0ab1e9f | 2010-09-01 17:32:36 +0000 | [diff] [blame] | 437 | |
| 438 | // For a class template specialization, mangle the template arguments. |
| 439 | if (ClassTemplateSpecializationDecl *Spec |
| 440 | = dyn_cast<ClassTemplateSpecializationDecl>(D)) { |
| 441 | const TemplateArgumentList &Args = Spec->getTemplateInstantiationArgs(); |
| 442 | Out << '>'; |
| 443 | for (unsigned I = 0, N = Args.size(); I != N; ++I) { |
| 444 | Out << '#'; |
| 445 | VisitTemplateArgument(Args.get(I)); |
| 446 | } |
| 447 | } |
Ted Kremenek | c5b48b3 | 2010-01-15 23:34:31 +0000 | [diff] [blame] | 448 | } |
| 449 | |
Ted Kremenek | c50277f | 2010-01-12 23:33:42 +0000 | [diff] [blame] | 450 | void USRGenerator::VisitTypedefDecl(TypedefDecl *D) { |
Ted Kremenek | cbd66f0 | 2010-05-06 23:38:28 +0000 | [diff] [blame] | 451 | if (ShouldGenerateLocation(D) && GenLoc(D)) |
| 452 | return; |
Ted Kremenek | c50277f | 2010-01-12 23:33:42 +0000 | [diff] [blame] | 453 | DeclContext *DC = D->getDeclContext(); |
| 454 | if (NamedDecl *DCN = dyn_cast<NamedDecl>(DC)) |
Ted Kremenek | 896b70f | 2010-03-13 02:50:34 +0000 | [diff] [blame] | 455 | Visit(DCN); |
Ted Kremenek | e74ef12 | 2010-04-16 21:31:52 +0000 | [diff] [blame] | 456 | Out << "@T@"; |
Ted Kremenek | 6f15395 | 2010-04-15 21:51:13 +0000 | [diff] [blame] | 457 | Out << D->getName(); |
| 458 | } |
| 459 | |
Douglas Gregor | fe72e9c | 2010-08-31 17:01:39 +0000 | [diff] [blame] | 460 | void USRGenerator::VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D) { |
| 461 | GenLoc(D); |
| 462 | return; |
| 463 | } |
| 464 | |
Ted Kremenek | cbd66f0 | 2010-05-06 23:38:28 +0000 | [diff] [blame] | 465 | bool USRGenerator::GenLoc(const Decl *D) { |
| 466 | if (generatedLoc) |
| 467 | return IgnoreResults; |
| 468 | generatedLoc = true; |
Ted Kremenek | 8c36758 | 2011-04-29 21:35:23 +0000 | [diff] [blame] | 469 | |
| 470 | // Guard against null declarations in invalid code. |
| 471 | if (!D) { |
| 472 | IgnoreResults = true; |
| 473 | return true; |
| 474 | } |
Ted Kremenek | cbd66f0 | 2010-05-06 23:38:28 +0000 | [diff] [blame] | 475 | |
Ted Kremenek | 1d8052d | 2011-05-03 01:33:35 +0000 | [diff] [blame] | 476 | // Use the location of canonical decl. |
| 477 | D = D->getCanonicalDecl(); |
| 478 | |
Argyrios Kyrtzidis | b6a4ac4 | 2011-10-12 07:07:36 +0000 | [diff] [blame] | 479 | const SourceManager &SM = Context->getSourceManager(); |
Ted Kremenek | 6f15395 | 2010-04-15 21:51:13 +0000 | [diff] [blame] | 480 | SourceLocation L = D->getLocStart(); |
| 481 | if (L.isInvalid()) { |
| 482 | IgnoreResults = true; |
Ted Kremenek | cbd66f0 | 2010-05-06 23:38:28 +0000 | [diff] [blame] | 483 | return true; |
Ted Kremenek | 6f15395 | 2010-04-15 21:51:13 +0000 | [diff] [blame] | 484 | } |
Chandler Carruth | 4027853 | 2011-07-25 16:49:02 +0000 | [diff] [blame] | 485 | L = SM.getExpansionLoc(L); |
Ted Kremenek | 6f15395 | 2010-04-15 21:51:13 +0000 | [diff] [blame] | 486 | const std::pair<FileID, unsigned> &Decomposed = SM.getDecomposedLoc(L); |
| 487 | const FileEntry *FE = SM.getFileEntryForID(Decomposed.first); |
Ted Kremenek | e74ef12 | 2010-04-16 21:31:52 +0000 | [diff] [blame] | 488 | if (FE) { |
Michael J. Spencer | 472ccff | 2010-12-18 00:19:12 +0000 | [diff] [blame] | 489 | Out << llvm::sys::path::filename(FE->getName()); |
Ted Kremenek | e74ef12 | 2010-04-16 21:31:52 +0000 | [diff] [blame] | 490 | } |
Ted Kremenek | 6f15395 | 2010-04-15 21:51:13 +0000 | [diff] [blame] | 491 | else { |
| 492 | // This case really isn't interesting. |
| 493 | IgnoreResults = true; |
Ted Kremenek | cbd66f0 | 2010-05-06 23:38:28 +0000 | [diff] [blame] | 494 | return true; |
Ted Kremenek | 6f15395 | 2010-04-15 21:51:13 +0000 | [diff] [blame] | 495 | } |
Ted Kremenek | f48b531 | 2010-07-22 11:14:15 +0000 | [diff] [blame] | 496 | // Use the offest into the FileID to represent the location. Using |
| 497 | // a line/column can cause us to look back at the original source file, |
| 498 | // which is expensive. |
| 499 | Out << '@' << Decomposed.second; |
Ted Kremenek | cbd66f0 | 2010-05-06 23:38:28 +0000 | [diff] [blame] | 500 | return IgnoreResults; |
Ted Kremenek | c50277f | 2010-01-12 23:33:42 +0000 | [diff] [blame] | 501 | } |
| 502 | |
Ted Kremenek | 8e67219 | 2010-05-07 01:04:32 +0000 | [diff] [blame] | 503 | void USRGenerator::VisitType(QualType T) { |
| 504 | // This method mangles in USR information for types. It can possibly |
| 505 | // just reuse the naming-mangling logic used by codegen, although the |
| 506 | // requirements for USRs might not be the same. |
Argyrios Kyrtzidis | b6a4ac4 | 2011-10-12 07:07:36 +0000 | [diff] [blame] | 507 | ASTContext &Ctx = *Context; |
Ted Kremenek | 2ea5baf | 2010-05-07 20:39:40 +0000 | [diff] [blame] | 508 | |
Ted Kremenek | 8e67219 | 2010-05-07 01:04:32 +0000 | [diff] [blame] | 509 | do { |
Ted Kremenek | 2ea5baf | 2010-05-07 20:39:40 +0000 | [diff] [blame] | 510 | T = Ctx.getCanonicalType(T); |
Ted Kremenek | 8e67219 | 2010-05-07 01:04:32 +0000 | [diff] [blame] | 511 | Qualifiers Q = T.getQualifiers(); |
Ted Kremenek | 2ea5baf | 2010-05-07 20:39:40 +0000 | [diff] [blame] | 512 | unsigned qVal = 0; |
Ted Kremenek | 8e67219 | 2010-05-07 01:04:32 +0000 | [diff] [blame] | 513 | if (Q.hasConst()) |
Ted Kremenek | 2ea5baf | 2010-05-07 20:39:40 +0000 | [diff] [blame] | 514 | qVal |= 0x1; |
Ted Kremenek | 8e67219 | 2010-05-07 01:04:32 +0000 | [diff] [blame] | 515 | if (Q.hasVolatile()) |
Ted Kremenek | 2ea5baf | 2010-05-07 20:39:40 +0000 | [diff] [blame] | 516 | qVal |= 0x2; |
Ted Kremenek | 8e67219 | 2010-05-07 01:04:32 +0000 | [diff] [blame] | 517 | if (Q.hasRestrict()) |
Ted Kremenek | 2ea5baf | 2010-05-07 20:39:40 +0000 | [diff] [blame] | 518 | qVal |= 0x4; |
| 519 | if(qVal) |
| 520 | Out << ((char) ('0' + qVal)); |
Ted Kremenek | 8e67219 | 2010-05-07 01:04:32 +0000 | [diff] [blame] | 521 | |
| 522 | // Mangle in ObjC GC qualifiers? |
| 523 | |
Douglas Gregor | ba73ada | 2011-01-19 20:50:07 +0000 | [diff] [blame] | 524 | if (const PackExpansionType *Expansion = T->getAs<PackExpansionType>()) { |
| 525 | Out << 'P'; |
| 526 | T = Expansion->getPattern(); |
| 527 | } |
| 528 | |
Ted Kremenek | 8e67219 | 2010-05-07 01:04:32 +0000 | [diff] [blame] | 529 | if (const BuiltinType *BT = T->getAs<BuiltinType>()) { |
| 530 | unsigned char c = '\0'; |
| 531 | switch (BT->getKind()) { |
| 532 | case BuiltinType::Void: |
| 533 | c = 'v'; break; |
| 534 | case BuiltinType::Bool: |
| 535 | c = 'b'; break; |
| 536 | case BuiltinType::Char_U: |
| 537 | case BuiltinType::UChar: |
| 538 | c = 'c'; break; |
| 539 | case BuiltinType::Char16: |
| 540 | c = 'q'; break; |
| 541 | case BuiltinType::Char32: |
| 542 | c = 'w'; break; |
| 543 | case BuiltinType::UShort: |
| 544 | c = 's'; break; |
| 545 | case BuiltinType::UInt: |
| 546 | c = 'i'; break; |
| 547 | case BuiltinType::ULong: |
| 548 | c = 'l'; break; |
| 549 | case BuiltinType::ULongLong: |
| 550 | c = 'k'; break; |
| 551 | case BuiltinType::UInt128: |
| 552 | c = 'j'; break; |
| 553 | case BuiltinType::Char_S: |
| 554 | case BuiltinType::SChar: |
| 555 | c = 'C'; break; |
Chris Lattner | 3f59c97 | 2010-12-25 23:25:43 +0000 | [diff] [blame] | 556 | case BuiltinType::WChar_S: |
| 557 | case BuiltinType::WChar_U: |
Ted Kremenek | 8e67219 | 2010-05-07 01:04:32 +0000 | [diff] [blame] | 558 | c = 'W'; break; |
| 559 | case BuiltinType::Short: |
| 560 | c = 'S'; break; |
| 561 | case BuiltinType::Int: |
| 562 | c = 'I'; break; |
| 563 | case BuiltinType::Long: |
| 564 | c = 'L'; break; |
| 565 | case BuiltinType::LongLong: |
| 566 | c = 'K'; break; |
| 567 | case BuiltinType::Int128: |
| 568 | c = 'J'; break; |
Anton Korobeynikov | aa4a99b | 2011-10-14 23:23:15 +0000 | [diff] [blame] | 569 | case BuiltinType::Half: |
| 570 | c = 'h'; break; |
Ted Kremenek | 8e67219 | 2010-05-07 01:04:32 +0000 | [diff] [blame] | 571 | case BuiltinType::Float: |
| 572 | c = 'f'; break; |
| 573 | case BuiltinType::Double: |
| 574 | c = 'd'; break; |
| 575 | case BuiltinType::LongDouble: |
| 576 | c = 'D'; break; |
| 577 | case BuiltinType::NullPtr: |
| 578 | c = 'n'; break; |
John McCall | 2dde35b | 2011-10-18 22:28:37 +0000 | [diff] [blame] | 579 | #define BUILTIN_TYPE(Id, SingletonId) |
| 580 | #define PLACEHOLDER_TYPE(Id, SingletonId) case BuiltinType::Id: |
| 581 | #include "clang/AST/BuiltinTypes.def" |
Ted Kremenek | 8e67219 | 2010-05-07 01:04:32 +0000 | [diff] [blame] | 582 | case BuiltinType::Dependent: |
Ted Kremenek | 8e67219 | 2010-05-07 01:04:32 +0000 | [diff] [blame] | 583 | IgnoreResults = true; |
| 584 | return; |
| 585 | case BuiltinType::ObjCId: |
| 586 | c = 'o'; break; |
| 587 | case BuiltinType::ObjCClass: |
| 588 | c = 'O'; break; |
| 589 | case BuiltinType::ObjCSel: |
| 590 | c = 'e'; break; |
| 591 | } |
| 592 | Out << c; |
| 593 | return; |
| 594 | } |
Douglas Gregor | 66b7fbf | 2010-09-20 20:37:39 +0000 | [diff] [blame] | 595 | |
| 596 | // If we have already seen this (non-built-in) type, use a substitution |
| 597 | // encoding. |
| 598 | llvm::DenseMap<const Type *, unsigned>::iterator Substitution |
| 599 | = TypeSubstitutions.find(T.getTypePtr()); |
| 600 | if (Substitution != TypeSubstitutions.end()) { |
| 601 | Out << 'S' << Substitution->second << '_'; |
| 602 | return; |
| 603 | } else { |
| 604 | // Record this as a substitution. |
| 605 | unsigned Number = TypeSubstitutions.size(); |
| 606 | TypeSubstitutions[T.getTypePtr()] = Number; |
| 607 | } |
| 608 | |
| 609 | if (const PointerType *PT = T->getAs<PointerType>()) { |
| 610 | Out << '*'; |
| 611 | T = PT->getPointeeType(); |
| 612 | continue; |
| 613 | } |
| 614 | if (const ReferenceType *RT = T->getAs<ReferenceType>()) { |
| 615 | Out << '&'; |
| 616 | T = RT->getPointeeType(); |
| 617 | continue; |
| 618 | } |
| 619 | if (const FunctionProtoType *FT = T->getAs<FunctionProtoType>()) { |
| 620 | Out << 'F'; |
| 621 | VisitType(FT->getResultType()); |
| 622 | for (FunctionProtoType::arg_type_iterator |
| 623 | I = FT->arg_type_begin(), E = FT->arg_type_end(); I!=E; ++I) { |
| 624 | VisitType(*I); |
| 625 | } |
| 626 | if (FT->isVariadic()) |
| 627 | Out << '.'; |
| 628 | return; |
| 629 | } |
| 630 | if (const BlockPointerType *BT = T->getAs<BlockPointerType>()) { |
| 631 | Out << 'B'; |
| 632 | T = BT->getPointeeType(); |
| 633 | continue; |
| 634 | } |
Ted Kremenek | 8e67219 | 2010-05-07 01:04:32 +0000 | [diff] [blame] | 635 | if (const ComplexType *CT = T->getAs<ComplexType>()) { |
| 636 | Out << '<'; |
| 637 | T = CT->getElementType(); |
| 638 | continue; |
| 639 | } |
Ted Kremenek | 2ea5baf | 2010-05-07 20:39:40 +0000 | [diff] [blame] | 640 | if (const TagType *TT = T->getAs<TagType>()) { |
| 641 | Out << '$'; |
| 642 | VisitTagDecl(TT->getDecl()); |
| 643 | return; |
| 644 | } |
Douglas Gregor | fe72e9c | 2010-08-31 17:01:39 +0000 | [diff] [blame] | 645 | if (const TemplateTypeParmType *TTP = T->getAs<TemplateTypeParmType>()) { |
| 646 | Out << 't' << TTP->getDepth() << '.' << TTP->getIndex(); |
| 647 | return; |
| 648 | } |
| 649 | if (const TemplateSpecializationType *Spec |
| 650 | = T->getAs<TemplateSpecializationType>()) { |
| 651 | Out << '>'; |
| 652 | VisitTemplateName(Spec->getTemplateName()); |
| 653 | Out << Spec->getNumArgs(); |
| 654 | for (unsigned I = 0, N = Spec->getNumArgs(); I != N; ++I) |
| 655 | VisitTemplateArgument(Spec->getArg(I)); |
| 656 | return; |
| 657 | } |
| 658 | |
Ted Kremenek | 8e67219 | 2010-05-07 01:04:32 +0000 | [diff] [blame] | 659 | // Unhandled type. |
| 660 | Out << ' '; |
| 661 | break; |
| 662 | } while (true); |
| 663 | } |
| 664 | |
Douglas Gregor | fe72e9c | 2010-08-31 17:01:39 +0000 | [diff] [blame] | 665 | void USRGenerator::VisitTemplateParameterList( |
| 666 | const TemplateParameterList *Params) { |
| 667 | if (!Params) |
| 668 | return; |
| 669 | Out << '>' << Params->size(); |
| 670 | for (TemplateParameterList::const_iterator P = Params->begin(), |
| 671 | PEnd = Params->end(); |
| 672 | P != PEnd; ++P) { |
| 673 | Out << '#'; |
| 674 | if (isa<TemplateTypeParmDecl>(*P)) { |
Douglas Gregor | ba73ada | 2011-01-19 20:50:07 +0000 | [diff] [blame] | 675 | if (cast<TemplateTypeParmDecl>(*P)->isParameterPack()) |
| 676 | Out<< 'p'; |
Douglas Gregor | fe72e9c | 2010-08-31 17:01:39 +0000 | [diff] [blame] | 677 | Out << 'T'; |
| 678 | continue; |
| 679 | } |
| 680 | |
| 681 | if (NonTypeTemplateParmDecl *NTTP = dyn_cast<NonTypeTemplateParmDecl>(*P)) { |
Douglas Gregor | ba73ada | 2011-01-19 20:50:07 +0000 | [diff] [blame] | 682 | if (NTTP->isParameterPack()) |
| 683 | Out << 'p'; |
Douglas Gregor | fe72e9c | 2010-08-31 17:01:39 +0000 | [diff] [blame] | 684 | Out << 'N'; |
| 685 | VisitType(NTTP->getType()); |
| 686 | continue; |
| 687 | } |
| 688 | |
| 689 | TemplateTemplateParmDecl *TTP = cast<TemplateTemplateParmDecl>(*P); |
Douglas Gregor | ba73ada | 2011-01-19 20:50:07 +0000 | [diff] [blame] | 690 | if (TTP->isParameterPack()) |
| 691 | Out << 'p'; |
Douglas Gregor | fe72e9c | 2010-08-31 17:01:39 +0000 | [diff] [blame] | 692 | Out << 't'; |
| 693 | VisitTemplateParameterList(TTP->getTemplateParameters()); |
| 694 | } |
| 695 | } |
| 696 | |
| 697 | void USRGenerator::VisitTemplateName(TemplateName Name) { |
| 698 | if (TemplateDecl *Template = Name.getAsTemplateDecl()) { |
| 699 | if (TemplateTemplateParmDecl *TTP |
| 700 | = dyn_cast<TemplateTemplateParmDecl>(Template)) { |
| 701 | Out << 't' << TTP->getDepth() << '.' << TTP->getIndex(); |
| 702 | return; |
| 703 | } |
| 704 | |
| 705 | Visit(Template); |
| 706 | return; |
| 707 | } |
| 708 | |
| 709 | // FIXME: Visit dependent template names. |
| 710 | } |
| 711 | |
| 712 | void USRGenerator::VisitTemplateArgument(const TemplateArgument &Arg) { |
| 713 | switch (Arg.getKind()) { |
| 714 | case TemplateArgument::Null: |
| 715 | break; |
| 716 | |
| 717 | case TemplateArgument::Declaration: |
Douglas Gregor | 9747583 | 2010-10-05 18:37:06 +0000 | [diff] [blame] | 718 | if (Decl *D = Arg.getAsDecl()) |
| 719 | Visit(D); |
Douglas Gregor | fe72e9c | 2010-08-31 17:01:39 +0000 | [diff] [blame] | 720 | break; |
| 721 | |
Douglas Gregor | a7fc901 | 2011-01-05 18:58:31 +0000 | [diff] [blame] | 722 | case TemplateArgument::TemplateExpansion: |
Douglas Gregor | ba73ada | 2011-01-19 20:50:07 +0000 | [diff] [blame] | 723 | Out << 'P'; // pack expansion of... |
| 724 | // Fall through |
| 725 | case TemplateArgument::Template: |
Douglas Gregor | a7fc901 | 2011-01-05 18:58:31 +0000 | [diff] [blame] | 726 | VisitTemplateName(Arg.getAsTemplateOrTemplatePattern()); |
Douglas Gregor | fe72e9c | 2010-08-31 17:01:39 +0000 | [diff] [blame] | 727 | break; |
| 728 | |
| 729 | case TemplateArgument::Expression: |
| 730 | // FIXME: Visit expressions. |
| 731 | break; |
| 732 | |
| 733 | case TemplateArgument::Pack: |
Douglas Gregor | ba73ada | 2011-01-19 20:50:07 +0000 | [diff] [blame] | 734 | Out << 'p' << Arg.pack_size(); |
| 735 | for (TemplateArgument::pack_iterator P = Arg.pack_begin(), PEnd = Arg.pack_end(); |
| 736 | P != PEnd; ++P) |
| 737 | VisitTemplateArgument(*P); |
Douglas Gregor | fe72e9c | 2010-08-31 17:01:39 +0000 | [diff] [blame] | 738 | break; |
| 739 | |
| 740 | case TemplateArgument::Type: |
| 741 | VisitType(Arg.getAsType()); |
| 742 | break; |
| 743 | |
| 744 | case TemplateArgument::Integral: |
| 745 | Out << 'V'; |
| 746 | VisitType(Arg.getIntegralType()); |
| 747 | Out << *Arg.getAsIntegral(); |
| 748 | break; |
| 749 | } |
| 750 | } |
| 751 | |
Ted Kremenek | 896b70f | 2010-03-13 02:50:34 +0000 | [diff] [blame] | 752 | //===----------------------------------------------------------------------===// |
| 753 | // General purpose USR generation methods. |
| 754 | //===----------------------------------------------------------------------===// |
Ted Kremenek | cf84aa4 | 2010-01-18 20:23:29 +0000 | [diff] [blame] | 755 | |
Chris Lattner | 5f9e272 | 2011-07-23 10:55:15 +0000 | [diff] [blame] | 756 | void USRGenerator::GenObjCClass(StringRef cls) { |
Ted Kremenek | 896b70f | 2010-03-13 02:50:34 +0000 | [diff] [blame] | 757 | Out << "objc(cs)" << cls; |
| 758 | } |
| 759 | |
Chris Lattner | 5f9e272 | 2011-07-23 10:55:15 +0000 | [diff] [blame] | 760 | void USRGenerator::GenObjCCategory(StringRef cls, StringRef cat) { |
Ted Kremenek | e74ef12 | 2010-04-16 21:31:52 +0000 | [diff] [blame] | 761 | Out << "objc(cy)" << cls << '@' << cat; |
Ted Kremenek | 896b70f | 2010-03-13 02:50:34 +0000 | [diff] [blame] | 762 | } |
| 763 | |
Chris Lattner | 5f9e272 | 2011-07-23 10:55:15 +0000 | [diff] [blame] | 764 | void USRGenerator::GenObjCIvar(StringRef ivar) { |
Ted Kremenek | 3ebd8dc | 2010-05-07 20:07:23 +0000 | [diff] [blame] | 765 | Out << '@' << ivar; |
Ted Kremenek | 896b70f | 2010-03-13 02:50:34 +0000 | [diff] [blame] | 766 | } |
| 767 | |
Chris Lattner | 5f9e272 | 2011-07-23 10:55:15 +0000 | [diff] [blame] | 768 | void USRGenerator::GenObjCMethod(StringRef meth, bool isInstanceMethod) { |
Ted Kremenek | 896b70f | 2010-03-13 02:50:34 +0000 | [diff] [blame] | 769 | Out << (isInstanceMethod ? "(im)" : "(cm)") << meth; |
| 770 | } |
| 771 | |
Chris Lattner | 5f9e272 | 2011-07-23 10:55:15 +0000 | [diff] [blame] | 772 | void USRGenerator::GenObjCProperty(StringRef prop) { |
Ted Kremenek | 896b70f | 2010-03-13 02:50:34 +0000 | [diff] [blame] | 773 | Out << "(py)" << prop; |
| 774 | } |
| 775 | |
Chris Lattner | 5f9e272 | 2011-07-23 10:55:15 +0000 | [diff] [blame] | 776 | void USRGenerator::GenObjCProtocol(StringRef prot) { |
Ted Kremenek | 896b70f | 2010-03-13 02:50:34 +0000 | [diff] [blame] | 777 | Out << "objc(pl)" << prot; |
| 778 | } |
| 779 | |
| 780 | //===----------------------------------------------------------------------===// |
| 781 | // API hooks. |
| 782 | //===----------------------------------------------------------------------===// |
Ted Kremenek | cf84aa4 | 2010-01-18 20:23:29 +0000 | [diff] [blame] | 783 | |
Chris Lattner | 5f9e272 | 2011-07-23 10:55:15 +0000 | [diff] [blame] | 784 | static inline StringRef extractUSRSuffix(StringRef s) { |
Benjamin Kramer | cfb51b6 | 2010-04-08 15:54:07 +0000 | [diff] [blame] | 785 | return s.startswith("c:") ? s.substr(2) : ""; |
| 786 | } |
| 787 | |
Argyrios Kyrtzidis | 4e7064f | 2011-10-17 19:48:19 +0000 | [diff] [blame] | 788 | bool cxcursor::getDeclCursorUSR(const Decl *D, SmallVectorImpl<char> &Buf) { |
Ted Kremenek | e74ef12 | 2010-04-16 21:31:52 +0000 | [diff] [blame] | 789 | // Don't generate USRs for things with invalid locations. |
| 790 | if (!D || D->getLocStart().isInvalid()) |
Argyrios Kyrtzidis | b6a4ac4 | 2011-10-12 07:07:36 +0000 | [diff] [blame] | 791 | return true; |
Ted Kremenek | 896b70f | 2010-03-13 02:50:34 +0000 | [diff] [blame] | 792 | |
Ted Kremenek | 1865cfe | 2010-04-15 21:04:25 +0000 | [diff] [blame] | 793 | // Check if the cursor has 'NoLinkage'. |
Ted Kremenek | e74ef12 | 2010-04-16 21:31:52 +0000 | [diff] [blame] | 794 | if (const NamedDecl *ND = dyn_cast<NamedDecl>(D)) |
Ted Kremenek | 1865cfe | 2010-04-15 21:04:25 +0000 | [diff] [blame] | 795 | switch (ND->getLinkage()) { |
| 796 | case ExternalLinkage: |
| 797 | // Generate USRs for all entities with external linkage. |
| 798 | break; |
| 799 | case NoLinkage: |
Ted Kremenek | cbd66f0 | 2010-05-06 23:38:28 +0000 | [diff] [blame] | 800 | case UniqueExternalLinkage: |
Ted Kremenek | 1865cfe | 2010-04-15 21:04:25 +0000 | [diff] [blame] | 801 | // We allow enums, typedefs, and structs that have no linkage to |
| 802 | // have USRs that are anchored to the file they were defined in |
| 803 | // (e.g., the header). This is a little gross, but in principal |
| 804 | // enums/anonymous structs/etc. defined in a common header file |
| 805 | // are referred to across multiple translation units. |
Ted Kremenek | 6f15395 | 2010-04-15 21:51:13 +0000 | [diff] [blame] | 806 | if (isa<TagDecl>(ND) || isa<TypedefDecl>(ND) || |
Ted Kremenek | cf99910 | 2010-04-29 17:43:29 +0000 | [diff] [blame] | 807 | isa<EnumConstantDecl>(ND) || isa<FieldDecl>(ND) || |
Ted Kremenek | cbd66f0 | 2010-05-06 23:38:28 +0000 | [diff] [blame] | 808 | isa<VarDecl>(ND) || isa<NamespaceDecl>(ND)) |
Ted Kremenek | 1865cfe | 2010-04-15 21:04:25 +0000 | [diff] [blame] | 809 | break; |
| 810 | // Fall-through. |
| 811 | case InternalLinkage: |
Ted Kremenek | cf99910 | 2010-04-29 17:43:29 +0000 | [diff] [blame] | 812 | if (isa<FunctionDecl>(ND)) |
| 813 | break; |
Ted Kremenek | 1865cfe | 2010-04-15 21:04:25 +0000 | [diff] [blame] | 814 | } |
| 815 | |
Ted Kremenek | f019943 | 2010-11-16 08:15:38 +0000 | [diff] [blame] | 816 | { |
Argyrios Kyrtzidis | b6a4ac4 | 2011-10-12 07:07:36 +0000 | [diff] [blame] | 817 | USRGenerator UG(&D->getASTContext(), &Buf); |
Benjamin Kramer | 854625f | 2011-10-28 13:37:11 +0000 | [diff] [blame] | 818 | UG->Visit(const_cast<Decl*>(D)); |
Ted Kremenek | e542f77 | 2010-04-20 23:15:40 +0000 | [diff] [blame] | 819 | |
Argyrios Kyrtzidis | b6a4ac4 | 2011-10-12 07:07:36 +0000 | [diff] [blame] | 820 | if (UG->ignoreResults()) |
| 821 | return true; |
Ted Kremenek | f019943 | 2010-11-16 08:15:38 +0000 | [diff] [blame] | 822 | } |
Argyrios Kyrtzidis | b6a4ac4 | 2011-10-12 07:07:36 +0000 | [diff] [blame] | 823 | |
| 824 | return false; |
Ted Kremenek | 896b70f | 2010-03-13 02:50:34 +0000 | [diff] [blame] | 825 | } |
| 826 | |
Ted Kremenek | c3ef91d | 2010-04-11 22:20:26 +0000 | [diff] [blame] | 827 | extern "C" { |
| 828 | |
| 829 | CXString clang_getCursorUSR(CXCursor C) { |
Ted Kremenek | fa8231d | 2010-04-11 22:20:34 +0000 | [diff] [blame] | 830 | const CXCursorKind &K = clang_getCursorKind(C); |
| 831 | |
Argyrios Kyrtzidis | b6a4ac4 | 2011-10-12 07:07:36 +0000 | [diff] [blame] | 832 | if (clang_isDeclaration(K)) { |
| 833 | Decl *D = cxcursor::getCursorDecl(C); |
Argyrios Kyrtzidis | 16ed0e6 | 2011-12-10 02:36:25 +0000 | [diff] [blame] | 834 | if (!D) |
| 835 | return createCXString(""); |
| 836 | |
Argyrios Kyrtzidis | b6a4ac4 | 2011-10-12 07:07:36 +0000 | [diff] [blame] | 837 | CXTranslationUnit TU = cxcursor::getCursorTU(C); |
| 838 | if (!TU) |
| 839 | return createCXString(""); |
| 840 | |
| 841 | CXStringBuf *buf = cxstring::getCXStringBuf(TU); |
| 842 | if (!buf) |
| 843 | return createCXString(""); |
| 844 | |
| 845 | bool Ignore = cxcursor::getDeclCursorUSR(D, buf->Data); |
| 846 | if (Ignore) { |
| 847 | disposeCXStringBuf(buf); |
| 848 | return createCXString(""); |
| 849 | } |
| 850 | |
| 851 | // Return the C-string, but don't make a copy since it is already in |
| 852 | // the string buffer. |
| 853 | buf->Data.push_back('\0'); |
| 854 | return createCXString(buf); |
| 855 | } |
Ted Kremenek | fa8231d | 2010-04-11 22:20:34 +0000 | [diff] [blame] | 856 | |
| 857 | if (K == CXCursor_MacroDefinition) { |
Ted Kremenek | f019943 | 2010-11-16 08:15:38 +0000 | [diff] [blame] | 858 | CXTranslationUnit TU = cxcursor::getCursorTU(C); |
| 859 | if (!TU) |
| 860 | return createCXString(""); |
| 861 | |
| 862 | CXStringBuf *buf = cxstring::getCXStringBuf(TU); |
| 863 | if (!buf) |
| 864 | return createCXString(""); |
| 865 | |
| 866 | { |
Argyrios Kyrtzidis | b6a4ac4 | 2011-10-12 07:07:36 +0000 | [diff] [blame] | 867 | USRGenerator UG(&cxcursor::getCursorASTUnit(C)->getASTContext(), |
| 868 | &buf->Data); |
Ted Kremenek | f019943 | 2010-11-16 08:15:38 +0000 | [diff] [blame] | 869 | UG << "macro@" |
| 870 | << cxcursor::getCursorMacroDefinition(C)->getName()->getNameStart(); |
| 871 | } |
| 872 | buf->Data.push_back('\0'); |
| 873 | return createCXString(buf); |
Ted Kremenek | fa8231d | 2010-04-11 22:20:34 +0000 | [diff] [blame] | 874 | } |
| 875 | |
Ted Kremenek | c3ef91d | 2010-04-11 22:20:26 +0000 | [diff] [blame] | 876 | return createCXString(""); |
| 877 | } |
| 878 | |
Ted Kremenek | 896b70f | 2010-03-13 02:50:34 +0000 | [diff] [blame] | 879 | CXString clang_constructUSR_ObjCIvar(const char *name, CXString classUSR) { |
Ted Kremenek | 3ebd8dc | 2010-05-07 20:07:23 +0000 | [diff] [blame] | 880 | USRGenerator UG; |
| 881 | UG << extractUSRSuffix(clang_getCString(classUSR)); |
| 882 | UG->GenObjCIvar(name); |
| 883 | return createCXString(UG.str(), true); |
Ted Kremenek | 896b70f | 2010-03-13 02:50:34 +0000 | [diff] [blame] | 884 | } |
| 885 | |
| 886 | CXString clang_constructUSR_ObjCMethod(const char *name, |
| 887 | unsigned isInstanceMethod, |
| 888 | CXString classUSR) { |
Ted Kremenek | 3ebd8dc | 2010-05-07 20:07:23 +0000 | [diff] [blame] | 889 | USRGenerator UG; |
| 890 | UG << extractUSRSuffix(clang_getCString(classUSR)); |
| 891 | UG->GenObjCMethod(name, isInstanceMethod); |
| 892 | return createCXString(UG.str(), true); |
Ted Kremenek | 896b70f | 2010-03-13 02:50:34 +0000 | [diff] [blame] | 893 | } |
| 894 | |
| 895 | CXString clang_constructUSR_ObjCClass(const char *name) { |
Ted Kremenek | 3ebd8dc | 2010-05-07 20:07:23 +0000 | [diff] [blame] | 896 | USRGenerator UG; |
| 897 | UG->GenObjCClass(name); |
| 898 | return createCXString(UG.str(), true); |
Ted Kremenek | 896b70f | 2010-03-13 02:50:34 +0000 | [diff] [blame] | 899 | } |
| 900 | |
| 901 | CXString clang_constructUSR_ObjCProtocol(const char *name) { |
Ted Kremenek | 3ebd8dc | 2010-05-07 20:07:23 +0000 | [diff] [blame] | 902 | USRGenerator UG; |
| 903 | UG->GenObjCProtocol(name); |
| 904 | return createCXString(UG.str(), true); |
Ted Kremenek | 896b70f | 2010-03-13 02:50:34 +0000 | [diff] [blame] | 905 | } |
| 906 | |
Ted Kremenek | 66ccaec | 2010-03-15 17:38:58 +0000 | [diff] [blame] | 907 | CXString clang_constructUSR_ObjCCategory(const char *class_name, |
Ted Kremenek | 0c0fb41 | 2010-03-25 02:00:36 +0000 | [diff] [blame] | 908 | const char *category_name) { |
Ted Kremenek | 3ebd8dc | 2010-05-07 20:07:23 +0000 | [diff] [blame] | 909 | USRGenerator UG; |
| 910 | UG->GenObjCCategory(class_name, category_name); |
| 911 | return createCXString(UG.str(), true); |
Ted Kremenek | 896b70f | 2010-03-13 02:50:34 +0000 | [diff] [blame] | 912 | } |
| 913 | |
| 914 | CXString clang_constructUSR_ObjCProperty(const char *property, |
| 915 | CXString classUSR) { |
Ted Kremenek | 3ebd8dc | 2010-05-07 20:07:23 +0000 | [diff] [blame] | 916 | USRGenerator UG; |
| 917 | UG << extractUSRSuffix(clang_getCString(classUSR)); |
| 918 | UG->GenObjCProperty(property); |
| 919 | return createCXString(UG.str(), true); |
Ted Kremenek | cf84aa4 | 2010-01-18 20:23:29 +0000 | [diff] [blame] | 920 | } |
Ted Kremenek | 1b6869a | 2010-01-05 22:06:45 +0000 | [diff] [blame] | 921 | |
Ted Kremenek | 1b6869a | 2010-01-05 22:06:45 +0000 | [diff] [blame] | 922 | } // end extern "C" |