Bug Summary

File:tools/clang/lib/Sema/TreeTransform.h
Warning:line 5127, 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-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-8/lib/clang/8.0.0 -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I /build/llvm-toolchain-snapshot-8~svn345461/build-llvm/tools/clang/lib/Sema -I /build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Sema -I /build/llvm-toolchain-snapshot-8~svn345461/tools/clang/include -I /build/llvm-toolchain-snapshot-8~svn345461/build-llvm/tools/clang/include -I /build/llvm-toolchain-snapshot-8~svn345461/build-llvm/include -I /build/llvm-toolchain-snapshot-8~svn345461/include -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/x86_64-linux-gnu/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/x86_64-linux-gnu/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/c++/6.3.0/backward -internal-isystem /usr/include/clang/8.0.0/include/ -internal-isystem /usr/local/include -internal-isystem /usr/lib/llvm-8/lib/clang/8.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-8~svn345461/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-output=html -analyzer-config stable-report-filename=true -o /tmp/scan-build-2018-10-27-211344-32123-1 -x c++ /build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp -faddrsig

/build/llvm-toolchain-snapshot-8~svn345461/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/AST/PrettyDeclStackTrace.h"
22#include "clang/Basic/LangOptions.h"
23#include "clang/Sema/DeclSpec.h"
24#include "clang/Sema/Initialization.h"
25#include "clang/Sema/Lookup.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/// 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?")((Spec->getSpecializedTemplate() && "No variable template?"
) ? static_cast<void> (0) : __assert_fail ("Spec->getSpecializedTemplate() && \"No variable template?\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 81, __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?")((Spec->getSpecializedTemplate() && "No class template?"
) ? static_cast<void> (0) : __assert_fail ("Spec->getSpecializedTemplate() && \"No class template?\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 125, __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?")((Function->getPrimaryTemplate() && "No function template?"
) ? static_cast<void> (0) : __assert_fail ("Function->getPrimaryTemplate() && \"No function template?\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 144, __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 case ExceptionSpecEvaluation:
203 return false;
204
205 // This function should never be called when Kind's value is Memoization.
206 case Memoization:
207 break;
208 }
209
210 llvm_unreachable("Invalid SynthesisKind!")::llvm::llvm_unreachable_internal("Invalid SynthesisKind!", "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 210)
;
211}
212
213Sema::InstantiatingTemplate::InstantiatingTemplate(
214 Sema &SemaRef, CodeSynthesisContext::SynthesisKind Kind,
215 SourceLocation PointOfInstantiation, SourceRange InstantiationRange,
216 Decl *Entity, NamedDecl *Template, ArrayRef<TemplateArgument> TemplateArgs,
217 sema::TemplateDeductionInfo *DeductionInfo)
218 : SemaRef(SemaRef) {
219 // Don't allow further instantiation if a fatal error and an uncompilable
220 // error have occurred. Any diagnostics we might have raised will not be
221 // visible, and we do not need to construct a correct AST.
222 if (SemaRef.Diags.hasFatalErrorOccurred() &&
223 SemaRef.Diags.hasUncompilableErrorOccurred()) {
224 Invalid = true;
225 return;
226 }
227 Invalid = CheckInstantiationDepth(PointOfInstantiation, InstantiationRange);
228 if (!Invalid) {
229 CodeSynthesisContext Inst;
230 Inst.Kind = Kind;
231 Inst.PointOfInstantiation = PointOfInstantiation;
232 Inst.Entity = Entity;
233 Inst.Template = Template;
234 Inst.TemplateArgs = TemplateArgs.data();
235 Inst.NumTemplateArgs = TemplateArgs.size();
236 Inst.DeductionInfo = DeductionInfo;
237 Inst.InstantiationRange = InstantiationRange;
238 SemaRef.pushCodeSynthesisContext(Inst);
239
240 AlreadyInstantiating =
241 !SemaRef.InstantiatingSpecializations
242 .insert(std::make_pair(Inst.Entity->getCanonicalDecl(), Inst.Kind))
243 .second;
244 atTemplateBegin(SemaRef.TemplateInstCallbacks, SemaRef, Inst);
245 }
246}
247
248Sema::InstantiatingTemplate::InstantiatingTemplate(
249 Sema &SemaRef, SourceLocation PointOfInstantiation, Decl *Entity,
250 SourceRange InstantiationRange)
251 : InstantiatingTemplate(SemaRef,
252 CodeSynthesisContext::TemplateInstantiation,
253 PointOfInstantiation, InstantiationRange, Entity) {}
254
255Sema::InstantiatingTemplate::InstantiatingTemplate(
256 Sema &SemaRef, SourceLocation PointOfInstantiation, FunctionDecl *Entity,
257 ExceptionSpecification, SourceRange InstantiationRange)
258 : InstantiatingTemplate(
259 SemaRef, CodeSynthesisContext::ExceptionSpecInstantiation,
260 PointOfInstantiation, InstantiationRange, Entity) {}
261
262Sema::InstantiatingTemplate::InstantiatingTemplate(
263 Sema &SemaRef, SourceLocation PointOfInstantiation, TemplateParameter Param,
264 TemplateDecl *Template, ArrayRef<TemplateArgument> TemplateArgs,
265 SourceRange InstantiationRange)
266 : InstantiatingTemplate(
267 SemaRef,
268 CodeSynthesisContext::DefaultTemplateArgumentInstantiation,
269 PointOfInstantiation, InstantiationRange, getAsNamedDecl(Param),
270 Template, TemplateArgs) {}
271
272Sema::InstantiatingTemplate::InstantiatingTemplate(
273 Sema &SemaRef, SourceLocation PointOfInstantiation,
274 FunctionTemplateDecl *FunctionTemplate,
275 ArrayRef<TemplateArgument> TemplateArgs,
276 CodeSynthesisContext::SynthesisKind Kind,
277 sema::TemplateDeductionInfo &DeductionInfo, SourceRange InstantiationRange)
278 : InstantiatingTemplate(SemaRef, Kind, PointOfInstantiation,
279 InstantiationRange, FunctionTemplate, nullptr,
280 TemplateArgs, &DeductionInfo) {
281 assert(((Kind == CodeSynthesisContext::ExplicitTemplateArgumentSubstitution
|| Kind == CodeSynthesisContext::DeducedTemplateArgumentSubstitution
) ? static_cast<void> (0) : __assert_fail ("Kind == CodeSynthesisContext::ExplicitTemplateArgumentSubstitution || Kind == CodeSynthesisContext::DeducedTemplateArgumentSubstitution"
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 283, __PRETTY_FUNCTION__))
282 Kind == CodeSynthesisContext::ExplicitTemplateArgumentSubstitution ||((Kind == CodeSynthesisContext::ExplicitTemplateArgumentSubstitution
|| Kind == CodeSynthesisContext::DeducedTemplateArgumentSubstitution
) ? static_cast<void> (0) : __assert_fail ("Kind == CodeSynthesisContext::ExplicitTemplateArgumentSubstitution || Kind == CodeSynthesisContext::DeducedTemplateArgumentSubstitution"
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 283, __PRETTY_FUNCTION__))
283 Kind == CodeSynthesisContext::DeducedTemplateArgumentSubstitution)((Kind == CodeSynthesisContext::ExplicitTemplateArgumentSubstitution
|| Kind == CodeSynthesisContext::DeducedTemplateArgumentSubstitution
) ? static_cast<void> (0) : __assert_fail ("Kind == CodeSynthesisContext::ExplicitTemplateArgumentSubstitution || Kind == CodeSynthesisContext::DeducedTemplateArgumentSubstitution"
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 283, __PRETTY_FUNCTION__))
;
284}
285
286Sema::InstantiatingTemplate::InstantiatingTemplate(
287 Sema &SemaRef, SourceLocation PointOfInstantiation,
288 TemplateDecl *Template,
289 ArrayRef<TemplateArgument> TemplateArgs,
290 sema::TemplateDeductionInfo &DeductionInfo, SourceRange InstantiationRange)
291 : InstantiatingTemplate(
292 SemaRef,
293 CodeSynthesisContext::DeducedTemplateArgumentSubstitution,
294 PointOfInstantiation, InstantiationRange, Template, nullptr,
295 TemplateArgs, &DeductionInfo) {}
296
297Sema::InstantiatingTemplate::InstantiatingTemplate(
298 Sema &SemaRef, SourceLocation PointOfInstantiation,
299 ClassTemplatePartialSpecializationDecl *PartialSpec,
300 ArrayRef<TemplateArgument> TemplateArgs,
301 sema::TemplateDeductionInfo &DeductionInfo, SourceRange InstantiationRange)
302 : InstantiatingTemplate(
303 SemaRef,
304 CodeSynthesisContext::DeducedTemplateArgumentSubstitution,
305 PointOfInstantiation, InstantiationRange, PartialSpec, nullptr,
306 TemplateArgs, &DeductionInfo) {}
307
308Sema::InstantiatingTemplate::InstantiatingTemplate(
309 Sema &SemaRef, SourceLocation PointOfInstantiation,
310 VarTemplatePartialSpecializationDecl *PartialSpec,
311 ArrayRef<TemplateArgument> TemplateArgs,
312 sema::TemplateDeductionInfo &DeductionInfo, SourceRange InstantiationRange)
313 : InstantiatingTemplate(
314 SemaRef,
315 CodeSynthesisContext::DeducedTemplateArgumentSubstitution,
316 PointOfInstantiation, InstantiationRange, PartialSpec, nullptr,
317 TemplateArgs, &DeductionInfo) {}
318
319Sema::InstantiatingTemplate::InstantiatingTemplate(
320 Sema &SemaRef, SourceLocation PointOfInstantiation, ParmVarDecl *Param,
321 ArrayRef<TemplateArgument> TemplateArgs, SourceRange InstantiationRange)
322 : InstantiatingTemplate(
323 SemaRef,
324 CodeSynthesisContext::DefaultFunctionArgumentInstantiation,
325 PointOfInstantiation, InstantiationRange, Param, nullptr,
326 TemplateArgs) {}
327
328Sema::InstantiatingTemplate::InstantiatingTemplate(
329 Sema &SemaRef, SourceLocation PointOfInstantiation, NamedDecl *Template,
330 NonTypeTemplateParmDecl *Param, ArrayRef<TemplateArgument> TemplateArgs,
331 SourceRange InstantiationRange)
332 : InstantiatingTemplate(
333 SemaRef,
334 CodeSynthesisContext::PriorTemplateArgumentSubstitution,
335 PointOfInstantiation, InstantiationRange, Param, Template,
336 TemplateArgs) {}
337
338Sema::InstantiatingTemplate::InstantiatingTemplate(
339 Sema &SemaRef, SourceLocation PointOfInstantiation, NamedDecl *Template,
340 TemplateTemplateParmDecl *Param, ArrayRef<TemplateArgument> TemplateArgs,
341 SourceRange InstantiationRange)
342 : InstantiatingTemplate(
343 SemaRef,
344 CodeSynthesisContext::PriorTemplateArgumentSubstitution,
345 PointOfInstantiation, InstantiationRange, Param, Template,
346 TemplateArgs) {}
347
348Sema::InstantiatingTemplate::InstantiatingTemplate(
349 Sema &SemaRef, SourceLocation PointOfInstantiation, TemplateDecl *Template,
350 NamedDecl *Param, ArrayRef<TemplateArgument> TemplateArgs,
351 SourceRange InstantiationRange)
352 : InstantiatingTemplate(
353 SemaRef, CodeSynthesisContext::DefaultTemplateArgumentChecking,
354 PointOfInstantiation, InstantiationRange, Param, Template,
355 TemplateArgs) {}
356
357void Sema::pushCodeSynthesisContext(CodeSynthesisContext Ctx) {
358 Ctx.SavedInNonInstantiationSFINAEContext = InNonInstantiationSFINAEContext;
359 InNonInstantiationSFINAEContext = false;
360
361 CodeSynthesisContexts.push_back(Ctx);
362
363 if (!Ctx.isInstantiationRecord())
364 ++NonInstantiationEntries;
365}
366
367void Sema::popCodeSynthesisContext() {
368 auto &Active = CodeSynthesisContexts.back();
369 if (!Active.isInstantiationRecord()) {
370 assert(NonInstantiationEntries > 0)((NonInstantiationEntries > 0) ? static_cast<void> (
0) : __assert_fail ("NonInstantiationEntries > 0", "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 370, __PRETTY_FUNCTION__))
;
371 --NonInstantiationEntries;
372 }
373
374 InNonInstantiationSFINAEContext = Active.SavedInNonInstantiationSFINAEContext;
375
376 // Name lookup no longer looks in this template's defining module.
377 assert(CodeSynthesisContexts.size() >=((CodeSynthesisContexts.size() >= CodeSynthesisContextLookupModules
.size() && "forgot to remove a lookup module for a template instantiation"
) ? static_cast<void> (0) : __assert_fail ("CodeSynthesisContexts.size() >= CodeSynthesisContextLookupModules.size() && \"forgot to remove a lookup module for a template instantiation\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 379, __PRETTY_FUNCTION__))
378 CodeSynthesisContextLookupModules.size() &&((CodeSynthesisContexts.size() >= CodeSynthesisContextLookupModules
.size() && "forgot to remove a lookup module for a template instantiation"
) ? static_cast<void> (0) : __assert_fail ("CodeSynthesisContexts.size() >= CodeSynthesisContextLookupModules.size() && \"forgot to remove a lookup module for a template instantiation\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 379, __PRETTY_FUNCTION__))
379 "forgot to remove a lookup module for a template instantiation")((CodeSynthesisContexts.size() >= CodeSynthesisContextLookupModules
.size() && "forgot to remove a lookup module for a template instantiation"
) ? static_cast<void> (0) : __assert_fail ("CodeSynthesisContexts.size() >= CodeSynthesisContextLookupModules.size() && \"forgot to remove a lookup module for a template instantiation\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 379, __PRETTY_FUNCTION__))
;
380 if (CodeSynthesisContexts.size() ==
381 CodeSynthesisContextLookupModules.size()) {
382 if (Module *M = CodeSynthesisContextLookupModules.back())
383 LookupModulesCache.erase(M);
384 CodeSynthesisContextLookupModules.pop_back();
385 }
386
387 // If we've left the code synthesis context for the current context stack,
388 // stop remembering that we've emitted that stack.
389 if (CodeSynthesisContexts.size() ==
390 LastEmittedCodeSynthesisContextDepth)
391 LastEmittedCodeSynthesisContextDepth = 0;
392
393 CodeSynthesisContexts.pop_back();
394}
395
396void Sema::InstantiatingTemplate::Clear() {
397 if (!Invalid) {
398 if (!AlreadyInstantiating) {
399 auto &Active = SemaRef.CodeSynthesisContexts.back();
400 SemaRef.InstantiatingSpecializations.erase(
401 std::make_pair(Active.Entity, Active.Kind));
402 }
403
404 atTemplateEnd(SemaRef.TemplateInstCallbacks, SemaRef,
405 SemaRef.CodeSynthesisContexts.back());
406
407 SemaRef.popCodeSynthesisContext();
408 Invalid = true;
409 }
410}
411
412bool Sema::InstantiatingTemplate::CheckInstantiationDepth(
413 SourceLocation PointOfInstantiation,
414 SourceRange InstantiationRange) {
415 assert(SemaRef.NonInstantiationEntries <=((SemaRef.NonInstantiationEntries <= SemaRef.CodeSynthesisContexts
.size()) ? static_cast<void> (0) : __assert_fail ("SemaRef.NonInstantiationEntries <= SemaRef.CodeSynthesisContexts.size()"
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 416, __PRETTY_FUNCTION__))
416 SemaRef.CodeSynthesisContexts.size())((SemaRef.NonInstantiationEntries <= SemaRef.CodeSynthesisContexts
.size()) ? static_cast<void> (0) : __assert_fail ("SemaRef.NonInstantiationEntries <= SemaRef.CodeSynthesisContexts.size()"
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 416, __PRETTY_FUNCTION__))
;
417 if ((SemaRef.CodeSynthesisContexts.size() -
418 SemaRef.NonInstantiationEntries)
419 <= SemaRef.getLangOpts().InstantiationDepth)
420 return false;
421
422 SemaRef.Diag(PointOfInstantiation,
423 diag::err_template_recursion_depth_exceeded)
424 << SemaRef.getLangOpts().InstantiationDepth
425 << InstantiationRange;
426 SemaRef.Diag(PointOfInstantiation, diag::note_template_recursion_depth)
427 << SemaRef.getLangOpts().InstantiationDepth;
428 return true;
429}
430
431/// Prints the current instantiation stack through a series of
432/// notes.
433void Sema::PrintInstantiationStack() {
434 // Determine which template instantiations to skip, if any.
435 unsigned SkipStart = CodeSynthesisContexts.size(), SkipEnd = SkipStart;
436 unsigned Limit = Diags.getTemplateBacktraceLimit();
437 if (Limit && Limit < CodeSynthesisContexts.size()) {
438 SkipStart = Limit / 2 + Limit % 2;
439 SkipEnd = CodeSynthesisContexts.size() - Limit / 2;
440 }
441
442 // FIXME: In all of these cases, we need to show the template arguments
443 unsigned InstantiationIdx = 0;
444 for (SmallVectorImpl<CodeSynthesisContext>::reverse_iterator
445 Active = CodeSynthesisContexts.rbegin(),
446 ActiveEnd = CodeSynthesisContexts.rend();
447 Active != ActiveEnd;
448 ++Active, ++InstantiationIdx) {
449 // Skip this instantiation?
450 if (InstantiationIdx >= SkipStart && InstantiationIdx < SkipEnd) {
451 if (InstantiationIdx == SkipStart) {
452 // Note that we're skipping instantiations.
453 Diags.Report(Active->PointOfInstantiation,
454 diag::note_instantiation_contexts_suppressed)
455 << unsigned(CodeSynthesisContexts.size() - Limit);
456 }
457 continue;
458 }
459
460 switch (Active->Kind) {
461 case CodeSynthesisContext::TemplateInstantiation: {
462 Decl *D = Active->Entity;
463 if (CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(D)) {
464 unsigned DiagID = diag::note_template_member_class_here;
465 if (isa<ClassTemplateSpecializationDecl>(Record))
466 DiagID = diag::note_template_class_instantiation_here;
467 Diags.Report(Active->PointOfInstantiation, DiagID)
468 << Record << Active->InstantiationRange;
469 } else if (FunctionDecl *Function = dyn_cast<FunctionDecl>(D)) {
470 unsigned DiagID;
471 if (Function->getPrimaryTemplate())
472 DiagID = diag::note_function_template_spec_here;
473 else
474 DiagID = diag::note_template_member_function_here;
475 Diags.Report(Active->PointOfInstantiation, DiagID)
476 << Function
477 << Active->InstantiationRange;
478 } else if (VarDecl *VD = dyn_cast<VarDecl>(D)) {
479 Diags.Report(Active->PointOfInstantiation,
480 VD->isStaticDataMember()?
481 diag::note_template_static_data_member_def_here
482 : diag::note_template_variable_def_here)
483 << VD
484 << Active->InstantiationRange;
485 } else if (EnumDecl *ED = dyn_cast<EnumDecl>(D)) {
486 Diags.Report(Active->PointOfInstantiation,
487 diag::note_template_enum_def_here)
488 << ED
489 << Active->InstantiationRange;
490 } else if (FieldDecl *FD = dyn_cast<FieldDecl>(D)) {
491 Diags.Report(Active->PointOfInstantiation,
492 diag::note_template_nsdmi_here)
493 << FD << Active->InstantiationRange;
494 } else {
495 Diags.Report(Active->PointOfInstantiation,
496 diag::note_template_type_alias_instantiation_here)
497 << cast<TypeAliasTemplateDecl>(D)
498 << Active->InstantiationRange;
499 }
500 break;
501 }
502
503 case CodeSynthesisContext::DefaultTemplateArgumentInstantiation: {
504 TemplateDecl *Template = cast<TemplateDecl>(Active->Template);
505 SmallVector<char, 128> TemplateArgsStr;
506 llvm::raw_svector_ostream OS(TemplateArgsStr);
507 Template->printName(OS);
508 printTemplateArgumentList(OS, Active->template_arguments(),
509 getPrintingPolicy());
510 Diags.Report(Active->PointOfInstantiation,
511 diag::note_default_arg_instantiation_here)
512 << OS.str()
513 << Active->InstantiationRange;
514 break;
515 }
516
517 case CodeSynthesisContext::ExplicitTemplateArgumentSubstitution: {
518 FunctionTemplateDecl *FnTmpl = cast<FunctionTemplateDecl>(Active->Entity);
519 Diags.Report(Active->PointOfInstantiation,
520 diag::note_explicit_template_arg_substitution_here)
521 << FnTmpl
522 << getTemplateArgumentBindingsText(FnTmpl->getTemplateParameters(),
523 Active->TemplateArgs,
524 Active->NumTemplateArgs)
525 << Active->InstantiationRange;
526 break;
527 }
528
529 case CodeSynthesisContext::DeducedTemplateArgumentSubstitution: {
530 if (FunctionTemplateDecl *FnTmpl =
531 dyn_cast<FunctionTemplateDecl>(Active->Entity)) {
532 Diags.Report(Active->PointOfInstantiation,
533 diag::note_function_template_deduction_instantiation_here)
534 << FnTmpl
535 << getTemplateArgumentBindingsText(FnTmpl->getTemplateParameters(),
536 Active->TemplateArgs,
537 Active->NumTemplateArgs)
538 << Active->InstantiationRange;
539 } else {
540 bool IsVar = isa<VarTemplateDecl>(Active->Entity) ||
541 isa<VarTemplateSpecializationDecl>(Active->Entity);
542 bool IsTemplate = false;
543 TemplateParameterList *Params;
544 if (auto *D = dyn_cast<TemplateDecl>(Active->Entity)) {
545 IsTemplate = true;
546 Params = D->getTemplateParameters();
547 } else if (auto *D = dyn_cast<ClassTemplatePartialSpecializationDecl>(
548 Active->Entity)) {
549 Params = D->getTemplateParameters();
550 } else if (auto *D = dyn_cast<VarTemplatePartialSpecializationDecl>(
551 Active->Entity)) {
552 Params = D->getTemplateParameters();
553 } else {
554 llvm_unreachable("unexpected template kind")::llvm::llvm_unreachable_internal("unexpected template kind",
"/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 554)
;
555 }
556
557 Diags.Report(Active->PointOfInstantiation,
558 diag::note_deduced_template_arg_substitution_here)
559 << IsVar << IsTemplate << cast<NamedDecl>(Active->Entity)
560 << getTemplateArgumentBindingsText(Params, Active->TemplateArgs,
561 Active->NumTemplateArgs)
562 << Active->InstantiationRange;
563 }
564 break;
565 }
566
567 case CodeSynthesisContext::DefaultFunctionArgumentInstantiation: {
568 ParmVarDecl *Param = cast<ParmVarDecl>(Active->Entity);
569 FunctionDecl *FD = cast<FunctionDecl>(Param->getDeclContext());
570
571 SmallVector<char, 128> TemplateArgsStr;
572 llvm::raw_svector_ostream OS(TemplateArgsStr);
573 FD->printName(OS);
574 printTemplateArgumentList(OS, Active->template_arguments(),
575 getPrintingPolicy());
576 Diags.Report(Active->PointOfInstantiation,
577 diag::note_default_function_arg_instantiation_here)
578 << OS.str()
579 << Active->InstantiationRange;
580 break;
581 }
582
583 case CodeSynthesisContext::PriorTemplateArgumentSubstitution: {
584 NamedDecl *Parm = cast<NamedDecl>(Active->Entity);
585 std::string Name;
586 if (!Parm->getName().empty())
587 Name = std::string(" '") + Parm->getName().str() + "'";
588
589 TemplateParameterList *TemplateParams = nullptr;
590 if (TemplateDecl *Template = dyn_cast<TemplateDecl>(Active->Template))
591 TemplateParams = Template->getTemplateParameters();
592 else
593 TemplateParams =
594 cast<ClassTemplatePartialSpecializationDecl>(Active->Template)
595 ->getTemplateParameters();
596 Diags.Report(Active->PointOfInstantiation,
597 diag::note_prior_template_arg_substitution)
598 << isa<TemplateTemplateParmDecl>(Parm)
599 << Name
600 << getTemplateArgumentBindingsText(TemplateParams,
601 Active->TemplateArgs,
602 Active->NumTemplateArgs)
603 << Active->InstantiationRange;
604 break;
605 }
606
607 case CodeSynthesisContext::DefaultTemplateArgumentChecking: {
608 TemplateParameterList *TemplateParams = nullptr;
609 if (TemplateDecl *Template = dyn_cast<TemplateDecl>(Active->Template))
610 TemplateParams = Template->getTemplateParameters();
611 else
612 TemplateParams =
613 cast<ClassTemplatePartialSpecializationDecl>(Active->Template)
614 ->getTemplateParameters();
615
616 Diags.Report(Active->PointOfInstantiation,
617 diag::note_template_default_arg_checking)
618 << getTemplateArgumentBindingsText(TemplateParams,
619 Active->TemplateArgs,
620 Active->NumTemplateArgs)
621 << Active->InstantiationRange;
622 break;
623 }
624
625 case CodeSynthesisContext::ExceptionSpecEvaluation:
626 Diags.Report(Active->PointOfInstantiation,
627 diag::note_evaluating_exception_spec_here)
628 << cast<FunctionDecl>(Active->Entity);
629 break;
630
631 case CodeSynthesisContext::ExceptionSpecInstantiation:
632 Diags.Report(Active->PointOfInstantiation,
633 diag::note_template_exception_spec_instantiation_here)
634 << cast<FunctionDecl>(Active->Entity)
635 << Active->InstantiationRange;
636 break;
637
638 case CodeSynthesisContext::DeclaringSpecialMember:
639 Diags.Report(Active->PointOfInstantiation,
640 diag::note_in_declaration_of_implicit_special_member)
641 << cast<CXXRecordDecl>(Active->Entity) << Active->SpecialMember;
642 break;
643
644 case CodeSynthesisContext::DefiningSynthesizedFunction: {
645 // FIXME: For synthesized members other than special members, produce a note.
646 auto *MD = dyn_cast<CXXMethodDecl>(Active->Entity);
647 auto CSM = MD ? getSpecialMember(MD) : CXXInvalid;
648 if (CSM != CXXInvalid) {
649 Diags.Report(Active->PointOfInstantiation,
650 diag::note_member_synthesized_at)
651 << CSM << Context.getTagDeclType(MD->getParent());
652 }
653 break;
654 }
655
656 case CodeSynthesisContext::Memoization:
657 break;
658 }
659 }
660}
661
662Optional<TemplateDeductionInfo *> Sema::isSFINAEContext() const {
663 if (InNonInstantiationSFINAEContext)
664 return Optional<TemplateDeductionInfo *>(nullptr);
665
666 for (SmallVectorImpl<CodeSynthesisContext>::const_reverse_iterator
667 Active = CodeSynthesisContexts.rbegin(),
668 ActiveEnd = CodeSynthesisContexts.rend();
669 Active != ActiveEnd;
670 ++Active)
671 {
672 switch (Active->Kind) {
673 case CodeSynthesisContext::TemplateInstantiation:
674 // An instantiation of an alias template may or may not be a SFINAE
675 // context, depending on what else is on the stack.
676 if (isa<TypeAliasTemplateDecl>(Active->Entity))
677 break;
678 // Fall through.
679 case CodeSynthesisContext::DefaultFunctionArgumentInstantiation:
680 case CodeSynthesisContext::ExceptionSpecInstantiation:
681 // This is a template instantiation, so there is no SFINAE.
682 return None;
683
684 case CodeSynthesisContext::DefaultTemplateArgumentInstantiation:
685 case CodeSynthesisContext::PriorTemplateArgumentSubstitution:
686 case CodeSynthesisContext::DefaultTemplateArgumentChecking:
687 // A default template argument instantiation and substitution into
688 // template parameters with arguments for prior parameters may or may
689 // not be a SFINAE context; look further up the stack.
690 break;
691
692 case CodeSynthesisContext::ExplicitTemplateArgumentSubstitution:
693 case CodeSynthesisContext::DeducedTemplateArgumentSubstitution:
694 // We're either substitution explicitly-specified template arguments
695 // or deduced template arguments, so SFINAE applies.
696 assert(Active->DeductionInfo && "Missing deduction info pointer")((Active->DeductionInfo && "Missing deduction info pointer"
) ? static_cast<void> (0) : __assert_fail ("Active->DeductionInfo && \"Missing deduction info pointer\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 696, __PRETTY_FUNCTION__))
;
697 return Active->DeductionInfo;
698
699 case CodeSynthesisContext::DeclaringSpecialMember:
700 case CodeSynthesisContext::DefiningSynthesizedFunction:
701 // This happens in a context unrelated to template instantiation, so
702 // there is no SFINAE.
703 return None;
704
705 case CodeSynthesisContext::ExceptionSpecEvaluation:
706 // FIXME: This should not be treated as a SFINAE context, because
707 // we will cache an incorrect exception specification. However, clang
708 // bootstrap relies this! See PR31692.
709 break;
710
711 case CodeSynthesisContext::Memoization:
712 break;
713 }
714
715 // The inner context was transparent for SFINAE. If it occurred within a
716 // non-instantiation SFINAE context, then SFINAE applies.
717 if (Active->SavedInNonInstantiationSFINAEContext)
718 return Optional<TemplateDeductionInfo *>(nullptr);
719 }
720
721 return None;
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 /// 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 /// Returns the location of the entity being instantiated, if known.
751 SourceLocation getBaseLocation() { return Loc; }
752
753 /// Returns the name of the entity being instantiated, if any.
754 DeclarationName getBaseEntity() { return Entity; }
755
756 /// 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 /// 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 /// Transform the definition of the given declaration by
843 /// instantiating it.
844 Decl *TransformDefinition(SourceLocation Loc, Decl *D);
845
846 /// Transform the first qualifier within a scope by instantiating the
847 /// declaration.
848 NamedDecl *TransformFirstQualifierInScope(NamedDecl *D, SourceLocation Loc);
849
850 /// 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 /// 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 /// 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 /// Rebuild a DeclRefExpr for a ParmVarDecl reference.
889 ExprResult RebuildParmVarDeclRefExpr(ParmVarDecl *PD, SourceLocation Loc);
890
891 /// Transform a reference to a function parameter pack.
892 ExprResult TransformFunctionParmPackRefExpr(DeclRefExpr *E,
893 ParmVarDecl *PD);
894
895 /// 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 /// 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 /// 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)((S.ArgumentPackSubstitutionIndex >= 0) ? static_cast<void
> (0) : __assert_fail ("S.ArgumentPackSubstitutionIndex >= 0"
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 963, __PRETTY_FUNCTION__))
;
964 assert(S.ArgumentPackSubstitutionIndex < (int)Arg.pack_size())((S.ArgumentPackSubstitutionIndex < (int)Arg.pack_size()) ?
static_cast<void> (0) : __assert_fail ("S.ArgumentPackSubstitutionIndex < (int)Arg.pack_size()"
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 964, __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 &&((Arg.getKind() == TemplateArgument::Pack && "Missing argument pack"
) ? static_cast<void> (0) : __assert_fail ("Arg.getKind() == TemplateArgument::Pack && \"Missing argument pack\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 989, __PRETTY_FUNCTION__))
989 "Missing argument pack")((Arg.getKind() == TemplateArgument::Pack && "Missing argument pack"
) ? static_cast<void> (0) : __assert_fail ("Arg.getKind() == TemplateArgument::Pack && \"Missing argument pack\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 989, __PRETTY_FUNCTION__))
;
990 Arg = getPackSubstitutedTemplateArgument(getSema(), Arg);
991 }
992
993 TemplateName Template = Arg.getAsTemplate().getNameToSubstitute();
994 assert(!Template.isNull() && Template.getAsTemplateDecl() &&((!Template.isNull() && Template.getAsTemplateDecl() &&
"Wrong kind of template template argument") ? static_cast<
void> (0) : __assert_fail ("!Template.isNull() && Template.getAsTemplateDecl() && \"Wrong kind of template template argument\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 995, __PRETTY_FUNCTION__))
995 "Wrong kind of template template argument")((!Template.isNull() && Template.getAsTemplateDecl() &&
"Wrong kind of template template argument") ? static_cast<
void> (0) : __assert_fail ("!Template.isNull() && Template.getAsTemplateDecl() && \"Wrong kind of template template argument\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 995, __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 &&((Arg.getKind() == TemplateArgument::Pack && "Missing argument pack"
) ? static_cast<void> (0) : __assert_fail ("Arg.getKind() == TemplateArgument::Pack && \"Missing argument pack\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1030, __PRETTY_FUNCTION__))
1030 "Missing argument pack")((Arg.getKind() == TemplateArgument::Pack && "Missing argument pack"
) ? static_cast<void> (0) : __assert_fail ("Arg.getKind() == TemplateArgument::Pack && \"Missing argument pack\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1030, __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 &&((Arg.getKind() == TemplateArgument::Pack && "Missing argument pack"
) ? static_cast<void> (0) : __assert_fail ("Arg.getKind() == TemplateArgument::Pack && \"Missing argument pack\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1128, __PRETTY_FUNCTION__))
1128 "Missing argument pack")((Arg.getKind() == TemplateArgument::Pack && "Missing argument pack"
) ? static_cast<void> (0) : __assert_fail ("Arg.getKind() == TemplateArgument::Pack && \"Missing argument pack\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1128, __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")((!Template.isNull() && "Null template template argument"
) ? static_cast<void> (0) : __assert_fail ("!Template.isNull() && \"Null template template argument\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1141, __PRETTY_FUNCTION__))
;
1142 assert(!Template.getAsQualifiedTemplateName() &&((!Template.getAsQualifiedTemplateName() && "template decl to substitute is qualified?"
) ? static_cast<void> (0) : __assert_fail ("!Template.getAsQualifiedTemplateName() && \"template decl to substitute is qualified?\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1143, __PRETTY_FUNCTION__))
1143 "template decl to substitute is qualified?")((!Template.getAsQualifiedTemplateName() && "template decl to substitute is qualified?"
) ? static_cast<void> (0) : __assert_fail ("!Template.getAsQualifiedTemplateName() && \"template decl to substitute is qualified?\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1143, __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->getIdentKind());
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() &&((Arg.pack_size() == 1 && Arg.pack_begin()->isPackExpansion
() && "unexpected pack arguments in partial substitution"
) ? static_cast<void> (0) : __assert_fail ("Arg.pack_size() == 1 && Arg.pack_begin()->isPackExpansion() && \"unexpected pack arguments in partial substitution\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1194, __PRETTY_FUNCTION__))
1194 "unexpected pack arguments in partial substitution")((Arg.pack_size() == 1 && Arg.pack_begin()->isPackExpansion
() && "unexpected pack arguments in partial substitution"
) ? static_cast<void> (0) : __assert_fail ("Arg.pack_size() == 1 && Arg.pack_begin()->isPackExpansion() && \"unexpected pack arguments in partial substitution\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1194, __PRETTY_FUNCTION__))
;
1195 Arg = Arg.pack_begin()->getPackExpansionPattern();
1196 }
1197 assert(Arg.getKind() == TemplateArgument::Expression &&((Arg.getKind() == TemplateArgument::Expression && "unexpected nontype template argument kind in partial substitution"
) ? static_cast<void> (0) : __assert_fail ("Arg.getKind() == TemplateArgument::Expression && \"unexpected nontype template argument kind in partial substitution\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1198, __PRETTY_FUNCTION__))
1198 "unexpected nontype template argument kind in partial substitution")((Arg.getKind() == TemplateArgument::Expression && "unexpected nontype template argument kind in partial substitution"
) ? static_cast<void> (0) : __assert_fail ("Arg.getKind() == TemplateArgument::Expression && \"unexpected nontype template argument kind in partial substitution\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1198, __PRETTY_FUNCTION__))
;
1199 return Arg.getAsExpr();
1200 }
1201
1202 if (NTTP->isParameterPack()) {
1203 assert(Arg.getKind() == TemplateArgument::Pack &&((Arg.getKind() == TemplateArgument::Pack && "Missing argument pack"
) ? static_cast<void> (0) : __assert_fail ("Arg.getKind() == TemplateArgument::Pack && \"Missing argument pack\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1204, __PRETTY_FUNCTION__))
1204 "Missing argument pack")((Arg.getKind() == TemplateArgument::Pack && "Missing argument pack"
) ? static_cast<void> (0) : __assert_fail ("Arg.getKind() == TemplateArgument::Pack && \"Missing argument pack\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1204, __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 = 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")((!type.isNull() && "type substitution failed for param type"
) ? static_cast<void> (0) : __assert_fail ("!type.isNull() && \"type substitution failed for param type\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1290, __PRETTY_FUNCTION__))
;
1291 assert(!type->isDependentType() && "param type still dependent")((!type->isDependentType() && "param type still dependent"
) ? static_cast<void> (0) : __assert_fail ("!type->isDependentType() && \"param type still dependent\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1291, __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")((Found && "no instantiation for parameter pack") ? static_cast
<void> (0) : __assert_fail ("Found && \"no instantiation for parameter pack\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1370, __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())->((!cast<FunctionDecl>(E->getParam()->getDeclContext
())-> getDescribedFunctionTemplate() && "Default arg expressions are never formed in dependent cases."
) ? static_cast<void> (0) : __assert_fail ("!cast<FunctionDecl>(E->getParam()->getDeclContext())-> getDescribedFunctionTemplate() && \"Default arg expressions are never formed in dependent cases.\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1420, __PRETTY_FUNCTION__))
1419 getDescribedFunctionTemplate() &&((!cast<FunctionDecl>(E->getParam()->getDeclContext
())-> getDescribedFunctionTemplate() && "Default arg expressions are never formed in dependent cases."
) ? static_cast<void> (0) : __assert_fail ("!cast<FunctionDecl>(E->getParam()->getDeclContext())-> getDescribedFunctionTemplate() && \"Default arg expressions are never formed in dependent cases.\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1420, __PRETTY_FUNCTION__))
1420 "Default arg expressions are never formed in dependent cases.")((!cast<FunctionDecl>(E->getParam()->getDeclContext
())-> getDescribedFunctionTemplate() && "Default arg expressions are never formed in dependent cases."
) ? static_cast<void> (0) : __assert_fail ("!cast<FunctionDecl>(E->getParam()->getDeclContext())-> getDescribedFunctionTemplate() && \"Default arg expressions are never formed in dependent cases.\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1420, __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 &&((Arg.getKind() == TemplateArgument::Pack && "Missing argument pack"
) ? static_cast<void> (0) : __assert_fail ("Arg.getKind() == TemplateArgument::Pack && \"Missing argument pack\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1470, __PRETTY_FUNCTION__))
1470 "Missing argument pack")((Arg.getKind() == TemplateArgument::Pack && "Missing argument pack"
) ? static_cast<void> (0) : __assert_fail ("Arg.getKind() == TemplateArgument::Pack && \"Missing argument pack\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1470, __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 &&((Arg.getKind() == TemplateArgument::Type && "Template argument kind mismatch"
) ? static_cast<void> (0) : __assert_fail ("Arg.getKind() == TemplateArgument::Type && \"Template argument kind mismatch\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1488, __PRETTY_FUNCTION__))
1488 "Template argument kind mismatch")((Arg.getKind() == TemplateArgument::Type && "Template argument kind mismatch"
) ? static_cast<void> (0) : __assert_fail ("Arg.getKind() == TemplateArgument::Type && \"Template argument kind mismatch\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1488, __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/// 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() &&((!CodeSynthesisContexts.empty() && "Cannot perform an instantiation without some context on the "
"instantiation stack") ? static_cast<void> (0) : __assert_fail
("!CodeSynthesisContexts.empty() && \"Cannot perform an instantiation without some context on the \" \"instantiation stack\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1580, __PRETTY_FUNCTION__))
1579 "Cannot perform an instantiation without some context on the "((!CodeSynthesisContexts.empty() && "Cannot perform an instantiation without some context on the "
"instantiation stack") ? static_cast<void> (0) : __assert_fail
("!CodeSynthesisContexts.empty() && \"Cannot perform an instantiation without some context on the \" \"instantiation stack\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1580, __PRETTY_FUNCTION__))
1580 "instantiation stack")((!CodeSynthesisContexts.empty() && "Cannot perform an instantiation without some context on the "
"instantiation stack") ? static_cast<void> (0) : __assert_fail
("!CodeSynthesisContexts.empty() && \"Cannot perform an instantiation without some context on the \" \"instantiation stack\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1580, __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() &&((!CodeSynthesisContexts.empty() && "Cannot perform an instantiation without some context on the "
"instantiation stack") ? static_cast<void> (0) : __assert_fail
("!CodeSynthesisContexts.empty() && \"Cannot perform an instantiation without some context on the \" \"instantiation stack\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1597, __PRETTY_FUNCTION__))
1596 "Cannot perform an instantiation without some context on the "((!CodeSynthesisContexts.empty() && "Cannot perform an instantiation without some context on the "
"instantiation stack") ? static_cast<void> (0) : __assert_fail
("!CodeSynthesisContexts.empty() && \"Cannot perform an instantiation without some context on the \" \"instantiation stack\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1597, __PRETTY_FUNCTION__))
1597 "instantiation stack")((!CodeSynthesisContexts.empty() && "Cannot perform an instantiation without some context on the "
"instantiation stack") ? static_cast<void> (0) : __assert_fail
("!CodeSynthesisContexts.empty() && \"Cannot perform an instantiation without some context on the \" \"instantiation stack\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1597, __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() &&((!CodeSynthesisContexts.empty() && "Cannot perform an instantiation without some context on the "
"instantiation stack") ? static_cast<void> (0) : __assert_fail
("!CodeSynthesisContexts.empty() && \"Cannot perform an instantiation without some context on the \" \"instantiation stack\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1627, __PRETTY_FUNCTION__))
1626 "Cannot perform an instantiation without some context on the "((!CodeSynthesisContexts.empty() && "Cannot perform an instantiation without some context on the "
"instantiation stack") ? static_cast<void> (0) : __assert_fail
("!CodeSynthesisContexts.empty() && \"Cannot perform an instantiation without some context on the \" \"instantiation stack\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1627, __PRETTY_FUNCTION__))
1627 "instantiation stack")((!CodeSynthesisContexts.empty() && "Cannot perform an instantiation without some context on the "
"instantiation stack") ? static_cast<void> (0) : __assert_fail
("!CodeSynthesisContexts.empty() && \"Cannot perform an instantiation without some context on the \" \"instantiation stack\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1627, __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() &&((!CodeSynthesisContexts.empty() && "Cannot perform an instantiation without some context on the "
"instantiation stack") ? static_cast<void> (0) : __assert_fail
("!CodeSynthesisContexts.empty() && \"Cannot perform an instantiation without some context on the \" \"instantiation stack\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1672, __PRETTY_FUNCTION__))
1671 "Cannot perform an instantiation without some context on the "((!CodeSynthesisContexts.empty() && "Cannot perform an instantiation without some context on the "
"instantiation stack") ? static_cast<void> (0) : __assert_fail
("!CodeSynthesisContexts.empty() && \"Cannot perform an instantiation without some context on the \" \"instantiation stack\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1672, __PRETTY_FUNCTION__))
1672 "instantiation stack")((!CodeSynthesisContexts.empty() && "Cannot perform an instantiation without some context on the "
"instantiation stack") ? static_cast<void> (0) : __assert_fail
("!CodeSynthesisContexts.empty() && \"Cannot perform an instantiation without some context on the \" \"instantiation stack\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1672, __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)((ESI.Type != EST_Uninstantiated) ? static_cast<void> (
0) : __assert_fail ("ESI.Type != EST_Uninstantiated", "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1710, __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().getEndLoc(),
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()->getBeginLoc();
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/// 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() &&((!CodeSynthesisContexts.empty() && "Cannot perform an instantiation without some context on the "
"instantiation stack") ? static_cast<void> (0) : __assert_fail
("!CodeSynthesisContexts.empty() && \"Cannot perform an instantiation without some context on the \" \"instantiation stack\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1850, __PRETTY_FUNCTION__))
1849 "Cannot perform an instantiation without some context on the "((!CodeSynthesisContexts.empty() && "Cannot perform an instantiation without some context on the "
"instantiation stack") ? static_cast<void> (0) : __assert_fail
("!CodeSynthesisContexts.empty() && \"Cannot perform an instantiation without some context on the \" \"instantiation stack\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1850, __PRETTY_FUNCTION__))
1850 "instantiation stack")((!CodeSynthesisContexts.empty() && "Cannot perform an instantiation without some context on the "
"instantiation stack") ? static_cast<void> (0) : __assert_fail
("!CodeSynthesisContexts.empty() && \"Cannot perform an instantiation without some context on the \" \"instantiation stack\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 1850, __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/// 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/// 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 // 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")((!Inst.isAlreadyInstantiating() && "should have been caught by caller"
) ? static_cast<void> (0) : __assert_fail ("!Inst.isAlreadyInstantiating() && \"should have been caught by caller\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2028, __PRETTY_FUNCTION__))
;
2029 PrettyDeclStackTraceEntry CrashInfo(Context, 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 // BlockDecls can appear in a default-member-initializer. They must be the
2087 // child of a BlockExpr, so we only know how to instantiate them from there.
2088 if (isa<BlockDecl>(Member))
2089 continue;
2090
2091 if (Member->isInvalidDecl()) {
2092 Instantiation->setInvalidDecl();
2093 continue;
2094 }
2095
2096 Decl *NewMember = Instantiator.Visit(Member);
2097 if (NewMember) {
2098 if (FieldDecl *Field = dyn_cast<FieldDecl>(NewMember)) {
2099 Fields.push_back(Field);
2100 } else if (EnumDecl *Enum = dyn_cast<EnumDecl>(NewMember)) {
2101 // C++11 [temp.inst]p1: The implicit instantiation of a class template
2102 // specialization causes the implicit instantiation of the definitions
2103 // of unscoped member enumerations.
2104 // Record a point of instantiation for this implicit instantiation.
2105 if (TSK == TSK_ImplicitInstantiation && !Enum->isScoped() &&
2106 Enum->isCompleteDefinition()) {
2107 MemberSpecializationInfo *MSInfo =Enum->getMemberSpecializationInfo();
2108 assert(MSInfo && "no spec info for member enum specialization")((MSInfo && "no spec info for member enum specialization"
) ? static_cast<void> (0) : __assert_fail ("MSInfo && \"no spec info for member enum specialization\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2108, __PRETTY_FUNCTION__))
;
2109 MSInfo->setTemplateSpecializationKind(TSK_ImplicitInstantiation);
2110 MSInfo->setPointOfInstantiation(PointOfInstantiation);
2111 }
2112 } else if (StaticAssertDecl *SA = dyn_cast<StaticAssertDecl>(NewMember)) {
2113 if (SA->isFailed()) {
2114 // A static_assert failed. Bail out; instantiating this
2115 // class is probably not meaningful.
2116 Instantiation->setInvalidDecl();
2117 break;
2118 }
2119 }
2120
2121 if (NewMember->isInvalidDecl())
2122 Instantiation->setInvalidDecl();
2123 } else {
2124 // FIXME: Eventually, a NULL return will mean that one of the
2125 // instantiations was a semantic disaster, and we'll want to mark the
2126 // declaration invalid.
2127 // For now, we expect to skip some members that we can't yet handle.
2128 }
2129 }
2130
2131 // Finish checking fields.
2132 ActOnFields(nullptr, Instantiation->getLocation(), Instantiation, Fields,
2133 SourceLocation(), SourceLocation(), ParsedAttributesView());
2134 CheckCompletedCXXClass(Instantiation);
2135
2136 // Default arguments are parsed, if not instantiated. We can go instantiate
2137 // default arg exprs for default constructors if necessary now.
2138 ActOnFinishCXXNonNestedClass(Instantiation);
2139
2140 // Instantiate late parsed attributes, and attach them to their decls.
2141 // See Sema::InstantiateAttrs
2142 for (LateInstantiatedAttrVec::iterator I = LateAttrs.begin(),
2143 E = LateAttrs.end(); I != E; ++I) {
2144 assert(CurrentInstantiationScope == Instantiator.getStartingScope())((CurrentInstantiationScope == Instantiator.getStartingScope(
)) ? static_cast<void> (0) : __assert_fail ("CurrentInstantiationScope == Instantiator.getStartingScope()"
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2144, __PRETTY_FUNCTION__))
;
2145 CurrentInstantiationScope = I->Scope;
2146
2147 // Allow 'this' within late-parsed attributes.
2148 NamedDecl *ND = dyn_cast<NamedDecl>(I->NewDecl);
2149 CXXRecordDecl *ThisContext =
2150 dyn_cast_or_null<CXXRecordDecl>(ND->getDeclContext());
2151 CXXThisScopeRAII ThisScope(*this, ThisContext, /*TypeQuals*/0,
2152 ND && ND->isCXXInstanceMember());
2153
2154 Attr *NewAttr =
2155 instantiateTemplateAttribute(I->TmplAttr, Context, *this, TemplateArgs);
2156 I->NewDecl->addAttr(NewAttr);
2157 LocalInstantiationScope::deleteScopes(I->Scope,
2158 Instantiator.getStartingScope());
2159 }
2160 Instantiator.disableLateAttributeInstantiation();
2161 LateAttrs.clear();
2162
2163 ActOnFinishDelayedMemberInitializers(Instantiation);
2164
2165 // FIXME: We should do something similar for explicit instantiations so they
2166 // end up in the right module.
2167 if (TSK == TSK_ImplicitInstantiation) {
2168 Instantiation->setLocation(Pattern->getLocation());
2169 Instantiation->setLocStart(Pattern->getInnerLocStart());
2170 Instantiation->setBraceRange(Pattern->getBraceRange());
2171 }
2172
2173 if (!Instantiation->isInvalidDecl()) {
2174 // Perform any dependent diagnostics from the pattern.
2175 PerformDependentDiagnostics(Pattern, TemplateArgs);
2176
2177 // Instantiate any out-of-line class template partial
2178 // specializations now.
2179 for (TemplateDeclInstantiator::delayed_partial_spec_iterator
2180 P = Instantiator.delayed_partial_spec_begin(),
2181 PEnd = Instantiator.delayed_partial_spec_end();
2182 P != PEnd; ++P) {
2183 if (!Instantiator.InstantiateClassTemplatePartialSpecialization(
2184 P->first, P->second)) {
2185 Instantiation->setInvalidDecl();
2186 break;
2187 }
2188 }
2189
2190 // Instantiate any out-of-line variable template partial
2191 // specializations now.
2192 for (TemplateDeclInstantiator::delayed_var_partial_spec_iterator
2193 P = Instantiator.delayed_var_partial_spec_begin(),
2194 PEnd = Instantiator.delayed_var_partial_spec_end();
2195 P != PEnd; ++P) {
2196 if (!Instantiator.InstantiateVarTemplatePartialSpecialization(
2197 P->first, P->second)) {
2198 Instantiation->setInvalidDecl();
2199 break;
2200 }
2201 }
2202 }
2203
2204 // Exit the scope of this instantiation.
2205 SavedContext.pop();
2206
2207 if (!Instantiation->isInvalidDecl()) {
2208 Consumer.HandleTagDeclDefinition(Instantiation);
2209
2210 // Always emit the vtable for an explicit instantiation definition
2211 // of a polymorphic class template specialization.
2212 if (TSK == TSK_ExplicitInstantiationDefinition)
2213 MarkVTableUsed(PointOfInstantiation, Instantiation, true);
2214 }
2215
2216 return Instantiation->isInvalidDecl();
2217}
2218
2219/// Instantiate the definition of an enum from a given pattern.
2220///
2221/// \param PointOfInstantiation The point of instantiation within the
2222/// source code.
2223/// \param Instantiation is the declaration whose definition is being
2224/// instantiated. This will be a member enumeration of a class
2225/// temploid specialization, or a local enumeration within a
2226/// function temploid specialization.
2227/// \param Pattern The templated declaration from which the instantiation
2228/// occurs.
2229/// \param TemplateArgs The template arguments to be substituted into
2230/// the pattern.
2231/// \param TSK The kind of implicit or explicit instantiation to perform.
2232///
2233/// \return \c true if an error occurred, \c false otherwise.
2234bool Sema::InstantiateEnum(SourceLocation PointOfInstantiation,
2235 EnumDecl *Instantiation, EnumDecl *Pattern,
2236 const MultiLevelTemplateArgumentList &TemplateArgs,
2237 TemplateSpecializationKind TSK) {
2238 EnumDecl *PatternDef = Pattern->getDefinition();
2239 if (DiagnoseUninstantiableTemplate(PointOfInstantiation, Instantiation,
2240 Instantiation->getInstantiatedFromMemberEnum(),
2241 Pattern, PatternDef, TSK,/*Complain*/true))
2242 return true;
2243 Pattern = PatternDef;
2244
2245 // Record the point of instantiation.
2246 if (MemberSpecializationInfo *MSInfo
2247 = Instantiation->getMemberSpecializationInfo()) {
2248 MSInfo->setTemplateSpecializationKind(TSK);
2249 MSInfo->setPointOfInstantiation(PointOfInstantiation);
2250 }
2251
2252 InstantiatingTemplate Inst(*this, PointOfInstantiation, Instantiation);
2253 if (Inst.isInvalid())
2254 return true;
2255 if (Inst.isAlreadyInstantiating())
2256 return false;
2257 PrettyDeclStackTraceEntry CrashInfo(Context, Instantiation, SourceLocation(),
2258 "instantiating enum definition");
2259
2260 // The instantiation is visible here, even if it was first declared in an
2261 // unimported module.
2262 Instantiation->setVisibleDespiteOwningModule();
2263
2264 // Enter the scope of this instantiation. We don't use
2265 // PushDeclContext because we don't have a scope.
2266 ContextRAII SavedContext(*this, Instantiation);
2267 EnterExpressionEvaluationContext EvalContext(
2268 *this, Sema::ExpressionEvaluationContext::PotentiallyEvaluated);
2269
2270 LocalInstantiationScope Scope(*this, /*MergeWithParentScope*/true);
2271
2272 // Pull attributes from the pattern onto the instantiation.
2273 InstantiateAttrs(TemplateArgs, Pattern, Instantiation);
2274
2275 TemplateDeclInstantiator Instantiator(*this, Instantiation, TemplateArgs);
2276 Instantiator.InstantiateEnumDefinition(Instantiation, Pattern);
2277
2278 // Exit the scope of this instantiation.
2279 SavedContext.pop();
2280
2281 return Instantiation->isInvalidDecl();
2282}
2283
2284
2285/// Instantiate the definition of a field from the given pattern.
2286///
2287/// \param PointOfInstantiation The point of instantiation within the
2288/// source code.
2289/// \param Instantiation is the declaration whose definition is being
2290/// instantiated. This will be a class of a class temploid
2291/// specialization, or a local enumeration within a function temploid
2292/// specialization.
2293/// \param Pattern The templated declaration from which the instantiation
2294/// occurs.
2295/// \param TemplateArgs The template arguments to be substituted into
2296/// the pattern.
2297///
2298/// \return \c true if an error occurred, \c false otherwise.
2299bool Sema::InstantiateInClassInitializer(
2300 SourceLocation PointOfInstantiation, FieldDecl *Instantiation,
2301 FieldDecl *Pattern, const MultiLevelTemplateArgumentList &TemplateArgs) {
2302 // If there is no initializer, we don't need to do anything.
2303 if (!Pattern->hasInClassInitializer())
2304 return false;
2305
2306 assert(Instantiation->getInClassInitStyle() ==((Instantiation->getInClassInitStyle() == Pattern->getInClassInitStyle
() && "pattern and instantiation disagree about init style"
) ? static_cast<void> (0) : __assert_fail ("Instantiation->getInClassInitStyle() == Pattern->getInClassInitStyle() && \"pattern and instantiation disagree about init style\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2308, __PRETTY_FUNCTION__))
2307 Pattern->getInClassInitStyle() &&((Instantiation->getInClassInitStyle() == Pattern->getInClassInitStyle
() && "pattern and instantiation disagree about init style"
) ? static_cast<void> (0) : __assert_fail ("Instantiation->getInClassInitStyle() == Pattern->getInClassInitStyle() && \"pattern and instantiation disagree about init style\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2308, __PRETTY_FUNCTION__))
2308 "pattern and instantiation disagree about init style")((Instantiation->getInClassInitStyle() == Pattern->getInClassInitStyle
() && "pattern and instantiation disagree about init style"
) ? static_cast<void> (0) : __assert_fail ("Instantiation->getInClassInitStyle() == Pattern->getInClassInitStyle() && \"pattern and instantiation disagree about init style\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2308, __PRETTY_FUNCTION__))
;
2309
2310 // Error out if we haven't parsed the initializer of the pattern yet because
2311 // we are waiting for the closing brace of the outer class.
2312 Expr *OldInit = Pattern->getInClassInitializer();
2313 if (!OldInit) {
2314 RecordDecl *PatternRD = Pattern->getParent();
2315 RecordDecl *OutermostClass = PatternRD->getOuterLexicalRecordContext();
2316 Diag(PointOfInstantiation,
2317 diag::err_in_class_initializer_not_yet_parsed)
2318 << OutermostClass << Pattern;
2319 Diag(Pattern->getEndLoc(), diag::note_in_class_initializer_not_yet_parsed);
2320 Instantiation->setInvalidDecl();
2321 return true;
2322 }
2323
2324 InstantiatingTemplate Inst(*this, PointOfInstantiation, Instantiation);
2325 if (Inst.isInvalid())
2326 return true;
2327 if (Inst.isAlreadyInstantiating()) {
2328 // Error out if we hit an instantiation cycle for this initializer.
2329 Diag(PointOfInstantiation, diag::err_in_class_initializer_cycle)
2330 << Instantiation;
2331 return true;
2332 }
2333 PrettyDeclStackTraceEntry CrashInfo(Context, Instantiation, SourceLocation(),
2334 "instantiating default member init");
2335
2336 // Enter the scope of this instantiation. We don't use PushDeclContext because
2337 // we don't have a scope.
2338 ContextRAII SavedContext(*this, Instantiation->getParent());
2339 EnterExpressionEvaluationContext EvalContext(
2340 *this, Sema::ExpressionEvaluationContext::PotentiallyEvaluated);
2341
2342 LocalInstantiationScope Scope(*this, true);
2343
2344 // Instantiate the initializer.
2345 ActOnStartCXXInClassMemberInitializer();
2346 CXXThisScopeRAII ThisScope(*this, Instantiation->getParent(), /*TypeQuals=*/0);
2347
2348 ExprResult NewInit = SubstInitializer(OldInit, TemplateArgs,
2349 /*CXXDirectInit=*/false);
2350 Expr *Init = NewInit.get();
2351 assert((!Init || !isa<ParenListExpr>(Init)) && "call-style init in class")(((!Init || !isa<ParenListExpr>(Init)) && "call-style init in class"
) ? static_cast<void> (0) : __assert_fail ("(!Init || !isa<ParenListExpr>(Init)) && \"call-style init in class\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2351, __PRETTY_FUNCTION__))
;
2352 ActOnFinishCXXInClassMemberInitializer(
2353 Instantiation, Init ? Init->getBeginLoc() : SourceLocation(), Init);
2354
2355 if (auto *L = getASTMutationListener())
2356 L->DefaultMemberInitializerInstantiated(Instantiation);
2357
2358 // Return true if the in-class initializer is still missing.
2359 return !Instantiation->getInClassInitializer();
2360}
2361
2362namespace {
2363 /// A partial specialization whose template arguments have matched
2364 /// a given template-id.
2365 struct PartialSpecMatchResult {
2366 ClassTemplatePartialSpecializationDecl *Partial;
2367 TemplateArgumentList *Args;
2368 };
2369}
2370
2371bool Sema::usesPartialOrExplicitSpecialization(
2372 SourceLocation Loc, ClassTemplateSpecializationDecl *ClassTemplateSpec) {
2373 if (ClassTemplateSpec->getTemplateSpecializationKind() ==
2374 TSK_ExplicitSpecialization)
2375 return true;
2376
2377 SmallVector<ClassTemplatePartialSpecializationDecl *, 4> PartialSpecs;
2378 ClassTemplateSpec->getSpecializedTemplate()
2379 ->getPartialSpecializations(PartialSpecs);
2380 for (unsigned I = 0, N = PartialSpecs.size(); I != N; ++I) {
2381 TemplateDeductionInfo Info(Loc);
2382 if (!DeduceTemplateArguments(PartialSpecs[I],
2383 ClassTemplateSpec->getTemplateArgs(), Info))
2384 return true;
2385 }
2386
2387 return false;
2388}
2389
2390/// Get the instantiation pattern to use to instantiate the definition of a
2391/// given ClassTemplateSpecializationDecl (either the pattern of the primary
2392/// template or of a partial specialization).
2393static CXXRecordDecl *
2394getPatternForClassTemplateSpecialization(
2395 Sema &S, SourceLocation PointOfInstantiation,
2396 ClassTemplateSpecializationDecl *ClassTemplateSpec,
2397 TemplateSpecializationKind TSK, bool Complain) {
2398 Sema::InstantiatingTemplate Inst(S, PointOfInstantiation, ClassTemplateSpec);
2399 if (Inst.isInvalid() || Inst.isAlreadyInstantiating())
2400 return nullptr;
2401
2402 llvm::PointerUnion<ClassTemplateDecl *,
2403 ClassTemplatePartialSpecializationDecl *>
2404 Specialized = ClassTemplateSpec->getSpecializedTemplateOrPartial();
2405 if (!Specialized.is<ClassTemplatePartialSpecializationDecl *>()) {
2406 // Find best matching specialization.
2407 ClassTemplateDecl *Template = ClassTemplateSpec->getSpecializedTemplate();
2408
2409 // C++ [temp.class.spec.match]p1:
2410 // When a class template is used in a context that requires an
2411 // instantiation of the class, it is necessary to determine
2412 // whether the instantiation is to be generated using the primary
2413 // template or one of the partial specializations. This is done by
2414 // matching the template arguments of the class template
2415 // specialization with the template argument lists of the partial
2416 // specializations.
2417 typedef PartialSpecMatchResult MatchResult;
2418 SmallVector<MatchResult, 4> Matched;
2419 SmallVector<ClassTemplatePartialSpecializationDecl *, 4> PartialSpecs;
2420 Template->getPartialSpecializations(PartialSpecs);
2421 TemplateSpecCandidateSet FailedCandidates(PointOfInstantiation);
2422 for (unsigned I = 0, N = PartialSpecs.size(); I != N; ++I) {
2423 ClassTemplatePartialSpecializationDecl *Partial = PartialSpecs[I];
2424 TemplateDeductionInfo Info(FailedCandidates.getLocation());
2425 if (Sema::TemplateDeductionResult Result = S.DeduceTemplateArguments(
2426 Partial, ClassTemplateSpec->getTemplateArgs(), Info)) {
2427 // Store the failed-deduction information for use in diagnostics, later.
2428 // TODO: Actually use the failed-deduction info?
2429 FailedCandidates.addCandidate().set(
2430 DeclAccessPair::make(Template, AS_public), Partial,
2431 MakeDeductionFailureInfo(S.Context, Result, Info));
2432 (void)Result;
2433 } else {
2434 Matched.push_back(PartialSpecMatchResult());
2435 Matched.back().Partial = Partial;
2436 Matched.back().Args = Info.take();
2437 }
2438 }
2439
2440 // If we're dealing with a member template where the template parameters
2441 // have been instantiated, this provides the original template parameters
2442 // from which the member template's parameters were instantiated.
2443
2444 if (Matched.size() >= 1) {
2445 SmallVectorImpl<MatchResult>::iterator Best = Matched.begin();
2446 if (Matched.size() == 1) {
2447 // -- If exactly one matching specialization is found, the
2448 // instantiation is generated from that specialization.
2449 // We don't need to do anything for this.
2450 } else {
2451 // -- If more than one matching specialization is found, the
2452 // partial order rules (14.5.4.2) are used to determine
2453 // whether one of the specializations is more specialized
2454 // than the others. If none of the specializations is more
2455 // specialized than all of the other matching
2456 // specializations, then the use of the class template is
2457 // ambiguous and the program is ill-formed.
2458 for (SmallVectorImpl<MatchResult>::iterator P = Best + 1,
2459 PEnd = Matched.end();
2460 P != PEnd; ++P) {
2461 if (S.getMoreSpecializedPartialSpecialization(
2462 P->Partial, Best->Partial, PointOfInstantiation) ==
2463 P->Partial)
2464 Best = P;
2465 }
2466
2467 // Determine if the best partial specialization is more specialized than
2468 // the others.
2469 bool Ambiguous = false;
2470 for (SmallVectorImpl<MatchResult>::iterator P = Matched.begin(),
2471 PEnd = Matched.end();
2472 P != PEnd; ++P) {
2473 if (P != Best && S.getMoreSpecializedPartialSpecialization(
2474 P->Partial, Best->Partial,
2475 PointOfInstantiation) != Best->Partial) {
2476 Ambiguous = true;
2477 break;
2478 }
2479 }
2480
2481 if (Ambiguous) {
2482 // Partial ordering did not produce a clear winner. Complain.
2483 Inst.Clear();
2484 ClassTemplateSpec->setInvalidDecl();
2485 S.Diag(PointOfInstantiation,
2486 diag::err_partial_spec_ordering_ambiguous)
2487 << ClassTemplateSpec;
2488
2489 // Print the matching partial specializations.
2490 for (SmallVectorImpl<MatchResult>::iterator P = Matched.begin(),
2491 PEnd = Matched.end();
2492 P != PEnd; ++P)
2493 S.Diag(P->Partial->getLocation(), diag::note_partial_spec_match)
2494 << S.getTemplateArgumentBindingsText(
2495 P->Partial->getTemplateParameters(), *P->Args);
2496
2497 return nullptr;
2498 }
2499 }
2500
2501 ClassTemplateSpec->setInstantiationOf(Best->Partial, Best->Args);
2502 } else {
2503 // -- If no matches are found, the instantiation is generated
2504 // from the primary template.
2505 }
2506 }
2507
2508 CXXRecordDecl *Pattern = nullptr;
2509 Specialized = ClassTemplateSpec->getSpecializedTemplateOrPartial();
2510 if (auto *PartialSpec =
2511 Specialized.dyn_cast<ClassTemplatePartialSpecializationDecl *>()) {
2512 // Instantiate using the best class template partial specialization.
2513 while (PartialSpec->getInstantiatedFromMember()) {
2514 // If we've found an explicit specialization of this class template,
2515 // stop here and use that as the pattern.
2516 if (PartialSpec->isMemberSpecialization())
2517 break;
2518
2519 PartialSpec = PartialSpec->getInstantiatedFromMember();
2520 }
2521 Pattern = PartialSpec;
2522 } else {
2523 ClassTemplateDecl *Template = ClassTemplateSpec->getSpecializedTemplate();
2524 while (Template->getInstantiatedFromMemberTemplate()) {
2525 // If we've found an explicit specialization of this class template,
2526 // stop here and use that as the pattern.
2527 if (Template->isMemberSpecialization())
2528 break;
2529
2530 Template = Template->getInstantiatedFromMemberTemplate();
2531 }
2532 Pattern = Template->getTemplatedDecl();
2533 }
2534
2535 return Pattern;
2536}
2537
2538bool Sema::InstantiateClassTemplateSpecialization(
2539 SourceLocation PointOfInstantiation,
2540 ClassTemplateSpecializationDecl *ClassTemplateSpec,
2541 TemplateSpecializationKind TSK, bool Complain) {
2542 // Perform the actual instantiation on the canonical declaration.
2543 ClassTemplateSpec = cast<ClassTemplateSpecializationDecl>(
2544 ClassTemplateSpec->getCanonicalDecl());
2545 if (ClassTemplateSpec->isInvalidDecl())
2546 return true;
2547
2548 CXXRecordDecl *Pattern = getPatternForClassTemplateSpecialization(
2549 *this, PointOfInstantiation, ClassTemplateSpec, TSK, Complain);
2550 if (!Pattern)
2551 return true;
2552
2553 return InstantiateClass(PointOfInstantiation, ClassTemplateSpec, Pattern,
2554 getTemplateInstantiationArgs(ClassTemplateSpec), TSK,
2555 Complain);
2556}
2557
2558/// Instantiates the definitions of all of the member
2559/// of the given class, which is an instantiation of a class template
2560/// or a member class of a template.
2561void
2562Sema::InstantiateClassMembers(SourceLocation PointOfInstantiation,
2563 CXXRecordDecl *Instantiation,
2564 const MultiLevelTemplateArgumentList &TemplateArgs,
2565 TemplateSpecializationKind TSK) {
2566 // FIXME: We need to notify the ASTMutationListener that we did all of these
2567 // things, in case we have an explicit instantiation definition in a PCM, a
2568 // module, or preamble, and the declaration is in an imported AST.
2569 assert((((TSK == TSK_ExplicitInstantiationDefinition || TSK == TSK_ExplicitInstantiationDeclaration
|| (TSK == TSK_ImplicitInstantiation && Instantiation
->isLocalClass())) && "Unexpected template specialization kind!"
) ? static_cast<void> (0) : __assert_fail ("(TSK == TSK_ExplicitInstantiationDefinition || TSK == TSK_ExplicitInstantiationDeclaration || (TSK == TSK_ImplicitInstantiation && Instantiation->isLocalClass())) && \"Unexpected template specialization kind!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2573, __PRETTY_FUNCTION__))
2570 (TSK == TSK_ExplicitInstantiationDefinition ||(((TSK == TSK_ExplicitInstantiationDefinition || TSK == TSK_ExplicitInstantiationDeclaration
|| (TSK == TSK_ImplicitInstantiation && Instantiation
->isLocalClass())) && "Unexpected template specialization kind!"
) ? static_cast<void> (0) : __assert_fail ("(TSK == TSK_ExplicitInstantiationDefinition || TSK == TSK_ExplicitInstantiationDeclaration || (TSK == TSK_ImplicitInstantiation && Instantiation->isLocalClass())) && \"Unexpected template specialization kind!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2573, __PRETTY_FUNCTION__))
2571 TSK == TSK_ExplicitInstantiationDeclaration ||(((TSK == TSK_ExplicitInstantiationDefinition || TSK == TSK_ExplicitInstantiationDeclaration
|| (TSK == TSK_ImplicitInstantiation && Instantiation
->isLocalClass())) && "Unexpected template specialization kind!"
) ? static_cast<void> (0) : __assert_fail ("(TSK == TSK_ExplicitInstantiationDefinition || TSK == TSK_ExplicitInstantiationDeclaration || (TSK == TSK_ImplicitInstantiation && Instantiation->isLocalClass())) && \"Unexpected template specialization kind!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2573, __PRETTY_FUNCTION__))
2572 (TSK == TSK_ImplicitInstantiation && Instantiation->isLocalClass())) &&(((TSK == TSK_ExplicitInstantiationDefinition || TSK == TSK_ExplicitInstantiationDeclaration
|| (TSK == TSK_ImplicitInstantiation && Instantiation
->isLocalClass())) && "Unexpected template specialization kind!"
) ? static_cast<void> (0) : __assert_fail ("(TSK == TSK_ExplicitInstantiationDefinition || TSK == TSK_ExplicitInstantiationDeclaration || (TSK == TSK_ImplicitInstantiation && Instantiation->isLocalClass())) && \"Unexpected template specialization kind!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2573, __PRETTY_FUNCTION__))
2573 "Unexpected template specialization kind!")(((TSK == TSK_ExplicitInstantiationDefinition || TSK == TSK_ExplicitInstantiationDeclaration
|| (TSK == TSK_ImplicitInstantiation && Instantiation
->isLocalClass())) && "Unexpected template specialization kind!"
) ? static_cast<void> (0) : __assert_fail ("(TSK == TSK_ExplicitInstantiationDefinition || TSK == TSK_ExplicitInstantiationDeclaration || (TSK == TSK_ImplicitInstantiation && Instantiation->isLocalClass())) && \"Unexpected template specialization kind!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2573, __PRETTY_FUNCTION__))
;
2574 for (auto *D : Instantiation->decls()) {
2575 bool SuppressNew = false;
2576 if (auto *Function = dyn_cast<FunctionDecl>(D)) {
2577 if (FunctionDecl *Pattern =
2578 Function->getInstantiatedFromMemberFunction()) {
2579
2580 if (Function->hasAttr<ExcludeFromExplicitInstantiationAttr>())
2581 continue;
2582
2583 MemberSpecializationInfo *MSInfo =
2584 Function->getMemberSpecializationInfo();
2585 assert(MSInfo && "No member specialization information?")((MSInfo && "No member specialization information?") ?
static_cast<void> (0) : __assert_fail ("MSInfo && \"No member specialization information?\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2585, __PRETTY_FUNCTION__))
;
2586 if (MSInfo->getTemplateSpecializationKind()
2587 == TSK_ExplicitSpecialization)
2588 continue;
2589
2590 if (CheckSpecializationInstantiationRedecl(PointOfInstantiation, TSK,
2591 Function,
2592 MSInfo->getTemplateSpecializationKind(),
2593 MSInfo->getPointOfInstantiation(),
2594 SuppressNew) ||
2595 SuppressNew)
2596 continue;
2597
2598 // C++11 [temp.explicit]p8:
2599 // An explicit instantiation definition that names a class template
2600 // specialization explicitly instantiates the class template
2601 // specialization and is only an explicit instantiation definition
2602 // of members whose definition is visible at the point of
2603 // instantiation.
2604 if (TSK == TSK_ExplicitInstantiationDefinition && !Pattern->isDefined())
2605 continue;
2606
2607 Function->setTemplateSpecializationKind(TSK, PointOfInstantiation);
2608
2609 if (Function->isDefined()) {
2610 // Let the ASTConsumer know that this function has been explicitly
2611 // instantiated now, and its linkage might have changed.
2612 Consumer.HandleTopLevelDecl(DeclGroupRef(Function));
2613 } else if (TSK == TSK_ExplicitInstantiationDefinition) {
2614 InstantiateFunctionDefinition(PointOfInstantiation, Function);
2615 } else if (TSK == TSK_ImplicitInstantiation) {
2616 PendingLocalImplicitInstantiations.push_back(
2617 std::make_pair(Function, PointOfInstantiation));
2618 }
2619 }
2620 } else if (auto *Var = dyn_cast<VarDecl>(D)) {
2621 if (isa<VarTemplateSpecializationDecl>(Var))
2622 continue;
2623
2624 if (Var->isStaticDataMember()) {
2625 if (Var->hasAttr<ExcludeFromExplicitInstantiationAttr>())
2626 continue;
2627
2628 MemberSpecializationInfo *MSInfo = Var->getMemberSpecializationInfo();
2629 assert(MSInfo && "No member specialization information?")((MSInfo && "No member specialization information?") ?
static_cast<void> (0) : __assert_fail ("MSInfo && \"No member specialization information?\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2629, __PRETTY_FUNCTION__))
;
2630 if (MSInfo->getTemplateSpecializationKind()
2631 == TSK_ExplicitSpecialization)
2632 continue;
2633
2634 if (CheckSpecializationInstantiationRedecl(PointOfInstantiation, TSK,
2635 Var,
2636 MSInfo->getTemplateSpecializationKind(),
2637 MSInfo->getPointOfInstantiation(),
2638 SuppressNew) ||
2639 SuppressNew)
2640 continue;
2641
2642 if (TSK == TSK_ExplicitInstantiationDefinition) {
2643 // C++0x [temp.explicit]p8:
2644 // An explicit instantiation definition that names a class template
2645 // specialization explicitly instantiates the class template
2646 // specialization and is only an explicit instantiation definition
2647 // of members whose definition is visible at the point of
2648 // instantiation.
2649 if (!Var->getInstantiatedFromStaticDataMember()->getDefinition())
2650 continue;
2651
2652 Var->setTemplateSpecializationKind(TSK, PointOfInstantiation);
2653 InstantiateVariableDefinition(PointOfInstantiation, Var);
2654 } else {
2655 Var->setTemplateSpecializationKind(TSK, PointOfInstantiation);
2656 }
2657 }
2658 } else if (auto *Record = dyn_cast<CXXRecordDecl>(D)) {
2659 if (Record->hasAttr<ExcludeFromExplicitInstantiationAttr>())
2660 continue;
2661
2662 // Always skip the injected-class-name, along with any
2663 // redeclarations of nested classes, since both would cause us
2664 // to try to instantiate the members of a class twice.
2665 // Skip closure types; they'll get instantiated when we instantiate
2666 // the corresponding lambda-expression.
2667 if (Record->isInjectedClassName() || Record->getPreviousDecl() ||
2668 Record->isLambda())
2669 continue;
2670
2671 MemberSpecializationInfo *MSInfo = Record->getMemberSpecializationInfo();
2672 assert(MSInfo && "No member specialization information?")((MSInfo && "No member specialization information?") ?
static_cast<void> (0) : __assert_fail ("MSInfo && \"No member specialization information?\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2672, __PRETTY_FUNCTION__))
;
2673
2674 if (MSInfo->getTemplateSpecializationKind()
2675 == TSK_ExplicitSpecialization)
2676 continue;
2677
2678 if ((Context.getTargetInfo().getCXXABI().isMicrosoft() ||
2679 Context.getTargetInfo().getTriple().isWindowsItaniumEnvironment()) &&
2680 TSK == TSK_ExplicitInstantiationDeclaration) {
2681 // In MSVC and Windows Itanium mode, explicit instantiation decl of the
2682 // outer class doesn't affect the inner class.
2683 continue;
2684 }
2685
2686 if (CheckSpecializationInstantiationRedecl(PointOfInstantiation, TSK,
2687 Record,
2688 MSInfo->getTemplateSpecializationKind(),
2689 MSInfo->getPointOfInstantiation(),
2690 SuppressNew) ||
2691 SuppressNew)
2692 continue;
2693
2694 CXXRecordDecl *Pattern = Record->getInstantiatedFromMemberClass();
2695 assert(Pattern && "Missing instantiated-from-template information")((Pattern && "Missing instantiated-from-template information"
) ? static_cast<void> (0) : __assert_fail ("Pattern && \"Missing instantiated-from-template information\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2695, __PRETTY_FUNCTION__))
;
2696
2697 if (!Record->getDefinition()) {
2698 if (!Pattern->getDefinition()) {
2699 // C++0x [temp.explicit]p8:
2700 // An explicit instantiation definition that names a class template
2701 // specialization explicitly instantiates the class template
2702 // specialization and is only an explicit instantiation definition
2703 // of members whose definition is visible at the point of
2704 // instantiation.
2705 if (TSK == TSK_ExplicitInstantiationDeclaration) {
2706 MSInfo->setTemplateSpecializationKind(TSK);
2707 MSInfo->setPointOfInstantiation(PointOfInstantiation);
2708 }
2709
2710 continue;
2711 }
2712
2713 InstantiateClass(PointOfInstantiation, Record, Pattern,
2714 TemplateArgs,
2715 TSK);
2716 } else {
2717 if (TSK == TSK_ExplicitInstantiationDefinition &&
2718 Record->getTemplateSpecializationKind() ==
2719 TSK_ExplicitInstantiationDeclaration) {
2720 Record->setTemplateSpecializationKind(TSK);
2721 MarkVTableUsed(PointOfInstantiation, Record, true);
2722 }
2723 }
2724
2725 Pattern = cast_or_null<CXXRecordDecl>(Record->getDefinition());
2726 if (Pattern)
2727 InstantiateClassMembers(PointOfInstantiation, Pattern, TemplateArgs,
2728 TSK);
2729 } else if (auto *Enum = dyn_cast<EnumDecl>(D)) {
2730 MemberSpecializationInfo *MSInfo = Enum->getMemberSpecializationInfo();
2731 assert(MSInfo && "No member specialization information?")((MSInfo && "No member specialization information?") ?
static_cast<void> (0) : __assert_fail ("MSInfo && \"No member specialization information?\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2731, __PRETTY_FUNCTION__))
;
2732
2733 if (MSInfo->getTemplateSpecializationKind()
2734 == TSK_ExplicitSpecialization)
2735 continue;
2736
2737 if (CheckSpecializationInstantiationRedecl(
2738 PointOfInstantiation, TSK, Enum,
2739 MSInfo->getTemplateSpecializationKind(),
2740 MSInfo->getPointOfInstantiation(), SuppressNew) ||
2741 SuppressNew)
2742 continue;
2743
2744 if (Enum->getDefinition())
2745 continue;
2746
2747 EnumDecl *Pattern = Enum->getTemplateInstantiationPattern();
2748 assert(Pattern && "Missing instantiated-from-template information")((Pattern && "Missing instantiated-from-template information"
) ? static_cast<void> (0) : __assert_fail ("Pattern && \"Missing instantiated-from-template information\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2748, __PRETTY_FUNCTION__))
;
2749
2750 if (TSK == TSK_ExplicitInstantiationDefinition) {
2751 if (!Pattern->getDefinition())
2752 continue;
2753
2754 InstantiateEnum(PointOfInstantiation, Enum, Pattern, TemplateArgs, TSK);
2755 } else {
2756 MSInfo->setTemplateSpecializationKind(TSK);
2757 MSInfo->setPointOfInstantiation(PointOfInstantiation);
2758 }
2759 } else if (auto *Field = dyn_cast<FieldDecl>(D)) {
2760 // No need to instantiate in-class initializers during explicit
2761 // instantiation.
2762 if (Field->hasInClassInitializer() && TSK == TSK_ImplicitInstantiation) {
2763 CXXRecordDecl *ClassPattern =
2764 Instantiation->getTemplateInstantiationPattern();
2765 DeclContext::lookup_result Lookup =
2766 ClassPattern->lookup(Field->getDeclName());
2767 FieldDecl *Pattern = cast<FieldDecl>(Lookup.front());
2768 InstantiateInClassInitializer(PointOfInstantiation, Field, Pattern,
2769 TemplateArgs);
2770 }
2771 }
2772 }
2773}
2774
2775/// Instantiate the definitions of all of the members of the
2776/// given class template specialization, which was named as part of an
2777/// explicit instantiation.
2778void
2779Sema::InstantiateClassTemplateSpecializationMembers(
2780 SourceLocation PointOfInstantiation,
2781 ClassTemplateSpecializationDecl *ClassTemplateSpec,
2782 TemplateSpecializationKind TSK) {
2783 // C++0x [temp.explicit]p7:
2784 // An explicit instantiation that names a class template
2785 // specialization is an explicit instantion of the same kind
2786 // (declaration or definition) of each of its members (not
2787 // including members inherited from base classes) that has not
2788 // been previously explicitly specialized in the translation unit
2789 // containing the explicit instantiation, except as described
2790 // below.
2791 InstantiateClassMembers(PointOfInstantiation, ClassTemplateSpec,
2792 getTemplateInstantiationArgs(ClassTemplateSpec),
2793 TSK);
2794}
2795
2796StmtResult
2797Sema::SubstStmt(Stmt *S, const MultiLevelTemplateArgumentList &TemplateArgs) {
2798 if (!S)
2799 return S;
2800
2801 TemplateInstantiator Instantiator(*this, TemplateArgs,
2802 SourceLocation(),
2803 DeclarationName());
2804 return Instantiator.TransformStmt(S);
2805}
2806
2807ExprResult
2808Sema::SubstExpr(Expr *E, const MultiLevelTemplateArgumentList &TemplateArgs) {
2809 if (!E)
2810 return E;
2811
2812 TemplateInstantiator Instantiator(*this, TemplateArgs,
2813 SourceLocation(),
2814 DeclarationName());
2815 return Instantiator.TransformExpr(E);
2816}
2817
2818ExprResult Sema::SubstInitializer(Expr *Init,
2819 const MultiLevelTemplateArgumentList &TemplateArgs,
2820 bool CXXDirectInit) {
2821 TemplateInstantiator Instantiator(*this, TemplateArgs,
2822 SourceLocation(),
2823 DeclarationName());
2824 return Instantiator.TransformInitializer(Init, CXXDirectInit);
2825}
2826
2827bool Sema::SubstExprs(ArrayRef<Expr *> Exprs, bool IsCall,
2828 const MultiLevelTemplateArgumentList &TemplateArgs,
2829 SmallVectorImpl<Expr *> &Outputs) {
2830 if (Exprs.empty())
2831 return false;
2832
2833 TemplateInstantiator Instantiator(*this, TemplateArgs,
2834 SourceLocation(),
2835 DeclarationName());
2836 return Instantiator.TransformExprs(Exprs.data(), Exprs.size(),
2837 IsCall, Outputs);
2838}
2839
2840NestedNameSpecifierLoc
2841Sema::SubstNestedNameSpecifierLoc(NestedNameSpecifierLoc NNS,
2842 const MultiLevelTemplateArgumentList &TemplateArgs) {
2843 if (!NNS)
2844 return NestedNameSpecifierLoc();
2845
2846 TemplateInstantiator Instantiator(*this, TemplateArgs, NNS.getBeginLoc(),
2847 DeclarationName());
2848 return Instantiator.TransformNestedNameSpecifierLoc(NNS);
2849}
2850
2851/// Do template substitution on declaration name info.
2852DeclarationNameInfo
2853Sema::SubstDeclarationNameInfo(const DeclarationNameInfo &NameInfo,
2854 const MultiLevelTemplateArgumentList &TemplateArgs) {
2855 TemplateInstantiator Instantiator(*this, TemplateArgs, NameInfo.getLoc(),
2856 NameInfo.getName());
2857 return Instantiator.TransformDeclarationNameInfo(NameInfo);
2858}
2859
2860TemplateName
2861Sema::SubstTemplateName(NestedNameSpecifierLoc QualifierLoc,
2862 TemplateName Name, SourceLocation Loc,
2863 const MultiLevelTemplateArgumentList &TemplateArgs) {
2864 TemplateInstantiator Instantiator(*this, TemplateArgs, Loc,
2865 DeclarationName());
2866 CXXScopeSpec SS;
2867 SS.Adopt(QualifierLoc);
2868 return Instantiator.TransformTemplateName(SS, Name, Loc);
2869}
2870
2871bool Sema::Subst(const TemplateArgumentLoc *Args, unsigned NumArgs,
2872 TemplateArgumentListInfo &Result,
2873 const MultiLevelTemplateArgumentList &TemplateArgs) {
2874 TemplateInstantiator Instantiator(*this, TemplateArgs, SourceLocation(),
2875 DeclarationName());
2876
2877 return Instantiator.TransformTemplateArguments(Args, NumArgs, Result);
2878}
2879
2880static const Decl *getCanonicalParmVarDecl(const Decl *D) {
2881 // When storing ParmVarDecls in the local instantiation scope, we always
2882 // want to use the ParmVarDecl from the canonical function declaration,
2883 // since the map is then valid for any redeclaration or definition of that
2884 // function.
2885 if (const ParmVarDecl *PV = dyn_cast<ParmVarDecl>(D)) {
2886 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(PV->getDeclContext())) {
2887 unsigned i = PV->getFunctionScopeIndex();
2888 // This parameter might be from a freestanding function type within the
2889 // function and isn't necessarily referring to one of FD's parameters.
2890 if (FD->getParamDecl(i) == PV)
2891 return FD->getCanonicalDecl()->getParamDecl(i);
2892 }
2893 }
2894 return D;
2895}
2896
2897
2898llvm::PointerUnion<Decl *, LocalInstantiationScope::DeclArgumentPack *> *
2899LocalInstantiationScope::findInstantiationOf(const Decl *D) {
2900 D = getCanonicalParmVarDecl(D);
2901 for (LocalInstantiationScope *Current = this; Current;
2902 Current = Current->Outer) {
2903
2904 // Check if we found something within this scope.
2905 const Decl *CheckD = D;
2906 do {
2907 LocalDeclsMap::iterator Found = Current->LocalDecls.find(CheckD);
2908 if (Found != Current->LocalDecls.end())
2909 return &Found->second;
2910
2911 // If this is a tag declaration, it's possible that we need to look for
2912 // a previous declaration.
2913 if (const TagDecl *Tag = dyn_cast<TagDecl>(CheckD))
2914 CheckD = Tag->getPreviousDecl();
2915 else
2916 CheckD = nullptr;
2917 } while (CheckD);
2918
2919 // If we aren't combined with our outer scope, we're done.
2920 if (!Current->CombineWithOuterScope)
2921 break;
2922 }
2923
2924 // If we're performing a partial substitution during template argument
2925 // deduction, we may not have values for template parameters yet.
2926 if (isa<NonTypeTemplateParmDecl>(D) || isa<TemplateTypeParmDecl>(D) ||
2927 isa<TemplateTemplateParmDecl>(D))
2928 return nullptr;
2929
2930 // Local types referenced prior to definition may require instantiation.
2931 if (const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(D))
2932 if (RD->isLocalClass())
2933 return nullptr;
2934
2935 // Enumeration types referenced prior to definition may appear as a result of
2936 // error recovery.
2937 if (isa<EnumDecl>(D))
2938 return nullptr;
2939
2940 // If we didn't find the decl, then we either have a sema bug, or we have a
2941 // forward reference to a label declaration. Return null to indicate that
2942 // we have an uninstantiated label.
2943 assert(isa<LabelDecl>(D) && "declaration not instantiated in this scope")((isa<LabelDecl>(D) && "declaration not instantiated in this scope"
) ? static_cast<void> (0) : __assert_fail ("isa<LabelDecl>(D) && \"declaration not instantiated in this scope\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2943, __PRETTY_FUNCTION__))
;
2944 return nullptr;
2945}
2946
2947void LocalInstantiationScope::InstantiatedLocal(const Decl *D, Decl *Inst) {
2948 D = getCanonicalParmVarDecl(D);
2949 llvm::PointerUnion<Decl *, DeclArgumentPack *> &Stored = LocalDecls[D];
2950 if (Stored.isNull()) {
2951#ifndef NDEBUG
2952 // It should not be present in any surrounding scope either.
2953 LocalInstantiationScope *Current = this;
2954 while (Current->CombineWithOuterScope && Current->Outer) {
2955 Current = Current->Outer;
2956 assert(Current->LocalDecls.find(D) == Current->LocalDecls.end() &&((Current->LocalDecls.find(D) == Current->LocalDecls.end
() && "Instantiated local in inner and outer scopes")
? static_cast<void> (0) : __assert_fail ("Current->LocalDecls.find(D) == Current->LocalDecls.end() && \"Instantiated local in inner and outer scopes\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2957, __PRETTY_FUNCTION__))
2957 "Instantiated local in inner and outer scopes")((Current->LocalDecls.find(D) == Current->LocalDecls.end
() && "Instantiated local in inner and outer scopes")
? static_cast<void> (0) : __assert_fail ("Current->LocalDecls.find(D) == Current->LocalDecls.end() && \"Instantiated local in inner and outer scopes\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2957, __PRETTY_FUNCTION__))
;
2958 }
2959#endif
2960 Stored = Inst;
2961 } else if (DeclArgumentPack *Pack = Stored.dyn_cast<DeclArgumentPack *>()) {
2962 Pack->push_back(cast<ParmVarDecl>(Inst));
2963 } else {
2964 assert(Stored.get<Decl *>() == Inst && "Already instantiated this local")((Stored.get<Decl *>() == Inst && "Already instantiated this local"
) ? static_cast<void> (0) : __assert_fail ("Stored.get<Decl *>() == Inst && \"Already instantiated this local\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2964, __PRETTY_FUNCTION__))
;
2965 }
2966}
2967
2968void LocalInstantiationScope::InstantiatedLocalPackArg(const Decl *D,
2969 ParmVarDecl *Inst) {
2970 D = getCanonicalParmVarDecl(D);
2971 DeclArgumentPack *Pack = LocalDecls[D].get<DeclArgumentPack *>();
2972 Pack->push_back(Inst);
2973}
2974
2975void LocalInstantiationScope::MakeInstantiatedLocalArgPack(const Decl *D) {
2976#ifndef NDEBUG
2977 // This should be the first time we've been told about this decl.
2978 for (LocalInstantiationScope *Current = this;
2979 Current && Current->CombineWithOuterScope; Current = Current->Outer)
2980 assert(Current->LocalDecls.find(D) == Current->LocalDecls.end() &&((Current->LocalDecls.find(D) == Current->LocalDecls.end
() && "Creating local pack after instantiation of local"
) ? static_cast<void> (0) : __assert_fail ("Current->LocalDecls.find(D) == Current->LocalDecls.end() && \"Creating local pack after instantiation of local\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2981, __PRETTY_FUNCTION__))
2981 "Creating local pack after instantiation of local")((Current->LocalDecls.find(D) == Current->LocalDecls.end
() && "Creating local pack after instantiation of local"
) ? static_cast<void> (0) : __assert_fail ("Current->LocalDecls.find(D) == Current->LocalDecls.end() && \"Creating local pack after instantiation of local\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2981, __PRETTY_FUNCTION__))
;
2982#endif
2983
2984 D = getCanonicalParmVarDecl(D);
2985 llvm::PointerUnion<Decl *, DeclArgumentPack *> &Stored = LocalDecls[D];
2986 DeclArgumentPack *Pack = new DeclArgumentPack;
2987 Stored = Pack;
2988 ArgumentPacks.push_back(Pack);
2989}
2990
2991void LocalInstantiationScope::SetPartiallySubstitutedPack(NamedDecl *Pack,
2992 const TemplateArgument *ExplicitArgs,
2993 unsigned NumExplicitArgs) {
2994 assert((!PartiallySubstitutedPack || PartiallySubstitutedPack == Pack) &&(((!PartiallySubstitutedPack || PartiallySubstitutedPack == Pack
) && "Already have a partially-substituted pack") ? static_cast
<void> (0) : __assert_fail ("(!PartiallySubstitutedPack || PartiallySubstitutedPack == Pack) && \"Already have a partially-substituted pack\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2995, __PRETTY_FUNCTION__))
2995 "Already have a partially-substituted pack")(((!PartiallySubstitutedPack || PartiallySubstitutedPack == Pack
) && "Already have a partially-substituted pack") ? static_cast
<void> (0) : __assert_fail ("(!PartiallySubstitutedPack || PartiallySubstitutedPack == Pack) && \"Already have a partially-substituted pack\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2995, __PRETTY_FUNCTION__))
;
2996 assert((!PartiallySubstitutedPack(((!PartiallySubstitutedPack || NumArgsInPartiallySubstitutedPack
== NumExplicitArgs) && "Wrong number of arguments in partially-substituted pack"
) ? static_cast<void> (0) : __assert_fail ("(!PartiallySubstitutedPack || NumArgsInPartiallySubstitutedPack == NumExplicitArgs) && \"Wrong number of arguments in partially-substituted pack\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2998, __PRETTY_FUNCTION__))
2997 || NumArgsInPartiallySubstitutedPack == NumExplicitArgs) &&(((!PartiallySubstitutedPack || NumArgsInPartiallySubstitutedPack
== NumExplicitArgs) && "Wrong number of arguments in partially-substituted pack"
) ? static_cast<void> (0) : __assert_fail ("(!PartiallySubstitutedPack || NumArgsInPartiallySubstitutedPack == NumExplicitArgs) && \"Wrong number of arguments in partially-substituted pack\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2998, __PRETTY_FUNCTION__))
2998 "Wrong number of arguments in partially-substituted pack")(((!PartiallySubstitutedPack || NumArgsInPartiallySubstitutedPack
== NumExplicitArgs) && "Wrong number of arguments in partially-substituted pack"
) ? static_cast<void> (0) : __assert_fail ("(!PartiallySubstitutedPack || NumArgsInPartiallySubstitutedPack == NumExplicitArgs) && \"Wrong number of arguments in partially-substituted pack\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Sema/SemaTemplateInstantiate.cpp"
, 2998, __PRETTY_FUNCTION__))
;
2999 PartiallySubstitutedPack = Pack;
3000 ArgsInPartiallySubstitutedPack = ExplicitArgs;
3001 NumArgsInPartiallySubstitutedPack = NumExplicitArgs;
3002}
3003
3004NamedDecl *LocalInstantiationScope::getPartiallySubstitutedPack(
3005 const TemplateArgument **ExplicitArgs,
3006 unsigned *NumExplicitArgs) const {
3007 if (ExplicitArgs)
3008 *ExplicitArgs = nullptr;
3009 if (NumExplicitArgs)
3010 *NumExplicitArgs = 0;
3011
3012 for (const LocalInstantiationScope *Current = this; Current;
3013 Current = Current->Outer) {
3014 if (Current->PartiallySubstitutedPack) {
3015 if (ExplicitArgs)
3016 *ExplicitArgs = Current->ArgsInPartiallySubstitutedPack;
3017 if (NumExplicitArgs)
3018 *NumExplicitArgs = Current->NumArgsInPartiallySubstitutedPack;
3019
3020 return Current->PartiallySubstitutedPack;
3021 }
3022
3023 if (!Current->CombineWithOuterScope)
3024 break;
3025 }
3026
3027 return nullptr;
3028}

/build/llvm-toolchain-snapshot-8~svn345461/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/// 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/// overriding 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 /// 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 /// 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 /// Initializes a new tree transformer.
124 TreeTransform(Sema &SemaRef) : SemaRef(SemaRef) { }
125
126 /// Retrieves a reference to the derived class.
127 Derived &getDerived() { return static_cast<Derived&>(*this); }
128
129 /// 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 /// Retrieves a reference to the semantic analysis object used for
138 /// this tree transform.
139 Sema &getSema() const { return SemaRef; }
140
141 /// 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 /// 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 /// 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 /// 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 /// 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 /// 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 /// 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 /// 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 /// "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 /// "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 /// Note to the derived class when a function parameter pack is
281 /// being expanded.
282 void ExpandingFunctionParameterPack(ParmVarDecl *Pack) { }
283
284 /// 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 /// 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 /// 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 /// 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 /// 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 /// 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 /// 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/// 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 /// 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 /// 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 /// 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 /// 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 /// 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 /// 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 /// 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 /// 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 /// 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 /// 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 /// 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 /// 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 /// 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 /// 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 /// 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 /// Fakes up a TemplateArgumentLoc for a given TemplateArgument.
582 void InventTemplateArgumentLoc(const TemplateArgument &Arg,
583 TemplateArgumentLoc &ArgLoc);
584
585 /// 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 /// 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 /// 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 /// 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 /// 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 /// 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 /// 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 /// 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 /// 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 /// 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 /// 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 /// 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 /// 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 /// 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 /// 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 /// 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 /// Build a new potentially dependently-sized extended vector type
822 /// given the element type and 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 RebuildDependentVectorType(QualType ElementType, Expr *SizeExpr,
827 SourceLocation AttributeLoc,
828 VectorType::VectorKind);
829
830 /// Build a new extended vector type given the element type and
831 /// number of elements.
832 ///
833 /// By default, performs semantic analysis when building the vector type.
834 /// Subclasses may override this routine to provide different behavior.
835 QualType RebuildExtVectorType(QualType ElementType, unsigned NumElements,
836 SourceLocation AttributeLoc);
837
838 /// Build a new potentially dependently-sized extended vector type
839 /// given the element type and number of elements.
840 ///
841 /// By default, performs semantic analysis when building the vector type.
842 /// Subclasses may override this routine to provide different behavior.
843 QualType RebuildDependentSizedExtVectorType(QualType ElementType,
844 Expr *SizeExpr,
845 SourceLocation AttributeLoc);
846
847 /// Build a new DependentAddressSpaceType or return the pointee
848 /// type variable with the correct address space (retrieved from
849 /// AddrSpaceExpr) applied to it. The former will be returned in cases
850 /// where the address space remains dependent.
851 ///
852 /// By default, performs semantic analysis when building the type with address
853 /// space applied. Subclasses may override this routine to provide different
854 /// behavior.
855 QualType RebuildDependentAddressSpaceType(QualType PointeeType,
856 Expr *AddrSpaceExpr,
857 SourceLocation AttributeLoc);
858
859 /// Build a new function type.
860 ///
861 /// By default, performs semantic analysis when building the function type.
862 /// Subclasses may override this routine to provide different behavior.
863 QualType RebuildFunctionProtoType(QualType T,
864 MutableArrayRef<QualType> ParamTypes,
865 const FunctionProtoType::ExtProtoInfo &EPI);
866
867 /// Build a new unprototyped function type.
868 QualType RebuildFunctionNoProtoType(QualType ResultType);
869
870 /// Rebuild an unresolved typename type, given the decl that
871 /// the UnresolvedUsingTypenameDecl was transformed to.
872 QualType RebuildUnresolvedUsingType(SourceLocation NameLoc, Decl *D);
873
874 /// Build a new typedef type.
875 QualType RebuildTypedefType(TypedefNameDecl *Typedef) {
876 return SemaRef.Context.getTypeDeclType(Typedef);
877 }
878
879 /// Build a new class/struct/union type.
880 QualType RebuildRecordType(RecordDecl *Record) {
881 return SemaRef.Context.getTypeDeclType(Record);
882 }
883
884 /// Build a new Enum type.
885 QualType RebuildEnumType(EnumDecl *Enum) {
886 return SemaRef.Context.getTypeDeclType(Enum);
887 }
888
889 /// Build a new typeof(expr) type.
890 ///
891 /// By default, performs semantic analysis when building the typeof type.
892 /// Subclasses may override this routine to provide different behavior.
893 QualType RebuildTypeOfExprType(Expr *Underlying, SourceLocation Loc);
894
895 /// Build a new typeof(type) type.
896 ///
897 /// By default, builds a new TypeOfType with the given underlying type.
898 QualType RebuildTypeOfType(QualType Underlying);
899
900 /// Build a new unary transform type.
901 QualType RebuildUnaryTransformType(QualType BaseType,
902 UnaryTransformType::UTTKind UKind,
903 SourceLocation Loc);
904
905 /// Build a new C++11 decltype type.
906 ///
907 /// By default, performs semantic analysis when building the decltype type.
908 /// Subclasses may override this routine to provide different behavior.
909 QualType RebuildDecltypeType(Expr *Underlying, SourceLocation Loc);
910
911 /// Build a new C++11 auto type.
912 ///
913 /// By default, builds a new AutoType with the given deduced type.
914 QualType RebuildAutoType(QualType Deduced, AutoTypeKeyword Keyword) {
915 // Note, IsDependent is always false here: we implicitly convert an 'auto'
916 // which has been deduced to a dependent type into an undeduced 'auto', so
917 // that we'll retry deduction after the transformation.
918 return SemaRef.Context.getAutoType(Deduced, Keyword,
919 /*IsDependent*/ false);
920 }
921
922 /// By default, builds a new DeducedTemplateSpecializationType with the given
923 /// deduced type.
924 QualType RebuildDeducedTemplateSpecializationType(TemplateName Template,
925 QualType Deduced) {
926 return SemaRef.Context.getDeducedTemplateSpecializationType(
927 Template, Deduced, /*IsDependent*/ false);
928 }
929
930 /// Build a new template specialization type.
931 ///
932 /// By default, performs semantic analysis when building the template
933 /// specialization type. Subclasses may override this routine to provide
934 /// different behavior.
935 QualType RebuildTemplateSpecializationType(TemplateName Template,
936 SourceLocation TemplateLoc,
937 TemplateArgumentListInfo &Args);
938
939 /// Build a new parenthesized type.
940 ///
941 /// By default, builds a new ParenType type from the inner type.
942 /// Subclasses may override this routine to provide different behavior.
943 QualType RebuildParenType(QualType InnerType) {
944 return SemaRef.BuildParenType(InnerType);
945 }
946
947 /// Build a new qualified name type.
948 ///
949 /// By default, builds a new ElaboratedType type from the keyword,
950 /// the nested-name-specifier and the named type.
951 /// Subclasses may override this routine to provide different behavior.
952 QualType RebuildElaboratedType(SourceLocation KeywordLoc,
953 ElaboratedTypeKeyword Keyword,
954 NestedNameSpecifierLoc QualifierLoc,
955 QualType Named) {
956 return SemaRef.Context.getElaboratedType(Keyword,
957 QualifierLoc.getNestedNameSpecifier(),
958 Named);
959 }
960
961 /// Build a new typename type that refers to a template-id.
962 ///
963 /// By default, builds a new DependentNameType type from the
964 /// nested-name-specifier and the given type. Subclasses may override
965 /// this routine to provide different behavior.
966 QualType RebuildDependentTemplateSpecializationType(
967 ElaboratedTypeKeyword Keyword,
968 NestedNameSpecifierLoc QualifierLoc,
969 SourceLocation TemplateKWLoc,
970 const IdentifierInfo *Name,
971 SourceLocation NameLoc,
972 TemplateArgumentListInfo &Args,
973 bool AllowInjectedClassName) {
974 // Rebuild the template name.
975 // TODO: avoid TemplateName abstraction
976 CXXScopeSpec SS;
977 SS.Adopt(QualifierLoc);
978 TemplateName InstName = getDerived().RebuildTemplateName(
979 SS, TemplateKWLoc, *Name, NameLoc, QualType(), nullptr,
980 AllowInjectedClassName);
981
982 if (InstName.isNull())
983 return QualType();
984
985 // If it's still dependent, make a dependent specialization.
986 if (InstName.getAsDependentTemplateName())
987 return SemaRef.Context.getDependentTemplateSpecializationType(Keyword,
988 QualifierLoc.getNestedNameSpecifier(),
989 Name,
990 Args);
991
992 // Otherwise, make an elaborated type wrapping a non-dependent
993 // specialization.
994 QualType T =
995 getDerived().RebuildTemplateSpecializationType(InstName, NameLoc, Args);
996 if (T.isNull()) return QualType();
997
998 if (Keyword == ETK_None && QualifierLoc.getNestedNameSpecifier() == nullptr)
999 return T;
1000
1001 return SemaRef.Context.getElaboratedType(Keyword,
1002 QualifierLoc.getNestedNameSpecifier(),
1003 T);
1004 }
1005
1006 /// Build a new typename type that refers to an identifier.
1007 ///
1008 /// By default, performs semantic analysis when building the typename type
1009 /// (or elaborated type). Subclasses may override this routine to provide
1010 /// different behavior.
1011 QualType RebuildDependentNameType(ElaboratedTypeKeyword Keyword,
1012 SourceLocation KeywordLoc,
1013 NestedNameSpecifierLoc QualifierLoc,
1014 const IdentifierInfo *Id,
1015 SourceLocation IdLoc,
1016 bool DeducedTSTContext) {
1017 CXXScopeSpec SS;
1018 SS.Adopt(QualifierLoc);
1019
1020 if (QualifierLoc.getNestedNameSpecifier()->isDependent()) {
1021 // If the name is still dependent, just build a new dependent name type.
1022 if (!SemaRef.computeDeclContext(SS))
1023 return SemaRef.Context.getDependentNameType(Keyword,
1024 QualifierLoc.getNestedNameSpecifier(),
1025 Id);
1026 }
1027
1028 if (Keyword == ETK_None || Keyword == ETK_Typename) {
1029 QualType T = SemaRef.CheckTypenameType(Keyword, KeywordLoc, QualifierLoc,
1030 *Id, IdLoc);
1031 // If a dependent name resolves to a deduced template specialization type,
1032 // check that we're in one of the syntactic contexts permitting it.
1033 if (!DeducedTSTContext) {
1034 if (auto *Deduced = dyn_cast_or_null<DeducedTemplateSpecializationType>(
1035 T.isNull() ? nullptr : T->getContainedDeducedType())) {
1036 SemaRef.Diag(IdLoc, diag::err_dependent_deduced_tst)
1037 << (int)SemaRef.getTemplateNameKindForDiagnostics(
1038 Deduced->getTemplateName())
1039 << QualType(QualifierLoc.getNestedNameSpecifier()->getAsType(), 0);
1040 if (auto *TD = Deduced->getTemplateName().getAsTemplateDecl())
1041 SemaRef.Diag(TD->getLocation(), diag::note_template_decl_here);
1042 return QualType();
1043 }
1044 }
1045 return T;
1046 }
1047
1048 TagTypeKind Kind = TypeWithKeyword::getTagTypeKindForKeyword(Keyword);
1049
1050 // We had a dependent elaborated-type-specifier that has been transformed
1051 // into a non-dependent elaborated-type-specifier. Find the tag we're
1052 // referring to.
1053 LookupResult Result(SemaRef, Id, IdLoc, Sema::LookupTagName);
1054 DeclContext *DC = SemaRef.computeDeclContext(SS, false);
1055 if (!DC)
1056 return QualType();
1057
1058 if (SemaRef.RequireCompleteDeclContext(SS, DC))
1059 return QualType();
1060
1061 TagDecl *Tag = nullptr;
1062 SemaRef.LookupQualifiedName(Result, DC);
1063 switch (Result.getResultKind()) {
1064 case LookupResult::NotFound:
1065 case LookupResult::NotFoundInCurrentInstantiation:
1066 break;
1067
1068 case LookupResult::Found:
1069 Tag = Result.getAsSingle<TagDecl>();
1070 break;
1071
1072 case LookupResult::FoundOverloaded:
1073 case LookupResult::FoundUnresolvedValue:
1074 llvm_unreachable("Tag lookup cannot find non-tags")::llvm::llvm_unreachable_internal("Tag lookup cannot find non-tags"
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Sema/TreeTransform.h"
, 1074)
;
1075
1076 case LookupResult::Ambiguous:
1077 // Let the LookupResult structure handle ambiguities.
1078 return QualType();
1079 }
1080
1081 if (!Tag) {
1082 // Check where the name exists but isn't a tag type and use that to emit
1083 // better diagnostics.
1084 LookupResult Result(SemaRef, Id, IdLoc, Sema::LookupTagName);
1085 SemaRef.LookupQualifiedName(Result, DC);
1086 switch (Result.getResultKind()) {
1087 case LookupResult::Found:
1088 case LookupResult::FoundOverloaded:
1089 case LookupResult::FoundUnresolvedValue: {
1090 NamedDecl *SomeDecl = Result.getRepresentativeDecl();
1091 Sema::NonTagKind NTK = SemaRef.getNonTagTypeDeclKind(SomeDecl, Kind);
1092 SemaRef.Diag(IdLoc, diag::err_tag_reference_non_tag) << SomeDecl
1093 << NTK << Kind;
1094 SemaRef.Diag(SomeDecl->getLocation(), diag::note_declared_at);
1095 break;
1096 }
1097 default:
1098 SemaRef.Diag(IdLoc, diag::err_not_tag_in_scope)
1099 << Kind << Id << DC << QualifierLoc.getSourceRange();
1100 break;
1101 }
1102 return QualType();
1103 }
1104
1105 if (!SemaRef.isAcceptableTagRedeclaration(Tag, Kind, /*isDefinition*/false,
1106 IdLoc, Id)) {
1107 SemaRef.Diag(KeywordLoc, diag::err_use_with_wrong_tag) << Id;
1108 SemaRef.Diag(Tag->getLocation(), diag::note_previous_use);
1109 return QualType();
1110 }
1111
1112 // Build the elaborated-type-specifier type.
1113 QualType T = SemaRef.Context.getTypeDeclType(Tag);
1114 return SemaRef.Context.getElaboratedType(Keyword,
1115 QualifierLoc.getNestedNameSpecifier(),
1116 T);
1117 }
1118
1119 /// Build a new pack expansion type.
1120 ///
1121 /// By default, builds a new PackExpansionType type from the given pattern.
1122 /// Subclasses may override this routine to provide different behavior.
1123 QualType RebuildPackExpansionType(QualType Pattern,
1124 SourceRange PatternRange,
1125 SourceLocation EllipsisLoc,
1126 Optional<unsigned> NumExpansions) {
1127 return getSema().CheckPackExpansion(Pattern, PatternRange, EllipsisLoc,
1128 NumExpansions);
1129 }
1130
1131 /// Build a new atomic type given its value type.
1132 ///
1133 /// By default, performs semantic analysis when building the atomic type.
1134 /// Subclasses may override this routine to provide different behavior.
1135 QualType RebuildAtomicType(QualType ValueType, SourceLocation KWLoc);
1136
1137 /// Build a new pipe type given its value type.
1138 QualType RebuildPipeType(QualType ValueType, SourceLocation KWLoc,
1139 bool isReadPipe);
1140
1141 /// Build a new template name given a nested name specifier, a flag
1142 /// indicating whether the "template" keyword was provided, and the template
1143 /// that the template name refers to.
1144 ///
1145 /// By default, builds the new template name directly. Subclasses may override
1146 /// this routine to provide different behavior.
1147 TemplateName RebuildTemplateName(CXXScopeSpec &SS,
1148 bool TemplateKW,
1149 TemplateDecl *Template);
1150
1151 /// Build a new template name given a nested name specifier and the
1152 /// name that is referred to as a template.
1153 ///
1154 /// By default, performs semantic analysis to determine whether the name can
1155 /// be resolved to a specific template, then builds the appropriate kind of
1156 /// template name. Subclasses may override this routine to provide different
1157 /// behavior.
1158 TemplateName RebuildTemplateName(CXXScopeSpec &SS,
1159 SourceLocation TemplateKWLoc,
1160 const IdentifierInfo &Name,
1161 SourceLocation NameLoc, QualType ObjectType,
1162 NamedDecl *FirstQualifierInScope,
1163 bool AllowInjectedClassName);
1164
1165 /// Build a new template name given a nested name specifier and the
1166 /// overloaded operator name that is referred to as a template.
1167 ///
1168 /// By default, performs semantic analysis to determine whether the name can
1169 /// be resolved to a specific template, then builds the appropriate kind of
1170 /// template name. Subclasses may override this routine to provide different
1171 /// behavior.
1172 TemplateName RebuildTemplateName(CXXScopeSpec &SS,
1173 SourceLocation TemplateKWLoc,
1174 OverloadedOperatorKind Operator,
1175 SourceLocation NameLoc, QualType ObjectType,
1176 bool AllowInjectedClassName);
1177
1178 /// Build a new template name given a template template parameter pack
1179 /// and the
1180 ///
1181 /// By default, performs semantic analysis to determine whether the name can
1182 /// be resolved to a specific template, then builds the appropriate kind of
1183 /// template name. Subclasses may override this routine to provide different
1184 /// behavior.
1185 TemplateName RebuildTemplateName(TemplateTemplateParmDecl *Param,
1186 const TemplateArgument &ArgPack) {
1187 return getSema().Context.getSubstTemplateTemplateParmPack(Param, ArgPack);
1188 }
1189
1190 /// Build a new compound statement.
1191 ///
1192 /// By default, performs semantic analysis to build the new statement.
1193 /// Subclasses may override this routine to provide different behavior.
1194 StmtResult RebuildCompoundStmt(SourceLocation LBraceLoc,
1195 MultiStmtArg Statements,
1196 SourceLocation RBraceLoc,
1197 bool IsStmtExpr) {
1198 return getSema().ActOnCompoundStmt(LBraceLoc, RBraceLoc, Statements,
1199 IsStmtExpr);
1200 }
1201
1202 /// Build a new case statement.
1203 ///
1204 /// By default, performs semantic analysis to build the new statement.
1205 /// Subclasses may override this routine to provide different behavior.
1206 StmtResult RebuildCaseStmt(SourceLocation CaseLoc,
1207 Expr *LHS,
1208 SourceLocation EllipsisLoc,
1209 Expr *RHS,
1210 SourceLocation ColonLoc) {
1211 return getSema().ActOnCaseStmt(CaseLoc, LHS, EllipsisLoc, RHS,
1212 ColonLoc);
1213 }
1214
1215 /// Attach the body to a new case statement.
1216 ///
1217 /// By default, performs semantic analysis to build the new statement.
1218 /// Subclasses may override this routine to provide different behavior.
1219 StmtResult RebuildCaseStmtBody(Stmt *S, Stmt *Body) {
1220 getSema().ActOnCaseStmtBody(S, Body);
1221 return S;
1222 }
1223
1224 /// Build a new default statement.
1225 ///
1226 /// By default, performs semantic analysis to build the new statement.
1227 /// Subclasses may override this routine to provide different behavior.
1228 StmtResult RebuildDefaultStmt(SourceLocation DefaultLoc,
1229 SourceLocation ColonLoc,
1230 Stmt *SubStmt) {
1231 return getSema().ActOnDefaultStmt(DefaultLoc, ColonLoc, SubStmt,
1232 /*CurScope=*/nullptr);
1233 }
1234
1235 /// Build a new label statement.
1236 ///
1237 /// By default, performs semantic analysis to build the new statement.
1238 /// Subclasses may override this routine to provide different behavior.
1239 StmtResult RebuildLabelStmt(SourceLocation IdentLoc, LabelDecl *L,
1240 SourceLocation ColonLoc, Stmt *SubStmt) {
1241 return SemaRef.ActOnLabelStmt(IdentLoc, L, ColonLoc, SubStmt);
1242 }
1243
1244 /// Build a new label 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 RebuildAttributedStmt(SourceLocation AttrLoc,
1249 ArrayRef<const Attr*> Attrs,
1250 Stmt *SubStmt) {
1251 return SemaRef.ActOnAttributedStmt(AttrLoc, Attrs, SubStmt);
1252 }
1253
1254 /// Build a new "if" statement.
1255 ///
1256 /// By default, performs semantic analysis to build the new statement.
1257 /// Subclasses may override this routine to provide different behavior.
1258 StmtResult RebuildIfStmt(SourceLocation IfLoc, bool IsConstexpr,
1259 Sema::ConditionResult Cond, Stmt *Init, Stmt *Then,
1260 SourceLocation ElseLoc, Stmt *Else) {
1261 return getSema().ActOnIfStmt(IfLoc, IsConstexpr, Init, Cond, Then,
1262 ElseLoc, Else);
1263 }
1264
1265 /// Start building a new switch statement.
1266 ///
1267 /// By default, performs semantic analysis to build the new statement.
1268 /// Subclasses may override this routine to provide different behavior.
1269 StmtResult RebuildSwitchStmtStart(SourceLocation SwitchLoc, Stmt *Init,
1270 Sema::ConditionResult Cond) {
1271 return getSema().ActOnStartOfSwitchStmt(SwitchLoc, Init, Cond);
1272 }
1273
1274 /// Attach the body to the switch statement.
1275 ///
1276 /// By default, performs semantic analysis to build the new statement.
1277 /// Subclasses may override this routine to provide different behavior.
1278 StmtResult RebuildSwitchStmtBody(SourceLocation SwitchLoc,
1279 Stmt *Switch, Stmt *Body) {
1280 return getSema().ActOnFinishSwitchStmt(SwitchLoc, Switch, Body);
1281 }
1282
1283 /// Build a new while statement.
1284 ///
1285 /// By default, performs semantic analysis to build the new statement.
1286 /// Subclasses may override this routine to provide different behavior.
1287 StmtResult RebuildWhileStmt(SourceLocation WhileLoc,
1288 Sema::ConditionResult Cond, Stmt *Body) {
1289 return getSema().ActOnWhileStmt(WhileLoc, Cond, Body);
1290 }
1291
1292 /// Build a new do-while statement.
1293 ///
1294 /// By default, performs semantic analysis to build the new statement.
1295 /// Subclasses may override this routine to provide different behavior.
1296 StmtResult RebuildDoStmt(SourceLocation DoLoc, Stmt *Body,
1297 SourceLocation WhileLoc, SourceLocation LParenLoc,
1298 Expr *Cond, SourceLocation RParenLoc) {
1299 return getSema().ActOnDoStmt(DoLoc, Body, WhileLoc, LParenLoc,
1300 Cond, RParenLoc);
1301 }
1302
1303 /// Build a new for statement.
1304 ///
1305 /// By default, performs semantic analysis to build the new statement.
1306 /// Subclasses may override this routine to provide different behavior.
1307 StmtResult RebuildForStmt(SourceLocation ForLoc, SourceLocation LParenLoc,
1308 Stmt *Init, Sema::ConditionResult Cond,
1309 Sema::FullExprArg Inc, SourceLocation RParenLoc,
1310 Stmt *Body) {
1311 return getSema().ActOnForStmt(ForLoc, LParenLoc, Init, Cond,
1312 Inc, RParenLoc, Body);
1313 }
1314
1315 /// Build a new goto statement.
1316 ///
1317 /// By default, performs semantic analysis to build the new statement.
1318 /// Subclasses may override this routine to provide different behavior.
1319 StmtResult RebuildGotoStmt(SourceLocation GotoLoc, SourceLocation LabelLoc,
1320 LabelDecl *Label) {
1321 return getSema().ActOnGotoStmt(GotoLoc, LabelLoc, Label);
1322 }
1323
1324 /// Build a new indirect goto 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 RebuildIndirectGotoStmt(SourceLocation GotoLoc,
1329 SourceLocation StarLoc,
1330 Expr *Target) {
1331 return getSema().ActOnIndirectGotoStmt(GotoLoc, StarLoc, Target);
1332 }
1333
1334 /// Build a new return statement.
1335 ///
1336 /// By default, performs semantic analysis to build the new statement.
1337 /// Subclasses may override this routine to provide different behavior.
1338 StmtResult RebuildReturnStmt(SourceLocation ReturnLoc, Expr *Result) {
1339 return getSema().BuildReturnStmt(ReturnLoc, Result);
1340 }
1341
1342 /// Build a new declaration 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 RebuildDeclStmt(MutableArrayRef<Decl *> Decls,
1347 SourceLocation StartLoc, SourceLocation EndLoc) {
1348 Sema::DeclGroupPtrTy DG = getSema().BuildDeclaratorGroup(Decls);
1349 return getSema().ActOnDeclStmt(DG, StartLoc, EndLoc);
1350 }
1351
1352 /// Build a new inline asm statement.
1353 ///
1354 /// By default, performs semantic analysis to build the new statement.
1355 /// Subclasses may override this routine to provide different behavior.
1356 StmtResult RebuildGCCAsmStmt(SourceLocation AsmLoc, bool IsSimple,
1357 bool IsVolatile, unsigned NumOutputs,
1358 unsigned NumInputs, IdentifierInfo **Names,
1359 MultiExprArg Constraints, MultiExprArg Exprs,
1360 Expr *AsmString, MultiExprArg Clobbers,
1361 SourceLocation RParenLoc) {
1362 return getSema().ActOnGCCAsmStmt(AsmLoc, IsSimple, IsVolatile, NumOutputs,
1363 NumInputs, Names, Constraints, Exprs,
1364 AsmString, Clobbers, RParenLoc);
1365 }
1366
1367 /// Build a new MS style inline asm statement.
1368 ///
1369 /// By default, performs semantic analysis to build the new statement.
1370 /// Subclasses may override this routine to provide different behavior.
1371 StmtResult RebuildMSAsmStmt(SourceLocation AsmLoc, SourceLocation LBraceLoc,
1372 ArrayRef<Token> AsmToks,
1373 StringRef AsmString,
1374 unsigned NumOutputs, unsigned NumInputs,
1375 ArrayRef<StringRef> Constraints,
1376 ArrayRef<StringRef> Clobbers,
1377 ArrayRef<Expr*> Exprs,
1378 SourceLocation EndLoc) {
1379 return getSema().ActOnMSAsmStmt(AsmLoc, LBraceLoc, AsmToks, AsmString,
1380 NumOutputs, NumInputs,
1381 Constraints, Clobbers, Exprs, EndLoc);
1382 }
1383
1384 /// Build a new co_return statement.
1385 ///
1386 /// By default, performs semantic analysis to build the new statement.
1387 /// Subclasses may override this routine to provide different behavior.
1388 StmtResult RebuildCoreturnStmt(SourceLocation CoreturnLoc, Expr *Result,
1389 bool IsImplicit) {
1390 return getSema().BuildCoreturnStmt(CoreturnLoc, Result, IsImplicit);
1391 }
1392
1393 /// Build a new co_await expression.
1394 ///
1395 /// By default, performs semantic analysis to build the new expression.
1396 /// Subclasses may override this routine to provide different behavior.
1397 ExprResult RebuildCoawaitExpr(SourceLocation CoawaitLoc, Expr *Result,
1398 bool IsImplicit) {
1399 return getSema().BuildResolvedCoawaitExpr(CoawaitLoc, Result, IsImplicit);
1400 }
1401
1402 /// Build a new co_await 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 RebuildDependentCoawaitExpr(SourceLocation CoawaitLoc,
1407 Expr *Result,
1408 UnresolvedLookupExpr *Lookup) {
1409 return getSema().BuildUnresolvedCoawaitExpr(CoawaitLoc, Result, Lookup);
1410 }
1411
1412 /// Build a new co_yield expression.
1413 ///
1414 /// By default, performs semantic analysis to build the new expression.
1415 /// Subclasses may override this routine to provide different behavior.
1416 ExprResult RebuildCoyieldExpr(SourceLocation CoyieldLoc, Expr *Result) {
1417 return getSema().BuildCoyieldExpr(CoyieldLoc, Result);
1418 }
1419
1420 StmtResult RebuildCoroutineBodyStmt(CoroutineBodyStmt::CtorArgs Args) {
1421 return getSema().BuildCoroutineBodyStmt(Args);
1422 }
1423
1424 /// Build a new Objective-C \@try statement.
1425 ///
1426 /// By default, performs semantic analysis to build the new statement.
1427 /// Subclasses may override this routine to provide different behavior.
1428 StmtResult RebuildObjCAtTryStmt(SourceLocation AtLoc,
1429 Stmt *TryBody,
1430 MultiStmtArg CatchStmts,
1431 Stmt *Finally) {
1432 return getSema().ActOnObjCAtTryStmt(AtLoc, TryBody, CatchStmts,
1433 Finally);
1434 }
1435
1436 /// Rebuild an Objective-C exception declaration.
1437 ///
1438 /// By default, performs semantic analysis to build the new declaration.
1439 /// Subclasses may override this routine to provide different behavior.
1440 VarDecl *RebuildObjCExceptionDecl(VarDecl *ExceptionDecl,
1441 TypeSourceInfo *TInfo, QualType T) {
1442 return getSema().BuildObjCExceptionDecl(TInfo, T,
1443 ExceptionDecl->getInnerLocStart(),
1444 ExceptionDecl->getLocation(),
1445 ExceptionDecl->getIdentifier());
1446 }
1447
1448 /// Build a new Objective-C \@catch statement.
1449 ///
1450 /// By default, performs semantic analysis to build the new statement.
1451 /// Subclasses may override this routine to provide different behavior.
1452 StmtResult RebuildObjCAtCatchStmt(SourceLocation AtLoc,
1453 SourceLocation RParenLoc,
1454 VarDecl *Var,
1455 Stmt *Body) {
1456 return getSema().ActOnObjCAtCatchStmt(AtLoc, RParenLoc,
1457 Var, Body);
1458 }
1459
1460 /// Build a new Objective-C \@finally statement.
1461 ///
1462 /// By default, performs semantic analysis to build the new statement.
1463 /// Subclasses may override this routine to provide different behavior.
1464 StmtResult RebuildObjCAtFinallyStmt(SourceLocation AtLoc,
1465 Stmt *Body) {
1466 return getSema().ActOnObjCAtFinallyStmt(AtLoc, Body);
1467 }
1468
1469 /// Build a new Objective-C \@throw statement.
1470 ///
1471 /// By default, performs semantic analysis to build the new statement.
1472 /// Subclasses may override this routine to provide different behavior.
1473 StmtResult RebuildObjCAtThrowStmt(SourceLocation AtLoc,
1474 Expr *Operand) {
1475 return getSema().BuildObjCAtThrowStmt(AtLoc, Operand);
1476 }
1477
1478 /// Build a new OpenMP executable directive.
1479 ///
1480 /// By default, performs semantic analysis to build the new statement.
1481 /// Subclasses may override this routine to provide different behavior.
1482 StmtResult RebuildOMPExecutableDirective(OpenMPDirectiveKind Kind,
1483 DeclarationNameInfo DirName,
1484 OpenMPDirectiveKind CancelRegion,
1485 ArrayRef<OMPClause *> Clauses,
1486 Stmt *AStmt, SourceLocation StartLoc,
1487 SourceLocation EndLoc) {
1488 return getSema().ActOnOpenMPExecutableDirective(
1489 Kind, DirName, CancelRegion, Clauses, AStmt, StartLoc, EndLoc);
1490 }
1491
1492 /// Build a new OpenMP 'if' clause.
1493 ///
1494 /// By default, performs semantic analysis to build the new OpenMP clause.
1495 /// Subclasses may override this routine to provide different behavior.
1496 OMPClause *RebuildOMPIfClause(OpenMPDirectiveKind NameModifier,
1497 Expr *Condition, SourceLocation StartLoc,
1498 SourceLocation LParenLoc,
1499 SourceLocation NameModifierLoc,
1500 SourceLocation ColonLoc,
1501 SourceLocation EndLoc) {
1502 return getSema().ActOnOpenMPIfClause(NameModifier, Condition, StartLoc,
1503 LParenLoc, NameModifierLoc, ColonLoc,
1504 EndLoc);
1505 }
1506
1507 /// Build a new OpenMP 'final' clause.
1508 ///
1509 /// By default, performs semantic analysis to build the new OpenMP clause.
1510 /// Subclasses may override this routine to provide different behavior.
1511 OMPClause *RebuildOMPFinalClause(Expr *Condition, SourceLocation StartLoc,
1512 SourceLocation LParenLoc,
1513 SourceLocation EndLoc) {
1514 return getSema().ActOnOpenMPFinalClause(Condition, StartLoc, LParenLoc,
1515 EndLoc);
1516 }
1517
1518 /// Build a new OpenMP 'num_threads' clause.
1519 ///
1520 /// By default, performs semantic analysis to build the new OpenMP clause.
1521 /// Subclasses may override this routine to provide different behavior.
1522 OMPClause *RebuildOMPNumThreadsClause(Expr *NumThreads,
1523 SourceLocation StartLoc,
1524 SourceLocation LParenLoc,
1525 SourceLocation EndLoc) {
1526 return getSema().ActOnOpenMPNumThreadsClause(NumThreads, StartLoc,
1527 LParenLoc, EndLoc);
1528 }
1529
1530 /// Build a new OpenMP 'safelen' 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 *RebuildOMPSafelenClause(Expr *Len, SourceLocation StartLoc,
1535 SourceLocation LParenLoc,
1536 SourceLocation EndLoc) {
1537 return getSema().ActOnOpenMPSafelenClause(Len, StartLoc, LParenLoc, EndLoc);
1538 }
1539
1540 /// Build a new OpenMP 'simdlen' 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 *RebuildOMPSimdlenClause(Expr *Len, SourceLocation StartLoc,
1545 SourceLocation LParenLoc,
1546 SourceLocation EndLoc) {
1547 return getSema().ActOnOpenMPSimdlenClause(Len, StartLoc, LParenLoc, EndLoc);
1548 }
1549
1550 /// Build a new OpenMP 'collapse' clause.
1551 ///
1552 /// By default, performs semantic analysis to build the new OpenMP clause.
1553 /// Subclasses may override this routine to provide different behavior.
1554 OMPClause *RebuildOMPCollapseClause(Expr *Num, SourceLocation StartLoc,
1555 SourceLocation LParenLoc,
1556 SourceLocation EndLoc) {
1557 return getSema().ActOnOpenMPCollapseClause(Num, StartLoc, LParenLoc,
1558 EndLoc);
1559 }
1560
1561 /// Build a new OpenMP 'default' clause.
1562 ///
1563 /// By default, performs semantic analysis to build the new OpenMP clause.
1564 /// Subclasses may override this routine to provide different behavior.
1565 OMPClause *RebuildOMPDefaultClause(OpenMPDefaultClauseKind Kind,
1566 SourceLocation KindKwLoc,
1567 SourceLocation StartLoc,
1568 SourceLocation LParenLoc,
1569 SourceLocation EndLoc) {
1570 return getSema().ActOnOpenMPDefaultClause(Kind, KindKwLoc,
1571 StartLoc, LParenLoc, EndLoc);
1572 }
1573
1574 /// Build a new OpenMP 'proc_bind' clause.
1575 ///
1576 /// By default, performs semantic analysis to build the new OpenMP clause.
1577 /// Subclasses may override this routine to provide different behavior.
1578 OMPClause *RebuildOMPProcBindClause(OpenMPProcBindClauseKind Kind,
1579 SourceLocation KindKwLoc,
1580 SourceLocation StartLoc,
1581 SourceLocation LParenLoc,
1582 SourceLocation EndLoc) {
1583 return getSema().ActOnOpenMPProcBindClause(Kind, KindKwLoc,
1584 StartLoc, LParenLoc, EndLoc);
1585 }
1586
1587 /// Build a new OpenMP 'schedule' clause.
1588 ///
1589 /// By default, performs semantic analysis to build the new OpenMP clause.
1590 /// Subclasses may override this routine to provide different behavior.
1591 OMPClause *RebuildOMPScheduleClause(
1592 OpenMPScheduleClauseModifier M1, OpenMPScheduleClauseModifier M2,
1593 OpenMPScheduleClauseKind Kind, Expr *ChunkSize, SourceLocation StartLoc,
1594 SourceLocation LParenLoc, SourceLocation M1Loc, SourceLocation M2Loc,
1595 SourceLocation KindLoc, SourceLocation CommaLoc, SourceLocation EndLoc) {
1596 return getSema().ActOnOpenMPScheduleClause(
1597 M1, M2, Kind, ChunkSize, StartLoc, LParenLoc, M1Loc, M2Loc, KindLoc,
1598 CommaLoc, EndLoc);
1599 }
1600
1601 /// Build a new OpenMP 'ordered' 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 *RebuildOMPOrderedClause(SourceLocation StartLoc,
1606 SourceLocation EndLoc,
1607 SourceLocation LParenLoc, Expr *Num) {
1608 return getSema().ActOnOpenMPOrderedClause(StartLoc, EndLoc, LParenLoc, Num);
1609 }
1610
1611 /// Build a new OpenMP 'private' clause.
1612 ///
1613 /// By default, performs semantic analysis to build the new OpenMP clause.
1614 /// Subclasses may override this routine to provide different behavior.
1615 OMPClause *RebuildOMPPrivateClause(ArrayRef<Expr *> VarList,
1616 SourceLocation StartLoc,
1617 SourceLocation LParenLoc,
1618 SourceLocation EndLoc) {
1619 return getSema().ActOnOpenMPPrivateClause(VarList, StartLoc, LParenLoc,
1620 EndLoc);
1621 }
1622
1623 /// Build a new OpenMP 'firstprivate' clause.
1624 ///
1625 /// By default, performs semantic analysis to build the new OpenMP clause.
1626 /// Subclasses may override this routine to provide different behavior.
1627 OMPClause *RebuildOMPFirstprivateClause(ArrayRef<Expr *> VarList,
1628 SourceLocation StartLoc,
1629 SourceLocation LParenLoc,
1630 SourceLocation EndLoc) {
1631 return getSema().ActOnOpenMPFirstprivateClause(VarList, StartLoc, LParenLoc,
1632 EndLoc);
1633 }
1634
1635 /// Build a new OpenMP 'lastprivate' clause.
1636 ///
1637 /// By default, performs semantic analysis to build the new OpenMP clause.
1638 /// Subclasses may override this routine to provide different behavior.
1639 OMPClause *RebuildOMPLastprivateClause(ArrayRef<Expr *> VarList,
1640 SourceLocation StartLoc,
1641 SourceLocation LParenLoc,
1642 SourceLocation EndLoc) {
1643 return getSema().ActOnOpenMPLastprivateClause(VarList, StartLoc, LParenLoc,
1644 EndLoc);
1645 }
1646
1647 /// Build a new OpenMP 'shared' clause.
1648 ///
1649 /// By default, performs semantic analysis to build the new OpenMP clause.
1650 /// Subclasses may override this routine to provide different behavior.
1651 OMPClause *RebuildOMPSharedClause(ArrayRef<Expr *> VarList,
1652 SourceLocation StartLoc,
1653 SourceLocation LParenLoc,
1654 SourceLocation EndLoc) {
1655 return getSema().ActOnOpenMPSharedClause(VarList, StartLoc, LParenLoc,
1656 EndLoc);
1657 }
1658
1659 /// Build a new OpenMP 'reduction' clause.
1660 ///
1661 /// By default, performs semantic analysis to build the new statement.
1662 /// Subclasses may override this routine to provide different behavior.
1663 OMPClause *RebuildOMPReductionClause(ArrayRef<Expr *> VarList,
1664 SourceLocation StartLoc,
1665 SourceLocation LParenLoc,
1666 SourceLocation ColonLoc,
1667 SourceLocation EndLoc,
1668 CXXScopeSpec &ReductionIdScopeSpec,
1669 const DeclarationNameInfo &ReductionId,
1670 ArrayRef<Expr *> UnresolvedReductions) {
1671 return getSema().ActOnOpenMPReductionClause(
1672 VarList, StartLoc, LParenLoc, ColonLoc, EndLoc, ReductionIdScopeSpec,
1673 ReductionId, UnresolvedReductions);
1674 }
1675
1676 /// Build a new OpenMP 'task_reduction' clause.
1677 ///
1678 /// By default, performs semantic analysis to build the new statement.
1679 /// Subclasses may override this routine to provide different behavior.
1680 OMPClause *RebuildOMPTaskReductionClause(
1681 ArrayRef<Expr *> VarList, SourceLocation StartLoc,
1682 SourceLocation LParenLoc, SourceLocation ColonLoc, SourceLocation EndLoc,
1683 CXXScopeSpec &ReductionIdScopeSpec,
1684 const DeclarationNameInfo &ReductionId,
1685 ArrayRef<Expr *> UnresolvedReductions) {
1686 return getSema().ActOnOpenMPTaskReductionClause(
1687 VarList, StartLoc, LParenLoc, ColonLoc, EndLoc, ReductionIdScopeSpec,
1688 ReductionId, UnresolvedReductions);
1689 }
1690
1691 /// Build a new OpenMP 'in_reduction' clause.
1692 ///
1693 /// By default, performs semantic analysis to build the new statement.
1694 /// Subclasses may override this routine to provide different behavior.
1695 OMPClause *
1696 RebuildOMPInReductionClause(ArrayRef<Expr *> VarList, SourceLocation StartLoc,
1697 SourceLocation LParenLoc, SourceLocation ColonLoc,
1698 SourceLocation EndLoc,
1699 CXXScopeSpec &ReductionIdScopeSpec,
1700 const DeclarationNameInfo &ReductionId,
1701 ArrayRef<Expr *> UnresolvedReductions) {
1702 return getSema().ActOnOpenMPInReductionClause(
1703 VarList, StartLoc, LParenLoc, ColonLoc, EndLoc, ReductionIdScopeSpec,
1704 ReductionId, UnresolvedReductions);
1705 }
1706
1707 /// Build a new OpenMP 'linear' clause.
1708 ///
1709 /// By default, performs semantic analysis to build the new OpenMP clause.
1710 /// Subclasses may override this routine to provide different behavior.
1711 OMPClause *RebuildOMPLinearClause(ArrayRef<Expr *> VarList, Expr *Step,
1712 SourceLocation StartLoc,
1713 SourceLocation LParenLoc,
1714 OpenMPLinearClauseKind Modifier,
1715 SourceLocation ModifierLoc,
1716 SourceLocation ColonLoc,
1717 SourceLocation EndLoc) {
1718 return getSema().ActOnOpenMPLinearClause(VarList, Step, StartLoc, LParenLoc,
1719 Modifier, ModifierLoc, ColonLoc,
1720 EndLoc);
1721 }
1722
1723 /// Build a new OpenMP 'aligned' clause.
1724 ///
1725 /// By default, performs semantic analysis to build the new OpenMP clause.
1726 /// Subclasses may override this routine to provide different behavior.
1727 OMPClause *RebuildOMPAlignedClause(ArrayRef<Expr *> VarList, Expr *Alignment,
1728 SourceLocation StartLoc,
1729 SourceLocation LParenLoc,
1730 SourceLocation ColonLoc,
1731 SourceLocation EndLoc) {
1732 return getSema().ActOnOpenMPAlignedClause(VarList, Alignment, StartLoc,
1733 LParenLoc, ColonLoc, EndLoc);
1734 }
1735
1736 /// Build a new OpenMP 'copyin' clause.
1737 ///
1738 /// By default, performs semantic analysis to build the new OpenMP clause.
1739 /// Subclasses may override this routine to provide different behavior.
1740 OMPClause *RebuildOMPCopyinClause(ArrayRef<Expr *> VarList,
1741 SourceLocation StartLoc,
1742 SourceLocation LParenLoc,
1743 SourceLocation EndLoc) {
1744 return getSema().ActOnOpenMPCopyinClause(VarList, StartLoc, LParenLoc,
1745 EndLoc);
1746 }
1747
1748 /// Build a new OpenMP 'copyprivate' clause.
1749 ///
1750 /// By default, performs semantic analysis to build the new OpenMP clause.
1751 /// Subclasses may override this routine to provide different behavior.
1752 OMPClause *RebuildOMPCopyprivateClause(ArrayRef<Expr *> VarList,
1753 SourceLocation StartLoc,
1754 SourceLocation LParenLoc,
1755 SourceLocation EndLoc) {
1756 return getSema().ActOnOpenMPCopyprivateClause(VarList, StartLoc, LParenLoc,
1757 EndLoc);
1758 }
1759
1760 /// Build a new OpenMP 'flush' pseudo clause.
1761 ///
1762 /// By default, performs semantic analysis to build the new OpenMP clause.
1763 /// Subclasses may override this routine to provide different behavior.
1764 OMPClause *RebuildOMPFlushClause(ArrayRef<Expr *> VarList,
1765 SourceLocation StartLoc,
1766 SourceLocation LParenLoc,
1767 SourceLocation EndLoc) {
1768 return getSema().ActOnOpenMPFlushClause(VarList, StartLoc, LParenLoc,
1769 EndLoc);
1770 }
1771
1772 /// Build a new OpenMP 'depend' pseudo clause.
1773 ///
1774 /// By default, performs semantic analysis to build the new OpenMP clause.
1775 /// Subclasses may override this routine to provide different behavior.
1776 OMPClause *
1777 RebuildOMPDependClause(OpenMPDependClauseKind DepKind, SourceLocation DepLoc,
1778 SourceLocation ColonLoc, ArrayRef<Expr *> VarList,
1779 SourceLocation StartLoc, SourceLocation LParenLoc,
1780 SourceLocation EndLoc) {
1781 return getSema().ActOnOpenMPDependClause(DepKind, DepLoc, ColonLoc, VarList,
1782 StartLoc, LParenLoc, EndLoc);
1783 }
1784
1785 /// Build a new OpenMP 'device' clause.
1786 ///
1787 /// By default, performs semantic analysis to build the new statement.
1788 /// Subclasses may override this routine to provide different behavior.
1789 OMPClause *RebuildOMPDeviceClause(Expr *Device, SourceLocation StartLoc,
1790 SourceLocation LParenLoc,
1791 SourceLocation EndLoc) {
1792 return getSema().ActOnOpenMPDeviceClause(Device, StartLoc, LParenLoc,
1793 EndLoc);
1794 }
1795
1796 /// Build a new OpenMP 'map' clause.
1797 ///
1798 /// By default, performs semantic analysis to build the new OpenMP clause.
1799 /// Subclasses may override this routine to provide different behavior.
1800 OMPClause *
1801 RebuildOMPMapClause(OpenMPMapClauseKind MapTypeModifier,
1802 OpenMPMapClauseKind MapType, bool IsMapTypeImplicit,
1803 SourceLocation MapLoc, SourceLocation ColonLoc,
1804 ArrayRef<Expr *> VarList, SourceLocation StartLoc,
1805 SourceLocation LParenLoc, SourceLocation EndLoc) {
1806 return getSema().ActOnOpenMPMapClause(MapTypeModifier, MapType,
1807 IsMapTypeImplicit, MapLoc, ColonLoc,
1808 VarList, StartLoc, LParenLoc, EndLoc);
1809 }
1810
1811 /// Build a new OpenMP 'num_teams' clause.
1812 ///
1813 /// By default, performs semantic analysis to build the new statement.
1814 /// Subclasses may override this routine to provide different behavior.
1815 OMPClause *RebuildOMPNumTeamsClause(Expr *NumTeams, SourceLocation StartLoc,
1816 SourceLocation LParenLoc,
1817 SourceLocation EndLoc) {
1818 return getSema().ActOnOpenMPNumTeamsClause(NumTeams, StartLoc, LParenLoc,
1819 EndLoc);
1820 }
1821
1822 /// Build a new OpenMP 'thread_limit' clause.
1823 ///
1824 /// By default, performs semantic analysis to build the new statement.
1825 /// Subclasses may override this routine to provide different behavior.
1826 OMPClause *RebuildOMPThreadLimitClause(Expr *ThreadLimit,
1827 SourceLocation StartLoc,
1828 SourceLocation LParenLoc,
1829 SourceLocation EndLoc) {
1830 return getSema().ActOnOpenMPThreadLimitClause(ThreadLimit, StartLoc,
1831 LParenLoc, EndLoc);
1832 }
1833
1834 /// Build a new OpenMP 'priority' clause.
1835 ///
1836 /// By default, performs semantic analysis to build the new statement.
1837 /// Subclasses may override this routine to provide different behavior.
1838 OMPClause *RebuildOMPPriorityClause(Expr *Priority, SourceLocation StartLoc,
1839 SourceLocation LParenLoc,
1840 SourceLocation EndLoc) {
1841 return getSema().ActOnOpenMPPriorityClause(Priority, StartLoc, LParenLoc,
1842 EndLoc);
1843 }
1844
1845 /// Build a new OpenMP 'grainsize' clause.
1846 ///
1847 /// By default, performs semantic analysis to build the new statement.
1848 /// Subclasses may override this routine to provide different behavior.
1849 OMPClause *RebuildOMPGrainsizeClause(Expr *Grainsize, SourceLocation StartLoc,
1850 SourceLocation LParenLoc,
1851 SourceLocation EndLoc) {
1852 return getSema().ActOnOpenMPGrainsizeClause(Grainsize, StartLoc, LParenLoc,
1853 EndLoc);
1854 }
1855
1856 /// Build a new OpenMP 'num_tasks' clause.
1857 ///
1858 /// By default, performs semantic analysis to build the new statement.
1859 /// Subclasses may override this routine to provide different behavior.
1860 OMPClause *RebuildOMPNumTasksClause(Expr *NumTasks, SourceLocation StartLoc,
1861 SourceLocation LParenLoc,
1862 SourceLocation EndLoc) {
1863 return getSema().ActOnOpenMPNumTasksClause(NumTasks, StartLoc, LParenLoc,
1864 EndLoc);
1865 }
1866
1867 /// Build a new OpenMP 'hint' clause.
1868 ///
1869 /// By default, performs semantic analysis to build the new statement.
1870 /// Subclasses may override this routine to provide different behavior.
1871 OMPClause *RebuildOMPHintClause(Expr *Hint, SourceLocation StartLoc,
1872 SourceLocation LParenLoc,
1873 SourceLocation EndLoc) {
1874 return getSema().ActOnOpenMPHintClause(Hint, StartLoc, LParenLoc, EndLoc);
1875 }
1876
1877 /// Build a new OpenMP 'dist_schedule' clause.
1878 ///
1879 /// By default, performs semantic analysis to build the new OpenMP clause.
1880 /// Subclasses may override this routine to provide different behavior.
1881 OMPClause *
1882 RebuildOMPDistScheduleClause(OpenMPDistScheduleClauseKind Kind,
1883 Expr *ChunkSize, SourceLocation StartLoc,
1884 SourceLocation LParenLoc, SourceLocation KindLoc,
1885 SourceLocation CommaLoc, SourceLocation EndLoc) {
1886 return getSema().ActOnOpenMPDistScheduleClause(
1887 Kind, ChunkSize, StartLoc, LParenLoc, KindLoc, CommaLoc, EndLoc);
1888 }
1889
1890 /// Build a new OpenMP 'to' clause.
1891 ///
1892 /// By default, performs semantic analysis to build the new statement.
1893 /// Subclasses may override this routine to provide different behavior.
1894 OMPClause *RebuildOMPToClause(ArrayRef<Expr *> VarList,
1895 SourceLocation StartLoc,
1896 SourceLocation LParenLoc,
1897 SourceLocation EndLoc) {
1898 return getSema().ActOnOpenMPToClause(VarList, StartLoc, LParenLoc, EndLoc);
1899 }
1900
1901 /// Build a new OpenMP 'from' clause.
1902 ///
1903 /// By default, performs semantic analysis to build the new statement.
1904 /// Subclasses may override this routine to provide different behavior.
1905 OMPClause *RebuildOMPFromClause(ArrayRef<Expr *> VarList,
1906 SourceLocation StartLoc,
1907 SourceLocation LParenLoc,
1908 SourceLocation EndLoc) {
1909 return getSema().ActOnOpenMPFromClause(VarList, StartLoc, LParenLoc,
1910 EndLoc);
1911 }
1912
1913 /// Build a new OpenMP 'use_device_ptr' clause.
1914 ///
1915 /// By default, performs semantic analysis to build the new OpenMP clause.
1916 /// Subclasses may override this routine to provide different behavior.
1917 OMPClause *RebuildOMPUseDevicePtrClause(ArrayRef<Expr *> VarList,
1918 SourceLocation StartLoc,
1919 SourceLocation LParenLoc,
1920 SourceLocation EndLoc) {
1921 return getSema().ActOnOpenMPUseDevicePtrClause(VarList, StartLoc, LParenLoc,
1922 EndLoc);
1923 }
1924
1925 /// Build a new OpenMP 'is_device_ptr' clause.
1926 ///
1927 /// By default, performs semantic analysis to build the new OpenMP clause.
1928 /// Subclasses may override this routine to provide different behavior.
1929 OMPClause *RebuildOMPIsDevicePtrClause(ArrayRef<Expr *> VarList,
1930 SourceLocation StartLoc,
1931 SourceLocation LParenLoc,
1932 SourceLocation EndLoc) {
1933 return getSema().ActOnOpenMPIsDevicePtrClause(VarList, StartLoc, LParenLoc,
1934 EndLoc);
1935 }
1936
1937 /// Rebuild the operand to an Objective-C \@synchronized statement.
1938 ///
1939 /// By default, performs semantic analysis to build the new statement.
1940 /// Subclasses may override this routine to provide different behavior.
1941 ExprResult RebuildObjCAtSynchronizedOperand(SourceLocation atLoc,
1942 Expr *object) {
1943 return getSema().ActOnObjCAtSynchronizedOperand(atLoc, object);
1944 }
1945
1946 /// Build a new Objective-C \@synchronized statement.
1947 ///
1948 /// By default, performs semantic analysis to build the new statement.
1949 /// Subclasses may override this routine to provide different behavior.
1950 StmtResult RebuildObjCAtSynchronizedStmt(SourceLocation AtLoc,
1951 Expr *Object, Stmt *Body) {
1952 return getSema().ActOnObjCAtSynchronizedStmt(AtLoc, Object, Body);
1953 }
1954
1955 /// Build a new Objective-C \@autoreleasepool statement.
1956 ///
1957 /// By default, performs semantic analysis to build the new statement.
1958 /// Subclasses may override this routine to provide different behavior.
1959 StmtResult RebuildObjCAutoreleasePoolStmt(SourceLocation AtLoc,
1960 Stmt *Body) {
1961 return getSema().ActOnObjCAutoreleasePoolStmt(AtLoc, Body);
1962 }
1963
1964 /// Build a new Objective-C fast enumeration statement.
1965 ///
1966 /// By default, performs semantic analysis to build the new statement.
1967 /// Subclasses may override this routine to provide different behavior.
1968 StmtResult RebuildObjCForCollectionStmt(SourceLocation ForLoc,
1969 Stmt *Element,
1970 Expr *Collection,
1971 SourceLocation RParenLoc,
1972 Stmt *Body) {
1973 StmtResult ForEachStmt = getSema().ActOnObjCForCollectionStmt(ForLoc,
1974 Element,
1975 Collection,
1976 RParenLoc);
1977 if (ForEachStmt.isInvalid())
1978 return StmtError();
1979
1980 return getSema().FinishObjCForCollectionStmt(ForEachStmt.get(), Body);
1981 }
1982
1983 /// Build a new C++ exception declaration.
1984 ///
1985 /// By default, performs semantic analysis to build the new decaration.
1986 /// Subclasses may override this routine to provide different behavior.
1987 VarDecl *RebuildExceptionDecl(VarDecl *ExceptionDecl,
1988 TypeSourceInfo *Declarator,
1989 SourceLocation StartLoc,
1990 SourceLocation IdLoc,
1991 IdentifierInfo *Id) {
1992 VarDecl *Var = getSema().BuildExceptionDeclaration(nullptr, Declarator,
1993 StartLoc, IdLoc, Id);
1994 if (Var)
1995 getSema().CurContext->addDecl(Var);
1996 return Var;
1997 }
1998
1999 /// Build a new C++ catch statement.
2000 ///
2001 /// By default, performs semantic analysis to build the new statement.
2002 /// Subclasses may override this routine to provide different behavior.
2003 StmtResult RebuildCXXCatchStmt(SourceLocation CatchLoc,
2004 VarDecl *ExceptionDecl,
2005 Stmt *Handler) {
2006 return Owned(new (getSema().Context) CXXCatchStmt(CatchLoc, ExceptionDecl,
2007 Handler));
2008 }
2009
2010 /// Build a new C++ try statement.
2011 ///
2012 /// By default, performs semantic analysis to build the new statement.
2013 /// Subclasses may override this routine to provide different behavior.
2014 StmtResult RebuildCXXTryStmt(SourceLocation TryLoc, Stmt *TryBlock,
2015 ArrayRef<Stmt *> Handlers) {
2016 return getSema().ActOnCXXTryBlock(TryLoc, TryBlock, Handlers);
2017 }
2018
2019 /// Build a new C++0x range-based for statement.
2020 ///
2021 /// By default, performs semantic analysis to build the new statement.
2022 /// Subclasses may override this routine to provide different behavior.
2023 StmtResult RebuildCXXForRangeStmt(SourceLocation ForLoc,
2024 SourceLocation CoawaitLoc, Stmt *Init,
2025 SourceLocation ColonLoc, Stmt *Range,
2026 Stmt *Begin, Stmt *End, Expr *Cond,
2027 Expr *Inc, Stmt *LoopVar,
2028 SourceLocation RParenLoc) {
2029 // If we've just learned that the range is actually an Objective-C
2030 // collection, treat this as an Objective-C fast enumeration loop.
2031 if (DeclStmt *RangeStmt = dyn_cast<DeclStmt>(Range)) {
2032 if (RangeStmt->isSingleDecl()) {
2033 if (VarDecl *RangeVar = dyn_cast<VarDecl>(RangeStmt->getSingleDecl())) {
2034 if (RangeVar->isInvalidDecl())
2035 return StmtError();
2036
2037 Expr *RangeExpr = RangeVar->getInit();
2038 if (!RangeExpr->isTypeDependent() &&
2039 RangeExpr->getType()->isObjCObjectPointerType()) {
2040 // FIXME: Support init-statements in Objective-C++20 ranged for
2041 // statement.
2042 if (Init) {
2043 return SemaRef.Diag(Init->getBeginLoc(),
2044 diag::err_objc_for_range_init_stmt)
2045 << Init->getSourceRange();
2046 }
2047 return getSema().ActOnObjCForCollectionStmt(ForLoc, LoopVar,
2048 RangeExpr, RParenLoc);
2049 }
2050 }
2051 }
2052 }
2053
2054 return getSema().BuildCXXForRangeStmt(ForLoc, CoawaitLoc, Init, ColonLoc,
2055 Range, Begin, End, Cond, Inc, LoopVar,
2056 RParenLoc, Sema::BFRK_Rebuild);
2057 }
2058
2059 /// Build a new C++0x range-based for statement.
2060 ///
2061 /// By default, performs semantic analysis to build the new statement.
2062 /// Subclasses may override this routine to provide different behavior.
2063 StmtResult RebuildMSDependentExistsStmt(SourceLocation KeywordLoc,
2064 bool IsIfExists,
2065 NestedNameSpecifierLoc QualifierLoc,
2066 DeclarationNameInfo NameInfo,
2067 Stmt *Nested) {
2068 return getSema().BuildMSDependentExistsStmt(KeywordLoc, IsIfExists,
2069 QualifierLoc, NameInfo, Nested);
2070 }
2071
2072 /// Attach body to a C++0x range-based for statement.
2073 ///
2074 /// By default, performs semantic analysis to finish the new statement.
2075 /// Subclasses may override this routine to provide different behavior.
2076 StmtResult FinishCXXForRangeStmt(Stmt *ForRange, Stmt *Body) {
2077 return getSema().FinishCXXForRangeStmt(ForRange, Body);
2078 }
2079
2080 StmtResult RebuildSEHTryStmt(bool IsCXXTry, SourceLocation TryLoc,
2081 Stmt *TryBlock, Stmt *Handler) {
2082 return getSema().ActOnSEHTryBlock(IsCXXTry, TryLoc, TryBlock, Handler);
2083 }
2084
2085 StmtResult RebuildSEHExceptStmt(SourceLocation Loc, Expr *FilterExpr,
2086 Stmt *Block) {
2087 return getSema().ActOnSEHExceptBlock(Loc, FilterExpr, Block);
2088 }
2089
2090 StmtResult RebuildSEHFinallyStmt(SourceLocation Loc, Stmt *Block) {
2091 return SEHFinallyStmt::Create(getSema().getASTContext(), Loc, Block);
2092 }
2093
2094 /// Build a new predefined expression.
2095 ///
2096 /// By default, performs semantic analysis to build the new expression.
2097 /// Subclasses may override this routine to provide different behavior.
2098 ExprResult RebuildPredefinedExpr(SourceLocation Loc,
2099 PredefinedExpr::IdentKind IK) {
2100 return getSema().BuildPredefinedExpr(Loc, IK);
2101 }
2102
2103 /// Build a new expression that references a declaration.
2104 ///
2105 /// By default, performs semantic analysis to build the new expression.
2106 /// Subclasses may override this routine to provide different behavior.
2107 ExprResult RebuildDeclarationNameExpr(const CXXScopeSpec &SS,
2108 LookupResult &R,
2109 bool RequiresADL) {
2110 return getSema().BuildDeclarationNameExpr(SS, R, RequiresADL);
2111 }
2112
2113
2114 /// Build a new expression that references a declaration.
2115 ///
2116 /// By default, performs semantic analysis to build the new expression.
2117 /// Subclasses may override this routine to provide different behavior.
2118 ExprResult RebuildDeclRefExpr(NestedNameSpecifierLoc QualifierLoc,
2119 ValueDecl *VD,
2120 const DeclarationNameInfo &NameInfo,
2121 TemplateArgumentListInfo *TemplateArgs) {
2122 CXXScopeSpec SS;
2123 SS.Adopt(QualifierLoc);
2124
2125 // FIXME: loses template args.
2126
2127 return getSema().BuildDeclarationNameExpr(SS, NameInfo, VD);
2128 }
2129
2130 /// Build a new expression in parentheses.
2131 ///
2132 /// By default, performs semantic analysis to build the new expression.
2133 /// Subclasses may override this routine to provide different behavior.
2134 ExprResult RebuildParenExpr(Expr *SubExpr, SourceLocation LParen,
2135 SourceLocation RParen) {
2136 return getSema().ActOnParenExpr(LParen, RParen, SubExpr);
2137 }
2138
2139 /// Build a new pseudo-destructor expression.
2140 ///
2141 /// By default, performs semantic analysis to build the new expression.
2142 /// Subclasses may override this routine to provide different behavior.
2143 ExprResult RebuildCXXPseudoDestructorExpr(Expr *Base,
2144 SourceLocation OperatorLoc,
2145 bool isArrow,
2146 CXXScopeSpec &SS,
2147 TypeSourceInfo *ScopeType,
2148 SourceLocation CCLoc,
2149 SourceLocation TildeLoc,
2150 PseudoDestructorTypeStorage Destroyed);
2151
2152 /// Build a new unary operator expression.
2153 ///
2154 /// By default, performs semantic analysis to build the new expression.
2155 /// Subclasses may override this routine to provide different behavior.
2156 ExprResult RebuildUnaryOperator(SourceLocation OpLoc,
2157 UnaryOperatorKind Opc,
2158 Expr *SubExpr) {
2159 return getSema().BuildUnaryOp(/*Scope=*/nullptr, OpLoc, Opc, SubExpr);
2160 }
2161
2162 /// Build a new builtin offsetof expression.
2163 ///
2164 /// By default, performs semantic analysis to build the new expression.
2165 /// Subclasses may override this routine to provide different behavior.
2166 ExprResult RebuildOffsetOfExpr(SourceLocation OperatorLoc,
2167 TypeSourceInfo *Type,
2168 ArrayRef<Sema::OffsetOfComponent> Components,
2169 SourceLocation RParenLoc) {
2170 return getSema().BuildBuiltinOffsetOf(OperatorLoc, Type, Components,
2171 RParenLoc);
2172 }
2173
2174 /// Build a new sizeof, alignof or vec_step expression with a
2175 /// type argument.
2176 ///
2177 /// By default, performs semantic analysis to build the new expression.
2178 /// Subclasses may override this routine to provide different behavior.
2179 ExprResult RebuildUnaryExprOrTypeTrait(TypeSourceInfo *TInfo,
2180 SourceLocation OpLoc,
2181 UnaryExprOrTypeTrait ExprKind,
2182 SourceRange R) {
2183 return getSema().CreateUnaryExprOrTypeTraitExpr(TInfo, OpLoc, ExprKind, R);
2184 }
2185
2186 /// Build a new sizeof, alignof or vec step expression with an
2187 /// expression argument.
2188 ///
2189 /// By default, performs semantic analysis to build the new expression.
2190 /// Subclasses may override this routine to provide different behavior.
2191 ExprResult RebuildUnaryExprOrTypeTrait(Expr *SubExpr, SourceLocation OpLoc,
2192 UnaryExprOrTypeTrait ExprKind,
2193 SourceRange R) {
2194 ExprResult Result
2195 = getSema().CreateUnaryExprOrTypeTraitExpr(SubExpr, OpLoc, ExprKind);
2196 if (Result.isInvalid())
2197 return ExprError();
2198
2199 return Result;
2200 }
2201
2202 /// Build a new array subscript expression.
2203 ///
2204 /// By default, performs semantic analysis to build the new expression.
2205 /// Subclasses may override this routine to provide different behavior.
2206 ExprResult RebuildArraySubscriptExpr(Expr *LHS,
2207 SourceLocation LBracketLoc,
2208 Expr *RHS,
2209 SourceLocation RBracketLoc) {
2210 return getSema().ActOnArraySubscriptExpr(/*Scope=*/nullptr, LHS,
2211 LBracketLoc, RHS,
2212 RBracketLoc);
2213 }
2214
2215 /// Build a new array section expression.
2216 ///
2217 /// By default, performs semantic analysis to build the new expression.
2218 /// Subclasses may override this routine to provide different behavior.
2219 ExprResult RebuildOMPArraySectionExpr(Expr *Base, SourceLocation LBracketLoc,
2220 Expr *LowerBound,
2221 SourceLocation ColonLoc, Expr *Length,
2222 SourceLocation RBracketLoc) {
2223 return getSema().ActOnOMPArraySectionExpr(Base, LBracketLoc, LowerBound,
2224 ColonLoc, Length, RBracketLoc);
2225 }
2226
2227 /// Build a new call expression.
2228 ///
2229 /// By default, performs semantic analysis to build the new expression.
2230 /// Subclasses may override this routine to provide different behavior.
2231 ExprResult RebuildCallExpr(Expr *Callee, SourceLocation LParenLoc,
2232 MultiExprArg Args,
2233 SourceLocation RParenLoc,
2234 Expr *ExecConfig = nullptr) {
2235 return getSema().ActOnCallExpr(/*Scope=*/nullptr, Callee, LParenLoc,
2236 Args, RParenLoc, ExecConfig);
2237 }
2238
2239 /// Build a new member access expression.
2240 ///
2241 /// By default, performs semantic analysis to build the new expression.
2242 /// Subclasses may override this routine to provide different behavior.
2243 ExprResult RebuildMemberExpr(Expr *Base, SourceLocation OpLoc,
2244 bool isArrow,
2245 NestedNameSpecifierLoc QualifierLoc,
2246 SourceLocation TemplateKWLoc,
2247 const DeclarationNameInfo &MemberNameInfo,
2248 ValueDecl *Member,
2249 NamedDecl *FoundDecl,
2250 const TemplateArgumentListInfo *ExplicitTemplateArgs,
2251 NamedDecl *FirstQualifierInScope) {
2252 ExprResult BaseResult = getSema().PerformMemberExprBaseConversion(Base,
2253 isArrow);
2254 if (!Member->getDeclName()) {
2255 // We have a reference to an unnamed field. This is always the
2256 // base of an anonymous struct/union member access, i.e. the
2257 // field is always of record type.
2258 assert(Member->getType()->isRecordType() &&((Member->getType()->isRecordType() && "unnamed member not of record type?"
) ? static_cast<void> (0) : __assert_fail ("Member->getType()->isRecordType() && \"unnamed member not of record type?\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Sema/TreeTransform.h"
, 2259, __PRETTY_FUNCTION__))
2259 "unnamed member not of record type?")((Member->getType()->isRecordType() && "unnamed member not of record type?"
) ? static_cast<void> (0) : __assert_fail ("Member->getType()->isRecordType() && \"unnamed member not of record type?\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Sema/TreeTransform.h"
, 2259, __PRETTY_FUNCTION__))
;
2260
2261 BaseResult =
2262 getSema().PerformObjectMemberConversion(BaseResult.get(),
2263 QualifierLoc.getNestedNameSpecifier(),
2264 FoundDecl, Member);
2265 if (BaseResult.isInvalid())
2266 return ExprError();
2267 Base = BaseResult.get();
2268
2269 CXXScopeSpec EmptySS;
2270 return getSema().BuildFieldReferenceExpr(
2271 Base, isArrow, OpLoc, EmptySS, cast<FieldDecl>(Member),
2272 DeclAccessPair::make(FoundDecl, FoundDecl->getAccess()), MemberNameInfo);
2273 }
2274
2275 CXXScopeSpec SS;
2276 SS.Adopt(QualifierLoc);
2277
2278 Base = BaseResult.get();
2279 QualType BaseType = Base->getType();
2280
2281 if (isArrow && !BaseType->isPointerType())
2282 return ExprError();
2283
2284 // FIXME: this involves duplicating earlier analysis in a lot of
2285 // cases; we should avoid this when possible.
2286 LookupResult R(getSema(), MemberNameInfo, Sema::LookupMemberName);
2287 R.addDecl(FoundDecl);
2288 R.resolveKind();
2289
2290 return getSema().BuildMemberReferenceExpr(Base, BaseType, OpLoc, isArrow,
2291 SS, TemplateKWLoc,
2292 FirstQualifierInScope,
2293 R, ExplicitTemplateArgs,
2294 /*S*/nullptr);
2295 }
2296
2297 /// Build a new binary operator expression.
2298 ///
2299 /// By default, performs semantic analysis to build the new expression.
2300 /// Subclasses may override this routine to provide different behavior.
2301 ExprResult RebuildBinaryOperator(SourceLocation OpLoc,
2302 BinaryOperatorKind Opc,
2303 Expr *LHS, Expr *RHS) {
2304 return getSema().BuildBinOp(/*Scope=*/nullptr, OpLoc, Opc, LHS, RHS);
2305 }
2306
2307 /// Build a new conditional operator expression.
2308 ///
2309 /// By default, performs semantic analysis to build the new expression.
2310 /// Subclasses may override this routine to provide different behavior.
2311 ExprResult RebuildConditionalOperator(Expr *Cond,
2312 SourceLocation QuestionLoc,
2313 Expr *LHS,
2314 SourceLocation ColonLoc,
2315 Expr *RHS) {
2316 return getSema().ActOnConditionalOp(QuestionLoc, ColonLoc, Cond,
2317 LHS, RHS);
2318 }
2319
2320 /// Build a new C-style cast expression.
2321 ///
2322 /// By default, performs semantic analysis to build the new expression.
2323 /// Subclasses may override this routine to provide different behavior.
2324 ExprResult RebuildCStyleCastExpr(SourceLocation LParenLoc,
2325 TypeSourceInfo *TInfo,
2326 SourceLocation RParenLoc,
2327 Expr *SubExpr) {
2328 return getSema().BuildCStyleCastExpr(LParenLoc, TInfo, RParenLoc,
2329 SubExpr);
2330 }
2331
2332 /// Build a new compound literal expression.
2333 ///
2334 /// By default, performs semantic analysis to build the new expression.
2335 /// Subclasses may override this routine to provide different behavior.
2336 ExprResult RebuildCompoundLiteralExpr(SourceLocation LParenLoc,
2337 TypeSourceInfo *TInfo,
2338 SourceLocation RParenLoc,
2339 Expr *Init) {
2340 return getSema().BuildCompoundLiteralExpr(LParenLoc, TInfo, RParenLoc,
2341 Init);
2342 }
2343
2344 /// Build a new extended vector element access expression.
2345 ///
2346 /// By default, performs semantic analysis to build the new expression.
2347 /// Subclasses may override this routine to provide different behavior.
2348 ExprResult RebuildExtVectorElementExpr(Expr *Base,
2349 SourceLocation OpLoc,
2350 SourceLocation AccessorLoc,
2351 IdentifierInfo &Accessor) {
2352
2353 CXXScopeSpec SS;
2354 DeclarationNameInfo NameInfo(&Accessor, AccessorLoc);
2355 return getSema().BuildMemberReferenceExpr(Base, Base->getType(),
2356 OpLoc, /*IsArrow*/ false,
2357 SS, SourceLocation(),
2358 /*FirstQualifierInScope*/ nullptr,
2359 NameInfo,
2360 /* TemplateArgs */ nullptr,
2361 /*S*/ nullptr);
2362 }
2363
2364 /// Build a new initializer list expression.
2365 ///
2366 /// By default, performs semantic analysis to build the new expression.
2367 /// Subclasses may override this routine to provide different behavior.
2368 ExprResult RebuildInitList(SourceLocation LBraceLoc,
2369 MultiExprArg Inits,
2370 SourceLocation RBraceLoc) {
2371 return SemaRef.ActOnInitList(LBraceLoc, Inits, RBraceLoc);
2372 }
2373
2374 /// Build a new designated initializer expression.
2375 ///
2376 /// By default, performs semantic analysis to build the new expression.
2377 /// Subclasses may override this routine to provide different behavior.
2378 ExprResult RebuildDesignatedInitExpr(Designation &Desig,
2379 MultiExprArg ArrayExprs,
2380 SourceLocation EqualOrColonLoc,
2381 bool GNUSyntax,
2382 Expr *Init) {
2383 ExprResult Result
2384 = SemaRef.ActOnDesignatedInitializer(Desig, EqualOrColonLoc, GNUSyntax,
2385 Init);
2386 if (Result.isInvalid())
2387 return ExprError();
2388
2389 return Result;
2390 }
2391
2392 /// Build a new value-initialized expression.
2393 ///
2394 /// By default, builds the implicit value initialization without performing
2395 /// any semantic analysis. Subclasses may override this routine to provide
2396 /// different behavior.
2397 ExprResult RebuildImplicitValueInitExpr(QualType T) {
2398 return new (SemaRef.Context) ImplicitValueInitExpr(T);
2399 }
2400
2401 /// Build a new \c va_arg expression.
2402 ///
2403 /// By default, performs semantic analysis to build the new expression.
2404 /// Subclasses may override this routine to provide different behavior.
2405 ExprResult RebuildVAArgExpr(SourceLocation BuiltinLoc,
2406 Expr *SubExpr, TypeSourceInfo *TInfo,
2407 SourceLocation RParenLoc) {
2408 return getSema().BuildVAArgExpr(BuiltinLoc,
2409 SubExpr, TInfo,
2410 RParenLoc);
2411 }
2412
2413 /// Build a new expression list in parentheses.
2414 ///
2415 /// By default, performs semantic analysis to build the new expression.
2416 /// Subclasses may override this routine to provide different behavior.
2417 ExprResult RebuildParenListExpr(SourceLocation LParenLoc,
2418 MultiExprArg SubExprs,
2419 SourceLocation RParenLoc) {
2420 return getSema().ActOnParenListExpr(LParenLoc, RParenLoc, SubExprs);
2421 }
2422
2423 /// Build a new address-of-label expression.
2424 ///
2425 /// By default, performs semantic analysis, using the name of the label
2426 /// rather than attempting to map the label statement itself.
2427 /// Subclasses may override this routine to provide different behavior.
2428 ExprResult RebuildAddrLabelExpr(SourceLocation AmpAmpLoc,
2429 SourceLocation LabelLoc, LabelDecl *Label) {
2430 return getSema().ActOnAddrLabel(AmpAmpLoc, LabelLoc, Label);
2431 }
2432
2433 /// Build a new GNU statement expression.
2434 ///
2435 /// By default, performs semantic analysis to build the new expression.
2436 /// Subclasses may override this routine to provide different behavior.
2437 ExprResult RebuildStmtExpr(SourceLocation LParenLoc,
2438 Stmt *SubStmt,
2439 SourceLocation RParenLoc) {
2440 return getSema().ActOnStmtExpr(LParenLoc, SubStmt, RParenLoc);
2441 }
2442
2443 /// Build a new __builtin_choose_expr expression.
2444 ///
2445 /// By default, performs semantic analysis to build the new expression.
2446 /// Subclasses may override this routine to provide different behavior.
2447 ExprResult RebuildChooseExpr(SourceLocation BuiltinLoc,
2448 Expr *Cond, Expr *LHS, Expr *RHS,
2449 SourceLocation RParenLoc) {
2450 return SemaRef.ActOnChooseExpr(BuiltinLoc,
2451 Cond, LHS, RHS,
2452 RParenLoc);
2453 }
2454
2455 /// Build a new generic selection expression.
2456 ///
2457 /// By default, performs semantic analysis to build the new expression.
2458 /// Subclasses may override this routine to provide different behavior.
2459 ExprResult RebuildGenericSelectionExpr(SourceLocation KeyLoc,
2460 SourceLocation DefaultLoc,
2461 SourceLocation RParenLoc,
2462 Expr *ControllingExpr,
2463 ArrayRef<TypeSourceInfo *> Types,
2464 ArrayRef<Expr *> Exprs) {
2465 return getSema().CreateGenericSelectionExpr(KeyLoc, DefaultLoc, RParenLoc,
2466 ControllingExpr, Types, Exprs);
2467 }
2468
2469 /// Build a new overloaded operator call expression.
2470 ///
2471 /// By default, performs semantic analysis to build the new expression.
2472 /// The semantic analysis provides the behavior of template instantiation,
2473 /// copying with transformations that turn what looks like an overloaded
2474 /// operator call into a use of a builtin operator, performing
2475 /// argument-dependent lookup, etc. Subclasses may override this routine to
2476 /// provide different behavior.
2477 ExprResult RebuildCXXOperatorCallExpr(OverloadedOperatorKind Op,
2478 SourceLocation OpLoc,
2479 Expr *Callee,
2480 Expr *First,
2481 Expr *Second);
2482
2483 /// Build a new C++ "named" cast expression, such as static_cast or
2484 /// reinterpret_cast.
2485 ///
2486 /// By default, this routine dispatches to one of the more-specific routines
2487 /// for a particular named case, e.g., RebuildCXXStaticCastExpr().
2488 /// Subclasses may override this routine to provide different behavior.
2489 ExprResult RebuildCXXNamedCastExpr(SourceLocation OpLoc,
2490 Stmt::StmtClass Class,
2491 SourceLocation LAngleLoc,
2492 TypeSourceInfo *TInfo,
2493 SourceLocation RAngleLoc,
2494 SourceLocation LParenLoc,
2495 Expr *SubExpr,
2496 SourceLocation RParenLoc) {
2497 switch (Class) {
2498 case Stmt::CXXStaticCastExprClass:
2499 return getDerived().RebuildCXXStaticCastExpr(OpLoc, LAngleLoc, TInfo,
2500 RAngleLoc, LParenLoc,
2501 SubExpr, RParenLoc);
2502
2503 case Stmt::CXXDynamicCastExprClass:
2504 return getDerived().RebuildCXXDynamicCastExpr(OpLoc, LAngleLoc, TInfo,
2505 RAngleLoc, LParenLoc,
2506 SubExpr, RParenLoc);
2507
2508 case Stmt::CXXReinterpretCastExprClass:
2509 return getDerived().RebuildCXXReinterpretCastExpr(OpLoc, LAngleLoc, TInfo,
2510 RAngleLoc, LParenLoc,
2511 SubExpr,
2512 RParenLoc);
2513
2514 case Stmt::CXXConstCastExprClass:
2515 return getDerived().RebuildCXXConstCastExpr(OpLoc, LAngleLoc, TInfo,
2516 RAngleLoc, LParenLoc,
2517 SubExpr, RParenLoc);
2518
2519 default:
2520 llvm_unreachable("Invalid C++ named cast")::llvm::llvm_unreachable_internal("Invalid C++ named cast", "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Sema/TreeTransform.h"
, 2520)
;
2521 }
2522 }
2523
2524 /// Build a new C++ static_cast expression.
2525 ///
2526 /// By default, performs semantic analysis to build the new expression.
2527 /// Subclasses may override this routine to provide different behavior.
2528 ExprResult RebuildCXXStaticCastExpr(SourceLocation OpLoc,
2529 SourceLocation LAngleLoc,
2530 TypeSourceInfo *TInfo,
2531 SourceLocation RAngleLoc,
2532 SourceLocation LParenLoc,
2533 Expr *SubExpr,
2534 SourceLocation RParenLoc) {
2535 return getSema().BuildCXXNamedCast(OpLoc, tok::kw_static_cast,
2536 TInfo, SubExpr,
2537 SourceRange(LAngleLoc, RAngleLoc),
2538 SourceRange(LParenLoc, RParenLoc));
2539 }
2540
2541 /// Build a new C++ dynamic_cast expression.
2542 ///
2543 /// By default, performs semantic analysis to build the new expression.
2544 /// Subclasses may override this routine to provide different behavior.
2545 ExprResult RebuildCXXDynamicCastExpr(SourceLocation OpLoc,
2546 SourceLocation LAngleLoc,
2547 TypeSourceInfo *TInfo,
2548 SourceLocation RAngleLoc,
2549 SourceLocation LParenLoc,
2550 Expr *SubExpr,
2551 SourceLocation RParenLoc) {
2552 return getSema().BuildCXXNamedCast(OpLoc, tok::kw_dynamic_cast,
2553 TInfo, SubExpr,
2554 SourceRange(LAngleLoc, RAngleLoc),
2555 SourceRange(LParenLoc, RParenLoc));
2556 }
2557
2558 /// Build a new C++ reinterpret_cast expression.
2559 ///
2560 /// By default, performs semantic analysis to build the new expression.
2561 /// Subclasses may override this routine to provide different behavior.
2562 ExprResult RebuildCXXReinterpretCastExpr(SourceLocation OpLoc,
2563 SourceLocation LAngleLoc,
2564 TypeSourceInfo *TInfo,
2565 SourceLocation RAngleLoc,
2566 SourceLocation LParenLoc,
2567 Expr *SubExpr,
2568 SourceLocation RParenLoc) {
2569 return getSema().BuildCXXNamedCast(OpLoc, tok::kw_reinterpret_cast,
2570 TInfo, SubExpr,
2571 SourceRange(LAngleLoc, RAngleLoc),
2572 SourceRange(LParenLoc, RParenLoc));
2573 }
2574
2575 /// Build a new C++ const_cast expression.
2576 ///
2577 /// By default, performs semantic analysis to build the new expression.
2578 /// Subclasses may override this routine to provide different behavior.
2579 ExprResult RebuildCXXConstCastExpr(SourceLocation OpLoc,
2580 SourceLocation LAngleLoc,
2581 TypeSourceInfo *TInfo,
2582 SourceLocation RAngleLoc,
2583 SourceLocation LParenLoc,
2584 Expr *SubExpr,
2585 SourceLocation RParenLoc) {
2586 return getSema().BuildCXXNamedCast(OpLoc, tok::kw_const_cast,
2587 TInfo, SubExpr,
2588 SourceRange(LAngleLoc, RAngleLoc),
2589 SourceRange(LParenLoc, RParenLoc));
2590 }
2591
2592 /// Build a new C++ functional-style cast expression.
2593 ///
2594 /// By default, performs semantic analysis to build the new expression.
2595 /// Subclasses may override this routine to provide different behavior.
2596 ExprResult RebuildCXXFunctionalCastExpr(TypeSourceInfo *TInfo,
2597 SourceLocation LParenLoc,
2598 Expr *Sub,
2599 SourceLocation RParenLoc,
2600 bool ListInitialization) {
2601 return getSema().BuildCXXTypeConstructExpr(TInfo, LParenLoc,
2602 MultiExprArg(&Sub, 1), RParenLoc,
2603 ListInitialization);
2604 }
2605
2606 /// Build a new C++ typeid(type) expression.
2607 ///
2608 /// By default, performs semantic analysis to build the new expression.
2609 /// Subclasses may override this routine to provide different behavior.
2610 ExprResult RebuildCXXTypeidExpr(QualType TypeInfoType,
2611 SourceLocation TypeidLoc,
2612 TypeSourceInfo *Operand,
2613 SourceLocation RParenLoc) {
2614 return getSema().BuildCXXTypeId(TypeInfoType, TypeidLoc, Operand,
2615 RParenLoc);
2616 }
2617
2618
2619 /// Build a new C++ typeid(expr) expression.
2620 ///
2621 /// By default, performs semantic analysis to build the new expression.
2622 /// Subclasses may override this routine to provide different behavior.
2623 ExprResult RebuildCXXTypeidExpr(QualType TypeInfoType,
2624 SourceLocation TypeidLoc,
2625 Expr *Operand,
2626 SourceLocation RParenLoc) {
2627 return getSema().BuildCXXTypeId(TypeInfoType, TypeidLoc, Operand,
2628 RParenLoc);
2629 }
2630
2631 /// Build a new C++ __uuidof(type) expression.
2632 ///
2633 /// By default, performs semantic analysis to build the new expression.
2634 /// Subclasses may override this routine to provide different behavior.
2635 ExprResult RebuildCXXUuidofExpr(QualType TypeInfoType,
2636 SourceLocation TypeidLoc,
2637 TypeSourceInfo *Operand,
2638 SourceLocation RParenLoc) {
2639 return getSema().BuildCXXUuidof(TypeInfoType, TypeidLoc, Operand,
2640 RParenLoc);
2641 }
2642
2643 /// Build a new C++ __uuidof(expr) expression.
2644 ///
2645 /// By default, performs semantic analysis to build the new expression.
2646 /// Subclasses may override this routine to provide different behavior.
2647 ExprResult RebuildCXXUuidofExpr(QualType TypeInfoType,
2648 SourceLocation TypeidLoc,
2649 Expr *Operand,
2650 SourceLocation RParenLoc) {
2651 return getSema().BuildCXXUuidof(TypeInfoType, TypeidLoc, Operand,
2652 RParenLoc);
2653 }
2654
2655 /// Build a new C++ "this" expression.
2656 ///
2657 /// By default, builds a new "this" expression without performing any
2658 /// semantic analysis. Subclasses may override this routine to provide
2659 /// different behavior.
2660 ExprResult RebuildCXXThisExpr(SourceLocation ThisLoc,
2661 QualType ThisType,
2662 bool isImplicit) {
2663 getSema().CheckCXXThisCapture(ThisLoc);
2664 return new (getSema().Context) CXXThisExpr(ThisLoc, ThisType, isImplicit);
2665 }
2666
2667 /// Build a new C++ throw expression.
2668 ///
2669 /// By default, performs semantic analysis to build the new expression.
2670 /// Subclasses may override this routine to provide different behavior.
2671 ExprResult RebuildCXXThrowExpr(SourceLocation ThrowLoc, Expr *Sub,
2672 bool IsThrownVariableInScope) {
2673 return getSema().BuildCXXThrow(ThrowLoc, Sub, IsThrownVariableInScope);
2674 }
2675
2676 /// Build a new C++ default-argument expression.
2677 ///
2678 /// By default, builds a new default-argument expression, which does not
2679 /// require any semantic analysis. Subclasses may override this routine to
2680 /// provide different behavior.
2681 ExprResult RebuildCXXDefaultArgExpr(SourceLocation Loc,
2682 ParmVarDecl *Param) {
2683 return CXXDefaultArgExpr::Create(getSema().Context, Loc, Param);
2684 }
2685
2686 /// Build a new C++11 default-initialization expression.
2687 ///
2688 /// By default, builds a new default field initialization expression, which
2689 /// does not require any semantic analysis. Subclasses may override this
2690 /// routine to provide different behavior.
2691 ExprResult RebuildCXXDefaultInitExpr(SourceLocation Loc,
2692 FieldDecl *Field) {
2693 return CXXDefaultInitExpr::Create(getSema().Context, Loc, Field);
2694 }
2695
2696 /// Build a new C++ zero-initialization expression.
2697 ///
2698 /// By default, performs semantic analysis to build the new expression.
2699 /// Subclasses may override this routine to provide different behavior.
2700 ExprResult RebuildCXXScalarValueInitExpr(TypeSourceInfo *TSInfo,
2701 SourceLocation LParenLoc,
2702 SourceLocation RParenLoc) {
2703 return getSema().BuildCXXTypeConstructExpr(
2704 TSInfo, LParenLoc, None, RParenLoc, /*ListInitialization=*/false);
2705 }
2706
2707 /// Build a new C++ "new" expression.
2708 ///
2709 /// By default, performs semantic analysis to build the new expression.
2710 /// Subclasses may override this routine to provide different behavior.
2711 ExprResult RebuildCXXNewExpr(SourceLocation StartLoc,
2712 bool UseGlobal,
2713 SourceLocation PlacementLParen,
2714 MultiExprArg PlacementArgs,
2715 SourceLocation PlacementRParen,
2716 SourceRange TypeIdParens,
2717 QualType AllocatedType,
2718 TypeSourceInfo *AllocatedTypeInfo,
2719 Expr *ArraySize,
2720 SourceRange DirectInitRange,
2721 Expr *Initializer) {
2722 return getSema().BuildCXXNew(StartLoc, UseGlobal,
2723 PlacementLParen,
2724 PlacementArgs,
2725 PlacementRParen,
2726 TypeIdParens,
2727 AllocatedType,
2728 AllocatedTypeInfo,
2729 ArraySize,
2730 DirectInitRange,
2731 Initializer);
2732 }
2733
2734 /// Build a new C++ "delete" expression.
2735 ///
2736 /// By default, performs semantic analysis to build the new expression.
2737 /// Subclasses may override this routine to provide different behavior.
2738 ExprResult RebuildCXXDeleteExpr(SourceLocation StartLoc,
2739 bool IsGlobalDelete,
2740 bool IsArrayForm,
2741 Expr *Operand) {
2742 return getSema().ActOnCXXDelete(StartLoc, IsGlobalDelete, IsArrayForm,
2743 Operand);
2744 }
2745
2746 /// Build a new type trait expression.
2747 ///
2748 /// By default, performs semantic analysis to build the new expression.
2749 /// Subclasses may override this routine to provide different behavior.
2750 ExprResult RebuildTypeTrait(TypeTrait Trait,
2751 SourceLocation StartLoc,
2752 ArrayRef<TypeSourceInfo *> Args,
2753 SourceLocation RParenLoc) {
2754 return getSema().BuildTypeTrait(Trait, StartLoc, Args, RParenLoc);
2755 }
2756
2757 /// Build a new array type trait expression.
2758 ///
2759 /// By default, performs semantic analysis to build the new expression.
2760 /// Subclasses may override this routine to provide different behavior.
2761 ExprResult RebuildArrayTypeTrait(ArrayTypeTrait Trait,
2762 SourceLocation StartLoc,
2763 TypeSourceInfo *TSInfo,
2764 Expr *DimExpr,
2765 SourceLocation RParenLoc) {
2766 return getSema().BuildArrayTypeTrait(Trait, StartLoc, TSInfo, DimExpr, RParenLoc);
2767 }
2768
2769 /// Build a new expression trait expression.
2770 ///
2771 /// By default, performs semantic analysis to build the new expression.
2772 /// Subclasses may override this routine to provide different behavior.
2773 ExprResult RebuildExpressionTrait(ExpressionTrait Trait,
2774 SourceLocation StartLoc,
2775 Expr *Queried,
2776 SourceLocation RParenLoc) {
2777 return getSema().BuildExpressionTrait(Trait, StartLoc, Queried, RParenLoc);
2778 }
2779
2780 /// Build a new (previously unresolved) declaration reference
2781 /// expression.
2782 ///
2783 /// By default, performs semantic analysis to build the new expression.
2784 /// Subclasses may override this routine to provide different behavior.
2785 ExprResult RebuildDependentScopeDeclRefExpr(
2786 NestedNameSpecifierLoc QualifierLoc,
2787 SourceLocation TemplateKWLoc,
2788 const DeclarationNameInfo &NameInfo,
2789 const TemplateArgumentListInfo *TemplateArgs,
2790 bool IsAddressOfOperand,
2791 TypeSourceInfo **RecoveryTSI) {
2792 CXXScopeSpec SS;
2793 SS.Adopt(QualifierLoc);
2794
2795 if (TemplateArgs || TemplateKWLoc.isValid())
2796 return getSema().BuildQualifiedTemplateIdExpr(SS, TemplateKWLoc, NameInfo,
2797 TemplateArgs);
2798
2799 return getSema().BuildQualifiedDeclarationNameExpr(
2800 SS, NameInfo, IsAddressOfOperand, /*S*/nullptr, RecoveryTSI);
2801 }
2802
2803 /// Build a new template-id expression.
2804 ///
2805 /// By default, performs semantic analysis to build the new expression.
2806 /// Subclasses may override this routine to provide different behavior.
2807 ExprResult RebuildTemplateIdExpr(const CXXScopeSpec &SS,
2808 SourceLocation TemplateKWLoc,
2809 LookupResult &R,
2810 bool RequiresADL,
2811 const TemplateArgumentListInfo *TemplateArgs) {
2812 return getSema().BuildTemplateIdExpr(SS, TemplateKWLoc, R, RequiresADL,
2813 TemplateArgs);
2814 }
2815
2816 /// Build a new object-construction expression.
2817 ///
2818 /// By default, performs semantic analysis to build the new expression.
2819 /// Subclasses may override this routine to provide different behavior.
2820 ExprResult RebuildCXXConstructExpr(QualType T,
2821 SourceLocation Loc,
2822 CXXConstructorDecl *Constructor,
2823 bool IsElidable,
2824 MultiExprArg Args,
2825 bool HadMultipleCandidates,
2826 bool ListInitialization,
2827 bool StdInitListInitialization,
2828 bool RequiresZeroInit,
2829 CXXConstructExpr::ConstructionKind ConstructKind,
2830 SourceRange ParenRange) {
2831 SmallVector<Expr*, 8> ConvertedArgs;
2832 if (getSema().CompleteConstructorCall(Constructor, Args, Loc,
2833 ConvertedArgs))
2834 return ExprError();
2835
2836 return getSema().BuildCXXConstructExpr(Loc, T, Constructor,
2837 IsElidable,
2838 ConvertedArgs,
2839 HadMultipleCandidates,
2840 ListInitialization,
2841 StdInitListInitialization,
2842 RequiresZeroInit, ConstructKind,
2843 ParenRange);
2844 }
2845
2846 /// Build a new implicit construction via inherited constructor
2847 /// expression.
2848 ExprResult RebuildCXXInheritedCtorInitExpr(QualType T, SourceLocation Loc,
2849 CXXConstructorDecl *Constructor,
2850 bool ConstructsVBase,
2851 bool InheritedFromVBase) {
2852 return new (getSema().Context) CXXInheritedCtorInitExpr(
2853 Loc, T, Constructor, ConstructsVBase, InheritedFromVBase);
2854 }
2855
2856 /// Build a new object-construction expression.
2857 ///
2858 /// By default, performs semantic analysis to build the new expression.
2859 /// Subclasses may override this routine to provide different behavior.
2860 ExprResult RebuildCXXTemporaryObjectExpr(TypeSourceInfo *TSInfo,
2861 SourceLocation LParenOrBraceLoc,
2862 MultiExprArg Args,
2863 SourceLocation RParenOrBraceLoc,
2864 bool ListInitialization) {
2865 return getSema().BuildCXXTypeConstructExpr(
2866 TSInfo, LParenOrBraceLoc, Args, RParenOrBraceLoc, ListInitialization);
2867 }
2868
2869 /// Build a new object-construction expression.
2870 ///
2871 /// By default, performs semantic analysis to build the new expression.
2872 /// Subclasses may override this routine to provide different behavior.
2873 ExprResult RebuildCXXUnresolvedConstructExpr(TypeSourceInfo *TSInfo,
2874 SourceLocation LParenLoc,
2875 MultiExprArg Args,
2876 SourceLocation RParenLoc,
2877 bool ListInitialization) {
2878 return getSema().BuildCXXTypeConstructExpr(TSInfo, LParenLoc, Args,
2879 RParenLoc, ListInitialization);
2880 }
2881
2882 /// Build a new member reference expression.
2883 ///
2884 /// By default, performs semantic analysis to build the new expression.
2885 /// Subclasses may override this routine to provide different behavior.
2886 ExprResult RebuildCXXDependentScopeMemberExpr(Expr *BaseE,
2887 QualType BaseType,
2888 bool IsArrow,
2889 SourceLocation OperatorLoc,
2890 NestedNameSpecifierLoc QualifierLoc,
2891 SourceLocation TemplateKWLoc,
2892 NamedDecl *FirstQualifierInScope,
2893 const DeclarationNameInfo &MemberNameInfo,
2894 const TemplateArgumentListInfo *TemplateArgs) {
2895 CXXScopeSpec SS;
2896 SS.Adopt(QualifierLoc);
2897
2898 return SemaRef.BuildMemberReferenceExpr(BaseE, BaseType,
2899 OperatorLoc, IsArrow,
2900 SS, TemplateKWLoc,
2901 FirstQualifierInScope,
2902 MemberNameInfo,