Bug Summary

File:tools/clang/lib/Sema/SemaTemplateInstantiate.cpp
Warning:line 5053, column 24
Forming reference to null pointer

Annotated Source Code

Press '?' to see keyboard shortcuts

clang -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name SemaTemplateInstantiate.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-eagerly-assume -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -mrelocation-model pic -pic-level 2 -mthread-model posix -relaxed-aliasing -fmath-errno -masm-verbose -mconstructor-aliases -munwind-tables -fuse-init-array -target-cpu x86-64 -dwarf-column-info -debugger-tuning=gdb -momit-leaf-frame-pointer -ffunction-sections -fdata-sections -resource-dir /usr/lib/llvm-7/lib/clang/7.0.0 -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I /build/llvm-toolchain-snapshot-7~svn325118/build-llvm/tools/clang/lib/Sema -I /build/llvm-toolchain-snapshot-7~svn325118/tools/clang/lib/Sema -I /build/llvm-toolchain-snapshot-7~svn325118/tools/clang/include -I /build/llvm-toolchain-snapshot-7~svn325118/build-llvm/tools/clang/include -I /build/llvm-toolchain-snapshot-7~svn325118/build-llvm/include -I /build/llvm-toolchain-snapshot-7~svn325118/include -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/7.3.0/../../../../include/c++/7.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/7.3.0/../../../../include/x86_64-linux-gnu/c++/7.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/7.3.0/../../../../include/x86_64-linux-gnu/c++/7.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/7.3.0/../../../../include/c++/7.3.0/backward -internal-isystem /usr/include/clang/7.0.0/include/ -internal-isystem /usr/local/include -internal-isystem /usr/lib/llvm-7/lib/clang/7.0.0/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-comment -std=c++11 -fdeprecated-macro -fdebug-compilation-dir /build/llvm-toolchain-snapshot-7~svn325118/build-llvm/tools/clang/lib/Sema -ferror-limit 19 -fmessage-length 0 -fvisibility-inlines-hidden -fobjc-runtime=gcc -fno-common -fdiagnostics-show-option -vectorize-loops -vectorize-slp -analyzer-checker optin.performance.Padding -analyzer-output=html -analyzer-config stable-report-filename=true -o /tmp/scan-build-2018-02-14-150435-17243-1 -x c++ /build/llvm-toolchain-snapshot-7~svn325118/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp

/build/llvm-toolchain-snapshot-7~svn325118/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp

