reference, declarationdefinition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced

Declarations

tools/clang/include/clang/CrossTU/CrossTranslationUnit.h
   29 class ASTUnit;
tools/clang/include/clang/Index/IndexingAction.h
   24   class ASTUnit;
tools/clang/lib/StaticAnalyzer/Frontend/ModelInjector.h
   32 class ASTUnit;
tools/clang/tools/extra/clang-query/QuerySession.h
   18 class ASTUnit;
tools/clang/tools/libclang/CIndexer.h
   27 class ASTUnit;
tools/clang/tools/libclang/CXCursor.h
   24 class ASTUnit;
tools/clang/tools/libclang/CXTranslationUnit.h
   21   class ASTUnit;
tools/clang/tools/libclang/CXType.h
   21 class ASTUnit;
tools/clang/tools/libclang/CursorVisitor.h
   20   class ASTUnit;
tools/clang/unittests/AST/ASTImporterFixtures.h
   34 class ASTUnit;

References

include/llvm/Support/BuryPointer.h
   23 template <typename T> void BuryPointer(std::unique_ptr<T> Ptr) {
include/llvm/Support/CrashRecoveryContext.h
  147   T *resource;
  148   CrashRecoveryContextCleanupBase(CrashRecoveryContext *context, T *resource)
  156   static Derived *create(T *x) {
  183   CrashRecoveryContextCleanupBase<CrashRecoveryContextDeleteCleanup<T>, T> {
  183   CrashRecoveryContextCleanupBase<CrashRecoveryContextDeleteCleanup<T>, T> {
  185   CrashRecoveryContextDeleteCleanup(CrashRecoveryContext *context, T *resource)
  241   CrashRecoveryContextCleanupRegistrar(T *x)
include/llvm/Support/PointerLikeTypeTraits.h
   56   static inline void *getAsVoidPointer(T *P) { return P; }
   57   static inline T *getFromVoidPointer(void *P) { return static_cast<T *>(P); }
   59   enum { NumLowBitsAvailable = detail::ConstantLog2<alignof(T)>::value };
   91   typedef PointerLikeTypeTraits<T *> NonConst;
   93   static inline const void *getAsVoidPointer(const T *P) {
   96   static inline const T *getFromVoidPointer(const void *P) {
tools/clang/include/clang/CrossTU/CrossTranslationUnit.h
  147   llvm::Expected<ASTUnit *> loadExternalAST(StringRef LookupName,
  158                                                         ASTUnit *Unit);
  160                                                    ASTUnit *Unit);
  176   llvm::Optional<std::pair<SourceLocation /*FromLoc*/, ASTUnit *>>
  181       llvm::DenseMap<FileID, std::pair<FileID, ASTUnit *>>;
  184   ASTImporter &getOrCreateASTImporter(ASTUnit *Unit);
  194   llvm::Expected<const T *> importDefinitionImpl(const T *D, ASTUnit *Unit);
  216     std::unique_ptr<ASTUnit> operator()(StringRef ASTFilePath);
  257     llvm::Expected<ASTUnit *> getASTUnitForFunction(StringRef FunctionName,
  277     llvm::Expected<ASTUnit *> getASTUnitForFile(StringRef FileName,
  281     using OwningMapTy = BaseMapTy<std::unique_ptr<clang::ASTUnit>>;
  282     using NonOwningMapTy = BaseMapTy<clang::ASTUnit *>;
tools/clang/include/clang/Frontend/ASTUnit.h
  256                              ASTUnit &AST, CaptureDiagsKind CaptureDiagnostics);
  408     ASTUnit &Self;
  411     explicit ConcurrencyCheck(ASTUnit &Self) : Self(Self) {
  420   ASTUnit(const ASTUnit &) = delete;
  421   ASTUnit &operator=(const ASTUnit &) = delete;
  421   ASTUnit &operator=(const ASTUnit &) = delete;
  665   static std::unique_ptr<ASTUnit>
  691   static std::unique_ptr<ASTUnit> LoadFromASTFile(
  749   static ASTUnit *LoadFromCompilerInvocationAction(
  753       FrontendAction *Action = nullptr, ASTUnit *Unit = nullptr,
  761       std::unique_ptr<ASTUnit> *ErrAST = nullptr);
  777   static std::unique_ptr<ASTUnit> LoadFromCompilerInvocation(
  818   static ASTUnit *LoadFromCommandLine(
  837       std::unique_ptr<ASTUnit> *ErrAST = nullptr,
tools/clang/include/clang/Frontend/FrontendAction.h
   38   std::unique_ptr<ASTUnit> CurrentASTUnit;
  156   ASTUnit &getCurrentASTUnit() const {
  163   std::unique_ptr<ASTUnit> takeCurrentASTUnit() {
  168                        std::unique_ptr<ASTUnit> AST = nullptr);
tools/clang/include/clang/Index/IndexingAction.h
   55 void indexASTUnit(ASTUnit &Unit, IndexDataConsumer &DataConsumer,
tools/clang/include/clang/Tooling/Tooling.h
  204 std::unique_ptr<ASTUnit>
  222 std::unique_ptr<ASTUnit> buildASTFromCodeWithArgs(
  357   int buildASTs(std::vector<std::unique_ptr<ASTUnit>> &ASTs);
tools/clang/lib/ARCMigrate/ARCMT.cpp
  270   std::unique_ptr<ASTUnit> Unit(ASTUnit::LoadFromCompilerInvocationAction(
  270   std::unique_ptr<ASTUnit> Unit(ASTUnit::LoadFromCompilerInvocationAction(
  546   std::unique_ptr<ASTUnit> Unit(ASTUnit::LoadFromCompilerInvocationAction(
  546   std::unique_ptr<ASTUnit> Unit(ASTUnit::LoadFromCompilerInvocationAction(
tools/clang/lib/CrossTU/CrossTranslationUnit.cpp
  241   llvm::Expected<ASTUnit *> ASTUnitOrError =
  245   ASTUnit *Unit = *ASTUnitOrError;
  348 std::unique_ptr<ASTUnit>
  358   return ASTUnit::LoadFromASTFile(
  360       ASTUnit::LoadEverything, Diags, CI.getFileSystemOpts());
  369 llvm::Expected<ASTUnit *>
  384     std::unique_ptr<ASTUnit> LoadedUnit = FileAccessor(FileName);
  387     ASTUnit *Unit = LoadedUnit.get();
  405 llvm::Expected<ASTUnit *>
  427     if (llvm::Expected<ASTUnit *> FoundForFile =
  474 llvm::Expected<ASTUnit *> CrossTranslationUnitContext::loadExternalAST(
  483   llvm::Expected<ASTUnit *> Unit = ASTStorage.getASTUnitForFunction(
  499 CrossTranslationUnitContext::importDefinitionImpl(const T *D, ASTUnit *Unit) {
  533                                               ASTUnit *Unit) {
  539                                               ASTUnit *Unit) {
  550 CrossTranslationUnitContext::getOrCreateASTImporter(ASTUnit *Unit) {
  569 llvm::Optional<std::pair<SourceLocation, ASTUnit *>>
  580   clang::ASTUnit *Unit = I->second.second;
tools/clang/lib/Frontend/ASTMerge.cpp
   49     std::unique_ptr<ASTUnit> Unit = ASTUnit::LoadFromASTFile(
   49     std::unique_ptr<ASTUnit> Unit = ASTUnit::LoadFromASTFile(
   50         ASTFiles[I], CI.getPCHContainerReader(), ASTUnit::LoadEverything, Diags,
tools/clang/lib/Frontend/ASTUnit.cpp
  614   SmallVectorImpl<ASTUnit::StandaloneDiagnostic> *StandaloneDiags;
  622       SmallVectorImpl<ASTUnit::StandaloneDiagnostic> *StandaloneDiags,
  653       SmallVectorImpl<ASTUnit::StandaloneDiagnostic> *StandaloneDiags)
  674 static ASTUnit::StandaloneDiagnostic
  747                              ASTUnit &AST,
  756 std::unique_ptr<ASTUnit> ASTUnit::LoadFromASTFile(
  763   std::unique_ptr<ASTUnit> AST(new ASTUnit(true));
  763   std::unique_ptr<ASTUnit> AST(new ASTUnit(true));
  766   llvm::CrashRecoveryContextCleanupRegistrar<ASTUnit>
  939   ASTUnit &Unit;
  943   TopLevelDeclTrackerConsumer(ASTUnit &_Unit, unsigned &Hash)
  998   ASTUnit &Unit;
 1010   TopLevelDeclTrackerAction(ASTUnit &_Unit) : Unit(_Unit) {}
 1060   llvm::SmallVector<ASTUnit::StandaloneDiagnostic, 4> PreambleDiags;
 1245 static ASTUnit::StandaloneFixIt makeStandaloneFixIt(const SourceManager &SM,
 1248   ASTUnit::StandaloneFixIt OutFix;
 1257 static ASTUnit::StandaloneDiagnostic
 1260   ASTUnit::StandaloneDiagnostic OutDiag;
 1491 std::unique_ptr<ASTUnit>
 1496   std::unique_ptr<ASTUnit> AST(new ASTUnit(false));
 1496   std::unique_ptr<ASTUnit> AST(new ASTUnit(false));
 1512 ASTUnit *ASTUnit::LoadFromCompilerInvocationAction(
 1516     ASTUnit *Unit, bool Persistent, StringRef ResourceFilesPath,
 1520     std::unique_ptr<ASTUnit> *ErrAST) {
 1523   std::unique_ptr<ASTUnit> OwnAST;
 1524   ASTUnit *AST = Unit;
 1547   llvm::CrashRecoveryContextCleanupRegistrar<ASTUnit>
 1692 std::unique_ptr<ASTUnit> ASTUnit::LoadFromCompilerInvocation(
 1701   std::unique_ptr<ASTUnit> AST(new ASTUnit(false));
 1701   std::unique_ptr<ASTUnit> AST(new ASTUnit(false));
 1716   llvm::CrashRecoveryContextCleanupRegistrar<ASTUnit>
 1729 ASTUnit *ASTUnit::LoadFromCommandLine(
 1740     llvm::Optional<StringRef> ModuleFormat, std::unique_ptr<ASTUnit> *ErrAST,
 1779   std::unique_ptr<ASTUnit> AST;
 1780   AST.reset(new ASTUnit(false));
 1807   llvm::CrashRecoveryContextCleanupRegistrar<ASTUnit>
 1907     ASTUnit &AST;
 1911     AugmentedCodeCompleteConsumer(ASTUnit &AST, CodeCompleteConsumer &Next,
 2059   for (ASTUnit::cached_completion_iterator
 2622   for (ASTUnit::top_level_iterator TL = top_level_begin(),
tools/clang/lib/Frontend/FrontendAction.cpp
  137                                      std::unique_ptr<ASTUnit> AST) {
  565     std::unique_ptr<ASTUnit> AST = ASTUnit::LoadFromASTFile(
  565     std::unique_ptr<ASTUnit> AST = ASTUnit::LoadFromASTFile(
  566         InputFile, CI.getPCHContainerReader(), ASTUnit::LoadPreprocessorOnly,
  631     std::unique_ptr<ASTUnit> AST = ASTUnit::LoadFromASTFile(
  631     std::unique_ptr<ASTUnit> AST = ASTUnit::LoadFromASTFile(
  632         InputFile, CI.getPCHContainerReader(), ASTUnit::LoadEverything, Diags,
tools/clang/lib/Index/IndexingAction.cpp
  146 static void indexTranslationUnit(ASTUnit &Unit, IndexingContext &IndexCtx) {
  160 void index::indexASTUnit(ASTUnit &Unit, IndexDataConsumer &DataConsumer,
tools/clang/lib/Tooling/Tooling.cpp
  571   std::vector<std::unique_ptr<ASTUnit>> &ASTs;
  574   ASTBuilderAction(std::vector<std::unique_ptr<ASTUnit>> &ASTs) : ASTs(ASTs) {}
  580     std::unique_ptr<ASTUnit> AST = ASTUnit::LoadFromCompilerInvocation(
  580     std::unique_ptr<ASTUnit> AST = ASTUnit::LoadFromCompilerInvocation(
  596 int ClangTool::buildASTs(std::vector<std::unique_ptr<ASTUnit>> &ASTs) {
  612 std::unique_ptr<ASTUnit>
  619 std::unique_ptr<ASTUnit> buildASTFromCodeWithArgs(
  623   std::vector<std::unique_ptr<ASTUnit>> ASTs;
tools/clang/tools/c-index-test/core_main.cpp
  228   std::unique_ptr<ASTUnit> Unit(ASTUnit::LoadFromCompilerInvocationAction(
  228   std::unique_ptr<ASTUnit> Unit(ASTUnit::LoadFromCompilerInvocationAction(
  262   std::unique_ptr<ASTUnit> AU = ASTUnit::LoadFromASTFile(
  262   std::unique_ptr<ASTUnit> AU = ASTUnit::LoadFromASTFile(
  263       modulePath, *pchRdr, ASTUnit::LoadASTOnly, Diags,
tools/clang/tools/clang-diff/ClangDiff.cpp
   86 static std::unique_ptr<ASTUnit>
  107   std::vector<std::unique_ptr<ASTUnit>> ASTs;
  462     std::unique_ptr<ASTUnit> AST = getAST(CommonCompilations, SourcePath);
  483   std::unique_ptr<ASTUnit> Src = getAST(CommonCompilations, SourcePath);
  484   std::unique_ptr<ASTUnit> Dst = getAST(CommonCompilations, DestinationPath);
tools/clang/tools/extra/clang-query/QuerySession.h
   25   QuerySession(llvm::ArrayRef<std::unique_ptr<ASTUnit>> ASTs)
   30   llvm::ArrayRef<std::unique_ptr<ASTUnit>> ASTs;
tools/clang/tools/extra/clang-query/tool/ClangQuery.cpp
  101   std::vector<std::unique_ptr<ASTUnit>> ASTs;
tools/clang/tools/extra/unittests/clang-query/QueryEngineTest.cpp
   28   ArrayRef<std::unique_ptr<ASTUnit>> mkASTUnit2(std::unique_ptr<ASTUnit> a,
   28   ArrayRef<std::unique_ptr<ASTUnit>> mkASTUnit2(std::unique_ptr<ASTUnit> a,
   29                                                 std::unique_ptr<ASTUnit> b) {
   43   std::unique_ptr<ASTUnit> ASTs[2];
tools/clang/tools/libclang/CIndex.cpp
   72                                               std::unique_ptr<ASTUnit> AU) {
   88 bool cxtu::isASTReadError(ASTUnit *AU) {
   89   for (ASTUnit::stored_diag_iterator D = AU->stored_diag_begin(),
  256   ASTUnit *Unit = cxtu::getASTUnit(TU);
  305   ASTUnit *Unit = cxtu::getASTUnit(TU);
  522     ASTUnit *CXXUnit = cxtu::getASTUnit(TU);
  529           for (ASTUnit::top_level_iterator TL = CXXUnit->top_level_begin(),
 3370   std::unique_ptr<ASTUnit> AU = ASTUnit::LoadFromASTFile(
 3370   std::unique_ptr<ASTUnit> AU = ASTUnit::LoadFromASTFile(
 3372       ASTUnit::LoadEverything, Diags,
 3459   std::unique_ptr<std::vector<ASTUnit::RemappedFile>> RemappedFiles(
 3460       new std::vector<ASTUnit::RemappedFile>());
 3464     std::vector<ASTUnit::RemappedFile> > RemappedCleanup(RemappedFiles.get());
 3516   std::unique_ptr<ASTUnit> ErrUnit;
 3527   std::unique_ptr<ASTUnit> Unit(ASTUnit::LoadFromCommandLine(
 3527   std::unique_ptr<ASTUnit> Unit(ASTUnit::LoadFromCommandLine(
 3673   ASTUnit *ASTU = getCursorASTUnit(C);
 3685   ASTUnit *ASTU = getCursorASTUnit(C);
 4014   ASTUnit *CXXUnit = cxtu::getASTUnit(TU);
 4015   ASTUnit::ConcurrencyCheck Check(*CXXUnit);
 4057     ASTUnit *Unit = cxtu::getASTUnit(CTUnit);
 4072     ASTUnit *Unit = cxtu::getASTUnit(CTUnit);
 4106   ASTUnit *CXXUnit = cxtu::getASTUnit(TU);
 4107   ASTUnit::ConcurrencyCheck Check(*CXXUnit);
 4109   std::unique_ptr<std::vector<ASTUnit::RemappedFile>> RemappedFiles(
 4110       new std::vector<ASTUnit::RemappedFile>());
 4114     std::vector<ASTUnit::RemappedFile> > RemappedCleanup(RemappedFiles.get());
 4166   ASTUnit *CXXUnit = cxtu::getASTUnit(CTUnit);
 4176   ASTUnit *CXXUnit = cxtu::getASTUnit(TU);
 4199   ASTUnit *CXXUnit = cxtu::getASTUnit(CTUnit);
 4213   ASTUnit *CXXUnit = cxtu::getASTUnit(CTUnit);
 4250   ASTUnit *CXXUnit = cxtu::getASTUnit(TU);
 4290   ASTUnit *CXXUnit = cxtu::getASTUnit(TU);
 5665   ASTUnit *CXXUnit = cxtu::getASTUnit(TU);
 5666   ASTUnit::ConcurrencyCheck Check(*CXXUnit);
 5954   ASTUnit *CXXUnit = cxtu::getASTUnit(TU);
 6029     ASTUnit *TU = getCursorASTUnit(C);
 6035     ASTUnit *TU = getCursorASTUnit(C);
 6041     ASTUnit *TU = getCursorASTUnit(C);
 6047     ASTUnit *TU = getCursorASTUnit(C);
 6657   ASTUnit *CXXUnit = cxtu::getASTUnit(TU);
 6679   ASTUnit *CXXUnit = cxtu::getASTUnit(TU);
 6693   ASTUnit *CXXUnit = cxtu::getASTUnit(TU);
 6701 static void getTokens(ASTUnit *CXXUnit, SourceRange Range,
 6783   ASTUnit *CXXUnit = cxtu::getASTUnit(TU);
 6825   ASTUnit *CXXUnit = cxtu::getASTUnit(TU);
 6829   ASTUnit::ConcurrencyCheck Check(*CXXUnit);
 7441   ASTUnit *CXXUnit = cxtu::getASTUnit(TU);
 7540 static void clang_annotateTokensImpl(CXTranslationUnit TU, ASTUnit *CXXUnit,
 7672   ASTUnit *CXXUnit = cxtu::getASTUnit(TU);
 7676   ASTUnit::ConcurrencyCheck Check(*CXXUnit);
 8283   ASTUnit &Unit = *cxtu::getASTUnit(TU);
 8565   ASTUnit *astUnit = cxtu::getASTUnit(TU);
 8669   ASTUnit *astUnit = cxtu::getASTUnit(TU);
 8708   ASTUnit *astUnit = cxtu::getASTUnit(TU);
 8779 void cxindex::printDiagsToStderr(ASTUnit *Unit) {
 8783   for (ASTUnit::stored_diag_iterator D = Unit->stored_diag_begin(), 
 8808   ASTUnit *Unit = cxtu::getASTUnit(TU);
 8845   ASTUnit *Unit = cxtu::getASTUnit(TU);
 8882   ASTUnit *Unit = cxtu::getASTUnit(TU);
 8900     if (ASTUnit *Unit = cxtu::getASTUnit(TU)) {
tools/clang/tools/libclang/CIndexCodeCompletion.cpp
  712   ASTUnit *AST = cxtu::getASTUnit(TU);
  720   ASTUnit::ConcurrencyCheck Check(*AST);
  723   SmallVector<ASTUnit::RemappedFile, 4> RemappedFiles;
tools/clang/tools/libclang/CIndexDiagnostic.cpp
  153   ASTUnit *AU = cxtu::getASTUnit(TU);
  190     for (ASTUnit::stored_diag_iterator it = AU->stored_diag_begin(),
tools/clang/tools/libclang/CIndexHigh.cpp
  245   ASTUnit &Unit;
  250   FindFileMacroRefVisitData(ASTUnit &Unit, const FileEntry *File,
  313   ASTUnit *Unit = cxtu::getASTUnit(TU);
  339   ASTUnit &Unit;
  343   FindFileIncludesVisitor(ASTUnit &Unit, const FileEntry *File,
  385   ASTUnit *Unit = cxtu::getASTUnit(TU);
  437   ASTUnit *CXXUnit = cxcursor::getCursorASTUnit(cursor);
  441   ASTUnit::ConcurrencyCheck Check(*CXXUnit);
  500   ASTUnit *CXXUnit = cxtu::getASTUnit(TU);
  504   ASTUnit::ConcurrencyCheck Check(*CXXUnit);
tools/clang/tools/libclang/CIndexInclusionStack.cpp
   25   ASTUnit *CXXUnit = cxtu::getASTUnit(TU);
tools/clang/tools/libclang/CIndexer.h
  126     void printDiagsToStderr(ASTUnit *Unit);
tools/clang/tools/libclang/CXCursor.cpp
  895   ASTUnit *TU = getCursorASTUnit(C);
 1039 ASTUnit *cxcursor::getCursorASTUnit(CXCursor Cursor) {
 1432       ASTUnit *unit = getCursorASTUnit(cursor);
 1446     ASTUnit *unit = getCursorASTUnit(cursor);
tools/clang/tools/libclang/CXCursor.h
  246 ASTUnit *getCursorASTUnit(CXCursor Cursor);
tools/clang/tools/libclang/CXSourceLocation.cpp
  128   ASTUnit *CXXUnit = cxtu::getASTUnit(TU);
  129   ASTUnit::ConcurrencyCheck Check(*CXXUnit);
  159   ASTUnit *CXXUnit = cxtu::getASTUnit(TU);
tools/clang/tools/libclang/CXTranslationUnit.h
   30   clang::ASTUnit *TheASTUnit;
   47                                              std::unique_ptr<ASTUnit> AU);
   49 static inline ASTUnit *getASTUnit(CXTranslationUnit TU) {
   57 bool isASTReadError(ASTUnit *AU);
tools/clang/tools/libclang/CursorVisitor.h
   65   ASTUnit *AU;
  174   ASTUnit *getASTUnit() const { return AU; }
tools/clang/tools/libclang/Indexing.cpp
  553   auto Unit = ASTUnit::create(CInvok, Diags, CaptureDiagnostics,
  558   auto *UPtr = Unit.get();
  615   bool Success = ASTUnit::LoadFromCompilerInvocationAction(
  641 static void indexPreprocessingRecord(ASTUnit &Unit, CXIndexDataConsumer &IdxCtx) {
  689   ASTUnit *Unit = cxtu::getASTUnit(TU);
  693   ASTUnit::ConcurrencyCheck Check(*Unit);
tools/clang/unittests/AST/ASTImporterFixtures.cpp
   24 void createVirtualFileIfNeeded(ASTUnit *ToAST, StringRef FileName,
   35 void createVirtualFileIfNeeded(ASTUnit *ToAST, StringRef FileName,
   66     ASTUnit *ToAST) {
   79     const std::shared_ptr<ASTImporterSharedState> &SharedState, ASTUnit *ToAST,
   91     const std::shared_ptr<ASTImporterSharedState> &SharedState, ASTUnit *ToAST,
   98     const std::shared_ptr<ASTImporterSharedState> &SharedState, ASTUnit *ToAST,
tools/clang/unittests/AST/ASTImporterFixtures.h
   43 void createVirtualFileIfNeeded(ASTUnit *ToAST, StringRef FileName,
   46 void createVirtualFileIfNeeded(ASTUnit *ToAST, StringRef FileName,
  105     std::unique_ptr<ASTUnit> Unit;
  119                      ASTUnit *ToAST);
  121                  ASTUnit *ToAST, Decl *FromDecl);
  124                   ASTUnit *ToAST, Decl *FromDecl);
  126                     ASTUnit *ToAST, QualType FromType);
  148   std::unique_ptr<ASTUnit> ToAST;
tools/clang/unittests/AST/ASTImporterTest.cpp
   32   llvm::Expected<NodeType> importNode(ASTUnit *From, ASTUnit *To,
   32   llvm::Expected<NodeType> importNode(ASTUnit *From, ASTUnit *To,
   70     std::unique_ptr<ASTUnit> FromAST = tooling::buildASTFromCodeWithArgs(
  157   using SingleASTUnit = std::unique_ptr<ASTUnit>;
  195     using ImporterKey = std::pair<const ASTUnit *, const ASTUnit *>;
  195     using ImporterKey = std::pair<const ASTUnit *, const ASTUnit *>;
  211       ASTUnit *From = AllASTs[FromFile].get();
  212       ASTUnit *To = AllASTs[ToFile].get();
tools/clang/unittests/AST/ASTTraverserTest.cpp
   88 const FunctionDecl *getFunctionNode(clang::ASTUnit *AST,
tools/clang/unittests/AST/StructuralEquivalenceTest.cpp
   18   std::unique_ptr<ASTUnit> AST0, AST1;
tools/clang/unittests/ASTMatchers/ASTMatchersInternalTest.cpp
  134   std::unique_ptr<ASTUnit> AST(tooling::buildASTFromCode("int x;"));
  160   std::unique_ptr<ASTUnit> AST(tooling::buildASTFromCode("int x;"));
  167   std::unique_ptr<ASTUnit> AST =
tools/clang/unittests/ASTMatchers/ASTMatchersTest.h
  345   std::unique_ptr<ASTUnit> AST(buildASTFromCodeWithArgs(Code, Args));
tools/clang/unittests/Analysis/ExprMutationAnalyzerTest.cpp
   32 std::unique_ptr<ASTUnit>
   42 std::unique_ptr<ASTUnit> buildASTFromCode(const Twine &Code) {
   54 bool isMutated(const SmallVectorImpl<BoundNodes> &Results, ASTUnit *AST) {
tools/clang/unittests/CrossTU/CrossTranslationUnitTest.cpp
   73     std::unique_ptr<ASTUnit> ASTWithDefinition =
   89         llvm::Optional<std::pair<SourceLocation, ASTUnit *>> SLocResult =
   94           ASTUnit *OrigUnit = (*SLocResult).second;
tools/clang/unittests/Frontend/ASTUnitTest.cpp
   34   std::unique_ptr<ASTUnit> createASTUnit(bool isVolatile) {
   53     return ASTUnit::LoadFromCompilerInvocation(
   74   std::unique_ptr<ASTUnit> AST = createASTUnit(false);
   89   std::unique_ptr<ASTUnit> AU = ASTUnit::LoadFromASTFile(
   89   std::unique_ptr<ASTUnit> AU = ASTUnit::LoadFromASTFile(
   91       ASTUnit::LoadEverything, Diags, FileSystemOptions(),
  101   std::unique_ptr<ASTUnit> AST = createASTUnit(true);
tools/clang/unittests/Frontend/PCHPreambleTest.cpp
   79   std::unique_ptr<ASTUnit> ParseAST(const std::string &EntryFile) {
   98     std::unique_ptr<ASTUnit> AST = ASTUnit::LoadFromCompilerInvocation(
   98     std::unique_ptr<ASTUnit> AST = ASTUnit::LoadFromCompilerInvocation(
  104   bool ReparseAST(const std::unique_ptr<ASTUnit> &AST) {
  137   std::unique_ptr<ASTUnit> AST(ParseAST(MainName));
  157   std::unique_ptr<ASTUnit> AST(ParseAST(MainName));
  180   std::unique_ptr<ASTUnit> AST(ParseAST(MainName));
  204   std::unique_ptr<ASTUnit> AST(ParseAST(MainName));
  230   std::unique_ptr<ASTUnit> AST(ParseAST(Main));
tools/clang/unittests/Rewrite/RewriterTest.cpp
   18   std::unique_ptr<ASTUnit> AST;
tools/clang/unittests/Tooling/RangeSelectorTest.cpp
   37   std::unique_ptr<clang::ASTUnit> ASTUnit;
tools/clang/unittests/Tooling/SourceCodeBuildersTest.cpp
   42   std::unique_ptr<ASTUnit> AstUnit;
tools/clang/unittests/Tooling/StencilTest.cpp
   46   std::unique_ptr<ASTUnit> AstUnit;
tools/clang/unittests/Tooling/ToolingTest.cpp
   89 bool FindClassDeclX(ASTUnit *AST) {
  120   std::unique_ptr<ASTUnit> AST = buildASTFromCode("class X;");
  602   std::vector<std::unique_ptr<ASTUnit>> ASTs;
  634   std::vector<std::unique_ptr<ASTUnit>> ASTs;
usr/include/c++/7.4.0/bits/move.h
   72     constexpr _Tp&&
   83     constexpr _Tp&&
usr/include/c++/7.4.0/bits/unique_ptr.h
   68         default_delete(const default_delete<_Up>&) noexcept { }
   72       operator()(_Tp* __ptr) const
   74 	static_assert(!is_void<_Tp>::value,
   76 	static_assert(sizeof(_Tp)>0,
  122 	  using type = _Up*;
  137       using pointer = typename _Ptr<_Tp, _Dp>::type;
  161 	typename __uniq_ptr_impl<_Tp, _Up>::_DeleterConstraint::type;
  163       __uniq_ptr_impl<_Tp, _Dp> _M_t;
  166       using pointer	  = typename __uniq_ptr_impl<_Tp, _Dp>::pointer;
  167       using element_type  = _Tp;
  252 	unique_ptr(unique_ptr<_Up, _Ep>&& __u) noexcept
  297           __safe_conversion_up<_Up, _Ep>,
  301 	operator=(unique_ptr<_Up, _Ep>&& __u) noexcept
  689     operator==(const unique_ptr<_Tp, _Dp>& __x, nullptr_t) noexcept
  706     operator!=(const unique_ptr<_Tp, _Dp>& __x, nullptr_t) noexcept
  824     make_unique(_Args&&... __args)
usr/include/c++/7.4.0/type_traits
  215     : public __is_void_helper<typename remove_cv<_Tp>::type>::type
  581     : public __or_<is_lvalue_reference<_Tp>,
  582                    is_rvalue_reference<_Tp>>::type
  601     : public __not_<__or_<is_function<_Tp>, is_reference<_Tp>,
  601     : public __not_<__or_<is_function<_Tp>, is_reference<_Tp>,
  602                           is_void<_Tp>>>::type
  638     : public __or_<is_object<_Tp>, is_reference<_Tp>>::type
  638     : public __or_<is_object<_Tp>, is_reference<_Tp>>::type
 1554     { typedef _Tp     type; };
 1563     { typedef _Tp     type; };
 1574       remove_const<typename remove_volatile<_Tp>::type>::type     type;
 1633     { typedef _Tp   type; };
 1645     { typedef _Tp&   type; };
 1650     : public __add_lvalue_reference_helper<_Tp>