Coverage Report

Created: 2019-07-24 05:18

/Users/buildslave/jenkins/workspace/clang-stage2-coverage-R/llvm/tools/clang/lib/AST/ASTImporter.cpp
Line
Count
Source (jump to first uncovered line)
1
//===- ASTImporter.cpp - Importing ASTs from other Contexts ---------------===//
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
//  This file defines the ASTImporter class which imports AST nodes from one
10
//  context into another context.
11
//
12
//===----------------------------------------------------------------------===//
13
14
#include "clang/AST/ASTImporter.h"
15
#include "clang/AST/ASTImporterSharedState.h"
16
#include "clang/AST/ASTContext.h"
17
#include "clang/AST/ASTDiagnostic.h"
18
#include "clang/AST/ASTStructuralEquivalence.h"
19
#include "clang/AST/Attr.h"
20
#include "clang/AST/Decl.h"
21
#include "clang/AST/DeclAccessPair.h"
22
#include "clang/AST/DeclBase.h"
23
#include "clang/AST/DeclCXX.h"
24
#include "clang/AST/DeclFriend.h"
25
#include "clang/AST/DeclGroup.h"
26
#include "clang/AST/DeclObjC.h"
27
#include "clang/AST/DeclTemplate.h"
28
#include "clang/AST/DeclVisitor.h"
29
#include "clang/AST/DeclarationName.h"
30
#include "clang/AST/Expr.h"
31
#include "clang/AST/ExprCXX.h"
32
#include "clang/AST/ExprObjC.h"
33
#include "clang/AST/ExternalASTSource.h"
34
#include "clang/AST/LambdaCapture.h"
35
#include "clang/AST/NestedNameSpecifier.h"
36
#include "clang/AST/OperationKinds.h"
37
#include "clang/AST/Stmt.h"
38
#include "clang/AST/StmtCXX.h"
39
#include "clang/AST/StmtObjC.h"
40
#include "clang/AST/StmtVisitor.h"
41
#include "clang/AST/TemplateBase.h"
42
#include "clang/AST/TemplateName.h"
43
#include "clang/AST/Type.h"
44
#include "clang/AST/TypeLoc.h"
45
#include "clang/AST/TypeVisitor.h"
46
#include "clang/AST/UnresolvedSet.h"
47
#include "clang/Basic/ExceptionSpecificationType.h"
48
#include "clang/Basic/FileManager.h"
49
#include "clang/Basic/IdentifierTable.h"
50
#include "clang/Basic/LLVM.h"
51
#include "clang/Basic/LangOptions.h"
52
#include "clang/Basic/SourceLocation.h"
53
#include "clang/Basic/SourceManager.h"
54
#include "clang/Basic/Specifiers.h"
55
#include "llvm/ADT/APSInt.h"
56
#include "llvm/ADT/ArrayRef.h"
57
#include "llvm/ADT/DenseMap.h"
58
#include "llvm/ADT/None.h"
59
#include "llvm/ADT/Optional.h"
60
#include "llvm/ADT/ScopeExit.h"
61
#include "llvm/ADT/STLExtras.h"
62
#include "llvm/ADT/SmallVector.h"
63
#include "llvm/Support/Casting.h"
64
#include "llvm/Support/ErrorHandling.h"
65
#include "llvm/Support/MemoryBuffer.h"
66
#include <algorithm>
67
#include <cassert>
68
#include <cstddef>
69
#include <memory>
70
#include <type_traits>
71
#include <utility>
72
73
namespace clang {
74
75
  using llvm::make_error;
76
  using llvm::Error;
77
  using llvm::Expected;
78
  using ExpectedType = llvm::Expected<QualType>;
79
  using ExpectedStmt = llvm::Expected<Stmt *>;
80
  using ExpectedExpr = llvm::Expected<Expr *>;
81
  using ExpectedDecl = llvm::Expected<Decl *>;
82
  using ExpectedSLoc = llvm::Expected<SourceLocation>;
83
84
0
  std::string ImportError::toString() const {
85
0
    // FIXME: Improve error texts.
86
0
    switch (Error) {
87
0
    case NameConflict:
88
0
      return "NameConflict";
89
0
    case UnsupportedConstruct:
90
0
      return "UnsupportedConstruct";
91
0
    case Unknown:
92
0
      return "Unknown error";
93
0
    }
94
0
    llvm_unreachable("Invalid error code.");
95
0
    return "Invalid error code.";
96
0
  }
97
98
0
  void ImportError::log(raw_ostream &OS) const {
99
0
    OS << toString();
100
0
  }
101
102
0
  std::error_code ImportError::convertToErrorCode() const {
103
0
    llvm_unreachable("Function not implemented.");
104
0
  }
105
106
  char ImportError::ID;
107
108
  template <class T>
109
  SmallVector<Decl *, 2>
110
3.75k
  getCanonicalForwardRedeclChain(Redeclarable<T>* D) {
111
3.75k
    SmallVector<Decl *, 2> Redecls;
112
4.83k
    for (auto *R : D->getFirstDecl()->redecls()) {
113
4.83k
      if (R != D->getFirstDecl())
114
1.08k
        Redecls.push_back(R);
115
4.83k
    }
116
3.75k
    Redecls.push_back(D->getFirstDecl());
117
3.75k
    std::reverse(Redecls.begin(), Redecls.end());
118
3.75k
    return Redecls;
119
3.75k
  }
llvm::SmallVector<clang::Decl*, 2u> clang::getCanonicalForwardRedeclChain<clang::FunctionDecl>(clang::Redeclarable<clang::FunctionDecl>*)
Line
Count
Source
110
2.63k
  getCanonicalForwardRedeclChain(Redeclarable<T>* D) {
111
2.63k
    SmallVector<Decl *, 2> Redecls;
112
3.49k
    for (auto *R : D->getFirstDecl()->redecls()) {
113
3.49k
      if (R != D->getFirstDecl())
114
867
        Redecls.push_back(R);
115
3.49k
    }
116
2.63k
    Redecls.push_back(D->getFirstDecl());
117
2.63k
    std::reverse(Redecls.begin(), Redecls.end());
118
2.63k
    return Redecls;
119
2.63k
  }
llvm::SmallVector<clang::Decl*, 2u> clang::getCanonicalForwardRedeclChain<clang::VarDecl>(clang::Redeclarable<clang::VarDecl>*)
Line
Count
Source
110
790
  getCanonicalForwardRedeclChain(Redeclarable<T>* D) {
111
790
    SmallVector<Decl *, 2> Redecls;
112
918
    for (auto *R : D->getFirstDecl()->redecls()) {
113
918
      if (R != D->getFirstDecl())
114
128
        Redecls.push_back(R);
115
918
    }
116
790
    Redecls.push_back(D->getFirstDecl());
117
790
    std::reverse(Redecls.begin(), Redecls.end());
118
790
    return Redecls;
119
790
  }
llvm::SmallVector<clang::Decl*, 2u> clang::getCanonicalForwardRedeclChain<clang::TagDecl>(clang::Redeclarable<clang::TagDecl>*)
Line
Count
Source
110
329
  getCanonicalForwardRedeclChain(Redeclarable<T>* D) {
111
329
    SmallVector<Decl *, 2> Redecls;
112
414
    for (auto *R : D->getFirstDecl()->redecls()) {
113
414
      if (R != D->getFirstDecl())
114
85
        Redecls.push_back(R);
115
414
    }
116
329
    Redecls.push_back(D->getFirstDecl());
117
329
    std::reverse(Redecls.begin(), Redecls.end());
118
329
    return Redecls;
119
329
  }
120
121
3.75k
  SmallVector<Decl*, 2> getCanonicalForwardRedeclChain(Decl* D) {
122
3.75k
    if (auto *FD = dyn_cast<FunctionDecl>(D))
123
2.63k
      return getCanonicalForwardRedeclChain<FunctionDecl>(FD);
124
1.11k
    if (auto *VD = dyn_cast<VarDecl>(D))
125
790
      return getCanonicalForwardRedeclChain<VarDecl>(VD);
126
329
    if (auto *TD = dyn_cast<TagDecl>(D))
127
329
      return getCanonicalForwardRedeclChain<TagDecl>(TD);
128
0
    llvm_unreachable("Bad declaration kind");
129
0
  }
130
131
25.3k
  void updateFlags(const Decl *From, Decl *To) {
132
25.3k
    // Check if some flags or attrs are new in 'From' and copy into 'To'.
133
25.3k
    // FIXME: Other flags or attrs?
134
25.3k
    if (From->isUsed(false) && 
!To->isUsed(false)1.19k
)
135
44
      To->setIsUsed();
136
25.3k
  }
137
138
  class ASTNodeImporter : public TypeVisitor<ASTNodeImporter, ExpectedType>,
139
                          public DeclVisitor<ASTNodeImporter, ExpectedDecl>,
140
                          public StmtVisitor<ASTNodeImporter, ExpectedStmt> {
141
    ASTImporter &Importer;
142
143
    // Use this instead of Importer.importInto .
144
    template <typename ImportT>
145
18.4k
    LLVM_NODISCARD Error importInto(ImportT &To, const ImportT &From) {
146
18.4k
      return Importer.importInto(To, From);
147
18.4k
    }
llvm::Error clang::ASTNodeImporter::importInto<clang::SourceLocation>(clang::SourceLocation&, clang::SourceLocation const&)
Line
Count
Source
145
9.18k
    LLVM_NODISCARD Error importInto(ImportT &To, const ImportT &From) {
146
9.18k
      return Importer.importInto(To, From);
147
9.18k
    }
llvm::Error clang::ASTNodeImporter::importInto<clang::DeclarationName>(clang::DeclarationName&, clang::DeclarationName const&)
Line
Count
Source
145
9.20k
    LLVM_NODISCARD Error importInto(ImportT &To, const ImportT &From) {
146
9.20k
      return Importer.importInto(To, From);
147
9.20k
    }
llvm::Error clang::ASTNodeImporter::importInto<clang::QualType>(clang::QualType&, clang::QualType const&)
Line
Count
Source
145
24
    LLVM_NODISCARD Error importInto(ImportT &To, const ImportT &From) {
146
24
      return Importer.importInto(To, From);
147
24
    }
148
149
    // Use this to import pointers of specific type.
150
    template <typename ImportT>
151
2.56k
    LLVM_NODISCARD Error importInto(ImportT *&To, ImportT *From) {
152
2.56k
      auto ToOrErr = Importer.Import(From);
153
2.56k
      if (ToOrErr)
154
2.56k
        To = cast_or_null<ImportT>(*ToOrErr);
155
2.56k
      return ToOrErr.takeError();
156
2.56k
    }
llvm::Error clang::ASTNodeImporter::importInto<clang::FunctionTemplateDecl>(clang::FunctionTemplateDecl*&, clang::FunctionTemplateDecl*)
Line
Count
Source
151
426
    LLVM_NODISCARD Error importInto(ImportT *&To, ImportT *From) {
152
426
      auto ToOrErr = Importer.Import(From);
153
426
      if (ToOrErr)
154
426
        To = cast_or_null<ImportT>(*ToOrErr);
155
426
      return ToOrErr.takeError();
156
426
    }
llvm::Error clang::ASTNodeImporter::importInto<clang::Decl>(clang::Decl*&, clang::Decl*)
Line
Count
Source
151
49
    LLVM_NODISCARD Error importInto(ImportT *&To, ImportT *From) {
152
49
      auto ToOrErr = Importer.Import(From);
153
49
      if (ToOrErr)
154
49
        To = cast_or_null<ImportT>(*ToOrErr);
155
49
      return ToOrErr.takeError();
156
49
    }
llvm::Error clang::ASTNodeImporter::importInto<clang::ClassTemplateDecl>(clang::ClassTemplateDecl*&, clang::ClassTemplateDecl*)
Line
Count
Source
151
739
    LLVM_NODISCARD Error importInto(ImportT *&To, ImportT *From) {
152
739
      auto ToOrErr = Importer.Import(From);
153
739
      if (ToOrErr)
154
739
        To = cast_or_null<ImportT>(*ToOrErr);
155
739
      return ToOrErr.takeError();
156
739
    }
llvm::Error clang::ASTNodeImporter::importInto<clang::NamedDecl>(clang::NamedDecl*&, clang::NamedDecl*)
Line
Count
Source
151
76
    LLVM_NODISCARD Error importInto(ImportT *&To, ImportT *From) {
152
76
      auto ToOrErr = Importer.Import(From);
153
76
      if (ToOrErr)
154
76
        To = cast_or_null<ImportT>(*ToOrErr);
155
76
      return ToOrErr.takeError();
156
76
    }
llvm::Error clang::ASTNodeImporter::importInto<clang::ObjCInterfaceDecl>(clang::ObjCInterfaceDecl*&, clang::ObjCInterfaceDecl*)
Line
Count
Source
151
34
    LLVM_NODISCARD Error importInto(ImportT *&To, ImportT *From) {
152
34
      auto ToOrErr = Importer.Import(From);
153
34
      if (ToOrErr)
154
34
        To = cast_or_null<ImportT>(*ToOrErr);
155
34
      return ToOrErr.takeError();
156
34
    }
llvm::Error clang::ASTNodeImporter::importInto<clang::ObjCCategoryDecl>(clang::ObjCCategoryDecl*&, clang::ObjCCategoryDecl*)
Line
Count
Source
151
6
    LLVM_NODISCARD Error importInto(ImportT *&To, ImportT *From) {
152
6
      auto ToOrErr = Importer.Import(From);
153
6
      if (ToOrErr)
154
6
        To = cast_or_null<ImportT>(*ToOrErr);
155
6
      return ToOrErr.takeError();
156
6
    }
llvm::Error clang::ASTNodeImporter::importInto<clang::ObjCPropertyDecl>(clang::ObjCPropertyDecl*&, clang::ObjCPropertyDecl*)
Line
Count
Source
151
8
    LLVM_NODISCARD Error importInto(ImportT *&To, ImportT *From) {
152
8
      auto ToOrErr = Importer.Import(From);
153
8
      if (ToOrErr)
154
8
        To = cast_or_null<ImportT>(*ToOrErr);
155
8
      return ToOrErr.takeError();
156
8
    }
llvm::Error clang::ASTNodeImporter::importInto<clang::ObjCIvarDecl>(clang::ObjCIvarDecl*&, clang::ObjCIvarDecl*)
Line
Count
Source
151
8
    LLVM_NODISCARD Error importInto(ImportT *&To, ImportT *From) {
152
8
      auto ToOrErr = Importer.Import(From);
153
8
      if (ToOrErr)
154
8
        To = cast_or_null<ImportT>(*ToOrErr);
155
8
      return ToOrErr.takeError();
156
8
    }
llvm::Error clang::ASTNodeImporter::importInto<clang::CXXRecordDecl>(clang::CXXRecordDecl*&, clang::CXXRecordDecl*)
Line
Count
Source
151
686
    LLVM_NODISCARD Error importInto(ImportT *&To, ImportT *From) {
152
686
      auto ToOrErr = Importer.Import(From);
153
686
      if (ToOrErr)
154
686
        To = cast_or_null<ImportT>(*ToOrErr);
155
686
      return ToOrErr.takeError();
156
686
    }
llvm::Error clang::ASTNodeImporter::importInto<clang::VarDecl>(clang::VarDecl*&, clang::VarDecl*)
Line
Count
Source
151
7
    LLVM_NODISCARD Error importInto(ImportT *&To, ImportT *From) {
152
7
      auto ToOrErr = Importer.Import(From);
153
7
      if (ToOrErr)
154
7
        To = cast_or_null<ImportT>(*ToOrErr);
155
7
      return ToOrErr.takeError();
156
7
    }
llvm::Error clang::ASTNodeImporter::importInto<clang::VarTemplateDecl>(clang::VarTemplateDecl*&, clang::VarTemplateDecl*)
Line
Count
Source
151
8
    LLVM_NODISCARD Error importInto(ImportT *&To, ImportT *From) {
152
8
      auto ToOrErr = Importer.Import(From);
153
8
      if (ToOrErr)
154
8
        To = cast_or_null<ImportT>(*ToOrErr);
155
8
      return ToOrErr.takeError();
156
8
    }
llvm::Error clang::ASTNodeImporter::importInto<clang::FunctionDecl>(clang::FunctionDecl*&, clang::FunctionDecl*)
Line
Count
Source
151
516
    LLVM_NODISCARD Error importInto(ImportT *&To, ImportT *From) {
152
516
      auto ToOrErr = Importer.Import(From);
153
516
      if (ToOrErr)
154
516
        To = cast_or_null<ImportT>(*ToOrErr);
155
516
      return ToOrErr.takeError();
156
516
    }
157
158
    // Call the import function of ASTImporter for a baseclass of type `T` and
159
    // cast the return value to `T`.
160
    template <typename T>
161
27.7k
    Expected<T *> import(T *From) {
162
27.7k
      auto ToOrErr = Importer.Import(From);
163
27.7k
      if (!ToOrErr)
164
98
        return ToOrErr.takeError();
165
27.6k
      return cast_or_null<T>(*ToOrErr);
166
27.6k
    }
llvm::Expected<clang::Expr*> clang::ASTNodeImporter::import<clang::Expr>(clang::Expr*)
Line
Count
Source
161
6.94k
    Expected<T *> import(T *From) {
162
6.94k
      auto ToOrErr = Importer.Import(From);
163
6.94k
      if (!ToOrErr)
164
0
        return ToOrErr.takeError();
165
6.94k
      return cast_or_null<T>(*ToOrErr);
166
6.94k
    }
llvm::Expected<clang::ValueDecl*> clang::ASTNodeImporter::import<clang::ValueDecl>(clang::ValueDecl*)
Line
Count
Source
161
588
    Expected<T *> import(T *From) {
162
588
      auto ToOrErr = Importer.Import(From);
163
588
      if (!ToOrErr)
164
0
        return ToOrErr.takeError();
165
588
      return cast_or_null<T>(*ToOrErr);
166
588
    }
llvm::Expected<clang::TypeSourceInfo*> clang::ASTNodeImporter::import<clang::TypeSourceInfo>(clang::TypeSourceInfo*)
Line
Count
Source
161
5.72k
    Expected<T *> import(T *From) {
162
5.72k
      auto ToOrErr = Importer.Import(From);
163
5.72k
      if (!ToOrErr)
164
0
        return ToOrErr.takeError();
165
5.72k
      return cast_or_null<T>(*ToOrErr);
166
5.72k
    }
llvm::Expected<clang::Decl*> clang::ASTNodeImporter::import<clang::Decl>(clang::Decl*)
Line
Count
Source
161
3.63k
    Expected<T *> import(T *From) {
162
3.63k
      auto ToOrErr = Importer.Import(From);
163
3.63k
      if (!ToOrErr)
164
40
        return ToOrErr.takeError();
165
3.59k
      return cast_or_null<T>(*ToOrErr);
166
3.59k
    }
llvm::Expected<clang::VarDecl*> clang::ASTNodeImporter::import<clang::VarDecl>(clang::VarDecl*)
Line
Count
Source
161
273
    Expected<T *> import(T *From) {
162
273
      auto ToOrErr = Importer.Import(From);
163
273
      if (!ToOrErr)
164
0
        return ToOrErr.takeError();
165
273
      return cast_or_null<T>(*ToOrErr);
166
273
    }
llvm::Expected<clang::UnresolvedUsingTypenameDecl*> clang::ASTNodeImporter::import<clang::UnresolvedUsingTypenameDecl>(clang::UnresolvedUsingTypenameDecl*)
Line
Count
Source
161
1
    Expected<T *> import(T *From) {
162
1
      auto ToOrErr = Importer.Import(From);
163
1
      if (!ToOrErr)
164
0
        return ToOrErr.takeError();
165
1
      return cast_or_null<T>(*ToOrErr);
166
1
    }
llvm::Expected<clang::TypedefNameDecl*> clang::ASTNodeImporter::import<clang::TypedefNameDecl>(clang::TypedefNameDecl*)
Line
Count
Source
161
37
    Expected<T *> import(T *From) {
162
37
      auto ToOrErr = Importer.Import(From);
163
37
      if (!ToOrErr)
164
0
        return ToOrErr.takeError();
165
37
      return cast_or_null<T>(*ToOrErr);
166
37
    }
llvm::Expected<clang::CXXRecordDecl*> clang::ASTNodeImporter::import<clang::CXXRecordDecl>(clang::CXXRecordDecl*)
Line
Count
Source
161
63
    Expected<T *> import(T *From) {
162
63
      auto ToOrErr = Importer.Import(From);
163
63
      if (!ToOrErr)
164
0
        return ToOrErr.takeError();
165
63
      return cast_or_null<T>(*ToOrErr);
166
63
    }
llvm::Expected<clang::RecordDecl*> clang::ASTNodeImporter::import<clang::RecordDecl>(clang::RecordDecl*)
Line
Count
Source
161
906
    Expected<T *> import(T *From) {
162
906
      auto ToOrErr = Importer.Import(From);
163
906
      if (!ToOrErr)
164
10
        return ToOrErr.takeError();
165
896
      return cast_or_null<T>(*ToOrErr);
166
896
    }
llvm::Expected<clang::EnumDecl*> clang::ASTNodeImporter::import<clang::EnumDecl>(clang::EnumDecl*)
Line
Count
Source
161
73
    Expected<T *> import(T *From) {
162
73
      auto ToOrErr = Importer.Import(From);
163
73
      if (!ToOrErr)
164
0
        return ToOrErr.takeError();
165
73
      return cast_or_null<T>(*ToOrErr);
166
73
    }
llvm::Expected<clang::TemplateTypeParmDecl*> clang::ASTNodeImporter::import<clang::TemplateTypeParmDecl>(clang::TemplateTypeParmDecl*)
Line
Count
Source
161
255
    Expected<T *> import(T *From) {
162
255
      auto ToOrErr = Importer.Import(From);
163
255
      if (!ToOrErr)
164
0
        return ToOrErr.takeError();
165
255
      return cast_or_null<T>(*ToOrErr);
166
255
    }
llvm::Expected<clang::NestedNameSpecifier*> clang::ASTNodeImporter::import<clang::NestedNameSpecifier>(clang::NestedNameSpecifier*)
Line
Count
Source
161
217
    Expected<T *> import(T *From) {
162
217
      auto ToOrErr = Importer.Import(From);
163
217
      if (!ToOrErr)
164
0
        return ToOrErr.takeError();
165
217
      return cast_or_null<T>(*ToOrErr);
166
217
    }
llvm::Expected<clang::TagDecl*> clang::ASTNodeImporter::import<clang::TagDecl>(clang::TagDecl*)
Line
Count
Source
161
196
    Expected<T *> import(T *From) {
162
196
      auto ToOrErr = Importer.Import(From);
163
196
      if (!ToOrErr)
164
0
        return ToOrErr.takeError();
165
196
      return cast_or_null<T>(*ToOrErr);
166
196
    }
llvm::Expected<clang::ObjCInterfaceDecl*> clang::ASTNodeImporter::import<clang::ObjCInterfaceDecl>(clang::ObjCInterfaceDecl*)
Line
Count
Source
161
13
    Expected<T *> import(T *From) {
162
13
      auto ToOrErr = Importer.Import(From);
163
13
      if (!ToOrErr)
164
0
        return ToOrErr.takeError();
165
13
      return cast_or_null<T>(*ToOrErr);
166
13
    }
llvm::Expected<clang::ObjCProtocolDecl*> clang::ASTNodeImporter::import<clang::ObjCProtocolDecl>(clang::ObjCProtocolDecl*)
Line
Count
Source
161
4
    Expected<T *> import(T *From) {
162
4
      auto ToOrErr = Importer.Import(From);
163
4
      if (!ToOrErr)
164
0
        return ToOrErr.takeError();
165
4
      return cast_or_null<T>(*ToOrErr);
166
4
    }
llvm::Expected<clang::CXXMethodDecl*> clang::ASTNodeImporter::import<clang::CXXMethodDecl>(clang::CXXMethodDecl*)
Line
Count
Source
161
319
    Expected<T *> import(T *From) {
162
319
      auto ToOrErr = Importer.Import(From);
163
319
      if (!ToOrErr)
164
0
        return ToOrErr.takeError();
165
319
      return cast_or_null<T>(*ToOrErr);
166
319
    }
llvm::Expected<clang::Attr*> clang::ASTNodeImporter::import<clang::Attr>(clang::Attr*)
Line
Count
Source
161
181
    Expected<T *> import(T *From) {
162
181
      auto ToOrErr = Importer.Import(From);
163
181
      if (!ToOrErr)
164
0
        return ToOrErr.takeError();
165
181
      return cast_or_null<T>(*ToOrErr);
166
181
    }
llvm::Expected<clang::NamespaceDecl*> clang::ASTNodeImporter::import<clang::NamespaceDecl>(clang::NamespaceDecl*)
Line
Count
Source
161
20
    Expected<T *> import(T *From) {
162
20
      auto ToOrErr = Importer.Import(From);
163
20
      if (!ToOrErr)
164
0
        return ToOrErr.takeError();
165
20
      return cast_or_null<T>(*ToOrErr);
166
20
    }
llvm::Expected<clang::TypeAliasDecl*> clang::ASTNodeImporter::import<clang::TypeAliasDecl>(clang::TypeAliasDecl*)
Line
Count
Source
161
12
    Expected<T *> import(T *From) {
162
12
      auto ToOrErr = Importer.Import(From);
163
12
      if (!ToOrErr)
164
0
        return ToOrErr.takeError();
165
12
      return cast_or_null<T>(*ToOrErr);
166
12
    }
llvm::Expected<clang::LabelStmt*> clang::ASTNodeImporter::import<clang::LabelStmt>(clang::LabelStmt*)
Line
Count
Source
161
6
    Expected<T *> import(T *From) {
162
6
      auto ToOrErr = Importer.Import(From);
163
6
      if (!ToOrErr)
164
0
        return ToOrErr.takeError();
165
6
      return cast_or_null<T>(*ToOrErr);
166
6
    }
llvm::Expected<clang::FunctionDecl*> clang::ASTNodeImporter::import<clang::FunctionDecl>(clang::FunctionDecl*)
Line
Count
Source
161
3.57k
    Expected<T *> import(T *From) {
162
3.57k
      auto ToOrErr = Importer.Import(From);
163
3.57k
      if (!ToOrErr)
164
0
        return ToOrErr.takeError();
165
3.57k
      return cast_or_null<T>(*ToOrErr);
166
3.57k
    }
llvm::Expected<clang::FunctionTemplateDecl*> clang::ASTNodeImporter::import<clang::FunctionTemplateDecl>(clang::FunctionTemplateDecl*)
Line
Count
Source
161
280
    Expected<T *> import(T *From) {
162
280
      auto ToOrErr = Importer.Import(From);
163
280
      if (!ToOrErr)
164
0
        return ToOrErr.takeError();
165
280
      return cast_or_null<T>(*ToOrErr);
166
280
    }
llvm::Expected<clang::Stmt*> clang::ASTNodeImporter::import<clang::Stmt>(clang::Stmt*)
Line
Count
Source
161
1.87k
    Expected<T *> import(T *From) {
162
1.87k
      auto ToOrErr = Importer.Import(From);
163
1.87k
      if (!ToOrErr)
164
48
        return ToOrErr.takeError();
165
1.82k
      return cast_or_null<T>(*ToOrErr);
166
1.82k
    }
llvm::Expected<clang::ParmVarDecl*> clang::ASTNodeImporter::import<clang::ParmVarDecl>(clang::ParmVarDecl*)
Line
Count
Source
161
633
    Expected<T *> import(T *From) {
162
633
      auto ToOrErr = Importer.Import(From);
163
633
      if (!ToOrErr)
164
0
        return ToOrErr.takeError();
165
633
      return cast_or_null<T>(*ToOrErr);
166
633
    }
llvm::Expected<clang::CXXCtorInitializer*> clang::ASTNodeImporter::import<clang::CXXCtorInitializer>(clang::CXXCtorInitializer*)
Line
Count
Source
161
42
    Expected<T *> import(T *From) {
162
42
      auto ToOrErr = Importer.Import(From);
163
42
      if (!ToOrErr)
164
0
        return ToOrErr.takeError();
165
42
      return cast_or_null<T>(*ToOrErr);
166
42
    }
llvm::Expected<clang::NamedDecl*> clang::ASTNodeImporter::import<clang::NamedDecl>(clang::NamedDecl*)
Line
Count
Source
161
1.46k
    Expected<T *> import(T *From) {
162
1.46k
      auto ToOrErr = Importer.Import(From);
163
1.46k
      if (!ToOrErr)
164
0
        return ToOrErr.takeError();
165
1.46k
      return cast_or_null<T>(*ToOrErr);
166
1.46k
    }
llvm::Expected<clang::ObjCCategoryImplDecl*> clang::ASTNodeImporter::import<clang::ObjCCategoryImplDecl>(clang::ObjCCategoryImplDecl*)
Line
Count
Source
161
6
    Expected<T *> import(T *From) {
162
6
      auto ToOrErr = Importer.Import(From);
163
6
      if (!ToOrErr)
164
0
        return ToOrErr.takeError();
165
6
      return cast_or_null<T>(*ToOrErr);
166
6
    }
llvm::Expected<clang::UsingShadowDecl*> clang::ASTNodeImporter::import<clang::UsingShadowDecl>(clang::UsingShadowDecl*)
Line
Count
Source
161
15
    Expected<T *> import(T *From) {
162
15
      auto ToOrErr = Importer.Import(From);
163
15
      if (!ToOrErr)
164
0
        return ToOrErr.takeError();
165
15
      return cast_or_null<T>(*ToOrErr);
166
15
    }
llvm::Expected<clang::UsingDecl*> clang::ASTNodeImporter::import<clang::UsingDecl>(clang::UsingDecl*)
Line
Count
Source
161
15
    Expected<T *> import(T *From) {
162
15
      auto ToOrErr = Importer.Import(From);
163
15
      if (!ToOrErr)
164
0
        return ToOrErr.takeError();
165
15
      return cast_or_null<T>(*ToOrErr);
166
15
    }
llvm::Expected<clang::ObjCCategoryDecl*> clang::ASTNodeImporter::import<clang::ObjCCategoryDecl>(clang::ObjCCategoryDecl*)
Line
Count
Source
161
7
    Expected<T *> import(T *From) {
162
7
      auto ToOrErr = Importer.Import(From);
163
7
      if (!ToOrErr)
164
0
        return ToOrErr.takeError();
165
7
      return cast_or_null<T>(*ToOrErr);
166
7
    }
llvm::Expected<clang::ObjCImplementationDecl*> clang::ASTNodeImporter::import<clang::ObjCImplementationDecl>(clang::ObjCImplementationDecl*)
Line
Count
Source
161
6
    Expected<T *> import(T *From) {
162
6
      auto ToOrErr = Importer.Import(From);
163
6
      if (!ToOrErr)
164
0
        return ToOrErr.takeError();
165
6
      return cast_or_null<T>(*ToOrErr);
166
6
    }
llvm::Expected<clang::ObjCTypeParamDecl*> clang::ASTNodeImporter::import<clang::ObjCTypeParamDecl>(clang::ObjCTypeParamDecl*)
Line
Count
Source
161
4
    Expected<T *> import(T *From) {
162
4
      auto ToOrErr = Importer.Import(From);
163
4
      if (!ToOrErr)
164
0
        return ToOrErr.takeError();
165
4
      return cast_or_null<T>(*ToOrErr);
166
4
    }
llvm::Expected<clang::ObjCMethodDecl*> clang::ASTNodeImporter::import<clang::ObjCMethodDecl>(clang::ObjCMethodDecl*)
Line
Count
Source
161
14
    Expected<T *> import(T *From) {
162
14
      auto ToOrErr = Importer.Import(From);
163
14
      if (!ToOrErr)
164
0
        return ToOrErr.takeError();
165
14
      return cast_or_null<T>(*ToOrErr);
166
14
    }
llvm::Expected<clang::ObjCIvarDecl*> clang::ASTNodeImporter::import<clang::ObjCIvarDecl>(clang::ObjCIvarDecl*)
Line
Count
Source
161
7
    Expected<T *> import(T *From) {
162
7
      auto ToOrErr = Importer.Import(From);
163
7
      if (!ToOrErr)
164
0
        return ToOrErr.takeError();
165
7
      return cast_or_null<T>(*ToOrErr);
166
7
    }
llvm::Expected<clang::FieldDecl*> clang::ASTNodeImporter::import<clang::FieldDecl>(clang::FieldDecl*)
Line
Count
Source
161
21
    Expected<T *> import(T *From) {
162
21
      auto ToOrErr = Importer.Import(From);
163
21
      if (!ToOrErr)
164
0
        return ToOrErr.takeError();
165
21
      return cast_or_null<T>(*ToOrErr);
166
21
    }
Unexecuted instantiation: llvm::Expected<clang::VarTemplateDecl*> clang::ASTNodeImporter::import<clang::VarTemplateDecl>(clang::VarTemplateDecl*)
llvm::Expected<clang::VarTemplatePartialSpecializationDecl*> clang::ASTNodeImporter::import<clang::VarTemplatePartialSpecializationDecl>(clang::VarTemplatePartialSpecializationDecl*)
Line
Count
Source
161
2
    Expected<T *> import(T *From) {
162
2
      auto ToOrErr = Importer.Import(From);
163
2
      if (!ToOrErr)
164
0
        return ToOrErr.takeError();
165
2
      return cast_or_null<T>(*ToOrErr);
166
2
    }
llvm::Expected<clang::StringLiteral*> clang::ASTNodeImporter::import<clang::StringLiteral>(clang::StringLiteral*)
Line
Count
Source
161
28
    Expected<T *> import(T *From) {
162
28
      auto ToOrErr = Importer.Import(From);
163
28
      if (!ToOrErr)
164
0
        return ToOrErr.takeError();
165
28
      return cast_or_null<T>(*ToOrErr);
166
28
    }
Unexecuted instantiation: llvm::Expected<clang::AddrLabelExpr*> clang::ASTNodeImporter::import<clang::AddrLabelExpr>(clang::AddrLabelExpr*)
llvm::Expected<clang::LabelDecl*> clang::ASTNodeImporter::import<clang::LabelDecl>(clang::LabelDecl*)
Line
Count
Source
161
20
    Expected<T *> import(T *From) {
162
20
      auto ToOrErr = Importer.Import(From);
163
20
      if (!ToOrErr)
164
0
        return ToOrErr.takeError();
165
20
      return cast_or_null<T>(*ToOrErr);
166
20
    }
llvm::Expected<clang::SwitchCase*> clang::ASTNodeImporter::import<clang::SwitchCase>(clang::SwitchCase*)
Line
Count
Source
161
20
    Expected<T *> import(T *From) {
162
20
      auto ToOrErr = Importer.Import(From);
163
20
      if (!ToOrErr)
164
0
        return ToOrErr.takeError();
165
20
      return cast_or_null<T>(*ToOrErr);
166
20
    }
llvm::Expected<clang::CompoundStmt*> clang::ASTNodeImporter::import<clang::CompoundStmt>(clang::CompoundStmt*)
Line
Count
Source
161
12
    Expected<T *> import(T *From) {
162
12
      auto ToOrErr = Importer.Import(From);
163
12
      if (!ToOrErr)
164
0
        return ToOrErr.takeError();
165
12
      return cast_or_null<T>(*ToOrErr);
166
12
    }
llvm::Expected<clang::CXXCatchStmt*> clang::ASTNodeImporter::import<clang::CXXCatchStmt>(clang::CXXCatchStmt*)
Line
Count
Source
161
10
    Expected<T *> import(T *From) {
162
10
      auto ToOrErr = Importer.Import(From);
163
10
      if (!ToOrErr)
164
0
        return ToOrErr.takeError();
165
10
      return cast_or_null<T>(*ToOrErr);
166
10
    }
llvm::Expected<clang::DeclStmt*> clang::ASTNodeImporter::import<clang::DeclStmt>(clang::DeclStmt*)
Line
Count
Source
161
8
    Expected<T *> import(T *From) {
162
8
      auto ToOrErr = Importer.Import(From);
163
8
      if (!ToOrErr)
164
0
        return ToOrErr.takeError();
165
8
      return cast_or_null<T>(*ToOrErr);
166
8
    }
llvm::Expected<clang::ObjCAtFinallyStmt*> clang::ASTNodeImporter::import<clang::ObjCAtFinallyStmt>(clang::ObjCAtFinallyStmt*)
Line
Count
Source
161
6
    Expected<T *> import(T *From) {
162
6
      auto ToOrErr = Importer.Import(From);
163
6
      if (!ToOrErr)
164
0
        return ToOrErr.takeError();
165
6
      return cast_or_null<T>(*ToOrErr);
166
6
    }
llvm::Expected<clang::ObjCAtCatchStmt*> clang::ASTNodeImporter::import<clang::ObjCAtCatchStmt>(clang::ObjCAtCatchStmt*)
Line
Count
Source
161
6
    Expected<T *> import(T *From) {
162
6
      auto ToOrErr = Importer.Import(From);
163
6
      if (!ToOrErr)
164
0
        return ToOrErr.takeError();
165
6
      return cast_or_null<T>(*ToOrErr);
166
6
    }
llvm::Expected<clang::OpaqueValueExpr*> clang::ASTNodeImporter::import<clang::OpaqueValueExpr>(clang::OpaqueValueExpr*)
Line
Count
Source
161
10
    Expected<T *> import(T *From) {
162
10
      auto ToOrErr = Importer.Import(From);
163
10
      if (!ToOrErr)
164
0
        return ToOrErr.takeError();
165
10
      return cast_or_null<T>(*ToOrErr);
166
10
    }
llvm::Expected<clang::CXXBaseSpecifier*> clang::ASTNodeImporter::import<clang::CXXBaseSpecifier>(clang::CXXBaseSpecifier*)
Line
Count
Source
161
4
    Expected<T *> import(T *From) {
162
4
      auto ToOrErr = Importer.Import(From);
163
4
      if (!ToOrErr)
164
0
        return ToOrErr.takeError();
165
4
      return cast_or_null<T>(*ToOrErr);
166
4
    }
llvm::Expected<clang::CXXDestructorDecl*> clang::ASTNodeImporter::import<clang::CXXDestructorDecl>(clang::CXXDestructorDecl*)
Line
Count
Source
161
4
    Expected<T *> import(T *From) {
162
4
      auto ToOrErr = Importer.Import(From);
163
4
      if (!ToOrErr)
164
0
        return ToOrErr.takeError();
165
4
      return cast_or_null<T>(*ToOrErr);
166
4
    }
llvm::Expected<clang::CXXConstructorDecl*> clang::ASTNodeImporter::import<clang::CXXConstructorDecl>(clang::CXXConstructorDecl*)
Line
Count
Source
161
126
    Expected<T *> import(T *From) {
162
126
      auto ToOrErr = Importer.Import(From);
163
126
      if (!ToOrErr)
164
0
        return ToOrErr.takeError();
165
126
      return cast_or_null<T>(*ToOrErr);
166
126
    }
Unexecuted instantiation: llvm::Expected<clang::BlockDecl*> clang::ASTNodeImporter::import<clang::BlockDecl>(clang::BlockDecl*)
llvm::Expected<clang::InitListExpr*> clang::ASTNodeImporter::import<clang::InitListExpr>(clang::InitListExpr*)
Line
Count
Source
161
50
    Expected<T *> import(T *From) {
162
50
      auto ToOrErr = Importer.Import(From);
163
50
      if (!ToOrErr)
164
0
        return ToOrErr.takeError();
165
50
      return cast_or_null<T>(*ToOrErr);
166
50
    }
llvm::Expected<clang::NonTypeTemplateParmDecl*> clang::ASTNodeImporter::import<clang::NonTypeTemplateParmDecl>(clang::NonTypeTemplateParmDecl*)
Line
Count
Source
161
5
    Expected<T *> import(T *From) {
162
5
      auto ToOrErr = Importer.Import(From);
163
5
      if (!ToOrErr)
164
0
        return ToOrErr.takeError();
165
5
      return cast_or_null<T>(*ToOrErr);
166
5
    }
167
168
    template <typename T>
169
442
    Expected<T *> import(const T *From) {
170
442
      return import(const_cast<T *>(From));
171
442
    }
llvm::Expected<clang::Attr*> clang::ASTNodeImporter::import<clang::Attr>(clang::Attr const*)
Line
Count
Source
169
181
    Expected<T *> import(const T *From) {
170
181
      return import(const_cast<T *>(From));
171
181
    }
llvm::Expected<clang::VarDecl*> clang::ASTNodeImporter::import<clang::VarDecl>(clang::VarDecl const*)
Line
Count
Source
169
201
    Expected<T *> import(const T *From) {
170
201
      return import(const_cast<T *>(From));
171
201
    }
llvm::Expected<clang::CXXDestructorDecl*> clang::ASTNodeImporter::import<clang::CXXDestructorDecl>(clang::CXXDestructorDecl const*)
Line
Count
Source
169
4
    Expected<T *> import(const T *From) {
170
4
      return import(const_cast<T *>(From));
171
4
    }
llvm::Expected<clang::ValueDecl*> clang::ASTNodeImporter::import<clang::ValueDecl>(clang::ValueDecl const*)
Line
Count
Source
169
27
    Expected<T *> import(const T *From) {
170
27
      return import(const_cast<T *>(From));
171
27
    }
llvm::Expected<clang::CXXMethodDecl*> clang::ASTNodeImporter::import<clang::CXXMethodDecl>(clang::CXXMethodDecl const*)
Line
Count
Source
169
29
    Expected<T *> import(const T *From) {
170
29
      return import(const_cast<T *>(From));
171
29
    }
172
173
    // Call the import function of ASTImporter for type `T`.
174
    template <typename T>
175
43.8k
    Expected<T> import(const T &From) {
176
43.8k
      return Importer.Import(From);
177
43.8k
    }
llvm::Expected<clang::SourceLocation> clang::ASTNodeImporter::import<clang::SourceLocation>(clang::SourceLocation const&)
Line
Count
Source
175
23.3k
    Expected<T> import(const T &From) {
176
23.3k
      return Importer.Import(From);
177
23.3k
    }
llvm::Expected<clang::QualType> clang::ASTNodeImporter::import<clang::QualType>(clang::QualType const&)
Line
Count
Source
175
13.4k
    Expected<T> import(const T &From) {
176
13.4k
      return Importer.Import(From);
177
13.4k
    }
llvm::Expected<clang::TemplateName> clang::ASTNodeImporter::import<clang::TemplateName>(clang::TemplateName const&)
Line
Count
Source
175
364
    Expected<T> import(const T &From) {
176
364
      return Importer.Import(From);
177
364
    }
llvm::Expected<clang::NestedNameSpecifierLoc> clang::ASTNodeImporter::import<clang::NestedNameSpecifierLoc>(clang::NestedNameSpecifierLoc const&)
Line
Count
Source
175
5.60k
    Expected<T> import(const T &From) {
176
5.60k
      return Importer.Import(From);
177
5.60k
    }
llvm::Expected<clang::SourceRange> clang::ASTNodeImporter::import<clang::SourceRange>(clang::SourceRange const&)
Line
Count
Source
175
395
    Expected<T> import(const T &From) {
176
395
      return Importer.Import(From);
177
395
    }
llvm::Expected<clang::Selector> clang::ASTNodeImporter::import<clang::Selector>(clang::Selector const&)
Line
Count
Source
175
14
    Expected<T> import(const T &From) {
176
14
      return Importer.Import(From);
177
14
    }
llvm::Expected<clang::DeclarationName> clang::ASTNodeImporter::import<clang::DeclarationName>(clang::DeclarationName const&)
Line
Count
Source
175
786
    Expected<T> import(const T &From) {
176
786
      return Importer.Import(From);
177
786
    }
178
179
    // Import an Optional<T> by importing the contained T, if any.
180
    template<typename T>
181
3
    Expected<Optional<T>> import(Optional<T> From) {
182
3
      if (!From)
183
2
        return Optional<T>();
184
1
      return import(*From);
185
1
    }
186
187
    template <class T>
188
    Expected<std::tuple<T>>
189
36.0k
    importSeq(const T &From) {
190
36.0k
      Expected<T> ToOrErr = import(From);
191
36.0k
      if (!ToOrErr)
192
10
        return ToOrErr.takeError();
193
35.9k
      return std::make_tuple<T>(std::move(*ToOrErr));
194
35.9k
    }
llvm::Expected<std::__1::tuple<clang::QualType> > clang::ASTNodeImporter::importSeq<clang::QualType>(clang::QualType const&)
Line
Count
Source
189
6.16k
    importSeq(const T &From) {
190
6.16k
      Expected<T> ToOrErr = import(From);
191
6.16k
      if (!ToOrErr)
192
10
        return ToOrErr.takeError();
193
6.15k
      return std::make_tuple<T>(std::move(*ToOrErr));
194
6.15k
    }
llvm::Expected<std::__1::tuple<clang::SourceRange> > clang::ASTNodeImporter::importSeq<clang::SourceRange>(clang::SourceRange const&)
Line
Count
Source
189
195
    importSeq(const T &From) {
190
195
      Expected<T> ToOrErr = import(From);
191
195
      if (!ToOrErr)
192
0
        return ToOrErr.takeError();
193
195
      return std::make_tuple<T>(std::move(*ToOrErr));
194
195
    }
llvm::Expected<std::__1::tuple<clang::FunctionDecl*> > clang::ASTNodeImporter::importSeq<clang::FunctionDecl*>(clang::FunctionDecl* const&)
Line
Count
Source
189
3.55k
    importSeq(const T &From) {
190
3.55k
      Expected<T> ToOrErr = import(From);
191
3.55k
      if (!ToOrErr)
192
0
        return ToOrErr.takeError();
193
3.55k
      return std::make_tuple<T>(std::move(*ToOrErr));
194
3.55k
    }
llvm::Expected<std::__1::tuple<clang::UnresolvedUsingTypenameDecl*> > clang::ASTNodeImporter::importSeq<clang::UnresolvedUsingTypenameDecl*>(clang::UnresolvedUsingTypenameDecl* const&)
Line
Count
Source
189
1
    importSeq(const T &From) {
190
1
      Expected<T> ToOrErr = import(From);
191
1
      if (!ToOrErr)
192
0
        return ToOrErr.takeError();
193
1
      return std::make_tuple<T>(std::move(*ToOrErr));
194
1
    }
llvm::Expected<std::__1::tuple<clang::Decl*> > clang::ASTNodeImporter::importSeq<clang::Decl*>(clang::Decl* const&)
Line
Count
Source
189
1
    importSeq(const T &From) {
190
1
      Expected<T> ToOrErr = import(From);
191
1
      if (!ToOrErr)
192
0
        return ToOrErr.takeError();
193
1
      return std::make_tuple<T>(std::move(*ToOrErr));
194
1
    }
llvm::Expected<std::__1::tuple<clang::SourceLocation> > clang::ASTNodeImporter::importSeq<clang::SourceLocation>(clang::SourceLocation const&)
Line
Count
Source
189
11.0k
    importSeq(const T &From) {
190
11.0k
      Expected<T> ToOrErr = import(From);
191
11.0k
      if (!ToOrErr)
192
0
        return ToOrErr.takeError();
193
11.0k
      return std::make_tuple<T>(std::move(*ToOrErr));
194
11.0k
    }
llvm::Expected<std::__1::tuple<clang::StringLiteral*> > clang::ASTNodeImporter::importSeq<clang::StringLiteral*>(clang::StringLiteral* const&)
Line
Count
Source
189
16
    importSeq(const T &From) {
190
16
      Expected<T> ToOrErr = import(From);
191
16
      if (!ToOrErr)
192
0
        return ToOrErr.takeError();
193
16
      return std::make_tuple<T>(std::move(*ToOrErr));
194
16
    }
llvm::Expected<std::__1::tuple<clang::NestedNameSpecifierLoc> > clang::ASTNodeImporter::importSeq<clang::NestedNameSpecifierLoc>(clang::NestedNameSpecifierLoc const&)
Line
Count
Source
189
3.49k
    importSeq(const T &From) {
190
3.49k
      Expected<T> ToOrErr = import(From);
191
3.49k
      if (!ToOrErr)
192
0
        return ToOrErr.takeError();
193
3.49k
      return std::make_tuple<T>(std::move(*ToOrErr));
194
3.49k
    }
llvm::Expected<std::__1::tuple<clang::NamespaceDecl*> > clang::ASTNodeImporter::importSeq<clang::NamespaceDecl*>(clang::NamespaceDecl* const&)
Line
Count
Source
189
20
    importSeq(const T &From) {
190
20
      Expected<T> ToOrErr = import(From);
191
20
      if (!ToOrErr)
192
0
        return ToOrErr.takeError();
193
20
      return std::make_tuple<T>(std::move(*ToOrErr));
194
20
    }
llvm::Expected<std::__1::tuple<clang::TypeSourceInfo*> > clang::ASTNodeImporter::importSeq<clang::TypeSourceInfo*>(clang::TypeSourceInfo* const&)
Line
Count
Source
189
4.84k
    importSeq(const T &From) {
190
4.84k
      Expected<T> ToOrErr = import(From);
191
4.84k
      if (!ToOrErr)
192
0
        return ToOrErr.takeError();
193
4.84k
      return std::make_tuple<T>(std::move(*ToOrErr));
194
4.84k
    }
llvm::Expected<std::__1::tuple<clang::TemplateParameterList*> > clang::ASTNodeImporter::importSeq<clang::TemplateParameterList*>(clang::TemplateParameterList* const&)
Line
Count
Source
189
12
    importSeq(const T &From) {
190
12
      Expected<T> ToOrErr = import(From);
191
12
      if (!ToOrErr)
192
0
        return ToOrErr.takeError();
193
12
      return std::make_tuple<T>(std::move(*ToOrErr));
194
12
    }
llvm::Expected<std::__1::tuple<clang::TypeAliasDecl*> > clang::ASTNodeImporter::importSeq<clang::TypeAliasDecl*>(clang::TypeAliasDecl* const&)
Line
Count
Source
189
12
    importSeq(const T &From) {
190
12
      Expected<T> ToOrErr = import(From);
191
12
      if (!ToOrErr)
192
0
        return ToOrErr.takeError();
193
12
      return std::make_tuple<T>(std::move(*ToOrErr));
194
12
    }
llvm::Expected<std::__1::tuple<clang::Expr*> > clang::ASTNodeImporter::importSeq<clang::Expr*>(clang::Expr* const&)
Line
Count
Source
189
4.27k
    importSeq(const T &From) {
190
4.27k
      Expected<T> ToOrErr = import(From);
191
4.27k
      if (!ToOrErr)
192
0
        return ToOrErr.takeError();
193
4.27k
      return std::make_tuple<T>(std::move(*ToOrErr));
194
4.27k
    }
llvm::Expected<std::__1::tuple<clang::DeclarationName> > clang::ASTNodeImporter::importSeq<clang::DeclarationName>(clang::DeclarationName const&)
Line
Count
Source
189
781
    importSeq(const T &From) {
190
781
      Expected<T> ToOrErr = import(From);
191
781
      if (!ToOrErr)
192
0
        return ToOrErr.takeError();
193
781
      return std::make_tuple<T>(std::move(*ToOrErr));
194
781
    }
llvm::Expected<std::__1::tuple<clang::Selector> > clang::ASTNodeImporter::importSeq<clang::Selector>(clang::Selector const&)
Line
Count
Source
189
14
    importSeq(const T &From) {
190
14
      Expected<T> ToOrErr = import(From);
191
14
      if (!ToOrErr)
192
0
        return ToOrErr.takeError();
193
14
      return std::make_tuple<T>(std::move(*ToOrErr));
194
14
    }
llvm::Expected<std::__1::tuple<clang::ObjCMethodDecl*> > clang::ASTNodeImporter::importSeq<clang::ObjCMethodDecl*>(clang::ObjCMethodDecl* const&)
Line
Count
Source
189
14
    importSeq(const T &From) {
190
14
      Expected<T> ToOrErr = import(From);
191
14
      if (!ToOrErr)
192
0
        return ToOrErr.takeError();
193
14
      return std::make_tuple<T>(std::move(*ToOrErr));
194
14
    }
llvm::Expected<std::__1::tuple<clang::ObjCIvarDecl*> > clang::ASTNodeImporter::importSeq<clang::ObjCIvarDecl*>(clang::ObjCIvarDecl* const&)
Line
Count
Source
189
7
    importSeq(const T &From) {
190
7
      Expected<T> ToOrErr = import(From);
191
7
      if (!ToOrErr)
192
0
        return ToOrErr.takeError();
193
7
      return std::make_tuple<T>(std::move(*ToOrErr));
194
7
    }
llvm::Expected<std::__1::tuple<clang::DeclGroupRef> > clang::ASTNodeImporter::importSeq<clang::DeclGroupRef>(clang::DeclGroupRef const&)
Line
Count
Source
189
253
    importSeq(const T &From) {
190
253
      Expected<T> ToOrErr = import(From);
191
253
      if (!ToOrErr)
192
0
        return ToOrErr.takeError();
193
253
      return std::make_tuple<T>(std::move(*ToOrErr));
194
253
    }
llvm::Expected<std::__1::tuple<clang::Stmt*> > clang::ASTNodeImporter::importSeq<clang::Stmt*>(clang::Stmt* const&)
Line
Count
Source
189
143
    importSeq(const T &From) {
190
143
      Expected<T> ToOrErr = import(From);
191
143
      if (!ToOrErr)
192
0
        return ToOrErr.takeError();
193
143
      return std::make_tuple<T>(std::move(*ToOrErr));
194
143
    }
llvm::Expected<std::__1::tuple<clang::LabelDecl*> > clang::ASTNodeImporter::importSeq<clang::LabelDecl*>(clang::LabelDecl* const&)
Line
Count
Source
189
20
    importSeq(const T &From) {
190
20
      Expected<T> ToOrErr = import(From);
191
20
      if (!ToOrErr)
192
0
        return ToOrErr.takeError();
193
20
      return std::make_tuple<T>(std::move(*ToOrErr));
194
20
    }
llvm::Expected<std::__1::tuple<clang::VarDecl*> > clang::ASTNodeImporter::importSeq<clang::VarDecl*>(clang::VarDecl* const&)
Line
Count
Source
189
55
    importSeq(const T &From) {
190
55
      Expected<T> ToOrErr = import(From);
191
55
      if (!ToOrErr)
192
0
        return ToOrErr.takeError();
193
55
      return std::make_tuple<T>(std::move(*ToOrErr));
194
55
    }
llvm::Expected<std::__1::tuple<clang::VarDecl const*> > clang::ASTNodeImporter::importSeq<clang::VarDecl const*>(clang::VarDecl const* const&)
Line
Count
Source
189
201
    importSeq(const T &From) {
190
201
      Expected<T> ToOrErr = import(From);
191
201
      if (!ToOrErr)
192
0
        return ToOrErr.takeError();
193
201
      return std::make_tuple<T>(std::move(*ToOrErr));
194
201
    }
llvm::Expected<std::__1::tuple<clang::DeclStmt*> > clang::ASTNodeImporter::importSeq<clang::DeclStmt*>(clang::DeclStmt* const&)
Line
Count
Source
189
8
    importSeq(const T &From) {
190
8
      Expected<T> ToOrErr = import(From);
191
8
      if (!ToOrErr)
192
0
        return ToOrErr.takeError();
193
8
      return std::make_tuple<T>(std::move(*ToOrErr));
194
8
    }
llvm::Expected<std::__1::tuple<clang::ObjCAtFinallyStmt*> > clang::ASTNodeImporter::importSeq<clang::ObjCAtFinallyStmt*>(clang::ObjCAtFinallyStmt* const&)
Line
Count
Source
189
6
    importSeq(const T &From) {
190
6
      Expected<T> ToOrErr = import(From);
191
6
      if (!ToOrErr)
192
0
        return ToOrErr.takeError();
193
6
      return std::make_tuple<T>(std::move(*ToOrErr));
194
6
    }
llvm::Expected<std::__1::tuple<clang::CompoundStmt*> > clang::ASTNodeImporter::importSeq<clang::CompoundStmt*>(clang::CompoundStmt* const&)
Line
Count
Source
189
4
    importSeq(const T &From) {
190
4
      Expected<T> ToOrErr = import(From);
191
4
      if (!ToOrErr)
192
0
        return ToOrErr.takeError();
193
4
      return std::make_tuple<T>(std::move(*ToOrErr));
194
4
    }
llvm::Expected<std::__1::tuple<clang::ValueDecl*> > clang::ASTNodeImporter::importSeq<clang::ValueDecl*>(clang::ValueDecl* const&)
Line
Count
Source
189
561
    importSeq(const T &From) {
190
561
      Expected<T> ToOrErr = import(From);
191
561
      if (!ToOrErr)
192
0
        return ToOrErr.takeError();
193
561
      return std::make_tuple<T>(std::move(*ToOrErr));
194
561
    }
llvm::Expected<std::__1::tuple<clang::OpaqueValueExpr*> > clang::ASTNodeImporter::importSeq<clang::OpaqueValueExpr*>(clang::OpaqueValueExpr* const&)
Line
Count
Source
189
10
    importSeq(const T &From) {
190
10
      Expected<T> ToOrErr = import(From);
191
10
      if (!ToOrErr)
192
0
        return ToOrErr.takeError();
193
10
      return std::make_tuple<T>(std::move(*ToOrErr));
194
10
    }
llvm::Expected<std::__1::tuple<clang::CXXConstructorDecl*> > clang::ASTNodeImporter::importSeq<clang::CXXConstructorDecl*>(clang::CXXConstructorDecl* const&)
Line
Count
Source
189
126
    importSeq(const T &From) {
190
126
      Expected<T> ToOrErr = import(From);
191
126
      if (!ToOrErr)
192
0
        return ToOrErr.takeError();
193
126
      return std::make_tuple<T>(std::move(*ToOrErr));
194
126
    }
llvm::Expected<std::__1::tuple<clang::ValueDecl const*> > clang::ASTNodeImporter::importSeq<clang::ValueDecl const*>(clang::ValueDecl const* const&)
Line
Count
Source
189
27
    importSeq(const T &From) {
190
27
      Expected<T> ToOrErr = import(From);
191
27
      if (!ToOrErr)
192
0
        return ToOrErr.takeError();
193
27
      return std::make_tuple<T>(std::move(*ToOrErr));
194
27
    }
llvm::Expected<std::__1::tuple<clang::NamedDecl*> > clang::ASTNodeImporter::importSeq<clang::NamedDecl*>(clang::NamedDecl* const&)
Line
Count
Source
189
100
    importSeq(const T &From) {
190
100
      Expected<T> ToOrErr = import(From);
191
100
      if (!ToOrErr)
192
0
        return ToOrErr.takeError();
193
100
      return std::make_tuple<T>(std::move(*ToOrErr));
194
100
    }
llvm::Expected<std::__1::tuple<llvm::Optional<clang::Expr*> > > clang::ASTNodeImporter::importSeq<llvm::Optional<clang::Expr*> >(llvm::Optional<clang::Expr*> const&)
Line
Count
Source
189
3
    importSeq(const T &From) {
190
3
      Expected<T> ToOrErr = import(From);
191
3
      if (!ToOrErr)
192
0
        return ToOrErr.takeError();
193
3
      return std::make_tuple<T>(std::move(*ToOrErr));
194
3
    }
llvm::Expected<std::__1::tuple<clang::NonTypeTemplateParmDecl*> > clang::ASTNodeImporter::importSeq<clang::NonTypeTemplateParmDecl*>(clang::NonTypeTemplateParmDecl* const&)
Line
Count
Source
189
5
    importSeq(const T &From) {
190
5
      Expected<T> ToOrErr = import(From);
191
5
      if (!ToOrErr)
192
0
        return ToOrErr.takeError();
193
5
      return std::make_tuple<T>(std::move(*ToOrErr));
194
5
    }
195
196
    // Import multiple objects with a single function call.
197
    // This should work for every type for which a variant of `import` exists.
198
    // The arguments are processed from left to right and import is stopped on
199
    // first error.
200
    template <class THead, class... TTail>
201
    Expected<std::tuple<THead, TTail...>>
202
27.0k
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
27.0k
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
27.0k
      if (!ToHeadOrErr)
205
10
        return ToHeadOrErr.takeError();
206
27.0k
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
27.0k
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
27.0k
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
27.0k
    }
llvm::Expected<std::__1::tuple<clang::QualType, clang::Expr*, clang::SourceRange> > clang::ASTNodeImporter::importSeq<clang::QualType, clang::Expr*, clang::SourceRange>(clang::QualType const&, clang::Expr* const&, clang::SourceRange const&)
Line
Count
Source
202
12
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
12
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
12
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
12
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
12
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
12
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
12
    }
llvm::Expected<std::__1::tuple<clang::Expr*, clang::SourceRange> > clang::ASTNodeImporter::importSeq<clang::Expr*, clang::SourceRange>(clang::Expr* const&, clang::SourceRange const&)
Line
Count
Source
202
12
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
12
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
12
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
12
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
12
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
12
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
12
    }
llvm::Expected<std::__1::tuple<clang::Expr*, clang::FunctionDecl*, clang::FunctionDecl*> > clang::ASTNodeImporter::importSeq<clang::Expr*, clang::FunctionDecl*, clang::FunctionDecl*>(clang::Expr* const&, clang::FunctionDecl* const&, clang::FunctionDecl* const&)
Line
Count
Source
202
1.70k
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
1.70k
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
1.70k
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
1.70k
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
1.70k
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
1.70k
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
1.70k
    }
llvm::Expected<std::__1::tuple<clang::FunctionDecl*, clang::FunctionDecl*> > clang::ASTNodeImporter::importSeq<clang::FunctionDecl*, clang::FunctionDecl*>(clang::FunctionDecl* const&, clang::FunctionDecl* const&)
Line
Count
Source
202
1.70k
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
1.70k
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
1.70k
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
1.70k
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
1.70k
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
1.70k
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
1.70k
    }
llvm::Expected<std::__1::tuple<clang::UnresolvedUsingTypenameDecl*, clang::Decl*> > clang::ASTNodeImporter::importSeq<clang::UnresolvedUsingTypenameDecl*, clang::Decl*>(clang::UnresolvedUsingTypenameDecl* const&, clang::Decl* const&)
Line
Count
Source
202
1
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
1
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
1
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
1
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
1
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
1
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
1
    }
llvm::Expected<std::__1::tuple<clang::SourceLocation, clang::Expr*, clang::StringLiteral*, clang::SourceLocation> > clang::ASTNodeImporter::importSeq<clang::SourceLocation, clang::Expr*, clang::StringLiteral*, clang::SourceLocation>(clang::SourceLocation const&, clang::Expr* const&, clang::StringLiteral* const&, clang::SourceLocation const&)
Line
Count
Source
202
12
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
12
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
12
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
12
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
12
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
12
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
12
    }
llvm::Expected<std::__1::tuple<clang::Expr*, clang::StringLiteral*, clang::SourceLocation> > clang::ASTNodeImporter::importSeq<clang::Expr*, clang::StringLiteral*, clang::SourceLocation>(clang::Expr* const&, clang::StringLiteral* const&, clang::SourceLocation const&)
Line
Count
Source
202
12
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
12
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
12
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
12
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
12
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
12
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
12
    }
llvm::Expected<std::__1::tuple<clang::StringLiteral*, clang::SourceLocation> > clang::ASTNodeImporter::importSeq<clang::StringLiteral*, clang::SourceLocation>(clang::StringLiteral* const&, clang::SourceLocation const&)
Line
Count
Source
202
12
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
12
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
12
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
12
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
12
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
12
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
12
    }
llvm::Expected<std::__1::tuple<clang::SourceLocation, clang::SourceLocation, clang::NestedNameSpecifierLoc, clang::SourceLocation, clang::NamespaceDecl*> > clang::ASTNodeImporter::importSeq<clang::SourceLocation, clang::SourceLocation, clang::NestedNameSpecifierLoc, clang::SourceLocation, clang::NamespaceDecl*>(clang::SourceLocation const&, clang::SourceLocation const&, clang::NestedNameSpecifierLoc const&, clang::SourceLocation const&, clang::NamespaceDecl* const&)
Line
Count
Source
202
3
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
3
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
3
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
3
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
3
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
3
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
3
    }
llvm::Expected<std::__1::tuple<clang::SourceLocation, clang::NestedNameSpecifierLoc, clang::SourceLocation, clang::NamespaceDecl*> > clang::ASTNodeImporter::importSeq<clang::SourceLocation, clang::NestedNameSpecifierLoc, clang::SourceLocation, clang::NamespaceDecl*>(clang::SourceLocation const&, clang::NestedNameSpecifierLoc const&, clang::SourceLocation const&, clang::NamespaceDecl* const&)
Line
Count
Source
202
3
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
3
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
3
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
3
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
3
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
3
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
3
    }
llvm::Expected<std::__1::tuple<clang::NestedNameSpecifierLoc, clang::SourceLocation, clang::NamespaceDecl*> > clang::ASTNodeImporter::importSeq<clang::NestedNameSpecifierLoc, clang::SourceLocation, clang::NamespaceDecl*>(clang::NestedNameSpecifierLoc const&, clang::SourceLocation const&, clang::NamespaceDecl* const&)
Line
Count
Source
202
3
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
3
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
3
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
3
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
3
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
3
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
3
    }
llvm::Expected<std::__1::tuple<clang::SourceLocation, clang::NamespaceDecl*> > clang::ASTNodeImporter::importSeq<clang::SourceLocation, clang::NamespaceDecl*>(clang::SourceLocation const&, clang::NamespaceDecl* const&)
Line
Count
Source
202
3
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
3
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
3
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
3
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
3
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
3
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
3
    }
llvm::Expected<std::__1::tuple<clang::QualType, clang::TypeSourceInfo*, clang::SourceLocation> > clang::ASTNodeImporter::importSeq<clang::QualType, clang::TypeSourceInfo*, clang::SourceLocation>(clang::QualType const&, clang::TypeSourceInfo* const&, clang::SourceLocation const&)
Line
Count
Source
202
573
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
573
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
573
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
573
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
573
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
573
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
573
    }
llvm::Expected<std::__1::tuple<clang::TypeSourceInfo*, clang::SourceLocation> > clang::ASTNodeImporter::importSeq<clang::TypeSourceInfo*, clang::SourceLocation>(clang::TypeSourceInfo* const&, clang::SourceLocation const&)
Line
Count
Source
202
573
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
573
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
573
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
573
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
573
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
573
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
573
    }
llvm::Expected<std::__1::tuple<clang::TemplateParameterList*, clang::TypeAliasDecl*> > clang::ASTNodeImporter::importSeq<clang::TemplateParameterList*, clang::TypeAliasDecl*>(clang::TemplateParameterList* const&, clang::TypeAliasDecl* const&)
Line
Count
Source
202
12
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
12
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
12
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
12
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
12
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
12
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
12
    }
llvm::Expected<std::__1::tuple<clang::SourceLocation, clang::NestedNameSpecifierLoc, clang::QualType> > clang::ASTNodeImporter::importSeq<clang::SourceLocation, clang::NestedNameSpecifierLoc, clang::QualType>(clang::SourceLocation const&, clang::NestedNameSpecifierLoc const&, clang::QualType const&)
Line
Count
Source
202
70
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
70
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
70
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
70
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
70
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
70
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
70
    }
llvm::Expected<std::__1::tuple<clang::NestedNameSpecifierLoc, clang::QualType> > clang::ASTNodeImporter::importSeq<clang::NestedNameSpecifierLoc, clang::QualType>(clang::NestedNameSpecifierLoc const&, clang::QualType const&)
Line
Count
Source
202
70
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
70
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
70
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
70
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
70
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
70
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
70
    }
llvm::Expected<std::__1::tuple<clang::QualType, clang::TypeSourceInfo*, clang::SourceLocation, clang::NestedNameSpecifierLoc, clang::SourceLocation> > clang::ASTNodeImporter::importSeq<clang::QualType, clang::TypeSourceInfo*, clang::SourceLocation, clang::NestedNameSpecifierLoc, clang::SourceLocation>(clang::QualType const&, clang::TypeSourceInfo* const&, clang::SourceLocation const&, clang::NestedNameSpecifierLoc const&, clang::SourceLocation const&)
Line
Count
Source
202
2.10k
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
2.10k
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
2.10k
      if (!ToHeadOrErr)
205
9
        return ToHeadOrErr.takeError();
206
2.09k
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
2.09k
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
2.09k
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
2.09k
    }
llvm::Expected<std::__1::tuple<clang::TypeSourceInfo*, clang::SourceLocation, clang::NestedNameSpecifierLoc, clang::SourceLocation> > clang::ASTNodeImporter::importSeq<clang::TypeSourceInfo*, clang::SourceLocation, clang::NestedNameSpecifierLoc, clang::SourceLocation>(clang::TypeSourceInfo* const&, clang::SourceLocation const&, clang::NestedNameSpecifierLoc const&, clang::SourceLocation const&)
Line
Count
Source
202
2.09k
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
2.09k
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
2.09k
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
2.09k
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
2.09k
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
2.09k
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
2.09k
    }
llvm::Expected<std::__1::tuple<clang::SourceLocation, clang::NestedNameSpecifierLoc, clang::SourceLocation> > clang::ASTNodeImporter::importSeq<clang::SourceLocation, clang::NestedNameSpecifierLoc, clang::SourceLocation>(clang::SourceLocation const&, clang::NestedNameSpecifierLoc const&, clang::SourceLocation const&)
Line
Count
Source
202
2.11k
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
2.11k
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
2.11k
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
2.11k
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
2.11k
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
2.11k
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
2.11k
    }
llvm::Expected<std::__1::tuple<clang::NestedNameSpecifierLoc, clang::SourceLocation> > clang::ASTNodeImporter::importSeq<clang::NestedNameSpecifierLoc, clang::SourceLocation>(clang::NestedNameSpecifierLoc const&, clang::SourceLocation const&)
Line
Count
Source
202
2.11k
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
2.11k
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
2.11k
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
2.11k
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
2.11k
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
2.11k
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
2.11k
    }
llvm::Expected<std::__1::tuple<clang::FunctionDecl*, clang::Expr*> > clang::ASTNodeImporter::importSeq<clang::FunctionDecl*, clang::Expr*>(clang::FunctionDecl* const&, clang::Expr* const&)
Line
Count
Source
202
135
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
135
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
135
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
135
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
135
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
135
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
135
    }
llvm::Expected<std::__1::tuple<clang::QualType, clang::TypeSourceInfo*, clang::Expr*, clang::SourceLocation, clang::Expr*> > clang::ASTNodeImporter::importSeq<clang::QualType, clang::TypeSourceInfo*, clang::Expr*, clang::SourceLocation, clang::Expr*>(clang::QualType const&, clang::TypeSourceInfo* const&, clang::Expr* const&, clang::SourceLocation const&, clang::Expr* const&)
Line
Count
Source
202
593
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
593
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
593
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
593
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
593
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
593
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
593
    }
llvm::Expected<std::__1::tuple<clang::TypeSourceInfo*, clang::Expr*, clang::SourceLocation, clang::Expr*> > clang::ASTNodeImporter::importSeq<clang::TypeSourceInfo*, clang::Expr*, clang::SourceLocation, clang::Expr*>(clang::TypeSourceInfo* const&, clang::Expr* const&, clang::SourceLocation const&, clang::Expr* const&)
Line
Count
Source
202
593
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
593
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
593
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
593
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
593
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
593
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
593
    }
llvm::Expected<std::__1::tuple<clang::Expr*, clang::SourceLocation, clang::Expr*> > clang::ASTNodeImporter::importSeq<clang::Expr*, clang::SourceLocation, clang::Expr*>(clang::Expr* const&, clang::SourceLocation const&, clang::Expr* const&)
Line
Count
Source
202
593
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
593
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
593
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
593
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
593
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
593
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
593
    }
llvm::Expected<std::__1::tuple<clang::SourceLocation, clang::Expr*> > clang::ASTNodeImporter::importSeq<clang::SourceLocation, clang::Expr*>(clang::SourceLocation const&, clang::Expr* const&)
Line
Count
Source
202
618
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
618
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
618
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
618
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
618
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
618
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
618
    }
llvm::Expected<std::__1::tuple<clang::QualType, clang::TypeSourceInfo*, clang::Expr*, clang::SourceLocation> > clang::ASTNodeImporter::importSeq<clang::QualType, clang::TypeSourceInfo*, clang::Expr*, clang::SourceLocation>(clang::QualType const&, clang::TypeSourceInfo* const&, clang::Expr* const&, clang::SourceLocation const&)
Line
Count
Source
202
10
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
10
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
10
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
10
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
10
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
10
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
10
    }
llvm::Expected<std::__1::tuple<clang::TypeSourceInfo*, clang::Expr*, clang::SourceLocation> > clang::ASTNodeImporter::importSeq<clang::TypeSourceInfo*, clang::Expr*, clang::SourceLocation>(clang::TypeSourceInfo* const&, clang::Expr* const&, clang::SourceLocation const&)
Line
Count
Source
202
10
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
10
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
10
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
10
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
10
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
10
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
10
    }
llvm::Expected<std::__1::tuple<clang::Expr*, clang::SourceLocation> > clang::ASTNodeImporter::importSeq<clang::Expr*, clang::SourceLocation>(clang::Expr* const&, clang::SourceLocation const&)
Line
Count
Source
202
13
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
13
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
13
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
13
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
13
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
13
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
13
    }
llvm::Expected<std::__1::tuple<clang::QualType, clang::TypeSourceInfo*, clang::SourceLocation, clang::NestedNameSpecifierLoc> > clang::ASTNodeImporter::importSeq<clang::QualType, clang::TypeSourceInfo*, clang::SourceLocation, clang::NestedNameSpecifierLoc>(clang::QualType const&, clang::TypeSourceInfo* const&, clang::SourceLocation const&, clang::NestedNameSpecifierLoc const&)
Line
Count
Source
202
704
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
704
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
704
      if (!ToHeadOrErr)
205
1
        return ToHeadOrErr.takeError();
206
703
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
703
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
703
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
703
    }
llvm::Expected<std::__1::tuple<clang::TypeSourceInfo*, clang::SourceLocation, clang::NestedNameSpecifierLoc> > clang::ASTNodeImporter::importSeq<clang::TypeSourceInfo*, clang::SourceLocation, clang::NestedNameSpecifierLoc>(clang::TypeSourceInfo* const&, clang::SourceLocation const&, clang::NestedNameSpecifierLoc const&)
Line
Count
Source
202
703
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
703
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
703
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
703
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
703
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
703
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
703
    }
llvm::Expected<std::__1::tuple<clang::SourceLocation, clang::NestedNameSpecifierLoc> > clang::ASTNodeImporter::importSeq<clang::SourceLocation, clang::NestedNameSpecifierLoc>(clang::SourceLocation const&, clang::NestedNameSpecifierLoc const&)
Line
Count
Source
202
714
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
714
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
714
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
714
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
714
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
714
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
714
    }
Unexecuted instantiation: llvm::Expected<std::__1::tuple<clang::DeclarationName, clang::SourceLocation, clang::QualType> > clang::ASTNodeImporter::importSeq<clang::DeclarationName, clang::SourceLocation, clang::QualType>(clang::DeclarationName const&, clang::SourceLocation const&, clang::QualType const&)
llvm::Expected<std::__1::tuple<clang::SourceLocation, clang::QualType> > clang::ASTNodeImporter::importSeq<clang::SourceLocation, clang::QualType>(clang::SourceLocation const&, clang::QualType const&)
Line
Count
Source
202
632
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
632
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
632
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
632
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
632
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
632
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
632
    }
llvm::Expected<std::__1::tuple<clang::DeclarationName, clang::SourceLocation, clang::QualType, clang::SourceLocation, clang::TypeSourceInfo*> > clang::ASTNodeImporter::importSeq<clang::DeclarationName, clang::SourceLocation, clang::QualType, clang::SourceLocation, clang::TypeSourceInfo*>(clang::DeclarationName const&, clang::SourceLocation const&, clang::QualType const&, clang::SourceLocation const&, clang::TypeSourceInfo* const&)
Line
Count
Source
202
616
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
616
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
616
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
616
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
616
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
616
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
616
    }
llvm::Expected<std::__1::tuple<clang::SourceLocation, clang::QualType, clang::SourceLocation, clang::TypeSourceInfo*> > clang::ASTNodeImporter::importSeq<clang::SourceLocation, clang::QualType, clang::SourceLocation, clang::TypeSourceInfo*>(clang::SourceLocation const&, clang::QualType const&, clang::SourceLocation const&, clang::TypeSourceInfo* const&)
Line
Count
Source
202
616
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
616
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
616
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
616
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
616
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
616
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
616
    }
llvm::Expected<std::__1::tuple<clang::QualType, clang::SourceLocation, clang::TypeSourceInfo*> > clang::ASTNodeImporter::importSeq<clang::QualType, clang::SourceLocation, clang::TypeSourceInfo*>(clang::QualType const&, clang::SourceLocation const&, clang::TypeSourceInfo* const&)
Line
Count
Source
202
616
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
616
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
616
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
616
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
616
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
616
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
616
    }
llvm::Expected<std::__1::tuple<clang::SourceLocation, clang::TypeSourceInfo*> > clang::ASTNodeImporter::importSeq<clang::SourceLocation, clang::TypeSourceInfo*>(clang::SourceLocation const&, clang::TypeSourceInfo* const&)
Line
Count
Source
202
634
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
634
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
634
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
634
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
634
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
634
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
634
    }
llvm::Expected<std::__1::tuple<clang::SourceLocation, clang::QualType, clang::TypeSourceInfo*> > clang::ASTNodeImporter::importSeq<clang::SourceLocation, clang::QualType, clang::TypeSourceInfo*>(clang::SourceLocation const&, clang::QualType const&, clang::TypeSourceInfo* const&)
Line
Count
Source
202
43
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
43
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
43
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
43
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
43
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
43
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
43
    }
llvm::Expected<std::__1::tuple<clang::QualType, clang::TypeSourceInfo*> > clang::ASTNodeImporter::importSeq<clang::QualType, clang::TypeSourceInfo*>(clang::QualType const&, clang::TypeSourceInfo* const&)
Line
Count
Source
202
43
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
43
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
43
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
43
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
43
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
43
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
43
    }
llvm::Expected<std::__1::tuple<clang::SourceLocation, clang::SourceLocation, clang::SourceLocation, clang::TypeSourceInfo*> > clang::ASTNodeImporter::importSeq<clang::SourceLocation, clang::SourceLocation, clang::SourceLocation, clang::TypeSourceInfo*>(clang::SourceLocation const&, clang::SourceLocation const&, clang::SourceLocation const&, clang::TypeSourceInfo* const&)
Line
Count
Source
202
4
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
4
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
4
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
4
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
4
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
4
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
4
    }
llvm::Expected<std::__1::tuple<clang::SourceLocation, clang::SourceLocation, clang::SourceLocation, clang::SourceLocation> > clang::ASTNodeImporter::importSeq<clang::SourceLocation, clang::SourceLocation, clang::SourceLocation, clang::SourceLocation>(clang::SourceLocation const&, clang::SourceLocation const&, clang::SourceLocation const&, clang::SourceLocation const&)
Line
Count
Source
202
16
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
16
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
16
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
16
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
16
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
16
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
16
    }
llvm::Expected<std::__1::tuple<clang::SourceLocation, clang::SourceLocation, clang::NestedNameSpecifierLoc> > clang::ASTNodeImporter::importSeq<clang::SourceLocation, clang::SourceLocation, clang::NestedNameSpecifierLoc>(clang::SourceLocation const&, clang::SourceLocation const&, clang::NestedNameSpecifierLoc const&)
Line
Count
Source
202
11
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
11
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
11
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
11
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
11
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
11
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
11
    }
llvm::Expected<std::__1::tuple<clang::NamespaceDecl*, clang::SourceLocation, clang::SourceLocation, clang::NestedNameSpecifierLoc, clang::SourceLocation> > clang::ASTNodeImporter::importSeq<clang::NamespaceDecl*, clang::SourceLocation, clang::SourceLocation, clang::NestedNameSpecifierLoc, clang::SourceLocation>(clang::NamespaceDecl* const&, clang::SourceLocation const&, clang::SourceLocation const&, clang::NestedNameSpecifierLoc const&, clang::SourceLocation const&)
Line
Count
Source
202
17
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
17
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
17
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
17
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
17
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
17
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
17
    }
llvm::Expected<std::__1::tuple<clang::SourceLocation, clang::SourceLocation, clang::NestedNameSpecifierLoc, clang::SourceLocation> > clang::ASTNodeImporter::importSeq<clang::SourceLocation, clang::SourceLocation, clang::NestedNameSpecifierLoc, clang::SourceLocation>(clang::SourceLocation const&, clang::SourceLocation const&, clang::NestedNameSpecifierLoc const&, clang::SourceLocation const&)
Line
Count
Source
202
19
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
19
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
19
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
19
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
19
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
19
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
19
    }
llvm::Expected<std::__1::tuple<clang::SourceLocation, clang::SourceLocation, clang::SourceLocation> > clang::ASTNodeImporter::importSeq<clang::SourceLocation, clang::SourceLocation, clang::SourceLocation>(clang::SourceLocation const&, clang::SourceLocation const&, clang::SourceLocation const&)
Line
Count
Source
202
136
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
136
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
136
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
136
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
136
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
136
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
136
    }
llvm::Expected<std::__1::tuple<clang::SourceLocation, clang::SourceLocation, clang::SourceLocation, clang::SourceLocation, clang::SourceLocation> > clang::ASTNodeImporter::importSeq<clang::SourceLocation, clang::SourceLocation, clang::SourceLocation, clang::SourceLocation, clang::SourceLocation>(clang::SourceLocation const&, clang::SourceLocation const&, clang::SourceLocation const&, clang::SourceLocation const&, clang::SourceLocation const&)
Line
Count
Source
202
6
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
6
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
6
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
6
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
6
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
6
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
6
    }
llvm::Expected<std::__1::tuple<clang::QualType, clang::TypeSourceInfo*, clang::SourceLocation, clang::SourceLocation> > clang::ASTNodeImporter::importSeq<clang::QualType, clang::TypeSourceInfo*, clang::SourceLocation, clang::SourceLocation>(clang::QualType const&, clang::TypeSourceInfo* const&, clang::SourceLocation const&, clang::SourceLocation const&)
Line
Count
Source
202
8
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
8
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
8
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
8
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
8
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
8
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
8
    }
llvm::Expected<std::__1::tuple<clang::TypeSourceInfo*, clang::SourceLocation, clang::SourceLocation> > clang::ASTNodeImporter::importSeq<clang::TypeSourceInfo*, clang::SourceLocation, clang::SourceLocation>(clang::TypeSourceInfo* const&, clang::SourceLocation const&, clang::SourceLocation const&)
Line
Count
Source
202
12
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
12
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
12
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
12
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
12
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
12
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
12
    }
llvm::Expected<std::__1::tuple<clang::Selector, clang::Selector, clang::SourceLocation, clang::SourceLocation, clang::ObjCMethodDecl*, clang::ObjCMethodDecl*, clang::ObjCIvarDecl*> > clang::ASTNodeImporter::importSeq<clang::Selector, clang::Selector, clang::SourceLocation, clang::SourceLocation, clang::ObjCMethodDecl*, clang::ObjCMethodDecl*, clang::ObjCIvarDecl*>(clang::Selector const&, clang::Selector const&, clang::SourceLocation const&, clang::SourceLocation const&, clang::ObjCMethodDecl* const&, clang::ObjCMethodDecl* const&, clang::ObjCIvarDecl* const&)
Line
Count
Source
202
7
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
7
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
7
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
7
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
7
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
7
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
7
    }
llvm::Expected<std::__1::tuple<clang::Selector, clang::SourceLocation, clang::SourceLocation, clang::ObjCMethodDecl*, clang::ObjCMethodDecl*, clang::ObjCIvarDecl*> > clang::ASTNodeImporter::importSeq<clang::Selector, clang::SourceLocation, clang::SourceLocation, clang::ObjCMethodDecl*, clang::ObjCMethodDecl*, clang::ObjCIvarDecl*>(clang::Selector const&, clang::SourceLocation const&, clang::SourceLocation const&, clang::ObjCMethodDecl* const&, clang::ObjCMethodDecl* const&, clang::ObjCIvarDecl* const&)
Line
Count
Source
202
7
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
7
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
7
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
7
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
7
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
7
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
7
    }
llvm::Expected<std::__1::tuple<clang::SourceLocation, clang::SourceLocation, clang::ObjCMethodDecl*, clang::ObjCMethodDecl*, clang::ObjCIvarDecl*> > clang::ASTNodeImporter::importSeq<clang::SourceLocation, clang::SourceLocation, clang::ObjCMethodDecl*, clang::ObjCMethodDecl*, clang::ObjCIvarDecl*>(clang::SourceLocation const&, clang::SourceLocation const&, clang::ObjCMethodDecl* const&, clang::ObjCMethodDecl* const&, clang::ObjCIvarDecl* const&)
Line
Count
Source
202
7
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
7
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
7
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
7
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
7
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
7
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
7
    }
llvm::Expected<std::__1::tuple<clang::SourceLocation, clang::ObjCMethodDecl*, clang::ObjCMethodDecl*, clang::ObjCIvarDecl*> > clang::ASTNodeImporter::importSeq<clang::SourceLocation, clang::ObjCMethodDecl*, clang::ObjCMethodDecl*, clang::ObjCIvarDecl*>(clang::SourceLocation const&, clang::ObjCMethodDecl* const&, clang::ObjCMethodDecl* const&, clang::ObjCIvarDecl* const&)
Line
Count
Source
202
7
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
7
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
7
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
7
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
7
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
7
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
7
    }
llvm::Expected<std::__1::tuple<clang::ObjCMethodDecl*, clang::ObjCMethodDecl*, clang::ObjCIvarDecl*> > clang::ASTNodeImporter::importSeq<clang::ObjCMethodDecl*, clang::ObjCMethodDecl*, clang::ObjCIvarDecl*>(clang::ObjCMethodDecl* const&, clang::ObjCMethodDecl* const&, clang::ObjCIvarDecl* const&)
Line
Count
Source
202
7
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
7
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
7
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
7
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
7
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
7
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
7
    }
llvm::Expected<std::__1::tuple<clang::ObjCMethodDecl*, clang::ObjCIvarDecl*> > clang::ASTNodeImporter::importSeq<clang::ObjCMethodDecl*, clang::ObjCIvarDecl*>(clang::ObjCMethodDecl* const&, clang::ObjCIvarDecl* const&)
Line
Count
Source
202
7
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
7
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
7
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
7
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
7
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
7
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
7
    }
llvm::Expected<std::__1::tuple<clang::DeclarationName, clang::SourceLocation, clang::QualType, clang::TypeSourceInfo*, clang::SourceLocation> > clang::ASTNodeImporter::importSeq<clang::DeclarationName, clang::SourceLocation, clang::QualType, clang::TypeSourceInfo*, clang::SourceLocation>(clang::DeclarationName const&, clang::SourceLocation const&, clang::QualType const&, clang::TypeSourceInfo* const&, clang::SourceLocation const&)
Line
Count
Source
202
51
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
51
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
51
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
51
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
51
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
51
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
51
    }
llvm::Expected<std::__1::tuple<clang::SourceLocation, clang::QualType, clang::TypeSourceInfo*, clang::SourceLocation> > clang::ASTNodeImporter::importSeq<clang::SourceLocation, clang::QualType, clang::TypeSourceInfo*, clang::SourceLocation>(clang::SourceLocation const&, clang::QualType const&, clang::TypeSourceInfo* const&, clang::SourceLocation const&)
Line
Count
Source
202
51
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
51
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
51
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
51
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
51
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
51
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
51
    }
llvm::Expected<std::__1::tuple<clang::DeclGroupRef, clang::SourceLocation, clang::SourceLocation> > clang::ASTNodeImporter::importSeq<clang::DeclGroupRef, clang::SourceLocation, clang::SourceLocation>(clang::DeclGroupRef const&, clang::SourceLocation const&, clang::SourceLocation const&)
Line
Count
Source
202
253
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
253
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
253
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
253
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
253
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
253
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
253
    }
llvm::Expected<std::__1::tuple<clang::Expr*, clang::Expr*, clang::Stmt*, clang::SourceLocation, clang::SourceLocation, clang::SourceLocation> > clang::ASTNodeImporter::importSeq<clang::Expr*, clang::Expr*, clang::Stmt*, clang::SourceLocation, clang::SourceLocation, clang::SourceLocation>(clang::Expr* const&, clang::Expr* const&, clang::Stmt* const&, clang::SourceLocation const&, clang::SourceLocation const&, clang::SourceLocation const&)
Line
Count
Source
202
18
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
18
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
18
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
18
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
18
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
18
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
18
    }
llvm::Expected<std::__1::tuple<clang::Expr*, clang::Stmt*, clang::SourceLocation, clang::SourceLocation, clang::SourceLocation> > clang::ASTNodeImporter::importSeq<clang::Expr*, clang::Stmt*, clang::SourceLocation, clang::SourceLocation, clang::SourceLocation>(clang::Expr* const&, clang::Stmt* const&, clang::SourceLocation const&, clang::SourceLocation const&, clang::SourceLocation const&)
Line
Count
Source
202
28
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
28
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
28
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
28
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
28
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
28
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
28
    }
llvm::Expected<std::__1::tuple<clang::Stmt*, clang::SourceLocation, clang::SourceLocation, clang::SourceLocation> > clang::ASTNodeImporter::importSeq<clang::Stmt*, clang::SourceLocation, clang::SourceLocation, clang::SourceLocation>(clang::Stmt* const&, clang::SourceLocation const&, clang::SourceLocation const&, clang::SourceLocation const&)
Line
Count
Source
202
28
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
28
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
28
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
28
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
28
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
28
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
28
    }
llvm::Expected<std::__1::tuple<clang::SourceLocation, clang::SourceLocation, clang::Stmt*> > clang::ASTNodeImporter::importSeq<clang::SourceLocation, clang::SourceLocation, clang::Stmt*>(clang::SourceLocation const&, clang::SourceLocation const&, clang::Stmt* const&)
Line
Count
Source
202
2
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
2
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
2
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
2
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
2
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
2
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
2
    }
llvm::Expected<std::__1::tuple<clang::SourceLocation, clang::Stmt*> > clang::ASTNodeImporter::importSeq<clang::SourceLocation, clang::Stmt*>(clang::SourceLocation const&, clang::Stmt* const&)
Line
Count
Source
202
13
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
13
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
13
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
13
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
13
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
13
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
13
    }
llvm::Expected<std::__1::tuple<clang::SourceLocation, clang::LabelDecl*, clang::Stmt*> > clang::ASTNodeImporter::importSeq<clang::SourceLocation, clang::LabelDecl*, clang::Stmt*>(clang::SourceLocation const&, clang::LabelDecl* const&, clang::Stmt* const&)
Line
Count
Source
202
10
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
10
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
10
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
10
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
10
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
10
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
10
    }
llvm::Expected<std::__1::tuple<clang::LabelDecl*, clang::Stmt*> > clang::ASTNodeImporter::importSeq<clang::LabelDecl*, clang::Stmt*>(clang::LabelDecl* const&, clang::Stmt* const&)
Line
Count
Source
202
10
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
10
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
10
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
10
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
10
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
10
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
10
    }
llvm::Expected<std::__1::tuple<clang::SourceLocation, clang::Stmt*, clang::VarDecl*, clang::Expr*, clang::Stmt*, clang::SourceLocation, clang::Stmt*> > clang::ASTNodeImporter::importSeq<clang::SourceLocation, clang::Stmt*, clang::VarDecl*, clang::Expr*, clang::Stmt*, clang::SourceLocation, clang::Stmt*>(clang::SourceLocation const&, clang::Stmt* const&, clang::VarDecl* const&, clang::Expr* const&, clang::Stmt* const&, clang::SourceLocation const&, clang::Stmt* const&)
Line
Count
Source
202
11
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
11
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
11
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
11
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
11
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
11
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
11
    }
llvm::Expected<std::__1::tuple<clang::Stmt*, clang::VarDecl*, clang::Expr*, clang::Stmt*, clang::SourceLocation, clang::Stmt*> > clang::ASTNodeImporter::importSeq<clang::Stmt*, clang::VarDecl*, clang::Expr*, clang::Stmt*, clang::SourceLocation, clang::Stmt*>(clang::Stmt* const&, clang::VarDecl* const&, clang::Expr* const&, clang::Stmt* const&, clang::SourceLocation const&, clang::Stmt* const&)
Line
Count
Source
202
11
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
11
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
11
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
11
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
11
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
11
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
11
    }
llvm::Expected<std::__1::tuple<clang::VarDecl*, clang::Expr*, clang::Stmt*, clang::SourceLocation, clang::Stmt*> > clang::ASTNodeImporter::importSeq<clang::VarDecl*, clang::Expr*, clang::Stmt*, clang::SourceLocation, clang::Stmt*>(clang::VarDecl* const&, clang::Expr* const&, clang::Stmt* const&, clang::SourceLocation const&, clang::Stmt* const&)
Line
Count
Source
202
11
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
11
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
11
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
11
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
11
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
11
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
11
    }
llvm::Expected<std::__1::tuple<clang::Expr*, clang::Stmt*, clang::SourceLocation, clang::Stmt*> > clang::ASTNodeImporter::importSeq<clang::Expr*, clang::Stmt*, clang::SourceLocation, clang::Stmt*>(clang::Expr* const&, clang::Stmt* const&, clang::SourceLocation const&, clang::Stmt* const&)
Line
Count
Source
202
11
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
11
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
11
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
11
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
11
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
11
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
11
    }
llvm::Expected<std::__1::tuple<clang::Stmt*, clang::SourceLocation, clang::Stmt*> > clang::ASTNodeImporter::importSeq<clang::Stmt*, clang::SourceLocation, clang::Stmt*>(clang::Stmt* const&, clang::SourceLocation const&, clang::Stmt* const&)
Line
Count
Source
202
11
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
11
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
11
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
11
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
11
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
11
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
11
    }
llvm::Expected<std::__1::tuple<clang::Stmt*, clang::VarDecl*, clang::Expr*, clang::Stmt*, clang::SourceLocation> > clang::ASTNodeImporter::importSeq<clang::Stmt*, clang::VarDecl*, clang::Expr*, clang::Stmt*, clang::SourceLocation>(clang::Stmt* const&, clang::VarDecl* const&, clang::Expr* const&, clang::Stmt* const&, clang::SourceLocation const&)
Line
Count
Source
202
12
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
12
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
12
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
12
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
12
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
12
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
12
    }
llvm::Expected<std::__1::tuple<clang::VarDecl*, clang::Expr*, clang::Stmt*, clang::SourceLocation> > clang::ASTNodeImporter::importSeq<clang::VarDecl*, clang::Expr*, clang::Stmt*, clang::SourceLocation>(clang::VarDecl* const&, clang::Expr* const&, clang::Stmt* const&, clang::SourceLocation const&)
Line
Count
Source
202
18
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
18
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
18
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
18
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
18
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
18
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
18
    }
llvm::Expected<std::__1::tuple<clang::Expr*, clang::Stmt*, clang::SourceLocation> > clang::ASTNodeImporter::importSeq<clang::Expr*, clang::Stmt*, clang::SourceLocation>(clang::Expr* const&, clang::Stmt* const&, clang::SourceLocation const&)
Line
Count
Source
202
18
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
18
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
18
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
18
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
18
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
18
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
18
    }
llvm::Expected<std::__1::tuple<clang::Stmt*, clang::SourceLocation> > clang::ASTNodeImporter::importSeq<clang::Stmt*, clang::SourceLocation>(clang::Stmt* const&, clang::SourceLocation const&)
Line
Count
Source
202
18
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
18
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
18
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
18
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
18
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
18
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
18
    }
llvm::Expected<std::__1::tuple<clang::Stmt*, clang::Expr*, clang::SourceLocation, clang::SourceLocation, clang::SourceLocation> > clang::ASTNodeImporter::importSeq<clang::Stmt*, clang::Expr*, clang::SourceLocation, clang::SourceLocation, clang::SourceLocation>(clang::Stmt* const&, clang::Expr* const&, clang::SourceLocation const&, clang::SourceLocation const&, clang::SourceLocation const&)
Line
Count
Source
202
4
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
4
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
4
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
4
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
4
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
4
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
4
    }
llvm::Expected<std::__1::tuple<clang::Expr*, clang::SourceLocation, clang::SourceLocation, clang::SourceLocation> > clang::ASTNodeImporter::importSeq<clang::Expr*, clang::SourceLocation, clang::SourceLocation, clang::SourceLocation>(clang::Expr* const&, clang::SourceLocation const&, clang::SourceLocation const&, clang::SourceLocation const&)
Line
Count
Source
202
4
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
4
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
4
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
4
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
4
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
4
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
4
    }
llvm::Expected<std::__1::tuple<clang::Stmt*, clang::Expr*, clang::VarDecl*, clang::Expr*, clang::Stmt*, clang::SourceLocation, clang::SourceLocation, clang::SourceLocation> > clang::ASTNodeImporter::importSeq<clang::Stmt*, clang::Expr*, clang::VarDecl*, clang::Expr*, clang::Stmt*, clang::SourceLocation, clang::SourceLocation, clang::SourceLocation>(clang::Stmt* const&, clang::Expr* const&, clang::VarDecl* const&, clang::Expr* const&, clang::Stmt* const&, clang::SourceLocation const&, clang::SourceLocation const&, clang::SourceLocation const&)
Line
Count
Source
202
10
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
10
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
10
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
10
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
10
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
10
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
10
    }
llvm::Expected<std::__1::tuple<clang::Expr*, clang::VarDecl*, clang::Expr*, clang::Stmt*, clang::SourceLocation, clang::SourceLocation, clang::SourceLocation> > clang::ASTNodeImporter::importSeq<clang::Expr*, clang::VarDecl*, clang::Expr*, clang::Stmt*, clang::SourceLocation, clang::SourceLocation, clang::SourceLocation>(clang::Expr* const&, clang::VarDecl* const&, clang::Expr* const&, clang::Stmt* const&, clang::SourceLocation const&, clang::SourceLocation const&, clang::SourceLocation const&)
Line
Count
Source
202
10
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
10
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
10
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
10
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
10
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
10
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
10
    }
llvm::Expected<std::__1::tuple<clang::VarDecl*, clang::Expr*, clang::Stmt*, clang::SourceLocation, clang::SourceLocation, clang::SourceLocation> > clang::ASTNodeImporter::importSeq<clang::VarDecl*, clang::Expr*, clang::Stmt*, clang::SourceLocation, clang::SourceLocation, clang::SourceLocation>(clang::VarDecl* const&, clang::Expr* const&, clang::Stmt* const&, clang::SourceLocation const&, clang::SourceLocation const&, clang::SourceLocation const&)
Line
Count
Source
202
10
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
10
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
10
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
10
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
10
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
10
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
10
    }
llvm::Expected<std::__1::tuple<clang::LabelDecl*, clang::SourceLocation, clang::SourceLocation> > clang::ASTNodeImporter::importSeq<clang::LabelDecl*, clang::SourceLocation, clang::SourceLocation>(clang::LabelDecl* const&, clang::SourceLocation const&, clang::SourceLocation const&)
Line
Count
Source
202
4
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
4
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
4
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
4
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
4
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
4
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
4
    }
llvm::Expected<std::__1::tuple<clang::SourceLocation, clang::SourceLocation, clang::Expr*> > clang::ASTNodeImporter::importSeq<clang::SourceLocation, clang::SourceLocation, clang::Expr*>(clang::SourceLocation const&, clang::SourceLocation const&, clang::Expr* const&)
Line
Count
Source
202
25
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
25
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
25
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
25
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
25
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
25
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
25
    }
llvm::Expected<std::__1::tuple<clang::SourceLocation, clang::Expr*, clang::VarDecl const*> > clang::ASTNodeImporter::importSeq<clang::SourceLocation, clang::Expr*, clang::VarDecl const*>(clang::SourceLocation const&, clang::Expr* const&, clang::VarDecl const* const&)
Line
Count
Source
202
201
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
201
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
201
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
201
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
201
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
201
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
201
    }
llvm::Expected<std::__1::tuple<clang::Expr*, clang::VarDecl const*> > clang::ASTNodeImporter::importSeq<clang::Expr*, clang::VarDecl const*>(clang::Expr* const&, clang::VarDecl const* const&)
Line
Count
Source
202
201
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
201
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
201
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
201
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
201
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
201
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
201
    }
llvm::Expected<std::__1::tuple<clang::SourceLocation, clang::VarDecl*, clang::Stmt*> > clang::ASTNodeImporter::importSeq<clang::SourceLocation, clang::VarDecl*, clang::Stmt*>(clang::SourceLocation const&, clang::VarDecl* const&, clang::Stmt* const&)
Line
Count
Source
202
16
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
16
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
16
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
16
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
16
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
16
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
16
    }
llvm::Expected<std::__1::tuple<clang::VarDecl*, clang::Stmt*> > clang::ASTNodeImporter::importSeq<clang::VarDecl*, clang::Stmt*>(clang::VarDecl* const&, clang::Stmt* const&)
Line
Count
Source
202
16
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
16
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
16
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
16
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
16
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
16
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
16
    }
llvm::Expected<std::__1::tuple<clang::Stmt*, clang::DeclStmt*, clang::DeclStmt*, clang::DeclStmt*, clang::Expr*, clang::Expr*, clang::DeclStmt*, clang::Stmt*> > clang::ASTNodeImporter::importSeq<clang::Stmt*, clang::DeclStmt*, clang::DeclStmt*, clang::DeclStmt*, clang::Expr*, clang::Expr*, clang::DeclStmt*, clang::Stmt*>(clang::Stmt* const&, clang::DeclStmt* const&, clang::DeclStmt* const&, clang::DeclStmt* const&, clang::Expr* const&, clang::Expr* const&, clang::DeclStmt* const&, clang::Stmt* const&)
Line
Count
Source
202
2
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
2
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
2
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
2
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
2
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
2
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
2
    }
llvm::Expected<std::__1::tuple<clang::DeclStmt*, clang::DeclStmt*, clang::DeclStmt*, clang::Expr*, clang::Expr*, clang::DeclStmt*, clang::Stmt*> > clang::ASTNodeImporter::importSeq<clang::DeclStmt*, clang::DeclStmt*, clang::DeclStmt*, clang::Expr*, clang::Expr*, clang::DeclStmt*, clang::Stmt*>(clang::DeclStmt* const&, clang::DeclStmt* const&, clang::DeclStmt* const&, clang::Expr* const&, clang::Expr* const&, clang::DeclStmt* const&, clang::Stmt* const&)
Line
Count
Source
202
2
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
2
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
2
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
2
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
2
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
2
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
2
    }
llvm::Expected<std::__1::tuple<clang::DeclStmt*, clang::DeclStmt*, clang::Expr*, clang::Expr*, clang::DeclStmt*, clang::Stmt*> > clang::ASTNodeImporter::importSeq<clang::DeclStmt*, clang::DeclStmt*, clang::Expr*, clang::Expr*, clang::DeclStmt*, clang::Stmt*>(clang::DeclStmt* const&, clang::DeclStmt* const&, clang::Expr* const&, clang::Expr* const&, clang::DeclStmt* const&, clang::Stmt* const&)
Line
Count
Source
202
2
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
2
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
2
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
2
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
2
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
2
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
2
    }
llvm::Expected<std::__1::tuple<clang::DeclStmt*, clang::Expr*, clang::Expr*, clang::DeclStmt*, clang::Stmt*> > clang::ASTNodeImporter::importSeq<clang::DeclStmt*, clang::Expr*, clang::Expr*, clang::DeclStmt*, clang::Stmt*>(clang::DeclStmt* const&, clang::Expr* const&, clang::Expr* const&, clang::DeclStmt* const&, clang::Stmt* const&)
Line
Count
Source
202
2
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
2
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
2
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
2
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
2
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
2
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
2
    }
llvm::Expected<std::__1::tuple<clang::Expr*, clang::Expr*, clang::DeclStmt*, clang::Stmt*> > clang::ASTNodeImporter::importSeq<clang::Expr*, clang::Expr*, clang::DeclStmt*, clang::Stmt*>(clang::Expr* const&, clang::Expr* const&, clang::DeclStmt* const&, clang::Stmt* const&)
Line
Count
Source
202
2
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
2
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
2
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
2
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
2
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
2
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
2
    }
llvm::Expected<std::__1::tuple<clang::Expr*, clang::DeclStmt*, clang::Stmt*> > clang::ASTNodeImporter::importSeq<clang::Expr*, clang::DeclStmt*, clang::Stmt*>(clang::Expr* const&, clang::DeclStmt* const&, clang::Stmt* const&)
Line
Count
Source
202
2
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
2
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
2
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
2
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
2
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
2
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
2
    }
llvm::Expected<std::__1::tuple<clang::DeclStmt*, clang::Stmt*> > clang::ASTNodeImporter::importSeq<clang::DeclStmt*, clang::Stmt*>(clang::DeclStmt* const&, clang::Stmt* const&)
Line
Count
Source
202
2
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
2
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
2
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
2
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
2
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
2
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
2
    }
Unexecuted instantiation: llvm::Expected<std::__1::tuple<clang::Stmt*, clang::Expr*, clang::Stmt*, clang::SourceLocation, clang::SourceLocation> > clang::ASTNodeImporter::importSeq<clang::Stmt*, clang::Expr*, clang::Stmt*, clang::SourceLocation, clang::SourceLocation>(clang::Stmt* const&, clang::Expr* const&, clang::Stmt* const&, clang::SourceLocation const&, clang::SourceLocation const&)
Unexecuted instantiation: llvm::Expected<std::__1::tuple<clang::Expr*, clang::Stmt*, clang::SourceLocation, clang::SourceLocation> > clang::ASTNodeImporter::importSeq<clang::Expr*, clang::Stmt*, clang::SourceLocation, clang::SourceLocation>(clang::Expr* const&, clang::Stmt* const&, clang::SourceLocation const&, clang::SourceLocation const&)
Unexecuted instantiation: llvm::Expected<std::__1::tuple<clang::Stmt*, clang::SourceLocation, clang::SourceLocation> > clang::ASTNodeImporter::importSeq<clang::Stmt*, clang::SourceLocation, clang::SourceLocation>(clang::Stmt* const&, clang::SourceLocation const&, clang::SourceLocation const&)
llvm::Expected<std::__1::tuple<clang::SourceLocation, clang::SourceLocation, clang::VarDecl*, clang::Stmt*> > clang::ASTNodeImporter::importSeq<clang::SourceLocation, clang::SourceLocation, clang::VarDecl*, clang::Stmt*>(clang::SourceLocation const&, clang::SourceLocation const&, clang::VarDecl* const&, clang::Stmt* const&)
Line
Count
Source
202
6
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
6
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
6
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
6
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
6
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
6
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
6
    }
llvm::Expected<std::__1::tuple<clang::SourceLocation, clang::Stmt*, clang::ObjCAtFinallyStmt*> > clang::ASTNodeImporter::importSeq<clang::SourceLocation, clang::Stmt*, clang::ObjCAtFinallyStmt*>(clang::SourceLocation const&, clang::Stmt* const&, clang::ObjCAtFinallyStmt* const&)
Line
Count
Source
202
6
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
6
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
6
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
6
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
6
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
6
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
6
    }
llvm::Expected<std::__1::tuple<clang::Stmt*, clang::ObjCAtFinallyStmt*> > clang::ASTNodeImporter::importSeq<clang::Stmt*, clang::ObjCAtFinallyStmt*>(clang::Stmt* const&, clang::ObjCAtFinallyStmt* const&)
Line
Count
Source
202
6
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
6
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
6
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
6
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
6
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
6
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
6
    }
Unexecuted instantiation: llvm::Expected<std::__1::tuple<clang::SourceLocation, clang::Expr*, clang::CompoundStmt*> > clang::ASTNodeImporter::importSeq<clang::SourceLocation, clang::Expr*, clang::CompoundStmt*>(clang::SourceLocation const&, clang::Expr* const&, clang::CompoundStmt* const&)
Unexecuted instantiation: llvm::Expected<std::__1::tuple<clang::Expr*, clang::CompoundStmt*> > clang::ASTNodeImporter::importSeq<clang::Expr*, clang::CompoundStmt*>(clang::Expr* const&, clang::CompoundStmt* const&)
llvm::Expected<std::__1::tuple<clang::SourceLocation, clang::Expr*, clang::TypeSourceInfo*, clang::SourceLocation, clang::QualType> > clang::ASTNodeImporter::importSeq<clang::SourceLocation, clang::Expr*, clang::TypeSourceInfo*, clang::SourceLocation, clang::QualType>(clang::SourceLocation const&, clang::Expr* const&, clang::TypeSourceInfo* const&, clang::SourceLocation const&, clang::QualType const&)
Line
Count
Source
202
4
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
4
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
4
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
4
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
4
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
4
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
4
    }
llvm::Expected<std::__1::tuple<clang::Expr*, clang::TypeSourceInfo*, clang::SourceLocation, clang::QualType> > clang::ASTNodeImporter::importSeq<clang::Expr*, clang::TypeSourceInfo*, clang::SourceLocation, clang::QualType>(clang::Expr* const&, clang::TypeSourceInfo* const&, clang::SourceLocation const&, clang::QualType const&)
Line
Count
Source
202
4
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
4
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
4
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
4
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
4
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
4
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
4
    }
llvm::Expected<std::__1::tuple<clang::TypeSourceInfo*, clang::SourceLocation, clang::QualType> > clang::ASTNodeImporter::importSeq<clang::TypeSourceInfo*, clang::SourceLocation, clang::QualType>(clang::TypeSourceInfo* const&, clang::SourceLocation const&, clang::QualType const&)
Line
Count
Source
202
4
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
4
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
4
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
4
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
4
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
4
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
4
    }
llvm::Expected<std::__1::tuple<clang::Expr*, clang::Expr*, clang::Expr*, clang::SourceLocation, clang::SourceLocation, clang::QualType> > clang::ASTNodeImporter::importSeq<clang::Expr*, clang::Expr*, clang::Expr*, clang::SourceLocation, clang::SourceLocation, clang::QualType>(clang::Expr* const&, clang::Expr* const&, clang::Expr* const&, clang::SourceLocation const&, clang::SourceLocation const&, clang::QualType const&)
Line
Count
Source
202
18
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
18
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
18
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
18
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
18
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
18
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
18
    }
llvm::Expected<std::__1::tuple<clang::Expr*, clang::Expr*, clang::SourceLocation, clang::SourceLocation, clang::QualType> > clang::ASTNodeImporter::importSeq<clang::Expr*, clang::Expr*, clang::SourceLocation, clang::SourceLocation, clang::QualType>(clang::Expr* const&, clang::Expr* const&, clang::SourceLocation const&, clang::SourceLocation const&, clang::QualType const&)
Line
Count
Source
202
18
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
18
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
18
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
18
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
18
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
18
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
18
    }
llvm::Expected<std::__1::tuple<clang::Expr*, clang::SourceLocation, clang::SourceLocation, clang::QualType> > clang::ASTNodeImporter::importSeq<clang::Expr*, clang::SourceLocation, clang::SourceLocation, clang::QualType>(clang::Expr* const&, clang::SourceLocation const&, clang::SourceLocation const&, clang::QualType const&)
Line
Count
Source
202
18
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
18
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
18
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
18
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
18
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
18
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
18
    }
llvm::Expected<std::__1::tuple<clang::SourceLocation, clang::QualType, clang::StringLiteral*> > clang::ASTNodeImporter::importSeq<clang::SourceLocation, clang::QualType, clang::StringLiteral*>(clang::SourceLocation const&, clang::QualType const&, clang::StringLiteral* const&)
Line
Count
Source
202
4
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
4
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
4
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
4
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
4
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
4
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
4
    }
llvm::Expected<std::__1::tuple<clang::QualType, clang::StringLiteral*> > clang::ASTNodeImporter::importSeq<clang::QualType, clang::StringLiteral*>(clang::QualType const&, clang::StringLiteral* const&)
Line
Count
Source
202
4
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
4
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
4
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
4
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
4
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
4
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
4
    }
llvm::Expected<std::__1::tuple<clang::NestedNameSpecifierLoc, clang::SourceLocation, clang::ValueDecl*, clang::SourceLocation, clang::QualType> > clang::ASTNodeImporter::importSeq<clang::NestedNameSpecifierLoc, clang::SourceLocation, clang::ValueDecl*, clang::SourceLocation, clang::QualType>(clang::NestedNameSpecifierLoc const&, clang::SourceLocation const&, clang::ValueDecl* const&, clang::SourceLocation const&, clang::QualType const&)
Line
Count
Source
202
489
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
489
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
489
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
489
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
489
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
489
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
489
    }
llvm::Expected<std::__1::tuple<clang::SourceLocation, clang::ValueDecl*, clang::SourceLocation, clang::QualType> > clang::ASTNodeImporter::importSeq<clang::SourceLocation, clang::ValueDecl*, clang::SourceLocation, clang::QualType>(clang::SourceLocation const&, clang::ValueDecl* const&, clang::SourceLocation const&, clang::QualType const&)
Line
Count
Source
202
489
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
489
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
489
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
489
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
489
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
489
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
489
    }
llvm::Expected<std::__1::tuple<clang::ValueDecl*, clang::SourceLocation, clang::QualType> > clang::ASTNodeImporter::importSeq<clang::ValueDecl*, clang::SourceLocation, clang::QualType>(clang::ValueDecl* const&, clang::SourceLocation const&, clang::QualType const&)
Line
Count
Source
202
489
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
489
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
489
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
489
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
489
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
489
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
489
    }
llvm::Expected<std::__1::tuple<clang::SourceLocation, clang::TypeSourceInfo*, clang::QualType, clang::Expr*> > clang::ASTNodeImporter::importSeq<clang::SourceLocation, clang::TypeSourceInfo*, clang::QualType, clang::Expr*>(clang::SourceLocation const&, clang::TypeSourceInfo* const&, clang::QualType const&, clang::Expr* const&)
Line
Count
Source
202
4
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
4
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
4
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
4
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
4
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
4
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
4
    }
llvm::Expected<std::__1::tuple<clang::TypeSourceInfo*, clang::QualType, clang::Expr*> > clang::ASTNodeImporter::importSeq<clang::TypeSourceInfo*, clang::QualType, clang::Expr*>(clang::TypeSourceInfo* const&, clang::QualType const&, clang::Expr* const&)
Line
Count
Source
202
4
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
4
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
4
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
4
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
4
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
4
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
4
    }
llvm::Expected<std::__1::tuple<clang::QualType, clang::Expr*> > clang::ASTNodeImporter::importSeq<clang::QualType, clang::Expr*>(clang::QualType const&, clang::Expr* const&)
Line
Count
Source
202
14
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
14
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
14
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
14
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
14
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
14
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
14
    }
llvm::Expected<std::__1::tuple<clang::SourceLocation, clang::QualType, clang::SourceLocation> > clang::ASTNodeImporter::importSeq<clang::SourceLocation, clang::QualType, clang::SourceLocation>(clang::SourceLocation const&, clang::QualType const&, clang::SourceLocation const&)
Line
Count
Source
202
4
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
4
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
4
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
4
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
4
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
4
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
4
    }
llvm::Expected<std::__1::tuple<clang::QualType, clang::SourceLocation> > clang::ASTNodeImporter::importSeq<clang::QualType, clang::SourceLocation>(clang::QualType const&, clang::SourceLocation const&)
Line
Count
Source
202
301
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
301
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
301
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
301
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
301
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
301
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
301
    }
llvm::Expected<std::__1::tuple<clang::SourceLocation, clang::SourceLocation, clang::LabelDecl*, clang::QualType> > clang::ASTNodeImporter::importSeq<clang::SourceLocation, clang::SourceLocation, clang::LabelDecl*, clang::QualType>(clang::SourceLocation const&, clang::SourceLocation const&, clang::LabelDecl* const&, clang::QualType const&)
Line
Count
Source
202
6
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
6
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
6
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
6
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
6
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
6
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
6
    }
llvm::Expected<std::__1::tuple<clang::SourceLocation, clang::LabelDecl*, clang::QualType> > clang::ASTNodeImporter::importSeq<clang::SourceLocation, clang::LabelDecl*, clang::QualType>(clang::SourceLocation const&, clang::LabelDecl* const&, clang::QualType const&)
Line
Count
Source
202
6
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
6
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
6
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
6
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
6
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
6
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
6
    }
llvm::Expected<std::__1::tuple<clang::LabelDecl*, clang::QualType> > clang::ASTNodeImporter::importSeq<clang::LabelDecl*, clang::QualType>(clang::LabelDecl* const&, clang::QualType const&)
Line
Count
Source
202
6
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
6
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
6
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
6
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
6
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
6
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
6
    }
llvm::Expected<std::__1::tuple<clang::CompoundStmt*, clang::QualType, clang::SourceLocation, clang::SourceLocation> > clang::ASTNodeImporter::importSeq<clang::CompoundStmt*, clang::QualType, clang::SourceLocation, clang::SourceLocation>(clang::CompoundStmt* const&, clang::QualType const&, clang::SourceLocation const&, clang::SourceLocation const&)
Line
Count
Source
202
4
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
4
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
4
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
4
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
4
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
4
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
4
    }
llvm::Expected<std::__1::tuple<clang::Expr*, clang::QualType, clang::SourceLocation> > clang::ASTNodeImporter::importSeq<clang::Expr*, clang::QualType, clang::SourceLocation>(clang::Expr* const&, clang::QualType const&, clang::SourceLocation const&)
Line
Count
Source
202
281
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
281
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
281
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
281
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
281
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
281
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
281
    }
llvm::Expected<std::__1::tuple<clang::QualType, clang::SourceLocation, clang::SourceLocation> > clang::ASTNodeImporter::importSeq<clang::QualType, clang::SourceLocation, clang::SourceLocation>(clang::QualType const&, clang::SourceLocation const&, clang::SourceLocation const&)
Line
Count
Source
202
20
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
20
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
20
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
20
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
20
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
20
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
20
    }
llvm::Expected<std::__1::tuple<clang::Expr*, clang::Expr*, clang::QualType, clang::SourceLocation> > clang::ASTNodeImporter::importSeq<clang::Expr*, clang::Expr*, clang::QualType, clang::SourceLocation>(clang::Expr* const&, clang::Expr* const&, clang::QualType const&, clang::SourceLocation const&)
Line
Count
Source
202
95
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
95
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
95
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
95
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
95
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
95
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
95
    }
llvm::Expected<std::__1::tuple<clang::Expr*, clang::SourceLocation, clang::Expr*, clang::SourceLocation, clang::Expr*, clang::QualType> > clang::ASTNodeImporter::importSeq<clang::Expr*, clang::SourceLocation, clang::Expr*, clang::SourceLocation, clang::Expr*, clang::QualType>(clang::Expr* const&, clang::SourceLocation const&, clang::Expr* const&, clang::SourceLocation const&, clang::Expr* const&, clang::QualType const&)
Line
Count
Source
202
5
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
5
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
5
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
5
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
5
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
5
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
5
    }
llvm::Expected<std::__1::tuple<clang::SourceLocation, clang::Expr*, clang::SourceLocation, clang::Expr*, clang::QualType> > clang::ASTNodeImporter::importSeq<clang::SourceLocation, clang::Expr*, clang::SourceLocation, clang::Expr*, clang::QualType>(clang::SourceLocation const&, clang::Expr* const&, clang::SourceLocation const&, clang::Expr* const&, clang::QualType const&)
Line
Count
Source
202
5
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
5
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
5
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
5
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
5
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
5
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
5
    }
llvm::Expected<std::__1::tuple<clang::Expr*, clang::SourceLocation, clang::Expr*, clang::QualType> > clang::ASTNodeImporter::importSeq<clang::Expr*, clang::SourceLocation, clang::Expr*, clang::QualType>(clang::Expr* const&, clang::SourceLocation const&, clang::Expr* const&, clang::QualType const&)
Line
Count
Source
202
5
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
5
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
5
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
5
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
5
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
5
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
5
    }
llvm::Expected<std::__1::tuple<clang::SourceLocation, clang::Expr*, clang::QualType> > clang::ASTNodeImporter::importSeq<clang::SourceLocation, clang::Expr*, clang::QualType>(clang::SourceLocation const&, clang::Expr* const&, clang::QualType const&)
Line
Count
Source
202
5
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
5
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
5
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
5
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
5
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
5
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
5
    }
llvm::Expected<std::__1::tuple<clang::Expr*, clang::QualType> > clang::ASTNodeImporter::importSeq<clang::Expr*, clang::QualType>(clang::Expr* const&, clang::QualType const&)
Line
Count
Source
202
5
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
5
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
5
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
5
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
5
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
5
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
5
    }
llvm::Expected<std::__1::tuple<clang::Expr*, clang::OpaqueValueExpr*, clang::Expr*, clang::Expr*, clang::Expr*, clang::SourceLocation, clang::SourceLocation, clang::QualType> > clang::ASTNodeImporter::importSeq<clang::Expr*, clang::OpaqueValueExpr*, clang::Expr*, clang::Expr*, clang::Expr*, clang::SourceLocation, clang::SourceLocation, clang::QualType>(clang::Expr* const&, clang::OpaqueValueExpr* const&, clang::Expr* const&, clang::Expr* const&, clang::Expr* const&, clang::SourceLocation const&, clang::SourceLocation const&, clang::QualType const&)
Line
Count
Source
202
8
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
8
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
8
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
8
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
8
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
8
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
8
    }
llvm::Expected<std::__1::tuple<clang::OpaqueValueExpr*, clang::Expr*, clang::Expr*, clang::Expr*, clang::SourceLocation, clang::SourceLocation, clang::QualType> > clang::ASTNodeImporter::importSeq<clang::OpaqueValueExpr*, clang::Expr*, clang::Expr*, clang::Expr*, clang::SourceLocation, clang::SourceLocation, clang::QualType>(clang::OpaqueValueExpr* const&, clang::Expr* const&, clang::Expr* const&, clang::Expr* const&, clang::SourceLocation const&, clang::SourceLocation const&, clang::QualType const&)
Line
Count
Source
202
8
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
8
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
8
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
8
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
8
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
8
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
8
    }
llvm::Expected<std::__1::tuple<clang::SourceLocation, clang::TypeSourceInfo*, clang::Expr*, clang::SourceLocation, clang::QualType> > clang::ASTNodeImporter::importSeq<clang::SourceLocation, clang::TypeSourceInfo*, clang::Expr*, clang::SourceLocation, clang::QualType>(clang::SourceLocation const&, clang::TypeSourceInfo* const&, clang::Expr* const&, clang::SourceLocation const&, clang::QualType const&)
Line
Count
Source
202
2
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
2
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
2
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
2
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
2
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
2
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
2
    }
llvm::Expected<std::__1::tuple<clang::TypeSourceInfo*, clang::Expr*, clang::SourceLocation, clang::QualType> > clang::ASTNodeImporter::importSeq<clang::TypeSourceInfo*, clang::Expr*, clang::SourceLocation, clang::QualType>(clang::TypeSourceInfo* const&, clang::Expr* const&, clang::SourceLocation const&, clang::QualType const&)
Line
Count
Source
202
2
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
2
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
2
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
2
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
2
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
2
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
2
    }
llvm::Expected<std::__1::tuple<clang::Expr*, clang::SourceLocation, clang::QualType> > clang::ASTNodeImporter::importSeq<clang::Expr*, clang::SourceLocation, clang::QualType>(clang::Expr* const&, clang::SourceLocation const&, clang::QualType const&)
Line
Count
Source
202
3
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
3
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
3
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
3
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
3
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
3
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
3
    }
llvm::Expected<std::__1::tuple<clang::SourceLocation, clang::Expr*, clang::SourceLocation, clang::QualType> > clang::ASTNodeImporter::importSeq<clang::SourceLocation, clang::Expr*, clang::SourceLocation, clang::QualType>(clang::SourceLocation const&, clang::Expr* const&, clang::SourceLocation const&, clang::QualType const&)
Line
Count
Source
202
1
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
1
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
1
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
1
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
1
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
1
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
1
    }
llvm::Expected<std::__1::tuple<clang::SourceLocation, clang::QualType, clang::Expr*> > clang::ASTNodeImporter::importSeq<clang::SourceLocation, clang::QualType, clang::Expr*>(clang::SourceLocation const&, clang::QualType const&, clang::Expr* const&)
Line
Count
Source
202
10
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
10
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
10
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
10
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
10
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
10
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
10
    }
llvm::Expected<std::__1::tuple<clang::Expr*, clang::Expr*, clang::QualType, clang::QualType, clang::QualType, clang::SourceLocation> > clang::ASTNodeImporter::importSeq<clang::Expr*, clang::Expr*, clang::QualType, clang::QualType, clang::QualType, clang::SourceLocation>(clang::Expr* const&, clang::Expr* const&, clang::QualType const&, clang::QualType const&, clang::QualType const&, clang::SourceLocation const&)
Line
Count
Source
202
16
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
16
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
16
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
16
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
16
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
16
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
16
    }
llvm::Expected<std::__1::tuple<clang::Expr*, clang::QualType, clang::QualType, clang::QualType, clang::SourceLocation> > clang::ASTNodeImporter::importSeq<clang::Expr*, clang::QualType, clang::QualType, clang::QualType, clang::SourceLocation>(clang::Expr* const&, clang::QualType const&, clang::QualType const&, clang::QualType const&, clang::SourceLocation const&)
Line
Count
Source
202
16
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
16
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
16
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
16
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
16
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
16
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
16
    }
llvm::Expected<std::__1::tuple<clang::QualType, clang::QualType, clang::QualType, clang::SourceLocation> > clang::ASTNodeImporter::importSeq<clang::QualType, clang::QualType, clang::QualType, clang::SourceLocation>(clang::QualType const&, clang::QualType const&, clang::QualType const&, clang::SourceLocation const&)
Line
Count
Source
202
16
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
16
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
16
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
16
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
16
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
16
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
16
    }
llvm::Expected<std::__1::tuple<clang::QualType, clang::QualType, clang::SourceLocation> > clang::ASTNodeImporter::importSeq<clang::QualType, clang::QualType, clang::SourceLocation>(clang::QualType const&, clang::QualType const&, clang::SourceLocation const&)
Line
Count
Source
202
16
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
16
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
16
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
16
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
16
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
16
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
16
    }
llvm::Expected<std::__1::tuple<clang::QualType, clang::Expr*, clang::TypeSourceInfo*> > clang::ASTNodeImporter::importSeq<clang::QualType, clang::Expr*, clang::TypeSourceInfo*>(clang::QualType const&, clang::Expr* const&, clang::TypeSourceInfo* const&)
Line
Count
Source
202
133
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
133
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
133
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
133
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
133
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
133
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
133
    }
llvm::Expected<std::__1::tuple<clang::Expr*, clang::TypeSourceInfo*> > clang::ASTNodeImporter::importSeq<clang::Expr*, clang::TypeSourceInfo*>(clang::Expr* const&, clang::TypeSourceInfo* const&)
Line
Count
Source
202
133
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
133
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
133
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
133
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
133
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
133
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
133
    }
llvm::Expected<std::__1::tuple<clang::SourceLocation, clang::SourceLocation> > clang::ASTNodeImporter::importSeq<clang::SourceLocation, clang::SourceLocation>(clang::SourceLocation const&, clang::SourceLocation const&)
Line
Count
Source
202
465
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
465
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
465
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
465
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
465
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
465
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
465
    }
llvm::Expected<std::__1::tuple<clang::QualType, clang::Expr*, clang::SourceLocation, clang::SourceLocation> > clang::ASTNodeImporter::importSeq<clang::QualType, clang::Expr*, clang::SourceLocation, clang::SourceLocation>(clang::QualType const&, clang::Expr* const&, clang::SourceLocation const&, clang::SourceLocation const&)
Line
Count
Source
202
2
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
2
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
2
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
2
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
2
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
2
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
2
    }
llvm::Expected<std::__1::tuple<clang::Expr*, clang::SourceLocation, clang::SourceLocation> > clang::ASTNodeImporter::importSeq<clang::Expr*, clang::SourceLocation, clang::SourceLocation>(clang::Expr* const&, clang::SourceLocation const&, clang::SourceLocation const&)
Line
Count
Source
202
2
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
2
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
2
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
2
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
2
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
2
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
2
    }
llvm::Expected<std::__1::tuple<clang::CXXConstructorDecl*, clang::QualType, clang::TypeSourceInfo*, clang::SourceRange> > clang::ASTNodeImporter::importSeq<clang::CXXConstructorDecl*, clang::QualType, clang::TypeSourceInfo*, clang::SourceRange>(clang::CXXConstructorDecl* const&, clang::QualType const&, clang::TypeSourceInfo* const&, clang::SourceRange const&)
Line
Count
Source
202
16
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
16
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
16
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
16
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
16
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
16
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
16
    }
llvm::Expected<std::__1::tuple<clang::QualType, clang::TypeSourceInfo*, clang::SourceRange> > clang::ASTNodeImporter::importSeq<clang::QualType, clang::TypeSourceInfo*, clang::SourceRange>(clang::QualType const&, clang::TypeSourceInfo* const&, clang::SourceRange const&)
Line
Count
Source
202
16
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
16
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
16
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
16
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
16
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
16
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
16
    }
llvm::Expected<std::__1::tuple<clang::TypeSourceInfo*, clang::SourceRange> > clang::ASTNodeImporter::importSeq<clang::TypeSourceInfo*, clang::SourceRange>(clang::TypeSourceInfo* const&, clang::SourceRange const&)
Line
Count
Source
202
16
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
16
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
16
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
16
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
16
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
16
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
16
    }
llvm::Expected<std::__1::tuple<clang::QualType, clang::Expr*, clang::ValueDecl const*> > clang::ASTNodeImporter::importSeq<clang::QualType, clang::Expr*, clang::ValueDecl const*>(clang::QualType const&, clang::Expr* const&, clang::ValueDecl const* const&)
Line
Count
Source
202
27
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
27
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
27
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
27
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
27
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
27
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
27
    }
llvm::Expected<std::__1::tuple<clang::Expr*, clang::ValueDecl const*> > clang::ASTNodeImporter::importSeq<clang::Expr*, clang::ValueDecl const*>(clang::Expr* const&, clang::ValueDecl const* const&)
Line
Count
Source
202
27
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
27
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
27
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
27
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
27
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
27
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
27
    }
llvm::Expected<std::__1::tuple<clang::QualType, clang::Expr*, clang::SourceLocation> > clang::ASTNodeImporter::importSeq<clang::QualType, clang::Expr*, clang::SourceLocation>(clang::QualType const&, clang::Expr* const&, clang::SourceLocation const&)
Line
Count
Source
202
2
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
2
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
2
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
2
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
2
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
2
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
2
    }
llvm::Expected<std::__1::tuple<clang::SourceLocation, clang::NamedDecl*, clang::SourceLocation, clang::SourceLocation> > clang::ASTNodeImporter::importSeq<clang::SourceLocation, clang::NamedDecl*, clang::SourceLocation, clang::SourceLocation>(clang::SourceLocation const&, clang::NamedDecl* const&, clang::SourceLocation const&, clang::SourceLocation const&)
Line
Count
Source
202
12
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
12
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
12
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
12
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
12
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
12
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
12
    }
llvm::Expected<std::__1::tuple<clang::NamedDecl*, clang::SourceLocation, clang::SourceLocation> > clang::ASTNodeImporter::importSeq<clang::NamedDecl*, clang::SourceLocation, clang::SourceLocation>(clang::NamedDecl* const&, clang::SourceLocation const&, clang::SourceLocation const&)
Line
Count
Source
202
12
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
12
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
12
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
12
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
12
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
12
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
12
    }
llvm::Expected<std::__1::tuple<clang::FunctionDecl*, clang::FunctionDecl*, clang::SourceRange, llvm::Optional<clang::Expr*>, clang::Expr*, clang::QualType, clang::TypeSourceInfo*, clang::SourceRange, clang::SourceRange> > clang::ASTNodeImporter::importSeq<clang::FunctionDecl*, clang::FunctionDecl*, clang::SourceRange, llvm::Optional<clang::Expr*>, clang::Expr*, clang::QualType, clang::TypeSourceInfo*, clang::SourceRange, clang::SourceRange>(clang::FunctionDecl* const&, clang::FunctionDecl* const&, clang::SourceRange const&, llvm::Optional<clang::Expr*> const&, clang::Expr* const&, clang::QualType const&, clang::TypeSourceInfo* const&, clang::SourceRange const&, clang::SourceRange const&)
Line
Count
Source
202
3
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
3
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
3
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
3
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
3
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
3
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
3
    }
llvm::Expected<std::__1::tuple<clang::FunctionDecl*, clang::SourceRange, llvm::Optional<clang::Expr*>, clang::Expr*, clang::QualType, clang::TypeSourceInfo*, clang::SourceRange, clang::SourceRange> > clang::ASTNodeImporter::importSeq<clang::FunctionDecl*, clang::SourceRange, llvm::Optional<clang::Expr*>, clang::Expr*, clang::QualType, clang::TypeSourceInfo*, clang::SourceRange, clang::SourceRange>(clang::FunctionDecl* const&, clang::SourceRange const&, llvm::Optional<clang::Expr*> const&, clang::Expr* const&, clang::QualType const&, clang::TypeSourceInfo* const&, clang::SourceRange const&, clang::SourceRange const&)
Line
Count
Source
202
3
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
3
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
3
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
3
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
3
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
3
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
3
    }
llvm::Expected<std::__1::tuple<clang::SourceRange, llvm::Optional<clang::Expr*>, clang::Expr*, clang::QualType, clang::TypeSourceInfo*, clang::SourceRange, clang::SourceRange> > clang::ASTNodeImporter::importSeq<clang::SourceRange, llvm::Optional<clang::Expr*>, clang::Expr*, clang::QualType, clang::TypeSourceInfo*, clang::SourceRange, clang::SourceRange>(clang::SourceRange const&, llvm::Optional<clang::Expr*> const&, clang::Expr* const&, clang::QualType const&, clang::TypeSourceInfo* const&, clang::SourceRange const&, clang::SourceRange const&)
Line
Count
Source
202
3
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
3
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
3
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
3
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
3
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
3
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
3
    }
llvm::Expected<std::__1::tuple<llvm::Optional<clang::Expr*>, clang::Expr*, clang::QualType, clang::TypeSourceInfo*, clang::SourceRange, clang::SourceRange> > clang::ASTNodeImporter::importSeq<llvm::Optional<clang::Expr*>, clang::Expr*, clang::QualType, clang::TypeSourceInfo*, clang::SourceRange, clang::SourceRange>(llvm::Optional<clang::Expr*> const&, clang::Expr* const&, clang::QualType const&, clang::TypeSourceInfo* const&, clang::SourceRange const&, clang::SourceRange const&)
Line
Count
Source
202
3
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
3
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
3
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
3
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
3
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
3
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
3
    }
llvm::Expected<std::__1::tuple<clang::Expr*, clang::QualType, clang::TypeSourceInfo*, clang::SourceRange, clang::SourceRange> > clang::ASTNodeImporter::importSeq<clang::Expr*, clang::QualType, clang::TypeSourceInfo*, clang::SourceRange, clang::SourceRange>(clang::Expr* const&, clang::QualType const&, clang::TypeSourceInfo* const&, clang::SourceRange const&, clang::SourceRange const&)
Line
Count
Source
202
3
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
3
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
3
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
3
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
3
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
3
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
3
    }
llvm::Expected<std::__1::tuple<clang::QualType, clang::TypeSourceInfo*, clang::SourceRange, clang::SourceRange> > clang::ASTNodeImporter::importSeq<clang::QualType, clang::TypeSourceInfo*, clang::SourceRange, clang::SourceRange>(clang::QualType const&, clang::TypeSourceInfo* const&, clang::SourceRange const&, clang::SourceRange const&)
Line
Count
Source
202
3
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
3
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
3
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
3
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
3
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
3
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
3
    }
llvm::Expected<std::__1::tuple<clang::TypeSourceInfo*, clang::SourceRange, clang::SourceRange> > clang::ASTNodeImporter::importSeq<clang::TypeSourceInfo*, clang::SourceRange, clang::SourceRange>(clang::TypeSourceInfo* const&, clang::SourceRange const&, clang::SourceRange const&)
Line
Count
Source
202
3
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
3
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
3
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
3
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
3
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
3
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
3
    }
llvm::Expected<std::__1::tuple<clang::SourceRange, clang::SourceRange> > clang::ASTNodeImporter::importSeq<clang::SourceRange, clang::SourceRange>(clang::SourceRange const&, clang::SourceRange const&)
Line
Count
Source
202
3
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
3
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
3
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
3
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
3
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
3
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
3
    }
llvm::Expected<std::__1::tuple<clang::QualType, clang::FunctionDecl*, clang::Expr*, clang::SourceLocation> > clang::ASTNodeImporter::importSeq<clang::QualType, clang::FunctionDecl*, clang::Expr*, clang::SourceLocation>(clang::QualType const&, clang::FunctionDecl* const&, clang::Expr* const&, clang::SourceLocation const&)
Line
Count
Source
202
1
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
1
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
1
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
1
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
1
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
1
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
1
    }
llvm::Expected<std::__1::tuple<clang::FunctionDecl*, clang::Expr*, clang::SourceLocation> > clang::ASTNodeImporter::importSeq<clang::FunctionDecl*, clang::Expr*, clang::SourceLocation>(clang::FunctionDecl* const&, clang::Expr* const&, clang::SourceLocation const&)
Line
Count
Source
202
1
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
1
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
1
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
1
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
1
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
1
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
1
    }
llvm::Expected<std::__1::tuple<clang::QualType, clang::SourceLocation, clang::CXXConstructorDecl*, clang::SourceRange> > clang::ASTNodeImporter::importSeq<clang::QualType, clang::SourceLocation, clang::CXXConstructorDecl*, clang::SourceRange>(clang::QualType const&, clang::SourceLocation const&, clang::CXXConstructorDecl* const&, clang::SourceRange const&)
Line
Count
Source
202
108
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
108
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
108
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
108
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
108
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
108
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
108
    }
llvm::Expected<std::__1::tuple<clang::SourceLocation, clang::CXXConstructorDecl*, clang::SourceRange> > clang::ASTNodeImporter::importSeq<clang::SourceLocation, clang::CXXConstructorDecl*, clang::SourceRange>(clang::SourceLocation const&, clang::CXXConstructorDecl* const&, clang::SourceRange const&)
Line
Count
Source
202
108
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
108
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
108
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
108
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
108
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
108
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
108
    }
llvm::Expected<std::__1::tuple<clang::CXXConstructorDecl*, clang::SourceRange> > clang::ASTNodeImporter::importSeq<clang::CXXConstructorDecl*, clang::SourceRange>(clang::CXXConstructorDecl* const&, clang::SourceRange const&)
Line
Count
Source
202
108
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
108
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
108
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
108
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
108
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
108
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
108
    }
llvm::Expected<std::__1::tuple<clang::Expr*, clang::SourceLocation, clang::NestedNameSpecifierLoc, clang::SourceLocation, clang::ValueDecl*, clang::QualType> > clang::ASTNodeImporter::importSeq<clang::Expr*, clang::SourceLocation, clang::NestedNameSpecifierLoc, clang::SourceLocation, clang::ValueDecl*, clang::QualType>(clang::Expr* const&, clang::SourceLocation const&, clang::NestedNameSpecifierLoc const&, clang::SourceLocation const&, clang::ValueDecl* const&, clang::QualType const&)
Line
Count
Source
202
72
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
72
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
72
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
72
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
72
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
72
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
72
    }
llvm::Expected<std::__1::tuple<clang::SourceLocation, clang::NestedNameSpecifierLoc, clang::SourceLocation, clang::ValueDecl*, clang::QualType> > clang::ASTNodeImporter::importSeq<clang::SourceLocation, clang::NestedNameSpecifierLoc, clang::SourceLocation, clang::ValueDecl*, clang::QualType>(clang::SourceLocation const&, clang::NestedNameSpecifierLoc const&, clang::SourceLocation const&, clang::ValueDecl* const&, clang::QualType const&)
Line
Count
Source
202
72
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
72
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
72
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
72
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
72
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
72
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
72
    }
llvm::Expected<std::__1::tuple<clang::NestedNameSpecifierLoc, clang::SourceLocation, clang::ValueDecl*, clang::QualType> > clang::ASTNodeImporter::importSeq<clang::NestedNameSpecifierLoc, clang::SourceLocation, clang::ValueDecl*, clang::QualType>(clang::NestedNameSpecifierLoc const&, clang::SourceLocation const&, clang::ValueDecl* const&, clang::QualType const&)
Line
Count
Source
202
72
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
72
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
72
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
72
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
72
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
72
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
72
    }
llvm::Expected<std::__1::tuple<clang::SourceLocation, clang::ValueDecl*, clang::QualType> > clang::ASTNodeImporter::importSeq<clang::SourceLocation, clang::ValueDecl*, clang::QualType>(clang::SourceLocation const&, clang::ValueDecl* const&, clang::QualType const&)
Line
Count
Source
202
72
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
72
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
72
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
72
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
72
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
72
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
72
    }
llvm::Expected<std::__1::tuple<clang::ValueDecl*, clang::QualType> > clang::ASTNodeImporter::importSeq<clang::ValueDecl*, clang::QualType>(clang::ValueDecl* const&, clang::QualType const&)
Line
Count
Source
202
72
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
72
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
72
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
72
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
72
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
72
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
72
    }
llvm::Expected<std::__1::tuple<clang::NamedDecl*, clang::DeclarationName, clang::SourceLocation, clang::SourceLocation, clang::SourceLocation> > clang::ASTNodeImporter::importSeq<clang::NamedDecl*, clang::DeclarationName, clang::SourceLocation, clang::SourceLocation, clang::SourceLocation>(clang::NamedDecl* const&, clang::DeclarationName const&, clang::SourceLocation const&, clang::SourceLocation const&, clang::SourceLocation const&)
Line
Count
Source
202
72
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
72
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
72
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
72
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
72
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
72
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
72
    }
llvm::Expected<std::__1::tuple<clang::DeclarationName, clang::SourceLocation, clang::SourceLocation, clang::SourceLocation> > clang::ASTNodeImporter::importSeq<clang::DeclarationName, clang::SourceLocation, clang::SourceLocation, clang::SourceLocation>(clang::DeclarationName const&, clang::SourceLocation const&, clang::SourceLocation const&, clang::SourceLocation const&)
Line
Count
Source
202
80
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
80
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
80
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
80
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
80
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
80
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
80
    }
llvm::Expected<std::__1::tuple<clang::Expr*, clang::SourceLocation, clang::NestedNameSpecifierLoc, clang::TypeSourceInfo*, clang::SourceLocation, clang::SourceLocation> > clang::ASTNodeImporter::importSeq<clang::Expr*, clang::SourceLocation, clang::NestedNameSpecifierLoc, clang::TypeSourceInfo*, clang::SourceLocation, clang::SourceLocation>(clang::Expr* const&, clang::SourceLocation const&, clang::NestedNameSpecifierLoc const&, clang::TypeSourceInfo* const&, clang::SourceLocation const&, clang::SourceLocation const&)
Line
Count
Source
202
4
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
4
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
4
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
4
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
4
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
4
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
4
    }
llvm::Expected<std::__1::tuple<clang::SourceLocation, clang::NestedNameSpecifierLoc, clang::TypeSourceInfo*, clang::SourceLocation, clang::SourceLocation> > clang::ASTNodeImporter::importSeq<clang::SourceLocation, clang::NestedNameSpecifierLoc, clang::TypeSourceInfo*, clang::SourceLocation, clang::SourceLocation>(clang::SourceLocation const&, clang::NestedNameSpecifierLoc const&, clang::TypeSourceInfo* const&, clang::SourceLocation const&, clang::SourceLocation const&)
Line
Count
Source
202
4
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
4
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
4
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
4
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
4
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
4
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
4
    }
llvm::Expected<std::__1::tuple<clang::NestedNameSpecifierLoc, clang::TypeSourceInfo*, clang::SourceLocation, clang::SourceLocation> > clang::ASTNodeImporter::importSeq<clang::NestedNameSpecifierLoc, clang::TypeSourceInfo*, clang::SourceLocation, clang::SourceLocation>(clang::NestedNameSpecifierLoc const&, clang::TypeSourceInfo* const&, clang::SourceLocation const&, clang::SourceLocation const&)
Line
Count
Source
202
4
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
4
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
4
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
4
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
4
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
4
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
4
    }
llvm::Expected<std::__1::tuple<clang::QualType, clang::SourceLocation, clang::NestedNameSpecifierLoc, clang::SourceLocation, clang::NamedDecl*> > clang::ASTNodeImporter::importSeq<clang::QualType, clang::SourceLocation, clang::NestedNameSpecifierLoc, clang::SourceLocation, clang::NamedDecl*>(clang::QualType const&, clang::SourceLocation const&, clang::NestedNameSpecifierLoc const&, clang::SourceLocation const&, clang::NamedDecl* const&)
Line
Count
Source
202
16
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
16
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
16
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
16
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
16
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
16
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
16
    }
llvm::Expected<std::__1::tuple<clang::SourceLocation, clang::NestedNameSpecifierLoc, clang::SourceLocation, clang::NamedDecl*> > clang::ASTNodeImporter::importSeq<clang::SourceLocation, clang::NestedNameSpecifierLoc, clang::SourceLocation, clang::NamedDecl*>(clang::SourceLocation const&, clang::NestedNameSpecifierLoc const&, clang::SourceLocation const&, clang::NamedDecl* const&)
Line
Count
Source
202
16
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
16
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
16
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
16
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
16
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
16
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
16
    }
llvm::Expected<std::__1::tuple<clang::NestedNameSpecifierLoc, clang::SourceLocation, clang::NamedDecl*> > clang::ASTNodeImporter::importSeq<clang::NestedNameSpecifierLoc, clang::SourceLocation, clang::NamedDecl*>(clang::NestedNameSpecifierLoc const&, clang::SourceLocation const&, clang::NamedDecl* const&)
Line
Count
Source
202
16
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
16
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
16
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
16
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
16
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
16
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
16
    }
llvm::Expected<std::__1::tuple<clang::SourceLocation, clang::NamedDecl*> > clang::ASTNodeImporter::importSeq<clang::SourceLocation, clang::NamedDecl*>(clang::SourceLocation const&, clang::NamedDecl* const&)
Line
Count
Source
202
16
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
16
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
16
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
16
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
16
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
16
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
16
    }
llvm::Expected<std::__1::tuple<clang::DeclarationName, clang::SourceLocation> > clang::ASTNodeImporter::importSeq<clang::DeclarationName, clang::SourceLocation>(clang::DeclarationName const&, clang::SourceLocation const&)
Line
Count
Source
202
34
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
34
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
34
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
34
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
34
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
34
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
34
    }
llvm::Expected<std::__1::tuple<clang::NestedNameSpecifierLoc, clang::SourceLocation, clang::DeclarationName, clang::SourceLocation, clang::SourceLocation, clang::SourceLocation> > clang::ASTNodeImporter::importSeq<clang::NestedNameSpecifierLoc, clang::SourceLocation, clang::DeclarationName, clang::SourceLocation, clang::SourceLocation, clang::SourceLocation>(clang::NestedNameSpecifierLoc const&, clang::SourceLocation const&, clang::DeclarationName const&, clang::SourceLocation const&, clang::SourceLocation const&, clang::SourceLocation const&)
Line
Count
Source
202
8
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
8
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
8
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
8
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
8
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
8
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
8
    }
llvm::Expected<std::__1::tuple<clang::SourceLocation, clang::DeclarationName, clang::SourceLocation, clang::SourceLocation, clang::SourceLocation> > clang::ASTNodeImporter::importSeq<clang::SourceLocation, clang::DeclarationName, clang::SourceLocation, clang::SourceLocation, clang::SourceLocation>(clang::SourceLocation const&, clang::DeclarationName const&, clang::SourceLocation const&, clang::SourceLocation const&, clang::SourceLocation const&)
Line
Count
Source
202
8
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
8
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
8
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
8
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
8
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
8
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
8
    }
llvm::Expected<std::__1::tuple<clang::SourceLocation, clang::SourceLocation, clang::TypeSourceInfo*> > clang::ASTNodeImporter::importSeq<clang::SourceLocation, clang::SourceLocation, clang::TypeSourceInfo*>(clang::SourceLocation const&, clang::SourceLocation const&, clang::TypeSourceInfo* const&)
Line
Count
Source
202
18
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
18
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
18
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
18
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
18
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
18
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
18
    }
llvm::Expected<std::__1::tuple<clang::QualType, clang::SourceLocation, clang::NestedNameSpecifierLoc, clang::SourceLocation> > clang::ASTNodeImporter::importSeq<clang::QualType, clang::SourceLocation, clang::NestedNameSpecifierLoc, clang::SourceLocation>(clang::QualType const&, clang::SourceLocation const&, clang::NestedNameSpecifierLoc const&, clang::SourceLocation const&)
Line
Count
Source
202
8
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
8
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
8
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
8
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
8
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
8
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
8
    }
llvm::Expected<std::__1::tuple<clang::SourceRange, clang::SourceLocation, clang::SourceLocation> > clang::ASTNodeImporter::importSeq<clang::SourceRange, clang::SourceLocation, clang::SourceLocation>(clang::SourceRange const&, clang::SourceLocation const&, clang::SourceLocation const&)
Line
Count
Source
202
23
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
23
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
23
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
23
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
23
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
23
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
23
    }
llvm::Expected<std::__1::tuple<clang::SourceLocation, clang::SourceLocation, clang::QualType> > clang::ASTNodeImporter::importSeq<clang::SourceLocation, clang::SourceLocation, clang::QualType>(clang::SourceLocation const&, clang::SourceLocation const&, clang::QualType const&)
Line
Count
Source
202
136
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
136
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
136
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
136
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
136
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
136
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
136
    }
llvm::Expected<std::__1::tuple<clang::SourceLocation, clang::QualType, clang::CXXConstructorDecl*> > clang::ASTNodeImporter::importSeq<clang::SourceLocation, clang::QualType, clang::CXXConstructorDecl*>(clang::SourceLocation const&, clang::QualType const&, clang::CXXConstructorDecl* const&)
Line
Count
Source
202
2
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
2
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
2
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
2
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
2
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
2
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
2
    }
llvm::Expected<std::__1::tuple<clang::QualType, clang::CXXConstructorDecl*> > clang::ASTNodeImporter::importSeq<clang::QualType, clang::CXXConstructorDecl*>(clang::QualType const&, clang::CXXConstructorDecl* const&)
Line
Count
Source
202
2
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
2
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
2
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
2
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
2
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
2
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
2
    }
llvm::Expected<std::__1::tuple<clang::QualType, clang::OpaqueValueExpr*, clang::Expr*> > clang::ASTNodeImporter::importSeq<clang::QualType, clang::OpaqueValueExpr*, clang::Expr*>(clang::QualType const&, clang::OpaqueValueExpr* const&, clang::Expr* const&)
Line
Count
Source
202
2
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
2
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
2
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
2
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
2
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
2
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
2
    }
llvm::Expected<std::__1::tuple<clang::OpaqueValueExpr*, clang::Expr*> > clang::ASTNodeImporter::importSeq<clang::OpaqueValueExpr*, clang::Expr*>(clang::OpaqueValueExpr* const&, clang::Expr* const&)
Line
Count
Source
202
2
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
2
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
2
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
2
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
2
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
2
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
2
    }
llvm::Expected<std::__1::tuple<clang::QualType, clang::Expr*, clang::TypeSourceInfo*, clang::SourceLocation, clang::SourceLocation, clang::SourceRange> > clang::ASTNodeImporter::importSeq<clang::QualType, clang::Expr*, clang::TypeSourceInfo*, clang::SourceLocation, clang::SourceLocation, clang::SourceRange>(clang::QualType const&, clang::Expr* const&, clang::TypeSourceInfo* const&, clang::SourceLocation const&, clang::SourceLocation const&, clang::SourceRange const&)
Line
Count
Source
202
27
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
27
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
27
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
27
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
27
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
27
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
27
    }
llvm::Expected<std::__1::tuple<clang::Expr*, clang::TypeSourceInfo*, clang::SourceLocation, clang::SourceLocation, clang::SourceRange> > clang::ASTNodeImporter::importSeq<clang::Expr*, clang::TypeSourceInfo*, clang::SourceLocation, clang::SourceLocation, clang::SourceRange>(clang::Expr* const&, clang::TypeSourceInfo* const&, clang::SourceLocation const&, clang::SourceLocation const&, clang::SourceRange const&)
Line
Count
Source
202
27
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
27
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
27
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
27
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
27
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
27
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
27
    }
llvm::Expected<std::__1::tuple<clang::TypeSourceInfo*, clang::SourceLocation, clang::SourceLocation, clang::SourceRange> > clang::ASTNodeImporter::importSeq<clang::TypeSourceInfo*, clang::SourceLocation, clang::SourceLocation, clang::SourceRange>(clang::TypeSourceInfo* const&, clang::SourceLocation const&, clang::SourceLocation const&, clang::SourceRange const&)
Line
Count
Source
202
27
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
27
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
27
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
27
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
27
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
27
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
27
    }
llvm::Expected<std::__1::tuple<clang::SourceLocation, clang::SourceLocation, clang::SourceRange> > clang::ASTNodeImporter::importSeq<clang::SourceLocation, clang::SourceLocation, clang::SourceRange>(clang::SourceLocation const&, clang::SourceLocation const&, clang::SourceRange const&)
Line
Count
Source
202
27
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
27
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
27
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
27
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
27
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
27
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
27
    }
llvm::Expected<std::__1::tuple<clang::SourceLocation, clang::SourceRange> > clang::ASTNodeImporter::importSeq<clang::SourceLocation, clang::SourceRange>(clang::SourceLocation const&, clang::SourceRange const&)
Line
Count
Source
202
27
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
27
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
27
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
27
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
27
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
27
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
27
    }
llvm::Expected<std::__1::tuple<clang::QualType, clang::SourceLocation, clang::NonTypeTemplateParmDecl*, clang::Expr*> > clang::ASTNodeImporter::importSeq<clang::QualType, clang::SourceLocation, clang::NonTypeTemplateParmDecl*, clang::Expr*>(clang::QualType const&, clang::SourceLocation const&, clang::NonTypeTemplateParmDecl* const&, clang::Expr* const&)
Line
Count
Source
202
5
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
5
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
5
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
5
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
5
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
5
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
5
    }
llvm::Expected<std::__1::tuple<clang::SourceLocation, clang::NonTypeTemplateParmDecl*, clang::Expr*> > clang::ASTNodeImporter::importSeq<clang::SourceLocation, clang::NonTypeTemplateParmDecl*, clang::Expr*>(clang::SourceLocation const&, clang::NonTypeTemplateParmDecl* const&, clang::Expr* const&)
Line
Count
Source
202
5
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
5
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
5
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
5
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
5
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
5
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
5
    }
llvm::Expected<std::__1::tuple<clang::NonTypeTemplateParmDecl*, clang::Expr*> > clang::ASTNodeImporter::importSeq<clang::NonTypeTemplateParmDecl*, clang::Expr*>(clang::NonTypeTemplateParmDecl* const&, clang::Expr* const&)
Line
Count
Source
202
5
    importSeq(const THead &FromHead, const TTail &...FromTail) {
203
5
      Expected<std::tuple<THead>> ToHeadOrErr = importSeq(FromHead);
204
5
      if (!ToHeadOrErr)
205
0
        return ToHeadOrErr.takeError();
206
5
      Expected<std::tuple<TTail...>> ToTailOrErr = importSeq(FromTail...);
207
5
      if (!ToTailOrErr)
208
0
        return ToTailOrErr.takeError();
209
5
      return std::tuple_cat(*ToHeadOrErr, *ToTailOrErr);
210
5
    }
211
212
// Wrapper for an overload set.
213
    template <typename ToDeclT> struct CallOverloadedCreateFun {
214
      template <typename... Args>
215
      auto operator()(Args &&... args)
216
8.61k
          -> decltype(ToDeclT::Create(std::forward<Args>(args)...)) {
217
8.61k
        return ToDeclT::Create(std::forward<Args>(args)...);
218
8.61k
      }
Unexecuted instantiation: decltype(clang::EmptyDecl::Create(clang::ASTContext&, clang::DeclContext*, clang::SourceLocation)(std::forward<clang::ASTContext&>(fp), std::forward<clang::DeclContext*&>(fp), std::forward<clang::SourceLocation&>(fp))) clang::ASTNodeImporter::CallOverloadedCreateFun<clang::EmptyDecl>::operator()<clang::ASTContext&, clang::DeclContext*&, clang::SourceLocation&>(clang::ASTContext&&&, clang::DeclContext*&&&, clang::SourceLocation&&&)
decltype(clang::AccessSpecDecl::Create(clang::ASTContext&, clang::AccessSpecifier, clang::DeclContext*, clang::SourceLocation, clang::SourceLocation)(std::forward<clang::ASTContext&>(fp), std::forward<clang::AccessSpecifier>(fp), std::forward<clang::DeclContext*&>(fp), std::forward<clang::SourceLocation&>(fp), std::forward<clang::SourceLocation&>(fp))) clang::ASTNodeImporter::CallOverloadedCreateFun<clang::AccessSpecDecl>::operator()<clang::ASTContext&, clang::AccessSpecifier, clang::DeclContext*&, clang::SourceLocation&, clang::SourceLocation&>(clang::ASTContext&&&, clang::AccessSpecifier&&, clang::DeclContext*&&&, clang::SourceLocation&&&, clang::SourceLocation&&&)
Line
Count
Source
216
37
          -> decltype(ToDeclT::Create(std::forward<Args>(args)...)) {
217
37
        return ToDeclT::Create(std::forward<Args>(args)...);
218
37
      }
decltype(clang::StaticAssertDecl::Create(clang::ASTContext&, clang::DeclContext*, clang::SourceLocation, clang::Expr*, clang::StringLiteral*, clang::SourceLocation, bool)(std::forward<clang::ASTContext&>(fp), std::forward<clang::DeclContext*&>(fp), std::forward<clang::SourceLocation&>(fp), std::forward<clang::Expr*&>(fp), std::forward<clang::StringLiteral*&>(fp), std::forward<clang::SourceLocation&>(fp), std::forward<bool>(fp))) clang::ASTNodeImporter::CallOverloadedCreateFun<clang::StaticAssertDecl>::operator()<clang::ASTContext&, clang::DeclContext*&, clang::SourceLocation&, clang::Expr*&, clang::StringLiteral*&, clang::SourceLocation&, bool>(clang::ASTContext&&&, clang::DeclContext*&&&, clang::SourceLocation&&&, clang::Expr*&&&, clang::StringLiteral*&&&, clang::SourceLocation&&&, bool&&)
Line
Count
Source
216
12
          -> decltype(ToDeclT::Create(std::forward<Args>(args)...)) {
217
12
        return ToDeclT::Create(std::forward<Args>(args)...);
218
12
      }
decltype(clang::NamespaceDecl::Create(clang::ASTContext&, clang::DeclContext*, bool, clang::SourceLocation, clang::SourceLocation, clang::IdentifierInfo*, clang::NamespaceDecl*)(std::forward<clang::ASTContext&>(fp), std::forward<clang::DeclContext*&>(fp), std::forward<bool>(fp), std::forward<clang::SourceLocation&>(fp), std::forward<clang::SourceLocation&>(fp), std::forward<clang::IdentifierInfo*>(fp), std::forward<std::nullptr_t>(fp))) clang::ASTNodeImporter::CallOverloadedCreateFun<clang::NamespaceDecl>::operator()<clang::ASTContext&, clang::DeclContext*&, bool, clang::SourceLocation&, clang::SourceLocation&, clang::IdentifierInfo*, std::nullptr_t>(clang::ASTContext&&&, clang::DeclContext*&&&, bool&&, clang::SourceLocation&&&, clang::SourceLocation&&&, clang::IdentifierInfo*&&, std::nullptr_t&&)
Line
Count
Source
216
189
          -> decltype(ToDeclT::Create(std::forward<Args>(args)...)) {
217
189
        return ToDeclT::Create(std::forward<Args>(args)...);
218
189
      }
decltype(clang::NamespaceAliasDecl::Create(clang::ASTContext&, clang::DeclContext*, clang::SourceLocation, clang::SourceLocation, clang::IdentifierInfo*, clang::NestedNameSpecifierLoc, clang::SourceLocation, clang::NamedDecl*)(std::forward<clang::ASTContext&>(fp), std::forward<clang::DeclContext*&>(fp), std::forward<clang::SourceLocation&>(fp), std::forward<clang::SourceLocation&>(fp), std::forward<clang::IdentifierInfo*&>(fp), std::forward<clang::NestedNameSpecifierLoc&>(fp), std::forward<clang::SourceLocation&>(fp), std::forward<clang::NamespaceDecl*&>(fp))) clang::ASTNodeImporter::CallOverloadedCreateFun<clang::NamespaceAliasDecl>::operator()<clang::ASTContext&, clang::DeclContext*&, clang::SourceLocation&, clang::SourceLocation&, clang::IdentifierInfo*&, clang::NestedNameSpecifierLoc&, clang::SourceLocation&, clang::NamespaceDecl*&>(clang::ASTContext&&&, clang::DeclContext*&&&, clang::SourceLocation&&&, clang::SourceLocation&&&, clang::IdentifierInfo*&&&, clang::NestedNameSpecifierLoc&&&, clang::SourceLocation&&&, clang::NamespaceDecl*&&&)
Line
Count
Source
216
3
          -> decltype(ToDeclT::Create(std::forward<Args>(args)...)) {
217
3
        return ToDeclT::Create(std::forward<Args>(args)...);
218
3
      }
decltype(clang::TypeAliasDecl::Create(clang::ASTContext&, clang::DeclContext*, clang::SourceLocation, clang::SourceLocation, clang::IdentifierInfo*, clang::TypeSourceInfo*)(std::forward<clang::ASTContext&>(fp), std::forward<clang::DeclContext*&>(fp), std::forward<clang::SourceLocation&>(fp), std::forward<clang::SourceLocation&>(fp), std::forward<clang::IdentifierInfo*>(fp), std::forward<clang::TypeSourceInfo*&>(fp))) clang::ASTNodeImporter::CallOverloadedCreateFun<clang::TypeAliasDecl>::operator()<clang::ASTContext&, clang::DeclContext*&, clang::SourceLocation&, clang::SourceLocation&, clang::IdentifierInfo*, clang::TypeSourceInfo*&>(clang::ASTContext&&&, clang::DeclContext*&&&, clang::SourceLocation&&&, clang::SourceLocation&&&, clang::IdentifierInfo*&&, clang::TypeSourceInfo*&&&)
Line
Count
Source
216
16
          -> decltype(ToDeclT::Create(std::forward<Args>(args)...)) {
217
16
        return ToDeclT::Create(std::forward<Args>(args)...);
218
16
      }
decltype(clang::TypedefDecl::Create(clang::ASTContext&, clang::DeclContext*, clang::SourceLocation, clang::SourceLocation, clang::IdentifierInfo*, clang::TypeSourceInfo*)(std::forward<clang::ASTContext&>(fp), std::forward<clang::DeclContext*&>(fp), std::forward<clang::SourceLocation&>(fp), std::forward<clang::SourceLocation&>(fp), std::forward<clang::IdentifierInfo*>(fp), std::forward<clang::TypeSourceInfo*&>(fp))) clang::ASTNodeImporter::CallOverloadedCreateFun<clang::TypedefDecl>::operator()<clang::ASTContext&, clang::DeclContext*&, clang::SourceLocation&, clang::SourceLocation&, clang::IdentifierInfo*, clang::TypeSourceInfo*&>(clang::ASTContext&&&, clang::DeclContext*&&&, clang::SourceLocation&&&, clang::SourceLocation&&&, clang::IdentifierInfo*&&, clang::TypeSourceInfo*&&&)
Line
Count
Source
216
496
          -> decltype(ToDeclT::Create(std::forward<Args>(args)...)) {
217
496
        return ToDeclT::Create(std::forward<Args>(args)...);
218
496
      }
decltype(clang::TypeAliasTemplateDecl::Create(clang::ASTContext&, clang::DeclContext*, clang::SourceLocation, clang::DeclarationName, clang::TemplateParameterList*, clang::NamedDecl*)(std::forward<clang::ASTContext&>(fp), std::forward<clang::DeclContext*&>(fp), std::forward<clang::SourceLocation&>(fp), std::forward<clang::DeclarationName&>(fp), std::forward<clang::TemplateParameterList*&>(fp), std::forward<clang::TypeAliasDecl*&>(fp))) clang::ASTNodeImporter::CallOverloadedCreateFun<clang::TypeAliasTemplateDecl>::operator()<clang::ASTContext&, clang::DeclContext*&, clang::SourceLocation&, clang::DeclarationName&, clang::TemplateParameterList*&, clang::TypeAliasDecl*&>(clang::ASTContext&&&, clang::DeclContext*&&&, clang::SourceLocation&&&, clang::DeclarationName&&&, clang::TemplateParameterList*&&&, clang::TypeAliasDecl*&&&)
Line
Count
Source
216
12
          -> decltype(ToDeclT::Create(std::forward<Args>(args)...)) {
217
12
        return ToDeclT::Create(std::forward<Args>(args)...);
218
12
      }
Unexecuted instantiation: decltype(clang::LabelDecl::Create(std::forward<clang::ASTContext&>(fp), std::forward<clang::DeclContext*&>(fp), std::forward<clang::SourceLocation&>(fp), std::forward<clang::IdentifierInfo*>(fp), std::forward<clang::SourceLocation&>(fp))) clang::ASTNodeImporter::CallOverloadedCreateFun<clang::LabelDecl>::operator()<clang::ASTContext&, clang::DeclContext*&, clang::SourceLocation&, clang::IdentifierInfo*, clang::SourceLocation&>(clang::ASTContext&&&, clang::DeclContext*&&&, clang::SourceLocation&&&, clang::IdentifierInfo*&&, clang::SourceLocation&&&)
decltype(clang::LabelDecl::Create(std::forward<clang::ASTContext&>(fp), std::forward<clang::DeclContext*&>(fp), std::forward<clang::SourceLocation&>(fp), std::forward<clang::IdentifierInfo*>(fp))) clang::ASTNodeImporter::CallOverloadedCreateFun<clang::LabelDecl>::operator()<clang::ASTContext&, clang::DeclContext*&, clang::SourceLocation&, clang::IdentifierInfo*>(clang::ASTContext&&&, clang::DeclContext*&&&, clang::SourceLocation&&&, clang::IdentifierInfo*&&)
Line
Count
Source
216
6
          -> decltype(ToDeclT::Create(std::forward<Args>(args)...)) {
217
6
        return ToDeclT::Create(std::forward<Args>(args)...);
218
6
      }
decltype(clang::EnumDecl::Create(clang::ASTContext&, clang::DeclContext*, clang::SourceLocation, clang::SourceLocation, clang::IdentifierInfo*, clang::EnumDecl*, bool, bool, bool)(std::forward<clang::ASTContext&>(fp), std::forward<clang::DeclContext*&>(fp), std::forward<clang::SourceLocation&>(fp), std::forward<clang::SourceLocation&>(fp), std::forward<clang::IdentifierInfo*>(fp), std::forward<std::nullptr_t>(fp), std::forward<bool>(fp), std::forward<bool>(fp), std::forward<bool>(fp))) clang::ASTNodeImporter::CallOverloadedCreateFun<clang::EnumDecl>::operator()<clang::ASTContext&, clang::DeclContext*&, clang::SourceLocation&, clang::SourceLocation&, clang::IdentifierInfo*, std::nullptr_t, bool, bool, bool>(clang::ASTContext&&&, clang::DeclContext*&&&, clang::SourceLocation&&&, clang::SourceLocation&&&, clang::IdentifierInfo*&&, std::nullptr_t&&, bool&&, bool&&, bool&&)
Line
Count
Source
216
70
          -> decltype(ToDeclT::Create(std::forward<Args>(args)...)) {
217
70
        return ToDeclT::Create(std::forward<Args>(args)...);
218
70
      }
decltype(clang::CXXRecordDecl::Create(clang::ASTContext const&, clang::TagTypeKind, clang::DeclContext*, clang::SourceLocation, clang::SourceLocation, clang::IdentifierInfo*, clang::CXXRecordDecl*, bool)(std::forward<clang::ASTContext&>(fp), std::forward<clang::TagTypeKind>(fp), std::forward<clang::DeclContext*&>(fp), std::forward<clang::SourceLocation&>(fp), std::forward<clang::SourceLocation&>(fp), std::forward<clang::IdentifierInfo*>(fp), std::forward<clang::CXXRecordDecl*>(fp), std::forward<bool const&>(fp))) clang::ASTNodeImporter::CallOverloadedCreateFun<clang::CXXRecordDecl>::operator()<clang::ASTContext&, clang::TagTypeKind, clang::DeclContext*&, clang::SourceLocation&, clang::SourceLocation&, clang::IdentifierInfo*, clang::CXXRecordDecl*, bool const&>(clang::ASTContext&&&, clang::TagTypeKind&&, clang::DeclContext*&&&, clang::SourceLocation&&&, clang::SourceLocation&&&, clang::IdentifierInfo*&&, clang::CXXRecordDecl*&&, bool const&&&)
Line
Count
Source
216
705
          -> decltype(ToDeclT::Create(std::forward<Args>(args)...)) {
217
705
        return ToDeclT::Create(std::forward<Args>(args)...);
218
705
      }
decltype(clang::CXXRecordDecl::Create(clang::ASTContext const&, clang::TagTypeKind, clang::DeclContext*, clang::SourceLocation, clang::SourceLocation, clang::IdentifierInfo*, clang::CXXRecordDecl*, bool)(std::forward<clang::ASTContext&>(fp), std::forward<clang::TagTypeKind>(fp), std::forward<clang::DeclContext*&>(fp), std::forward<clang::SourceLocation&>(fp), std::forward<clang::SourceLocation&>(fp), std::forward<clang::IdentifierInfo*>(fp), std::forward<clang::CXXRecordDecl*>(fp))) clang::ASTNodeImporter::CallOverloadedCreateFun<clang::CXXRecordDecl>::operator()<clang::ASTContext&, clang::TagTypeKind, clang::DeclContext*&, clang::SourceLocation&, clang::SourceLocation&, clang::IdentifierInfo*, clang::CXXRecordDecl*>(clang::ASTContext&&&, clang::TagTypeKind&&, clang::DeclContext*&&&, clang::SourceLocation&&&, clang::SourceLocation&&&, clang::IdentifierInfo*&&, clang::CXXRecordDecl*&&)
Line
Count
Source
216
1.04k
          -> decltype(ToDeclT::Create(std::forward<Args>(args)...)) {
217
1.04k
        return ToDeclT::Create(std::forward<Args>(args)...);
218
1.04k
      }
decltype(clang::RecordDecl::Create(clang::ASTContext const&, clang::TagTypeKind, clang::DeclContext*, clang::SourceLocation, clang::SourceLocation, clang::IdentifierInfo*, clang::RecordDecl*)(std::forward<clang::ASTContext&>(fp), std::forward<clang::TagTypeKind>(fp), std::forward<clang::DeclContext*&>(fp), std::forward<clang::SourceLocation&>(fp), std::forward<clang::SourceLocation&>(fp), std::forward<clang::IdentifierInfo*>(fp), std::forward<clang::RecordDecl*&>(fp))) clang::ASTNodeImporter::CallOverloadedCreateFun<clang::RecordDecl>::operator()<clang::ASTContext&, clang::TagTypeKind, clang::DeclContext*&, clang::SourceLocation&, clang::SourceLocation&, clang::IdentifierInfo*, clang::RecordDecl*&>(clang::ASTContext&&&, clang::TagTypeKind&&, clang::DeclContext*&&&, clang::SourceLocation&&&, clang::SourceLocation&&&, clang::IdentifierInfo*&&, clang::RecordDecl*&&&)
Line
Count
Source
216
156
          -> decltype(ToDeclT::Create(std::forward<Args>(args)...)) {
217
156
        return ToDeclT::Create(std::forward<Args>(args)...);
218
156
      }
decltype(clang::EnumConstantDecl::Create(clang::ASTContext&, clang::EnumDecl*, clang::SourceLocation, clang::IdentifierInfo*, clang::QualType, clang::Expr*, llvm::APSInt const&)(std::forward<clang::ASTContext&>(fp), std::forward<clang::EnumDecl*>(fp), std::forward<clang::SourceLocation&>(fp), std::forward<clang::IdentifierInfo*>(fp), std::forward<clang::QualType&>(fp), std::forward<clang::Expr*&>(fp), std::forward<llvm::APSInt const&>(fp))) clang::ASTNodeImporter::CallOverloadedCreateFun<clang::EnumConstantDecl>::operator()<clang::ASTContext&, clang::EnumDecl*, clang::SourceLocation&, clang::IdentifierInfo*, clang::QualType&, clang::Expr*&, llvm::APSInt const&>(clang::ASTContext&&&, clang::EnumDecl*&&, clang::SourceLocation&&&, clang::IdentifierInfo*&&, clang::QualType&&&, clang::Expr*&&&, llvm::APSInt const&&&)
Line
Count
Source
216
52
          -> decltype(ToDeclT::Create(std::forward<Args>(args)...)) {
217
52
        return ToDeclT::Create(std::forward<Args>(args)...);
218
52
      }
decltype(clang::CXXConstructorDecl::Create(clang::ASTContext&, clang::CXXRecordDecl*, clang::SourceLocation, clang::DeclarationNameInfo const&, clang::QualType, clang::TypeSourceInfo*, clang::ExplicitSpecifier, bool, bool, clang::ConstexprSpecKind, clang::InheritedConstructor)(std::forward<clang::ASTContext&>(fp), std::forward<clang::CXXRecordDecl*>(fp), std::forward<clang::SourceLocation&>(fp), std::forward<clang::DeclarationNameInfo&>(fp), std::forward<clang::QualType&>(fp), std::forward<clang::TypeSourceInfo*&>(fp), std::forward<clang::ExplicitSpecifier>(fp), std::forward<bool>(fp), std::forward<bool>(fp), std::forward<clang::ConstexprSpecKind>(fp))) clang::ASTNodeImporter::CallOverloadedCreateFun<clang::CXXConstructorDecl>::operator()<clang::ASTContext&, clang::CXXRecordDecl*, clang::SourceLocation&, clang::DeclarationNameInfo&, clang::QualType&, clang::TypeSourceInfo*&, clang::ExplicitSpecifier, bool, bool, clang::ConstexprSpecKind>(clang::ASTContext&&&, clang::CXXRecordDecl*&&, clang::SourceLocation&&&, clang::DeclarationNameInfo&&&, clang::QualType&&&, clang::TypeSourceInfo*&&&, clang::ExplicitSpecifier&&, bool&&, bool&&, clang::ConstexprSpecKind&&)
Line
Count
Source
216
314
          -> decltype(ToDeclT::Create(std::forward<Args>(args)...)) {
217
314
        return ToDeclT::Create(std::forward<Args>(args)...);
218
314
      }
decltype(clang::CXXDestructorDecl::Create(clang::ASTContext&, clang::CXXRecordDecl*, clang::SourceLocation, clang::DeclarationNameInfo const&, clang::QualType, clang::TypeSourceInfo*, bool, bool)(std::forward<clang::ASTContext&>(fp), std::forward<clang::CXXRecordDecl*>(fp), std::forward<clang::SourceLocation&>(fp), std::forward<clang::DeclarationNameInfo&>(fp), std::forward<clang::QualType&>(fp), std::forward<clang::TypeSourceInfo*&>(fp), std::forward<bool>(fp), std::forward<bool>(fp))) clang::ASTNodeImporter::CallOverloadedCreateFun<clang::CXXDestructorDecl>::operator()<clang::ASTContext&, clang::CXXRecordDecl*, clang::SourceLocation&, clang::DeclarationNameInfo&, clang::QualType&, clang::TypeSourceInfo*&, bool, bool>(clang::ASTContext&&&, clang::CXXRecordDecl*&&, clang::SourceLocation&&&, clang::DeclarationNameInfo&&&, clang::QualType&&&, clang::TypeSourceInfo*&&&, bool&&, bool&&)
Line
Count
Source
216
135
          -> decltype(ToDeclT::Create(std::forward<Args>(args)...)) {
217
135
        return ToDeclT::Create(std::forward<Args>(args)...);
218
135
      }
decltype(clang::CXXConversionDecl::Create(clang::ASTContext&, clang::CXXRecordDecl*, clang::SourceLocation, clang::DeclarationNameInfo const&, clang::QualType, clang::TypeSourceInfo*, bool, clang::ExplicitSpecifier, clang::ConstexprSpecKind, clang::SourceLocation)(std::forward<clang::ASTContext&>(fp), std::forward<clang::CXXRecordDecl*>(fp), std::forward<clang::SourceLocation&>(fp), std::forward<clang::DeclarationNameInfo&>(fp), std::forward<clang::QualType&>(fp), std::forward<clang::TypeSourceInfo*&>(fp), std::forward<bool>(fp), std::forward<clang::ExplicitSpecifier>(fp), std::forward<clang::ConstexprSpecKind>(fp), std::forward<clang::SourceLocation>(fp))) clang::ASTNodeImporter::CallOverloadedCreateFun<clang::CXXConversionDecl>::operator()<clang::ASTContext&, clang::CXXRecordDecl*, clang::SourceLocation&, clang::DeclarationNameInfo&, clang::QualType&, clang::TypeSourceInfo*&, bool, clang::ExplicitSpecifier, clang::ConstexprSpecKind, clang::SourceLocation>(clang::ASTContext&&&, clang::CXXRecordDecl*&&, clang::SourceLocation&&&, clang::DeclarationNameInfo&&&, clang::QualType&&&, clang::TypeSourceInfo*&&&, bool&&, clang::ExplicitSpecifier&&, clang::ConstexprSpecKind&&, clang::SourceLocation&&)
Line
Count
Source
216
22
          -> decltype(ToDeclT::Create(std::forward<Args>(args)...)) {
217
22
        return ToDeclT::Create(std::forward<Args>(args)...);
218
22
      }
decltype(clang::CXXMethodDecl::Create(clang::ASTContext&, clang::CXXRecordDecl*, clang::SourceLocation, clang::DeclarationNameInfo const&, clang::QualType, clang::TypeSourceInfo*, clang::StorageClass, bool, clang::ConstexprSpecKind, clang::SourceLocation)(std::forward<clang::ASTContext&>(fp), std::forward<clang::CXXRecordDecl*>(fp), std::forward<clang::SourceLocation&>(fp), std::forward<clang::DeclarationNameInfo&>(fp), std::forward<clang::QualType&>(fp), std::forward<clang::TypeSourceInfo*&>(fp), std::forward<clang::StorageClass>(fp), std::forward<bool>(fp), std::forward<clang::ConstexprSpecKind>(fp), std::forward<clang::SourceLocation>(fp))) clang::ASTNodeImporter::CallOverloadedCreateFun<clang::CXXMethodDecl>::operator()<clang::ASTContext&, clang::CXXRecordDecl*, clang::SourceLocation&, clang::DeclarationNameInfo&, clang::QualType&, clang::TypeSourceInfo*&, clang::StorageClass, bool, clang::ConstexprSpecKind, clang::SourceLocation>(clang::ASTContext&&&, clang::CXXRecordDecl*&&, clang::SourceLocation&&&, clang::DeclarationNameInfo&&&, clang::QualType&&&, clang::TypeSourceInfo*&&&, clang::StorageClass&&, bool&&, clang::ConstexprSpecKind&&, clang::SourceLocation&&)
Line
Count
Source
216
359
          -> decltype(ToDeclT::Create(std::forward<Args>(args)...)) {
217
359
        return ToDeclT::Create(std::forward<Args>(args)...);
218
359
      }
decltype(clang::FunctionDecl::Create(std::forward<clang::ASTContext&>(fp), std::forward<clang::DeclContext*&>(fp), std::forward<clang::SourceLocation&>(fp), std::forward<clang::DeclarationNameInfo&>(fp), std::forward<clang::QualType&>(fp), std::forward<clang::TypeSourceInfo*&>(fp), std::forward<clang::StorageClass>(fp), std::forward<bool>(fp), std::forward<bool>(fp), std::forward<clang::ConstexprSpecKind>(fp))) clang::ASTNodeImporter::CallOverloadedCreateFun<clang::FunctionDecl>::operator()<clang::ASTContext&, clang::DeclContext*&, clang::SourceLocation&, clang::DeclarationNameInfo&, clang::QualType&, clang::TypeSourceInfo*&, clang::StorageClass, bool, bool, clang::ConstexprSpecKind>(clang::ASTContext&&&, clang::DeclContext*&&&, clang::SourceLocation&&&, clang::DeclarationNameInfo&&&, clang::QualType&&&, clang::TypeSourceInfo*&&&, clang::StorageClass&&, bool&&, bool&&, clang::ConstexprSpecKind&&)
Line
Count
Source
216
1.24k
          -> decltype(ToDeclT::Create(std::forward<Args>(args)...)) {
217
1.24k
        return ToDeclT::Create(std::forward<Args>(args)...);
218
1.24k
      }
decltype(clang::FieldDecl::Create(clang::ASTContext const&, clang::DeclContext*, clang::SourceLocation, clang::SourceLocation, clang::IdentifierInfo*, clang::QualType, clang::TypeSourceInfo*, clang::Expr*, bool, clang::InClassInitStyle)(std::forward<clang::ASTContext&>(fp), std::forward<clang::DeclContext*&>(fp), std::forward<clang::SourceLocation&>(fp), std::forward<clang::SourceLocation&>(fp), std::forward<clang::IdentifierInfo*>(fp), std::forward<clang::QualType&>(fp), std::forward<clang::TypeSourceInfo*&>(fp), std::forward<clang::Expr*&>(fp), std::forward<bool>(fp), std::forward<clang::InClassInitStyle>(fp))) clang::ASTNodeImporter::CallOverloadedCreateFun<clang::FieldDecl>::operator()<clang::ASTContext&, clang::DeclContext*&, clang::SourceLocation&, clang::SourceLocation&, clang::IdentifierInfo*, clang::QualType&, clang::TypeSourceInfo*&, clang::Expr*&, bool, clang::InClassInitStyle>(clang::ASTContext&&&, clang::DeclContext*&&&, clang::SourceLocation&&&, clang::SourceLocation&&&, clang::IdentifierInfo*&&, clang::QualType&&&, clang::TypeSourceInfo*&&&, clang::Expr*&&&, bool&&, clang::InClassInitStyle&&)
Line
Count
Source
216
593
          -> decltype(ToDeclT::Create(std::forward<Args>(args)...)) {
217
593
        return ToDeclT::Create(std::forward<Args>(args)...);
218
593
      }
decltype(clang::IndirectFieldDecl::Create(clang::ASTContext&, clang::DeclContext*, clang::SourceLocation, clang::IdentifierInfo*, clang::QualType, llvm::MutableArrayRef<clang::NamedDecl*>)(std::forward<clang::ASTContext&>(fp), std::forward<clang::DeclContext*&>(fp), std::forward<clang::SourceLocation&>(fp), std::forward<clang::IdentifierInfo*>(fp), std::forward<clang::QualType&>(fp), std::forward<llvm::MutableArrayRef<clang::NamedDecl*>&>(fp))) clang::ASTNodeImporter::CallOverloadedCreateFun<clang::IndirectFieldDecl>::operator()<clang::ASTContext&, clang::DeclContext*&, clang::SourceLocation&, clang::IdentifierInfo*, clang::QualType&, llvm::MutableArrayRef<clang::NamedDecl*>&>(clang::ASTContext&&&, clang::DeclContext*&&&, clang::SourceLocation&&&, clang::IdentifierInfo*&&, clang::QualType&&&, llvm::MutableArrayRef<clang::NamedDecl*>&&&)
Line
Count
Source
216
27
          -> decltype(ToDeclT::Create(std::forward<Args>(args)...)) {
217
27
        return ToDeclT::Create(std::forward<Args>(args)...);
218
27
      }
decltype(clang::FriendDecl::Create(clang::ASTContext&, clang::DeclContext*, clang::SourceLocation, llvm::PointerUnion<clang::NamedDecl*, clang::TypeSourceInfo*>, clang::SourceLocation, llvm::ArrayRef<clang::TemplateParameterList*>)(std::forward<clang::ASTContext&>(fp), std::forward<clang::DeclContext*&>(fp), std::forward<clang::SourceLocation&>(fp), std::forward<llvm::PointerUnion<clang::NamedDecl*, clang::TypeSourceInfo*>&>(fp), std::forward<clang::SourceLocation&>(fp), std::forward<llvm::SmallVector<clang::TemplateParameterList*, 1u>&>(fp))) clang::ASTNodeImporter::CallOverloadedCreateFun<clang::FriendDecl>::operator()<clang::ASTContext&, clang::DeclContext*&, clang::SourceLocation&, llvm::PointerUnion<clang::NamedDecl*, clang::TypeSourceInfo*>&, clang::SourceLocation&, llvm::SmallVector<clang::TemplateParameterList*, 1u>&>(clang::ASTContext&&&, clang::DeclContext*&&&, clang::SourceLocation&&&, llvm::PointerUnion<clang::NamedDecl*, clang::TypeSourceInfo*>&&&, clang::SourceLocation&&&, llvm::SmallVector<clang::TemplateParameterList*, 1u>&&&)
Line
Count
Source
216
91
          -> decltype(ToDeclT::Create(std::forward<Args>(args)...)) {
217
91
        return ToDeclT::Create(std::forward<Args>(args)...);
218
91
      }
decltype(clang::ObjCIvarDecl::Create(clang::ASTContext&, clang::ObjCContainerDecl*, clang::SourceLocation, clang::SourceLocation, clang::IdentifierInfo*, clang::QualType, clang::TypeSourceInfo*, clang::ObjCIvarDecl::AccessControl, clang::Expr*, bool)(std::forward<clang::ASTContext&>(fp), std::forward<clang::ObjCContainerDecl*>(fp), std::forward<clang::SourceLocation&>(fp), std::forward<clang::SourceLocation&>(fp), std::forward<clang::IdentifierInfo*>(fp), std::forward<clang::QualType&>(fp), std::forward<clang::TypeSourceInfo*&>(fp), std::forward<clang::ObjCIvarDecl::AccessControl>(fp), std::forward<clang::Expr*&>(fp), std::forward<bool>(fp))) clang::ASTNodeImporter::CallOverloadedCreateFun<clang::ObjCIvarDecl>::operator()<clang::ASTContext&, clang::ObjCContainerDecl*, clang::SourceLocation&, clang::SourceLocation&, clang::IdentifierInfo*, clang::QualType&, clang::TypeSourceInfo*&, clang::ObjCIvarDecl::AccessControl, clang::Expr*&, bool>(clang::ASTContext&&&, clang::ObjCContainerDecl*&&, clang::SourceLocation&&&, clang::SourceLocation&&&, clang::IdentifierInfo*&&, clang::QualType&&&, clang::TypeSourceInfo*&&&, clang::ObjCIvarDecl::AccessControl&&, clang::Expr*&&&, bool&&)
Line
Count
Source
216
10
          -> decltype(ToDeclT::Create(std::forward<Args>(args)...)) {
217
10
        return ToDeclT::Create(std::forward<Args>(args)...);
218
10
      }
decltype(clang::VarDecl::Create(clang::ASTContext&, clang::DeclContext*, clang::SourceLocation, clang::SourceLocation, clang::IdentifierInfo*, clang::QualType, clang::TypeSourceInfo*, clang::StorageClass)(std::forward<clang::ASTContext&>(fp), std::forward<clang::DeclContext*&>(fp), std::forward<clang::SourceLocation&>(fp), std::forward<clang::SourceLocation&>(fp), std::forward<clang::IdentifierInfo*>(fp), std::forward<clang::QualType&>(fp), std::forward<clang::TypeSourceInfo*&>(fp), std::forward<clang::StorageClass>(fp))) clang::ASTNodeImporter::CallOverloadedCreateFun<clang::VarDecl>::operator()<clang::ASTContext&, clang::DeclContext*&, clang::SourceLocation&, clang::SourceLocation&, clang::IdentifierInfo*, clang::QualType&, clang::TypeSourceInfo*&, clang::StorageClass>(clang::ASTContext&&&, clang::DeclContext*&&&, clang::SourceLocation&&&, clang::SourceLocation&&&, clang::IdentifierInfo*&&, clang::QualType&&&, clang::TypeSourceInfo*&&&, clang::StorageClass&&)
Line
Count
Source
216
703
          -> decltype(ToDeclT::Create(std::forward<Args>(args)...)) {
217
703
        return ToDeclT::Create(std::forward<Args>(args)...);
218
703
      }
Unexecuted instantiation: decltype(clang::ImplicitParamDecl::Create(std::forward<clang::ASTContext&>(fp), std::forward<clang::DeclContext*&>(fp), std::forward<clang::SourceLocation&>(fp), std::forward<clang::IdentifierInfo*>(fp), std::forward<clang::QualType&>(fp), std::forward<clang::ImplicitParamDecl::ImplicitParamKind>(fp))) clang::ASTNodeImporter::CallOverloadedCreateFun<clang::ImplicitParamDecl>::operator()<clang::ASTContext&, clang::DeclContext*&, clang::SourceLocation&, clang::IdentifierInfo*, clang::QualType&, clang::ImplicitParamDecl::ImplicitParamKind>(clang::ASTContext&&&, clang::DeclContext*&&&, clang::SourceLocation&&&, clang::IdentifierInfo*&&, clang::QualType&&&, clang::ImplicitParamDecl::ImplicitParamKind&&)
decltype(clang::ParmVarDecl::Create(clang::ASTContext&, clang::DeclContext*, clang::SourceLocation, clang::SourceLocation, clang::IdentifierInfo*, clang::QualType, clang::TypeSourceInfo*, clang::StorageClass, clang::Expr*)(std::forward<clang::ASTContext&>(fp), std::forward<clang::DeclContext*&>(fp), std::forward<clang::SourceLocation&>(fp), std::forward<clang::SourceLocation&>(fp), std::forward<clang::IdentifierInfo*>(fp), std::forward<clang::QualType&>(fp), std::forward<clang::TypeSourceInfo*&>(fp), std::forward<clang::StorageClass>(fp), std::forward<std::nullptr_t>(fp))) clang::ASTNodeImporter::CallOverloadedCreateFun<clang::ParmVarDecl>::operator()<clang::ASTContext&, clang::DeclContext*&, clang::SourceLocation&, clang::SourceLocation&, clang::IdentifierInfo*, clang::QualType&, clang::TypeSourceInfo*&, clang::StorageClass, std::nullptr_t>(clang::ASTContext&&&, clang::DeclContext*&&&, clang::SourceLocation&&&, clang::SourceLocation&&&, clang::IdentifierInfo*&&, clang::QualType&&&, clang::TypeSourceInfo*&&&, clang::StorageClass&&, std::nullptr_t&&)
Line
Count
Source
216
616
          -> decltype(ToDeclT::Create(std::forward<Args>(args)...)) {
217
616
        return ToDeclT::Create(std::forward<Args>(args)...);
218
616
      }
decltype(clang::ObjCMethodDecl::Create(clang::ASTContext&, clang::SourceLocation, clang::SourceLocation, clang::Selector, clang::QualType, clang::TypeSourceInfo*, clang::DeclContext*, bool, bool, bool, bool, bool, clang::ObjCMethodDecl::ImplementationControl, bool)(std::forward<clang::ASTContext&>(fp), std::forward<clang::SourceLocation&>(fp), std::forward<clang::SourceLocation&>(fp), std::forward<clang::Selector>(fp), std::forward<clang::QualType&>(fp), std::forward<clang::TypeSourceInfo*&>(fp), std::forward<clang::DeclContext*&>(fp), std::forward<bool>(fp), std::forward<bool>(fp), std::forward<bool>(fp), std::forward<bool>(fp), std::forward<bool>(fp), std::forward<clang::ObjCMethodDecl::ImplementationControl>(fp), std::forward<bool>(fp))) clang::ASTNodeImporter::CallOverloadedCreateFun<clang::ObjCMethodDecl>::operator()<clang::ASTContext&, clang::SourceLocation&, clang::SourceLocation&, clang::Selector, clang::QualType&, clang::TypeSourceInfo*&, clang::DeclContext*&, bool, bool, bool, bool, bool, clang::ObjCMethodDecl::ImplementationControl, bool>(clang::ASTContext&&&, clang::SourceLocation&&&, clang::SourceLocation&&&, clang::Selector&&, clang::QualType&&&, clang::TypeSourceInfo*&&&, clang::DeclContext*&&&, bool&&, bool&&, bool&&, bool&&, bool&&, clang::ObjCMethodDecl::ImplementationControl&&, bool&&)
Line
Count
Source
216
43
          -> decltype(ToDeclT::Create(std::forward<Args>(args)...)) {
217
43
        return ToDeclT::Create(std::forward<Args>(args)...);
218
43
      }
decltype(clang::ObjCTypeParamDecl::Create(clang::ASTContext&, clang::DeclContext*, clang::ObjCTypeParamVariance, clang::SourceLocation, unsigned int, clang::SourceLocation, clang::IdentifierInfo*, clang::SourceLocation, clang::TypeSourceInfo*)(std::forward<clang::ASTContext&>(fp), std::forward<clang::DeclContext*&>(fp), std::forward<clang::ObjCTypeParamVariance>(fp), std::forward<clang::SourceLocation&>(fp), std::forward<unsigned int>(fp), std::forward<clang::SourceLocation&>(fp), std::forward<clang::IdentifierInfo*>(fp), std::forward<clang::SourceLocation&>(fp), std::forward<clang::TypeSourceInfo*&>(fp))) clang::ASTNodeImporter::CallOverloadedCreateFun<clang::ObjCTypeParamDecl>::operator()<clang::ASTContext&, clang::DeclContext*&, clang::ObjCTypeParamVariance, clang::SourceLocation&, unsigned int, clang::SourceLocation&, clang::IdentifierInfo*, clang::SourceLocation&, clang::TypeSourceInfo*&>(clang::ASTContext&&&, clang::DeclContext*&&&, clang::ObjCTypeParamVariance&&, clang::SourceLocation&&&, unsigned int&&, clang::SourceLocation&&&, clang::IdentifierInfo*&&, clang::SourceLocation&&&, clang::TypeSourceInfo*&&&)
Line
Count
Source
216
4
          -> decltype(ToDeclT::Create(std::forward<Args>(args)...)) {
217
4
        return ToDeclT::Create(std::forward<Args>(args)...);
218
4
      }
decltype(clang::ObjCCategoryDecl::Create(clang::ASTContext&, clang::DeclContext*, clang::SourceLocation, clang::SourceLocation, clang::SourceLocation, clang::IdentifierInfo*, clang::ObjCInterfaceDecl*, clang::ObjCTypeParamList*, clang::SourceLocation, clang::SourceLocation)(std::forward<clang::ASTContext&>(fp), std::forward<clang::DeclContext*&>(fp), std::forward<clang::SourceLocation&>(fp), std::forward<clang::SourceLocation&>(fp), std::forward<clang::SourceLocation&>(fp), std::forward<clang::IdentifierInfo*>(fp), std::forward<clang::ObjCInterfaceDecl*&>(fp), std::forward<std::nullptr_t>(fp), std::forward<clang::SourceLocation&>(fp), std::forward<clang::SourceLocation&>(fp))) clang::ASTNodeImporter::CallOverloadedCreateFun<clang::ObjCCategoryDecl>::operator()<clang::ASTContext&, clang::DeclContext*&, clang::SourceLocation&, clang::SourceLocation&, clang::SourceLocation&, clang::IdentifierInfo*, clang::ObjCInterfaceDecl*&, std::nullptr_t, clang::SourceLocation&, clang::SourceLocation&>(clang::ASTContext&&&, clang::DeclContext*&&&, clang::SourceLocation&&&, clang::SourceLocation&&&, clang::SourceLocation&&&, clang::IdentifierInfo*&&, clang::ObjCInterfaceDecl*&&&, std::nullptr_t&&, clang::SourceLocation&&&, clang::SourceLocation&&&)
Line
Count
Source
216
8
          -> decltype(ToDeclT::Create(std::forward<Args>(args)...)) {
217
8
        return ToDeclT::Create(std::forward<Args>(args)...);
218
8
      }
decltype(clang::ObjCProtocolDecl::Create(clang::ASTContext&, clang::DeclContext*, clang::IdentifierInfo*, clang::SourceLocation, clang::SourceLocation, clang::ObjCProtocolDecl*)(std::forward<clang::ASTContext&>(fp), std::forward<clang::DeclContext*&>(fp), std::forward<clang::IdentifierInfo*>(fp), std::forward<clang::SourceLocation&>(fp), std::forward<clang::SourceLocation&>(fp), std::forward<std::nullptr_t>(fp))) clang::ASTNodeImporter::CallOverloadedCreateFun<clang::ObjCProtocolDecl>::operator()<clang::ASTContext&, clang::DeclContext*&, clang::IdentifierInfo*, clang::SourceLocation&, clang::SourceLocation&, std::nullptr_t>(clang::ASTContext&&&, clang::DeclContext*&&&, clang::IdentifierInfo*&&, clang::SourceLocation&&&, clang::SourceLocation&&&, std::nullptr_t&&)
Line
Count
Source
216
8
          -> decltype(ToDeclT::Create(std::forward<Args>(args)...)) {
217
8
        return ToDeclT::Create(std::forward<Args>(args)...);
218
8
      }
decltype(clang::LinkageSpecDecl::Create(clang::ASTContext&, clang::DeclContext*, clang::SourceLocation, clang::SourceLocation, clang::LinkageSpecDecl::LanguageIDs, bool)(std::forward<clang::ASTContext&>(fp), std::forward<clang::DeclContext*&>(fp), std::forward<clang::SourceLocation&>(fp), std::forward<clang::SourceLocation&>(fp), std::forward<clang::LinkageSpecDecl::LanguageIDs>(fp), std::forward<bool&>(fp))) clang::ASTNodeImporter::CallOverloadedCreateFun<clang::LinkageSpecDecl>::operator()<clang::ASTContext&, clang::DeclContext*&, clang::SourceLocation&, clang::SourceLocation&, clang::LinkageSpecDecl::LanguageIDs, bool&>(clang::ASTContext&&&, clang::DeclContext*&&&, clang::SourceLocation&&&, clang::SourceLocation&&&, clang::LinkageSpecDecl::LanguageIDs&&, bool&&&)
Line
Count
Source
216
2
          -> decltype(ToDeclT::Create(std::forward<Args>(args)...)) {
217
2
        return ToDeclT::Create(std::forward<Args>(args)...);
218
2
      }
decltype(clang::UsingDecl::Create(clang::ASTContext&, clang::DeclContext*, clang::SourceLocation, clang::NestedNameSpecifierLoc, clang::DeclarationNameInfo const&, bool)(std::forward<clang::ASTContext&>(fp), std::forward<clang::DeclContext*&>(fp), std::forward<clang::SourceLocation&>(fp), std::forward<clang::NestedNameSpecifierLoc&>(fp), std::forward<clang::DeclarationNameInfo&>(fp), std::forward<bool>(fp))) clang::ASTNodeImporter::CallOverloadedCreateFun<clang::UsingDecl>::operator()<clang::ASTContext&, clang::DeclContext*&, clang::SourceLocation&, clang::NestedNameSpecifierLoc&, clang::DeclarationNameInfo&, bool>(clang::ASTContext&&&, clang::DeclContext*&&&, clang::SourceLocation&&&, clang::NestedNameSpecifierLoc&&&, clang::DeclarationNameInfo&&&, bool&&)
Line
Count
Source
216
11
          -> decltype(ToDeclT::Create(std::forward<Args>(args)...)) {
217
11
        return ToDeclT::Create(std::forward<Args>(args)...);
218
11
      }
decltype(clang::UsingShadowDecl::Create(clang::ASTContext&, clang::DeclContext*, clang::SourceLocation, clang::UsingDecl*, clang::NamedDecl*)(std::forward<clang::ASTContext&>(fp), std::forward<clang::DeclContext*&>(fp), std::forward<clang::SourceLocation&>(fp), std::forward<clang::UsingDecl*&>(fp), std::forward<clang::NamedDecl*&>(fp))) clang::ASTNodeImporter::CallOverloadedCreateFun<clang::UsingShadowDecl>::operator()<clang::ASTContext&, clang::DeclContext*&, clang::SourceLocation&, clang::UsingDecl*&, clang::NamedDecl*&>(clang::ASTContext&&&, clang::DeclContext*&&&, clang::SourceLocation&&&, clang::UsingDecl*&&&, clang::NamedDecl*&&&)
Line
Count
Source
216
15
          -> decltype(ToDeclT::Create(std::forward<Args>(args)...)) {
217
15
        return ToDeclT::Create(std::forward<Args>(args)...);
218
15
      }
decltype(clang::UsingDirectiveDecl::Create(clang::ASTContext&, clang::DeclContext*, clang::SourceLocation, clang::SourceLocation, clang::NestedNameSpecifierLoc, clang::SourceLocation, clang::NamedDecl*, clang::DeclContext*)(std::forward<clang::ASTContext&>(fp), std::forward<clang::DeclContext*&>(fp), std::forward<clang::SourceLocation&>(fp), std::forward<clang::SourceLocation&>(fp), std::forward<clang::NestedNameSpecifierLoc&>(fp), std::forward<clang::SourceLocation&>(fp), std::forward<clang::NamespaceDecl*&>(fp), std::forward<clang::DeclContext*&>(fp))) clang::ASTNodeImporter::CallOverloadedCreateFun<clang::UsingDirectiveDecl>::operator()<clang::ASTContext&, clang::DeclContext*&, clang::SourceLocation&, clang::SourceLocation&, clang::NestedNameSpecifierLoc&, clang::SourceLocation&, clang::NamespaceDecl*&, clang::DeclContext*&>(clang::ASTContext&&&, clang::DeclContext*&&&, clang::SourceLocation&&&, clang::SourceLocation&&&, clang::NestedNameSpecifierLoc&&&, clang::SourceLocation&&&, clang::NamespaceDecl*&&&, clang::DeclContext*&&&)
Line
Count
Source
216
17
          -> decltype(ToDeclT::Create(std::forward<Args>(args)...)) {
217
17
        return ToDeclT::Create(std::forward<Args>(args)...);
218
17
      }
decltype(clang::UnresolvedUsingValueDecl::Create(clang::ASTContext&, clang::DeclContext*, clang::SourceLocation, clang::NestedNameSpecifierLoc, clang::DeclarationNameInfo const&, clang::SourceLocation)(std::forward<clang::ASTContext&>(fp), std::forward<clang::DeclContext*&>(fp), std::forward<clang::SourceLocation&>(fp), std::forward<clang::NestedNameSpecifierLoc&>(fp), std::forward<clang::DeclarationNameInfo&>(fp), std::forward<clang::SourceLocation&>(fp))) clang::ASTNodeImporter::CallOverloadedCreateFun<clang::UnresolvedUsingValueDecl>::operator()<clang::ASTContext&, clang::DeclContext*&, clang::SourceLocation&, clang::NestedNameSpecifierLoc&, clang::DeclarationNameInfo&, clang::SourceLocation&>(clang::ASTContext&&&, clang::DeclContext*&&&, clang::SourceLocation&&&, clang::NestedNameSpecifierLoc&&&, clang::DeclarationNameInfo&&&, clang::SourceLocation&&&)
Line
Count
Source
216
1
          -> decltype(ToDeclT::Create(std::forward<Args>(args)...)) {
217
1
        return ToDeclT::Create(std::forward<Args>(args)...);
218
1
      }
decltype(clang::UnresolvedUsingTypenameDecl::Create(clang::ASTContext&, clang::DeclContext*, clang::SourceLocation, clang::SourceLocation, clang::NestedNameSpecifierLoc, clang::SourceLocation, clang::DeclarationName, clang::SourceLocation)(std::forward<clang::ASTContext&>(fp), std::forward<clang::DeclContext*&>(fp), std::forward<clang::SourceLocation&>(fp), std::forward<clang::SourceLocation&>(fp), std::forward<clang::NestedNameSpecifierLoc&>(fp), std::forward<clang::SourceLocation&>(fp), std::forward<clang::DeclarationName&>(fp), std::forward<clang::SourceLocation&>(fp))) clang::ASTNodeImporter::CallOverloadedCreateFun<clang::UnresolvedUsingTypenameDecl>::operator()<clang::ASTContext&, clang::DeclContext*&, clang::SourceLocation&, clang::SourceLocation&, clang::NestedNameSpecifierLoc&, clang::SourceLocation&, clang::DeclarationName&, clang::SourceLocation&>(clang::ASTContext&&&, clang::DeclContext*&&&, clang::SourceLocation&&&, clang::SourceLocation&&&, clang::NestedNameSpecifierLoc&&&, clang::SourceLocation&&&, clang::DeclarationName&&&, clang::SourceLocation&&&)
Line
Count
Source
216
1
          -> decltype(ToDeclT::Create(std::forward<Args>(args)...)) {
217
1
        return ToDeclT::Create(std::forward<Args>(args)...);
218
1
      }
decltype(clang::ObjCInterfaceDecl::Create(clang::ASTContext const&, clang::DeclContext*, clang::SourceLocation, clang::IdentifierInfo*, clang::ObjCTypeParamList*, clang::ObjCInterfaceDecl*, clang::SourceLocation, bool)(std::forward<clang::ASTContext&>(fp), std::forward<clang::DeclContext*&>(fp), std::forward<clang::SourceLocation&>(fp), std::forward<clang::IdentifierInfo*>(fp), std::forward<std::nullptr_t>(fp), std::forward<std::nullptr_t>(fp), std::forward<clang::SourceLocation&>(fp), std::forward<bool>(fp))) clang::ASTNodeImporter::CallOverloadedCreateFun<clang::ObjCInterfaceDecl>::operator()<clang::ASTContext&, clang::DeclContext*&, clang::SourceLocation&, clang::IdentifierInfo*, std::nullptr_t, std::nullptr_t, clang::SourceLocation&, bool>(clang::ASTContext&&&, clang::DeclContext*&&&, clang::SourceLocation&&&, clang::IdentifierInfo*&&, std::nullptr_t&&, std::nullptr_t&&, clang::SourceLocation&&&, bool&&)
Line
Count
Source
216
49
          -> decltype(ToDeclT::Create(std::forward<Args>(args)...)) {
217
49
        return ToDeclT::Create(std::forward<Args>(args)...);
218
49
      }
decltype(clang::ObjCCategoryImplDecl::Create(clang::ASTContext&, clang::DeclContext*, clang::IdentifierInfo*, clang::ObjCInterfaceDecl*, clang::SourceLocation, clang::SourceLocation, clang::SourceLocation)(std::forward<clang::ASTContext&>(fp), std::forward<clang::DeclContext*&>(fp), std::forward<clang::IdentifierInfo*>(fp), std::forward<clang::ObjCInterfaceDecl*>(fp), std::forward<clang::SourceLocation&>(fp), std::forward<clang::SourceLocation&>(fp), std::forward<clang::SourceLocation&>(fp))) clang::ASTNodeImporter::CallOverloadedCreateFun<clang::ObjCCategoryImplDecl>::operator()<clang::ASTContext&, clang::DeclContext*&, clang::IdentifierInfo*, clang::ObjCInterfaceDecl*, clang::SourceLocation&, clang::SourceLocation&, clang::SourceLocation&>(clang::ASTContext&&&, clang::DeclContext*&&&, clang::IdentifierInfo*&&, clang::ObjCInterfaceDecl*&&, clang::SourceLocation&&&, clang::SourceLocation&&&, clang::SourceLocation&&&)
Line
Count
Source
216
4
          -> decltype(ToDeclT::Create(std::forward<Args>(args)...)) {
217
4
        return ToDeclT::Create(std::forward<Args>(args)...);
218
4
      }
decltype(clang::ObjCImplementationDecl::Create(clang::ASTContext&, clang::DeclContext*, clang::ObjCInterfaceDecl*, clang::ObjCInterfaceDecl*, clang::SourceLocation, clang::SourceLocation, clang::SourceLocation, clang::SourceLocation, clang::SourceLocation)(std::forward<clang::ASTContext&>(fp), std::forward<clang::DeclContext*&>(fp), std::forward<clang::ObjCInterfaceDecl*&>(fp), std::forward<clang::ObjCInterfaceDecl*&>(fp), std::forward<clang::SourceLocation&>(fp), std::forward<clang::SourceLocation&>(fp), std::forward<clang::SourceLocation&>(fp), std::forward<clang::SourceLocation&>(fp), std::forward<clang::SourceLocation&>(fp))) clang::ASTNodeImporter::CallOverloadedCreateFun<clang::ObjCImplementationDecl>::operator()<clang::ASTContext&, clang::DeclContext*&, clang::ObjCInterfaceDecl*&, clang::ObjCInterfaceDecl*&, clang::SourceLocation&, clang::SourceLocation&, clang::SourceLocation&, clang::SourceLocation&, clang::SourceLocation&>(clang::ASTContext&&&, clang::DeclContext*&&&, clang::ObjCInterfaceDecl*&&&, clang::ObjCInterfaceDecl*&&&, clang::SourceLocation&&&, clang::SourceLocation&&&, clang::SourceLocation&&&, clang::SourceLocation&&&, clang::SourceLocation&&&)
Line
Count
Source
216
6
          -> decltype(ToDeclT::Create(std::forward<Args>(args)...)) {
217
6
        return ToDeclT::Create(std::forward<Args>(args)...);
218
6
      }
decltype(clang::ObjCPropertyDecl::Create(clang::ASTContext&, clang::DeclContext*, clang::SourceLocation, clang::IdentifierInfo*, clang::SourceLocation, clang::SourceLocation, clang::QualType, clang::TypeSourceInfo*, clang::ObjCPropertyDecl::PropertyControl)(std::forward<clang::ASTContext&>(fp), std::forward<clang::DeclContext*&>(fp), std::forward<clang::SourceLocation&>(fp), std::forward<clang::IdentifierInfo*>(fp), std::forward<clang::SourceLocation&>(fp), std::forward<clang::SourceLocation&>(fp), std::forward<clang::QualType&>(fp), std::forward<clang::TypeSourceInfo*&>(fp), std::forward<clang::ObjCPropertyDecl::PropertyControl>(fp))) clang::ASTNodeImporter::CallOverloadedCreateFun<clang::ObjCPropertyDecl>::operator()<clang::ASTContext&, clang::DeclContext*&, clang::SourceLocation&, clang::IdentifierInfo*, clang::SourceLocation&, clang::SourceLocation&, clang::QualType&, clang::TypeSourceInfo*&, clang::ObjCPropertyDecl::PropertyControl>(clang::ASTContext&&&, clang::DeclContext*&&&, clang::SourceLocation&&&, clang::IdentifierInfo*&&, clang::SourceLocation&&&, clang::SourceLocation&&&, clang::QualType&&&, clang::TypeSourceInfo*&&&, clang::ObjCPropertyDecl::PropertyControl&&)
Line
Count
Source
216
7
          -> decltype(ToDeclT::Create(std::forward<Args>(args)...)) {
217
7
        return ToDeclT::Create(std::forward<Args>(args)...);
218
7
      }
decltype(clang::ObjCPropertyImplDecl::Create(clang::ASTContext&, clang::DeclContext*, clang::SourceLocation, clang::SourceLocation, clang::ObjCPropertyDecl*, clang::ObjCPropertyImplDecl::Kind, clang::ObjCIvarDecl*, clang::SourceLocation)(std::forward<clang::ASTContext&>(fp), std::forward<clang::DeclContext*&>(fp), std::forward<clang::SourceLocation&>(fp), std::forward<clang::SourceLocation&>(fp), std::forward<clang::ObjCPropertyDecl*&>(fp), std::forward<clang::ObjCPropertyImplDecl::Kind>(fp), std::forward<clang::ObjCIvarDecl*&>(fp), std::forward<clang::SourceLocation&>(fp))) clang::ASTNodeImporter::CallOverloadedCreateFun<clang::ObjCPropertyImplDecl>::operator()<clang::ASTContext&, clang::DeclContext*&, clang::SourceLocation&, clang::SourceLocation&, clang::ObjCPropertyDecl*&, clang::ObjCPropertyImplDecl::Kind, clang::ObjCIvarDecl*&, clang::SourceLocation&>(clang::ASTContext&&&, clang::DeclContext*&&&, clang::SourceLocation&&&, clang::SourceLocation&&&, clang::ObjCPropertyDecl*&&&, clang::ObjCPropertyImplDecl::Kind&&, clang::ObjCIvarDecl*&&&, clang::SourceLocation&&&)
Line
Count
Source
216
4
          -> decltype(ToDeclT::Create(std::forward<Args>(args)...)) {
217
4
        return ToDeclT::Create(std::forward<Args>(args)...);
218
4
      }
decltype(clang::TemplateTypeParmDecl::Create(clang::ASTContext const&, clang::DeclContext*, clang::SourceLocation, clang::SourceLocation, unsigned int, unsigned int, clang::IdentifierInfo*, bool, bool)(std::forward<clang::ASTContext&>(fp), std::forward<clang::TranslationUnitDecl*>(fp), std::forward<clang::SourceLocation&>(fp), std::forward<clang::SourceLocation&>(fp), std::forward<unsigned int>(fp), std::forward<unsigned int>(fp), std::forward<clang::IdentifierInfo*>(fp), std::forward<bool>(fp), std::forward<bool>(fp))) clang::ASTNodeImporter::CallOverloadedCreateFun<clang::TemplateTypeParmDecl>::operator()<clang::ASTContext&, clang::TranslationUnitDecl*, clang::SourceLocation&, clang::SourceLocation&, unsigned int, unsigned int, clang::IdentifierInfo*, bool, bool>(clang::ASTContext&&&, clang::TranslationUnitDecl*&&, clang::SourceLocation&&&, clang::SourceLocation&&&, unsigned int&&, unsigned int&&, clang::IdentifierInfo*&&, bool&&, bool&&)
Line
Count
Source
216
653
          -> decltype(ToDeclT::Create(std::forward<Args>(args)...)) {
217
653
        return ToDeclT::Create(std::forward<Args>(args)...);
218
653
      }
decltype(clang::NonTypeTemplateParmDecl::Create(std::forward<clang::ASTContext&>(fp), std::forward<clang::TranslationUnitDecl*>(fp), std::forward<clang::SourceLocation&>(fp), std::forward<clang::SourceLocation&>(fp), std::forward<unsigned int>(fp), std::forward<unsigned int>(fp), std::forward<clang::IdentifierInfo*>(fp), std::forward<clang::QualType&>(fp), std::forward<bool>(fp), std::forward<clang::TypeSourceInfo*&>(fp))) clang::ASTNodeImporter::CallOverloadedCreateFun<clang::NonTypeTemplateParmDecl>::operator()<clang::ASTContext&, clang::TranslationUnitDecl*, clang::SourceLocation&, clang::SourceLocation&, unsigned int, unsigned int, clang::IdentifierInfo*, clang::QualType&, bool, clang::TypeSourceInfo*&>(clang::ASTContext&&&, clang::TranslationUnitDecl*&&, clang::SourceLocation&&&, clang::SourceLocation&&&, unsigned int&&, unsigned int&&, clang::IdentifierInfo*&&, clang::QualType&&&, bool&&, clang::TypeSourceInfo*&&&)
Line
Count
Source
216
51
          -> decltype(ToDeclT::Create(std::forward<Args>(args)...)) {
217
51
        return ToDeclT::Create(std::forward<Args>(args)...);
218
51
      }
decltype(clang::TemplateTemplateParmDecl::Create(std::forward<clang::ASTContext&>(fp), std::forward<clang::TranslationUnitDecl*>(fp), std::forward<clang::SourceLocation&>(fp), std::forward<unsigned int>(fp), std::forward<unsigned int>(fp), std::forward<bool>(fp), std::forward<clang::IdentifierInfo*>(fp), std::forward<clang::TemplateParameterList*&>(fp))) clang::ASTNodeImporter::CallOverloadedCreateFun<clang::TemplateTemplateParmDecl>::operator()<clang::ASTContext&, clang::TranslationUnitDecl*, clang::SourceLocation&, unsigned int, unsigned int, bool, clang::IdentifierInfo*, clang::TemplateParameterList*&>(clang::ASTContext&&&, clang::TranslationUnitDecl*&&, clang::SourceLocation&&&, unsigned int&&, unsigned int&&, bool&&, clang::IdentifierInfo*&&, clang::TemplateParameterList*&&&)
Line
Count
Source
216
5
          -> decltype(ToDeclT::Create(std::forward<Args>(args)...)) {
217
5
        return ToDeclT::Create(std::forward<Args>(args)...);
218
5
      }
decltype(clang::ClassTemplateDecl::Create(clang::ASTContext&, clang::DeclContext*, clang::SourceLocation, clang::DeclarationName, clang::TemplateParameterList*, clang::NamedDecl*, clang::Expr*)(std::forward<clang::ASTContext&>(fp), std::forward<clang::DeclContext*&>(fp), std::forward<clang::SourceLocation&>(fp), std::forward<clang::DeclarationName&>(fp), std::forward<clang::TemplateParameterList*&>(fp), std::forward<clang::CXXRecordDecl*&>(fp))) clang::ASTNodeImporter::CallOverloadedCreateFun<clang::ClassTemplateDecl>::operator()<clang::ASTContext&, clang::DeclContext*&, clang::SourceLocation&, clang::DeclarationName&, clang::TemplateParameterList*&, clang::CXXRecordDecl*&>(clang::ASTContext&&&, clang::DeclContext*&&&, clang::SourceLocation&&&, clang::DeclarationName&&&, clang::TemplateParameterList*&&&, clang::CXXRecordDecl*&&&)
Line
Count
Source
216
349
          -> decltype(ToDeclT::Create(std::forward<Args>(args)...)) {
217
349
        return ToDeclT::Create(std::forward<Args>(args)...);
218
349
      }
decltype(clang::ClassTemplatePartialSpecializationDecl::Create(clang::ASTContext&, clang::TagTypeKind, clang::DeclContext*, clang::SourceLocation, clang::SourceLocation, clang::TemplateParameterList*, clang::ClassTemplateDecl*, llvm::ArrayRef<clang::TemplateArgument>, clang::TemplateArgumentListInfo const&, clang::QualType, clang::ClassTemplatePartialSpecializationDecl*)(std::forward<clang::ASTContext&>(fp), std::forward<clang::TagTypeKind>(fp), std::forward<clang::DeclContext*&>(fp), std::forward<clang::SourceLocation&>(fp), std::forward<clang::SourceLocation&>(fp), std::forward<clang::TemplateParameterList*&>(fp), std::forward<clang::ClassTemplateDecl*&>(fp), std::forward<llvm::ArrayRef<clang::TemplateArgument> >(fp), std::forward<clang::TemplateArgumentListInfo&>(fp), std::forward<clang::QualType&>(fp), std::forward<clang::ClassTemplatePartialSpecializationDecl*>(fp))) clang::ASTNodeImporter::CallOverloadedCreateFun<clang::ClassTemplatePartialSpecializationDecl>::operator()<clang::ASTContext&, clang::TagTypeKind, clang::DeclContext*&, clang::SourceLocation&, clang::SourceLocation&, clang::TemplateParameterList*&, clang::ClassTemplateDecl*&, llvm::ArrayRef<clang::TemplateArgument>, clang::TemplateArgumentListInfo&, clang::QualType&, clang::ClassTemplatePartialSpecializationDecl*>(clang::ASTContext&&&, clang::TagTypeKind&&, clang::DeclContext*&&&, clang::SourceLocation&&&, clang::SourceLocation&&&, clang::TemplateParameterList*&&&, clang::ClassTemplateDecl*&&&, llvm::ArrayRef<clang::TemplateArgument>&&, clang::TemplateArgumentListInfo&&&, clang::QualType&&&, clang::ClassTemplatePartialSpecializationDecl*&&)
Line
Count
Source
216
16
          -> decltype(ToDeclT::Create(std::forward<Args>(args)...)) {
217
16
        return ToDeclT::Create(std::forward<Args>(args)...);
218
16
      }
decltype(clang::ClassTemplateSpecializationDecl::Create(clang::ASTContext&, clang::TagTypeKind, clang::DeclContext*, clang::SourceLocation, clang::SourceLocation, clang::ClassTemplateDecl*, llvm::ArrayRef<clang::TemplateArgument>, clang::ClassTemplateSpecializationDecl*)(std::forward<clang::ASTContext&>(fp), std::forward<clang::TagTypeKind>(fp), std::forward<clang::DeclContext*&>(fp), std::forward<clang::SourceLocation&>(fp), std::forward<clang::SourceLocation&>(fp), std::forward<clang::ClassTemplateDecl*&>(fp), std::forward<llvm::SmallVector<clang::TemplateArgument, 2u>&>(fp), std::forward<clang::ClassTemplateSpecializationDecl*&>(fp))) clang::ASTNodeImporter::CallOverloadedCreateFun<clang::ClassTemplateSpecializationDecl>::operator()<clang::ASTContext&, clang::TagTypeKind, clang::DeclContext*&, clang::SourceLocation&, clang::SourceLocation&, clang::ClassTemplateDecl*&, llvm::SmallVector<clang::TemplateArgument, 2u>&, clang::ClassTemplateSpecializationDecl*&>(clang::ASTContext&&&, clang::TagTypeKind&&, clang::DeclContext*&&&, clang::SourceLocation&&&, clang::SourceLocation&&&, clang::ClassTemplateDecl*&&&, llvm::SmallVector<clang::TemplateArgument, 2u>&&&, clang::ClassTemplateSpecializationDecl*&&&)
Line
Count
Source
216
143
          -> decltype(ToDeclT::Create(std::forward<Args>(args)...)) {
217
143
        return ToDeclT::Create(std::forward<Args>(args)...);
218
143
      }
decltype(clang::VarTemplateDecl::Create(clang::ASTContext&, clang::DeclContext*, clang::SourceLocation, clang::DeclarationName, clang::TemplateParameterList*, clang::VarDecl*)(std::forward<clang::ASTContext&>(fp), std::forward<clang::DeclContext*&>(fp), std::forward<clang::SourceLocation&>(fp), std::forward<clang::DeclarationName&>(fp), std::forward<clang::TemplateParameterList*&>(fp), std::forward<clang::VarDecl*&>(fp))) clang::ASTNodeImporter::CallOverloadedCreateFun<clang::VarTemplateDecl>::operator()<clang::ASTContext&, clang::DeclContext*&, clang::SourceLocation&, clang::DeclarationName&, clang::TemplateParameterList*&, clang::VarDecl*&>(clang::ASTContext&&&, clang::DeclContext*&&&, clang::SourceLocation&&&, clang::DeclarationName&&&, clang::TemplateParameterList*&&&, clang::VarDecl*&&&)
Line
Count
Source
216
7
          -> decltype(ToDeclT::Create(std::forward<Args>(args)...)) {
217
7
        return ToDeclT::Create(std::forward<Args>(args)...);
218
7
      }
decltype(clang::VarTemplatePartialSpecializationDecl::Create(clang::ASTContext&, clang::DeclContext*, clang::SourceLocation, clang::SourceLocation, clang::TemplateParameterList*, clang::VarTemplateDecl*, clang::QualType, clang::TypeSourceInfo*, clang::StorageClass, llvm::ArrayRef<clang::TemplateArgument>, clang::TemplateArgumentListInfo const&)(std::forward<clang::ASTContext&>(fp), std::forward<clang::DeclContext*&>(fp), std::forward<clang::SourceLocation&>(fp), std::forward<clang::SourceLocation&>(fp), std::forward<clang::TemplateParameterList*&>(fp), std::forward<clang::VarTemplateDecl*&>(fp), std::forward<clang::QualType&>(fp), std::forward<clang::TypeSourceInfo*&>(fp), std::forward<clang::StorageClass>(fp), std::forward<llvm::SmallVector<clang::TemplateArgument, 2u>&>(fp), std::forward<clang::TemplateArgumentListInfo&>(fp))) clang::ASTNodeImporter::CallOverloadedCreateFun<clang::VarTemplatePartialSpecializationDecl>::operator()<clang::ASTContext&, clang::DeclContext*&, clang::SourceLocation&, clang::SourceLocation&, clang::TemplateParameterList*&, clang::VarTemplateDecl*&, clang::QualType&, clang::TypeSourceInfo*&, clang::StorageClass, llvm::SmallVector<clang::TemplateArgument, 2u>&, clang::TemplateArgumentListInfo&>(clang::ASTContext&&&, clang::DeclContext*&&&, clang::SourceLocation&&&, clang::SourceLocation&&&, clang::TemplateParameterList*&&&, clang::VarTemplateDecl*&&&, clang::QualType&&&, clang::TypeSourceInfo*&&&, clang::StorageClass&&, llvm::SmallVector<clang::TemplateArgument, 2u>&&&, clang::TemplateArgumentListInfo&&&)
Line
Count
Source
216
2
          -> decltype(ToDeclT::Create(std::forward<Args>(args)...)) {
217
2
        return ToDeclT::Create(std::forward<Args>(args)...);
218
2
      }
decltype(clang::VarTemplateSpecializationDecl::Create(clang::ASTContext&, clang::DeclContext*, clang::SourceLocation, clang::SourceLocation, clang::VarTemplateDecl*, clang::QualType, clang::TypeSourceInfo*, clang::StorageClass, llvm::ArrayRef<clang::TemplateArgument>)(std::forward<clang::ASTContext&>(fp), std::forward<clang::DeclContext*&>(fp), std::forward<clang::SourceLocation&>(fp), std::forward<clang::SourceLocation&>(fp), std::forward<clang::VarTemplateDecl*&>(fp), std::forward<clang::QualType&>(fp), std::forward<clang::TypeSourceInfo*&>(fp), std::forward<clang::StorageClass>(fp), std::forward<llvm::SmallVector<clang::TemplateArgument, 2u>&>(fp))) clang::ASTNodeImporter::CallOverloadedCreateFun<clang::VarTemplateSpecializationDecl>::operator()<clang::ASTContext&, clang::DeclContext*&, clang::SourceLocation&, clang::SourceLocation&, clang::VarTemplateDecl*&, clang::QualType&, clang::TypeSourceInfo*&, clang::StorageClass, llvm::SmallVector<clang::TemplateArgument, 2u>&>(clang::ASTContext&&&, clang::DeclContext*&&&, clang::SourceLocation&&&, clang::SourceLocation&&&, clang::VarTemplateDecl*&&&, clang::QualType&&&, clang::TypeSourceInfo*&&&, clang::StorageClass&&, llvm::SmallVector<clang::TemplateArgument, 2u>&&&)
Line
Count
Source
216
6
          -> decltype(ToDeclT::Create(std::forward<Args>(args)...)) {
217
6
        return ToDeclT::Create(std::forward<Args>(args)...);
218
6
      }
decltype(clang::FunctionTemplateDecl::Create(clang::ASTContext&, clang::DeclContext*, clang::SourceLocation, clang::DeclarationName, clang::TemplateParameterList*, clang::NamedDecl*)(std::forward<clang::ASTContext&>(fp), std::forward<clang::DeclContext*&>(fp), std::forward<clang::SourceLocation&>(fp), std::forward<clang::DeclarationName&>(fp), std::forward<clang::TemplateParameterList*&>(fp), std::forward<clang::FunctionDecl*&>(fp))) clang::ASTNodeImporter::CallOverloadedCreateFun<clang::FunctionTemplateDecl>::operator()<clang::ASTContext&, clang::DeclContext*&, clang::SourceLocation&, clang::DeclarationName&, clang::TemplateParameterList*&, clang::FunctionDecl*&>(clang::ASTContext&&&, clang::DeclContext*&&&, clang::SourceLocation&&&, clang::DeclarationName&&&, clang::TemplateParameterList*&&&, clang::FunctionDecl*&&&)
Line
Count
Source
216
280
          -> decltype(ToDeclT::Create(std::forward<Args>(args)...)) {
217
280
        return ToDeclT::Create(std::forward<Args>(args)...);
218
280
      }
219
    };
220
221
    // Always use these functions to create a Decl during import. There are
222
    // certain tasks which must be done after the Decl was created, e.g. we
223
    // must immediately register that as an imported Decl.  The parameter `ToD`
224
    // will be set to the newly created Decl or if had been imported before
225
    // then to the already imported Decl.  Returns a bool value set to true if
226
    // the `FromD` had been imported before.
227
    template <typename ToDeclT, typename FromDeclT, typename... Args>
228
    LLVM_NODISCARD bool GetImportedOrCreateDecl(ToDeclT *&ToD, FromDeclT *FromD,
229
8.03k
                                                Args &&... args) {
230
8.03k
      // There may be several overloads of ToDeclT::Create. We must make sure
231
8.03k
      // to call the one which would be chosen by the arguments, thus we use a
232
8.03k
      // wrapper for the overload set.
233
8.03k
      CallOverloadedCreateFun<ToDeclT> OC;
234
8.03k
      return GetImportedOrCreateSpecialDecl(ToD, OC, FromD,
235
8.03k
                                            std::forward<Args>(args)...);
236
8.03k
    }
Unexecuted instantiation: bool clang::ASTNodeImporter::GetImportedOrCreateDecl<clang::EmptyDecl, clang::EmptyDecl, clang::ASTContext&, clang::DeclContext*&, clang::SourceLocation&>(clang::EmptyDecl*&, clang::EmptyDecl*, clang::ASTContext&&&, clang::DeclContext*&&&, clang::SourceLocation&&&)
bool clang::ASTNodeImporter::GetImportedOrCreateDecl<clang::AccessSpecDecl, clang::AccessSpecDecl, clang::ASTContext&, clang::AccessSpecifier, clang::DeclContext*&, clang::SourceLocation&, clang::SourceLocation&>(clang::AccessSpecDecl*&, clang::AccessSpecDecl*, clang::ASTContext&&&, clang::AccessSpecifier&&, clang::DeclContext*&&&, clang::SourceLocation&&&, clang::SourceLocation&&&)
Line
Count
Source
229
37
                                                Args &&... args) {
230
37
      // There may be several overloads of ToDeclT::Create. We must make sure
231
37
      // to call the one which would be chosen by the arguments, thus we use a
232
37
      // wrapper for the overload set.
233
37
      CallOverloadedCreateFun<ToDeclT> OC;
234
37
      return GetImportedOrCreateSpecialDecl(ToD, OC, FromD,
235
37
                                            std::forward<Args>(args)...);
236
37
    }
bool clang::ASTNodeImporter::GetImportedOrCreateDecl<clang::StaticAssertDecl, clang::StaticAssertDecl, clang::ASTContext&, clang::DeclContext*&, clang::SourceLocation&, clang::Expr*&, clang::StringLiteral*&, clang::SourceLocation&, bool>(clang::StaticAssertDecl*&, clang::StaticAssertDecl*, clang::ASTContext&&&, clang::DeclContext*&&&, clang::SourceLocation&&&, clang::Expr*&&&, clang::StringLiteral*&&&, clang::SourceLocation&&&, bool&&)
Line
Count
Source
229
12
                                                Args &&... args) {
230
12
      // There may be several overloads of ToDeclT::Create. We must make sure
231
12
      // to call the one which would be chosen by the arguments, thus we use a
232
12
      // wrapper for the overload set.
233
12
      CallOverloadedCreateFun<ToDeclT> OC;
234
12
      return GetImportedOrCreateSpecialDecl(ToD, OC, FromD,
235
12
                                            std::forward<Args>(args)...);
236
12
    }
bool clang::ASTNodeImporter::GetImportedOrCreateDecl<clang::NamespaceDecl, clang::NamespaceDecl, clang::ASTContext&, clang::DeclContext*&, bool, clang::SourceLocation&, clang::SourceLocation&, clang::IdentifierInfo*, std::nullptr_t>(clang::NamespaceDecl*&, clang::NamespaceDecl*, clang::ASTContext&&&, clang::DeclContext*&&&, bool&&, clang::SourceLocation&&&, clang::SourceLocation&&&, clang::IdentifierInfo*&&, std::nullptr_t&&)
Line
Count
Source
229
189
                                                Args &&... args) {
230
189
      // There may be several overloads of ToDeclT::Create. We must make sure
231
189
      // to call the one which would be chosen by the arguments, thus we use a
232
189
      // wrapper for the overload set.
233
189
      CallOverloadedCreateFun<ToDeclT> OC;
234
189
      return GetImportedOrCreateSpecialDecl(ToD, OC, FromD,
235
189
                                            std::forward<Args>(args)...);
236
189
    }
bool clang::ASTNodeImporter::GetImportedOrCreateDecl<clang::NamespaceAliasDecl, clang::NamespaceAliasDecl, clang::ASTContext&, clang::DeclContext*&, clang::SourceLocation&, clang::SourceLocation&, clang::IdentifierInfo*&, clang::NestedNameSpecifierLoc&, clang::SourceLocation&, clang::NamespaceDecl*&>(clang::NamespaceAliasDecl*&, clang::NamespaceAliasDecl*, clang::ASTContext&&&, clang::DeclContext*&&&, clang::SourceLocation&&&, clang::SourceLocation&&&, clang::IdentifierInfo*&&&, clang::NestedNameSpecifierLoc&&&, clang::SourceLocation&&&, clang::NamespaceDecl*&&&)
Line
Count
Source
229
3
                                                Args &&... args) {
230
3
      // There may be several overloads of ToDeclT::Create. We must make sure
231
3
      // to call the one which would be chosen by the arguments, thus we use a
232
3
      // wrapper for the overload set.
233
3
      CallOverloadedCreateFun<ToDeclT> OC;
234
3
      return GetImportedOrCreateSpecialDecl(ToD, OC, FromD,
235
3
                                            std::forward<Args>(args)...);
236
3
    }
bool clang::ASTNodeImporter::GetImportedOrCreateDecl<clang::TypeAliasTemplateDecl, clang::TypeAliasTemplateDecl, clang::ASTContext&, clang::DeclContext*&, clang::SourceLocation&, clang::DeclarationName&, clang::TemplateParameterList*&, clang::TypeAliasDecl*&>(clang::TypeAliasTemplateDecl*&, clang::TypeAliasTemplateDecl*, clang::ASTContext&&&, clang::DeclContext*&&&, clang::SourceLocation&&&, clang::DeclarationName&&&, clang::TemplateParameterList*&&&, clang::TypeAliasDecl*&&&)
Line
Count
Source
229
12
                                                Args &&... args) {
230
12
      // There may be several overloads of ToDeclT::Create. We must make sure
231
12
      // to call the one which would be chosen by the arguments, thus we use a
232
12
      // wrapper for the overload set.
233
12
      CallOverloadedCreateFun<ToDeclT> OC;
234
12
      return GetImportedOrCreateSpecialDecl(ToD, OC, FromD,
235
12
                                            std::forward<Args>(args)...);
236
12
    }
Unexecuted instantiation: bool clang::ASTNodeImporter::GetImportedOrCreateDecl<clang::LabelDecl, clang::LabelDecl, clang::ASTContext&, clang::DeclContext*&, clang::SourceLocation&, clang::IdentifierInfo*, clang::SourceLocation&>(clang::LabelDecl*&, clang::LabelDecl*, clang::ASTContext&&&, clang::DeclContext*&&&, clang::SourceLocation&&&, clang::IdentifierInfo*&&, clang::SourceLocation&&&)
bool clang::ASTNodeImporter::GetImportedOrCreateDecl<clang::LabelDecl, clang::LabelDecl, clang::ASTContext&, clang::DeclContext*&, clang::SourceLocation&, clang::IdentifierInfo*>(clang::LabelDecl*&, clang::LabelDecl*, clang::ASTContext&&&, clang::DeclContext*&&&, clang::SourceLocation&&&, clang::IdentifierInfo*&&)
Line
Count
Source
229
6
                                                Args &&... args) {
230
6
      // There may be several overloads of ToDeclT::Create. We must make sure
231
6
      // to call the one which would be chosen by the arguments, thus we use a
232
6
      // wrapper for the overload set.
233
6
      CallOverloadedCreateFun<ToDeclT> OC;
234
6
      return GetImportedOrCreateSpecialDecl(ToD, OC, FromD,
235
6
                                            std::forward<Args>(args)...);
236
6
    }
bool clang::ASTNodeImporter::GetImportedOrCreateDecl<clang::EnumDecl, clang::EnumDecl, clang::ASTContext&, clang::DeclContext*&, clang::SourceLocation&, clang::SourceLocation&, clang::IdentifierInfo*, std::nullptr_t, bool, bool, bool>(clang::EnumDecl*&, clang::EnumDecl*, clang::ASTContext&&&, clang::DeclContext*&&&, clang::SourceLocation&&&, clang::SourceLocation&&&, clang::IdentifierInfo*&&, std::nullptr_t&&, bool&&, bool&&, bool&&)
Line
Count
Source
229
70
                                                Args &&... args) {
230
70
      // There may be several overloads of ToDeclT::Create. We must make sure
231
70
      // to call the one which would be chosen by the arguments, thus we use a
232
70
      // wrapper for the overload set.
233
70
      CallOverloadedCreateFun<ToDeclT> OC;
234
70
      return GetImportedOrCreateSpecialDecl(ToD, OC, FromD,
235
70
                                            std::forward<Args>(args)...);
236
70
    }
bool clang::ASTNodeImporter::GetImportedOrCreateDecl<clang::CXXRecordDecl, clang::RecordDecl, clang::ASTContext&, clang::TagTypeKind, clang::DeclContext*&, clang::SourceLocation&, clang::SourceLocation&, clang::IdentifierInfo*, clang::CXXRecordDecl*, bool const&>(clang::CXXRecordDecl*&, clang::RecordDecl*, clang::ASTContext&&&, clang::TagTypeKind&&, clang::DeclContext*&&&, clang::SourceLocation&&&, clang::SourceLocation&&&, clang::IdentifierInfo*&&, clang::CXXRecordDecl*&&, bool const&&&)
Line
Count
Source
229
705
                                                Args &&... args) {
230
705
      // There may be several overloads of ToDeclT::Create. We must make sure
231
705
      // to call the one which would be chosen by the arguments, thus we use a
232
705
      // wrapper for the overload set.
233
705
      CallOverloadedCreateFun<ToDeclT> OC;
234
705
      return GetImportedOrCreateSpecialDecl(ToD, OC, FromD,
235
705
                                            std::forward<Args>(args)...);
236
705
    }
bool clang::ASTNodeImporter::GetImportedOrCreateDecl<clang::CXXRecordDecl, clang::RecordDecl, clang::ASTContext&, clang::TagTypeKind, clang::DeclContext*&, clang::SourceLocation&, clang::SourceLocation&, clang::IdentifierInfo*, clang::CXXRecordDecl*>(clang::CXXRecordDecl*&, clang::RecordDecl*, clang::ASTContext&&&, clang::TagTypeKind&&, clang::DeclContext*&&&, clang::SourceLocation&&&, clang::SourceLocation&&&, clang::IdentifierInfo*&&, clang::CXXRecordDecl*&&)
Line
Count
Source
229
1.23k
                                                Args &&... args) {
230
1.23k
      // There may be several overloads of ToDeclT::Create. We must make sure
231
1.23k
      // to call the one which would be chosen by the arguments, thus we use a
232
1.23k
      // wrapper for the overload set.
233
1.23k
      CallOverloadedCreateFun<ToDeclT> OC;
234
1.23k
      return GetImportedOrCreateSpecialDecl(ToD, OC, FromD,
235
1.23k
                                            std::forward<Args>(args)...);
236
1.23k
    }
bool clang::ASTNodeImporter::GetImportedOrCreateDecl<clang::RecordDecl, clang::RecordDecl, clang::ASTContext&, clang::TagTypeKind, clang::DeclContext*&, clang::SourceLocation&, clang::SourceLocation&, clang::IdentifierInfo*, clang::RecordDecl*&>(clang::RecordDecl*&, clang::RecordDecl*, clang::ASTContext&&&, clang::TagTypeKind&&, clang::DeclContext*&&&, clang::SourceLocation&&&, clang::SourceLocation&&&, clang::IdentifierInfo*&&, clang::RecordDecl*&&&)
Line
Count
Source
229
167
                                                Args &&... args) {
230
167
      // There may be several overloads of ToDeclT::Create. We must make sure
231
167
      // to call the one which would be chosen by the arguments, thus we use a
232
167
      // wrapper for the overload set.
233
167
      CallOverloadedCreateFun<ToDeclT> OC;
234
167
      return GetImportedOrCreateSpecialDecl(ToD, OC, FromD,
235
167
                                            std::forward<Args>(args)...);
236
167
    }
bool clang::ASTNodeImporter::GetImportedOrCreateDecl<clang::EnumConstantDecl, clang::EnumConstantDecl, clang::ASTContext&, clang::EnumDecl*, clang::SourceLocation&, clang::IdentifierInfo*, clang::QualType&, clang::Expr*&, llvm::APSInt const&>(clang::EnumConstantDecl*&, clang::EnumConstantDecl*, clang::ASTContext&&&, clang::EnumDecl*&&, clang::SourceLocation&&&, clang::IdentifierInfo*&&, clang::QualType&&&, clang::Expr*&&&, llvm::APSInt const&&&)
Line
Count
Source
229
52
                                                Args &&... args) {
230
52
      // There may be several overloads of ToDeclT::Create. We must make sure
231
52
      // to call the one which would be chosen by the arguments, thus we use a
232
52
      // wrapper for the overload set.
233
52
      CallOverloadedCreateFun<ToDeclT> OC;
234
52
      return GetImportedOrCreateSpecialDecl(ToD, OC, FromD,
235
52
                                            std::forward<Args>(args)...);
236
52
    }
bool clang::ASTNodeImporter::GetImportedOrCreateDecl<clang::FunctionDecl, clang::FunctionDecl, clang::ASTContext&, clang::DeclContext*&, clang::SourceLocation&, clang::DeclarationNameInfo&, clang::QualType&, clang::TypeSourceInfo*&, clang::StorageClass, bool, bool, clang::ConstexprSpecKind>(clang::FunctionDecl*&, clang::FunctionDecl*, clang::ASTContext&&&, clang::DeclContext*&&&, clang::SourceLocation&&&, clang::DeclarationNameInfo&&&, clang::QualType&&&, clang::TypeSourceInfo*&&&, clang::StorageClass&&, bool&&, bool&&, clang::ConstexprSpecKind&&)
Line
Count
Source
229
1.26k
                                                Args &&... args) {
230
1.26k
      // There may be several overloads of ToDeclT::Create. We must make sure
231
1.26k
      // to call the one which would be chosen by the arguments, thus we use a
232
1.26k
      // wrapper for the overload set.
233
1.26k
      CallOverloadedCreateFun<ToDeclT> OC;
234
1.26k
      return GetImportedOrCreateSpecialDecl(ToD, OC, FromD,
235
1.26k
                                            std::forward<Args>(args)...);
236
1.26k
    }
bool clang::ASTNodeImporter::GetImportedOrCreateDecl<clang::FieldDecl, clang::FieldDecl, clang::ASTContext&, clang::DeclContext*&, clang::SourceLocation&, clang::SourceLocation&, clang::IdentifierInfo*, clang::QualType&, clang::TypeSourceInfo*&, clang::Expr*&, bool, clang::InClassInitStyle>(clang::FieldDecl*&, clang::FieldDecl*, clang::ASTContext&&&, clang::DeclContext*&&&, clang::SourceLocation&&&, clang::SourceLocation&&&, clang::IdentifierInfo*&&, clang::QualType&&&, clang::TypeSourceInfo*&&&, clang::Expr*&&&, bool&&, clang::InClassInitStyle&&)
Line
Count
Source
229
593
                                                Args &&... args) {
230
593
      // There may be several overloads of ToDeclT::Create. We must make sure
231
593
      // to call the one which would be chosen by the arguments, thus we use a
232
593
      // wrapper for the overload set.
233
593
      CallOverloadedCreateFun<ToDeclT> OC;
234
593
      return GetImportedOrCreateSpecialDecl(ToD, OC, FromD,
235
593
                                            std::forward<Args>(args)...);
236
593
    }
bool clang::ASTNodeImporter::GetImportedOrCreateDecl<clang::IndirectFieldDecl, clang::IndirectFieldDecl, clang::ASTContext&, clang::DeclContext*&, clang::SourceLocation&, clang::IdentifierInfo*, clang::QualType&, llvm::MutableArrayRef<clang::NamedDecl*>&>(clang::IndirectFieldDecl*&, clang::IndirectFieldDecl*, clang::ASTContext&&&, clang::DeclContext*&&&, clang::SourceLocation&&&, clang::IdentifierInfo*&&, clang::QualType&&&, llvm::MutableArrayRef<clang::NamedDecl*>&&&)
Line
Count
Source
229
27
                                                Args &&... args) {
230
27
      // There may be several overloads of ToDeclT::Create. We must make sure
231
27
      // to call the one which would be chosen by the arguments, thus we use a
232
27
      // wrapper for the overload set.
233
27
      CallOverloadedCreateFun<ToDeclT> OC;
234
27
      return GetImportedOrCreateSpecialDecl(ToD, OC, FromD,
235
27
                                            std::forward<Args>(args)...);
236
27
    }
bool clang::ASTNodeImporter::GetImportedOrCreateDecl<clang::FriendDecl, clang::FriendDecl, clang::ASTContext&, clang::DeclContext*&, clang::SourceLocation&, llvm::PointerUnion<clang::NamedDecl*, clang::TypeSourceInfo*>&, clang::SourceLocation&, llvm::SmallVector<clang::TemplateParameterList*, 1u>&>(clang::FriendDecl*&, clang::FriendDecl*, clang::ASTContext&&&, clang::DeclContext*&&&, clang::SourceLocation&&&, llvm::PointerUnion<clang::NamedDecl*, clang::TypeSourceInfo*>&&&, clang::SourceLocation&&&, llvm::SmallVector<clang::TemplateParameterList*, 1u>&&&)
Line
Count
Source
229
91
                                                Args &&... args) {
230
91
      // There may be several overloads of ToDeclT::Create. We must make sure
231
91
      // to call the one which would be chosen by the arguments, thus we use a
232
91
      // wrapper for the overload set.
233
91
      CallOverloadedCreateFun<ToDeclT> OC;
234
91
      return GetImportedOrCreateSpecialDecl(ToD, OC, FromD,
235
91
                                            std::forward<Args>(args)...);
236
91
    }
bool clang::ASTNodeImporter::GetImportedOrCreateDecl<clang::ObjCIvarDecl, clang::ObjCIvarDecl, clang::ASTContext&, clang::ObjCContainerDecl*, clang::SourceLocation&, clang::SourceLocation&, clang::IdentifierInfo*, clang::QualType&, clang::TypeSourceInfo*&, clang::ObjCIvarDecl::AccessControl, clang::Expr*&, bool>(clang::ObjCIvarDecl*&, clang::ObjCIvarDecl*, clang::ASTContext&&&, clang::ObjCContainerDecl*&&, clang::SourceLocation&&&, clang::SourceLocation&&&, clang::IdentifierInfo*&&, clang::QualType&&&, clang::TypeSourceInfo*&&&, clang::ObjCIvarDecl::AccessControl&&, clang::Expr*&&&, bool&&)
Line
Count
Source
229
10
                                                Args &&... args) {
230
10
      // There may be several overloads of ToDeclT::Create. We must make sure
231
10
      // to call the one which would be chosen by the arguments, thus we use a
232
10
      // wrapper for the overload set.
233
10
      CallOverloadedCreateFun<ToDeclT> OC;
234
10
      return GetImportedOrCreateSpecialDecl(ToD, OC, FromD,
235
10
                                            std::forward<Args>(args)...);
236
10
    }
bool clang::ASTNodeImporter::GetImportedOrCreateDecl<clang::VarDecl, clang::VarDecl, clang::ASTContext&, clang::DeclContext*&, clang::SourceLocation&, clang::SourceLocation&, clang::IdentifierInfo*, clang::QualType&, clang::TypeSourceInfo*&, clang::StorageClass>(clang::VarDecl*&, clang::VarDecl*, clang::ASTContext&&&, clang::DeclContext*&&&, clang::SourceLocation&&&, clang::SourceLocation&&&, clang::IdentifierInfo*&&, clang::QualType&&&, clang::TypeSourceInfo*&&&, clang::StorageClass&&)
Line
Count
Source
229
703
                                                Args &&... args) {
230
703
      // There may be several overloads of ToDeclT::Create. We must make sure
231
703
      // to call the one which would be chosen by the arguments, thus we use a
232
703
      // wrapper for the overload set.
233
703
      CallOverloadedCreateFun<ToDeclT> OC;
234
703
      return GetImportedOrCreateSpecialDecl(ToD, OC, FromD,
235
703
                                            std::forward<Args>(args)...);
236
703
    }
Unexecuted instantiation: bool clang::ASTNodeImporter::GetImportedOrCreateDecl<clang::ImplicitParamDecl, clang::ImplicitParamDecl, clang::ASTContext&, clang::DeclContext*&, clang::SourceLocation&, clang::IdentifierInfo*, clang::QualType&, clang::ImplicitParamDecl::ImplicitParamKind>(clang::ImplicitParamDecl*&, clang::ImplicitParamDecl*, clang::ASTContext&&&, clang::DeclContext*&&&, clang::SourceLocation&&&, clang::IdentifierInfo*&&, clang::QualType&&&, clang::ImplicitParamDecl::ImplicitParamKind&&)
bool clang::ASTNodeImporter::GetImportedOrCreateDecl<clang::ParmVarDecl, clang::ParmVarDecl, clang::ASTContext&, clang::DeclContext*&, clang::SourceLocation&, clang::SourceLocation&, clang::IdentifierInfo*, clang::QualType&, clang::TypeSourceInfo*&, clang::StorageClass, std::nullptr_t>(clang::ParmVarDecl*&, clang::ParmVarDecl*, clang::ASTContext&&&, clang::DeclContext*&&&, clang::SourceLocation&&&, clang::SourceLocation&&&, clang::IdentifierInfo*&&, clang::QualType&&&, clang::TypeSourceInfo*&&&, clang::StorageClass&&, std::nullptr_t&&)
Line
Count
Source
229
616
                                                Args &&... args) {
230
616
      // There may be several overloads of ToDeclT::Create. We must make sure
231
616
      // to call the one which would be chosen by the arguments, thus we use a
232
616
      // wrapper for the overload set.
233
616
      CallOverloadedCreateFun<ToDeclT> OC;
234
616
      return GetImportedOrCreateSpecialDecl(ToD, OC, FromD,
235
616
                                            std::forward<Args>(args)...);
236
616
    }
bool clang::ASTNodeImporter::GetImportedOrCreateDecl<clang::ObjCMethodDecl, clang::ObjCMethodDecl, clang::ASTContext&, clang::SourceLocation&, clang::SourceLocation&, clang::Selector, clang::QualType&, clang::TypeSourceInfo*&, clang::DeclContext*&, bool, bool, bool, bool, bool, clang::ObjCMethodDecl::ImplementationControl, bool>(clang::ObjCMethodDecl*&, clang::ObjCMethodDecl*, clang::ASTContext&&&, clang::SourceLocation&&&, clang::SourceLocation&&&, clang::Selector&&, clang::QualType&&&, clang::TypeSourceInfo*&&&, clang::DeclContext*&&&, bool&&, bool&&, bool&&, bool&&, bool&&, clang::ObjCMethodDecl::ImplementationControl&&, bool&&)
Line
Count
Source
229
43
                                                Args &&... args) {
230
43
      // There may be several overloads of ToDeclT::Create. We must make sure
231
43
      // to call the one which would be chosen by the arguments, thus we use a
232
43
      // wrapper for the overload set.
233
43
      CallOverloadedCreateFun<ToDeclT> OC;
234
43
      return GetImportedOrCreateSpecialDecl(ToD, OC, FromD,
235
43
                                            std::forward<Args>(args)...);
236
43
    }
bool clang::ASTNodeImporter::GetImportedOrCreateDecl<clang::ObjCTypeParamDecl, clang::ObjCTypeParamDecl, clang::ASTContext&, clang::DeclContext*&, clang::ObjCTypeParamVariance, clang::SourceLocation&, unsigned int, clang::SourceLocation&, clang::IdentifierInfo*, clang::SourceLocation&, clang::TypeSourceInfo*&>(clang::ObjCTypeParamDecl*&, clang::ObjCTypeParamDecl*, clang::ASTContext&&&, clang::DeclContext*&&&, clang::ObjCTypeParamVariance&&, clang::SourceLocation&&&, unsigned int&&, clang::SourceLocation&&&, clang::IdentifierInfo*&&, clang::SourceLocation&&&, clang::TypeSourceInfo*&&&)
Line
Count
Source
229
4
                                                Args &&... args) {
230
4
      // There may be several overloads of ToDeclT::Create. We must make sure
231
4
      // to call the one which would be chosen by the arguments, thus we use a
232
4
      // wrapper for the overload set.
233
4
      CallOverloadedCreateFun<ToDeclT> OC;
234
4
      return GetImportedOrCreateSpecialDecl(ToD, OC, FromD,
235
4
                                            std::forward<Args>(args)...);
236
4
    }
bool clang::ASTNodeImporter::GetImportedOrCreateDecl<clang::ObjCCategoryDecl, clang::ObjCCategoryDecl, clang::ASTContext&, clang::DeclContext*&, clang::SourceLocation&, clang::SourceLocation&, clang::SourceLocation&, clang::IdentifierInfo*, clang::ObjCInterfaceDecl*&, std::nullptr_t, clang::SourceLocation&, clang::SourceLocation&>(clang::ObjCCategoryDecl*&, clang::ObjCCategoryDecl*, clang::ASTContext&&&, clang::DeclContext*&&&, clang::SourceLocation&&&, clang::SourceLocation&&&, clang::SourceLocation&&&, clang::IdentifierInfo*&&, clang::ObjCInterfaceDecl*&&&, std::nullptr_t&&, clang::SourceLocation&&&, clang::SourceLocation&&&)
Line
Count
Source
229
8
                                                Args &&... args) {
230
8
      // There may be several overloads of ToDeclT::Create. We must make sure
231
8
      // to call the one which would be chosen by the arguments, thus we use a
232
8
      // wrapper for the overload set.
233
8
      CallOverloadedCreateFun<ToDeclT> OC;
234
8
      return GetImportedOrCreateSpecialDecl(ToD, OC, FromD,
235
8
                                            std::forward<Args>(args)...);
236
8
    }
bool clang::ASTNodeImporter::GetImportedOrCreateDecl<clang::ObjCProtocolDecl, clang::ObjCProtocolDecl, clang::ASTContext&, clang::DeclContext*&, clang::IdentifierInfo*, clang::SourceLocation&, clang::SourceLocation&, std::nullptr_t>(clang::ObjCProtocolDecl*&, clang::ObjCProtocolDecl*, clang::ASTContext&&&, clang::DeclContext*&&&, clang::IdentifierInfo*&&, clang::SourceLocation&&&, clang::SourceLocation&&&, std::nullptr_t&&)
Line
Count
Source
229
8
                                                Args &&... args) {
230
8
      // There may be several overloads of ToDeclT::Create. We must make sure
231
8
      // to call the one which would be chosen by the arguments, thus we use a
232
8
      // wrapper for the overload set.
233
8
      CallOverloadedCreateFun<ToDeclT> OC;
234
8
      return GetImportedOrCreateSpecialDecl(ToD, OC, FromD,
235
8
                                            std::forward<Args>(args)...);
236
8
    }
bool clang::ASTNodeImporter::GetImportedOrCreateDecl<clang::LinkageSpecDecl, clang::LinkageSpecDecl, clang::ASTContext&, clang::DeclContext*&, clang::SourceLocation&, clang::SourceLocation&, clang::LinkageSpecDecl::LanguageIDs, bool&>(clang::LinkageSpecDecl*&, clang::LinkageSpecDecl*, clang::ASTContext&&&, clang::DeclContext*&&&, clang::SourceLocation&&&, clang::SourceLocation&&&, clang::LinkageSpecDecl::LanguageIDs&&, bool&&&)
Line
Count
Source
229
2
                                                Args &&... args) {
230
2
      // There may be several overloads of ToDeclT::Create. We must make sure
231
2
      // to call the one which would be chosen by the arguments, thus we use a
232
2
      // wrapper for the overload set.
233
2
      CallOverloadedCreateFun<ToDeclT> OC;
234
2
      return GetImportedOrCreateSpecialDecl(ToD, OC, FromD,
235
2
                                            std::forward<Args>(args)...);
236
2
    }
bool clang::ASTNodeImporter::GetImportedOrCreateDecl<clang::UsingDecl, clang::UsingDecl, clang::ASTContext&, clang::DeclContext*&, clang::SourceLocation&, clang::NestedNameSpecifierLoc&, clang::DeclarationNameInfo&, bool>(clang::UsingDecl*&, clang::UsingDecl*, clang::ASTContext&&&, clang::DeclContext*&&&, clang::SourceLocation&&&, clang::NestedNameSpecifierLoc&&&, clang::DeclarationNameInfo&&&, bool&&)
Line
Count
Source
229
11
                                                Args &&... args) {
230
11
      // There may be several overloads of ToDeclT::Create. We must make sure
231
11
      // to call the one which would be chosen by the arguments, thus we use a
232
11
      // wrapper for the overload set.
233
11
      CallOverloadedCreateFun<ToDeclT> OC;
234
11
      return GetImportedOrCreateSpecialDecl(ToD, OC, FromD,
235
11
                                            std::forward<Args>(args)...);
236
11
    }
bool clang::ASTNodeImporter::GetImportedOrCreateDecl<clang::UsingShadowDecl, clang::UsingShadowDecl, clang::ASTContext&, clang::DeclContext*&, clang::SourceLocation&, clang::UsingDecl*&, clang::NamedDecl*&>(clang::UsingShadowDecl*&, clang::UsingShadowDecl*, clang::ASTContext&&&, clang::DeclContext*&&&, clang::SourceLocation&&&, clang::UsingDecl*&&&, clang::NamedDecl*&&&)
Line
Count
Source
229
15
                                                Args &&... args) {
230
15
      // There may be several overloads of ToDeclT::Create. We must make sure
231
15
      // to call the one which would be chosen by the arguments, thus we use a
232
15
      // wrapper for the overload set.
233
15
      CallOverloadedCreateFun<ToDeclT> OC;
234
15
      return GetImportedOrCreateSpecialDecl(ToD, OC, FromD,
235
15
                                            std::forward<Args>(args)...);
236
15
    }
bool clang::ASTNodeImporter::GetImportedOrCreateDecl<clang::UsingDirectiveDecl, clang::UsingDirectiveDecl, clang::ASTContext&, clang::DeclContext*&, clang::SourceLocation&, clang::SourceLocation&, clang::NestedNameSpecifierLoc&, clang::SourceLocation&, clang::NamespaceDecl*&, clang::DeclContext*&>(clang::UsingDirectiveDecl*&, clang::UsingDirectiveDecl*, clang::ASTContext&&&, clang::DeclContext*&&&, clang::SourceLocation&&&, clang::SourceLocation&&&, clang::NestedNameSpecifierLoc&&&, clang::SourceLocation&&&, clang::NamespaceDecl*&&&, clang::DeclContext*&&&)
Line
Count
Source
229
17
                                                Args &&... args) {
230
17
      // There may be several overloads of ToDeclT::Create. We must make sure
231
17
      // to call the one which would be chosen by the arguments, thus we use a
232
17
      // wrapper for the overload set.
233
17
      CallOverloadedCreateFun<ToDeclT> OC;
234
17
      return GetImportedOrCreateSpecialDecl(ToD, OC, FromD,
235
17
                                            std::forward<Args>(args)...);
236
17
    }
bool clang::ASTNodeImporter::GetImportedOrCreateDecl<clang::UnresolvedUsingValueDecl, clang::UnresolvedUsingValueDecl, clang::ASTContext&, clang::DeclContext*&, clang::SourceLocation&, clang::NestedNameSpecifierLoc&, clang::DeclarationNameInfo&, clang::SourceLocation&>(clang::UnresolvedUsingValueDecl*&, clang::UnresolvedUsingValueDecl*, clang::ASTContext&&&, clang::DeclContext*&&&, clang::SourceLocation&&&, clang::NestedNameSpecifierLoc&&&, clang::DeclarationNameInfo&&&, clang::SourceLocation&&&)
Line
Count
Source
229
1
                                                Args &&... args) {
230
1
      // There may be several overloads of ToDeclT::Create. We must make sure
231
1
      // to call the one which would be chosen by the arguments, thus we use a
232
1
      // wrapper for the overload set.
233
1
      CallOverloadedCreateFun<ToDeclT> OC;
234
1
      return GetImportedOrCreateSpecialDecl(ToD, OC, FromD,
235
1
                                            std::forward<Args>(args)...);
236
1
    }
bool clang::ASTNodeImporter::GetImportedOrCreateDecl<clang::UnresolvedUsingTypenameDecl, clang::UnresolvedUsingTypenameDecl, clang::ASTContext&, clang::DeclContext*&, clang::SourceLocation&, clang::SourceLocation&, clang::NestedNameSpecifierLoc&, clang::SourceLocation&, clang::DeclarationName&, clang::SourceLocation&>(clang::UnresolvedUsingTypenameDecl*&, clang::UnresolvedUsingTypenameDecl*, clang::ASTContext&&&, clang::DeclContext*&&&, clang::SourceLocation&&&, clang::SourceLocation&&&, clang::NestedNameSpecifierLoc&&&, clang::SourceLocation&&&, clang::DeclarationName&&&, clang::SourceLocation&&&)
Line
Count
Source
229
1
                                                Args &&... args) {
230
1
      // There may be several overloads of ToDeclT::Create. We must make sure
231
1
      // to call the one which would be chosen by the arguments, thus we use a
232
1
      // wrapper for the overload set.
233
1
      CallOverloadedCreateFun<ToDeclT> OC;
234
1
      return GetImportedOrCreateSpecialDecl(ToD, OC, FromD,
235
1
                                            std::forward<Args>(args)...);
236
1
    }
bool clang::ASTNodeImporter::GetImportedOrCreateDecl<clang::ObjCInterfaceDecl, clang::ObjCInterfaceDecl, clang::ASTContext&, clang::DeclContext*&, clang::SourceLocation&, clang::IdentifierInfo*, std::nullptr_t, std::nullptr_t, clang::SourceLocation&, bool>(clang::ObjCInterfaceDecl*&, clang::ObjCInterfaceDecl*, clang::ASTContext&&&, clang::DeclContext*&&&, clang::SourceLocation&&&, clang::IdentifierInfo*&&, std::nullptr_t&&, std::nullptr_t&&, clang::SourceLocation&&&, bool&&)
Line
Count
Source
229
49
                                                Args &&... args) {
230
49
      // There may be several overloads of ToDeclT::Create. We must make sure
231
49
      // to call the one which would be chosen by the arguments, thus we use a
232
49
      // wrapper for the overload set.
233
49
      CallOverloadedCreateFun<ToDeclT> OC;
234
49
      return GetImportedOrCreateSpecialDecl(ToD, OC, FromD,
235
49
                                            std::forward<Args>(args)...);
236
49
    }
bool clang::ASTNodeImporter::GetImportedOrCreateDecl<clang::ObjCCategoryImplDecl, clang::ObjCCategoryImplDecl, clang::ASTContext&, clang::DeclContext*&, clang::IdentifierInfo*, clang::ObjCInterfaceDecl*, clang::SourceLocation&, clang::SourceLocation&, clang::SourceLocation&>(clang::ObjCCategoryImplDecl*&, clang::ObjCCategoryImplDecl*, clang::ASTContext&&&, clang::DeclContext*&&&, clang::IdentifierInfo*&&, clang::ObjCInterfaceDecl*&&, clang::SourceLocation&&&, clang::SourceLocation&&&, clang::SourceLocation&&&)
Line
Count
Source
229
4
                                                Args &&... args) {
230
4
      // There may be several overloads of ToDeclT::Create. We must make sure
231
4
      // to call the one which would be chosen by the arguments, thus we use a
232
4
      // wrapper for the overload set.
233
4
      CallOverloadedCreateFun<ToDeclT> OC;
234
4
      return GetImportedOrCreateSpecialDecl(ToD, OC, FromD,
235
4
                                            std::forward<Args>(args)...);
236
4
    }
bool clang::ASTNodeImporter::GetImportedOrCreateDecl<clang::ObjCImplementationDecl, clang::ObjCImplementationDecl, clang::ASTContext&, clang::DeclContext*&, clang::ObjCInterfaceDecl*&, clang::ObjCInterfaceDecl*&, clang::SourceLocation&, clang::SourceLocation&, clang::SourceLocation&, clang::SourceLocation&, clang::SourceLocation&>(clang::ObjCImplementationDecl*&, clang::ObjCImplementationDecl*, clang::ASTContext&&&, clang::DeclContext*&&&, clang::ObjCInterfaceDecl*&&&, clang::ObjCInterfaceDecl*&&&, clang::SourceLocation&&&, clang::SourceLocation&&&, clang::SourceLocation&&&, clang::SourceLocation&&&, clang::SourceLocation&&&)
Line
Count
Source
229
6
                                                Args &&... args) {
230
6
      // There may be several overloads of ToDeclT::Create. We must make sure
231
6
      // to call the one which would be chosen by the arguments, thus we use a
232
6
      // wrapper for the overload set.
233
6
      CallOverloadedCreateFun<ToDeclT> OC;
234
6
      return GetImportedOrCreateSpecialDecl(ToD, OC, FromD,
235
6
                                            std::forward<Args>(args)...);
236
6
    }
bool clang::ASTNodeImporter::GetImportedOrCreateDecl<clang::ObjCPropertyDecl, clang::ObjCPropertyDecl, clang::ASTContext&, clang::DeclContext*&, clang::SourceLocation&, clang::IdentifierInfo*, clang::SourceLocation&, clang::SourceLocation&, clang::QualType&, clang::TypeSourceInfo*&, clang::ObjCPropertyDecl::PropertyControl>(clang::ObjCPropertyDecl*&, clang::ObjCPropertyDecl*, clang::ASTContext&&&, clang::DeclContext*&&&, clang::SourceLocation&&&, clang::IdentifierInfo*&&, clang::SourceLocation&&&, clang::SourceLocation&&&, clang::QualType&&&, clang::TypeSourceInfo*&&&, clang::ObjCPropertyDecl::PropertyControl&&)
Line
Count
Source
229
7
                                                Args &&... args) {
230
7
      // There may be several overloads of ToDeclT::Create. We must make sure
231
7
      // to call the one which would be chosen by the arguments, thus we use a
232
7
      // wrapper for the overload set.
233
7
      CallOverloadedCreateFun<ToDeclT> OC;
234
7
      return GetImportedOrCreateSpecialDecl(ToD, OC, FromD,
235
7
                                            std::forward<Args>(args)...);
236
7
    }
bool clang::ASTNodeImporter::GetImportedOrCreateDecl<clang::ObjCPropertyImplDecl, clang::ObjCPropertyImplDecl, clang::ASTContext&, clang::DeclContext*&, clang::SourceLocation&, clang::SourceLocation&, clang::ObjCPropertyDecl*&, clang::ObjCPropertyImplDecl::Kind, clang::ObjCIvarDecl*&, clang::SourceLocation&>(clang::ObjCPropertyImplDecl*&, clang::ObjCPropertyImplDecl*, clang::ASTContext&&&, clang::DeclContext*&&&, clang::SourceLocation&&&, clang::SourceLocation&&&, clang::ObjCPropertyDecl*&&&, clang::ObjCPropertyImplDecl::Kind&&, clang::ObjCIvarDecl*&&&, clang::SourceLocation&&&)
Line
Count
Source
229
4
                                                Args &&... args) {
230
4
      // There may be several overloads of ToDeclT::Create. We must make sure
231
4
      // to call the one which would be chosen by the arguments, thus we use a
232
4
      // wrapper for the overload set.
233
4
      CallOverloadedCreateFun<ToDeclT> OC;
234
4
      return GetImportedOrCreateSpecialDecl(ToD, OC, FromD,
235
4
                                            std::forward<Args>(args)...);
236
4
    }
bool clang::ASTNodeImporter::GetImportedOrCreateDecl<clang::TemplateTypeParmDecl, clang::TemplateTypeParmDecl, clang::ASTContext&, clang::TranslationUnitDecl*, clang::SourceLocation&, clang::SourceLocation&, unsigned int, unsigned int, clang::IdentifierInfo*, bool, bool>(clang::TemplateTypeParmDecl*&, clang::TemplateTypeParmDecl*, clang::ASTContext&&&, clang::TranslationUnitDecl*&&, clang::SourceLocation&&&, clang::SourceLocation&&&, unsigned int&&, unsigned int&&, clang::IdentifierInfo*&&, bool&&, bool&&)
Line
Count
Source
229
653
                                                Args &&... args) {
230
653
      // There may be several overloads of ToDeclT::Create. We must make sure
231
653
      // to call the one which would be chosen by the arguments, thus we use a
232
653
      // wrapper for the overload set.
233
653
      CallOverloadedCreateFun<ToDeclT> OC;
234
653
      return GetImportedOrCreateSpecialDecl(ToD, OC, FromD,
235
653
                                            std::forward<Args>(args)...);
236
653
    }
bool clang::ASTNodeImporter::GetImportedOrCreateDecl<clang::NonTypeTemplateParmDecl, clang::NonTypeTemplateParmDecl, clang::ASTContext&, clang::TranslationUnitDecl*, clang::SourceLocation&, clang::SourceLocation&, unsigned int, unsigned int, clang::IdentifierInfo*, clang::QualType&, bool, clang::TypeSourceInfo*&>(clang::NonTypeTemplateParmDecl*&, clang::NonTypeTemplateParmDecl*, clang::ASTContext&&&, clang::TranslationUnitDecl*&&, clang::SourceLocation&&&, clang::SourceLocation&&&, unsigned int&&, unsigned int&&, clang::IdentifierInfo*&&, clang::QualType&&&, bool&&, clang::TypeSourceInfo*&&&)
Line
Count
Source
229
51
                                                Args &&... args) {
230
51
      // There may be several overloads of ToDeclT::Create. We must make sure
231
51
      // to call the one which would be chosen by the arguments, thus we use a
232
51
      // wrapper for the overload set.
233
51
      CallOverloadedCreateFun<ToDeclT> OC;
234
51
      return GetImportedOrCreateSpecialDecl(ToD, OC, FromD,
235
51
                                            std::forward<Args>(args)...);
236
51
    }
bool clang::ASTNodeImporter::GetImportedOrCreateDecl<clang::TemplateTemplateParmDecl, clang::TemplateTemplateParmDecl, clang::ASTContext&, clang::TranslationUnitDecl*, clang::SourceLocation&, unsigned int, unsigned int, bool, clang::IdentifierInfo*, clang::TemplateParameterList*&>(clang::TemplateTemplateParmDecl*&, clang::TemplateTemplateParmDecl*, clang::ASTContext&&&, clang::TranslationUnitDecl*&&, clang::SourceLocation&&&, unsigned int&&, unsigned int&&, bool&&, clang::IdentifierInfo*&&, clang::TemplateParameterList*&&&)
Line
Count
Source
229
5
                                                Args &&... args) {
230
5
      // There may be several overloads of ToDeclT::Create. We must make sure
231
5
      // to call the one which would be chosen by the arguments, thus we use a
232
5
      // wrapper for the overload set.
233
5
      CallOverloadedCreateFun<ToDeclT> OC;
234
5
      return GetImportedOrCreateSpecialDecl(ToD, OC, FromD,
235
5
                                            std::forward<Args>(args)...);
236
5
    }
bool clang::ASTNodeImporter::GetImportedOrCreateDecl<clang::ClassTemplateDecl, clang::ClassTemplateDecl, clang::ASTContext&, clang::DeclContext*&, clang::SourceLocation&, clang::DeclarationName&, clang::TemplateParameterList*&, clang::CXXRecordDecl*&>(clang::ClassTemplateDecl*&, clang::ClassTemplateDecl*, clang::ASTContext&&&, clang::DeclContext*&&&, clang::SourceLocation&&&, clang::DeclarationName&&&, clang::TemplateParameterList*&&&, clang::CXXRecordDecl*&&&)
Line
Count
Source
229
686
                                                Args &&... args) {
230
686
      // There may be several overloads of ToDeclT::Create. We must make sure
231
686
      // to call the one which would be chosen by the arguments, thus we use a
232
686
      // wrapper for the overload set.
233
686
      CallOverloadedCreateFun<ToDeclT> OC;
234
686
      return GetImportedOrCreateSpecialDecl(ToD, OC, FromD,
235
686
                                            std::forward<Args>(args)...);
236
686
    }
bool clang::ASTNodeImporter::GetImportedOrCreateDecl<clang::ClassTemplateSpecializationDecl, clang::ClassTemplateSpecializationDecl, clang::ASTContext&, clang::TagTypeKind, clang::DeclContext*&, clang::SourceLocation&, clang::SourceLocation&, clang::ClassTemplateDecl*&, llvm::SmallVector<clang::TemplateArgument, 2u>&, clang::ClassTemplateSpecializationDecl*&>(clang::ClassTemplateSpecializationDecl*&, clang::ClassTemplateSpecializationDecl*, clang::ASTContext&&&, clang::TagTypeKind&&, clang::DeclContext*&&&, clang::SourceLocation&&&, clang::SourceLocation&&&, clang::ClassTemplateDecl*&&&, llvm::SmallVector<clang::TemplateArgument, 2u>&&&, clang::ClassTemplateSpecializationDecl*&&&)
Line
Count
Source
229
143
                                                Args &&... args) {
230
143
      // There may be several overloads of ToDeclT::Create. We must make sure
231
143
      // to call the one which would be chosen by the arguments, thus we use a
232
143
      // wrapper for the overload set.
233
143
      CallOverloadedCreateFun<ToDeclT> OC;
234
143
      return GetImportedOrCreateSpecialDecl(ToD, OC, FromD,
235
143
                                            std::forward<Args>(args)...);
236
143
    }
bool clang::ASTNodeImporter::GetImportedOrCreateDecl<clang::VarTemplateDecl, clang::VarTemplateDecl, clang::ASTContext&, clang::DeclContext*&, clang::SourceLocation&, clang::DeclarationName&, clang::TemplateParameterList*&, clang::VarDecl*&>(clang::VarTemplateDecl*&, clang::VarTemplateDecl*, clang::ASTContext&&&, clang::DeclContext*&&&, clang::SourceLocation&&&, clang::DeclarationName&&&, clang::TemplateParameterList*&&&, clang::VarDecl*&&&)
Line
Count
Source
229
7
                                                Args &&... args) {
230
7
      // There may be several overloads of ToDeclT::Create. We must make sure
231
7
      // to call the one which would be chosen by the arguments, thus we use a
232
7
      // wrapper for the overload set.
233
7
      CallOverloadedCreateFun<ToDeclT> OC;
234
7
      return GetImportedOrCreateSpecialDecl(ToD, OC, FromD,
235
7
                                            std::forward<Args>(args)...);
236
7
    }
bool clang::ASTNodeImporter::GetImportedOrCreateDecl<clang::VarTemplatePartialSpecializationDecl, clang::VarTemplateSpecializationDecl, clang::ASTContext&, clang::DeclContext*&, clang::SourceLocation&, clang::SourceLocation&, clang::TemplateParameterList*&, clang::VarTemplateDecl*&, clang::QualType&, clang::TypeSourceInfo*&, clang::StorageClass, llvm::SmallVector<clang::TemplateArgument, 2u>&, clang::TemplateArgumentListInfo&>(clang::VarTemplatePartialSpecializationDecl*&, clang::VarTemplateSpecializationDecl*, clang::ASTContext&&&, clang::DeclContext*&&&, clang::SourceLocation&&&, clang::SourceLocation&&&, clang::TemplateParameterList*&&&, clang::VarTemplateDecl*&&&, clang::QualType&&&, clang::TypeSourceInfo*&&&, clang::StorageClass&&, llvm::SmallVector<clang::TemplateArgument, 2u>&&&, clang::TemplateArgumentListInfo&&&)
Line
Count
Source
229
2
                                                Args &&... args) {
230
2
      // There may be several overloads of ToDeclT::Create. We must make sure
231
2
      // to call the one which would be chosen by the arguments, thus we use a
232
2
      // wrapper for the overload set.
233
2
      CallOverloadedCreateFun<ToDeclT> OC;
234
2
      return GetImportedOrCreateSpecialDecl(ToD, OC, FromD,
235
2
                                            std::forward<Args>(args)...);
236
2
    }
bool clang::ASTNodeImporter::GetImportedOrCreateDecl<clang::VarTemplateSpecializationDecl, clang::VarTemplateSpecializationDecl, clang::ASTContext&, clang::DeclContext*&, clang::SourceLocation&, clang::SourceLocation&, clang::VarTemplateDecl*&, clang::QualType&, clang::TypeSourceInfo*&, clang::StorageClass, llvm::SmallVector<clang::TemplateArgument, 2u>&>(clang::VarTemplateSpecializationDecl*&, clang::VarTemplateSpecializationDecl*, clang::ASTContext&&&, clang::DeclContext*&&&, clang::SourceLocation&&&, clang::SourceLocation&&&, clang::VarTemplateDecl*&&&, clang::QualType&&&, clang::TypeSourceInfo*&&&, clang::StorageClass&&, llvm::SmallVector<clang::TemplateArgument, 2u>&&&)
Line
Count
Source
229
6
                                                Args &&... args) {
230
6
      // There may be several overloads of ToDeclT::Create. We must make sure
231
6
      // to call the one which would be chosen by the arguments, thus we use a
232
6
      // wrapper for the overload set.
233
6
      CallOverloadedCreateFun<ToDeclT> OC;
234
6
      return GetImportedOrCreateSpecialDecl(ToD, OC, FromD,
235
6
                                            std::forward<Args>(args)...);
236
6
    }
bool clang::ASTNodeImporter::GetImportedOrCreateDecl<clang::FunctionTemplateDecl, clang::FunctionTemplateDecl, clang::ASTContext&, clang::DeclContext*&, clang::SourceLocation&, clang::DeclarationName&, clang::TemplateParameterList*&, clang::FunctionDecl*&>(clang::FunctionTemplateDecl*&, clang::FunctionTemplateDecl*, clang::ASTContext&&&, clang::DeclContext*&&&, clang::SourceLocation&&&, clang::DeclarationName&&&, clang::TemplateParameterList*&&&, clang::FunctionDecl*&&&)
Line
Count
Source
229
516
                                                Args &&... args) {
230
516
      // There may be several overloads of ToDeclT::Create. We must make sure
231
516
      // to call the one which would be chosen by the arguments, thus we use a
232
516
      // wrapper for the overload set.
233
516
      CallOverloadedCreateFun<ToDeclT> OC;
234
516
      return GetImportedOrCreateSpecialDecl(ToD, OC, FromD,
235
516
                                            std::forward<Args>(args)...);
236
516
    }
237
    // Use this overload if a special Type is needed to be created.  E.g if we
238
    // want to create a `TypeAliasDecl` and assign that to a `TypedefNameDecl`
239
    // then:
240
    // TypedefNameDecl *ToTypedef;
241
    // GetImportedOrCreateDecl<TypeAliasDecl>(ToTypedef, FromD, ...);
242
    template <typename NewDeclT, typename ToDeclT, typename FromDeclT,
243
              typename... Args>
244
    LLVM_NODISCARD bool GetImportedOrCreateDecl(ToDeclT *&ToD, FromDeclT *FromD,
245
1.36k
                                                Args &&... args) {
246
1.36k
      CallOverloadedCreateFun<NewDeclT> OC;
247
1.36k
      return GetImportedOrCreateSpecialDecl(ToD, OC, FromD,
248
1.36k
                                            std::forward<Args>(args)...);
249
1.36k
    }
bool clang::ASTNodeImporter::GetImportedOrCreateDecl<clang::TypeAliasDecl, clang::TypedefNameDecl, clang::TypedefNameDecl, clang::ASTContext&, clang::DeclContext*&, clang::SourceLocation&, clang::SourceLocation&, clang::IdentifierInfo*, clang::TypeSourceInfo*&>(clang::TypedefNameDecl*&, clang::TypedefNameDecl*, clang::ASTContext&&&, clang::DeclContext*&&&, clang::SourceLocation&&&, clang::SourceLocation&&&, clang::IdentifierInfo*&&, clang::TypeSourceInfo*&&&)
Line
Count
Source
245
16
                                                Args &&... args) {
246
16
      CallOverloadedCreateFun<NewDeclT> OC;
247
16
      return GetImportedOrCreateSpecialDecl(ToD, OC, FromD,
248
16
                                            std::forward<Args>(args)...);
249
16
    }
bool clang::ASTNodeImporter::GetImportedOrCreateDecl<clang::TypedefDecl, clang::TypedefNameDecl, clang::TypedefNameDecl, clang::ASTContext&, clang::DeclContext*&, clang::SourceLocation&, clang::SourceLocation&, clang::IdentifierInfo*, clang::TypeSourceInfo*&>(clang::TypedefNameDecl*&, clang::TypedefNameDecl*, clang::ASTContext&&&, clang::DeclContext*&&&, clang::SourceLocation&&&, clang::SourceLocation&&&, clang::IdentifierInfo*&&, clang::TypeSourceInfo*&&&)
Line
Count
Source
245
502
                                                Args &&... args) {
246
502
      CallOverloadedCreateFun<NewDeclT> OC;
247
502
      return GetImportedOrCreateSpecialDecl(ToD, OC, FromD,
248
502
                                            std::forward<Args>(args)...);
249
502
    }
bool clang::ASTNodeImporter::GetImportedOrCreateDecl<clang::CXXConstructorDecl, clang::FunctionDecl, clang::FunctionDecl, clang::ASTContext&, clang::CXXRecordDecl*, clang::SourceLocation&, clang::DeclarationNameInfo&, clang::QualType&, clang::TypeSourceInfo*&, clang::ExplicitSpecifier, bool, bool, clang::ConstexprSpecKind>(clang::FunctionDecl*&, clang::FunctionDecl*, clang::ASTContext&&&, clang::CXXRecordDecl*&&, clang::SourceLocation&&&, clang::DeclarationNameInfo&&&, clang::QualType&&&, clang::TypeSourceInfo*&&&, clang::ExplicitSpecifier&&, bool&&, bool&&, clang::ConstexprSpecKind&&)
Line
Count
Source
245
314
                                                Args &&... args) {
246
314
      CallOverloadedCreateFun<NewDeclT> OC;
247
314
      return GetImportedOrCreateSpecialDecl(ToD, OC, FromD,
248
314
                                            std::forward<Args>(args)...);
249
314
    }
bool clang::ASTNodeImporter::GetImportedOrCreateDecl<clang::CXXDestructorDecl, clang::FunctionDecl, clang::FunctionDecl, clang::ASTContext&, clang::CXXRecordDecl*, clang::SourceLocation&, clang::DeclarationNameInfo&, clang::QualType&, clang::TypeSourceInfo*&, bool, bool>(clang::FunctionDecl*&, clang::FunctionDecl*, clang::ASTContext&&&, clang::CXXRecordDecl*&&, clang::SourceLocation&&&, clang::DeclarationNameInfo&&&, clang::QualType&&&, clang::TypeSourceInfo*&&&, bool&&, bool&&)
Line
Count
Source
245
135
                                                Args &&... args) {
246
135
      CallOverloadedCreateFun<NewDeclT> OC;
247
135
      return GetImportedOrCreateSpecialDecl(ToD, OC, FromD,
248
135
                                            std::forward<Args>(args)...);
249
135
    }
bool clang::ASTNodeImporter::GetImportedOrCreateDecl<clang::CXXConversionDecl, clang::FunctionDecl, clang::FunctionDecl, clang::ASTContext&, clang::CXXRecordDecl*, clang::SourceLocation&, clang::DeclarationNameInfo&, clang::QualType&, clang::TypeSourceInfo*&, bool, clang::ExplicitSpecifier, clang::ConstexprSpecKind, clang::SourceLocation>(clang::FunctionDecl*&, clang::FunctionDecl*, clang::ASTContext&&&, clang::CXXRecordDecl*&&, clang::SourceLocation&&&, clang::DeclarationNameInfo&&&, clang::QualType&&&, clang::TypeSourceInfo*&&&, bool&&, clang::ExplicitSpecifier&&, clang::ConstexprSpecKind&&, clang::SourceLocation&&)
Line
Count
Source
245
22
                                                Args &&... args) {
246
22
      CallOverloadedCreateFun<NewDeclT> OC;
247
22
      return GetImportedOrCreateSpecialDecl(ToD, OC, FromD,
248
22
                                            std::forward<Args>(args)...);
249
22
    }
bool clang::ASTNodeImporter::GetImportedOrCreateDecl<clang::CXXMethodDecl, clang::FunctionDecl, clang::FunctionDecl, clang::ASTContext&, clang::CXXRecordDecl*, clang::SourceLocation&, clang::DeclarationNameInfo&, clang::QualType&, clang::TypeSourceInfo*&, clang::StorageClass, bool, clang::ConstexprSpecKind, clang::SourceLocation>(clang::FunctionDecl*&, clang::FunctionDecl*, clang::ASTContext&&&, clang::CXXRecordDecl*&&, clang::SourceLocation&&&, clang::DeclarationNameInfo&&&, clang::QualType&&&, clang::TypeSourceInfo*&&&, clang::StorageClass&&, bool&&, clang::ConstexprSpecKind&&, clang::SourceLocation&&)
Line
Count
Source
245
359
                                                Args &&... args) {
246
359
      CallOverloadedCreateFun<NewDeclT> OC;
247
359
      return GetImportedOrCreateSpecialDecl(ToD, OC, FromD,
248
359
                                            std::forward<Args>(args)...);
249
359
    }
bool clang::ASTNodeImporter::GetImportedOrCreateDecl<clang::ClassTemplatePartialSpecializationDecl, clang::ClassTemplateSpecializationDecl, clang::ClassTemplateSpecializationDecl, clang::ASTContext&, clang::TagTypeKind, clang::DeclContext*&, clang::SourceLocation&, clang::SourceLocation&, clang::TemplateParameterList*&, clang::ClassTemplateDecl*&, llvm::ArrayRef<clang::TemplateArgument>, clang::TemplateArgumentListInfo&, clang::QualType&, clang::ClassTemplatePartialSpecializationDecl*>(clang::ClassTemplateSpecializationDecl*&, clang::ClassTemplateSpecializationDecl*, clang::ASTContext&&&, clang::TagTypeKind&&, clang::DeclContext*&&&, clang::SourceLocation&&&, clang::SourceLocation&&&, clang::TemplateParameterList*&&&, clang::ClassTemplateDecl*&&&, llvm::ArrayRef<clang::TemplateArgument>&&, clang::TemplateArgumentListInfo&&&, clang::QualType&&&, clang::ClassTemplatePartialSpecializationDecl*&&)
Line
Count
Source
245
16
                                                Args &&... args) {
246
16
      CallOverloadedCreateFun<NewDeclT> OC;
247
16
      return GetImportedOrCreateSpecialDecl(ToD, OC, FromD,
248
16
                                            std::forward<Args>(args)...);
249
16
    }
250
    // Use this version if a special create function must be
251
    // used, e.g. CXXRecordDecl::CreateLambda .
252
    template <typename ToDeclT, typename CreateFunT, typename FromDeclT,
253
              typename... Args>
254
    LLVM_NODISCARD bool
255
    GetImportedOrCreateSpecialDecl(ToDeclT *&ToD, CreateFunT CreateFun,
256
9.42k
                                   FromDeclT *FromD, Args &&... args) {
257
9.42k
      if (Importer.getImportDeclErrorIfAny(FromD)) {
258
4
        ToD = nullptr;
259
4
        return true; // Already imported but with error.
260
4
      }
261
9.42k
      ToD = cast_or_null<ToDeclT>(Importer.GetAlreadyImportedOrNull(FromD));
262
9.42k
      if (ToD)
263
784
        return true; // Already imported.
264
8.64k
      ToD = CreateFun(std::forward<Args>(args)...);
265
8.64k
      // Keep track of imported Decls.
266
8.64k
      Importer.RegisterImportedDecl(FromD, ToD);
267
8.64k
      InitializeImportedDecl(FromD, ToD);
268
8.64k
      return false; // A new Decl is created.
269
8.64k
    }
Unexecuted instantiation: bool clang::ASTNodeImporter::GetImportedOrCreateSpecialDecl<clang::EmptyDecl, clang::ASTNodeImporter::CallOverloadedCreateFun<clang::EmptyDecl>, clang::EmptyDecl, clang::ASTContext&, clang::DeclContext*&, clang::SourceLocation&>(clang::EmptyDecl*&, clang::ASTNodeImporter::CallOverloadedCreateFun<clang::EmptyDecl>, clang::EmptyDecl*, clang::ASTContext&&&, clang::DeclContext*&&&, clang::SourceLocation&&&)
bool clang::ASTNodeImporter::GetImportedOrCreateSpecialDecl<clang::AccessSpecDecl, clang::ASTNodeImporter::CallOverloadedCreateFun<clang::AccessSpecDecl>, clang::AccessSpecDecl, clang::ASTContext&, clang::AccessSpecifier, clang::DeclContext*&, clang::SourceLocation&, clang::SourceLocation&>(clang::AccessSpecDecl*&, clang::ASTNodeImporter::CallOverloadedCreateFun<clang::AccessSpecDecl>, clang::AccessSpecDecl*, clang::ASTContext&&&, clang::AccessSpecifier&&, clang::DeclContext*&&&, clang::SourceLocation&&&, clang::SourceLocation&&&)
Line
Count
Source
256
37
                                   FromDeclT *FromD, Args &&... args) {
257
37
      if (Importer.getImportDeclErrorIfAny(FromD)) {
258
0
        ToD = nullptr;
259
0
        return true; // Already imported but with error.
260
0
      }
261
37
      ToD = cast_or_null<ToDeclT>(Importer.GetAlreadyImportedOrNull(FromD));
262
37
      if (ToD)
263
0
        return true; // Already imported.
264
37
      ToD = CreateFun(std::forward<Args>(args)...);
265
37
      // Keep track of imported Decls.
266
37
      Importer.RegisterImportedDecl(FromD, ToD);
267
37
      InitializeImportedDecl(FromD, ToD);
268
37
      return false; // A new Decl is created.
269
37
    }
bool clang::ASTNodeImporter::GetImportedOrCreateSpecialDecl<clang::StaticAssertDecl, clang::ASTNodeImporter::CallOverloadedCreateFun<clang::StaticAssertDecl>, clang::StaticAssertDecl, clang::ASTContext&, clang::DeclContext*&, clang::SourceLocation&, clang::Expr*&, clang::StringLiteral*&, clang::SourceLocation&, bool>(clang::StaticAssertDecl*&, clang::ASTNodeImporter::CallOverloadedCreateFun<clang::StaticAssertDecl>, clang::StaticAssertDecl*, clang::ASTContext&&&, clang::DeclContext*&&&, clang::SourceLocation&&&, clang::Expr*&&&, clang::StringLiteral*&&&, clang::SourceLocation&&&, bool&&)
Line
Count
Source
256
12
                                   FromDeclT *FromD, Args &&... args) {
257
12
      if (Importer.getImportDeclErrorIfAny(FromD)) {
258
0
        ToD = nullptr;
259
0
        return true; // Already imported but with error.
260
0
      }
261
12
      ToD = cast_or_null<ToDeclT>(Importer.GetAlreadyImportedOrNull(FromD));
262
12
      if (ToD)
263
0
        return true; // Already imported.
264
12
      ToD = CreateFun(std::forward<Args>(args)...);
265
12
      // Keep track of imported Decls.
266
12
      Importer.RegisterImportedDecl(FromD, ToD);
267
12
      InitializeImportedDecl(FromD, ToD);
268
12
      return false; // A new Decl is created.
269
12
    }
bool clang::ASTNodeImporter::GetImportedOrCreateSpecialDecl<clang::NamespaceDecl, clang::ASTNodeImporter::CallOverloadedCreateFun<clang::NamespaceDecl>, clang::NamespaceDecl, clang::ASTContext&, clang::DeclContext*&, bool, clang::SourceLocation&, clang::SourceLocation&, clang::IdentifierInfo*, std::nullptr_t>(clang::NamespaceDecl*&, clang::ASTNodeImporter::CallOverloadedCreateFun<clang::NamespaceDecl>, clang::NamespaceDecl*, clang::ASTContext&&&, clang::DeclContext*&&&, bool&&, clang::SourceLocation&&&, clang::SourceLocation&&&, clang::IdentifierInfo*&&, std::nullptr_t&&)
Line
Count
Source
256
189
                                   FromDeclT *FromD, Args &&... args) {
257
189
      if (Importer.getImportDeclErrorIfAny(FromD)) {
258
0
        ToD = nullptr;
259
0
        return true; // Already imported but with error.
260
0
      }
261
189
      ToD = cast_or_null<ToDeclT>(Importer.GetAlreadyImportedOrNull(FromD));
262
189
      if (ToD)
263
0
        return true; // Already imported.
264
189
      ToD = CreateFun(std::forward<Args>(args)...);
265
189
      // Keep track of imported Decls.
266
189
      Importer.RegisterImportedDecl(FromD, ToD);
267
189
      InitializeImportedDecl(FromD, ToD);
268
189
      return false; // A new Decl is created.
269
189
    }
bool clang::ASTNodeImporter::GetImportedOrCreateSpecialDecl<clang::NamespaceAliasDecl, clang::ASTNodeImporter::CallOverloadedCreateFun<clang::NamespaceAliasDecl>, clang::NamespaceAliasDecl, clang::ASTContext&, clang::DeclContext*&, clang::SourceLocation&, clang::SourceLocation&, clang::IdentifierInfo*&, clang::NestedNameSpecifierLoc&, clang::SourceLocation&, clang::NamespaceDecl*&>(clang::NamespaceAliasDecl*&, clang::ASTNodeImporter::CallOverloadedCreateFun<clang::NamespaceAliasDecl>, clang::NamespaceAliasDecl*, clang::ASTContext&&&, clang::DeclContext*&&&, clang::SourceLocation&&&, clang::SourceLocation&&&, clang::IdentifierInfo*&&&, clang::NestedNameSpecifierLoc&&&, clang::SourceLocation&&&, clang::NamespaceDecl*&&&)
Line
Count
Source
256
3
                                   FromDeclT *FromD, Args &&... args) {
257
3
      if (Importer.getImportDeclErrorIfAny(FromD)) {
258
0
        ToD = nullptr;
259
0
        return true; // Already imported but with error.
260
0
      }
261
3
      ToD = cast_or_null<ToDeclT>(Importer.GetAlreadyImportedOrNull(FromD));
262
3
      if (ToD)
263
0
        return true; // Already imported.
264
3
      ToD = CreateFun(std::forward<Args>(args)...);
265
3
      // Keep track of imported Decls.
266
3
      Importer.RegisterImportedDecl(FromD, ToD);
267
3
      InitializeImportedDecl(FromD, ToD);
268
3
      return false; // A new Decl is created.
269
3
    }
bool clang::ASTNodeImporter::GetImportedOrCreateSpecialDecl<clang::TypedefNameDecl, clang::ASTNodeImporter::CallOverloadedCreateFun<clang::TypeAliasDecl>, clang::TypedefNameDecl, clang::ASTContext&, clang::DeclContext*&, clang::SourceLocation&, clang::SourceLocation&, clang::IdentifierInfo*, clang::TypeSourceInfo*&>(clang::TypedefNameDecl*&, clang::ASTNodeImporter::CallOverloadedCreateFun<clang::TypeAliasDecl>, clang::TypedefNameDecl*, clang::ASTContext&&&, clang::DeclContext*&&&, clang::SourceLocation&&&, clang::SourceLocation&&&, clang::IdentifierInfo*&&, clang::TypeSourceInfo*&&&)
Line
Count
Source
256
16
                                   FromDeclT *FromD, Args &&... args) {
257
16
      if (Importer.getImportDeclErrorIfAny(FromD)) {
258
0
        ToD = nullptr;
259
0
        return true; // Already imported but with error.
260
0
      }
261
16
      ToD = cast_or_null<ToDeclT>(Importer.GetAlreadyImportedOrNull(FromD));
262
16
      if (ToD)
263
0
        return true; // Already imported.
264
16
      ToD = CreateFun(std::forward<Args>(args)...);
265
16
      // Keep track of imported Decls.
266
16
      Importer.RegisterImportedDecl(FromD, ToD);
267
16
      InitializeImportedDecl(FromD, ToD);
268
16
      return false; // A new Decl is created.
269
16
    }
bool clang::ASTNodeImporter::GetImportedOrCreateSpecialDecl<clang::TypedefNameDecl, clang::ASTNodeImporter::CallOverloadedCreateFun<clang::TypedefDecl>, clang::TypedefNameDecl, clang::ASTContext&, clang::DeclContext*&, clang::SourceLocation&, clang::SourceLocation&, clang::IdentifierInfo*, clang::TypeSourceInfo*&>(clang::TypedefNameDecl*&, clang::ASTNodeImporter::CallOverloadedCreateFun<clang::TypedefDecl>, clang::TypedefNameDecl*, clang::ASTContext&&&, clang::DeclContext*&&&, clang::SourceLocation&&&, clang::SourceLocation&&&, clang::IdentifierInfo*&&, clang::TypeSourceInfo*&&&)
Line
Count
Source
256
502
                                   FromDeclT *FromD, Args &&... args) {
257
502
      if (Importer.getImportDeclErrorIfAny(FromD)) {
258
0
        ToD = nullptr;
259
0
        return true; // Already imported but with error.
260
0
      }
261
502
      ToD = cast_or_null<ToDeclT>(Importer.GetAlreadyImportedOrNull(FromD));
262
502
      if (ToD)
263
6
        return true; // Already imported.
264
496
      ToD = CreateFun(std::forward<Args>(args)...);
265
496
      // Keep track of imported Decls.
266
496
      Importer.RegisterImportedDecl(FromD, ToD);
267
496
      InitializeImportedDecl(FromD, ToD);
268
496
      return false; // A new Decl is created.
269
496
    }
bool clang::ASTNodeImporter::GetImportedOrCreateSpecialDecl<clang::TypeAliasTemplateDecl, clang::ASTNodeImporter::CallOverloadedCreateFun<clang::TypeAliasTemplateDecl>, clang::TypeAliasTemplateDecl, clang::ASTContext&, clang::DeclContext*&, clang::SourceLocation&, clang::DeclarationName&, clang::TemplateParameterList*&, clang::TypeAliasDecl*&>(clang::TypeAliasTemplateDecl*&, clang::ASTNodeImporter::CallOverloadedCreateFun<clang::TypeAliasTemplateDecl>, clang::TypeAliasTemplateDecl*, clang::ASTContext&&&, clang::DeclContext*&&&, clang::SourceLocation&&&, clang::DeclarationName&&&, clang::TemplateParameterList*&&&, clang::TypeAliasDecl*&&&)
Line
Count
Source
256
12
                                   FromDeclT *FromD, Args &&... args) {
257
12
      if (Importer.getImportDeclErrorIfAny(FromD)) {
258
0
        ToD = nullptr;
259
0
        return true; // Already imported but with error.
260
0
      }
261
12
      ToD = cast_or_null<ToDeclT>(Importer.GetAlreadyImportedOrNull(FromD));
262
12
      if (ToD)
263
0
        return true; // Already imported.
264
12
      ToD = CreateFun(std::forward<Args>(args)...);
265
12
      // Keep track of imported Decls.
266
12
      Importer.RegisterImportedDecl(FromD, ToD);
267
12
      InitializeImportedDecl(FromD, ToD);
268
12
      return false; // A new Decl is created.
269
12
    }
Unexecuted instantiation: bool clang::ASTNodeImporter::GetImportedOrCreateSpecialDecl<clang::LabelDecl, clang::ASTNodeImporter::CallOverloadedCreateFun<clang::LabelDecl>, clang::LabelDecl, clang::ASTContext&, clang::DeclContext*&, clang::SourceLocation&, clang::IdentifierInfo*, clang::SourceLocation&>(clang::LabelDecl*&, clang::ASTNodeImporter::CallOverloadedCreateFun<clang::LabelDecl>, clang::LabelDecl*, clang::ASTContext&&&, clang::DeclContext*&&&, clang::SourceLocation&&&, clang::IdentifierInfo*&&, clang::SourceLocation&&&)
bool clang::ASTNodeImporter::GetImportedOrCreateSpecialDecl<clang::LabelDecl, clang::ASTNodeImporter::CallOverloadedCreateFun<clang::LabelDecl>, clang::LabelDecl, clang::ASTContext&, clang::DeclContext*&, clang::SourceLocation&, clang::IdentifierInfo*>(clang::LabelDecl*&, clang::ASTNodeImporter::CallOverloadedCreateFun<clang::LabelDecl>, clang::LabelDecl*, clang::ASTContext&&&, clang::DeclContext*&&&, clang::SourceLocation&&&, clang::IdentifierInfo*&&)
Line
Count
Source
256
6
                                   FromDeclT *FromD, Args &&... args) {
257
6
      if (Importer.getImportDeclErrorIfAny(FromD)) {
258
0
        ToD = nullptr;
259
0
        return true; // Already imported but with error.
260
0
      }
261
6
      ToD = cast_or_null<ToDeclT>(Importer.GetAlreadyImportedOrNull(FromD));
262
6
      if (ToD)
263
0
        return true; // Already imported.
264
6
      ToD = CreateFun(std::forward<Args>(args)...);
265
6
      // Keep track of imported Decls.
266
6
      Importer.RegisterImportedDecl(FromD, ToD);
267
6
      InitializeImportedDecl(FromD, ToD);
268
6
      return false; // A new Decl is created.
269
6
    }
bool clang::ASTNodeImporter::GetImportedOrCreateSpecialDecl<clang::EnumDecl, clang::ASTNodeImporter::CallOverloadedCreateFun<clang::EnumDecl>, clang::EnumDecl, clang::ASTContext&, clang::DeclContext*&, clang::SourceLocation&, clang::SourceLocation&, clang::IdentifierInfo*, std::nullptr_t, bool, bool, bool>(clang::EnumDecl*&, clang::ASTNodeImporter::CallOverloadedCreateFun<clang::EnumDecl>, clang::EnumDecl*, clang::ASTContext&&&, clang::DeclContext*&&&, clang::SourceLocation&&&, clang::SourceLocation&&&, clang::IdentifierInfo*&&, std::nullptr_t&&, bool&&, bool&&, bool&&)
Line
Count
Source
256
70
                                   FromDeclT *FromD, Args &&... args) {
257
70
      if (Importer.getImportDeclErrorIfAny(FromD)) {
258
0
        ToD = nullptr;
259
0
        return true; // Already imported but with error.
260
0
      }
261
70
      ToD = cast_or_null<ToDeclT>(Importer.GetAlreadyImportedOrNull(FromD));
262
70
      if (ToD)
263
0
        return true; // Already imported.
264
70
      ToD = CreateFun(std::forward<Args>(args)...);
265
70
      // Keep track of imported Decls.
266
70
      Importer.RegisterImportedDecl(FromD, ToD);
267
70
      InitializeImportedDecl(FromD, ToD);
268
70
      return false; // A new Decl is created.
269
70
    }
bool clang::ASTNodeImporter::GetImportedOrCreateSpecialDecl<clang::CXXRecordDecl, clang::CXXRecordDecl* (*)(clang::ASTContext const&, clang::DeclContext*, clang::TypeSourceInfo*, clang::SourceLocation, bool, bool, clang::LambdaCaptureDefault), clang::RecordDecl, clang::ASTContext&, clang::DeclContext*&, clang::TypeSourceInfo*&, clang::SourceLocation&, bool, bool, clang::LambdaCaptureDefault>(clang::CXXRecordDecl*&, clang::CXXRecordDecl* (*)(clang::ASTContext const&, clang::DeclContext*, clang::TypeSourceInfo*, clang::SourceLocation, bool, bool, clang::LambdaCaptureDefault), clang::RecordDecl*, clang::ASTContext&&&, clang::DeclContext*&&&, clang::TypeSourceInfo*&&&, clang::SourceLocation&&&, bool&&, bool&&, clang::LambdaCaptureDefault&&)
Line
Count
Source
256
27
                                   FromDeclT *FromD, Args &&... args) {
257
27
      if (Importer.getImportDeclErrorIfAny(FromD)) {
258
0
        ToD = nullptr;
259
0
        return true; // Already imported but with error.
260
0
      }
261
27
      ToD = cast_or_null<ToDeclT>(Importer.GetAlreadyImportedOrNull(FromD));
262
27
      if (ToD)
263
0
        return true; // Already imported.
264
27
      ToD = CreateFun(std::forward<Args>(args)...);
265
27
      // Keep track of imported Decls.
266
27
      Importer.RegisterImportedDecl(FromD, ToD);
267
27
      InitializeImportedDecl(FromD, ToD);
268
27
      return false; // A new Decl is created.
269
27
    }
bool clang::ASTNodeImporter::GetImportedOrCreateSpecialDecl<clang::CXXRecordDecl, clang::ASTNodeImporter::CallOverloadedCreateFun<clang::CXXRecordDecl>, clang::RecordDecl, clang::ASTContext&, clang::TagTypeKind, clang::DeclContext*&, clang::SourceLocation&, clang::SourceLocation&, clang::IdentifierInfo*, clang::CXXRecordDecl*, bool const&>(clang::CXXRecordDecl*&, clang::ASTNodeImporter::CallOverloadedCreateFun<clang::CXXRecordDecl>, clang::RecordDecl*, clang::ASTContext&&&, clang::TagTypeKind&&, clang::DeclContext*&&&, clang::SourceLocation&&&, clang::SourceLocation&&&, clang::IdentifierInfo*&&, clang::CXXRecordDecl*&&, bool const&&&)
Line
Count
Source
256
705
                                   FromDeclT *FromD, Args &&... args) {
257
705
      if (Importer.getImportDeclErrorIfAny(FromD)) {
258
0
        ToD = nullptr;
259
0
        return true; // Already imported but with error.
260
0
      }
261
705
      ToD = cast_or_null<ToDeclT>(Importer.GetAlreadyImportedOrNull(FromD));
262
705
      if (ToD)
263
0
        return true; // Already imported.
264
705
      ToD = CreateFun(std::forward<Args>(args)...);
265
705
      // Keep track of imported Decls.
266
705
      Importer.RegisterImportedDecl(FromD, ToD);
267
705
      InitializeImportedDecl(FromD, ToD);
268
705
      return false; // A new Decl is created.
269
705
    }
bool clang::ASTNodeImporter::GetImportedOrCreateSpecialDecl<clang::CXXRecordDecl, clang::ASTNodeImporter::CallOverloadedCreateFun<clang::CXXRecordDecl>, clang::RecordDecl, clang::ASTContext&, clang::TagTypeKind, clang::DeclContext*&, clang::SourceLocation&, clang::SourceLocation&, clang::IdentifierInfo*, clang::CXXRecordDecl*>(clang::CXXRecordDecl*&, clang::ASTNodeImporter::CallOverloadedCreateFun<clang::CXXRecordDecl>, clang::RecordDecl*, clang::ASTContext&&&, clang::TagTypeKind&&, clang::DeclContext*&&&, clang::SourceLocation&&&, clang::SourceLocation&&&, clang::IdentifierInfo*&&, clang::CXXRecordDecl*&&)
Line
Count
Source
256
1.23k
                                   FromDeclT *FromD, Args &&... args) {
257
1.23k
      if (Importer.getImportDeclErrorIfAny(FromD)) {
258
4
        ToD = nullptr;
259
4
        return true; // Already imported but with error.
260
4
      }
261
1.23k
      ToD = cast_or_null<ToDeclT>(Importer.GetAlreadyImportedOrNull(FromD));
262
1.23k
      if (ToD)
263
182
        return true; // Already imported.
264
1.04k
      ToD = CreateFun(std::forward<Args>(args)...);
265
1.04k
      // Keep track of imported Decls.
266
1.04k
      Importer.RegisterImportedDecl(FromD, ToD);
267
1.04k
      InitializeImportedDecl(FromD, ToD);
268
1.04k
      return false; // A new Decl is created.
269
1.04k
    }
bool clang::ASTNodeImporter::GetImportedOrCreateSpecialDecl<clang::RecordDecl, clang::ASTNodeImporter::CallOverloadedCreateFun<clang::RecordDecl>, clang::RecordDecl, clang::ASTContext&, clang::TagTypeKind, clang::DeclContext*&, clang::SourceLocation&, clang::SourceLocation&, clang::IdentifierInfo*, clang::RecordDecl*&>(clang::RecordDecl*&, clang::ASTNodeImporter::CallOverloadedCreateFun<clang::RecordDecl>, clang::RecordDecl*, clang::ASTContext&&&, clang::TagTypeKind&&, clang::DeclContext*&&&, clang::SourceLocation&&&, clang::SourceLocation&&&, clang::IdentifierInfo*&&, clang::RecordDecl*&&&)
Line
Count
Source
256
167
                                   FromDeclT *FromD, Args &&... args) {
257
167
      if (Importer.getImportDeclErrorIfAny(FromD)) {
258
0
        ToD = nullptr;
259
0
        return true; // Already imported but with error.
260
0
      }
261
167
      ToD = cast_or_null<ToDeclT>(Importer.GetAlreadyImportedOrNull(FromD));
262
167
      if (ToD)
263
11
        return true; // Already imported.
264
156
      ToD = CreateFun(std::forward<Args>(args)...);
265
156
      // Keep track of imported Decls.
266
156
      Importer.RegisterImportedDecl(FromD, ToD);
267
156
      InitializeImportedDecl(FromD, ToD);
268
156
      return false; // A new Decl is created.
269
156
    }
bool clang::ASTNodeImporter::GetImportedOrCreateSpecialDecl<clang::EnumConstantDecl, clang::ASTNodeImporter::CallOverloadedCreateFun<clang::EnumConstantDecl>, clang::EnumConstantDecl, clang::ASTContext&, clang::EnumDecl*, clang::SourceLocation&, clang::IdentifierInfo*, clang::QualType&, clang::Expr*&, llvm::APSInt const&>(clang::EnumConstantDecl*&, clang::ASTNodeImporter::CallOverloadedCreateFun<clang::EnumConstantDecl>, clang::EnumConstantDecl*, clang::ASTContext&&&, clang::EnumDecl*&&, clang::SourceLocation&&&, clang::IdentifierInfo*&&, clang::QualType&&&, clang::Expr*&&&, llvm::APSInt const&&&)
Line
Count
Source
256
52
                                   FromDeclT *FromD, Args &&... args) {
257
52
      if (Importer.getImportDeclErrorIfAny(FromD)) {
258
0
        ToD = nullptr;
259
0
        return true; // Already imported but with error.
260
0
      }
261
52
      ToD = cast_or_null<ToDeclT>(Importer.GetAlreadyImportedOrNull(FromD));
262
52
      if (ToD)
263
0
        return true; // Already imported.
264
52
      ToD = CreateFun(std::forward<Args>(args)...);
265
52
      // Keep track of imported Decls.
266
52
      Importer.RegisterImportedDecl(FromD, ToD);
267
52
      InitializeImportedDecl(FromD, ToD);
268
52
      return false; // A new Decl is created.
269
52
    }
bool clang::ASTNodeImporter::GetImportedOrCreateSpecialDecl<clang::FunctionDecl, clang::ASTNodeImporter::CallOverloadedCreateFun<clang::CXXConstructorDecl>, clang::FunctionDecl, clang::ASTContext&, clang::CXXRecordDecl*, clang::SourceLocation&, clang::DeclarationNameInfo&, clang::QualType&, clang::TypeSourceInfo*&, clang::ExplicitSpecifier, bool, bool, clang::ConstexprSpecKind>(clang::FunctionDecl*&, clang::ASTNodeImporter::CallOverloadedCreateFun<clang::CXXConstructorDecl>, clang::FunctionDecl*, clang::ASTContext&&&, clang::CXXRecordDecl*&&, clang::SourceLocation&&&, clang::DeclarationNameInfo&&&, clang::QualType&&&, clang::TypeSourceInfo*&&&, clang::ExplicitSpecifier&&, bool&&, bool&&, clang::ConstexprSpecKind&&)
Line
Count
Source
256
314
                                   FromDeclT *FromD, Args &&... args) {
257
314
      if (Importer.getImportDeclErrorIfAny(FromD)) {
258
0
        ToD = nullptr;
259
0
        return true; // Already imported but with error.
260
0
      }
261
314
      ToD = cast_or_null<ToDeclT>(Importer.GetAlreadyImportedOrNull(FromD));
262
314
      if (ToD)
263
0
        return true; // Already imported.
264
314
      ToD = CreateFun(std::forward<Args>(args)...);
265
314
      // Keep track of imported Decls.
266
314
      Importer.RegisterImportedDecl(FromD, ToD);
267
314
      InitializeImportedDecl(FromD, ToD);
268
314
      return false; // A new Decl is created.
269
314
    }
bool clang::ASTNodeImporter::GetImportedOrCreateSpecialDecl<clang::FunctionDecl, clang::ASTNodeImporter::CallOverloadedCreateFun<clang::CXXDestructorDecl>, clang::FunctionDecl, clang::ASTContext&, clang::CXXRecordDecl*, clang::SourceLocation&, clang::DeclarationNameInfo&, clang::QualType&, clang::TypeSourceInfo*&, bool, bool>(clang::FunctionDecl*&, clang::ASTNodeImporter::CallOverloadedCreateFun<clang::CXXDestructorDecl>, clang::FunctionDecl*, clang::ASTContext&&&, clang::CXXRecordDecl*&&, clang::SourceLocation&&&, clang::DeclarationNameInfo&&&, clang::QualType&&&, clang::TypeSourceInfo*&&&, bool&&, bool&&)
Line
Count
Source
256
135
                                   FromDeclT *FromD, Args &&... args) {
257
135
      if (Importer.getImportDeclErrorIfAny(FromD)) {
258
0
        ToD = nullptr;
259
0
        return true; // Already imported but with error.
260
0
      }
261
135
      ToD = cast_or_null<ToDeclT>(Importer.GetAlreadyImportedOrNull(FromD));
262
135
      if (ToD)
263
0
        return true; // Already imported.
264
135
      ToD = CreateFun(std::forward<Args>(args)...);
265
135
      // Keep track of imported Decls.
266
135
      Importer.RegisterImportedDecl(FromD, ToD);
267
135
      InitializeImportedDecl(FromD, ToD);
268
135
      return false; // A new Decl is created.
269
135
    }
bool clang::ASTNodeImporter::GetImportedOrCreateSpecialDecl<clang::FunctionDecl, clang::ASTNodeImporter::CallOverloadedCreateFun<clang::CXXConversionDecl>, clang::FunctionDecl, clang::ASTContext&, clang::CXXRecordDecl*, clang::SourceLocation&, clang::DeclarationNameInfo&, clang::QualType&, clang::TypeSourceInfo*&, bool, clang::ExplicitSpecifier, clang::ConstexprSpecKind, clang::SourceLocation>(clang::FunctionDecl*&, clang::ASTNodeImporter::CallOverloadedCreateFun<clang::CXXConversionDecl>, clang::FunctionDecl*, clang::ASTContext&&&, clang::CXXRecordDecl*&&, clang::SourceLocation&&&, clang::DeclarationNameInfo&&&, clang::QualType&&&, clang::TypeSourceInfo*&&&, bool&&, clang::ExplicitSpecifier&&, clang::ConstexprSpecKind&&, clang::SourceLocation&&)
Line
Count
Source
256
22
                                   FromDeclT *FromD, Args &&... args) {
257
22
      if (Importer.getImportDeclErrorIfAny(FromD)) {
258
0
        ToD = nullptr;
259
0
        return true; // Already imported but with error.
260
0
      }
261
22
      ToD = cast_or_null<ToDeclT>(Importer.GetAlreadyImportedOrNull(FromD));
262
22
      if (ToD)
263
0
        return true; // Already imported.
264
22
      ToD = CreateFun(std::forward<Args>(args)...);
265
22
      // Keep track of imported Decls.
266
22
      Importer.RegisterImportedDecl(FromD, ToD);
267
22
      InitializeImportedDecl(FromD, ToD);
268
22
      return false; // A new Decl is created.
269
22
    }
bool clang::ASTNodeImporter::GetImportedOrCreateSpecialDecl<clang::FunctionDecl, clang::ASTNodeImporter::CallOverloadedCreateFun<clang::CXXMethodDecl>, clang::FunctionDecl, clang::ASTContext&, clang::CXXRecordDecl*, clang::SourceLocation&, clang::DeclarationNameInfo&, clang::QualType&, clang::TypeSourceInfo*&, clang::StorageClass, bool, clang::ConstexprSpecKind, clang::SourceLocation>(clang::FunctionDecl*&, clang::ASTNodeImporter::CallOverloadedCreateFun<clang::CXXMethodDecl>, clang::FunctionDecl*, clang::ASTContext&&&, clang::CXXRecordDecl*&&, clang::SourceLocation&&&, clang::DeclarationNameInfo&&&, clang::QualType&&&, clang::TypeSourceInfo*&&&, clang::StorageClass&&, bool&&, clang::ConstexprSpecKind&&, clang::SourceLocation&&)
Line
Count
Source
256
359
                                   FromDeclT *FromD, Args &&... args) {
257
359
      if (Importer.getImportDeclErrorIfAny(FromD)) {
258
0
        ToD = nullptr;
259
0
        return true; // Already imported but with error.
260
0
      }
261
359
      ToD = cast_or_null<ToDeclT>(Importer.GetAlreadyImportedOrNull(FromD));
262
359
      if (ToD)
263
0
        return true; // Already imported.
264
359
      ToD = CreateFun(std::forward<Args>(args)...);
265
359
      // Keep track of imported Decls.
266
359
      Importer.RegisterImportedDecl(FromD, ToD);
267
359
      InitializeImportedDecl(FromD, ToD);
268
359
      return false; // A new Decl is created.
269
359
    }
bool clang::ASTNodeImporter::GetImportedOrCreateSpecialDecl<clang::FunctionDecl, clang::ASTNodeImporter::CallOverloadedCreateFun<clang::FunctionDecl>, clang::FunctionDecl, clang::ASTContext&, clang::DeclContext*&, clang::SourceLocation&, clang::DeclarationNameInfo&, clang::QualType&, clang::TypeSourceInfo*&, clang::StorageClass, bool, bool, clang::ConstexprSpecKind>(clang::FunctionDecl*&, clang::ASTNodeImporter::CallOverloadedCreateFun<clang::FunctionDecl>, clang::FunctionDecl*, clang::ASTContext&&&, clang::DeclContext*&&&, clang::SourceLocation&&&, clang::DeclarationNameInfo&&&, clang::QualType&&&, clang::TypeSourceInfo*&&&, clang::StorageClass&&, bool&&, bool&&, clang::ConstexprSpecKind&&)
Line
Count
Source
256
1.26k
                                   FromDeclT *FromD, Args &&... args) {
257
1.26k
      if (Importer.getImportDeclErrorIfAny(FromD)) {
258
0
        ToD = nullptr;
259
0
        return true; // Already imported but with error.
260
0
      }
261
1.26k
      ToD = cast_or_null<ToDeclT>(Importer.GetAlreadyImportedOrNull(FromD));
262
1.26k
      if (ToD)
263
12
        return true; // Already imported.
264
1.24k
      ToD = CreateFun(std::forward<Args>(args)...);
265
1.24k
      // Keep track of imported Decls.
266
1.24k
      Importer.RegisterImportedDecl(FromD, ToD);
267
1.24k
      InitializeImportedDecl(FromD, ToD);
268
1.24k
      return false; // A new Decl is created.
269
1.24k
    }
bool clang::ASTNodeImporter::GetImportedOrCreateSpecialDecl<clang::FieldDecl, clang::ASTNodeImporter::CallOverloadedCreateFun<clang::FieldDecl>, clang::FieldDecl, clang::ASTContext&, clang::DeclContext*&, clang::SourceLocation&, clang::SourceLocation&, clang::IdentifierInfo*, clang::QualType&, clang::TypeSourceInfo*&, clang::Expr*&, bool, clang::InClassInitStyle>(clang::FieldDecl*&, clang::ASTNodeImporter::CallOverloadedCreateFun<clang::FieldDecl>, clang::FieldDecl*, clang::ASTContext&&&, clang::DeclContext*&&&, clang::SourceLocation&&&, clang::SourceLocation&&&, clang::IdentifierInfo*&&, clang::QualType&&&, clang::TypeSourceInfo*&&&, clang::Expr*&&&, bool&&, clang::InClassInitStyle&&)
Line
Count
Source
256
593
                                   FromDeclT *FromD, Args &&... args) {
257
593
      if (Importer.getImportDeclErrorIfAny(FromD)) {
258
0
        ToD = nullptr;
259
0
        return true; // Already imported but with error.
260
0
      }
261
593
      ToD = cast_or_null<ToDeclT>(Importer.GetAlreadyImportedOrNull(FromD));
262
593
      if (ToD)
263
0
        return true; // Already imported.
264
593
      ToD = CreateFun(std::forward<Args>(args)...);
265
593
      // Keep track of imported Decls.
266
593
      Importer.RegisterImportedDecl(FromD, ToD);
267
593
      InitializeImportedDecl(FromD, ToD);
268
593
      return false; // A new Decl is created.
269
593
    }
bool clang::ASTNodeImporter::GetImportedOrCreateSpecialDecl<clang::IndirectFieldDecl, clang::ASTNodeImporter::CallOverloadedCreateFun<clang::IndirectFieldDecl>, clang::IndirectFieldDecl, clang::ASTContext&, clang::DeclContext*&, clang::SourceLocation&, clang::IdentifierInfo*, clang::QualType&, llvm::MutableArrayRef<clang::NamedDecl*>&>(clang::IndirectFieldDecl*&, clang::ASTNodeImporter::CallOverloadedCreateFun<clang::IndirectFieldDecl>, clang::IndirectFieldDecl*, clang::ASTContext&&&, clang::DeclContext*&&&, clang::SourceLocation&&&, clang::IdentifierInfo*&&, clang::QualType&&&, llvm::MutableArrayRef<clang::NamedDecl*>&&&)
Line
Count
Source
256
27
                                   FromDeclT *FromD, Args &&... args) {
257
27
      if (Importer.getImportDeclErrorIfAny(FromD)) {
258
0
        ToD = nullptr;
259
0
        return true; // Already imported but with error.
260
0
      }
261
27
      ToD = cast_or_null<ToDeclT>(Importer.GetAlreadyImportedOrNull(FromD));
262
27
      if (ToD)
263
0
        return true; // Already imported.
264
27
      ToD = CreateFun(std::forward<Args>(args)...);
265
27
      // Keep track of imported Decls.
266
27
      Importer.RegisterImportedDecl(FromD, ToD);
267
27
      InitializeImportedDecl(FromD, ToD);
268
27
      return false; // A new Decl is created.
269
27
    }
bool clang::ASTNodeImporter::GetImportedOrCreateSpecialDecl<clang::FriendDecl, clang::ASTNodeImporter::CallOverloadedCreateFun<clang::FriendDecl>, clang::FriendDecl, clang::ASTContext&, clang::DeclContext*&, clang::SourceLocation&, llvm::PointerUnion<clang::NamedDecl*, clang::TypeSourceInfo*>&, clang::SourceLocation&, llvm::SmallVector<clang::TemplateParameterList*, 1u>&>(clang::FriendDecl*&, clang::ASTNodeImporter::CallOverloadedCreateFun<clang::FriendDecl>, clang::FriendDecl*, clang::ASTContext&&&, clang::DeclContext*&&&, clang::SourceLocation&&&, llvm::PointerUnion<clang::NamedDecl*, clang::TypeSourceInfo*>&&&, clang::SourceLocation&&&, llvm::SmallVector<clang::TemplateParameterList*, 1u>&&&)
Line
Count
Source
256
91
                                   FromDeclT *FromD, Args &&... args) {
257
91
      if (Importer.getImportDeclErrorIfAny(FromD)) {
258
0
        ToD = nullptr;
259
0
        return true; // Already imported but with error.
260
0
      }
261
91
      ToD = cast_or_null<ToDeclT>(Importer.GetAlreadyImportedOrNull(FromD));
262
91
      if (ToD)
263
0
        return true; // Already imported.
264
91
      ToD = CreateFun(std::forward<Args>(args)...);
265
91
      // Keep track of imported Decls.
266
91
      Importer.RegisterImportedDecl(FromD, ToD);
267
91
      InitializeImportedDecl(FromD, ToD);
268
91
      return false; // A new Decl is created.
269
91
    }
bool clang::ASTNodeImporter::GetImportedOrCreateSpecialDecl<clang::ObjCIvarDecl, clang::ASTNodeImporter::CallOverloadedCreateFun<clang::ObjCIvarDecl>, clang::ObjCIvarDecl, clang::ASTContext&, clang::ObjCContainerDecl*, clang::SourceLocation&, clang::SourceLocation&, clang::IdentifierInfo*, clang::QualType&, clang::TypeSourceInfo*&, clang::ObjCIvarDecl::AccessControl, clang::Expr*&, bool>(clang::ObjCIvarDecl*&, clang::ASTNodeImporter::CallOverloadedCreateFun<clang::ObjCIvarDecl>, clang::ObjCIvarDecl*, clang::ASTContext&&&, clang::ObjCContainerDecl*&&, clang::SourceLocation&&&, clang::SourceLocation&&&, clang::IdentifierInfo*&&, clang::QualType&&&, clang::TypeSourceInfo*&&&, clang::ObjCIvarDecl::AccessControl&&, clang::Expr*&&&, bool&&)
Line
Count
Source
256
10
                                   FromDeclT *FromD, Args &&... args) {
257
10
      if (Importer.getImportDeclErrorIfAny(FromD)) {
258
0
        ToD = nullptr;
259
0
        return true; // Already imported but with error.
260
0
      }
261
10
      ToD = cast_or_null<ToDeclT>(Importer.GetAlreadyImportedOrNull(FromD));
262
10
      if (ToD)
263
0
        return true; // Already imported.
264
10
      ToD = CreateFun(std::forward<Args>(args)...);
265
10
      // Keep track of imported Decls.
266
10
      Importer.RegisterImportedDecl(FromD, ToD);
267
10
      InitializeImportedDecl(FromD, ToD);
268
10
      return false; // A new Decl is created.
269
10
    }
bool clang::ASTNodeImporter::GetImportedOrCreateSpecialDecl<clang::VarDecl, clang::ASTNodeImporter::CallOverloadedCreateFun<clang::VarDecl>, clang::VarDecl, clang::ASTContext&, clang::DeclContext*&, clang::SourceLocation&, clang::SourceLocation&, clang::IdentifierInfo*, clang::QualType&, clang::TypeSourceInfo*&, clang::StorageClass>(clang::VarDecl*&, clang::ASTNodeImporter::CallOverloadedCreateFun<clang::VarDecl>, clang::VarDecl*, clang::ASTContext&&&, clang::DeclContext*&&&, clang::SourceLocation&&&, clang::SourceLocation&&&, clang::IdentifierInfo*&&, clang::QualType&&&, clang::TypeSourceInfo*&&&, clang::StorageClass&&)
Line
Count
Source
256
703
                                   FromDeclT *FromD, Args &&... args) {
257
703
      if (Importer.getImportDeclErrorIfAny(FromD)) {
258
0
        ToD = nullptr;
259
0
        return true; // Already imported but with error.
260
0
      }
261
703
      ToD = cast_or_null<ToDeclT>(Importer.GetAlreadyImportedOrNull(FromD));
262
703
      if (ToD)
263
0
        return true; // Already imported.
264
703
      ToD = CreateFun(std::forward<Args>(args)...);
265
703
      // Keep track of imported Decls.
266
703
      Importer.RegisterImportedDecl(FromD, ToD);
267
703
      InitializeImportedDecl(FromD, ToD);
268
703
      return false; // A new Decl is created.
269
703
    }
Unexecuted instantiation: bool clang::ASTNodeImporter::GetImportedOrCreateSpecialDecl<clang::ImplicitParamDecl, clang::ASTNodeImporter::CallOverloadedCreateFun<clang::ImplicitParamDecl>, clang::ImplicitParamDecl, clang::ASTContext&, clang::DeclContext*&, clang::SourceLocation&, clang::IdentifierInfo*, clang::QualType&, clang::ImplicitParamDecl::ImplicitParamKind>(clang::ImplicitParamDecl*&, clang::ASTNodeImporter::CallOverloadedCreateFun<clang::ImplicitParamDecl>, clang::ImplicitParamDecl*, clang::ASTContext&&&, clang::DeclContext*&&&, clang::SourceLocation&&&, clang::IdentifierInfo*&&, clang::QualType&&&, clang::ImplicitParamDecl::ImplicitParamKind&&)
bool clang::ASTNodeImporter::GetImportedOrCreateSpecialDecl<clang::ParmVarDecl, clang::ASTNodeImporter::CallOverloadedCreateFun<clang::ParmVarDecl>, clang::ParmVarDecl, clang::ASTContext&, clang::DeclContext*&, clang::SourceLocation&, clang::SourceLocation&, clang::IdentifierInfo*, clang::QualType&, clang::TypeSourceInfo*&, clang::StorageClass, std::nullptr_t>(clang::ParmVarDecl*&, clang::ASTNodeImporter::CallOverloadedCreateFun<clang::ParmVarDecl>, clang::ParmVarDecl*, clang::ASTContext&&&, clang::DeclContext*&&&, clang::SourceLocation&&&, clang::SourceLocation&&&, clang::IdentifierInfo*&&, clang::QualType&&&, clang::TypeSourceInfo*&&&, clang::StorageClass&&, std::nullptr_t&&)
Line
Count
Source
256
616
                                   FromDeclT *FromD, Args &&... args) {
257
616
      if (Importer.getImportDeclErrorIfAny(FromD)) {
258
0
        ToD = nullptr;
259
0
        return true; // Already imported but with error.
260
0
      }
261
616
      ToD = cast_or_null<ToDeclT>(Importer.GetAlreadyImportedOrNull(FromD));
262
616
      if (ToD)
263
0
        return true; // Already imported.
264
616
      ToD = CreateFun(std::forward<Args>(args)...);
265
616
      // Keep track of imported Decls.
266
616
      Importer.RegisterImportedDecl(FromD, ToD);
267
616
      InitializeImportedDecl(FromD, ToD);
268
616
      return false; // A new Decl is created.
269
616
    }
bool clang::ASTNodeImporter::GetImportedOrCreateSpecialDecl<clang::ObjCMethodDecl, clang::ASTNodeImporter::CallOverloadedCreateFun<clang::ObjCMethodDecl>, clang::ObjCMethodDecl, clang::ASTContext&, clang::SourceLocation&, clang::SourceLocation&, clang::Selector, clang::QualType&, clang::TypeSourceInfo*&, clang::DeclContext*&, bool, bool, bool, bool, bool, clang::ObjCMethodDecl::ImplementationControl, bool>(clang::ObjCMethodDecl*&, clang::ASTNodeImporter::CallOverloadedCreateFun<clang::ObjCMethodDecl>, clang::ObjCMethodDecl*, clang::ASTContext&&&, clang::SourceLocation&&&, clang::SourceLocation&&&, clang::Selector&&, clang::QualType&&&, clang::TypeSourceInfo*&&&, clang::DeclContext*&&&, bool&&, bool&&, bool&&, bool&&, bool&&, clang::ObjCMethodDecl::ImplementationControl&&, bool&&)
Line
Count
Source
256
43
                                   FromDeclT *FromD, Args &&... args) {
257
43
      if (Importer.getImportDeclErrorIfAny(FromD)) {
258
0
        ToD = nullptr;
259
0
        return true; // Already imported but with error.
260
0
      }
261
43
      ToD = cast_or_null<ToDeclT>(Importer.GetAlreadyImportedOrNull(FromD));
262
43
      if (ToD)
263
0
        return true; // Already imported.
264
43
      ToD = CreateFun(std::forward<Args>(args)...);
265
43
      // Keep track of imported Decls.
266
43
      Importer.RegisterImportedDecl(FromD, ToD);
267
43
      InitializeImportedDecl(FromD, ToD);
268
43
      return false; // A new Decl is created.
269
43
    }
bool clang::ASTNodeImporter::GetImportedOrCreateSpecialDecl<clang::ObjCTypeParamDecl, clang::ASTNodeImporter::CallOverloadedCreateFun<clang::ObjCTypeParamDecl>, clang::ObjCTypeParamDecl, clang::ASTContext&, clang::DeclContext*&, clang::ObjCTypeParamVariance, clang::SourceLocation&, unsigned int, clang::SourceLocation&, clang::IdentifierInfo*, clang::SourceLocation&, clang::TypeSourceInfo*&>(clang::ObjCTypeParamDecl*&, clang::ASTNodeImporter::CallOverloadedCreateFun<clang::ObjCTypeParamDecl>, clang::ObjCTypeParamDecl*, clang::ASTContext&&&, clang::DeclContext*&&&, clang::ObjCTypeParamVariance&&, clang::SourceLocation&&&, unsigned int&&, clang::SourceLocation&&&, clang::IdentifierInfo*&&, clang::SourceLocation&&&, clang::TypeSourceInfo*&&&)
Line
Count
Source
256
4
                                   FromDeclT *FromD, Args &&... args) {
257
4
      if (Importer.getImportDeclErrorIfAny(FromD)) {
258
0
        ToD = nullptr;
259
0
        return true; // Already imported but with error.
260
0
      }
261
4
      ToD = cast_or_null<ToDeclT>(Importer.GetAlreadyImportedOrNull(FromD));
262
4
      if (ToD)
263
0
        return true; // Already imported.
264
4
      ToD = CreateFun(std::forward<Args>(args)...);
265
4
      // Keep track of imported Decls.
266
4
      Importer.RegisterImportedDecl(FromD, ToD);
267
4
      InitializeImportedDecl(FromD, ToD);
268
4
      return false; // A new Decl is created.
269
4
    }
bool clang::ASTNodeImporter::GetImportedOrCreateSpecialDecl<clang::ObjCCategoryDecl, clang::ASTNodeImporter::CallOverloadedCreateFun<clang::ObjCCategoryDecl>, clang::ObjCCategoryDecl, clang::ASTContext&, clang::DeclContext*&, clang::SourceLocation&, clang::SourceLocation&, clang::SourceLocation&, clang::IdentifierInfo*, clang::ObjCInterfaceDecl*&, std::nullptr_t, clang::SourceLocation&, clang::SourceLocation&>(clang::ObjCCategoryDecl*&, clang::ASTNodeImporter::CallOverloadedCreateFun<clang::ObjCCategoryDecl>, clang::ObjCCategoryDecl*, clang::ASTContext&&&, clang::DeclContext*&&&, clang::SourceLocation&&&, clang::SourceLocation&&&, clang::SourceLocation&&&, clang::IdentifierInfo*&&, clang::ObjCInterfaceDecl*&&&, std::nullptr_t&&, clang::SourceLocation&&&, clang::SourceLocation&&&)
Line
Count
Source
256
8
                                   FromDeclT *FromD, Args &&... args) {
257
8
      if (Importer.getImportDeclErrorIfAny(FromD)) {
258
0
        ToD = nullptr;
259
0
        return true; // Already imported but with error.
260
0
      }
261
8
      ToD = cast_or_null<ToDeclT>(Importer.GetAlreadyImportedOrNull(FromD));
262
8
      if (ToD)
263
0
        return true; // Already imported.
264
8
      ToD = CreateFun(std::forward<Args>(args)...);
265
8
      // Keep track of imported Decls.
266
8
      Importer.RegisterImportedDecl(FromD, ToD);
267
8
      InitializeImportedDecl(FromD, ToD);
268
8
      return false; // A new Decl is created.
269
8
    }
bool clang::ASTNodeImporter::GetImportedOrCreateSpecialDecl<clang::ObjCProtocolDecl, clang::ASTNodeImporter::CallOverloadedCreateFun<clang::ObjCProtocolDecl>, clang::ObjCProtocolDecl, clang::ASTContext&, clang::DeclContext*&, clang::IdentifierInfo*, clang::SourceLocation&, clang::SourceLocation&, std::nullptr_t>(clang::ObjCProtocolDecl*&, clang::ASTNodeImporter::CallOverloadedCreateFun<clang::ObjCProtocolDecl>, clang::ObjCProtocolDecl*, clang::ASTContext&&&, clang::DeclContext*&&&, clang::IdentifierInfo*&&, clang::SourceLocation&&&, clang::SourceLocation&&&, std::nullptr_t&&)
Line
Count
Source
256
8
                                   FromDeclT *FromD, Args &&... args) {
257
8
      if (Importer.getImportDeclErrorIfAny(FromD)) {
258
0
        ToD = nullptr;
259
0
        return true; // Already imported but with error.
260
0
      }
261
8
      ToD = cast_or_null<ToDeclT>(Importer.GetAlreadyImportedOrNull(FromD));
262
8
      if (ToD)
263
0
        return true; // Already imported.
264
8
      ToD = CreateFun(std::forward<Args>(args)...);
265
8
      // Keep track of imported Decls.
266
8
      Importer.RegisterImportedDecl(FromD, ToD);
267
8
      InitializeImportedDecl(FromD, ToD);
268
8
      return false; // A new Decl is created.
269
8
    }
bool clang::ASTNodeImporter::GetImportedOrCreateSpecialDecl<clang::LinkageSpecDecl, clang::ASTNodeImporter::CallOverloadedCreateFun<clang::LinkageSpecDecl>, clang::LinkageSpecDecl, clang::ASTContext&, clang::DeclContext*&, clang::SourceLocation&, clang::SourceLocation&, clang::LinkageSpecDecl::LanguageIDs, bool&>(clang::LinkageSpecDecl*&, clang::ASTNodeImporter::CallOverloadedCreateFun<clang::LinkageSpecDecl>, clang::LinkageSpecDecl*, clang::ASTContext&&&, clang::DeclContext*&&&, clang::SourceLocation&&&, clang::SourceLocation&&&, clang::LinkageSpecDecl::LanguageIDs&&, bool&&&)
Line
Count
Source
256
2
                                   FromDeclT *FromD, Args &&... args) {
257
2
      if (Importer.getImportDeclErrorIfAny(FromD)) {
258
0
        ToD = nullptr;
259
0
        return true; // Already imported but with error.
260
0
      }
261
2
      ToD = cast_or_null<ToDeclT>(Importer.GetAlreadyImportedOrNull(FromD));
262
2
      if (ToD)
263
0
        return true; // Already imported.
264
2
      ToD = CreateFun(std::forward<Args>(args)...);
265
2
      // Keep track of imported Decls.
266
2
      Importer.RegisterImportedDecl(FromD, ToD);
267
2
      InitializeImportedDecl(FromD, ToD);
268
2
      return false; // A new Decl is created.
269
2
    }
bool clang::ASTNodeImporter::GetImportedOrCreateSpecialDecl<clang::UsingDecl, clang::ASTNodeImporter::CallOverloadedCreateFun<clang::UsingDecl>, clang::UsingDecl, clang::ASTContext&, clang::DeclContext*&, clang::SourceLocation&, clang::NestedNameSpecifierLoc&, clang::DeclarationNameInfo&, bool>(clang::UsingDecl*&, clang::ASTNodeImporter::CallOverloadedCreateFun<clang::UsingDecl>, clang::UsingDecl*, clang::ASTContext&&&, clang::DeclContext*&&&, clang::SourceLocation&&&, clang::NestedNameSpecifierLoc&&&, clang::DeclarationNameInfo&&&, bool&&)
Line
Count
Source
256
11
                                   FromDeclT *FromD, Args &&... args) {
257
11
      if (Importer.getImportDeclErrorIfAny(FromD)) {
258
0
        ToD = nullptr;
259
0
        return true; // Already imported but with error.
260
0
      }
261
11
      ToD = cast_or_null<ToDeclT>(Importer.GetAlreadyImportedOrNull(FromD));
262
11
      if (ToD)
263
0
        return true; // Already imported.
264
11
      ToD = CreateFun(std::forward<Args>(args)...);
265
11
      // Keep track of imported Decls.
266
11
      Importer.RegisterImportedDecl(FromD, ToD);
267
11
      InitializeImportedDecl(FromD, ToD);
268
11
      return false; // A new Decl is created.
269
11
    }
bool clang::ASTNodeImporter::GetImportedOrCreateSpecialDecl<clang::UsingShadowDecl, clang::ASTNodeImporter::CallOverloadedCreateFun<clang::UsingShadowDecl>, clang::UsingShadowDecl, clang::ASTContext&, clang::DeclContext*&, clang::SourceLocation&, clang::UsingDecl*&, clang::NamedDecl*&>(clang::UsingShadowDecl*&, clang::ASTNodeImporter::CallOverloadedCreateFun<clang::UsingShadowDecl>, clang::UsingShadowDecl*, clang::ASTContext&&&, clang::DeclContext*&&&, clang::SourceLocation&&&, clang::UsingDecl*&&&, clang::NamedDecl*&&&)
Line
Count
Source
256
15
                                   FromDeclT *FromD, Args &&... args) {
257
15
      if (Importer.getImportDeclErrorIfAny(FromD)) {
258
0
        ToD = nullptr;
259
0
        return true; // Already imported but with error.
<