1//===------- SemaTemplateInstantiate.cpp - C++ Template Instantiation ------===/
2//
3// The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//===----------------------------------------------------------------------===/
8//
9// This file implements C++ template instantiation.
10//
11//===----------------------------------------------------------------------===/
12
13#include "clang/Sema/SemaInternal.h"
14#include "TreeTransform.h"
15#include "clang/AST/ASTConsumer.h"
16#include "clang/AST/ASTContext.h"
17#include "clang/AST/ASTLambda.h"
18#include "clang/AST/ASTMutationListener.h"
19#include "clang/AST/DeclTemplate.h"
20#include "clang/AST/Expr.h"
21#include "clang/Basic/LangOptions.h"
22#include "clang/Sema/DeclSpec.h"
23#include "clang/Sema/Initialization.h"
24#include "clang/Sema/Lookup.h"
25#include "clang/Sema/PrettyDeclStackTrace.h"
26#include "clang/Sema/Template.h"
27#include "clang/Sema/TemplateDeduction.h"
28#include "clang/Sema/TemplateInstCallback.h"
29
30using namespace clang;
31using namespace sema;
32
33//===----------------------------------------------------------------------===/
34// Template Instantiation Support
35//===----------------------------------------------------------------------===/
36
37/// \brief Retrieve the template argument list(s) that should be used to
38/// instantiate the definition of the given declaration.
39///
40/// \param D the declaration for which we are computing template instantiation
41/// arguments.
42///
43/// \param Innermost if non-NULL, the innermost template argument list.
44///
45/// \param RelativeToPrimary true if we should get the template
46/// arguments relative to the primary template, even when we're
47/// dealing with a specialization. This is only relevant for function
48/// template specializations.
49///
50/// \param Pattern If non-NULL, indicates the pattern from which we will be
51/// instantiating the definition of the given declaration, \p D. This is
52/// used to determine the proper set of template instantiation arguments for
53/// friend function template specializations.
54MultiLevelTemplateArgumentList
55Sema::getTemplateInstantiationArgs(NamedDecl *D,
56 const TemplateArgumentList *Innermost,
57 bool RelativeToPrimary,
58 const FunctionDecl *Pattern) {
59 // Accumulate the set of template argument lists in this structure.
60 MultiLevelTemplateArgumentList Result;
61
62 if (Innermost)
63 Result.addOuterTemplateArguments(Innermost);
64
65 DeclContext *Ctx = dyn_cast<DeclContext>(D);
66 if (!Ctx) {
67 Ctx = D->getDeclContext();
68
69 // Add template arguments from a variable template instantiation.
70 if (VarTemplateSpecializationDecl *Spec =
71 dyn_cast<VarTemplateSpecializationDecl>(D)) {
72 // We're done when we hit an explicit specialization.
73 if (Spec->getSpecializationKind() == TSK_ExplicitSpecialization &&
74 !isa<VarTemplatePartialSpecializationDecl>(Spec))
75 return Result;
76
77 Result.addOuterTemplateArguments(&Spec->getTemplateInstantiationArgs());
78
79 // If this variable template specialization was instantiated from a
80 // specialized member that is a variable template, we're done.
81 assert(Spec->getSpecializedTemplate() && "No variable template?")(static_cast <bool> (Spec->getSpecializedTemplate() &&
"No variable template?") ? void (0) : __assert_fail ("Spec->getSpecializedTemplate() && \"No variable template?\""
, "/build/llvm-toolchain-snapshot-7~svn325118/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 81, __extension__ __PRETTY_FUNCTION__))
;
82 llvm::PointerUnion<VarTemplateDecl*,
83 VarTemplatePartialSpecializationDecl*> Specialized
84 = Spec->getSpecializedTemplateOrPartial();
85 if (VarTemplatePartialSpecializationDecl *Partial =
86 Specialized.dyn_cast<VarTemplatePartialSpecializationDecl *>()) {
87 if (Partial->isMemberSpecialization())
88 return Result;
89 } else {
90 VarTemplateDecl *Tmpl = Specialized.get<VarTemplateDecl *>();
91 if (Tmpl->isMemberSpecialization())
92 return Result;
93 }
94 }
95
96 // If we have a template template parameter with translation unit context,
97 // then we're performing substitution into a default template argument of
98 // this template template parameter before we've constructed the template
99 // that will own this template template parameter. In this case, we
100 // use empty template parameter lists for all of the outer templates
101 // to avoid performing any substitutions.
102 if (Ctx->isTranslationUnit()) {
103 if (TemplateTemplateParmDecl *TTP
104 = dyn_cast<TemplateTemplateParmDecl>(D)) {
105 for (unsigned I = 0, N = TTP->getDepth() + 1; I != N; ++I)
106 Result.addOuterTemplateArguments(None);
107 return Result;
108 }
109 }
110 }
111
112 while (!Ctx->isFileContext()) {
113 // Add template arguments from a class template instantiation.
114 if (ClassTemplateSpecializationDecl *Spec
115 = dyn_cast<ClassTemplateSpecializationDecl>(Ctx)) {
116 // We're done when we hit an explicit specialization.
117 if (Spec->getSpecializationKind() == TSK_ExplicitSpecialization &&
118 !isa<ClassTemplatePartialSpecializationDecl>(Spec))
119 break;
120
121 Result.addOuterTemplateArguments(&Spec->getTemplateInstantiationArgs());
122
123 // If this class template specialization was instantiated from a
124 // specialized member that is a class template, we're done.
125 assert(Spec->getSpecializedTemplate() && "No class template?")(static_cast <bool> (Spec->getSpecializedTemplate() &&
"No class template?") ? void (0) : __assert_fail ("Spec->getSpecializedTemplate() && \"No class template?\""
, "/build/llvm-toolchain-snapshot-7~svn325118/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 125, __extension__ __PRETTY_FUNCTION__))
;
126 if (Spec->getSpecializedTemplate()->isMemberSpecialization())
127 break;
128 }
129 // Add template arguments from a function template specialization.
130 else if (FunctionDecl *Function = dyn_cast<FunctionDecl>(Ctx)) {
131 if (!RelativeToPrimary &&
132 (Function->getTemplateSpecializationKind() ==
133 TSK_ExplicitSpecialization &&
134 !Function->getClassScopeSpecializationPattern()))
135 break;
136
137 if (const TemplateArgumentList *TemplateArgs
138 = Function->getTemplateSpecializationArgs()) {
139 // Add the template arguments for this specialization.
140 Result.addOuterTemplateArguments(TemplateArgs);
141
142 // If this function was instantiated from a specialized member that is
143 // a function template, we're done.
144 assert(Function->getPrimaryTemplate() && "No function template?")(static_cast <bool> (Function->getPrimaryTemplate() &&
"No function template?") ? void (0) : __assert_fail ("Function->getPrimaryTemplate() && \"No function template?\""
, "/build/llvm-toolchain-snapshot-7~svn325118/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 144, __extension__ __PRETTY_FUNCTION__))
;
145 if (Function->getPrimaryTemplate()->isMemberSpecialization())
146 break;
147
148 // If this function is a generic lambda specialization, we are done.
149 if (isGenericLambdaCallOperatorSpecialization(Function))
150 break;
151
152 } else if (FunctionTemplateDecl *FunTmpl
153 = Function->getDescribedFunctionTemplate()) {
154 // Add the "injected" template arguments.
155 Result.addOuterTemplateArguments(FunTmpl->getInjectedTemplateArgs());
156 }
157
158 // If this is a friend declaration and it declares an entity at
159 // namespace scope, take arguments from its lexical parent
160 // instead of its semantic parent, unless of course the pattern we're
161 // instantiating actually comes from the file's context!
162 if (Function->getFriendObjectKind() &&
163 Function->getDeclContext()->isFileContext() &&
164 (!Pattern || !Pattern->getLexicalDeclContext()->isFileContext())) {
165 Ctx = Function->getLexicalDeclContext();
166 RelativeToPrimary = false;
167 continue;
168 }
169 } else if (CXXRecordDecl *Rec = dyn_cast<CXXRecordDecl>(Ctx)) {
170 if (ClassTemplateDecl *ClassTemplate = Rec->getDescribedClassTemplate()) {
171 QualType T = ClassTemplate->getInjectedClassNameSpecialization();
172 const TemplateSpecializationType *TST =
173 cast<TemplateSpecializationType>(Context.getCanonicalType(T));
174 Result.addOuterTemplateArguments(
175 llvm::makeArrayRef(TST->getArgs(), TST->getNumArgs()));
176 if (ClassTemplate->isMemberSpecialization())
177 break;
178 }
179 }
180
181 Ctx = Ctx->getParent();
182 RelativeToPrimary = false;
183 }
184
185 return Result;
186}
187
188bool Sema::CodeSynthesisContext::isInstantiationRecord() const {
189 switch (Kind) {
190 case TemplateInstantiation:
191 case ExceptionSpecInstantiation:
192 case DefaultTemplateArgumentInstantiation:
193 case DefaultFunctionArgumentInstantiation:
194 case ExplicitTemplateArgumentSubstitution:
195 case DeducedTemplateArgumentSubstitution:
196 case PriorTemplateArgumentSubstitution:
197 return true;
198
199 case DefaultTemplateArgumentChecking:
200 case DeclaringSpecialMember:
201 case DefiningSynthesizedFunction:
202 return false;
203
204 // This function should never be called when Kind's value is Memoization.
205 case Memoization:
206 break;
207 }
208
209 llvm_unreachable("Invalid SynthesisKind!")::llvm::llvm_unreachable_internal("Invalid SynthesisKind!", "/build/llvm-toolchain-snapshot-7~svn325118/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 209)
;
210}
211
212Sema::InstantiatingTemplate::InstantiatingTemplate(
213 Sema &SemaRef, CodeSynthesisContext::SynthesisKind Kind,
214 SourceLocation PointOfInstantiation, SourceRange InstantiationRange,
215 Decl *Entity, NamedDecl *Template, ArrayRef<TemplateArgument> TemplateArgs,
216 sema::TemplateDeductionInfo *DeductionInfo)
217 : SemaRef(SemaRef) {
218 // Don't allow further instantiation if a fatal error and an uncompilable
219 // error have occurred. Any diagnostics we might have raised will not be
220 // visible, and we do not need to construct a correct AST.
221 if (SemaRef.Diags.hasFatalErrorOccurred() &&
222 SemaRef.Diags.hasUncompilableErrorOccurred()) {
223 Invalid = true;
224 return;
225 }
226 Invalid = CheckInstantiationDepth(PointOfInstantiation, InstantiationRange);
227 if (!Invalid) {
228 CodeSynthesisContext Inst;
229 Inst.Kind = Kind;
230 Inst.PointOfInstantiation = PointOfInstantiation;
231 Inst.Entity = Entity;
232 Inst.Template = Template;
233 Inst.TemplateArgs = TemplateArgs.data();
234 Inst.NumTemplateArgs = TemplateArgs.size();
235 Inst.DeductionInfo = DeductionInfo;
236 Inst.InstantiationRange = InstantiationRange;
237 SemaRef.pushCodeSynthesisContext(Inst);
238
239 AlreadyInstantiating =
240 !SemaRef.InstantiatingSpecializations
241 .insert(std::make_pair(Inst.Entity->getCanonicalDecl(), Inst.Kind))
242 .second;
243 atTemplateBegin(SemaRef.TemplateInstCallbacks, SemaRef, Inst);
244 }
245}
246
247Sema::InstantiatingTemplate::InstantiatingTemplate(
248 Sema &SemaRef, SourceLocation PointOfInstantiation, Decl *Entity,
249 SourceRange InstantiationRange)
250 : InstantiatingTemplate(SemaRef,
251 CodeSynthesisContext::TemplateInstantiation,
252 PointOfInstantiation, InstantiationRange, Entity) {}
253
254Sema::InstantiatingTemplate::InstantiatingTemplate(
255 Sema &SemaRef, SourceLocation PointOfInstantiation, FunctionDecl *Entity,
256 ExceptionSpecification, SourceRange InstantiationRange)
257 : InstantiatingTemplate(
258 SemaRef, CodeSynthesisContext::ExceptionSpecInstantiation,
259 PointOfInstantiation, InstantiationRange, Entity) {}
260
261Sema::InstantiatingTemplate::InstantiatingTemplate(
262 Sema &SemaRef, SourceLocation PointOfInstantiation, TemplateParameter Param,
263 TemplateDecl *Template, ArrayRef<TemplateArgument> TemplateArgs,
264 SourceRange InstantiationRange)
265 : InstantiatingTemplate(
266 SemaRef,
267 CodeSynthesisContext::DefaultTemplateArgumentInstantiation,
268 PointOfInstantiation, InstantiationRange, getAsNamedDecl(Param),
269 Template, TemplateArgs) {}
270
271Sema::InstantiatingTemplate::InstantiatingTemplate(
272 Sema &SemaRef, SourceLocation PointOfInstantiation,
273 FunctionTemplateDecl *FunctionTemplate,
274 ArrayRef<TemplateArgument> TemplateArgs,
275 CodeSynthesisContext::SynthesisKind Kind,
276 sema::TemplateDeductionInfo &DeductionInfo, SourceRange InstantiationRange)
277 : InstantiatingTemplate(SemaRef, Kind, PointOfInstantiation,
278 InstantiationRange, FunctionTemplate, nullptr,
279 TemplateArgs, &DeductionInfo) {
280 assert((static_cast <bool> (Kind == CodeSynthesisContext::ExplicitTemplateArgumentSubstitution
|| Kind == CodeSynthesisContext::DeducedTemplateArgumentSubstitution
) ? void (0) : __assert_fail ("Kind == CodeSynthesisContext::ExplicitTemplateArgumentSubstitution || Kind == CodeSynthesisContext::DeducedTemplateArgumentSubstitution"
, "/build/llvm-toolchain-snapshot-7~svn325118/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 282, __extension__ __PRETTY_FUNCTION__))
281 Kind == CodeSynthesisContext::ExplicitTemplateArgumentSubstitution ||(static_cast <bool> (Kind == CodeSynthesisContext::ExplicitTemplateArgumentSubstitution
|| Kind == CodeSynthesisContext::DeducedTemplateArgumentSubstitution
) ? void (0) : __assert_fail ("Kind == CodeSynthesisContext::ExplicitTemplateArgumentSubstitution || Kind == CodeSynthesisContext::DeducedTemplateArgumentSubstitution"
, "/build/llvm-toolchain-snapshot-7~svn325118/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 282, __extension__ __PRETTY_FUNCTION__))
282 Kind == CodeSynthesisContext::DeducedTemplateArgumentSubstitution)(static_cast <bool> (Kind == CodeSynthesisContext::ExplicitTemplateArgumentSubstitution
|| Kind == CodeSynthesisContext::DeducedTemplateArgumentSubstitution
) ? void (0) : __assert_fail ("Kind == CodeSynthesisContext::ExplicitTemplateArgumentSubstitution || Kind == CodeSynthesisContext::DeducedTemplateArgumentSubstitution"
, "/build/llvm-toolchain-snapshot-7~svn325118/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 282, __extension__ __PRETTY_FUNCTION__))
;
283}
284
285Sema::InstantiatingTemplate::InstantiatingTemplate(
286 Sema &SemaRef, SourceLocation PointOfInstantiation,
287 TemplateDecl *Template,
288 ArrayRef<TemplateArgument> TemplateArgs,
289 sema::TemplateDeductionInfo &DeductionInfo, SourceRange InstantiationRange)
290 : InstantiatingTemplate(
291 SemaRef,
292 CodeSynthesisContext::DeducedTemplateArgumentSubstitution,
293 PointOfInstantiation, InstantiationRange, Template, nullptr,
294 TemplateArgs, &DeductionInfo) {}
295
296Sema::InstantiatingTemplate::InstantiatingTemplate(
297 Sema &SemaRef, SourceLocation PointOfInstantiation,
298 ClassTemplatePartialSpecializationDecl *PartialSpec,
299 ArrayRef<TemplateArgument> TemplateArgs,
300 sema::TemplateDeductionInfo &DeductionInfo, SourceRange InstantiationRange)
301 : InstantiatingTemplate(
302 SemaRef,
303 CodeSynthesisContext::DeducedTemplateArgumentSubstitution,
304 PointOfInstantiation, InstantiationRange, PartialSpec, nullptr,
305 TemplateArgs, &DeductionInfo) {}
306
307Sema::InstantiatingTemplate::InstantiatingTemplate(
308 Sema &SemaRef, SourceLocation PointOfInstantiation,
309 VarTemplatePartialSpecializationDecl *PartialSpec,
310 ArrayRef<TemplateArgument> TemplateArgs,
311 sema::TemplateDeductionInfo &DeductionInfo, SourceRange InstantiationRange)
312 : InstantiatingTemplate(
313 SemaRef,
314 CodeSynthesisContext::DeducedTemplateArgumentSubstitution,
315 PointOfInstantiation, InstantiationRange, PartialSpec, nullptr,
316 TemplateArgs, &DeductionInfo) {}
317
318Sema::InstantiatingTemplate::InstantiatingTemplate(
319 Sema &SemaRef, SourceLocation PointOfInstantiation, ParmVarDecl *Param,
320 ArrayRef<TemplateArgument> TemplateArgs, SourceRange InstantiationRange)
321 : InstantiatingTemplate(
322 SemaRef,
323 CodeSynthesisContext::DefaultFunctionArgumentInstantiation,
324 PointOfInstantiation, InstantiationRange, Param, nullptr,
325 TemplateArgs) {}
326
327Sema::InstantiatingTemplate::InstantiatingTemplate(
328 Sema &SemaRef, SourceLocation PointOfInstantiation, NamedDecl *Template,
329 NonTypeTemplateParmDecl *Param, ArrayRef<TemplateArgument> TemplateArgs,
330 SourceRange InstantiationRange)
331 : InstantiatingTemplate(
332 SemaRef,
333 CodeSynthesisContext::PriorTemplateArgumentSubstitution,
334 PointOfInstantiation, InstantiationRange, Param, Template,
335 TemplateArgs) {}
336
337Sema::InstantiatingTemplate::InstantiatingTemplate(
338 Sema &SemaRef, SourceLocation PointOfInstantiation, NamedDecl *Template,
339 TemplateTemplateParmDecl *Param, ArrayRef<TemplateArgument> TemplateArgs,
340 SourceRange InstantiationRange)
341 : InstantiatingTemplate(
342 SemaRef,
343 CodeSynthesisContext::PriorTemplateArgumentSubstitution,
344 PointOfInstantiation, InstantiationRange, Param, Template,
345 TemplateArgs) {}
346
347Sema::InstantiatingTemplate::InstantiatingTemplate(
348 Sema &SemaRef, SourceLocation PointOfInstantiation, TemplateDecl *Template,
349 NamedDecl *Param, ArrayRef<TemplateArgument> TemplateArgs,
350 SourceRange InstantiationRange)
351 : InstantiatingTemplate(
352 SemaRef, CodeSynthesisContext::DefaultTemplateArgumentChecking,
353 PointOfInstantiation, InstantiationRange, Param, Template,
354 TemplateArgs) {}
355
356void Sema::pushCodeSynthesisContext(CodeSynthesisContext Ctx) {
357 Ctx.SavedInNonInstantiationSFINAEContext = InNonInstantiationSFINAEContext;
358 InNonInstantiationSFINAEContext = false;
359
360 CodeSynthesisContexts.push_back(Ctx);
361
362 if (!Ctx.isInstantiationRecord())
363 ++NonInstantiationEntries;
364}
365
366void Sema::popCodeSynthesisContext() {
367 auto &Active = CodeSynthesisContexts.back();
368 if (!Active.isInstantiationRecord()) {
369 assert(NonInstantiationEntries > 0)(static_cast <bool> (NonInstantiationEntries > 0) ? void
(0) : __assert_fail ("NonInstantiationEntries > 0", "/build/llvm-toolchain-snapshot-7~svn325118/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 369, __extension__ __PRETTY_FUNCTION__))
;
370 --NonInstantiationEntries;
371 }
372
373 InNonInstantiationSFINAEContext = Active.SavedInNonInstantiationSFINAEContext;
374
375 // Name lookup no longer looks in this template's defining module.
376 assert(CodeSynthesisContexts.size() >=(static_cast <bool> (CodeSynthesisContexts.size() >=
CodeSynthesisContextLookupModules.size() && "forgot to remove a lookup module for a template instantiation"
) ? void (0) : __assert_fail ("CodeSynthesisContexts.size() >= CodeSynthesisContextLookupModules.size() && \"forgot to remove a lookup module for a template instantiation\""
, "/build/llvm-toolchain-snapshot-7~svn325118/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 378, __extension__ __PRETTY_FUNCTION__))
377 CodeSynthesisContextLookupModules.size() &&(static_cast <bool> (CodeSynthesisContexts.size() >=
CodeSynthesisContextLookupModules.size() && "forgot to remove a lookup module for a template instantiation"
) ? void (0) : __assert_fail ("CodeSynthesisContexts.size() >= CodeSynthesisContextLookupModules.size() && \"forgot to remove a lookup module for a template instantiation\""
, "/build/llvm-toolchain-snapshot-7~svn325118/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 378, __extension__ __PRETTY_FUNCTION__))
378 "forgot to remove a lookup module for a template instantiation")(static_cast <bool> (CodeSynthesisContexts.size() >=
CodeSynthesisContextLookupModules.size() && "forgot to remove a lookup module for a template instantiation"
) ? void (0) : __assert_fail ("CodeSynthesisContexts.size() >= CodeSynthesisContextLookupModules.size() && \"forgot to remove a lookup module for a template instantiation\""
, "/build/llvm-toolchain-snapshot-7~svn325118/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 378, __extension__ __PRETTY_FUNCTION__))
;
379 if (CodeSynthesisContexts.size() ==
380 CodeSynthesisContextLookupModules.size()) {
381 if (Module *M = CodeSynthesisContextLookupModules.back())
382 LookupModulesCache.erase(M);
383 CodeSynthesisContextLookupModules.pop_back();
384 }
385
386 // If we've left the code synthesis context for the current context stack,
387 // stop remembering that we've emitted that stack.
388 if (CodeSynthesisContexts.size() ==
389 LastEmittedCodeSynthesisContextDepth)
390 LastEmittedCodeSynthesisContextDepth = 0;
391
392 CodeSynthesisContexts.pop_back();
393}
394
395void Sema::InstantiatingTemplate::Clear() {
396 if (!Invalid) {
397 if (!AlreadyInstantiating) {
398 auto &Active = SemaRef.CodeSynthesisContexts.back();
399 SemaRef.InstantiatingSpecializations.erase(
400 std::make_pair(Active.Entity, Active.Kind));
401 }
402
403 atTemplateEnd(SemaRef.TemplateInstCallbacks, SemaRef,
404 SemaRef.CodeSynthesisContexts.back());
405
406 SemaRef.popCodeSynthesisContext();
407 Invalid = true;
408 }
409}
410
411bool Sema::InstantiatingTemplate::CheckInstantiationDepth(
412 SourceLocation PointOfInstantiation,
413 SourceRange InstantiationRange) {
414 assert(SemaRef.NonInstantiationEntries <=(static_cast <bool> (SemaRef.NonInstantiationEntries <=
SemaRef.CodeSynthesisContexts.size()) ? void (0) : __assert_fail
("SemaRef.NonInstantiationEntries <= SemaRef.CodeSynthesisContexts.size()"
, "/build/llvm-toolchain-snapshot-7~svn325118/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 415, __extension__ __PRETTY_FUNCTION__))
415 SemaRef.CodeSynthesisContexts.size())(static_cast <bool> (SemaRef.NonInstantiationEntries <=
SemaRef.CodeSynthesisContexts.size()) ? void (0) : __assert_fail
("SemaRef.NonInstantiationEntries <= SemaRef.CodeSynthesisContexts.size()"
, "/build/llvm-toolchain-snapshot-7~svn325118/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 415, __extension__ __PRETTY_FUNCTION__))
;
416 if ((SemaRef.CodeSynthesisContexts.size() -
417 SemaRef.NonInstantiationEntries)
418 <= SemaRef.getLangOpts().InstantiationDepth)
419 return false;
420
421 SemaRef.Diag(PointOfInstantiation,
422 diag::err_template_recursion_depth_exceeded)
423 << SemaRef.getLangOpts().InstantiationDepth
424 << InstantiationRange;
425 SemaRef.Diag(PointOfInstantiation, diag::note_template_recursion_depth)
426 << SemaRef.getLangOpts().InstantiationDepth;
427 return true;
428}
429
430/// \brief Prints the current instantiation stack through a series of
431/// notes.
432void Sema::PrintInstantiationStack() {
433 // Determine which template instantiations to skip, if any.
434 unsigned SkipStart = CodeSynthesisContexts.size(), SkipEnd = SkipStart;
435 unsigned Limit = Diags.getTemplateBacktraceLimit();
436 if (Limit && Limit < CodeSynthesisContexts.size()) {
437 SkipStart = Limit / 2 + Limit % 2;
438 SkipEnd = CodeSynthesisContexts.size() - Limit / 2;
439 }
440
441 // FIXME: In all of these cases, we need to show the template arguments
442 unsigned InstantiationIdx = 0;
443 for (SmallVectorImpl<CodeSynthesisContext>::reverse_iterator
444 Active = CodeSynthesisContexts.rbegin(),
445 ActiveEnd = CodeSynthesisContexts.rend();
446 Active != ActiveEnd;
447 ++Active, ++InstantiationIdx) {
448 // Skip this instantiation?
449 if (InstantiationIdx >= SkipStart && InstantiationIdx < SkipEnd) {
450 if (InstantiationIdx == SkipStart) {
451 // Note that we're skipping instantiations.
452 Diags.Report(Active->PointOfInstantiation,
453 diag::note_instantiation_contexts_suppressed)
454 << unsigned(CodeSynthesisContexts.size() - Limit);
455 }
456 continue;
457 }
458
459 switch (Active->Kind) {
460 case CodeSynthesisContext::TemplateInstantiation: {
461 Decl *D = Active->Entity;
462 if (CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(D)) {
463 unsigned DiagID = diag::note_template_member_class_here;
464 if (isa<ClassTemplateSpecializationDecl>(Record))
465 DiagID = diag::note_template_class_instantiation_here;
466 Diags.Report(Active->PointOfInstantiation, DiagID)
467 << Record << Active->InstantiationRange;
468 } else if (FunctionDecl *Function = dyn_cast<FunctionDecl>(D)) {
469 unsigned DiagID;
470 if (Function->getPrimaryTemplate())
471 DiagID = diag::note_function_template_spec_here;
472 else
473 DiagID = diag::note_template_member_function_here;
474 Diags.Report(Active->PointOfInstantiation, DiagID)
475 << Function
476 << Active->InstantiationRange;
477 } else if (VarDecl *VD = dyn_cast<VarDecl>(D)) {
478 Diags.Report(Active->PointOfInstantiation,
479 VD->isStaticDataMember()?
480 diag::note_template_static_data_member_def_here
481 : diag::note_template_variable_def_here)
482 << VD
483 << Active->InstantiationRange;
484 } else if (EnumDecl *ED = dyn_cast<EnumDecl>(D)) {
485 Diags.Report(Active->PointOfInstantiation,
486 diag::note_template_enum_def_here)
487 << ED
488 << Active->InstantiationRange;
489 } else if (FieldDecl *FD = dyn_cast<FieldDecl>(D)) {
490 Diags.Report(Active->PointOfInstantiation,
491 diag::note_template_nsdmi_here)
492 << FD << Active->InstantiationRange;
493 } else {
494 Diags.Report(Active->PointOfInstantiation,
495 diag::note_template_type_alias_instantiation_here)
496 << cast<TypeAliasTemplateDecl>(D)
497 << Active->InstantiationRange;
498 }
499 break;
500 }
501
502 case CodeSynthesisContext::DefaultTemplateArgumentInstantiation: {
503 TemplateDecl *Template = cast<TemplateDecl>(Active->Template);
504 SmallVector<char, 128> TemplateArgsStr;
505 llvm::raw_svector_ostream OS(TemplateArgsStr);
506 Template->printName(OS);
507 printTemplateArgumentList(OS, Active->template_arguments(),
508 getPrintingPolicy());
509 Diags.Report(Active->PointOfInstantiation,
510 diag::note_default_arg_instantiation_here)
511 << OS.str()
512 << Active->InstantiationRange;
513 break;
514 }
515
516 case CodeSynthesisContext::ExplicitTemplateArgumentSubstitution: {
517 FunctionTemplateDecl *FnTmpl = cast<FunctionTemplateDecl>(Active->Entity);
518 Diags.Report(Active->PointOfInstantiation,
519 diag::note_explicit_template_arg_substitution_here)
520 << FnTmpl
521 << getTemplateArgumentBindingsText(FnTmpl->getTemplateParameters(),
522 Active->TemplateArgs,
523 Active->NumTemplateArgs)
524 << Active->InstantiationRange;
525 break;
526 }
527
528 case CodeSynthesisContext::DeducedTemplateArgumentSubstitution: {
529 if (FunctionTemplateDecl *FnTmpl =
530 dyn_cast<FunctionTemplateDecl>(Active->Entity)) {
531 Diags.Report(Active->PointOfInstantiation,
532 diag::note_function_template_deduction_instantiation_here)
533 << FnTmpl
534 << getTemplateArgumentBindingsText(FnTmpl->getTemplateParameters(),
535 Active->TemplateArgs,
536 Active->NumTemplateArgs)
537 << Active->InstantiationRange;
538 } else {
539 bool IsVar = isa<VarTemplateDecl>(Active->Entity) ||
540 isa<VarTemplateSpecializationDecl>(Active->Entity);
541 bool IsTemplate = false;
542 TemplateParameterList *Params;
543 if (auto *D = dyn_cast<TemplateDecl>(Active->Entity)) {
544 IsTemplate = true;
545 Params = D->getTemplateParameters();
546 } else if (auto *D = dyn_cast<ClassTemplatePartialSpecializationDecl>(
547 Active->Entity)) {
548 Params = D->getTemplateParameters();
549 } else if (auto *D = dyn_cast<VarTemplatePartialSpecializationDecl>(
550 Active->Entity)) {
551 Params = D->getTemplateParameters();
552 } else {
553 llvm_unreachable("unexpected template kind")::llvm::llvm_unreachable_internal("unexpected template kind",
"/build/llvm-toolchain-snapshot-7~svn325118/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 553)
;
554 }
555
556 Diags.Report(Active->PointOfInstantiation,
557 diag::note_deduced_template_arg_substitution_here)
558 << IsVar << IsTemplate << cast<NamedDecl>(Active->Entity)
559 << getTemplateArgumentBindingsText(Params, Active->TemplateArgs,
560 Active->NumTemplateArgs)
561 << Active->InstantiationRange;
562 }
563 break;
564 }
565
566 case CodeSynthesisContext::DefaultFunctionArgumentInstantiation: {
567 ParmVarDecl *Param = cast<ParmVarDecl>(Active->Entity);
568 FunctionDecl *FD = cast<FunctionDecl>(Param->getDeclContext());
569
570 SmallVector<char, 128> TemplateArgsStr;
571 llvm::raw_svector_ostream OS(TemplateArgsStr);
572 FD->printName(OS);
573 printTemplateArgumentList(OS, Active->template_arguments(),
574 getPrintingPolicy());
575 Diags.Report(Active->PointOfInstantiation,
576 diag::note_default_function_arg_instantiation_here)
577 << OS.str()
578 << Active->InstantiationRange;
579 break;
580 }
581
582 case CodeSynthesisContext::PriorTemplateArgumentSubstitution: {
583 NamedDecl *Parm = cast<NamedDecl>(Active->Entity);
584 std::string Name;
585 if (!Parm->getName().empty())
586 Name = std::string(" '") + Parm->getName().str() + "'";
587
588 TemplateParameterList *TemplateParams = nullptr;
589 if (TemplateDecl *Template = dyn_cast<TemplateDecl>(Active->Template))
590 TemplateParams = Template->getTemplateParameters();
591 else
592 TemplateParams =
593 cast<ClassTemplatePartialSpecializationDecl>(Active->Template)
594 ->getTemplateParameters();
595 Diags.Report(Active->PointOfInstantiation,
596 diag::note_prior_template_arg_substitution)
597 << isa<TemplateTemplateParmDecl>(Parm)
598 << Name
599 << getTemplateArgumentBindingsText(TemplateParams,
600 Active->TemplateArgs,
601 Active->NumTemplateArgs)
602 << Active->InstantiationRange;
603 break;
604 }
605
606 case CodeSynthesisContext::DefaultTemplateArgumentChecking: {
607 TemplateParameterList *TemplateParams = nullptr;
608 if (TemplateDecl *Template = dyn_cast<TemplateDecl>(Active->Template))
609 TemplateParams = Template->getTemplateParameters();
610 else
611 TemplateParams =
612 cast<ClassTemplatePartialSpecializationDecl>(Active->Template)
613 ->getTemplateParameters();
614
615 Diags.Report(Active->PointOfInstantiation,
616 diag::note_template_default_arg_checking)
617 << getTemplateArgumentBindingsText(TemplateParams,
618 Active->TemplateArgs,
619 Active->NumTemplateArgs)
620 << Active->InstantiationRange;
621 break;
622 }
623
624 case CodeSynthesisContext::ExceptionSpecInstantiation:
625 Diags.Report(Active->PointOfInstantiation,
626 diag::note_template_exception_spec_instantiation_here)
627 << cast<FunctionDecl>(Active->Entity)
628 << Active->InstantiationRange;
629 break;
630
631 case CodeSynthesisContext::DeclaringSpecialMember:
632 Diags.Report(Active->PointOfInstantiation,
633 diag::note_in_declaration_of_implicit_special_member)
634 << cast<CXXRecordDecl>(Active->Entity) << Active->SpecialMember;
635 break;
636
637 case CodeSynthesisContext::DefiningSynthesizedFunction: {
638 // FIXME: For synthesized members other than special members, produce a note.
639 auto *MD = dyn_cast<CXXMethodDecl>(Active->Entity);
640 auto CSM = MD ? getSpecialMember(MD) : CXXInvalid;
641 if (CSM != CXXInvalid) {
642 Diags.Report(Active->PointOfInstantiation,
643 diag::note_member_synthesized_at)
644 << CSM << Context.getTagDeclType(MD->getParent());
645 }
646 break;
647 }
648
649 case CodeSynthesisContext::Memoization:
650 break;
651 }
652 }
653}
654
655Optional<TemplateDeductionInfo *> Sema::isSFINAEContext() const {
656 if (InNonInstantiationSFINAEContext)
657 return Optional<TemplateDeductionInfo *>(nullptr);
658
659 for (SmallVectorImpl<CodeSynthesisContext>::const_reverse_iterator
660 Active = CodeSynthesisContexts.rbegin(),
661 ActiveEnd = CodeSynthesisContexts.rend();
662 Active != ActiveEnd;
663 ++Active)
664 {
665 switch (Active->Kind) {
666 case CodeSynthesisContext::TemplateInstantiation:
667 // An instantiation of an alias template may or may not be a SFINAE
668 // context, depending on what else is on the stack.
669 if (isa<TypeAliasTemplateDecl>(Active->Entity))
670 break;
671 // Fall through.
672 case CodeSynthesisContext::DefaultFunctionArgumentInstantiation:
673 case CodeSynthesisContext::ExceptionSpecInstantiation:
674 // This is a template instantiation, so there is no SFINAE.
675 return None;
676
677 case CodeSynthesisContext::DefaultTemplateArgumentInstantiation:
678 case CodeSynthesisContext::PriorTemplateArgumentSubstitution:
679 case CodeSynthesisContext::DefaultTemplateArgumentChecking:
680 // A default template argument instantiation and substitution into
681 // template parameters with arguments for prior parameters may or may
682 // not be a SFINAE context; look further up the stack.
683 break;
684
685 case CodeSynthesisContext::ExplicitTemplateArgumentSubstitution:
686 case CodeSynthesisContext::DeducedTemplateArgumentSubstitution:
687 // We're either substitution explicitly-specified template arguments
688 // or deduced template arguments, so SFINAE applies.
689 assert(Active->DeductionInfo && "Missing deduction info pointer")(static_cast <bool> (Active->DeductionInfo &&
"Missing deduction info pointer") ? void (0) : __assert_fail
("Active->DeductionInfo && \"Missing deduction info pointer\""
, "/build/llvm-toolchain-snapshot-7~svn325118/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 689, __extension__ __PRETTY_FUNCTION__))
;
690 return Active->DeductionInfo;
691
692 case CodeSynthesisContext::DeclaringSpecialMember:
693 case CodeSynthesisContext::DefiningSynthesizedFunction:
694 // This happens in a context unrelated to template instantiation, so
695 // there is no SFINAE.
696 return None;
697
698 case CodeSynthesisContext::Memoization:
699 break;
700 }
701
702 // The inner context was transparent for SFINAE. If it occurred within a
703 // non-instantiation SFINAE context, then SFINAE applies.
704 if (Active->SavedInNonInstantiationSFINAEContext)
705 return Optional<TemplateDeductionInfo *>(nullptr);
706 }
707
708 return None;
709}
710
711/// \brief Retrieve the depth and index of a parameter pack.
712static std::pair<unsigned, unsigned>
713getDepthAndIndex(NamedDecl *ND) {
714 if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(ND))
715 return std::make_pair(TTP->getDepth(), TTP->getIndex());
716
717 if (NonTypeTemplateParmDecl *NTTP = dyn_cast<NonTypeTemplateParmDecl>(ND))
718 return std::make_pair(NTTP->getDepth(), NTTP->getIndex());
719
720 TemplateTemplateParmDecl *TTP = cast<TemplateTemplateParmDecl>(ND);
721 return std::make_pair(TTP->getDepth(), TTP->getIndex());
722}
723
724//===----------------------------------------------------------------------===/
725// Template Instantiation for Types
726//===----------------------------------------------------------------------===/
727namespace {
728 class TemplateInstantiator : public TreeTransform<TemplateInstantiator> {
729 const MultiLevelTemplateArgumentList &TemplateArgs;
730 SourceLocation Loc;
731 DeclarationName Entity;
732
733 public:
734 typedef TreeTransform<TemplateInstantiator> inherited;
735
736 TemplateInstantiator(Sema &SemaRef,
737 const MultiLevelTemplateArgumentList &TemplateArgs,
738 SourceLocation Loc,
739 DeclarationName Entity)
740 : inherited(SemaRef), TemplateArgs(TemplateArgs), Loc(Loc),
741 Entity(Entity) { }
742
743 /// \brief Determine whether the given type \p T has already been
744 /// transformed.
745 ///
746 /// For the purposes of template instantiation, a type has already been
747 /// transformed if it is NULL or if it is not dependent.
748 bool AlreadyTransformed(QualType T);
749
750 /// \brief Returns the location of the entity being instantiated, if known.
751 SourceLocation getBaseLocation() { return Loc; }
752
753 /// \brief Returns the name of the entity being instantiated, if any.
754 DeclarationName getBaseEntity() { return Entity; }
755
756 /// \brief Sets the "base" location and entity when that
757 /// information is known based on another transformation.
758 void setBase(SourceLocation Loc, DeclarationName Entity) {
759 this->Loc = Loc;
760 this->Entity = Entity;
761 }
762
763 bool TryExpandParameterPacks(SourceLocation EllipsisLoc,
764 SourceRange PatternRange,
765 ArrayRef<UnexpandedParameterPack> Unexpanded,
766 bool &ShouldExpand, bool &RetainExpansion,
767 Optional<unsigned> &NumExpansions) {
768 return getSema().CheckParameterPacksForExpansion(EllipsisLoc,
769 PatternRange, Unexpanded,
770 TemplateArgs,
771 ShouldExpand,
772 RetainExpansion,
773 NumExpansions);
774 }
775
776 void ExpandingFunctionParameterPack(ParmVarDecl *Pack) {
777 SemaRef.CurrentInstantiationScope->MakeInstantiatedLocalArgPack(Pack);
778 }
779
780 TemplateArgument ForgetPartiallySubstitutedPack() {
781 TemplateArgument Result;
782 if (NamedDecl *PartialPack
783 = SemaRef.CurrentInstantiationScope->getPartiallySubstitutedPack()){
784 MultiLevelTemplateArgumentList &TemplateArgs
785 = const_cast<MultiLevelTemplateArgumentList &>(this->TemplateArgs);
786 unsigned Depth, Index;
787 std::tie(Depth, Index) = getDepthAndIndex(PartialPack);
788 if (TemplateArgs.hasTemplateArgument(Depth, Index)) {
789 Result = TemplateArgs(Depth, Index);
790 TemplateArgs.setArgument(Depth, Index, TemplateArgument());
791 }
792 }
793
794 return Result;
795 }
796
797 void RememberPartiallySubstitutedPack(TemplateArgument Arg) {
798 if (Arg.isNull())
799 return;
800
801 if (NamedDecl *PartialPack
802 = SemaRef.CurrentInstantiationScope->getPartiallySubstitutedPack()){
803 MultiLevelTemplateArgumentList &TemplateArgs
804 = const_cast<MultiLevelTemplateArgumentList &>(this->TemplateArgs);
805 unsigned Depth, Index;
806 std::tie(Depth, Index) = getDepthAndIndex(PartialPack);
807 TemplateArgs.setArgument(Depth, Index, Arg);
808 }
809 }
810
811 /// \brief Transform the given declaration by instantiating a reference to
812 /// this declaration.
813 Decl *TransformDecl(SourceLocation Loc, Decl *D);
814
815 void transformAttrs(Decl *Old, Decl *New) {
816 SemaRef.InstantiateAttrs(TemplateArgs, Old, New);
817 }
818
819 void transformedLocalDecl(Decl *Old, Decl *New) {
820 // If we've instantiated the call operator of a lambda or the call
821 // operator template of a generic lambda, update the "instantiation of"
822 // information.
823 auto *NewMD = dyn_cast<CXXMethodDecl>(New);
824 if (NewMD && isLambdaCallOperator(NewMD)) {
825 auto *OldMD = dyn_cast<CXXMethodDecl>(Old);
826 if (auto *NewTD = NewMD->getDescribedFunctionTemplate())
827 NewTD->setInstantiatedFromMemberTemplate(
828 OldMD->getDescribedFunctionTemplate());
829 else
830 NewMD->setInstantiationOfMemberFunction(OldMD,
831 TSK_ImplicitInstantiation);
832 }
833
834 SemaRef.CurrentInstantiationScope->InstantiatedLocal(Old, New);
835
836 // We recreated a local declaration, but not by instantiating it. There
837 // may be pending dependent diagnostics to produce.
838 if (auto *DC = dyn_cast<DeclContext>(Old))
839 SemaRef.PerformDependentDiagnostics(DC, TemplateArgs);
840 }
841
842 /// \brief Transform the definition of the given declaration by
843 /// instantiating it.
844 Decl *TransformDefinition(SourceLocation Loc, Decl *D);
845
846 /// \brief Transform the first qualifier within a scope by instantiating the
847 /// declaration.
848 NamedDecl *TransformFirstQualifierInScope(NamedDecl *D, SourceLocation Loc);
849
850 /// \brief Rebuild the exception declaration and register the declaration
851 /// as an instantiated local.
852 VarDecl *RebuildExceptionDecl(VarDecl *ExceptionDecl,
853 TypeSourceInfo *Declarator,
854 SourceLocation StartLoc,
855 SourceLocation NameLoc,
856 IdentifierInfo *Name);
857
858 /// \brief Rebuild the Objective-C exception declaration and register the
859 /// declaration as an instantiated local.
860 VarDecl *RebuildObjCExceptionDecl(VarDecl *ExceptionDecl,
861 TypeSourceInfo *TSInfo, QualType T);
862
863 /// \brief Check for tag mismatches when instantiating an
864 /// elaborated type.
865 QualType RebuildElaboratedType(SourceLocation KeywordLoc,
866 ElaboratedTypeKeyword Keyword,
867 NestedNameSpecifierLoc QualifierLoc,
868 QualType T);
869
870 TemplateName
871 TransformTemplateName(CXXScopeSpec &SS, TemplateName Name,
872 SourceLocation NameLoc,
873 QualType ObjectType = QualType(),
874 NamedDecl *FirstQualifierInScope = nullptr,
875 bool AllowInjectedClassName = false);
876
877 const LoopHintAttr *TransformLoopHintAttr(const LoopHintAttr *LH);
878
879 ExprResult TransformPredefinedExpr(PredefinedExpr *E);
880 ExprResult TransformDeclRefExpr(DeclRefExpr *E);
881 ExprResult TransformCXXDefaultArgExpr(CXXDefaultArgExpr *E);
882
883 ExprResult TransformTemplateParmRefExpr(DeclRefExpr *E,
884 NonTypeTemplateParmDecl *D);
885 ExprResult TransformSubstNonTypeTemplateParmPackExpr(
886 SubstNonTypeTemplateParmPackExpr *E);
887
888 /// \brief Rebuild a DeclRefExpr for a ParmVarDecl reference.
889 ExprResult RebuildParmVarDeclRefExpr(ParmVarDecl *PD, SourceLocation Loc);
890
891 /// \brief Transform a reference to a function parameter pack.
892 ExprResult TransformFunctionParmPackRefExpr(DeclRefExpr *E,
893 ParmVarDecl *PD);
894
895 /// \brief Transform a FunctionParmPackExpr which was built when we couldn't
896 /// expand a function parameter pack reference which refers to an expanded
897 /// pack.
898 ExprResult TransformFunctionParmPackExpr(FunctionParmPackExpr *E);
899
900 QualType TransformFunctionProtoType(TypeLocBuilder &TLB,
901 FunctionProtoTypeLoc TL) {
902 // Call the base version; it will forward to our overridden version below.
903 return inherited::TransformFunctionProtoType(TLB, TL);
904 }
905
906 template<typename Fn>
907 QualType TransformFunctionProtoType(TypeLocBuilder &TLB,
908 FunctionProtoTypeLoc TL,
909 CXXRecordDecl *ThisContext,
910 unsigned ThisTypeQuals,
911 Fn TransformExceptionSpec);
912
913 ParmVarDecl *TransformFunctionTypeParam(ParmVarDecl *OldParm,
914 int indexAdjustment,
915 Optional<unsigned> NumExpansions,
916 bool ExpectParameterPack);
917
918 /// \brief Transforms a template type parameter type by performing
919 /// substitution of the corresponding template type argument.
920 QualType TransformTemplateTypeParmType(TypeLocBuilder &TLB,
921 TemplateTypeParmTypeLoc TL);
922
923 /// \brief Transforms an already-substituted template type parameter pack
924 /// into either itself (if we aren't substituting into its pack expansion)
925 /// or the appropriate substituted argument.
926 QualType TransformSubstTemplateTypeParmPackType(TypeLocBuilder &TLB,
927 SubstTemplateTypeParmPackTypeLoc TL);
928
929 ExprResult TransformLambdaExpr(LambdaExpr *E) {
930 LocalInstantiationScope Scope(SemaRef, /*CombineWithOuterScope=*/true);
931 return TreeTransform<TemplateInstantiator>::TransformLambdaExpr(E);
932 }
933
934 TemplateParameterList *TransformTemplateParameterList(
935 TemplateParameterList *OrigTPL) {
936 if (!OrigTPL || !OrigTPL->size()) return OrigTPL;
937
938 DeclContext *Owner = OrigTPL->getParam(0)->getDeclContext();
939 TemplateDeclInstantiator DeclInstantiator(getSema(),
940 /* DeclContext *Owner */ Owner, TemplateArgs);
941 return DeclInstantiator.SubstTemplateParams(OrigTPL);
942 }
943 private:
944 ExprResult transformNonTypeTemplateParmRef(NonTypeTemplateParmDecl *parm,
945 SourceLocation loc,
946 TemplateArgument arg);
947 };
948}
949
950bool TemplateInstantiator::AlreadyTransformed(QualType T) {
951 if (T.isNull())
952 return true;
953
954 if (T->isInstantiationDependentType() || T->isVariablyModifiedType())
955 return false;
956
957 getSema().MarkDeclarationsReferencedInType(Loc, T);
958 return true;
959}
960
961static TemplateArgument
962getPackSubstitutedTemplateArgument(Sema &S, TemplateArgument Arg) {
963 assert(S.ArgumentPackSubstitutionIndex >= 0)(static_cast <bool> (S.ArgumentPackSubstitutionIndex >=
0) ? void (0) : __assert_fail ("S.ArgumentPackSubstitutionIndex >= 0"
, "/build/llvm-toolchain-snapshot-7~svn325118/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 963, __extension__ __PRETTY_FUNCTION__))
;
964 assert(S.ArgumentPackSubstitutionIndex < (int)Arg.pack_size())(static_cast <bool> (S.ArgumentPackSubstitutionIndex <
(int)Arg.pack_size()) ? void (0) : __assert_fail ("S.ArgumentPackSubstitutionIndex < (int)Arg.pack_size()"
, "/build/llvm-toolchain-snapshot-7~svn325118/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 964, __extension__ __PRETTY_FUNCTION__))
;
965 Arg = Arg.pack_begin()[S.ArgumentPackSubstitutionIndex];
966 if (Arg.isPackExpansion())
967 Arg = Arg.getPackExpansionPattern();
968 return Arg;
969}
970
971Decl *TemplateInstantiator::TransformDecl(SourceLocation Loc, Decl *D) {
972 if (!D)
973 return nullptr;
974
975 if (TemplateTemplateParmDecl *TTP = dyn_cast<TemplateTemplateParmDecl>(D)) {
976 if (TTP->getDepth() < TemplateArgs.getNumLevels()) {
977 // If the corresponding template argument is NULL or non-existent, it's
978 // because we are performing instantiation from explicitly-specified
979 // template arguments in a function template, but there were some
980 // arguments left unspecified.
981 if (!TemplateArgs.hasTemplateArgument(TTP->getDepth(),
982 TTP->getPosition()))
983 return D;
984
985 TemplateArgument Arg = TemplateArgs(TTP->getDepth(), TTP->getPosition());
986
987 if (TTP->isParameterPack()) {
988 assert(Arg.getKind() == TemplateArgument::Pack &&(static_cast <bool> (Arg.getKind() == TemplateArgument::
Pack && "Missing argument pack") ? void (0) : __assert_fail
("Arg.getKind() == TemplateArgument::Pack && \"Missing argument pack\""
, "/build/llvm-toolchain-snapshot-7~svn325118/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 989, __extension__ __PRETTY_FUNCTION__))
989 "Missing argument pack")(static_cast <bool> (Arg.getKind() == TemplateArgument::
Pack && "Missing argument pack") ? void (0) : __assert_fail
("Arg.getKind() == TemplateArgument::Pack && \"Missing argument pack\""
, "/build/llvm-toolchain-snapshot-7~svn325118/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 989, __extension__ __PRETTY_FUNCTION__))
;
990 Arg = getPackSubstitutedTemplateArgument(getSema(), Arg);
991 }
992
993 TemplateName Template = Arg.getAsTemplate().getNameToSubstitute();
994 assert(!Template.isNull() && Template.getAsTemplateDecl() &&(static_cast <bool> (!Template.isNull() && Template
.getAsTemplateDecl() && "Wrong kind of template template argument"
) ? void (0) : __assert_fail ("!Template.isNull() && Template.getAsTemplateDecl() && \"Wrong kind of template template argument\""
, "/build/llvm-toolchain-snapshot-7~svn325118/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 995, __extension__ __PRETTY_FUNCTION__))
995 "Wrong kind of template template argument")(static_cast <bool> (!Template.isNull() && Template
.getAsTemplateDecl() && "Wrong kind of template template argument"
) ? void (0) : __assert_fail ("!Template.isNull() && Template.getAsTemplateDecl() && \"Wrong kind of template template argument\""
, "/build/llvm-toolchain-snapshot-7~svn325118/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 995, __extension__ __PRETTY_FUNCTION__))
;
996 return Template.getAsTemplateDecl();
997 }
998
999 // Fall through to find the instantiated declaration for this template
1000 // template parameter.
1001 }
1002
1003 return SemaRef.FindInstantiatedDecl(Loc, cast<NamedDecl>(D), TemplateArgs);
1004}
1005
1006Decl *TemplateInstantiator::TransformDefinition(SourceLocation Loc, Decl *D) {
1007 Decl *Inst = getSema().SubstDecl(D, getSema().CurContext, TemplateArgs);
1008 if (!Inst)
1009 return nullptr;
1010
1011 getSema().CurrentInstantiationScope->InstantiatedLocal(D, Inst);
1012 return Inst;
1013}
1014
1015NamedDecl *
1016TemplateInstantiator::TransformFirstQualifierInScope(NamedDecl *D,
1017 SourceLocation Loc) {
1018 // If the first part of the nested-name-specifier was a template type
1019 // parameter, instantiate that type parameter down to a tag type.
1020 if (TemplateTypeParmDecl *TTPD = dyn_cast_or_null<TemplateTypeParmDecl>(D)) {
1021 const TemplateTypeParmType *TTP
1022 = cast<TemplateTypeParmType>(getSema().Context.getTypeDeclType(TTPD));
1023
1024 if (TTP->getDepth() < TemplateArgs.getNumLevels()) {
1025 // FIXME: This needs testing w/ member access expressions.
1026 TemplateArgument Arg = TemplateArgs(TTP->getDepth(), TTP->getIndex());
1027
1028 if (TTP->isParameterPack()) {
1029 assert(Arg.getKind() == TemplateArgument::Pack &&(static_cast <bool> (Arg.getKind() == TemplateArgument::
Pack && "Missing argument pack") ? void (0) : __assert_fail
("Arg.getKind() == TemplateArgument::Pack && \"Missing argument pack\""
, "/build/llvm-toolchain-snapshot-7~svn325118/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1030, __extension__ __PRETTY_FUNCTION__))
1030 "Missing argument pack")(static_cast <bool> (Arg.getKind() == TemplateArgument::
Pack && "Missing argument pack") ? void (0) : __assert_fail
("Arg.getKind() == TemplateArgument::Pack && \"Missing argument pack\""
, "/build/llvm-toolchain-snapshot-7~svn325118/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1030, __extension__ __PRETTY_FUNCTION__))
;
1031
1032 if (getSema().ArgumentPackSubstitutionIndex == -1)
1033 return nullptr;
1034
1035 Arg = getPackSubstitutedTemplateArgument(getSema(), Arg);
1036 }
1037
1038 QualType T = Arg.getAsType();
1039 if (T.isNull())
1040 return cast_or_null<NamedDecl>(TransformDecl(Loc, D));
1041
1042 if (const TagType *Tag = T->getAs<TagType>())
1043 return Tag->getDecl();
1044
1045 // The resulting type is not a tag; complain.
1046 getSema().Diag(Loc, diag::err_nested_name_spec_non_tag) << T;
1047 return nullptr;
1048 }
1049 }
1050
1051 return cast_or_null<NamedDecl>(TransformDecl(Loc, D));
1052}
1053
1054VarDecl *
1055TemplateInstantiator::RebuildExceptionDecl(VarDecl *ExceptionDecl,
1056 TypeSourceInfo *Declarator,
1057 SourceLocation StartLoc,
1058 SourceLocation NameLoc,
1059 IdentifierInfo *Name) {
1060 VarDecl *Var = inherited::RebuildExceptionDecl(ExceptionDecl, Declarator,
1061 StartLoc, NameLoc, Name);
1062 if (Var)
1063 getSema().CurrentInstantiationScope->InstantiatedLocal(ExceptionDecl, Var);
1064 return Var;
1065}
1066
1067VarDecl *TemplateInstantiator::RebuildObjCExceptionDecl(VarDecl *ExceptionDecl,
1068 TypeSourceInfo *TSInfo,
1069 QualType T) {
1070 VarDecl *Var = inherited::RebuildObjCExceptionDecl(ExceptionDecl, TSInfo, T);
1071 if (Var)
1072 getSema().CurrentInstantiationScope->InstantiatedLocal(ExceptionDecl, Var);
1073 return Var;
1074}
1075
1076QualType
1077TemplateInstantiator::RebuildElaboratedType(SourceLocation KeywordLoc,
1078 ElaboratedTypeKeyword Keyword,
1079 NestedNameSpecifierLoc QualifierLoc,
1080 QualType T) {
1081 if (const TagType *TT = T->getAs<TagType>()) {
1082 TagDecl* TD = TT->getDecl();
1083
1084 SourceLocation TagLocation = KeywordLoc;
1085
1086 IdentifierInfo *Id = TD->getIdentifier();
1087
1088 // TODO: should we even warn on struct/class mismatches for this? Seems
1089 // like it's likely to produce a lot of spurious errors.
1090 if (Id && Keyword != ETK_None && Keyword != ETK_Typename) {
1091 TagTypeKind Kind = TypeWithKeyword::getTagTypeKindForKeyword(Keyword);
1092 if (!SemaRef.isAcceptableTagRedeclaration(TD, Kind, /*isDefinition*/false,
1093 TagLocation, Id)) {
1094 SemaRef.Diag(TagLocation, diag::err_use_with_wrong_tag)
1095 << Id
1096 << FixItHint::CreateReplacement(SourceRange(TagLocation),
1097 TD->getKindName());
1098 SemaRef.Diag(TD->getLocation(), diag::note_previous_use);
1099 }
1100 }
1101 }
1102
1103 return TreeTransform<TemplateInstantiator>::RebuildElaboratedType(KeywordLoc,
1104 Keyword,
1105 QualifierLoc,
1106 T);
1107}
1108
1109TemplateName TemplateInstantiator::TransformTemplateName(
1110 CXXScopeSpec &SS, TemplateName Name, SourceLocation NameLoc,
1111 QualType ObjectType, NamedDecl *FirstQualifierInScope,
1112 bool AllowInjectedClassName) {
1113 if (TemplateTemplateParmDecl *TTP
1114 = dyn_cast_or_null<TemplateTemplateParmDecl>(Name.getAsTemplateDecl())) {
1115 if (TTP->getDepth() < TemplateArgs.getNumLevels()) {
1116 // If the corresponding template argument is NULL or non-existent, it's
1117 // because we are performing instantiation from explicitly-specified
1118 // template arguments in a function template, but there were some
1119 // arguments left unspecified.
1120 if (!TemplateArgs.hasTemplateArgument(TTP->getDepth(),
1121 TTP->getPosition()))
1122 return Name;
1123
1124 TemplateArgument Arg = TemplateArgs(TTP->getDepth(), TTP->getPosition());
1125
1126 if (TTP->isParameterPack()) {
1127 assert(Arg.getKind() == TemplateArgument::Pack &&(static_cast <bool> (Arg.getKind() == TemplateArgument::
Pack && "Missing argument pack") ? void (0) : __assert_fail
("Arg.getKind() == TemplateArgument::Pack && \"Missing argument pack\""
, "/build/llvm-toolchain-snapshot-7~svn325118/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1128, __extension__ __PRETTY_FUNCTION__))
1128 "Missing argument pack")(static_cast <bool> (Arg.getKind() == TemplateArgument::
Pack && "Missing argument pack") ? void (0) : __assert_fail
("Arg.getKind() == TemplateArgument::Pack && \"Missing argument pack\""
, "/build/llvm-toolchain-snapshot-7~svn325118/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1128, __extension__ __PRETTY_FUNCTION__))
;
1129
1130 if (getSema().ArgumentPackSubstitutionIndex == -1) {
1131 // We have the template argument pack to substitute, but we're not
1132 // actually expanding the enclosing pack expansion yet. So, just
1133 // keep the entire argument pack.
1134 return getSema().Context.getSubstTemplateTemplateParmPack(TTP, Arg);
1135 }
1136
1137 Arg = getPackSubstitutedTemplateArgument(getSema(), Arg);
1138 }
1139
1140 TemplateName Template = Arg.getAsTemplate().getNameToSubstitute();
1141 assert(!Template.isNull() && "Null template template argument")(static_cast <bool> (!Template.isNull() && "Null template template argument"
) ? void (0) : __assert_fail ("!Template.isNull() && \"Null template template argument\""
, "/build/llvm-toolchain-snapshot-7~svn325118/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1141, __extension__ __PRETTY_FUNCTION__))
;
1142 assert(!Template.getAsQualifiedTemplateName() &&(static_cast <bool> (!Template.getAsQualifiedTemplateName
() && "template decl to substitute is qualified?") ? void
(0) : __assert_fail ("!Template.getAsQualifiedTemplateName() && \"template decl to substitute is qualified?\""
, "/build/llvm-toolchain-snapshot-7~svn325118/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1143, __extension__ __PRETTY_FUNCTION__))
1143 "template decl to substitute is qualified?")(static_cast <bool> (!Template.getAsQualifiedTemplateName
() && "template decl to substitute is qualified?") ? void
(0) : __assert_fail ("!Template.getAsQualifiedTemplateName() && \"template decl to substitute is qualified?\""
, "/build/llvm-toolchain-snapshot-7~svn325118/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1143, __extension__ __PRETTY_FUNCTION__))
;
1144
1145 Template = getSema().Context.getSubstTemplateTemplateParm(TTP, Template);
1146 return Template;
1147 }
1148 }
1149
1150 if (SubstTemplateTemplateParmPackStorage *SubstPack
1151 = Name.getAsSubstTemplateTemplateParmPack()) {
1152 if (getSema().ArgumentPackSubstitutionIndex == -1)
1153 return Name;
1154
1155 TemplateArgument Arg = SubstPack->getArgumentPack();
1156 Arg = getPackSubstitutedTemplateArgument(getSema(), Arg);
1157 return Arg.getAsTemplate().getNameToSubstitute();
1158 }
1159
1160 return inherited::TransformTemplateName(SS, Name, NameLoc, ObjectType,
1161 FirstQualifierInScope,
1162 AllowInjectedClassName);
1163}
1164
1165ExprResult
1166TemplateInstantiator::TransformPredefinedExpr(PredefinedExpr *E) {
1167 if (!E->isTypeDependent())
1168 return E;
1169
1170 return getSema().BuildPredefinedExpr(E->getLocation(), E->getIdentType());
1171}
1172
1173ExprResult
1174TemplateInstantiator::TransformTemplateParmRefExpr(DeclRefExpr *E,
1175 NonTypeTemplateParmDecl *NTTP) {
1176 // If the corresponding template argument is NULL or non-existent, it's
1177 // because we are performing instantiation from explicitly-specified
1178 // template arguments in a function template, but there were some
1179 // arguments left unspecified.
1180 if (!TemplateArgs.hasTemplateArgument(NTTP->getDepth(),
1181 NTTP->getPosition()))
1182 return E;
1183
1184 TemplateArgument Arg = TemplateArgs(NTTP->getDepth(), NTTP->getPosition());
1185
1186 if (TemplateArgs.getNumLevels() != TemplateArgs.getNumSubstitutedLevels()) {
1187 // We're performing a partial substitution, so the substituted argument
1188 // could be dependent. As a result we can't create a SubstNonType*Expr
1189 // node now, since that represents a fully-substituted argument.
1190 // FIXME: We should have some AST representation for this.
1191 if (Arg.getKind() == TemplateArgument::Pack) {
1192 // FIXME: This won't work for alias templates.
1193 assert(Arg.pack_size() == 1 && Arg.pack_begin()->isPackExpansion() &&(static_cast <bool> (Arg.pack_size() == 1 && Arg
.pack_begin()->isPackExpansion() && "unexpected pack arguments in partial substitution"
) ? void (0) : __assert_fail ("Arg.pack_size() == 1 && Arg.pack_begin()->isPackExpansion() && \"unexpected pack arguments in partial substitution\""
, "/build/llvm-toolchain-snapshot-7~svn325118/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1194, __extension__ __PRETTY_FUNCTION__))
1194 "unexpected pack arguments in partial substitution")(static_cast <bool> (Arg.pack_size() == 1 && Arg
.pack_begin()->isPackExpansion() && "unexpected pack arguments in partial substitution"
) ? void (0) : __assert_fail ("Arg.pack_size() == 1 && Arg.pack_begin()->isPackExpansion() && \"unexpected pack arguments in partial substitution\""
, "/build/llvm-toolchain-snapshot-7~svn325118/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1194, __extension__ __PRETTY_FUNCTION__))
;
1195 Arg = Arg.pack_begin()->getPackExpansionPattern();
1196 }
1197 assert(Arg.getKind() == TemplateArgument::Expression &&(static_cast <bool> (Arg.getKind() == TemplateArgument::
Expression && "unexpected nontype template argument kind in partial substitution"
) ? void (0) : __assert_fail ("Arg.getKind() == TemplateArgument::Expression && \"unexpected nontype template argument kind in partial substitution\""
, "/build/llvm-toolchain-snapshot-7~svn325118/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1198, __extension__ __PRETTY_FUNCTION__))
1198 "unexpected nontype template argument kind in partial substitution")(static_cast <bool> (Arg.getKind() == TemplateArgument::
Expression && "unexpected nontype template argument kind in partial substitution"
) ? void (0) : __assert_fail ("Arg.getKind() == TemplateArgument::Expression && \"unexpected nontype template argument kind in partial substitution\""
, "/build/llvm-toolchain-snapshot-7~svn325118/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1198, __extension__ __PRETTY_FUNCTION__))
;
1199 return Arg.getAsExpr();
1200 }
1201
1202 if (NTTP->isParameterPack()) {
1203 assert(Arg.getKind() == TemplateArgument::Pack &&(static_cast <bool> (Arg.getKind() == TemplateArgument::
Pack && "Missing argument pack") ? void (0) : __assert_fail
("Arg.getKind() == TemplateArgument::Pack && \"Missing argument pack\""
, "/build/llvm-toolchain-snapshot-7~svn325118/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1204, __extension__ __PRETTY_FUNCTION__))
1204 "Missing argument pack")(static_cast <bool> (Arg.getKind() == TemplateArgument::
Pack && "Missing argument pack") ? void (0) : __assert_fail
("Arg.getKind() == TemplateArgument::Pack && \"Missing argument pack\""
, "/build/llvm-toolchain-snapshot-7~svn325118/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1204, __extension__ __PRETTY_FUNCTION__))
;
1205
1206 if (getSema().ArgumentPackSubstitutionIndex == -1) {
1207 // We have an argument pack, but we can't select a particular argument
1208 // out of it yet. Therefore, we'll build an expression to hold on to that
1209 // argument pack.
1210 QualType TargetType = SemaRef.SubstType(NTTP->getType(), TemplateArgs,
1211 E->getLocation(),
1212 NTTP->getDeclName());
1213 if (TargetType.isNull())
1214 return ExprError();
1215
1216 return new (SemaRef.Context) SubstNonTypeTemplateParmPackExpr(
1217 TargetType.getNonLValueExprType(SemaRef.Context),
1218 TargetType->isReferenceType() ? VK_LValue : VK_RValue, NTTP,
1219 E->getLocation(), Arg);
1220 }
1221
1222 Arg = getPackSubstitutedTemplateArgument(getSema(), Arg);
1223 }
1224
1225 return transformNonTypeTemplateParmRef(NTTP, E->getLocation(), Arg);
1226}
1227
1228const LoopHintAttr *
1229TemplateInstantiator::TransformLoopHintAttr(const LoopHintAttr *LH) {
1230 Expr *TransformedExpr = getDerived().TransformExpr(LH->getValue()).get();
1231
1232 if (TransformedExpr == LH->getValue())
1233 return LH;
1234
1235 // Generate error if there is a problem with the value.
1236 if (getSema().CheckLoopHintExpr(TransformedExpr, LH->getLocation()))
1237 return LH;
1238
1239 // Create new LoopHintValueAttr with integral expression in place of the
1240 // non-type template parameter.
1241 return LoopHintAttr::CreateImplicit(
1242 getSema().Context, LH->getSemanticSpelling(), LH->getOption(),
1243 LH->getState(), TransformedExpr, LH->getRange());
1244}
1245
1246ExprResult TemplateInstantiator::transformNonTypeTemplateParmRef(
1247 NonTypeTemplateParmDecl *parm,
1248 SourceLocation loc,
1249 TemplateArgument arg) {
1250 ExprResult result;
1251 QualType type;
1252
1253 // The template argument itself might be an expression, in which
1254 // case we just return that expression.
1255 if (arg.getKind() == TemplateArgument::Expression) {
1256 Expr *argExpr = arg.getAsExpr();
1257 result = argExpr;
1258 type = argExpr->getType();
1259
1260 } else if (arg.getKind() == TemplateArgument::Declaration ||
1261 arg.getKind() == TemplateArgument::NullPtr) {
1262 ValueDecl *VD;
1263 if (arg.getKind() == TemplateArgument::Declaration) {
1264 VD = cast<ValueDecl>(arg.getAsDecl());
1265
1266 // Find the instantiation of the template argument. This is
1267 // required for nested templates.
1268 VD = cast_or_null<ValueDecl>(
1269 getSema().FindInstantiatedDecl(loc, VD, TemplateArgs));
1270 if (!VD)
1271 return ExprError();
1272 } else {
1273 // Propagate NULL template argument.
1274 VD = nullptr;
1275 }
1276
1277 // Derive the type we want the substituted decl to have. This had
1278 // better be non-dependent, or these checks will have serious problems.
1279 if (parm->isExpandedParameterPack()) {
1280 type = parm->getExpansionType(SemaRef.ArgumentPackSubstitutionIndex);
1281 } else if (parm->isParameterPack() &&
1282 isa<PackExpansionType>(parm->getType())) {
1283 type = SemaRef.SubstType(
1284 cast<PackExpansionType>(parm->getType())->getPattern(),
1285 TemplateArgs, loc, parm->getDeclName());
1286 } else {
1287 type = SemaRef.SubstType(VD ? arg.getParamTypeForDecl() : arg.getNullPtrType(),
1288 TemplateArgs, loc, parm->getDeclName());
1289 }
1290 assert(!type.isNull() && "type substitution failed for param type")(static_cast <bool> (!type.isNull() && "type substitution failed for param type"
) ? void (0) : __assert_fail ("!type.isNull() && \"type substitution failed for param type\""
, "/build/llvm-toolchain-snapshot-7~svn325118/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1290, __extension__ __PRETTY_FUNCTION__))
;
1291 assert(!type->isDependentType() && "param type still dependent")(static_cast <bool> (!type->isDependentType() &&
"param type still dependent") ? void (0) : __assert_fail ("!type->isDependentType() && \"param type still dependent\""
, "/build/llvm-toolchain-snapshot-7~svn325118/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1291, __extension__ __PRETTY_FUNCTION__))
;
1292 result = SemaRef.BuildExpressionFromDeclTemplateArgument(arg, type, loc);
1293
1294 if (!result.isInvalid()) type = result.get()->getType();
1295 } else {
1296 result = SemaRef.BuildExpressionFromIntegralTemplateArgument(arg, loc);
1297
1298 // Note that this type can be different from the type of 'result',
1299 // e.g. if it's an enum type.
1300 type = arg.getIntegralType();
1301 }
1302 if (result.isInvalid()) return ExprError();
1303
1304 Expr *resultExpr = result.get();
1305 return new (SemaRef.Context) SubstNonTypeTemplateParmExpr(
1306 type, resultExpr->getValueKind(), loc, parm, resultExpr);
1307}
1308
1309ExprResult
1310TemplateInstantiator::TransformSubstNonTypeTemplateParmPackExpr(
1311 SubstNonTypeTemplateParmPackExpr *E) {
1312 if (getSema().ArgumentPackSubstitutionIndex == -1) {
1313 // We aren't expanding the parameter pack, so just return ourselves.
1314 return E;
1315 }
1316
1317 TemplateArgument Arg = E->getArgumentPack();
1318 Arg = getPackSubstitutedTemplateArgument(getSema(), Arg);
1319 return transformNonTypeTemplateParmRef(E->getParameterPack(),
1320 E->getParameterPackLocation(),
1321 Arg);
1322}
1323
1324ExprResult
1325TemplateInstantiator::RebuildParmVarDeclRefExpr(ParmVarDecl *PD,
1326 SourceLocation Loc) {
1327 DeclarationNameInfo NameInfo(PD->getDeclName(), Loc);
1328 return getSema().BuildDeclarationNameExpr(CXXScopeSpec(), NameInfo, PD);
1329}
1330
1331ExprResult
1332TemplateInstantiator::TransformFunctionParmPackExpr(FunctionParmPackExpr *E) {
1333 if (getSema().ArgumentPackSubstitutionIndex != -1) {
1334 // We can expand this parameter pack now.
1335 ParmVarDecl *D = E->getExpansion(getSema().ArgumentPackSubstitutionIndex);
1336 ValueDecl *VD = cast_or_null<ValueDecl>(TransformDecl(E->getExprLoc(), D));
1337 if (!VD)
1338 return ExprError();
1339 return RebuildParmVarDeclRefExpr(cast<ParmVarDecl>(VD), E->getExprLoc());
1340 }
1341
1342 QualType T = TransformType(E->getType());
1343 if (T.isNull())
1344 return ExprError();
1345
1346 // Transform each of the parameter expansions into the corresponding
1347 // parameters in the instantiation of the function decl.
1348 SmallVector<ParmVarDecl *, 8> Parms;
1349 Parms.reserve(E->getNumExpansions());
1350 for (FunctionParmPackExpr::iterator I = E->begin(), End = E->end();
1351 I != End; ++I) {
1352 ParmVarDecl *D =
1353 cast_or_null<ParmVarDecl>(TransformDecl(E->getExprLoc(), *I));
1354 if (!D)
1355 return ExprError();
1356 Parms.push_back(D);
1357 }
1358
1359 return FunctionParmPackExpr::Create(getSema().Context, T,
1360 E->getParameterPack(),
1361 E->getParameterPackLocation(), Parms);
1362}
1363
1364ExprResult
1365TemplateInstantiator::TransformFunctionParmPackRefExpr(DeclRefExpr *E,
1366 ParmVarDecl *PD) {
1367 typedef LocalInstantiationScope::DeclArgumentPack DeclArgumentPack;
1368 llvm::PointerUnion<Decl *, DeclArgumentPack *> *Found
1369 = getSema().CurrentInstantiationScope->findInstantiationOf(PD);
1370 assert(Found && "no instantiation for parameter pack")(static_cast <bool> (Found && "no instantiation for parameter pack"
) ? void (0) : __assert_fail ("Found && \"no instantiation for parameter pack\""
, "/build/llvm-toolchain-snapshot-7~svn325118/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1370, __extension__ __PRETTY_FUNCTION__))
;
1371
1372 Decl *TransformedDecl;
1373 if (DeclArgumentPack *Pack = Found->dyn_cast<DeclArgumentPack *>()) {
1374 // If this is a reference to a function parameter pack which we can
1375 // substitute but can't yet expand, build a FunctionParmPackExpr for it.
1376 if (getSema().ArgumentPackSubstitutionIndex == -1) {
1377 QualType T = TransformType(E->getType());
1378 if (T.isNull())
1379 return ExprError();
1380 return FunctionParmPackExpr::Create(getSema().Context, T, PD,
1381 E->getExprLoc(), *Pack);
1382 }
1383
1384 TransformedDecl = (*Pack)[getSema().ArgumentPackSubstitutionIndex];
1385 } else {
1386 TransformedDecl = Found->get<Decl*>();
1387 }
1388
1389 // We have either an unexpanded pack or a specific expansion.
1390 return RebuildParmVarDeclRefExpr(cast<ParmVarDecl>(TransformedDecl),
1391 E->getExprLoc());
1392}
1393
1394ExprResult
1395TemplateInstantiator::TransformDeclRefExpr(DeclRefExpr *E) {
1396 NamedDecl *D = E->getDecl();
1397
1398 // Handle references to non-type template parameters and non-type template
1399 // parameter packs.
1400 if (NonTypeTemplateParmDecl *NTTP = dyn_cast<NonTypeTemplateParmDecl>(D)) {
1401 if (NTTP->getDepth() < TemplateArgs.getNumLevels())
1402 return TransformTemplateParmRefExpr(E, NTTP);
1403
1404 // We have a non-type template parameter that isn't fully substituted;
1405 // FindInstantiatedDecl will find it in the local instantiation scope.
1406 }
1407
1408 // Handle references to function parameter packs.
1409 if (ParmVarDecl *PD = dyn_cast<ParmVarDecl>(D))
1410 if (PD->isParameterPack())
1411 return TransformFunctionParmPackRefExpr(E, PD);
1412
1413 return TreeTransform<TemplateInstantiator>::TransformDeclRefExpr(E);
1414}
1415
1416ExprResult TemplateInstantiator::TransformCXXDefaultArgExpr(
1417 CXXDefaultArgExpr *E) {
1418 assert(!cast<FunctionDecl>(E->getParam()->getDeclContext())->(static_cast <bool> (!cast<FunctionDecl>(E->getParam
()->getDeclContext())-> getDescribedFunctionTemplate() &&
"Default arg expressions are never formed in dependent cases."
) ? void (0) : __assert_fail ("!cast<FunctionDecl>(E->getParam()->getDeclContext())-> getDescribedFunctionTemplate() && \"Default arg expressions are never formed in dependent cases.\""
, "/build/llvm-toolchain-snapshot-7~svn325118/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1420, __extension__ __PRETTY_FUNCTION__))
1419 getDescribedFunctionTemplate() &&(static_cast <bool> (!cast<FunctionDecl>(E->getParam
()->getDeclContext())-> getDescribedFunctionTemplate() &&
"Default arg expressions are never formed in dependent cases."
) ? void (0) : __assert_fail ("!cast<FunctionDecl>(E->getParam()->getDeclContext())-> getDescribedFunctionTemplate() && \"Default arg expressions are never formed in dependent cases.\""
, "/build/llvm-toolchain-snapshot-7~svn325118/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1420, __extension__ __PRETTY_FUNCTION__))
1420 "Default arg expressions are never formed in dependent cases.")(static_cast <bool> (!cast<FunctionDecl>(E->getParam
()->getDeclContext())-> getDescribedFunctionTemplate() &&
"Default arg expressions are never formed in dependent cases."
) ? void (0) : __assert_fail ("!cast<FunctionDecl>(E->getParam()->getDeclContext())-> getDescribedFunctionTemplate() && \"Default arg expressions are never formed in dependent cases.\""
, "/build/llvm-toolchain-snapshot-7~svn325118/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1420, __extension__ __PRETTY_FUNCTION__))
;
1421 return SemaRef.BuildCXXDefaultArgExpr(E->getUsedLocation(),
1422 cast<FunctionDecl>(E->getParam()->getDeclContext()),
1423 E->getParam());
1424}
1425
1426template<typename Fn>
1427QualType TemplateInstantiator::TransformFunctionProtoType(TypeLocBuilder &TLB,
1428 FunctionProtoTypeLoc TL,
1429 CXXRecordDecl *ThisContext,
1430 unsigned ThisTypeQuals,
1431 Fn TransformExceptionSpec) {
1432 // We need a local instantiation scope for this function prototype.
1433 LocalInstantiationScope Scope(SemaRef, /*CombineWithOuterScope=*/true);
1434 return inherited::TransformFunctionProtoType(
1435 TLB, TL, ThisContext, ThisTypeQuals, TransformExceptionSpec);
1436}
1437
1438ParmVarDecl *
1439TemplateInstantiator::TransformFunctionTypeParam(ParmVarDecl *OldParm,
1440 int indexAdjustment,
1441 Optional<unsigned> NumExpansions,
1442 bool ExpectParameterPack) {
1443 return SemaRef.SubstParmVarDecl(OldParm, TemplateArgs, indexAdjustment,
1444 NumExpansions, ExpectParameterPack);
1445}
1446
1447QualType
1448TemplateInstantiator::TransformTemplateTypeParmType(TypeLocBuilder &TLB,
1449 TemplateTypeParmTypeLoc TL) {
1450 const TemplateTypeParmType *T = TL.getTypePtr();
1451 if (T->getDepth() < TemplateArgs.getNumLevels()) {
1452 // Replace the template type parameter with its corresponding
1453 // template argument.
1454
1455 // If the corresponding template argument is NULL or doesn't exist, it's
1456 // because we are performing instantiation from explicitly-specified
1457 // template arguments in a function template class, but there were some
1458 // arguments left unspecified.
1459 if (!TemplateArgs.hasTemplateArgument(T->getDepth(), T->getIndex())) {
1460 TemplateTypeParmTypeLoc NewTL
1461 = TLB.push<TemplateTypeParmTypeLoc>(TL.getType());
1462 NewTL.setNameLoc(TL.getNameLoc());
1463 return TL.getType();
1464 }
1465
1466 TemplateArgument Arg = TemplateArgs(T->getDepth(), T->getIndex());
1467
1468 if (T->isParameterPack()) {
1469 assert(Arg.getKind() == TemplateArgument::Pack &&(static_cast <bool> (Arg.getKind() == TemplateArgument::
Pack && "Missing argument pack") ? void (0) : __assert_fail
("Arg.getKind() == TemplateArgument::Pack && \"Missing argument pack\""
, "/build/llvm-toolchain-snapshot-7~svn325118/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1470, __extension__ __PRETTY_FUNCTION__))
1470 "Missing argument pack")(static_cast <bool> (Arg.getKind() == TemplateArgument::
Pack && "Missing argument pack") ? void (0) : __assert_fail
("Arg.getKind() == TemplateArgument::Pack && \"Missing argument pack\""
, "/build/llvm-toolchain-snapshot-7~svn325118/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1470, __extension__ __PRETTY_FUNCTION__))
;
1471
1472 if (getSema().ArgumentPackSubstitutionIndex == -1) {
1473 // We have the template argument pack, but we're not expanding the
1474 // enclosing pack expansion yet. Just save the template argument
1475 // pack for later substitution.
1476 QualType Result
1477 = getSema().Context.getSubstTemplateTypeParmPackType(T, Arg);
1478 SubstTemplateTypeParmPackTypeLoc NewTL
1479 = TLB.push<SubstTemplateTypeParmPackTypeLoc>(Result);
1480 NewTL.setNameLoc(TL.getNameLoc());
1481 return Result;
1482 }
1483
1484 Arg = getPackSubstitutedTemplateArgument(getSema(), Arg);
1485 }
1486
1487 assert(Arg.getKind() == TemplateArgument::Type &&(static_cast <bool> (Arg.getKind() == TemplateArgument::
Type && "Template argument kind mismatch") ? void (0)
: __assert_fail ("Arg.getKind() == TemplateArgument::Type && \"Template argument kind mismatch\""
, "/build/llvm-toolchain-snapshot-7~svn325118/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1488, __extension__ __PRETTY_FUNCTION__))
1488 "Template argument kind mismatch")(static_cast <bool> (Arg.getKind() == TemplateArgument::
Type && "Template argument kind mismatch") ? void (0)
: __assert_fail ("Arg.getKind() == TemplateArgument::Type && \"Template argument kind mismatch\""
, "/build/llvm-toolchain-snapshot-7~svn325118/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1488, __extension__ __PRETTY_FUNCTION__))
;
1489
1490 QualType Replacement = Arg.getAsType();
1491
1492 // TODO: only do this uniquing once, at the start of instantiation.
1493 QualType Result
1494 = getSema().Context.getSubstTemplateTypeParmType(T, Replacement);
1495 SubstTemplateTypeParmTypeLoc NewTL
1496 = TLB.push<SubstTemplateTypeParmTypeLoc>(Result);
1497 NewTL.setNameLoc(TL.getNameLoc());
1498 return Result;
1499 }
1500
1501 // The template type parameter comes from an inner template (e.g.,
1502 // the template parameter list of a member template inside the
1503 // template we are instantiating). Create a new template type
1504 // parameter with the template "level" reduced by one.
1505 TemplateTypeParmDecl *NewTTPDecl = nullptr;
1506 if (TemplateTypeParmDecl *OldTTPDecl = T->getDecl())
1507 NewTTPDecl = cast_or_null<TemplateTypeParmDecl>(
1508 TransformDecl(TL.getNameLoc(), OldTTPDecl));
1509
1510 QualType Result = getSema().Context.getTemplateTypeParmType(
1511 T->getDepth() - TemplateArgs.getNumSubstitutedLevels(), T->getIndex(),
1512 T->isParameterPack(), NewTTPDecl);
1513 TemplateTypeParmTypeLoc NewTL = TLB.push<TemplateTypeParmTypeLoc>(Result);
1514 NewTL.setNameLoc(TL.getNameLoc());
1515 return Result;
1516}
1517
1518QualType
1519TemplateInstantiator::TransformSubstTemplateTypeParmPackType(
1520 TypeLocBuilder &TLB,
1521 SubstTemplateTypeParmPackTypeLoc TL) {
1522 if (getSema().ArgumentPackSubstitutionIndex == -1) {
1523 // We aren't expanding the parameter pack, so just return ourselves.
1524 SubstTemplateTypeParmPackTypeLoc NewTL
1525 = TLB.push<SubstTemplateTypeParmPackTypeLoc>(TL.getType());
1526 NewTL.setNameLoc(TL.getNameLoc());
1527 return TL.getType();
1528 }
1529
1530 TemplateArgument Arg = TL.getTypePtr()->getArgumentPack();
1531 Arg = getPackSubstitutedTemplateArgument(getSema(), Arg);
1532 QualType Result = Arg.getAsType();
1533
1534 Result = getSema().Context.getSubstTemplateTypeParmType(
1535 TL.getTypePtr()->getReplacedParameter(),
1536 Result);
1537 SubstTemplateTypeParmTypeLoc NewTL
1538 = TLB.push<SubstTemplateTypeParmTypeLoc>(Result);
1539 NewTL.setNameLoc(TL.getNameLoc());
1540 return Result;
1541}
1542
1543/// \brief Perform substitution on the type T with a given set of template
1544/// arguments.
1545///
1546/// This routine substitutes the given template arguments into the
1547/// type T and produces the instantiated type.
1548///
1549/// \param T the type into which the template arguments will be
1550/// substituted. If this type is not dependent, it will be returned
1551/// immediately.
1552///
1553/// \param Args the template arguments that will be
1554/// substituted for the top-level template parameters within T.
1555///
1556/// \param Loc the location in the source code where this substitution
1557/// is being performed. It will typically be the location of the
1558/// declarator (if we're instantiating the type of some declaration)
1559/// or the location of the type in the source code (if, e.g., we're
1560/// instantiating the type of a cast expression).
1561///
1562/// \param Entity the name of the entity associated with a declaration
1563/// being instantiated (if any). May be empty to indicate that there
1564/// is no such entity (if, e.g., this is a type that occurs as part of
1565/// a cast expression) or that the entity has no name (e.g., an
1566/// unnamed function parameter).
1567///
1568/// \param AllowDeducedTST Whether a DeducedTemplateSpecializationType is
1569/// acceptable as the top level type of the result.
1570///
1571/// \returns If the instantiation succeeds, the instantiated
1572/// type. Otherwise, produces diagnostics and returns a NULL type.
1573TypeSourceInfo *Sema::SubstType(TypeSourceInfo *T,
1574 const MultiLevelTemplateArgumentList &Args,
1575 SourceLocation Loc,
1576 DeclarationName Entity,
1577 bool AllowDeducedTST) {
1578 assert(!CodeSynthesisContexts.empty() &&(static_cast <bool> (!CodeSynthesisContexts.empty() &&
"Cannot perform an instantiation without some context on the "
"instantiation stack") ? void (0) : __assert_fail ("!CodeSynthesisContexts.empty() && \"Cannot perform an instantiation without some context on the \" \"instantiation stack\""
, "/build/llvm-toolchain-snapshot-7~svn325118/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1580, __extension__ __PRETTY_FUNCTION__))
1579 "Cannot perform an instantiation without some context on the "(static_cast <bool> (!CodeSynthesisContexts.empty() &&
"Cannot perform an instantiation without some context on the "
"instantiation stack") ? void (0) : __assert_fail ("!CodeSynthesisContexts.empty() && \"Cannot perform an instantiation without some context on the \" \"instantiation stack\""
, "/build/llvm-toolchain-snapshot-7~svn325118/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1580, __extension__ __PRETTY_FUNCTION__))
1580 "instantiation stack")(static_cast <bool> (!CodeSynthesisContexts.empty() &&
"Cannot perform an instantiation without some context on the "
"instantiation stack") ? void (0) : __assert_fail ("!CodeSynthesisContexts.empty() && \"Cannot perform an instantiation without some context on the \" \"instantiation stack\""
, "/build/llvm-toolchain-snapshot-7~svn325118/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1580, __extension__ __PRETTY_FUNCTION__))
;
1581
1582 if (!T->getType()->isInstantiationDependentType() &&
1583 !T->getType()->isVariablyModifiedType())
1584 return T;
1585
1586 TemplateInstantiator Instantiator(*this, Args, Loc, Entity);
1587 return AllowDeducedTST ? Instantiator.TransformTypeWithDeducedTST(T)
1588 : Instantiator.TransformType(T);
1589}
1590
1591TypeSourceInfo *Sema::SubstType(TypeLoc TL,
1592 const MultiLevelTemplateArgumentList &Args,
1593 SourceLocation Loc,
1594 DeclarationName Entity) {
1595 assert(!CodeSynthesisContexts.empty() &&(static_cast <bool> (!CodeSynthesisContexts.empty() &&
"Cannot perform an instantiation without some context on the "
"instantiation stack") ? void (0) : __assert_fail ("!CodeSynthesisContexts.empty() && \"Cannot perform an instantiation without some context on the \" \"instantiation stack\""
, "/build/llvm-toolchain-snapshot-7~svn325118/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1597, __extension__ __PRETTY_FUNCTION__))
1596 "Cannot perform an instantiation without some context on the "(static_cast <bool> (!CodeSynthesisContexts.empty() &&
"Cannot perform an instantiation without some context on the "
"instantiation stack") ? void (0) : __assert_fail ("!CodeSynthesisContexts.empty() && \"Cannot perform an instantiation without some context on the \" \"instantiation stack\""
, "/build/llvm-toolchain-snapshot-7~svn325118/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1597, __extension__ __PRETTY_FUNCTION__))
1597 "instantiation stack")(static_cast <bool> (!CodeSynthesisContexts.empty() &&
"Cannot perform an instantiation without some context on the "
"instantiation stack") ? void (0) : __assert_fail ("!CodeSynthesisContexts.empty() && \"Cannot perform an instantiation without some context on the \" \"instantiation stack\""
, "/build/llvm-toolchain-snapshot-7~svn325118/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1597, __extension__ __PRETTY_FUNCTION__))
;
1598
1599 if (TL.getType().isNull())
1600 return nullptr;
1601
1602 if (!TL.getType()->isInstantiationDependentType() &&
1603 !TL.getType()->isVariablyModifiedType()) {
1604 // FIXME: Make a copy of the TypeLoc data here, so that we can
1605 // return a new TypeSourceInfo. Inefficient!
1606 TypeLocBuilder TLB;
1607 TLB.pushFullCopy(TL);
1608 return TLB.getTypeSourceInfo(Context, TL.getType());
1609 }
1610
1611 TemplateInstantiator Instantiator(*this, Args, Loc, Entity);
1612 TypeLocBuilder TLB;
1613 TLB.reserve(TL.getFullDataSize());
1614 QualType Result = Instantiator.TransformType(TLB, TL);
1615 if (Result.isNull())
1616 return nullptr;
1617
1618 return TLB.getTypeSourceInfo(Context, Result);
1619}
1620
1621/// Deprecated form of the above.
1622QualType Sema::SubstType(QualType T,
1623 const MultiLevelTemplateArgumentList &TemplateArgs,
1624 SourceLocation Loc, DeclarationName Entity) {
1625 assert(!CodeSynthesisContexts.empty() &&(static_cast <bool> (!CodeSynthesisContexts.empty() &&
"Cannot perform an instantiation without some context on the "
"instantiation stack") ? void (0) : __assert_fail ("!CodeSynthesisContexts.empty() && \"Cannot perform an instantiation without some context on the \" \"instantiation stack\""
, "/build/llvm-toolchain-snapshot-7~svn325118/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1627, __extension__ __PRETTY_FUNCTION__))
1626 "Cannot perform an instantiation without some context on the "(static_cast <bool> (!CodeSynthesisContexts.empty() &&
"Cannot perform an instantiation without some context on the "
"instantiation stack") ? void (0) : __assert_fail ("!CodeSynthesisContexts.empty() && \"Cannot perform an instantiation without some context on the \" \"instantiation stack\""
, "/build/llvm-toolchain-snapshot-7~svn325118/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1627, __extension__ __PRETTY_FUNCTION__))
1627 "instantiation stack")(static_cast <bool> (!CodeSynthesisContexts.empty() &&
"Cannot perform an instantiation without some context on the "
"instantiation stack") ? void (0) : __assert_fail ("!CodeSynthesisContexts.empty() && \"Cannot perform an instantiation without some context on the \" \"instantiation stack\""
, "/build/llvm-toolchain-snapshot-7~svn325118/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1627, __extension__ __PRETTY_FUNCTION__))
;
1628
1629 // If T is not a dependent type or a variably-modified type, there
1630 // is nothing to do.
1631 if (!T->isInstantiationDependentType() && !T->isVariablyModifiedType())
1632 return T;
1633
1634 TemplateInstantiator Instantiator(*this, TemplateArgs, Loc, Entity);
1635 return Instantiator.TransformType(T);
1636}
1637
1638static bool NeedsInstantiationAsFunctionType(TypeSourceInfo *T) {
1639 if (T->getType()->isInstantiationDependentType() ||
1640 T->getType()->isVariablyModifiedType())
1641 return true;
1642
1643 TypeLoc TL = T->getTypeLoc().IgnoreParens();
1644 if (!TL.getAs<FunctionProtoTypeLoc>())
1645 return false;
1646
1647 FunctionProtoTypeLoc FP = TL.castAs<FunctionProtoTypeLoc>();
1648 for (ParmVarDecl *P : FP.getParams()) {
1649 // This must be synthesized from a typedef.
1650 if (!P) continue;
1651
1652 // If there are any parameters, a new TypeSourceInfo that refers to the
1653 // instantiated parameters must be built.
1654 return true;
1655 }
1656
1657 return false;
1658}
1659
1660/// A form of SubstType intended specifically for instantiating the
1661/// type of a FunctionDecl. Its purpose is solely to force the
1662/// instantiation of default-argument expressions and to avoid
1663/// instantiating an exception-specification.
1664TypeSourceInfo *Sema::SubstFunctionDeclType(TypeSourceInfo *T,
1665 const MultiLevelTemplateArgumentList &Args,
1666 SourceLocation Loc,
1667 DeclarationName Entity,
1668 CXXRecordDecl *ThisContext,
1669 unsigned ThisTypeQuals) {
1670 assert(!CodeSynthesisContexts.empty() &&(static_cast <bool> (!CodeSynthesisContexts.empty() &&
"Cannot perform an instantiation without some context on the "
"instantiation stack") ? void (0) : __assert_fail ("!CodeSynthesisContexts.empty() && \"Cannot perform an instantiation without some context on the \" \"instantiation stack\""
, "/build/llvm-toolchain-snapshot-7~svn325118/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1672, __extension__ __PRETTY_FUNCTION__))
1671 "Cannot perform an instantiation without some context on the "(static_cast <bool> (!CodeSynthesisContexts.empty() &&
"Cannot perform an instantiation without some context on the "
"instantiation stack") ? void (0) : __assert_fail ("!CodeSynthesisContexts.empty() && \"Cannot perform an instantiation without some context on the \" \"instantiation stack\""
, "/build/llvm-toolchain-snapshot-7~svn325118/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1672, __extension__ __PRETTY_FUNCTION__))
1672 "instantiation stack")(static_cast <bool> (!CodeSynthesisContexts.empty() &&
"Cannot perform an instantiation without some context on the "
"instantiation stack") ? void (0) : __assert_fail ("!CodeSynthesisContexts.empty() && \"Cannot perform an instantiation without some context on the \" \"instantiation stack\""
, "/build/llvm-toolchain-snapshot-7~svn325118/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1672, __extension__ __PRETTY_FUNCTION__))
;
1673
1674 if (!NeedsInstantiationAsFunctionType(T))
1675 return T;
1676
1677 TemplateInstantiator Instantiator(*this, Args, Loc, Entity);
1678
1679 TypeLocBuilder TLB;
1680
1681 TypeLoc TL = T->getTypeLoc();
1682 TLB.reserve(TL.getFullDataSize());
1683
1684 QualType Result;
1685
1686 if (FunctionProtoTypeLoc Proto =
1687 TL.IgnoreParens().getAs<FunctionProtoTypeLoc>()) {
1688 // Instantiate the type, other than its exception specification. The
1689 // exception specification is instantiated in InitFunctionInstantiation
1690 // once we've built the FunctionDecl.
1691 // FIXME: Set the exception specification to EST_Uninstantiated here,
1692 // instead of rebuilding the function type again later.
1693 Result = Instantiator.TransformFunctionProtoType(
1694 TLB, Proto, ThisContext, ThisTypeQuals,
1695 [](FunctionProtoType::ExceptionSpecInfo &ESI,
1696 bool &Changed) { return false; });
1697 } else {
1698 Result = Instantiator.TransformType(TLB, TL);
1699 }
1700 if (Result.isNull())
1701 return nullptr;
1702
1703 return TLB.getTypeSourceInfo(Context, Result);
1704}
1705
1706bool Sema::SubstExceptionSpec(SourceLocation Loc,
1707 FunctionProtoType::ExceptionSpecInfo &ESI,
1708 SmallVectorImpl<QualType> &ExceptionStorage,
1709 const MultiLevelTemplateArgumentList &Args) {
1710 assert(ESI.Type != EST_Uninstantiated)(static_cast <bool> (ESI.Type != EST_Uninstantiated) ? void
(0) : __assert_fail ("ESI.Type != EST_Uninstantiated", "/build/llvm-toolchain-snapshot-7~svn325118/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1710, __extension__ __PRETTY_FUNCTION__))
;
1711
1712 bool Changed = false;
1713 TemplateInstantiator Instantiator(*this, Args, Loc, DeclarationName());
1714 return Instantiator.TransformExceptionSpec(Loc, ESI, ExceptionStorage,
1715 Changed);
1716}
1717
1718void Sema::SubstExceptionSpec(FunctionDecl *New, const FunctionProtoType *Proto,
1719 const MultiLevelTemplateArgumentList &Args) {
1720 FunctionProtoType::ExceptionSpecInfo ESI =
1721 Proto->getExtProtoInfo().ExceptionSpec;
1722
1723 SmallVector<QualType, 4> ExceptionStorage;
1724 if (SubstExceptionSpec(New->getTypeSourceInfo()->getTypeLoc().getLocEnd(),
1725 ESI, ExceptionStorage, Args))
1726 // On error, recover by dropping the exception specification.
1727 ESI.Type = EST_None;
1728
1729 UpdateExceptionSpec(New, ESI);
1730}
1731
1732ParmVarDecl *Sema::SubstParmVarDecl(ParmVarDecl *OldParm,
1733 const MultiLevelTemplateArgumentList &TemplateArgs,
1734 int indexAdjustment,
1735 Optional<unsigned> NumExpansions,
1736 bool ExpectParameterPack) {
1737 TypeSourceInfo *OldDI = OldParm->getTypeSourceInfo();
1738 TypeSourceInfo *NewDI = nullptr;
1739
1740 TypeLoc OldTL = OldDI->getTypeLoc();
1741 if (PackExpansionTypeLoc ExpansionTL = OldTL.getAs<PackExpansionTypeLoc>()) {
1742
1743 // We have a function parameter pack. Substitute into the pattern of the
1744 // expansion.
1745 NewDI = SubstType(ExpansionTL.getPatternLoc(), TemplateArgs,
1746 OldParm->getLocation(), OldParm->getDeclName());
1747 if (!NewDI)
1748 return nullptr;
1749
1750 if (NewDI->getType()->containsUnexpandedParameterPack()) {
1751 // We still have unexpanded parameter packs, which means that
1752 // our function parameter is still a function parameter pack.
1753 // Therefore, make its type a pack expansion type.
1754 NewDI = CheckPackExpansion(NewDI, ExpansionTL.getEllipsisLoc(),
1755 NumExpansions);
1756 } else if (ExpectParameterPack) {
1757 // We expected to get a parameter pack but didn't (because the type
1758 // itself is not a pack expansion type), so complain. This can occur when
1759 // the substitution goes through an alias template that "loses" the
1760 // pack expansion.
1761 Diag(OldParm->getLocation(),
1762 diag::err_function_parameter_pack_without_parameter_packs)
1763 << NewDI->getType();
1764 return nullptr;
1765 }
1766 } else {
1767 NewDI = SubstType(OldDI, TemplateArgs, OldParm->getLocation(),
1768 OldParm->getDeclName());
1769 }
1770
1771 if (!NewDI)
1772 return nullptr;
1773
1774 if (NewDI->getType()->isVoidType()) {
1775 Diag(OldParm->getLocation(), diag::err_param_with_void_type);
1776 return nullptr;
1777 }
1778
1779 ParmVarDecl *NewParm = CheckParameter(Context.getTranslationUnitDecl(),
1780 OldParm->getInnerLocStart(),
1781 OldParm->getLocation(),
1782 OldParm->getIdentifier(),
1783 NewDI->getType(), NewDI,
1784 OldParm->getStorageClass());
1785 if (!NewParm)
1786 return nullptr;
1787
1788 // Mark the (new) default argument as uninstantiated (if any).
1789 if (OldParm->hasUninstantiatedDefaultArg()) {
1790 Expr *Arg = OldParm->getUninstantiatedDefaultArg();
1791 NewParm->setUninstantiatedDefaultArg(Arg);
1792 } else if (OldParm->hasUnparsedDefaultArg()) {
1793 NewParm->setUnparsedDefaultArg();
1794 UnparsedDefaultArgInstantiations[OldParm].push_back(NewParm);
1795 } else if (Expr *Arg = OldParm->getDefaultArg()) {
1796 FunctionDecl *OwningFunc = cast<FunctionDecl>(OldParm->getDeclContext());
1797 if (OwningFunc->isLexicallyWithinFunctionOrMethod()) {
1798 // Instantiate default arguments for methods of local classes (DR1484)
1799 // and non-defining declarations.
1800 Sema::ContextRAII SavedContext(*this, OwningFunc);
1801 LocalInstantiationScope Local(*this, true);
1802 ExprResult NewArg = SubstExpr(Arg, TemplateArgs);
1803 if (NewArg.isUsable()) {
1804 // It would be nice if we still had this.
1805 SourceLocation EqualLoc = NewArg.get()->getLocStart();
1806 SetParamDefaultArgument(NewParm, NewArg.get(), EqualLoc);
1807 }
1808 } else {
1809 // FIXME: if we non-lazily instantiated non-dependent default args for
1810 // non-dependent parameter types we could remove a bunch of duplicate
1811 // conversion warnings for such arguments.
1812 NewParm->setUninstantiatedDefaultArg(Arg);
1813 }
1814 }
1815
1816 NewParm->setHasInheritedDefaultArg(OldParm->hasInheritedDefaultArg());
1817
1818 if (OldParm->isParameterPack() && !NewParm->isParameterPack()) {
1819 // Add the new parameter to the instantiated parameter pack.
1820 CurrentInstantiationScope->InstantiatedLocalPackArg(OldParm, NewParm);
1821 } else {
1822 // Introduce an Old -> New mapping
1823 CurrentInstantiationScope->InstantiatedLocal(OldParm, NewParm);
1824 }
1825
1826 // FIXME: OldParm may come from a FunctionProtoType, in which case CurContext
1827 // can be anything, is this right ?
1828 NewParm->setDeclContext(CurContext);
1829
1830 NewParm->setScopeInfo(OldParm->getFunctionScopeDepth(),
1831 OldParm->getFunctionScopeIndex() + indexAdjustment);
1832
1833 InstantiateAttrs(TemplateArgs, OldParm, NewParm);
1834
1835 return NewParm;
1836}
1837
1838/// \brief Substitute the given template arguments into the given set of
1839/// parameters, producing the set of parameter types that would be generated
1840/// from such a substitution.
1841bool Sema::SubstParmTypes(
1842 SourceLocation Loc, ArrayRef<ParmVarDecl *> Params,
1843 const FunctionProtoType::ExtParameterInfo *ExtParamInfos,
1844 const MultiLevelTemplateArgumentList &TemplateArgs,
1845 SmallVectorImpl<QualType> &ParamTypes,
1846 SmallVectorImpl<ParmVarDecl *> *OutParams,
1847 ExtParameterInfoBuilder &ParamInfos) {
1848 assert(!CodeSynthesisContexts.empty() &&(static_cast <bool> (!CodeSynthesisContexts.empty() &&
"Cannot perform an instantiation without some context on the "
"instantiation stack") ? void (0) : __assert_fail ("!CodeSynthesisContexts.empty() && \"Cannot perform an instantiation without some context on the \" \"instantiation stack\""
, "/build/llvm-toolchain-snapshot-7~svn325118/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1850, __extension__ __PRETTY_FUNCTION__))
1849 "Cannot perform an instantiation without some context on the "(static_cast <bool> (!CodeSynthesisContexts.empty() &&
"Cannot perform an instantiation without some context on the "
"instantiation stack") ? void (0) : __assert_fail ("!CodeSynthesisContexts.empty() && \"Cannot perform an instantiation without some context on the \" \"instantiation stack\""
, "/build/llvm-toolchain-snapshot-7~svn325118/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1850, __extension__ __PRETTY_FUNCTION__))
1850 "instantiation stack")(static_cast <bool> (!CodeSynthesisContexts.empty() &&
"Cannot perform an instantiation without some context on the "
"instantiation stack") ? void (0) : __assert_fail ("!CodeSynthesisContexts.empty() && \"Cannot perform an instantiation without some context on the \" \"instantiation stack\""
, "/build/llvm-toolchain-snapshot-7~svn325118/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1850, __extension__ __PRETTY_FUNCTION__))
;
1851
1852 TemplateInstantiator Instantiator(*this, TemplateArgs, Loc,
1853 DeclarationName());
1854 return Instantiator.TransformFunctionTypeParams(
2
Calling 'TreeTransform::TransformFunctionTypeParams'
1855 Loc, Params, nullptr, ExtParamInfos, ParamTypes, OutParams, ParamInfos);
1
Passing null pointer value via 3rd parameter 'ParamTypes'
1856}
1857
1858/// \brief Perform substitution on the base class specifiers of the
1859/// given class template specialization.
1860///
1861/// Produces a diagnostic and returns true on error, returns false and
1862/// attaches the instantiated base classes to the class template
1863/// specialization if successful.
1864bool
1865Sema::SubstBaseSpecifiers(CXXRecordDecl *Instantiation,
1866 CXXRecordDecl *Pattern,
1867 const MultiLevelTemplateArgumentList &TemplateArgs) {
1868 bool Invalid = false;
1869 SmallVector<CXXBaseSpecifier*, 4> InstantiatedBases;
1870 for (const auto &Base : Pattern->bases()) {
1871 if (!Base.getType()->isDependentType()) {
1872 if (const CXXRecordDecl *RD = Base.getType()->getAsCXXRecordDecl()) {
1873 if (RD->isInvalidDecl())
1874 Instantiation->setInvalidDecl();
1875 }
1876 InstantiatedBases.push_back(new (Context) CXXBaseSpecifier(Base));
1877 continue;
1878 }
1879
1880 SourceLocation EllipsisLoc;
1881 TypeSourceInfo *BaseTypeLoc;
1882 if (Base.isPackExpansion()) {
1883 // This is a pack expansion. See whether we should expand it now, or
1884 // wait until later.
1885 SmallVector<UnexpandedParameterPack, 2> Unexpanded;
1886 collectUnexpandedParameterPacks(Base.getTypeSourceInfo()->getTypeLoc(),
1887 Unexpanded);
1888 bool ShouldExpand = false;
1889 bool RetainExpansion = false;
1890 Optional<unsigned> NumExpansions;
1891 if (CheckParameterPacksForExpansion(Base.getEllipsisLoc(),
1892 Base.getSourceRange(),
1893 Unexpanded,
1894 TemplateArgs, ShouldExpand,
1895 RetainExpansion,
1896 NumExpansions)) {
1897 Invalid = true;
1898 continue;
1899 }
1900
1901 // If we should expand this pack expansion now, do so.
1902 if (ShouldExpand) {
1903 for (unsigned I = 0; I != *NumExpansions; ++I) {
1904 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(*this, I);
1905
1906 TypeSourceInfo *BaseTypeLoc = SubstType(Base.getTypeSourceInfo(),
1907 TemplateArgs,
1908 Base.getSourceRange().getBegin(),
1909 DeclarationName());
1910 if (!BaseTypeLoc) {
1911 Invalid = true;
1912 continue;
1913 }
1914
1915 if (CXXBaseSpecifier *InstantiatedBase
1916 = CheckBaseSpecifier(Instantiation,
1917 Base.getSourceRange(),
1918 Base.isVirtual(),
1919 Base.getAccessSpecifierAsWritten(),
1920 BaseTypeLoc,
1921 SourceLocation()))
1922 InstantiatedBases.push_back(InstantiatedBase);
1923 else
1924 Invalid = true;
1925 }
1926
1927 continue;
1928 }
1929
1930 // The resulting base specifier will (still) be a pack expansion.
1931 EllipsisLoc = Base.getEllipsisLoc();
1932 Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(*this, -1);
1933 BaseTypeLoc = SubstType(Base.getTypeSourceInfo(),
1934 TemplateArgs,
1935 Base.getSourceRange().getBegin(),
1936 DeclarationName());
1937 } else {
1938 BaseTypeLoc = SubstType(Base.getTypeSourceInfo(),
1939 TemplateArgs,
1940 Base.getSourceRange().getBegin(),
1941 DeclarationName());
1942 }
1943
1944 if (!BaseTypeLoc) {
1945 Invalid = true;
1946 continue;
1947 }
1948
1949 if (CXXBaseSpecifier *InstantiatedBase
1950 = CheckBaseSpecifier(Instantiation,
1951 Base.getSourceRange(),
1952 Base.isVirtual(),
1953 Base.getAccessSpecifierAsWritten(),
1954 BaseTypeLoc,
1955 EllipsisLoc))
1956 InstantiatedBases.push_back(InstantiatedBase);
1957 else
1958 Invalid = true;
1959 }
1960
1961 if (!Invalid && AttachBaseSpecifiers(Instantiation, InstantiatedBases))
1962 Invalid = true;
1963
1964 return Invalid;
1965}
1966
1967// Defined via #include from SemaTemplateInstantiateDecl.cpp
1968namespace clang {
1969 namespace sema {
1970 Attr *instantiateTemplateAttribute(const Attr *At, ASTContext &C, Sema &S,
1971 const MultiLevelTemplateArgumentList &TemplateArgs);
1972 Attr *instantiateTemplateAttributeForDecl(
1973 const Attr *At, ASTContext &C, Sema &S,
1974 const MultiLevelTemplateArgumentList &TemplateArgs);
1975 }
1976}
1977
1978/// \brief Instantiate the definition of a class from a given pattern.
1979///
1980/// \param PointOfInstantiation The point of instantiation within the
1981/// source code.
1982///
1983/// \param Instantiation is the declaration whose definition is being
1984/// instantiated. This will be either a class template specialization
1985/// or a member class of a class template specialization.
1986///
1987/// \param Pattern is the pattern from which the instantiation
1988/// occurs. This will be either the declaration of a class template or
1989/// the declaration of a member class of a class template.
1990///
1991/// \param TemplateArgs The template arguments to be substituted into
1992/// the pattern.
1993///
1994/// \param TSK the kind of implicit or explicit instantiation to perform.
1995///
1996/// \param Complain whether to complain if the class cannot be instantiated due
1997/// to the lack of a definition.
1998///
1999/// \returns true if an error occurred, false otherwise.
2000bool
2001Sema::InstantiateClass(SourceLocation PointOfInstantiation,
2002 CXXRecordDecl *Instantiation, CXXRecordDecl *Pattern,
2003 const MultiLevelTemplateArgumentList &TemplateArgs,
2004 TemplateSpecializationKind TSK,
2005 bool Complain) {
2006 CXXRecordDecl *PatternDef
2007 = cast_or_null<CXXRecordDecl>(Pattern->getDefinition());
2008 if (DiagnoseUninstantiableTemplate(PointOfInstantiation, Instantiation,
2009 Instantiation->getInstantiatedFromMemberClass(),
2010 Pattern, PatternDef, TSK, Complain))
2011 return true;
2012 Pattern = PatternDef;
2013
2014 // \brief Record the point of instantiation.
2015 if (MemberSpecializationInfo *MSInfo
2016 = Instantiation->getMemberSpecializationInfo()) {
2017 MSInfo->setTemplateSpecializationKind(TSK);
2018 MSInfo->setPointOfInstantiation(PointOfInstantiation);
2019 } else if (ClassTemplateSpecializationDecl *Spec
2020 = dyn_cast<ClassTemplateSpecializationDecl>(Instantiation)) {
2021 Spec->setTemplateSpecializationKind(TSK);
2022 Spec->setPointOfInstantiation(PointOfInstantiation);
2023 }
2024
2025 InstantiatingTemplate Inst(*this, PointOfInstantiation, Instantiation);
2026 if (Inst.isInvalid())
2027 return true;
2028 assert(!Inst.isAlreadyInstantiating() && "should have been caught by caller")(static_cast <bool> (!Inst.isAlreadyInstantiating() &&
"should have been caught by caller") ? void (0) : __assert_fail
("!Inst.isAlreadyInstantiating() && \"should have been caught by caller\""
, "/build/llvm-toolchain-snapshot-7~svn325118/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2028, __extension__ __PRETTY_FUNCTION__))
;
2029 PrettyDeclStackTraceEntry CrashInfo(*this, Instantiation, SourceLocation(),
2030 "instantiating class definition");
2031
2032 // Enter the scope of this instantiation. We don't use
2033 // PushDeclContext because we don't have a scope.
2034 ContextRAII SavedContext(*this, Instantiation);
2035 EnterExpressionEvaluationContext EvalContext(
2036 *this, Sema::ExpressionEvaluationContext::PotentiallyEvaluated);
2037
2038 // If this is an instantiation of a local class, merge this local
2039 // instantiation scope with the enclosing scope. Otherwise, every
2040 // instantiation of a class has its own local instantiation scope.
2041 bool MergeWithParentScope = !Instantiation->isDefinedOutsideFunctionOrMethod();
2042 LocalInstantiationScope Scope(*this, MergeWithParentScope);
2043
2044 // Some class state isn't processed immediately but delayed till class
2045 // instantiation completes. We may not be ready to handle any delayed state
2046 // already on the stack as it might correspond to a different class, so save
2047 // it now and put it back later.
2048 SavePendingParsedClassStateRAII SavedPendingParsedClassState(*this);
2049
2050 // Pull attributes from the pattern onto the instantiation.
2051 InstantiateAttrs(TemplateArgs, Pattern, Instantiation);
2052
2053 // Start the definition of this instantiation.
2054 Instantiation->startDefinition();
2055
2056 // The instantiation is visible here, even if it was first declared in an
2057 // unimported module.
2058 Instantiation->setVisibleDespiteOwningModule();
2059
2060 // FIXME: This loses the as-written tag kind for an explicit instantiation.
2061 Instantiation->setTagKind(Pattern->getTagKind());
2062
2063 // Do substitution on the base class specifiers.
2064 if (SubstBaseSpecifiers(Instantiation, Pattern, TemplateArgs))
2065 Instantiation->setInvalidDecl();
2066
2067 TemplateDeclInstantiator Instantiator(*this, Instantiation, TemplateArgs);
2068 SmallVector<Decl*, 4> Fields;
2069 // Delay instantiation of late parsed attributes.
2070 LateInstantiatedAttrVec LateAttrs;
2071 Instantiator.enableLateAttributeInstantiation(&LateAttrs);
2072
2073 for (auto *Member : Pattern->decls()) {
2074 // Don't instantiate members not belonging in this semantic context.
2075 // e.g. for:
2076 // @code
2077 // template <int i> class A {
2078 // class B *g;
2079 // };
2080 // @endcode
2081 // 'class B' has the template as lexical context but semantically it is
2082 // introduced in namespace scope.
2083 if (Member->getDeclContext() != Pattern)
2084 continue;
2085
2086 if (Member->isInvalidDecl()) {
2087 Instantiation->setInvalidDecl();
2088 continue;
2089 }
2090
2091 Decl *NewMember = Instantiator.Visit(Member);
2092 if (NewMember) {
2093 if (FieldDecl *Field = dyn_cast<FieldDecl>(NewMember)) {
2094 Fields.push_back(Field);
2095 } else if (EnumDecl *Enum = dyn_cast<EnumDecl>(NewMember)) {
2096 // C++11 [temp.inst]p1: The implicit instantiation of a class template
2097 // specialization causes the implicit instantiation of the definitions
2098 // of unscoped member enumerations.
2099 // Record a point of instantiation for this implicit instantiation.
2100 if (TSK == TSK_ImplicitInstantiation && !Enum->isScoped() &&
2101 Enum->isCompleteDefinition()) {
2102 MemberSpecializationInfo *MSInfo =Enum->getMemberSpecializationInfo();
2103 assert(MSInfo && "no spec info for member enum specialization")(static_cast <bool> (MSInfo && "no spec info for member enum specialization"
) ? void (0) : __assert_fail ("MSInfo && \"no spec info for member enum specialization\""
, "/build/llvm-toolchain-snapshot-7~svn325118/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2103, __extension__ __PRETTY_FUNCTION__))
;
2104 MSInfo->setTemplateSpecializationKind(TSK_ImplicitInstantiation);
2105 MSInfo->setPointOfInstantiation(PointOfInstantiation);
2106 }
2107 } else if (StaticAssertDecl *SA = dyn_cast<StaticAssertDecl>(NewMember)) {
2108 if (SA->isFailed()) {
2109 // A static_assert failed. Bail out; instantiating this
2110 // class is probably not meaningful.
2111 Instantiation->setInvalidDecl();
2112 break;
2113 }
2114 }
2115
2116 if (NewMember->isInvalidDecl())
2117 Instantiation->setInvalidDecl();
2118 } else {
2119 // FIXME: Eventually, a NULL return will mean that one of the
2120 // instantiations was a semantic disaster, and we'll want to mark the
2121 // declaration invalid.
2122 // For now, we expect to skip some members that we can't yet handle.
2123 }
2124 }
2125
2126 // See if trivial_abi has to be dropped.
2127 if (Instantiation && Instantiation->hasAttr<TrivialABIAttr>())
2128 checkIllFormedTrivialABIStruct(*Instantiation);
2129
2130 // Finish checking fields.
2131 ActOnFields(nullptr, Instantiation->getLocation(), Instantiation, Fields,
2132 SourceLocation(), SourceLocation(), nullptr);
2133 CheckCompletedCXXClass(Instantiation);
2134
2135 // Default arguments are parsed, if not instantiated. We can go instantiate
2136 // default arg exprs for default constructors if necessary now.
2137 ActOnFinishCXXNonNestedClass(Instantiation);
2138
2139 // Instantiate late parsed attributes, and attach them to their decls.
2140 // See Sema::InstantiateAttrs
2141 for (LateInstantiatedAttrVec::iterator I = LateAttrs.begin(),
2142 E = LateAttrs.end(); I != E; ++I) {
2143 assert(CurrentInstantiationScope == Instantiator.getStartingScope())(static_cast <bool> (CurrentInstantiationScope == Instantiator
.getStartingScope()) ? void (0) : __assert_fail ("CurrentInstantiationScope == Instantiator.getStartingScope()"
, "/build/llvm-toolchain-snapshot-7~svn325118/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2143, __extension__ __PRETTY_FUNCTION__))
;
2144 CurrentInstantiationScope = I->Scope;
2145
2146 // Allow 'this' within late-parsed attributes.
2147 NamedDecl *ND = dyn_cast<NamedDecl>(I->NewDecl);
2148 CXXRecordDecl *ThisContext =
2149 dyn_cast_or_null<CXXRecordDecl>(ND->getDeclContext());
2150 CXXThisScopeRAII ThisScope(*this, ThisContext, /*TypeQuals*/0,
2151 ND && ND->isCXXInstanceMember());
2152
2153 Attr *NewAttr =
2154 instantiateTemplateAttribute(I->TmplAttr, Context, *this, TemplateArgs);
2155 I->NewDecl->addAttr(NewAttr);
2156 LocalInstantiationScope::deleteScopes(I->Scope,
2157 Instantiator.getStartingScope());
2158 }
2159 Instantiator.disableLateAttributeInstantiation();
2160 LateAttrs.clear();
2161
2162 ActOnFinishDelayedMemberInitializers(Instantiation);
2163
2164 // FIXME: We should do something similar for explicit instantiations so they
2165 // end up in the right module.
2166 if (TSK == TSK_ImplicitInstantiation) {
2167 Instantiation->setLocation(Pattern->getLocation());
2168 Instantiation->setLocStart(Pattern->getInnerLocStart());
2169 Instantiation->setBraceRange(Pattern->getBraceRange());
2170 }
2171
2172 if (!Instantiation->isInvalidDecl()) {
2173 // Perform any dependent diagnostics from the pattern.
2174 PerformDependentDiagnostics(Pattern, TemplateArgs);
2175
2176 // Instantiate any out-of-line class template partial
2177 // specializations now.
2178 for (TemplateDeclInstantiator::delayed_partial_spec_iterator
2179 P = Instantiator.delayed_partial_spec_begin(),
2180 PEnd = Instantiator.delayed_partial_spec_end();
2181 P != PEnd; ++P) {
2182 if (!Instantiator.InstantiateClassTemplatePartialSpecialization(
2183 P->first, P->second)) {
2184 Instantiation->setInvalidDecl();
2185 break;
2186 }
2187 }
2188
2189 // Instantiate any out-of-line variable template partial
2190 // specializations now.
2191 for (TemplateDeclInstantiator::delayed_var_partial_spec_iterator
2192 P = Instantiator.delayed_var_partial_spec_begin(),
2193 PEnd = Instantiator.delayed_var_partial_spec_end();
2194 P != PEnd; ++P) {
2195 if (!Instantiator.InstantiateVarTemplatePartialSpecialization(
2196 P->first, P->second)) {
2197 Instantiation->setInvalidDecl();
2198 break;
2199 }
2200 }
2201 }
2202
2203 // Exit the scope of this instantiation.
2204 SavedContext.pop();
2205
2206 if (!Instantiation->isInvalidDecl()) {
2207 Consumer.HandleTagDeclDefinition(Instantiation);
2208
2209 // Always emit the vtable for an explicit instantiation definition
2210 // of a polymorphic class template specialization.
2211 if (TSK == TSK_ExplicitInstantiationDefinition)
2212 MarkVTableUsed(PointOfInstantiation, Instantiation, true);
2213 }
2214
2215 return Instantiation->isInvalidDecl();
2216}
2217
2218/// \brief Instantiate the definition of an enum from a given pattern.
2219///
2220/// \param PointOfInstantiation The point of instantiation within the
2221/// source code.
2222/// \param Instantiation is the declaration whose definition is being
2223/// instantiated. This will be a member enumeration of a class
2224/// temploid specialization, or a local enumeration within a
2225/// function temploid specialization.
2226/// \param Pattern The templated declaration from which the instantiation
2227/// occurs.
2228/// \param TemplateArgs The template arguments to be substituted into
2229/// the pattern.
2230/// \param TSK The kind of implicit or explicit instantiation to perform.
2231///
2232/// \return \c true if an error occurred, \c false otherwise.
2233bool Sema::InstantiateEnum(SourceLocation PointOfInstantiation,
2234 EnumDecl *Instantiation, EnumDecl *Pattern,
2235 const MultiLevelTemplateArgumentList &TemplateArgs,
2236 TemplateSpecializationKind TSK) {
2237 EnumDecl *PatternDef = Pattern->getDefinition();
2238 if (DiagnoseUninstantiableTemplate(PointOfInstantiation, Instantiation,
2239 Instantiation->getInstantiatedFromMemberEnum(),
2240 Pattern, PatternDef, TSK,/*Complain*/true))
2241 return true;
2242 Pattern = PatternDef;
2243
2244 // Record the point of instantiation.
2245 if (MemberSpecializationInfo *MSInfo
2246 = Instantiation->getMemberSpecializationInfo()) {
2247 MSInfo->setTemplateSpecializationKind(TSK);
2248 MSInfo->setPointOfInstantiation(PointOfInstantiation);
2249 }
2250
2251 InstantiatingTemplate Inst(*this, PointOfInstantiation, Instantiation);
2252 if (Inst.isInvalid())
2253 return true;
2254 if (Inst.isAlreadyInstantiating())
2255 return false;
2256 PrettyDeclStackTraceEntry CrashInfo(*this, Instantiation, SourceLocation(),
2257 "instantiating enum definition");
2258
2259 // The instantiation is visible here, even if it was first declared in an
2260 // unimported module.
2261 Instantiation->setVisibleDespiteOwningModule();
2262
2263 // Enter the scope of this instantiation. We don't use
2264 // PushDeclContext because we don't have a scope.
2265 ContextRAII SavedContext(*this, Instantiation);
2266 EnterExpressionEvaluationContext EvalContext(
2267 *this, Sema::ExpressionEvaluationContext::PotentiallyEvaluated);
2268
2269 LocalInstantiationScope Scope(*this, /*MergeWithParentScope*/true);
2270
2271 // Pull attributes from the pattern onto the instantiation.
2272 InstantiateAttrs(TemplateArgs, Pattern, Instantiation);
2273
2274 TemplateDeclInstantiator Instantiator(*this, Instantiation, TemplateArgs);
2275 Instantiator.InstantiateEnumDefinition(Instantiation, Pattern);
2276
2277 // Exit the scope of this instantiation.
2278 SavedContext.pop();
2279
2280 return Instantiation->isInvalidDecl();
2281}
2282
2283
2284/// \brief Instantiate the definition of a field from the given pattern.
2285///
2286/// \param PointOfInstantiation The point of instantiation within the
2287/// source code.
2288/// \param Instantiation is the declaration whose definition is being
2289/// instantiated. This will be a class of a class temploid
2290/// specialization, or a local enumeration within a function temploid
2291/// specialization.
2292/// \param Pattern The templated declaration from which the instantiation
2293/// occurs.
2294/// \param TemplateArgs The template arguments to be substituted into
2295/// the pattern.
2296///
2297/// \return \c true if an error occurred, \c false otherwise.
2298bool Sema::InstantiateInClassInitializer(
2299 SourceLocation PointOfInstantiation, FieldDecl *Instantiation,
2300 FieldDecl *Pattern, const MultiLevelTemplateArgumentList &TemplateArgs) {
2301 // If there is no initializer, we don't need to do anything.
2302 if (!Pattern->hasInClassInitializer())
2303 return false;
2304
2305 assert(Instantiation->getInClassInitStyle() ==(static_cast <bool> (Instantiation->getInClassInitStyle
() == Pattern->getInClassInitStyle() && "pattern and instantiation disagree about init style"
) ? void (0) : __assert_fail ("Instantiation->getInClassInitStyle() == Pattern->getInClassInitStyle() && \"pattern and instantiation disagree about init style\""
, "/build/llvm-toolchain-snapshot-7~svn325118/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2307, __extension__ __PRETTY_FUNCTION__))
2306 Pattern->getInClassInitStyle() &&(static_cast <bool> (Instantiation->getInClassInitStyle
() == Pattern->getInClassInitStyle() && "pattern and instantiation disagree about init style"
) ? void (0) : __assert_fail ("Instantiation->getInClassInitStyle() == Pattern->getInClassInitStyle() && \"pattern and instantiation disagree about init style\""
, "/build/llvm-toolchain-snapshot-7~svn325118/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2307, __extension__ __PRETTY_FUNCTION__))
2307 "pattern and instantiation disagree about init style")(static_cast <bool> (Instantiation->getInClassInitStyle
() == Pattern->getInClassInitStyle() && "pattern and instantiation disagree about init style"
) ? void (0) : __assert_fail ("Instantiation->getInClassInitStyle() == Pattern->getInClassInitStyle() && \"pattern and instantiation disagree about init style\""
, "/build/llvm-toolchain-snapshot-7~svn325118/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2307, __extension__ __PRETTY_FUNCTION__))
;
2308
2309 // Error out if we haven't parsed the initializer of the pattern yet because
2310 // we are waiting for the closing brace of the outer class.
2311 Expr *OldInit = Pattern->getInClassInitializer();
2312 if (!OldInit) {
2313 RecordDecl *PatternRD = Pattern->getParent();
2314 RecordDecl *OutermostClass = PatternRD->getOuterLexicalRecordContext();
2315 Diag(PointOfInstantiation,
2316 diag::err_in_class_initializer_not_yet_parsed)
2317 << OutermostClass << Pattern;
2318 Diag(Pattern->getLocEnd(), diag::note_in_class_initializer_not_yet_parsed);
2319 Instantiation->setInvalidDecl();
2320 return true;
2321 }
2322
2323 InstantiatingTemplate Inst(*this, PointOfInstantiation, Instantiation);
2324 if (Inst.isInvalid())
2325 return true;
2326 if (Inst.isAlreadyInstantiating()) {
2327 // Error out if we hit an instantiation cycle for this initializer.
2328 Diag(PointOfInstantiation, diag::err_in_class_initializer_cycle)
2329 << Instantiation;
2330 return true;
2331 }
2332 PrettyDeclStackTraceEntry CrashInfo(*this, Instantiation, SourceLocation(),
2333 "instantiating default member init");
2334
2335 // Enter the scope of this instantiation. We don't use PushDeclContext because
2336 // we don't have a scope.
2337 ContextRAII SavedContext(*this, Instantiation->getParent());
2338 EnterExpressionEvaluationContext EvalContext(
2339 *this, Sema::ExpressionEvaluationContext::PotentiallyEvaluated);
2340
2341 LocalInstantiationScope Scope(*this, true);
2342
2343 // Instantiate the initializer.
2344 ActOnStartCXXInClassMemberInitializer();
2345 CXXThisScopeRAII ThisScope(*this, Instantiation->getParent(), /*TypeQuals=*/0);
2346
2347 ExprResult NewInit = SubstInitializer(OldInit, TemplateArgs,
2348 /*CXXDirectInit=*/false);
2349 Expr *Init = NewInit.get();
2350 assert((!Init || !isa<ParenListExpr>(Init)) && "call-style init in class")(static_cast <bool> ((!Init || !isa<ParenListExpr>
(Init)) && "call-style init in class") ? void (0) : __assert_fail
("(!Init || !isa<ParenListExpr>(Init)) && \"call-style init in class\""
, "/build/llvm-toolchain-snapshot-7~svn325118/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2350, __extension__ __PRETTY_FUNCTION__))
;
2351 ActOnFinishCXXInClassMemberInitializer(
2352 Instantiation, Init ? Init->getLocStart() : SourceLocation(), Init);
2353
2354 if (auto *L = getASTMutationListener())
2355 L->DefaultMemberInitializerInstantiated(Instantiation);
2356
2357 // Return true if the in-class initializer is still missing.
2358 return !Instantiation->getInClassInitializer();
2359}
2360
2361namespace {
2362 /// \brief A partial specialization whose template arguments have matched
2363 /// a given template-id.
2364 struct PartialSpecMatchResult {
2365 ClassTemplatePartialSpecializationDecl *Partial;
2366 TemplateArgumentList *Args;
2367 };
2368}
2369
2370bool Sema::usesPartialOrExplicitSpecialization(
2371 SourceLocation Loc, ClassTemplateSpecializationDecl *ClassTemplateSpec) {
2372 if (ClassTemplateSpec->getTemplateSpecializationKind() ==
2373 TSK_ExplicitSpecialization)
2374 return true;
2375
2376 SmallVector<ClassTemplatePartialSpecializationDecl *, 4> PartialSpecs;
2377 ClassTemplateSpec->getSpecializedTemplate()
2378 ->getPartialSpecializations(PartialSpecs);
2379 for (unsigned I = 0, N = PartialSpecs.size(); I != N; ++I) {
2380 TemplateDeductionInfo Info(Loc);
2381 if (!DeduceTemplateArguments(PartialSpecs[I],
2382 ClassTemplateSpec->getTemplateArgs(), Info))
2383 return true;
2384 }
2385
2386 return false;
2387}
2388
2389/// Get the instantiation pattern to use to instantiate the definition of a
2390/// given ClassTemplateSpecializationDecl (either the pattern of the primary
2391/// template or of a partial specialization).
2392static CXXRecordDecl *
2393getPatternForClassTemplateSpecialization(
2394 Sema &S, SourceLocation PointOfInstantiation,
2395 ClassTemplateSpecializationDecl *ClassTemplateSpec,
2396 TemplateSpecializationKind TSK, bool Complain) {
2397 Sema::InstantiatingTemplate Inst(S, PointOfInstantiation, ClassTemplateSpec);
2398 if (Inst.isInvalid() || Inst.isAlreadyInstantiating())
2399 return nullptr;
2400
2401 ClassTemplateDecl *Template = ClassTemplateSpec->getSpecializedTemplate();
2402 CXXRecordDecl *Pattern = nullptr;
2403
2404 // C++ [temp.class.spec.match]p1:
2405 // When a class template is used in a context that requires an
2406 // instantiation of the class, it is necessary to determine
2407 // whether the instantiation is to be generated using the primary
2408 // template or one of the partial specializations. This is done by
2409 // matching the template arguments of the class template
2410 // specialization with the template argument lists of the partial
2411 // specializations.
2412 typedef PartialSpecMatchResult MatchResult;
2413 SmallVector<MatchResult, 4> Matched;
2414 SmallVector<ClassTemplatePartialSpecializationDecl *, 4> PartialSpecs;
2415 Template->getPartialSpecializations(PartialSpecs);
2416 TemplateSpecCandidateSet FailedCandidates(PointOfInstantiation);
2417 for (unsigned I = 0, N = PartialSpecs.size(); I != N; ++I) {
2418 ClassTemplatePartialSpecializationDecl *Partial = PartialSpecs[I];
2419 TemplateDeductionInfo Info(FailedCandidates.getLocation());
2420 if (Sema::TemplateDeductionResult Result = S.DeduceTemplateArguments(
2421 Partial, ClassTemplateSpec->getTemplateArgs(), Info)) {
2422 // Store the failed-deduction information for use in diagnostics, later.
2423 // TODO: Actually use the failed-deduction info?
2424 FailedCandidates.addCandidate().set(
2425 DeclAccessPair::make(Template, AS_public), Partial,
2426 MakeDeductionFailureInfo(S.Context, Result, Info));
2427 (void)Result;
2428 } else {
2429 Matched.push_back(PartialSpecMatchResult());
2430 Matched.back().Partial = Partial;
2431 Matched.back().Args = Info.take();
2432 }
2433 }
2434
2435 // If we're dealing with a member template where the template parameters
2436 // have been instantiated, this provides the original template parameters
2437 // from which the member template's parameters were instantiated.
2438
2439 if (Matched.size() >= 1) {
2440 SmallVectorImpl<MatchResult>::iterator Best = Matched.begin();
2441 if (Matched.size() == 1) {
2442 // -- If exactly one matching specialization is found, the
2443 // instantiation is generated from that specialization.
2444 // We don't need to do anything for this.
2445 } else {
2446 // -- If more than one matching specialization is found, the
2447 // partial order rules (14.5.4.2) are used to determine
2448 // whether one of the specializations is more specialized
2449 // than the others. If none of the specializations is more
2450 // specialized than all of the other matching
2451 // specializations, then the use of the class template is
2452 // ambiguous and the program is ill-formed.
2453 for (SmallVectorImpl<MatchResult>::iterator P = Best + 1,
2454 PEnd = Matched.end();
2455 P != PEnd; ++P) {
2456 if (S.getMoreSpecializedPartialSpecialization(
2457 P->Partial, Best->Partial, PointOfInstantiation) == P->Partial)
2458 Best = P;
2459 }
2460
2461 // Determine if the best partial specialization is more specialized than
2462 // the others.
2463 bool Ambiguous = false;
2464 for (SmallVectorImpl<MatchResult>::iterator P = Matched.begin(),
2465 PEnd = Matched.end();
2466 P != PEnd; ++P) {
2467 if (P != Best &&
2468 S.getMoreSpecializedPartialSpecialization(P->Partial, Best->Partial,
2469 PointOfInstantiation) !=
2470 Best->Partial) {
2471 Ambiguous = true;
2472 break;
2473 }
2474 }
2475
2476 if (Ambiguous) {
2477 // Partial ordering did not produce a clear winner. Complain.
2478 Inst.Clear();
2479 ClassTemplateSpec->setInvalidDecl();
2480 S.Diag(PointOfInstantiation, diag::err_partial_spec_ordering_ambiguous)
2481 << ClassTemplateSpec;
2482
2483 // Print the matching partial specializations.
2484 for (SmallVectorImpl<MatchResult>::iterator P = Matched.begin(),
2485 PEnd = Matched.end();
2486 P != PEnd; ++P)
2487 S.Diag(P->Partial->getLocation(), diag::note_partial_spec_match)
2488 << S.getTemplateArgumentBindingsText(
2489 P->Partial->getTemplateParameters(), *P->Args);
2490
2491 return nullptr;
2492 }
2493 }
2494
2495 // Instantiate using the best class template partial specialization.
2496 ClassTemplatePartialSpecializationDecl *OrigPartialSpec = Best->Partial;
2497 while (OrigPartialSpec->getInstantiatedFromMember()) {
2498 // If we've found an explicit specialization of this class template,
2499 // stop here and use that as the pattern.
2500 if (OrigPartialSpec->isMemberSpecialization())
2501 break;
2502
2503 OrigPartialSpec = OrigPartialSpec->getInstantiatedFromMember();
2504 }
2505
2506 Pattern = OrigPartialSpec;
2507 ClassTemplateSpec->setInstantiationOf(Best->Partial, Best->Args);
2508 } else {
2509 // -- If no matches are found, the instantiation is generated
2510 // from the primary template.
2511 ClassTemplateDecl *OrigTemplate = Template;
2512 while (OrigTemplate->getInstantiatedFromMemberTemplate()) {
2513 // If we've found an explicit specialization of this class template,
2514 // stop here and use that as the pattern.
2515 if (OrigTemplate->isMemberSpecialization())
2516 break;
2517
2518 OrigTemplate = OrigTemplate->getInstantiatedFromMemberTemplate();
2519 }
2520
2521 Pattern = OrigTemplate->getTemplatedDecl();
2522 }
2523
2524 return Pattern;
2525}
2526
2527bool Sema::InstantiateClassTemplateSpecialization(
2528 SourceLocation PointOfInstantiation,
2529 ClassTemplateSpecializationDecl *ClassTemplateSpec,
2530 TemplateSpecializationKind TSK, bool Complain) {
2531 // Perform the actual instantiation on the canonical declaration.
2532 ClassTemplateSpec = cast<ClassTemplateSpecializationDecl>(
2533 ClassTemplateSpec->getCanonicalDecl());
2534 if (ClassTemplateSpec->isInvalidDecl())
2535 return true;
2536
2537 CXXRecordDecl *Pattern = getPatternForClassTemplateSpecialization(
2538 *this, PointOfInstantiation, ClassTemplateSpec, TSK, Complain);
2539 if (!Pattern)
2540 return true;
2541
2542 return InstantiateClass(PointOfInstantiation, ClassTemplateSpec, Pattern,
2543 getTemplateInstantiationArgs(ClassTemplateSpec), TSK,
2544 Complain);
2545}
2546
2547/// \brief Instantiates the definitions of all of the member
2548/// of the given class, which is an instantiation of a class template
2549/// or a member class of a template.
2550void
2551Sema::InstantiateClassMembers(SourceLocation PointOfInstantiation,
2552 CXXRecordDecl *Instantiation,
2553 const MultiLevelTemplateArgumentList &TemplateArgs,
2554 TemplateSpecializationKind TSK) {
2555 // FIXME: We need to notify the ASTMutationListener that we did all of these
2556 // things, in case we have an explicit instantiation definition in a PCM, a
2557 // module, or preamble, and the declaration is in an imported AST.
2558 assert((static_cast <bool> ((TSK == TSK_ExplicitInstantiationDefinition
|| TSK == TSK_ExplicitInstantiationDeclaration || (TSK == TSK_ImplicitInstantiation
&& Instantiation->isLocalClass())) && "Unexpected template specialization kind!"
) ? void (0) : __assert_fail ("(TSK == TSK_ExplicitInstantiationDefinition || TSK == TSK_ExplicitInstantiationDeclaration || (TSK == TSK_ImplicitInstantiation && Instantiation->isLocalClass())) && \"Unexpected template specialization kind!\""
, "/build/llvm-toolchain-snapshot-7~svn325118/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2562, __extension__ __PRETTY_FUNCTION__))
2559 (TSK == TSK_ExplicitInstantiationDefinition ||(static_cast <bool> ((TSK == TSK_ExplicitInstantiationDefinition
|| TSK == TSK_ExplicitInstantiationDeclaration || (TSK == TSK_ImplicitInstantiation
&& Instantiation->isLocalClass())) && "Unexpected template specialization kind!"
) ? void (0) : __assert_fail ("(TSK == TSK_ExplicitInstantiationDefinition || TSK == TSK_ExplicitInstantiationDeclaration || (TSK == TSK_ImplicitInstantiation && Instantiation->isLocalClass())) && \"Unexpected template specialization kind!\""
, "/build/llvm-toolchain-snapshot-7~svn325118/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2562, __extension__ __PRETTY_FUNCTION__))
2560 TSK == TSK_ExplicitInstantiationDeclaration ||(static_cast <bool> ((TSK == TSK_ExplicitInstantiationDefinition
|| TSK == TSK_ExplicitInstantiationDeclaration || (TSK == TSK_ImplicitInstantiation
&& Instantiation->isLocalClass())) && "Unexpected template specialization kind!"
) ? void (0) : __assert_fail ("(TSK == TSK_ExplicitInstantiationDefinition || TSK == TSK_ExplicitInstantiationDeclaration || (TSK == TSK_ImplicitInstantiation && Instantiation->isLocalClass())) && \"Unexpected template specialization kind!\""
, "/build/llvm-toolchain-snapshot-7~svn325118/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2562, __extension__ __PRETTY_FUNCTION__))
2561 (TSK == TSK_ImplicitInstantiation && Instantiation->isLocalClass())) &&(static_cast <bool> ((TSK == TSK_ExplicitInstantiationDefinition
|| TSK == TSK_ExplicitInstantiationDeclaration || (TSK == TSK_ImplicitInstantiation
&& Instantiation->isLocalClass())) && "Unexpected template specialization kind!"
) ? void (0) : __assert_fail ("(TSK == TSK_ExplicitInstantiationDefinition || TSK == TSK_ExplicitInstantiationDeclaration || (TSK == TSK_ImplicitInstantiation && Instantiation->isLocalClass())) && \"Unexpected template specialization kind!\""
, "/build/llvm-toolchain-snapshot-7~svn325118/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2562, __extension__ __PRETTY_FUNCTION__))
2562 "Unexpected template specialization kind!")(static_cast <bool> ((TSK == TSK_ExplicitInstantiationDefinition
|| TSK == TSK_ExplicitInstantiationDeclaration || (TSK == TSK_ImplicitInstantiation
&& Instantiation->isLocalClass())) && "Unexpected template specialization kind!"
) ? void (0) : __assert_fail ("(TSK == TSK_ExplicitInstantiationDefinition || TSK == TSK_ExplicitInstantiationDeclaration || (TSK == TSK_ImplicitInstantiation && Instantiation->isLocalClass())) && \"Unexpected template specialization kind!\""
, "/build/llvm-toolchain-snapshot-7~svn325118/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2562, __extension__ __PRETTY_FUNCTION__))
;
2563 for (auto *D : Instantiation->decls()) {
2564 bool SuppressNew = false;
2565 if (auto *Function = dyn_cast<FunctionDecl>(D)) {
2566 if (FunctionDecl *Pattern
2567 = Function->getInstantiatedFromMemberFunction()) {
2568 MemberSpecializationInfo *MSInfo
2569 = Function->getMemberSpecializationInfo();
2570 assert(MSInfo && "No member specialization information?")(static_cast <bool> (MSInfo && "No member specialization information?"
) ? void (0) : __assert_fail ("MSInfo && \"No member specialization information?\""
, "/build/llvm-toolchain-snapshot-7~svn325118/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2570, __extension__ __PRETTY_FUNCTION__))
;
2571 if (MSInfo->getTemplateSpecializationKind()
2572 == TSK_ExplicitSpecialization)
2573 continue;
2574
2575 if (CheckSpecializationInstantiationRedecl(PointOfInstantiation, TSK,
2576 Function,
2577 MSInfo->getTemplateSpecializationKind(),
2578 MSInfo->getPointOfInstantiation(),
2579 SuppressNew) ||
2580 SuppressNew)
2581 continue;
2582
2583 // C++11 [temp.explicit]p8:
2584 // An explicit instantiation definition that names a class template
2585 // specialization explicitly instantiates the class template
2586 // specialization and is only an explicit instantiation definition
2587 // of members whose definition is visible at the point of
2588 // instantiation.
2589 if (TSK == TSK_ExplicitInstantiationDefinition && !Pattern->isDefined())
2590 continue;
2591
2592 Function->setTemplateSpecializationKind(TSK, PointOfInstantiation);
2593
2594 if (Function->isDefined()) {
2595 // Let the ASTConsumer know that this function has been explicitly
2596 // instantiated now, and its linkage might have changed.
2597 Consumer.HandleTopLevelDecl(DeclGroupRef(Function));
2598 } else if (TSK == TSK_ExplicitInstantiationDefinition) {
2599 InstantiateFunctionDefinition(PointOfInstantiation, Function);
2600 } else if (TSK == TSK_ImplicitInstantiation) {
2601 PendingLocalImplicitInstantiations.push_back(
2602 std::make_pair(Function, PointOfInstantiation));
2603 }
2604 }
2605 } else if (auto *Var = dyn_cast<VarDecl>(D)) {
2606 if (isa<VarTemplateSpecializationDecl>(Var))
2607 continue;
2608
2609 if (Var->isStaticDataMember()) {
2610 MemberSpecializationInfo *MSInfo = Var->getMemberSpecializationInfo();
2611 assert(MSInfo && "No member specialization information?")(static_cast <bool> (MSInfo && "No member specialization information?"
) ? void (0) : __assert_fail ("MSInfo && \"No member specialization information?\""
, "/build/llvm-toolchain-snapshot-7~svn325118/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2611, __extension__ __PRETTY_FUNCTION__))
;
2612 if (MSInfo->getTemplateSpecializationKind()
2613 == TSK_ExplicitSpecialization)
2614 continue;
2615
2616 if (CheckSpecializationInstantiationRedecl(PointOfInstantiation, TSK,
2617 Var,
2618 MSInfo->getTemplateSpecializationKind(),
2619 MSInfo->getPointOfInstantiation(),
2620 SuppressNew) ||
2621 SuppressNew)
2622 continue;
2623
2624 if (TSK == TSK_ExplicitInstantiationDefinition) {
2625 // C++0x [temp.explicit]p8:
2626 // An explicit instantiation definition that names a class template
2627 // specialization explicitly instantiates the class template
2628 // specialization and is only an explicit instantiation definition
2629 // of members whose definition is visible at the point of
2630 // instantiation.
2631 if (!Var->getInstantiatedFromStaticDataMember()->getDefinition())
2632 continue;
2633
2634 Var->setTemplateSpecializationKind(TSK, PointOfInstantiation);
2635 InstantiateVariableDefinition(PointOfInstantiation, Var);
2636 } else {
2637 Var->setTemplateSpecializationKind(TSK, PointOfInstantiation);
2638 }
2639 }
2640 } else if (auto *Record = dyn_cast<CXXRecordDecl>(D)) {
2641 // Always skip the injected-class-name, along with any
2642 // redeclarations of nested classes, since both would cause us
2643 // to try to instantiate the members of a class twice.
2644 // Skip closure types; they'll get instantiated when we instantiate
2645 // the corresponding lambda-expression.
2646 if (Record->isInjectedClassName() || Record->getPreviousDecl() ||
2647 Record->isLambda())
2648 continue;
2649
2650 MemberSpecializationInfo *MSInfo = Record->getMemberSpecializationInfo();
2651 assert(MSInfo && "No member specialization information?")(static_cast <bool> (MSInfo && "No member specialization information?"
) ? void (0) : __assert_fail ("MSInfo && \"No member specialization information?\""
, "/build/llvm-toolchain-snapshot-7~svn325118/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2651, __extension__ __PRETTY_FUNCTION__))
;
2652
2653 if (MSInfo->getTemplateSpecializationKind()
2654 == TSK_ExplicitSpecialization)
2655 continue;
2656
2657 if ((Context.getTargetInfo().getCXXABI().isMicrosoft() ||
2658 Context.getTargetInfo().getTriple().isWindowsItaniumEnvironment()) &&
2659 TSK == TSK_ExplicitInstantiationDeclaration) {
2660 // In MSVC and Windows Itanium mode, explicit instantiation decl of the
2661 // outer class doesn't affect the inner class.
2662 continue;
2663 }
2664
2665 if (CheckSpecializationInstantiationRedecl(PointOfInstantiation, TSK,
2666 Record,
2667 MSInfo->getTemplateSpecializationKind(),
2668 MSInfo->getPointOfInstantiation(),
2669 SuppressNew) ||
2670 SuppressNew)
2671 continue;
2672
2673 CXXRecordDecl *Pattern = Record->getInstantiatedFromMemberClass();
2674 assert(Pattern && "Missing instantiated-from-template information")(static_cast <bool> (Pattern && "Missing instantiated-from-template information"
) ? void (0) : __assert_fail ("Pattern && \"Missing instantiated-from-template information\""
, "/build/llvm-toolchain-snapshot-7~svn325118/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2674, __extension__ __PRETTY_FUNCTION__))
;
2675
2676 if (!Record->getDefinition()) {
2677 if (!Pattern->getDefinition()) {
2678 // C++0x [temp.explicit]p8:
2679 // An explicit instantiation definition that names a class template
2680 // specialization explicitly instantiates the class template
2681 // specialization and is only an explicit instantiation definition
2682 // of members whose definition is visible at the point of
2683 // instantiation.
2684 if (TSK == TSK_ExplicitInstantiationDeclaration) {
2685 MSInfo->setTemplateSpecializationKind(TSK);
2686 MSInfo->setPointOfInstantiation(PointOfInstantiation);
2687 }
2688
2689 continue;
2690 }
2691
2692 InstantiateClass(PointOfInstantiation, Record, Pattern,
2693 TemplateArgs,
2694 TSK);
2695 } else {
2696 if (TSK == TSK_ExplicitInstantiationDefinition &&
2697 Record->getTemplateSpecializationKind() ==
2698 TSK_ExplicitInstantiationDeclaration) {
2699 Record->setTemplateSpecializationKind(TSK);
2700 MarkVTableUsed(PointOfInstantiation, Record, true);
2701 }
2702 }
2703
2704 Pattern = cast_or_null<CXXRecordDecl>(Record->getDefinition());
2705 if (Pattern)
2706 InstantiateClassMembers(PointOfInstantiation, Pattern, TemplateArgs,
2707 TSK);
2708 } else if (auto *Enum = dyn_cast<EnumDecl>(D)) {
2709 MemberSpecializationInfo *MSInfo = Enum->getMemberSpecializationInfo();
2710 assert(MSInfo && "No member specialization information?")(static_cast <bool> (MSInfo && "No member specialization information?"
) ? void (0) : __assert_fail ("MSInfo && \"No member specialization information?\""
, "/build/llvm-toolchain-snapshot-7~svn325118/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2710, __extension__ __PRETTY_FUNCTION__))
;
2711
2712 if (MSInfo->getTemplateSpecializationKind()
2713 == TSK_ExplicitSpecialization)
2714 continue;
2715
2716 if (CheckSpecializationInstantiationRedecl(
2717 PointOfInstantiation, TSK, Enum,
2718 MSInfo->getTemplateSpecializationKind(),
2719 MSInfo->getPointOfInstantiation(), SuppressNew) ||
2720 SuppressNew)
2721 continue;
2722
2723 if (Enum->getDefinition())
2724 continue;
2725
2726 EnumDecl *Pattern = Enum->getTemplateInstantiationPattern();
2727 assert(Pattern && "Missing instantiated-from-template information")(static_cast <bool> (Pattern && "Missing instantiated-from-template information"
) ? void (0) : __assert_fail ("Pattern && \"Missing instantiated-from-template information\""
, "/build/llvm-toolchain-snapshot-7~svn325118/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2727, __extension__ __PRETTY_FUNCTION__))
;
2728
2729 if (TSK == TSK_ExplicitInstantiationDefinition) {
2730 if (!Pattern->getDefinition())
2731 continue;
2732
2733 InstantiateEnum(PointOfInstantiation, Enum, Pattern, TemplateArgs, TSK);
2734 } else {
2735 MSInfo->setTemplateSpecializationKind(TSK);
2736 MSInfo->setPointOfInstantiation(PointOfInstantiation);
2737 }
2738 } else if (auto *Field = dyn_cast<FieldDecl>(D)) {
2739 // No need to instantiate in-class initializers during explicit
2740 // instantiation.
2741 if (Field->hasInClassInitializer() && TSK == TSK_ImplicitInstantiation) {
2742 CXXRecordDecl *ClassPattern =
2743 Instantiation->getTemplateInstantiationPattern();
2744 DeclContext::lookup_result Lookup =
2745 ClassPattern->lookup(Field->getDeclName());
2746 FieldDecl *Pattern = cast<FieldDecl>(Lookup.front());
2747 InstantiateInClassInitializer(PointOfInstantiation, Field, Pattern,
2748 TemplateArgs);
2749 }
2750 }
2751 }
2752}
2753
2754/// \brief Instantiate the definitions of all of the members of the
2755/// given class template specialization, which was named as part of an
2756/// explicit instantiation.
2757void
2758Sema::InstantiateClassTemplateSpecializationMembers(
2759 SourceLocation PointOfInstantiation,
2760 ClassTemplateSpecializationDecl *ClassTemplateSpec,
2761 TemplateSpecializationKind TSK) {
2762 // C++0x [temp.explicit]p7:
2763 // An explicit instantiation that names a class template
2764 // specialization is an explicit instantion of the same kind
2765 // (declaration or definition) of each of its members (not
2766 // including members inherited from base classes) that has not
2767 // been previously explicitly specialized in the translation unit
2768 // containing the explicit instantiation, except as described
2769 // below.
2770 InstantiateClassMembers(PointOfInstantiation, ClassTemplateSpec,
2771 getTemplateInstantiationArgs(ClassTemplateSpec),
2772 TSK);
2773}
2774
2775StmtResult
2776Sema::SubstStmt(Stmt *S, const MultiLevelTemplateArgumentList &TemplateArgs) {
2777 if (!S)
2778 return S;
2779
2780 TemplateInstantiator Instantiator(*this, TemplateArgs,
2781 SourceLocation(),
2782 DeclarationName());
2783 return Instantiator.TransformStmt(S);
2784}
2785
2786ExprResult
2787Sema::SubstExpr(Expr *E, const MultiLevelTemplateArgumentList &TemplateArgs) {
2788 if (!E)
2789 return E;
2790
2791 TemplateInstantiator Instantiator(*this, TemplateArgs,
2792 SourceLocation(),
2793 DeclarationName());
2794 return Instantiator.TransformExpr(E);
2795}
2796
2797ExprResult Sema::SubstInitializer(Expr *Init,
2798 const MultiLevelTemplateArgumentList &TemplateArgs,
2799 bool CXXDirectInit) {
2800 TemplateInstantiator Instantiator(*this, TemplateArgs,
2801 SourceLocation(),
2802 DeclarationName());
2803 return Instantiator.TransformInitializer(Init, CXXDirectInit);
2804}
2805
2806bool Sema::SubstExprs(ArrayRef<Expr *> Exprs, bool IsCall,
2807 const MultiLevelTemplateArgumentList &TemplateArgs,
2808 SmallVectorImpl<Expr *> &Outputs) {
2809 if (Exprs.empty())
2810 return false;
2811
2812 TemplateInstantiator Instantiator(*this, TemplateArgs,
2813 SourceLocation(),
2814 DeclarationName());
2815 return Instantiator.TransformExprs(Exprs.data(), Exprs.size(),
2816 IsCall, Outputs);
2817}
2818
2819NestedNameSpecifierLoc
2820Sema::SubstNestedNameSpecifierLoc(NestedNameSpecifierLoc NNS,
2821 const MultiLevelTemplateArgumentList &TemplateArgs) {
2822 if (!NNS)
2823 return NestedNameSpecifierLoc();
2824
2825 TemplateInstantiator Instantiator(*this, TemplateArgs, NNS.getBeginLoc(),
2826 DeclarationName());
2827 return Instantiator.TransformNestedNameSpecifierLoc(NNS);
2828}
2829
2830/// \brief Do template substitution on declaration name info.
2831DeclarationNameInfo
2832Sema::SubstDeclarationNameInfo(const DeclarationNameInfo &NameInfo,
2833 const MultiLevelTemplateArgumentList &TemplateArgs) {
2834 TemplateInstantiator Instantiator(*this, TemplateArgs, NameInfo.getLoc(),
2835 NameInfo.getName());
2836 return Instantiator.TransformDeclarationNameInfo(NameInfo);
2837}
2838
2839TemplateName
2840Sema::SubstTemplateName(NestedNameSpecifierLoc QualifierLoc,
2841 TemplateName Name, SourceLocation Loc,
2842 const MultiLevelTemplateArgumentList &TemplateArgs) {
2843 TemplateInstantiator Instantiator(*this, TemplateArgs, Loc,
2844 DeclarationName());
2845 CXXScopeSpec SS;
2846 SS.Adopt(QualifierLoc);
2847 return Instantiator.TransformTemplateName(SS, Name, Loc);
2848}
2849
2850bool Sema::Subst(const TemplateArgumentLoc *Args, unsigned NumArgs,
2851 TemplateArgumentListInfo &Result,
2852 const MultiLevelTemplateArgumentList &TemplateArgs) {
2853 TemplateInstantiator Instantiator(*this, TemplateArgs, SourceLocation(),
2854 DeclarationName());
2855
2856 return Instantiator.TransformTemplateArguments(Args, NumArgs, Result);
2857}
2858
2859static const Decl *getCanonicalParmVarDecl(const Decl *D) {
2860 // When storing ParmVarDecls in the local instantiation scope, we always
2861 // want to use the ParmVarDecl from the canonical function declaration,
2862 // since the map is then valid for any redeclaration or definition of that
2863 // function.
2864 if (const ParmVarDecl *PV = dyn_cast<ParmVarDecl>(D)) {
2865 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(PV->getDeclContext())) {
2866 unsigned i = PV->getFunctionScopeIndex();
2867 // This parameter might be from a freestanding function type within the
2868 // function and isn't necessarily referring to one of FD's parameters.
2869 if (FD->getParamDecl(i) == PV)
2870 return FD->getCanonicalDecl()->getParamDecl(i);
2871 }
2872 }
2873 return D;
2874}
2875
2876
2877llvm::PointerUnion<Decl *, LocalInstantiationScope::DeclArgumentPack *> *
2878LocalInstantiationScope::findInstantiationOf(const Decl *D) {
2879 D = getCanonicalParmVarDecl(D);
2880 for (LocalInstantiationScope *Current = this; Current;
2881 Current = Current->Outer) {
2882
2883 // Check if we found something within this scope.
2884 const Decl *CheckD = D;
2885 do {
2886 LocalDeclsMap::iterator Found = Current->LocalDecls.find(CheckD);
2887 if (Found != Current->LocalDecls.end())
2888 return &Found->second;
2889
2890 // If this is a tag declaration, it's possible that we need to look for
2891 // a previous declaration.
2892 if (const TagDecl *Tag = dyn_cast<TagDecl>(CheckD))
2893 CheckD = Tag->getPreviousDecl();
2894 else
2895 CheckD = nullptr;
2896 } while (CheckD);
2897
2898 // If we aren't combined with our outer scope, we're done.
2899 if (!Current->CombineWithOuterScope)
2900 break;
2901 }
2902
2903 // If we're performing a partial substitution during template argument
2904 // deduction, we may not have values for template parameters yet.
2905 if (isa<NonTypeTemplateParmDecl>(D) || isa<TemplateTypeParmDecl>(D) ||
2906 isa<TemplateTemplateParmDecl>(D))
2907 return nullptr;
2908
2909 // Local types referenced prior to definition may require instantiation.
2910 if (const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(D))
2911 if (RD->isLocalClass())
2912 return nullptr;
2913
2914 // Enumeration types referenced prior to definition may appear as a result of
2915 // error recovery.
2916 if (isa<EnumDecl>(D))
2917 return nullptr;
2918
2919 // If we didn't find the decl, then we either have a sema bug, or we have a
2920 // forward reference to a label declaration. Return null to indicate that
2921 // we have an uninstantiated label.
2922 assert(isa<LabelDecl>(D) && "declaration not instantiated in this scope")(static_cast <bool> (isa<LabelDecl>(D) &&
"declaration not instantiated in this scope") ? void (0) : __assert_fail
("isa<LabelDecl>(D) && \"declaration not instantiated in this scope\""
, "/build/llvm-toolchain-snapshot-7~svn325118/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2922, __extension__ __PRETTY_FUNCTION__))
;
2923 return nullptr;
2924}
2925
2926void LocalInstantiationScope::InstantiatedLocal(const Decl *D, Decl *Inst) {
2927 D = getCanonicalParmVarDecl(D);
2928 llvm::PointerUnion<Decl *, DeclArgumentPack *> &Stored = LocalDecls[D];
2929 if (Stored.isNull()) {
2930#ifndef NDEBUG
2931 // It should not be present in any surrounding scope either.
2932 LocalInstantiationScope *Current = this;
2933 while (Current->CombineWithOuterScope && Current->Outer) {
2934 Current = Current->Outer;
2935 assert(Current->LocalDecls.find(D) == Current->LocalDecls.end() &&(static_cast <bool> (Current->LocalDecls.find(D) == Current
->LocalDecls.end() && "Instantiated local in inner and outer scopes"
) ? void (0) : __assert_fail ("Current->LocalDecls.find(D) == Current->LocalDecls.end() && \"Instantiated local in inner and outer scopes\""
, "/build/llvm-toolchain-snapshot-7~svn325118/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2936, __extension__ __PRETTY_FUNCTION__))
2936 "Instantiated local in inner and outer scopes")(static_cast <bool> (Current->LocalDecls.find(D) == Current
->LocalDecls.end() && "Instantiated local in inner and outer scopes"
) ? void (0) : __assert_fail ("Current->LocalDecls.find(D) == Current->LocalDecls.end() && \"Instantiated local in inner and outer scopes\""
, "/build/llvm-toolchain-snapshot-7~svn325118/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2936, __extension__ __PRETTY_FUNCTION__))
;
2937 }
2938#endif
2939 Stored = Inst;
2940 } else if (DeclArgumentPack *Pack = Stored.dyn_cast<DeclArgumentPack *>()) {
2941 Pack->push_back(cast<ParmVarDecl>(Inst));
2942 } else {
2943 assert(Stored.get<Decl *>() == Inst && "Already instantiated this local")(static_cast <bool> (Stored.get<Decl *>() == Inst
&& "Already instantiated this local") ? void (0) : __assert_fail
("Stored.get<Decl *>() == Inst && \"Already instantiated this local\""
, "/build/llvm-toolchain-snapshot-7~svn325118/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2943, __extension__ __PRETTY_FUNCTION__))
;
2944 }
2945}
2946
2947void LocalInstantiationScope::InstantiatedLocalPackArg(const Decl *D,
2948 ParmVarDecl *Inst) {
2949 D = getCanonicalParmVarDecl(D);
2950 DeclArgumentPack *Pack = LocalDecls[D].get<DeclArgumentPack *>();
2951 Pack->push_back(Inst);
2952}
2953
2954void LocalInstantiationScope::MakeInstantiatedLocalArgPack(const Decl *D) {
2955#ifndef NDEBUG
2956 // This should be the first time we've been told about this decl.
2957 for (LocalInstantiationScope *Current = this;
2958 Current && Current->CombineWithOuterScope; Current = Current->Outer)
2959 assert(Current->LocalDecls.find(D) == Current->LocalDecls.end() &&(static_cast <bool> (Current->LocalDecls.find(D) == Current
->LocalDecls.end() && "Creating local pack after instantiation of local"
) ? void (0) : __assert_fail ("Current->LocalDecls.find(D) == Current->LocalDecls.end() && \"Creating local pack after instantiation of local\""
, "/build/llvm-toolchain-snapshot-7~svn325118/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2960, __extension__ __PRETTY_FUNCTION__))
2960 "Creating local pack after instantiation of local")(static_cast <bool> (Current->LocalDecls.find(D) == Current
->LocalDecls.end() && "Creating local pack after instantiation of local"
) ? void (0) : __assert_fail ("Current->LocalDecls.find(D) == Current->LocalDecls.end() && \"Creating local pack after instantiation of local\""
, "/build/llvm-toolchain-snapshot-7~svn325118/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2960, __extension__ __PRETTY_FUNCTION__))
;
2961#endif
2962
2963 D = getCanonicalParmVarDecl(D);
2964 llvm::PointerUnion<Decl *, DeclArgumentPack *> &Stored = LocalDecls[D];
2965 DeclArgumentPack *Pack = new DeclArgumentPack;
2966 Stored = Pack;
2967 ArgumentPacks.push_back(Pack);
2968}
2969
2970void LocalInstantiationScope::SetPartiallySubstitutedPack(NamedDecl *Pack,
2971 const TemplateArgument *ExplicitArgs,
2972 unsigned NumExplicitArgs) {
2973 assert((!PartiallySubstitutedPack || PartiallySubstitutedPack == Pack) &&(static_cast <bool> ((!PartiallySubstitutedPack || PartiallySubstitutedPack
== Pack) && "Already have a partially-substituted pack"
) ? void (0) : __assert_fail ("(!PartiallySubstitutedPack || PartiallySubstitutedPack == Pack) && \"Already have a partially-substituted pack\""
, "/build/llvm-toolchain-snapshot-7~svn325118/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2974, __extension__ __PRETTY_FUNCTION__))
2974 "Already have a partially-substituted pack")(static_cast <bool> ((!PartiallySubstitutedPack || PartiallySubstitutedPack
== Pack) && "Already have a partially-substituted pack"
) ? void (0) : __assert_fail ("(!PartiallySubstitutedPack || PartiallySubstitutedPack == Pack) && \"Already have a partially-substituted pack\""
, "/build/llvm-toolchain-snapshot-7~svn325118/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2974, __extension__ __PRETTY_FUNCTION__))
;
2975 assert((!PartiallySubstitutedPack(static_cast <bool> ((!PartiallySubstitutedPack || NumArgsInPartiallySubstitutedPack
== NumExplicitArgs) && "Wrong number of arguments in partially-substituted pack"
) ? void (0) : __assert_fail ("(!PartiallySubstitutedPack || NumArgsInPartiallySubstitutedPack == NumExplicitArgs) && \"Wrong number of arguments in partially-substituted pack\""
, "/build/llvm-toolchain-snapshot-7~svn325118/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2977, __extension__ __PRETTY_FUNCTION__))
2976 || NumArgsInPartiallySubstitutedPack == NumExplicitArgs) &&(static_cast <bool> ((!PartiallySubstitutedPack || NumArgsInPartiallySubstitutedPack
== NumExplicitArgs) && "Wrong number of arguments in partially-substituted pack"
) ? void (0) : __assert_fail ("(!PartiallySubstitutedPack || NumArgsInPartiallySubstitutedPack == NumExplicitArgs) && \"Wrong number of arguments in partially-substituted pack\""
, "/build/llvm-toolchain-snapshot-7~svn325118/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2977, __extension__ __PRETTY_FUNCTION__))
2977 "Wrong number of arguments in partially-substituted pack")(static_cast <bool> ((!PartiallySubstitutedPack || NumArgsInPartiallySubstitutedPack
== NumExplicitArgs) && "Wrong number of arguments in partially-substituted pack"
) ? void (0) : __assert_fail ("(!PartiallySubstitutedPack || NumArgsInPartiallySubstitutedPack == NumExplicitArgs) && \"Wrong number of arguments in partially-substituted pack\""
, "/build/llvm-toolchain-snapshot-7~svn325118/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2977, __extension__ __PRETTY_FUNCTION__))
;
2978 PartiallySubstitutedPack = Pack;
2979 ArgsInPartiallySubstitutedPack = ExplicitArgs;
2980 NumArgsInPartiallySubstitutedPack = NumExplicitArgs;
2981}
2982
2983NamedDecl *LocalInstantiationScope::getPartiallySubstitutedPack(
2984 const TemplateArgument **ExplicitArgs,
2985 unsigned *NumExplicitArgs) const {
2986 if (ExplicitArgs)
2987 *ExplicitArgs = nullptr;
2988 if (NumExplicitArgs)
2989 *NumExplicitArgs = 0;
2990
2991 for (const LocalInstantiationScope *Current = this; Current;
2992 Current = Current->Outer) {
2993 if (Current->PartiallySubstitutedPack) {
2994 if (ExplicitArgs)
2995 *ExplicitArgs = Current->ArgsInPartiallySubstitutedPack;
2996 if (NumExplicitArgs)
2997 *NumExplicitArgs = Current->NumArgsInPartiallySubstitutedPack;
2998
2999 return Current->PartiallySubstitutedPack;
3000 }
3001
3002 if (!Current->CombineWithOuterScope)
3003 break;
3004 }
3005
3006 return nullptr;
3007}

/build/llvm-toolchain-snapshot-7~svn325118/tools/clang/lib/Sema/TreeTransform.h

1//===------- TreeTransform.h - Semantic Tree Transformation -----*- C++ -*-===//
2//
3// The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//===----------------------------------------------------------------------===//
8//
9// This file implements a semantic tree transformation that takes a given
10// AST and rebuilds it, possibly transforming some nodes in the process.
11//
12//===----------------------------------------------------------------------===//
13
14#ifndef LLVM_CLANG_LIB_SEMA_TREETRANSFORM_H
15#define LLVM_CLANG_LIB_SEMA_TREETRANSFORM_H
16
17#include "CoroutineStmtBuilder.h"
18#include "TypeLocBuilder.h"
19#include "clang/AST/Decl.h"
20#include "clang/AST/DeclObjC.h"
21#include "clang/AST/DeclTemplate.h"
22#include "clang/AST/Expr.h"
23#include "clang/AST/ExprCXX.h"
24#include "clang/AST/ExprObjC.h"
25#include "clang/AST/ExprOpenMP.h"
26#include "clang/AST/Stmt.h"
27#include "clang/AST/StmtCXX.h"
28#include "clang/AST/StmtObjC.h"
29#include "clang/AST/StmtOpenMP.h"
30#include "clang/Sema/Designator.h"
31#include "clang/Sema/Lookup.h"
32#include "clang/Sema/Ownership.h"
33#include "clang/Sema/ParsedTemplate.h"
34#include "clang/Sema/ScopeInfo.h"
35#include "clang/Sema/SemaDiagnostic.h"
36#include "clang/Sema/SemaInternal.h"
37#include "llvm/ADT/ArrayRef.h"
38#include "llvm/Support/ErrorHandling.h"
39#include <algorithm>
40
41namespace clang {
42using namespace sema;
43
44/// \brief A semantic tree transformation that allows one to transform one
45/// abstract syntax tree into another.
46///
47/// A new tree transformation is defined by creating a new subclass \c X of
48/// \c TreeTransform<X> and then overriding certain operations to provide
49/// behavior specific to that transformation. For example, template
50/// instantiation is implemented as a tree transformation where the
51/// transformation of TemplateTypeParmType nodes involves substituting the
52/// template arguments for their corresponding template parameters; a similar
53/// transformation is performed for non-type template parameters and
54/// template template parameters.
55///
56/// This tree-transformation template uses static polymorphism to allow
57/// subclasses to customize any of its operations. Thus, a subclass can
58/// override any of the transformation or rebuild operators by providing an
59/// operation with the same signature as the default implementation. The
60/// overridding function should not be virtual.
61///
62/// Semantic tree transformations are split into two stages, either of which
63/// can be replaced by a subclass. The "transform" step transforms an AST node
64/// or the parts of an AST node using the various transformation functions,
65/// then passes the pieces on to the "rebuild" step, which constructs a new AST
66/// node of the appropriate kind from the pieces. The default transformation
67/// routines recursively transform the operands to composite AST nodes (e.g.,
68/// the pointee type of a PointerType node) and, if any of those operand nodes
69/// were changed by the transformation, invokes the rebuild operation to create
70/// a new AST node.
71///
72/// Subclasses can customize the transformation at various levels. The
73/// most coarse-grained transformations involve replacing TransformType(),
74/// TransformExpr(), TransformDecl(), TransformNestedNameSpecifierLoc(),
75/// TransformTemplateName(), or TransformTemplateArgument() with entirely
76/// new implementations.
77///
78/// For more fine-grained transformations, subclasses can replace any of the
79/// \c TransformXXX functions (where XXX is the name of an AST node, e.g.,
80/// PointerType, StmtExpr) to alter the transformation. As mentioned previously,
81/// replacing TransformTemplateTypeParmType() allows template instantiation
82/// to substitute template arguments for their corresponding template
83/// parameters. Additionally, subclasses can override the \c RebuildXXX
84/// functions to control how AST nodes are rebuilt when their operands change.
85/// By default, \c TreeTransform will invoke semantic analysis to rebuild
86/// AST nodes. However, certain other tree transformations (e.g, cloning) may
87/// be able to use more efficient rebuild steps.
88///
89/// There are a handful of other functions that can be overridden, allowing one
90/// to avoid traversing nodes that don't need any transformation
91/// (\c AlreadyTransformed()), force rebuilding AST nodes even when their
92/// operands have not changed (\c AlwaysRebuild()), and customize the
93/// default locations and entity names used for type-checking
94/// (\c getBaseLocation(), \c getBaseEntity()).
95template<typename Derived>
96class TreeTransform {
97 /// \brief Private RAII object that helps us forget and then re-remember
98 /// the template argument corresponding to a partially-substituted parameter
99 /// pack.
100 class ForgetPartiallySubstitutedPackRAII {
101 Derived &Self;
102 TemplateArgument Old;
103
104 public:
105 ForgetPartiallySubstitutedPackRAII(Derived &Self) : Self(Self) {
106 Old = Self.ForgetPartiallySubstitutedPack();
107 }
108
109 ~ForgetPartiallySubstitutedPackRAII() {
110 Self.RememberPartiallySubstitutedPack(Old);
111 }
112 };
113
114protected:
115 Sema &SemaRef;
116
117 /// \brief The set of local declarations that have been transformed, for
118 /// cases where we are forced to build new declarations within the transformer
119 /// rather than in the subclass (e.g., lambda closure types).
120 llvm::DenseMap<Decl *, Decl *> TransformedLocalDecls;
121
122public:
123 /// \brief Initializes a new tree transformer.
124 TreeTransform(Sema &SemaRef) : SemaRef(SemaRef) { }
125
126 /// \brief Retrieves a reference to the derived class.
127 Derived &getDerived() { return static_cast<Derived&>(*this); }
128
129 /// \brief Retrieves a reference to the derived class.
130 const Derived &getDerived() const {
131 return static_cast<const Derived&>(*this);
132 }
133
134 static inline ExprResult Owned(Expr *E) { return E; }
135 static inline StmtResult Owned(Stmt *S) { return S; }
136
137 /// \brief Retrieves a reference to the semantic analysis object used for
138 /// this tree transform.
139 Sema &getSema() const { return SemaRef; }
140
141 /// \brief Whether the transformation should always rebuild AST nodes, even
142 /// if none of the children have changed.
143 ///
144 /// Subclasses may override this function to specify when the transformation
145 /// should rebuild all AST nodes.
146 ///
147 /// We must always rebuild all AST nodes when performing variadic template
148 /// pack expansion, in order to avoid violating the AST invariant that each
149 /// statement node appears at most once in its containing declaration.
150 bool AlwaysRebuild() { return SemaRef.ArgumentPackSubstitutionIndex != -1; }
151
152 /// \brief Returns the location of the entity being transformed, if that
153 /// information was not available elsewhere in the AST.
154 ///
155 /// By default, returns no source-location information. Subclasses can
156 /// provide an alternative implementation that provides better location
157 /// information.
158 SourceLocation getBaseLocation() { return SourceLocation(); }
159
160 /// \brief Returns the name of the entity being transformed, if that
161 /// information was not available elsewhere in the AST.
162 ///
163 /// By default, returns an empty name. Subclasses can provide an alternative
164 /// implementation with a more precise name.
165 DeclarationName getBaseEntity() { return DeclarationName(); }
166
167 /// \brief Sets the "base" location and entity when that
168 /// information is known based on another transformation.
169 ///
170 /// By default, the source location and entity are ignored. Subclasses can
171 /// override this function to provide a customized implementation.
172 void setBase(SourceLocation Loc, DeclarationName Entity) { }
173
174 /// \brief RAII object that temporarily sets the base location and entity
175 /// used for reporting diagnostics in types.
176 class TemporaryBase {
177 TreeTransform &Self;
178 SourceLocation OldLocation;
179 DeclarationName OldEntity;
180
181 public:
182 TemporaryBase(TreeTransform &Self, SourceLocation Location,
183 DeclarationName Entity) : Self(Self) {
184 OldLocation = Self.getDerived().getBaseLocation();
185 OldEntity = Self.getDerived().getBaseEntity();
186
187 if (Location.isValid())
188 Self.getDerived().setBase(Location, Entity);
189 }
190
191 ~TemporaryBase() {
192 Self.getDerived().setBase(OldLocation, OldEntity);
193 }
194 };
195
196 /// \brief Determine whether the given type \p T has already been
197 /// transformed.
198 ///
199 /// Subclasses can provide an alternative implementation of this routine
200 /// to short-circuit evaluation when it is known that a given type will
201 /// not change. For example, template instantiation need not traverse
202 /// non-dependent types.
203 bool AlreadyTransformed(QualType T) {
204 return T.isNull();
205 }
206
207 /// \brief Determine whether the given call argument should be dropped, e.g.,
208 /// because it is a default argument.
209 ///
210 /// Subclasses can provide an alternative implementation of this routine to
211 /// determine which kinds of call arguments get dropped. By default,
212 /// CXXDefaultArgument nodes are dropped (prior to transformation).
213 bool DropCallArgument(Expr *E) {
214 return E->isDefaultArgument();
215 }
216
217 /// \brief Determine whether we should expand a pack expansion with the
218 /// given set of parameter packs into separate arguments by repeatedly
219 /// transforming the pattern.
220 ///
221 /// By default, the transformer never tries to expand pack expansions.
222 /// Subclasses can override this routine to provide different behavior.
223 ///
224 /// \param EllipsisLoc The location of the ellipsis that identifies the
225 /// pack expansion.
226 ///
227 /// \param PatternRange The source range that covers the entire pattern of
228 /// the pack expansion.
229 ///
230 /// \param Unexpanded The set of unexpanded parameter packs within the
231 /// pattern.
232 ///
233 /// \param ShouldExpand Will be set to \c true if the transformer should
234 /// expand the corresponding pack expansions into separate arguments. When
235 /// set, \c NumExpansions must also be set.
236 ///
237 /// \param RetainExpansion Whether the caller should add an unexpanded
238 /// pack expansion after all of the expanded arguments. This is used
239 /// when extending explicitly-specified template argument packs per
240 /// C++0x [temp.arg.explicit]p9.
241 ///
242 /// \param NumExpansions The number of separate arguments that will be in
243 /// the expanded form of the corresponding pack expansion. This is both an
244 /// input and an output parameter, which can be set by the caller if the
245 /// number of expansions is known a priori (e.g., due to a prior substitution)
246 /// and will be set by the callee when the number of expansions is known.
247 /// The callee must set this value when \c ShouldExpand is \c true; it may
248 /// set this value in other cases.
249 ///
250 /// \returns true if an error occurred (e.g., because the parameter packs
251 /// are to be instantiated with arguments of different lengths), false
252 /// otherwise. If false, \c ShouldExpand (and possibly \c NumExpansions)
253 /// must be set.
254 bool TryExpandParameterPacks(SourceLocation EllipsisLoc,
255 SourceRange PatternRange,
256 ArrayRef<UnexpandedParameterPack> Unexpanded,
257 bool &ShouldExpand,
258 bool &RetainExpansion,
259 Optional<unsigned> &NumExpansions) {
260 ShouldExpand = false;
261 return false;
262 }
263
264 /// \brief "Forget" about the partially-substituted pack template argument,
265 /// when performing an instantiation that must preserve the parameter pack
266 /// use.
267 ///
268 /// This routine is meant to be overridden by the template instantiator.
269 TemplateArgument ForgetPartiallySubstitutedPack() {
270 return TemplateArgument();
271 }
272
273 /// \brief "Remember" the partially-substituted pack template argument
274 /// after performing an instantiation that must preserve the parameter pack
275 /// use.
276 ///
277 /// This routine is meant to be overridden by the template instantiator.
278 void RememberPartiallySubstitutedPack(TemplateArgument Arg) { }
279
280 /// \brief Note to the derived class when a function parameter pack is
281 /// being expanded.
282 void ExpandingFunctionParameterPack(ParmVarDecl *Pack) { }
283
284 /// \brief Transforms the given type into another type.
285 ///
286 /// By default, this routine transforms a type by creating a
287 /// TypeSourceInfo for it and delegating to the appropriate
288 /// function. This is expensive, but we don't mind, because
289 /// this method is deprecated anyway; all users should be
290 /// switched to storing TypeSourceInfos.
291 ///
292 /// \returns the transformed type.
293 QualType TransformType(QualType T);
294
295 /// \brief Transforms the given type-with-location into a new
296 /// type-with-location.
297 ///
298 /// By default, this routine transforms a type by delegating to the
299 /// appropriate TransformXXXType to build a new type. Subclasses
300 /// may override this function (to take over all type
301 /// transformations) or some set of the TransformXXXType functions
302 /// to alter the transformation.
303 TypeSourceInfo *TransformType(TypeSourceInfo *DI);
304
305 /// \brief Transform the given type-with-location into a new
306 /// type, collecting location information in the given builder
307 /// as necessary.
308 ///
309 QualType TransformType(TypeLocBuilder &TLB, TypeLoc TL);
310
311 /// \brief Transform a type that is permitted to produce a
312 /// DeducedTemplateSpecializationType.
313 ///
314 /// This is used in the (relatively rare) contexts where it is acceptable
315 /// for transformation to produce a class template type with deduced
316 /// template arguments.
317 /// @{
318 QualType TransformTypeWithDeducedTST(QualType T);
319 TypeSourceInfo *TransformTypeWithDeducedTST(TypeSourceInfo *DI);
320 /// @}
321
322 /// \brief Transform the given statement.
323 ///
324 /// By default, this routine transforms a statement by delegating to the
325 /// appropriate TransformXXXStmt function to transform a specific kind of
326 /// statement or the TransformExpr() function to transform an expression.
327 /// Subclasses may override this function to transform statements using some
328 /// other mechanism.
329 ///
330 /// \returns the transformed statement.
331 StmtResult TransformStmt(Stmt *S);
332
333 /// \brief Transform the given statement.
334 ///
335 /// By default, this routine transforms a statement by delegating to the
336 /// appropriate TransformOMPXXXClause function to transform a specific kind
337 /// of clause. Subclasses may override this function to transform statements
338 /// using some other mechanism.
339 ///
340 /// \returns the transformed OpenMP clause.
341 OMPClause *TransformOMPClause(OMPClause *S);
342
343 /// \brief Transform the given attribute.
344 ///
345 /// By default, this routine transforms a statement by delegating to the
346 /// appropriate TransformXXXAttr function to transform a specific kind
347 /// of attribute. Subclasses may override this function to transform
348 /// attributed statements using some other mechanism.
349 ///
350 /// \returns the transformed attribute
351 const Attr *TransformAttr(const Attr *S);
352
353/// \brief Transform the specified attribute.
354///
355/// Subclasses should override the transformation of attributes with a pragma
356/// spelling to transform expressions stored within the attribute.
357///
358/// \returns the transformed attribute.
359#define ATTR(X)
360#define PRAGMA_SPELLING_ATTR(X) \
361 const X##Attr *Transform##X##Attr(const X##Attr *R) { return R; }
362#include "clang/Basic/AttrList.inc"
363
364 /// \brief Transform the given expression.
365 ///
366 /// By default, this routine transforms an expression by delegating to the
367 /// appropriate TransformXXXExpr function to build a new expression.
368 /// Subclasses may override this function to transform expressions using some
369 /// other mechanism.
370 ///
371 /// \returns the transformed expression.
372 ExprResult TransformExpr(Expr *E);
373
374 /// \brief Transform the given initializer.
375 ///
376 /// By default, this routine transforms an initializer by stripping off the
377 /// semantic nodes added by initialization, then passing the result to
378 /// TransformExpr or TransformExprs.
379 ///
380 /// \returns the transformed initializer.
381 ExprResult TransformInitializer(Expr *Init, bool NotCopyInit);
382
383 /// \brief Transform the given list of expressions.
384 ///
385 /// This routine transforms a list of expressions by invoking
386 /// \c TransformExpr() for each subexpression. However, it also provides
387 /// support for variadic templates by expanding any pack expansions (if the
388 /// derived class permits such expansion) along the way. When pack expansions
389 /// are present, the number of outputs may not equal the number of inputs.
390 ///
391 /// \param Inputs The set of expressions to be transformed.
392 ///
393 /// \param NumInputs The number of expressions in \c Inputs.
394 ///
395 /// \param IsCall If \c true, then this transform is being performed on
396 /// function-call arguments, and any arguments that should be dropped, will
397 /// be.
398 ///
399 /// \param Outputs The transformed input expressions will be added to this
400 /// vector.
401 ///
402 /// \param ArgChanged If non-NULL, will be set \c true if any argument changed
403 /// due to transformation.
404 ///
405 /// \returns true if an error occurred, false otherwise.
406 bool TransformExprs(Expr *const *Inputs, unsigned NumInputs, bool IsCall,
407 SmallVectorImpl<Expr *> &Outputs,
408 bool *ArgChanged = nullptr);
409
410 /// \brief Transform the given declaration, which is referenced from a type
411 /// or expression.
412 ///
413 /// By default, acts as the identity function on declarations, unless the
414 /// transformer has had to transform the declaration itself. Subclasses
415 /// may override this function to provide alternate behavior.
416 Decl *TransformDecl(SourceLocation Loc, Decl *D) {
417 llvm::DenseMap<Decl *, Decl *>::iterator Known
418 = TransformedLocalDecls.find(D);
419 if (Known != TransformedLocalDecls.end())
420 return Known->second;
421
422 return D;
423 }
424
425 /// \brief Transform the specified condition.
426 ///
427 /// By default, this transforms the variable and expression and rebuilds
428 /// the condition.
429 Sema::ConditionResult TransformCondition(SourceLocation Loc, VarDecl *Var,
430 Expr *Expr,
431 Sema::ConditionKind Kind);
432
433 /// \brief Transform the attributes associated with the given declaration and
434 /// place them on the new declaration.
435 ///
436 /// By default, this operation does nothing. Subclasses may override this
437 /// behavior to transform attributes.
438 void transformAttrs(Decl *Old, Decl *New) { }
439
440 /// \brief Note that a local declaration has been transformed by this
441 /// transformer.
442 ///
443 /// Local declarations are typically transformed via a call to
444 /// TransformDefinition. However, in some cases (e.g., lambda expressions),
445 /// the transformer itself has to transform the declarations. This routine
446 /// can be overridden by a subclass that keeps track of such mappings.
447 void transformedLocalDecl(Decl *Old, Decl *New) {
448 TransformedLocalDecls[Old] = New;
449 }
450
451 /// \brief Transform the definition of the given declaration.
452 ///
453 /// By default, invokes TransformDecl() to transform the declaration.
454 /// Subclasses may override this function to provide alternate behavior.
455 Decl *TransformDefinition(SourceLocation Loc, Decl *D) {
456 return getDerived().TransformDecl(Loc, D);
457 }
458
459 /// \brief Transform the given declaration, which was the first part of a
460 /// nested-name-specifier in a member access expression.
461 ///
462 /// This specific declaration transformation only applies to the first
463 /// identifier in a nested-name-specifier of a member access expression, e.g.,
464 /// the \c T in \c x->T::member
465 ///
466 /// By default, invokes TransformDecl() to transform the declaration.
467 /// Subclasses may override this function to provide alternate behavior.
468 NamedDecl *TransformFirstQualifierInScope(NamedDecl *D, SourceLocation Loc) {
469 return cast_or_null<NamedDecl>(getDerived().TransformDecl(Loc, D));
470 }
471
472 /// Transform the set of declarations in an OverloadExpr.
473 bool TransformOverloadExprDecls(OverloadExpr *Old, bool RequiresADL,
474 LookupResult &R);
475
476 /// \brief Transform the given nested-name-specifier with source-location
477 /// information.
478 ///
479 /// By default, transforms all of the types and declarations within the
480 /// nested-name-specifier. Subclasses may override this function to provide
481 /// alternate behavior.
482 NestedNameSpecifierLoc
483 TransformNestedNameSpecifierLoc(NestedNameSpecifierLoc NNS,
484 QualType ObjectType = QualType(),
485 NamedDecl *FirstQualifierInScope = nullptr);
486
487 /// \brief Transform the given declaration name.
488 ///
489 /// By default, transforms the types of conversion function, constructor,
490 /// and destructor names and then (if needed) rebuilds the declaration name.
491 /// Identifiers and selectors are returned unmodified. Sublcasses may
492 /// override this function to provide alternate behavior.
493 DeclarationNameInfo
494 TransformDeclarationNameInfo(const DeclarationNameInfo &NameInfo);
495
496 /// \brief Transform the given template name.
497 ///
498 /// \param SS The nested-name-specifier that qualifies the template
499 /// name. This nested-name-specifier must already have been transformed.
500 ///
501 /// \param Name The template name to transform.
502 ///
503 /// \param NameLoc The source location of the template name.
504 ///
505 /// \param ObjectType If we're translating a template name within a member
506 /// access expression, this is the type of the object whose member template
507 /// is being referenced.
508 ///
509 /// \param FirstQualifierInScope If the first part of a nested-name-specifier
510 /// also refers to a name within the current (lexical) scope, this is the
511 /// declaration it refers to.
512 ///
513 /// By default, transforms the template name by transforming the declarations
514 /// and nested-name-specifiers that occur within the template name.
515 /// Subclasses may override this function to provide alternate behavior.
516 TemplateName
517 TransformTemplateName(CXXScopeSpec &SS, TemplateName Name,
518 SourceLocation NameLoc,
519 QualType ObjectType = QualType(),
520 NamedDecl *FirstQualifierInScope = nullptr,
521 bool AllowInjectedClassName = false);
522
523 /// \brief Transform the given template argument.
524 ///
525 /// By default, this operation transforms the type, expression, or
526 /// declaration stored within the template argument and constructs a
527 /// new template argument from the transformed result. Subclasses may
528 /// override this function to provide alternate behavior.
529 ///
530 /// Returns true if there was an error.
531 bool TransformTemplateArgument(const TemplateArgumentLoc &Input,
532 TemplateArgumentLoc &Output,
533 bool Uneval = false);
534
535 /// \brief Transform the given set of template arguments.
536 ///
537 /// By default, this operation transforms all of the template arguments
538 /// in the input set using \c TransformTemplateArgument(), and appends
539 /// the transformed arguments to the output list.
540 ///
541 /// Note that this overload of \c TransformTemplateArguments() is merely
542 /// a convenience function. Subclasses that wish to override this behavior
543 /// should override the iterator-based member template version.
544 ///
545 /// \param Inputs The set of template arguments to be transformed.
546 ///
547 /// \param NumInputs The number of template arguments in \p Inputs.
548 ///
549 /// \param Outputs The set of transformed template arguments output by this
550 /// routine.
551 ///
552 /// Returns true if an error occurred.
553 bool TransformTemplateArguments(const TemplateArgumentLoc *Inputs,
554 unsigned NumInputs,
555 TemplateArgumentListInfo &Outputs,
556 bool Uneval = false) {
557 return TransformTemplateArguments(Inputs, Inputs + NumInputs, Outputs,
558 Uneval);
559 }
560
561 /// \brief Transform the given set of template arguments.
562 ///
563 /// By default, this operation transforms all of the template arguments
564 /// in the input set using \c TransformTemplateArgument(), and appends
565 /// the transformed arguments to the output list.
566 ///
567 /// \param First An iterator to the first template argument.
568 ///
569 /// \param Last An iterator one step past the last template argument.
570 ///
571 /// \param Outputs The set of transformed template arguments output by this
572 /// routine.
573 ///
574 /// Returns true if an error occurred.
575 template<typename InputIterator>
576 bool TransformTemplateArguments(InputIterator First,
577 InputIterator Last,
578 TemplateArgumentListInfo &Outputs,
579 bool Uneval = false);
580
581 /// \brief Fakes up a TemplateArgumentLoc for a given TemplateArgument.
582 void InventTemplateArgumentLoc(const TemplateArgument &Arg,
583 TemplateArgumentLoc &ArgLoc);
584
585 /// \brief Fakes up a TypeSourceInfo for a type.
586 TypeSourceInfo *InventTypeSourceInfo(QualType T) {
587 return SemaRef.Context.getTrivialTypeSourceInfo(T,
588 getDerived().getBaseLocation());
589 }
590
591#define ABSTRACT_TYPELOC(CLASS, PARENT)
592#define TYPELOC(CLASS, PARENT) \
593 QualType Transform##CLASS##Type(TypeLocBuilder &TLB, CLASS##TypeLoc T);
594#include "clang/AST/TypeLocNodes.def"
595
596 template<typename Fn>
597 QualType TransformFunctionProtoType(TypeLocBuilder &TLB,
598 FunctionProtoTypeLoc TL,
599 CXXRecordDecl *ThisContext,
600 unsigned ThisTypeQuals,
601 Fn TransformExceptionSpec);
602
603 bool TransformExceptionSpec(SourceLocation Loc,
604 FunctionProtoType::ExceptionSpecInfo &ESI,
605 SmallVectorImpl<QualType> &Exceptions,
606 bool &Changed);
607
608 StmtResult TransformSEHHandler(Stmt *Handler);
609
610 QualType
611 TransformTemplateSpecializationType(TypeLocBuilder &TLB,
612 TemplateSpecializationTypeLoc TL,
613 TemplateName Template);
614
615 QualType
616 TransformDependentTemplateSpecializationType(TypeLocBuilder &TLB,
617 DependentTemplateSpecializationTypeLoc TL,
618 TemplateName Template,
619 CXXScopeSpec &SS);
620
621 QualType TransformDependentTemplateSpecializationType(
622 TypeLocBuilder &TLB, DependentTemplateSpecializationTypeLoc TL,
623 NestedNameSpecifierLoc QualifierLoc);
624
625 /// \brief Transforms the parameters of a function type into the
626 /// given vectors.
627 ///
628 /// The result vectors should be kept in sync; null entries in the
629 /// variables vector are acceptable.
630 ///
631 /// Return true on error.
632 bool TransformFunctionTypeParams(
633 SourceLocation Loc, ArrayRef<ParmVarDecl *> Params,
634 const QualType *ParamTypes,
635 const FunctionProtoType::ExtParameterInfo *ParamInfos,
636 SmallVectorImpl<QualType> &PTypes, SmallVectorImpl<ParmVarDecl *> *PVars,
637 Sema::ExtParameterInfoBuilder &PInfos);
638
639 /// \brief Transforms a single function-type parameter. Return null
640 /// on error.
641 ///
642 /// \param indexAdjustment - A number to add to the parameter's
643 /// scope index; can be negative
644 ParmVarDecl *TransformFunctionTypeParam(ParmVarDecl *OldParm,
645 int indexAdjustment,
646 Optional<unsigned> NumExpansions,
647 bool ExpectParameterPack);
648
649 QualType TransformReferenceType(TypeLocBuilder &TLB, ReferenceTypeLoc TL);
650
651 StmtResult TransformCompoundStmt(CompoundStmt *S, bool IsStmtExpr);
652 ExprResult TransformCXXNamedCastExpr(CXXNamedCastExpr *E);
653
654 TemplateParameterList *TransformTemplateParameterList(
655 TemplateParameterList *TPL) {
656 return TPL;
657 }
658
659 ExprResult TransformAddressOfOperand(Expr *E);
660
661 ExprResult TransformDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *E,
662 bool IsAddressOfOperand,
663 TypeSourceInfo **RecoveryTSI);
664
665 ExprResult TransformParenDependentScopeDeclRefExpr(
666 ParenExpr *PE, DependentScopeDeclRefExpr *DRE, bool IsAddressOfOperand,
667 TypeSourceInfo **RecoveryTSI);
668
669 StmtResult TransformOMPExecutableDirective(OMPExecutableDirective *S);
670
671// FIXME: We use LLVM_ATTRIBUTE_NOINLINE because inlining causes a ridiculous
672// amount of stack usage with clang.
673#define STMT(Node, Parent) \
674 LLVM_ATTRIBUTE_NOINLINE__attribute__((noinline)) \
675 StmtResult Transform##Node(Node *S);
676#define EXPR(Node, Parent) \
677 LLVM_ATTRIBUTE_NOINLINE__attribute__((noinline)) \
678 ExprResult Transform##Node(Node *E);
679#define ABSTRACT_STMT(Stmt)
680#include "clang/AST/StmtNodes.inc"
681
682#define OPENMP_CLAUSE(Name, Class) \
683 LLVM_ATTRIBUTE_NOINLINE__attribute__((noinline)) \
684 OMPClause *Transform ## Class(Class *S);
685#include "clang/Basic/OpenMPKinds.def"
686
687 /// \brief Build a new qualified type given its unqualified type and type
688 /// qualifiers.
689 ///
690 /// By default, this routine adds type qualifiers only to types that can
691 /// have qualifiers, and silently suppresses those qualifiers that are not
692 /// permitted. Subclasses may override this routine to provide different
693 /// behavior.
694 QualType RebuildQualifiedType(QualType T, SourceLocation Loc,
695 Qualifiers Quals);
696
697 /// \brief Build a new pointer type given its pointee type.
698 ///
699 /// By default, performs semantic analysis when building the pointer type.
700 /// Subclasses may override this routine to provide different behavior.
701 QualType RebuildPointerType(QualType PointeeType, SourceLocation Sigil);
702
703 /// \brief Build a new block pointer type given its pointee type.
704 ///
705 /// By default, performs semantic analysis when building the block pointer
706 /// type. Subclasses may override this routine to provide different behavior.
707 QualType RebuildBlockPointerType(QualType PointeeType, SourceLocation Sigil);
708
709 /// \brief Build a new reference type given the type it references.
710 ///
711 /// By default, performs semantic analysis when building the
712 /// reference type. Subclasses may override this routine to provide
713 /// different behavior.
714 ///
715 /// \param LValue whether the type was written with an lvalue sigil
716 /// or an rvalue sigil.
717 QualType RebuildReferenceType(QualType ReferentType,
718 bool LValue,
719 SourceLocation Sigil);
720
721 /// \brief Build a new member pointer type given the pointee type and the
722 /// class type it refers into.
723 ///
724 /// By default, performs semantic analysis when building the member pointer
725 /// type. Subclasses may override this routine to provide different behavior.
726 QualType RebuildMemberPointerType(QualType PointeeType, QualType ClassType,
727 SourceLocation Sigil);
728
729 QualType RebuildObjCTypeParamType(const ObjCTypeParamDecl *Decl,
730 SourceLocation ProtocolLAngleLoc,
731 ArrayRef<ObjCProtocolDecl *> Protocols,
732 ArrayRef<SourceLocation> ProtocolLocs,
733 SourceLocation ProtocolRAngleLoc);
734
735 /// \brief Build an Objective-C object type.
736 ///
737 /// By default, performs semantic analysis when building the object type.
738 /// Subclasses may override this routine to provide different behavior.
739 QualType RebuildObjCObjectType(QualType BaseType,
740 SourceLocation Loc,
741 SourceLocation TypeArgsLAngleLoc,
742 ArrayRef<TypeSourceInfo *> TypeArgs,
743 SourceLocation TypeArgsRAngleLoc,
744 SourceLocation ProtocolLAngleLoc,
745 ArrayRef<ObjCProtocolDecl *> Protocols,
746 ArrayRef<SourceLocation> ProtocolLocs,
747 SourceLocation ProtocolRAngleLoc);
748
749 /// \brief Build a new Objective-C object pointer type given the pointee type.
750 ///
751 /// By default, directly builds the pointer type, with no additional semantic
752 /// analysis.
753 QualType RebuildObjCObjectPointerType(QualType PointeeType,
754 SourceLocation Star);
755
756 /// \brief Build a new array type given the element type, size
757 /// modifier, size of the array (if known), size expression, and index type
758 /// qualifiers.
759 ///
760 /// By default, performs semantic analysis when building the array type.
761 /// Subclasses may override this routine to provide different behavior.
762 /// Also by default, all of the other Rebuild*Array
763 QualType RebuildArrayType(QualType ElementType,
764 ArrayType::ArraySizeModifier SizeMod,
765 const llvm::APInt *Size,
766 Expr *SizeExpr,
767 unsigned IndexTypeQuals,
768 SourceRange BracketsRange);
769
770 /// \brief Build a new constant array type given the element type, size
771 /// modifier, (known) size of the array, and index type qualifiers.
772 ///
773 /// By default, performs semantic analysis when building the array type.
774 /// Subclasses may override this routine to provide different behavior.
775 QualType RebuildConstantArrayType(QualType ElementType,
776 ArrayType::ArraySizeModifier SizeMod,
777 const llvm::APInt &Size,
778 unsigned IndexTypeQuals,
779 SourceRange BracketsRange);
780
781 /// \brief Build a new incomplete array type given the element type, size
782 /// modifier, and index type qualifiers.
783 ///
784 /// By default, performs semantic analysis when building the array type.
785 /// Subclasses may override this routine to provide different behavior.
786 QualType RebuildIncompleteArrayType(QualType ElementType,
787 ArrayType::ArraySizeModifier SizeMod,
788 unsigned IndexTypeQuals,
789 SourceRange BracketsRange);
790
791 /// \brief Build a new variable-length array type given the element type,
792 /// size modifier, size expression, and index type qualifiers.
793 ///
794 /// By default, performs semantic analysis when building the array type.
795 /// Subclasses may override this routine to provide different behavior.
796 QualType RebuildVariableArrayType(QualType ElementType,
797 ArrayType::ArraySizeModifier SizeMod,
798 Expr *SizeExpr,
799 unsigned IndexTypeQuals,
800 SourceRange BracketsRange);
801
802 /// \brief Build a new dependent-sized array type given the element type,
803 /// size modifier, size expression, and index type qualifiers.
804 ///
805 /// By default, performs semantic analysis when building the array type.
806 /// Subclasses may override this routine to provide different behavior.
807 QualType RebuildDependentSizedArrayType(QualType ElementType,
808 ArrayType::ArraySizeModifier SizeMod,
809 Expr *SizeExpr,
810 unsigned IndexTypeQuals,
811 SourceRange BracketsRange);
812
813 /// \brief Build a new vector type given the element type and
814 /// number of elements.
815 ///
816 /// By default, performs semantic analysis when building the vector type.
817 /// Subclasses may override this routine to provide different behavior.
818 QualType RebuildVectorType(QualType ElementType, unsigned NumElements,
819 VectorType::VectorKind VecKind);
820
821 /// \brief Build a new extended vector type given the element type and
822 /// number of elements.
823 ///
824 /// By default, performs semantic analysis when building the vector type.
825 /// Subclasses may override this routine to provide different behavior.
826 QualType RebuildExtVectorType(QualType ElementType, unsigned NumElements,
827 SourceLocation AttributeLoc);
828
829 /// \brief Build a new potentially dependently-sized extended vector type
830 /// given the element type and number of elements.
831 ///
832 /// By default, performs semantic analysis when building the vector type.
833 /// Subclasses may override this routine to provide different behavior.
834 QualType RebuildDependentSizedExtVectorType(QualType ElementType,
835 Expr *SizeExpr,
836 SourceLocation AttributeLoc);
837
838 /// \brief Build a new DependentAddressSpaceType or return the pointee
839 /// type variable with the correct address space (retrieved from
840 /// AddrSpaceExpr) applied to it. The former will be returned in cases
841 /// where the address space remains dependent.
842 ///
843 /// By default, performs semantic analysis when building the type with address
844 /// space applied. Subclasses may override this routine to provide different
845 /// behavior.
846 QualType RebuildDependentAddressSpaceType(QualType PointeeType,
847 Expr *AddrSpaceExpr,
848 SourceLocation AttributeLoc);
849
850 /// \brief Build a new function type.
851 ///
852 /// By default, performs semantic analysis when building the function type.
853 /// Subclasses may override this routine to provide different behavior.
854 QualType RebuildFunctionProtoType(QualType T,
855 MutableArrayRef<QualType> ParamTypes,
856 const FunctionProtoType::ExtProtoInfo &EPI);
857
858 /// \brief Build a new unprototyped function type.
859 QualType RebuildFunctionNoProtoType(QualType ResultType);
860
861 /// \brief Rebuild an unresolved typename type, given the decl that
862 /// the UnresolvedUsingTypenameDecl was transformed to.
863 QualType RebuildUnresolvedUsingType(SourceLocation NameLoc, Decl *D);
864
865 /// \brief Build a new typedef type.
866 QualType RebuildTypedefType(TypedefNameDecl *Typedef) {
867 return SemaRef.Context.getTypeDeclType(Typedef);
868 }
869
870 /// \brief Build a new class/struct/union type.
871 QualType RebuildRecordType(RecordDecl *Record) {
872 return SemaRef.Context.getTypeDeclType(Record);
873 }
874
875 /// \brief Build a new Enum type.
876 QualType RebuildEnumType(EnumDecl *Enum) {
877 return SemaRef.Context.getTypeDeclType(Enum);
878 }
879
880 /// \brief Build a new typeof(expr) type.
881 ///
882 /// By default, performs semantic analysis when building the typeof type.
883 /// Subclasses may override this routine to provide different behavior.
884 QualType RebuildTypeOfExprType(Expr *Underlying, SourceLocation Loc);
885
886 /// \brief Build a new typeof(type) type.
887 ///
888 /// By default, builds a new TypeOfType with the given underlying type.
889 QualType RebuildTypeOfType(QualType Underlying);
890
891 /// \brief Build a new unary transform type.
892 QualType RebuildUnaryTransformType(QualType BaseType,
893 UnaryTransformType::UTTKind UKind,
894 SourceLocation Loc);
895
896 /// \brief Build a new C++11 decltype type.
897 ///
898 /// By default, performs semantic analysis when building the decltype type.
899 /// Subclasses may override this routine to provide different behavior.
900 QualType RebuildDecltypeType(Expr *Underlying, SourceLocation Loc);
901
902 /// \brief Build a new C++11 auto type.
903 ///
904 /// By default, builds a new AutoType with the given deduced type.
905 QualType RebuildAutoType(QualType Deduced, AutoTypeKeyword Keyword) {
906 // Note, IsDependent is always false here: we implicitly convert an 'auto'
907 // which has been deduced to a dependent type into an undeduced 'auto', so
908 // that we'll retry deduction after the transformation.
909 return SemaRef.Context.getAutoType(Deduced, Keyword,
910 /*IsDependent*/ false);
911 }
912
913 /// By default, builds a new DeducedTemplateSpecializationType with the given
914 /// deduced type.
915 QualType RebuildDeducedTemplateSpecializationType(TemplateName Template,
916 QualType Deduced) {
917 return SemaRef.Context.getDeducedTemplateSpecializationType(
918 Template, Deduced, /*IsDependent*/ false);
919 }
920
921 /// \brief Build a new template specialization type.
922 ///
923 /// By default, performs semantic analysis when building the template
924 /// specialization type. Subclasses may override this routine to provide
925 /// different behavior.
926 QualType RebuildTemplateSpecializationType(TemplateName Template,
927 SourceLocation TemplateLoc,
928 TemplateArgumentListInfo &Args);
929
930 /// \brief Build a new parenthesized type.
931 ///
932 /// By default, builds a new ParenType type from the inner type.
933 /// Subclasses may override this routine to provide different behavior.
934 QualType RebuildParenType(QualType InnerType) {
935 return SemaRef.BuildParenType(InnerType);
936 }
937
938 /// \brief Build a new qualified name type.
939 ///
940 /// By default, builds a new ElaboratedType type from the keyword,
941 /// the nested-name-specifier and the named type.
942 /// Subclasses may override this routine to provide different behavior.
943 QualType RebuildElaboratedType(SourceLocation KeywordLoc,
944 ElaboratedTypeKeyword Keyword,
945 NestedNameSpecifierLoc QualifierLoc,
946 QualType Named) {
947 return SemaRef.Context.getElaboratedType(Keyword,
948 QualifierLoc.getNestedNameSpecifier(),
949 Named);
950 }
951
952 /// \brief Build a new typename type that refers to a template-id.
953 ///
954 /// By default, builds a new DependentNameType type from the
955 /// nested-name-specifier and the given type. Subclasses may override
956 /// this routine to provide different behavior.
957 QualType RebuildDependentTemplateSpecializationType(
958 ElaboratedTypeKeyword Keyword,
959 NestedNameSpecifierLoc QualifierLoc,
960 const IdentifierInfo *Name,
961 SourceLocation NameLoc,
962 TemplateArgumentListInfo &Args,
963 bool AllowInjectedClassName) {
964 // Rebuild the template name.
965 // TODO: avoid TemplateName abstraction
966 CXXScopeSpec SS;
967 SS.Adopt(QualifierLoc);
968 TemplateName InstName
969 = getDerived().RebuildTemplateName(SS, *Name, NameLoc, QualType(),
970 nullptr, AllowInjectedClassName);
971
972 if (InstName.isNull())
973 return QualType();
974
975 // If it's still dependent, make a dependent specialization.
976 if (InstName.getAsDependentTemplateName())
977 return SemaRef.Context.getDependentTemplateSpecializationType(Keyword,
978 QualifierLoc.getNestedNameSpecifier(),
979 Name,
980 Args);
981
982 // Otherwise, make an elaborated type wrapping a non-dependent
983 // specialization.
984 QualType T =
985 getDerived().RebuildTemplateSpecializationType(InstName, NameLoc, Args);
986 if (T.isNull()) return QualType();
987
988 if (Keyword == ETK_None && QualifierLoc.getNestedNameSpecifier() == nullptr)
989 return T;
990
991 return SemaRef.Context.getElaboratedType(Keyword,
992 QualifierLoc.getNestedNameSpecifier(),
993 T);
994 }
995
996 /// \brief Build a new typename type that refers to an identifier.
997 ///
998 /// By default, performs semantic analysis when building the typename type
999 /// (or elaborated type). Subclasses may override this routine to provide
1000 /// different behavior.
1001 QualType RebuildDependentNameType(ElaboratedTypeKeyword Keyword,
1002 SourceLocation KeywordLoc,
1003 NestedNameSpecifierLoc QualifierLoc,
1004 const IdentifierInfo *Id,
1005 SourceLocation IdLoc,
1006 bool DeducedTSTContext) {
1007 CXXScopeSpec SS;
1008 SS.Adopt(QualifierLoc);
1009
1010 if (QualifierLoc.getNestedNameSpecifier()->isDependent()) {
1011 // If the name is still dependent, just build a new dependent name type.
1012 if (!SemaRef.computeDeclContext(SS))
1013 return SemaRef.Context.getDependentNameType(Keyword,
1014 QualifierLoc.getNestedNameSpecifier(),
1015 Id);
1016 }
1017
1018 if (Keyword == ETK_None || Keyword == ETK_Typename) {
1019 QualType T = SemaRef.CheckTypenameType(Keyword, KeywordLoc, QualifierLoc,
1020 *Id, IdLoc);
1021 // If a dependent name resolves to a deduced template specialization type,
1022 // check that we're in one of the syntactic contexts permitting it.
1023 if (!DeducedTSTContext) {
1024 if (auto *Deduced = dyn_cast_or_null<DeducedTemplateSpecializationType>(
1025 T.isNull() ? nullptr : T->getContainedDeducedType())) {
1026 SemaRef.Diag(IdLoc, diag::err_dependent_deduced_tst)
1027 << (int)SemaRef.getTemplateNameKindForDiagnostics(
1028 Deduced->getTemplateName())
1029 << QualType(QualifierLoc.getNestedNameSpecifier()->getAsType(), 0);
1030 if (auto *TD = Deduced->getTemplateName().getAsTemplateDecl())
1031 SemaRef.Diag(TD->getLocation(), diag::note_template_decl_here);
1032 return QualType();
1033 }
1034 }
1035 return T;
1036 }
1037
1038 TagTypeKind Kind = TypeWithKeyword::getTagTypeKindForKeyword(Keyword);
1039
1040 // We had a dependent elaborated-type-specifier that has been transformed
1041 // into a non-dependent elaborated-type-specifier. Find the tag we're
1042 // referring to.
1043 LookupResult Result(SemaRef, Id, IdLoc, Sema::LookupTagName);
1044 DeclContext *DC = SemaRef.computeDeclContext(SS, false);
1045 if (!DC)
1046 return QualType();
1047
1048 if (SemaRef.RequireCompleteDeclContext(SS, DC))
1049 return QualType();
1050
1051 TagDecl *Tag = nullptr;
1052 SemaRef.LookupQualifiedName(Result, DC);
1053 switch (Result.getResultKind()) {
1054 case LookupResult::NotFound:
1055 case LookupResult::NotFoundInCurrentInstantiation:
1056 break;
1057
1058 case LookupResult::Found:
1059 Tag = Result.getAsSingle<TagDecl>();
1060 break;
1061
1062 case LookupResult::FoundOverloaded:
1063 case LookupResult::FoundUnresolvedValue:
1064 llvm_unreachable("Tag lookup cannot find non-tags")::llvm::llvm_unreachable_internal("Tag lookup cannot find non-tags"
, "/build/llvm-toolchain-snapshot-7~svn325118/tools/clang/lib/Sema/TreeTransform.h"
, 1064)
;
1065
1066 case LookupResult::Ambiguous:
1067 // Let the LookupResult structure handle ambiguities.
1068 return QualType();
1069 }
1070
1071 if (!Tag) {
1072 // Check where the name exists but isn't a tag type and use that to emit
1073 // better diagnostics.
1074 LookupResult Result(SemaRef, Id, IdLoc, Sema::LookupTagName);
1075 SemaRef.LookupQualifiedName(Result, DC);
1076 switch (Result.getResultKind()) {
1077 case LookupResult::Found:
1078 case LookupResult::FoundOverloaded:
1079 case LookupResult::FoundUnresolvedValue: {
1080 NamedDecl *SomeDecl = Result.getRepresentativeDecl();
1081 Sema::NonTagKind NTK = SemaRef.getNonTagTypeDeclKind(SomeDecl, Kind);
1082 SemaRef.Diag(IdLoc, diag::err_tag_reference_non_tag) << SomeDecl
1083 << NTK << Kind;
1084 SemaRef.Diag(SomeDecl->getLocation(), diag::note_declared_at);
1085 break;
1086 }
1087 default:
1088 SemaRef.Diag(IdLoc, diag::err_not_tag_in_scope)
1089 << Kind << Id << DC << QualifierLoc.getSourceRange();
1090 break;
1091 }
1092 return QualType();
1093 }
1094
1095 if (!SemaRef.isAcceptableTagRedeclaration(Tag, Kind, /*isDefinition*/false,
1096 IdLoc, Id)) {
1097 SemaRef.Diag(KeywordLoc, diag::err_use_with_wrong_tag) << Id;
1098 SemaRef.Diag(Tag->getLocation(), diag::note_previous_use);
1099 return QualType();
1100 }
1101
1102 // Build the elaborated-type-specifier type.
1103 QualType T = SemaRef.Context.getTypeDeclType(Tag);
1104 return SemaRef.Context.getElaboratedType(Keyword,
1105 QualifierLoc.getNestedNameSpecifier(),
1106 T);
1107 }
1108
1109 /// \brief Build a new pack expansion type.
1110 ///
1111 /// By default, builds a new PackExpansionType type from the given pattern.
1112 /// Subclasses may override this routine to provide different behavior.
1113 QualType RebuildPackExpansionType(QualType Pattern,
1114 SourceRange PatternRange,
1115 SourceLocation EllipsisLoc,
1116 Optional<unsigned> NumExpansions) {
1117 return getSema().CheckPackExpansion(Pattern, PatternRange, EllipsisLoc,
1118 NumExpansions);
1119 }
1120
1121 /// \brief Build a new atomic type given its value type.
1122 ///
1123 /// By default, performs semantic analysis when building the atomic type.
1124 /// Subclasses may override this routine to provide different behavior.
1125 QualType RebuildAtomicType(QualType ValueType, SourceLocation KWLoc);
1126
1127 /// \brief Build a new pipe type given its value type.
1128 QualType RebuildPipeType(QualType ValueType, SourceLocation KWLoc,
1129 bool isReadPipe);
1130
1131 /// \brief Build a new template name given a nested name specifier, a flag
1132 /// indicating whether the "template" keyword was provided, and the template
1133 /// that the template name refers to.
1134 ///
1135 /// By default, builds the new template name directly. Subclasses may override
1136 /// this routine to provide different behavior.
1137 TemplateName RebuildTemplateName(CXXScopeSpec &SS,
1138 bool TemplateKW,
1139 TemplateDecl *Template);
1140
1141 /// \brief Build a new template name given a nested name specifier and the
1142 /// name that is referred to as a template.
1143 ///
1144 /// By default, performs semantic analysis to determine whether the name can
1145 /// be resolved to a specific template, then builds the appropriate kind of
1146 /// template name. Subclasses may override this routine to provide different
1147 /// behavior.
1148 TemplateName RebuildTemplateName(CXXScopeSpec &SS,
1149 const IdentifierInfo &Name,
1150 SourceLocation NameLoc,
1151 QualType ObjectType,
1152 NamedDecl *FirstQualifierInScope,
1153 bool AllowInjectedClassName);
1154
1155 /// \brief Build a new template name given a nested name specifier and the
1156 /// overloaded operator name that is referred to as a template.
1157 ///
1158 /// By default, performs semantic analysis to determine whether the name can
1159 /// be resolved to a specific template, then builds the appropriate kind of
1160 /// template name. Subclasses may override this routine to provide different
1161 /// behavior.
1162 TemplateName RebuildTemplateName(CXXScopeSpec &SS,
1163 OverloadedOperatorKind Operator,
1164 SourceLocation NameLoc,
1165 QualType ObjectType,
1166 bool AllowInjectedClassName);
1167
1168 /// \brief Build a new template name given a template template parameter pack
1169 /// and the
1170 ///
1171 /// By default, performs semantic analysis to determine whether the name can
1172 /// be resolved to a specific template, then builds the appropriate kind of
1173 /// template name. Subclasses may override this routine to provide different
1174 /// behavior.
1175 TemplateName RebuildTemplateName(TemplateTemplateParmDecl *Param,
1176 const TemplateArgument &ArgPack) {
1177 return getSema().Context.getSubstTemplateTemplateParmPack(Param, ArgPack);
1178 }
1179
1180 /// \brief Build a new compound statement.
1181 ///
1182 /// By default, performs semantic analysis to build the new statement.
1183 /// Subclasses may override this routine to provide different behavior.
1184 StmtResult RebuildCompoundStmt(SourceLocation LBraceLoc,
1185 MultiStmtArg Statements,
1186 SourceLocation RBraceLoc,
1187 bool IsStmtExpr) {
1188 return getSema().ActOnCompoundStmt(LBraceLoc, RBraceLoc, Statements,
1189 IsStmtExpr);
1190 }
1191
1192 /// \brief Build a new case statement.
1193 ///
1194 /// By default, performs semantic analysis to build the new statement.
1195 /// Subclasses may override this routine to provide different behavior.
1196 StmtResult RebuildCaseStmt(SourceLocation CaseLoc,
1197 Expr *LHS,
1198 SourceLocation EllipsisLoc,
1199 Expr *RHS,
1200 SourceLocation ColonLoc) {
1201 return getSema().ActOnCaseStmt(CaseLoc, LHS, EllipsisLoc, RHS,
1202 ColonLoc);
1203 }
1204
1205 /// \brief Attach the body to a new case statement.
1206 ///
1207 /// By default, performs semantic analysis to build the new statement.
1208 /// Subclasses may override this routine to provide different behavior.
1209 StmtResult RebuildCaseStmtBody(Stmt *S, Stmt *Body) {
1210 getSema().ActOnCaseStmtBody(S, Body);
1211 return S;
1212 }
1213
1214 /// \brief Build a new default statement.
1215 ///
1216 /// By default, performs semantic analysis to build the new statement.
1217 /// Subclasses may override this routine to provide different behavior.
1218 StmtResult RebuildDefaultStmt(SourceLocation DefaultLoc,
1219 SourceLocation ColonLoc,
1220 Stmt *SubStmt) {
1221 return getSema().ActOnDefaultStmt(DefaultLoc, ColonLoc, SubStmt,
1222 /*CurScope=*/nullptr);
1223 }
1224
1225 /// \brief Build a new label statement.
1226 ///
1227 /// By default, performs semantic analysis to build the new statement.
1228 /// Subclasses may override this routine to provide different behavior.
1229 StmtResult RebuildLabelStmt(SourceLocation IdentLoc, LabelDecl *L,
1230 SourceLocation ColonLoc, Stmt *SubStmt) {
1231 return SemaRef.ActOnLabelStmt(IdentLoc, L, ColonLoc, SubStmt);
1232 }
1233
1234 /// \brief Build a new label statement.
1235 ///
1236 /// By default, performs semantic analysis to build the new statement.
1237 /// Subclasses may override this routine to provide different behavior.
1238 StmtResult RebuildAttributedStmt(SourceLocation AttrLoc,
1239 ArrayRef<const Attr*> Attrs,
1240 Stmt *SubStmt) {
1241 return SemaRef.ActOnAttributedStmt(AttrLoc, Attrs, SubStmt);
1242 }
1243
1244 /// \brief Build a new "if" statement.
1245 ///
1246 /// By default, performs semantic analysis to build the new statement.
1247 /// Subclasses may override this routine to provide different behavior.
1248 StmtResult RebuildIfStmt(SourceLocation IfLoc, bool IsConstexpr,
1249 Sema::ConditionResult Cond, Stmt *Init, Stmt *Then,
1250 SourceLocation ElseLoc, Stmt *Else) {
1251 return getSema().ActOnIfStmt(IfLoc, IsConstexpr, Init, Cond, Then,
1252 ElseLoc, Else);
1253 }
1254
1255 /// \brief Start building a new switch statement.
1256 ///
1257 /// By default, performs semantic analysis to build the new statement.
1258 /// Subclasses may override this routine to provide different behavior.
1259 StmtResult RebuildSwitchStmtStart(SourceLocation SwitchLoc, Stmt *Init,
1260 Sema::ConditionResult Cond) {
1261 return getSema().ActOnStartOfSwitchStmt(SwitchLoc, Init, Cond);
1262 }
1263
1264 /// \brief Attach the body to the switch statement.
1265 ///
1266 /// By default, performs semantic analysis to build the new statement.
1267 /// Subclasses may override this routine to provide different behavior.
1268 StmtResult RebuildSwitchStmtBody(SourceLocation SwitchLoc,
1269 Stmt *Switch, Stmt *Body) {
1270 return getSema().ActOnFinishSwitchStmt(SwitchLoc, Switch, Body);
1271 }
1272
1273 /// \brief Build a new while statement.
1274 ///
1275 /// By default, performs semantic analysis to build the new statement.
1276 /// Subclasses may override this routine to provide different behavior.
1277 StmtResult RebuildWhileStmt(SourceLocation WhileLoc,
1278 Sema::ConditionResult Cond, Stmt *Body) {
1279 return getSema().ActOnWhileStmt(WhileLoc, Cond, Body);
1280 }
1281
1282 /// \brief Build a new do-while statement.
1283 ///
1284 /// By default, performs semantic analysis to build the new statement.
1285 /// Subclasses may override this routine to provide different behavior.
1286 StmtResult RebuildDoStmt(SourceLocation DoLoc, Stmt *Body,
1287 SourceLocation WhileLoc, SourceLocation LParenLoc,
1288 Expr *Cond, SourceLocation RParenLoc) {
1289 return getSema().ActOnDoStmt(DoLoc, Body, WhileLoc, LParenLoc,
1290 Cond, RParenLoc);
1291 }
1292
1293 /// \brief Build a new for statement.
1294 ///
1295 /// By default, performs semantic analysis to build the new statement.
1296 /// Subclasses may override this routine to provide different behavior.
1297 StmtResult RebuildForStmt(SourceLocation ForLoc, SourceLocation LParenLoc,
1298 Stmt *Init, Sema::ConditionResult Cond,
1299 Sema::FullExprArg Inc, SourceLocation RParenLoc,
1300 Stmt *Body) {
1301 return getSema().ActOnForStmt(ForLoc, LParenLoc, Init, Cond,
1302 Inc, RParenLoc, Body);
1303 }
1304
1305 /// \brief Build a new goto statement.
1306 ///
1307 /// By default, performs semantic analysis to build the new statement.
1308 /// Subclasses may override this routine to provide different behavior.
1309 StmtResult RebuildGotoStmt(SourceLocation GotoLoc, SourceLocation LabelLoc,
1310 LabelDecl *Label) {
1311 return getSema().ActOnGotoStmt(GotoLoc, LabelLoc, Label);
1312 }
1313
1314 /// \brief Build a new indirect goto statement.
1315 ///
1316 /// By default, performs semantic analysis to build the new statement.
1317 /// Subclasses may override this routine to provide different behavior.
1318 StmtResult RebuildIndirectGotoStmt(SourceLocation GotoLoc,
1319 SourceLocation StarLoc,
1320 Expr *Target) {
1321 return getSema().ActOnIndirectGotoStmt(GotoLoc, StarLoc, Target);
1322 }
1323
1324 /// \brief Build a new return statement.
1325 ///
1326 /// By default, performs semantic analysis to build the new statement.
1327 /// Subclasses may override this routine to provide different behavior.
1328 StmtResult RebuildReturnStmt(SourceLocation ReturnLoc, Expr *Result) {
1329 return getSema().BuildReturnStmt(ReturnLoc, Result);
1330 }
1331
1332 /// \brief Build a new declaration statement.
1333 ///
1334 /// By default, performs semantic analysis to build the new statement.
1335 /// Subclasses may override this routine to provide different behavior.
1336 StmtResult RebuildDeclStmt(MutableArrayRef<Decl *> Decls,
1337 SourceLocation StartLoc, SourceLocation EndLoc) {
1338 Sema::DeclGroupPtrTy DG = getSema().BuildDeclaratorGroup(Decls);
1339 return getSema().ActOnDeclStmt(DG, StartLoc, EndLoc);
1340 }
1341
1342 /// \brief Build a new inline asm statement.
1343 ///
1344 /// By default, performs semantic analysis to build the new statement.
1345 /// Subclasses may override this routine to provide different behavior.
1346 StmtResult RebuildGCCAsmStmt(SourceLocation AsmLoc, bool IsSimple,
1347 bool IsVolatile, unsigned NumOutputs,
1348 unsigned NumInputs, IdentifierInfo **Names,
1349 MultiExprArg Constraints, MultiExprArg Exprs,
1350 Expr *AsmString, MultiExprArg Clobbers,
1351 SourceLocation RParenLoc) {
1352 return getSema().ActOnGCCAsmStmt(AsmLoc, IsSimple, IsVolatile, NumOutputs,
1353 NumInputs, Names, Constraints, Exprs,
1354 AsmString, Clobbers, RParenLoc);
1355 }
1356
1357 /// \brief Build a new MS style inline asm statement.
1358 ///
1359 /// By default, performs semantic analysis to build the new statement.
1360 /// Subclasses may override this routine to provide different behavior.
1361 StmtResult RebuildMSAsmStmt(SourceLocation AsmLoc, SourceLocation LBraceLoc,
1362 ArrayRef<Token> AsmToks,
1363 StringRef AsmString,
1364 unsigned NumOutputs, unsigned NumInputs,
1365 ArrayRef<StringRef> Constraints,
1366 ArrayRef<StringRef> Clobbers,
1367 ArrayRef<Expr*> Exprs,
1368 SourceLocation EndLoc) {
1369 return getSema().ActOnMSAsmStmt(AsmLoc, LBraceLoc, AsmToks, AsmString,
1370 NumOutputs, NumInputs,
1371 Constraints, Clobbers, Exprs, EndLoc);
1372 }
1373
1374 /// \brief Build a new co_return statement.
1375 ///
1376 /// By default, performs semantic analysis to build the new statement.
1377 /// Subclasses may override this routine to provide different behavior.
1378 StmtResult RebuildCoreturnStmt(SourceLocation CoreturnLoc, Expr *Result,
1379 bool IsImplicit) {
1380 return getSema().BuildCoreturnStmt(CoreturnLoc, Result, IsImplicit);
1381 }
1382
1383 /// \brief Build a new co_await expression.
1384 ///
1385 /// By default, performs semantic analysis to build the new expression.
1386 /// Subclasses may override this routine to provide different behavior.
1387 ExprResult RebuildCoawaitExpr(SourceLocation CoawaitLoc, Expr *Result,
1388 bool IsImplicit) {
1389 return getSema().BuildResolvedCoawaitExpr(CoawaitLoc, Result, IsImplicit);
1390 }
1391
1392 /// \brief Build a new co_await expression.
1393 ///
1394 /// By default, performs semantic analysis to build the new expression.
1395 /// Subclasses may override this routine to provide different behavior.
1396 ExprResult RebuildDependentCoawaitExpr(SourceLocation CoawaitLoc,
1397 Expr *Result,
1398 UnresolvedLookupExpr *Lookup) {
1399 return getSema().BuildUnresolvedCoawaitExpr(CoawaitLoc, Result, Lookup);
1400 }
1401
1402 /// \brief Build a new co_yield expression.
1403 ///
1404 /// By default, performs semantic analysis to build the new expression.
1405 /// Subclasses may override this routine to provide different behavior.
1406 ExprResult RebuildCoyieldExpr(SourceLocation CoyieldLoc, Expr *Result) {
1407 return getSema().BuildCoyieldExpr(CoyieldLoc, Result);
1408 }
1409
1410 StmtResult RebuildCoroutineBodyStmt(CoroutineBodyStmt::CtorArgs Args) {
1411 return getSema().BuildCoroutineBodyStmt(Args);
1412 }
1413
1414 /// \brief Build a new Objective-C \@try statement.
1415 ///
1416 /// By default, performs semantic analysis to build the new statement.
1417 /// Subclasses may override this routine to provide different behavior.
1418 StmtResult RebuildObjCAtTryStmt(SourceLocation AtLoc,
1419 Stmt *TryBody,
1420 MultiStmtArg CatchStmts,
1421 Stmt *Finally) {
1422 return getSema().ActOnObjCAtTryStmt(AtLoc, TryBody, CatchStmts,
1423 Finally);
1424 }
1425
1426 /// \brief Rebuild an Objective-C exception declaration.
1427 ///
1428 /// By default, performs semantic analysis to build the new declaration.
1429 /// Subclasses may override this routine to provide different behavior.
1430 VarDecl *RebuildObjCExceptionDecl(VarDecl *ExceptionDecl,
1431 TypeSourceInfo *TInfo, QualType T) {
1432 return getSema().BuildObjCExceptionDecl(TInfo, T,
1433 ExceptionDecl->getInnerLocStart(),
1434 ExceptionDecl->getLocation(),
1435 ExceptionDecl->getIdentifier());
1436 }
1437
1438 /// \brief Build a new Objective-C \@catch statement.
1439 ///
1440 /// By default, performs semantic analysis to build the new statement.
1441 /// Subclasses may override this routine to provide different behavior.
1442 StmtResult RebuildObjCAtCatchStmt(SourceLocation AtLoc,
1443 SourceLocation RParenLoc,
1444 VarDecl *Var,
1445 Stmt *Body) {
1446 return getSema().ActOnObjCAtCatchStmt(AtLoc, RParenLoc,
1447 Var, Body);
1448 }
1449
1450 /// \brief Build a new Objective-C \@finally statement.
1451 ///
1452 /// By default, performs semantic analysis to build the new statement.
1453 /// Subclasses may override this routine to provide different behavior.
1454 StmtResult RebuildObjCAtFinallyStmt(SourceLocation AtLoc,
1455 Stmt *Body) {
1456 return getSema().ActOnObjCAtFinallyStmt(AtLoc, Body);
1457 }
1458
1459 /// \brief Build a new Objective-C \@throw statement.
1460 ///
1461 /// By default, performs semantic analysis to build the new statement.
1462 /// Subclasses may override this routine to provide different behavior.
1463 StmtResult RebuildObjCAtThrowStmt(SourceLocation AtLoc,
1464 Expr *Operand) {
1465 return getSema().BuildObjCAtThrowStmt(AtLoc, Operand);
1466 }
1467
1468 /// \brief Build a new OpenMP executable directive.
1469 ///
1470 /// By default, performs semantic analysis to build the new statement.
1471 /// Subclasses may override this routine to provide different behavior.
1472 StmtResult RebuildOMPExecutableDirective(OpenMPDirectiveKind Kind,
1473 DeclarationNameInfo DirName,
1474 OpenMPDirectiveKind CancelRegion,
1475 ArrayRef<OMPClause *> Clauses,
1476 Stmt *AStmt, SourceLocation StartLoc,
1477 SourceLocation EndLoc) {
1478 return getSema().ActOnOpenMPExecutableDirective(
1479 Kind, DirName, CancelRegion, Clauses, AStmt, StartLoc, EndLoc);
1480 }
1481
1482 /// \brief Build a new OpenMP 'if' clause.
1483 ///
1484 /// By default, performs semantic analysis to build the new OpenMP clause.
1485 /// Subclasses may override this routine to provide different behavior.
1486 OMPClause *RebuildOMPIfClause(OpenMPDirectiveKind NameModifier,
1487 Expr *Condition, SourceLocation StartLoc,
1488 SourceLocation LParenLoc,
1489 SourceLocation NameModifierLoc,
1490 SourceLocation ColonLoc,
1491 SourceLocation EndLoc) {
1492 return getSema().ActOnOpenMPIfClause(NameModifier, Condition, StartLoc,
1493 LParenLoc, NameModifierLoc, ColonLoc,
1494 EndLoc);
1495 }
1496
1497 /// \brief Build a new OpenMP 'final' clause.
1498 ///
1499 /// By default, performs semantic analysis to build the new OpenMP clause.
1500 /// Subclasses may override this routine to provide different behavior.
1501 OMPClause *RebuildOMPFinalClause(Expr *Condition, SourceLocation StartLoc,
1502 SourceLocation LParenLoc,
1503 SourceLocation EndLoc) {
1504 return getSema().ActOnOpenMPFinalClause(Condition, StartLoc, LParenLoc,
1505 EndLoc);
1506 }
1507
1508 /// \brief Build a new OpenMP 'num_threads' clause.
1509 ///
1510 /// By default, performs semantic analysis to build the new OpenMP clause.
1511 /// Subclasses may override this routine to provide different behavior.
1512 OMPClause *RebuildOMPNumThreadsClause(Expr *NumThreads,
1513 SourceLocation StartLoc,
1514 SourceLocation LParenLoc,
1515 SourceLocation EndLoc) {
1516 return getSema().ActOnOpenMPNumThreadsClause(NumThreads, StartLoc,
1517 LParenLoc, EndLoc);
1518 }
1519
1520 /// \brief Build a new OpenMP 'safelen' clause.
1521 ///
1522 /// By default, performs semantic analysis to build the new OpenMP clause.
1523 /// Subclasses may override this routine to provide different behavior.
1524 OMPClause *RebuildOMPSafelenClause(Expr *Len, SourceLocation StartLoc,
1525 SourceLocation LParenLoc,
1526 SourceLocation EndLoc) {
1527 return getSema().ActOnOpenMPSafelenClause(Len, StartLoc, LParenLoc, EndLoc);
1528 }
1529
1530 /// \brief Build a new OpenMP 'simdlen' clause.
1531 ///
1532 /// By default, performs semantic analysis to build the new OpenMP clause.
1533 /// Subclasses may override this routine to provide different behavior.
1534 OMPClause *RebuildOMPSimdlenClause(Expr *Len, SourceLocation StartLoc,
1535 SourceLocation LParenLoc,
1536 SourceLocation EndLoc) {
1537 return getSema().ActOnOpenMPSimdlenClause(Len, StartLoc, LParenLoc, EndLoc);
1538 }
1539
1540 /// \brief Build a new OpenMP 'collapse' clause.
1541 ///
1542 /// By default, performs semantic analysis to build the new OpenMP clause.
1543 /// Subclasses may override this routine to provide different behavior.
1544 OMPClause *RebuildOMPCollapseClause(Expr *Num, SourceLocation StartLoc,
1545 SourceLocation LParenLoc,
1546 SourceLocation EndLoc) {
1547 return getSema().ActOnOpenMPCollapseClause(Num, StartLoc, LParenLoc,
1548 EndLoc);
1549 }
1550
1551 /// \brief Build a new OpenMP 'default' clause.
1552 ///
1553 /// By default, performs semantic analysis to build the new OpenMP clause.
1554 /// Subclasses may override this routine to provide different behavior.
1555 OMPClause *RebuildOMPDefaultClause(OpenMPDefaultClauseKind Kind,
1556 SourceLocation KindKwLoc,
1557 SourceLocation StartLoc,
1558 SourceLocation LParenLoc,
1559 SourceLocation EndLoc) {
1560 return getSema().ActOnOpenMPDefaultClause(Kind, KindKwLoc,
1561 StartLoc, LParenLoc, EndLoc);
1562 }
1563
1564 /// \brief Build a new OpenMP 'proc_bind' clause.
1565 ///
1566 /// By default, performs semantic analysis to build the new OpenMP clause.
1567 /// Subclasses may override this routine to provide different behavior.
1568 OMPClause *RebuildOMPProcBindClause(OpenMPProcBindClauseKind Kind,
1569 SourceLocation KindKwLoc,
1570 SourceLocation StartLoc,
1571 SourceLocation LParenLoc,
1572 SourceLocation EndLoc) {
1573 return getSema().ActOnOpenMPProcBindClause(Kind, KindKwLoc,
1574 StartLoc, LParenLoc, EndLoc);
1575 }
1576
1577 /// \brief Build a new OpenMP 'schedule' clause.
1578 ///
1579 /// By default, performs semantic analysis to build the new OpenMP clause.
1580 /// Subclasses may override this routine to provide different behavior.
1581 OMPClause *RebuildOMPScheduleClause(
1582 OpenMPScheduleClauseModifier M1, OpenMPScheduleClauseModifier M2,
1583 OpenMPScheduleClauseKind Kind, Expr *ChunkSize, SourceLocation StartLoc,
1584 SourceLocation LParenLoc, SourceLocation M1Loc, SourceLocation M2Loc,
1585 SourceLocation KindLoc, SourceLocation CommaLoc, SourceLocation EndLoc) {
1586 return getSema().ActOnOpenMPScheduleClause(
1587 M1, M2, Kind, ChunkSize, StartLoc, LParenLoc, M1Loc, M2Loc, KindLoc,
1588 CommaLoc, EndLoc);
1589 }
1590
1591 /// \brief Build a new OpenMP 'ordered' clause.
1592 ///
1593 /// By default, performs semantic analysis to build the new OpenMP clause.
1594 /// Subclasses may override this routine to provide different behavior.
1595 OMPClause *RebuildOMPOrderedClause(SourceLocation StartLoc,
1596 SourceLocation EndLoc,
1597 SourceLocation LParenLoc, Expr *Num) {
1598 return getSema().ActOnOpenMPOrderedClause(StartLoc, EndLoc, LParenLoc, Num);
1599 }
1600
1601 /// \brief Build a new OpenMP 'private' clause.
1602 ///
1603 /// By default, performs semantic analysis to build the new OpenMP clause.
1604 /// Subclasses may override this routine to provide different behavior.
1605 OMPClause *RebuildOMPPrivateClause(ArrayRef<Expr *> VarList,
1606 SourceLocation StartLoc,
1607 SourceLocation LParenLoc,
1608 SourceLocation EndLoc) {
1609 return getSema().ActOnOpenMPPrivateClause(VarList, StartLoc, LParenLoc,
1610 EndLoc);
1611 }
1612
1613 /// \brief Build a new OpenMP 'firstprivate' clause.
1614 ///
1615 /// By default, performs semantic analysis to build the new OpenMP clause.
1616 /// Subclasses may override this routine to provide different behavior.
1617 OMPClause *RebuildOMPFirstprivateClause(ArrayRef<Expr *> VarList,
1618 SourceLocation StartLoc,
1619 SourceLocation LParenLoc,
1620 SourceLocation EndLoc) {
1621 return getSema().ActOnOpenMPFirstprivateClause(VarList, StartLoc, LParenLoc,
1622 EndLoc);
1623 }
1624
1625 /// \brief Build a new OpenMP 'lastprivate' clause.
1626 ///
1627 /// By default, performs semantic analysis to build the new OpenMP clause.
1628 /// Subclasses may override this routine to provide different behavior.
1629 OMPClause *RebuildOMPLastprivateClause(ArrayRef<Expr *> VarList,
1630 SourceLocation StartLoc,
1631 SourceLocation LParenLoc,
1632 SourceLocation EndLoc) {
1633 return getSema().ActOnOpenMPLastprivateClause(VarList, StartLoc, LParenLoc,
1634 EndLoc);
1635 }
1636
1637 /// \brief Build a new OpenMP 'shared' clause.
1638 ///
1639 /// By default, performs semantic analysis to build the new OpenMP clause.
1640 /// Subclasses may override this routine to provide different behavior.
1641 OMPClause *RebuildOMPSharedClause(ArrayRef<Expr *> VarList,
1642 SourceLocation StartLoc,
1643 SourceLocation LParenLoc,
1644 SourceLocation EndLoc) {
1645 return getSema().ActOnOpenMPSharedClause(VarList, StartLoc, LParenLoc,
1646 EndLoc);
1647 }
1648
1649 /// \brief Build a new OpenMP 'reduction' clause.
1650 ///
1651 /// By default, performs semantic analysis to build the new statement.
1652 /// Subclasses may override this routine to provide different behavior.
1653 OMPClause *RebuildOMPReductionClause(ArrayRef<Expr *> VarList,
1654 SourceLocation StartLoc,
1655 SourceLocation LParenLoc,
1656 SourceLocation ColonLoc,
1657 SourceLocation EndLoc,
1658 CXXScopeSpec &ReductionIdScopeSpec,
1659 const DeclarationNameInfo &ReductionId,
1660 ArrayRef<Expr *> UnresolvedReductions) {
1661 return getSema().ActOnOpenMPReductionClause(
1662 VarList, StartLoc, LParenLoc, ColonLoc, EndLoc, ReductionIdScopeSpec,
1663 ReductionId, UnresolvedReductions);
1664 }
1665
1666 /// Build a new OpenMP 'task_reduction' clause.
1667 ///
1668 /// By default, performs semantic analysis to build the new statement.
1669 /// Subclasses may override this routine to provide different behavior.
1670 OMPClause *RebuildOMPTaskReductionClause(
1671 ArrayRef<Expr *> VarList, SourceLocation StartLoc,
1672 SourceLocation LParenLoc, SourceLocation ColonLoc, SourceLocation EndLoc,
1673 CXXScopeSpec &ReductionIdScopeSpec,
1674 const DeclarationNameInfo &ReductionId,
1675 ArrayRef<Expr *> UnresolvedReductions) {
1676 return getSema().ActOnOpenMPTaskReductionClause(
1677 VarList, StartLoc, LParenLoc, ColonLoc, EndLoc, ReductionIdScopeSpec,
1678 ReductionId, UnresolvedReductions);
1679 }
1680
1681 /// Build a new OpenMP 'in_reduction' clause.
1682 ///
1683 /// By default, performs semantic analysis to build the new statement.
1684 /// Subclasses may override this routine to provide different behavior.
1685 OMPClause *
1686 RebuildOMPInReductionClause(ArrayRef<Expr *> VarList, SourceLocation StartLoc,
1687 SourceLocation LParenLoc, SourceLocation ColonLoc,
1688 SourceLocation EndLoc,
1689 CXXScopeSpec &ReductionIdScopeSpec,
1690 const DeclarationNameInfo &ReductionId,
1691 ArrayRef<Expr *> UnresolvedReductions) {
1692 return getSema().ActOnOpenMPInReductionClause(
1693 VarList, StartLoc, LParenLoc, ColonLoc, EndLoc, ReductionIdScopeSpec,
1694 ReductionId, UnresolvedReductions);
1695 }
1696
1697 /// \brief Build a new OpenMP 'linear' clause.
1698 ///
1699 /// By default, performs semantic analysis to build the new OpenMP clause.
1700 /// Subclasses may override this routine to provide different behavior.
1701 OMPClause *RebuildOMPLinearClause(ArrayRef<Expr *> VarList, Expr *Step,
1702 SourceLocation StartLoc,
1703 SourceLocation LParenLoc,
1704 OpenMPLinearClauseKind Modifier,
1705 SourceLocation ModifierLoc,
1706 SourceLocation ColonLoc,
1707 SourceLocation EndLoc) {
1708 return getSema().ActOnOpenMPLinearClause(VarList, Step, StartLoc, LParenLoc,
1709 Modifier, ModifierLoc, ColonLoc,
1710 EndLoc);
1711 }
1712
1713 /// \brief Build a new OpenMP 'aligned' clause.
1714 ///
1715 /// By default, performs semantic analysis to build the new OpenMP clause.
1716 /// Subclasses may override this routine to provide different behavior.
1717 OMPClause *RebuildOMPAlignedClause(ArrayRef<Expr *> VarList, Expr *Alignment,
1718 SourceLocation StartLoc,
1719 SourceLocation LParenLoc,
1720 SourceLocation ColonLoc,
1721 SourceLocation EndLoc) {
1722 return getSema().ActOnOpenMPAlignedClause(VarList, Alignment, StartLoc,
1723 LParenLoc, ColonLoc, EndLoc);
1724 }
1725
1726 /// \brief Build a new OpenMP 'copyin' clause.
1727 ///
1728 /// By default, performs semantic analysis to build the new OpenMP clause.
1729 /// Subclasses may override this routine to provide different behavior.
1730 OMPClause *RebuildOMPCopyinClause(ArrayRef<Expr *> VarList,
1731 SourceLocation StartLoc,
1732 SourceLocation LParenLoc,
1733 SourceLocation EndLoc) {
1734 return getSema().ActOnOpenMPCopyinClause(VarList, StartLoc, LParenLoc,
1735 EndLoc);
1736 }
1737
1738 /// \brief Build a new OpenMP 'copyprivate' clause.
1739 ///
1740 /// By default, performs semantic analysis to build the new OpenMP clause.
1741 /// Subclasses may override this routine to provide different behavior.
1742 OMPClause *RebuildOMPCopyprivateClause(ArrayRef<Expr *> VarList,
1743 SourceLocation StartLoc,
1744 SourceLocation LParenLoc,
1745 SourceLocation EndLoc) {
1746 return getSema().ActOnOpenMPCopyprivateClause(VarList, StartLoc, LParenLoc,
1747 EndLoc);
1748 }
1749
1750 /// \brief Build a new OpenMP 'flush' pseudo clause.
1751 ///
1752 /// By default, performs semantic analysis to build the new OpenMP clause.
1753 /// Subclasses may override this routine to provide different behavior.
1754 OMPClause *RebuildOMPFlushClause(ArrayRef<Expr *> VarList,
1755 SourceLocation StartLoc,
1756 SourceLocation LParenLoc,
1757 SourceLocation EndLoc) {
1758 return getSema().ActOnOpenMPFlushClause(VarList, StartLoc, LParenLoc,
1759 EndLoc);
1760 }
1761
1762 /// \brief Build a new OpenMP 'depend' pseudo clause.
1763 ///
1764 /// By default, performs semantic analysis to build the new OpenMP clause.
1765 /// Subclasses may override this routine to provide different behavior.
1766 OMPClause *
1767 RebuildOMPDependClause(OpenMPDependClauseKind DepKind, SourceLocation DepLoc,
1768 SourceLocation ColonLoc, ArrayRef<Expr *> VarList,
1769 SourceLocation StartLoc, SourceLocation LParenLoc,
1770 SourceLocation EndLoc) {
1771 return getSema().ActOnOpenMPDependClause(DepKind, DepLoc, ColonLoc, VarList,
1772 StartLoc, LParenLoc, EndLoc);
1773 }
1774
1775 /// \brief Build a new OpenMP 'device' clause.
1776 ///
1777 /// By default, performs semantic analysis to build the new statement.
1778 /// Subclasses may override this routine to provide different behavior.
1779 OMPClause *RebuildOMPDeviceClause(Expr *Device, SourceLocation StartLoc,
1780 SourceLocation LParenLoc,
1781 SourceLocation EndLoc) {
1782 return getSema().ActOnOpenMPDeviceClause(Device, StartLoc, LParenLoc,
1783 EndLoc);
1784 }
1785
1786 /// \brief Build a new OpenMP 'map' clause.
1787 ///
1788 /// By default, performs semantic analysis to build the new OpenMP clause.
1789 /// Subclasses may override this routine to provide different behavior.
1790 OMPClause *
1791 RebuildOMPMapClause(OpenMPMapClauseKind MapTypeModifier,
1792 OpenMPMapClauseKind MapType, bool IsMapTypeImplicit,
1793 SourceLocation MapLoc, SourceLocation ColonLoc,
1794 ArrayRef<Expr *> VarList, SourceLocation StartLoc,
1795 SourceLocation LParenLoc, SourceLocation EndLoc) {
1796 return getSema().ActOnOpenMPMapClause(MapTypeModifier, MapType,
1797 IsMapTypeImplicit, MapLoc, ColonLoc,
1798 VarList, StartLoc, LParenLoc, EndLoc);
1799 }
1800
1801 /// \brief Build a new OpenMP 'num_teams' clause.
1802 ///
1803 /// By default, performs semantic analysis to build the new statement.
1804 /// Subclasses may override this routine to provide different behavior.
1805 OMPClause *RebuildOMPNumTeamsClause(Expr *NumTeams, SourceLocation StartLoc,
1806 SourceLocation LParenLoc,
1807 SourceLocation EndLoc) {
1808 return getSema().ActOnOpenMPNumTeamsClause(NumTeams, StartLoc, LParenLoc,
1809 EndLoc);
1810 }
1811
1812 /// \brief Build a new OpenMP 'thread_limit' clause.
1813 ///
1814 /// By default, performs semantic analysis to build the new statement.
1815 /// Subclasses may override this routine to provide different behavior.
1816 OMPClause *RebuildOMPThreadLimitClause(Expr *ThreadLimit,
1817 SourceLocation StartLoc,
1818 SourceLocation LParenLoc,
1819 SourceLocation EndLoc) {
1820 return getSema().ActOnOpenMPThreadLimitClause(ThreadLimit, StartLoc,
1821 LParenLoc, EndLoc);
1822 }
1823
1824 /// \brief Build a new OpenMP 'priority' clause.
1825 ///
1826 /// By default, performs semantic analysis to build the new statement.
1827 /// Subclasses may override this routine to provide different behavior.
1828 OMPClause *RebuildOMPPriorityClause(Expr *Priority, SourceLocation StartLoc,
1829 SourceLocation LParenLoc,
1830 SourceLocation EndLoc) {
1831 return getSema().ActOnOpenMPPriorityClause(Priority, StartLoc, LParenLoc,
1832 EndLoc);
1833 }
1834
1835 /// \brief Build a new OpenMP 'grainsize' clause.
1836 ///
1837 /// By default, performs semantic analysis to build the new statement.
1838 /// Subclasses may override this routine to provide different behavior.
1839 OMPClause *RebuildOMPGrainsizeClause(Expr *Grainsize, SourceLocation StartLoc,
1840 SourceLocation LParenLoc,
1841 SourceLocation EndLoc) {
1842 return getSema().ActOnOpenMPGrainsizeClause(Grainsize, StartLoc, LParenLoc,
1843 EndLoc);
1844 }
1845
1846 /// \brief Build a new OpenMP 'num_tasks' clause.
1847 ///
1848 /// By default, performs semantic analysis to build the new statement.
1849 /// Subclasses may override this routine to provide different behavior.
1850 OMPClause *RebuildOMPNumTasksClause(Expr *NumTasks, SourceLocation StartLoc,
1851 SourceLocation LParenLoc,
1852 SourceLocation EndLoc) {
1853 return getSema().ActOnOpenMPNumTasksClause(NumTasks, StartLoc, LParenLoc,
1854 EndLoc);
1855 }
1856
1857 /// \brief Build a new OpenMP 'hint' clause.
1858 ///
1859 /// By default, performs semantic analysis to build the new statement.
1860 /// Subclasses may override this routine to provide different behavior.
1861 OMPClause *RebuildOMPHintClause(Expr *Hint, SourceLocation StartLoc,
1862 SourceLocation LParenLoc,
1863 SourceLocation EndLoc) {
1864 return getSema().ActOnOpenMPHintClause(Hint, StartLoc, LParenLoc, EndLoc);
1865 }
1866
1867 /// \brief Build a new OpenMP 'dist_schedule' clause.
1868 ///
1869 /// By default, performs semantic analysis to build the new OpenMP clause.
1870 /// Subclasses may override this routine to provide different behavior.
1871 OMPClause *
1872 RebuildOMPDistScheduleClause(OpenMPDistScheduleClauseKind Kind,
1873 Expr *ChunkSize, SourceLocation StartLoc,
1874 SourceLocation LParenLoc, SourceLocation KindLoc,
1875 SourceLocation CommaLoc, SourceLocation EndLoc) {
1876 return getSema().ActOnOpenMPDistScheduleClause(
1877 Kind, ChunkSize, StartLoc, LParenLoc, KindLoc, CommaLoc, EndLoc);
1878 }
1879
1880 /// \brief Build a new OpenMP 'to' clause.
1881 ///
1882 /// By default, performs semantic analysis to build the new statement.
1883 /// Subclasses may override this routine to provide different behavior.
1884 OMPClause *RebuildOMPToClause(ArrayRef<Expr *> VarList,
1885 SourceLocation StartLoc,
1886 SourceLocation LParenLoc,
1887 SourceLocation EndLoc) {
1888 return getSema().ActOnOpenMPToClause(VarList, StartLoc, LParenLoc, EndLoc);
1889 }
1890
1891 /// \brief Build a new OpenMP 'from' clause.
1892 ///
1893 /// By default, performs semantic analysis to build the new statement.
1894 /// Subclasses may override this routine to provide different behavior.
1895 OMPClause *RebuildOMPFromClause(ArrayRef<Expr *> VarList,
1896 SourceLocation StartLoc,
1897 SourceLocation LParenLoc,
1898 SourceLocation EndLoc) {
1899 return getSema().ActOnOpenMPFromClause(VarList, StartLoc, LParenLoc,
1900 EndLoc);
1901 }
1902
1903 /// Build a new OpenMP 'use_device_ptr' clause.
1904 ///
1905 /// By default, performs semantic analysis to build the new OpenMP clause.
1906 /// Subclasses may override this routine to provide different behavior.
1907 OMPClause *RebuildOMPUseDevicePtrClause(ArrayRef<Expr *> VarList,
1908 SourceLocation StartLoc,
1909 SourceLocation LParenLoc,
1910 SourceLocation EndLoc) {
1911 return getSema().ActOnOpenMPUseDevicePtrClause(VarList, StartLoc, LParenLoc,
1912 EndLoc);
1913 }
1914
1915 /// Build a new OpenMP 'is_device_ptr' clause.
1916 ///
1917 /// By default, performs semantic analysis to build the new OpenMP clause.
1918 /// Subclasses may override this routine to provide different behavior.
1919 OMPClause *RebuildOMPIsDevicePtrClause(ArrayRef<Expr *> VarList,
1920 SourceLocation StartLoc,
1921 SourceLocation LParenLoc,
1922 SourceLocation EndLoc) {
1923 return getSema().ActOnOpenMPIsDevicePtrClause(VarList, StartLoc, LParenLoc,
1924 EndLoc);
1925 }
1926
1927 /// \brief Rebuild the operand to an Objective-C \@synchronized statement.
1928 ///
1929 /// By default, performs semantic analysis to build the new statement.
1930 /// Subclasses may override this routine to provide different behavior.
1931 ExprResult RebuildObjCAtSynchronizedOperand(SourceLocation atLoc,
1932 Expr *object) {
1933 return getSema().ActOnObjCAtSynchronizedOperand(atLoc, object);
1934 }
1935
1936 /// \brief Build a new Objective-C \@synchronized statement.
1937 ///
1938 /// By default, performs semantic analysis to build the new statement.
1939 /// Subclasses may override this routine to provide different behavior.
1940 StmtResult RebuildObjCAtSynchronizedStmt(SourceLocation AtLoc,
1941 Expr *Object, Stmt *Body) {
1942 return getSema().ActOnObjCAtSynchronizedStmt(AtLoc, Object, Body);
1943 }
1944
1945 /// \brief Build a new Objective-C \@autoreleasepool statement.
1946 ///
1947 /// By default, performs semantic analysis to build the new statement.
1948 /// Subclasses may override this routine to provide different behavior.
1949 StmtResult RebuildObjCAutoreleasePoolStmt(SourceLocation AtLoc,
1950 Stmt *Body) {
1951 return getSema().ActOnObjCAutoreleasePoolStmt(AtLoc, Body);
1952 }
1953
1954 /// \brief Build a new Objective-C fast enumeration statement.
1955 ///
1956 /// By default, performs semantic analysis to build the new statement.
1957 /// Subclasses may override this routine to provide different behavior.
1958 StmtResult RebuildObjCForCollectionStmt(SourceLocation ForLoc,
1959 Stmt *Element,
1960 Expr *Collection,
1961 SourceLocation RParenLoc,
1962 Stmt *Body) {
1963 StmtResult ForEachStmt = getSema().ActOnObjCForCollectionStmt(ForLoc,
1964 Element,
1965 Collection,
1966 RParenLoc);
1967 if (ForEachStmt.isInvalid())
1968 return StmtError();
1969
1970 return getSema().FinishObjCForCollectionStmt(ForEachStmt.get(), Body);
1971 }
1972
1973 /// \brief Build a new C++ exception declaration.
1974 ///
1975 /// By default, performs semantic analysis to build the new decaration.
1976 /// Subclasses may override this routine to provide different behavior.
1977 VarDecl *RebuildExceptionDecl(VarDecl *ExceptionDecl,
1978 TypeSourceInfo *Declarator,
1979 SourceLocation StartLoc,
1980 SourceLocation IdLoc,
1981 IdentifierInfo *Id) {
1982 VarDecl *Var = getSema().BuildExceptionDeclaration(nullptr, Declarator,
1983 StartLoc, IdLoc, Id);
1984 if (Var)
1985 getSema().CurContext->addDecl(Var);
1986 return Var;
1987 }
1988
1989 /// \brief Build a new C++ catch statement.
1990 ///
1991 /// By default, performs semantic analysis to build the new statement.
1992 /// Subclasses may override this routine to provide different behavior.
1993 StmtResult RebuildCXXCatchStmt(SourceLocation CatchLoc,
1994 VarDecl *ExceptionDecl,
1995 Stmt *Handler) {
1996 return Owned(new (getSema().Context) CXXCatchStmt(CatchLoc, ExceptionDecl,
1997 Handler));
1998 }
1999
2000 /// \brief Build a new C++ try statement.
2001 ///
2002 /// By default, performs semantic analysis to build the new statement.
2003 /// Subclasses may override this routine to provide different behavior.
2004 StmtResult RebuildCXXTryStmt(SourceLocation TryLoc, Stmt *TryBlock,
2005 ArrayRef<Stmt *> Handlers) {
2006 return getSema().ActOnCXXTryBlock(TryLoc, TryBlock, Handlers);
2007 }
2008
2009 /// \brief Build a new C++0x range-based for statement.
2010 ///
2011 /// By default, performs semantic analysis to build the new statement.
2012 /// Subclasses may override this routine to provide different behavior.
2013 StmtResult RebuildCXXForRangeStmt(SourceLocation ForLoc,
2014 SourceLocation CoawaitLoc,
2015 SourceLocation ColonLoc,
2016 Stmt *Range, Stmt *Begin, Stmt *End,
2017 Expr *Cond, Expr *Inc,
2018 Stmt *LoopVar,
2019 SourceLocation RParenLoc) {
2020 // If we've just learned that the range is actually an Objective-C
2021 // collection, treat this as an Objective-C fast enumeration loop.
2022 if (DeclStmt *RangeStmt = dyn_cast<DeclStmt>(Range)) {
2023 if (RangeStmt->isSingleDecl()) {
2024 if (VarDecl *RangeVar = dyn_cast<VarDecl>(RangeStmt->getSingleDecl())) {
2025 if (RangeVar->isInvalidDecl())
2026 return StmtError();
2027
2028 Expr *RangeExpr = RangeVar->getInit();
2029 if (!RangeExpr->isTypeDependent() &&
2030 RangeExpr->getType()->isObjCObjectPointerType())
2031 return getSema().ActOnObjCForCollectionStmt(ForLoc, LoopVar, RangeExpr,
2032 RParenLoc);
2033 }
2034 }
2035 }
2036
2037 return getSema().BuildCXXForRangeStmt(ForLoc, CoawaitLoc, ColonLoc,
2038 Range, Begin, End,
2039 Cond, Inc, LoopVar, RParenLoc,
2040 Sema::BFRK_Rebuild);
2041 }
2042
2043 /// \brief Build a new C++0x range-based for statement.
2044 ///
2045 /// By default, performs semantic analysis to build the new statement.
2046 /// Subclasses may override this routine to provide different behavior.
2047 StmtResult RebuildMSDependentExistsStmt(SourceLocation KeywordLoc,
2048 bool IsIfExists,
2049 NestedNameSpecifierLoc QualifierLoc,
2050 DeclarationNameInfo NameInfo,
2051 Stmt *Nested) {
2052 return getSema().BuildMSDependentExistsStmt(KeywordLoc, IsIfExists,
2053 QualifierLoc, NameInfo, Nested);
2054 }
2055
2056 /// \brief Attach body to a C++0x range-based for statement.
2057 ///
2058 /// By default, performs semantic analysis to finish the new statement.
2059 /// Subclasses may override this routine to provide different behavior.
2060 StmtResult FinishCXXForRangeStmt(Stmt *ForRange, Stmt *Body) {
2061 return getSema().FinishCXXForRangeStmt(ForRange, Body);
2062 }
2063
2064 StmtResult RebuildSEHTryStmt(bool IsCXXTry, SourceLocation TryLoc,
2065 Stmt *TryBlock, Stmt *Handler) {
2066 return getSema().ActOnSEHTryBlock(IsCXXTry, TryLoc, TryBlock, Handler);
2067 }
2068
2069 StmtResult RebuildSEHExceptStmt(SourceLocation Loc, Expr *FilterExpr,
2070 Stmt *Block) {
2071 return getSema().ActOnSEHExceptBlock(Loc, FilterExpr, Block);
2072 }
2073
2074 StmtResult RebuildSEHFinallyStmt(SourceLocation Loc, Stmt *Block) {
2075 return SEHFinallyStmt::Create(getSema().getASTContext(), Loc, Block);
2076 }
2077
2078 /// \brief Build a new predefined expression.
2079 ///
2080 /// By default, performs semantic analysis to build the new expression.
2081 /// Subclasses may override this routine to provide different behavior.
2082 ExprResult RebuildPredefinedExpr(SourceLocation Loc,
2083 PredefinedExpr::IdentType IT) {
2084 return getSema().BuildPredefinedExpr(Loc, IT);
2085 }
2086
2087 /// \brief Build a new expression that references a declaration.
2088 ///
2089 /// By default, performs semantic analysis to build the new expression.
2090 /// Subclasses may override this routine to provide different behavior.
2091 ExprResult RebuildDeclarationNameExpr(const CXXScopeSpec &SS,
2092 LookupResult &R,
2093 bool RequiresADL) {
2094 return getSema().BuildDeclarationNameExpr(SS, R, RequiresADL);
2095 }
2096
2097
2098 /// \brief Build a new expression that references a declaration.
2099 ///
2100 /// By default, performs semantic analysis to build the new expression.
2101 /// Subclasses may override this routine to provide different behavior.
2102 ExprResult RebuildDeclRefExpr(NestedNameSpecifierLoc QualifierLoc,
2103 ValueDecl *VD,
2104 const DeclarationNameInfo &NameInfo,
2105 TemplateArgumentListInfo *TemplateArgs) {
2106 CXXScopeSpec SS;
2107 SS.Adopt(QualifierLoc);
2108
2109 // FIXME: loses template args.
2110
2111 return getSema().BuildDeclarationNameExpr(SS, NameInfo, VD);
2112 }
2113
2114 /// \brief Build a new expression in parentheses.
2115 ///
2116 /// By default, performs semantic analysis to build the new expression.
2117 /// Subclasses may override this routine to provide different behavior.
2118 ExprResult RebuildParenExpr(Expr *SubExpr, SourceLocation LParen,
2119 SourceLocation RParen) {
2120 return getSema().ActOnParenExpr(LParen, RParen, SubExpr);
2121 }
2122
2123 /// \brief Build a new pseudo-destructor expression.
2124 ///
2125 /// By default, performs semantic analysis to build the new expression.
2126 /// Subclasses may override this routine to provide different behavior.
2127 ExprResult RebuildCXXPseudoDestructorExpr(Expr *Base,
2128 SourceLocation OperatorLoc,
2129 bool isArrow,
2130 CXXScopeSpec &SS,
2131 TypeSourceInfo *ScopeType,
2132 SourceLocation CCLoc,
2133 SourceLocation TildeLoc,
2134 PseudoDestructorTypeStorage Destroyed);
2135
2136 /// \brief Build a new unary operator expression.
2137 ///
2138 /// By default, performs semantic analysis to build the new expression.
2139 /// Subclasses may override this routine to provide different behavior.
2140 ExprResult RebuildUnaryOperator(SourceLocation OpLoc,
2141 UnaryOperatorKind Opc,
2142 Expr *SubExpr) {
2143 return getSema().BuildUnaryOp(/*Scope=*/nullptr, OpLoc, Opc, SubExpr);
2144 }
2145
2146 /// \brief Build a new builtin offsetof expression.
2147 ///
2148 /// By default, performs semantic analysis to build the new expression.
2149 /// Subclasses may override this routine to provide different behavior.
2150 ExprResult RebuildOffsetOfExpr(SourceLocation OperatorLoc,
2151 TypeSourceInfo *Type,
2152 ArrayRef<Sema::OffsetOfComponent> Components,
2153 SourceLocation RParenLoc) {
2154 return getSema().BuildBuiltinOffsetOf(OperatorLoc, Type, Components,
2155 RParenLoc);
2156 }
2157
2158 /// \brief Build a new sizeof, alignof or vec_step expression with a
2159 /// type argument.
2160 ///
2161 /// By default, performs semantic analysis to build the new expression.
2162 /// Subclasses may override this routine to provide different behavior.
2163 ExprResult RebuildUnaryExprOrTypeTrait(TypeSourceInfo *TInfo,
2164 SourceLocation OpLoc,
2165 UnaryExprOrTypeTrait ExprKind,
2166 SourceRange R) {
2167 return getSema().CreateUnaryExprOrTypeTraitExpr(TInfo, OpLoc, ExprKind, R);
2168 }
2169
2170 /// \brief Build a new sizeof, alignof or vec step expression with an
2171 /// expression argument.
2172 ///
2173 /// By default, performs semantic analysis to build the new expression.
2174 /// Subclasses may override this routine to provide different behavior.
2175 ExprResult RebuildUnaryExprOrTypeTrait(Expr *SubExpr, SourceLocation OpLoc,
2176 UnaryExprOrTypeTrait ExprKind,
2177 SourceRange R) {
2178 ExprResult Result
2179 = getSema().CreateUnaryExprOrTypeTraitExpr(SubExpr, OpLoc, ExprKind);
2180 if (Result.isInvalid())
2181 return ExprError();
2182
2183 return Result;
2184 }
2185
2186 /// \brief Build a new array subscript expression.
2187 ///
2188 /// By default, performs semantic analysis to build the new expression.
2189 /// Subclasses may override this routine to provide different behavior.
2190 ExprResult RebuildArraySubscriptExpr(Expr *LHS,
2191 SourceLocation LBracketLoc,
2192 Expr *RHS,
2193 SourceLocation RBracketLoc) {
2194 return getSema().ActOnArraySubscriptExpr(/*Scope=*/nullptr, LHS,
2195 LBracketLoc, RHS,
2196 RBracketLoc);
2197 }
2198
2199 /// \brief Build a new array section expression.
2200 ///
2201 /// By default, performs semantic analysis to build the new expression.
2202 /// Subclasses may override this routine to provide different behavior.
2203 ExprResult RebuildOMPArraySectionExpr(Expr *Base, SourceLocation LBracketLoc,
2204 Expr *LowerBound,
2205 SourceLocation ColonLoc, Expr *Length,
2206 SourceLocation RBracketLoc) {
2207 return getSema().ActOnOMPArraySectionExpr(Base, LBracketLoc, LowerBound,
2208 ColonLoc, Length, RBracketLoc);
2209 }
2210
2211 /// \brief Build a new call expression.
2212 ///
2213 /// By default, performs semantic analysis to build the new expression.
2214 /// Subclasses may override this routine to provide different behavior.
2215 ExprResult RebuildCallExpr(Expr *Callee, SourceLocation LParenLoc,
2216 MultiExprArg Args,
2217 SourceLocation RParenLoc,
2218 Expr *ExecConfig = nullptr) {
2219 return getSema().ActOnCallExpr(/*Scope=*/nullptr, Callee, LParenLoc,
2220 Args, RParenLoc, ExecConfig);
2221 }
2222
2223 /// \brief Build a new member access expression.
2224 ///
2225 /// By default, performs semantic analysis to build the new expression.
2226 /// Subclasses may override this routine to provide different behavior.
2227 ExprResult RebuildMemberExpr(Expr *Base, SourceLocation OpLoc,
2228 bool isArrow,
2229 NestedNameSpecifierLoc QualifierLoc,
2230 SourceLocation TemplateKWLoc,
2231 const DeclarationNameInfo &MemberNameInfo,
2232 ValueDecl *Member,
2233 NamedDecl *FoundDecl,
2234 const TemplateArgumentListInfo *ExplicitTemplateArgs,
2235 NamedDecl *FirstQualifierInScope) {
2236 ExprResult BaseResult = getSema().PerformMemberExprBaseConversion(Base,
2237 isArrow);
2238 if (!Member->getDeclName()) {
2239 // We have a reference to an unnamed field. This is always the
2240 // base of an anonymous struct/union member access, i.e. the
2241 // field is always of record type.
2242 assert(!QualifierLoc && "Can't have an unnamed field with a qualifier!")(static_cast <bool> (!QualifierLoc && "Can't have an unnamed field with a qualifier!"
) ? void (0) : __assert_fail ("!QualifierLoc && \"Can't have an unnamed field with a qualifier!\""
, "/build/llvm-toolchain-snapshot-7~svn325118/tools/clang/lib/Sema/TreeTransform.h"
, 2242, __extension__ __PRETTY_FUNCTION__))
;
2243 assert(Member->getType()->isRecordType() &&(static_cast <bool> (Member->getType()->isRecordType
() && "unnamed member not of record type?") ? void (0
) : __assert_fail ("Member->getType()->isRecordType() && \"unnamed member not of record type?\""
, "/build/llvm-toolchain-snapshot-7~svn325118/tools/clang/lib/Sema/TreeTransform.h"
, 2244, __extension__ __PRETTY_FUNCTION__))
2244 "unnamed member not of record type?")(static_cast <bool> (Member->getType()->isRecordType
() && "unnamed member not of record type?") ? void (0
) : __assert_fail ("Member->getType()->isRecordType() && \"unnamed member not of record type?\""
, "/build/llvm-toolchain-snapshot-7~svn325118/tools/clang/lib/Sema/TreeTransform.h"
, 2244, __extension__ __PRETTY_FUNCTION__))
;
2245
2246 BaseResult =
2247 getSema().PerformObjectMemberConversion(BaseResult.get(),
2248 QualifierLoc.getNestedNameSpecifier(),
2249 FoundDecl, Member);
2250 if (BaseResult.isInvalid())
2251 return ExprError();
2252 Base = BaseResult.get();
2253 ExprValueKind VK = isArrow ? VK_LValue : Base->getValueKind();
2254 MemberExpr *ME = new (getSema().Context)
2255 MemberExpr(Base, isArrow, OpLoc, Member, MemberNameInfo,
2256 cast<FieldDecl>(Member)->getType(), VK, OK_Ordinary);
2257 return ME;
2258 }
2259
2260 CXXScopeSpec SS;
2261 SS.Adopt(QualifierLoc);
2262
2263 Base = BaseResult.get();
2264 QualType BaseType = Base->getType();
2265
2266 if (isArrow && !BaseType->isPointerType())
2267 return ExprError();
2268
2269 // FIXME: this involves duplicating earlier analysis in a lot of
2270 // cases; we should avoid this when possible.
2271 LookupResult R(getSema(), MemberNameInfo, Sema::LookupMemberName);
2272 R.addDecl(FoundDecl);
2273 R.resolveKind();
2274
2275 return getSema().BuildMemberReferenceExpr(Base, BaseType, OpLoc, isArrow,
2276 SS, TemplateKWLoc,
2277 FirstQualifierInScope,
2278 R, ExplicitTemplateArgs,
2279 /*S*/nullptr);
2280 }
2281
2282 /// \brief Build a new binary operator expression.
2283 ///
2284 /// By default, performs semantic analysis to build the new expression.
2285 /// Subclasses may override this routine to provide different behavior.
2286 ExprResult RebuildBinaryOperator(SourceLocation OpLoc,
2287 BinaryOperatorKind Opc,
2288 Expr *LHS, Expr *RHS) {
2289 return getSema().BuildBinOp(/*Scope=*/nullptr, OpLoc, Opc, LHS, RHS);
2290 }
2291
2292 /// \brief Build a new conditional operator expression.
2293 ///
2294 /// By default, performs semantic analysis to build the new expression.
2295 /// Subclasses may override this routine to provide different behavior.
2296 ExprResult RebuildConditionalOperator(Expr *Cond,
2297 SourceLocation QuestionLoc,
2298 Expr *LHS,
2299 SourceLocation ColonLoc,
2300 Expr *RHS) {
2301 return getSema().ActOnConditionalOp(QuestionLoc, ColonLoc, Cond,
2302 LHS, RHS);
2303 }
2304
2305 /// \brief Build a new C-style cast expression.
2306 ///
2307 /// By default, performs semantic analysis to build the new expression.
2308 /// Subclasses may override this routine to provide different behavior.
2309 ExprResult RebuildCStyleCastExpr(SourceLocation LParenLoc,
2310 TypeSourceInfo *TInfo,
2311 SourceLocation RParenLoc,
2312 Expr *SubExpr) {
2313 return getSema().BuildCStyleCastExpr(LParenLoc, TInfo, RParenLoc,
2314 SubExpr);
2315 }
2316
2317 /// \brief Build a new compound literal expression.
2318 ///
2319 /// By default, performs semantic analysis to build the new expression.
2320 /// Subclasses may override this routine to provide different behavior.
2321 ExprResult RebuildCompoundLiteralExpr(SourceLocation LParenLoc,
2322 TypeSourceInfo *TInfo,
2323 SourceLocation RParenLoc,
2324 Expr *Init) {
2325 return getSema().BuildCompoundLiteralExpr(LParenLoc, TInfo, RParenLoc,
2326 Init);
2327 }
2328
2329 /// \brief Build a new extended vector element access expression.
2330 ///
2331 /// By default, performs semantic analysis to build the new expression.
2332 /// Subclasses may override this routine to provide different behavior.
2333 ExprResult RebuildExtVectorElementExpr(Expr *Base,
2334 SourceLocation OpLoc,
2335 SourceLocation AccessorLoc,
2336 IdentifierInfo &Accessor) {
2337
2338 CXXScopeSpec SS;
2339 DeclarationNameInfo NameInfo(&Accessor, AccessorLoc);
2340 return getSema().BuildMemberReferenceExpr(Base, Base->getType(),
2341 OpLoc, /*IsArrow*/ false,
2342 SS, SourceLocation(),
2343 /*FirstQualifierInScope*/ nullptr,
2344 NameInfo,
2345 /* TemplateArgs */ nullptr,
2346 /*S*/ nullptr);
2347 }
2348
2349 /// \brief Build a new initializer list expression.
2350 ///
2351 /// By default, performs semantic analysis to build the new expression.
2352 /// Subclasses may override this routine to provide different behavior.
2353 ExprResult RebuildInitList(SourceLocation LBraceLoc,
2354 MultiExprArg Inits,
2355 SourceLocation RBraceLoc) {
2356 return SemaRef.ActOnInitList(LBraceLoc, Inits, RBraceLoc);
2357 }
2358
2359 /// \brief Build a new designated initializer expression.
2360 ///
2361 /// By default, performs semantic analysis to build the new expression.
2362 /// Subclasses may override this routine to provide different behavior.
2363 ExprResult RebuildDesignatedInitExpr(Designation &Desig,
2364 MultiExprArg ArrayExprs,
2365 SourceLocation EqualOrColonLoc,
2366 bool GNUSyntax,
2367 Expr *Init) {
2368 ExprResult Result
2369 = SemaRef.ActOnDesignatedInitializer(Desig, EqualOrColonLoc, GNUSyntax,
2370 Init);
2371 if (Result.isInvalid())
2372 return ExprError();
2373
2374 return Result;
2375 }
2376
2377 /// \brief Build a new value-initialized expression.
2378 ///
2379 /// By default, builds the implicit value initialization without performing
2380 /// any semantic analysis. Subclasses may override this routine to provide
2381 /// different behavior.
2382 ExprResult RebuildImplicitValueInitExpr(QualType T) {
2383 return new (SemaRef.Context) ImplicitValueInitExpr(T);
2384 }
2385
2386 /// \brief Build a new \c va_arg expression.
2387 ///
2388 /// By default, performs semantic analysis to build the new expression.
2389 /// Subclasses may override this routine to provide different behavior.
2390 ExprResult RebuildVAArgExpr(SourceLocation BuiltinLoc,
2391 Expr *SubExpr, TypeSourceInfo *TInfo,
2392 SourceLocation RParenLoc) {
2393 return getSema().BuildVAArgExpr(BuiltinLoc,
2394 SubExpr, TInfo,
2395 RParenLoc);
2396 }
2397
2398 /// \brief Build a new expression list in parentheses.
2399 ///
2400 /// By default, performs semantic analysis to build the new expression.
2401 /// Subclasses may override this routine to provide different behavior.
2402 ExprResult RebuildParenListExpr(SourceLocation LParenLoc,
2403 MultiExprArg SubExprs,
2404 SourceLocation RParenLoc) {
2405 return getSema().ActOnParenListExpr(LParenLoc, RParenLoc, SubExprs);
2406 }
2407
2408 /// \brief Build a new address-of-label expression.
2409 ///
2410 /// By default, performs semantic analysis, using the name of the label
2411 /// rather than attempting to map the label statement itself.
2412 /// Subclasses may override this routine to provide different behavior.
2413 ExprResult RebuildAddrLabelExpr(SourceLocation AmpAmpLoc,
2414 SourceLocation LabelLoc, LabelDecl *Label) {
2415 return getSema().ActOnAddrLabel(AmpAmpLoc, LabelLoc, Label);
2416 }
2417
2418 /// \brief Build a new GNU statement expression.
2419 ///
2420 /// By default, performs semantic analysis to build the new expression.
2421 /// Subclasses may override this routine to provide different behavior.
2422 ExprResult RebuildStmtExpr(SourceLocation LParenLoc,
2423 Stmt *SubStmt,
2424 SourceLocation RParenLoc) {
2425 return getSema().ActOnStmtExpr(LParenLoc, SubStmt, RParenLoc);
2426 }
2427
2428 /// \brief Build a new __builtin_choose_expr expression.
2429 ///
2430 /// By default, performs semantic analysis to build the new expression.
2431 /// Subclasses may override this routine to provide different behavior.
2432 ExprResult RebuildChooseExpr(SourceLocation BuiltinLoc,
2433 Expr *Cond, Expr *LHS, Expr *RHS,
2434 SourceLocation RParenLoc) {
2435 return SemaRef.ActOnChooseExpr(BuiltinLoc,
2436 Cond, LHS, RHS,
2437 RParenLoc);
2438 }
2439
2440 /// \brief Build a new generic selection expression.
2441 ///
2442 /// By default, performs semantic analysis to build the new expression.
2443 /// Subclasses may override this routine to provide different behavior.
2444 ExprResult RebuildGenericSelectionExpr(SourceLocation KeyLoc,
2445 SourceLocation DefaultLoc,
2446 SourceLocation RParenLoc,
2447 Expr *ControllingExpr,
2448 ArrayRef<TypeSourceInfo *> Types,
2449 ArrayRef<Expr *> Exprs) {
2450 return getSema().CreateGenericSelectionExpr(KeyLoc, DefaultLoc, RParenLoc,
2451 ControllingExpr, Types, Exprs);
2452 }
2453
2454 /// \brief Build a new overloaded operator call expression.
2455 ///
2456 /// By default, performs semantic analysis to build the new expression.
2457 /// The semantic analysis provides the behavior of template instantiation,
2458 /// copying with transformations that turn what looks like an overloaded
2459 /// operator call into a use of a builtin operator, performing
2460 /// argument-dependent lookup, etc. Subclasses may override this routine to
2461 /// provide different behavior.
2462 ExprResult RebuildCXXOperatorCallExpr(OverloadedOperatorKind Op,
2463 SourceLocation OpLoc,
2464 Expr *Callee,
2465 Expr *First,
2466 Expr *Second);
2467
2468 /// \brief Build a new C++ "named" cast expression, such as static_cast or
2469 /// reinterpret_cast.
2470 ///
2471 /// By default, this routine dispatches to one of the more-specific routines
2472 /// for a particular named case, e.g., RebuildCXXStaticCastExpr().
2473 /// Subclasses may override this routine to provide different behavior.
2474 ExprResult RebuildCXXNamedCastExpr(SourceLocation OpLoc,
2475 Stmt::StmtClass Class,
2476 SourceLocation LAngleLoc,
2477 TypeSourceInfo *TInfo,
2478 SourceLocation RAngleLoc,
2479 SourceLocation LParenLoc,
2480 Expr *SubExpr,
2481 SourceLocation RParenLoc) {
2482 switch (Class) {
2483 case Stmt::CXXStaticCastExprClass:
2484 return getDerived().RebuildCXXStaticCastExpr(OpLoc, LAngleLoc, TInfo,
2485 RAngleLoc, LParenLoc,
2486 SubExpr, RParenLoc);
2487
2488 case Stmt::CXXDynamicCastExprClass:
2489 return getDerived().RebuildCXXDynamicCastExpr(OpLoc, LAngleLoc, TInfo,
2490 RAngleLoc, LParenLoc,
2491 SubExpr, RParenLoc);
2492
2493 case Stmt::CXXReinterpretCastExprClass:
2494 return getDerived().RebuildCXXReinterpretCastExpr(OpLoc, LAngleLoc, TInfo,
2495 RAngleLoc, LParenLoc,
2496 SubExpr,
2497 RParenLoc);
2498
2499 case Stmt::CXXConstCastExprClass:
2500 return getDerived().RebuildCXXConstCastExpr(OpLoc, LAngleLoc, TInfo,
2501 RAngleLoc, LParenLoc,
2502 SubExpr, RParenLoc);
2503
2504 default:
2505 llvm_unreachable("Invalid C++ named cast")::llvm::llvm_unreachable_internal("Invalid C++ named cast", "/build/llvm-toolchain-snapshot-7~svn325118/tools/clang/lib/Sema/TreeTransform.h"
, 2505)
;
2506 }
2507 }
2508
2509 /// \brief Build a new C++ static_cast expression.
2510 ///
2511 /// By default, performs semantic analysis to build the new expression.
2512 /// Subclasses may override this routine to provide different behavior.
2513 ExprResult RebuildCXXStaticCastExpr(SourceLocation OpLoc,
2514 SourceLocation LAngleLoc,
2515 TypeSourceInfo *TInfo,
2516 SourceLocation RAngleLoc,
2517 SourceLocation LParenLoc,
2518 Expr *SubExpr,
2519 SourceLocation RParenLoc) {
2520 return getSema().BuildCXXNamedCast(OpLoc, tok::kw_static_cast,
2521 TInfo, SubExpr,
2522 SourceRange(LAngleLoc, RAngleLoc),
2523 SourceRange(LParenLoc, RParenLoc));
2524 }
2525
2526 /// \brief Build a new C++ dynamic_cast expression.
2527 ///
2528 /// By default, performs semantic analysis to build the new expression.
2529 /// Subclasses may override this routine to provide different behavior.
2530 ExprResult RebuildCXXDynamicCastExpr(SourceLocation OpLoc,
2531 SourceLocation LAngleLoc,
2532 TypeSourceInfo *TInfo,
2533 SourceLocation RAngleLoc,
2534 SourceLocation LParenLoc,
2535 Expr *SubExpr,
2536 SourceLocation RParenLoc) {
2537 return getSema().BuildCXXNamedCast(OpLoc, tok::kw_dynamic_cast,
2538 TInfo, SubExpr,
2539 SourceRange(LAngleLoc, RAngleLoc),
2540 SourceRange(LParenLoc, RParenLoc));
2541 }
2542
2543 /// \brief Build a new C++ reinterpret_cast expression.
2544 ///
2545 /// By default, performs semantic analysis to build the new expression.
2546 /// Subclasses may override this routine to provide different behavior.
2547 ExprResult RebuildCXXReinterpretCastExpr(SourceLocation OpLoc,
2548 SourceLocation LAngleLoc,
2549 TypeSourceInfo *TInfo,
2550 SourceLocation RAngleLoc,
2551 SourceLocation LParenLoc,
2552 Expr *SubExpr,
2553 SourceLocation RParenLoc) {
2554 return getSema().BuildCXXNamedCast(OpLoc, tok::kw_reinterpret_cast,
2555 TInfo, SubExpr,
2556 SourceRange(LAngleLoc, RAngleLoc),
2557 SourceRange(LParenLoc, RParenLoc));
2558 }
2559
2560 /// \brief Build a new C++ const_cast expression.
2561 ///
2562 /// By default, performs semantic analysis to build the new expression.
2563 /// Subclasses may override this routine to provide different behavior.
2564 ExprResult RebuildCXXConstCastExpr(SourceLocation OpLoc,
2565 SourceLocation LAngleLoc,
2566 TypeSourceInfo *TInfo,
2567 SourceLocation RAngleLoc,
2568 SourceLocation LParenLoc,
2569 Expr *SubExpr,
2570 SourceLocation RParenLoc) {
2571 return getSema().BuildCXXNamedCast(OpLoc, tok::kw_const_cast,
2572 TInfo, SubExpr,
2573 SourceRange(LAngleLoc, RAngleLoc),
2574 SourceRange(LParenLoc, RParenLoc));
2575 }
2576
2577 /// \brief Build a new C++ functional-style cast expression.
2578 ///
2579 /// By default, performs semantic analysis to build the new expression.
2580 /// Subclasses may override this routine to provide different behavior.
2581 ExprResult RebuildCXXFunctionalCastExpr(TypeSourceInfo *TInfo,
2582 SourceLocation LParenLoc,
2583 Expr *Sub,
2584 SourceLocation RParenLoc,
2585 bool ListInitialization) {
2586 return getSema().BuildCXXTypeConstructExpr(TInfo, LParenLoc,
2587 MultiExprArg(&Sub, 1), RParenLoc,
2588 ListInitialization);
2589 }
2590
2591 /// \brief Build a new C++ typeid(type) expression.
2592 ///
2593 /// By default, performs semantic analysis to build the new expression.
2594 /// Subclasses may override this routine to provide different behavior.
2595 ExprResult RebuildCXXTypeidExpr(QualType TypeInfoType,
2596 SourceLocation TypeidLoc,
2597 TypeSourceInfo *Operand,
2598 SourceLocation RParenLoc) {
2599 return getSema().BuildCXXTypeId(TypeInfoType, TypeidLoc, Operand,
2600 RParenLoc);
2601 }
2602
2603
2604 /// \brief Build a new C++ typeid(expr) expression.
2605 ///
2606 /// By default, performs semantic analysis to build the new expression.
2607 /// Subclasses may override this routine to provide different behavior.
2608 ExprResult RebuildCXXTypeidExpr(QualType TypeInfoType,
2609 SourceLocation TypeidLoc,
2610 Expr *Operand,
2611 SourceLocation RParenLoc) {
2612 return getSema().BuildCXXTypeId(TypeInfoType, TypeidLoc, Operand,
2613 RParenLoc);
2614 }
2615
2616 /// \brief Build a new C++ __uuidof(type) expression.
2617 ///
2618 /// By default, performs semantic analysis to build the new expression.
2619 /// Subclasses may override this routine to provide different behavior.
2620 ExprResult RebuildCXXUuidofExpr(QualType TypeInfoType,
2621 SourceLocation TypeidLoc,
2622 TypeSourceInfo *Operand,
2623 SourceLocation RParenLoc) {
2624 return getSema().BuildCXXUuidof(TypeInfoType, TypeidLoc, Operand,
2625 RParenLoc);
2626 }
2627
2628 /// \brief Build a new C++ __uuidof(expr) expression.
2629 ///
2630 /// By default, performs semantic analysis to build the new expression.
2631 /// Subclasses may override this routine to provide different behavior.
2632 ExprResult RebuildCXXUuidofExpr(QualType TypeInfoType,
2633 SourceLocation TypeidLoc,
2634 Expr *Operand,
2635 SourceLocation RParenLoc) {
2636 return getSema().BuildCXXUuidof(TypeInfoType, TypeidLoc, Operand,
2637 RParenLoc);
2638 }
2639
2640 /// \brief Build a new C++ "this" expression.
2641 ///
2642 /// By default, builds a new "this" expression without performing any
2643 /// semantic analysis. Subclasses may override this routine to provide
2644 /// different behavior.
2645 ExprResult RebuildCXXThisExpr(SourceLocation ThisLoc,
2646 QualType ThisType,
2647 bool isImplicit) {
2648 getSema().CheckCXXThisCapture(ThisLoc);
2649 return new (getSema().Context) CXXThisExpr(ThisLoc, ThisType, isImplicit);
2650 }
2651
2652 /// \brief Build a new C++ throw expression.
2653 ///
2654 /// By default, performs semantic analysis to build the new expression.
2655 /// Subclasses may override this routine to provide different behavior.
2656 ExprResult RebuildCXXThrowExpr(SourceLocation ThrowLoc, Expr *Sub,
2657 bool IsThrownVariableInScope) {
2658 return getSema().BuildCXXThrow(ThrowLoc, Sub, IsThrownVariableInScope);
2659 }
2660
2661 /// \brief Build a new C++ default-argument expression.
2662 ///
2663 /// By default, builds a new default-argument expression, which does not
2664 /// require any semantic analysis. Subclasses may override this routine to
2665 /// provide different behavior.
2666 ExprResult RebuildCXXDefaultArgExpr(SourceLocation Loc,
2667 ParmVarDecl *Param) {
2668 return CXXDefaultArgExpr::Create(getSema().Context, Loc, Param);
2669 }
2670
2671 /// \brief Build a new C++11 default-initialization expression.
2672 ///
2673 /// By default, builds a new default field initialization expression, which
2674 /// does not require any semantic analysis. Subclasses may override this
2675 /// routine to provide different behavior.
2676 ExprResult RebuildCXXDefaultInitExpr(SourceLocation Loc,
2677 FieldDecl *Field) {
2678 return CXXDefaultInitExpr::Create(getSema().Context, Loc, Field);
2679 }
2680
2681 /// \brief Build a new C++ zero-initialization expression.
2682 ///
2683 /// By default, performs semantic analysis to build the new expression.
2684 /// Subclasses may override this routine to provide different behavior.
2685 ExprResult RebuildCXXScalarValueInitExpr(TypeSourceInfo *TSInfo,
2686 SourceLocation LParenLoc,
2687 SourceLocation RParenLoc) {
2688 return getSema().BuildCXXTypeConstructExpr(
2689 TSInfo, LParenLoc, None, RParenLoc, /*ListInitialization=*/false);
2690 }
2691
2692 /// \brief Build a new C++ "new" expression.
2693 ///
2694 /// By default, performs semantic analysis to build the new expression.
2695 /// Subclasses may override this routine to provide different behavior.
2696 ExprResult RebuildCXXNewExpr(SourceLocation StartLoc,
2697 bool UseGlobal,
2698 SourceLocation PlacementLParen,
2699 MultiExprArg PlacementArgs,
2700 SourceLocation PlacementRParen,
2701 SourceRange TypeIdParens,
2702 QualType AllocatedType,
2703 TypeSourceInfo *AllocatedTypeInfo,
2704 Expr *ArraySize,
2705 SourceRange DirectInitRange,
2706 Expr *Initializer) {
2707 return getSema().BuildCXXNew(StartLoc, UseGlobal,
2708 PlacementLParen,
2709 PlacementArgs,
2710 PlacementRParen,
2711 TypeIdParens,
2712 AllocatedType,
2713 AllocatedTypeInfo,
2714 ArraySize,
2715 DirectInitRange,
2716 Initializer);
2717 }
2718
2719 /// \brief Build a new C++ "delete" expression.
2720 ///
2721 /// By default, performs semantic analysis to build the new expression.
2722 /// Subclasses may override this routine to provide different behavior.
2723 ExprResult RebuildCXXDeleteExpr(SourceLocation StartLoc,
2724 bool IsGlobalDelete,
2725 bool IsArrayForm,
2726 Expr *Operand) {
2727 return getSema().ActOnCXXDelete(StartLoc, IsGlobalDelete, IsArrayForm,
2728 Operand);
2729 }
2730
2731 /// \brief Build a new type trait expression.
2732 ///
2733 /// By default, performs semantic analysis to build the new expression.
2734 /// Subclasses may override this routine to provide different behavior.
2735 ExprResult RebuildTypeTrait(TypeTrait Trait,
2736 SourceLocation StartLoc,
2737 ArrayRef<TypeSourceInfo *> Args,
2738 SourceLocation RParenLoc) {
2739 return getSema().BuildTypeTrait(Trait, StartLoc, Args, RParenLoc);
2740 }
2741
2742 /// \brief Build a new array type trait expression.
2743 ///
2744 /// By default, performs semantic analysis to build the new expression.
2745 /// Subclasses may override this routine to provide different behavior.
2746 ExprResult RebuildArrayTypeTrait(ArrayTypeTrait Trait,
2747 SourceLocation StartLoc,
2748 TypeSourceInfo *TSInfo,
2749 Expr *DimExpr,
2750 SourceLocation RParenLoc) {
2751 return getSema().BuildArrayTypeTrait(Trait, StartLoc, TSInfo, DimExpr, RParenLoc);
2752 }
2753
2754 /// \brief Build a new expression trait expression.
2755 ///
2756 /// By default, performs semantic analysis to build the new expression.
2757 /// Subclasses may override this routine to provide different behavior.
2758 ExprResult RebuildExpressionTrait(ExpressionTrait Trait,
2759 SourceLocation StartLoc,
2760 Expr *Queried,
2761 SourceLocation RParenLoc) {
2762 return getSema().BuildExpressionTrait(Trait, StartLoc, Queried, RParenLoc);
2763 }
2764
2765 /// \brief Build a new (previously unresolved) declaration reference
2766 /// expression.
2767 ///
2768 /// By default, performs semantic analysis to build the new expression.
2769 /// Subclasses may override this routine to provide different behavior.
2770 ExprResult RebuildDependentScopeDeclRefExpr(
2771 NestedNameSpecifierLoc QualifierLoc,
2772 SourceLocation TemplateKWLoc,
2773 const DeclarationNameInfo &NameInfo,
2774 const TemplateArgumentListInfo *TemplateArgs,
2775 bool IsAddressOfOperand,
2776 TypeSourceInfo **RecoveryTSI) {
2777 CXXScopeSpec SS;
2778 SS.Adopt(QualifierLoc);
2779
2780 if (TemplateArgs || TemplateKWLoc.isValid())
2781 return getSema().BuildQualifiedTemplateIdExpr(SS, TemplateKWLoc, NameInfo,
2782 TemplateArgs);
2783
2784 return getSema().BuildQualifiedDeclarationNameExpr(
2785 SS, NameInfo, IsAddressOfOperand, /*S*/nullptr, RecoveryTSI);
2786 }
2787
2788 /// \brief Build a new template-id expression.
2789 ///
2790 /// By default, performs semantic analysis to build the new expression.
2791 /// Subclasses may override this routine to provide different behavior.
2792 ExprResult RebuildTemplateIdExpr(const CXXScopeSpec &SS,
2793 SourceLocation TemplateKWLoc,
2794 LookupResult &R,
2795 bool RequiresADL,
2796 const TemplateArgumentListInfo *TemplateArgs) {
2797 return getSema().BuildTemplateIdExpr(SS, TemplateKWLoc, R, RequiresADL,
2798 TemplateArgs);
2799 }
2800
2801 /// \brief Build a new object-construction expression.
2802 ///
2803 /// By default, performs semantic analysis to build the new expression.
2804 /// Subclasses may override this routine to provide different behavior.
2805 ExprResult RebuildCXXConstructExpr(QualType T,
2806 SourceLocation Loc,
2807 CXXConstructorDecl *Constructor,
2808 bool IsElidable,
2809 MultiExprArg Args,
2810 bool HadMultipleCandidates,
2811 bool ListInitialization,
2812 bool StdInitListInitialization,
2813 bool RequiresZeroInit,
2814 CXXConstructExpr::ConstructionKind ConstructKind,
2815 SourceRange ParenRange) {
2816 SmallVector<Expr*, 8> ConvertedArgs;
2817 if (getSema().CompleteConstructorCall(Constructor, Args, Loc,
2818 ConvertedArgs))
2819 return ExprError();
2820
2821 return getSema().BuildCXXConstructExpr(Loc, T, Constructor,
2822 IsElidable,
2823 ConvertedArgs,
2824 HadMultipleCandidates,
2825 ListInitialization,
2826 StdInitListInitialization,
2827 RequiresZeroInit, ConstructKind,
2828 ParenRange);
2829 }
2830
2831 /// \brief Build a new implicit construction via inherited constructor
2832 /// expression.
2833 ExprResult RebuildCXXInheritedCtorInitExpr(QualType T, SourceLocation Loc,
2834 CXXConstructorDecl *Constructor,
2835 bool ConstructsVBase,
2836 bool InheritedFromVBase) {
2837 return new (getSema().Context) CXXInheritedCtorInitExpr(
2838 Loc, T, Constructor, ConstructsVBase, InheritedFromVBase);
2839 }
2840
2841 /// \brief Build a new object-construction expression.
2842 ///
2843 /// By default, performs semantic analysis to build the new expression.
2844 /// Subclasses may override this routine to provide different behavior.
2845 ExprResult RebuildCXXTemporaryObjectExpr(TypeSourceInfo *TSInfo,
2846 SourceLocation LParenOrBraceLoc,
2847 MultiExprArg Args,
2848 SourceLocation RParenOrBraceLoc,
2849 bool ListInitialization) {
2850 return getSema().BuildCXXTypeConstructExpr(
2851 TSInfo, LParenOrBraceLoc, Args, RParenOrBraceLoc, ListInitialization);
2852 }
2853
2854 /// \brief Build a new object-construction expression.
2855 ///
2856 /// By default, performs semantic analysis to build the new expression.
2857 /// Subclasses may override this routine to provide different behavior.
2858 ExprResult RebuildCXXUnresolvedConstructExpr(TypeSourceInfo *TSInfo,
2859 SourceLocation LParenLoc,
2860 MultiExprArg Args,
2861 SourceLocation RParenLoc,
2862 bool ListInitialization) {
2863 return getSema().BuildCXXTypeConstructExpr(TSInfo, LParenLoc, Args,
2864 RParenLoc, ListInitialization);
2865 }
2866
2867 /// \brief Build a new member reference expression.
2868 ///
2869 /// By default, performs semantic analysis to build the new expression.
2870 /// Subclasses may override this routine to provide different behavior.
2871 ExprResult RebuildCXXDependentScopeMemberExpr(Expr *BaseE,
2872 QualType BaseType,
2873 bool IsArrow,
2874 SourceLocation OperatorLoc,
2875 NestedNameSpecifierLoc QualifierLoc,
2876 SourceLocation TemplateKWLoc,
2877 NamedDecl *FirstQualifierInScope,
2878 const DeclarationNameInfo &MemberNameInfo,
2879 const TemplateArgumentListInfo *TemplateArgs) {
2880 CXXScopeSpec SS;