1//===------- TreeTransform.h - Semantic Tree Transformation -----*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//===----------------------------------------------------------------------===//
7//
8// This file implements a semantic tree transformation that takes a given
9// AST and rebuilds it, possibly transforming some nodes in the process.
10//
11//===----------------------------------------------------------------------===//
12
13#ifndef LLVM_CLANG_LIB_SEMA_TREETRANSFORM_H
14#define LLVM_CLANG_LIB_SEMA_TREETRANSFORM_H
15
16#include "CoroutineStmtBuilder.h"
17#include "TypeLocBuilder.h"
18#include "clang/AST/Decl.h"
19#include "clang/AST/DeclObjC.h"
20#include "clang/AST/DeclTemplate.h"
21#include "clang/AST/Expr.h"
22#include "clang/AST/ExprCXX.h"
23#include "clang/AST/ExprConcepts.h"
24#include "clang/AST/ExprObjC.h"
25#include "clang/AST/ExprOpenMP.h"
26#include "clang/AST/OpenMPClause.h"
27#include "clang/AST/Stmt.h"
28#include "clang/AST/StmtCXX.h"
29#include "clang/AST/StmtObjC.h"
30#include "clang/AST/StmtOpenACC.h"
31#include "clang/AST/StmtOpenMP.h"
32#include "clang/AST/StmtSYCL.h"
33#include "clang/Basic/DiagnosticParse.h"
34#include "clang/Basic/OpenMPKinds.h"
35#include "clang/Sema/Designator.h"
36#include "clang/Sema/EnterExpressionEvaluationContext.h"
37#include "clang/Sema/Lookup.h"
38#include "clang/Sema/Ownership.h"
39#include "clang/Sema/ParsedTemplate.h"
40#include "clang/Sema/ScopeInfo.h"
41#include "clang/Sema/SemaDiagnostic.h"
42#include "clang/Sema/SemaHLSL.h"
43#include "clang/Sema/SemaInternal.h"
44#include "clang/Sema/SemaObjC.h"
45#include "clang/Sema/SemaOpenACC.h"
46#include "clang/Sema/SemaOpenMP.h"
47#include "clang/Sema/SemaPseudoObject.h"
48#include "clang/Sema/SemaSYCL.h"
49#include "clang/Sema/Template.h"
50#include "llvm/ADT/ArrayRef.h"
51#include "llvm/Support/ErrorHandling.h"
52#include <algorithm>
53#include <optional>
54
55using namespace llvm::omp;
56
57namespace clang {
58using namespace sema;
59
60// This helper class is used to facilitate pack expansion during tree transform.
61struct UnexpandedInfo {
62 SourceLocation Ellipsis;
63 UnsignedOrNone OrigNumExpansions = std::nullopt;
64
65 bool Expand = false;
66 bool RetainExpansion = false;
67 UnsignedOrNone NumExpansions = std::nullopt;
68 bool ExpandUnderForgetSubstitions = false;
69};
70
71/// A semantic tree transformation that allows one to transform one
72/// abstract syntax tree into another.
73///
74/// A new tree transformation is defined by creating a new subclass \c X of
75/// \c TreeTransform<X> and then overriding certain operations to provide
76/// behavior specific to that transformation. For example, template
77/// instantiation is implemented as a tree transformation where the
78/// transformation of TemplateTypeParmType nodes involves substituting the
79/// template arguments for their corresponding template parameters; a similar
80/// transformation is performed for non-type template parameters and
81/// template template parameters.
82///
83/// This tree-transformation template uses static polymorphism to allow
84/// subclasses to customize any of its operations. Thus, a subclass can
85/// override any of the transformation or rebuild operators by providing an
86/// operation with the same signature as the default implementation. The
87/// overriding function should not be virtual.
88///
89/// Semantic tree transformations are split into two stages, either of which
90/// can be replaced by a subclass. The "transform" step transforms an AST node
91/// or the parts of an AST node using the various transformation functions,
92/// then passes the pieces on to the "rebuild" step, which constructs a new AST
93/// node of the appropriate kind from the pieces. The default transformation
94/// routines recursively transform the operands to composite AST nodes (e.g.,
95/// the pointee type of a PointerType node) and, if any of those operand nodes
96/// were changed by the transformation, invokes the rebuild operation to create
97/// a new AST node.
98///
99/// Subclasses can customize the transformation at various levels. The
100/// most coarse-grained transformations involve replacing TransformType(),
101/// TransformExpr(), TransformDecl(), TransformNestedNameSpecifierLoc(),
102/// TransformTemplateName(), or TransformTemplateArgument() with entirely
103/// new implementations.
104///
105/// For more fine-grained transformations, subclasses can replace any of the
106/// \c TransformXXX functions (where XXX is the name of an AST node, e.g.,
107/// PointerType, StmtExpr) to alter the transformation. As mentioned previously,
108/// replacing TransformTemplateTypeParmType() allows template instantiation
109/// to substitute template arguments for their corresponding template
110/// parameters. Additionally, subclasses can override the \c RebuildXXX
111/// functions to control how AST nodes are rebuilt when their operands change.
112/// By default, \c TreeTransform will invoke semantic analysis to rebuild
113/// AST nodes. However, certain other tree transformations (e.g, cloning) may
114/// be able to use more efficient rebuild steps.
115///
116/// There are a handful of other functions that can be overridden, allowing one
117/// to avoid traversing nodes that don't need any transformation
118/// (\c AlreadyTransformed()), force rebuilding AST nodes even when their
119/// operands have not changed (\c AlwaysRebuild()), and customize the
120/// default locations and entity names used for type-checking
121/// (\c getBaseLocation(), \c getBaseEntity()).
122template<typename Derived>
123class TreeTransform {
124 /// Private RAII object that helps us forget and then re-remember
125 /// the template argument corresponding to a partially-substituted parameter
126 /// pack.
127 class ForgetPartiallySubstitutedPackRAII {
128 Derived &Self;
129 TemplateArgument Old;
130 // Set the pack expansion index to -1 to avoid pack substitution and
131 // indicate that parameter packs should be instantiated as themselves.
132 Sema::ArgPackSubstIndexRAII ResetPackSubstIndex;
133
134 public:
135 ForgetPartiallySubstitutedPackRAII(Derived &Self)
136 : Self(Self), ResetPackSubstIndex(Self.getSema(), std::nullopt) {
137 Old = Self.ForgetPartiallySubstitutedPack();
138 }
139
140 ~ForgetPartiallySubstitutedPackRAII() {
141 Self.RememberPartiallySubstitutedPack(Old);
142 }
143 ForgetPartiallySubstitutedPackRAII(
144 const ForgetPartiallySubstitutedPackRAII &) = delete;
145 ForgetPartiallySubstitutedPackRAII &
146 operator=(const ForgetPartiallySubstitutedPackRAII &) = delete;
147 };
148
149protected:
150 Sema &SemaRef;
151
152 /// The set of local declarations that have been transformed, for
153 /// cases where we are forced to build new declarations within the transformer
154 /// rather than in the subclass (e.g., lambda closure types).
155 llvm::DenseMap<Decl *, Decl *> TransformedLocalDecls;
156
157public:
158 /// Initializes a new tree transformer.
159 TreeTransform(Sema &SemaRef) : SemaRef(SemaRef) { }
160
161 /// Retrieves a reference to the derived class.
162 Derived &getDerived() { return static_cast<Derived&>(*this); }
163
164 /// Retrieves a reference to the derived class.
165 const Derived &getDerived() const {
166 return static_cast<const Derived&>(*this);
167 }
168
169 static inline ExprResult Owned(Expr *E) { return E; }
170 static inline StmtResult Owned(Stmt *S) { return S; }
171
172 /// Retrieves a reference to the semantic analysis object used for
173 /// this tree transform.
174 Sema &getSema() const { return SemaRef; }
175
176 /// Whether the transformation should always rebuild AST nodes, even
177 /// if none of the children have changed.
178 ///
179 /// Subclasses may override this function to specify when the transformation
180 /// should rebuild all AST nodes.
181 ///
182 /// We must always rebuild all AST nodes when performing variadic template
183 /// pack expansion, in order to avoid violating the AST invariant that each
184 /// statement node appears at most once in its containing declaration.
185 bool AlwaysRebuild() { return static_cast<bool>(SemaRef.ArgPackSubstIndex); }
186
187 /// Whether the transformation is forming an expression or statement that
188 /// replaces the original. In this case, we'll reuse mangling numbers from
189 /// existing lambdas.
190 bool ReplacingOriginal() { return false; }
191
192 /// Wether CXXConstructExpr can be skipped when they are implicit.
193 /// They will be reconstructed when used if needed.
194 /// This is useful when the user that cause rebuilding of the
195 /// CXXConstructExpr is outside of the expression at which the TreeTransform
196 /// started.
197 bool AllowSkippingCXXConstructExpr() { return true; }
198
199 /// Returns the location of the entity being transformed, if that
200 /// information was not available elsewhere in the AST.
201 ///
202 /// By default, returns no source-location information. Subclasses can
203 /// provide an alternative implementation that provides better location
204 /// information.
205 SourceLocation getBaseLocation() { return SourceLocation(); }
206
207 /// Returns the name of the entity being transformed, if that
208 /// information was not available elsewhere in the AST.
209 ///
210 /// By default, returns an empty name. Subclasses can provide an alternative
211 /// implementation with a more precise name.
212 DeclarationName getBaseEntity() { return DeclarationName(); }
213
214 /// Sets the "base" location and entity when that
215 /// information is known based on another transformation.
216 ///
217 /// By default, the source location and entity are ignored. Subclasses can
218 /// override this function to provide a customized implementation.
219 void setBase(SourceLocation Loc, DeclarationName Entity) { }
220
221 /// RAII object that temporarily sets the base location and entity
222 /// used for reporting diagnostics in types.
223 class TemporaryBase {
224 TreeTransform &Self;
225 SourceLocation OldLocation;
226 DeclarationName OldEntity;
227
228 public:
229 TemporaryBase(TreeTransform &Self, SourceLocation Location,
230 DeclarationName Entity) : Self(Self) {
231 OldLocation = Self.getDerived().getBaseLocation();
232 OldEntity = Self.getDerived().getBaseEntity();
233
234 if (Location.isValid())
235 Self.getDerived().setBase(Location, Entity);
236 }
237
238 ~TemporaryBase() {
239 Self.getDerived().setBase(OldLocation, OldEntity);
240 }
241 TemporaryBase(const TemporaryBase &) = delete;
242 TemporaryBase &operator=(const TemporaryBase &) = delete;
243 };
244
245 /// Determine whether the given type \p T has already been
246 /// transformed.
247 ///
248 /// Subclasses can provide an alternative implementation of this routine
249 /// to short-circuit evaluation when it is known that a given type will
250 /// not change. For example, template instantiation need not traverse
251 /// non-dependent types.
252 bool AlreadyTransformed(QualType T) {
253 return T.isNull();
254 }
255
256 /// Transform a template parameter depth level.
257 ///
258 /// During a transformation that transforms template parameters, this maps
259 /// an old template parameter depth to a new depth.
260 unsigned TransformTemplateDepth(unsigned Depth) {
261 return Depth;
262 }
263
264 /// Determine whether the given call argument should be dropped, e.g.,
265 /// because it is a default argument.
266 ///
267 /// Subclasses can provide an alternative implementation of this routine to
268 /// determine which kinds of call arguments get dropped. By default,
269 /// CXXDefaultArgument nodes are dropped (prior to transformation).
270 bool DropCallArgument(Expr *E) {
271 return E->isDefaultArgument();
272 }
273
274 /// Determine whether we should expand a pack expansion with the
275 /// given set of parameter packs into separate arguments by repeatedly
276 /// transforming the pattern.
277 ///
278 /// By default, the transformer never tries to expand pack expansions.
279 /// Subclasses can override this routine to provide different behavior.
280 ///
281 /// \param EllipsisLoc The location of the ellipsis that identifies the
282 /// pack expansion.
283 ///
284 /// \param PatternRange The source range that covers the entire pattern of
285 /// the pack expansion.
286 ///
287 /// \param Unexpanded The set of unexpanded parameter packs within the
288 /// pattern.
289 ///
290 /// \param ShouldExpand Will be set to \c true if the transformer should
291 /// expand the corresponding pack expansions into separate arguments. When
292 /// set, \c NumExpansions must also be set.
293 ///
294 /// \param RetainExpansion Whether the caller should add an unexpanded
295 /// pack expansion after all of the expanded arguments. This is used
296 /// when extending explicitly-specified template argument packs per
297 /// C++0x [temp.arg.explicit]p9.
298 ///
299 /// \param NumExpansions The number of separate arguments that will be in
300 /// the expanded form of the corresponding pack expansion. This is both an
301 /// input and an output parameter, which can be set by the caller if the
302 /// number of expansions is known a priori (e.g., due to a prior substitution)
303 /// and will be set by the callee when the number of expansions is known.
304 /// The callee must set this value when \c ShouldExpand is \c true; it may
305 /// set this value in other cases.
306 ///
307 /// \returns true if an error occurred (e.g., because the parameter packs
308 /// are to be instantiated with arguments of different lengths), false
309 /// otherwise. If false, \c ShouldExpand (and possibly \c NumExpansions)
310 /// must be set.
311 bool TryExpandParameterPacks(SourceLocation EllipsisLoc,
312 SourceRange PatternRange,
313 ArrayRef<UnexpandedParameterPack> Unexpanded,
314 bool FailOnPackProducingTemplates,
315 bool &ShouldExpand, bool &RetainExpansion,
316 UnsignedOrNone &NumExpansions) {
317 ShouldExpand = false;
318 return false;
319 }
320
321 /// "Forget" about the partially-substituted pack template argument,
322 /// when performing an instantiation that must preserve the parameter pack
323 /// use.
324 ///
325 /// This routine is meant to be overridden by the template instantiator.
326 TemplateArgument ForgetPartiallySubstitutedPack() {
327 return TemplateArgument();
328 }
329
330 /// "Remember" the partially-substituted pack template argument
331 /// after performing an instantiation that must preserve the parameter pack
332 /// use.
333 ///
334 /// This routine is meant to be overridden by the template instantiator.
335 void RememberPartiallySubstitutedPack(TemplateArgument Arg) { }
336
337 /// "Forget" the template substitution to allow transforming the AST without
338 /// any template instantiations. This is used to expand template packs when
339 /// their size is not known in advance (e.g. for builtins that produce type
340 /// packs).
341 MultiLevelTemplateArgumentList ForgetSubstitution() { return {}; }
342 void RememberSubstitution(MultiLevelTemplateArgumentList) {}
343
344private:
345 struct ForgetSubstitutionRAII {
346 Derived &Self;
347 MultiLevelTemplateArgumentList Old;
348
349 public:
350 ForgetSubstitutionRAII(Derived &Self) : Self(Self) {
351 Old = Self.ForgetSubstitution();
352 }
353
354 ~ForgetSubstitutionRAII() { Self.RememberSubstitution(std::move(Old)); }
355 };
356
357public:
358 /// Note to the derived class when a function parameter pack is
359 /// being expanded.
360 void ExpandingFunctionParameterPack(ParmVarDecl *Pack) { }
361
362 /// Transforms the given type into another type.
363 ///
364 /// By default, this routine transforms a type by creating a
365 /// TypeSourceInfo for it and delegating to the appropriate
366 /// function. This is expensive, but we don't mind, because
367 /// this method is deprecated anyway; all users should be
368 /// switched to storing TypeSourceInfos.
369 ///
370 /// \returns the transformed type.
371 QualType TransformType(QualType T);
372
373 /// Transforms the given type-with-location into a new
374 /// type-with-location.
375 ///
376 /// By default, this routine transforms a type by delegating to the
377 /// appropriate TransformXXXType to build a new type. Subclasses
378 /// may override this function (to take over all type
379 /// transformations) or some set of the TransformXXXType functions
380 /// to alter the transformation.
381 TypeSourceInfo *TransformType(TypeSourceInfo *TSI);
382
383 /// Transform the given type-with-location into a new
384 /// type, collecting location information in the given builder
385 /// as necessary.
386 ///
387 QualType TransformType(TypeLocBuilder &TLB, TypeLoc TL);
388
389 /// Transform a type that is permitted to produce a
390 /// DeducedTemplateSpecializationType.
391 ///
392 /// This is used in the (relatively rare) contexts where it is acceptable
393 /// for transformation to produce a class template type with deduced
394 /// template arguments.
395 /// @{
396 QualType TransformTypeWithDeducedTST(QualType T);
397 TypeSourceInfo *TransformTypeWithDeducedTST(TypeSourceInfo *TSI);
398 /// @}
399
400 /// The reason why the value of a statement is not discarded, if any.
401 enum class StmtDiscardKind {
402 Discarded,
403 NotDiscarded,
404 StmtExprResult,
405 };
406
407 /// Transform the given statement.
408 ///
409 /// By default, this routine transforms a statement by delegating to the
410 /// appropriate TransformXXXStmt function to transform a specific kind of
411 /// statement or the TransformExpr() function to transform an expression.
412 /// Subclasses may override this function to transform statements using some
413 /// other mechanism.
414 ///
415 /// \returns the transformed statement.
416 StmtResult TransformStmt(Stmt *S,
417 StmtDiscardKind SDK = StmtDiscardKind::Discarded);
418
419 /// Transform the given statement.
420 ///
421 /// By default, this routine transforms a statement by delegating to the
422 /// appropriate TransformOMPXXXClause function to transform a specific kind
423 /// of clause. Subclasses may override this function to transform statements
424 /// using some other mechanism.
425 ///
426 /// \returns the transformed OpenMP clause.
427 OMPClause *TransformOMPClause(OMPClause *S);
428
429 /// Transform the given attribute.
430 ///
431 /// By default, this routine transforms a statement by delegating to the
432 /// appropriate TransformXXXAttr function to transform a specific kind
433 /// of attribute. Subclasses may override this function to transform
434 /// attributed statements/types using some other mechanism.
435 ///
436 /// \returns the transformed attribute
437 const Attr *TransformAttr(const Attr *S);
438
439 // Transform the given statement attribute.
440 //
441 // Delegates to the appropriate TransformXXXAttr function to transform a
442 // specific kind of statement attribute. Unlike the non-statement taking
443 // version of this, this implements all attributes, not just pragmas.
444 const Attr *TransformStmtAttr(const Stmt *OrigS, const Stmt *InstS,
445 const Attr *A);
446
447 // Transform the specified attribute.
448 //
449 // Subclasses should override the transformation of attributes with a pragma
450 // spelling to transform expressions stored within the attribute.
451 //
452 // \returns the transformed attribute.
453#define ATTR(X) \
454 const X##Attr *Transform##X##Attr(const X##Attr *R) { return R; }
455#include "clang/Basic/AttrList.inc"
456
457 // Transform the specified attribute.
458 //
459 // Subclasses should override the transformation of attributes to do
460 // transformation and checking of statement attributes. By default, this
461 // delegates to the non-statement taking version.
462 //
463 // \returns the transformed attribute.
464#define ATTR(X) \
465 const X##Attr *TransformStmt##X##Attr(const Stmt *, const Stmt *, \
466 const X##Attr *A) { \
467 return getDerived().Transform##X##Attr(A); \
468 }
469#include "clang/Basic/AttrList.inc"
470
471 /// Transform the given expression.
472 ///
473 /// By default, this routine transforms an expression by delegating to the
474 /// appropriate TransformXXXExpr function to build a new expression.
475 /// Subclasses may override this function to transform expressions using some
476 /// other mechanism.
477 ///
478 /// \returns the transformed expression.
479 ExprResult TransformExpr(Expr *E);
480
481 /// Transform the given initializer.
482 ///
483 /// By default, this routine transforms an initializer by stripping off the
484 /// semantic nodes added by initialization, then passing the result to
485 /// TransformExpr or TransformExprs.
486 ///
487 /// \returns the transformed initializer.
488 ExprResult TransformInitializer(Expr *Init, bool NotCopyInit);
489
490 /// Transform the given list of expressions.
491 ///
492 /// This routine transforms a list of expressions by invoking
493 /// \c TransformExpr() for each subexpression. However, it also provides
494 /// support for variadic templates by expanding any pack expansions (if the
495 /// derived class permits such expansion) along the way. When pack expansions
496 /// are present, the number of outputs may not equal the number of inputs.
497 ///
498 /// \param Inputs The set of expressions to be transformed.
499 ///
500 /// \param NumInputs The number of expressions in \c Inputs.
501 ///
502 /// \param IsCall If \c true, then this transform is being performed on
503 /// function-call arguments, and any arguments that should be dropped, will
504 /// be.
505 ///
506 /// \param Outputs The transformed input expressions will be added to this
507 /// vector.
508 ///
509 /// \param ArgChanged If non-NULL, will be set \c true if any argument changed
510 /// due to transformation.
511 ///
512 /// \returns true if an error occurred, false otherwise.
513 bool TransformExprs(Expr *const *Inputs, unsigned NumInputs, bool IsCall,
514 SmallVectorImpl<Expr *> &Outputs,
515 bool *ArgChanged = nullptr);
516
517 /// Transform the given declaration, which is referenced from a type
518 /// or expression.
519 ///
520 /// By default, acts as the identity function on declarations, unless the
521 /// transformer has had to transform the declaration itself. Subclasses
522 /// may override this function to provide alternate behavior.
523 Decl *TransformDecl(SourceLocation Loc, Decl *D) {
524 llvm::DenseMap<Decl *, Decl *>::iterator Known
525 = TransformedLocalDecls.find(Val: D);
526 if (Known != TransformedLocalDecls.end())
527 return Known->second;
528
529 return D;
530 }
531
532 /// Transform the specified condition.
533 ///
534 /// By default, this transforms the variable and expression and rebuilds
535 /// the condition.
536 Sema::ConditionResult TransformCondition(SourceLocation Loc, VarDecl *Var,
537 Expr *Expr,
538 Sema::ConditionKind Kind);
539
540 /// Transform the attributes associated with the given declaration and
541 /// place them on the new declaration.
542 ///
543 /// By default, this operation does nothing. Subclasses may override this
544 /// behavior to transform attributes.
545 void transformAttrs(Decl *Old, Decl *New) { }
546
547 /// Note that a local declaration has been transformed by this
548 /// transformer.
549 ///
550 /// Local declarations are typically transformed via a call to
551 /// TransformDefinition. However, in some cases (e.g., lambda expressions),
552 /// the transformer itself has to transform the declarations. This routine
553 /// can be overridden by a subclass that keeps track of such mappings.
554 void transformedLocalDecl(Decl *Old, ArrayRef<Decl *> New) {
555 assert(New.size() == 1 &&
556 "must override transformedLocalDecl if performing pack expansion");
557 TransformedLocalDecls[Old] = New.front();
558 }
559
560 /// Transform the definition of the given declaration.
561 ///
562 /// By default, invokes TransformDecl() to transform the declaration.
563 /// Subclasses may override this function to provide alternate behavior.
564 Decl *TransformDefinition(SourceLocation Loc, Decl *D) {
565 return getDerived().TransformDecl(Loc, D);
566 }
567
568 /// Transform the given declaration, which was the first part of a
569 /// nested-name-specifier in a member access expression.
570 ///
571 /// This specific declaration transformation only applies to the first
572 /// identifier in a nested-name-specifier of a member access expression, e.g.,
573 /// the \c T in \c x->T::member
574 ///
575 /// By default, invokes TransformDecl() to transform the declaration.
576 /// Subclasses may override this function to provide alternate behavior.
577 NamedDecl *TransformFirstQualifierInScope(NamedDecl *D, SourceLocation Loc) {
578 return cast_or_null<NamedDecl>(getDerived().TransformDecl(Loc, D));
579 }
580
581 /// Transform the set of declarations in an OverloadExpr.
582 bool TransformOverloadExprDecls(OverloadExpr *Old, bool RequiresADL,
583 LookupResult &R);
584
585 /// Transform the given nested-name-specifier with source-location
586 /// information.
587 ///
588 /// By default, transforms all of the types and declarations within the
589 /// nested-name-specifier. Subclasses may override this function to provide
590 /// alternate behavior.
591 NestedNameSpecifierLoc
592 TransformNestedNameSpecifierLoc(NestedNameSpecifierLoc NNS,
593 QualType ObjectType = QualType(),
594 NamedDecl *FirstQualifierInScope = nullptr);
595
596 /// Transform the given declaration name.
597 ///
598 /// By default, transforms the types of conversion function, constructor,
599 /// and destructor names and then (if needed) rebuilds the declaration name.
600 /// Identifiers and selectors are returned unmodified. Subclasses may
601 /// override this function to provide alternate behavior.
602 DeclarationNameInfo
603 TransformDeclarationNameInfo(const DeclarationNameInfo &NameInfo);
604
605 bool TransformRequiresExprRequirements(
606 ArrayRef<concepts::Requirement *> Reqs,
607 llvm::SmallVectorImpl<concepts::Requirement *> &Transformed);
608 concepts::TypeRequirement *
609 TransformTypeRequirement(concepts::TypeRequirement *Req);
610 concepts::ExprRequirement *
611 TransformExprRequirement(concepts::ExprRequirement *Req);
612 concepts::NestedRequirement *
613 TransformNestedRequirement(concepts::NestedRequirement *Req);
614
615 /// Transform the given template name.
616 ///
617 /// \param SS The nested-name-specifier that qualifies the template
618 /// name. This nested-name-specifier must already have been transformed.
619 ///
620 /// \param Name The template name to transform.
621 ///
622 /// \param NameLoc The source location of the template name.
623 ///
624 /// \param ObjectType If we're translating a template name within a member
625 /// access expression, this is the type of the object whose member template
626 /// is being referenced.
627 ///
628 /// \param FirstQualifierInScope If the first part of a nested-name-specifier
629 /// also refers to a name within the current (lexical) scope, this is the
630 /// declaration it refers to.
631 ///
632 /// By default, transforms the template name by transforming the declarations
633 /// and nested-name-specifiers that occur within the template name.
634 /// Subclasses may override this function to provide alternate behavior.
635 TemplateName TransformTemplateName(NestedNameSpecifierLoc &QualifierLoc,
636 SourceLocation TemplateKWLoc,
637 TemplateName Name, SourceLocation NameLoc,
638 QualType ObjectType = QualType(),
639 NamedDecl *FirstQualifierInScope = nullptr,
640 bool AllowInjectedClassName = false);
641
642 TemplateName TransformConceptTemplateName(TemplateName Name,
643 SourceLocation NameLoc);
644
645 /// Transform the given template argument.
646 ///
647 /// By default, this operation transforms the type, expression, or
648 /// declaration stored within the template argument and constructs a
649 /// new template argument from the transformed result. Subclasses may
650 /// override this function to provide alternate behavior.
651 ///
652 /// Returns true if there was an error.
653 bool TransformTemplateArgument(const TemplateArgumentLoc &Input,
654 TemplateArgumentLoc &Output,
655 bool Uneval = false);
656
657 TemplateArgument TransformNamedTemplateTemplateArgument(
658 NestedNameSpecifierLoc &QualifierLoc, SourceLocation TemplateKeywordLoc,
659 TemplateName Name, SourceLocation NameLoc);
660
661 /// Transform the given set of template arguments.
662 ///
663 /// By default, this operation transforms all of the template arguments
664 /// in the input set using \c TransformTemplateArgument(), and appends
665 /// the transformed arguments to the output list.
666 ///
667 /// Note that this overload of \c TransformTemplateArguments() is merely
668 /// a convenience function. Subclasses that wish to override this behavior
669 /// should override the iterator-based member template version.
670 ///
671 /// \param Inputs The set of template arguments to be transformed.
672 ///
673 /// \param NumInputs The number of template arguments in \p Inputs.
674 ///
675 /// \param Outputs The set of transformed template arguments output by this
676 /// routine.
677 ///
678 /// Returns true if an error occurred.
679 bool TransformTemplateArguments(const TemplateArgumentLoc *Inputs,
680 unsigned NumInputs,
681 TemplateArgumentListInfo &Outputs,
682 bool Uneval = false) {
683 return TransformTemplateArguments(Inputs, Inputs + NumInputs, Outputs,
684 Uneval);
685 }
686
687 /// Transform the given set of template arguments.
688 ///
689 /// By default, this operation transforms all of the template arguments
690 /// in the input set using \c TransformTemplateArgument(), and appends
691 /// the transformed arguments to the output list.
692 ///
693 /// \param First An iterator to the first template argument.
694 ///
695 /// \param Last An iterator one step past the last template argument.
696 ///
697 /// \param Outputs The set of transformed template arguments output by this
698 /// routine.
699 ///
700 /// Returns true if an error occurred.
701 template<typename InputIterator>
702 bool TransformTemplateArguments(InputIterator First,
703 InputIterator Last,
704 TemplateArgumentListInfo &Outputs,
705 bool Uneval = false);
706
707 template <typename InputIterator>
708 bool TransformConceptTemplateArguments(InputIterator First,
709 InputIterator Last,
710 TemplateArgumentListInfo &Outputs,
711 bool Uneval = false);
712
713 /// Checks if the argument pack from \p In will need to be expanded and does
714 /// the necessary prework.
715 /// Whether the expansion is needed is captured in Info.Expand.
716 ///
717 /// - When the expansion is required, \p Out will be a template pattern that
718 /// would need to be expanded.
719 /// - When the expansion must not happen, \p Out will be a pack that must be
720 /// returned to the outputs directly.
721 ///
722 /// \return true iff the error occurred
723 bool PreparePackForExpansion(TemplateArgumentLoc In, bool Uneval,
724 TemplateArgumentLoc &Out, UnexpandedInfo &Info);
725
726 /// Fakes up a TemplateArgumentLoc for a given TemplateArgument.
727 void InventTemplateArgumentLoc(const TemplateArgument &Arg,
728 TemplateArgumentLoc &ArgLoc);
729
730 /// Fakes up a TypeSourceInfo for a type.
731 TypeSourceInfo *InventTypeSourceInfo(QualType T) {
732 return SemaRef.Context.getTrivialTypeSourceInfo(T,
733 Loc: getDerived().getBaseLocation());
734 }
735
736#define ABSTRACT_TYPELOC(CLASS, PARENT)
737#define TYPELOC(CLASS, PARENT) \
738 QualType Transform##CLASS##Type(TypeLocBuilder &TLB, CLASS##TypeLoc T);
739#include "clang/AST/TypeLocNodes.def"
740
741 QualType TransformTemplateTypeParmType(TypeLocBuilder &TLB,
742 TemplateTypeParmTypeLoc TL,
743 bool SuppressObjCLifetime);
744 QualType
745 TransformSubstTemplateTypeParmPackType(TypeLocBuilder &TLB,
746 SubstTemplateTypeParmPackTypeLoc TL,
747 bool SuppressObjCLifetime);
748
749 template<typename Fn>
750 QualType TransformFunctionProtoType(TypeLocBuilder &TLB,
751 FunctionProtoTypeLoc TL,
752 CXXRecordDecl *ThisContext,
753 Qualifiers ThisTypeQuals,
754 Fn TransformExceptionSpec);
755
756 bool TransformExceptionSpec(SourceLocation Loc,
757 FunctionProtoType::ExceptionSpecInfo &ESI,
758 SmallVectorImpl<QualType> &Exceptions,
759 bool &Changed);
760
761 StmtResult TransformSEHHandler(Stmt *Handler);
762
763 QualType TransformTemplateSpecializationType(TypeLocBuilder &TLB,
764 TemplateSpecializationTypeLoc TL,
765 QualType ObjectType,
766 NamedDecl *FirstQualifierInScope,
767 bool AllowInjectedClassName);
768
769 QualType TransformTagType(TypeLocBuilder &TLB, TagTypeLoc TL);
770
771 /// Transforms the parameters of a function type into the
772 /// given vectors.
773 ///
774 /// The result vectors should be kept in sync; null entries in the
775 /// variables vector are acceptable.
776 ///
777 /// LastParamTransformed, if non-null, will be set to the index of the last
778 /// parameter on which transformation was started. In the event of an error,
779 /// this will contain the parameter which failed to instantiate.
780 ///
781 /// Return true on error.
782 bool TransformFunctionTypeParams(
783 SourceLocation Loc, ArrayRef<ParmVarDecl *> Params,
784 const QualType *ParamTypes,
785 const FunctionProtoType::ExtParameterInfo *ParamInfos,
786 SmallVectorImpl<QualType> &PTypes, SmallVectorImpl<ParmVarDecl *> *PVars,
787 Sema::ExtParameterInfoBuilder &PInfos, unsigned *LastParamTransformed);
788
789 bool TransformFunctionTypeParams(
790 SourceLocation Loc, ArrayRef<ParmVarDecl *> Params,
791 const QualType *ParamTypes,
792 const FunctionProtoType::ExtParameterInfo *ParamInfos,
793 SmallVectorImpl<QualType> &PTypes, SmallVectorImpl<ParmVarDecl *> *PVars,
794 Sema::ExtParameterInfoBuilder &PInfos) {
795 return getDerived().TransformFunctionTypeParams(
796 Loc, Params, ParamTypes, ParamInfos, PTypes, PVars, PInfos, nullptr);
797 }
798
799 /// Transforms the parameters of a requires expresison into the given vectors.
800 ///
801 /// The result vectors should be kept in sync; null entries in the
802 /// variables vector are acceptable.
803 ///
804 /// Returns an unset ExprResult on success. Returns an ExprResult the 'not
805 /// satisfied' RequiresExpr if subsitution failed, OR an ExprError, both of
806 /// which are cases where transformation shouldn't continue.
807 ExprResult TransformRequiresTypeParams(
808 SourceLocation KWLoc, SourceLocation RBraceLoc, const RequiresExpr *RE,
809 RequiresExprBodyDecl *Body, ArrayRef<ParmVarDecl *> Params,
810 SmallVectorImpl<QualType> &PTypes,
811 SmallVectorImpl<ParmVarDecl *> &TransParams,
812 Sema::ExtParameterInfoBuilder &PInfos) {
813 if (getDerived().TransformFunctionTypeParams(
814 KWLoc, Params, /*ParamTypes=*/nullptr,
815 /*ParamInfos=*/nullptr, PTypes, &TransParams, PInfos))
816 return ExprError();
817
818 return ExprResult{};
819 }
820
821 /// Transforms a single function-type parameter. Return null
822 /// on error.
823 ///
824 /// \param indexAdjustment - A number to add to the parameter's
825 /// scope index; can be negative
826 ParmVarDecl *TransformFunctionTypeParam(ParmVarDecl *OldParm,
827 int indexAdjustment,
828 UnsignedOrNone NumExpansions,
829 bool ExpectParameterPack);
830
831 /// Transform the body of a lambda-expression.
832 StmtResult TransformLambdaBody(LambdaExpr *E, Stmt *Body);
833 /// Alternative implementation of TransformLambdaBody that skips transforming
834 /// the body.
835 StmtResult SkipLambdaBody(LambdaExpr *E, Stmt *Body);
836
837 CXXRecordDecl::LambdaDependencyKind
838 ComputeLambdaDependency(LambdaScopeInfo *LSI) {
839 return static_cast<CXXRecordDecl::LambdaDependencyKind>(
840 LSI->Lambda->getLambdaDependencyKind());
841 }
842
843 ExprResult TransformLambdaConstraint(Expr *AC) { return AC; }
844
845 QualType TransformReferenceType(TypeLocBuilder &TLB, ReferenceTypeLoc TL);
846
847 StmtResult TransformCompoundStmt(CompoundStmt *S, bool IsStmtExpr);
848 ExprResult TransformCXXNamedCastExpr(CXXNamedCastExpr *E);
849
850 TemplateParameterList *TransformTemplateParameterList(
851 TemplateParameterList *TPL) {
852 return TPL;
853 }
854
855 ExprResult TransformAddressOfOperand(Expr *E);
856
857 ExprResult TransformDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *E,
858 bool IsAddressOfOperand,
859 TypeSourceInfo **RecoveryTSI);
860
861 ExprResult TransformParenDependentScopeDeclRefExpr(
862 ParenExpr *PE, DependentScopeDeclRefExpr *DRE, bool IsAddressOfOperand,
863 TypeSourceInfo **RecoveryTSI);
864
865 ExprResult TransformUnresolvedLookupExpr(UnresolvedLookupExpr *E,
866 bool IsAddressOfOperand);
867
868 StmtResult TransformOMPExecutableDirective(OMPExecutableDirective *S);
869
870 StmtResult TransformOMPInformationalDirective(OMPExecutableDirective *S);
871
872// FIXME: We use LLVM_ATTRIBUTE_NOINLINE because inlining causes a ridiculous
873// amount of stack usage with clang.
874#define STMT(Node, Parent) \
875 LLVM_ATTRIBUTE_NOINLINE \
876 StmtResult Transform##Node(Node *S);
877#define VALUESTMT(Node, Parent) \
878 LLVM_ATTRIBUTE_NOINLINE \
879 StmtResult Transform##Node(Node *S, StmtDiscardKind SDK);
880#define EXPR(Node, Parent) \
881 LLVM_ATTRIBUTE_NOINLINE \
882 ExprResult Transform##Node(Node *E);
883#define ABSTRACT_STMT(Stmt)
884#include "clang/AST/StmtNodes.inc"
885
886#define GEN_CLANG_CLAUSE_CLASS
887#define CLAUSE_CLASS(Enum, Str, Class) \
888 LLVM_ATTRIBUTE_NOINLINE \
889 OMPClause *Transform##Class(Class *S);
890#include "llvm/Frontend/OpenMP/OMP.inc"
891
892 /// Build a new qualified type given its unqualified type and type location.
893 ///
894 /// By default, this routine adds type qualifiers only to types that can
895 /// have qualifiers, and silently suppresses those qualifiers that are not
896 /// permitted. Subclasses may override this routine to provide different
897 /// behavior.
898 QualType RebuildQualifiedType(QualType T, QualifiedTypeLoc TL);
899
900 /// Build a new pointer type given its pointee type.
901 ///
902 /// By default, performs semantic analysis when building the pointer type.
903 /// Subclasses may override this routine to provide different behavior.
904 QualType RebuildPointerType(QualType PointeeType, SourceLocation Sigil);
905
906 /// Build a new block pointer type given its pointee type.
907 ///
908 /// By default, performs semantic analysis when building the block pointer
909 /// type. Subclasses may override this routine to provide different behavior.
910 QualType RebuildBlockPointerType(QualType PointeeType, SourceLocation Sigil);
911
912 /// Build a new reference type given the type it references.
913 ///
914 /// By default, performs semantic analysis when building the
915 /// reference type. Subclasses may override this routine to provide
916 /// different behavior.
917 ///
918 /// \param LValue whether the type was written with an lvalue sigil
919 /// or an rvalue sigil.
920 QualType RebuildReferenceType(QualType ReferentType,
921 bool LValue,
922 SourceLocation Sigil);
923
924 /// Build a new member pointer type given the pointee type and the
925 /// qualifier it refers into.
926 ///
927 /// By default, performs semantic analysis when building the member pointer
928 /// type. Subclasses may override this routine to provide different behavior.
929 QualType RebuildMemberPointerType(QualType PointeeType,
930 const CXXScopeSpec &SS, CXXRecordDecl *Cls,
931 SourceLocation Sigil);
932
933 QualType RebuildObjCTypeParamType(const ObjCTypeParamDecl *Decl,
934 SourceLocation ProtocolLAngleLoc,
935 ArrayRef<ObjCProtocolDecl *> Protocols,
936 ArrayRef<SourceLocation> ProtocolLocs,
937 SourceLocation ProtocolRAngleLoc);
938
939 /// Build an Objective-C object type.
940 ///
941 /// By default, performs semantic analysis when building the object type.
942 /// Subclasses may override this routine to provide different behavior.
943 QualType RebuildObjCObjectType(QualType BaseType,
944 SourceLocation Loc,
945 SourceLocation TypeArgsLAngleLoc,
946 ArrayRef<TypeSourceInfo *> TypeArgs,
947 SourceLocation TypeArgsRAngleLoc,
948 SourceLocation ProtocolLAngleLoc,
949 ArrayRef<ObjCProtocolDecl *> Protocols,
950 ArrayRef<SourceLocation> ProtocolLocs,
951 SourceLocation ProtocolRAngleLoc);
952
953 /// Build a new Objective-C object pointer type given the pointee type.
954 ///
955 /// By default, directly builds the pointer type, with no additional semantic
956 /// analysis.
957 QualType RebuildObjCObjectPointerType(QualType PointeeType,
958 SourceLocation Star);
959
960 /// Build a new array type given the element type, size
961 /// modifier, size of the array (if known), size expression, and index type
962 /// qualifiers.
963 ///
964 /// By default, performs semantic analysis when building the array type.
965 /// Subclasses may override this routine to provide different behavior.
966 /// Also by default, all of the other Rebuild*Array
967 QualType RebuildArrayType(QualType ElementType, ArraySizeModifier SizeMod,
968 const llvm::APInt *Size, Expr *SizeExpr,
969 unsigned IndexTypeQuals, SourceRange BracketsRange);
970
971 /// Build a new constant array type given the element type, size
972 /// modifier, (known) size of the array, and index type qualifiers.
973 ///
974 /// By default, performs semantic analysis when building the array type.
975 /// Subclasses may override this routine to provide different behavior.
976 QualType RebuildConstantArrayType(QualType ElementType,
977 ArraySizeModifier SizeMod,
978 const llvm::APInt &Size, Expr *SizeExpr,
979 unsigned IndexTypeQuals,
980 SourceRange BracketsRange);
981
982 /// Build a new incomplete array type given the element type, size
983 /// modifier, and index type qualifiers.
984 ///
985 /// By default, performs semantic analysis when building the array type.
986 /// Subclasses may override this routine to provide different behavior.
987 QualType RebuildIncompleteArrayType(QualType ElementType,
988 ArraySizeModifier SizeMod,
989 unsigned IndexTypeQuals,
990 SourceRange BracketsRange);
991
992 /// Build a new variable-length array type given the element type,
993 /// size modifier, size expression, and index type qualifiers.
994 ///
995 /// By default, performs semantic analysis when building the array type.
996 /// Subclasses may override this routine to provide different behavior.
997 QualType RebuildVariableArrayType(QualType ElementType,
998 ArraySizeModifier SizeMod, Expr *SizeExpr,
999 unsigned IndexTypeQuals,
1000 SourceRange BracketsRange);
1001
1002 /// Build a new dependent-sized array type given the element type,
1003 /// size modifier, size expression, and index type qualifiers.
1004 ///
1005 /// By default, performs semantic analysis when building the array type.
1006 /// Subclasses may override this routine to provide different behavior.
1007 QualType RebuildDependentSizedArrayType(QualType ElementType,
1008 ArraySizeModifier SizeMod,
1009 Expr *SizeExpr,
1010 unsigned IndexTypeQuals,
1011 SourceRange BracketsRange);
1012
1013 /// Build a new vector type given the element type and
1014 /// number of elements.
1015 ///
1016 /// By default, performs semantic analysis when building the vector type.
1017 /// Subclasses may override this routine to provide different behavior.
1018 QualType RebuildVectorType(QualType ElementType, unsigned NumElements,
1019 VectorKind VecKind);
1020
1021 /// Build a new potentially dependently-sized extended vector type
1022 /// given the element type and number of elements.
1023 ///
1024 /// By default, performs semantic analysis when building the vector type.
1025 /// Subclasses may override this routine to provide different behavior.
1026 QualType RebuildDependentVectorType(QualType ElementType, Expr *SizeExpr,
1027 SourceLocation AttributeLoc, VectorKind);
1028
1029 /// Build a new extended vector type given the element type and
1030 /// number of elements.
1031 ///
1032 /// By default, performs semantic analysis when building the vector type.
1033 /// Subclasses may override this routine to provide different behavior.
1034 QualType RebuildExtVectorType(QualType ElementType, unsigned NumElements,
1035 SourceLocation AttributeLoc);
1036
1037 /// Build a new potentially dependently-sized extended vector type
1038 /// given the element type and number of elements.
1039 ///
1040 /// By default, performs semantic analysis when building the vector type.
1041 /// Subclasses may override this routine to provide different behavior.
1042 QualType RebuildDependentSizedExtVectorType(QualType ElementType,
1043 Expr *SizeExpr,
1044 SourceLocation AttributeLoc);
1045
1046 /// Build a new matrix type given the element type and dimensions.
1047 QualType RebuildConstantMatrixType(QualType ElementType, unsigned NumRows,
1048 unsigned NumColumns,
1049 SourceLocation AttributeLoc);
1050
1051 /// Build a new matrix type given the type and dependently-defined
1052 /// dimensions.
1053 QualType RebuildDependentSizedMatrixType(QualType ElementType, Expr *RowExpr,
1054 Expr *ColumnExpr,
1055 SourceLocation AttributeLoc);
1056
1057 /// Build a new DependentAddressSpaceType or return the pointee
1058 /// type variable with the correct address space (retrieved from
1059 /// AddrSpaceExpr) applied to it. The former will be returned in cases
1060 /// where the address space remains dependent.
1061 ///
1062 /// By default, performs semantic analysis when building the type with address
1063 /// space applied. Subclasses may override this routine to provide different
1064 /// behavior.
1065 QualType RebuildDependentAddressSpaceType(QualType PointeeType,
1066 Expr *AddrSpaceExpr,
1067 SourceLocation AttributeLoc);
1068
1069 /// Build a new function type.
1070 ///
1071 /// By default, performs semantic analysis when building the function type.
1072 /// Subclasses may override this routine to provide different behavior.
1073 QualType RebuildFunctionProtoType(QualType T,
1074 MutableArrayRef<QualType> ParamTypes,
1075 const FunctionProtoType::ExtProtoInfo &EPI);
1076
1077 /// Build a new unprototyped function type.
1078 QualType RebuildFunctionNoProtoType(QualType ResultType);
1079
1080 /// Rebuild an unresolved typename type, given the decl that
1081 /// the UnresolvedUsingTypenameDecl was transformed to.
1082 QualType RebuildUnresolvedUsingType(ElaboratedTypeKeyword Keyword,
1083 NestedNameSpecifier Qualifier,
1084 SourceLocation NameLoc, Decl *D);
1085
1086 /// Build a new type found via an alias.
1087 QualType RebuildUsingType(ElaboratedTypeKeyword Keyword,
1088 NestedNameSpecifier Qualifier, UsingShadowDecl *D,
1089 QualType UnderlyingType) {
1090 return SemaRef.Context.getUsingType(Keyword, Qualifier, D, UnderlyingType);
1091 }
1092
1093 /// Build a new typedef type.
1094 QualType RebuildTypedefType(ElaboratedTypeKeyword Keyword,
1095 NestedNameSpecifier Qualifier,
1096 TypedefNameDecl *Typedef) {
1097 return SemaRef.Context.getTypedefType(Keyword, Qualifier, Decl: Typedef);
1098 }
1099
1100 /// Build a new MacroDefined type.
1101 QualType RebuildMacroQualifiedType(QualType T,
1102 const IdentifierInfo *MacroII) {
1103 return SemaRef.Context.getMacroQualifiedType(UnderlyingTy: T, MacroII);
1104 }
1105
1106 /// Build a new class/struct/union/enum type.
1107 QualType RebuildTagType(ElaboratedTypeKeyword Keyword,
1108 NestedNameSpecifier Qualifier, TagDecl *Tag) {
1109 return SemaRef.Context.getTagType(Keyword, Qualifier, TD: Tag,
1110 /*OwnsTag=*/OwnsTag: false);
1111 }
1112 QualType RebuildCanonicalTagType(TagDecl *Tag) {
1113 return SemaRef.Context.getCanonicalTagType(TD: Tag);
1114 }
1115
1116 /// Build a new typeof(expr) type.
1117 ///
1118 /// By default, performs semantic analysis when building the typeof type.
1119 /// Subclasses may override this routine to provide different behavior.
1120 QualType RebuildTypeOfExprType(Expr *Underlying, SourceLocation Loc,
1121 TypeOfKind Kind);
1122
1123 /// Build a new typeof(type) type.
1124 ///
1125 /// By default, builds a new TypeOfType with the given underlying type.
1126 QualType RebuildTypeOfType(QualType Underlying, TypeOfKind Kind);
1127
1128 /// Build a new unary transform type.
1129 QualType RebuildUnaryTransformType(QualType BaseType,
1130 UnaryTransformType::UTTKind UKind,
1131 SourceLocation Loc);
1132
1133 /// Build a new C++11 decltype type.
1134 ///
1135 /// By default, performs semantic analysis when building the decltype type.
1136 /// Subclasses may override this routine to provide different behavior.
1137 QualType RebuildDecltypeType(Expr *Underlying, SourceLocation Loc);
1138
1139 QualType RebuildPackIndexingType(QualType Pattern, Expr *IndexExpr,
1140 SourceLocation Loc, bool FullySubstituted,
1141 ArrayRef<QualType> Expansions = {});
1142
1143 /// Build a new C++11 auto type.
1144 ///
1145 /// By default, builds a new AutoType with the given deduced type.
1146 QualType RebuildAutoType(DeducedKind DK, QualType DeducedAsType,
1147 AutoTypeKeyword Keyword,
1148 TemplateName TypeConstraintConcept,
1149 ArrayRef<TemplateArgument> TypeConstraintArgs) {
1150 return SemaRef.Context.getAutoType(
1151 DK, DeducedAsType, Keyword, TypeConstraintConcept, TypeConstraintArgs);
1152 }
1153
1154 /// By default, builds a new DeducedTemplateSpecializationType with the given
1155 /// deduced type.
1156 QualType RebuildDeducedTemplateSpecializationType(
1157 DeducedKind DK, QualType DeducedAsType, ElaboratedTypeKeyword Keyword,
1158 TemplateName Template) {
1159 return SemaRef.Context.getDeducedTemplateSpecializationType(
1160 DK, DeducedAsType, Keyword, Template);
1161 }
1162
1163 /// Build a new template specialization type.
1164 ///
1165 /// By default, performs semantic analysis when building the template
1166 /// specialization type. Subclasses may override this routine to provide
1167 /// different behavior.
1168 QualType RebuildTemplateSpecializationType(ElaboratedTypeKeyword Keyword,
1169 TemplateName Template,
1170 SourceLocation TemplateLoc,
1171 TemplateArgumentListInfo &Args);
1172
1173 /// Build a new parenthesized type.
1174 ///
1175 /// By default, builds a new ParenType type from the inner type.
1176 /// Subclasses may override this routine to provide different behavior.
1177 QualType RebuildParenType(QualType InnerType) {
1178 return SemaRef.BuildParenType(T: InnerType);
1179 }
1180
1181 /// Build a new typename type that refers to an identifier.
1182 ///
1183 /// By default, performs semantic analysis when building the typename type
1184 /// (or elaborated type). Subclasses may override this routine to provide
1185 /// different behavior.
1186 QualType RebuildDependentNameType(ElaboratedTypeKeyword Keyword,
1187 SourceLocation KeywordLoc,
1188 NestedNameSpecifierLoc QualifierLoc,
1189 const IdentifierInfo *Id,
1190 SourceLocation IdLoc,
1191 bool DeducedTSTContext) {
1192 CXXScopeSpec SS;
1193 SS.Adopt(Other: QualifierLoc);
1194
1195 if (QualifierLoc.getNestedNameSpecifier().isDependent()) {
1196 // If the name is still dependent, just build a new dependent name type.
1197 if (!SemaRef.computeDeclContext(SS))
1198 return SemaRef.Context.getDependentNameType(Keyword,
1199 NNS: QualifierLoc.getNestedNameSpecifier(),
1200 Name: Id);
1201 }
1202
1203 if (Keyword == ElaboratedTypeKeyword::None ||
1204 Keyword == ElaboratedTypeKeyword::Typename) {
1205 return SemaRef.CheckTypenameType(Keyword, KeywordLoc, QualifierLoc,
1206 II: *Id, IILoc: IdLoc, DeducedTSTContext);
1207 }
1208
1209 TagTypeKind Kind = TypeWithKeyword::getTagTypeKindForKeyword(Keyword);
1210
1211 // We had a dependent elaborated-type-specifier that has been transformed
1212 // into a non-dependent elaborated-type-specifier. Find the tag we're
1213 // referring to.
1214 LookupResult Result(SemaRef, Id, IdLoc, Sema::LookupTagName);
1215 DeclContext *DC = SemaRef.computeDeclContext(SS, EnteringContext: false);
1216 if (!DC)
1217 return QualType();
1218
1219 if (SemaRef.RequireCompleteDeclContext(SS, DC))
1220 return QualType();
1221
1222 TagDecl *Tag = nullptr;
1223 SemaRef.LookupQualifiedName(R&: Result, LookupCtx: DC);
1224 switch (Result.getResultKind()) {
1225 case LookupResultKind::NotFound:
1226 case LookupResultKind::NotFoundInCurrentInstantiation:
1227 break;
1228
1229 case LookupResultKind::Found:
1230 Tag = Result.getAsSingle<TagDecl>();
1231 break;
1232
1233 case LookupResultKind::FoundOverloaded:
1234 case LookupResultKind::FoundUnresolvedValue:
1235 llvm_unreachable("Tag lookup cannot find non-tags");
1236
1237 case LookupResultKind::Ambiguous:
1238 // Let the LookupResult structure handle ambiguities.
1239 return QualType();
1240 }
1241
1242 if (!Tag) {
1243 // Check where the name exists but isn't a tag type and use that to emit
1244 // better diagnostics.
1245 LookupResult Result(SemaRef, Id, IdLoc, Sema::LookupTagName);
1246 SemaRef.LookupQualifiedName(R&: Result, LookupCtx: DC);
1247 switch (Result.getResultKind()) {
1248 case LookupResultKind::Found:
1249 case LookupResultKind::FoundOverloaded:
1250 case LookupResultKind::FoundUnresolvedValue: {
1251 NamedDecl *SomeDecl = Result.getRepresentativeDecl();
1252 NonTagKind NTK = SemaRef.getNonTagTypeDeclKind(D: SomeDecl, TTK: Kind);
1253 SemaRef.Diag(Loc: IdLoc, DiagID: diag::err_tag_reference_non_tag)
1254 << SomeDecl << NTK << Kind;
1255 SemaRef.Diag(Loc: SomeDecl->getLocation(), DiagID: diag::note_declared_at);
1256 break;
1257 }
1258 default:
1259 SemaRef.Diag(Loc: IdLoc, DiagID: diag::err_not_tag_in_scope)
1260 << Kind << Id << DC << QualifierLoc.getSourceRange();
1261 break;
1262 }
1263 return QualType();
1264 }
1265 if (!SemaRef.isAcceptableTagRedeclaration(Previous: Tag, NewTag: Kind, /*isDefinition*/isDefinition: false,
1266 NewTagLoc: IdLoc, Name: Id)) {
1267 SemaRef.Diag(Loc: KeywordLoc, DiagID: diag::err_use_with_wrong_tag) << Id;
1268 SemaRef.Diag(Loc: Tag->getLocation(), DiagID: diag::note_previous_use);
1269 return QualType();
1270 }
1271 return getDerived().RebuildTagType(
1272 Keyword, QualifierLoc.getNestedNameSpecifier(), Tag);
1273 }
1274
1275 /// Build a new pack expansion type.
1276 ///
1277 /// By default, builds a new PackExpansionType type from the given pattern.
1278 /// Subclasses may override this routine to provide different behavior.
1279 QualType RebuildPackExpansionType(QualType Pattern, SourceRange PatternRange,
1280 SourceLocation EllipsisLoc,
1281 UnsignedOrNone NumExpansions) {
1282 return getSema().CheckPackExpansion(Pattern, PatternRange, EllipsisLoc,
1283 NumExpansions);
1284 }
1285
1286 /// Build a new atomic type given its value type.
1287 ///
1288 /// By default, performs semantic analysis when building the atomic type.
1289 /// Subclasses may override this routine to provide different behavior.
1290 QualType RebuildAtomicType(QualType ValueType, SourceLocation KWLoc);
1291
1292 /// Build a new pipe type given its value type.
1293 QualType RebuildPipeType(QualType ValueType, SourceLocation KWLoc,
1294 bool isReadPipe);
1295
1296 /// Build a bit-precise int given its value type.
1297 QualType RebuildBitIntType(bool IsUnsigned, unsigned NumBits,
1298 SourceLocation Loc);
1299
1300 /// Build a dependent bit-precise int given its value type.
1301 QualType RebuildDependentBitIntType(bool IsUnsigned, Expr *NumBitsExpr,
1302 SourceLocation Loc);
1303
1304 /// Build a new template name given a nested name specifier, a flag
1305 /// indicating whether the "template" keyword was provided, and the template
1306 /// that the template name refers to.
1307 ///
1308 /// By default, builds the new template name directly. Subclasses may override
1309 /// this routine to provide different behavior.
1310 TemplateName RebuildTemplateName(CXXScopeSpec &SS, bool TemplateKW,
1311 TemplateName Name);
1312
1313 /// Build a new template name given a nested name specifier and the
1314 /// name that is referred to as a template.
1315 ///
1316 /// By default, performs semantic analysis to determine whether the name can
1317 /// be resolved to a specific template, then builds the appropriate kind of
1318 /// template name. Subclasses may override this routine to provide different
1319 /// behavior.
1320 TemplateName RebuildTemplateName(CXXScopeSpec &SS,
1321 SourceLocation TemplateKWLoc,
1322 const IdentifierInfo &Name,
1323 SourceLocation NameLoc, QualType ObjectType,
1324 bool AllowInjectedClassName);
1325
1326 /// Build a new template name given a nested name specifier and the
1327 /// overloaded operator name that is referred to as a template.
1328 ///
1329 /// By default, performs semantic analysis to determine whether the name can
1330 /// be resolved to a specific template, then builds the appropriate kind of
1331 /// template name. Subclasses may override this routine to provide different
1332 /// behavior.
1333 TemplateName RebuildTemplateName(CXXScopeSpec &SS,
1334 SourceLocation TemplateKWLoc,
1335 OverloadedOperatorKind Operator,
1336 SourceLocation NameLoc, QualType ObjectType,
1337 bool AllowInjectedClassName);
1338
1339 TemplateName RebuildTemplateName(CXXScopeSpec &SS,
1340 SourceLocation TemplateKWLoc,
1341 IdentifierOrOverloadedOperator IO,
1342 SourceLocation NameLoc, QualType ObjectType,
1343 bool AllowInjectedClassName);
1344
1345 /// Build a new template name given a template template parameter pack
1346 /// and the
1347 ///
1348 /// By default, performs semantic analysis to determine whether the name can
1349 /// be resolved to a specific template, then builds the appropriate kind of
1350 /// template name. Subclasses may override this routine to provide different
1351 /// behavior.
1352 TemplateName RebuildTemplateName(const TemplateArgument &ArgPack,
1353 Decl *AssociatedDecl, unsigned Index,
1354 bool Final) {
1355 return getSema().Context.getSubstTemplateTemplateParmPack(
1356 ArgPack, AssociatedDecl, Index, Final);
1357 }
1358
1359 /// Build a new pack-index-template-name ([temp.names]).
1360 ///
1361 /// By default, performs semantic analysis to build the new template name.
1362 /// Subclasses may override this routine to provide different behavior.
1363 TemplateName
1364 RebuildPackIndexingTemplateName(TemplateName Pattern, Expr *IndexExpr,
1365 bool FullySubstituted,
1366 ArrayRef<TemplateName> Expansions = {}) {
1367 return getSema().BuildPackIndexingTemplateName(
1368 Pattern, IndexExpr, FullySubstituted, Expansions);
1369 }
1370
1371 /// Build a new compound statement.
1372 ///
1373 /// By default, performs semantic analysis to build the new statement.
1374 /// Subclasses may override this routine to provide different behavior.
1375 StmtResult RebuildCompoundStmt(SourceLocation LBraceLoc,
1376 MultiStmtArg Statements,
1377 SourceLocation RBraceLoc,
1378 bool IsStmtExpr) {
1379 return getSema().ActOnCompoundStmt(LBraceLoc, RBraceLoc, Statements,
1380 IsStmtExpr);
1381 }
1382
1383 /// Build a new case statement.
1384 ///
1385 /// By default, performs semantic analysis to build the new statement.
1386 /// Subclasses may override this routine to provide different behavior.
1387 StmtResult RebuildCaseStmt(SourceLocation CaseLoc,
1388 Expr *LHS,
1389 SourceLocation EllipsisLoc,
1390 Expr *RHS,
1391 SourceLocation ColonLoc) {
1392 return getSema().ActOnCaseStmt(CaseLoc, LHS, EllipsisLoc, RHS,
1393 ColonLoc);
1394 }
1395
1396 /// Attach the body to a new case statement.
1397 ///
1398 /// By default, performs semantic analysis to build the new statement.
1399 /// Subclasses may override this routine to provide different behavior.
1400 StmtResult RebuildCaseStmtBody(Stmt *S, Stmt *Body) {
1401 getSema().ActOnCaseStmtBody(S, Body);
1402 return S;
1403 }
1404
1405 /// Build a new default statement.
1406 ///
1407 /// By default, performs semantic analysis to build the new statement.
1408 /// Subclasses may override this routine to provide different behavior.
1409 StmtResult RebuildDefaultStmt(SourceLocation DefaultLoc,
1410 SourceLocation ColonLoc,
1411 Stmt *SubStmt) {
1412 return getSema().ActOnDefaultStmt(DefaultLoc, ColonLoc, SubStmt,
1413 /*CurScope=*/nullptr);
1414 }
1415
1416 /// Build a new label statement.
1417 ///
1418 /// By default, performs semantic analysis to build the new statement.
1419 /// Subclasses may override this routine to provide different behavior.
1420 StmtResult RebuildLabelStmt(SourceLocation IdentLoc, LabelDecl *L,
1421 SourceLocation ColonLoc, Stmt *SubStmt) {
1422 return SemaRef.ActOnLabelStmt(IdentLoc, TheDecl: L, ColonLoc, SubStmt);
1423 }
1424
1425 /// Build a new attributed statement.
1426 ///
1427 /// By default, performs semantic analysis to build the new statement.
1428 /// Subclasses may override this routine to provide different behavior.
1429 StmtResult RebuildAttributedStmt(SourceLocation AttrLoc,
1430 ArrayRef<const Attr *> Attrs,
1431 Stmt *SubStmt) {
1432 if (SemaRef.CheckRebuiltStmtAttributes(Attrs))
1433 return StmtError();
1434 return SemaRef.BuildAttributedStmt(AttrsLoc: AttrLoc, Attrs, SubStmt);
1435 }
1436
1437 /// Build a new "if" statement.
1438 ///
1439 /// By default, performs semantic analysis to build the new statement.
1440 /// Subclasses may override this routine to provide different behavior.
1441 StmtResult RebuildIfStmt(SourceLocation IfLoc, IfStatementKind Kind,
1442 SourceLocation LParenLoc, Sema::ConditionResult Cond,
1443 SourceLocation RParenLoc, Stmt *Init, Stmt *Then,
1444 SourceLocation ElseLoc, Stmt *Else) {
1445 return getSema().ActOnIfStmt(IfLoc, Kind, LParenLoc, Init, Cond, RParenLoc,
1446 Then, ElseLoc, Else);
1447 }
1448
1449 /// Start building a new switch statement.
1450 ///
1451 /// By default, performs semantic analysis to build the new statement.
1452 /// Subclasses may override this routine to provide different behavior.
1453 StmtResult RebuildSwitchStmtStart(SourceLocation SwitchLoc,
1454 SourceLocation LParenLoc, Stmt *Init,
1455 Sema::ConditionResult Cond,
1456 SourceLocation RParenLoc) {
1457 return getSema().ActOnStartOfSwitchStmt(SwitchLoc, LParenLoc, Init, Cond,
1458 RParenLoc);
1459 }
1460
1461 /// Attach the body to the switch statement.
1462 ///
1463 /// By default, performs semantic analysis to build the new statement.
1464 /// Subclasses may override this routine to provide different behavior.
1465 StmtResult RebuildSwitchStmtBody(SourceLocation SwitchLoc,
1466 Stmt *Switch, Stmt *Body) {
1467 return getSema().ActOnFinishSwitchStmt(SwitchLoc, Switch, Body);
1468 }
1469
1470 /// Build a new while statement.
1471 ///
1472 /// By default, performs semantic analysis to build the new statement.
1473 /// Subclasses may override this routine to provide different behavior.
1474 StmtResult RebuildWhileStmt(SourceLocation WhileLoc, SourceLocation LParenLoc,
1475 Sema::ConditionResult Cond,
1476 SourceLocation RParenLoc, Stmt *Body) {
1477 return getSema().ActOnWhileStmt(WhileLoc, LParenLoc, Cond, RParenLoc, Body);
1478 }
1479
1480 /// Build a new do-while statement.
1481 ///
1482 /// By default, performs semantic analysis to build the new statement.
1483 /// Subclasses may override this routine to provide different behavior.
1484 StmtResult RebuildDoStmt(SourceLocation DoLoc, Stmt *Body,
1485 SourceLocation WhileLoc, SourceLocation LParenLoc,
1486 Expr *Cond, SourceLocation RParenLoc) {
1487 return getSema().ActOnDoStmt(DoLoc, Body, WhileLoc, LParenLoc,
1488 Cond, RParenLoc);
1489 }
1490
1491 /// Build a new for statement.
1492 ///
1493 /// By default, performs semantic analysis to build the new statement.
1494 /// Subclasses may override this routine to provide different behavior.
1495 StmtResult RebuildForStmt(SourceLocation ForLoc, SourceLocation LParenLoc,
1496 Stmt *Init, Sema::ConditionResult Cond,
1497 Sema::FullExprArg Inc, SourceLocation RParenLoc,
1498 Stmt *Body) {
1499 return getSema().ActOnForStmt(ForLoc, LParenLoc, Init, Cond,
1500 Inc, RParenLoc, Body);
1501 }
1502
1503 /// Build a new goto statement.
1504 ///
1505 /// By default, performs semantic analysis to build the new statement.
1506 /// Subclasses may override this routine to provide different behavior.
1507 StmtResult RebuildGotoStmt(SourceLocation GotoLoc, SourceLocation LabelLoc,
1508 LabelDecl *Label) {
1509 return getSema().ActOnGotoStmt(GotoLoc, LabelLoc, Label);
1510 }
1511
1512 /// Build a new indirect goto statement.
1513 ///
1514 /// By default, performs semantic analysis to build the new statement.
1515 /// Subclasses may override this routine to provide different behavior.
1516 StmtResult RebuildIndirectGotoStmt(SourceLocation GotoLoc,
1517 SourceLocation StarLoc,
1518 Expr *Target) {
1519 return getSema().ActOnIndirectGotoStmt(GotoLoc, StarLoc, Target);
1520 }
1521
1522 /// Build a new return statement.
1523 ///
1524 /// By default, performs semantic analysis to build the new statement.
1525 /// Subclasses may override this routine to provide different behavior.
1526 StmtResult RebuildReturnStmt(SourceLocation ReturnLoc, Expr *Result) {
1527 return getSema().BuildReturnStmt(ReturnLoc, Result);
1528 }
1529
1530 /// Build a new declaration statement.
1531 ///
1532 /// By default, performs semantic analysis to build the new statement.
1533 /// Subclasses may override this routine to provide different behavior.
1534 StmtResult RebuildDeclStmt(MutableArrayRef<Decl *> Decls,
1535 SourceLocation StartLoc, SourceLocation EndLoc) {
1536 Sema::DeclGroupPtrTy DG = getSema().BuildDeclaratorGroup(Decls);
1537 return getSema().ActOnDeclStmt(DG, StartLoc, EndLoc);
1538 }
1539
1540 /// Build a new inline asm statement.
1541 ///
1542 /// By default, performs semantic analysis to build the new statement.
1543 /// Subclasses may override this routine to provide different behavior.
1544 StmtResult RebuildGCCAsmStmt(SourceLocation AsmLoc, bool IsSimple,
1545 bool IsVolatile, unsigned NumOutputs,
1546 unsigned NumInputs, IdentifierInfo **Names,
1547 MultiExprArg Constraints, MultiExprArg Exprs,
1548 Expr *AsmString, MultiExprArg Clobbers,
1549 unsigned NumLabels,
1550 SourceLocation RParenLoc) {
1551 return getSema().ActOnGCCAsmStmt(AsmLoc, IsSimple, IsVolatile, NumOutputs,
1552 NumInputs, Names, Constraints, Exprs,
1553 AsmString, Clobbers, NumLabels, RParenLoc);
1554 }
1555
1556 /// Build a new MS style inline asm statement.
1557 ///
1558 /// By default, performs semantic analysis to build the new statement.
1559 /// Subclasses may override this routine to provide different behavior.
1560 StmtResult RebuildMSAsmStmt(SourceLocation AsmLoc, SourceLocation LBraceLoc,
1561 ArrayRef<Token> AsmToks,
1562 StringRef AsmString,
1563 unsigned NumOutputs, unsigned NumInputs,
1564 ArrayRef<StringRef> Constraints,
1565 ArrayRef<StringRef> Clobbers,
1566 ArrayRef<Expr*> Exprs,
1567 SourceLocation EndLoc) {
1568 return getSema().ActOnMSAsmStmt(AsmLoc, LBraceLoc, AsmToks, AsmString,
1569 NumOutputs, NumInputs,
1570 Constraints, Clobbers, Exprs, EndLoc);
1571 }
1572
1573 /// Build a new co_return statement.
1574 ///
1575 /// By default, performs semantic analysis to build the new statement.
1576 /// Subclasses may override this routine to provide different behavior.
1577 StmtResult RebuildCoreturnStmt(SourceLocation CoreturnLoc, Expr *Result,
1578 bool IsImplicit) {
1579 return getSema().BuildCoreturnStmt(CoreturnLoc, Result, IsImplicit);
1580 }
1581
1582 /// Build a new co_await expression.
1583 ///
1584 /// By default, performs semantic analysis to build the new expression.
1585 /// Subclasses may override this routine to provide different behavior.
1586 ExprResult RebuildCoawaitExpr(SourceLocation CoawaitLoc, Expr *Operand,
1587 UnresolvedLookupExpr *OpCoawaitLookup,
1588 bool IsImplicit) {
1589 // This function rebuilds a coawait-expr given its operator.
1590 // For an explicit coawait-expr, the rebuild involves the full set
1591 // of transformations performed by BuildUnresolvedCoawaitExpr(),
1592 // including calling await_transform().
1593 // For an implicit coawait-expr, we need to rebuild the "operator
1594 // coawait" but not await_transform(), so use BuildResolvedCoawaitExpr().
1595 // This mirrors how the implicit CoawaitExpr is originally created
1596 // in Sema::ActOnCoroutineBodyStart().
1597 if (IsImplicit) {
1598 ExprResult Suspend = getSema().BuildOperatorCoawaitCall(
1599 CoawaitLoc, Operand, OpCoawaitLookup);
1600 if (Suspend.isInvalid())
1601 return ExprError();
1602 return getSema().BuildResolvedCoawaitExpr(CoawaitLoc, Operand,
1603 Suspend.get(), true);
1604 }
1605
1606 return getSema().BuildUnresolvedCoawaitExpr(CoawaitLoc, Operand,
1607 OpCoawaitLookup);
1608 }
1609
1610 /// Build a new co_await expression.
1611 ///
1612 /// By default, performs semantic analysis to build the new expression.
1613 /// Subclasses may override this routine to provide different behavior.
1614 ExprResult RebuildDependentCoawaitExpr(SourceLocation CoawaitLoc,
1615 Expr *Result,
1616 UnresolvedLookupExpr *Lookup) {
1617 return getSema().BuildUnresolvedCoawaitExpr(CoawaitLoc, Result, Lookup);
1618 }
1619
1620 /// Build a new co_yield expression.
1621 ///
1622 /// By default, performs semantic analysis to build the new expression.
1623 /// Subclasses may override this routine to provide different behavior.
1624 ExprResult RebuildCoyieldExpr(SourceLocation CoyieldLoc, Expr *Result) {
1625 return getSema().BuildCoyieldExpr(CoyieldLoc, Result);
1626 }
1627
1628 StmtResult RebuildCoroutineBodyStmt(CoroutineBodyStmt::CtorArgs Args) {
1629 return getSema().BuildCoroutineBodyStmt(Args);
1630 }
1631
1632 /// Build a new Objective-C \@try statement.
1633 ///
1634 /// By default, performs semantic analysis to build the new statement.
1635 /// Subclasses may override this routine to provide different behavior.
1636 StmtResult RebuildObjCAtTryStmt(SourceLocation AtLoc,
1637 Stmt *TryBody,
1638 MultiStmtArg CatchStmts,
1639 Stmt *Finally) {
1640 return getSema().ObjC().ActOnObjCAtTryStmt(AtLoc, TryBody, CatchStmts,
1641 Finally);
1642 }
1643
1644 /// Rebuild an Objective-C exception declaration.
1645 ///
1646 /// By default, performs semantic analysis to build the new declaration.
1647 /// Subclasses may override this routine to provide different behavior.
1648 VarDecl *RebuildObjCExceptionDecl(VarDecl *ExceptionDecl,
1649 TypeSourceInfo *TInfo, QualType T) {
1650 return getSema().ObjC().BuildObjCExceptionDecl(
1651 TInfo, T, ExceptionDecl->getInnerLocStart(),
1652 ExceptionDecl->getLocation(), ExceptionDecl->getIdentifier());
1653 }
1654
1655 /// Build a new Objective-C \@catch statement.
1656 ///
1657 /// By default, performs semantic analysis to build the new statement.
1658 /// Subclasses may override this routine to provide different behavior.
1659 StmtResult RebuildObjCAtCatchStmt(SourceLocation AtLoc,
1660 SourceLocation RParenLoc,
1661 VarDecl *Var,
1662 Stmt *Body) {
1663 return getSema().ObjC().ActOnObjCAtCatchStmt(AtLoc, RParenLoc, Var, Body);
1664 }
1665
1666 /// Build a new Objective-C \@finally statement.
1667 ///
1668 /// By default, performs semantic analysis to build the new statement.
1669 /// Subclasses may override this routine to provide different behavior.
1670 StmtResult RebuildObjCAtFinallyStmt(SourceLocation AtLoc,
1671 Stmt *Body) {
1672 return getSema().ObjC().ActOnObjCAtFinallyStmt(AtLoc, Body);
1673 }
1674
1675 /// Build a new Objective-C \@throw statement.
1676 ///
1677 /// By default, performs semantic analysis to build the new statement.
1678 /// Subclasses may override this routine to provide different behavior.
1679 StmtResult RebuildObjCAtThrowStmt(SourceLocation AtLoc,
1680 Expr *Operand) {
1681 return getSema().ObjC().BuildObjCAtThrowStmt(AtLoc, Operand);
1682 }
1683
1684 /// Build a new OpenMP Canonical loop.
1685 ///
1686 /// Ensures that the outermost loop in @p LoopStmt is wrapped by a
1687 /// OMPCanonicalLoop.
1688 StmtResult RebuildOMPCanonicalLoop(Stmt *LoopStmt) {
1689 return getSema().OpenMP().ActOnOpenMPCanonicalLoop(LoopStmt);
1690 }
1691
1692 /// Build a new OpenMP executable directive.
1693 ///
1694 /// By default, performs semantic analysis to build the new statement.
1695 /// Subclasses may override this routine to provide different behavior.
1696 StmtResult RebuildOMPExecutableDirective(OpenMPDirectiveKind Kind,
1697 DeclarationNameInfo DirName,
1698 OpenMPDirectiveKind CancelRegion,
1699 ArrayRef<OMPClause *> Clauses,
1700 Stmt *AStmt, SourceLocation StartLoc,
1701 SourceLocation EndLoc) {
1702
1703 return getSema().OpenMP().ActOnOpenMPExecutableDirective(
1704 Kind, DirName, CancelRegion, Clauses, AStmt, StartLoc, EndLoc);
1705 }
1706
1707 /// Build a new OpenMP metadirective.
1708 ///
1709 /// By default, performs semantic analysis to build the new statement.
1710 /// Subclasses may override this routine to provide different behavior.
1711 StmtResult RebuildOMPMetaDirective(SourceLocation StartLoc,
1712 SourceLocation EndLoc,
1713 ArrayRef<OMPTraitInfo *> TraitInfos,
1714 ArrayRef<Stmt *> Variants) {
1715 return getSema().OpenMP().ActOnOpenMPMetaDirective(StartLoc, EndLoc,
1716 TraitInfos, Variants);
1717 }
1718
1719 /// Build a new OpenMP informational directive.
1720 StmtResult RebuildOMPInformationalDirective(OpenMPDirectiveKind Kind,
1721 DeclarationNameInfo DirName,
1722 ArrayRef<OMPClause *> Clauses,
1723 Stmt *AStmt,
1724 SourceLocation StartLoc,
1725 SourceLocation EndLoc) {
1726
1727 return getSema().OpenMP().ActOnOpenMPInformationalDirective(
1728 Kind, DirName, Clauses, AStmt, StartLoc, EndLoc);
1729 }
1730
1731 /// Build a new OpenMP 'if' clause.
1732 ///
1733 /// By default, performs semantic analysis to build the new OpenMP clause.
1734 /// Subclasses may override this routine to provide different behavior.
1735 OMPClause *RebuildOMPIfClause(OpenMPDirectiveKind NameModifier,
1736 Expr *Condition, SourceLocation StartLoc,
1737 SourceLocation LParenLoc,
1738 SourceLocation NameModifierLoc,
1739 SourceLocation ColonLoc,
1740 SourceLocation EndLoc) {
1741 return getSema().OpenMP().ActOnOpenMPIfClause(
1742 NameModifier, Condition, StartLoc, LParenLoc, NameModifierLoc, ColonLoc,
1743 EndLoc);
1744 }
1745
1746 /// Build a new OpenMP 'final' clause.
1747 ///
1748 /// By default, performs semantic analysis to build the new OpenMP clause.
1749 /// Subclasses may override this routine to provide different behavior.
1750 OMPClause *RebuildOMPFinalClause(Expr *Condition, SourceLocation StartLoc,
1751 SourceLocation LParenLoc,
1752 SourceLocation EndLoc) {
1753 return getSema().OpenMP().ActOnOpenMPFinalClause(Condition, StartLoc,
1754 LParenLoc, EndLoc);
1755 }
1756
1757 /// Build a new OpenMP 'num_threads' clause.
1758 ///
1759 /// By default, performs semantic analysis to build the new OpenMP clause.
1760 /// Subclasses may override this routine to provide different behavior.
1761 OMPClause *RebuildOMPNumThreadsClause(
1762 ArrayRef<Expr *> VarList,
1763 OpenMPNumThreadsClauseModifier PrescriptivenessModifier,
1764 SourceLocation PrescriptivenessModifierLoc,
1765 OpenMPNumThreadsClauseModifier DimsModifier, Expr *DimsModifierExpr,
1766 SourceLocation DimsModifierLoc, SourceLocation StartLoc,
1767 SourceLocation LParenLoc, SourceLocation EndLoc) {
1768 return getSema().OpenMP().ActOnOpenMPNumThreadsClause(
1769 VarList, PrescriptivenessModifier, PrescriptivenessModifierLoc,
1770 DimsModifier, DimsModifierExpr, DimsModifierLoc, StartLoc, LParenLoc,
1771 EndLoc);
1772 }
1773
1774 /// Build a new OpenMP 'safelen' clause.
1775 ///
1776 /// By default, performs semantic analysis to build the new OpenMP clause.
1777 /// Subclasses may override this routine to provide different behavior.
1778 OMPClause *RebuildOMPSafelenClause(Expr *Len, SourceLocation StartLoc,
1779 SourceLocation LParenLoc,
1780 SourceLocation EndLoc) {
1781 return getSema().OpenMP().ActOnOpenMPSafelenClause(Len, StartLoc, LParenLoc,
1782 EndLoc);
1783 }
1784
1785 /// Build a new OpenMP 'simdlen' clause.
1786 ///
1787 /// By default, performs semantic analysis to build the new OpenMP clause.
1788 /// Subclasses may override this routine to provide different behavior.
1789 OMPClause *RebuildOMPSimdlenClause(Expr *Len, SourceLocation StartLoc,
1790 SourceLocation LParenLoc,
1791 SourceLocation EndLoc) {
1792 return getSema().OpenMP().ActOnOpenMPSimdlenClause(Len, StartLoc, LParenLoc,
1793 EndLoc);
1794 }
1795
1796 OMPClause *RebuildOMPSizesClause(ArrayRef<Expr *> Sizes,
1797 SourceLocation StartLoc,
1798 SourceLocation LParenLoc,
1799 SourceLocation EndLoc) {
1800 return getSema().OpenMP().ActOnOpenMPSizesClause(Sizes, StartLoc, LParenLoc,
1801 EndLoc);
1802 }
1803
1804 OMPClause *RebuildOMPCountsClause(ArrayRef<Expr *> Counts,
1805 SourceLocation StartLoc,
1806 SourceLocation LParenLoc,
1807 SourceLocation EndLoc,
1808 std::optional<unsigned> FillIdx,
1809 SourceLocation FillLoc) {
1810 unsigned FillCount = FillIdx ? 1 : 0;
1811 return getSema().OpenMP().ActOnOpenMPCountsClause(
1812 Counts, StartLoc, LParenLoc, EndLoc, FillIdx, FillLoc, FillCount);
1813 }
1814
1815 /// Build a new OpenMP 'permutation' clause.
1816 OMPClause *RebuildOMPPermutationClause(ArrayRef<Expr *> PermExprs,
1817 SourceLocation StartLoc,
1818 SourceLocation LParenLoc,
1819 SourceLocation EndLoc) {
1820 return getSema().OpenMP().ActOnOpenMPPermutationClause(PermExprs, StartLoc,
1821 LParenLoc, EndLoc);
1822 }
1823
1824 /// Build a new OpenMP 'full' clause.
1825 OMPClause *RebuildOMPFullClause(SourceLocation StartLoc,
1826 SourceLocation EndLoc) {
1827 return getSema().OpenMP().ActOnOpenMPFullClause(StartLoc, EndLoc);
1828 }
1829
1830 /// Build a new OpenMP 'partial' clause.
1831 OMPClause *RebuildOMPPartialClause(Expr *Factor, SourceLocation StartLoc,
1832 SourceLocation LParenLoc,
1833 SourceLocation EndLoc) {
1834 return getSema().OpenMP().ActOnOpenMPPartialClause(Factor, StartLoc,
1835 LParenLoc, EndLoc);
1836 }
1837
1838 /// Build a new OpenMP 'depth' clause.
1839 OMPClause *RebuildOMPDepthClause(Expr *Depth, SourceLocation StartLoc,
1840 SourceLocation LParenLoc,
1841 SourceLocation EndLoc) {
1842 return getSema().OpenMP().ActOnOpenMPDepthClause(Depth, StartLoc, LParenLoc,
1843 EndLoc);
1844 }
1845
1846 OMPClause *
1847 RebuildOMPLoopRangeClause(Expr *First, Expr *Count, SourceLocation StartLoc,
1848 SourceLocation LParenLoc, SourceLocation FirstLoc,
1849 SourceLocation CountLoc, SourceLocation EndLoc) {
1850 return getSema().OpenMP().ActOnOpenMPLoopRangeClause(
1851 First, Count, StartLoc, LParenLoc, FirstLoc, CountLoc, EndLoc);
1852 }
1853
1854 /// Build a new OpenMP 'allocator' clause.
1855 ///
1856 /// By default, performs semantic analysis to build the new OpenMP clause.
1857 /// Subclasses may override this routine to provide different behavior.
1858 OMPClause *RebuildOMPAllocatorClause(Expr *A, SourceLocation StartLoc,
1859 SourceLocation LParenLoc,
1860 SourceLocation EndLoc) {
1861 return getSema().OpenMP().ActOnOpenMPAllocatorClause(A, StartLoc, LParenLoc,
1862 EndLoc);
1863 }
1864
1865 /// Build a new OpenMP 'collapse' clause.
1866 ///
1867 /// By default, performs semantic analysis to build the new OpenMP clause.
1868 /// Subclasses may override this routine to provide different behavior.
1869 OMPClause *RebuildOMPCollapseClause(Expr *Num, SourceLocation StartLoc,
1870 SourceLocation LParenLoc,
1871 SourceLocation EndLoc) {
1872 return getSema().OpenMP().ActOnOpenMPCollapseClause(Num, StartLoc,
1873 LParenLoc, EndLoc);
1874 }
1875
1876 /// Build a new OpenMP 'default' clause.
1877 ///
1878 /// By default, performs semantic analysis to build the new OpenMP clause.
1879 /// Subclasses may override this routine to provide different behavior.
1880 OMPClause *RebuildOMPDefaultClause(DefaultKind Kind, SourceLocation KindKwLoc,
1881 OpenMPDefaultClauseVariableCategory VCKind,
1882 SourceLocation VCLoc,
1883 SourceLocation StartLoc,
1884 SourceLocation LParenLoc,
1885 SourceLocation EndLoc) {
1886 return getSema().OpenMP().ActOnOpenMPDefaultClause(
1887 Kind, KindKwLoc, VCKind, VCLoc, StartLoc, LParenLoc, EndLoc);
1888 }
1889
1890 /// Build a new OpenMP 'proc_bind' clause.
1891 ///
1892 /// By default, performs semantic analysis to build the new OpenMP clause.
1893 /// Subclasses may override this routine to provide different behavior.
1894 OMPClause *RebuildOMPProcBindClause(ProcBindKind Kind,
1895 SourceLocation KindKwLoc,
1896 SourceLocation StartLoc,
1897 SourceLocation LParenLoc,
1898 SourceLocation EndLoc) {
1899 return getSema().OpenMP().ActOnOpenMPProcBindClause(
1900 Kind, KindKwLoc, StartLoc, LParenLoc, EndLoc);
1901 }
1902 OMPClause *RebuildOMPTransparentClause(Expr *ImpexTypeArg,
1903 SourceLocation StartLoc,
1904 SourceLocation LParenLoc,
1905 SourceLocation EndLoc) {
1906 return getSema().OpenMP().ActOnOpenMPTransparentClause(
1907 ImpexTypeArg, StartLoc, LParenLoc, EndLoc);
1908 }
1909
1910 /// Build a new OpenMP 'schedule' clause.
1911 ///
1912 /// By default, performs semantic analysis to build the new OpenMP clause.
1913 /// Subclasses may override this routine to provide different behavior.
1914 OMPClause *RebuildOMPScheduleClause(
1915 OpenMPScheduleClauseModifier M1, OpenMPScheduleClauseModifier M2,
1916 OpenMPScheduleClauseKind Kind, Expr *ChunkSize, SourceLocation StartLoc,
1917 SourceLocation LParenLoc, SourceLocation M1Loc, SourceLocation M2Loc,
1918 SourceLocation KindLoc, SourceLocation CommaLoc, SourceLocation EndLoc) {
1919 return getSema().OpenMP().ActOnOpenMPScheduleClause(
1920 M1, M2, Kind, ChunkSize, StartLoc, LParenLoc, M1Loc, M2Loc, KindLoc,
1921 CommaLoc, EndLoc);
1922 }
1923
1924 /// Build a new OpenMP 'ordered' clause.
1925 ///
1926 /// By default, performs semantic analysis to build the new OpenMP clause.
1927 /// Subclasses may override this routine to provide different behavior.
1928 OMPClause *RebuildOMPOrderedClause(SourceLocation StartLoc,
1929 SourceLocation EndLoc,
1930 SourceLocation LParenLoc, Expr *Num) {
1931 return getSema().OpenMP().ActOnOpenMPOrderedClause(StartLoc, EndLoc,
1932 LParenLoc, Num);
1933 }
1934
1935 /// Build a new OpenMP 'nowait' clause.
1936 ///
1937 /// By default, performs semantic analysis to build the new OpenMP clause.
1938 /// Subclasses may override this routine to provide different behavior.
1939 OMPClause *RebuildOMPNowaitClause(Expr *Condition, SourceLocation StartLoc,
1940 SourceLocation LParenLoc,
1941 SourceLocation EndLoc) {
1942 return getSema().OpenMP().ActOnOpenMPNowaitClause(StartLoc, EndLoc,
1943 LParenLoc, Condition);
1944 }
1945
1946 /// Build a new OpenMP 'private' clause.
1947 ///
1948 /// By default, performs semantic analysis to build the new OpenMP clause.
1949 /// Subclasses may override this routine to provide different behavior.
1950 OMPClause *RebuildOMPPrivateClause(ArrayRef<Expr *> VarList,
1951 SourceLocation StartLoc,
1952 SourceLocation LParenLoc,
1953 SourceLocation EndLoc) {
1954 return getSema().OpenMP().ActOnOpenMPPrivateClause(VarList, StartLoc,
1955 LParenLoc, EndLoc);
1956 }
1957
1958 /// Build a new OpenMP 'firstprivate' clause.
1959 ///
1960 /// By default, performs semantic analysis to build the new OpenMP clause.
1961 /// Subclasses may override this routine to provide different behavior.
1962 OMPClause *RebuildOMPFirstprivateClause(ArrayRef<Expr *> VarList,
1963 SourceLocation StartLoc,
1964 SourceLocation LParenLoc,
1965 SourceLocation EndLoc) {
1966 return getSema().OpenMP().ActOnOpenMPFirstprivateClause(VarList, StartLoc,
1967 LParenLoc, EndLoc);
1968 }
1969
1970 /// Build a new OpenMP 'lastprivate' clause.
1971 ///
1972 /// By default, performs semantic analysis to build the new OpenMP clause.
1973 /// Subclasses may override this routine to provide different behavior.
1974 OMPClause *RebuildOMPLastprivateClause(ArrayRef<Expr *> VarList,
1975 OpenMPLastprivateModifier LPKind,
1976 SourceLocation LPKindLoc,
1977 SourceLocation ColonLoc,
1978 SourceLocation StartLoc,
1979 SourceLocation LParenLoc,
1980 SourceLocation EndLoc) {
1981 return getSema().OpenMP().ActOnOpenMPLastprivateClause(
1982 VarList, LPKind, LPKindLoc, ColonLoc, StartLoc, LParenLoc, EndLoc);
1983 }
1984
1985 /// Build a new OpenMP 'shared' clause.
1986 ///
1987 /// By default, performs semantic analysis to build the new OpenMP clause.
1988 /// Subclasses may override this routine to provide different behavior.
1989 OMPClause *RebuildOMPSharedClause(ArrayRef<Expr *> VarList,
1990 SourceLocation StartLoc,
1991 SourceLocation LParenLoc,
1992 SourceLocation EndLoc) {
1993 return getSema().OpenMP().ActOnOpenMPSharedClause(VarList, StartLoc,
1994 LParenLoc, EndLoc);
1995 }
1996
1997 /// Build a new OpenMP 'reduction' clause.
1998 ///
1999 /// By default, performs semantic analysis to build the new statement.
2000 /// Subclasses may override this routine to provide different behavior.
2001 OMPClause *RebuildOMPReductionClause(
2002 ArrayRef<Expr *> VarList, OpenMPReductionClauseModifier Modifier,
2003 OpenMPOriginalSharingModifier OriginalSharingModifier,
2004 SourceLocation StartLoc, SourceLocation LParenLoc,
2005 SourceLocation ModifierLoc, SourceLocation ColonLoc,
2006 SourceLocation EndLoc, CXXScopeSpec &ReductionIdScopeSpec,
2007 const DeclarationNameInfo &ReductionId,
2008 ArrayRef<Expr *> UnresolvedReductions) {
2009 return getSema().OpenMP().ActOnOpenMPReductionClause(
2010 VarList, {Modifier, OriginalSharingModifier}, StartLoc, LParenLoc,
2011 ModifierLoc, ColonLoc, EndLoc, ReductionIdScopeSpec, ReductionId,
2012 UnresolvedReductions);
2013 }
2014
2015 /// Build a new OpenMP 'task_reduction' clause.
2016 ///
2017 /// By default, performs semantic analysis to build the new statement.
2018 /// Subclasses may override this routine to provide different behavior.
2019 OMPClause *RebuildOMPTaskReductionClause(
2020 ArrayRef<Expr *> VarList, SourceLocation StartLoc,
2021 SourceLocation LParenLoc, SourceLocation ColonLoc, SourceLocation EndLoc,
2022 CXXScopeSpec &ReductionIdScopeSpec,
2023 const DeclarationNameInfo &ReductionId,
2024 ArrayRef<Expr *> UnresolvedReductions) {
2025 return getSema().OpenMP().ActOnOpenMPTaskReductionClause(
2026 VarList, StartLoc, LParenLoc, ColonLoc, EndLoc, ReductionIdScopeSpec,
2027 ReductionId, UnresolvedReductions);
2028 }
2029
2030 /// Build a new OpenMP 'in_reduction' clause.
2031 ///
2032 /// By default, performs semantic analysis to build the new statement.
2033 /// Subclasses may override this routine to provide different behavior.
2034 OMPClause *
2035 RebuildOMPInReductionClause(ArrayRef<Expr *> VarList, SourceLocation StartLoc,
2036 SourceLocation LParenLoc, SourceLocation ColonLoc,
2037 SourceLocation EndLoc,
2038 CXXScopeSpec &ReductionIdScopeSpec,
2039 const DeclarationNameInfo &ReductionId,
2040 ArrayRef<Expr *> UnresolvedReductions) {
2041 return getSema().OpenMP().ActOnOpenMPInReductionClause(
2042 VarList, StartLoc, LParenLoc, ColonLoc, EndLoc, ReductionIdScopeSpec,
2043 ReductionId, UnresolvedReductions);
2044 }
2045
2046 /// Build a new OpenMP 'linear' clause.
2047 ///
2048 /// By default, performs semantic analysis to build the new OpenMP clause.
2049 /// Subclasses may override this routine to provide different behavior.
2050 OMPClause *RebuildOMPLinearClause(
2051 ArrayRef<Expr *> VarList, Expr *Step, SourceLocation StartLoc,
2052 SourceLocation LParenLoc, OpenMPLinearClauseKind Modifier,
2053 SourceLocation ModifierLoc, SourceLocation ColonLoc,
2054 SourceLocation StepModifierLoc, SourceLocation EndLoc) {
2055 return getSema().OpenMP().ActOnOpenMPLinearClause(
2056 VarList, Step, StartLoc, LParenLoc, Modifier, ModifierLoc, ColonLoc,
2057 StepModifierLoc, EndLoc);
2058 }
2059
2060 /// Build a new OpenMP 'aligned' clause.
2061 ///
2062 /// By default, performs semantic analysis to build the new OpenMP clause.
2063 /// Subclasses may override this routine to provide different behavior.
2064 OMPClause *RebuildOMPAlignedClause(ArrayRef<Expr *> VarList, Expr *Alignment,
2065 SourceLocation StartLoc,
2066 SourceLocation LParenLoc,
2067 SourceLocation ColonLoc,
2068 SourceLocation EndLoc) {
2069 return getSema().OpenMP().ActOnOpenMPAlignedClause(
2070 VarList, Alignment, StartLoc, LParenLoc, ColonLoc, EndLoc);
2071 }
2072
2073 /// Build a new OpenMP 'copyin' clause.
2074 ///
2075 /// By default, performs semantic analysis to build the new OpenMP clause.
2076 /// Subclasses may override this routine to provide different behavior.
2077 OMPClause *RebuildOMPCopyinClause(ArrayRef<Expr *> VarList,
2078 SourceLocation StartLoc,
2079 SourceLocation LParenLoc,
2080 SourceLocation EndLoc) {
2081 return getSema().OpenMP().ActOnOpenMPCopyinClause(VarList, StartLoc,
2082 LParenLoc, EndLoc);
2083 }
2084
2085 /// Build a new OpenMP 'copyprivate' clause.
2086 ///
2087 /// By default, performs semantic analysis to build the new OpenMP clause.
2088 /// Subclasses may override this routine to provide different behavior.
2089 OMPClause *RebuildOMPCopyprivateClause(ArrayRef<Expr *> VarList,
2090 SourceLocation StartLoc,
2091 SourceLocation LParenLoc,
2092 SourceLocation EndLoc) {
2093 return getSema().OpenMP().ActOnOpenMPCopyprivateClause(VarList, StartLoc,
2094 LParenLoc, EndLoc);
2095 }
2096
2097 /// Build a new OpenMP 'flush' pseudo clause.
2098 ///
2099 /// By default, performs semantic analysis to build the new OpenMP clause.
2100 /// Subclasses may override this routine to provide different behavior.
2101 OMPClause *RebuildOMPFlushClause(ArrayRef<Expr *> VarList,
2102 SourceLocation StartLoc,
2103 SourceLocation LParenLoc,
2104 SourceLocation EndLoc) {
2105 return getSema().OpenMP().ActOnOpenMPFlushClause(VarList, StartLoc,
2106 LParenLoc, EndLoc);
2107 }
2108
2109 /// Build a new OpenMP 'depobj' pseudo clause.
2110 ///
2111 /// By default, performs semantic analysis to build the new OpenMP clause.
2112 /// Subclasses may override this routine to provide different behavior.
2113 OMPClause *RebuildOMPDepobjClause(Expr *Depobj, SourceLocation StartLoc,
2114 SourceLocation LParenLoc,
2115 SourceLocation EndLoc) {
2116 return getSema().OpenMP().ActOnOpenMPDepobjClause(Depobj, StartLoc,
2117 LParenLoc, EndLoc);
2118 }
2119
2120 /// Build a new OpenMP 'depend' pseudo clause.
2121 ///
2122 /// By default, performs semantic analysis to build the new OpenMP clause.
2123 /// Subclasses may override this routine to provide different behavior.
2124 OMPClause *RebuildOMPDependClause(OMPDependClause::DependDataTy Data,
2125 Expr *DepModifier, ArrayRef<Expr *> VarList,
2126 SourceLocation StartLoc,
2127 SourceLocation LParenLoc,
2128 SourceLocation EndLoc) {
2129 return getSema().OpenMP().ActOnOpenMPDependClause(
2130 Data, DepModifier, VarList, StartLoc, LParenLoc, EndLoc);
2131 }
2132
2133 /// Build a new OpenMP 'device' clause.
2134 ///
2135 /// By default, performs semantic analysis to build the new statement.
2136 /// Subclasses may override this routine to provide different behavior.
2137 OMPClause *RebuildOMPDeviceClause(OpenMPDeviceClauseModifier Modifier,
2138 Expr *Device, SourceLocation StartLoc,
2139 SourceLocation LParenLoc,
2140 SourceLocation ModifierLoc,
2141 SourceLocation EndLoc) {
2142 return getSema().OpenMP().ActOnOpenMPDeviceClause(
2143 Modifier, Device, StartLoc, LParenLoc, ModifierLoc, EndLoc);
2144 }
2145
2146 /// Build a new OpenMP 'map' clause.
2147 ///
2148 /// By default, performs semantic analysis to build the new OpenMP clause.
2149 /// Subclasses may override this routine to provide different behavior.
2150 OMPClause *RebuildOMPMapClause(
2151 Expr *IteratorModifier, ArrayRef<OpenMPMapModifierKind> MapTypeModifiers,
2152 ArrayRef<SourceLocation> MapTypeModifiersLoc,
2153 CXXScopeSpec MapperIdScopeSpec, DeclarationNameInfo MapperId,
2154 OpenMPMapClauseKind MapType, bool IsMapTypeImplicit,
2155 SourceLocation MapLoc, SourceLocation ColonLoc, ArrayRef<Expr *> VarList,
2156 const OMPVarListLocTy &Locs, ArrayRef<Expr *> UnresolvedMappers) {
2157 return getSema().OpenMP().ActOnOpenMPMapClause(
2158 IteratorModifier, MapTypeModifiers, MapTypeModifiersLoc,
2159 MapperIdScopeSpec, MapperId, MapType, IsMapTypeImplicit, MapLoc,
2160 ColonLoc, VarList, Locs,
2161 /*NoDiagnose=*/false, UnresolvedMappers);
2162 }
2163
2164 /// Build a new OpenMP 'allocate' clause.
2165 ///
2166 /// By default, performs semantic analysis to build the new OpenMP clause.
2167 /// Subclasses may override this routine to provide different behavior.
2168 OMPClause *
2169 RebuildOMPAllocateClause(Expr *Allocate, Expr *Alignment,
2170 OpenMPAllocateClauseModifier FirstModifier,
2171 SourceLocation FirstModifierLoc,
2172 OpenMPAllocateClauseModifier SecondModifier,
2173 SourceLocation SecondModifierLoc,
2174 ArrayRef<Expr *> VarList, SourceLocation StartLoc,
2175 SourceLocation LParenLoc, SourceLocation ColonLoc,
2176 SourceLocation EndLoc) {
2177 return getSema().OpenMP().ActOnOpenMPAllocateClause(
2178 Allocate, Alignment, FirstModifier, FirstModifierLoc, SecondModifier,
2179 SecondModifierLoc, VarList, StartLoc, LParenLoc, ColonLoc, EndLoc);
2180 }
2181
2182 /// Build a new OpenMP 'num_teams' clause.
2183 ///
2184 /// By default, performs semantic analysis to build the new statement.
2185 /// Subclasses may override this routine to provide different behavior.
2186 OMPClause *RebuildOMPNumTeamsClause(
2187 ArrayRef<Expr *> VarList, OpenMPNumTeamsClauseModifier Modifier,
2188 Expr *ModifierExpr, SourceLocation ModifierLoc,
2189 OpenMPNumTeamsClauseModifier ModifierExtra, Expr *ModifierExtraExpr,
2190 SourceLocation ModifierExtraLoc, SourceLocation StartLoc,
2191 SourceLocation LParenLoc, SourceLocation EndLoc) {
2192 return getSema().OpenMP().ActOnOpenMPNumTeamsClause(
2193 VarList, Modifier, ModifierExpr, ModifierLoc, ModifierExtra,
2194 ModifierExtraExpr, ModifierExtraLoc, StartLoc, LParenLoc, EndLoc);
2195 }
2196
2197 /// Build a new OpenMP 'thread_limit' clause.
2198 ///
2199 /// By default, performs semantic analysis to build the new statement.
2200 /// Subclasses may override this routine to provide different behavior.
2201 OMPClause *RebuildOMPThreadLimitClause(
2202 ArrayRef<Expr *> VarList, OpenMPThreadLimitClauseModifier Modifier,
2203 Expr *ModifierExpr, SourceLocation ModifierLoc, SourceLocation StartLoc,
2204 SourceLocation LParenLoc, SourceLocation EndLoc) {
2205 return getSema().OpenMP().ActOnOpenMPThreadLimitClause(
2206 VarList, Modifier, ModifierExpr, ModifierLoc, StartLoc, LParenLoc,
2207 EndLoc);
2208 }
2209
2210 /// Build a new OpenMP 'priority' clause.
2211 ///
2212 /// By default, performs semantic analysis to build the new statement.
2213 /// Subclasses may override this routine to provide different behavior.
2214 OMPClause *RebuildOMPPriorityClause(Expr *Priority, SourceLocation StartLoc,
2215 SourceLocation LParenLoc,
2216 SourceLocation EndLoc) {
2217 return getSema().OpenMP().ActOnOpenMPPriorityClause(Priority, StartLoc,
2218 LParenLoc, EndLoc);
2219 }
2220
2221 /// Build a new OpenMP 'grainsize' clause.
2222 ///
2223 /// By default, performs semantic analysis to build the new statement.
2224 /// Subclasses may override this routine to provide different behavior.
2225 OMPClause *RebuildOMPGrainsizeClause(OpenMPGrainsizeClauseModifier Modifier,
2226 Expr *Device, SourceLocation StartLoc,
2227 SourceLocation LParenLoc,
2228 SourceLocation ModifierLoc,
2229 SourceLocation EndLoc) {
2230 return getSema().OpenMP().ActOnOpenMPGrainsizeClause(
2231 Modifier, Device, StartLoc, LParenLoc, ModifierLoc, EndLoc);
2232 }
2233
2234 /// Build a new OpenMP 'num_tasks' clause.
2235 ///
2236 /// By default, performs semantic analysis to build the new statement.
2237 /// Subclasses may override this routine to provide different behavior.
2238 OMPClause *RebuildOMPNumTasksClause(OpenMPNumTasksClauseModifier Modifier,
2239 Expr *NumTasks, SourceLocation StartLoc,
2240 SourceLocation LParenLoc,
2241 SourceLocation ModifierLoc,
2242 SourceLocation EndLoc) {
2243 return getSema().OpenMP().ActOnOpenMPNumTasksClause(
2244 Modifier, NumTasks, StartLoc, LParenLoc, ModifierLoc, EndLoc);
2245 }
2246
2247 /// Build a new OpenMP 'hint' clause.
2248 ///
2249 /// By default, performs semantic analysis to build the new statement.
2250 /// Subclasses may override this routine to provide different behavior.
2251 OMPClause *RebuildOMPHintClause(Expr *Hint, SourceLocation StartLoc,
2252 SourceLocation LParenLoc,
2253 SourceLocation EndLoc) {
2254 return getSema().OpenMP().ActOnOpenMPHintClause(Hint, StartLoc, LParenLoc,
2255 EndLoc);
2256 }
2257
2258 /// Build a new OpenMP 'detach' clause.
2259 ///
2260 /// By default, performs semantic analysis to build the new statement.
2261 /// Subclasses may override this routine to provide different behavior.
2262 OMPClause *RebuildOMPDetachClause(Expr *Evt, SourceLocation StartLoc,
2263 SourceLocation LParenLoc,
2264 SourceLocation EndLoc) {
2265 return getSema().OpenMP().ActOnOpenMPDetachClause(Evt, StartLoc, LParenLoc,
2266 EndLoc);
2267 }
2268
2269 /// Build a new OpenMP 'dist_schedule' clause.
2270 ///
2271 /// By default, performs semantic analysis to build the new OpenMP clause.
2272 /// Subclasses may override this routine to provide different behavior.
2273 OMPClause *
2274 RebuildOMPDistScheduleClause(OpenMPDistScheduleClauseKind Kind,
2275 Expr *ChunkSize, SourceLocation StartLoc,
2276 SourceLocation LParenLoc, SourceLocation KindLoc,
2277 SourceLocation CommaLoc, SourceLocation EndLoc) {
2278 return getSema().OpenMP().ActOnOpenMPDistScheduleClause(
2279 Kind, ChunkSize, StartLoc, LParenLoc, KindLoc, CommaLoc, EndLoc);
2280 }
2281
2282 /// Build a new OpenMP 'to' clause.
2283 ///
2284 /// By default, performs semantic analysis to build the new statement.
2285 /// Subclasses may override this routine to provide different behavior.
2286 OMPClause *
2287 RebuildOMPToClause(ArrayRef<OpenMPMotionModifierKind> MotionModifiers,
2288 ArrayRef<SourceLocation> MotionModifiersLoc,
2289 Expr *IteratorModifier, CXXScopeSpec &MapperIdScopeSpec,
2290 DeclarationNameInfo &MapperId, SourceLocation ColonLoc,
2291 ArrayRef<Expr *> VarList, const OMPVarListLocTy &Locs,
2292 ArrayRef<Expr *> UnresolvedMappers) {
2293 return getSema().OpenMP().ActOnOpenMPToClause(
2294 MotionModifiers, MotionModifiersLoc, IteratorModifier,
2295 MapperIdScopeSpec, MapperId, ColonLoc, VarList, Locs,
2296 UnresolvedMappers);
2297 }
2298
2299 /// Build a new OpenMP 'from' clause.
2300 ///
2301 /// By default, performs semantic analysis to build the new statement.
2302 /// Subclasses may override this routine to provide different behavior.
2303 OMPClause *
2304 RebuildOMPFromClause(ArrayRef<OpenMPMotionModifierKind> MotionModifiers,
2305 ArrayRef<SourceLocation> MotionModifiersLoc,
2306 Expr *IteratorModifier, CXXScopeSpec &MapperIdScopeSpec,
2307 DeclarationNameInfo &MapperId, SourceLocation ColonLoc,
2308 ArrayRef<Expr *> VarList, const OMPVarListLocTy &Locs,
2309 ArrayRef<Expr *> UnresolvedMappers) {
2310 return getSema().OpenMP().ActOnOpenMPFromClause(
2311 MotionModifiers, MotionModifiersLoc, IteratorModifier,
2312 MapperIdScopeSpec, MapperId, ColonLoc, VarList, Locs,
2313 UnresolvedMappers);
2314 }
2315
2316 /// Build a new OpenMP 'use_device_ptr' clause.
2317 ///
2318 /// By default, performs semantic analysis to build the new OpenMP clause.
2319 /// Subclasses may override this routine to provide different behavior.
2320 OMPClause *RebuildOMPUseDevicePtrClause(
2321 ArrayRef<Expr *> VarList, const OMPVarListLocTy &Locs,
2322 OpenMPUseDevicePtrFallbackModifier FallbackModifier,
2323 SourceLocation FallbackModifierLoc) {
2324 return getSema().OpenMP().ActOnOpenMPUseDevicePtrClause(
2325 VarList, Locs, FallbackModifier, FallbackModifierLoc);
2326 }
2327
2328 /// Build a new OpenMP 'use_device_addr' clause.
2329 ///
2330 /// By default, performs semantic analysis to build the new OpenMP clause.
2331 /// Subclasses may override this routine to provide different behavior.
2332 OMPClause *RebuildOMPUseDeviceAddrClause(ArrayRef<Expr *> VarList,
2333 const OMPVarListLocTy &Locs) {
2334 return getSema().OpenMP().ActOnOpenMPUseDeviceAddrClause(VarList, Locs);
2335 }
2336
2337 /// Build a new OpenMP 'is_device_ptr' clause.
2338 ///
2339 /// By default, performs semantic analysis to build the new OpenMP clause.
2340 /// Subclasses may override this routine to provide different behavior.
2341 OMPClause *RebuildOMPIsDevicePtrClause(ArrayRef<Expr *> VarList,
2342 const OMPVarListLocTy &Locs) {
2343 return getSema().OpenMP().ActOnOpenMPIsDevicePtrClause(VarList, Locs);
2344 }
2345
2346 /// Build a new OpenMP 'has_device_addr' clause.
2347 ///
2348 /// By default, performs semantic analysis to build the new OpenMP clause.
2349 /// Subclasses may override this routine to provide different behavior.
2350 OMPClause *RebuildOMPHasDeviceAddrClause(ArrayRef<Expr *> VarList,
2351 const OMPVarListLocTy &Locs) {
2352 return getSema().OpenMP().ActOnOpenMPHasDeviceAddrClause(VarList, Locs);
2353 }
2354
2355 /// Build a new OpenMP 'defaultmap' clause.
2356 ///
2357 /// By default, performs semantic analysis to build the new OpenMP clause.
2358 /// Subclasses may override this routine to provide different behavior.
2359 OMPClause *RebuildOMPDefaultmapClause(OpenMPDefaultmapClauseModifier M,
2360 OpenMPDefaultmapClauseKind Kind,
2361 SourceLocation StartLoc,
2362 SourceLocation LParenLoc,
2363 SourceLocation MLoc,
2364 SourceLocation KindLoc,
2365 SourceLocation EndLoc) {
2366 return getSema().OpenMP().ActOnOpenMPDefaultmapClause(
2367 M, Kind, StartLoc, LParenLoc, MLoc, KindLoc, EndLoc);
2368 }
2369
2370 /// Build a new OpenMP 'nontemporal' clause.
2371 ///
2372 /// By default, performs semantic analysis to build the new OpenMP clause.
2373 /// Subclasses may override this routine to provide different behavior.
2374 OMPClause *RebuildOMPNontemporalClause(ArrayRef<Expr *> VarList,
2375 SourceLocation StartLoc,
2376 SourceLocation LParenLoc,
2377 SourceLocation EndLoc) {
2378 return getSema().OpenMP().ActOnOpenMPNontemporalClause(VarList, StartLoc,
2379 LParenLoc, EndLoc);
2380 }
2381
2382 /// Build a new OpenMP 'inclusive' clause.
2383 ///
2384 /// By default, performs semantic analysis to build the new OpenMP clause.
2385 /// Subclasses may override this routine to provide different behavior.
2386 OMPClause *RebuildOMPInclusiveClause(ArrayRef<Expr *> VarList,
2387 SourceLocation StartLoc,
2388 SourceLocation LParenLoc,
2389 SourceLocation EndLoc) {
2390 return getSema().OpenMP().ActOnOpenMPInclusiveClause(VarList, StartLoc,
2391 LParenLoc, EndLoc);
2392 }
2393
2394 /// Build a new OpenMP 'exclusive' clause.
2395 ///
2396 /// By default, performs semantic analysis to build the new OpenMP clause.
2397 /// Subclasses may override this routine to provide different behavior.
2398 OMPClause *RebuildOMPExclusiveClause(ArrayRef<Expr *> VarList,
2399 SourceLocation StartLoc,
2400 SourceLocation LParenLoc,
2401 SourceLocation EndLoc) {
2402 return getSema().OpenMP().ActOnOpenMPExclusiveClause(VarList, StartLoc,
2403 LParenLoc, EndLoc);
2404 }
2405
2406 /// Build a new OpenMP 'uses_allocators' clause.
2407 ///
2408 /// By default, performs semantic analysis to build the new OpenMP clause.
2409 /// Subclasses may override this routine to provide different behavior.
2410 OMPClause *RebuildOMPUsesAllocatorsClause(
2411 ArrayRef<SemaOpenMP::UsesAllocatorsData> Data, SourceLocation StartLoc,
2412 SourceLocation LParenLoc, SourceLocation EndLoc) {
2413 return getSema().OpenMP().ActOnOpenMPUsesAllocatorClause(
2414 StartLoc, LParenLoc, EndLoc, Data);
2415 }
2416
2417 /// Build a new OpenMP 'affinity' clause.
2418 ///
2419 /// By default, performs semantic analysis to build the new OpenMP clause.
2420 /// Subclasses may override this routine to provide different behavior.
2421 OMPClause *RebuildOMPAffinityClause(SourceLocation StartLoc,
2422 SourceLocation LParenLoc,
2423 SourceLocation ColonLoc,
2424 SourceLocation EndLoc, Expr *Modifier,
2425 ArrayRef<Expr *> Locators) {
2426 return getSema().OpenMP().ActOnOpenMPAffinityClause(
2427 StartLoc, LParenLoc, ColonLoc, EndLoc, Modifier, Locators);
2428 }
2429
2430 /// Build a new OpenMP 'order' clause.
2431 ///
2432 /// By default, performs semantic analysis to build the new OpenMP clause.
2433 /// Subclasses may override this routine to provide different behavior.
2434 OMPClause *RebuildOMPOrderClause(
2435 OpenMPOrderClauseKind Kind, SourceLocation KindKwLoc,
2436 SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc,
2437 OpenMPOrderClauseModifier Modifier, SourceLocation ModifierKwLoc) {
2438 return getSema().OpenMP().ActOnOpenMPOrderClause(
2439 Modifier, Kind, StartLoc, LParenLoc, ModifierKwLoc, KindKwLoc, EndLoc);
2440 }
2441
2442 /// Build a new OpenMP 'init' clause.
2443 ///
2444 /// By default, performs semantic analysis to build the new OpenMP clause.
2445 /// Subclasses may override this routine to provide different behavior.
2446 OMPClause *RebuildOMPInitClause(Expr *InteropVar, OMPInteropInfo &InteropInfo,
2447 SourceLocation StartLoc,
2448 SourceLocation LParenLoc,
2449 SourceLocation VarLoc,
2450 SourceLocation EndLoc) {
2451 return getSema().OpenMP().ActOnOpenMPInitClause(
2452 InteropVar, InteropInfo, StartLoc, LParenLoc, VarLoc, EndLoc);
2453 }
2454
2455 /// Build a new OpenMP 'use' clause.
2456 ///
2457 /// By default, performs semantic analysis to build the new OpenMP clause.
2458 /// Subclasses may override this routine to provide different behavior.
2459 OMPClause *RebuildOMPUseClause(Expr *InteropVar, SourceLocation StartLoc,
2460 SourceLocation LParenLoc,
2461 SourceLocation VarLoc, SourceLocation EndLoc) {
2462 return getSema().OpenMP().ActOnOpenMPUseClause(InteropVar, StartLoc,
2463 LParenLoc, VarLoc, EndLoc);
2464 }
2465
2466 /// Build a new OpenMP 'destroy' clause.
2467 ///
2468 /// By default, performs semantic analysis to build the new OpenMP clause.
2469 /// Subclasses may override this routine to provide different behavior.
2470 OMPClause *RebuildOMPDestroyClause(Expr *InteropVar, SourceLocation StartLoc,
2471 SourceLocation LParenLoc,
2472 SourceLocation VarLoc,
2473 SourceLocation EndLoc) {
2474 return getSema().OpenMP().ActOnOpenMPDestroyClause(
2475 InteropVar, StartLoc, LParenLoc, VarLoc, EndLoc);
2476 }
2477
2478 /// Build a new OpenMP 'novariants' clause.
2479 ///
2480 /// By default, performs semantic analysis to build the new OpenMP clause.
2481 /// Subclasses may override this routine to provide different behavior.
2482 OMPClause *RebuildOMPNovariantsClause(Expr *Condition,
2483 SourceLocation StartLoc,
2484 SourceLocation LParenLoc,
2485 SourceLocation EndLoc) {
2486 return getSema().OpenMP().ActOnOpenMPNovariantsClause(Condition, StartLoc,
2487 LParenLoc, EndLoc);
2488 }
2489
2490 /// Build a new OpenMP 'nocontext' clause.
2491 ///
2492 /// By default, performs semantic analysis to build the new OpenMP clause.
2493 /// Subclasses may override this routine to provide different behavior.
2494 OMPClause *RebuildOMPNocontextClause(Expr *Condition, SourceLocation StartLoc,
2495 SourceLocation LParenLoc,
2496 SourceLocation EndLoc) {
2497 return getSema().OpenMP().ActOnOpenMPNocontextClause(Condition, StartLoc,
2498 LParenLoc, EndLoc);
2499 }
2500
2501 /// Build a new OpenMP 'filter' clause.
2502 ///
2503 /// By default, performs semantic analysis to build the new OpenMP clause.
2504 /// Subclasses may override this routine to provide different behavior.
2505 OMPClause *RebuildOMPFilterClause(Expr *ThreadID, SourceLocation StartLoc,
2506 SourceLocation LParenLoc,
2507 SourceLocation EndLoc) {
2508 return getSema().OpenMP().ActOnOpenMPFilterClause(ThreadID, StartLoc,
2509 LParenLoc, EndLoc);
2510 }
2511
2512 /// Build a new OpenMP 'bind' clause.
2513 ///
2514 /// By default, performs semantic analysis to build the new OpenMP clause.
2515 /// Subclasses may override this routine to provide different behavior.
2516 OMPClause *RebuildOMPBindClause(OpenMPBindClauseKind Kind,
2517 SourceLocation KindLoc,
2518 SourceLocation StartLoc,
2519 SourceLocation LParenLoc,
2520 SourceLocation EndLoc) {
2521 return getSema().OpenMP().ActOnOpenMPBindClause(Kind, KindLoc, StartLoc,
2522 LParenLoc, EndLoc);
2523 }
2524
2525 /// Build a new OpenMP 'ompx_dyn_cgroup_mem' clause.
2526 ///
2527 /// By default, performs semantic analysis to build the new OpenMP clause.
2528 /// Subclasses may override this routine to provide different behavior.
2529 OMPClause *RebuildOMPXDynCGroupMemClause(Expr *Size, SourceLocation StartLoc,
2530 SourceLocation LParenLoc,
2531 SourceLocation EndLoc) {
2532 return getSema().OpenMP().ActOnOpenMPXDynCGroupMemClause(Size, StartLoc,
2533 LParenLoc, EndLoc);
2534 }
2535
2536 /// Build a new OpenMP 'dyn_groupprivate' clause.
2537 ///
2538 /// By default, performs semantic analysis to build the new OpenMP clause.
2539 /// Subclasses may override this routine to provide different behavior.
2540 OMPClause *RebuildOMPDynGroupprivateClause(
2541 OpenMPDynGroupprivateClauseModifier M1,
2542 OpenMPDynGroupprivateClauseFallbackModifier M2, Expr *Size,
2543 SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation M1Loc,
2544 SourceLocation M2Loc, SourceLocation EndLoc) {
2545 return getSema().OpenMP().ActOnOpenMPDynGroupprivateClause(
2546 M1, M2, Size, StartLoc, LParenLoc, M1Loc, M2Loc, EndLoc);
2547 }
2548
2549 /// Build a new OpenMP 'ompx_attribute' clause.
2550 ///
2551 /// By default, performs semantic analysis to build the new OpenMP clause.
2552 /// Subclasses may override this routine to provide different behavior.
2553 OMPClause *RebuildOMPXAttributeClause(ArrayRef<const Attr *> Attrs,
2554 SourceLocation StartLoc,
2555 SourceLocation LParenLoc,
2556 SourceLocation EndLoc) {
2557 return getSema().OpenMP().ActOnOpenMPXAttributeClause(Attrs, StartLoc,
2558 LParenLoc, EndLoc);
2559 }
2560
2561 /// Build a new OpenMP 'ompx_bare' clause.
2562 ///
2563 /// By default, performs semantic analysis to build the new OpenMP clause.
2564 /// Subclasses may override this routine to provide different behavior.
2565 OMPClause *RebuildOMPXBareClause(SourceLocation StartLoc,
2566 SourceLocation EndLoc) {
2567 return getSema().OpenMP().ActOnOpenMPXBareClause(StartLoc, EndLoc);
2568 }
2569
2570 /// Build a new OpenMP 'align' clause.
2571 ///
2572 /// By default, performs semantic analysis to build the new OpenMP clause.
2573 /// Subclasses may override this routine to provide different behavior.
2574 OMPClause *RebuildOMPAlignClause(Expr *A, SourceLocation StartLoc,
2575 SourceLocation LParenLoc,
2576 SourceLocation EndLoc) {
2577 return getSema().OpenMP().ActOnOpenMPAlignClause(A, StartLoc, LParenLoc,
2578 EndLoc);
2579 }
2580
2581 /// Build a new OpenMP 'at' clause.
2582 ///
2583 /// By default, performs semantic analysis to build the new OpenMP clause.
2584 /// Subclasses may override this routine to provide different behavior.
2585 OMPClause *RebuildOMPAtClause(OpenMPAtClauseKind Kind, SourceLocation KwLoc,
2586 SourceLocation StartLoc,
2587 SourceLocation LParenLoc,
2588 SourceLocation EndLoc) {
2589 return getSema().OpenMP().ActOnOpenMPAtClause(Kind, KwLoc, StartLoc,
2590 LParenLoc, EndLoc);
2591 }
2592
2593 /// Build a new OpenMP 'severity' clause.
2594 ///
2595 /// By default, performs semantic analysis to build the new OpenMP clause.
2596 /// Subclasses may override this routine to provide different behavior.
2597 OMPClause *RebuildOMPSeverityClause(OpenMPSeverityClauseKind Kind,
2598 SourceLocation KwLoc,
2599 SourceLocation StartLoc,
2600 SourceLocation LParenLoc,
2601 SourceLocation EndLoc) {
2602 return getSema().OpenMP().ActOnOpenMPSeverityClause(Kind, KwLoc, StartLoc,
2603 LParenLoc, EndLoc);
2604 }
2605
2606 /// Build a new OpenMP 'message' clause.
2607 ///
2608 /// By default, performs semantic analysis to build the new OpenMP clause.
2609 /// Subclasses may override this routine to provide different behavior.
2610 OMPClause *RebuildOMPMessageClause(Expr *MS, SourceLocation StartLoc,
2611 SourceLocation LParenLoc,
2612 SourceLocation EndLoc) {
2613 return getSema().OpenMP().ActOnOpenMPMessageClause(MS, StartLoc, LParenLoc,
2614 EndLoc);
2615 }
2616
2617 /// Build a new OpenMP 'doacross' clause.
2618 ///
2619 /// By default, performs semantic analysis to build the new OpenMP clause.
2620 /// Subclasses may override this routine to provide different behavior.
2621 OMPClause *
2622 RebuildOMPDoacrossClause(OpenMPDoacrossClauseModifier DepType,
2623 SourceLocation DepLoc, SourceLocation ColonLoc,
2624 ArrayRef<Expr *> VarList, SourceLocation StartLoc,
2625 SourceLocation LParenLoc, SourceLocation EndLoc) {
2626 return getSema().OpenMP().ActOnOpenMPDoacrossClause(
2627 DepType, DepLoc, ColonLoc, VarList, StartLoc, LParenLoc, EndLoc);
2628 }
2629
2630 /// Build a new OpenMP 'holds' clause.
2631 OMPClause *RebuildOMPHoldsClause(Expr *A, SourceLocation StartLoc,
2632 SourceLocation LParenLoc,
2633 SourceLocation EndLoc) {
2634 return getSema().OpenMP().ActOnOpenMPHoldsClause(A, StartLoc, LParenLoc,
2635 EndLoc);
2636 }
2637
2638 /// Rebuild the operand to an Objective-C \@synchronized statement.
2639 ///
2640 /// By default, performs semantic analysis to build the new statement.
2641 /// Subclasses may override this routine to provide different behavior.
2642 ExprResult RebuildObjCAtSynchronizedOperand(SourceLocation atLoc,
2643 Expr *object) {
2644 return getSema().ObjC().ActOnObjCAtSynchronizedOperand(atLoc, object);
2645 }
2646
2647 /// Build a new Objective-C \@synchronized statement.
2648 ///
2649 /// By default, performs semantic analysis to build the new statement.
2650 /// Subclasses may override this routine to provide different behavior.
2651 StmtResult RebuildObjCAtSynchronizedStmt(SourceLocation AtLoc,
2652 Expr *Object, Stmt *Body) {
2653 return getSema().ObjC().ActOnObjCAtSynchronizedStmt(AtLoc, Object, Body);
2654 }
2655
2656 /// Build a new Objective-C \@autoreleasepool statement.
2657 ///
2658 /// By default, performs semantic analysis to build the new statement.
2659 /// Subclasses may override this routine to provide different behavior.
2660 StmtResult RebuildObjCAutoreleasePoolStmt(SourceLocation AtLoc,
2661 Stmt *Body) {
2662 return getSema().ObjC().ActOnObjCAutoreleasePoolStmt(AtLoc, Body);
2663 }
2664
2665 /// Build a new Objective-C fast enumeration statement.
2666 ///
2667 /// By default, performs semantic analysis to build the new statement.
2668 /// Subclasses may override this routine to provide different behavior.
2669 StmtResult RebuildObjCForCollectionStmt(SourceLocation ForLoc,
2670 Stmt *Element,
2671 Expr *Collection,
2672 SourceLocation RParenLoc,
2673 Stmt *Body) {
2674 StmtResult ForEachStmt = getSema().ObjC().ActOnObjCForCollectionStmt(
2675 ForLoc, Element, Collection, RParenLoc);
2676 if (ForEachStmt.isInvalid())
2677 return StmtError();
2678
2679 return getSema().ObjC().FinishObjCForCollectionStmt(ForEachStmt.get(),
2680 Body);
2681 }
2682
2683 /// Build a new C++ exception declaration.
2684 ///
2685 /// By default, performs semantic analysis to build the new decaration.
2686 /// Subclasses may override this routine to provide different behavior.
2687 VarDecl *RebuildExceptionDecl(VarDecl *ExceptionDecl,
2688 TypeSourceInfo *Declarator,
2689 SourceLocation StartLoc,
2690 SourceLocation IdLoc,
2691 IdentifierInfo *Id) {
2692 VarDecl *Var = getSema().BuildExceptionDeclaration(nullptr, Declarator,
2693 StartLoc, IdLoc, Id);
2694 if (Var)
2695 getSema().CurContext->addDecl(Var);
2696 return Var;
2697 }
2698
2699 /// Build a new C++ catch statement.
2700 ///
2701 /// By default, performs semantic analysis to build the new statement.
2702 /// Subclasses may override this routine to provide different behavior.
2703 StmtResult RebuildCXXCatchStmt(SourceLocation CatchLoc,
2704 VarDecl *ExceptionDecl,
2705 Stmt *Handler) {
2706 return Owned(new (getSema().Context) CXXCatchStmt(CatchLoc, ExceptionDecl,
2707 Handler));
2708 }
2709
2710 /// Build a new C++ try statement.
2711 ///
2712 /// By default, performs semantic analysis to build the new statement.
2713 /// Subclasses may override this routine to provide different behavior.
2714 StmtResult RebuildCXXTryStmt(SourceLocation TryLoc, Stmt *TryBlock,
2715 ArrayRef<Stmt *> Handlers) {
2716 return getSema().ActOnCXXTryBlock(TryLoc, TryBlock, Handlers);
2717 }
2718
2719 /// Build a new C++0x range-based for statement.
2720 ///
2721 /// By default, performs semantic analysis to build the new statement.
2722 /// Subclasses may override this routine to provide different behavior.
2723 StmtResult RebuildCXXForRangeStmt(
2724 SourceLocation ForLoc, SourceLocation CoawaitLoc, Stmt *Init,
2725 SourceLocation ColonLoc, Stmt *Range, Stmt *Begin, Stmt *End, Expr *Cond,
2726 Expr *Inc, Stmt *LoopVar, SourceLocation RParenLoc,
2727 ArrayRef<MaterializeTemporaryExpr *> LifetimeExtendTemps) {
2728 // If we've just learned that the range is actually an Objective-C
2729 // collection, treat this as an Objective-C fast enumeration loop.
2730 if (DeclStmt *RangeStmt = dyn_cast<DeclStmt>(Val: Range)) {
2731 if (RangeStmt->isSingleDecl()) {
2732 if (VarDecl *RangeVar = dyn_cast<VarDecl>(Val: RangeStmt->getSingleDecl())) {
2733 if (RangeVar->isInvalidDecl())
2734 return StmtError();
2735
2736 Expr *RangeExpr = RangeVar->getInit();
2737 if (!RangeExpr->isTypeDependent() &&
2738 RangeExpr->getType()->isObjCObjectPointerType()) {
2739 // FIXME: Support init-statements in Objective-C++20 ranged for
2740 // statement.
2741 if (Init) {
2742 return SemaRef.Diag(Loc: Init->getBeginLoc(),
2743 DiagID: diag::err_objc_for_range_init_stmt)
2744 << Init->getSourceRange();
2745 }
2746 return getSema().ObjC().ActOnObjCForCollectionStmt(
2747 ForLoc, LoopVar, RangeExpr, RParenLoc);
2748 }
2749 }
2750 }
2751 }
2752
2753 return getSema().BuildCXXForRangeStmt(
2754 ForLoc, CoawaitLoc, Init, ColonLoc, Range, Begin, End, Cond, Inc,
2755 LoopVar, RParenLoc, Sema::BFRK_Rebuild, LifetimeExtendTemps);
2756 }
2757
2758 /// Build a new C++0x range-based for statement.
2759 ///
2760 /// By default, performs semantic analysis to build the new statement.
2761 /// Subclasses may override this routine to provide different behavior.
2762 StmtResult RebuildMSDependentExistsStmt(SourceLocation KeywordLoc,
2763 bool IsIfExists,
2764 NestedNameSpecifierLoc QualifierLoc,
2765 DeclarationNameInfo NameInfo,
2766 Stmt *Nested) {
2767 return getSema().BuildMSDependentExistsStmt(KeywordLoc, IsIfExists,
2768 QualifierLoc, NameInfo, Nested);
2769 }
2770
2771 /// Attach body to a C++0x range-based for statement.
2772 ///
2773 /// By default, performs semantic analysis to finish the new statement.
2774 /// Subclasses may override this routine to provide different behavior.
2775 StmtResult FinishCXXForRangeStmt(Stmt *ForRange, Stmt *Body) {
2776 return getSema().FinishCXXForRangeStmt(ForRange, Body);
2777 }
2778
2779 StmtResult RebuildSEHTryStmt(bool IsCXXTry, SourceLocation TryLoc,
2780 Stmt *TryBlock, Stmt *Handler) {
2781 return getSema().ActOnSEHTryBlock(IsCXXTry, TryLoc, TryBlock, Handler);
2782 }
2783
2784 StmtResult RebuildSEHExceptStmt(SourceLocation Loc, Expr *FilterExpr,
2785 Stmt *Block) {
2786 return getSema().ActOnSEHExceptBlock(Loc, FilterExpr, Block);
2787 }
2788
2789 StmtResult RebuildSEHFinallyStmt(SourceLocation Loc, Stmt *Block) {
2790 return SEHFinallyStmt::Create(C: getSema().getASTContext(), FinallyLoc: Loc, Block);
2791 }
2792
2793 ExprResult RebuildSYCLUniqueStableNameExpr(SourceLocation OpLoc,
2794 SourceLocation LParen,
2795 SourceLocation RParen,
2796 TypeSourceInfo *TSI) {
2797 return getSema().SYCL().BuildUniqueStableNameExpr(OpLoc, LParen, RParen,
2798 TSI);
2799 }
2800
2801 /// Build a new predefined expression.
2802 ///
2803 /// By default, performs semantic analysis to build the new expression.
2804 /// Subclasses may override this routine to provide different behavior.
2805 ExprResult RebuildPredefinedExpr(SourceLocation Loc, PredefinedIdentKind IK) {
2806 return getSema().BuildPredefinedExpr(Loc, IK);
2807 }
2808
2809 /// Build a new expression that references a declaration.
2810 ///
2811 /// By default, performs semantic analysis to build the new expression.
2812 /// Subclasses may override this routine to provide different behavior.
2813 ExprResult RebuildDeclarationNameExpr(const CXXScopeSpec &SS,
2814 LookupResult &R,
2815 bool RequiresADL) {
2816 return getSema().BuildDeclarationNameExpr(SS, R, RequiresADL);
2817 }
2818
2819
2820 /// Build a new expression that references a declaration.
2821 ///
2822 /// By default, performs semantic analysis to build the new expression.
2823 /// Subclasses may override this routine to provide different behavior.
2824 ExprResult RebuildDeclRefExpr(NestedNameSpecifierLoc QualifierLoc,
2825 ValueDecl *VD,
2826 const DeclarationNameInfo &NameInfo,
2827 NamedDecl *Found,
2828 TemplateArgumentListInfo *TemplateArgs) {
2829 CXXScopeSpec SS;
2830 SS.Adopt(Other: QualifierLoc);
2831 return getSema().BuildDeclarationNameExpr(SS, NameInfo, VD, Found,
2832 TemplateArgs);
2833 }
2834
2835 /// Build a new expression in parentheses.
2836 ///
2837 /// By default, performs semantic analysis to build the new expression.
2838 /// Subclasses may override this routine to provide different behavior.
2839 ExprResult RebuildParenExpr(Expr *SubExpr, SourceLocation LParen,
2840 SourceLocation RParen) {
2841 return getSema().ActOnParenExpr(LParen, RParen, SubExpr);
2842 }
2843
2844 /// Build a new pseudo-destructor expression.
2845 ///
2846 /// By default, performs semantic analysis to build the new expression.
2847 /// Subclasses may override this routine to provide different behavior.
2848 ExprResult RebuildCXXPseudoDestructorExpr(Expr *Base,
2849 SourceLocation OperatorLoc,
2850 bool isArrow,
2851 CXXScopeSpec &SS,
2852 TypeSourceInfo *ScopeType,
2853 SourceLocation CCLoc,
2854 SourceLocation TildeLoc,
2855 PseudoDestructorTypeStorage Destroyed);
2856
2857 /// Build a new unary operator expression.
2858 ///
2859 /// By default, performs semantic analysis to build the new expression.
2860 /// Subclasses may override this routine to provide different behavior.
2861 ExprResult RebuildUnaryOperator(SourceLocation OpLoc,
2862 UnaryOperatorKind Opc,
2863 Expr *SubExpr) {
2864 return getSema().BuildUnaryOp(/*Scope=*/nullptr, OpLoc, Opc, SubExpr);
2865 }
2866
2867 /// Build a new builtin offsetof expression.
2868 ///
2869 /// By default, performs semantic analysis to build the new expression.
2870 /// Subclasses may override this routine to provide different behavior.
2871 ExprResult RebuildOffsetOfExpr(SourceLocation OperatorLoc,
2872 TypeSourceInfo *Type, const Designation &Desig,
2873 SourceLocation RParenLoc) {
2874 return getSema().BuildBuiltinOffsetOf(OperatorLoc, Type, Desig, RParenLoc);
2875 }
2876
2877 /// Build a new sizeof, alignof or vec_step expression with a
2878 /// type argument.
2879 ///
2880 /// By default, performs semantic analysis to build the new expression.
2881 /// Subclasses may override this routine to provide different behavior.
2882 ExprResult RebuildUnaryExprOrTypeTrait(TypeSourceInfo *TInfo,
2883 SourceLocation OpLoc,
2884 UnaryExprOrTypeTrait ExprKind,
2885 SourceRange R) {
2886 return getSema().CreateUnaryExprOrTypeTraitExpr(TInfo, OpLoc, ExprKind, R);
2887 }
2888
2889 /// Build a new sizeof, alignof or vec step expression with an
2890 /// expression argument.
2891 ///
2892 /// By default, performs semantic analysis to build the new expression.
2893 /// Subclasses may override this routine to provide different behavior.
2894 ExprResult RebuildUnaryExprOrTypeTrait(Expr *SubExpr, SourceLocation OpLoc,
2895 UnaryExprOrTypeTrait ExprKind,
2896 SourceRange R) {
2897 ExprResult Result
2898 = getSema().CreateUnaryExprOrTypeTraitExpr(SubExpr, OpLoc, ExprKind);
2899 if (Result.isInvalid())
2900 return ExprError();
2901
2902 return Result;
2903 }
2904
2905 /// Build a new array subscript expression.
2906 ///
2907 /// By default, performs semantic analysis to build the new expression.
2908 /// Subclasses may override this routine to provide different behavior.
2909 ExprResult RebuildArraySubscriptExpr(Expr *LHS,
2910 SourceLocation LBracketLoc,
2911 Expr *RHS,
2912 SourceLocation RBracketLoc) {
2913 return getSema().ActOnArraySubscriptExpr(/*Scope=*/nullptr, LHS,
2914 LBracketLoc, RHS,
2915 RBracketLoc);
2916 }
2917
2918 /// Build a new matrix single subscript expression.
2919 ///
2920 /// By default, performs semantic analysis to build the new expression.
2921 /// Subclasses may override this routine to provide different behavior.
2922 ExprResult RebuildMatrixSingleSubscriptExpr(Expr *Base, Expr *RowIdx,
2923 SourceLocation RBracketLoc) {
2924 return getSema().CreateBuiltinMatrixSingleSubscriptExpr(Base, RowIdx,
2925 RBracketLoc);
2926 }
2927
2928 /// Build a new matrix subscript expression.
2929 ///
2930 /// By default, performs semantic analysis to build the new expression.
2931 /// Subclasses may override this routine to provide different behavior.
2932 ExprResult RebuildMatrixSubscriptExpr(Expr *Base, Expr *RowIdx,
2933 Expr *ColumnIdx,
2934 SourceLocation RBracketLoc) {
2935 return getSema().CreateBuiltinMatrixSubscriptExpr(Base, RowIdx, ColumnIdx,
2936 RBracketLoc);
2937 }
2938
2939 /// Build a new array section expression.
2940 ///
2941 /// By default, performs semantic analysis to build the new expression.
2942 /// Subclasses may override this routine to provide different behavior.
2943 ExprResult RebuildArraySectionExpr(bool IsOMPArraySection, Expr *Base,
2944 SourceLocation LBracketLoc,
2945 Expr *LowerBound,
2946 SourceLocation ColonLocFirst,
2947 SourceLocation ColonLocSecond,
2948 Expr *Length, Expr *Stride,
2949 SourceLocation RBracketLoc) {
2950 if (IsOMPArraySection)
2951 return getSema().OpenMP().ActOnOMPArraySectionExpr(
2952 Base, LBracketLoc, LowerBound, ColonLocFirst, ColonLocSecond, Length,
2953 Stride, RBracketLoc);
2954
2955 assert(Stride == nullptr && !ColonLocSecond.isValid() &&
2956 "Stride/second colon not allowed for OpenACC");
2957
2958 return getSema().OpenACC().ActOnArraySectionExpr(
2959 Base, LBracketLoc, LowerBound, ColonLocFirst, Length, RBracketLoc);
2960 }
2961
2962 /// Build a new array shaping expression.
2963 ///
2964 /// By default, performs semantic analysis to build the new expression.
2965 /// Subclasses may override this routine to provide different behavior.
2966 ExprResult RebuildOMPArrayShapingExpr(Expr *Base, SourceLocation LParenLoc,
2967 SourceLocation RParenLoc,
2968 ArrayRef<Expr *> Dims,
2969 ArrayRef<SourceRange> BracketsRanges) {
2970 return getSema().OpenMP().ActOnOMPArrayShapingExpr(
2971 Base, LParenLoc, RParenLoc, Dims, BracketsRanges);
2972 }
2973
2974 /// Build a new iterator expression.
2975 ///
2976 /// By default, performs semantic analysis to build the new expression.
2977 /// Subclasses may override this routine to provide different behavior.
2978 ExprResult
2979 RebuildOMPIteratorExpr(SourceLocation IteratorKwLoc, SourceLocation LLoc,
2980 SourceLocation RLoc,
2981 ArrayRef<SemaOpenMP::OMPIteratorData> Data) {
2982 return getSema().OpenMP().ActOnOMPIteratorExpr(
2983 /*Scope=*/nullptr, IteratorKwLoc, LLoc, RLoc, Data);
2984 }
2985
2986 /// Build a new call expression.
2987 ///
2988 /// By default, performs semantic analysis to build the new expression.
2989 /// Subclasses may override this routine to provide different behavior.
2990 ExprResult RebuildCallExpr(Expr *Callee, SourceLocation LParenLoc,
2991 MultiExprArg Args,
2992 SourceLocation RParenLoc,
2993 Expr *ExecConfig = nullptr) {
2994 return getSema().ActOnCallExpr(
2995 /*Scope=*/nullptr, Callee, LParenLoc, Args, RParenLoc, ExecConfig);
2996 }
2997
2998 ExprResult RebuildCxxSubscriptExpr(Expr *Callee, SourceLocation LParenLoc,
2999 MultiExprArg Args,
3000 SourceLocation RParenLoc) {
3001 return getSema().ActOnArraySubscriptExpr(
3002 /*Scope=*/nullptr, Callee, LParenLoc, Args, RParenLoc);
3003 }
3004
3005 /// Build a new member access expression.
3006 ///
3007 /// By default, performs semantic analysis to build the new expression.
3008 /// Subclasses may override this routine to provide different behavior.
3009 ExprResult RebuildMemberExpr(Expr *Base, SourceLocation OpLoc,
3010 bool isArrow,
3011 NestedNameSpecifierLoc QualifierLoc,
3012 SourceLocation TemplateKWLoc,
3013 const DeclarationNameInfo &MemberNameInfo,
3014 ValueDecl *Member,
3015 NamedDecl *FoundDecl,
3016 const TemplateArgumentListInfo *ExplicitTemplateArgs,
3017 NamedDecl *FirstQualifierInScope) {
3018 ExprResult BaseResult = getSema().PerformMemberExprBaseConversion(Base,
3019 isArrow);
3020 if (!Member->getDeclName()) {
3021 // We have a reference to an unnamed field. This is always the
3022 // base of an anonymous struct/union member access, i.e. the
3023 // field is always of record type.
3024 assert(Member->getType()->isRecordType() &&
3025 "unnamed member not of record type?");
3026
3027 BaseResult =
3028 getSema().PerformObjectMemberConversion(BaseResult.get(),
3029 QualifierLoc.getNestedNameSpecifier(),
3030 FoundDecl, Member);
3031 if (BaseResult.isInvalid())
3032 return ExprError();
3033 Base = BaseResult.get();
3034
3035 // `TranformMaterializeTemporaryExpr()` removes materialized temporaries
3036 // from the AST, so we need to re-insert them if needed (since
3037 // `BuildFieldRefereneExpr()` doesn't do this).
3038 if (!isArrow && Base->isPRValue()) {
3039 BaseResult = getSema().TemporaryMaterializationConversion(Base);
3040 if (BaseResult.isInvalid())
3041 return ExprError();
3042 Base = BaseResult.get();
3043 }
3044
3045 CXXScopeSpec EmptySS;
3046 return getSema().BuildFieldReferenceExpr(
3047 Base, isArrow, OpLoc, EmptySS, cast<FieldDecl>(Val: Member),
3048 DeclAccessPair::make(D: FoundDecl, AS: FoundDecl->getAccess()),
3049 MemberNameInfo);
3050 }
3051
3052 CXXScopeSpec SS;
3053 SS.Adopt(Other: QualifierLoc);
3054
3055 Base = BaseResult.get();
3056 if (Base->containsErrors())
3057 return ExprError();
3058
3059 QualType BaseType = Base->getType();
3060
3061 if (isArrow && !BaseType->isPointerType())
3062 return ExprError();
3063
3064 // FIXME: this involves duplicating earlier analysis in a lot of
3065 // cases; we should avoid this when possible.
3066 LookupResult R(getSema(), MemberNameInfo, Sema::LookupMemberName);
3067 R.addDecl(D: FoundDecl);
3068 R.resolveKind();
3069
3070 if (getSema().isUnevaluatedContext() && Base->isImplicitCXXThis() &&
3071 isa<FieldDecl, IndirectFieldDecl, MSPropertyDecl>(Val: Member)) {
3072 if (auto *ThisClass = cast<CXXThisExpr>(Val: Base)
3073 ->getType()
3074 ->getPointeeType()
3075 ->getAsCXXRecordDecl()) {
3076 auto *Class = cast<CXXRecordDecl>(Val: Member->getDeclContext());
3077 // In unevaluated contexts, an expression supposed to be a member access
3078 // might reference a member in an unrelated class.
3079 if (!ThisClass->Equals(DC: Class) && !ThisClass->isDerivedFrom(Base: Class))
3080 return getSema().BuildDeclRefExpr(Member, Member->getType(),
3081 VK_LValue, Member->getLocation());
3082 }
3083 }
3084
3085 return getSema().BuildMemberReferenceExpr(Base, BaseType, OpLoc, isArrow,
3086 SS, TemplateKWLoc,
3087 FirstQualifierInScope,
3088 R, ExplicitTemplateArgs,
3089 /*S*/nullptr);
3090 }
3091
3092 /// Build a new binary operator expression.
3093 ///
3094 /// By default, performs semantic analysis to build the new expression.
3095 /// Subclasses may override this routine to provide different behavior.
3096 ExprResult RebuildBinaryOperator(SourceLocation OpLoc, BinaryOperatorKind Opc,
3097 Expr *LHS, Expr *RHS,
3098 bool ForFoldExpression = false) {
3099 return getSema().BuildBinOp(/*Scope=*/nullptr, OpLoc, Opc, LHS, RHS,
3100 ForFoldExpression);
3101 }
3102
3103 /// Build a new rewritten operator expression.
3104 ///
3105 /// By default, performs semantic analysis to build the new expression.
3106 /// Subclasses may override this routine to provide different behavior.
3107 ExprResult RebuildCXXRewrittenBinaryOperator(
3108 SourceLocation OpLoc, BinaryOperatorKind Opcode,
3109 const UnresolvedSetImpl &UnqualLookups, Expr *LHS, Expr *RHS) {
3110 return getSema().CreateOverloadedBinOp(OpLoc, Opcode, UnqualLookups, LHS,
3111 RHS, /*RequiresADL*/false);
3112 }
3113
3114 /// Build a new conditional operator expression.
3115 ///
3116 /// By default, performs semantic analysis to build the new expression.
3117 /// Subclasses may override this routine to provide different behavior.
3118 ExprResult RebuildConditionalOperator(Expr *Cond,
3119 SourceLocation QuestionLoc,
3120 Expr *LHS,
3121 SourceLocation ColonLoc,
3122 Expr *RHS) {
3123 return getSema().ActOnConditionalOp(QuestionLoc, ColonLoc, Cond,
3124 LHS, RHS);
3125 }
3126
3127 /// Build a new C-style cast expression.
3128 ///
3129 /// By default, performs semantic analysis to build the new expression.
3130 /// Subclasses may override this routine to provide different behavior.
3131 ExprResult RebuildCStyleCastExpr(SourceLocation LParenLoc,
3132 TypeSourceInfo *TInfo,
3133 SourceLocation RParenLoc,
3134 Expr *SubExpr) {
3135 return getSema().BuildCStyleCastExpr(LParenLoc, TInfo, RParenLoc,
3136 SubExpr);
3137 }
3138
3139 /// Build a new compound literal expression.
3140 ///
3141 /// By default, performs semantic analysis to build the new expression.
3142 /// Subclasses may override this routine to provide different behavior.
3143 ExprResult RebuildCompoundLiteralExpr(SourceLocation LParenLoc,
3144 TypeSourceInfo *TInfo,
3145 SourceLocation RParenLoc,
3146 Expr *Init) {
3147 return getSema().BuildCompoundLiteralExpr(LParenLoc, TInfo, RParenLoc,
3148 Init);
3149 }
3150
3151 /// Build a new extended vector or matrix element access expression.
3152 ///
3153 /// By default, performs semantic analysis to build the new expression.
3154 /// Subclasses may override this routine to provide different behavior.
3155 ExprResult RebuildExtVectorOrMatrixElementExpr(Expr *Base,
3156 SourceLocation OpLoc,
3157 bool IsArrow,
3158 SourceLocation AccessorLoc,
3159 IdentifierInfo &Accessor) {
3160
3161 CXXScopeSpec SS;
3162 DeclarationNameInfo NameInfo(&Accessor, AccessorLoc);
3163 return getSema().BuildMemberReferenceExpr(
3164 Base, Base->getType(), OpLoc, IsArrow, SS, SourceLocation(),
3165 /*FirstQualifierInScope*/ nullptr, NameInfo,
3166 /* TemplateArgs */ nullptr,
3167 /*S*/ nullptr);
3168 }
3169
3170 /// Build a new initializer list expression.
3171 ///
3172 /// By default, performs semantic analysis to build the new expression.
3173 /// Subclasses may override this routine to provide different behavior.
3174 ExprResult RebuildInitList(SourceLocation LBraceLoc, MultiExprArg Inits,
3175 SourceLocation RBraceLoc, bool IsExplicit) {
3176 return SemaRef.BuildInitList(LBraceLoc, InitArgList: Inits, RBraceLoc, IsExplicit);
3177 }
3178
3179 /// Build a new designated initializer expression.
3180 ///
3181 /// By default, performs semantic analysis to build the new expression.
3182 /// Subclasses may override this routine to provide different behavior.
3183 ExprResult RebuildDesignatedInitExpr(Designation &Desig,
3184 MultiExprArg ArrayExprs,
3185 SourceLocation EqualOrColonLoc,
3186 bool GNUSyntax,
3187 Expr *Init) {
3188 ExprResult Result
3189 = SemaRef.ActOnDesignatedInitializer(Desig, EqualOrColonLoc, GNUSyntax,
3190 Init);
3191 if (Result.isInvalid())
3192 return ExprError();
3193
3194 return Result;
3195 }
3196
3197 /// Build a new value-initialized expression.
3198 ///
3199 /// By default, builds the implicit value initialization without performing
3200 /// any semantic analysis. Subclasses may override this routine to provide
3201 /// different behavior.
3202 ExprResult RebuildImplicitValueInitExpr(QualType T) {
3203 return new (SemaRef.Context) ImplicitValueInitExpr(T);
3204 }
3205
3206 /// Build a new \c va_arg expression.
3207 ///
3208 /// By default, performs semantic analysis to build the new expression.
3209 /// Subclasses may override this routine to provide different behavior.
3210 ExprResult RebuildVAArgExpr(SourceLocation BuiltinLoc,
3211 Expr *SubExpr, TypeSourceInfo *TInfo,
3212 SourceLocation RParenLoc) {
3213 return getSema().BuildVAArgExpr(BuiltinLoc,
3214 SubExpr, TInfo,
3215 RParenLoc);
3216 }
3217
3218 /// Build a new expression list in parentheses.
3219 ///
3220 /// By default, performs semantic analysis to build the new expression.
3221 /// Subclasses may override this routine to provide different behavior.
3222 ExprResult RebuildParenListExpr(SourceLocation LParenLoc,
3223 MultiExprArg SubExprs,
3224 SourceLocation RParenLoc) {
3225 return getSema().ActOnParenListExpr(LParenLoc, RParenLoc, SubExprs);
3226 }
3227
3228 ExprResult RebuildCXXParenListInitExpr(ArrayRef<Expr *> Args, QualType T,
3229 unsigned NumUserSpecifiedExprs,
3230 SourceLocation InitLoc,
3231 SourceLocation LParenLoc,
3232 SourceLocation RParenLoc) {
3233 return getSema().ActOnCXXParenListInitExpr(Args, T, NumUserSpecifiedExprs,
3234 InitLoc, LParenLoc, RParenLoc);
3235 }
3236
3237 /// Build a new address-of-label expression.
3238 ///
3239 /// By default, performs semantic analysis, using the name of the label
3240 /// rather than attempting to map the label statement itself.
3241 /// Subclasses may override this routine to provide different behavior.
3242 ExprResult RebuildAddrLabelExpr(SourceLocation AmpAmpLoc,
3243 SourceLocation LabelLoc, LabelDecl *Label) {
3244 return getSema().ActOnAddrLabel(AmpAmpLoc, LabelLoc, Label);
3245 }
3246
3247 /// Build a new GNU statement expression.
3248 ///
3249 /// By default, performs semantic analysis to build the new expression.
3250 /// Subclasses may override this routine to provide different behavior.
3251 ExprResult RebuildStmtExpr(SourceLocation LParenLoc, Stmt *SubStmt,
3252 SourceLocation RParenLoc, unsigned TemplateDepth) {
3253 return getSema().BuildStmtExpr(LParenLoc, SubStmt, RParenLoc,
3254 TemplateDepth);
3255 }
3256
3257 /// Build a new __builtin_choose_expr expression.
3258 ///
3259 /// By default, performs semantic analysis to build the new expression.
3260 /// Subclasses may override this routine to provide different behavior.
3261 ExprResult RebuildChooseExpr(SourceLocation BuiltinLoc,
3262 Expr *Cond, Expr *LHS, Expr *RHS,
3263 SourceLocation RParenLoc) {
3264 return SemaRef.ActOnChooseExpr(BuiltinLoc,
3265 CondExpr: Cond, LHSExpr: LHS, RHSExpr: RHS,
3266 RPLoc: RParenLoc);
3267 }
3268
3269 /// Build a new generic selection expression with an expression predicate.
3270 ///
3271 /// By default, performs semantic analysis to build the new expression.
3272 /// Subclasses may override this routine to provide different behavior.
3273 ExprResult RebuildGenericSelectionExpr(SourceLocation KeyLoc,
3274 SourceLocation DefaultLoc,
3275 SourceLocation RParenLoc,
3276 Expr *ControllingExpr,
3277 ArrayRef<TypeSourceInfo *> Types,
3278 ArrayRef<Expr *> Exprs) {
3279 return getSema().CreateGenericSelectionExpr(KeyLoc, DefaultLoc, RParenLoc,
3280 /*PredicateIsExpr=*/true,
3281 ControllingExpr, Types, Exprs);
3282 }
3283
3284 /// Build a new generic selection expression with a type predicate.
3285 ///
3286 /// By default, performs semantic analysis to build the new expression.
3287 /// Subclasses may override this routine to provide different behavior.
3288 ExprResult RebuildGenericSelectionExpr(SourceLocation KeyLoc,
3289 SourceLocation DefaultLoc,
3290 SourceLocation RParenLoc,
3291 TypeSourceInfo *ControllingType,
3292 ArrayRef<TypeSourceInfo *> Types,
3293 ArrayRef<Expr *> Exprs) {
3294 return getSema().CreateGenericSelectionExpr(KeyLoc, DefaultLoc, RParenLoc,
3295 /*PredicateIsExpr=*/false,
3296 ControllingType, Types, Exprs);
3297 }
3298
3299 /// Build a new overloaded operator call expression.
3300 ///
3301 /// By default, performs semantic analysis to build the new expression.
3302 /// The semantic analysis provides the behavior of template instantiation,
3303 /// copying with transformations that turn what looks like an overloaded
3304 /// operator call into a use of a builtin operator, performing
3305 /// argument-dependent lookup, etc. Subclasses may override this routine to
3306 /// provide different behavior.
3307 ExprResult RebuildCXXOperatorCallExpr(OverloadedOperatorKind Op,
3308 SourceLocation OpLoc,
3309 SourceLocation CalleeLoc,
3310 bool RequiresADL,
3311 const UnresolvedSetImpl &Functions,
3312 Expr *First, Expr *Second);
3313
3314 /// Build a new C++ "named" cast expression, such as static_cast or
3315 /// reinterpret_cast.
3316 ///
3317 /// By default, this routine dispatches to one of the more-specific routines
3318 /// for a particular named case, e.g., RebuildCXXStaticCastExpr().
3319 /// Subclasses may override this routine to provide different behavior.
3320 ExprResult RebuildCXXNamedCastExpr(SourceLocation OpLoc,
3321 Stmt::StmtClass Class,
3322 SourceLocation LAngleLoc,
3323 TypeSourceInfo *TInfo,
3324 SourceLocation RAngleLoc,
3325 SourceLocation LParenLoc,
3326 Expr *SubExpr,
3327 SourceLocation RParenLoc) {
3328 switch (Class) {
3329 case Stmt::CXXStaticCastExprClass:
3330 return getDerived().RebuildCXXStaticCastExpr(OpLoc, LAngleLoc, TInfo,
3331 RAngleLoc, LParenLoc,
3332 SubExpr, RParenLoc);
3333
3334 case Stmt::CXXDynamicCastExprClass:
3335 return getDerived().RebuildCXXDynamicCastExpr(OpLoc, LAngleLoc, TInfo,
3336 RAngleLoc, LParenLoc,
3337 SubExpr, RParenLoc);
3338
3339 case Stmt::CXXReinterpretCastExprClass:
3340 return getDerived().RebuildCXXReinterpretCastExpr(OpLoc, LAngleLoc, TInfo,
3341 RAngleLoc, LParenLoc,
3342 SubExpr,
3343 RParenLoc);
3344
3345 case Stmt::CXXConstCastExprClass:
3346 return getDerived().RebuildCXXConstCastExpr(OpLoc, LAngleLoc, TInfo,
3347 RAngleLoc, LParenLoc,
3348 SubExpr, RParenLoc);
3349
3350 case Stmt::CXXAddrspaceCastExprClass:
3351 return getDerived().RebuildCXXAddrspaceCastExpr(
3352 OpLoc, LAngleLoc, TInfo, RAngleLoc, LParenLoc, SubExpr, RParenLoc);
3353
3354 default:
3355 llvm_unreachable("Invalid C++ named cast");
3356 }
3357 }
3358
3359 /// Build a new C++ static_cast expression.
3360 ///
3361 /// By default, performs semantic analysis to build the new expression.
3362 /// Subclasses may override this routine to provide different behavior.
3363 ExprResult RebuildCXXStaticCastExpr(SourceLocation OpLoc,
3364 SourceLocation LAngleLoc,
3365 TypeSourceInfo *TInfo,
3366 SourceLocation RAngleLoc,
3367 SourceLocation LParenLoc,
3368 Expr *SubExpr,
3369 SourceLocation RParenLoc) {
3370 return getSema().BuildCXXNamedCast(OpLoc, tok::kw_static_cast,
3371 TInfo, SubExpr,
3372 SourceRange(LAngleLoc, RAngleLoc),
3373 SourceRange(LParenLoc, RParenLoc));
3374 }
3375
3376 /// Build a new C++ dynamic_cast expression.
3377 ///
3378 /// By default, performs semantic analysis to build the new expression.
3379 /// Subclasses may override this routine to provide different behavior.
3380 ExprResult RebuildCXXDynamicCastExpr(SourceLocation OpLoc,
3381 SourceLocation LAngleLoc,
3382 TypeSourceInfo *TInfo,
3383 SourceLocation RAngleLoc,
3384 SourceLocation LParenLoc,
3385 Expr *SubExpr,
3386 SourceLocation RParenLoc) {
3387 return getSema().BuildCXXNamedCast(OpLoc, tok::kw_dynamic_cast,
3388 TInfo, SubExpr,
3389 SourceRange(LAngleLoc, RAngleLoc),
3390 SourceRange(LParenLoc, RParenLoc));
3391 }
3392
3393 /// Build a new C++ reinterpret_cast expression.
3394 ///
3395 /// By default, performs semantic analysis to build the new expression.
3396 /// Subclasses may override this routine to provide different behavior.
3397 ExprResult RebuildCXXReinterpretCastExpr(SourceLocation OpLoc,
3398 SourceLocation LAngleLoc,
3399 TypeSourceInfo *TInfo,
3400 SourceLocation RAngleLoc,
3401 SourceLocation LParenLoc,
3402 Expr *SubExpr,
3403 SourceLocation RParenLoc) {
3404 return getSema().BuildCXXNamedCast(OpLoc, tok::kw_reinterpret_cast,
3405 TInfo, SubExpr,
3406 SourceRange(LAngleLoc, RAngleLoc),
3407 SourceRange(LParenLoc, RParenLoc));
3408 }
3409
3410 /// Build a new C++ const_cast expression.
3411 ///
3412 /// By default, performs semantic analysis to build the new expression.
3413 /// Subclasses may override this routine to provide different behavior.
3414 ExprResult RebuildCXXConstCastExpr(SourceLocation OpLoc,
3415 SourceLocation LAngleLoc,
3416 TypeSourceInfo *TInfo,
3417 SourceLocation RAngleLoc,
3418 SourceLocation LParenLoc,
3419 Expr *SubExpr,
3420 SourceLocation RParenLoc) {
3421 return getSema().BuildCXXNamedCast(OpLoc, tok::kw_const_cast,
3422 TInfo, SubExpr,
3423 SourceRange(LAngleLoc, RAngleLoc),
3424 SourceRange(LParenLoc, RParenLoc));
3425 }
3426
3427 ExprResult
3428 RebuildCXXAddrspaceCastExpr(SourceLocation OpLoc, SourceLocation LAngleLoc,
3429 TypeSourceInfo *TInfo, SourceLocation RAngleLoc,
3430 SourceLocation LParenLoc, Expr *SubExpr,
3431 SourceLocation RParenLoc) {
3432 return getSema().BuildCXXNamedCast(
3433 OpLoc, tok::kw_addrspace_cast, TInfo, SubExpr,
3434 SourceRange(LAngleLoc, RAngleLoc), SourceRange(LParenLoc, RParenLoc));
3435 }
3436
3437 /// Build a new C++ functional-style cast expression.
3438 ///
3439 /// By default, performs semantic analysis to build the new expression.
3440 /// Subclasses may override this routine to provide different behavior.
3441 ExprResult RebuildCXXFunctionalCastExpr(TypeSourceInfo *TInfo,
3442 SourceLocation LParenLoc,
3443 Expr *Sub,
3444 SourceLocation RParenLoc,
3445 bool ListInitialization) {
3446 // If Sub is a ParenListExpr, then Sub is the syntatic form of a
3447 // CXXParenListInitExpr. Pass its expanded arguments so that the
3448 // CXXParenListInitExpr can be rebuilt.
3449 if (auto *PLE = dyn_cast<ParenListExpr>(Val: Sub))
3450 return getSema().BuildCXXTypeConstructExpr(
3451 TInfo, LParenLoc, MultiExprArg(PLE->getExprs(), PLE->getNumExprs()),
3452 RParenLoc, ListInitialization);
3453
3454 if (auto *PLE = dyn_cast<CXXParenListInitExpr>(Val: Sub))
3455 return getSema().BuildCXXTypeConstructExpr(
3456 TInfo, LParenLoc, PLE->getUserSpecifiedInitExprs(), RParenLoc,
3457 ListInitialization);
3458
3459 return getSema().BuildCXXTypeConstructExpr(TInfo, LParenLoc,
3460 MultiExprArg(&Sub, 1), RParenLoc,
3461 ListInitialization);
3462 }
3463
3464 /// Build a new C++ __builtin_bit_cast expression.
3465 ///
3466 /// By default, performs semantic analysis to build the new expression.
3467 /// Subclasses may override this routine to provide different behavior.
3468 ExprResult RebuildBuiltinBitCastExpr(SourceLocation KWLoc,
3469 TypeSourceInfo *TSI, Expr *Sub,
3470 SourceLocation RParenLoc) {
3471 return getSema().BuildBuiltinBitCastExpr(KWLoc, TSI, Sub, RParenLoc);
3472 }
3473
3474 /// Build a new C++ typeid(type) expression.
3475 ///
3476 /// By default, performs semantic analysis to build the new expression.
3477 /// Subclasses may override this routine to provide different behavior.
3478 ExprResult RebuildCXXTypeidExpr(QualType TypeInfoType,
3479 SourceLocation TypeidLoc,
3480 TypeSourceInfo *Operand,
3481 SourceLocation RParenLoc) {
3482 return getSema().BuildCXXTypeId(TypeInfoType, TypeidLoc, Operand,
3483 RParenLoc);
3484 }
3485
3486
3487 /// Build a new C++ typeid(expr) expression.
3488 ///
3489 /// By default, performs semantic analysis to build the new expression.
3490 /// Subclasses may override this routine to provide different behavior.
3491 ExprResult RebuildCXXTypeidExpr(QualType TypeInfoType,
3492 SourceLocation TypeidLoc,
3493 Expr *Operand,
3494 SourceLocation RParenLoc) {
3495 return getSema().BuildCXXTypeId(TypeInfoType, TypeidLoc, Operand,
3496 RParenLoc);
3497 }
3498
3499 /// Build a new C++ __uuidof(type) expression.
3500 ///
3501 /// By default, performs semantic analysis to build the new expression.
3502 /// Subclasses may override this routine to provide different behavior.
3503 ExprResult RebuildCXXUuidofExpr(QualType Type, SourceLocation TypeidLoc,
3504 TypeSourceInfo *Operand,
3505 SourceLocation RParenLoc) {
3506 return getSema().BuildCXXUuidof(Type, TypeidLoc, Operand, RParenLoc);
3507 }
3508
3509 /// Build a new C++ __uuidof(expr) expression.
3510 ///
3511 /// By default, performs semantic analysis to build the new expression.
3512 /// Subclasses may override this routine to provide different behavior.
3513 ExprResult RebuildCXXUuidofExpr(QualType Type, SourceLocation TypeidLoc,
3514 Expr *Operand, SourceLocation RParenLoc) {
3515 return getSema().BuildCXXUuidof(Type, TypeidLoc, Operand, RParenLoc);
3516 }
3517
3518 /// Build a new C++ "this" expression.
3519 ///
3520 /// By default, performs semantic analysis to build a new "this" expression.
3521 /// Subclasses may override this routine to provide different behavior.
3522 ExprResult RebuildCXXThisExpr(SourceLocation ThisLoc,
3523 QualType ThisType,
3524 bool isImplicit) {
3525 if (getSema().CheckCXXThisType(ThisLoc, ThisType))
3526 return ExprError();
3527 return getSema().BuildCXXThisExpr(ThisLoc, ThisType, isImplicit);
3528 }
3529
3530 /// Build a new C++ throw expression.
3531 ///
3532 /// By default, performs semantic analysis to build the new expression.
3533 /// Subclasses may override this routine to provide different behavior.
3534 ExprResult RebuildCXXThrowExpr(SourceLocation ThrowLoc, Expr *Sub,
3535 bool IsThrownVariableInScope) {
3536 return getSema().BuildCXXThrow(ThrowLoc, Sub, IsThrownVariableInScope);
3537 }
3538
3539 /// Build a new C++ default-argument expression.
3540 ///
3541 /// By default, builds a new default-argument expression, which does not
3542 /// require any semantic analysis. Subclasses may override this routine to
3543 /// provide different behavior.
3544 ExprResult RebuildCXXDefaultArgExpr(SourceLocation Loc, ParmVarDecl *Param,
3545 Expr *RewrittenExpr) {
3546 return CXXDefaultArgExpr::Create(C: getSema().Context, Loc, Param,
3547 RewrittenExpr, UsedContext: getSema().CurContext);
3548 }
3549
3550 /// Build a new C++11 default-initialization expression.
3551 ///
3552 /// By default, builds a new default field initialization expression, which
3553 /// does not require any semantic analysis. Subclasses may override this
3554 /// routine to provide different behavior.
3555 ExprResult RebuildCXXDefaultInitExpr(SourceLocation Loc, FieldDecl *Field,
3556 Expr *RewrittenInit) {
3557 return CXXDefaultInitExpr::Create(Ctx: getSema().Context, Loc, Field,
3558 UsedContext: getSema().CurContext, RewrittenInitExpr: RewrittenInit);
3559 }
3560
3561 /// Build a new C++ zero-initialization expression.
3562 ///
3563 /// By default, performs semantic analysis to build the new expression.
3564 /// Subclasses may override this routine to provide different behavior.
3565 ExprResult RebuildCXXScalarValueInitExpr(TypeSourceInfo *TSInfo,
3566 SourceLocation LParenLoc,
3567 SourceLocation RParenLoc) {
3568 return getSema().BuildCXXTypeConstructExpr(TSInfo, LParenLoc, {}, RParenLoc,
3569 /*ListInitialization=*/false);
3570 }
3571
3572 /// Build a new C++ "new" expression.
3573 ///
3574 /// By default, performs semantic analysis to build the new expression.
3575 /// Subclasses may override this routine to provide different behavior.
3576 ExprResult RebuildCXXNewExpr(SourceLocation StartLoc, bool UseGlobal,
3577 SourceLocation PlacementLParen,
3578 MultiExprArg PlacementArgs,
3579 SourceLocation PlacementRParen,
3580 SourceRange TypeIdParens, QualType AllocatedType,
3581 TypeSourceInfo *AllocatedTypeInfo,
3582 std::optional<Expr *> ArraySize,
3583 SourceRange DirectInitRange, Expr *Initializer) {
3584 return getSema().BuildCXXNew(StartLoc, UseGlobal,
3585 PlacementLParen,
3586 PlacementArgs,
3587 PlacementRParen,
3588 TypeIdParens,
3589 AllocatedType,
3590 AllocatedTypeInfo,
3591 ArraySize,
3592 DirectInitRange,
3593 Initializer);
3594 }
3595
3596 /// Build a new C++ "delete" expression.
3597 ///
3598 /// By default, performs semantic analysis to build the new expression.
3599 /// Subclasses may override this routine to provide different behavior.
3600 ExprResult RebuildCXXDeleteExpr(SourceLocation StartLoc,
3601 bool IsGlobalDelete,
3602 bool IsArrayForm,
3603 Expr *Operand) {
3604 return getSema().ActOnCXXDelete(StartLoc, IsGlobalDelete, IsArrayForm,
3605 Operand);
3606 }
3607
3608 /// Build a new type trait expression.
3609 ///
3610 /// By default, performs semantic analysis to build the new expression.
3611 /// Subclasses may override this routine to provide different behavior.
3612 ExprResult RebuildTypeTrait(TypeTrait Trait,
3613 SourceLocation StartLoc,
3614 ArrayRef<TypeSourceInfo *> Args,
3615 SourceLocation RParenLoc) {
3616 return getSema().BuildTypeTrait(Trait, StartLoc, Args, RParenLoc);
3617 }
3618
3619 /// Build a new array type trait expression.
3620 ///
3621 /// By default, performs semantic analysis to build the new expression.
3622 /// Subclasses may override this routine to provide different behavior.
3623 ExprResult RebuildArrayTypeTrait(ArrayTypeTrait Trait,
3624 SourceLocation StartLoc,
3625 TypeSourceInfo *TSInfo,
3626 Expr *DimExpr,
3627 SourceLocation RParenLoc) {
3628 return getSema().BuildArrayTypeTrait(Trait, StartLoc, TSInfo, DimExpr, RParenLoc);
3629 }
3630
3631 /// Build a new expression trait expression.
3632 ///
3633 /// By default, performs semantic analysis to build the new expression.
3634 /// Subclasses may override this routine to provide different behavior.
3635 ExprResult RebuildExpressionTrait(ExpressionTrait Trait,
3636 SourceLocation StartLoc,
3637 Expr *Queried,
3638 SourceLocation RParenLoc) {
3639 return getSema().BuildExpressionTrait(Trait, StartLoc, Queried, RParenLoc);
3640 }
3641
3642 /// Build a new (previously unresolved) declaration reference
3643 /// expression.
3644 ///
3645 /// By default, performs semantic analysis to build the new expression.
3646 /// Subclasses may override this routine to provide different behavior.
3647 ExprResult RebuildDependentScopeDeclRefExpr(
3648 NestedNameSpecifierLoc QualifierLoc,
3649 SourceLocation TemplateKWLoc,
3650 const DeclarationNameInfo &NameInfo,
3651 const TemplateArgumentListInfo *TemplateArgs,
3652 bool IsAddressOfOperand,
3653 TypeSourceInfo **RecoveryTSI) {
3654 CXXScopeSpec SS;
3655 SS.Adopt(Other: QualifierLoc);
3656
3657 if (TemplateArgs || TemplateKWLoc.isValid())
3658 return getSema().BuildQualifiedTemplateIdExpr(
3659 SS, TemplateKWLoc, NameInfo, TemplateArgs, IsAddressOfOperand);
3660
3661 return getSema().BuildQualifiedDeclarationNameExpr(
3662 SS, NameInfo, IsAddressOfOperand, RecoveryTSI);
3663 }
3664
3665 /// Build a new template-id expression.
3666 ///
3667 /// By default, performs semantic analysis to build the new expression.
3668 /// Subclasses may override this routine to provide different behavior.
3669 ExprResult RebuildTemplateIdExpr(const CXXScopeSpec &SS,
3670 SourceLocation TemplateKWLoc,
3671 LookupResult &R,
3672 bool RequiresADL,
3673 const TemplateArgumentListInfo *TemplateArgs) {
3674 return getSema().BuildTemplateIdExpr(SS, TemplateKWLoc, R, RequiresADL,
3675 TemplateArgs);
3676 }
3677
3678 /// Build a new object-construction expression.
3679 ///
3680 /// By default, performs semantic analysis to build the new expression.
3681 /// Subclasses may override this routine to provide different behavior.
3682 ExprResult RebuildCXXConstructExpr(
3683 QualType T, SourceLocation Loc, CXXConstructorDecl *Constructor,
3684 bool IsElidable, MultiExprArg Args, bool HadMultipleCandidates,
3685 bool ListInitialization, bool StdInitListInitialization,
3686 bool RequiresZeroInit, CXXConstructionKind ConstructKind,
3687 SourceRange ParenRange) {
3688 // Reconstruct the constructor we originally found, which might be
3689 // different if this is a call to an inherited constructor.
3690 CXXConstructorDecl *FoundCtor = Constructor;
3691 if (Constructor->isInheritingConstructor())
3692 FoundCtor = Constructor->getInheritedConstructor().getConstructor();
3693
3694 SmallVector<Expr *, 8> ConvertedArgs;
3695 if (getSema().CompleteConstructorCall(FoundCtor, T, Args, Loc,
3696 ConvertedArgs))
3697 return ExprError();
3698
3699 return getSema().BuildCXXConstructExpr(Loc, T, Constructor,
3700 IsElidable,
3701 ConvertedArgs,
3702 HadMultipleCandidates,
3703 ListInitialization,
3704 StdInitListInitialization,
3705 RequiresZeroInit, ConstructKind,
3706 ParenRange);
3707 }
3708
3709 /// Build a new implicit construction via inherited constructor
3710 /// expression.
3711 ExprResult RebuildCXXInheritedCtorInitExpr(QualType T, SourceLocation Loc,
3712 CXXConstructorDecl *Constructor,
3713 bool ConstructsVBase,
3714 bool InheritedFromVBase) {
3715 return new (getSema().Context) CXXInheritedCtorInitExpr(
3716 Loc, T, Constructor, ConstructsVBase, InheritedFromVBase);
3717 }
3718
3719 /// Build a new object-construction expression.
3720 ///
3721 /// By default, performs semantic analysis to build the new expression.
3722 /// Subclasses may override this routine to provide different behavior.
3723 ExprResult RebuildCXXTemporaryObjectExpr(TypeSourceInfo *TSInfo,
3724 SourceLocation LParenOrBraceLoc,
3725 MultiExprArg Args,
3726 SourceLocation RParenOrBraceLoc,
3727 bool ListInitialization) {
3728 return getSema().BuildCXXTypeConstructExpr(
3729 TSInfo, LParenOrBraceLoc, Args, RParenOrBraceLoc, ListInitialization);
3730 }
3731
3732 /// Build a new object-construction expression.
3733 ///
3734 /// By default, performs semantic analysis to build the new expression.
3735 /// Subclasses may override this routine to provide different behavior.
3736 ExprResult RebuildCXXUnresolvedConstructExpr(TypeSourceInfo *TSInfo,
3737 SourceLocation LParenLoc,
3738 MultiExprArg Args,
3739 SourceLocation RParenLoc,
3740 bool ListInitialization) {
3741 return getSema().BuildCXXTypeConstructExpr(TSInfo, LParenLoc, Args,
3742 RParenLoc, ListInitialization);
3743 }
3744
3745 /// Build a new member reference expression.
3746 ///
3747 /// By default, performs semantic analysis to build the new expression.
3748 /// Subclasses may override this routine to provide different behavior.
3749 ExprResult RebuildCXXDependentScopeMemberExpr(Expr *BaseE,
3750 QualType BaseType,
3751 bool IsArrow,
3752 SourceLocation OperatorLoc,
3753 NestedNameSpecifierLoc QualifierLoc,
3754 SourceLocation TemplateKWLoc,
3755 NamedDecl *FirstQualifierInScope,
3756 const DeclarationNameInfo &MemberNameInfo,
3757 const TemplateArgumentListInfo *TemplateArgs) {
3758 CXXScopeSpec SS;
3759 SS.Adopt(Other: QualifierLoc);
3760
3761 return SemaRef.BuildMemberReferenceExpr(Base: BaseE, BaseType,
3762 OpLoc: OperatorLoc, IsArrow,
3763 SS, TemplateKWLoc,
3764 FirstQualifierInScope,
3765 NameInfo: MemberNameInfo,
3766 TemplateArgs, /*S*/S: nullptr);
3767 }
3768
3769 /// Build a new member reference expression.
3770 ///
3771 /// By default, performs semantic analysis to build the new expression.
3772 /// Subclasses may override this routine to provide different behavior.
3773 ExprResult RebuildUnresolvedMemberExpr(Expr *BaseE, QualType BaseType,
3774 SourceLocation OperatorLoc,
3775 bool IsArrow,
3776 NestedNameSpecifierLoc QualifierLoc,
3777 SourceLocation TemplateKWLoc,
3778 NamedDecl *FirstQualifierInScope,
3779 LookupResult &R,
3780 const TemplateArgumentListInfo *TemplateArgs) {
3781 CXXScopeSpec SS;
3782 SS.Adopt(Other: QualifierLoc);
3783
3784 return SemaRef.BuildMemberReferenceExpr(Base: BaseE, BaseType,
3785 OpLoc: OperatorLoc, IsArrow,
3786 SS, TemplateKWLoc,
3787 FirstQualifierInScope,
3788 R, TemplateArgs, /*S*/S: nullptr);
3789 }
3790
3791 /// Build a new noexcept expression.
3792 ///
3793 /// By default, performs semantic analysis to build the new expression.
3794 /// Subclasses may override this routine to provide different behavior.
3795 ExprResult RebuildCXXNoexceptExpr(SourceRange Range, Expr *Arg) {
3796 return SemaRef.BuildCXXNoexceptExpr(KeyLoc: Range.getBegin(), Operand: Arg, RParen: Range.getEnd());
3797 }
3798
3799 UnsignedOrNone
3800 ComputeSizeOfPackExprWithoutSubstitution(ArrayRef<TemplateArgument> PackArgs);
3801
3802 /// Build a new expression to compute the length of a parameter pack.
3803 ExprResult RebuildSizeOfPackExpr(SourceLocation OperatorLoc, NamedDecl *Pack,
3804 SourceLocation PackLoc,
3805 SourceLocation RParenLoc,
3806 UnsignedOrNone Length,
3807 ArrayRef<TemplateArgument> PartialArgs) {
3808 return SizeOfPackExpr::Create(Context&: SemaRef.Context, OperatorLoc, Pack, PackLoc,
3809 RParenLoc, Length, PartialArgs);
3810 }
3811
3812 ExprResult RebuildPackIndexingExpr(SourceLocation EllipsisLoc,
3813 SourceLocation RSquareLoc,
3814 Expr *PackIdExpression, Expr *IndexExpr,
3815 ArrayRef<Expr *> ExpandedExprs,
3816 bool FullySubstituted = false) {
3817 return getSema().BuildPackIndexingExpr(PackIdExpression, EllipsisLoc,
3818 IndexExpr, RSquareLoc, ExpandedExprs,
3819 FullySubstituted);
3820 }
3821
3822 /// Build a new expression representing a call to a source location
3823 /// builtin.
3824 ///
3825 /// By default, performs semantic analysis to build the new expression.
3826 /// Subclasses may override this routine to provide different behavior.
3827 ExprResult RebuildSourceLocExpr(SourceLocIdentKind Kind, QualType ResultTy,
3828 SourceLocation BuiltinLoc,
3829 SourceLocation RPLoc,
3830 DeclContext *ParentContext) {
3831 return getSema().BuildSourceLocExpr(Kind, ResultTy, BuiltinLoc, RPLoc,
3832 ParentContext);
3833 }
3834
3835 ExprResult RebuildConceptSpecializationExpr(NestedNameSpecifierLoc NNS,
3836 SourceLocation TemplateKWLoc, DeclarationNameInfo ConceptNameInfo,
3837 NamedDecl *FoundDecl, ConceptDecl *NamedConcept,
3838 TemplateArgumentListInfo *TALI) {
3839 CXXScopeSpec SS;
3840 SS.Adopt(Other: NNS);
3841 ExprResult Result = getSema().CheckConceptTemplateId(SS, TemplateKWLoc,
3842 ConceptNameInfo,
3843 FoundDecl,
3844 NamedConcept, TALI);
3845 if (Result.isInvalid())
3846 return ExprError();
3847 return Result;
3848 }
3849
3850 /// \brief Build a new requires expression.
3851 ///
3852 /// By default, performs semantic analysis to build the new expression.
3853 /// Subclasses may override this routine to provide different behavior.
3854 ExprResult RebuildRequiresExpr(SourceLocation RequiresKWLoc,
3855 RequiresExprBodyDecl *Body,
3856 SourceLocation LParenLoc,
3857 ArrayRef<ParmVarDecl *> LocalParameters,
3858 SourceLocation RParenLoc,
3859 ArrayRef<concepts::Requirement *> Requirements,
3860 SourceLocation ClosingBraceLoc) {
3861 return RequiresExpr::Create(C&: SemaRef.Context, RequiresKWLoc, Body, LParenLoc,
3862 LocalParameters, RParenLoc, Requirements,
3863 RBraceLoc: ClosingBraceLoc);
3864 }
3865
3866 concepts::TypeRequirement *
3867 RebuildTypeRequirement(
3868 concepts::Requirement::SubstitutionDiagnostic *SubstDiag) {
3869 return SemaRef.BuildTypeRequirement(SubstDiag);
3870 }
3871
3872 concepts::TypeRequirement *RebuildTypeRequirement(TypeSourceInfo *T) {
3873 return SemaRef.BuildTypeRequirement(Type: T);
3874 }
3875
3876 concepts::ExprRequirement *
3877 RebuildExprRequirement(
3878 concepts::Requirement::SubstitutionDiagnostic *SubstDiag, bool IsSimple,
3879 SourceLocation NoexceptLoc,
3880 concepts::ExprRequirement::ReturnTypeRequirement Ret) {
3881 return SemaRef.BuildExprRequirement(ExprSubstDiag: SubstDiag, IsSatisfied: IsSimple, NoexceptLoc,
3882 ReturnTypeRequirement: std::move(Ret));
3883 }
3884
3885 concepts::ExprRequirement *
3886 RebuildExprRequirement(Expr *E, bool IsSimple, SourceLocation NoexceptLoc,
3887 concepts::ExprRequirement::ReturnTypeRequirement Ret) {
3888 return SemaRef.BuildExprRequirement(E, IsSatisfied: IsSimple, NoexceptLoc,
3889 ReturnTypeRequirement: std::move(Ret));
3890 }
3891
3892 concepts::NestedRequirement *
3893 RebuildNestedRequirement(StringRef InvalidConstraintEntity,
3894 const ASTConstraintSatisfaction &Satisfaction) {
3895 return new (getSema().Context)
3896 concepts::NestedRequirement(InvalidConstraintEntity, &Satisfaction);
3897 }
3898
3899 concepts::NestedRequirement *RebuildNestedRequirement(Expr *Constraint) {
3900 return SemaRef.BuildNestedRequirement(E: Constraint);
3901 }
3902
3903 /// \brief Build a new Objective-C boxed expression.
3904 ///
3905 /// By default, performs semantic analysis to build the new expression.
3906 /// Subclasses may override this routine to provide different behavior.
3907 ExprResult RebuildObjCBoxedExpr(SourceRange SR, Expr *ValueExpr) {
3908 return getSema().ObjC().BuildObjCBoxedExpr(SR, ValueExpr);
3909 }
3910
3911 /// Build a new Objective-C array literal.
3912 ///
3913 /// By default, performs semantic analysis to build the new expression.
3914 /// Subclasses may override this routine to provide different behavior.
3915 ExprResult RebuildObjCArrayLiteral(SourceRange Range,
3916 Expr **Elements, unsigned NumElements) {
3917 return getSema().ObjC().BuildObjCArrayLiteral(
3918 Range, MultiExprArg(Elements, NumElements));
3919 }
3920
3921 ExprResult RebuildObjCSubscriptRefExpr(SourceLocation RB,
3922 Expr *Base, Expr *Key,
3923 ObjCMethodDecl *getterMethod,
3924 ObjCMethodDecl *setterMethod) {
3925 return getSema().ObjC().BuildObjCSubscriptExpression(
3926 RB, Base, Key, getterMethod, setterMethod);
3927 }
3928
3929 /// Build a new Objective-C dictionary literal.
3930 ///
3931 /// By default, performs semantic analysis to build the new expression.
3932 /// Subclasses may override this routine to provide different behavior.
3933 ExprResult RebuildObjCDictionaryLiteral(SourceRange Range,
3934 MutableArrayRef<ObjCDictionaryElement> Elements) {
3935 return getSema().ObjC().BuildObjCDictionaryLiteral(Range, Elements);
3936 }
3937
3938 /// Build a new Objective-C \@encode expression.
3939 ///
3940 /// By default, performs semantic analysis to build the new expression.
3941 /// Subclasses may override this routine to provide different behavior.
3942 ExprResult RebuildObjCEncodeExpr(SourceLocation AtLoc,
3943 TypeSourceInfo *EncodeTypeInfo,
3944 SourceLocation RParenLoc) {
3945 return SemaRef.ObjC().BuildObjCEncodeExpression(AtLoc, EncodedTypeInfo: EncodeTypeInfo,
3946 RParenLoc);
3947 }
3948
3949 /// Build a new Objective-C class message.
3950 ExprResult RebuildObjCMessageExpr(TypeSourceInfo *ReceiverTypeInfo,
3951 Selector Sel,
3952 ArrayRef<SourceLocation> SelectorLocs,
3953 ObjCMethodDecl *Method,
3954 SourceLocation LBracLoc,
3955 MultiExprArg Args,
3956 SourceLocation RBracLoc) {
3957 return SemaRef.ObjC().BuildClassMessage(
3958 ReceiverTypeInfo, ReceiverType: ReceiverTypeInfo->getType(),
3959 /*SuperLoc=*/SuperLoc: SourceLocation(), Sel, Method, LBracLoc, SelectorLocs,
3960 RBracLoc, Args);
3961 }
3962
3963 /// Build a new Objective-C instance message.
3964 ExprResult RebuildObjCMessageExpr(Expr *Receiver,
3965 Selector Sel,
3966 ArrayRef<SourceLocation> SelectorLocs,
3967 ObjCMethodDecl *Method,
3968 SourceLocation LBracLoc,
3969 MultiExprArg Args,
3970 SourceLocation RBracLoc) {
3971 return SemaRef.ObjC().BuildInstanceMessage(Receiver, ReceiverType: Receiver->getType(),
3972 /*SuperLoc=*/SuperLoc: SourceLocation(),
3973 Sel, Method, LBracLoc,
3974 SelectorLocs, RBracLoc, Args);
3975 }
3976
3977 /// Build a new Objective-C instance/class message to 'super'.
3978 ExprResult RebuildObjCMessageExpr(SourceLocation SuperLoc,
3979 Selector Sel,
3980 ArrayRef<SourceLocation> SelectorLocs,
3981 QualType SuperType,
3982 ObjCMethodDecl *Method,
3983 SourceLocation LBracLoc,
3984 MultiExprArg Args,
3985 SourceLocation RBracLoc) {
3986 return Method->isInstanceMethod()
3987 ? SemaRef.ObjC().BuildInstanceMessage(
3988 Receiver: nullptr, ReceiverType: SuperType, SuperLoc, Sel, Method, LBracLoc,
3989 SelectorLocs, RBracLoc, Args)
3990 : SemaRef.ObjC().BuildClassMessage(ReceiverTypeInfo: nullptr, ReceiverType: SuperType, SuperLoc,
3991 Sel, Method, LBracLoc,
3992 SelectorLocs, RBracLoc, Args);
3993 }
3994
3995 /// Build a new Objective-C ivar reference expression.
3996 ///
3997 /// By default, performs semantic analysis to build the new expression.
3998 /// Subclasses may override this routine to provide different behavior.
3999 ExprResult RebuildObjCIvarRefExpr(Expr *BaseArg, ObjCIvarDecl *Ivar,
4000 SourceLocation IvarLoc,
4001 bool IsArrow, bool IsFreeIvar) {
4002 CXXScopeSpec SS;
4003 DeclarationNameInfo NameInfo(Ivar->getDeclName(), IvarLoc);
4004 ExprResult Result = getSema().BuildMemberReferenceExpr(
4005 BaseArg, BaseArg->getType(),
4006 /*FIXME:*/ IvarLoc, IsArrow, SS, SourceLocation(),
4007 /*FirstQualifierInScope=*/nullptr, NameInfo,
4008 /*TemplateArgs=*/nullptr,
4009 /*S=*/nullptr);
4010 if (IsFreeIvar && Result.isUsable())
4011 cast<ObjCIvarRefExpr>(Val: Result.get())->setIsFreeIvar(IsFreeIvar);
4012 return Result;
4013 }
4014
4015 /// Build a new Objective-C property reference expression.
4016 ///
4017 /// By default, performs semantic analysis to build the new expression.
4018 /// Subclasses may override this routine to provide different behavior.
4019 ExprResult RebuildObjCPropertyRefExpr(Expr *BaseArg,
4020 ObjCPropertyDecl *Property,
4021 SourceLocation PropertyLoc) {
4022 CXXScopeSpec SS;
4023 DeclarationNameInfo NameInfo(Property->getDeclName(), PropertyLoc);
4024 return getSema().BuildMemberReferenceExpr(BaseArg, BaseArg->getType(),
4025 /*FIXME:*/PropertyLoc,
4026 /*IsArrow=*/false,
4027 SS, SourceLocation(),
4028 /*FirstQualifierInScope=*/nullptr,
4029 NameInfo,
4030 /*TemplateArgs=*/nullptr,
4031 /*S=*/nullptr);
4032 }
4033
4034 /// Build a new Objective-C property reference expression.
4035 ///
4036 /// By default, performs semantic analysis to build the new expression.
4037 /// Subclasses may override this routine to provide different behavior.
4038 ExprResult RebuildObjCPropertyRefExpr(Expr *Base, QualType T,
4039 ObjCMethodDecl *Getter,
4040 ObjCMethodDecl *Setter,
4041 SourceLocation PropertyLoc) {
4042 // Since these expressions can only be value-dependent, we do not
4043 // need to perform semantic analysis again.
4044 return Owned(
4045 new (getSema().Context) ObjCPropertyRefExpr(Getter, Setter, T,
4046 VK_LValue, OK_ObjCProperty,
4047 PropertyLoc, Base));
4048 }
4049
4050 /// Build a new Objective-C "isa" expression.
4051 ///
4052 /// By default, performs semantic analysis to build the new expression.
4053 /// Subclasses may override this routine to provide different behavior.
4054 ExprResult RebuildObjCIsaExpr(Expr *BaseArg, SourceLocation IsaLoc,
4055 SourceLocation OpLoc, bool IsArrow) {
4056 CXXScopeSpec SS;
4057 DeclarationNameInfo NameInfo(&getSema().Context.Idents.get("isa"), IsaLoc);
4058 return getSema().BuildMemberReferenceExpr(BaseArg, BaseArg->getType(),
4059 OpLoc, IsArrow,
4060 SS, SourceLocation(),
4061 /*FirstQualifierInScope=*/nullptr,
4062 NameInfo,
4063 /*TemplateArgs=*/nullptr,
4064 /*S=*/nullptr);
4065 }
4066
4067 /// Build a new shuffle vector expression.
4068 ///
4069 /// By default, performs semantic analysis to build the new expression.
4070 /// Subclasses may override this routine to provide different behavior.
4071 ExprResult RebuildShuffleVectorExpr(SourceLocation BuiltinLoc,
4072 MultiExprArg SubExprs,
4073 SourceLocation RParenLoc) {
4074 // Find the declaration for __builtin_shufflevector
4075 const IdentifierInfo &Name
4076 = SemaRef.Context.Idents.get(Name: "__builtin_shufflevector");
4077 TranslationUnitDecl *TUDecl = SemaRef.Context.getTranslationUnitDecl();
4078 DeclContext::lookup_result Lookup = TUDecl->lookup(Name: DeclarationName(&Name));
4079 assert(!Lookup.empty() && "No __builtin_shufflevector?");
4080
4081 // Build a reference to the __builtin_shufflevector builtin
4082 FunctionDecl *Builtin = cast<FunctionDecl>(Val: Lookup.front());
4083 Expr *Callee = new (SemaRef.Context)
4084 DeclRefExpr(SemaRef.Context, Builtin, false,
4085 SemaRef.Context.BuiltinFnTy, VK_PRValue, BuiltinLoc);
4086 QualType CalleePtrTy = SemaRef.Context.getPointerType(T: Builtin->getType());
4087 Callee = SemaRef.ImpCastExprToType(E: Callee, Type: CalleePtrTy,
4088 CK: CK_BuiltinFnToFnPtr).get();
4089
4090 // Build the CallExpr
4091 ExprResult TheCall = CallExpr::Create(
4092 Ctx: SemaRef.Context, Fn: Callee, Args: SubExprs, Ty: Builtin->getCallResultType(),
4093 VK: Expr::getValueKindForType(T: Builtin->getReturnType()), RParenLoc,
4094 FPFeatures: FPOptionsOverride());
4095
4096 // Type-check the __builtin_shufflevector expression.
4097 return SemaRef.BuiltinShuffleVector(TheCall: cast<CallExpr>(Val: TheCall.get()));
4098 }
4099
4100 /// Build a new convert vector expression.
4101 ExprResult RebuildConvertVectorExpr(SourceLocation BuiltinLoc,
4102 Expr *SrcExpr, TypeSourceInfo *DstTInfo,
4103 SourceLocation RParenLoc) {
4104 return SemaRef.ConvertVectorExpr(E: SrcExpr, TInfo: DstTInfo, BuiltinLoc, RParenLoc);
4105 }
4106
4107 /// Build a new template argument pack expansion.
4108 ///
4109 /// By default, performs semantic analysis to build a new pack expansion
4110 /// for a template argument. Subclasses may override this routine to provide
4111 /// different behavior.
4112 TemplateArgumentLoc RebuildPackExpansion(TemplateArgumentLoc Pattern,
4113 SourceLocation EllipsisLoc,
4114 UnsignedOrNone NumExpansions) {
4115 switch (Pattern.getArgument().getKind()) {
4116 case TemplateArgument::Expression: {
4117 ExprResult Result
4118 = getSema().CheckPackExpansion(Pattern.getSourceExpression(),
4119 EllipsisLoc, NumExpansions);
4120 if (Result.isInvalid())
4121 return TemplateArgumentLoc();
4122
4123 return TemplateArgumentLoc(TemplateArgument(Result.get(),
4124 /*IsCanonical=*/false),
4125 Result.get());
4126 }
4127
4128 case TemplateArgument::Template:
4129 return TemplateArgumentLoc(
4130 SemaRef.Context,
4131 TemplateArgument(Pattern.getArgument().getAsTemplate(),
4132 NumExpansions),
4133 Pattern.getTemplateKWLoc(), Pattern.getTemplateQualifierLoc(),
4134 Pattern.getTemplateNameLoc(), EllipsisLoc);
4135
4136 case TemplateArgument::Null:
4137 case TemplateArgument::Integral:
4138 case TemplateArgument::Declaration:
4139 case TemplateArgument::StructuralValue:
4140 case TemplateArgument::Pack:
4141 case TemplateArgument::TemplateExpansion:
4142 case TemplateArgument::NullPtr:
4143 llvm_unreachable("Pack expansion pattern has no parameter packs");
4144
4145 case TemplateArgument::Type:
4146 if (TypeSourceInfo *Expansion
4147 = getSema().CheckPackExpansion(Pattern.getTypeSourceInfo(),
4148 EllipsisLoc,
4149 NumExpansions))
4150 return TemplateArgumentLoc(TemplateArgument(Expansion->getType()),
4151 Expansion);
4152 break;
4153 }
4154
4155 return TemplateArgumentLoc();
4156 }
4157
4158 /// Build a new expression pack expansion.
4159 ///
4160 /// By default, performs semantic analysis to build a new pack expansion
4161 /// for an expression. Subclasses may override this routine to provide
4162 /// different behavior.
4163 ExprResult RebuildPackExpansion(Expr *Pattern, SourceLocation EllipsisLoc,
4164 UnsignedOrNone NumExpansions) {
4165 return getSema().CheckPackExpansion(Pattern, EllipsisLoc, NumExpansions);
4166 }
4167
4168 /// Build a new C++1z fold-expression.
4169 ///
4170 /// By default, performs semantic analysis in order to build a new fold
4171 /// expression.
4172 ExprResult RebuildCXXFoldExpr(UnresolvedLookupExpr *ULE,
4173 SourceLocation LParenLoc, Expr *LHS,
4174 BinaryOperatorKind Operator,
4175 SourceLocation EllipsisLoc, Expr *RHS,
4176 SourceLocation RParenLoc,
4177 UnsignedOrNone NumExpansions) {
4178 return getSema().BuildCXXFoldExpr(ULE, LParenLoc, LHS, Operator,
4179 EllipsisLoc, RHS, RParenLoc,
4180 NumExpansions);
4181 }
4182
4183 ExprResult RebuildLambdaExpr(SourceLocation StartLoc, SourceLocation EndLoc,
4184 LambdaScopeInfo *LSI) {
4185 for (ParmVarDecl *PVD : LSI->CallOperator->parameters()) {
4186 if (Expr *Init = PVD->getInit())
4187 LSI->ContainsUnexpandedParameterPack |=
4188 Init->containsUnexpandedParameterPack();
4189 else if (PVD->hasUninstantiatedDefaultArg())
4190 LSI->ContainsUnexpandedParameterPack |=
4191 PVD->getUninstantiatedDefaultArg()
4192 ->containsUnexpandedParameterPack();
4193 }
4194 return getSema().BuildLambdaExpr(StartLoc, EndLoc);
4195 }
4196
4197 /// Build an empty C++1z fold-expression with the given operator.
4198 ///
4199 /// By default, produces the fallback value for the fold-expression, or
4200 /// produce an error if there is no fallback value.
4201 ExprResult RebuildEmptyCXXFoldExpr(SourceLocation EllipsisLoc,
4202 BinaryOperatorKind Operator) {
4203 return getSema().BuildEmptyCXXFoldExpr(EllipsisLoc, Operator);
4204 }
4205
4206 /// Build a new atomic operation expression.
4207 ///
4208 /// By default, performs semantic analysis to build the new expression.
4209 /// Subclasses may override this routine to provide different behavior.
4210 ExprResult RebuildAtomicExpr(SourceLocation BuiltinLoc, MultiExprArg SubExprs,
4211 AtomicExpr::AtomicOp Op,
4212 SourceLocation RParenLoc) {
4213 // Use this for all of the locations, since we don't know the difference
4214 // between the call and the expr at this point.
4215 SourceRange Range{BuiltinLoc, RParenLoc};
4216 return getSema().BuildAtomicExpr(Range, Range, RParenLoc, SubExprs, Op,
4217 Sema::AtomicArgumentOrder::AST);
4218 }
4219
4220 ExprResult RebuildRecoveryExpr(SourceLocation BeginLoc, SourceLocation EndLoc,
4221 ArrayRef<Expr *> SubExprs, QualType Type) {
4222 return getSema().CreateRecoveryExpr(BeginLoc, EndLoc, SubExprs, Type);
4223 }
4224
4225 StmtResult RebuildOpenACCComputeConstruct(OpenACCDirectiveKind K,
4226 SourceLocation BeginLoc,
4227 SourceLocation DirLoc,
4228 SourceLocation EndLoc,
4229 ArrayRef<OpenACCClause *> Clauses,
4230 StmtResult StrBlock) {
4231 return getSema().OpenACC().ActOnEndStmtDirective(
4232 K, BeginLoc, DirLoc, SourceLocation{}, SourceLocation{}, {},
4233 OpenACCAtomicKind::None, SourceLocation{}, EndLoc, Clauses, StrBlock);
4234 }
4235
4236 StmtResult RebuildOpenACCLoopConstruct(SourceLocation BeginLoc,
4237 SourceLocation DirLoc,
4238 SourceLocation EndLoc,
4239 ArrayRef<OpenACCClause *> Clauses,
4240 StmtResult Loop) {
4241 return getSema().OpenACC().ActOnEndStmtDirective(
4242 OpenACCDirectiveKind::Loop, BeginLoc, DirLoc, SourceLocation{},
4243 SourceLocation{}, {}, OpenACCAtomicKind::None, SourceLocation{}, EndLoc,
4244 Clauses, Loop);
4245 }
4246
4247 StmtResult RebuildOpenACCCombinedConstruct(OpenACCDirectiveKind K,
4248 SourceLocation BeginLoc,
4249 SourceLocation DirLoc,
4250 SourceLocation EndLoc,
4251 ArrayRef<OpenACCClause *> Clauses,
4252 StmtResult Loop) {
4253 return getSema().OpenACC().ActOnEndStmtDirective(
4254 K, BeginLoc, DirLoc, SourceLocation{}, SourceLocation{}, {},
4255 OpenACCAtomicKind::None, SourceLocation{}, EndLoc, Clauses, Loop);
4256 }
4257
4258 StmtResult RebuildOpenACCDataConstruct(SourceLocation BeginLoc,
4259 SourceLocation DirLoc,
4260 SourceLocation EndLoc,
4261 ArrayRef<OpenACCClause *> Clauses,
4262 StmtResult StrBlock) {
4263 return getSema().OpenACC().ActOnEndStmtDirective(
4264 OpenACCDirectiveKind::Data, BeginLoc, DirLoc, SourceLocation{},
4265 SourceLocation{}, {}, OpenACCAtomicKind::None, SourceLocation{}, EndLoc,
4266 Clauses, StrBlock);
4267 }
4268
4269 StmtResult
4270 RebuildOpenACCEnterDataConstruct(SourceLocation BeginLoc,
4271 SourceLocation DirLoc, SourceLocation EndLoc,
4272 ArrayRef<OpenACCClause *> Clauses) {
4273 return getSema().OpenACC().ActOnEndStmtDirective(
4274 OpenACCDirectiveKind::EnterData, BeginLoc, DirLoc, SourceLocation{},
4275 SourceLocation{}, {}, OpenACCAtomicKind::None, SourceLocation{}, EndLoc,
4276 Clauses, {});
4277 }
4278
4279 StmtResult
4280 RebuildOpenACCExitDataConstruct(SourceLocation BeginLoc,
4281 SourceLocation DirLoc, SourceLocation EndLoc,
4282 ArrayRef<OpenACCClause *> Clauses) {
4283 return getSema().OpenACC().ActOnEndStmtDirective(
4284 OpenACCDirectiveKind::ExitData, BeginLoc, DirLoc, SourceLocation{},
4285 SourceLocation{}, {}, OpenACCAtomicKind::None, SourceLocation{}, EndLoc,
4286 Clauses, {});
4287 }
4288
4289 StmtResult RebuildOpenACCHostDataConstruct(SourceLocation BeginLoc,
4290 SourceLocation DirLoc,
4291 SourceLocation EndLoc,
4292 ArrayRef<OpenACCClause *> Clauses,
4293 StmtResult StrBlock) {
4294 return getSema().OpenACC().ActOnEndStmtDirective(
4295 OpenACCDirectiveKind::HostData, BeginLoc, DirLoc, SourceLocation{},
4296 SourceLocation{}, {}, OpenACCAtomicKind::None, SourceLocation{}, EndLoc,
4297 Clauses, StrBlock);
4298 }
4299
4300 StmtResult RebuildOpenACCInitConstruct(SourceLocation BeginLoc,
4301 SourceLocation DirLoc,
4302 SourceLocation EndLoc,
4303 ArrayRef<OpenACCClause *> Clauses) {
4304 return getSema().OpenACC().ActOnEndStmtDirective(
4305 OpenACCDirectiveKind::Init, BeginLoc, DirLoc, SourceLocation{},
4306 SourceLocation{}, {}, OpenACCAtomicKind::None, SourceLocation{}, EndLoc,
4307 Clauses, {});
4308 }
4309
4310 StmtResult
4311 RebuildOpenACCShutdownConstruct(SourceLocation BeginLoc,
4312 SourceLocation DirLoc, SourceLocation EndLoc,
4313 ArrayRef<OpenACCClause *> Clauses) {
4314 return getSema().OpenACC().ActOnEndStmtDirective(
4315 OpenACCDirectiveKind::Shutdown, BeginLoc, DirLoc, SourceLocation{},
4316 SourceLocation{}, {}, OpenACCAtomicKind::None, SourceLocation{}, EndLoc,
4317 Clauses, {});
4318 }
4319
4320 StmtResult RebuildOpenACCSetConstruct(SourceLocation BeginLoc,
4321 SourceLocation DirLoc,
4322 SourceLocation EndLoc,
4323 ArrayRef<OpenACCClause *> Clauses) {
4324 return getSema().OpenACC().ActOnEndStmtDirective(
4325 OpenACCDirectiveKind::Set, BeginLoc, DirLoc, SourceLocation{},
4326 SourceLocation{}, {}, OpenACCAtomicKind::None, SourceLocation{}, EndLoc,
4327 Clauses, {});
4328 }
4329
4330 StmtResult RebuildOpenACCUpdateConstruct(SourceLocation BeginLoc,
4331 SourceLocation DirLoc,
4332 SourceLocation EndLoc,
4333 ArrayRef<OpenACCClause *> Clauses) {
4334 return getSema().OpenACC().ActOnEndStmtDirective(
4335 OpenACCDirectiveKind::Update, BeginLoc, DirLoc, SourceLocation{},
4336 SourceLocation{}, {}, OpenACCAtomicKind::None, SourceLocation{}, EndLoc,
4337 Clauses, {});
4338 }
4339
4340 StmtResult RebuildOpenACCWaitConstruct(
4341 SourceLocation BeginLoc, SourceLocation DirLoc, SourceLocation LParenLoc,
4342 Expr *DevNumExpr, SourceLocation QueuesLoc, ArrayRef<Expr *> QueueIdExprs,
4343 SourceLocation RParenLoc, SourceLocation EndLoc,
4344 ArrayRef<OpenACCClause *> Clauses) {
4345 llvm::SmallVector<Expr *> Exprs;
4346 Exprs.push_back(Elt: DevNumExpr);
4347 llvm::append_range(C&: Exprs, R&: QueueIdExprs);
4348 return getSema().OpenACC().ActOnEndStmtDirective(
4349 OpenACCDirectiveKind::Wait, BeginLoc, DirLoc, LParenLoc, QueuesLoc,
4350 Exprs, OpenACCAtomicKind::None, RParenLoc, EndLoc, Clauses, {});
4351 }
4352
4353 StmtResult RebuildOpenACCCacheConstruct(
4354 SourceLocation BeginLoc, SourceLocation DirLoc, SourceLocation LParenLoc,
4355 SourceLocation ReadOnlyLoc, ArrayRef<Expr *> VarList,
4356 SourceLocation RParenLoc, SourceLocation EndLoc) {
4357 return getSema().OpenACC().ActOnEndStmtDirective(
4358 OpenACCDirectiveKind::Cache, BeginLoc, DirLoc, LParenLoc, ReadOnlyLoc,
4359 VarList, OpenACCAtomicKind::None, RParenLoc, EndLoc, {}, {});
4360 }
4361
4362 StmtResult RebuildOpenACCAtomicConstruct(SourceLocation BeginLoc,
4363 SourceLocation DirLoc,
4364 OpenACCAtomicKind AtKind,
4365 SourceLocation EndLoc,
4366 ArrayRef<OpenACCClause *> Clauses,
4367 StmtResult AssociatedStmt) {
4368 return getSema().OpenACC().ActOnEndStmtDirective(
4369 OpenACCDirectiveKind::Atomic, BeginLoc, DirLoc, SourceLocation{},
4370 SourceLocation{}, {}, AtKind, SourceLocation{}, EndLoc, Clauses,
4371 AssociatedStmt);
4372 }
4373
4374 ExprResult RebuildOpenACCAsteriskSizeExpr(SourceLocation AsteriskLoc) {
4375 return getSema().OpenACC().ActOnOpenACCAsteriskSizeExpr(AsteriskLoc);
4376 }
4377
4378 ExprResult
4379 RebuildSubstNonTypeTemplateParmExpr(Decl *AssociatedDecl, unsigned Index,
4380 QualType ParamType, SourceLocation Loc,
4381 TemplateArgument Arg,
4382 UnsignedOrNone PackIndex, bool Final) {
4383 return getSema().BuildSubstNonTypeTemplateParmExpr(
4384 AssociatedDecl, Index, ParamType, Loc, Arg, PackIndex, Final);
4385 }
4386
4387 OMPClause *RebuildOpenMPTransparentClause(Expr *ImpexType,
4388 SourceLocation StartLoc,
4389 SourceLocation LParenLoc,
4390 SourceLocation EndLoc) {
4391 return getSema().OpenMP().ActOnOpenMPTransparentClause(ImpexType, StartLoc,
4392 LParenLoc, EndLoc);
4393 }
4394
4395private:
4396 QualType TransformTypeInObjectScope(TypeLocBuilder &TLB, TypeLoc TL,
4397 QualType ObjectType,
4398 NamedDecl *FirstQualifierInScope);
4399
4400 TypeSourceInfo *TransformTypeInObjectScope(TypeSourceInfo *TSInfo,
4401 QualType ObjectType,
4402 NamedDecl *FirstQualifierInScope) {
4403 if (getDerived().AlreadyTransformed(TSInfo->getType()))
4404 return TSInfo;
4405
4406 TypeLocBuilder TLB;
4407 QualType T = TransformTypeInObjectScope(TLB, TSInfo->getTypeLoc(),
4408 ObjectType, FirstQualifierInScope);
4409 if (T.isNull())
4410 return nullptr;
4411 return TLB.getTypeSourceInfo(Context&: SemaRef.Context, T);
4412 }
4413
4414 QualType TransformDependentNameType(TypeLocBuilder &TLB,
4415 DependentNameTypeLoc TL,
4416 bool DeducibleTSTContext,
4417 QualType ObjectType = QualType(),
4418 NamedDecl *UnqualLookup = nullptr);
4419
4420 llvm::SmallVector<OpenACCClause *>
4421 TransformOpenACCClauseList(OpenACCDirectiveKind DirKind,
4422 ArrayRef<const OpenACCClause *> OldClauses);
4423
4424 OpenACCClause *
4425 TransformOpenACCClause(ArrayRef<const OpenACCClause *> ExistingClauses,
4426 OpenACCDirectiveKind DirKind,
4427 const OpenACCClause *OldClause);
4428};
4429
4430template <typename Derived>
4431StmtResult TreeTransform<Derived>::TransformStmt(Stmt *S, StmtDiscardKind SDK) {
4432 if (!S)
4433 return S;
4434
4435 switch (S->getStmtClass()) {
4436 case Stmt::NoStmtClass: break;
4437
4438 // Transform individual statement nodes
4439 // Pass SDK into statements that can produce a value
4440#define STMT(Node, Parent) \
4441 case Stmt::Node##Class: return getDerived().Transform##Node(cast<Node>(S));
4442#define VALUESTMT(Node, Parent) \
4443 case Stmt::Node##Class: \
4444 return getDerived().Transform##Node(cast<Node>(S), SDK);
4445#define ABSTRACT_STMT(Node)
4446#define EXPR(Node, Parent)
4447#include "clang/AST/StmtNodes.inc"
4448
4449 // Transform expressions by calling TransformExpr.
4450#define STMT(Node, Parent)
4451#define ABSTRACT_STMT(Stmt)
4452#define EXPR(Node, Parent) case Stmt::Node##Class:
4453#include "clang/AST/StmtNodes.inc"
4454 {
4455 ExprResult E = getDerived().TransformExpr(cast<Expr>(Val: S));
4456
4457 if (SDK == StmtDiscardKind::StmtExprResult)
4458 E = getSema().ActOnStmtExprResult(E);
4459 return getSema().ActOnExprStmt(E, SDK == StmtDiscardKind::Discarded);
4460 }
4461 }
4462
4463 return S;
4464}
4465
4466template<typename Derived>
4467OMPClause *TreeTransform<Derived>::TransformOMPClause(OMPClause *S) {
4468 if (!S)
4469 return S;
4470
4471 switch (S->getClauseKind()) {
4472 default: break;
4473 // Transform individual clause nodes
4474#define GEN_CLANG_CLAUSE_CLASS
4475#define CLAUSE_CLASS(Enum, Str, Class) \
4476 case Enum: \
4477 return getDerived().Transform##Class(cast<Class>(S));
4478#include "llvm/Frontend/OpenMP/OMP.inc"
4479 }
4480
4481 return S;
4482}
4483
4484
4485template<typename Derived>
4486ExprResult TreeTransform<Derived>::TransformExpr(Expr *E) {
4487 if (!E)
4488 return E;
4489
4490 switch (E->getStmtClass()) {
4491 case Stmt::NoStmtClass: break;
4492#define STMT(Node, Parent) case Stmt::Node##Class: break;
4493#define ABSTRACT_STMT(Stmt)
4494#define EXPR(Node, Parent) \
4495 case Stmt::Node##Class: return getDerived().Transform##Node(cast<Node>(E));
4496#include "clang/AST/StmtNodes.inc"
4497 }
4498
4499 return E;
4500}
4501
4502template<typename Derived>
4503ExprResult TreeTransform<Derived>::TransformInitializer(Expr *Init,
4504 bool NotCopyInit) {
4505 // Initializers are instantiated like expressions, except that various outer
4506 // layers are stripped.
4507 if (!Init)
4508 return Init;
4509
4510 if (auto *FE = dyn_cast<FullExpr>(Val: Init))
4511 Init = FE->getSubExpr();
4512
4513 if (auto *AIL = dyn_cast<ArrayInitLoopExpr>(Val: Init)) {
4514 OpaqueValueExpr *OVE = AIL->getCommonExpr();
4515 Init = OVE->getSourceExpr();
4516 }
4517
4518 if (MaterializeTemporaryExpr *MTE = dyn_cast<MaterializeTemporaryExpr>(Val: Init))
4519 Init = MTE->getSubExpr();
4520
4521 while (CXXBindTemporaryExpr *Binder = dyn_cast<CXXBindTemporaryExpr>(Val: Init))
4522 Init = Binder->getSubExpr();
4523
4524 if (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(Val: Init))
4525 Init = ICE->getSubExprAsWritten();
4526
4527 if (CXXStdInitializerListExpr *ILE =
4528 dyn_cast<CXXStdInitializerListExpr>(Val: Init))
4529 return TransformInitializer(Init: ILE->getSubExpr(), NotCopyInit);
4530
4531 // If this is copy-initialization, we only need to reconstruct
4532 // InitListExprs. Other forms of copy-initialization will be a no-op if
4533 // the initializer is already the right type.
4534 CXXConstructExpr *Construct = dyn_cast<CXXConstructExpr>(Val: Init);
4535 if (!NotCopyInit && !(Construct && Construct->isListInitialization()))
4536 return getDerived().TransformExpr(Init);
4537
4538 // Revert value-initialization back to empty parens.
4539 if (CXXScalarValueInitExpr *VIE = dyn_cast<CXXScalarValueInitExpr>(Val: Init)) {
4540 SourceRange Parens = VIE->getSourceRange();
4541 return getDerived().RebuildParenListExpr(Parens.getBegin(), {},
4542 Parens.getEnd());
4543 }
4544
4545 // FIXME: We shouldn't build ImplicitValueInitExprs for direct-initialization.
4546 if (isa<ImplicitValueInitExpr>(Val: Init))
4547 return getDerived().RebuildParenListExpr(SourceLocation(), {},
4548 SourceLocation());
4549
4550 // Revert initialization by constructor back to a parenthesized or braced list
4551 // of expressions. Any other form of initializer can just be reused directly.
4552 if (!Construct || isa<CXXTemporaryObjectExpr>(Val: Construct))
4553 return getDerived().TransformExpr(Init);
4554
4555 // If the initialization implicitly converted an initializer list to a
4556 // std::initializer_list object, unwrap the std::initializer_list too.
4557 if (Construct && Construct->isStdInitListInitialization())
4558 return TransformInitializer(Init: Construct->getArg(Arg: 0), NotCopyInit);
4559
4560 // Enter a list-init context if this was list initialization.
4561 EnterExpressionEvaluationContext Context(
4562 getSema(), EnterExpressionEvaluationContext::InitList,
4563 Construct->isListInitialization());
4564
4565 getSema().currentEvaluationContext().InLifetimeExtendingContext =
4566 getSema().parentEvaluationContext().InLifetimeExtendingContext;
4567 getSema().currentEvaluationContext().RebuildDefaultArgOrDefaultInit =
4568 getSema().parentEvaluationContext().RebuildDefaultArgOrDefaultInit;
4569 SmallVector<Expr*, 8> NewArgs;
4570 bool ArgChanged = false;
4571 if (getDerived().TransformExprs(Construct->getArgs(), Construct->getNumArgs(),
4572 /*IsCall*/true, NewArgs, &ArgChanged))
4573 return ExprError();
4574
4575 // If this was list initialization, revert to syntactic list form.
4576 if (Construct->isListInitialization())
4577 return getDerived().RebuildInitList(Construct->getBeginLoc(), NewArgs,
4578 Construct->getEndLoc(),
4579 /*IsExplicit=*/true);
4580
4581 // Build a ParenListExpr to represent anything else.
4582 SourceRange Parens = Construct->getParenOrBraceRange();
4583 if (Parens.isInvalid()) {
4584 // This was a variable declaration's initialization for which no initializer
4585 // was specified.
4586 assert(NewArgs.empty() &&
4587 "no parens or braces but have direct init with arguments?");
4588 return ExprEmpty();
4589 }
4590 return getDerived().RebuildParenListExpr(Parens.getBegin(), NewArgs,
4591 Parens.getEnd());
4592}
4593
4594template<typename Derived>
4595bool TreeTransform<Derived>::TransformExprs(Expr *const *Inputs,
4596 unsigned NumInputs,
4597 bool IsCall,
4598 SmallVectorImpl<Expr *> &Outputs,
4599 bool *ArgChanged) {
4600 for (unsigned I = 0; I != NumInputs; ++I) {
4601 // If requested, drop call arguments that need to be dropped.
4602 if (IsCall && getDerived().DropCallArgument(Inputs[I])) {
4603 if (ArgChanged)
4604 *ArgChanged = true;
4605
4606 break;
4607 }
4608
4609 if (PackExpansionExpr *Expansion = dyn_cast<PackExpansionExpr>(Val: Inputs[I])) {
4610 Expr *Pattern = Expansion->getPattern();
4611
4612 SmallVector<UnexpandedParameterPack, 2> Unexpanded;
4613 getSema().collectUnexpandedParameterPacks(Pattern, Unexpanded);
4614 assert(!Unexpanded.empty() && "Pack expansion without parameter packs?");
4615
4616 // Determine whether the set of unexpanded parameter packs can and should
4617 // be expanded.
4618 bool Expand = true;
4619 bool RetainExpansion = false;
4620 UnsignedOrNone OrigNumExpansions = Expansion->getNumExpansions();
4621 UnsignedOrNone NumExpansions = OrigNumExpansions;
4622 if (getDerived().TryExpandParameterPacks(
4623 Expansion->getEllipsisLoc(), Pattern->getSourceRange(),
4624 Unexpanded, /*FailOnPackProducingTemplates=*/true, Expand,
4625 RetainExpansion, NumExpansions))
4626 return true;
4627
4628 if (!Expand) {
4629 // The transform has determined that we should perform a simple
4630 // transformation on the pack expansion, producing another pack
4631 // expansion.
4632 Sema::ArgPackSubstIndexRAII SubstIndex(getSema(), std::nullopt);
4633 ExprResult OutPattern = getDerived().TransformExpr(Pattern);
4634 if (OutPattern.isInvalid())
4635 return true;
4636
4637 ExprResult Out = getDerived().RebuildPackExpansion(OutPattern.get(),
4638 Expansion->getEllipsisLoc(),
4639 NumExpansions);
4640 if (Out.isInvalid())
4641 return true;
4642
4643 if (ArgChanged)
4644 *ArgChanged = true;
4645 Outputs.push_back(Elt: Out.get());
4646 continue;
4647 }
4648
4649 // Record right away that the argument was changed. This needs
4650 // to happen even if the array expands to nothing.
4651 if (ArgChanged) *ArgChanged = true;
4652
4653 // The transform has determined that we should perform an elementwise
4654 // expansion of the pattern. Do so.
4655 for (unsigned I = 0; I != *NumExpansions; ++I) {
4656 Sema::ArgPackSubstIndexRAII SubstIndex(getSema(), I);
4657 ExprResult Out = getDerived().TransformExpr(Pattern);
4658 if (Out.isInvalid())
4659 return true;
4660
4661 if (Out.get()->containsUnexpandedParameterPack()) {
4662 Out = getDerived().RebuildPackExpansion(
4663 Out.get(), Expansion->getEllipsisLoc(), OrigNumExpansions);
4664 if (Out.isInvalid())
4665 return true;
4666 }
4667
4668 Outputs.push_back(Elt: Out.get());
4669 }
4670
4671 // If we're supposed to retain a pack expansion, do so by temporarily
4672 // forgetting the partially-substituted parameter pack.
4673 if (RetainExpansion) {
4674 ForgetPartiallySubstitutedPackRAII Forget(getDerived());
4675
4676 ExprResult Out = getDerived().TransformExpr(Pattern);
4677 if (Out.isInvalid())
4678 return true;
4679
4680 Out = getDerived().RebuildPackExpansion(
4681 Out.get(), Expansion->getEllipsisLoc(), OrigNumExpansions);
4682 if (Out.isInvalid())
4683 return true;
4684
4685 Outputs.push_back(Elt: Out.get());
4686 }
4687
4688 continue;
4689 }
4690
4691 ExprResult Result =
4692 IsCall ? getDerived().TransformInitializer(Inputs[I], /*DirectInit*/false)
4693 : getDerived().TransformExpr(Inputs[I]);
4694 if (Result.isInvalid())
4695 return true;
4696
4697 if (Result.get() != Inputs[I] && ArgChanged)
4698 *ArgChanged = true;
4699
4700 Outputs.push_back(Elt: Result.get());
4701 }
4702
4703 return false;
4704}
4705
4706template <typename Derived>
4707Sema::ConditionResult TreeTransform<Derived>::TransformCondition(
4708 SourceLocation Loc, VarDecl *Var, Expr *Expr, Sema::ConditionKind Kind) {
4709
4710 EnterExpressionEvaluationContext Eval(
4711 SemaRef, Sema::ExpressionEvaluationContext::ConstantEvaluated,
4712 /*LambdaContextDecl=*/nullptr,
4713 /*ExprContext=*/Sema::ExpressionEvaluationContextRecord::EK_Other,
4714 /*ShouldEnter=*/Kind == Sema::ConditionKind::ConstexprIf);
4715
4716 if (Var) {
4717 VarDecl *ConditionVar = cast_or_null<VarDecl>(
4718 getDerived().TransformDefinition(Var->getLocation(), Var));
4719
4720 if (!ConditionVar)
4721 return Sema::ConditionError();
4722
4723 return getSema().ActOnConditionVariable(ConditionVar, Loc, Kind);
4724 }
4725
4726 if (Expr) {
4727 ExprResult CondExpr = getDerived().TransformExpr(Expr);
4728
4729 if (CondExpr.isInvalid())
4730 return Sema::ConditionError();
4731
4732 return getSema().ActOnCondition(nullptr, Loc, CondExpr.get(), Kind,
4733 /*MissingOK=*/true);
4734 }
4735
4736 return Sema::ConditionResult();
4737}
4738
4739template <typename Derived>
4740NestedNameSpecifierLoc TreeTransform<Derived>::TransformNestedNameSpecifierLoc(
4741 NestedNameSpecifierLoc NNS, QualType ObjectType,
4742 NamedDecl *FirstQualifierInScope) {
4743 SmallVector<NestedNameSpecifierLoc, 4> Qualifiers;
4744
4745 auto insertNNS = [&Qualifiers](NestedNameSpecifierLoc NNS) {
4746 for (NestedNameSpecifierLoc Qualifier = NNS; Qualifier;
4747 Qualifier = Qualifier.getAsNamespaceAndPrefix().Prefix)
4748 Qualifiers.push_back(Elt: Qualifier);
4749 };
4750 insertNNS(NNS);
4751
4752 CXXScopeSpec SS;
4753 while (!Qualifiers.empty()) {
4754 NestedNameSpecifierLoc Q = Qualifiers.pop_back_val();
4755 NestedNameSpecifier QNNS = Q.getNestedNameSpecifier();
4756
4757 switch (QNNS.getKind()) {
4758 case NestedNameSpecifier::Kind::Null:
4759 llvm_unreachable("unexpected null nested name specifier");
4760
4761 case NestedNameSpecifier::Kind::Namespace: {
4762 auto *NS = cast<NamespaceBaseDecl>(getDerived().TransformDecl(
4763 Q.getLocalBeginLoc(), const_cast<NamespaceBaseDecl *>(
4764 QNNS.getAsNamespaceAndPrefix().Namespace)));
4765 SS.Extend(Context&: SemaRef.Context, Namespace: NS, NamespaceLoc: Q.getLocalBeginLoc(), ColonColonLoc: Q.getLocalEndLoc());
4766 break;
4767 }
4768
4769 case NestedNameSpecifier::Kind::Global:
4770 // There is no meaningful transformation that one could perform on the
4771 // global scope.
4772 SS.MakeGlobal(Context&: SemaRef.Context, ColonColonLoc: Q.getBeginLoc());
4773 break;
4774
4775 case NestedNameSpecifier::Kind::MicrosoftSuper: {
4776 CXXRecordDecl *RD = cast_or_null<CXXRecordDecl>(
4777 getDerived().TransformDecl(SourceLocation(), QNNS.getAsRecordDecl()));
4778 SS.MakeMicrosoftSuper(Context&: SemaRef.Context, RD, SuperLoc: Q.getBeginLoc(),
4779 ColonColonLoc: Q.getEndLoc());
4780 break;
4781 }
4782
4783 case NestedNameSpecifier::Kind::Type: {
4784 assert(SS.isEmpty());
4785 TypeLoc TL = Q.castAsTypeLoc();
4786
4787 if (auto DNT = TL.getAs<DependentNameTypeLoc>()) {
4788 NestedNameSpecifierLoc QualifierLoc = DNT.getQualifierLoc();
4789 if (QualifierLoc) {
4790 QualifierLoc = getDerived().TransformNestedNameSpecifierLoc(
4791 QualifierLoc, ObjectType, FirstQualifierInScope);
4792 if (!QualifierLoc)
4793 return NestedNameSpecifierLoc();
4794 ObjectType = QualType();
4795 FirstQualifierInScope = nullptr;
4796 }
4797 SS.Adopt(Other: QualifierLoc);
4798 Sema::NestedNameSpecInfo IdInfo(
4799 const_cast<IdentifierInfo *>(DNT.getTypePtr()->getIdentifier()),
4800 DNT.getNameLoc(), Q.getLocalEndLoc(), ObjectType);
4801 if (SemaRef.BuildCXXNestedNameSpecifier(/*Scope=*/S: nullptr, IdInfo,
4802 EnteringContext: false, SS,
4803 ScopeLookupResult: FirstQualifierInScope, ErrorRecoveryLookup: false))
4804 return NestedNameSpecifierLoc();
4805 return SS.getWithLocInContext(Context&: SemaRef.Context);
4806 }
4807
4808 QualType T = TL.getType();
4809 TypeLocBuilder TLB;
4810 if (!getDerived().AlreadyTransformed(T)) {
4811 T = TransformTypeInObjectScope(TLB, TL, ObjectType,
4812 FirstQualifierInScope);
4813 if (T.isNull())
4814 return NestedNameSpecifierLoc();
4815 TL = TLB.getTypeLocInContext(Context&: SemaRef.Context, T);
4816 }
4817
4818 if (T->isDependentType() || T->isRecordType() ||
4819 (SemaRef.getLangOpts().CPlusPlus11 && T->isEnumeralType())) {
4820 if (T->isEnumeralType())
4821 SemaRef.Diag(Loc: TL.getBeginLoc(),
4822 DiagID: diag::warn_cxx98_compat_enum_nested_name_spec);
4823 SS.Make(Context&: SemaRef.Context, TL, ColonColonLoc: Q.getLocalEndLoc());
4824 break;
4825 }
4826 // If the nested-name-specifier is an invalid type def, don't emit an
4827 // error because a previous error should have already been emitted.
4828 TypedefTypeLoc TTL = TL.getAsAdjusted<TypedefTypeLoc>();
4829 if (!TTL || !TTL.getDecl()->isInvalidDecl()) {
4830 SemaRef.Diag(Loc: TL.getBeginLoc(), DiagID: diag::err_nested_name_spec_non_tag)
4831 << T << SS.getRange();
4832 }
4833 return NestedNameSpecifierLoc();
4834 }
4835 }
4836 }
4837
4838 // Don't rebuild the nested-name-specifier if we don't have to.
4839 if (SS.getScopeRep() == NNS.getNestedNameSpecifier() &&
4840 !getDerived().AlwaysRebuild())
4841 return NNS;
4842
4843 // If we can re-use the source-location data from the original
4844 // nested-name-specifier, do so.
4845 if (SS.location_size() == NNS.getDataLength() &&
4846 memcmp(s1: SS.location_data(), s2: NNS.getOpaqueData(), n: SS.location_size()) == 0)
4847 return NestedNameSpecifierLoc(SS.getScopeRep(), NNS.getOpaqueData());
4848
4849 // Allocate new nested-name-specifier location information.
4850 return SS.getWithLocInContext(Context&: SemaRef.Context);
4851}
4852
4853template<typename Derived>
4854DeclarationNameInfo
4855TreeTransform<Derived>
4856::TransformDeclarationNameInfo(const DeclarationNameInfo &NameInfo) {
4857 DeclarationName Name = NameInfo.getName();
4858 if (!Name)
4859 return DeclarationNameInfo();
4860
4861 switch (Name.getNameKind()) {
4862 case DeclarationName::Identifier:
4863 case DeclarationName::ObjCZeroArgSelector:
4864 case DeclarationName::ObjCOneArgSelector:
4865 case DeclarationName::ObjCMultiArgSelector:
4866 case DeclarationName::CXXOperatorName:
4867 case DeclarationName::CXXLiteralOperatorName:
4868 case DeclarationName::CXXUsingDirective:
4869 return NameInfo;
4870
4871 case DeclarationName::CXXDeductionGuideName: {
4872 TemplateDecl *OldTemplate = Name.getCXXDeductionGuideTemplate();
4873 TemplateDecl *NewTemplate = cast_or_null<TemplateDecl>(
4874 getDerived().TransformDecl(NameInfo.getLoc(), OldTemplate));
4875 if (!NewTemplate)
4876 return DeclarationNameInfo();
4877
4878 DeclarationNameInfo NewNameInfo(NameInfo);
4879 NewNameInfo.setName(
4880 SemaRef.Context.DeclarationNames.getCXXDeductionGuideName(TD: NewTemplate));
4881 return NewNameInfo;
4882 }
4883
4884 case DeclarationName::CXXConstructorName:
4885 case DeclarationName::CXXDestructorName:
4886 case DeclarationName::CXXConversionFunctionName: {
4887 TypeSourceInfo *NewTInfo;
4888 CanQualType NewCanTy;
4889 if (TypeSourceInfo *OldTInfo = NameInfo.getNamedTypeInfo()) {
4890 NewTInfo = getDerived().TransformType(OldTInfo);
4891 if (!NewTInfo)
4892 return DeclarationNameInfo();
4893 NewCanTy = SemaRef.Context.getCanonicalType(T: NewTInfo->getType());
4894 }
4895 else {
4896 NewTInfo = nullptr;
4897 TemporaryBase Rebase(*this, NameInfo.getLoc(), Name);
4898 QualType NewT = getDerived().TransformType(Name.getCXXNameType());
4899 if (NewT.isNull())
4900 return DeclarationNameInfo();
4901 NewCanTy = SemaRef.Context.getCanonicalType(T: NewT);
4902 }
4903
4904 DeclarationName NewName
4905 = SemaRef.Context.DeclarationNames.getCXXSpecialName(Kind: Name.getNameKind(),
4906 Ty: NewCanTy);
4907 DeclarationNameInfo NewNameInfo(NameInfo);
4908 NewNameInfo.setName(NewName);
4909 NewNameInfo.setNamedTypeInfo(NewTInfo);
4910 return NewNameInfo;
4911 }
4912 }
4913
4914 llvm_unreachable("Unknown name kind.");
4915}
4916
4917template <typename Derived>
4918TemplateName TreeTransform<Derived>::RebuildTemplateName(
4919 CXXScopeSpec &SS, SourceLocation TemplateKWLoc,
4920 IdentifierOrOverloadedOperator IO, SourceLocation NameLoc,
4921 QualType ObjectType, bool AllowInjectedClassName) {
4922 if (const IdentifierInfo *II = IO.getIdentifier())
4923 return getDerived().RebuildTemplateName(SS, TemplateKWLoc, *II, NameLoc,
4924 ObjectType, AllowInjectedClassName);
4925 return getDerived().RebuildTemplateName(SS, TemplateKWLoc, IO.getOperator(),
4926 NameLoc, ObjectType,
4927 AllowInjectedClassName);
4928}
4929
4930template <typename Derived>
4931TemplateName TreeTransform<Derived>::TransformTemplateName(
4932 NestedNameSpecifierLoc &QualifierLoc, SourceLocation TemplateKWLoc,
4933 TemplateName Name, SourceLocation NameLoc, QualType ObjectType,
4934 NamedDecl *FirstQualifierInScope, bool AllowInjectedClassName) {
4935 if (QualifiedTemplateName *QTN = Name.getAsQualifiedTemplateName()) {
4936 TemplateName UnderlyingName = QTN->getUnderlyingTemplate();
4937
4938 if (QualifierLoc) {
4939 QualifierLoc = getDerived().TransformNestedNameSpecifierLoc(
4940 QualifierLoc, ObjectType, FirstQualifierInScope);
4941 if (!QualifierLoc)
4942 return TemplateName();
4943 }
4944
4945 NestedNameSpecifierLoc UnderlyingQualifier;
4946 TemplateName NewUnderlyingName = getDerived().TransformTemplateName(
4947 UnderlyingQualifier, TemplateKWLoc, UnderlyingName, NameLoc, ObjectType,
4948 FirstQualifierInScope, AllowInjectedClassName);
4949 if (NewUnderlyingName.isNull())
4950 return TemplateName();
4951 assert(!UnderlyingQualifier && "unexpected qualifier");
4952
4953 if (!getDerived().AlwaysRebuild() &&
4954 QualifierLoc.getNestedNameSpecifier() == QTN->getQualifier() &&
4955 NewUnderlyingName == UnderlyingName)
4956 return Name;
4957 CXXScopeSpec SS;
4958 SS.Adopt(Other: QualifierLoc);
4959 return getDerived().RebuildTemplateName(SS, QTN->hasTemplateKeyword(),
4960 NewUnderlyingName);
4961 }
4962
4963 if (DependentTemplateName *DTN = Name.getAsDependentTemplateName()) {
4964 if (QualifierLoc) {
4965 QualifierLoc = getDerived().TransformNestedNameSpecifierLoc(
4966 QualifierLoc, ObjectType, FirstQualifierInScope);
4967 if (!QualifierLoc)
4968 return TemplateName();
4969 // The qualifier-in-scope and object type only apply to the leftmost
4970 // entity.
4971 ObjectType = QualType();
4972 }
4973
4974 if (!getDerived().AlwaysRebuild() &&
4975 QualifierLoc.getNestedNameSpecifier() == DTN->getQualifier() &&
4976 ObjectType.isNull())
4977 return Name;
4978
4979 CXXScopeSpec SS;
4980 SS.Adopt(Other: QualifierLoc);
4981 return getDerived().RebuildTemplateName(SS, TemplateKWLoc, DTN->getName(),
4982 NameLoc, ObjectType,
4983 AllowInjectedClassName);
4984 }
4985
4986 if (SubstTemplateTemplateParmStorage *S =
4987 Name.getAsSubstTemplateTemplateParm()) {
4988 assert(!QualifierLoc && "Unexpected qualified SubstTemplateTemplateParm");
4989
4990 NestedNameSpecifierLoc ReplacementQualifierLoc;
4991 TemplateName ReplacementName = S->getReplacement();
4992 if (NestedNameSpecifier Qualifier = ReplacementName.getQualifier()) {
4993 NestedNameSpecifierLocBuilder Builder;
4994 Builder.MakeTrivial(Context&: SemaRef.Context, Qualifier, R: NameLoc);
4995 ReplacementQualifierLoc = Builder.getWithLocInContext(Context&: SemaRef.Context);
4996 }
4997
4998 TemplateName NewName = getDerived().TransformTemplateName(
4999 ReplacementQualifierLoc, TemplateKWLoc, ReplacementName, NameLoc,
5000 ObjectType, FirstQualifierInScope, AllowInjectedClassName);
5001 if (NewName.isNull())
5002 return TemplateName();
5003 Decl *AssociatedDecl =
5004 getDerived().TransformDecl(NameLoc, S->getAssociatedDecl());
5005 if (!getDerived().AlwaysRebuild() && NewName == S->getReplacement() &&
5006 AssociatedDecl == S->getAssociatedDecl())
5007 return Name;
5008 return SemaRef.Context.getSubstTemplateTemplateParm(
5009 replacement: NewName, AssociatedDecl, Index: S->getIndex(), PackIndex: S->getPackIndex(),
5010 Final: S->getFinal());
5011 }
5012
5013 if (PackIndexingTemplateStorage *PI = Name.getAsPackIndexingTemplate()) {
5014 assert(!QualifierLoc && "Unexpected qualified pack-index-template-name");
5015
5016 ExprResult IndexExpr;
5017 {
5018 EnterExpressionEvaluationContext ConstantContext(
5019 SemaRef, Sema::ExpressionEvaluationContext::ConstantEvaluated);
5020 IndexExpr = getDerived().TransformExpr(PI->getIndexExpr());
5021 if (IndexExpr.isInvalid())
5022 return TemplateName();
5023 }
5024
5025 auto TransformOne = [&](TemplateName N) {
5026 NestedNameSpecifierLoc NoQualifier;
5027 return getDerived().TransformTemplateName(
5028 NoQualifier, TemplateKWLoc, N, NameLoc, ObjectType,
5029 FirstQualifierInScope, AllowInjectedClassName);
5030 };
5031
5032 TemplateName Pattern = PI->getPattern();
5033 SmallVector<TemplateName, 4> SubstitutedNames;
5034 ArrayRef<TemplateName> Names = PI->getExpansions();
5035
5036 bool NotYetExpanded = Names.empty();
5037 bool FullySubstituted = true;
5038
5039 if (Names.empty() && !PI->expandsToEmptyPack())
5040 Names = ArrayRef(&Pattern, 1);
5041
5042 for (TemplateName N : Names) {
5043 if (!N.containsUnexpandedParameterPack()) {
5044 TemplateName Transformed = TransformOne(N);
5045 if (Transformed.isNull())
5046 return TemplateName();
5047 SubstitutedNames.push_back(Elt: Transformed);
5048 continue;
5049 }
5050
5051 SmallVector<UnexpandedParameterPack, 2> Unexpanded;
5052 getSema().collectUnexpandedParameterPacks(N, Unexpanded);
5053 assert(!Unexpanded.empty() && "Pack expansion without parameter packs?");
5054
5055 bool ShouldExpand = true;
5056 bool RetainExpansion = false;
5057 UnsignedOrNone NumExpansions = std::nullopt;
5058 if (getDerived().TryExpandParameterPacks(
5059 NameLoc, SourceRange(), Unexpanded,
5060 /*FailOnPackProducingTemplates=*/true, ShouldExpand,
5061 RetainExpansion, NumExpansions))
5062 return TemplateName();
5063
5064 if (!ShouldExpand) {
5065 Sema::ArgPackSubstIndexRAII SubstIndex(getSema(), std::nullopt);
5066 TemplateName Pack = TransformOne(N);
5067 if (Pack.isNull())
5068 return TemplateName();
5069 if (NotYetExpanded) {
5070 FullySubstituted = false;
5071 return getDerived().RebuildPackIndexingTemplateName(
5072 Pack, IndexExpr.get(), FullySubstituted);
5073 }
5074 SubstitutedNames.push_back(Elt: Pack);
5075 continue;
5076 }
5077
5078 for (unsigned I = 0; I != *NumExpansions; ++I) {
5079 Sema::ArgPackSubstIndexRAII SubstIndex(getSema(), I);
5080 TemplateName Out = TransformOne(N);
5081 if (Out.isNull())
5082 return TemplateName();
5083 SubstitutedNames.push_back(Elt: Out);
5084 FullySubstituted &= !Out.containsUnexpandedParameterPack();
5085 }
5086
5087 // If we're supposed to retain a pack expansion, do so by temporarily
5088 // forgetting the partially-substituted parameter pack.
5089 if (RetainExpansion) {
5090 FullySubstituted = false;
5091 ForgetPartiallySubstitutedPackRAII Forget(getDerived());
5092 TemplateName Out = TransformOne(N);
5093 if (Out.isNull())
5094 return TemplateName();
5095 SubstitutedNames.push_back(Elt: Out);
5096 }
5097 }
5098
5099 Sema::ArgPackSubstIndexRAII SubstIndex(getSema(), std::nullopt);
5100 TemplateName NewPattern = TransformOne(Pattern);
5101 if (NewPattern.isNull())
5102 return TemplateName();
5103
5104 return getDerived().RebuildPackIndexingTemplateName(
5105 NewPattern, IndexExpr.get(), FullySubstituted, SubstitutedNames);
5106 }
5107
5108 assert(!Name.getAsDeducedTemplateName() &&
5109 "DeducedTemplateName should not escape partial ordering");
5110
5111 // FIXME: Preserve UsingTemplateName.
5112 if (auto *Template = Name.getAsTemplateDecl()) {
5113 assert(!QualifierLoc && "Unexpected qualifier");
5114 return TemplateName(cast_or_null<TemplateDecl>(
5115 getDerived().TransformDecl(NameLoc, Template)));
5116 }
5117
5118 if (SubstTemplateTemplateParmPackStorage *SubstPack
5119 = Name.getAsSubstTemplateTemplateParmPack()) {
5120 assert(!QualifierLoc &&
5121 "Unexpected qualified SubstTemplateTemplateParmPack");
5122 return getDerived().RebuildTemplateName(
5123 SubstPack->getArgumentPack(), SubstPack->getAssociatedDecl(),
5124 SubstPack->getIndex(), SubstPack->getFinal());
5125 }
5126
5127 // These should be getting filtered out before they reach the AST.
5128 llvm_unreachable("overloaded function decl survived to here");
5129}
5130
5131template <typename Derived>
5132TemplateName
5133TreeTransform<Derived>::TransformConceptTemplateName(TemplateName Name,
5134 SourceLocation NameLoc) {
5135 NestedNameSpecifierLoc QualifierLoc;
5136 return getDerived().TransformTemplateName(
5137 QualifierLoc, /*TemplateKWLoc=*/SourceLocation(), Name, NameLoc);
5138}
5139
5140template <typename Derived>
5141TemplateArgument TreeTransform<Derived>::TransformNamedTemplateTemplateArgument(
5142 NestedNameSpecifierLoc &QualifierLoc, SourceLocation TemplateKeywordLoc,
5143 TemplateName Name, SourceLocation NameLoc) {
5144 TemplateName TN = getDerived().TransformTemplateName(
5145 QualifierLoc, TemplateKeywordLoc, Name, NameLoc);
5146 if (TN.isNull())
5147 return TemplateArgument();
5148 return TemplateArgument(TN);
5149}
5150
5151template<typename Derived>
5152void TreeTransform<Derived>::InventTemplateArgumentLoc(
5153 const TemplateArgument &Arg,
5154 TemplateArgumentLoc &Output) {
5155 Output = getSema().getTrivialTemplateArgumentLoc(
5156 Arg, QualType(), getDerived().getBaseLocation());
5157}
5158
5159template <typename Derived>
5160bool TreeTransform<Derived>::TransformTemplateArgument(
5161 const TemplateArgumentLoc &Input, TemplateArgumentLoc &Output,
5162 bool Uneval) {
5163 const TemplateArgument &Arg = Input.getArgument();
5164 switch (Arg.getKind()) {
5165 case TemplateArgument::Null:
5166 case TemplateArgument::Pack:
5167 llvm_unreachable("Unexpected TemplateArgument");
5168
5169 case TemplateArgument::Integral:
5170 case TemplateArgument::NullPtr:
5171 case TemplateArgument::Declaration:
5172 case TemplateArgument::StructuralValue: {
5173 // Transform a resolved template argument straight to a resolved template
5174 // argument. We get here when substituting into an already-substituted
5175 // template type argument during concept satisfaction checking.
5176 QualType T = Arg.getNonTypeTemplateArgumentType();
5177 QualType NewT = getDerived().TransformType(T);
5178 if (NewT.isNull())
5179 return true;
5180
5181 ValueDecl *D = Arg.getKind() == TemplateArgument::Declaration
5182 ? Arg.getAsDecl()
5183 : nullptr;
5184 ValueDecl *NewD = D ? cast_or_null<ValueDecl>(getDerived().TransformDecl(
5185 getDerived().getBaseLocation(), D))
5186 : nullptr;
5187 if (D && !NewD)
5188 return true;
5189
5190 if (NewT == T && D == NewD)
5191 Output = Input;
5192 else if (Arg.getKind() == TemplateArgument::Integral)
5193 Output = TemplateArgumentLoc(
5194 TemplateArgument(getSema().Context, Arg.getAsIntegral(), NewT),
5195 TemplateArgumentLocInfo());
5196 else if (Arg.getKind() == TemplateArgument::NullPtr)
5197 Output = TemplateArgumentLoc(TemplateArgument(NewT, /*IsNullPtr=*/true),
5198 TemplateArgumentLocInfo());
5199 else if (Arg.getKind() == TemplateArgument::Declaration)
5200 Output = TemplateArgumentLoc(TemplateArgument(NewD, NewT),
5201 TemplateArgumentLocInfo());
5202 else if (Arg.getKind() == TemplateArgument::StructuralValue)
5203 Output = TemplateArgumentLoc(
5204 TemplateArgument(getSema().Context, NewT, Arg.getAsStructuralValue()),
5205 TemplateArgumentLocInfo());
5206 else
5207 llvm_unreachable("unexpected template argument kind");
5208
5209 return false;
5210 }
5211
5212 case TemplateArgument::Type: {
5213 TypeSourceInfo *TSI = Input.getTypeSourceInfo();
5214 if (!TSI)
5215 TSI = InventTypeSourceInfo(T: Input.getArgument().getAsType());
5216
5217 TSI = getDerived().TransformType(TSI);
5218 if (!TSI)
5219 return true;
5220
5221 Output = TemplateArgumentLoc(TemplateArgument(TSI->getType()), TSI);
5222 return false;
5223 }
5224
5225 case TemplateArgument::Template: {
5226 NestedNameSpecifierLoc QualifierLoc = Input.getTemplateQualifierLoc();
5227
5228 TemplateArgument Out = getDerived().TransformNamedTemplateTemplateArgument(
5229 QualifierLoc, Input.getTemplateKWLoc(), Arg.getAsTemplate(),
5230 Input.getTemplateNameLoc());
5231 if (Out.isNull())
5232 return true;
5233 Output = TemplateArgumentLoc(SemaRef.Context, Out, Input.getTemplateKWLoc(),
5234 QualifierLoc, Input.getTemplateNameLoc());
5235 return false;
5236 }
5237
5238 case TemplateArgument::TemplateExpansion:
5239 llvm_unreachable("Caller should expand pack expansions");
5240
5241 case TemplateArgument::Expression: {
5242 // Template argument expressions are constant expressions.
5243 EnterExpressionEvaluationContext Unevaluated(
5244 getSema(),
5245 Uneval ? Sema::ExpressionEvaluationContext::Unevaluated
5246 : Sema::ExpressionEvaluationContext::ConstantEvaluated,
5247 Sema::ReuseLambdaContextDecl, /*ExprContext=*/
5248 Sema::ExpressionEvaluationContextRecord::EK_TemplateArgument);
5249
5250 Expr *InputExpr = Input.getSourceExpression();
5251 if (!InputExpr)
5252 InputExpr = Input.getArgument().getAsExpr();
5253
5254 ExprResult E = getDerived().TransformExpr(InputExpr);
5255 E = SemaRef.ActOnConstantExpression(Res: E);
5256 if (E.isInvalid())
5257 return true;
5258 Output = TemplateArgumentLoc(
5259 TemplateArgument(E.get(), /*IsCanonical=*/false), E.get());
5260 return false;
5261 }
5262 }
5263
5264 // Work around bogus GCC warning
5265 return true;
5266}
5267
5268/// Iterator adaptor that invents template argument location information
5269/// for each of the template arguments in its underlying iterator.
5270template<typename Derived, typename InputIterator>
5271class TemplateArgumentLocInventIterator {
5272 TreeTransform<Derived> &Self;
5273 InputIterator Iter;
5274
5275public:
5276 typedef TemplateArgumentLoc value_type;
5277 typedef TemplateArgumentLoc reference;
5278 typedef typename std::iterator_traits<InputIterator>::difference_type
5279 difference_type;
5280 typedef std::input_iterator_tag iterator_category;
5281
5282 class pointer {
5283 TemplateArgumentLoc Arg;
5284
5285 public:
5286 explicit pointer(TemplateArgumentLoc Arg) : Arg(Arg) { }
5287
5288 const TemplateArgumentLoc *operator->() const { return &Arg; }
5289 };
5290
5291 explicit TemplateArgumentLocInventIterator(TreeTransform<Derived> &Self,
5292 InputIterator Iter)
5293 : Self(Self), Iter(Iter) { }
5294
5295 TemplateArgumentLocInventIterator &operator++() {
5296 ++Iter;
5297 return *this;
5298 }
5299
5300 TemplateArgumentLocInventIterator operator++(int) {
5301 TemplateArgumentLocInventIterator Old(*this);
5302 ++(*this);
5303 return Old;
5304 }
5305
5306 reference operator*() const {
5307 TemplateArgumentLoc Result;
5308 Self.InventTemplateArgumentLoc(*Iter, Result);
5309 return Result;
5310 }
5311
5312 pointer operator->() const { return pointer(**this); }
5313
5314 friend bool operator==(const TemplateArgumentLocInventIterator &X,
5315 const TemplateArgumentLocInventIterator &Y) {
5316 return X.Iter == Y.Iter;
5317 }
5318
5319 friend bool operator!=(const TemplateArgumentLocInventIterator &X,
5320 const TemplateArgumentLocInventIterator &Y) {
5321 return X.Iter != Y.Iter;
5322 }
5323};
5324
5325template<typename Derived>
5326template<typename InputIterator>
5327bool TreeTransform<Derived>::TransformTemplateArguments(
5328 InputIterator First, InputIterator Last, TemplateArgumentListInfo &Outputs,
5329 bool Uneval) {
5330 for (TemplateArgumentLoc In : llvm::make_range(First, Last)) {
5331 TemplateArgumentLoc Out;
5332 if (In.getArgument().getKind() == TemplateArgument::Pack) {
5333 // Unpack argument packs, which we translate them into separate
5334 // arguments.
5335 // FIXME: We could do much better if we could guarantee that the
5336 // TemplateArgumentLocInfo for the pack expansion would be usable for
5337 // all of the template arguments in the argument pack.
5338 typedef TemplateArgumentLocInventIterator<Derived,
5339 TemplateArgument::pack_iterator>
5340 PackLocIterator;
5341
5342 TemplateArgumentListInfo *PackOutput = &Outputs;
5343
5344 if (TransformTemplateArguments(
5345 PackLocIterator(*this, In.getArgument().pack_begin()),
5346 PackLocIterator(*this, In.getArgument().pack_end()), *PackOutput,
5347 Uneval))
5348 return true;
5349
5350 continue;
5351 }
5352
5353 if (In.getArgument().isPackExpansion()) {
5354 UnexpandedInfo Info;
5355 TemplateArgumentLoc Prepared;
5356 if (getDerived().PreparePackForExpansion(In, Uneval, Prepared, Info))
5357 return true;
5358 if (!Info.Expand) {
5359 Outputs.addArgument(Loc: Prepared);
5360 continue;
5361 }
5362
5363 // The transform has determined that we should perform an elementwise
5364 // expansion of the pattern. Do so.
5365 std::optional<ForgetSubstitutionRAII> ForgetSubst;
5366 if (Info.ExpandUnderForgetSubstitions)
5367 ForgetSubst.emplace(getDerived());
5368 for (unsigned I = 0; I != *Info.NumExpansions; ++I) {
5369 Sema::ArgPackSubstIndexRAII SubstIndex(getSema(), I);
5370
5371 TemplateArgumentLoc Out;
5372 if (getDerived().TransformTemplateArgument(Prepared, Out, Uneval))
5373 return true;
5374
5375 if (Out.getArgument().containsUnexpandedParameterPack()) {
5376 Out = getDerived().RebuildPackExpansion(Out, Info.Ellipsis,
5377 Info.OrigNumExpansions);
5378 if (Out.getArgument().isNull())
5379 return true;
5380 }
5381
5382 Outputs.addArgument(Loc: Out);
5383 }
5384
5385 // If we're supposed to retain a pack expansion, do so by temporarily
5386 // forgetting the partially-substituted parameter pack.
5387 if (Info.RetainExpansion) {
5388 ForgetPartiallySubstitutedPackRAII Forget(getDerived());
5389
5390 TemplateArgumentLoc Out;
5391 if (getDerived().TransformTemplateArgument(Prepared, Out, Uneval))
5392 return true;
5393
5394 Out = getDerived().RebuildPackExpansion(Out, Info.Ellipsis,
5395 Info.OrigNumExpansions);
5396 if (Out.getArgument().isNull())
5397 return true;
5398
5399 Outputs.addArgument(Loc: Out);
5400 }
5401
5402 continue;
5403 }
5404
5405 // The simple case:
5406 if (getDerived().TransformTemplateArgument(In, Out, Uneval))
5407 return true;
5408
5409 Outputs.addArgument(Loc: Out);
5410 }
5411
5412 return false;
5413}
5414
5415template <typename Derived>
5416template <typename InputIterator>
5417bool TreeTransform<Derived>::TransformConceptTemplateArguments(
5418 InputIterator First, InputIterator Last, TemplateArgumentListInfo &Outputs,
5419 bool Uneval) {
5420
5421 // [C++26][temp.constr.normal]
5422 // any non-dependent concept template argument
5423 // is substituted into the constraint-expression of C.
5424 auto isNonDependentConceptArgument = [](const TemplateArgument &Arg) {
5425 return !Arg.isDependent() && Arg.isConceptOrConceptTemplateParameter();
5426 };
5427
5428 for (; First != Last; ++First) {
5429 TemplateArgumentLoc Out;
5430 TemplateArgumentLoc In = *First;
5431
5432 if (In.getArgument().getKind() == TemplateArgument::Pack) {
5433 typedef TemplateArgumentLocInventIterator<Derived,
5434 TemplateArgument::pack_iterator>
5435 PackLocIterator;
5436 if (TransformConceptTemplateArguments(
5437 PackLocIterator(*this, In.getArgument().pack_begin()),
5438 PackLocIterator(*this, In.getArgument().pack_end()), Outputs,
5439 Uneval))
5440 return true;
5441 continue;
5442 }
5443
5444 if (!isNonDependentConceptArgument(In.getArgument())) {
5445 Outputs.addArgument(Loc: In);
5446 continue;
5447 }
5448
5449 if (getDerived().TransformTemplateArgument(In, Out, Uneval))
5450 return true;
5451
5452 Outputs.addArgument(Loc: Out);
5453 }
5454
5455 return false;
5456}
5457
5458// FIXME: Find ways to reduce code duplication for pack expansions.
5459template <typename Derived>
5460bool TreeTransform<Derived>::PreparePackForExpansion(TemplateArgumentLoc In,
5461 bool Uneval,
5462 TemplateArgumentLoc &Out,
5463 UnexpandedInfo &Info) {
5464 auto ComputeInfo = [this](TemplateArgumentLoc Arg,
5465 bool IsLateExpansionAttempt, UnexpandedInfo &Info,
5466 TemplateArgumentLoc &Pattern) {
5467 assert(Arg.getArgument().isPackExpansion());
5468 // We have a pack expansion, for which we will be substituting into the
5469 // pattern.
5470 Pattern = getSema().getTemplateArgumentPackExpansionPattern(
5471 Arg, Info.Ellipsis, Info.OrigNumExpansions);
5472 SmallVector<UnexpandedParameterPack, 2> Unexpanded;
5473 getSema().collectUnexpandedParameterPacks(Pattern, Unexpanded);
5474 if (IsLateExpansionAttempt) {
5475 // Request expansion only when there is an opportunity to expand a pack
5476 // that required a substituion first.
5477 bool SawPackTypes =
5478 llvm::any_of(Unexpanded, [](UnexpandedParameterPack P) {
5479 return isa<const SubstBuiltinTemplatePackType *>(Val: P.first);
5480 });
5481 if (!SawPackTypes) {
5482 Info.Expand = false;
5483 return false;
5484 }
5485 }
5486 assert(!Unexpanded.empty() && "Pack expansion without parameter packs?");
5487
5488 // Determine whether the set of unexpanded parameter packs can and
5489 // should be expanded.
5490 Info.Expand = true;
5491 Info.RetainExpansion = false;
5492 Info.NumExpansions = Info.OrigNumExpansions;
5493 return getDerived().TryExpandParameterPacks(
5494 Info.Ellipsis, Pattern.getSourceRange(), Unexpanded,
5495 /*FailOnPackProducingTemplates=*/false, Info.Expand,
5496 Info.RetainExpansion, Info.NumExpansions);
5497 };
5498
5499 TemplateArgumentLoc Pattern;
5500 if (ComputeInfo(In, false, Info, Pattern))
5501 return true;
5502
5503 if (Info.Expand) {
5504 Out = Pattern;
5505 return false;
5506 }
5507
5508 // The transform has determined that we should perform a simple
5509 // transformation on the pack expansion, producing another pack
5510 // expansion.
5511 TemplateArgumentLoc OutPattern;
5512 std::optional<Sema::ArgPackSubstIndexRAII> SubstIndex(
5513 std::in_place, getSema(), std::nullopt);
5514 if (getDerived().TransformTemplateArgument(Pattern, OutPattern, Uneval))
5515 return true;
5516
5517 Out = getDerived().RebuildPackExpansion(OutPattern, Info.Ellipsis,
5518 Info.NumExpansions);
5519 if (Out.getArgument().isNull())
5520 return true;
5521 SubstIndex.reset();
5522
5523 if (!OutPattern.getArgument().containsUnexpandedParameterPack())
5524 return false;
5525
5526 // Some packs will learn their length after substitution, e.g.
5527 // __builtin_dedup_pack<T,int> has size 1 or 2, depending on the substitution
5528 // value of `T`.
5529 //
5530 // We only expand after we know sizes of all packs, check if this is the case
5531 // or not. However, we avoid a full template substitution and only do
5532 // expanstions after this point.
5533
5534 // E.g. when substituting template arguments of tuple with {T -> int} in the
5535 // following example:
5536 // template <class T>
5537 // struct TupleWithInt {
5538 // using type = std::tuple<__builtin_dedup_pack<T, int>...>;
5539 // };
5540 // TupleWithInt<int>::type y;
5541 // At this point we will see the `__builtin_dedup_pack<int, int>` with a known
5542 // length and run `ComputeInfo()` to provide the necessary information to our
5543 // caller.
5544 //
5545 // Note that we may still have situations where builtin is not going to be
5546 // expanded. For example:
5547 // template <class T>
5548 // struct Foo {
5549 // template <class U> using tuple_with_t =
5550 // std::tuple<__builtin_dedup_pack<T, U, int>...>; using type =
5551 // tuple_with_t<short>;
5552 // }
5553 // Because the substitution into `type` happens in dependent context, `type`
5554 // will be `tuple<builtin_dedup_pack<T, short, int>...>` after substitution
5555 // and the caller will not be able to expand it.
5556 ForgetSubstitutionRAII ForgetSubst(getDerived());
5557 if (ComputeInfo(Out, true, Info, OutPattern))
5558 return true;
5559 if (!Info.Expand)
5560 return false;
5561 Out = OutPattern;
5562 Info.ExpandUnderForgetSubstitions = true;
5563 return false;
5564}
5565
5566//===----------------------------------------------------------------------===//
5567// Type transformation
5568//===----------------------------------------------------------------------===//
5569
5570template<typename Derived>
5571QualType TreeTransform<Derived>::TransformType(QualType T) {
5572 if (getDerived().AlreadyTransformed(T))
5573 return T;
5574
5575 // Temporary workaround. All of these transformations should
5576 // eventually turn into transformations on TypeLocs.
5577 TypeSourceInfo *TSI = getSema().Context.getTrivialTypeSourceInfo(
5578 T, getDerived().getBaseLocation());
5579
5580 TypeSourceInfo *NewTSI = getDerived().TransformType(TSI);
5581
5582 if (!NewTSI)
5583 return QualType();
5584
5585 return NewTSI->getType();
5586}
5587
5588template <typename Derived>
5589TypeSourceInfo *TreeTransform<Derived>::TransformType(TypeSourceInfo *TSI) {
5590 // Refine the base location to the type's location.
5591 TemporaryBase Rebase(*this, TSI->getTypeLoc().getBeginLoc(),
5592 getDerived().getBaseEntity());
5593 if (getDerived().AlreadyTransformed(TSI->getType()))
5594 return TSI;
5595
5596 TypeLocBuilder TLB;
5597
5598 TypeLoc TL = TSI->getTypeLoc();
5599 TLB.reserve(Requested: TL.getFullDataSize());
5600
5601 QualType Result = getDerived().TransformType(TLB, TL);
5602 if (Result.isNull())
5603 return nullptr;
5604
5605 return TLB.getTypeSourceInfo(Context&: SemaRef.Context, T: Result);
5606}
5607
5608template<typename Derived>
5609QualType
5610TreeTransform<Derived>::TransformType(TypeLocBuilder &TLB, TypeLoc T) {
5611 switch (T.getTypeLocClass()) {
5612#define ABSTRACT_TYPELOC(CLASS, PARENT)
5613#define TYPELOC(CLASS, PARENT) \
5614 case TypeLoc::CLASS: \
5615 return getDerived().Transform##CLASS##Type(TLB, \
5616 T.castAs<CLASS##TypeLoc>());
5617#include "clang/AST/TypeLocNodes.def"
5618 }
5619
5620 llvm_unreachable("unhandled type loc!");
5621}
5622
5623template<typename Derived>
5624QualType TreeTransform<Derived>::TransformTypeWithDeducedTST(QualType T) {
5625 if (!isa<DependentNameType>(Val: T))
5626 return TransformType(T);
5627
5628 if (getDerived().AlreadyTransformed(T))
5629 return T;
5630 TypeSourceInfo *TSI = getSema().Context.getTrivialTypeSourceInfo(
5631 T, getDerived().getBaseLocation());
5632 TypeSourceInfo *NewTSI = getDerived().TransformTypeWithDeducedTST(TSI);
5633 return NewTSI ? NewTSI->getType() : QualType();
5634}
5635
5636template <typename Derived>
5637TypeSourceInfo *
5638TreeTransform<Derived>::TransformTypeWithDeducedTST(TypeSourceInfo *TSI) {
5639 if (!isa<DependentNameType>(Val: TSI->getType()))
5640 return TransformType(TSI);
5641
5642 // Refine the base location to the type's location.
5643 TemporaryBase Rebase(*this, TSI->getTypeLoc().getBeginLoc(),
5644 getDerived().getBaseEntity());
5645 if (getDerived().AlreadyTransformed(TSI->getType()))
5646 return TSI;
5647
5648 TypeLocBuilder TLB;
5649
5650 TypeLoc TL = TSI->getTypeLoc();
5651 TLB.reserve(Requested: TL.getFullDataSize());
5652
5653 auto QTL = TL.getAs<QualifiedTypeLoc>();
5654 if (QTL)
5655 TL = QTL.getUnqualifiedLoc();
5656
5657 auto DNTL = TL.castAs<DependentNameTypeLoc>();
5658
5659 QualType Result = getDerived().TransformDependentNameType(
5660 TLB, DNTL, /*DeducedTSTContext*/true);
5661 if (Result.isNull())
5662 return nullptr;
5663
5664 if (QTL) {
5665 Result = getDerived().RebuildQualifiedType(Result, QTL);
5666 if (Result.isNull())
5667 return nullptr;
5668 TLB.TypeWasModifiedSafely(T: Result);
5669 }
5670
5671 return TLB.getTypeSourceInfo(Context&: SemaRef.Context, T: Result);
5672}
5673
5674template<typename Derived>
5675QualType
5676TreeTransform<Derived>::TransformQualifiedType(TypeLocBuilder &TLB,
5677 QualifiedTypeLoc T) {
5678 QualType Result;
5679 TypeLoc UnqualTL = T.getUnqualifiedLoc();
5680 auto SuppressObjCLifetime =
5681 T.getType().getLocalQualifiers().hasObjCLifetime();
5682 if (auto TTP = UnqualTL.getAs<TemplateTypeParmTypeLoc>()) {
5683 Result = getDerived().TransformTemplateTypeParmType(TLB, TTP,
5684 SuppressObjCLifetime);
5685 } else if (auto STTP = UnqualTL.getAs<SubstTemplateTypeParmPackTypeLoc>()) {
5686 Result = getDerived().TransformSubstTemplateTypeParmPackType(
5687 TLB, STTP, SuppressObjCLifetime);
5688 } else {
5689 Result = getDerived().TransformType(TLB, UnqualTL);
5690 }
5691
5692 if (Result.isNull())
5693 return QualType();
5694
5695 Result = getDerived().RebuildQualifiedType(Result, T);
5696
5697 if (Result.isNull())
5698 return QualType();
5699
5700 // RebuildQualifiedType might have updated the type, but not in a way
5701 // that invalidates the TypeLoc. (There's no location information for
5702 // qualifiers.)
5703 TLB.TypeWasModifiedSafely(T: Result);
5704
5705 return Result;
5706}
5707
5708template <typename Derived>
5709QualType TreeTransform<Derived>::RebuildQualifiedType(QualType T,
5710 QualifiedTypeLoc TL) {
5711
5712 SourceLocation Loc = TL.getBeginLoc();
5713 Qualifiers Quals = TL.getType().getLocalQualifiers();
5714
5715 if ((T.getAddressSpace() != LangAS::Default &&
5716 Quals.getAddressSpace() != LangAS::Default) &&
5717 T.getAddressSpace() != Quals.getAddressSpace()) {
5718 SemaRef.Diag(Loc, DiagID: diag::err_address_space_mismatch_templ_inst)
5719 << TL.getType() << T;
5720 return QualType();
5721 }
5722
5723 PointerAuthQualifier LocalPointerAuth = Quals.getPointerAuth();
5724 if (LocalPointerAuth.isPresent()) {
5725 if (T.getPointerAuth().isPresent()) {
5726 SemaRef.Diag(Loc, DiagID: diag::err_ptrauth_qualifier_redundant) << TL.getType();
5727 return QualType();
5728 }
5729 if (!T->isDependentType()) {
5730 if (!T->isSignableType(Ctx: SemaRef.getASTContext())) {
5731 SemaRef.Diag(Loc, DiagID: diag::err_ptrauth_qualifier_invalid_target) << T;
5732 return QualType();
5733 }
5734 }
5735 }
5736 // C++ [dcl.fct]p7:
5737 // [When] adding cv-qualifications on top of the function type [...] the
5738 // cv-qualifiers are ignored.
5739 if (T->isFunctionType()) {
5740 T = SemaRef.getASTContext().getAddrSpaceQualType(T,
5741 AddressSpace: Quals.getAddressSpace());
5742 return T;
5743 }
5744
5745 // C++ [dcl.ref]p1:
5746 // when the cv-qualifiers are introduced through the use of a typedef-name
5747 // or decltype-specifier [...] the cv-qualifiers are ignored.
5748 // Note that [dcl.ref]p1 lists all cases in which cv-qualifiers can be
5749 // applied to a reference type.
5750 if (T->isReferenceType()) {
5751 // The only qualifier that applies to a reference type is restrict.
5752 if (!Quals.hasRestrict())
5753 return T;
5754 Quals = Qualifiers::fromCVRMask(CVR: Qualifiers::Restrict);
5755 }
5756
5757 // Suppress Objective-C lifetime qualifiers if they don't make sense for the
5758 // resulting type.
5759 if (Quals.hasObjCLifetime()) {
5760 if (!T->isObjCLifetimeType() && !T->isDependentType())
5761 Quals.removeObjCLifetime();
5762 else if (T.getObjCLifetime()) {
5763 // Objective-C ARC:
5764 // A lifetime qualifier applied to a substituted template parameter
5765 // overrides the lifetime qualifier from the template argument.
5766 const AutoType *AutoTy;
5767 if ((AutoTy = dyn_cast<AutoType>(Val&: T)) && AutoTy->isDeduced()) {
5768 // 'auto' types behave the same way as template parameters.
5769 QualType Deduced = AutoTy->getDeducedType();
5770 Qualifiers Qs = Deduced.getQualifiers();
5771 Qs.removeObjCLifetime();
5772 Deduced =
5773 SemaRef.Context.getQualifiedType(T: Deduced.getUnqualifiedType(), Qs);
5774 T = SemaRef.Context.getAutoType(DK: AutoTy->getDeducedKind(), DeducedAsType: Deduced,
5775 Keyword: AutoTy->getKeyword(),
5776 TypeConstraintConcept: AutoTy->getTypeConstraintConcept(),
5777 TypeConstraintArgs: AutoTy->getTypeConstraintArguments());
5778 } else {
5779 // Otherwise, complain about the addition of a qualifier to an
5780 // already-qualified type.
5781 // FIXME: Why is this check not in Sema::BuildQualifiedType?
5782 SemaRef.Diag(Loc, DiagID: diag::err_attr_objc_ownership_redundant) << T;
5783 Quals.removeObjCLifetime();
5784 }
5785 }
5786 }
5787
5788 return SemaRef.BuildQualifiedType(T, Loc, Qs: Quals);
5789}
5790
5791template <typename Derived>
5792QualType TreeTransform<Derived>::TransformTypeInObjectScope(
5793 TypeLocBuilder &TLB, TypeLoc TL, QualType ObjectType,
5794 NamedDecl *FirstQualifierInScope) {
5795 assert(!getDerived().AlreadyTransformed(TL.getType()));
5796
5797 switch (TL.getTypeLocClass()) {
5798 case TypeLoc::TemplateSpecialization:
5799 return getDerived().TransformTemplateSpecializationType(
5800 TLB, TL.castAs<TemplateSpecializationTypeLoc>(), ObjectType,
5801 FirstQualifierInScope, /*AllowInjectedClassName=*/true);
5802 case TypeLoc::DependentName:
5803 return getDerived().TransformDependentNameType(
5804 TLB, TL.castAs<DependentNameTypeLoc>(), /*DeducedTSTContext=*/false,
5805 ObjectType, FirstQualifierInScope);
5806 default:
5807 // Any dependent canonical type can appear here, through type alias
5808 // templates.
5809 return getDerived().TransformType(TLB, TL);
5810 }
5811}
5812
5813template <class TyLoc> static inline
5814QualType TransformTypeSpecType(TypeLocBuilder &TLB, TyLoc T) {
5815 TyLoc NewT = TLB.push<TyLoc>(T.getType());
5816 NewT.setNameLoc(T.getNameLoc());
5817 return T.getType();
5818}
5819
5820template<typename Derived>
5821QualType TreeTransform<Derived>::TransformBuiltinType(TypeLocBuilder &TLB,
5822 BuiltinTypeLoc T) {
5823 BuiltinTypeLoc NewT = TLB.push<BuiltinTypeLoc>(T: T.getType());
5824 NewT.setBuiltinLoc(T.getBuiltinLoc());
5825 if (T.needsExtraLocalData())
5826 NewT.getWrittenBuiltinSpecs() = T.getWrittenBuiltinSpecs();
5827 return T.getType();
5828}
5829
5830template<typename Derived>
5831QualType TreeTransform<Derived>::TransformComplexType(TypeLocBuilder &TLB,
5832 ComplexTypeLoc T) {
5833 // FIXME: recurse?
5834 return TransformTypeSpecType(TLB, T);
5835}
5836
5837template <typename Derived>
5838QualType TreeTransform<Derived>::TransformAdjustedType(TypeLocBuilder &TLB,
5839 AdjustedTypeLoc TL) {
5840 // Adjustments applied during transformation are handled elsewhere.
5841 return getDerived().TransformType(TLB, TL.getOriginalLoc());
5842}
5843
5844template<typename Derived>
5845QualType TreeTransform<Derived>::TransformDecayedType(TypeLocBuilder &TLB,
5846 DecayedTypeLoc TL) {
5847 QualType OriginalType = getDerived().TransformType(TLB, TL.getOriginalLoc());
5848 if (OriginalType.isNull())
5849 return QualType();
5850
5851 QualType Result = TL.getType();
5852 if (getDerived().AlwaysRebuild() ||
5853 OriginalType != TL.getOriginalLoc().getType())
5854 Result = SemaRef.Context.getDecayedType(T: OriginalType);
5855 TLB.push<DecayedTypeLoc>(T: Result);
5856 // Nothing to set for DecayedTypeLoc.
5857 return Result;
5858}
5859
5860template <typename Derived>
5861QualType
5862TreeTransform<Derived>::TransformArrayParameterType(TypeLocBuilder &TLB,
5863 ArrayParameterTypeLoc TL) {
5864 QualType OriginalType = getDerived().TransformType(TLB, TL.getElementLoc());
5865 if (OriginalType.isNull())
5866 return QualType();
5867
5868 QualType Result = TL.getType();
5869 if (getDerived().AlwaysRebuild() ||
5870 OriginalType != TL.getElementLoc().getType())
5871 Result = SemaRef.Context.getArrayParameterType(Ty: OriginalType);
5872 TLB.push<ArrayParameterTypeLoc>(T: Result);
5873 // Nothing to set for ArrayParameterTypeLoc.
5874 return Result;
5875}
5876
5877template<typename Derived>
5878QualType TreeTransform<Derived>::TransformPointerType(TypeLocBuilder &TLB,
5879 PointerTypeLoc TL) {
5880 QualType PointeeType
5881 = getDerived().TransformType(TLB, TL.getPointeeLoc());
5882 if (PointeeType.isNull())
5883 return QualType();
5884
5885 QualType Result = TL.getType();
5886 if (PointeeType->getAs<ObjCObjectType>()) {
5887 // A dependent pointer type 'T *' has is being transformed such
5888 // that an Objective-C class type is being replaced for 'T'. The
5889 // resulting pointer type is an ObjCObjectPointerType, not a
5890 // PointerType.
5891 Result = SemaRef.Context.getObjCObjectPointerType(OIT: PointeeType);
5892
5893 ObjCObjectPointerTypeLoc NewT = TLB.push<ObjCObjectPointerTypeLoc>(T: Result);
5894 NewT.setStarLoc(TL.getStarLoc());
5895 return Result;
5896 }
5897
5898 if (getDerived().AlwaysRebuild() ||
5899 PointeeType != TL.getPointeeLoc().getType()) {
5900 Result = getDerived().RebuildPointerType(PointeeType, TL.getSigilLoc());
5901 if (Result.isNull())
5902 return QualType();
5903 }
5904
5905 // Objective-C ARC can add lifetime qualifiers to the type that we're
5906 // pointing to.
5907 TLB.TypeWasModifiedSafely(T: Result->getPointeeType());
5908
5909 PointerTypeLoc NewT = TLB.push<PointerTypeLoc>(T: Result);
5910 NewT.setSigilLoc(TL.getSigilLoc());
5911 return Result;
5912}
5913
5914template<typename Derived>
5915QualType
5916TreeTransform<Derived>::TransformBlockPointerType(TypeLocBuilder &TLB,
5917 BlockPointerTypeLoc TL) {
5918 QualType PointeeType
5919 = getDerived().TransformType(TLB, TL.getPointeeLoc());
5920 if (PointeeType.isNull())
5921 return QualType();
5922
5923 QualType Result = TL.getType();
5924 if (getDerived().AlwaysRebuild() ||
5925 PointeeType != TL.getPointeeLoc().getType()) {
5926 Result = getDerived().RebuildBlockPointerType(PointeeType,
5927 TL.getSigilLoc());
5928 if (Result.isNull())
5929 return QualType();
5930 }
5931
5932 BlockPointerTypeLoc NewT = TLB.push<BlockPointerTypeLoc>(T: Result);
5933 NewT.setSigilLoc(TL.getSigilLoc());
5934 return Result;
5935}
5936
5937/// Transforms a reference type. Note that somewhat paradoxically we
5938/// don't care whether the type itself is an l-value type or an r-value
5939/// type; we only care if the type was *written* as an l-value type
5940/// or an r-value type.
5941template<typename Derived>
5942QualType
5943TreeTransform<Derived>::TransformReferenceType(TypeLocBuilder &TLB,
5944 ReferenceTypeLoc TL) {
5945 const ReferenceType *T = TL.getTypePtr();
5946
5947 // Note that this works with the pointee-as-written.
5948 QualType PointeeType = getDerived().TransformType(TLB, TL.getPointeeLoc());
5949 if (PointeeType.isNull())
5950 return QualType();
5951
5952 QualType Result = TL.getType();
5953 if (getDerived().AlwaysRebuild() ||
5954 PointeeType != T->getPointeeTypeAsWritten()) {
5955 Result = getDerived().RebuildReferenceType(PointeeType,
5956 T->isSpelledAsLValue(),
5957 TL.getSigilLoc());
5958 if (Result.isNull())
5959 return QualType();
5960 }
5961
5962 // Objective-C ARC can add lifetime qualifiers to the type that we're
5963 // referring to.
5964 TLB.TypeWasModifiedSafely(
5965 T: Result->castAs<ReferenceType>()->getPointeeTypeAsWritten());
5966
5967 // r-value references can be rebuilt as l-value references.
5968 ReferenceTypeLoc NewTL;
5969 if (isa<LValueReferenceType>(Val: Result))
5970 NewTL = TLB.push<LValueReferenceTypeLoc>(T: Result);
5971 else
5972 NewTL = TLB.push<RValueReferenceTypeLoc>(T: Result);
5973 NewTL.setSigilLoc(TL.getSigilLoc());
5974
5975 return Result;
5976}
5977
5978template<typename Derived>
5979QualType
5980TreeTransform<Derived>::TransformLValueReferenceType(TypeLocBuilder &TLB,
5981 LValueReferenceTypeLoc TL) {
5982 return TransformReferenceType(TLB, TL);
5983}
5984
5985template<typename Derived>
5986QualType
5987TreeTransform<Derived>::TransformRValueReferenceType(TypeLocBuilder &TLB,
5988 RValueReferenceTypeLoc TL) {
5989 return TransformReferenceType(TLB, TL);
5990}
5991
5992template<typename Derived>
5993QualType
5994TreeTransform<Derived>::TransformMemberPointerType(TypeLocBuilder &TLB,
5995 MemberPointerTypeLoc TL) {
5996 QualType PointeeType = getDerived().TransformType(TLB, TL.getPointeeLoc());
5997 if (PointeeType.isNull())
5998 return QualType();
5999
6000 const MemberPointerType *T = TL.getTypePtr();
6001
6002 NestedNameSpecifierLoc OldQualifierLoc = TL.getQualifierLoc();
6003 NestedNameSpecifierLoc NewQualifierLoc =
6004 getDerived().TransformNestedNameSpecifierLoc(OldQualifierLoc);
6005 if (!NewQualifierLoc)
6006 return QualType();
6007
6008 CXXRecordDecl *OldCls = T->getMostRecentCXXRecordDecl(), *NewCls = nullptr;
6009 if (OldCls) {
6010 NewCls = cast_or_null<CXXRecordDecl>(
6011 getDerived().TransformDecl(TL.getStarLoc(), OldCls));
6012 if (!NewCls)
6013 return QualType();
6014 }
6015
6016 QualType Result = TL.getType();
6017 if (getDerived().AlwaysRebuild() || PointeeType != T->getPointeeType() ||
6018 NewQualifierLoc.getNestedNameSpecifier() !=
6019 OldQualifierLoc.getNestedNameSpecifier() ||
6020 NewCls != OldCls) {
6021 CXXScopeSpec SS;
6022 SS.Adopt(Other: NewQualifierLoc);
6023 Result = getDerived().RebuildMemberPointerType(PointeeType, SS, NewCls,
6024 TL.getStarLoc());
6025 if (Result.isNull())
6026 return QualType();
6027 }
6028
6029 // If we had to adjust the pointee type when building a member pointer, make
6030 // sure to push TypeLoc info for it.
6031 const MemberPointerType *MPT = Result->getAs<MemberPointerType>();
6032 if (MPT && PointeeType != MPT->getPointeeType()) {
6033 assert(isa<AdjustedType>(MPT->getPointeeType()));
6034 TLB.push<AdjustedTypeLoc>(T: MPT->getPointeeType());
6035 }
6036
6037 MemberPointerTypeLoc NewTL = TLB.push<MemberPointerTypeLoc>(T: Result);
6038 NewTL.setSigilLoc(TL.getSigilLoc());
6039 NewTL.setQualifierLoc(NewQualifierLoc);
6040
6041 return Result;
6042}
6043
6044template<typename Derived>
6045QualType
6046TreeTransform<Derived>::TransformConstantArrayType(TypeLocBuilder &TLB,
6047 ConstantArrayTypeLoc TL) {
6048 const ConstantArrayType *T = TL.getTypePtr();
6049 QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc());
6050 if (ElementType.isNull())
6051 return QualType();
6052
6053 // Prefer the expression from the TypeLoc; the other may have been uniqued.
6054 Expr *OldSize = TL.getSizeExpr();
6055 if (!OldSize)
6056 OldSize = const_cast<Expr*>(T->getSizeExpr());
6057 Expr *NewSize = nullptr;
6058 if (OldSize) {
6059 EnterExpressionEvaluationContext Unevaluated(
6060 SemaRef, Sema::ExpressionEvaluationContext::ConstantEvaluated);
6061 NewSize = getDerived().TransformExpr(OldSize).template getAs<Expr>();
6062 NewSize = SemaRef.ActOnConstantExpression(Res: NewSize).get();
6063 }
6064
6065 QualType Result = TL.getType();
6066 if (getDerived().AlwaysRebuild() ||
6067 ElementType != T->getElementType() ||
6068 (T->getSizeExpr() && NewSize != OldSize)) {
6069 Result = getDerived().RebuildConstantArrayType(ElementType,
6070 T->getSizeModifier(),
6071 T->getSize(), NewSize,
6072 T->getIndexTypeCVRQualifiers(),
6073 TL.getBracketsRange());
6074 if (Result.isNull())
6075 return QualType();
6076 }
6077
6078 // We might have either a ConstantArrayType or a VariableArrayType now:
6079 // a ConstantArrayType is allowed to have an element type which is a
6080 // VariableArrayType if the type is dependent. Fortunately, all array
6081 // types have the same location layout.
6082 ArrayTypeLoc NewTL = TLB.push<ArrayTypeLoc>(T: Result);
6083 NewTL.setLBracketLoc(TL.getLBracketLoc());
6084 NewTL.setRBracketLoc(TL.getRBracketLoc());
6085 NewTL.setSizeExpr(NewSize);
6086
6087 return Result;
6088}
6089
6090template<typename Derived>
6091QualType TreeTransform<Derived>::TransformIncompleteArrayType(
6092 TypeLocBuilder &TLB,
6093 IncompleteArrayTypeLoc TL) {
6094 const IncompleteArrayType *T = TL.getTypePtr();
6095 QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc());
6096 if (ElementType.isNull())
6097 return QualType();
6098
6099 QualType Result = TL.getType();
6100 if (getDerived().AlwaysRebuild() ||
6101 ElementType != T->getElementType()) {
6102 Result = getDerived().RebuildIncompleteArrayType(ElementType,
6103 T->getSizeModifier(),
6104 T->getIndexTypeCVRQualifiers(),
6105 TL.getBracketsRange());
6106 if (Result.isNull())
6107 return QualType();
6108 }
6109
6110 IncompleteArrayTypeLoc NewTL = TLB.push<IncompleteArrayTypeLoc>(T: Result);
6111 NewTL.setLBracketLoc(TL.getLBracketLoc());
6112 NewTL.setRBracketLoc(TL.getRBracketLoc());
6113 NewTL.setSizeExpr(nullptr);
6114
6115 return Result;
6116}
6117
6118template<typename Derived>
6119QualType
6120TreeTransform<Derived>::TransformVariableArrayType(TypeLocBuilder &TLB,
6121 VariableArrayTypeLoc TL) {
6122 const VariableArrayType *T = TL.getTypePtr();
6123 QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc());
6124 if (ElementType.isNull())
6125 return QualType();
6126
6127 ExprResult SizeResult;
6128 {
6129 EnterExpressionEvaluationContext Context(
6130 SemaRef, Sema::ExpressionEvaluationContext::PotentiallyEvaluated);
6131 SizeResult = getDerived().TransformExpr(T->getSizeExpr());
6132 }
6133 if (SizeResult.isInvalid())
6134 return QualType();
6135 SizeResult =
6136 SemaRef.ActOnFinishFullExpr(Expr: SizeResult.get(), /*DiscardedValue*/ DiscardedValue: false);
6137 if (SizeResult.isInvalid())
6138 return QualType();
6139
6140 Expr *Size = SizeResult.get();
6141
6142 QualType Result = TL.getType();
6143 if (getDerived().AlwaysRebuild() ||
6144 ElementType != T->getElementType() ||
6145 Size != T->getSizeExpr()) {
6146 Result = getDerived().RebuildVariableArrayType(ElementType,
6147 T->getSizeModifier(),
6148 Size,
6149 T->getIndexTypeCVRQualifiers(),
6150 TL.getBracketsRange());
6151 if (Result.isNull())
6152 return QualType();
6153 }
6154
6155 // We might have constant size array now, but fortunately it has the same
6156 // location layout.
6157 ArrayTypeLoc NewTL = TLB.push<ArrayTypeLoc>(T: Result);
6158 NewTL.setLBracketLoc(TL.getLBracketLoc());
6159 NewTL.setRBracketLoc(TL.getRBracketLoc());
6160 NewTL.setSizeExpr(Size);
6161
6162 return Result;
6163}
6164
6165template<typename Derived>
6166QualType
6167TreeTransform<Derived>::TransformDependentSizedArrayType(TypeLocBuilder &TLB,
6168 DependentSizedArrayTypeLoc TL) {
6169 const DependentSizedArrayType *T = TL.getTypePtr();
6170 QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc());
6171 if (ElementType.isNull())
6172 return QualType();
6173
6174 // Array bounds are constant expressions.
6175 EnterExpressionEvaluationContext Unevaluated(
6176 SemaRef, Sema::ExpressionEvaluationContext::ConstantEvaluated);
6177
6178 // If we have a VLA then it won't be a constant.
6179 SemaRef.ExprEvalContexts.back().InConditionallyConstantEvaluateContext = true;
6180
6181 // Prefer the expression from the TypeLoc; the other may have been uniqued.
6182 Expr *origSize = TL.getSizeExpr();
6183 if (!origSize) origSize = T->getSizeExpr();
6184
6185 ExprResult sizeResult
6186 = getDerived().TransformExpr(origSize);
6187 sizeResult = SemaRef.ActOnConstantExpression(Res: sizeResult);
6188 if (sizeResult.isInvalid())
6189 return QualType();
6190
6191 Expr *size = sizeResult.get();
6192
6193 QualType Result = TL.getType();
6194 if (getDerived().AlwaysRebuild() ||
6195 ElementType != T->getElementType() ||
6196 size != origSize) {
6197 Result = getDerived().RebuildDependentSizedArrayType(ElementType,
6198 T->getSizeModifier(),
6199 size,
6200 T->getIndexTypeCVRQualifiers(),
6201 TL.getBracketsRange());
6202 if (Result.isNull())
6203 return QualType();
6204 }
6205
6206 // We might have any sort of array type now, but fortunately they
6207 // all have the same location layout.
6208 ArrayTypeLoc NewTL = TLB.push<ArrayTypeLoc>(T: Result);
6209 NewTL.setLBracketLoc(TL.getLBracketLoc());
6210 NewTL.setRBracketLoc(TL.getRBracketLoc());
6211 NewTL.setSizeExpr(size);
6212
6213 return Result;
6214}
6215
6216template <typename Derived>
6217QualType TreeTransform<Derived>::TransformDependentVectorType(
6218 TypeLocBuilder &TLB, DependentVectorTypeLoc TL) {
6219 const DependentVectorType *T = TL.getTypePtr();
6220 QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc());
6221 if (ElementType.isNull())
6222 return QualType();
6223
6224 EnterExpressionEvaluationContext Unevaluated(
6225 SemaRef, Sema::ExpressionEvaluationContext::ConstantEvaluated);
6226
6227 Expr *OrigSize = TL.getSizeExpr();
6228 ExprResult Size = getDerived().TransformExpr(OrigSize);
6229 Size = SemaRef.ActOnConstantExpression(Res: Size);
6230 if (Size.isInvalid())
6231 return QualType();
6232
6233 QualType Result = TL.getType();
6234 if (getDerived().AlwaysRebuild() || ElementType != T->getElementType() ||
6235 Size.get() != OrigSize) {
6236 Result = getDerived().RebuildDependentVectorType(
6237 ElementType, Size.get(), T->getAttributeLoc(), T->getVectorKind());
6238 if (Result.isNull())
6239 return QualType();
6240 }
6241
6242 // Result might be dependent or not.
6243 if (isa<DependentVectorType>(Val: Result)) {
6244 DependentVectorTypeLoc NewTL =
6245 TLB.push<DependentVectorTypeLoc>(T: Result);
6246 NewTL.setNameLoc(TL.getNameLoc());
6247 NewTL.setAttrNameLoc(TL.getAttrNameLoc());
6248 NewTL.setSizeExpr(Size.get());
6249 } else {
6250 VectorTypeLoc NewTL = TLB.push<VectorTypeLoc>(T: Result);
6251 NewTL.setNameLoc(TL.getNameLoc());
6252 NewTL.setAttrNameLoc(TL.getAttrNameLoc());
6253 NewTL.setSizeExpr(Size.get());
6254 }
6255
6256 return Result;
6257}
6258
6259template<typename Derived>
6260QualType TreeTransform<Derived>::TransformDependentSizedExtVectorType(
6261 TypeLocBuilder &TLB,
6262 DependentSizedExtVectorTypeLoc TL) {
6263 const DependentSizedExtVectorType *T = TL.getTypePtr();
6264
6265 QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc());
6266 if (ElementType.isNull())
6267 return QualType();
6268
6269 // Vector sizes are constant expressions.
6270 EnterExpressionEvaluationContext Unevaluated(
6271 SemaRef, Sema::ExpressionEvaluationContext::ConstantEvaluated);
6272
6273 Expr *OrigSize = TL.getSizeExpr();
6274 ExprResult Size = getDerived().TransformExpr(OrigSize);
6275 Size = SemaRef.ActOnConstantExpression(Res: Size);
6276 if (Size.isInvalid())
6277 return QualType();
6278
6279 QualType Result = TL.getType();
6280 if (getDerived().AlwaysRebuild() || ElementType != T->getElementType() ||
6281 Size.get() != OrigSize) {
6282 Result = getDerived().RebuildDependentSizedExtVectorType(
6283 ElementType, Size.get(), T->getAttributeLoc());
6284 if (Result.isNull())
6285 return QualType();
6286 }
6287
6288 // Result might be dependent or not.
6289 if (isa<DependentSizedExtVectorType>(Val: Result)) {
6290 DependentSizedExtVectorTypeLoc NewTL
6291 = TLB.push<DependentSizedExtVectorTypeLoc>(T: Result);
6292 NewTL.setNameLoc(TL.getNameLoc());
6293 NewTL.setAttrNameLoc(TL.getAttrNameLoc());
6294 NewTL.setSizeExpr(Size.get());
6295 } else {
6296 ExtVectorTypeLoc NewTL = TLB.push<ExtVectorTypeLoc>(T: Result);
6297 NewTL.setNameLoc(TL.getNameLoc());
6298 NewTL.setAttrNameLoc(TL.getAttrNameLoc());
6299 NewTL.setSizeExpr(Size.get());
6300 }
6301
6302 return Result;
6303}
6304
6305template <typename Derived>
6306QualType
6307TreeTransform<Derived>::TransformConstantMatrixType(TypeLocBuilder &TLB,
6308 ConstantMatrixTypeLoc TL) {
6309 const ConstantMatrixType *T = TL.getTypePtr();
6310 QualType ElementType = getDerived().TransformType(T->getElementType());
6311 if (ElementType.isNull())
6312 return QualType();
6313
6314 QualType Result = TL.getType();
6315 if (getDerived().AlwaysRebuild() || ElementType != T->getElementType()) {
6316 Result = getDerived().RebuildConstantMatrixType(
6317 ElementType, T->getNumRows(), T->getNumColumns(), TL.getAttrNameLoc());
6318 if (Result.isNull())
6319 return QualType();
6320 }
6321
6322 ConstantMatrixTypeLoc NewTL = TLB.push<ConstantMatrixTypeLoc>(T: Result);
6323 NewTL.setAttrNameLoc(TL.getAttrNameLoc());
6324 NewTL.setAttrOperandParensRange(TL.getAttrOperandParensRange());
6325 NewTL.setAttrRowOperand(TL.getAttrRowOperand());
6326 NewTL.setAttrColumnOperand(TL.getAttrColumnOperand());
6327
6328 return Result;
6329}
6330
6331template <typename Derived>
6332QualType TreeTransform<Derived>::TransformDependentSizedMatrixType(
6333 TypeLocBuilder &TLB, DependentSizedMatrixTypeLoc TL) {
6334 const DependentSizedMatrixType *T = TL.getTypePtr();
6335
6336 QualType ElementType = getDerived().TransformType(T->getElementType());
6337 if (ElementType.isNull()) {
6338 return QualType();
6339 }
6340
6341 // Matrix dimensions are constant expressions.
6342 EnterExpressionEvaluationContext Unevaluated(
6343 SemaRef, Sema::ExpressionEvaluationContext::ConstantEvaluated);
6344
6345 Expr *origRows = TL.getAttrRowOperand();
6346 if (!origRows)
6347 origRows = T->getRowExpr();
6348 Expr *origColumns = TL.getAttrColumnOperand();
6349 if (!origColumns)
6350 origColumns = T->getColumnExpr();
6351
6352 ExprResult rowResult = getDerived().TransformExpr(origRows);
6353 rowResult = SemaRef.ActOnConstantExpression(Res: rowResult);
6354 if (rowResult.isInvalid())
6355 return QualType();
6356
6357 ExprResult columnResult = getDerived().TransformExpr(origColumns);
6358 columnResult = SemaRef.ActOnConstantExpression(Res: columnResult);
6359 if (columnResult.isInvalid())
6360 return QualType();
6361
6362 Expr *rows = rowResult.get();
6363 Expr *columns = columnResult.get();
6364
6365 QualType Result = TL.getType();
6366 if (getDerived().AlwaysRebuild() || ElementType != T->getElementType() ||
6367 rows != origRows || columns != origColumns) {
6368 Result = getDerived().RebuildDependentSizedMatrixType(
6369 ElementType, rows, columns, T->getAttributeLoc());
6370
6371 if (Result.isNull())
6372 return QualType();
6373 }
6374
6375 // We might have any sort of matrix type now, but fortunately they
6376 // all have the same location layout.
6377 MatrixTypeLoc NewTL = TLB.push<MatrixTypeLoc>(T: Result);
6378 NewTL.setAttrNameLoc(TL.getAttrNameLoc());
6379 NewTL.setAttrOperandParensRange(TL.getAttrOperandParensRange());
6380 NewTL.setAttrRowOperand(rows);
6381 NewTL.setAttrColumnOperand(columns);
6382 return Result;
6383}
6384
6385template <typename Derived>
6386QualType TreeTransform<Derived>::TransformDependentAddressSpaceType(
6387 TypeLocBuilder &TLB, DependentAddressSpaceTypeLoc TL) {
6388 const DependentAddressSpaceType *T = TL.getTypePtr();
6389
6390 QualType pointeeType =
6391 getDerived().TransformType(TLB, TL.getPointeeTypeLoc());
6392
6393 if (pointeeType.isNull())
6394 return QualType();
6395
6396 // Address spaces are constant expressions.
6397 EnterExpressionEvaluationContext Unevaluated(
6398 SemaRef, Sema::ExpressionEvaluationContext::ConstantEvaluated);
6399
6400 ExprResult AddrSpace = getDerived().TransformExpr(T->getAddrSpaceExpr());
6401 AddrSpace = SemaRef.ActOnConstantExpression(Res: AddrSpace);
6402 if (AddrSpace.isInvalid())
6403 return QualType();
6404
6405 QualType Result = TL.getType();
6406 if (getDerived().AlwaysRebuild() || pointeeType != T->getPointeeType() ||
6407 AddrSpace.get() != T->getAddrSpaceExpr()) {
6408 Result = getDerived().RebuildDependentAddressSpaceType(
6409 pointeeType, AddrSpace.get(), T->getAttributeLoc());
6410 if (Result.isNull())
6411 return QualType();
6412 }
6413
6414 // Result might be dependent or not.
6415 if (isa<DependentAddressSpaceType>(Val: Result)) {
6416 DependentAddressSpaceTypeLoc NewTL =
6417 TLB.push<DependentAddressSpaceTypeLoc>(T: Result);
6418
6419 NewTL.setAttrOperandParensRange(TL.getAttrOperandParensRange());
6420 NewTL.setAttrExprOperand(TL.getAttrExprOperand());
6421 NewTL.setAttrNameLoc(TL.getAttrNameLoc());
6422
6423 } else {
6424 TLB.TypeWasModifiedSafely(T: Result);
6425 }
6426
6427 return Result;
6428}
6429
6430template <typename Derived>
6431QualType TreeTransform<Derived>::TransformVectorType(TypeLocBuilder &TLB,
6432 VectorTypeLoc TL) {
6433 const VectorType *T = TL.getTypePtr();
6434 QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc());
6435 if (ElementType.isNull())
6436 return QualType();
6437
6438 QualType Result = TL.getType();
6439 if (getDerived().AlwaysRebuild() ||
6440 ElementType != T->getElementType()) {
6441 Result = getDerived().RebuildVectorType(ElementType, T->getNumElements(),
6442 T->getVectorKind());
6443 if (Result.isNull())
6444 return QualType();
6445 }
6446
6447 VectorTypeLoc NewTL = TLB.push<VectorTypeLoc>(T: Result);
6448 NewTL.setNameLoc(TL.getNameLoc());
6449 NewTL.setAttrNameLoc(TL.getAttrNameLoc());
6450 NewTL.setSizeExpr(TL.getSizeExpr());
6451
6452 return Result;
6453}
6454
6455template<typename Derived>
6456QualType TreeTransform<Derived>::TransformExtVectorType(TypeLocBuilder &TLB,
6457 ExtVectorTypeLoc TL) {
6458 const VectorType *T = TL.getTypePtr();
6459 QualType ElementType = getDerived().TransformType(TLB, TL.getElementLoc());
6460 if (ElementType.isNull())
6461 return QualType();
6462
6463 QualType Result = TL.getType();
6464 if (getDerived().AlwaysRebuild() ||
6465 ElementType != T->getElementType()) {
6466 Result = getDerived().RebuildExtVectorType(ElementType, T->getNumElements(),
6467 TL.getAttrNameLoc());
6468 if (Result.isNull())
6469 return QualType();
6470 }
6471
6472 ExtVectorTypeLoc NewTL = TLB.push<ExtVectorTypeLoc>(T: Result);
6473 NewTL.setNameLoc(TL.getNameLoc());
6474 NewTL.setAttrNameLoc(TL.getAttrNameLoc());
6475 NewTL.setSizeExpr(TL.getSizeExpr());
6476
6477 return Result;
6478}
6479
6480template <typename Derived>
6481ParmVarDecl *TreeTransform<Derived>::TransformFunctionTypeParam(
6482 ParmVarDecl *OldParm, int indexAdjustment, UnsignedOrNone NumExpansions,
6483 bool ExpectParameterPack) {
6484 TypeSourceInfo *OldTSI = OldParm->getTypeSourceInfo();
6485 TypeSourceInfo *NewTSI = nullptr;
6486
6487 if (NumExpansions && isa<PackExpansionType>(Val: OldTSI->getType())) {
6488 // If we're substituting into a pack expansion type and we know the
6489 // length we want to expand to, just substitute for the pattern.
6490 TypeLoc OldTL = OldTSI->getTypeLoc();
6491 PackExpansionTypeLoc OldExpansionTL = OldTL.castAs<PackExpansionTypeLoc>();
6492
6493 TypeLocBuilder TLB;
6494 TypeLoc NewTL = OldTSI->getTypeLoc();
6495 TLB.reserve(Requested: NewTL.getFullDataSize());
6496
6497 QualType Result = getDerived().TransformType(TLB,
6498 OldExpansionTL.getPatternLoc());
6499 if (Result.isNull())
6500 return nullptr;
6501
6502 Result = RebuildPackExpansionType(Pattern: Result,
6503 PatternRange: OldExpansionTL.getPatternLoc().getSourceRange(),
6504 EllipsisLoc: OldExpansionTL.getEllipsisLoc(),
6505 NumExpansions);
6506 if (Result.isNull())
6507 return nullptr;
6508
6509 PackExpansionTypeLoc NewExpansionTL
6510 = TLB.push<PackExpansionTypeLoc>(T: Result);
6511 NewExpansionTL.setEllipsisLoc(OldExpansionTL.getEllipsisLoc());
6512 NewTSI = TLB.getTypeSourceInfo(Context&: SemaRef.Context, T: Result);
6513 } else
6514 NewTSI = getDerived().TransformType(OldTSI);
6515 if (!NewTSI)
6516 return nullptr;
6517
6518 if (NewTSI == OldTSI && indexAdjustment == 0)
6519 return OldParm;
6520
6521 ParmVarDecl *newParm = ParmVarDecl::Create(
6522 C&: SemaRef.Context, DC: OldParm->getDeclContext(), StartLoc: OldParm->getInnerLocStart(),
6523 IdLoc: OldParm->getLocation(), Id: OldParm->getIdentifier(), T: NewTSI->getType(),
6524 TInfo: NewTSI, S: OldParm->getStorageClass(),
6525 /* DefArg */ DefArg: nullptr);
6526 newParm->setScopeInfo(scopeDepth: OldParm->getFunctionScopeDepth(),
6527 parameterIndex: OldParm->getFunctionScopeIndex() + indexAdjustment);
6528 getDerived().transformedLocalDecl(OldParm, {newParm});
6529 return newParm;
6530}
6531
6532template <typename Derived>
6533bool TreeTransform<Derived>::TransformFunctionTypeParams(
6534 SourceLocation Loc, ArrayRef<ParmVarDecl *> Params,
6535 const QualType *ParamTypes,
6536 const FunctionProtoType::ExtParameterInfo *ParamInfos,
6537 SmallVectorImpl<QualType> &OutParamTypes,
6538 SmallVectorImpl<ParmVarDecl *> *PVars,
6539 Sema::ExtParameterInfoBuilder &PInfos,
6540 unsigned *LastParamTransformed) {
6541 int indexAdjustment = 0;
6542
6543 unsigned NumParams = Params.size();
6544 for (unsigned i = 0; i != NumParams; ++i) {
6545 if (LastParamTransformed)
6546 *LastParamTransformed = i;
6547 if (ParmVarDecl *OldParm = Params[i]) {
6548 assert(OldParm->getFunctionScopeIndex() == i);
6549
6550 UnsignedOrNone NumExpansions = std::nullopt;
6551 ParmVarDecl *NewParm = nullptr;
6552 if (OldParm->isParameterPack()) {
6553 // We have a function parameter pack that may need to be expanded.
6554 SmallVector<UnexpandedParameterPack, 2> Unexpanded;
6555
6556 // Find the parameter packs that could be expanded.
6557 TypeLoc TL = OldParm->getTypeSourceInfo()->getTypeLoc();
6558 PackExpansionTypeLoc ExpansionTL = TL.castAs<PackExpansionTypeLoc>();
6559 TypeLoc Pattern = ExpansionTL.getPatternLoc();
6560 SemaRef.collectUnexpandedParameterPacks(TL: Pattern, Unexpanded);
6561
6562 // Determine whether we should expand the parameter packs.
6563 bool ShouldExpand = false;
6564 bool RetainExpansion = false;
6565 UnsignedOrNone OrigNumExpansions = std::nullopt;
6566 if (Unexpanded.size() > 0) {
6567 OrigNumExpansions = ExpansionTL.getTypePtr()->getNumExpansions();
6568 NumExpansions = OrigNumExpansions;
6569 if (getDerived().TryExpandParameterPacks(
6570 ExpansionTL.getEllipsisLoc(), Pattern.getSourceRange(),
6571 Unexpanded, /*FailOnPackProducingTemplates=*/true,
6572 ShouldExpand, RetainExpansion, NumExpansions)) {
6573 return true;
6574 }
6575 } else {
6576#ifndef NDEBUG
6577 const AutoType *AT =
6578 Pattern.getType().getTypePtr()->getContainedAutoType();
6579 assert((AT && (!AT->isDeduced() || AT->getDeducedType().isNull())) &&
6580 "Could not find parameter packs or undeduced auto type!");
6581#endif
6582 }
6583
6584 if (ShouldExpand) {
6585 // Expand the function parameter pack into multiple, separate
6586 // parameters.
6587 getDerived().ExpandingFunctionParameterPack(OldParm);
6588 for (unsigned I = 0; I != *NumExpansions; ++I) {
6589 Sema::ArgPackSubstIndexRAII SubstIndex(getSema(), I);
6590 ParmVarDecl *NewParm
6591 = getDerived().TransformFunctionTypeParam(OldParm,
6592 indexAdjustment++,
6593 OrigNumExpansions,
6594 /*ExpectParameterPack=*/false);
6595 if (!NewParm)
6596 return true;
6597
6598 if (ParamInfos)
6599 PInfos.set(index: OutParamTypes.size(), info: ParamInfos[i]);
6600 OutParamTypes.push_back(Elt: NewParm->getType());
6601 if (PVars)
6602 PVars->push_back(Elt: NewParm);
6603 }
6604
6605 // If we're supposed to retain a pack expansion, do so by temporarily
6606 // forgetting the partially-substituted parameter pack.
6607 if (RetainExpansion) {
6608 ForgetPartiallySubstitutedPackRAII Forget(getDerived());
6609 ParmVarDecl *NewParm
6610 = getDerived().TransformFunctionTypeParam(OldParm,
6611 indexAdjustment++,
6612 OrigNumExpansions,
6613 /*ExpectParameterPack=*/false);
6614 if (!NewParm)
6615 return true;
6616
6617 if (ParamInfos)
6618 PInfos.set(index: OutParamTypes.size(), info: ParamInfos[i]);
6619 OutParamTypes.push_back(Elt: NewParm->getType());
6620 if (PVars)
6621 PVars->push_back(Elt: NewParm);
6622 }
6623
6624 // The next parameter should have the same adjustment as the
6625 // last thing we pushed, but we post-incremented indexAdjustment
6626 // on every push. Also, if we push nothing, the adjustment should
6627 // go down by one.
6628 indexAdjustment--;
6629
6630 // We're done with the pack expansion.
6631 continue;
6632 }
6633
6634 // We'll substitute the parameter now without expanding the pack
6635 // expansion.
6636 Sema::ArgPackSubstIndexRAII SubstIndex(getSema(), std::nullopt);
6637 NewParm = getDerived().TransformFunctionTypeParam(OldParm,
6638 indexAdjustment,
6639 NumExpansions,
6640 /*ExpectParameterPack=*/true);
6641 assert(NewParm->isParameterPack() &&
6642 "Parameter pack no longer a parameter pack after "
6643 "transformation.");
6644 } else {
6645 NewParm = getDerived().TransformFunctionTypeParam(
6646 OldParm, indexAdjustment, std::nullopt,
6647 /*ExpectParameterPack=*/false);
6648 }
6649
6650 if (!NewParm)
6651 return true;
6652
6653 if (ParamInfos)
6654 PInfos.set(index: OutParamTypes.size(), info: ParamInfos[i]);
6655 OutParamTypes.push_back(Elt: NewParm->getType());
6656 if (PVars)
6657 PVars->push_back(Elt: NewParm);
6658 continue;
6659 }
6660
6661 // Deal with the possibility that we don't have a parameter
6662 // declaration for this parameter.
6663 assert(ParamTypes);
6664 QualType OldType = ParamTypes[i];
6665 bool IsPackExpansion = false;
6666 UnsignedOrNone NumExpansions = std::nullopt;
6667 QualType NewType;
6668 if (const PackExpansionType *Expansion
6669 = dyn_cast<PackExpansionType>(Val&: OldType)) {
6670 // We have a function parameter pack that may need to be expanded.
6671 QualType Pattern = Expansion->getPattern();
6672 SmallVector<UnexpandedParameterPack, 2> Unexpanded;
6673 getSema().collectUnexpandedParameterPacks(Pattern, Unexpanded);
6674
6675 // Determine whether we should expand the parameter packs.
6676 bool ShouldExpand = false;
6677 bool RetainExpansion = false;
6678 if (getDerived().TryExpandParameterPacks(
6679 Loc, SourceRange(), Unexpanded,
6680 /*FailOnPackProducingTemplates=*/true, ShouldExpand,
6681 RetainExpansion, NumExpansions)) {
6682 return true;
6683 }
6684
6685 if (ShouldExpand) {
6686 // Expand the function parameter pack into multiple, separate
6687 // parameters.
6688 for (unsigned I = 0; I != *NumExpansions; ++I) {
6689 Sema::ArgPackSubstIndexRAII SubstIndex(getSema(), I);
6690 QualType NewType = getDerived().TransformType(Pattern);
6691 if (NewType.isNull())
6692 return true;
6693
6694 if (NewType->containsUnexpandedParameterPack()) {
6695 NewType = getSema().getASTContext().getPackExpansionType(
6696 NewType, std::nullopt);
6697
6698 if (NewType.isNull())
6699 return true;
6700 }
6701
6702 if (ParamInfos)
6703 PInfos.set(index: OutParamTypes.size(), info: ParamInfos[i]);
6704 OutParamTypes.push_back(Elt: NewType);
6705 if (PVars)
6706 PVars->push_back(Elt: nullptr);
6707 }
6708
6709 // We're done with the pack expansion.
6710 continue;
6711 }
6712
6713 // If we're supposed to retain a pack expansion, do so by temporarily
6714 // forgetting the partially-substituted parameter pack.
6715 if (RetainExpansion) {
6716 ForgetPartiallySubstitutedPackRAII Forget(getDerived());
6717 QualType NewType = getDerived().TransformType(Pattern);
6718 if (NewType.isNull())
6719 return true;
6720
6721 if (ParamInfos)
6722 PInfos.set(index: OutParamTypes.size(), info: ParamInfos[i]);
6723 OutParamTypes.push_back(Elt: NewType);
6724 if (PVars)
6725 PVars->push_back(Elt: nullptr);
6726 }
6727
6728 // We'll substitute the parameter now without expanding the pack
6729 // expansion.
6730 OldType = Expansion->getPattern();
6731 IsPackExpansion = true;
6732 Sema::ArgPackSubstIndexRAII SubstIndex(getSema(), std::nullopt);
6733 NewType = getDerived().TransformType(OldType);
6734 } else {
6735 NewType = getDerived().TransformType(OldType);
6736 }
6737
6738 if (NewType.isNull())
6739 return true;
6740
6741 if (IsPackExpansion)
6742 NewType = getSema().Context.getPackExpansionType(NewType,
6743 NumExpansions);
6744
6745 if (ParamInfos)
6746 PInfos.set(index: OutParamTypes.size(), info: ParamInfos[i]);
6747 OutParamTypes.push_back(Elt: NewType);
6748 if (PVars)
6749 PVars->push_back(Elt: nullptr);
6750 }
6751
6752#ifndef NDEBUG
6753 if (PVars) {
6754 for (unsigned i = 0, e = PVars->size(); i != e; ++i)
6755 if (ParmVarDecl *parm = (*PVars)[i])
6756 assert(parm->getFunctionScopeIndex() == i);
6757 }
6758#endif
6759
6760 return false;
6761}
6762
6763template<typename Derived>
6764QualType
6765TreeTransform<Derived>::TransformFunctionProtoType(TypeLocBuilder &TLB,
6766 FunctionProtoTypeLoc TL) {
6767 SmallVector<QualType, 4> ExceptionStorage;
6768 return getDerived().TransformFunctionProtoType(
6769 TLB, TL, nullptr, Qualifiers(),
6770 [&](FunctionProtoType::ExceptionSpecInfo &ESI, bool &Changed) {
6771 return getDerived().TransformExceptionSpec(TL.getBeginLoc(), ESI,
6772 ExceptionStorage, Changed);
6773 });
6774}
6775
6776template<typename Derived> template<typename Fn>
6777QualType TreeTransform<Derived>::TransformFunctionProtoType(
6778 TypeLocBuilder &TLB, FunctionProtoTypeLoc TL, CXXRecordDecl *ThisContext,
6779 Qualifiers ThisTypeQuals, Fn TransformExceptionSpec) {
6780
6781 // Transform the parameters and return type.
6782 //
6783 // We are required to instantiate the params and return type in source order.
6784 // When the function has a trailing return type, we instantiate the
6785 // parameters before the return type, since the return type can then refer
6786 // to the parameters themselves (via decltype, sizeof, etc.).
6787 //
6788 SmallVector<QualType, 4> ParamTypes;
6789 SmallVector<ParmVarDecl*, 4> ParamDecls;
6790 Sema::ExtParameterInfoBuilder ExtParamInfos;
6791 const FunctionProtoType *T = TL.getTypePtr();
6792
6793 QualType ResultType;
6794
6795 if (T->hasTrailingReturn()) {
6796 if (getDerived().TransformFunctionTypeParams(
6797 TL.getBeginLoc(), TL.getParams(),
6798 TL.getTypePtr()->param_type_begin(),
6799 T->getExtParameterInfosOrNull(),
6800 ParamTypes, &ParamDecls, ExtParamInfos))
6801 return QualType();
6802
6803 {
6804 // C++11 [expr.prim.general]p3:
6805 // If a declaration declares a member function or member function
6806 // template of a class X, the expression this is a prvalue of type
6807 // "pointer to cv-qualifier-seq X" between the optional cv-qualifer-seq
6808 // and the end of the function-definition, member-declarator, or
6809 // declarator.
6810 auto *RD = dyn_cast<CXXRecordDecl>(Val: SemaRef.getCurLexicalContext());
6811 Sema::CXXThisScopeRAII ThisScope(
6812 SemaRef, !ThisContext && RD ? RD : ThisContext, ThisTypeQuals);
6813
6814 ResultType = getDerived().TransformType(TLB, TL.getReturnLoc());
6815 if (ResultType.isNull())
6816 return QualType();
6817 }
6818 }
6819 else {
6820 ResultType = getDerived().TransformType(TLB, TL.getReturnLoc());
6821 if (ResultType.isNull())
6822 return QualType();
6823
6824 if (getDerived().TransformFunctionTypeParams(
6825 TL.getBeginLoc(), TL.getParams(),
6826 TL.getTypePtr()->param_type_begin(),
6827 T->getExtParameterInfosOrNull(),
6828 ParamTypes, &ParamDecls, ExtParamInfos))
6829 return QualType();
6830 }
6831
6832 FunctionProtoType::ExtProtoInfo EPI = T->getExtProtoInfo();
6833
6834 bool EPIChanged = false;
6835 if (TransformExceptionSpec(EPI.ExceptionSpec, EPIChanged))
6836 return QualType();
6837
6838 // Handle extended parameter information.
6839 if (auto NewExtParamInfos =
6840 ExtParamInfos.getPointerOrNull(numParams: ParamTypes.size())) {
6841 if (!EPI.ExtParameterInfos ||
6842 llvm::ArrayRef(EPI.ExtParameterInfos, TL.getNumParams()) !=
6843 llvm::ArrayRef(NewExtParamInfos, ParamTypes.size())) {
6844 EPIChanged = true;
6845 }
6846 EPI.ExtParameterInfos = NewExtParamInfos;
6847 } else if (EPI.ExtParameterInfos) {
6848 EPIChanged = true;
6849 EPI.ExtParameterInfos = nullptr;
6850 }
6851
6852 // Transform any function effects with unevaluated conditions.
6853 // Hold this set in a local for the rest of this function, since EPI
6854 // may need to hold a FunctionEffectsRef pointing into it.
6855 std::optional<FunctionEffectSet> NewFX;
6856 if (ArrayRef FXConds = EPI.FunctionEffects.conditions(); !FXConds.empty()) {
6857 NewFX.emplace();
6858 EnterExpressionEvaluationContext Unevaluated(
6859 getSema(), Sema::ExpressionEvaluationContext::ConstantEvaluated);
6860
6861 for (const FunctionEffectWithCondition &PrevEC : EPI.FunctionEffects) {
6862 FunctionEffectWithCondition NewEC = PrevEC;
6863 if (Expr *CondExpr = PrevEC.Cond.getCondition()) {
6864 ExprResult NewExpr = getDerived().TransformExpr(CondExpr);
6865 if (NewExpr.isInvalid())
6866 return QualType();
6867 std::optional<FunctionEffectMode> Mode =
6868 SemaRef.ActOnEffectExpression(CondExpr: NewExpr.get(), AttributeName: PrevEC.Effect.name());
6869 if (!Mode)
6870 return QualType();
6871
6872 // The condition expression has been transformed, and re-evaluated.
6873 // It may or may not have become constant.
6874 switch (*Mode) {
6875 case FunctionEffectMode::True:
6876 NewEC.Cond = {};
6877 break;
6878 case FunctionEffectMode::False:
6879 NewEC.Effect = FunctionEffect(PrevEC.Effect.oppositeKind());
6880 NewEC.Cond = {};
6881 break;
6882 case FunctionEffectMode::Dependent:
6883 NewEC.Cond = EffectConditionExpr(NewExpr.get());
6884 break;
6885 case FunctionEffectMode::None:
6886 llvm_unreachable(
6887 "FunctionEffectMode::None shouldn't be possible here");
6888 }
6889 }
6890 if (!SemaRef.diagnoseConflictingFunctionEffect(FX: *NewFX, EC: NewEC,
6891 NewAttrLoc: TL.getBeginLoc())) {
6892 FunctionEffectSet::Conflicts Errs;
6893 NewFX->insert(NewEC, Errs);
6894 assert(Errs.empty());
6895 }
6896 }
6897 EPI.FunctionEffects = *NewFX;
6898 EPIChanged = true;
6899 }
6900
6901 QualType Result = TL.getType();
6902 if (getDerived().AlwaysRebuild() || ResultType != T->getReturnType() ||
6903 T->getParamTypes() != llvm::ArrayRef(ParamTypes) || EPIChanged) {
6904 Result = getDerived().RebuildFunctionProtoType(ResultType, ParamTypes, EPI);
6905 if (Result.isNull())
6906 return QualType();
6907 }
6908
6909 FunctionProtoTypeLoc NewTL = TLB.push<FunctionProtoTypeLoc>(T: Result);
6910 NewTL.setLocalRangeBegin(TL.getLocalRangeBegin());
6911 NewTL.setLParenLoc(TL.getLParenLoc());
6912 NewTL.setRParenLoc(TL.getRParenLoc());
6913 NewTL.setExceptionSpecRange(TL.getExceptionSpecRange());
6914 NewTL.setLocalRangeEnd(TL.getLocalRangeEnd());
6915 for (unsigned i = 0, e = NewTL.getNumParams(); i != e; ++i)
6916 NewTL.setParam(i, VD: ParamDecls[i]);
6917
6918 return Result;
6919}
6920
6921template<typename Derived>
6922bool TreeTransform<Derived>::TransformExceptionSpec(
6923 SourceLocation Loc, FunctionProtoType::ExceptionSpecInfo &ESI,
6924 SmallVectorImpl<QualType> &Exceptions, bool &Changed) {
6925 assert(ESI.Type != EST_Uninstantiated && ESI.Type != EST_Unevaluated);
6926
6927 // Instantiate a dynamic noexcept expression, if any.
6928 if (isComputedNoexcept(ESpecType: ESI.Type)) {
6929 // Update this scrope because ContextDecl in Sema will be used in
6930 // TransformExpr.
6931 auto *Method = dyn_cast_if_present<CXXMethodDecl>(Val: ESI.SourceTemplate);
6932 Sema::CXXThisScopeRAII ThisScope(
6933 SemaRef, Method ? Method->getParent() : nullptr,
6934 Method ? Method->getMethodQualifiers() : Qualifiers{},
6935 Method != nullptr);
6936 EnterExpressionEvaluationContext Unevaluated(
6937 getSema(), Sema::ExpressionEvaluationContext::ConstantEvaluated);
6938 ExprResult NoexceptExpr = getDerived().TransformExpr(ESI.NoexceptExpr);
6939 if (NoexceptExpr.isInvalid())
6940 return true;
6941
6942 ExceptionSpecificationType EST = ESI.Type;
6943 NoexceptExpr =
6944 getSema().ActOnNoexceptSpec(NoexceptExpr.get(), EST);
6945 if (NoexceptExpr.isInvalid())
6946 return true;
6947
6948 if (ESI.NoexceptExpr != NoexceptExpr.get() || EST != ESI.Type)
6949 Changed = true;
6950 ESI.NoexceptExpr = NoexceptExpr.get();
6951 ESI.Type = EST;
6952 }
6953
6954 if (ESI.Type != EST_Dynamic)
6955 return false;
6956
6957 // Instantiate a dynamic exception specification's type.
6958 for (QualType T : ESI.Exceptions) {
6959 if (const PackExpansionType *PackExpansion =
6960 T->getAs<PackExpansionType>()) {
6961 Changed = true;
6962
6963 // We have a pack expansion. Instantiate it.
6964 SmallVector<UnexpandedParameterPack, 2> Unexpanded;
6965 SemaRef.collectUnexpandedParameterPacks(T: PackExpansion->getPattern(),
6966 Unexpanded);
6967 assert(!Unexpanded.empty() && "Pack expansion without parameter packs?");
6968
6969 // Determine whether the set of unexpanded parameter packs can and
6970 // should
6971 // be expanded.
6972 bool Expand = false;
6973 bool RetainExpansion = false;
6974 UnsignedOrNone NumExpansions = PackExpansion->getNumExpansions();
6975 // FIXME: Track the location of the ellipsis (and track source location
6976 // information for the types in the exception specification in general).
6977 if (getDerived().TryExpandParameterPacks(
6978 Loc, SourceRange(), Unexpanded,
6979 /*FailOnPackProducingTemplates=*/true, Expand, RetainExpansion,
6980 NumExpansions))
6981 return true;
6982
6983 if (!Expand) {
6984 // We can't expand this pack expansion into separate arguments yet;
6985 // just substitute into the pattern and create a new pack expansion
6986 // type.
6987 Sema::ArgPackSubstIndexRAII SubstIndex(getSema(), std::nullopt);
6988 QualType U = getDerived().TransformType(PackExpansion->getPattern());
6989 if (U.isNull())
6990 return true;
6991
6992 U = SemaRef.Context.getPackExpansionType(Pattern: U, NumExpansions);
6993 Exceptions.push_back(Elt: U);
6994 continue;
6995 }
6996
6997 // Substitute into the pack expansion pattern for each slice of the
6998 // pack.
6999 for (unsigned ArgIdx = 0; ArgIdx != *NumExpansions; ++ArgIdx) {
7000 Sema::ArgPackSubstIndexRAII SubstIndex(getSema(), ArgIdx);
7001
7002 QualType U = getDerived().TransformType(PackExpansion->getPattern());
7003 if (U.isNull() || SemaRef.CheckSpecifiedExceptionType(T&: U, Range: Loc))
7004 return true;
7005
7006 Exceptions.push_back(Elt: U);
7007 }
7008 } else {
7009 QualType U = getDerived().TransformType(T);
7010 if (U.isNull() || SemaRef.CheckSpecifiedExceptionType(T&: U, Range: Loc))
7011 return true;
7012 if (T != U)
7013 Changed = true;
7014
7015 Exceptions.push_back(Elt: U);
7016 }
7017 }
7018
7019 ESI.Exceptions = Exceptions;
7020 if (ESI.Exceptions.empty())
7021 ESI.Type = EST_DynamicNone;
7022 return false;
7023}
7024
7025template<typename Derived>
7026QualType TreeTransform<Derived>::TransformFunctionNoProtoType(
7027 TypeLocBuilder &TLB,
7028 FunctionNoProtoTypeLoc TL) {
7029 const FunctionNoProtoType *T = TL.getTypePtr();
7030 QualType ResultType = getDerived().TransformType(TLB, TL.getReturnLoc());
7031 if (ResultType.isNull())
7032 return QualType();
7033
7034 QualType Result = TL.getType();
7035 if (getDerived().AlwaysRebuild() || ResultType != T->getReturnType())
7036 Result = getDerived().RebuildFunctionNoProtoType(ResultType);
7037
7038 FunctionNoProtoTypeLoc NewTL = TLB.push<FunctionNoProtoTypeLoc>(T: Result);
7039 NewTL.setLocalRangeBegin(TL.getLocalRangeBegin());
7040 NewTL.setLParenLoc(TL.getLParenLoc());
7041 NewTL.setRParenLoc(TL.getRParenLoc());
7042 NewTL.setLocalRangeEnd(TL.getLocalRangeEnd());
7043
7044 return Result;
7045}
7046
7047template <typename Derived>
7048QualType TreeTransform<Derived>::TransformUnresolvedUsingType(
7049 TypeLocBuilder &TLB, UnresolvedUsingTypeLoc TL) {
7050
7051 const UnresolvedUsingType *T = TL.getTypePtr();
7052 bool Changed = false;
7053
7054 NestedNameSpecifierLoc QualifierLoc = TL.getQualifierLoc();
7055 if (NestedNameSpecifierLoc OldQualifierLoc = QualifierLoc) {
7056 QualifierLoc = getDerived().TransformNestedNameSpecifierLoc(QualifierLoc);
7057 if (!QualifierLoc)
7058 return QualType();
7059 Changed |= QualifierLoc != OldQualifierLoc;
7060 }
7061
7062 auto *D = getDerived().TransformDecl(TL.getNameLoc(), T->getDecl());
7063 if (!D)
7064 return QualType();
7065 Changed |= D != T->getDecl();
7066
7067 QualType Result = TL.getType();
7068 if (getDerived().AlwaysRebuild() || Changed) {
7069 Result = getDerived().RebuildUnresolvedUsingType(
7070 T->getKeyword(), QualifierLoc.getNestedNameSpecifier(), TL.getNameLoc(),
7071 D);
7072 if (Result.isNull())
7073 return QualType();
7074 }
7075
7076 if (isa<UsingType>(Val: Result))
7077 TLB.push<UsingTypeLoc>(T: Result).set(ElaboratedKeywordLoc: TL.getElaboratedKeywordLoc(),
7078 QualifierLoc, NameLoc: TL.getNameLoc());
7079 else
7080 TLB.push<UnresolvedUsingTypeLoc>(T: Result).set(ElaboratedKeywordLoc: TL.getElaboratedKeywordLoc(),
7081 QualifierLoc, NameLoc: TL.getNameLoc());
7082 return Result;
7083}
7084
7085template <typename Derived>
7086QualType TreeTransform<Derived>::TransformUsingType(TypeLocBuilder &TLB,
7087 UsingTypeLoc TL) {
7088 const UsingType *T = TL.getTypePtr();
7089 bool Changed = false;
7090
7091 NestedNameSpecifierLoc QualifierLoc = TL.getQualifierLoc();
7092 if (NestedNameSpecifierLoc OldQualifierLoc = QualifierLoc) {
7093 QualifierLoc = getDerived().TransformNestedNameSpecifierLoc(QualifierLoc);
7094 if (!QualifierLoc)
7095 return QualType();
7096 Changed |= QualifierLoc != OldQualifierLoc;
7097 }
7098
7099 auto *D = cast_or_null<UsingShadowDecl>(
7100 getDerived().TransformDecl(TL.getNameLoc(), T->getDecl()));
7101 if (!D)
7102 return QualType();
7103 Changed |= D != T->getDecl();
7104
7105 QualType UnderlyingType = getDerived().TransformType(T->desugar());
7106 if (UnderlyingType.isNull())
7107 return QualType();
7108 Changed |= UnderlyingType != T->desugar();
7109
7110 QualType Result = TL.getType();
7111 if (getDerived().AlwaysRebuild() || Changed) {
7112 Result = getDerived().RebuildUsingType(
7113 T->getKeyword(), QualifierLoc.getNestedNameSpecifier(), D,
7114 UnderlyingType);
7115 if (Result.isNull())
7116 return QualType();
7117 }
7118 TLB.push<UsingTypeLoc>(T: Result).set(ElaboratedKeywordLoc: TL.getElaboratedKeywordLoc(), QualifierLoc,
7119 NameLoc: TL.getNameLoc());
7120 return Result;
7121}
7122
7123template<typename Derived>
7124QualType TreeTransform<Derived>::TransformTypedefType(TypeLocBuilder &TLB,
7125 TypedefTypeLoc TL) {
7126 const TypedefType *T = TL.getTypePtr();
7127 bool Changed = false;
7128
7129 NestedNameSpecifierLoc QualifierLoc = TL.getQualifierLoc();
7130 if (NestedNameSpecifierLoc OldQualifierLoc = QualifierLoc) {
7131 QualifierLoc = getDerived().TransformNestedNameSpecifierLoc(QualifierLoc);
7132 if (!QualifierLoc)
7133 return QualType();
7134 Changed |= QualifierLoc != OldQualifierLoc;
7135 }
7136
7137 auto *Typedef = cast_or_null<TypedefNameDecl>(
7138 getDerived().TransformDecl(TL.getNameLoc(), T->getDecl()));
7139 if (!Typedef)
7140 return QualType();
7141 Changed |= Typedef != T->getDecl();
7142
7143 // FIXME: Transform the UnderlyingType if different from decl.
7144
7145 QualType Result = TL.getType();
7146 if (getDerived().AlwaysRebuild() || Changed) {
7147 Result = getDerived().RebuildTypedefType(
7148 T->getKeyword(), QualifierLoc.getNestedNameSpecifier(), Typedef);
7149 if (Result.isNull())
7150 return QualType();
7151 }
7152
7153 TLB.push<TypedefTypeLoc>(T: Result).set(ElaboratedKeywordLoc: TL.getElaboratedKeywordLoc(),
7154 QualifierLoc, NameLoc: TL.getNameLoc());
7155 return Result;
7156}
7157
7158template<typename Derived>
7159QualType TreeTransform<Derived>::TransformTypeOfExprType(TypeLocBuilder &TLB,
7160 TypeOfExprTypeLoc TL) {
7161 // typeof expressions are not potentially evaluated contexts
7162 EnterExpressionEvaluationContext Unevaluated(
7163 SemaRef, Sema::ExpressionEvaluationContext::Unevaluated,
7164 Sema::ReuseLambdaContextDecl);
7165
7166 ExprResult E = getDerived().TransformExpr(TL.getUnderlyingExpr());
7167 if (E.isInvalid())
7168 return QualType();
7169
7170 E = SemaRef.HandleExprEvaluationContextForTypeof(E: E.get());
7171 if (E.isInvalid())
7172 return QualType();
7173
7174 QualType Result = TL.getType();
7175 TypeOfKind Kind = Result->castAs<TypeOfExprType>()->getKind();
7176 if (getDerived().AlwaysRebuild() || E.get() != TL.getUnderlyingExpr()) {
7177 Result =
7178 getDerived().RebuildTypeOfExprType(E.get(), TL.getTypeofLoc(), Kind);
7179 if (Result.isNull())
7180 return QualType();
7181 }
7182
7183 TypeOfExprTypeLoc NewTL = TLB.push<TypeOfExprTypeLoc>(T: Result);
7184 NewTL.setTypeofLoc(TL.getTypeofLoc());
7185 NewTL.setLParenLoc(TL.getLParenLoc());
7186 NewTL.setRParenLoc(TL.getRParenLoc());
7187
7188 return Result;
7189}
7190
7191template<typename Derived>
7192QualType TreeTransform<Derived>::TransformTypeOfType(TypeLocBuilder &TLB,
7193 TypeOfTypeLoc TL) {
7194 TypeSourceInfo* Old_Under_TI = TL.getUnmodifiedTInfo();
7195 TypeSourceInfo* New_Under_TI = getDerived().TransformType(Old_Under_TI);
7196 if (!New_Under_TI)
7197 return QualType();
7198
7199 QualType Result = TL.getType();
7200 TypeOfKind Kind = Result->castAs<TypeOfType>()->getKind();
7201 if (getDerived().AlwaysRebuild() || New_Under_TI != Old_Under_TI) {
7202 Result = getDerived().RebuildTypeOfType(New_Under_TI->getType(), Kind);
7203 if (Result.isNull())
7204 return QualType();
7205 }
7206
7207 TypeOfTypeLoc NewTL = TLB.push<TypeOfTypeLoc>(T: Result);
7208 NewTL.setTypeofLoc(TL.getTypeofLoc());
7209 NewTL.setLParenLoc(TL.getLParenLoc());
7210 NewTL.setRParenLoc(TL.getRParenLoc());
7211 NewTL.setUnmodifiedTInfo(New_Under_TI);
7212
7213 return Result;
7214}
7215
7216template<typename Derived>
7217QualType TreeTransform<Derived>::TransformDecltypeType(TypeLocBuilder &TLB,
7218 DecltypeTypeLoc TL) {
7219 const DecltypeType *T = TL.getTypePtr();
7220
7221 // decltype expressions are not potentially evaluated contexts
7222 EnterExpressionEvaluationContext Unevaluated(
7223 SemaRef, Sema::ExpressionEvaluationContext::Unevaluated, nullptr,
7224 Sema::ExpressionEvaluationContextRecord::EK_Decltype);
7225
7226 ExprResult E = getDerived().TransformExpr(T->getUnderlyingExpr());
7227 if (E.isInvalid())
7228 return QualType();
7229
7230 E = getSema().ActOnDecltypeExpression(E.get());
7231 if (E.isInvalid())
7232 return QualType();
7233
7234 QualType Result = TL.getType();
7235 if (getDerived().AlwaysRebuild() ||
7236 E.get() != T->getUnderlyingExpr()) {
7237 Result = getDerived().RebuildDecltypeType(E.get(), TL.getDecltypeLoc());
7238 if (Result.isNull())
7239 return QualType();
7240 }
7241 else E.get();
7242
7243 DecltypeTypeLoc NewTL = TLB.push<DecltypeTypeLoc>(T: Result);
7244 NewTL.setDecltypeLoc(TL.getDecltypeLoc());
7245 NewTL.setRParenLoc(TL.getRParenLoc());
7246 return Result;
7247}
7248
7249template <typename Derived>
7250QualType
7251TreeTransform<Derived>::TransformPackIndexingType(TypeLocBuilder &TLB,
7252 PackIndexingTypeLoc TL) {
7253 // Transform the index
7254 ExprResult IndexExpr;
7255 {
7256 EnterExpressionEvaluationContext ConstantContext(
7257 SemaRef, Sema::ExpressionEvaluationContext::ConstantEvaluated);
7258
7259 IndexExpr = getDerived().TransformExpr(TL.getIndexExpr());
7260 if (IndexExpr.isInvalid())
7261 return QualType();
7262 }
7263 QualType Pattern = TL.getPattern();
7264
7265 const PackIndexingType *PIT = TL.getTypePtr();
7266 SmallVector<QualType, 5> SubtitutedTypes;
7267 llvm::ArrayRef<QualType> Types = PIT->getExpansions();
7268
7269 bool NotYetExpanded = Types.empty();
7270 bool FullySubstituted = true;
7271
7272 if (Types.empty() && !PIT->expandsToEmptyPack())
7273 Types = llvm::ArrayRef<QualType>(&Pattern, 1);
7274
7275 for (QualType T : Types) {
7276 if (!T->containsUnexpandedParameterPack()) {
7277 QualType Transformed = getDerived().TransformType(T);
7278 if (Transformed.isNull())
7279 return QualType();
7280 SubtitutedTypes.push_back(Elt: Transformed);
7281 continue;
7282 }
7283
7284 SmallVector<UnexpandedParameterPack, 2> Unexpanded;
7285 getSema().collectUnexpandedParameterPacks(T, Unexpanded);
7286 assert(!Unexpanded.empty() && "Pack expansion without parameter packs?");
7287 // Determine whether the set of unexpanded parameter packs can and should
7288 // be expanded.
7289 bool ShouldExpand = true;
7290 bool RetainExpansion = false;
7291 UnsignedOrNone NumExpansions = std::nullopt;
7292 if (getDerived().TryExpandParameterPacks(
7293 TL.getEllipsisLoc(), SourceRange(), Unexpanded,
7294 /*FailOnPackProducingTemplates=*/true, ShouldExpand,
7295 RetainExpansion, NumExpansions))
7296 return QualType();
7297 if (!ShouldExpand) {
7298 Sema::ArgPackSubstIndexRAII SubstIndex(getSema(), std::nullopt);
7299 // FIXME: should we keep TypeLoc for individual expansions in
7300 // PackIndexingTypeLoc?
7301 TypeSourceInfo *TI =
7302 SemaRef.getASTContext().getTrivialTypeSourceInfo(T, Loc: TL.getBeginLoc());
7303 QualType Pack = getDerived().TransformType(TLB, TI->getTypeLoc());
7304 if (Pack.isNull())
7305 return QualType();
7306 if (NotYetExpanded) {
7307 FullySubstituted = false;
7308 QualType Out = getDerived().RebuildPackIndexingType(
7309 Pack, IndexExpr.get(), TL.getBeginLoc(), FullySubstituted);
7310 if (Out.isNull())
7311 return QualType();
7312
7313 PackIndexingTypeLoc Loc = TLB.push<PackIndexingTypeLoc>(T: Out);
7314 Loc.setEllipsisLoc(TL.getEllipsisLoc());
7315 return Out;
7316 }
7317 SubtitutedTypes.push_back(Elt: Pack);
7318 continue;
7319 }
7320 for (unsigned I = 0; I != *NumExpansions; ++I) {
7321 Sema::ArgPackSubstIndexRAII SubstIndex(getSema(), I);
7322 QualType Out = getDerived().TransformType(T);
7323 if (Out.isNull())
7324 return QualType();
7325 SubtitutedTypes.push_back(Elt: Out);
7326 FullySubstituted &= !Out->containsUnexpandedParameterPack();
7327 }
7328 // If we're supposed to retain a pack expansion, do so by temporarily
7329 // forgetting the partially-substituted parameter pack.
7330 if (RetainExpansion) {
7331 FullySubstituted = false;
7332 ForgetPartiallySubstitutedPackRAII Forget(getDerived());
7333 QualType Out = getDerived().TransformType(T);
7334 if (Out.isNull())
7335 return QualType();
7336 SubtitutedTypes.push_back(Elt: Out);
7337 }
7338 }
7339
7340 // A pack indexing type can appear in a larger pack expansion,
7341 // e.g. `Pack...[pack_of_indexes]...`
7342 // so we need to temporarily disable substitution of pack elements
7343 Sema::ArgPackSubstIndexRAII SubstIndex(getSema(), std::nullopt);
7344 QualType Result = getDerived().TransformType(TLB, TL.getPatternLoc());
7345
7346 QualType Out = getDerived().RebuildPackIndexingType(
7347 Result, IndexExpr.get(), TL.getBeginLoc(), FullySubstituted,
7348 SubtitutedTypes);
7349 if (Out.isNull())
7350 return Out;
7351
7352 PackIndexingTypeLoc Loc = TLB.push<PackIndexingTypeLoc>(T: Out);
7353 Loc.setEllipsisLoc(TL.getEllipsisLoc());
7354 return Out;
7355}
7356
7357template<typename Derived>
7358QualType TreeTransform<Derived>::TransformUnaryTransformType(
7359 TypeLocBuilder &TLB,
7360 UnaryTransformTypeLoc TL) {
7361 QualType Result = TL.getType();
7362 TypeSourceInfo *NewBaseTSI = TL.getUnderlyingTInfo();
7363 if (Result->isDependentType()) {
7364 const UnaryTransformType *T = TL.getTypePtr();
7365
7366 NewBaseTSI = getDerived().TransformType(TL.getUnderlyingTInfo());
7367 if (!NewBaseTSI)
7368 return QualType();
7369 QualType NewBase = NewBaseTSI->getType();
7370
7371 Result = getDerived().RebuildUnaryTransformType(NewBase,
7372 T->getUTTKind(),
7373 TL.getKWLoc());
7374 if (Result.isNull())
7375 return QualType();
7376 }
7377
7378 UnaryTransformTypeLoc NewTL = TLB.push<UnaryTransformTypeLoc>(T: Result);
7379 NewTL.setKWLoc(TL.getKWLoc());
7380 NewTL.setParensRange(TL.getParensRange());
7381 NewTL.setUnderlyingTInfo(NewBaseTSI);
7382 return Result;
7383}
7384
7385template<typename Derived>
7386QualType TreeTransform<Derived>::TransformDeducedTemplateSpecializationType(
7387 TypeLocBuilder &TLB, DeducedTemplateSpecializationTypeLoc TL) {
7388 const DeducedTemplateSpecializationType *T = TL.getTypePtr();
7389
7390 NestedNameSpecifierLoc QualifierLoc = TL.getQualifierLoc();
7391 TemplateName TemplateName = getDerived().TransformTemplateName(
7392 QualifierLoc, /*TemplateKELoc=*/SourceLocation(), T->getTemplateName(),
7393 TL.getTemplateNameLoc());
7394 if (TemplateName.isNull())
7395 return QualType();
7396
7397 QualType OldDeduced = T->getDeducedType();
7398 QualType NewDeduced;
7399 if (!OldDeduced.isNull()) {
7400 NewDeduced = getDerived().TransformType(OldDeduced);
7401 if (NewDeduced.isNull())
7402 return QualType();
7403 }
7404
7405 QualType Result = getDerived().RebuildDeducedTemplateSpecializationType(
7406 NewDeduced.isNull() ? DeducedKind::Undeduced : DeducedKind::Deduced,
7407 NewDeduced, T->getKeyword(), TemplateName);
7408 if (Result.isNull())
7409 return QualType();
7410
7411 auto NewTL = TLB.push<DeducedTemplateSpecializationTypeLoc>(T: Result);
7412 NewTL.setElaboratedKeywordLoc(TL.getElaboratedKeywordLoc());
7413 NewTL.setTemplateNameLoc(TL.getTemplateNameLoc());
7414 NewTL.setQualifierLoc(QualifierLoc);
7415 return Result;
7416}
7417
7418template <typename Derived>
7419QualType TreeTransform<Derived>::TransformTagType(TypeLocBuilder &TLB,
7420 TagTypeLoc TL) {
7421 const TagType *T = TL.getTypePtr();
7422
7423 NestedNameSpecifierLoc QualifierLoc = TL.getQualifierLoc();
7424 if (QualifierLoc) {
7425 QualifierLoc = getDerived().TransformNestedNameSpecifierLoc(QualifierLoc);
7426 if (!QualifierLoc)
7427 return QualType();
7428 }
7429
7430 auto *TD = cast_or_null<TagDecl>(
7431 getDerived().TransformDecl(TL.getNameLoc(), T->getDecl()));
7432 if (!TD)
7433 return QualType();
7434
7435 QualType Result = TL.getType();
7436 if (getDerived().AlwaysRebuild() || QualifierLoc != TL.getQualifierLoc() ||
7437 TD != T->getDecl()) {
7438 if (T->isCanonicalUnqualified())
7439 Result = getDerived().RebuildCanonicalTagType(TD);
7440 else
7441 Result = getDerived().RebuildTagType(
7442 T->getKeyword(), QualifierLoc.getNestedNameSpecifier(), TD);
7443 if (Result.isNull())
7444 return QualType();
7445 }
7446
7447 TagTypeLoc NewTL = TLB.push<TagTypeLoc>(T: Result);
7448 NewTL.setElaboratedKeywordLoc(TL.getElaboratedKeywordLoc());
7449 NewTL.setQualifierLoc(QualifierLoc);
7450 NewTL.setNameLoc(TL.getNameLoc());
7451
7452 return Result;
7453}
7454
7455template <typename Derived>
7456QualType TreeTransform<Derived>::TransformEnumType(TypeLocBuilder &TLB,
7457 EnumTypeLoc TL) {
7458 return getDerived().TransformTagType(TLB, TL);
7459}
7460
7461template <typename Derived>
7462QualType TreeTransform<Derived>::TransformRecordType(TypeLocBuilder &TLB,
7463 RecordTypeLoc TL) {
7464 return getDerived().TransformTagType(TLB, TL);
7465}
7466
7467template<typename Derived>
7468QualType TreeTransform<Derived>::TransformInjectedClassNameType(
7469 TypeLocBuilder &TLB,
7470 InjectedClassNameTypeLoc TL) {
7471 return getDerived().TransformTagType(TLB, TL);
7472}
7473
7474template<typename Derived>
7475QualType TreeTransform<Derived>::TransformTemplateTypeParmType(
7476 TypeLocBuilder &TLB,
7477 TemplateTypeParmTypeLoc TL) {
7478 return getDerived().TransformTemplateTypeParmType(
7479 TLB, TL,
7480 /*SuppressObjCLifetime=*/false);
7481}
7482
7483template <typename Derived>
7484QualType TreeTransform<Derived>::TransformTemplateTypeParmType(
7485 TypeLocBuilder &TLB, TemplateTypeParmTypeLoc TL, bool) {
7486 return TransformTypeSpecType(TLB, T: TL);
7487}
7488
7489template<typename Derived>
7490QualType TreeTransform<Derived>::TransformSubstTemplateTypeParmType(
7491 TypeLocBuilder &TLB,
7492 SubstTemplateTypeParmTypeLoc TL) {
7493 const SubstTemplateTypeParmType *T = TL.getTypePtr();
7494
7495 Decl *NewReplaced =
7496 getDerived().TransformDecl(TL.getNameLoc(), T->getAssociatedDecl());
7497
7498 // Substitute into the replacement type, which itself might involve something
7499 // that needs to be transformed. This only tends to occur with default
7500 // template arguments of template template parameters.
7501 TemporaryBase Rebase(*this, TL.getNameLoc(), DeclarationName());
7502 QualType Replacement = getDerived().TransformType(T->getReplacementType());
7503 if (Replacement.isNull())
7504 return QualType();
7505
7506 QualType Result = SemaRef.Context.getSubstTemplateTypeParmType(
7507 Replacement, AssociatedDecl: NewReplaced, Index: T->getIndex(), PackIndex: T->getPackIndex(),
7508 Final: T->getFinal());
7509
7510 // Propagate type-source information.
7511 SubstTemplateTypeParmTypeLoc NewTL
7512 = TLB.push<SubstTemplateTypeParmTypeLoc>(T: Result);
7513 NewTL.setNameLoc(TL.getNameLoc());
7514 return Result;
7515
7516}
7517template <typename Derived>
7518QualType TreeTransform<Derived>::TransformSubstBuiltinTemplatePackType(
7519 TypeLocBuilder &TLB, SubstBuiltinTemplatePackTypeLoc TL) {
7520 return TransformTypeSpecType(TLB, T: TL);
7521}
7522
7523template<typename Derived>
7524QualType TreeTransform<Derived>::TransformSubstTemplateTypeParmPackType(
7525 TypeLocBuilder &TLB,
7526 SubstTemplateTypeParmPackTypeLoc TL) {
7527 return getDerived().TransformSubstTemplateTypeParmPackType(
7528 TLB, TL, /*SuppressObjCLifetime=*/false);
7529}
7530
7531template <typename Derived>
7532QualType TreeTransform<Derived>::TransformSubstTemplateTypeParmPackType(
7533 TypeLocBuilder &TLB, SubstTemplateTypeParmPackTypeLoc TL, bool) {
7534 return TransformTypeSpecType(TLB, T: TL);
7535}
7536
7537template<typename Derived>
7538QualType TreeTransform<Derived>::TransformAtomicType(TypeLocBuilder &TLB,
7539 AtomicTypeLoc TL) {
7540 QualType ValueType = getDerived().TransformType(TLB, TL.getValueLoc());
7541 if (ValueType.isNull())
7542 return QualType();
7543
7544 QualType Result = TL.getType();
7545 if (getDerived().AlwaysRebuild() ||
7546 ValueType != TL.getValueLoc().getType()) {
7547 Result = getDerived().RebuildAtomicType(ValueType, TL.getKWLoc());
7548 if (Result.isNull())
7549 return QualType();
7550 }
7551
7552 AtomicTypeLoc NewTL = TLB.push<AtomicTypeLoc>(T: Result);
7553 NewTL.setKWLoc(TL.getKWLoc());
7554 NewTL.setLParenLoc(TL.getLParenLoc());
7555 NewTL.setRParenLoc(TL.getRParenLoc());
7556
7557 return Result;
7558}
7559
7560template <typename Derived>
7561QualType TreeTransform<Derived>::TransformPipeType(TypeLocBuilder &TLB,
7562 PipeTypeLoc TL) {
7563 QualType ValueType = getDerived().TransformType(TLB, TL.getValueLoc());
7564 if (ValueType.isNull())
7565 return QualType();
7566
7567 QualType Result = TL.getType();
7568 if (getDerived().AlwaysRebuild() || ValueType != TL.getValueLoc().getType()) {
7569 const PipeType *PT = Result->castAs<PipeType>();
7570 bool isReadPipe = PT->isReadOnly();
7571 Result = getDerived().RebuildPipeType(ValueType, TL.getKWLoc(), isReadPipe);
7572 if (Result.isNull())
7573 return QualType();
7574 }
7575
7576 PipeTypeLoc NewTL = TLB.push<PipeTypeLoc>(T: Result);
7577 NewTL.setKWLoc(TL.getKWLoc());
7578
7579 return Result;
7580}
7581
7582template <typename Derived>
7583QualType TreeTransform<Derived>::TransformBitIntType(TypeLocBuilder &TLB,
7584 BitIntTypeLoc TL) {
7585 const BitIntType *EIT = TL.getTypePtr();
7586 QualType Result = TL.getType();
7587
7588 if (getDerived().AlwaysRebuild()) {
7589 Result = getDerived().RebuildBitIntType(EIT->isUnsigned(),
7590 EIT->getNumBits(), TL.getNameLoc());
7591 if (Result.isNull())
7592 return QualType();
7593 }
7594
7595 BitIntTypeLoc NewTL = TLB.push<BitIntTypeLoc>(T: Result);
7596 NewTL.setNameLoc(TL.getNameLoc());
7597 return Result;
7598}
7599
7600template <typename Derived>
7601QualType TreeTransform<Derived>::TransformDependentBitIntType(
7602 TypeLocBuilder &TLB, DependentBitIntTypeLoc TL) {
7603 const DependentBitIntType *EIT = TL.getTypePtr();
7604
7605 EnterExpressionEvaluationContext Unevaluated(
7606 SemaRef, Sema::ExpressionEvaluationContext::ConstantEvaluated);
7607 ExprResult BitsExpr = getDerived().TransformExpr(EIT->getNumBitsExpr());
7608 BitsExpr = SemaRef.ActOnConstantExpression(Res: BitsExpr);
7609
7610 if (BitsExpr.isInvalid())
7611 return QualType();
7612
7613 QualType Result = TL.getType();
7614
7615 if (getDerived().AlwaysRebuild() || BitsExpr.get() != EIT->getNumBitsExpr()) {
7616 Result = getDerived().RebuildDependentBitIntType(
7617 EIT->isUnsigned(), BitsExpr.get(), TL.getNameLoc());
7618
7619 if (Result.isNull())
7620 return QualType();
7621 }
7622
7623 if (isa<DependentBitIntType>(Val: Result)) {
7624 DependentBitIntTypeLoc NewTL = TLB.push<DependentBitIntTypeLoc>(T: Result);
7625 NewTL.setNameLoc(TL.getNameLoc());
7626 } else {
7627 BitIntTypeLoc NewTL = TLB.push<BitIntTypeLoc>(T: Result);
7628 NewTL.setNameLoc(TL.getNameLoc());
7629 }
7630 return Result;
7631}
7632
7633template <typename Derived>
7634QualType TreeTransform<Derived>::TransformPredefinedSugarType(
7635 TypeLocBuilder &TLB, PredefinedSugarTypeLoc TL) {
7636 llvm_unreachable("This type does not need to be transformed.");
7637}
7638
7639 /// Simple iterator that traverses the template arguments in a
7640 /// container that provides a \c getArgLoc() member function.
7641 ///
7642 /// This iterator is intended to be used with the iterator form of
7643 /// \c TreeTransform<Derived>::TransformTemplateArguments().
7644 template<typename ArgLocContainer>
7645 class TemplateArgumentLocContainerIterator {
7646 ArgLocContainer *Container;
7647 unsigned Index;
7648
7649 public:
7650 typedef TemplateArgumentLoc value_type;
7651 typedef TemplateArgumentLoc reference;
7652 typedef int difference_type;
7653 typedef std::input_iterator_tag iterator_category;
7654
7655 class pointer {
7656 TemplateArgumentLoc Arg;
7657
7658 public:
7659 explicit pointer(TemplateArgumentLoc Arg) : Arg(Arg) { }
7660
7661 const TemplateArgumentLoc *operator->() const {
7662 return &Arg;
7663 }
7664 };
7665
7666
7667 TemplateArgumentLocContainerIterator() {}
7668
7669 TemplateArgumentLocContainerIterator(ArgLocContainer &Container,
7670 unsigned Index)
7671 : Container(&Container), Index(Index) { }
7672
7673 TemplateArgumentLocContainerIterator &operator++() {
7674 ++Index;
7675 return *this;
7676 }
7677
7678 TemplateArgumentLocContainerIterator operator++(int) {
7679 TemplateArgumentLocContainerIterator Old(*this);
7680 ++(*this);
7681 return Old;
7682 }
7683
7684 TemplateArgumentLoc operator*() const {
7685 return Container->getArgLoc(Index);
7686 }
7687
7688 pointer operator->() const {
7689 return pointer(Container->getArgLoc(Index));
7690 }
7691
7692 friend bool operator==(const TemplateArgumentLocContainerIterator &X,
7693 const TemplateArgumentLocContainerIterator &Y) {
7694 return X.Container == Y.Container && X.Index == Y.Index;
7695 }
7696
7697 friend bool operator!=(const TemplateArgumentLocContainerIterator &X,
7698 const TemplateArgumentLocContainerIterator &Y) {
7699 return !(X == Y);
7700 }
7701 };
7702
7703template<typename Derived>
7704QualType TreeTransform<Derived>::TransformAutoType(TypeLocBuilder &TLB,
7705 AutoTypeLoc TL) {
7706 const AutoType *T = TL.getTypePtr();
7707 QualType OldDeduced = T->getDeducedType();
7708 QualType NewDeduced;
7709 if (!OldDeduced.isNull()) {
7710 NewDeduced = getDerived().TransformType(OldDeduced);
7711 if (NewDeduced.isNull())
7712 return QualType();
7713 }
7714
7715 TemplateName NewCD;
7716 TemplateArgumentListInfo NewTemplateArgs;
7717 NestedNameSpecifierLoc NewNestedNameSpec;
7718 if (T->isConstrained()) {
7719 assert(TL.getConceptReference());
7720 NewCD = getDerived().TransformConceptTemplateName(
7721 T->getTypeConstraintConcept(), TL.getConceptNameLoc());
7722 if (NewCD.isNull())
7723 return QualType();
7724
7725 NewTemplateArgs.setLAngleLoc(TL.getLAngleLoc());
7726 NewTemplateArgs.setRAngleLoc(TL.getRAngleLoc());
7727 typedef TemplateArgumentLocContainerIterator<AutoTypeLoc> ArgIterator;
7728 if (getDerived().TransformTemplateArguments(
7729 ArgIterator(TL, 0), ArgIterator(TL, TL.getNumArgs()),
7730 NewTemplateArgs))
7731 return QualType();
7732
7733 if (TL.getNestedNameSpecifierLoc()) {
7734 NewNestedNameSpec
7735 = getDerived().TransformNestedNameSpecifierLoc(
7736 TL.getNestedNameSpecifierLoc());
7737 if (!NewNestedNameSpec)
7738 return QualType();
7739 }
7740 }
7741
7742 QualType Result = TL.getType();
7743 if (getDerived().AlwaysRebuild() || NewDeduced != OldDeduced ||
7744 T->isDependentType() || T->isConstrained()) {
7745 // FIXME: Maybe don't rebuild if all template arguments are the same.
7746 llvm::SmallVector<TemplateArgument, 4> NewArgList;
7747 NewArgList.reserve(N: NewTemplateArgs.size());
7748 for (const auto &ArgLoc : NewTemplateArgs.arguments())
7749 NewArgList.push_back(Elt: ArgLoc.getArgument());
7750 Result = getDerived().RebuildAutoType(
7751 NewDeduced.isNull() ? DeducedKind::Undeduced : DeducedKind::Deduced,
7752 NewDeduced, T->getKeyword(), NewCD, NewArgList);
7753 if (Result.isNull())
7754 return QualType();
7755 }
7756
7757 AutoTypeLoc NewTL = TLB.push<AutoTypeLoc>(T: Result);
7758 NewTL.setNameLoc(TL.getNameLoc());
7759 NewTL.setRParenLoc(TL.getRParenLoc());
7760 NewTL.setConceptReference(nullptr);
7761
7762 if (T->isConstrained()) {
7763 DeclarationName ConceptName =
7764 SemaRef.Context
7765 .getNameForTemplate(Name: TL.getTypePtr()->getTypeConstraintConcept(),
7766 NameLoc: TL.getConceptNameLoc())
7767 .getName();
7768 DeclarationNameInfo DNI =
7769 DeclarationNameInfo(ConceptName, TL.getConceptNameLoc(), ConceptName);
7770 auto *CR = ConceptReference::Create(
7771 C: SemaRef.Context, NNS: NewNestedNameSpec, TemplateKWLoc: TL.getTemplateKWLoc(), ConceptNameInfo: DNI,
7772 FoundDecl: TL.getFoundDecl(), NamedConcept: TL.getTypePtr()->getTypeConstraintConcept(),
7773 ArgsAsWritten: ASTTemplateArgumentListInfo::Create(C: SemaRef.Context, List: NewTemplateArgs));
7774 NewTL.setConceptReference(CR);
7775 }
7776
7777 return Result;
7778}
7779
7780template <typename Derived>
7781QualType TreeTransform<Derived>::TransformTemplateSpecializationType(
7782 TypeLocBuilder &TLB, TemplateSpecializationTypeLoc TL) {
7783 return getDerived().TransformTemplateSpecializationType(
7784 TLB, TL, /*ObjectType=*/QualType(), /*FirstQualifierInScope=*/nullptr,
7785 /*AllowInjectedClassName=*/false);
7786}
7787
7788template <typename Derived>
7789QualType TreeTransform<Derived>::TransformTemplateSpecializationType(
7790 TypeLocBuilder &TLB, TemplateSpecializationTypeLoc TL, QualType ObjectType,
7791 NamedDecl *FirstQualifierInScope, bool AllowInjectedClassName) {
7792 const TemplateSpecializationType *T = TL.getTypePtr();
7793
7794 NestedNameSpecifierLoc QualifierLoc = TL.getQualifierLoc();
7795 TemplateName Template = getDerived().TransformTemplateName(
7796 QualifierLoc, TL.getTemplateKeywordLoc(), T->getTemplateName(),
7797 TL.getTemplateNameLoc(), ObjectType, FirstQualifierInScope,
7798 AllowInjectedClassName);
7799 if (Template.isNull())
7800 return QualType();
7801
7802 TemplateArgumentListInfo NewTemplateArgs;
7803 NewTemplateArgs.setLAngleLoc(TL.getLAngleLoc());
7804 NewTemplateArgs.setRAngleLoc(TL.getRAngleLoc());
7805 typedef TemplateArgumentLocContainerIterator<TemplateSpecializationTypeLoc>
7806 ArgIterator;
7807 if (getDerived().TransformTemplateArguments(ArgIterator(TL, 0),
7808 ArgIterator(TL, TL.getNumArgs()),
7809 NewTemplateArgs))
7810 return QualType();
7811
7812 // This needs to be rebuilt if either the arguments changed, or if the
7813 // original template changed. If the template changed, and even if the
7814 // arguments didn't change, these arguments might not correspond to their
7815 // respective parameters, therefore needing conversions.
7816 QualType Result = getDerived().RebuildTemplateSpecializationType(
7817 TL.getTypePtr()->getKeyword(), Template, TL.getTemplateNameLoc(),
7818 NewTemplateArgs);
7819
7820 if (!Result.isNull()) {
7821 TLB.push<TemplateSpecializationTypeLoc>(T: Result).set(
7822 ElaboratedKeywordLoc: TL.getElaboratedKeywordLoc(), QualifierLoc, TemplateKeywordLoc: TL.getTemplateKeywordLoc(),
7823 NameLoc: TL.getTemplateNameLoc(), TAL: NewTemplateArgs);
7824 }
7825
7826 return Result;
7827}
7828
7829template <typename Derived>
7830QualType TreeTransform<Derived>::TransformAttributedType(TypeLocBuilder &TLB,
7831 AttributedTypeLoc TL) {
7832 const AttributedType *oldType = TL.getTypePtr();
7833 QualType modifiedType = getDerived().TransformType(TLB, TL.getModifiedLoc());
7834 if (modifiedType.isNull())
7835 return QualType();
7836
7837 // HLSL: re-validate matrix-layout markers after substitution. If the
7838 // post-substitution type is no longer a matrix, diagnose now.
7839 if (SemaRef.getLangOpts().HLSL &&
7840 SemaRef.HLSL().diagnoseMatrixLayoutInstantiation(
7841 K: oldType->getAttrKind(), T: modifiedType,
7842 Loc: TL.getAttr() ? TL.getAttr()->getLocation()
7843 : TL.getModifiedLoc().getBeginLoc()))
7844 return QualType();
7845
7846 // oldAttr can be null if we started with a QualType rather than a TypeLoc.
7847 const Attr *oldAttr = TL.getAttr();
7848 const Attr *newAttr = oldAttr ? getDerived().TransformAttr(oldAttr) : nullptr;
7849 if (oldAttr && !newAttr)
7850 return QualType();
7851
7852 QualType result = TL.getType();
7853
7854 // FIXME: dependent operand expressions?
7855 if (getDerived().AlwaysRebuild() ||
7856 modifiedType != oldType->getModifiedType()) {
7857 // If the equivalent type is equal to the modified type, we don't want to
7858 // transform it as well because:
7859 //
7860 // 1. The transformation would yield the same result and is therefore
7861 // superfluous, and
7862 //
7863 // 2. Transforming the same type twice can cause problems, e.g. if it
7864 // is a FunctionProtoType, we may end up instantiating the function
7865 // parameters twice, which causes an assertion since the parameters
7866 // are already bound to their counterparts in the template for this
7867 // instantiation.
7868 //
7869 QualType equivalentType = modifiedType;
7870 if (TL.getModifiedLoc().getType() != TL.getEquivalentTypeLoc().getType()) {
7871 TypeLocBuilder AuxiliaryTLB;
7872 AuxiliaryTLB.reserve(Requested: TL.getFullDataSize());
7873 equivalentType =
7874 getDerived().TransformType(AuxiliaryTLB, TL.getEquivalentTypeLoc());
7875 if (equivalentType.isNull())
7876 return QualType();
7877 }
7878
7879 if (SemaRef.getLangOpts().HLSL) {
7880 if (oldType->getAttrKind() == attr::HLSLRowMajor)
7881 equivalentType = SemaRef.Context.getMatrixTypeWithLayout(
7882 T: equivalentType, Layout: MatrixType::LayoutKind::RowMajor);
7883 else if (oldType->getAttrKind() == attr::HLSLColumnMajor)
7884 equivalentType = SemaRef.Context.getMatrixTypeWithLayout(
7885 T: equivalentType, Layout: MatrixType::LayoutKind::ColumnMajor);
7886 }
7887
7888 // Check whether we can add nullability; it is only represented as
7889 // type sugar, and therefore cannot be diagnosed in any other way.
7890 if (auto nullability = oldType->getImmediateNullability()) {
7891 if (!modifiedType->canHaveNullability()) {
7892 SemaRef.Diag(Loc: (TL.getAttr() ? TL.getAttr()->getLocation()
7893 : TL.getModifiedLoc().getBeginLoc()),
7894 DiagID: diag::err_nullability_nonpointer)
7895 << DiagNullabilityKind(*nullability, false) << modifiedType;
7896 return QualType();
7897 }
7898 }
7899
7900 result = SemaRef.Context.getAttributedType(attrKind: TL.getAttrKind(),
7901 modifiedType,
7902 equivalentType,
7903 attr: TL.getAttr());
7904 }
7905
7906 AttributedTypeLoc newTL = TLB.push<AttributedTypeLoc>(T: result);
7907 newTL.setAttr(newAttr);
7908 return result;
7909}
7910
7911template <typename Derived>
7912QualType TreeTransform<Derived>::TransformCountAttributedType(
7913 TypeLocBuilder &TLB, CountAttributedTypeLoc TL) {
7914 const CountAttributedType *OldTy = TL.getTypePtr();
7915 QualType InnerTy = getDerived().TransformType(TLB, TL.getInnerLoc());
7916 if (InnerTy.isNull())
7917 return QualType();
7918
7919 Expr *OldCount = TL.getCountExpr();
7920 Expr *NewCount = nullptr;
7921 if (OldCount) {
7922 ExprResult CountResult = getDerived().TransformExpr(OldCount);
7923 if (CountResult.isInvalid())
7924 return QualType();
7925 NewCount = CountResult.get();
7926 }
7927
7928 QualType Result = TL.getType();
7929 if (getDerived().AlwaysRebuild() || InnerTy != OldTy->desugar() ||
7930 OldCount != NewCount) {
7931 // Currently, CountAttributedType can only wrap incomplete array types.
7932 Result = SemaRef.BuildCountAttributedArrayOrPointerType(
7933 WrappedTy: InnerTy, CountExpr: NewCount, CountInBytes: OldTy->isCountInBytes(), OrNull: OldTy->isOrNull());
7934 }
7935
7936 TLB.push<CountAttributedTypeLoc>(T: Result);
7937 return Result;
7938}
7939
7940template <typename Derived>
7941QualType
7942TreeTransform<Derived>::TransformLateParsedAttrType(TypeLocBuilder &TLB,
7943 LateParsedAttrTypeLoc TL) {
7944 const LateParsedAttrType *OldTy = TL.getTypePtr();
7945 QualType InnerTy = getDerived().TransformType(TLB, TL.getInnerLoc());
7946 if (InnerTy.isNull())
7947 return QualType();
7948
7949 QualType Result = TL.getType();
7950 if (getDerived().AlwaysRebuild() || InnerTy != OldTy->getWrappedType()) {
7951 Result = SemaRef.Context.getLateParsedAttrType(
7952 Wrapped: InnerTy, LateParsedAttr: OldTy->getLateParsedAttribute());
7953 }
7954
7955 LateParsedAttrTypeLoc newTL = TLB.push<LateParsedAttrTypeLoc>(T: Result);
7956 newTL.setAttrNameLoc(TL.getAttrNameLoc());
7957 return Result;
7958}
7959
7960template <typename Derived>
7961QualType TreeTransform<Derived>::TransformBTFTagAttributedType(
7962 TypeLocBuilder &TLB, BTFTagAttributedTypeLoc TL) {
7963 // The BTFTagAttributedType is available for C only.
7964 llvm_unreachable("Unexpected TreeTransform for BTFTagAttributedType");
7965}
7966
7967template <typename Derived>
7968QualType TreeTransform<Derived>::TransformOverflowBehaviorType(
7969 TypeLocBuilder &TLB, OverflowBehaviorTypeLoc TL) {
7970 const OverflowBehaviorType *OldTy = TL.getTypePtr();
7971 QualType InnerTy = getDerived().TransformType(TLB, TL.getWrappedLoc());
7972 if (InnerTy.isNull())
7973 return QualType();
7974
7975 QualType Result = TL.getType();
7976 if (getDerived().AlwaysRebuild() || InnerTy != OldTy->getUnderlyingType()) {
7977 Result = SemaRef.Context.getOverflowBehaviorType(Kind: OldTy->getBehaviorKind(),
7978 Wrapped: InnerTy);
7979 if (Result.isNull())
7980 return QualType();
7981 }
7982
7983 OverflowBehaviorTypeLoc NewTL = TLB.push<OverflowBehaviorTypeLoc>(T: Result);
7984 NewTL.initializeLocal(Context&: SemaRef.Context, loc: TL.getAttrLoc());
7985 return Result;
7986}
7987
7988template <typename Derived>
7989QualType TreeTransform<Derived>::TransformHLSLAttributedResourceType(
7990 TypeLocBuilder &TLB, HLSLAttributedResourceTypeLoc TL) {
7991
7992 const HLSLAttributedResourceType *oldType = TL.getTypePtr();
7993
7994 QualType WrappedTy = getDerived().TransformType(TLB, TL.getWrappedLoc());
7995 if (WrappedTy.isNull())
7996 return QualType();
7997
7998 QualType ContainedTy = QualType();
7999 QualType OldContainedTy = oldType->getContainedType();
8000 TypeSourceInfo *ContainedTSI = nullptr;
8001 if (!OldContainedTy.isNull()) {
8002 TypeSourceInfo *oldContainedTSI = TL.getContainedTypeSourceInfo();
8003 if (!oldContainedTSI)
8004 oldContainedTSI = getSema().getASTContext().getTrivialTypeSourceInfo(
8005 OldContainedTy, SourceLocation());
8006 ContainedTSI = getDerived().TransformType(oldContainedTSI);
8007 if (!ContainedTSI)
8008 return QualType();
8009 ContainedTy = ContainedTSI->getType();
8010 }
8011
8012 HLSLAttributedResourceType::Attributes Attrs = oldType->getAttrs();
8013 if (Attrs.SampleCountExpr) {
8014 ExprResult SampleCountResult =
8015 getDerived().TransformExpr(Attrs.SampleCountExpr);
8016 if (SampleCountResult.isInvalid())
8017 return QualType();
8018 Attrs.SampleCountExpr = SampleCountResult.get();
8019 }
8020
8021 QualType Result = TL.getType();
8022 if (getDerived().AlwaysRebuild() || WrappedTy != oldType->getWrappedType() ||
8023 ContainedTy != oldType->getContainedType() ||
8024 Attrs.SampleCountExpr != oldType->getSampleCountExpr()) {
8025 Result = SemaRef.Context.getHLSLAttributedResourceType(Wrapped: WrappedTy,
8026 Contained: ContainedTy, Attrs);
8027 }
8028
8029 HLSLAttributedResourceTypeLoc NewTL =
8030 TLB.push<HLSLAttributedResourceTypeLoc>(T: Result);
8031 NewTL.setSourceRange(TL.getLocalSourceRange());
8032 NewTL.setContainedTypeSourceInfo(ContainedTSI);
8033 return Result;
8034}
8035
8036template <typename Derived>
8037QualType TreeTransform<Derived>::TransformHLSLInlineSpirvType(
8038 TypeLocBuilder &TLB, HLSLInlineSpirvTypeLoc TL) {
8039 // No transformations needed.
8040 return TL.getType();
8041}
8042
8043template<typename Derived>
8044QualType
8045TreeTransform<Derived>::TransformParenType(TypeLocBuilder &TLB,
8046 ParenTypeLoc TL) {
8047 QualType Inner = getDerived().TransformType(TLB, TL.getInnerLoc());
8048 if (Inner.isNull())
8049 return QualType();
8050
8051 QualType Result = TL.getType();
8052 if (getDerived().AlwaysRebuild() ||
8053 Inner != TL.getInnerLoc().getType()) {
8054 Result = getDerived().RebuildParenType(Inner);
8055 if (Result.isNull())
8056 return QualType();
8057 }
8058
8059 ParenTypeLoc NewTL = TLB.push<ParenTypeLoc>(T: Result);
8060 NewTL.setLParenLoc(TL.getLParenLoc());
8061 NewTL.setRParenLoc(TL.getRParenLoc());
8062 return Result;
8063}
8064
8065template <typename Derived>
8066QualType
8067TreeTransform<Derived>::TransformMacroQualifiedType(TypeLocBuilder &TLB,
8068 MacroQualifiedTypeLoc TL) {
8069 QualType Inner = getDerived().TransformType(TLB, TL.getInnerLoc());
8070 if (Inner.isNull())
8071 return QualType();
8072
8073 QualType Result = TL.getType();
8074 if (getDerived().AlwaysRebuild() || Inner != TL.getInnerLoc().getType()) {
8075 Result =
8076 getDerived().RebuildMacroQualifiedType(Inner, TL.getMacroIdentifier());
8077 if (Result.isNull())
8078 return QualType();
8079 }
8080
8081 MacroQualifiedTypeLoc NewTL = TLB.push<MacroQualifiedTypeLoc>(T: Result);
8082 NewTL.setExpansionLoc(TL.getExpansionLoc());
8083 return Result;
8084}
8085
8086template<typename Derived>
8087QualType TreeTransform<Derived>::TransformDependentNameType(
8088 TypeLocBuilder &TLB, DependentNameTypeLoc TL) {
8089 return TransformDependentNameType(TLB, TL, false);
8090}
8091
8092template <typename Derived>
8093QualType TreeTransform<Derived>::TransformDependentNameType(
8094 TypeLocBuilder &TLB, DependentNameTypeLoc TL, bool DeducedTSTContext,
8095 QualType ObjectType, NamedDecl *UnqualLookup) {
8096 const DependentNameType *T = TL.getTypePtr();
8097
8098 NestedNameSpecifierLoc QualifierLoc = TL.getQualifierLoc();
8099 if (QualifierLoc) {
8100 QualifierLoc = getDerived().TransformNestedNameSpecifierLoc(
8101 QualifierLoc, ObjectType, UnqualLookup);
8102 if (!QualifierLoc)
8103 return QualType();
8104 } else {
8105 assert((ObjectType.isNull() && !UnqualLookup) &&
8106 "must be transformed by TransformNestedNameSpecifierLoc");
8107 }
8108
8109 QualType Result
8110 = getDerived().RebuildDependentNameType(T->getKeyword(),
8111 TL.getElaboratedKeywordLoc(),
8112 QualifierLoc,
8113 T->getIdentifier(),
8114 TL.getNameLoc(),
8115 DeducedTSTContext);
8116 if (Result.isNull())
8117 return QualType();
8118
8119 if (isa<TagType>(Val: Result)) {
8120 auto NewTL = TLB.push<TagTypeLoc>(T: Result);
8121 NewTL.setElaboratedKeywordLoc(TL.getElaboratedKeywordLoc());
8122 NewTL.setQualifierLoc(QualifierLoc);
8123 NewTL.setNameLoc(TL.getNameLoc());
8124 } else if (isa<DeducedTemplateSpecializationType>(Val: Result)) {
8125 auto NewTL = TLB.push<DeducedTemplateSpecializationTypeLoc>(T: Result);
8126 NewTL.setElaboratedKeywordLoc(TL.getElaboratedKeywordLoc());
8127 NewTL.setTemplateNameLoc(TL.getNameLoc());
8128 NewTL.setQualifierLoc(QualifierLoc);
8129 } else if (isa<TypedefType>(Val: Result)) {
8130 TLB.push<TypedefTypeLoc>(T: Result).set(ElaboratedKeywordLoc: TL.getElaboratedKeywordLoc(),
8131 QualifierLoc, NameLoc: TL.getNameLoc());
8132 } else if (isa<UnresolvedUsingType>(Val: Result)) {
8133 auto NewTL = TLB.push<UnresolvedUsingTypeLoc>(T: Result);
8134 NewTL.set(ElaboratedKeywordLoc: TL.getElaboratedKeywordLoc(), QualifierLoc, NameLoc: TL.getNameLoc());
8135 } else {
8136 auto NewTL = TLB.push<DependentNameTypeLoc>(T: Result);
8137 NewTL.setElaboratedKeywordLoc(TL.getElaboratedKeywordLoc());
8138 NewTL.setQualifierLoc(QualifierLoc);
8139 NewTL.setNameLoc(TL.getNameLoc());
8140 }
8141 return Result;
8142}
8143
8144template<typename Derived>
8145QualType TreeTransform<Derived>::TransformPackExpansionType(TypeLocBuilder &TLB,
8146 PackExpansionTypeLoc TL) {
8147 QualType Pattern
8148 = getDerived().TransformType(TLB, TL.getPatternLoc());
8149 if (Pattern.isNull())
8150 return QualType();
8151
8152 QualType Result = TL.getType();
8153 if (getDerived().AlwaysRebuild() ||
8154 Pattern != TL.getPatternLoc().getType()) {
8155 Result = getDerived().RebuildPackExpansionType(Pattern,
8156 TL.getPatternLoc().getSourceRange(),
8157 TL.getEllipsisLoc(),
8158 TL.getTypePtr()->getNumExpansions());
8159 if (Result.isNull())
8160 return QualType();
8161 }
8162
8163 PackExpansionTypeLoc NewT = TLB.push<PackExpansionTypeLoc>(T: Result);
8164 NewT.setEllipsisLoc(TL.getEllipsisLoc());
8165 return Result;
8166}
8167
8168template<typename Derived>
8169QualType
8170TreeTransform<Derived>::TransformObjCInterfaceType(TypeLocBuilder &TLB,
8171 ObjCInterfaceTypeLoc TL) {
8172 // ObjCInterfaceType is never dependent.
8173 TLB.pushFullCopy(L: TL);
8174 return TL.getType();
8175}
8176
8177template<typename Derived>
8178QualType
8179TreeTransform<Derived>::TransformObjCTypeParamType(TypeLocBuilder &TLB,
8180 ObjCTypeParamTypeLoc TL) {
8181 const ObjCTypeParamType *T = TL.getTypePtr();
8182 ObjCTypeParamDecl *OTP = cast_or_null<ObjCTypeParamDecl>(
8183 getDerived().TransformDecl(T->getDecl()->getLocation(), T->getDecl()));
8184 if (!OTP)
8185 return QualType();
8186
8187 QualType Result = TL.getType();
8188 if (getDerived().AlwaysRebuild() ||
8189 OTP != T->getDecl()) {
8190 Result = getDerived().RebuildObjCTypeParamType(
8191 OTP, TL.getProtocolLAngleLoc(),
8192 llvm::ArrayRef(TL.getTypePtr()->qual_begin(), TL.getNumProtocols()),
8193 TL.getProtocolLocs(), TL.getProtocolRAngleLoc());
8194 if (Result.isNull())
8195 return QualType();
8196 }
8197
8198 ObjCTypeParamTypeLoc NewTL = TLB.push<ObjCTypeParamTypeLoc>(T: Result);
8199 if (TL.getNumProtocols()) {
8200 NewTL.setProtocolLAngleLoc(TL.getProtocolLAngleLoc());
8201 for (unsigned i = 0, n = TL.getNumProtocols(); i != n; ++i)
8202 NewTL.setProtocolLoc(i, Loc: TL.getProtocolLoc(i));
8203 NewTL.setProtocolRAngleLoc(TL.getProtocolRAngleLoc());
8204 }
8205 return Result;
8206}
8207
8208template<typename Derived>
8209QualType
8210TreeTransform<Derived>::TransformObjCObjectType(TypeLocBuilder &TLB,
8211 ObjCObjectTypeLoc TL) {
8212 // Transform base type.
8213 QualType BaseType = getDerived().TransformType(TLB, TL.getBaseLoc());
8214 if (BaseType.isNull())
8215 return QualType();
8216
8217 bool AnyChanged = BaseType != TL.getBaseLoc().getType();
8218
8219 // Transform type arguments.
8220 SmallVector<TypeSourceInfo *, 4> NewTypeArgInfos;
8221 for (unsigned i = 0, n = TL.getNumTypeArgs(); i != n; ++i) {
8222 TypeSourceInfo *TypeArgInfo = TL.getTypeArgTInfo(i);
8223 TypeLoc TypeArgLoc = TypeArgInfo->getTypeLoc();
8224 QualType TypeArg = TypeArgInfo->getType();
8225 if (auto PackExpansionLoc = TypeArgLoc.getAs<PackExpansionTypeLoc>()) {
8226 AnyChanged = true;
8227
8228 // We have a pack expansion. Instantiate it.
8229 const auto *PackExpansion = PackExpansionLoc.getType()
8230 ->castAs<PackExpansionType>();
8231 SmallVector<UnexpandedParameterPack, 2> Unexpanded;
8232 SemaRef.collectUnexpandedParameterPacks(T: PackExpansion->getPattern(),
8233 Unexpanded);
8234 assert(!Unexpanded.empty() && "Pack expansion without parameter packs?");
8235
8236 // Determine whether the set of unexpanded parameter packs can
8237 // and should be expanded.
8238 TypeLoc PatternLoc = PackExpansionLoc.getPatternLoc();
8239 bool Expand = false;
8240 bool RetainExpansion = false;
8241 UnsignedOrNone NumExpansions = PackExpansion->getNumExpansions();
8242 if (getDerived().TryExpandParameterPacks(
8243 PackExpansionLoc.getEllipsisLoc(), PatternLoc.getSourceRange(),
8244 Unexpanded, /*FailOnPackProducingTemplates=*/true, Expand,
8245 RetainExpansion, NumExpansions))
8246 return QualType();
8247
8248 if (!Expand) {
8249 // We can't expand this pack expansion into separate arguments yet;
8250 // just substitute into the pattern and create a new pack expansion
8251 // type.
8252 Sema::ArgPackSubstIndexRAII SubstIndex(getSema(), std::nullopt);
8253
8254 TypeLocBuilder TypeArgBuilder;
8255 TypeArgBuilder.reserve(Requested: PatternLoc.getFullDataSize());
8256 QualType NewPatternType = getDerived().TransformType(TypeArgBuilder,
8257 PatternLoc);
8258 if (NewPatternType.isNull())
8259 return QualType();
8260
8261 QualType NewExpansionType = SemaRef.Context.getPackExpansionType(
8262 Pattern: NewPatternType, NumExpansions);
8263 auto NewExpansionLoc = TLB.push<PackExpansionTypeLoc>(T: NewExpansionType);
8264 NewExpansionLoc.setEllipsisLoc(PackExpansionLoc.getEllipsisLoc());
8265 NewTypeArgInfos.push_back(
8266 Elt: TypeArgBuilder.getTypeSourceInfo(Context&: SemaRef.Context, T: NewExpansionType));
8267 continue;
8268 }
8269
8270 // Substitute into the pack expansion pattern for each slice of the
8271 // pack.
8272 for (unsigned ArgIdx = 0; ArgIdx != *NumExpansions; ++ArgIdx) {
8273 Sema::ArgPackSubstIndexRAII SubstIndex(getSema(), ArgIdx);
8274
8275 TypeLocBuilder TypeArgBuilder;
8276 TypeArgBuilder.reserve(Requested: PatternLoc.getFullDataSize());
8277
8278 QualType NewTypeArg = getDerived().TransformType(TypeArgBuilder,
8279 PatternLoc);
8280 if (NewTypeArg.isNull())
8281 return QualType();
8282
8283 NewTypeArgInfos.push_back(
8284 Elt: TypeArgBuilder.getTypeSourceInfo(Context&: SemaRef.Context, T: NewTypeArg));
8285 }
8286
8287 continue;
8288 }
8289
8290 TypeLocBuilder TypeArgBuilder;
8291 TypeArgBuilder.reserve(Requested: TypeArgLoc.getFullDataSize());
8292 QualType NewTypeArg =
8293 getDerived().TransformType(TypeArgBuilder, TypeArgLoc);
8294 if (NewTypeArg.isNull())
8295 return QualType();
8296
8297 // If nothing changed, just keep the old TypeSourceInfo.
8298 if (NewTypeArg == TypeArg) {
8299 NewTypeArgInfos.push_back(Elt: TypeArgInfo);
8300 continue;
8301 }
8302
8303 NewTypeArgInfos.push_back(
8304 Elt: TypeArgBuilder.getTypeSourceInfo(Context&: SemaRef.Context, T: NewTypeArg));
8305 AnyChanged = true;
8306 }
8307
8308 QualType Result = TL.getType();
8309 if (getDerived().AlwaysRebuild() || AnyChanged) {
8310 // Rebuild the type.
8311 Result = getDerived().RebuildObjCObjectType(
8312 BaseType, TL.getBeginLoc(), TL.getTypeArgsLAngleLoc(), NewTypeArgInfos,
8313 TL.getTypeArgsRAngleLoc(), TL.getProtocolLAngleLoc(),
8314 llvm::ArrayRef(TL.getTypePtr()->qual_begin(), TL.getNumProtocols()),
8315 TL.getProtocolLocs(), TL.getProtocolRAngleLoc());
8316
8317 if (Result.isNull())
8318 return QualType();
8319 }
8320
8321 ObjCObjectTypeLoc NewT = TLB.push<ObjCObjectTypeLoc>(T: Result);
8322 NewT.setHasBaseTypeAsWritten(true);
8323 NewT.setTypeArgsLAngleLoc(TL.getTypeArgsLAngleLoc());
8324 for (unsigned i = 0, n = TL.getNumTypeArgs(); i != n; ++i)
8325 NewT.setTypeArgTInfo(i, TInfo: NewTypeArgInfos[i]);
8326 NewT.setTypeArgsRAngleLoc(TL.getTypeArgsRAngleLoc());
8327 NewT.setProtocolLAngleLoc(TL.getProtocolLAngleLoc());
8328 for (unsigned i = 0, n = TL.getNumProtocols(); i != n; ++i)
8329 NewT.setProtocolLoc(i, Loc: TL.getProtocolLoc(i));
8330 NewT.setProtocolRAngleLoc(TL.getProtocolRAngleLoc());
8331 return Result;
8332}
8333
8334template<typename Derived>
8335QualType
8336TreeTransform<Derived>::TransformObjCObjectPointerType(TypeLocBuilder &TLB,
8337 ObjCObjectPointerTypeLoc TL) {
8338 QualType PointeeType = getDerived().TransformType(TLB, TL.getPointeeLoc());
8339 if (PointeeType.isNull())
8340 return QualType();
8341
8342 QualType Result = TL.getType();
8343 if (getDerived().AlwaysRebuild() ||
8344 PointeeType != TL.getPointeeLoc().getType()) {
8345 Result = getDerived().RebuildObjCObjectPointerType(PointeeType,
8346 TL.getStarLoc());
8347 if (Result.isNull())
8348 return QualType();
8349 }
8350
8351 ObjCObjectPointerTypeLoc NewT = TLB.push<ObjCObjectPointerTypeLoc>(T: Result);
8352 NewT.setStarLoc(TL.getStarLoc());
8353 return Result;
8354}
8355
8356//===----------------------------------------------------------------------===//
8357// Statement transformation
8358//===----------------------------------------------------------------------===//
8359template<typename Derived>
8360StmtResult
8361TreeTransform<Derived>::TransformNullStmt(NullStmt *S) {
8362 return S;
8363}
8364
8365template<typename Derived>
8366StmtResult
8367TreeTransform<Derived>::TransformCompoundStmt(CompoundStmt *S) {
8368 return getDerived().TransformCompoundStmt(S, false);
8369}
8370
8371template<typename Derived>
8372StmtResult
8373TreeTransform<Derived>::TransformCompoundStmt(CompoundStmt *S,
8374 bool IsStmtExpr) {
8375 Sema::CompoundScopeRAII CompoundScope(getSema());
8376 Sema::FPFeaturesStateRAII FPSave(getSema());
8377 if (S->hasStoredFPFeatures())
8378 getSema().resetFPOptions(
8379 S->getStoredFPFeatures().applyOverrides(getSema().getLangOpts()));
8380
8381 bool SubStmtInvalid = false;
8382 bool SubStmtChanged = false;
8383 SmallVector<Stmt*, 8> Statements;
8384 for (auto *B : S->body()) {
8385 StmtResult Result = getDerived().TransformStmt(
8386 B, IsStmtExpr && B == S->body_back() ? StmtDiscardKind::StmtExprResult
8387 : StmtDiscardKind::Discarded);
8388
8389 if (Result.isInvalid()) {
8390 // Immediately fail if this was a DeclStmt, since it's very
8391 // likely that this will cause problems for future statements.
8392 if (isa<DeclStmt>(Val: B))
8393 return StmtError();
8394
8395 // Otherwise, just keep processing substatements and fail later.
8396 SubStmtInvalid = true;
8397 continue;
8398 }
8399
8400 SubStmtChanged = SubStmtChanged || Result.get() != B;
8401 Statements.push_back(Elt: Result.getAs<Stmt>());
8402 }
8403
8404 if (SubStmtInvalid)
8405 return StmtError();
8406
8407 if (!getDerived().AlwaysRebuild() &&
8408 !SubStmtChanged)
8409 return S;
8410
8411 return getDerived().RebuildCompoundStmt(S->getLBracLoc(),
8412 Statements,
8413 S->getRBracLoc(),
8414 IsStmtExpr);
8415}
8416
8417template<typename Derived>
8418StmtResult
8419TreeTransform<Derived>::TransformCaseStmt(CaseStmt *S) {
8420 ExprResult LHS, RHS;
8421 {
8422 EnterExpressionEvaluationContext Unevaluated(
8423 SemaRef, Sema::ExpressionEvaluationContext::ConstantEvaluated);
8424
8425 // Transform the left-hand case value.
8426 LHS = getDerived().TransformExpr(S->getLHS());
8427 LHS = SemaRef.ActOnCaseExpr(CaseLoc: S->getCaseLoc(), Val: LHS);
8428 if (LHS.isInvalid())
8429 return StmtError();
8430
8431 // Transform the right-hand case value (for the GNU case-range extension).
8432 RHS = getDerived().TransformExpr(S->getRHS());
8433 RHS = SemaRef.ActOnCaseExpr(CaseLoc: S->getCaseLoc(), Val: RHS);
8434 if (RHS.isInvalid())
8435 return StmtError();
8436 }
8437
8438 // Build the case statement.
8439 // Case statements are always rebuilt so that they will attached to their
8440 // transformed switch statement.
8441 StmtResult Case = getDerived().RebuildCaseStmt(S->getCaseLoc(),
8442 LHS.get(),
8443 S->getEllipsisLoc(),
8444 RHS.get(),
8445 S->getColonLoc());
8446 if (Case.isInvalid())
8447 return StmtError();
8448
8449 // Transform the statement following the case
8450 StmtResult SubStmt =
8451 getDerived().TransformStmt(S->getSubStmt());
8452 if (SubStmt.isInvalid())
8453 return StmtError();
8454
8455 // Attach the body to the case statement
8456 return getDerived().RebuildCaseStmtBody(Case.get(), SubStmt.get());
8457}
8458
8459template <typename Derived>
8460StmtResult TreeTransform<Derived>::TransformDefaultStmt(DefaultStmt *S) {
8461 // Transform the statement following the default case
8462 StmtResult SubStmt =
8463 getDerived().TransformStmt(S->getSubStmt());
8464 if (SubStmt.isInvalid())
8465 return StmtError();
8466
8467 // Default statements are always rebuilt
8468 return getDerived().RebuildDefaultStmt(S->getDefaultLoc(), S->getColonLoc(),
8469 SubStmt.get());
8470}
8471
8472template<typename Derived>
8473StmtResult
8474TreeTransform<Derived>::TransformLabelStmt(LabelStmt *S, StmtDiscardKind SDK) {
8475 StmtResult SubStmt = getDerived().TransformStmt(S->getSubStmt(), SDK);
8476 if (SubStmt.isInvalid())
8477 return StmtError();
8478
8479 Decl *LD = getDerived().TransformDecl(S->getDecl()->getLocation(),
8480 S->getDecl());
8481 if (!LD)
8482 return StmtError();
8483
8484 // If we're transforming "in-place" (we're not creating new local
8485 // declarations), assume we're replacing the old label statement
8486 // and clear out the reference to it.
8487 if (LD == S->getDecl())
8488 S->getDecl()->setStmt(nullptr);
8489
8490 // FIXME: Pass the real colon location in.
8491 return getDerived().RebuildLabelStmt(S->getIdentLoc(),
8492 cast<LabelDecl>(Val: LD), SourceLocation(),
8493 SubStmt.get());
8494}
8495
8496template <typename Derived>
8497const Attr *TreeTransform<Derived>::TransformAttr(const Attr *R) {
8498 if (!R)
8499 return R;
8500
8501 switch (R->getKind()) {
8502// Transform attributes by calling TransformXXXAttr.
8503#define ATTR(X) \
8504 case attr::X: \
8505 return getDerived().Transform##X##Attr(cast<X##Attr>(R));
8506#include "clang/Basic/AttrList.inc"
8507 }
8508 return R;
8509}
8510
8511template <typename Derived>
8512const Attr *TreeTransform<Derived>::TransformStmtAttr(const Stmt *OrigS,
8513 const Stmt *InstS,
8514 const Attr *R) {
8515 if (!R)
8516 return R;
8517
8518 switch (R->getKind()) {
8519// Transform attributes by calling TransformStmtXXXAttr.
8520#define ATTR(X) \
8521 case attr::X: \
8522 return getDerived().TransformStmt##X##Attr(OrigS, InstS, cast<X##Attr>(R));
8523#include "clang/Basic/AttrList.inc"
8524 }
8525 return TransformAttr(R);
8526}
8527
8528template <typename Derived>
8529StmtResult
8530TreeTransform<Derived>::TransformAttributedStmt(AttributedStmt *S,
8531 StmtDiscardKind SDK) {
8532 StmtResult SubStmt = getDerived().TransformStmt(S->getSubStmt(), SDK);
8533 if (SubStmt.isInvalid())
8534 return StmtError();
8535
8536 bool AttrsChanged = false;
8537 SmallVector<const Attr *, 1> Attrs;
8538
8539 // Visit attributes and keep track if any are transformed.
8540 for (const auto *I : S->getAttrs()) {
8541 const Attr *R =
8542 getDerived().TransformStmtAttr(S->getSubStmt(), SubStmt.get(), I);
8543 AttrsChanged |= (I != R);
8544 if (R)
8545 Attrs.push_back(Elt: R);
8546 }
8547
8548 if (SubStmt.get() == S->getSubStmt() && !AttrsChanged)
8549 return S;
8550
8551 // If transforming the attributes failed for all of the attributes in the
8552 // statement, don't make an AttributedStmt without attributes.
8553 if (Attrs.empty())
8554 return SubStmt;
8555
8556 return getDerived().RebuildAttributedStmt(S->getAttrLoc(), Attrs,
8557 SubStmt.get());
8558}
8559
8560template<typename Derived>
8561StmtResult
8562TreeTransform<Derived>::TransformIfStmt(IfStmt *S) {
8563 // Transform the initialization statement
8564 StmtResult Init = getDerived().TransformStmt(S->getInit());
8565 if (Init.isInvalid())
8566 return StmtError();
8567
8568 Sema::ConditionResult Cond;
8569 if (!S->isConsteval()) {
8570 // Transform the condition
8571 Cond = getDerived().TransformCondition(
8572 S->getIfLoc(), S->getConditionVariable(), S->getCond(),
8573 S->isConstexpr() ? Sema::ConditionKind::ConstexprIf
8574 : Sema::ConditionKind::Boolean);
8575 if (Cond.isInvalid())
8576 return StmtError();
8577 }
8578
8579 // If this is a constexpr if, determine which arm we should instantiate.
8580 std::optional<bool> ConstexprConditionValue;
8581 if (S->isConstexpr())
8582 ConstexprConditionValue = Cond.getKnownValue();
8583
8584 // Transform the "then" branch.
8585 StmtResult Then;
8586 if (!ConstexprConditionValue || *ConstexprConditionValue) {
8587 EnterExpressionEvaluationContext Ctx(
8588 getSema(), Sema::ExpressionEvaluationContext::ImmediateFunctionContext,
8589 nullptr, Sema::ExpressionEvaluationContextRecord::EK_Other,
8590 S->isNonNegatedConsteval());
8591
8592 Then = getDerived().TransformStmt(S->getThen());
8593 if (Then.isInvalid())
8594 return StmtError();
8595 } else {
8596 // Discarded branch is replaced with empty CompoundStmt so we can keep
8597 // proper source location for start and end of original branch, so
8598 // subsequent transformations like CoverageMapping work properly
8599 Then = new (getSema().Context)
8600 CompoundStmt(S->getThen()->getBeginLoc(), S->getThen()->getEndLoc());
8601 }
8602
8603 // Transform the "else" branch.
8604 StmtResult Else;
8605 if (!ConstexprConditionValue || !*ConstexprConditionValue) {
8606 EnterExpressionEvaluationContext Ctx(
8607 getSema(), Sema::ExpressionEvaluationContext::ImmediateFunctionContext,
8608 nullptr, Sema::ExpressionEvaluationContextRecord::EK_Other,
8609 S->isNegatedConsteval());
8610
8611 Else = getDerived().TransformStmt(S->getElse());
8612 if (Else.isInvalid())
8613 return StmtError();
8614 } else if (S->getElse() && ConstexprConditionValue &&
8615 *ConstexprConditionValue) {
8616 // Same thing here as with <then> branch, we are discarding it, we can't
8617 // replace it with NULL nor NullStmt as we need to keep for source location
8618 // range, for CoverageMapping
8619 Else = new (getSema().Context)
8620 CompoundStmt(S->getElse()->getBeginLoc(), S->getElse()->getEndLoc());
8621 }
8622
8623 if (!getDerived().AlwaysRebuild() &&
8624 Init.get() == S->getInit() &&
8625 Cond.get() == std::make_pair(x: S->getConditionVariable(), y: S->getCond()) &&
8626 Then.get() == S->getThen() &&
8627 Else.get() == S->getElse())
8628 return S;
8629
8630 return getDerived().RebuildIfStmt(
8631 S->getIfLoc(), S->getStatementKind(), S->getLParenLoc(), Cond,
8632 S->getRParenLoc(), Init.get(), Then.get(), S->getElseLoc(), Else.get());
8633}
8634
8635template<typename Derived>
8636StmtResult
8637TreeTransform<Derived>::TransformSwitchStmt(SwitchStmt *S) {
8638 // Transform the initialization statement
8639 StmtResult Init = getDerived().TransformStmt(S->getInit());
8640 if (Init.isInvalid())
8641 return StmtError();
8642
8643 // Transform the condition.
8644 Sema::ConditionResult Cond = getDerived().TransformCondition(
8645 S->getSwitchLoc(), S->getConditionVariable(), S->getCond(),
8646 Sema::ConditionKind::Switch);
8647 if (Cond.isInvalid())
8648 return StmtError();
8649
8650 // Rebuild the switch statement.
8651 StmtResult Switch =
8652 getDerived().RebuildSwitchStmtStart(S->getSwitchLoc(), S->getLParenLoc(),
8653 Init.get(), Cond, S->getRParenLoc());
8654 if (Switch.isInvalid())
8655 return StmtError();
8656
8657 // Transform the body of the switch statement.
8658 StmtResult Body = getDerived().TransformStmt(S->getBody());
8659
8660 // Complete the switch statement.
8661 return getDerived().RebuildSwitchStmtBody(S->getSwitchLoc(), Switch.get(),
8662 Body.get());
8663}
8664
8665template<typename Derived>
8666StmtResult
8667TreeTransform<Derived>::TransformWhileStmt(WhileStmt *S) {
8668 // Transform the condition
8669 Sema::ConditionResult Cond = getDerived().TransformCondition(
8670 S->getWhileLoc(), S->getConditionVariable(), S->getCond(),
8671 Sema::ConditionKind::Boolean);
8672 if (Cond.isInvalid())
8673 return StmtError();
8674
8675 // OpenACC Restricts a while-loop inside of certain construct/clause
8676 // combinations, so diagnose that here in OpenACC mode.
8677 SemaOpenACC::LoopInConstructRAII LCR{SemaRef.OpenACC()};
8678 SemaRef.OpenACC().ActOnWhileStmt(WhileLoc: S->getBeginLoc());
8679
8680 // Transform the body
8681 StmtResult Body = getDerived().TransformStmt(S->getBody());
8682 if (Body.isInvalid())
8683 return StmtError();
8684
8685 if (!getDerived().AlwaysRebuild() &&
8686 Cond.get() == std::make_pair(x: S->getConditionVariable(), y: S->getCond()) &&
8687 Body.get() == S->getBody())
8688 return Owned(S);
8689
8690 return getDerived().RebuildWhileStmt(S->getWhileLoc(), S->getLParenLoc(),
8691 Cond, S->getRParenLoc(), Body.get());
8692}
8693
8694template<typename Derived>
8695StmtResult
8696TreeTransform<Derived>::TransformDoStmt(DoStmt *S) {
8697 // OpenACC Restricts a do-loop inside of certain construct/clause
8698 // combinations, so diagnose that here in OpenACC mode.
8699 SemaOpenACC::LoopInConstructRAII LCR{SemaRef.OpenACC()};
8700 SemaRef.OpenACC().ActOnDoStmt(DoLoc: S->getBeginLoc());
8701
8702 // Transform the body
8703 StmtResult Body = getDerived().TransformStmt(S->getBody());
8704 if (Body.isInvalid())
8705 return StmtError();
8706
8707 // Transform the condition
8708 ExprResult Cond = getDerived().TransformExpr(S->getCond());
8709 if (Cond.isInvalid())
8710 return StmtError();
8711
8712 if (!getDerived().AlwaysRebuild() &&
8713 Cond.get() == S->getCond() &&
8714 Body.get() == S->getBody())
8715 return S;
8716
8717 return getDerived().RebuildDoStmt(S->getDoLoc(), Body.get(), S->getWhileLoc(),
8718 /*FIXME:*/S->getWhileLoc(), Cond.get(),
8719 S->getRParenLoc());
8720}
8721
8722template<typename Derived>
8723StmtResult
8724TreeTransform<Derived>::TransformForStmt(ForStmt *S) {
8725 if (getSema().getLangOpts().getOpenMPVersion())
8726 getSema().OpenMP().startOpenMPLoop();
8727
8728 // Transform the initialization statement
8729 StmtResult Init = getDerived().TransformStmt(S->getInit());
8730 if (Init.isInvalid())
8731 return StmtError();
8732
8733 // In OpenMP loop region loop control variable must be captured and be
8734 // private. Perform analysis of first part (if any).
8735 if (getSema().getLangOpts().getOpenMPVersion() && Init.isUsable())
8736 getSema().OpenMP().ActOnOpenMPLoopInitialization(S->getForLoc(),
8737 Init.get());
8738
8739 // Transform the condition
8740 Sema::ConditionResult Cond = getDerived().TransformCondition(
8741 S->getForLoc(), S->getConditionVariable(), S->getCond(),
8742 Sema::ConditionKind::Boolean);
8743 if (Cond.isInvalid())
8744 return StmtError();
8745
8746 // Transform the increment
8747 ExprResult Inc = getDerived().TransformExpr(S->getInc());
8748 if (Inc.isInvalid())
8749 return StmtError();
8750
8751 Sema::FullExprArg FullInc(getSema().MakeFullDiscardedValueExpr(Inc.get()));
8752 if (S->getInc() && !FullInc.get())
8753 return StmtError();
8754
8755 // OpenACC Restricts a for-loop inside of certain construct/clause
8756 // combinations, so diagnose that here in OpenACC mode.
8757 SemaOpenACC::LoopInConstructRAII LCR{SemaRef.OpenACC()};
8758 SemaRef.OpenACC().ActOnForStmtBegin(
8759 ForLoc: S->getBeginLoc(), OldFirst: S->getInit(), First: Init.get(), OldSecond: S->getCond(),
8760 Second: Cond.get().second, OldThird: S->getInc(), Third: Inc.get());
8761
8762 // Transform the body
8763 StmtResult Body = getDerived().TransformStmt(S->getBody());
8764 if (Body.isInvalid())
8765 return StmtError();
8766
8767 SemaRef.OpenACC().ActOnForStmtEnd(ForLoc: S->getBeginLoc(), Body);
8768
8769 if (!getDerived().AlwaysRebuild() &&
8770 Init.get() == S->getInit() &&
8771 Cond.get() == std::make_pair(x: S->getConditionVariable(), y: S->getCond()) &&
8772 Inc.get() == S->getInc() &&
8773 Body.get() == S->getBody())
8774 return S;
8775
8776 return getDerived().RebuildForStmt(S->getForLoc(), S->getLParenLoc(),
8777 Init.get(), Cond, FullInc,
8778 S->getRParenLoc(), Body.get());
8779}
8780
8781template<typename Derived>
8782StmtResult
8783TreeTransform<Derived>::TransformGotoStmt(GotoStmt *S) {
8784 Decl *LD = getDerived().TransformDecl(S->getLabel()->getLocation(),
8785 S->getLabel());
8786 if (!LD)
8787 return StmtError();
8788
8789 // Goto statements must always be rebuilt, to resolve the label.
8790 return getDerived().RebuildGotoStmt(S->getGotoLoc(), S->getLabelLoc(),
8791 cast<LabelDecl>(Val: LD));
8792}
8793
8794template<typename Derived>
8795StmtResult
8796TreeTransform<Derived>::TransformIndirectGotoStmt(IndirectGotoStmt *S) {
8797 ExprResult Target = getDerived().TransformExpr(S->getTarget());
8798 if (Target.isInvalid())
8799 return StmtError();
8800 Target = SemaRef.MaybeCreateExprWithCleanups(SubExpr: Target.get());
8801
8802 if (!getDerived().AlwaysRebuild() &&
8803 Target.get() == S->getTarget())
8804 return S;
8805
8806 return getDerived().RebuildIndirectGotoStmt(S->getGotoLoc(), S->getStarLoc(),
8807 Target.get());
8808}
8809
8810template<typename Derived>
8811StmtResult
8812TreeTransform<Derived>::TransformContinueStmt(ContinueStmt *S) {
8813 if (!S->isNamed())
8814 return S;
8815
8816 Decl *LD = getDerived().TransformDecl(S->getLabelDecl()->getLocation(),
8817 S->getLabelDecl());
8818 if (!LD)
8819 return StmtError();
8820
8821 return new (SemaRef.Context)
8822 ContinueStmt(S->getKwLoc(), S->getLabelLoc(), cast<LabelDecl>(Val: LD));
8823}
8824
8825template<typename Derived>
8826StmtResult
8827TreeTransform<Derived>::TransformBreakStmt(BreakStmt *S) {
8828 if (!S->isNamed())
8829 return S;
8830
8831 Decl *LD = getDerived().TransformDecl(S->getLabelDecl()->getLocation(),
8832 S->getLabelDecl());
8833 if (!LD)
8834 return StmtError();
8835
8836 return new (SemaRef.Context)
8837 BreakStmt(S->getKwLoc(), S->getLabelLoc(), cast<LabelDecl>(Val: LD));
8838}
8839
8840template <typename Derived>
8841StmtResult TreeTransform<Derived>::TransformDeferStmt(DeferStmt *S) {
8842 StmtResult Result = getDerived().TransformStmt(S->getBody());
8843 if (!Result.isUsable())
8844 return StmtError();
8845 return DeferStmt::Create(Context&: getSema().Context, DeferLoc: S->getDeferLoc(), Body: Result.get());
8846}
8847
8848template<typename Derived>
8849StmtResult
8850TreeTransform<Derived>::TransformReturnStmt(ReturnStmt *S) {
8851 ExprResult Result = getDerived().TransformInitializer(S->getRetValue(),
8852 /*NotCopyInit*/false);
8853 if (Result.isInvalid())
8854 return StmtError();
8855
8856 // FIXME: We always rebuild the return statement because there is no way
8857 // to tell whether the return type of the function has changed.
8858 return getDerived().RebuildReturnStmt(S->getReturnLoc(), Result.get());
8859}
8860
8861template<typename Derived>
8862StmtResult
8863TreeTransform<Derived>::TransformDeclStmt(DeclStmt *S) {
8864 bool DeclChanged = false;
8865 SmallVector<Decl *, 4> Decls;
8866 LambdaScopeInfo *LSI = getSema().getCurLambda();
8867 for (auto *D : S->decls()) {
8868 Decl *Transformed = getDerived().TransformDefinition(D->getLocation(), D);
8869 if (!Transformed)
8870 return StmtError();
8871
8872 if (Transformed != D)
8873 DeclChanged = true;
8874
8875 if (LSI) {
8876 if (auto *TD = dyn_cast<TypeDecl>(Val: Transformed)) {
8877 if (auto *TN = dyn_cast<TypedefNameDecl>(Val: TD)) {
8878 LSI->ContainsUnexpandedParameterPack |=
8879 TN->getUnderlyingType()->containsUnexpandedParameterPack();
8880 } else {
8881 LSI->ContainsUnexpandedParameterPack |=
8882 getSema()
8883 .getASTContext()
8884 .getTypeDeclType(TD)
8885 ->containsUnexpandedParameterPack();
8886 }
8887 }
8888 if (auto *VD = dyn_cast<VarDecl>(Val: Transformed))
8889 LSI->ContainsUnexpandedParameterPack |=
8890 VD->getType()->containsUnexpandedParameterPack();
8891 }
8892
8893 Decls.push_back(Elt: Transformed);
8894 }
8895
8896 if (!getDerived().AlwaysRebuild() && !DeclChanged)
8897 return S;
8898
8899 return getDerived().RebuildDeclStmt(Decls, S->getBeginLoc(), S->getEndLoc());
8900}
8901
8902template<typename Derived>
8903StmtResult
8904TreeTransform<Derived>::TransformGCCAsmStmt(GCCAsmStmt *S) {
8905
8906 SmallVector<Expr*, 8> Constraints;
8907 SmallVector<Expr*, 8> Exprs;
8908 SmallVector<IdentifierInfo *, 4> Names;
8909
8910 SmallVector<Expr*, 8> Clobbers;
8911
8912 bool ExprsChanged = false;
8913
8914 auto RebuildString = [&](Expr *E) {
8915 ExprResult Result = getDerived().TransformExpr(E);
8916 if (!Result.isUsable())
8917 return Result;
8918 if (Result.get() != E) {
8919 ExprsChanged = true;
8920 Result = SemaRef.ActOnGCCAsmStmtString(Stm: Result.get(), /*ForLabel=*/ForAsmLabel: false);
8921 }
8922 return Result;
8923 };
8924
8925 // Go through the outputs.
8926 for (unsigned I = 0, E = S->getNumOutputs(); I != E; ++I) {
8927 Names.push_back(Elt: S->getOutputIdentifier(i: I));
8928
8929 ExprResult Result = RebuildString(S->getOutputConstraintExpr(i: I));
8930 if (Result.isInvalid())
8931 return StmtError();
8932
8933 Constraints.push_back(Elt: Result.get());
8934
8935 // Transform the output expr.
8936 Expr *OutputExpr = S->getOutputExpr(i: I);
8937 Result = getDerived().TransformExpr(OutputExpr);
8938 if (Result.isInvalid())
8939 return StmtError();
8940
8941 ExprsChanged |= Result.get() != OutputExpr;
8942
8943 Exprs.push_back(Elt: Result.get());
8944 }
8945
8946 // Go through the inputs.
8947 for (unsigned I = 0, E = S->getNumInputs(); I != E; ++I) {
8948 Names.push_back(Elt: S->getInputIdentifier(i: I));
8949
8950 ExprResult Result = RebuildString(S->getInputConstraintExpr(i: I));
8951 if (Result.isInvalid())
8952 return StmtError();
8953
8954 Constraints.push_back(Elt: Result.get());
8955
8956 // Transform the input expr.
8957 Expr *InputExpr = S->getInputExpr(i: I);
8958 Result = getDerived().TransformExpr(InputExpr);
8959 if (Result.isInvalid())
8960 return StmtError();
8961
8962 ExprsChanged |= Result.get() != InputExpr;
8963
8964 Exprs.push_back(Elt: Result.get());
8965 }
8966
8967 // Go through the Labels.
8968 for (unsigned I = 0, E = S->getNumLabels(); I != E; ++I) {
8969 Names.push_back(Elt: S->getLabelIdentifier(i: I));
8970
8971 ExprResult Result = getDerived().TransformExpr(S->getLabelExpr(i: I));
8972 if (Result.isInvalid())
8973 return StmtError();
8974 ExprsChanged |= Result.get() != S->getLabelExpr(i: I);
8975 Exprs.push_back(Elt: Result.get());
8976 }
8977
8978 // Go through the clobbers.
8979 for (unsigned I = 0, E = S->getNumClobbers(); I != E; ++I) {
8980 ExprResult Result = RebuildString(S->getClobberExpr(i: I));
8981 if (Result.isInvalid())
8982 return StmtError();
8983 Clobbers.push_back(Elt: Result.get());
8984 }
8985
8986 ExprResult AsmString = RebuildString(S->getAsmStringExpr());
8987 if (AsmString.isInvalid())
8988 return StmtError();
8989
8990 if (!getDerived().AlwaysRebuild() && !ExprsChanged)
8991 return S;
8992
8993 return getDerived().RebuildGCCAsmStmt(S->getAsmLoc(), S->isSimple(),
8994 S->isVolatile(), S->getNumOutputs(),
8995 S->getNumInputs(), Names.data(),
8996 Constraints, Exprs, AsmString.get(),
8997 Clobbers, S->getNumLabels(),
8998 S->getRParenLoc());
8999}
9000
9001template<typename Derived>
9002StmtResult
9003TreeTransform<Derived>::TransformMSAsmStmt(MSAsmStmt *S) {
9004 ArrayRef<Token> AsmToks = llvm::ArrayRef(S->getAsmToks(), S->getNumAsmToks());
9005
9006 bool HadError = false, HadChange = false;
9007
9008 ArrayRef<Expr*> SrcExprs = S->getAllExprs();
9009 SmallVector<Expr*, 8> TransformedExprs;
9010 TransformedExprs.reserve(N: SrcExprs.size());
9011 for (unsigned i = 0, e = SrcExprs.size(); i != e; ++i) {
9012 ExprResult Result = getDerived().TransformExpr(SrcExprs[i]);
9013 if (!Result.isUsable()) {
9014 HadError = true;
9015 } else {
9016 HadChange |= (Result.get() != SrcExprs[i]);
9017 TransformedExprs.push_back(Elt: Result.get());
9018 }
9019 }
9020
9021 if (HadError) return StmtError();
9022 if (!HadChange && !getDerived().AlwaysRebuild())
9023 return Owned(S);
9024
9025 return getDerived().RebuildMSAsmStmt(S->getAsmLoc(), S->getLBraceLoc(),
9026 AsmToks, S->getAsmString(),
9027 S->getNumOutputs(), S->getNumInputs(),
9028 S->getAllConstraints(), S->getClobbers(),
9029 TransformedExprs, S->getEndLoc());
9030}
9031
9032// C++ Coroutines
9033template<typename Derived>
9034StmtResult
9035TreeTransform<Derived>::TransformCoroutineBodyStmt(CoroutineBodyStmt *S) {
9036 auto *ScopeInfo = SemaRef.getCurFunction();
9037 auto *FD = cast<FunctionDecl>(Val: SemaRef.CurContext);
9038 assert(FD && ScopeInfo && !ScopeInfo->CoroutinePromise &&
9039 ScopeInfo->NeedsCoroutineSuspends &&
9040 ScopeInfo->CoroutineSuspends.first == nullptr &&
9041 ScopeInfo->CoroutineSuspends.second == nullptr &&
9042 "expected clean scope info");
9043
9044 // Set that we have (possibly-invalid) suspend points before we do anything
9045 // that may fail.
9046 ScopeInfo->setNeedsCoroutineSuspends(false);
9047
9048 // We re-build the coroutine promise object (and the coroutine parameters its
9049 // type and constructor depend on) based on the types used in our current
9050 // function. We must do so, and set it on the current FunctionScopeInfo,
9051 // before attempting to transform the other parts of the coroutine body
9052 // statement, such as the implicit suspend statements (because those
9053 // statements reference the FunctionScopeInfo::CoroutinePromise).
9054 if (!SemaRef.buildCoroutineParameterMoves(Loc: FD->getLocation()))
9055 return StmtError();
9056 auto *Promise = SemaRef.buildCoroutinePromise(Loc: FD->getLocation());
9057 if (!Promise)
9058 return StmtError();
9059 getDerived().transformedLocalDecl(S->getPromiseDecl(), {Promise});
9060 ScopeInfo->CoroutinePromise = Promise;
9061
9062 // Transform the implicit coroutine statements constructed using dependent
9063 // types during the previous parse: initial and final suspensions, the return
9064 // object, and others. We also transform the coroutine function's body.
9065 StmtResult InitSuspend = getDerived().TransformStmt(S->getInitSuspendStmt());
9066 if (InitSuspend.isInvalid())
9067 return StmtError();
9068 StmtResult FinalSuspend =
9069 getDerived().TransformStmt(S->getFinalSuspendStmt());
9070 if (FinalSuspend.isInvalid() ||
9071 !SemaRef.checkFinalSuspendNoThrow(FinalSuspend: FinalSuspend.get()))
9072 return StmtError();
9073 ScopeInfo->setCoroutineSuspends(Initial: InitSuspend.get(), Final: FinalSuspend.get());
9074 assert(isa<Expr>(InitSuspend.get()) && isa<Expr>(FinalSuspend.get()));
9075
9076 StmtResult BodyRes = getDerived().TransformStmt(S->getBody());
9077 if (BodyRes.isInvalid())
9078 return StmtError();
9079
9080 CoroutineStmtBuilder Builder(SemaRef, *FD, *ScopeInfo, BodyRes.get());
9081 if (Builder.isInvalid())
9082 return StmtError();
9083
9084 Expr *ReturnObject = S->getReturnValueInit();
9085 assert(ReturnObject && "the return object is expected to be valid");
9086 ExprResult Res = getDerived().TransformInitializer(ReturnObject,
9087 /*NoCopyInit*/ false);
9088 if (Res.isInvalid())
9089 return StmtError();
9090 Builder.ReturnValue = Res.get();
9091
9092 // If during the previous parse the coroutine still had a dependent promise
9093 // statement, we may need to build some implicit coroutine statements
9094 // (such as exception and fallthrough handlers) for the first time.
9095 if (S->hasDependentPromiseType()) {
9096 // We can only build these statements, however, if the current promise type
9097 // is not dependent.
9098 if (!Promise->getType()->isDependentType()) {
9099 assert(!S->getFallthroughHandler() && !S->getExceptionHandler() &&
9100 !S->getReturnStmtOnAllocFailure() && !S->getDeallocate() &&
9101 "these nodes should not have been built yet");
9102 if (!Builder.buildDependentStatements())
9103 return StmtError();
9104 }
9105 } else {
9106 if (auto *OnFallthrough = S->getFallthroughHandler()) {
9107 StmtResult Res = getDerived().TransformStmt(OnFallthrough);
9108 if (Res.isInvalid())
9109 return StmtError();
9110 Builder.OnFallthrough = Res.get();
9111 }
9112
9113 if (auto *OnException = S->getExceptionHandler()) {
9114 StmtResult Res = getDerived().TransformStmt(OnException);
9115 if (Res.isInvalid())
9116 return StmtError();
9117 Builder.OnException = Res.get();
9118 }
9119
9120 if (auto *OnAllocFailure = S->getReturnStmtOnAllocFailure()) {
9121 StmtResult Res = getDerived().TransformStmt(OnAllocFailure);
9122 if (Res.isInvalid())
9123 return StmtError();
9124 Builder.ReturnStmtOnAllocFailure = Res.get();
9125 }
9126
9127 // Transform any additional statements we may have already built
9128 assert(S->getAllocate() && S->getDeallocate() &&
9129 "allocation and deallocation calls must already be built");
9130 ExprResult AllocRes = getDerived().TransformExpr(S->getAllocate());
9131 if (AllocRes.isInvalid())
9132 return StmtError();
9133 Builder.Allocate = AllocRes.get();
9134
9135 ExprResult DeallocRes = getDerived().TransformExpr(S->getDeallocate());
9136 if (DeallocRes.isInvalid())
9137 return StmtError();
9138 Builder.Deallocate = DeallocRes.get();
9139
9140 if (auto *ResultDecl = S->getResultDecl()) {
9141 StmtResult Res = getDerived().TransformStmt(ResultDecl);
9142 if (Res.isInvalid())
9143 return StmtError();
9144 Builder.ResultDecl = Res.get();
9145 }
9146
9147 if (auto *ReturnStmt = S->getReturnStmt()) {
9148 StmtResult Res = getDerived().TransformStmt(ReturnStmt);
9149 if (Res.isInvalid())
9150 return StmtError();
9151 Builder.ReturnStmt = Res.get();
9152 }
9153 }
9154
9155 return getDerived().RebuildCoroutineBodyStmt(Builder);
9156}
9157
9158template<typename Derived>
9159StmtResult
9160TreeTransform<Derived>::TransformCoreturnStmt(CoreturnStmt *S) {
9161 ExprResult Result = getDerived().TransformInitializer(S->getOperand(),
9162 /*NotCopyInit*/false);
9163 if (Result.isInvalid())
9164 return StmtError();
9165
9166 // Always rebuild; we don't know if this needs to be injected into a new
9167 // context or if the promise type has changed.
9168 return getDerived().RebuildCoreturnStmt(S->getKeywordLoc(), Result.get(),
9169 S->isImplicit());
9170}
9171
9172template <typename Derived>
9173ExprResult TreeTransform<Derived>::TransformCoawaitExpr(CoawaitExpr *E) {
9174 ExprResult Operand = getDerived().TransformInitializer(E->getOperand(),
9175 /*NotCopyInit*/ false);
9176 if (Operand.isInvalid())
9177 return ExprError();
9178
9179 // Rebuild the common-expr from the operand rather than transforming it
9180 // separately.
9181
9182 // FIXME: getCurScope() should not be used during template instantiation.
9183 // We should pick up the set of unqualified lookup results for operator
9184 // co_await during the initial parse.
9185 ExprResult Lookup = getSema().BuildOperatorCoawaitLookupExpr(
9186 getSema().getCurScope(), E->getKeywordLoc());
9187
9188 // Always rebuild; we don't know if this needs to be injected into a new
9189 // context or if the promise type has changed.
9190 return getDerived().RebuildCoawaitExpr(
9191 E->getKeywordLoc(), Operand.get(),
9192 cast<UnresolvedLookupExpr>(Val: Lookup.get()), E->isImplicit());
9193}
9194
9195template <typename Derived>
9196ExprResult
9197TreeTransform<Derived>::TransformDependentCoawaitExpr(DependentCoawaitExpr *E) {
9198 ExprResult OperandResult = getDerived().TransformInitializer(E->getOperand(),
9199 /*NotCopyInit*/ false);
9200 if (OperandResult.isInvalid())
9201 return ExprError();
9202
9203 ExprResult LookupResult = getDerived().TransformUnresolvedLookupExpr(
9204 E->getOperatorCoawaitLookup());
9205
9206 if (LookupResult.isInvalid())
9207 return ExprError();
9208
9209 // Always rebuild; we don't know if this needs to be injected into a new
9210 // context or if the promise type has changed.
9211 return getDerived().RebuildDependentCoawaitExpr(
9212 E->getKeywordLoc(), OperandResult.get(),
9213 cast<UnresolvedLookupExpr>(Val: LookupResult.get()));
9214}
9215
9216template<typename Derived>
9217ExprResult
9218TreeTransform<Derived>::TransformCoyieldExpr(CoyieldExpr *E) {
9219 ExprResult Result = getDerived().TransformInitializer(E->getOperand(),
9220 /*NotCopyInit*/false);
9221 if (Result.isInvalid())
9222 return ExprError();
9223
9224 // Always rebuild; we don't know if this needs to be injected into a new
9225 // context or if the promise type has changed.
9226 return getDerived().RebuildCoyieldExpr(E->getKeywordLoc(), Result.get());
9227}
9228
9229// Objective-C Statements.
9230
9231template<typename Derived>
9232StmtResult
9233TreeTransform<Derived>::TransformObjCAtTryStmt(ObjCAtTryStmt *S) {
9234 // Transform the body of the @try.
9235 StmtResult TryBody = getDerived().TransformStmt(S->getTryBody());
9236 if (TryBody.isInvalid())
9237 return StmtError();
9238
9239 // Transform the @catch statements (if present).
9240 bool AnyCatchChanged = false;
9241 SmallVector<Stmt*, 8> CatchStmts;
9242 for (unsigned I = 0, N = S->getNumCatchStmts(); I != N; ++I) {
9243 StmtResult Catch = getDerived().TransformStmt(S->getCatchStmt(I));
9244 if (Catch.isInvalid())
9245 return StmtError();
9246 if (Catch.get() != S->getCatchStmt(I))
9247 AnyCatchChanged = true;
9248 CatchStmts.push_back(Elt: Catch.get());
9249 }
9250
9251 // Transform the @finally statement (if present).
9252 StmtResult Finally;
9253 if (S->getFinallyStmt()) {
9254 Finally = getDerived().TransformStmt(S->getFinallyStmt());
9255 if (Finally.isInvalid())
9256 return StmtError();
9257 }
9258
9259 // If nothing changed, just retain this statement.
9260 if (!getDerived().AlwaysRebuild() &&
9261 TryBody.get() == S->getTryBody() &&
9262 !AnyCatchChanged &&
9263 Finally.get() == S->getFinallyStmt())
9264 return S;
9265
9266 // Build a new statement.
9267 return getDerived().RebuildObjCAtTryStmt(S->getAtTryLoc(), TryBody.get(),
9268 CatchStmts, Finally.get());
9269}
9270
9271template<typename Derived>
9272StmtResult
9273TreeTransform<Derived>::TransformObjCAtCatchStmt(ObjCAtCatchStmt *S) {
9274 // Transform the @catch parameter, if there is one.
9275 VarDecl *Var = nullptr;
9276 if (VarDecl *FromVar = S->getCatchParamDecl()) {
9277 TypeSourceInfo *TSInfo = nullptr;
9278 if (FromVar->getTypeSourceInfo()) {
9279 TSInfo = getDerived().TransformType(FromVar->getTypeSourceInfo());
9280 if (!TSInfo)
9281 return StmtError();
9282 }
9283
9284 QualType T;
9285 if (TSInfo)
9286 T = TSInfo->getType();
9287 else {
9288 T = getDerived().TransformType(FromVar->getType());
9289 if (T.isNull())
9290 return StmtError();
9291 }
9292
9293 Var = getDerived().RebuildObjCExceptionDecl(FromVar, TSInfo, T);
9294 if (!Var)
9295 return StmtError();
9296 }
9297
9298 StmtResult Body = getDerived().TransformStmt(S->getCatchBody());
9299 if (Body.isInvalid())
9300 return StmtError();
9301
9302 return getDerived().RebuildObjCAtCatchStmt(S->getAtCatchLoc(),
9303 S->getRParenLoc(),
9304 Var, Body.get());
9305}
9306
9307template<typename Derived>
9308StmtResult
9309TreeTransform<Derived>::TransformObjCAtFinallyStmt(ObjCAtFinallyStmt *S) {
9310 // Transform the body.
9311 StmtResult Body = getDerived().TransformStmt(S->getFinallyBody());
9312 if (Body.isInvalid())
9313 return StmtError();
9314
9315 // If nothing changed, just retain this statement.
9316 if (!getDerived().AlwaysRebuild() &&
9317 Body.get() == S->getFinallyBody())
9318 return S;
9319
9320 // Build a new statement.
9321 return getDerived().RebuildObjCAtFinallyStmt(S->getAtFinallyLoc(),
9322 Body.get());
9323}
9324
9325template<typename Derived>
9326StmtResult
9327TreeTransform<Derived>::TransformObjCAtThrowStmt(ObjCAtThrowStmt *S) {
9328 ExprResult Operand;
9329 if (S->getThrowExpr()) {
9330 Operand = getDerived().TransformExpr(S->getThrowExpr());
9331 if (Operand.isInvalid())
9332 return StmtError();
9333 }
9334
9335 if (!getDerived().AlwaysRebuild() &&
9336 Operand.get() == S->getThrowExpr())
9337 return S;
9338
9339 return getDerived().RebuildObjCAtThrowStmt(S->getThrowLoc(), Operand.get());
9340}
9341
9342template<typename Derived>
9343StmtResult
9344TreeTransform<Derived>::TransformObjCAtSynchronizedStmt(
9345 ObjCAtSynchronizedStmt *S) {
9346 // Transform the object we are locking.
9347 ExprResult Object = getDerived().TransformExpr(S->getSynchExpr());
9348 if (Object.isInvalid())
9349 return StmtError();
9350 Object =
9351 getDerived().RebuildObjCAtSynchronizedOperand(S->getAtSynchronizedLoc(),
9352 Object.get());
9353 if (Object.isInvalid())
9354 return StmtError();
9355
9356 // Transform the body.
9357 StmtResult Body = getDerived().TransformStmt(S->getSynchBody());
9358 if (Body.isInvalid())
9359 return StmtError();
9360
9361 // If nothing change, just retain the current statement.
9362 if (!getDerived().AlwaysRebuild() &&
9363 Object.get() == S->getSynchExpr() &&
9364 Body.get() == S->getSynchBody())
9365 return S;
9366
9367 // Build a new statement.
9368 return getDerived().RebuildObjCAtSynchronizedStmt(S->getAtSynchronizedLoc(),
9369 Object.get(), Body.get());
9370}
9371
9372template<typename Derived>
9373StmtResult
9374TreeTransform<Derived>::TransformObjCAutoreleasePoolStmt(
9375 ObjCAutoreleasePoolStmt *S) {
9376 // Transform the body.
9377 StmtResult Body = getDerived().TransformStmt(S->getSubStmt());
9378 if (Body.isInvalid())
9379 return StmtError();
9380
9381 // If nothing changed, just retain this statement.
9382 if (!getDerived().AlwaysRebuild() &&
9383 Body.get() == S->getSubStmt())
9384 return S;
9385
9386 // Build a new statement.
9387 return getDerived().RebuildObjCAutoreleasePoolStmt(
9388 S->getAtLoc(), Body.get());
9389}
9390
9391template<typename Derived>
9392StmtResult
9393TreeTransform<Derived>::TransformObjCForCollectionStmt(
9394 ObjCForCollectionStmt *S) {
9395 // Transform the element statement.
9396 StmtResult Element = getDerived().TransformStmt(
9397 S->getElement(), StmtDiscardKind::NotDiscarded);
9398 if (Element.isInvalid())
9399 return StmtError();
9400
9401 // Transform the collection expression.
9402 ExprResult Collection = getDerived().TransformExpr(S->getCollection());
9403 if (Collection.isInvalid())
9404 return StmtError();
9405
9406 // Transform the body.
9407 StmtResult Body = getDerived().TransformStmt(S->getBody());
9408 if (Body.isInvalid())
9409 return StmtError();
9410
9411 // If nothing changed, just retain this statement.
9412 if (!getDerived().AlwaysRebuild() &&
9413 Element.get() == S->getElement() &&
9414 Collection.get() == S->getCollection() &&
9415 Body.get() == S->getBody())
9416 return S;
9417
9418 // Build a new statement.
9419 return getDerived().RebuildObjCForCollectionStmt(S->getForLoc(),
9420 Element.get(),
9421 Collection.get(),
9422 S->getRParenLoc(),
9423 Body.get());
9424}
9425
9426template <typename Derived>
9427StmtResult TreeTransform<Derived>::TransformCXXCatchStmt(CXXCatchStmt *S) {
9428 // Transform the exception declaration, if any.
9429 VarDecl *Var = nullptr;
9430 if (VarDecl *ExceptionDecl = S->getExceptionDecl()) {
9431 TypeSourceInfo *T =
9432 getDerived().TransformType(ExceptionDecl->getTypeSourceInfo());
9433 if (!T)
9434 return StmtError();
9435
9436 Var = getDerived().RebuildExceptionDecl(
9437 ExceptionDecl, T, ExceptionDecl->getInnerLocStart(),
9438 ExceptionDecl->getLocation(), ExceptionDecl->getIdentifier());
9439 if (!Var || Var->isInvalidDecl())
9440 return StmtError();
9441 }
9442
9443 // Transform the actual exception handler.
9444 StmtResult Handler = getDerived().TransformStmt(S->getHandlerBlock());
9445 if (Handler.isInvalid())
9446 return StmtError();
9447
9448 if (!getDerived().AlwaysRebuild() && !Var &&
9449 Handler.get() == S->getHandlerBlock())
9450 return S;
9451
9452 return getDerived().RebuildCXXCatchStmt(S->getCatchLoc(), Var, Handler.get());
9453}
9454
9455template <typename Derived>
9456StmtResult TreeTransform<Derived>::TransformCXXTryStmt(CXXTryStmt *S) {
9457 // Transform the try block itself.
9458 StmtResult TryBlock = getDerived().TransformCompoundStmt(S->getTryBlock());
9459 if (TryBlock.isInvalid())
9460 return StmtError();
9461
9462 // Transform the handlers.
9463 bool HandlerChanged = false;
9464 SmallVector<Stmt *, 8> Handlers;
9465 for (unsigned I = 0, N = S->getNumHandlers(); I != N; ++I) {
9466 StmtResult Handler = getDerived().TransformCXXCatchStmt(S->getHandler(i: I));
9467 if (Handler.isInvalid())
9468 return StmtError();
9469
9470 HandlerChanged = HandlerChanged || Handler.get() != S->getHandler(i: I);
9471 Handlers.push_back(Elt: Handler.getAs<Stmt>());
9472 }
9473
9474 getSema().DiagnoseExceptionUse(S->getTryLoc(), /* IsTry= */ true);
9475
9476 if (!getDerived().AlwaysRebuild() && TryBlock.get() == S->getTryBlock() &&
9477 !HandlerChanged)
9478 return S;
9479
9480 return getDerived().RebuildCXXTryStmt(S->getTryLoc(), TryBlock.get(),
9481 Handlers);
9482}
9483
9484template<typename Derived>
9485StmtResult
9486TreeTransform<Derived>::TransformCXXForRangeStmt(CXXForRangeStmt *S) {
9487 EnterExpressionEvaluationContext ForRangeInitContext(
9488 getSema(), Sema::ExpressionEvaluationContext::PotentiallyEvaluated,
9489 /*LambdaContextDecl=*/nullptr,
9490 Sema::ExpressionEvaluationContextRecord::EK_Other,
9491 getSema().getLangOpts().CPlusPlus23);
9492
9493 // P2718R0 - Lifetime extension in range-based for loops.
9494 if (getSema().getLangOpts().CPlusPlus23) {
9495 auto &LastRecord = getSema().currentEvaluationContext();
9496 LastRecord.InLifetimeExtendingContext = true;
9497 LastRecord.RebuildDefaultArgOrDefaultInit = true;
9498 }
9499 StmtResult Init =
9500 S->getInit() ? getDerived().TransformStmt(S->getInit()) : StmtResult();
9501 if (Init.isInvalid())
9502 return StmtError();
9503
9504 StmtResult Range = getDerived().TransformStmt(S->getRangeStmt());
9505 if (Range.isInvalid())
9506 return StmtError();
9507
9508 // Before c++23, ForRangeLifetimeExtendTemps should be empty.
9509 assert(getSema().getLangOpts().CPlusPlus23 ||
9510 getSema().ExprEvalContexts.back().ForRangeLifetimeExtendTemps.empty());
9511 auto ForRangeLifetimeExtendTemps =
9512 getSema().ExprEvalContexts.back().ForRangeLifetimeExtendTemps;
9513
9514 StmtResult Begin = getDerived().TransformStmt(S->getBeginStmt());
9515 if (Begin.isInvalid())
9516 return StmtError();
9517 StmtResult End = getDerived().TransformStmt(S->getEndStmt());
9518 if (End.isInvalid())
9519 return StmtError();
9520
9521 ExprResult Cond = getDerived().TransformExpr(S->getCond());
9522 if (Cond.isInvalid())
9523 return StmtError();
9524 if (Cond.get())
9525 Cond = SemaRef.CheckBooleanCondition(Loc: S->getColonLoc(), E: Cond.get());
9526 if (Cond.isInvalid())
9527 return StmtError();
9528 if (Cond.get())
9529 Cond = SemaRef.MaybeCreateExprWithCleanups(SubExpr: Cond.get());
9530
9531 ExprResult Inc = getDerived().TransformExpr(S->getInc());
9532 if (Inc.isInvalid())
9533 return StmtError();
9534 if (Inc.get())
9535 Inc = SemaRef.MaybeCreateExprWithCleanups(SubExpr: Inc.get());
9536
9537 StmtResult LoopVar = getDerived().TransformStmt(S->getLoopVarStmt());
9538 if (LoopVar.isInvalid())
9539 return StmtError();
9540
9541 StmtResult NewStmt = S;
9542 if (getDerived().AlwaysRebuild() ||
9543 Init.get() != S->getInit() ||
9544 Range.get() != S->getRangeStmt() ||
9545 Begin.get() != S->getBeginStmt() ||
9546 End.get() != S->getEndStmt() ||
9547 Cond.get() != S->getCond() ||
9548 Inc.get() != S->getInc() ||
9549 LoopVar.get() != S->getLoopVarStmt()) {
9550 NewStmt = getDerived().RebuildCXXForRangeStmt(
9551 S->getForLoc(), S->getCoawaitLoc(), Init.get(), S->getColonLoc(),
9552 Range.get(), Begin.get(), End.get(), Cond.get(), Inc.get(),
9553 LoopVar.get(), S->getRParenLoc(), ForRangeLifetimeExtendTemps);
9554 if (NewStmt.isInvalid() && LoopVar.get() != S->getLoopVarStmt()) {
9555 // Might not have attached any initializer to the loop variable.
9556 getSema().ActOnInitializerError(
9557 cast<DeclStmt>(Val: LoopVar.get())->getSingleDecl());
9558 return StmtError();
9559 }
9560 }
9561
9562 // OpenACC Restricts a while-loop inside of certain construct/clause
9563 // combinations, so diagnose that here in OpenACC mode.
9564 SemaOpenACC::LoopInConstructRAII LCR{SemaRef.OpenACC()};
9565 SemaRef.OpenACC().ActOnRangeForStmtBegin(ForLoc: S->getBeginLoc(), OldRangeFor: S, RangeFor: NewStmt.get());
9566
9567 StmtResult Body = getDerived().TransformStmt(S->getBody());
9568 if (Body.isInvalid())
9569 return StmtError();
9570
9571 SemaRef.OpenACC().ActOnForStmtEnd(ForLoc: S->getBeginLoc(), Body);
9572
9573 // Body has changed but we didn't rebuild the for-range statement. Rebuild
9574 // it now so we have a new statement to attach the body to.
9575 if (Body.get() != S->getBody() && NewStmt.get() == S) {
9576 NewStmt = getDerived().RebuildCXXForRangeStmt(
9577 S->getForLoc(), S->getCoawaitLoc(), Init.get(), S->getColonLoc(),
9578 Range.get(), Begin.get(), End.get(), Cond.get(), Inc.get(),
9579 LoopVar.get(), S->getRParenLoc(), ForRangeLifetimeExtendTemps);
9580 if (NewStmt.isInvalid())
9581 return StmtError();
9582 }
9583
9584 if (NewStmt.get() == S)
9585 return S;
9586
9587 return FinishCXXForRangeStmt(ForRange: NewStmt.get(), Body: Body.get());
9588}
9589
9590template <typename Derived>
9591StmtResult TreeTransform<Derived>::TransformCXXExpansionStmtPattern(
9592 CXXExpansionStmtPattern *S) {
9593 assert(SemaRef.CurContext->isExpansionStmt());
9594
9595 Decl *ESD =
9596 getDerived().TransformDecl(S->getDecl()->getLocation(), S->getDecl());
9597 if (!ESD || ESD->isInvalidDecl())
9598 return StmtError();
9599 CXXExpansionStmtDecl *NewESD = cast<CXXExpansionStmtDecl>(Val: ESD);
9600
9601 // This is required because some parts of an expansion statement (e.g. the
9602 // init-statement) are not in a dependent context and must thus be transformed
9603 // in the parent context.
9604 auto TransformStmtInParentContext = [&](Stmt *SubStmt) -> StmtResult {
9605 Sema::ContextRAII CtxGuard(SemaRef, SemaRef.CurContext->getParent(),
9606 /*NewThis=*/false);
9607 return getDerived().TransformStmt(SubStmt);
9608 };
9609
9610 Stmt *Init = S->getInit();
9611 if (Init) {
9612 StmtResult SR = TransformStmtInParentContext(Init);
9613 if (SR.isInvalid())
9614 return StmtError();
9615 Init = SR.get();
9616 }
9617
9618 // Collect lifetime-extended temporaries in case this ends up being a
9619 // destructuring or iterating expansion statement.
9620 //
9621 // CWG 3140: Additionally, for iterating expansions statements, we need to
9622 // apply lifetime extension to the initializer of the range.
9623 ExprResult ExpansionInitializer;
9624 StmtResult Range;
9625 SmallVector<MaterializeTemporaryExpr *, 8> LifetimeExtendTemps;
9626 if (S->isDependent() || S->isIterating()) {
9627 EnterExpressionEvaluationContext ExprEvalCtx(
9628 SemaRef, SemaRef.currentEvaluationContext().Context);
9629 SemaRef.currentEvaluationContext().InLifetimeExtendingContext = true;
9630 SemaRef.currentEvaluationContext().RebuildDefaultArgOrDefaultInit = true;
9631
9632 if (S->isDependent()) {
9633 // The expansion initializer should not be in the context of the expansion
9634 // statement because it isn't instantiated when the expansion statement is
9635 // expanded.
9636 Sema::ContextRAII CtxGuard(SemaRef, SemaRef.CurContext->getParent(),
9637 /*NewThis=*/false);
9638 ExpansionInitializer =
9639 getDerived().TransformExpr(S->getExpansionInitializer());
9640 if (ExpansionInitializer.isInvalid())
9641 return StmtError();
9642 } else if (S->isIterating()) {
9643 Range = TransformStmtInParentContext(S->getRangeVarStmt());
9644 if (Range.isInvalid())
9645 return StmtError();
9646 }
9647
9648 ExpansionInitializer =
9649 SemaRef.MaybeCreateExprWithCleanups(SubExpr: ExpansionInitializer);
9650
9651 LifetimeExtendTemps =
9652 SemaRef.currentEvaluationContext().ForRangeLifetimeExtendTemps;
9653 }
9654
9655 CXXExpansionStmtPattern *NewPattern = nullptr;
9656 if (S->isEnumerating()) {
9657 StmtResult ExpansionVar =
9658 getDerived().TransformStmt(S->getExpansionVarStmt());
9659 if (ExpansionVar.isInvalid())
9660 return StmtError();
9661
9662 NewPattern = CXXExpansionStmtPattern::CreateEnumerating(
9663 Context&: SemaRef.Context, ESD: NewESD, Init, ExpansionVar: ExpansionVar.getAs<DeclStmt>(),
9664 LParenLoc: S->getLParenLoc(), ColonLoc: S->getColonLoc(), RParenLoc: S->getRParenLoc());
9665 } else if (S->isIterating()) {
9666 StmtResult Begin = TransformStmtInParentContext(S->getBeginVarStmt());
9667 StmtResult Iter = TransformStmtInParentContext(S->getIterVarStmt());
9668 if (Begin.isInvalid() || Iter.isInvalid())
9669 return StmtError();
9670
9671 // The expansion variable is part of the pattern only and never ends
9672 // up in the instantiations, so keep it in the expansion statement's
9673 // DeclContext.
9674 StmtResult ExpansionVar =
9675 getDerived().TransformStmt(S->getExpansionVarStmt());
9676 if (ExpansionVar.isInvalid())
9677 return StmtError();
9678
9679 NewPattern = CXXExpansionStmtPattern::CreateIterating(
9680 Context&: SemaRef.Context, ESD: NewESD, Init, ExpansionVar: ExpansionVar.getAs<DeclStmt>(),
9681 Range: Range.getAs<DeclStmt>(), Begin: Begin.getAs<DeclStmt>(),
9682 Iter: Iter.getAs<DeclStmt>(), LParenLoc: S->getLParenLoc(), ColonLoc: S->getColonLoc(),
9683 RParenLoc: S->getRParenLoc());
9684
9685 SemaRef.ApplyForRangeOrExpansionStatementLifetimeExtension(
9686 RangeVar: NewPattern->getRangeVar(), Temporaries: LifetimeExtendTemps);
9687 } else if (S->isDependent()) {
9688 StmtResult ExpansionVar =
9689 getDerived().TransformStmt(S->getExpansionVarStmt());
9690 if (ExpansionVar.isInvalid())
9691 return StmtError();
9692
9693 StmtResult Res = SemaRef.BuildNonEnumeratingCXXExpansionStmtPattern(
9694 ESD: NewESD, Init, ExpansionVarStmt: ExpansionVar.getAs<DeclStmt>(),
9695 ExpansionInitializer: ExpansionInitializer.get(), LParenLoc: S->getLParenLoc(), ColonLoc: S->getColonLoc(),
9696 RParenLoc: S->getRParenLoc(), LifetimeExtendTemps);
9697
9698 if (Res.isInvalid())
9699 return StmtError();
9700
9701 NewPattern = cast<CXXExpansionStmtPattern>(Val: Res.get());
9702 } else {
9703 // The only time we instantiate an expansion statement is if its expansion
9704 // size is dependent (otherwise, we only instantiate the expansions and
9705 // leave the underlying CXXExpansionStmtPattern as-is). Since destructuring
9706 // expansion statements never have a dependent size, we should never get
9707 // here.
9708 llvm_unreachable("destructuring pattern should never be instantiated");
9709 }
9710
9711 StmtResult Body = getDerived().TransformStmt(S->getBody());
9712 if (Body.isInvalid())
9713 return StmtError();
9714
9715 return SemaRef.FinishCXXExpansionStmt(Expansion: NewPattern, Body: Body.get());
9716}
9717
9718template <typename Derived>
9719StmtResult TreeTransform<Derived>::TransformCXXExpansionStmtInstantiation(
9720 CXXExpansionStmtInstantiation *S) {
9721 bool SubStmtChanged = false;
9722 auto TransformStmts = [&](SmallVectorImpl<Stmt *> &NewStmts,
9723 ArrayRef<Stmt *> OldStmts) {
9724 for (Stmt *OldDS : OldStmts) {
9725 StmtResult NewDS = getDerived().TransformStmt(OldDS);
9726 if (NewDS.isInvalid())
9727 return true;
9728
9729 SubStmtChanged |= NewDS.get() != OldDS;
9730 NewStmts.push_back(Elt: NewDS.get());
9731 }
9732
9733 return false;
9734 };
9735
9736 Decl *ESD =
9737 getDerived().TransformDecl(S->getParent()->getLocation(), S->getParent());
9738 if (!ESD || ESD->isInvalidDecl())
9739 return StmtError();
9740 CXXExpansionStmtDecl *NewESD = cast<CXXExpansionStmtDecl>(Val: ESD);
9741
9742 SmallVector<Stmt *> PreambleStmts;
9743 SmallVector<Stmt *> Instantiations;
9744
9745 // Apply lifetime extension to the preamble statements if this was a
9746 // destructuring expansion statement.
9747 {
9748 EnterExpressionEvaluationContext ExprEvalCtx(
9749 SemaRef, SemaRef.currentEvaluationContext().Context);
9750 SemaRef.currentEvaluationContext().InLifetimeExtendingContext = true;
9751 SemaRef.currentEvaluationContext().RebuildDefaultArgOrDefaultInit = true;
9752 if (TransformStmts(PreambleStmts, S->getPreambleStmts()))
9753 return StmtError();
9754
9755 if (S->shouldApplyLifetimeExtensionToPreamble()) {
9756 auto *VD =
9757 cast<VarDecl>(Val: cast<DeclStmt>(Val: PreambleStmts.front())->getSingleDecl());
9758 SemaRef.ApplyForRangeOrExpansionStatementLifetimeExtension(
9759 RangeVar: VD, Temporaries: SemaRef.currentEvaluationContext().ForRangeLifetimeExtendTemps);
9760 }
9761 }
9762
9763 if (TransformStmts(Instantiations, S->getInstantiations()))
9764 return StmtError();
9765
9766 if (!getDerived().AlwaysRebuild() && !SubStmtChanged)
9767 return S;
9768
9769 return CXXExpansionStmtInstantiation::Create(
9770 C&: SemaRef.Context, Parent: NewESD, Instantiations, PreambleStmts,
9771 ShouldApplyLifetimeExtensionToPreamble: S->shouldApplyLifetimeExtensionToPreamble());
9772}
9773
9774template <typename Derived>
9775ExprResult TreeTransform<Derived>::TransformCXXExpansionSelectExpr(
9776 CXXExpansionSelectExpr *E) {
9777 ExprResult Range = getDerived().TransformExpr(E->getRangeExpr());
9778 ExprResult Idx = getDerived().TransformExpr(E->getIndexExpr());
9779 if (Range.isInvalid() || Idx.isInvalid())
9780 return ExprError();
9781
9782 if (!getDerived().AlwaysRebuild() && Range.get() == E->getRangeExpr() &&
9783 Idx.get() == E->getIndexExpr())
9784 return E;
9785
9786 return SemaRef.BuildCXXExpansionSelectExpr(Range: Range.getAs<InitListExpr>(),
9787 Idx: Idx.get());
9788}
9789
9790template<typename Derived>
9791StmtResult
9792TreeTransform<Derived>::TransformMSDependentExistsStmt(
9793 MSDependentExistsStmt *S) {
9794 // Transform the nested-name-specifier, if any.
9795 NestedNameSpecifierLoc QualifierLoc;
9796 if (S->getQualifierLoc()) {
9797 QualifierLoc
9798 = getDerived().TransformNestedNameSpecifierLoc(S->getQualifierLoc());
9799 if (!QualifierLoc)
9800 return StmtError();
9801 }
9802
9803 // Transform the declaration name.
9804 DeclarationNameInfo NameInfo = S->getNameInfo();
9805 if (NameInfo.getName()) {
9806 NameInfo = getDerived().TransformDeclarationNameInfo(NameInfo);
9807 if (!NameInfo.getName())
9808 return StmtError();
9809 }
9810
9811 // Check whether anything changed.
9812 if (!getDerived().AlwaysRebuild() &&
9813 QualifierLoc == S->getQualifierLoc() &&
9814 NameInfo.getName() == S->getNameInfo().getName())
9815 return S;
9816
9817 // Determine whether this name exists, if we can.
9818 CXXScopeSpec SS;
9819 SS.Adopt(Other: QualifierLoc);
9820 bool Dependent = false;
9821 switch (getSema().CheckMicrosoftIfExistsSymbol(/*S=*/nullptr, SS, NameInfo)) {
9822 case IfExistsResult::Exists:
9823 if (S->isIfExists())
9824 break;
9825
9826 return new (getSema().Context) NullStmt(S->getKeywordLoc());
9827
9828 case IfExistsResult::DoesNotExist:
9829 if (S->isIfNotExists())
9830 break;
9831
9832 return new (getSema().Context) NullStmt(S->getKeywordLoc());
9833
9834 case IfExistsResult::Dependent:
9835 Dependent = true;
9836 break;
9837
9838 case IfExistsResult::Error:
9839 return StmtError();
9840 }
9841
9842 // We need to continue with the instantiation, so do so now.
9843 StmtResult SubStmt = getDerived().TransformCompoundStmt(S->getSubStmt());
9844 if (SubStmt.isInvalid())
9845 return StmtError();
9846
9847 // If we have resolved the name, just transform to the substatement.
9848 if (!Dependent)
9849 return SubStmt;
9850
9851 // The name is still dependent, so build a dependent expression again.
9852 return getDerived().RebuildMSDependentExistsStmt(S->getKeywordLoc(),
9853 S->isIfExists(),
9854 QualifierLoc,
9855 NameInfo,
9856 SubStmt.get());
9857}
9858
9859template<typename Derived>
9860ExprResult
9861TreeTransform<Derived>::TransformMSPropertyRefExpr(MSPropertyRefExpr *E) {
9862 NestedNameSpecifierLoc QualifierLoc;
9863 if (E->getQualifierLoc()) {
9864 QualifierLoc
9865 = getDerived().TransformNestedNameSpecifierLoc(E->getQualifierLoc());
9866 if (!QualifierLoc)
9867 return ExprError();
9868 }
9869
9870 MSPropertyDecl *PD = cast_or_null<MSPropertyDecl>(
9871 getDerived().TransformDecl(E->getMemberLoc(), E->getPropertyDecl()));
9872 if (!PD)
9873 return ExprError();
9874
9875 ExprResult Base = getDerived().TransformExpr(E->getBaseExpr());
9876 if (Base.isInvalid())
9877 return ExprError();
9878
9879 return new (SemaRef.getASTContext())
9880 MSPropertyRefExpr(Base.get(), PD, E->isArrow(),
9881 SemaRef.getASTContext().PseudoObjectTy, VK_LValue,
9882 QualifierLoc, E->getMemberLoc());
9883}
9884
9885template <typename Derived>
9886ExprResult TreeTransform<Derived>::TransformMSPropertySubscriptExpr(
9887 MSPropertySubscriptExpr *E) {
9888 auto BaseRes = getDerived().TransformExpr(E->getBase());
9889 if (BaseRes.isInvalid())
9890 return ExprError();
9891 auto IdxRes = getDerived().TransformExpr(E->getIdx());
9892 if (IdxRes.isInvalid())
9893 return ExprError();
9894
9895 if (!getDerived().AlwaysRebuild() &&
9896 BaseRes.get() == E->getBase() &&
9897 IdxRes.get() == E->getIdx())
9898 return E;
9899
9900 return getDerived().RebuildArraySubscriptExpr(
9901 BaseRes.get(), SourceLocation(), IdxRes.get(), E->getRBracketLoc());
9902}
9903
9904template <typename Derived>
9905StmtResult TreeTransform<Derived>::TransformSEHTryStmt(SEHTryStmt *S) {
9906 StmtResult TryBlock = getDerived().TransformCompoundStmt(S->getTryBlock());
9907 if (TryBlock.isInvalid())
9908 return StmtError();
9909
9910 StmtResult Handler = getDerived().TransformSEHHandler(S->getHandler());
9911 if (Handler.isInvalid())
9912 return StmtError();
9913
9914 if (!getDerived().AlwaysRebuild() && TryBlock.get() == S->getTryBlock() &&
9915 Handler.get() == S->getHandler())
9916 return S;
9917
9918 return getDerived().RebuildSEHTryStmt(S->getIsCXXTry(), S->getTryLoc(),
9919 TryBlock.get(), Handler.get());
9920}
9921
9922template <typename Derived>
9923StmtResult TreeTransform<Derived>::TransformSEHFinallyStmt(SEHFinallyStmt *S) {
9924 StmtResult Block = getDerived().TransformCompoundStmt(S->getBlock());
9925 if (Block.isInvalid())
9926 return StmtError();
9927
9928 return getDerived().RebuildSEHFinallyStmt(S->getFinallyLoc(), Block.get());
9929}
9930
9931template <typename Derived>
9932StmtResult TreeTransform<Derived>::TransformSEHExceptStmt(SEHExceptStmt *S) {
9933 ExprResult FilterExpr = getDerived().TransformExpr(S->getFilterExpr());
9934 if (FilterExpr.isInvalid())
9935 return StmtError();
9936
9937 StmtResult Block = getDerived().TransformCompoundStmt(S->getBlock());
9938 if (Block.isInvalid())
9939 return StmtError();
9940
9941 return getDerived().RebuildSEHExceptStmt(S->getExceptLoc(), FilterExpr.get(),
9942 Block.get());
9943}
9944
9945template <typename Derived>
9946StmtResult TreeTransform<Derived>::TransformSEHHandler(Stmt *Handler) {
9947 if (isa<SEHFinallyStmt>(Val: Handler))
9948 return getDerived().TransformSEHFinallyStmt(cast<SEHFinallyStmt>(Val: Handler));
9949 else
9950 return getDerived().TransformSEHExceptStmt(cast<SEHExceptStmt>(Val: Handler));
9951}
9952
9953template<typename Derived>
9954StmtResult
9955TreeTransform<Derived>::TransformSEHLeaveStmt(SEHLeaveStmt *S) {
9956 return S;
9957}
9958
9959//===----------------------------------------------------------------------===//
9960// OpenMP directive transformation
9961//===----------------------------------------------------------------------===//
9962
9963template <typename Derived>
9964StmtResult
9965TreeTransform<Derived>::TransformOMPCanonicalLoop(OMPCanonicalLoop *L) {
9966 // OMPCanonicalLoops are eliminated during transformation, since they will be
9967 // recomputed by semantic analysis of the associated OMPLoopBasedDirective
9968 // after transformation.
9969 return getDerived().TransformStmt(L->getLoopStmt());
9970}
9971
9972template <typename Derived>
9973StmtResult TreeTransform<Derived>::TransformOMPExecutableDirective(
9974 OMPExecutableDirective *D) {
9975
9976 // Transform the clauses
9977 llvm::SmallVector<OMPClause *, 16> TClauses;
9978 ArrayRef<OMPClause *> Clauses = D->clauses();
9979 TClauses.reserve(N: Clauses.size());
9980 for (ArrayRef<OMPClause *>::iterator I = Clauses.begin(), E = Clauses.end();
9981 I != E; ++I) {
9982 if (*I) {
9983 getDerived().getSema().OpenMP().StartOpenMPClause((*I)->getClauseKind());
9984 OMPClause *Clause = getDerived().TransformOMPClause(*I);
9985 getDerived().getSema().OpenMP().EndOpenMPClause();
9986 if (Clause)
9987 TClauses.push_back(Elt: Clause);
9988 } else {
9989 TClauses.push_back(Elt: nullptr);
9990 }
9991 }
9992 StmtResult AssociatedStmt;
9993 if (D->hasAssociatedStmt() && D->getAssociatedStmt()) {
9994 getDerived().getSema().OpenMP().ActOnOpenMPRegionStart(
9995 D->getDirectiveKind(),
9996 /*CurScope=*/nullptr);
9997 StmtResult Body;
9998 {
9999 Sema::CompoundScopeRAII CompoundScope(getSema());
10000 Stmt *CS;
10001 if (D->getDirectiveKind() == OMPD_atomic ||
10002 D->getDirectiveKind() == OMPD_critical ||
10003 D->getDirectiveKind() == OMPD_section ||
10004 D->getDirectiveKind() == OMPD_master)
10005 CS = D->getAssociatedStmt();
10006 else
10007 CS = D->getRawStmt();
10008 Body = getDerived().TransformStmt(CS);
10009 if (Body.isUsable() && isOpenMPLoopDirective(DKind: D->getDirectiveKind()) &&
10010 getSema().getLangOpts().OpenMPIRBuilder)
10011 Body = getDerived().RebuildOMPCanonicalLoop(Body.get());
10012 }
10013 AssociatedStmt =
10014 getDerived().getSema().OpenMP().ActOnOpenMPRegionEnd(Body, TClauses);
10015 if (AssociatedStmt.isInvalid()) {
10016 return StmtError();
10017 }
10018 }
10019 if (TClauses.size() != Clauses.size()) {
10020 return StmtError();
10021 }
10022
10023 // Transform directive name for 'omp critical' directive.
10024 DeclarationNameInfo DirName;
10025 if (D->getDirectiveKind() == OMPD_critical) {
10026 DirName = cast<OMPCriticalDirective>(Val: D)->getDirectiveName();
10027 DirName = getDerived().TransformDeclarationNameInfo(DirName);
10028 }
10029 OpenMPDirectiveKind CancelRegion = OMPD_unknown;
10030 if (D->getDirectiveKind() == OMPD_cancellation_point) {
10031 CancelRegion = cast<OMPCancellationPointDirective>(Val: D)->getCancelRegion();
10032 } else if (D->getDirectiveKind() == OMPD_cancel) {
10033 CancelRegion = cast<OMPCancelDirective>(Val: D)->getCancelRegion();
10034 }
10035
10036 return getDerived().RebuildOMPExecutableDirective(
10037 D->getDirectiveKind(), DirName, CancelRegion, TClauses,
10038 AssociatedStmt.get(), D->getBeginLoc(), D->getEndLoc());
10039}
10040
10041/// This is mostly the same as above, but allows 'informational' class
10042/// directives when rebuilding the stmt. It still takes an
10043/// OMPExecutableDirective-type argument because we're reusing that as the
10044/// superclass for the 'assume' directive at present, instead of defining a
10045/// mostly-identical OMPInformationalDirective parent class.
10046template <typename Derived>
10047StmtResult TreeTransform<Derived>::TransformOMPInformationalDirective(
10048 OMPExecutableDirective *D) {
10049
10050 // Transform the clauses
10051 llvm::SmallVector<OMPClause *, 16> TClauses;
10052 ArrayRef<OMPClause *> Clauses = D->clauses();
10053 TClauses.reserve(N: Clauses.size());
10054 for (OMPClause *C : Clauses) {
10055 if (C) {
10056 getDerived().getSema().OpenMP().StartOpenMPClause(C->getClauseKind());
10057 OMPClause *Clause = getDerived().TransformOMPClause(C);
10058 getDerived().getSema().OpenMP().EndOpenMPClause();
10059 if (Clause)
10060 TClauses.push_back(Elt: Clause);
10061 } else {
10062 TClauses.push_back(Elt: nullptr);
10063 }
10064 }
10065 StmtResult AssociatedStmt;
10066 if (D->hasAssociatedStmt() && D->getAssociatedStmt()) {
10067 getDerived().getSema().OpenMP().ActOnOpenMPRegionStart(
10068 D->getDirectiveKind(),
10069 /*CurScope=*/nullptr);
10070 StmtResult Body;
10071 {
10072 Sema::CompoundScopeRAII CompoundScope(getSema());
10073 assert(D->getDirectiveKind() == OMPD_assume &&
10074 "Unexpected informational directive");
10075 Stmt *CS = D->getAssociatedStmt();
10076 Body = getDerived().TransformStmt(CS);
10077 }
10078 AssociatedStmt =
10079 getDerived().getSema().OpenMP().ActOnOpenMPRegionEnd(Body, TClauses);
10080 if (AssociatedStmt.isInvalid())
10081 return StmtError();
10082 }
10083 if (TClauses.size() != Clauses.size())
10084 return StmtError();
10085
10086 DeclarationNameInfo DirName;
10087
10088 return getDerived().RebuildOMPInformationalDirective(
10089 D->getDirectiveKind(), DirName, TClauses, AssociatedStmt.get(),
10090 D->getBeginLoc(), D->getEndLoc());
10091}
10092
10093template <typename Derived>
10094StmtResult
10095TreeTransform<Derived>::TransformOMPMetaDirective(OMPMetaDirective *D) {
10096 // Every variant is a complete directive (or the plain associated statement),
10097 // so it is transformed on its own.
10098 SmallVector<Stmt *, 4> Variants;
10099 for (Stmt *V : D->variants()) {
10100 StmtResult NewV = getDerived().TransformStmt(V);
10101 if (NewV.isInvalid())
10102 return StmtError();
10103 Variants.push_back(Elt: NewV.get());
10104 }
10105
10106 // Copy the trait infos and transform their score and condition expressions.
10107 // The implicit 'otherwise' trait info is added back by Sema.
10108 ArrayRef<OMPTraitInfo *> OldTraitInfos = D->traitInfos();
10109 if (D->hasImplicitOtherwise())
10110 OldTraitInfos = OldTraitInfos.drop_back();
10111 SmallVector<OMPTraitInfo *, 4> TraitInfos;
10112 for (const OMPTraitInfo *OldTI : OldTraitInfos) {
10113 OMPTraitInfo &TI = getSema().getASTContext().getNewOMPTraitInfo();
10114 TI = *OldTI;
10115 auto TransformScoreOrCondition = [&](Expr *&E, bool IsScore) {
10116 if (!E)
10117 return false;
10118 EnterExpressionEvaluationContext Ctx(
10119 getSema(),
10120 IsScore ? Sema::ExpressionEvaluationContext::ConstantEvaluated
10121 : Sema::ExpressionEvaluationContext::PotentiallyEvaluated);
10122 ExprResult ER = getDerived().TransformExpr(E);
10123 if (!ER.isUsable())
10124 return true;
10125 E = ER.get();
10126 return false;
10127 };
10128 if (TI.anyScoreOrCondition(Cond: TransformScoreOrCondition))
10129 return StmtError();
10130 TraitInfos.push_back(Elt: &TI);
10131 }
10132
10133 return getDerived().RebuildOMPMetaDirective(D->getBeginLoc(), D->getEndLoc(),
10134 TraitInfos, Variants);
10135}
10136
10137template <typename Derived>
10138StmtResult
10139TreeTransform<Derived>::TransformOMPParallelDirective(OMPParallelDirective *D) {
10140 DeclarationNameInfo DirName;
10141 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
10142 OMPD_parallel, DirName, nullptr, D->getBeginLoc());
10143 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
10144 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
10145 return Res;
10146}
10147
10148template <typename Derived>
10149StmtResult
10150TreeTransform<Derived>::TransformOMPSimdDirective(OMPSimdDirective *D) {
10151 DeclarationNameInfo DirName;
10152 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
10153 OMPD_simd, DirName, nullptr, D->getBeginLoc());
10154 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
10155 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
10156 return Res;
10157}
10158
10159template <typename Derived>
10160StmtResult
10161TreeTransform<Derived>::TransformOMPTileDirective(OMPTileDirective *D) {
10162 DeclarationNameInfo DirName;
10163 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
10164 D->getDirectiveKind(), DirName, nullptr, D->getBeginLoc());
10165 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
10166 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
10167 return Res;
10168}
10169
10170template <typename Derived>
10171StmtResult
10172TreeTransform<Derived>::TransformOMPStripeDirective(OMPStripeDirective *D) {
10173 DeclarationNameInfo DirName;
10174 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
10175 D->getDirectiveKind(), DirName, nullptr, D->getBeginLoc());
10176 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
10177 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
10178 return Res;
10179}
10180
10181template <typename Derived>
10182StmtResult
10183TreeTransform<Derived>::TransformOMPUnrollDirective(OMPUnrollDirective *D) {
10184 DeclarationNameInfo DirName;
10185 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
10186 D->getDirectiveKind(), DirName, nullptr, D->getBeginLoc());
10187 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
10188 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
10189 return Res;
10190}
10191
10192template <typename Derived>
10193StmtResult
10194TreeTransform<Derived>::TransformOMPReverseDirective(OMPReverseDirective *D) {
10195 DeclarationNameInfo DirName;
10196 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
10197 D->getDirectiveKind(), DirName, nullptr, D->getBeginLoc());
10198 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
10199 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
10200 return Res;
10201}
10202
10203template <typename Derived>
10204StmtResult TreeTransform<Derived>::TransformOMPInterchangeDirective(
10205 OMPInterchangeDirective *D) {
10206 DeclarationNameInfo DirName;
10207 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
10208 D->getDirectiveKind(), DirName, nullptr, D->getBeginLoc());
10209 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
10210 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
10211 return Res;
10212}
10213
10214template <typename Derived>
10215StmtResult
10216TreeTransform<Derived>::TransformOMPSplitDirective(OMPSplitDirective *D) {
10217 DeclarationNameInfo DirName;
10218 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
10219 D->getDirectiveKind(), DirName, nullptr, D->getBeginLoc());
10220 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
10221 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
10222 return Res;
10223}
10224
10225template <typename Derived>
10226StmtResult
10227TreeTransform<Derived>::TransformOMPFlattenDirective(OMPFlattenDirective *D) {
10228 DeclarationNameInfo DirName;
10229 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
10230 D->getDirectiveKind(), DirName, nullptr, D->getBeginLoc());
10231 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
10232 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
10233 return Res;
10234}
10235
10236template <typename Derived>
10237StmtResult
10238TreeTransform<Derived>::TransformOMPFuseDirective(OMPFuseDirective *D) {
10239 DeclarationNameInfo DirName;
10240 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
10241 D->getDirectiveKind(), DirName, nullptr, D->getBeginLoc());
10242 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
10243 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
10244 return Res;
10245}
10246
10247template <typename Derived>
10248StmtResult
10249TreeTransform<Derived>::TransformOMPForDirective(OMPForDirective *D) {
10250 DeclarationNameInfo DirName;
10251 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
10252 OMPD_for, DirName, nullptr, D->getBeginLoc());
10253 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
10254 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
10255 return Res;
10256}
10257
10258template <typename Derived>
10259StmtResult
10260TreeTransform<Derived>::TransformOMPForSimdDirective(OMPForSimdDirective *D) {
10261 DeclarationNameInfo DirName;
10262 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
10263 OMPD_for_simd, DirName, nullptr, D->getBeginLoc());
10264 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
10265 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
10266 return Res;
10267}
10268
10269template <typename Derived>
10270StmtResult
10271TreeTransform<Derived>::TransformOMPSectionsDirective(OMPSectionsDirective *D) {
10272 DeclarationNameInfo DirName;
10273 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
10274 OMPD_sections, DirName, nullptr, D->getBeginLoc());
10275 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
10276 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
10277 return Res;
10278}
10279
10280template <typename Derived>
10281StmtResult
10282TreeTransform<Derived>::TransformOMPSectionDirective(OMPSectionDirective *D) {
10283 DeclarationNameInfo DirName;
10284 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
10285 OMPD_section, DirName, nullptr, D->getBeginLoc());
10286 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
10287 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
10288 return Res;
10289}
10290
10291template <typename Derived>
10292StmtResult
10293TreeTransform<Derived>::TransformOMPScopeDirective(OMPScopeDirective *D) {
10294 DeclarationNameInfo DirName;
10295 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
10296 OMPD_scope, DirName, nullptr, D->getBeginLoc());
10297 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
10298 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
10299 return Res;
10300}
10301
10302template <typename Derived>
10303StmtResult
10304TreeTransform<Derived>::TransformOMPSingleDirective(OMPSingleDirective *D) {
10305 DeclarationNameInfo DirName;
10306 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
10307 OMPD_single, DirName, nullptr, D->getBeginLoc());
10308 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
10309 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
10310 return Res;
10311}
10312
10313template <typename Derived>
10314StmtResult
10315TreeTransform<Derived>::TransformOMPMasterDirective(OMPMasterDirective *D) {
10316 DeclarationNameInfo DirName;
10317 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
10318 OMPD_master, DirName, nullptr, D->getBeginLoc());
10319 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
10320 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
10321 return Res;
10322}
10323
10324template <typename Derived>
10325StmtResult
10326TreeTransform<Derived>::TransformOMPCriticalDirective(OMPCriticalDirective *D) {
10327 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
10328 OMPD_critical, D->getDirectiveName(), nullptr, D->getBeginLoc());
10329 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
10330 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
10331 return Res;
10332}
10333
10334template <typename Derived>
10335StmtResult TreeTransform<Derived>::TransformOMPParallelForDirective(
10336 OMPParallelForDirective *D) {
10337 DeclarationNameInfo DirName;
10338 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
10339 OMPD_parallel_for, DirName, nullptr, D->getBeginLoc());
10340 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
10341 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
10342 return Res;
10343}
10344
10345template <typename Derived>
10346StmtResult TreeTransform<Derived>::TransformOMPParallelForSimdDirective(
10347 OMPParallelForSimdDirective *D) {
10348 DeclarationNameInfo DirName;
10349 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
10350 OMPD_parallel_for_simd, DirName, nullptr, D->getBeginLoc());
10351 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
10352 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
10353 return Res;
10354}
10355
10356template <typename Derived>
10357StmtResult TreeTransform<Derived>::TransformOMPParallelMasterDirective(
10358 OMPParallelMasterDirective *D) {
10359 DeclarationNameInfo DirName;
10360 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
10361 OMPD_parallel_master, DirName, nullptr, D->getBeginLoc());
10362 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
10363 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
10364 return Res;
10365}
10366
10367template <typename Derived>
10368StmtResult TreeTransform<Derived>::TransformOMPParallelMaskedDirective(
10369 OMPParallelMaskedDirective *D) {
10370 DeclarationNameInfo DirName;
10371 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
10372 OMPD_parallel_masked, DirName, nullptr, D->getBeginLoc());
10373 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
10374 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
10375 return Res;
10376}
10377
10378template <typename Derived>
10379StmtResult TreeTransform<Derived>::TransformOMPParallelSectionsDirective(
10380 OMPParallelSectionsDirective *D) {
10381 DeclarationNameInfo DirName;
10382 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
10383 OMPD_parallel_sections, DirName, nullptr, D->getBeginLoc());
10384 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
10385 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
10386 return Res;
10387}
10388
10389template <typename Derived>
10390StmtResult
10391TreeTransform<Derived>::TransformOMPTaskDirective(OMPTaskDirective *D) {
10392 DeclarationNameInfo DirName;
10393 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
10394 OMPD_task, DirName, nullptr, D->getBeginLoc());
10395 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
10396 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
10397 return Res;
10398}
10399
10400template <typename Derived>
10401StmtResult TreeTransform<Derived>::TransformOMPTaskyieldDirective(
10402 OMPTaskyieldDirective *D) {
10403 DeclarationNameInfo DirName;
10404 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
10405 OMPD_taskyield, DirName, nullptr, D->getBeginLoc());
10406 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
10407 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
10408 return Res;
10409}
10410
10411template <typename Derived>
10412StmtResult
10413TreeTransform<Derived>::TransformOMPBarrierDirective(OMPBarrierDirective *D) {
10414 DeclarationNameInfo DirName;
10415 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
10416 OMPD_barrier, DirName, nullptr, D->getBeginLoc());
10417 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
10418 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
10419 return Res;
10420}
10421
10422template <typename Derived>
10423StmtResult
10424TreeTransform<Derived>::TransformOMPTaskwaitDirective(OMPTaskwaitDirective *D) {
10425 DeclarationNameInfo DirName;
10426 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
10427 OMPD_taskwait, DirName, nullptr, D->getBeginLoc());
10428 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
10429 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
10430 return Res;
10431}
10432
10433template <typename Derived>
10434StmtResult
10435TreeTransform<Derived>::TransformOMPAssumeDirective(OMPAssumeDirective *D) {
10436 DeclarationNameInfo DirName;
10437 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
10438 OMPD_assume, DirName, nullptr, D->getBeginLoc());
10439 StmtResult Res = getDerived().TransformOMPInformationalDirective(D);
10440 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
10441 return Res;
10442}
10443
10444template <typename Derived>
10445StmtResult
10446TreeTransform<Derived>::TransformOMPErrorDirective(OMPErrorDirective *D) {
10447 DeclarationNameInfo DirName;
10448 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
10449 OMPD_error, DirName, nullptr, D->getBeginLoc());
10450 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
10451 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
10452 return Res;
10453}
10454
10455template <typename Derived>
10456StmtResult TreeTransform<Derived>::TransformOMPTaskgroupDirective(
10457 OMPTaskgroupDirective *D) {
10458 DeclarationNameInfo DirName;
10459 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
10460 OMPD_taskgroup, DirName, nullptr, D->getBeginLoc());
10461 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
10462 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
10463 return Res;
10464}
10465
10466template <typename Derived>
10467StmtResult
10468TreeTransform<Derived>::TransformOMPFlushDirective(OMPFlushDirective *D) {
10469 DeclarationNameInfo DirName;
10470 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
10471 OMPD_flush, DirName, nullptr, D->getBeginLoc());
10472 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
10473 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
10474 return Res;
10475}
10476
10477template <typename Derived>
10478StmtResult
10479TreeTransform<Derived>::TransformOMPDepobjDirective(OMPDepobjDirective *D) {
10480 DeclarationNameInfo DirName;
10481 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
10482 OMPD_depobj, DirName, nullptr, D->getBeginLoc());
10483 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
10484 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
10485 return Res;
10486}
10487
10488template <typename Derived>
10489StmtResult
10490TreeTransform<Derived>::TransformOMPScanDirective(OMPScanDirective *D) {
10491 DeclarationNameInfo DirName;
10492 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
10493 OMPD_scan, DirName, nullptr, D->getBeginLoc());
10494 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
10495 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
10496 return Res;
10497}
10498
10499template <typename Derived>
10500StmtResult TreeTransform<Derived>::TransformOMPOrderedStandaloneDirective(
10501 OMPOrderedStandaloneDirective *D) {
10502 DeclarationNameInfo DirName;
10503 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
10504 OMPD_ordered_standalone, DirName, nullptr, D->getBeginLoc());
10505 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
10506 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
10507 return Res;
10508}
10509
10510template <typename Derived>
10511StmtResult TreeTransform<Derived>::TransformOMPOrderedBlockAssocDirective(
10512 OMPOrderedBlockAssocDirective *D) {
10513 DeclarationNameInfo DirName;
10514 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
10515 OMPD_ordered_blockassoc, DirName, nullptr, D->getBeginLoc());
10516 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
10517 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
10518 return Res;
10519}
10520
10521template <typename Derived>
10522StmtResult
10523TreeTransform<Derived>::TransformOMPAtomicDirective(OMPAtomicDirective *D) {
10524 DeclarationNameInfo DirName;
10525 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
10526 OMPD_atomic, DirName, nullptr, D->getBeginLoc());
10527 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
10528 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
10529 return Res;
10530}
10531
10532template <typename Derived>
10533StmtResult
10534TreeTransform<Derived>::TransformOMPTargetDirective(OMPTargetDirective *D) {
10535 DeclarationNameInfo DirName;
10536 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
10537 OMPD_target, DirName, nullptr, D->getBeginLoc());
10538 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
10539 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
10540 return Res;
10541}
10542
10543template <typename Derived>
10544StmtResult TreeTransform<Derived>::TransformOMPTargetDataDirective(
10545 OMPTargetDataDirective *D) {
10546 DeclarationNameInfo DirName;
10547 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
10548 OMPD_target_data, DirName, nullptr, D->getBeginLoc());
10549 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
10550 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
10551 return Res;
10552}
10553
10554template <typename Derived>
10555StmtResult TreeTransform<Derived>::TransformOMPTargetEnterDataDirective(
10556 OMPTargetEnterDataDirective *D) {
10557 DeclarationNameInfo DirName;
10558 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
10559 OMPD_target_enter_data, DirName, nullptr, D->getBeginLoc());
10560 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
10561 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
10562 return Res;
10563}
10564
10565template <typename Derived>
10566StmtResult TreeTransform<Derived>::TransformOMPTargetExitDataDirective(
10567 OMPTargetExitDataDirective *D) {
10568 DeclarationNameInfo DirName;
10569 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
10570 OMPD_target_exit_data, DirName, nullptr, D->getBeginLoc());
10571 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
10572 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
10573 return Res;
10574}
10575
10576template <typename Derived>
10577StmtResult TreeTransform<Derived>::TransformOMPTargetParallelDirective(
10578 OMPTargetParallelDirective *D) {
10579 DeclarationNameInfo DirName;
10580 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
10581 OMPD_target_parallel, DirName, nullptr, D->getBeginLoc());
10582 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
10583 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
10584 return Res;
10585}
10586
10587template <typename Derived>
10588StmtResult TreeTransform<Derived>::TransformOMPTargetParallelForDirective(
10589 OMPTargetParallelForDirective *D) {
10590 DeclarationNameInfo DirName;
10591 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
10592 OMPD_target_parallel_for, DirName, nullptr, D->getBeginLoc());
10593 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
10594 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
10595 return Res;
10596}
10597
10598template <typename Derived>
10599StmtResult TreeTransform<Derived>::TransformOMPTargetUpdateDirective(
10600 OMPTargetUpdateDirective *D) {
10601 DeclarationNameInfo DirName;
10602 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
10603 OMPD_target_update, DirName, nullptr, D->getBeginLoc());
10604 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
10605 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
10606 return Res;
10607}
10608
10609template <typename Derived>
10610StmtResult
10611TreeTransform<Derived>::TransformOMPTeamsDirective(OMPTeamsDirective *D) {
10612 DeclarationNameInfo DirName;
10613 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
10614 OMPD_teams, DirName, nullptr, D->getBeginLoc());
10615 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
10616 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
10617 return Res;
10618}
10619
10620template <typename Derived>
10621StmtResult TreeTransform<Derived>::TransformOMPCancellationPointDirective(
10622 OMPCancellationPointDirective *D) {
10623 DeclarationNameInfo DirName;
10624 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
10625 OMPD_cancellation_point, DirName, nullptr, D->getBeginLoc());
10626 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
10627 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
10628 return Res;
10629}
10630
10631template <typename Derived>
10632StmtResult
10633TreeTransform<Derived>::TransformOMPCancelDirective(OMPCancelDirective *D) {
10634 DeclarationNameInfo DirName;
10635 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
10636 OMPD_cancel, DirName, nullptr, D->getBeginLoc());
10637 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
10638 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
10639 return Res;
10640}
10641
10642template <typename Derived>
10643StmtResult
10644TreeTransform<Derived>::TransformOMPTaskLoopDirective(OMPTaskLoopDirective *D) {
10645 DeclarationNameInfo DirName;
10646 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
10647 OMPD_taskloop, DirName, nullptr, D->getBeginLoc());
10648 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
10649 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
10650 return Res;
10651}
10652
10653template <typename Derived>
10654StmtResult TreeTransform<Derived>::TransformOMPTaskLoopSimdDirective(
10655 OMPTaskLoopSimdDirective *D) {
10656 DeclarationNameInfo DirName;
10657 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
10658 OMPD_taskloop_simd, DirName, nullptr, D->getBeginLoc());
10659 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
10660 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
10661 return Res;
10662}
10663
10664template <typename Derived>
10665StmtResult TreeTransform<Derived>::TransformOMPMasterTaskLoopDirective(
10666 OMPMasterTaskLoopDirective *D) {
10667 DeclarationNameInfo DirName;
10668 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
10669 OMPD_master_taskloop, DirName, nullptr, D->getBeginLoc());
10670 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
10671 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
10672 return Res;
10673}
10674
10675template <typename Derived>
10676StmtResult TreeTransform<Derived>::TransformOMPMaskedTaskLoopDirective(
10677 OMPMaskedTaskLoopDirective *D) {
10678 DeclarationNameInfo DirName;
10679 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
10680 OMPD_masked_taskloop, DirName, nullptr, D->getBeginLoc());
10681 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
10682 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
10683 return Res;
10684}
10685
10686template <typename Derived>
10687StmtResult TreeTransform<Derived>::TransformOMPMasterTaskLoopSimdDirective(
10688 OMPMasterTaskLoopSimdDirective *D) {
10689 DeclarationNameInfo DirName;
10690 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
10691 OMPD_master_taskloop_simd, DirName, nullptr, D->getBeginLoc());
10692 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
10693 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
10694 return Res;
10695}
10696
10697template <typename Derived>
10698StmtResult TreeTransform<Derived>::TransformOMPMaskedTaskLoopSimdDirective(
10699 OMPMaskedTaskLoopSimdDirective *D) {
10700 DeclarationNameInfo DirName;
10701 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
10702 OMPD_masked_taskloop_simd, DirName, nullptr, D->getBeginLoc());
10703 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
10704 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
10705 return Res;
10706}
10707
10708template <typename Derived>
10709StmtResult TreeTransform<Derived>::TransformOMPParallelMasterTaskLoopDirective(
10710 OMPParallelMasterTaskLoopDirective *D) {
10711 DeclarationNameInfo DirName;
10712 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
10713 OMPD_parallel_master_taskloop, DirName, nullptr, D->getBeginLoc());
10714 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
10715 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
10716 return Res;
10717}
10718
10719template <typename Derived>
10720StmtResult TreeTransform<Derived>::TransformOMPParallelMaskedTaskLoopDirective(
10721 OMPParallelMaskedTaskLoopDirective *D) {
10722 DeclarationNameInfo DirName;
10723 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
10724 OMPD_parallel_masked_taskloop, DirName, nullptr, D->getBeginLoc());
10725 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
10726 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
10727 return Res;
10728}
10729
10730template <typename Derived>
10731StmtResult
10732TreeTransform<Derived>::TransformOMPParallelMasterTaskLoopSimdDirective(
10733 OMPParallelMasterTaskLoopSimdDirective *D) {
10734 DeclarationNameInfo DirName;
10735 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
10736 OMPD_parallel_master_taskloop_simd, DirName, nullptr, D->getBeginLoc());
10737 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
10738 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
10739 return Res;
10740}
10741
10742template <typename Derived>
10743StmtResult
10744TreeTransform<Derived>::TransformOMPParallelMaskedTaskLoopSimdDirective(
10745 OMPParallelMaskedTaskLoopSimdDirective *D) {
10746 DeclarationNameInfo DirName;
10747 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
10748 OMPD_parallel_masked_taskloop_simd, DirName, nullptr, D->getBeginLoc());
10749 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
10750 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
10751 return Res;
10752}
10753
10754template <typename Derived>
10755StmtResult TreeTransform<Derived>::TransformOMPDistributeDirective(
10756 OMPDistributeDirective *D) {
10757 DeclarationNameInfo DirName;
10758 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
10759 OMPD_distribute, DirName, nullptr, D->getBeginLoc());
10760 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
10761 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
10762 return Res;
10763}
10764
10765template <typename Derived>
10766StmtResult TreeTransform<Derived>::TransformOMPDistributeParallelForDirective(
10767 OMPDistributeParallelForDirective *D) {
10768 DeclarationNameInfo DirName;
10769 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
10770 OMPD_distribute_parallel_for, DirName, nullptr, D->getBeginLoc());
10771 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
10772 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
10773 return Res;
10774}
10775
10776template <typename Derived>
10777StmtResult
10778TreeTransform<Derived>::TransformOMPDistributeParallelForSimdDirective(
10779 OMPDistributeParallelForSimdDirective *D) {
10780 DeclarationNameInfo DirName;
10781 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
10782 OMPD_distribute_parallel_for_simd, DirName, nullptr, D->getBeginLoc());
10783 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
10784 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
10785 return Res;
10786}
10787
10788template <typename Derived>
10789StmtResult TreeTransform<Derived>::TransformOMPDistributeSimdDirective(
10790 OMPDistributeSimdDirective *D) {
10791 DeclarationNameInfo DirName;
10792 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
10793 OMPD_distribute_simd, DirName, nullptr, D->getBeginLoc());
10794 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
10795 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
10796 return Res;
10797}
10798
10799template <typename Derived>
10800StmtResult TreeTransform<Derived>::TransformOMPTargetParallelForSimdDirective(
10801 OMPTargetParallelForSimdDirective *D) {
10802 DeclarationNameInfo DirName;
10803 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
10804 OMPD_target_parallel_for_simd, DirName, nullptr, D->getBeginLoc());
10805 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
10806 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
10807 return Res;
10808}
10809
10810template <typename Derived>
10811StmtResult TreeTransform<Derived>::TransformOMPTargetSimdDirective(
10812 OMPTargetSimdDirective *D) {
10813 DeclarationNameInfo DirName;
10814 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
10815 OMPD_target_simd, DirName, nullptr, D->getBeginLoc());
10816 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
10817 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
10818 return Res;
10819}
10820
10821template <typename Derived>
10822StmtResult TreeTransform<Derived>::TransformOMPTeamsDistributeDirective(
10823 OMPTeamsDistributeDirective *D) {
10824 DeclarationNameInfo DirName;
10825 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
10826 OMPD_teams_distribute, DirName, nullptr, D->getBeginLoc());
10827 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
10828 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
10829 return Res;
10830}
10831
10832template <typename Derived>
10833StmtResult TreeTransform<Derived>::TransformOMPTeamsDistributeSimdDirective(
10834 OMPTeamsDistributeSimdDirective *D) {
10835 DeclarationNameInfo DirName;
10836 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
10837 OMPD_teams_distribute_simd, DirName, nullptr, D->getBeginLoc());
10838 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
10839 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
10840 return Res;
10841}
10842
10843template <typename Derived>
10844StmtResult TreeTransform<Derived>::TransformOMPTeamsDistributeParallelForSimdDirective(
10845 OMPTeamsDistributeParallelForSimdDirective *D) {
10846 DeclarationNameInfo DirName;
10847 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
10848 OMPD_teams_distribute_parallel_for_simd, DirName, nullptr,
10849 D->getBeginLoc());
10850 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
10851 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
10852 return Res;
10853}
10854
10855template <typename Derived>
10856StmtResult TreeTransform<Derived>::TransformOMPTeamsDistributeParallelForDirective(
10857 OMPTeamsDistributeParallelForDirective *D) {
10858 DeclarationNameInfo DirName;
10859 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
10860 OMPD_teams_distribute_parallel_for, DirName, nullptr, D->getBeginLoc());
10861 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
10862 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
10863 return Res;
10864}
10865
10866template <typename Derived>
10867StmtResult TreeTransform<Derived>::TransformOMPTargetTeamsDirective(
10868 OMPTargetTeamsDirective *D) {
10869 DeclarationNameInfo DirName;
10870 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
10871 OMPD_target_teams, DirName, nullptr, D->getBeginLoc());
10872 auto Res = getDerived().TransformOMPExecutableDirective(D);
10873 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
10874 return Res;
10875}
10876
10877template <typename Derived>
10878StmtResult TreeTransform<Derived>::TransformOMPTargetTeamsDistributeDirective(
10879 OMPTargetTeamsDistributeDirective *D) {
10880 DeclarationNameInfo DirName;
10881 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
10882 OMPD_target_teams_distribute, DirName, nullptr, D->getBeginLoc());
10883 auto Res = getDerived().TransformOMPExecutableDirective(D);
10884 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
10885 return Res;
10886}
10887
10888template <typename Derived>
10889StmtResult
10890TreeTransform<Derived>::TransformOMPTargetTeamsDistributeParallelForDirective(
10891 OMPTargetTeamsDistributeParallelForDirective *D) {
10892 DeclarationNameInfo DirName;
10893 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
10894 OMPD_target_teams_distribute_parallel_for, DirName, nullptr,
10895 D->getBeginLoc());
10896 auto Res = getDerived().TransformOMPExecutableDirective(D);
10897 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
10898 return Res;
10899}
10900
10901template <typename Derived>
10902StmtResult TreeTransform<Derived>::
10903 TransformOMPTargetTeamsDistributeParallelForSimdDirective(
10904 OMPTargetTeamsDistributeParallelForSimdDirective *D) {
10905 DeclarationNameInfo DirName;
10906 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
10907 OMPD_target_teams_distribute_parallel_for_simd, DirName, nullptr,
10908 D->getBeginLoc());
10909 auto Res = getDerived().TransformOMPExecutableDirective(D);
10910 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
10911 return Res;
10912}
10913
10914template <typename Derived>
10915StmtResult
10916TreeTransform<Derived>::TransformOMPTargetTeamsDistributeSimdDirective(
10917 OMPTargetTeamsDistributeSimdDirective *D) {
10918 DeclarationNameInfo DirName;
10919 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
10920 OMPD_target_teams_distribute_simd, DirName, nullptr, D->getBeginLoc());
10921 auto Res = getDerived().TransformOMPExecutableDirective(D);
10922 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
10923 return Res;
10924}
10925
10926template <typename Derived>
10927StmtResult
10928TreeTransform<Derived>::TransformOMPInteropDirective(OMPInteropDirective *D) {
10929 DeclarationNameInfo DirName;
10930 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
10931 OMPD_interop, DirName, nullptr, D->getBeginLoc());
10932 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
10933 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
10934 return Res;
10935}
10936
10937template <typename Derived>
10938StmtResult
10939TreeTransform<Derived>::TransformOMPDispatchDirective(OMPDispatchDirective *D) {
10940 DeclarationNameInfo DirName;
10941 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
10942 OMPD_dispatch, DirName, nullptr, D->getBeginLoc());
10943 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
10944 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
10945 return Res;
10946}
10947
10948template <typename Derived>
10949StmtResult
10950TreeTransform<Derived>::TransformOMPMaskedDirective(OMPMaskedDirective *D) {
10951 DeclarationNameInfo DirName;
10952 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
10953 OMPD_masked, DirName, nullptr, D->getBeginLoc());
10954 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
10955 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
10956 return Res;
10957}
10958
10959template <typename Derived>
10960StmtResult TreeTransform<Derived>::TransformOMPGenericLoopDirective(
10961 OMPGenericLoopDirective *D) {
10962 DeclarationNameInfo DirName;
10963 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
10964 OMPD_loop, DirName, nullptr, D->getBeginLoc());
10965 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
10966 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
10967 return Res;
10968}
10969
10970template <typename Derived>
10971StmtResult TreeTransform<Derived>::TransformOMPTeamsGenericLoopDirective(
10972 OMPTeamsGenericLoopDirective *D) {
10973 DeclarationNameInfo DirName;
10974 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
10975 OMPD_teams_loop, DirName, nullptr, D->getBeginLoc());
10976 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
10977 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
10978 return Res;
10979}
10980
10981template <typename Derived>
10982StmtResult TreeTransform<Derived>::TransformOMPTargetTeamsGenericLoopDirective(
10983 OMPTargetTeamsGenericLoopDirective *D) {
10984 DeclarationNameInfo DirName;
10985 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
10986 OMPD_target_teams_loop, DirName, nullptr, D->getBeginLoc());
10987 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
10988 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
10989 return Res;
10990}
10991
10992template <typename Derived>
10993StmtResult TreeTransform<Derived>::TransformOMPParallelGenericLoopDirective(
10994 OMPParallelGenericLoopDirective *D) {
10995 DeclarationNameInfo DirName;
10996 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
10997 OMPD_parallel_loop, DirName, nullptr, D->getBeginLoc());
10998 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
10999 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
11000 return Res;
11001}
11002
11003template <typename Derived>
11004StmtResult
11005TreeTransform<Derived>::TransformOMPTargetParallelGenericLoopDirective(
11006 OMPTargetParallelGenericLoopDirective *D) {
11007 DeclarationNameInfo DirName;
11008 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
11009 OMPD_target_parallel_loop, DirName, nullptr, D->getBeginLoc());
11010 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
11011 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
11012 return Res;
11013}
11014
11015template <typename Derived>
11016StmtResult TreeTransform<Derived>::TransformOMPTargetGenericLoopDirective(
11017 OMPTargetGenericLoopDirective *D) {
11018 DeclarationNameInfo DirName;
11019 getDerived().getSema().OpenMP().StartOpenMPDSABlock(
11020 OMPD_target_loop, DirName, nullptr, D->getBeginLoc());
11021 StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
11022 getDerived().getSema().OpenMP().EndOpenMPDSABlock(Res.get());
11023 return Res;
11024}
11025
11026//===----------------------------------------------------------------------===//
11027// OpenMP clause transformation
11028//===----------------------------------------------------------------------===//
11029template <typename Derived>
11030OMPClause *TreeTransform<Derived>::TransformOMPIfClause(OMPIfClause *C) {
11031 ExprResult Cond = getDerived().TransformExpr(C->getCondition());
11032 if (Cond.isInvalid())
11033 return nullptr;
11034 return getDerived().RebuildOMPIfClause(
11035 C->getNameModifier(), Cond.get(), C->getBeginLoc(), C->getLParenLoc(),
11036 C->getNameModifierLoc(), C->getColonLoc(), C->getEndLoc());
11037}
11038
11039template <typename Derived>
11040OMPClause *TreeTransform<Derived>::TransformOMPFinalClause(OMPFinalClause *C) {
11041 ExprResult Cond = getDerived().TransformExpr(C->getCondition());
11042 if (Cond.isInvalid())
11043 return nullptr;
11044 return getDerived().RebuildOMPFinalClause(Cond.get(), C->getBeginLoc(),
11045 C->getLParenLoc(), C->getEndLoc());
11046}
11047
11048template <typename Derived>
11049OMPClause *
11050TreeTransform<Derived>::TransformOMPNumThreadsClause(OMPNumThreadsClause *C) {
11051 llvm::SmallVector<Expr *, 3> Vars;
11052 Vars.reserve(N: C->varlist_size());
11053 for (auto *VE : C->varlist()) {
11054 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(Val: VE));
11055 if (EVar.isInvalid())
11056 return nullptr;
11057 Vars.push_back(Elt: EVar.get());
11058 }
11059 Expr *DimsModifierExpr = C->getDimsModifierExpr();
11060 if (DimsModifierExpr) {
11061 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(Val: DimsModifierExpr));
11062 if (EVar.isInvalid())
11063 return nullptr;
11064 DimsModifierExpr = EVar.get();
11065 }
11066 return getDerived().RebuildOMPNumThreadsClause(
11067 Vars, C->getPrescriptivenessModifier(),
11068 C->getPrescriptivenessModifierLoc(), C->getDimsModifier(),
11069 DimsModifierExpr, C->getDimsModifierLoc(), C->getBeginLoc(),
11070 C->getLParenLoc(), C->getEndLoc());
11071}
11072
11073template <typename Derived>
11074OMPClause *
11075TreeTransform<Derived>::TransformOMPSafelenClause(OMPSafelenClause *C) {
11076 ExprResult E = getDerived().TransformExpr(C->getSafelen());
11077 if (E.isInvalid())
11078 return nullptr;
11079 return getDerived().RebuildOMPSafelenClause(
11080 E.get(), C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
11081}
11082
11083template <typename Derived>
11084OMPClause *
11085TreeTransform<Derived>::TransformOMPAllocatorClause(OMPAllocatorClause *C) {
11086 ExprResult E = getDerived().TransformExpr(C->getAllocator());
11087 if (E.isInvalid())
11088 return nullptr;
11089 return getDerived().RebuildOMPAllocatorClause(
11090 E.get(), C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
11091}
11092
11093template <typename Derived>
11094OMPClause *
11095TreeTransform<Derived>::TransformOMPSimdlenClause(OMPSimdlenClause *C) {
11096 ExprResult E = getDerived().TransformExpr(C->getSimdlen());
11097 if (E.isInvalid())
11098 return nullptr;
11099 return getDerived().RebuildOMPSimdlenClause(
11100 E.get(), C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
11101}
11102
11103template <typename Derived>
11104OMPClause *TreeTransform<Derived>::TransformOMPSizesClause(OMPSizesClause *C) {
11105 SmallVector<Expr *, 4> TransformedSizes;
11106 TransformedSizes.reserve(N: C->getNumSizes());
11107 bool Changed = false;
11108 for (Expr *E : C->getSizesRefs()) {
11109 if (!E) {
11110 TransformedSizes.push_back(Elt: nullptr);
11111 continue;
11112 }
11113
11114 ExprResult T = getDerived().TransformExpr(E);
11115 if (T.isInvalid())
11116 return nullptr;
11117 if (E != T.get())
11118 Changed = true;
11119 TransformedSizes.push_back(Elt: T.get());
11120 }
11121
11122 if (!Changed && !getDerived().AlwaysRebuild())
11123 return C;
11124 return RebuildOMPSizesClause(Sizes: TransformedSizes, StartLoc: C->getBeginLoc(),
11125 LParenLoc: C->getLParenLoc(), EndLoc: C->getEndLoc());
11126}
11127
11128template <typename Derived>
11129OMPClause *
11130TreeTransform<Derived>::TransformOMPCountsClause(OMPCountsClause *C) {
11131 SmallVector<Expr *, 4> TransformedCounts;
11132 TransformedCounts.reserve(N: C->getNumCounts());
11133 for (Expr *E : C->getCountsRefs()) {
11134 if (!E) {
11135 TransformedCounts.push_back(Elt: nullptr);
11136 continue;
11137 }
11138
11139 ExprResult T = getDerived().TransformExpr(E);
11140 if (T.isInvalid())
11141 return nullptr;
11142 TransformedCounts.push_back(Elt: T.get());
11143 }
11144
11145 return RebuildOMPCountsClause(Counts: TransformedCounts, StartLoc: C->getBeginLoc(),
11146 LParenLoc: C->getLParenLoc(), EndLoc: C->getEndLoc(),
11147 FillIdx: C->getOmpFillIndex(), FillLoc: C->getOmpFillLoc());
11148}
11149
11150template <typename Derived>
11151OMPClause *
11152TreeTransform<Derived>::TransformOMPPermutationClause(OMPPermutationClause *C) {
11153 SmallVector<Expr *> TransformedArgs;
11154 TransformedArgs.reserve(N: C->getNumLoops());
11155 bool Changed = false;
11156 for (Expr *E : C->getArgsRefs()) {
11157 if (!E) {
11158 TransformedArgs.push_back(Elt: nullptr);
11159 continue;
11160 }
11161
11162 ExprResult T = getDerived().TransformExpr(E);
11163 if (T.isInvalid())
11164 return nullptr;
11165 if (E != T.get())
11166 Changed = true;
11167 TransformedArgs.push_back(Elt: T.get());
11168 }
11169
11170 if (!Changed && !getDerived().AlwaysRebuild())
11171 return C;
11172 return RebuildOMPPermutationClause(PermExprs: TransformedArgs, StartLoc: C->getBeginLoc(),
11173 LParenLoc: C->getLParenLoc(), EndLoc: C->getEndLoc());
11174}
11175
11176template <typename Derived>
11177OMPClause *TreeTransform<Derived>::TransformOMPFullClause(OMPFullClause *C) {
11178 if (!getDerived().AlwaysRebuild())
11179 return C;
11180 return RebuildOMPFullClause(StartLoc: C->getBeginLoc(), EndLoc: C->getEndLoc());
11181}
11182
11183template <typename Derived>
11184OMPClause *
11185TreeTransform<Derived>::TransformOMPPartialClause(OMPPartialClause *C) {
11186 ExprResult T = getDerived().TransformExpr(C->getFactor());
11187 if (T.isInvalid())
11188 return nullptr;
11189 Expr *Factor = T.get();
11190 bool Changed = Factor != C->getFactor();
11191
11192 if (!Changed && !getDerived().AlwaysRebuild())
11193 return C;
11194 return RebuildOMPPartialClause(Factor, StartLoc: C->getBeginLoc(), LParenLoc: C->getLParenLoc(),
11195 EndLoc: C->getEndLoc());
11196}
11197
11198template <typename Derived>
11199OMPClause *TreeTransform<Derived>::TransformOMPDepthClause(OMPDepthClause *C) {
11200 ExprResult T = getDerived().TransformExpr(C->getDepth());
11201 if (T.isInvalid())
11202 return nullptr;
11203 Expr *Depth = T.get();
11204 bool Changed = Depth != C->getDepth();
11205
11206 if (!Changed && !getDerived().AlwaysRebuild())
11207 return C;
11208 return RebuildOMPDepthClause(Depth, StartLoc: C->getBeginLoc(), LParenLoc: C->getLParenLoc(),
11209 EndLoc: C->getEndLoc());
11210}
11211
11212template <typename Derived>
11213OMPClause *
11214TreeTransform<Derived>::TransformOMPLoopRangeClause(OMPLoopRangeClause *C) {
11215 ExprResult F = getDerived().TransformExpr(C->getFirst());
11216 if (F.isInvalid())
11217 return nullptr;
11218
11219 ExprResult Cn = getDerived().TransformExpr(C->getCount());
11220 if (Cn.isInvalid())
11221 return nullptr;
11222
11223 Expr *First = F.get();
11224 Expr *Count = Cn.get();
11225
11226 bool Changed = (First != C->getFirst()) || (Count != C->getCount());
11227
11228 // If no changes and AlwaysRebuild() is false, return the original clause
11229 if (!Changed && !getDerived().AlwaysRebuild())
11230 return C;
11231
11232 return RebuildOMPLoopRangeClause(First, Count, StartLoc: C->getBeginLoc(),
11233 LParenLoc: C->getLParenLoc(), FirstLoc: C->getFirstLoc(),
11234 CountLoc: C->getCountLoc(), EndLoc: C->getEndLoc());
11235}
11236
11237template <typename Derived>
11238OMPClause *
11239TreeTransform<Derived>::TransformOMPCollapseClause(OMPCollapseClause *C) {
11240 ExprResult E = getDerived().TransformExpr(C->getNumForLoops());
11241 if (E.isInvalid())
11242 return nullptr;
11243 return getDerived().RebuildOMPCollapseClause(
11244 E.get(), C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
11245}
11246
11247template <typename Derived>
11248OMPClause *
11249TreeTransform<Derived>::TransformOMPDefaultClause(OMPDefaultClause *C) {
11250 return getDerived().RebuildOMPDefaultClause(
11251 C->getDefaultKind(), C->getDefaultKindKwLoc(), C->getDefaultVC(),
11252 C->getDefaultVCLoc(), C->getBeginLoc(), C->getLParenLoc(),
11253 C->getEndLoc());
11254}
11255
11256template <typename Derived>
11257OMPClause *
11258TreeTransform<Derived>::TransformOMPThreadsetClause(OMPThreadsetClause *C) {
11259 // No need to rebuild this clause, no template-dependent parameters.
11260 return C;
11261}
11262
11263template <typename Derived>
11264OMPClause *
11265TreeTransform<Derived>::TransformOMPTransparentClause(OMPTransparentClause *C) {
11266 Expr *Impex = C->getImpexType();
11267 ExprResult TransformedImpex = getDerived().TransformExpr(Impex);
11268
11269 if (TransformedImpex.isInvalid())
11270 return nullptr;
11271
11272 return getDerived().RebuildOMPTransparentClause(
11273 TransformedImpex.get(), C->getBeginLoc(), C->getLParenLoc(),
11274 C->getEndLoc());
11275}
11276
11277template <typename Derived>
11278OMPClause *
11279TreeTransform<Derived>::TransformOMPProcBindClause(OMPProcBindClause *C) {
11280 return getDerived().RebuildOMPProcBindClause(
11281 C->getProcBindKind(), C->getProcBindKindKwLoc(), C->getBeginLoc(),
11282 C->getLParenLoc(), C->getEndLoc());
11283}
11284
11285template <typename Derived>
11286OMPClause *
11287TreeTransform<Derived>::TransformOMPScheduleClause(OMPScheduleClause *C) {
11288 ExprResult E = getDerived().TransformExpr(C->getChunkSize());
11289 if (E.isInvalid())
11290 return nullptr;
11291 return getDerived().RebuildOMPScheduleClause(
11292 C->getFirstScheduleModifier(), C->getSecondScheduleModifier(),
11293 C->getScheduleKind(), E.get(), C->getBeginLoc(), C->getLParenLoc(),
11294 C->getFirstScheduleModifierLoc(), C->getSecondScheduleModifierLoc(),
11295 C->getScheduleKindLoc(), C->getCommaLoc(), C->getEndLoc());
11296}
11297
11298template <typename Derived>
11299OMPClause *
11300TreeTransform<Derived>::TransformOMPOrderedClause(OMPOrderedClause *C) {
11301 ExprResult E;
11302 if (auto *Num = C->getNumForLoops()) {
11303 E = getDerived().TransformExpr(Num);
11304 if (E.isInvalid())
11305 return nullptr;
11306 }
11307 return getDerived().RebuildOMPOrderedClause(C->getBeginLoc(), C->getEndLoc(),
11308 C->getLParenLoc(), E.get());
11309}
11310
11311template <typename Derived>
11312OMPClause *
11313TreeTransform<Derived>::TransformOMPDetachClause(OMPDetachClause *C) {
11314 ExprResult E;
11315 if (Expr *Evt = C->getEventHandler()) {
11316 E = getDerived().TransformExpr(Evt);
11317 if (E.isInvalid())
11318 return nullptr;
11319 }
11320 return getDerived().RebuildOMPDetachClause(E.get(), C->getBeginLoc(),
11321 C->getLParenLoc(), C->getEndLoc());
11322}
11323
11324template <typename Derived>
11325OMPClause *
11326TreeTransform<Derived>::TransformOMPNowaitClause(OMPNowaitClause *C) {
11327 ExprResult Cond;
11328 if (auto *Condition = C->getCondition()) {
11329 Cond = getDerived().TransformExpr(Condition);
11330 if (Cond.isInvalid())
11331 return nullptr;
11332 }
11333 return getDerived().RebuildOMPNowaitClause(Cond.get(), C->getBeginLoc(),
11334 C->getLParenLoc(), C->getEndLoc());
11335}
11336
11337template <typename Derived>
11338OMPClause *
11339TreeTransform<Derived>::TransformOMPUntiedClause(OMPUntiedClause *C) {
11340 // No need to rebuild this clause, no template-dependent parameters.
11341 return C;
11342}
11343
11344template <typename Derived>
11345OMPClause *
11346TreeTransform<Derived>::TransformOMPMergeableClause(OMPMergeableClause *C) {
11347 // No need to rebuild this clause, no template-dependent parameters.
11348 return C;
11349}
11350
11351template <typename Derived>
11352OMPClause *TreeTransform<Derived>::TransformOMPReadClause(OMPReadClause *C) {
11353 // No need to rebuild this clause, no template-dependent parameters.
11354 return C;
11355}
11356
11357template <typename Derived>
11358OMPClause *TreeTransform<Derived>::TransformOMPWriteClause(OMPWriteClause *C) {
11359 // No need to rebuild this clause, no template-dependent parameters.
11360 return C;
11361}
11362
11363template <typename Derived>
11364OMPClause *
11365TreeTransform<Derived>::TransformOMPUpdateClause(OMPUpdateClause *C) {
11366 // No need to rebuild this clause, no template-dependent parameters.
11367 return C;
11368}
11369
11370template <typename Derived>
11371OMPClause *TreeTransform<Derived>::TransformOMPUpdateDependObjectsClause(
11372 OMPUpdateDependObjectsClause *C) {
11373 // No need to rebuild this clause, no template-dependent parameters.
11374 return C;
11375}
11376
11377template <typename Derived>
11378OMPClause *
11379TreeTransform<Derived>::TransformOMPCaptureClause(OMPCaptureClause *C) {
11380 // No need to rebuild this clause, no template-dependent parameters.
11381 return C;
11382}
11383
11384template <typename Derived>
11385OMPClause *
11386TreeTransform<Derived>::TransformOMPCompareClause(OMPCompareClause *C) {
11387 // No need to rebuild this clause, no template-dependent parameters.
11388 return C;
11389}
11390
11391template <typename Derived>
11392OMPClause *TreeTransform<Derived>::TransformOMPFailClause(OMPFailClause *C) {
11393 // No need to rebuild this clause, no template-dependent parameters.
11394 return C;
11395}
11396
11397template <typename Derived>
11398OMPClause *
11399TreeTransform<Derived>::TransformOMPAbsentClause(OMPAbsentClause *C) {
11400 return C;
11401}
11402
11403template <typename Derived>
11404OMPClause *TreeTransform<Derived>::TransformOMPHoldsClause(OMPHoldsClause *C) {
11405 ExprResult E = getDerived().TransformExpr(C->getExpr());
11406 if (E.isInvalid())
11407 return nullptr;
11408 return getDerived().RebuildOMPHoldsClause(E.get(), C->getBeginLoc(),
11409 C->getLParenLoc(), C->getEndLoc());
11410}
11411
11412template <typename Derived>
11413OMPClause *
11414TreeTransform<Derived>::TransformOMPContainsClause(OMPContainsClause *C) {
11415 return C;
11416}
11417
11418template <typename Derived>
11419OMPClause *
11420TreeTransform<Derived>::TransformOMPNoOpenMPClause(OMPNoOpenMPClause *C) {
11421 return C;
11422}
11423template <typename Derived>
11424OMPClause *TreeTransform<Derived>::TransformOMPNoOpenMPRoutinesClause(
11425 OMPNoOpenMPRoutinesClause *C) {
11426 return C;
11427}
11428template <typename Derived>
11429OMPClause *TreeTransform<Derived>::TransformOMPNoOpenMPConstructsClause(
11430 OMPNoOpenMPConstructsClause *C) {
11431 return C;
11432}
11433template <typename Derived>
11434OMPClause *TreeTransform<Derived>::TransformOMPNoParallelismClause(
11435 OMPNoParallelismClause *C) {
11436 return C;
11437}
11438
11439template <typename Derived>
11440OMPClause *
11441TreeTransform<Derived>::TransformOMPSeqCstClause(OMPSeqCstClause *C) {
11442 // No need to rebuild this clause, no template-dependent parameters.
11443 return C;
11444}
11445
11446template <typename Derived>
11447OMPClause *
11448TreeTransform<Derived>::TransformOMPAcqRelClause(OMPAcqRelClause *C) {
11449 // No need to rebuild this clause, no template-dependent parameters.
11450 return C;
11451}
11452
11453template <typename Derived>
11454OMPClause *
11455TreeTransform<Derived>::TransformOMPAcquireClause(OMPAcquireClause *C) {
11456 // No need to rebuild this clause, no template-dependent parameters.
11457 return C;
11458}
11459
11460template <typename Derived>
11461OMPClause *
11462TreeTransform<Derived>::TransformOMPReleaseClause(OMPReleaseClause *C) {
11463 // No need to rebuild this clause, no template-dependent parameters.
11464 return C;
11465}
11466
11467template <typename Derived>
11468OMPClause *
11469TreeTransform<Derived>::TransformOMPRelaxedClause(OMPRelaxedClause *C) {
11470 // No need to rebuild this clause, no template-dependent parameters.
11471 return C;
11472}
11473
11474template <typename Derived>
11475OMPClause *TreeTransform<Derived>::TransformOMPWeakClause(OMPWeakClause *C) {
11476 // No need to rebuild this clause, no template-dependent parameters.
11477 return C;
11478}
11479
11480template <typename Derived>
11481OMPClause *
11482TreeTransform<Derived>::TransformOMPThreadsClause(OMPThreadsClause *C) {
11483 // No need to rebuild this clause, no template-dependent parameters.
11484 return C;
11485}
11486
11487template <typename Derived>
11488OMPClause *TreeTransform<Derived>::TransformOMPSIMDClause(OMPSIMDClause *C) {
11489 // No need to rebuild this clause, no template-dependent parameters.
11490 return C;
11491}
11492
11493template <typename Derived>
11494OMPClause *
11495TreeTransform<Derived>::TransformOMPNogroupClause(OMPNogroupClause *C) {
11496 // No need to rebuild this clause, no template-dependent parameters.
11497 return C;
11498}
11499
11500template <typename Derived>
11501OMPClause *TreeTransform<Derived>::TransformOMPInitClause(OMPInitClause *C) {
11502 ExprResult IVR = getDerived().TransformExpr(C->getInteropVar());
11503 if (IVR.isInvalid())
11504 return nullptr;
11505
11506 OMPInteropInfo InteropInfo(C->getIsTarget(), C->getIsTargetSync());
11507 for (OMPInitClause::PrefView P : C->prefs()) {
11508 Expr *NewFr = nullptr;
11509 if (P.Fr) {
11510 ExprResult ER = getDerived().TransformExpr(P.Fr);
11511 if (ER.isInvalid())
11512 return nullptr;
11513 NewFr = ER.get();
11514 }
11515 SmallVector<Expr *, 2> NewAttrs;
11516 NewAttrs.reserve(N: P.Attrs.size());
11517 for (Expr *A : P.Attrs) {
11518 ExprResult ER = getDerived().TransformExpr(A);
11519 if (ER.isInvalid())
11520 return nullptr;
11521 NewAttrs.push_back(Elt: ER.get());
11522 }
11523 InteropInfo.Prefs.emplace_back(Args&: NewFr, Args: std::move(NewAttrs));
11524 }
11525 InteropInfo.HasPreferAttrs = C->hasPreferAttrs();
11526 return getDerived().RebuildOMPInitClause(IVR.get(), InteropInfo,
11527 C->getBeginLoc(), C->getLParenLoc(),
11528 C->getVarLoc(), C->getEndLoc());
11529}
11530
11531template <typename Derived>
11532OMPClause *TreeTransform<Derived>::TransformOMPUseClause(OMPUseClause *C) {
11533 ExprResult ER = getDerived().TransformExpr(C->getInteropVar());
11534 if (ER.isInvalid())
11535 return nullptr;
11536 return getDerived().RebuildOMPUseClause(ER.get(), C->getBeginLoc(),
11537 C->getLParenLoc(), C->getVarLoc(),
11538 C->getEndLoc());
11539}
11540
11541template <typename Derived>
11542OMPClause *
11543TreeTransform<Derived>::TransformOMPDestroyClause(OMPDestroyClause *C) {
11544 ExprResult ER;
11545 if (Expr *IV = C->getInteropVar()) {
11546 ER = getDerived().TransformExpr(IV);
11547 if (ER.isInvalid())
11548 return nullptr;
11549 }
11550 return getDerived().RebuildOMPDestroyClause(ER.get(), C->getBeginLoc(),
11551 C->getLParenLoc(), C->getVarLoc(),
11552 C->getEndLoc());
11553}
11554
11555template <typename Derived>
11556OMPClause *
11557TreeTransform<Derived>::TransformOMPNovariantsClause(OMPNovariantsClause *C) {
11558 ExprResult Cond = getDerived().TransformExpr(C->getCondition());
11559 if (Cond.isInvalid())
11560 return nullptr;
11561 return getDerived().RebuildOMPNovariantsClause(
11562 Cond.get(), C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
11563}
11564
11565template <typename Derived>
11566OMPClause *
11567TreeTransform<Derived>::TransformOMPNocontextClause(OMPNocontextClause *C) {
11568 ExprResult Cond = getDerived().TransformExpr(C->getCondition());
11569 if (Cond.isInvalid())
11570 return nullptr;
11571 return getDerived().RebuildOMPNocontextClause(
11572 Cond.get(), C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
11573}
11574
11575template <typename Derived>
11576OMPClause *
11577TreeTransform<Derived>::TransformOMPFilterClause(OMPFilterClause *C) {
11578 ExprResult ThreadID = getDerived().TransformExpr(C->getThreadID());
11579 if (ThreadID.isInvalid())
11580 return nullptr;
11581 return getDerived().RebuildOMPFilterClause(ThreadID.get(), C->getBeginLoc(),
11582 C->getLParenLoc(), C->getEndLoc());
11583}
11584
11585template <typename Derived>
11586OMPClause *TreeTransform<Derived>::TransformOMPAlignClause(OMPAlignClause *C) {
11587 ExprResult E = getDerived().TransformExpr(C->getAlignment());
11588 if (E.isInvalid())
11589 return nullptr;
11590 return getDerived().RebuildOMPAlignClause(E.get(), C->getBeginLoc(),
11591 C->getLParenLoc(), C->getEndLoc());
11592}
11593
11594template <typename Derived>
11595OMPClause *TreeTransform<Derived>::TransformOMPUnifiedAddressClause(
11596 OMPUnifiedAddressClause *C) {
11597 llvm_unreachable("unified_address clause cannot appear in dependent context");
11598}
11599
11600template <typename Derived>
11601OMPClause *TreeTransform<Derived>::TransformOMPUnifiedSharedMemoryClause(
11602 OMPUnifiedSharedMemoryClause *C) {
11603 llvm_unreachable(
11604 "unified_shared_memory clause cannot appear in dependent context");
11605}
11606
11607template <typename Derived>
11608OMPClause *TreeTransform<Derived>::TransformOMPReverseOffloadClause(
11609 OMPReverseOffloadClause *C) {
11610 llvm_unreachable("reverse_offload clause cannot appear in dependent context");
11611}
11612
11613template <typename Derived>
11614OMPClause *TreeTransform<Derived>::TransformOMPDynamicAllocatorsClause(
11615 OMPDynamicAllocatorsClause *C) {
11616 llvm_unreachable(
11617 "dynamic_allocators clause cannot appear in dependent context");
11618}
11619
11620template <typename Derived>
11621OMPClause *TreeTransform<Derived>::TransformOMPAtomicDefaultMemOrderClause(
11622 OMPAtomicDefaultMemOrderClause *C) {
11623 llvm_unreachable(
11624 "atomic_default_mem_order clause cannot appear in dependent context");
11625}
11626
11627template <typename Derived>
11628OMPClause *
11629TreeTransform<Derived>::TransformOMPSelfMapsClause(OMPSelfMapsClause *C) {
11630 llvm_unreachable("self_maps clause cannot appear in dependent context");
11631}
11632
11633template <typename Derived>
11634OMPClause *TreeTransform<Derived>::TransformOMPAtClause(OMPAtClause *C) {
11635 return getDerived().RebuildOMPAtClause(C->getAtKind(), C->getAtKindKwLoc(),
11636 C->getBeginLoc(), C->getLParenLoc(),
11637 C->getEndLoc());
11638}
11639
11640template <typename Derived>
11641OMPClause *
11642TreeTransform<Derived>::TransformOMPSeverityClause(OMPSeverityClause *C) {
11643 return getDerived().RebuildOMPSeverityClause(
11644 C->getSeverityKind(), C->getSeverityKindKwLoc(), C->getBeginLoc(),
11645 C->getLParenLoc(), C->getEndLoc());
11646}
11647
11648template <typename Derived>
11649OMPClause *
11650TreeTransform<Derived>::TransformOMPMessageClause(OMPMessageClause *C) {
11651 ExprResult E = getDerived().TransformExpr(C->getMessageString());
11652 if (E.isInvalid())
11653 return nullptr;
11654 return getDerived().RebuildOMPMessageClause(
11655 E.get(), C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
11656}
11657
11658template <typename Derived>
11659OMPClause *
11660TreeTransform<Derived>::TransformOMPPrivateClause(OMPPrivateClause *C) {
11661 llvm::SmallVector<Expr *, 16> Vars;
11662 Vars.reserve(N: C->varlist_size());
11663 for (auto *VE : C->varlist()) {
11664 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(Val: VE));
11665 if (EVar.isInvalid())
11666 return nullptr;
11667 Vars.push_back(Elt: EVar.get());
11668 }
11669 return getDerived().RebuildOMPPrivateClause(
11670 Vars, C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
11671}
11672
11673template <typename Derived>
11674OMPClause *TreeTransform<Derived>::TransformOMPFirstprivateClause(
11675 OMPFirstprivateClause *C) {
11676 llvm::SmallVector<Expr *, 16> Vars;
11677 Vars.reserve(N: C->varlist_size());
11678 for (auto *VE : C->varlist()) {
11679 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(Val: VE));
11680 if (EVar.isInvalid())
11681 return nullptr;
11682 Vars.push_back(Elt: EVar.get());
11683 }
11684 return getDerived().RebuildOMPFirstprivateClause(
11685 Vars, C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
11686}
11687
11688template <typename Derived>
11689OMPClause *
11690TreeTransform<Derived>::TransformOMPLastprivateClause(OMPLastprivateClause *C) {
11691 llvm::SmallVector<Expr *, 16> Vars;
11692 Vars.reserve(N: C->varlist_size());
11693 for (auto *VE : C->varlist()) {
11694 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(Val: VE));
11695 if (EVar.isInvalid())
11696 return nullptr;
11697 Vars.push_back(Elt: EVar.get());
11698 }
11699 return getDerived().RebuildOMPLastprivateClause(
11700 Vars, C->getKind(), C->getKindLoc(), C->getColonLoc(), C->getBeginLoc(),
11701 C->getLParenLoc(), C->getEndLoc());
11702}
11703
11704template <typename Derived>
11705OMPClause *
11706TreeTransform<Derived>::TransformOMPSharedClause(OMPSharedClause *C) {
11707 llvm::SmallVector<Expr *, 16> Vars;
11708 Vars.reserve(N: C->varlist_size());
11709 for (auto *VE : C->varlist()) {
11710 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(Val: VE));
11711 if (EVar.isInvalid())
11712 return nullptr;
11713 Vars.push_back(Elt: EVar.get());
11714 }
11715 return getDerived().RebuildOMPSharedClause(Vars, C->getBeginLoc(),
11716 C->getLParenLoc(), C->getEndLoc());
11717}
11718
11719template <typename Derived>
11720OMPClause *
11721TreeTransform<Derived>::TransformOMPReductionClause(OMPReductionClause *C) {
11722 llvm::SmallVector<Expr *, 16> Vars;
11723 Vars.reserve(N: C->varlist_size());
11724 for (auto *VE : C->varlist()) {
11725 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(Val: VE));
11726 if (EVar.isInvalid())
11727 return nullptr;
11728 Vars.push_back(Elt: EVar.get());
11729 }
11730 CXXScopeSpec ReductionIdScopeSpec;
11731 ReductionIdScopeSpec.Adopt(Other: C->getQualifierLoc());
11732
11733 DeclarationNameInfo NameInfo = C->getNameInfo();
11734 if (NameInfo.getName()) {
11735 NameInfo = getDerived().TransformDeclarationNameInfo(NameInfo);
11736 if (!NameInfo.getName())
11737 return nullptr;
11738 }
11739 // Build a list of all UDR decls with the same names ranged by the Scopes.
11740 // The Scope boundary is a duplication of the previous decl.
11741 llvm::SmallVector<Expr *, 16> UnresolvedReductions;
11742 for (auto *E : C->reduction_ops()) {
11743 // Transform all the decls.
11744 if (E) {
11745 auto *ULE = cast<UnresolvedLookupExpr>(Val: E);
11746 UnresolvedSet<8> Decls;
11747 for (auto *D : ULE->decls()) {
11748 NamedDecl *InstD =
11749 cast<NamedDecl>(getDerived().TransformDecl(E->getExprLoc(), D));
11750 Decls.addDecl(D: InstD, AS: InstD->getAccess());
11751 }
11752 UnresolvedReductions.push_back(Elt: UnresolvedLookupExpr::Create(
11753 Context: SemaRef.Context, /*NamingClass=*/NamingClass: nullptr,
11754 QualifierLoc: ReductionIdScopeSpec.getWithLocInContext(Context&: SemaRef.Context), NameInfo,
11755 /*ADL=*/RequiresADL: true, Begin: Decls.begin(), End: Decls.end(),
11756 /*KnownDependent=*/KnownDependent: false, /*KnownInstantiationDependent=*/KnownInstantiationDependent: false));
11757 } else
11758 UnresolvedReductions.push_back(Elt: nullptr);
11759 }
11760 return getDerived().RebuildOMPReductionClause(
11761 Vars, C->getModifier(), C->getOriginalSharingModifier(), C->getBeginLoc(),
11762 C->getLParenLoc(), C->getModifierLoc(), C->getColonLoc(), C->getEndLoc(),
11763 ReductionIdScopeSpec, NameInfo, UnresolvedReductions);
11764}
11765
11766template <typename Derived>
11767OMPClause *TreeTransform<Derived>::TransformOMPTaskReductionClause(
11768 OMPTaskReductionClause *C) {
11769 llvm::SmallVector<Expr *, 16> Vars;
11770 Vars.reserve(N: C->varlist_size());
11771 for (auto *VE : C->varlist()) {
11772 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(Val: VE));
11773 if (EVar.isInvalid())
11774 return nullptr;
11775 Vars.push_back(Elt: EVar.get());
11776 }
11777 CXXScopeSpec ReductionIdScopeSpec;
11778 ReductionIdScopeSpec.Adopt(Other: C->getQualifierLoc());
11779
11780 DeclarationNameInfo NameInfo = C->getNameInfo();
11781 if (NameInfo.getName()) {
11782 NameInfo = getDerived().TransformDeclarationNameInfo(NameInfo);
11783 if (!NameInfo.getName())
11784 return nullptr;
11785 }
11786 // Build a list of all UDR decls with the same names ranged by the Scopes.
11787 // The Scope boundary is a duplication of the previous decl.
11788 llvm::SmallVector<Expr *, 16> UnresolvedReductions;
11789 for (auto *E : C->reduction_ops()) {
11790 // Transform all the decls.
11791 if (E) {
11792 auto *ULE = cast<UnresolvedLookupExpr>(Val: E);
11793 UnresolvedSet<8> Decls;
11794 for (auto *D : ULE->decls()) {
11795 NamedDecl *InstD =
11796 cast<NamedDecl>(getDerived().TransformDecl(E->getExprLoc(), D));
11797 Decls.addDecl(D: InstD, AS: InstD->getAccess());
11798 }
11799 UnresolvedReductions.push_back(Elt: UnresolvedLookupExpr::Create(
11800 Context: SemaRef.Context, /*NamingClass=*/NamingClass: nullptr,
11801 QualifierLoc: ReductionIdScopeSpec.getWithLocInContext(Context&: SemaRef.Context), NameInfo,
11802 /*ADL=*/RequiresADL: true, Begin: Decls.begin(), End: Decls.end(),
11803 /*KnownDependent=*/KnownDependent: false, /*KnownInstantiationDependent=*/KnownInstantiationDependent: false));
11804 } else
11805 UnresolvedReductions.push_back(Elt: nullptr);
11806 }
11807 return getDerived().RebuildOMPTaskReductionClause(
11808 Vars, C->getBeginLoc(), C->getLParenLoc(), C->getColonLoc(),
11809 C->getEndLoc(), ReductionIdScopeSpec, NameInfo, UnresolvedReductions);
11810}
11811
11812template <typename Derived>
11813OMPClause *
11814TreeTransform<Derived>::TransformOMPInReductionClause(OMPInReductionClause *C) {
11815 llvm::SmallVector<Expr *, 16> Vars;
11816 Vars.reserve(N: C->varlist_size());
11817 for (auto *VE : C->varlist()) {
11818 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(Val: VE));
11819 if (EVar.isInvalid())
11820 return nullptr;
11821 Vars.push_back(Elt: EVar.get());
11822 }
11823 CXXScopeSpec ReductionIdScopeSpec;
11824 ReductionIdScopeSpec.Adopt(Other: C->getQualifierLoc());
11825
11826 DeclarationNameInfo NameInfo = C->getNameInfo();
11827 if (NameInfo.getName()) {
11828 NameInfo = getDerived().TransformDeclarationNameInfo(NameInfo);
11829 if (!NameInfo.getName())
11830 return nullptr;
11831 }
11832 // Build a list of all UDR decls with the same names ranged by the Scopes.
11833 // The Scope boundary is a duplication of the previous decl.
11834 llvm::SmallVector<Expr *, 16> UnresolvedReductions;
11835 for (auto *E : C->reduction_ops()) {
11836 // Transform all the decls.
11837 if (E) {
11838 auto *ULE = cast<UnresolvedLookupExpr>(Val: E);
11839 UnresolvedSet<8> Decls;
11840 for (auto *D : ULE->decls()) {
11841 NamedDecl *InstD =
11842 cast<NamedDecl>(getDerived().TransformDecl(E->getExprLoc(), D));
11843 Decls.addDecl(D: InstD, AS: InstD->getAccess());
11844 }
11845 UnresolvedReductions.push_back(Elt: UnresolvedLookupExpr::Create(
11846 Context: SemaRef.Context, /*NamingClass=*/NamingClass: nullptr,
11847 QualifierLoc: ReductionIdScopeSpec.getWithLocInContext(Context&: SemaRef.Context), NameInfo,
11848 /*ADL=*/RequiresADL: true, Begin: Decls.begin(), End: Decls.end(),
11849 /*KnownDependent=*/KnownDependent: false, /*KnownInstantiationDependent=*/KnownInstantiationDependent: false));
11850 } else
11851 UnresolvedReductions.push_back(Elt: nullptr);
11852 }
11853 return getDerived().RebuildOMPInReductionClause(
11854 Vars, C->getBeginLoc(), C->getLParenLoc(), C->getColonLoc(),
11855 C->getEndLoc(), ReductionIdScopeSpec, NameInfo, UnresolvedReductions);
11856}
11857
11858template <typename Derived>
11859OMPClause *
11860TreeTransform<Derived>::TransformOMPLinearClause(OMPLinearClause *C) {
11861 llvm::SmallVector<Expr *, 16> Vars;
11862 Vars.reserve(N: C->varlist_size());
11863 for (auto *VE : C->varlist()) {
11864 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(Val: VE));
11865 if (EVar.isInvalid())
11866 return nullptr;
11867 Vars.push_back(Elt: EVar.get());
11868 }
11869 ExprResult Step = getDerived().TransformExpr(C->getStep());
11870 if (Step.isInvalid())
11871 return nullptr;
11872 return getDerived().RebuildOMPLinearClause(
11873 Vars, Step.get(), C->getBeginLoc(), C->getLParenLoc(), C->getModifier(),
11874 C->getModifierLoc(), C->getColonLoc(), C->getStepModifierLoc(),
11875 C->getEndLoc());
11876}
11877
11878template <typename Derived>
11879OMPClause *
11880TreeTransform<Derived>::TransformOMPAlignedClause(OMPAlignedClause *C) {
11881 llvm::SmallVector<Expr *, 16> Vars;
11882 Vars.reserve(N: C->varlist_size());
11883 for (auto *VE : C->varlist()) {
11884 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(Val: VE));
11885 if (EVar.isInvalid())
11886 return nullptr;
11887 Vars.push_back(Elt: EVar.get());
11888 }
11889 ExprResult Alignment = getDerived().TransformExpr(C->getAlignment());
11890 if (Alignment.isInvalid())
11891 return nullptr;
11892 return getDerived().RebuildOMPAlignedClause(
11893 Vars, Alignment.get(), C->getBeginLoc(), C->getLParenLoc(),
11894 C->getColonLoc(), C->getEndLoc());
11895}
11896
11897template <typename Derived>
11898OMPClause *
11899TreeTransform<Derived>::TransformOMPCopyinClause(OMPCopyinClause *C) {
11900 llvm::SmallVector<Expr *, 16> Vars;
11901 Vars.reserve(N: C->varlist_size());
11902 for (auto *VE : C->varlist()) {
11903 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(Val: VE));
11904 if (EVar.isInvalid())
11905 return nullptr;
11906 Vars.push_back(Elt: EVar.get());
11907 }
11908 return getDerived().RebuildOMPCopyinClause(Vars, C->getBeginLoc(),
11909 C->getLParenLoc(), C->getEndLoc());
11910}
11911
11912template <typename Derived>
11913OMPClause *
11914TreeTransform<Derived>::TransformOMPCopyprivateClause(OMPCopyprivateClause *C) {
11915 llvm::SmallVector<Expr *, 16> Vars;
11916 Vars.reserve(N: C->varlist_size());
11917 for (auto *VE : C->varlist()) {
11918 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(Val: VE));
11919 if (EVar.isInvalid())
11920 return nullptr;
11921 Vars.push_back(Elt: EVar.get());
11922 }
11923 return getDerived().RebuildOMPCopyprivateClause(
11924 Vars, C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
11925}
11926
11927template <typename Derived>
11928OMPClause *TreeTransform<Derived>::TransformOMPFlushClause(OMPFlushClause *C) {
11929 llvm::SmallVector<Expr *, 16> Vars;
11930 Vars.reserve(N: C->varlist_size());
11931 for (auto *VE : C->varlist()) {
11932 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(Val: VE));
11933 if (EVar.isInvalid())
11934 return nullptr;
11935 Vars.push_back(Elt: EVar.get());
11936 }
11937 return getDerived().RebuildOMPFlushClause(Vars, C->getBeginLoc(),
11938 C->getLParenLoc(), C->getEndLoc());
11939}
11940
11941template <typename Derived>
11942OMPClause *
11943TreeTransform<Derived>::TransformOMPDepobjClause(OMPDepobjClause *C) {
11944 ExprResult E = getDerived().TransformExpr(C->getDepobj());
11945 if (E.isInvalid())
11946 return nullptr;
11947 return getDerived().RebuildOMPDepobjClause(E.get(), C->getBeginLoc(),
11948 C->getLParenLoc(), C->getEndLoc());
11949}
11950
11951template <typename Derived>
11952OMPClause *
11953TreeTransform<Derived>::TransformOMPDependClause(OMPDependClause *C) {
11954 llvm::SmallVector<Expr *, 16> Vars;
11955 Expr *DepModifier = C->getModifier();
11956 if (DepModifier) {
11957 ExprResult DepModRes = getDerived().TransformExpr(DepModifier);
11958 if (DepModRes.isInvalid())
11959 return nullptr;
11960 DepModifier = DepModRes.get();
11961 }
11962 Vars.reserve(N: C->varlist_size());
11963 for (auto *VE : C->varlist()) {
11964 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(Val: VE));
11965 if (EVar.isInvalid())
11966 return nullptr;
11967 Vars.push_back(Elt: EVar.get());
11968 }
11969 return getDerived().RebuildOMPDependClause(
11970 {C->getDependencyKind(), C->getDependencyLoc(), C->getColonLoc(),
11971 C->getOmpAllMemoryLoc()},
11972 DepModifier, Vars, C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
11973}
11974
11975template <typename Derived>
11976OMPClause *
11977TreeTransform<Derived>::TransformOMPDeviceClause(OMPDeviceClause *C) {
11978 ExprResult E = getDerived().TransformExpr(C->getDevice());
11979 if (E.isInvalid())
11980 return nullptr;
11981 return getDerived().RebuildOMPDeviceClause(
11982 C->getModifier(), E.get(), C->getBeginLoc(), C->getLParenLoc(),
11983 C->getModifierLoc(), C->getEndLoc());
11984}
11985
11986template <typename Derived, class T>
11987bool transformOMPMappableExprListClause(
11988 TreeTransform<Derived> &TT, OMPMappableExprListClause<T> *C,
11989 llvm::SmallVectorImpl<Expr *> &Vars, CXXScopeSpec &MapperIdScopeSpec,
11990 DeclarationNameInfo &MapperIdInfo,
11991 llvm::SmallVectorImpl<Expr *> &UnresolvedMappers) {
11992 // Transform expressions in the list.
11993 Vars.reserve(N: C->varlist_size());
11994 for (auto *VE : C->varlist()) {
11995 ExprResult EVar = TT.getDerived().TransformExpr(cast<Expr>(VE));
11996 if (EVar.isInvalid())
11997 return true;
11998 Vars.push_back(Elt: EVar.get());
11999 }
12000 // Transform mapper scope specifier and identifier.
12001 NestedNameSpecifierLoc QualifierLoc;
12002 if (C->getMapperQualifierLoc()) {
12003 QualifierLoc = TT.getDerived().TransformNestedNameSpecifierLoc(
12004 C->getMapperQualifierLoc());
12005 if (!QualifierLoc)
12006 return true;
12007 }
12008 MapperIdScopeSpec.Adopt(Other: QualifierLoc);
12009 MapperIdInfo = C->getMapperIdInfo();
12010 if (MapperIdInfo.getName()) {
12011 MapperIdInfo = TT.getDerived().TransformDeclarationNameInfo(MapperIdInfo);
12012 if (!MapperIdInfo.getName())
12013 return true;
12014 }
12015 // Build a list of all candidate OMPDeclareMapperDecls, which is provided by
12016 // the previous user-defined mapper lookup in dependent environment.
12017 for (auto *E : C->mapperlists()) {
12018 // Transform all the decls.
12019 if (E) {
12020 auto *ULE = cast<UnresolvedLookupExpr>(E);
12021 UnresolvedSet<8> Decls;
12022 for (auto *D : ULE->decls()) {
12023 NamedDecl *InstD =
12024 cast<NamedDecl>(TT.getDerived().TransformDecl(E->getExprLoc(), D));
12025 Decls.addDecl(D: InstD, AS: InstD->getAccess());
12026 }
12027 UnresolvedMappers.push_back(Elt: UnresolvedLookupExpr::Create(
12028 TT.getSema().Context, /*NamingClass=*/nullptr,
12029 MapperIdScopeSpec.getWithLocInContext(Context&: TT.getSema().Context),
12030 MapperIdInfo, /*ADL=*/true, Decls.begin(), Decls.end(),
12031 /*KnownDependent=*/false, /*KnownInstantiationDependent=*/false));
12032 } else {
12033 UnresolvedMappers.push_back(Elt: nullptr);
12034 }
12035 }
12036 return false;
12037}
12038
12039template <typename Derived>
12040OMPClause *TreeTransform<Derived>::TransformOMPMapClause(OMPMapClause *C) {
12041 OMPVarListLocTy Locs(C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
12042 llvm::SmallVector<Expr *, 16> Vars;
12043 Expr *IteratorModifier = C->getIteratorModifier();
12044 if (IteratorModifier) {
12045 ExprResult MapModRes = getDerived().TransformExpr(IteratorModifier);
12046 if (MapModRes.isInvalid())
12047 return nullptr;
12048 IteratorModifier = MapModRes.get();
12049 }
12050 CXXScopeSpec MapperIdScopeSpec;
12051 DeclarationNameInfo MapperIdInfo;
12052 llvm::SmallVector<Expr *, 16> UnresolvedMappers;
12053 if (transformOMPMappableExprListClause<Derived, OMPMapClause>(
12054 *this, C, Vars, MapperIdScopeSpec, MapperIdInfo, UnresolvedMappers))
12055 return nullptr;
12056 return getDerived().RebuildOMPMapClause(
12057 IteratorModifier, C->getMapTypeModifiers(), C->getMapTypeModifiersLoc(),
12058 MapperIdScopeSpec, MapperIdInfo, C->getMapType(), C->isImplicitMapType(),
12059 C->getMapLoc(), C->getColonLoc(), Vars, Locs, UnresolvedMappers);
12060}
12061
12062template <typename Derived>
12063OMPClause *
12064TreeTransform<Derived>::TransformOMPAllocateClause(OMPAllocateClause *C) {
12065 Expr *Allocator = C->getAllocator();
12066 if (Allocator) {
12067 ExprResult AllocatorRes = getDerived().TransformExpr(Allocator);
12068 if (AllocatorRes.isInvalid())
12069 return nullptr;
12070 Allocator = AllocatorRes.get();
12071 }
12072 Expr *Alignment = C->getAlignment();
12073 if (Alignment) {
12074 ExprResult AlignmentRes = getDerived().TransformExpr(Alignment);
12075 if (AlignmentRes.isInvalid())
12076 return nullptr;
12077 Alignment = AlignmentRes.get();
12078 }
12079 llvm::SmallVector<Expr *, 16> Vars;
12080 Vars.reserve(N: C->varlist_size());
12081 for (auto *VE : C->varlist()) {
12082 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(Val: VE));
12083 if (EVar.isInvalid())
12084 return nullptr;
12085 Vars.push_back(Elt: EVar.get());
12086 }
12087 return getDerived().RebuildOMPAllocateClause(
12088 Allocator, Alignment, C->getFirstAllocateModifier(),
12089 C->getFirstAllocateModifierLoc(), C->getSecondAllocateModifier(),
12090 C->getSecondAllocateModifierLoc(), Vars, C->getBeginLoc(),
12091 C->getLParenLoc(), C->getColonLoc(), C->getEndLoc());
12092}
12093
12094template <typename Derived>
12095OMPClause *
12096TreeTransform<Derived>::TransformOMPNumTeamsClause(OMPNumTeamsClause *C) {
12097 llvm::SmallVector<Expr *, 3> Vars;
12098 Vars.reserve(N: C->varlist_size());
12099 for (auto *VE : C->varlist()) {
12100 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(Val: VE));
12101 if (EVar.isInvalid())
12102 return nullptr;
12103 Vars.push_back(Elt: EVar.get());
12104 }
12105 Expr *ModifierExpr = C->getModifierExpr();
12106 if (ModifierExpr) {
12107 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(Val: ModifierExpr));
12108 if (EVar.isInvalid())
12109 return nullptr;
12110 ModifierExpr = EVar.get();
12111 }
12112 return getDerived().RebuildOMPNumTeamsClause(
12113 Vars, C->getModifier(), ModifierExpr, C->getModifierLoc(),
12114 OMPC_NUMTEAMS_unknown, nullptr, SourceLocation(), C->getBeginLoc(),
12115 C->getLParenLoc(), C->getEndLoc());
12116}
12117
12118template <typename Derived>
12119OMPClause *
12120TreeTransform<Derived>::TransformOMPThreadLimitClause(OMPThreadLimitClause *C) {
12121 llvm::SmallVector<Expr *, 3> Vars;
12122 Vars.reserve(N: C->varlist_size());
12123 for (auto *VE : C->varlist()) {
12124 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(Val: VE));
12125 if (EVar.isInvalid())
12126 return nullptr;
12127 Vars.push_back(Elt: EVar.get());
12128 }
12129 Expr *ModifierExpr = C->getModifierExpr();
12130 if (ModifierExpr) {
12131 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(Val: ModifierExpr));
12132 if (EVar.isInvalid())
12133 return nullptr;
12134 ModifierExpr = EVar.get();
12135 }
12136 return getDerived().RebuildOMPThreadLimitClause(
12137 Vars, C->getModifier(), ModifierExpr, C->getModifierLoc(),
12138 C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
12139}
12140
12141template <typename Derived>
12142OMPClause *
12143TreeTransform<Derived>::TransformOMPPriorityClause(OMPPriorityClause *C) {
12144 ExprResult E = getDerived().TransformExpr(C->getPriority());
12145 if (E.isInvalid())
12146 return nullptr;
12147 return getDerived().RebuildOMPPriorityClause(
12148 E.get(), C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
12149}
12150
12151template <typename Derived>
12152OMPClause *
12153TreeTransform<Derived>::TransformOMPGrainsizeClause(OMPGrainsizeClause *C) {
12154 ExprResult E = getDerived().TransformExpr(C->getGrainsize());
12155 if (E.isInvalid())
12156 return nullptr;
12157 return getDerived().RebuildOMPGrainsizeClause(
12158 C->getModifier(), E.get(), C->getBeginLoc(), C->getLParenLoc(),
12159 C->getModifierLoc(), C->getEndLoc());
12160}
12161
12162template <typename Derived>
12163OMPClause *
12164TreeTransform<Derived>::TransformOMPNumTasksClause(OMPNumTasksClause *C) {
12165 ExprResult E = getDerived().TransformExpr(C->getNumTasks());
12166 if (E.isInvalid())
12167 return nullptr;
12168 return getDerived().RebuildOMPNumTasksClause(
12169 C->getModifier(), E.get(), C->getBeginLoc(), C->getLParenLoc(),
12170 C->getModifierLoc(), C->getEndLoc());
12171}
12172
12173template <typename Derived>
12174OMPClause *TreeTransform<Derived>::TransformOMPHintClause(OMPHintClause *C) {
12175 ExprResult E = getDerived().TransformExpr(C->getHint());
12176 if (E.isInvalid())
12177 return nullptr;
12178 return getDerived().RebuildOMPHintClause(E.get(), C->getBeginLoc(),
12179 C->getLParenLoc(), C->getEndLoc());
12180}
12181
12182template <typename Derived>
12183OMPClause *TreeTransform<Derived>::TransformOMPDistScheduleClause(
12184 OMPDistScheduleClause *C) {
12185 ExprResult E = getDerived().TransformExpr(C->getChunkSize());
12186 if (E.isInvalid())
12187 return nullptr;
12188 return getDerived().RebuildOMPDistScheduleClause(
12189 C->getDistScheduleKind(), E.get(), C->getBeginLoc(), C->getLParenLoc(),
12190 C->getDistScheduleKindLoc(), C->getCommaLoc(), C->getEndLoc());
12191}
12192
12193template <typename Derived>
12194OMPClause *
12195TreeTransform<Derived>::TransformOMPDefaultmapClause(OMPDefaultmapClause *C) {
12196 // Rebuild Defaultmap Clause since we need to invoke the checking of
12197 // defaultmap(none:variable-category) after template initialization.
12198 return getDerived().RebuildOMPDefaultmapClause(C->getDefaultmapModifier(),
12199 C->getDefaultmapKind(),
12200 C->getBeginLoc(),
12201 C->getLParenLoc(),
12202 C->getDefaultmapModifierLoc(),
12203 C->getDefaultmapKindLoc(),
12204 C->getEndLoc());
12205}
12206
12207template <typename Derived>
12208OMPClause *TreeTransform<Derived>::TransformOMPToClause(OMPToClause *C) {
12209 OMPVarListLocTy Locs(C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
12210 llvm::SmallVector<Expr *, 16> Vars;
12211 Expr *IteratorModifier = C->getIteratorModifier();
12212 if (IteratorModifier) {
12213 ExprResult MapModRes = getDerived().TransformExpr(IteratorModifier);
12214 if (MapModRes.isInvalid())
12215 return nullptr;
12216 IteratorModifier = MapModRes.get();
12217 }
12218 CXXScopeSpec MapperIdScopeSpec;
12219 DeclarationNameInfo MapperIdInfo;
12220 llvm::SmallVector<Expr *, 16> UnresolvedMappers;
12221 if (transformOMPMappableExprListClause<Derived, OMPToClause>(
12222 *this, C, Vars, MapperIdScopeSpec, MapperIdInfo, UnresolvedMappers))
12223 return nullptr;
12224 return getDerived().RebuildOMPToClause(
12225 C->getMotionModifiers(), C->getMotionModifiersLoc(), IteratorModifier,
12226 MapperIdScopeSpec, MapperIdInfo, C->getColonLoc(), Vars, Locs,
12227 UnresolvedMappers);
12228}
12229
12230template <typename Derived>
12231OMPClause *TreeTransform<Derived>::TransformOMPFromClause(OMPFromClause *C) {
12232 OMPVarListLocTy Locs(C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
12233 llvm::SmallVector<Expr *, 16> Vars;
12234 Expr *IteratorModifier = C->getIteratorModifier();
12235 if (IteratorModifier) {
12236 ExprResult MapModRes = getDerived().TransformExpr(IteratorModifier);
12237 if (MapModRes.isInvalid())
12238 return nullptr;
12239 IteratorModifier = MapModRes.get();
12240 }
12241 CXXScopeSpec MapperIdScopeSpec;
12242 DeclarationNameInfo MapperIdInfo;
12243 llvm::SmallVector<Expr *, 16> UnresolvedMappers;
12244 if (transformOMPMappableExprListClause<Derived, OMPFromClause>(
12245 *this, C, Vars, MapperIdScopeSpec, MapperIdInfo, UnresolvedMappers))
12246 return nullptr;
12247 return getDerived().RebuildOMPFromClause(
12248 C->getMotionModifiers(), C->getMotionModifiersLoc(), IteratorModifier,
12249 MapperIdScopeSpec, MapperIdInfo, C->getColonLoc(), Vars, Locs,
12250 UnresolvedMappers);
12251}
12252
12253template <typename Derived>
12254OMPClause *TreeTransform<Derived>::TransformOMPUseDevicePtrClause(
12255 OMPUseDevicePtrClause *C) {
12256 llvm::SmallVector<Expr *, 16> Vars;
12257 Vars.reserve(N: C->varlist_size());
12258 for (auto *VE : C->varlist()) {
12259 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(Val: VE));
12260 if (EVar.isInvalid())
12261 return nullptr;
12262 Vars.push_back(Elt: EVar.get());
12263 }
12264 OMPVarListLocTy Locs(C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
12265 return getDerived().RebuildOMPUseDevicePtrClause(
12266 Vars, Locs, C->getFallbackModifier(), C->getFallbackModifierLoc());
12267}
12268
12269template <typename Derived>
12270OMPClause *TreeTransform<Derived>::TransformOMPUseDeviceAddrClause(
12271 OMPUseDeviceAddrClause *C) {
12272 llvm::SmallVector<Expr *, 16> Vars;
12273 Vars.reserve(N: C->varlist_size());
12274 for (auto *VE : C->varlist()) {
12275 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(Val: VE));
12276 if (EVar.isInvalid())
12277 return nullptr;
12278 Vars.push_back(Elt: EVar.get());
12279 }
12280 OMPVarListLocTy Locs(C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
12281 return getDerived().RebuildOMPUseDeviceAddrClause(Vars, Locs);
12282}
12283
12284template <typename Derived>
12285OMPClause *
12286TreeTransform<Derived>::TransformOMPIsDevicePtrClause(OMPIsDevicePtrClause *C) {
12287 llvm::SmallVector<Expr *, 16> Vars;
12288 Vars.reserve(N: C->varlist_size());
12289 for (auto *VE : C->varlist()) {
12290 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(Val: VE));
12291 if (EVar.isInvalid())
12292 return nullptr;
12293 Vars.push_back(Elt: EVar.get());
12294 }
12295 OMPVarListLocTy Locs(C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
12296 return getDerived().RebuildOMPIsDevicePtrClause(Vars, Locs);
12297}
12298
12299template <typename Derived>
12300OMPClause *TreeTransform<Derived>::TransformOMPHasDeviceAddrClause(
12301 OMPHasDeviceAddrClause *C) {
12302 llvm::SmallVector<Expr *, 16> Vars;
12303 Vars.reserve(N: C->varlist_size());
12304 for (auto *VE : C->varlist()) {
12305 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(Val: VE));
12306 if (EVar.isInvalid())
12307 return nullptr;
12308 Vars.push_back(Elt: EVar.get());
12309 }
12310 OMPVarListLocTy Locs(C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
12311 return getDerived().RebuildOMPHasDeviceAddrClause(Vars, Locs);
12312}
12313
12314template <typename Derived>
12315OMPClause *
12316TreeTransform<Derived>::TransformOMPNontemporalClause(OMPNontemporalClause *C) {
12317 llvm::SmallVector<Expr *, 16> Vars;
12318 Vars.reserve(N: C->varlist_size());
12319 for (auto *VE : C->varlist()) {
12320 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(Val: VE));
12321 if (EVar.isInvalid())
12322 return nullptr;
12323 Vars.push_back(Elt: EVar.get());
12324 }
12325 return getDerived().RebuildOMPNontemporalClause(
12326 Vars, C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
12327}
12328
12329template <typename Derived>
12330OMPClause *
12331TreeTransform<Derived>::TransformOMPInclusiveClause(OMPInclusiveClause *C) {
12332 llvm::SmallVector<Expr *, 16> Vars;
12333 Vars.reserve(N: C->varlist_size());
12334 for (auto *VE : C->varlist()) {
12335 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(Val: VE));
12336 if (EVar.isInvalid())
12337 return nullptr;
12338 Vars.push_back(Elt: EVar.get());
12339 }
12340 return getDerived().RebuildOMPInclusiveClause(
12341 Vars, C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
12342}
12343
12344template <typename Derived>
12345OMPClause *
12346TreeTransform<Derived>::TransformOMPExclusiveClause(OMPExclusiveClause *C) {
12347 llvm::SmallVector<Expr *, 16> Vars;
12348 Vars.reserve(N: C->varlist_size());
12349 for (auto *VE : C->varlist()) {
12350 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(Val: VE));
12351 if (EVar.isInvalid())
12352 return nullptr;
12353 Vars.push_back(Elt: EVar.get());
12354 }
12355 return getDerived().RebuildOMPExclusiveClause(
12356 Vars, C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
12357}
12358
12359template <typename Derived>
12360OMPClause *TreeTransform<Derived>::TransformOMPUsesAllocatorsClause(
12361 OMPUsesAllocatorsClause *C) {
12362 SmallVector<SemaOpenMP::UsesAllocatorsData, 16> Data;
12363 Data.reserve(N: C->getNumberOfAllocators());
12364 for (unsigned I = 0, E = C->getNumberOfAllocators(); I < E; ++I) {
12365 OMPUsesAllocatorsClause::Data D = C->getAllocatorData(I);
12366 ExprResult Allocator = getDerived().TransformExpr(D.Allocator);
12367 if (Allocator.isInvalid())
12368 continue;
12369 ExprResult AllocatorTraits;
12370 if (Expr *AT = D.AllocatorTraits) {
12371 AllocatorTraits = getDerived().TransformExpr(AT);
12372 if (AllocatorTraits.isInvalid())
12373 continue;
12374 }
12375 SemaOpenMP::UsesAllocatorsData &NewD = Data.emplace_back();
12376 NewD.Allocator = Allocator.get();
12377 NewD.AllocatorTraits = AllocatorTraits.get();
12378 NewD.LParenLoc = D.LParenLoc;
12379 NewD.RParenLoc = D.RParenLoc;
12380 }
12381 return getDerived().RebuildOMPUsesAllocatorsClause(
12382 Data, C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
12383}
12384
12385template <typename Derived>
12386OMPClause *
12387TreeTransform<Derived>::TransformOMPAffinityClause(OMPAffinityClause *C) {
12388 SmallVector<Expr *, 4> Locators;
12389 Locators.reserve(N: C->varlist_size());
12390 ExprResult ModifierRes;
12391 if (Expr *Modifier = C->getModifier()) {
12392 ModifierRes = getDerived().TransformExpr(Modifier);
12393 if (ModifierRes.isInvalid())
12394 return nullptr;
12395 }
12396 for (Expr *E : C->varlist()) {
12397 ExprResult Locator = getDerived().TransformExpr(E);
12398 if (Locator.isInvalid())
12399 continue;
12400 Locators.push_back(Elt: Locator.get());
12401 }
12402 return getDerived().RebuildOMPAffinityClause(
12403 C->getBeginLoc(), C->getLParenLoc(), C->getColonLoc(), C->getEndLoc(),
12404 ModifierRes.get(), Locators);
12405}
12406
12407template <typename Derived>
12408OMPClause *TreeTransform<Derived>::TransformOMPOrderClause(OMPOrderClause *C) {
12409 return getDerived().RebuildOMPOrderClause(
12410 C->getKind(), C->getKindKwLoc(), C->getBeginLoc(), C->getLParenLoc(),
12411 C->getEndLoc(), C->getModifier(), C->getModifierKwLoc());
12412}
12413
12414template <typename Derived>
12415OMPClause *TreeTransform<Derived>::TransformOMPBindClause(OMPBindClause *C) {
12416 return getDerived().RebuildOMPBindClause(
12417 C->getBindKind(), C->getBindKindLoc(), C->getBeginLoc(),
12418 C->getLParenLoc(), C->getEndLoc());
12419}
12420
12421template <typename Derived>
12422OMPClause *TreeTransform<Derived>::TransformOMPXDynCGroupMemClause(
12423 OMPXDynCGroupMemClause *C) {
12424 ExprResult Size = getDerived().TransformExpr(C->getSize());
12425 if (Size.isInvalid())
12426 return nullptr;
12427 return getDerived().RebuildOMPXDynCGroupMemClause(
12428 Size.get(), C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
12429}
12430
12431template <typename Derived>
12432OMPClause *TreeTransform<Derived>::TransformOMPDynGroupprivateClause(
12433 OMPDynGroupprivateClause *C) {
12434 ExprResult Size = getDerived().TransformExpr(C->getSize());
12435 if (Size.isInvalid())
12436 return nullptr;
12437 return getDerived().RebuildOMPDynGroupprivateClause(
12438 C->getDynGroupprivateModifier(), C->getDynGroupprivateFallbackModifier(),
12439 Size.get(), C->getBeginLoc(), C->getLParenLoc(),
12440 C->getDynGroupprivateModifierLoc(),
12441 C->getDynGroupprivateFallbackModifierLoc(), C->getEndLoc());
12442}
12443
12444template <typename Derived>
12445OMPClause *
12446TreeTransform<Derived>::TransformOMPDoacrossClause(OMPDoacrossClause *C) {
12447 llvm::SmallVector<Expr *, 16> Vars;
12448 Vars.reserve(N: C->varlist_size());
12449 for (auto *VE : C->varlist()) {
12450 ExprResult EVar = getDerived().TransformExpr(cast<Expr>(Val: VE));
12451 if (EVar.isInvalid())
12452 return nullptr;
12453 Vars.push_back(Elt: EVar.get());
12454 }
12455 return getDerived().RebuildOMPDoacrossClause(
12456 C->getDependenceType(), C->getDependenceLoc(), C->getColonLoc(), Vars,
12457 C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
12458}
12459
12460template <typename Derived>
12461OMPClause *
12462TreeTransform<Derived>::TransformOMPXAttributeClause(OMPXAttributeClause *C) {
12463 SmallVector<const Attr *> NewAttrs;
12464 for (auto *A : C->getAttrs())
12465 NewAttrs.push_back(Elt: getDerived().TransformAttr(A));
12466 return getDerived().RebuildOMPXAttributeClause(
12467 NewAttrs, C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
12468}
12469
12470template <typename Derived>
12471OMPClause *TreeTransform<Derived>::TransformOMPXBareClause(OMPXBareClause *C) {
12472 return getDerived().RebuildOMPXBareClause(C->getBeginLoc(), C->getEndLoc());
12473}
12474
12475//===----------------------------------------------------------------------===//
12476// OpenACC transformation
12477//===----------------------------------------------------------------------===//
12478namespace {
12479template <typename Derived>
12480class OpenACCClauseTransform final
12481 : public OpenACCClauseVisitor<OpenACCClauseTransform<Derived>> {
12482 TreeTransform<Derived> &Self;
12483 ArrayRef<const OpenACCClause *> ExistingClauses;
12484 SemaOpenACC::OpenACCParsedClause &ParsedClause;
12485 OpenACCClause *NewClause = nullptr;
12486
12487 ExprResult VisitVar(Expr *VarRef) {
12488 ExprResult Res = Self.TransformExpr(VarRef);
12489
12490 if (!Res.isUsable())
12491 return Res;
12492
12493 Res = Self.getSema().OpenACC().ActOnVar(ParsedClause.getDirectiveKind(),
12494 ParsedClause.getClauseKind(),
12495 Res.get());
12496
12497 return Res;
12498 }
12499
12500 llvm::SmallVector<Expr *> VisitVarList(ArrayRef<Expr *> VarList) {
12501 llvm::SmallVector<Expr *> InstantiatedVarList;
12502 for (Expr *CurVar : VarList) {
12503 ExprResult VarRef = VisitVar(VarRef: CurVar);
12504
12505 if (VarRef.isUsable())
12506 InstantiatedVarList.push_back(Elt: VarRef.get());
12507 }
12508
12509 return InstantiatedVarList;
12510 }
12511
12512public:
12513 OpenACCClauseTransform(TreeTransform<Derived> &Self,
12514 ArrayRef<const OpenACCClause *> ExistingClauses,
12515 SemaOpenACC::OpenACCParsedClause &PC)
12516 : Self(Self), ExistingClauses(ExistingClauses), ParsedClause(PC) {}
12517
12518 OpenACCClause *CreatedClause() const { return NewClause; }
12519
12520#define VISIT_CLAUSE(CLAUSE_NAME) \
12521 void Visit##CLAUSE_NAME##Clause(const OpenACC##CLAUSE_NAME##Clause &Clause);
12522#include "clang/Basic/OpenACCClauses.def"
12523};
12524
12525template <typename Derived>
12526void OpenACCClauseTransform<Derived>::VisitDefaultClause(
12527 const OpenACCDefaultClause &C) {
12528 ParsedClause.setDefaultDetails(C.getDefaultClauseKind());
12529
12530 NewClause = OpenACCDefaultClause::Create(
12531 C: Self.getSema().getASTContext(), K: ParsedClause.getDefaultClauseKind(),
12532 BeginLoc: ParsedClause.getBeginLoc(), LParenLoc: ParsedClause.getLParenLoc(),
12533 EndLoc: ParsedClause.getEndLoc());
12534}
12535
12536template <typename Derived>
12537void OpenACCClauseTransform<Derived>::VisitIfClause(const OpenACCIfClause &C) {
12538 Expr *Cond = const_cast<Expr *>(C.getConditionExpr());
12539 assert(Cond && "If constructed with invalid Condition");
12540 Sema::ConditionResult Res = Self.TransformCondition(
12541 Cond->getExprLoc(), /*Var=*/nullptr, Cond, Sema::ConditionKind::Boolean);
12542
12543 if (Res.isInvalid() || !Res.get().second)
12544 return;
12545
12546 ParsedClause.setConditionDetails(Res.get().second);
12547
12548 NewClause = OpenACCIfClause::Create(
12549 C: Self.getSema().getASTContext(), BeginLoc: ParsedClause.getBeginLoc(),
12550 LParenLoc: ParsedClause.getLParenLoc(), ConditionExpr: ParsedClause.getConditionExpr(),
12551 EndLoc: ParsedClause.getEndLoc());
12552}
12553
12554template <typename Derived>
12555void OpenACCClauseTransform<Derived>::VisitSelfClause(
12556 const OpenACCSelfClause &C) {
12557
12558 // If this is an 'update' 'self' clause, this is actually a var list instead.
12559 if (ParsedClause.getDirectiveKind() == OpenACCDirectiveKind::Update) {
12560 llvm::SmallVector<Expr *> InstantiatedVarList;
12561 for (Expr *CurVar : C.getVarList()) {
12562 ExprResult Res = Self.TransformExpr(CurVar);
12563
12564 if (!Res.isUsable())
12565 continue;
12566
12567 Res = Self.getSema().OpenACC().ActOnVar(ParsedClause.getDirectiveKind(),
12568 ParsedClause.getClauseKind(),
12569 Res.get());
12570
12571 if (Res.isUsable())
12572 InstantiatedVarList.push_back(Elt: Res.get());
12573 }
12574
12575 ParsedClause.setVarListDetails(VarList: InstantiatedVarList,
12576 ModKind: OpenACCModifierKind::Invalid);
12577
12578 NewClause = OpenACCSelfClause::Create(
12579 Self.getSema().getASTContext(), ParsedClause.getBeginLoc(),
12580 ParsedClause.getLParenLoc(), ParsedClause.getVarList(),
12581 ParsedClause.getEndLoc());
12582 } else {
12583
12584 if (C.hasConditionExpr()) {
12585 Expr *Cond = const_cast<Expr *>(C.getConditionExpr());
12586 Sema::ConditionResult Res =
12587 Self.TransformCondition(Cond->getExprLoc(), /*Var=*/nullptr, Cond,
12588 Sema::ConditionKind::Boolean);
12589
12590 if (Res.isInvalid() || !Res.get().second)
12591 return;
12592
12593 ParsedClause.setConditionDetails(Res.get().second);
12594 }
12595
12596 NewClause = OpenACCSelfClause::Create(
12597 Self.getSema().getASTContext(), ParsedClause.getBeginLoc(),
12598 ParsedClause.getLParenLoc(), ParsedClause.getConditionExpr(),
12599 ParsedClause.getEndLoc());
12600 }
12601}
12602
12603template <typename Derived>
12604void OpenACCClauseTransform<Derived>::VisitNumGangsClause(
12605 const OpenACCNumGangsClause &C) {
12606 llvm::SmallVector<Expr *> InstantiatedIntExprs;
12607
12608 for (Expr *CurIntExpr : C.getIntExprs()) {
12609 ExprResult Res = Self.TransformExpr(CurIntExpr);
12610
12611 if (!Res.isUsable())
12612 return;
12613
12614 Res = Self.getSema().OpenACC().ActOnIntExpr(OpenACCDirectiveKind::Invalid,
12615 C.getClauseKind(),
12616 C.getBeginLoc(), Res.get());
12617 if (!Res.isUsable())
12618 return;
12619
12620 InstantiatedIntExprs.push_back(Elt: Res.get());
12621 }
12622
12623 ParsedClause.setIntExprDetails(InstantiatedIntExprs);
12624 NewClause = OpenACCNumGangsClause::Create(
12625 C: Self.getSema().getASTContext(), BeginLoc: ParsedClause.getBeginLoc(),
12626 LParenLoc: ParsedClause.getLParenLoc(), IntExprs: ParsedClause.getIntExprs(),
12627 EndLoc: ParsedClause.getEndLoc());
12628}
12629
12630template <typename Derived>
12631void OpenACCClauseTransform<Derived>::VisitPrivateClause(
12632 const OpenACCPrivateClause &C) {
12633 llvm::SmallVector<Expr *> InstantiatedVarList;
12634 llvm::SmallVector<OpenACCPrivateRecipe> InitRecipes;
12635
12636 for (const auto [RefExpr, InitRecipe] :
12637 llvm::zip(t: C.getVarList(), u: C.getInitRecipes())) {
12638 ExprResult VarRef = VisitVar(VarRef: RefExpr);
12639
12640 if (VarRef.isUsable()) {
12641 InstantiatedVarList.push_back(Elt: VarRef.get());
12642
12643 // We only have to create a new one if it is dependent, and Sema won't
12644 // make one of these unless the type is non-dependent.
12645 if (InitRecipe.isSet())
12646 InitRecipes.push_back(Elt: InitRecipe);
12647 else
12648 InitRecipes.push_back(
12649 Elt: Self.getSema().OpenACC().CreatePrivateInitRecipe(VarRef.get()));
12650 }
12651 }
12652 ParsedClause.setVarListDetails(VarList: InstantiatedVarList,
12653 ModKind: OpenACCModifierKind::Invalid);
12654
12655 NewClause = OpenACCPrivateClause::Create(
12656 C: Self.getSema().getASTContext(), BeginLoc: ParsedClause.getBeginLoc(),
12657 LParenLoc: ParsedClause.getLParenLoc(), VarList: ParsedClause.getVarList(), InitRecipes,
12658 EndLoc: ParsedClause.getEndLoc());
12659}
12660
12661template <typename Derived>
12662void OpenACCClauseTransform<Derived>::VisitHostClause(
12663 const OpenACCHostClause &C) {
12664 ParsedClause.setVarListDetails(VisitVarList(VarList: C.getVarList()),
12665 OpenACCModifierKind::Invalid);
12666
12667 NewClause = OpenACCHostClause::Create(
12668 C: Self.getSema().getASTContext(), BeginLoc: ParsedClause.getBeginLoc(),
12669 LParenLoc: ParsedClause.getLParenLoc(), VarList: ParsedClause.getVarList(),
12670 EndLoc: ParsedClause.getEndLoc());
12671}
12672
12673template <typename Derived>
12674void OpenACCClauseTransform<Derived>::VisitDeviceClause(
12675 const OpenACCDeviceClause &C) {
12676 ParsedClause.setVarListDetails(VisitVarList(VarList: C.getVarList()),
12677 OpenACCModifierKind::Invalid);
12678
12679 NewClause = OpenACCDeviceClause::Create(
12680 C: Self.getSema().getASTContext(), BeginLoc: ParsedClause.getBeginLoc(),
12681 LParenLoc: ParsedClause.getLParenLoc(), VarList: ParsedClause.getVarList(),
12682 EndLoc: ParsedClause.getEndLoc());
12683}
12684
12685template <typename Derived>
12686void OpenACCClauseTransform<Derived>::VisitFirstPrivateClause(
12687 const OpenACCFirstPrivateClause &C) {
12688 llvm::SmallVector<Expr *> InstantiatedVarList;
12689 llvm::SmallVector<OpenACCFirstPrivateRecipe> InitRecipes;
12690
12691 for (const auto [RefExpr, InitRecipe] :
12692 llvm::zip(t: C.getVarList(), u: C.getInitRecipes())) {
12693 ExprResult VarRef = VisitVar(VarRef: RefExpr);
12694
12695 if (VarRef.isUsable()) {
12696 InstantiatedVarList.push_back(Elt: VarRef.get());
12697
12698 // We only have to create a new one if it is dependent, and Sema won't
12699 // make one of these unless the type is non-dependent.
12700 if (InitRecipe.isSet())
12701 InitRecipes.push_back(Elt: InitRecipe);
12702 else
12703 InitRecipes.push_back(
12704 Elt: Self.getSema().OpenACC().CreateFirstPrivateInitRecipe(
12705 VarRef.get()));
12706 }
12707 }
12708 ParsedClause.setVarListDetails(VarList: InstantiatedVarList,
12709 ModKind: OpenACCModifierKind::Invalid);
12710
12711 NewClause = OpenACCFirstPrivateClause::Create(
12712 C: Self.getSema().getASTContext(), BeginLoc: ParsedClause.getBeginLoc(),
12713 LParenLoc: ParsedClause.getLParenLoc(), VarList: ParsedClause.getVarList(), InitRecipes,
12714 EndLoc: ParsedClause.getEndLoc());
12715}
12716
12717template <typename Derived>
12718void OpenACCClauseTransform<Derived>::VisitNoCreateClause(
12719 const OpenACCNoCreateClause &C) {
12720 ParsedClause.setVarListDetails(VisitVarList(VarList: C.getVarList()),
12721 OpenACCModifierKind::Invalid);
12722
12723 NewClause = OpenACCNoCreateClause::Create(
12724 C: Self.getSema().getASTContext(), BeginLoc: ParsedClause.getBeginLoc(),
12725 LParenLoc: ParsedClause.getLParenLoc(), VarList: ParsedClause.getVarList(),
12726 EndLoc: ParsedClause.getEndLoc());
12727}
12728
12729template <typename Derived>
12730void OpenACCClauseTransform<Derived>::VisitPresentClause(
12731 const OpenACCPresentClause &C) {
12732 ParsedClause.setVarListDetails(VisitVarList(VarList: C.getVarList()),
12733 OpenACCModifierKind::Invalid);
12734
12735 NewClause = OpenACCPresentClause::Create(
12736 C: Self.getSema().getASTContext(), BeginLoc: ParsedClause.getBeginLoc(),
12737 LParenLoc: ParsedClause.getLParenLoc(), VarList: ParsedClause.getVarList(),
12738 EndLoc: ParsedClause.getEndLoc());
12739}
12740
12741template <typename Derived>
12742void OpenACCClauseTransform<Derived>::VisitCopyClause(
12743 const OpenACCCopyClause &C) {
12744 ParsedClause.setVarListDetails(VisitVarList(VarList: C.getVarList()),
12745 C.getModifierList());
12746
12747 NewClause = OpenACCCopyClause::Create(
12748 C: Self.getSema().getASTContext(), Spelling: ParsedClause.getClauseKind(),
12749 BeginLoc: ParsedClause.getBeginLoc(), LParenLoc: ParsedClause.getLParenLoc(),
12750 Mods: ParsedClause.getModifierList(), VarList: ParsedClause.getVarList(),
12751 EndLoc: ParsedClause.getEndLoc());
12752}
12753
12754template <typename Derived>
12755void OpenACCClauseTransform<Derived>::VisitLinkClause(
12756 const OpenACCLinkClause &C) {
12757 llvm_unreachable("link clause not valid unless a decl transform");
12758}
12759
12760template <typename Derived>
12761void OpenACCClauseTransform<Derived>::VisitDeviceResidentClause(
12762 const OpenACCDeviceResidentClause &C) {
12763 llvm_unreachable("device_resident clause not valid unless a decl transform");
12764}
12765template <typename Derived>
12766void OpenACCClauseTransform<Derived>::VisitNoHostClause(
12767 const OpenACCNoHostClause &C) {
12768 llvm_unreachable("nohost clause not valid unless a decl transform");
12769}
12770template <typename Derived>
12771void OpenACCClauseTransform<Derived>::VisitBindClause(
12772 const OpenACCBindClause &C) {
12773 llvm_unreachable("bind clause not valid unless a decl transform");
12774}
12775
12776template <typename Derived>
12777void OpenACCClauseTransform<Derived>::VisitCopyInClause(
12778 const OpenACCCopyInClause &C) {
12779 ParsedClause.setVarListDetails(VisitVarList(VarList: C.getVarList()),
12780 C.getModifierList());
12781
12782 NewClause = OpenACCCopyInClause::Create(
12783 C: Self.getSema().getASTContext(), Spelling: ParsedClause.getClauseKind(),
12784 BeginLoc: ParsedClause.getBeginLoc(), LParenLoc: ParsedClause.getLParenLoc(),
12785 Mods: ParsedClause.getModifierList(), VarList: ParsedClause.getVarList(),
12786 EndLoc: ParsedClause.getEndLoc());
12787}
12788
12789template <typename Derived>
12790void OpenACCClauseTransform<Derived>::VisitCopyOutClause(
12791 const OpenACCCopyOutClause &C) {
12792 ParsedClause.setVarListDetails(VisitVarList(VarList: C.getVarList()),
12793 C.getModifierList());
12794
12795 NewClause = OpenACCCopyOutClause::Create(
12796 C: Self.getSema().getASTContext(), Spelling: ParsedClause.getClauseKind(),
12797 BeginLoc: ParsedClause.getBeginLoc(), LParenLoc: ParsedClause.getLParenLoc(),
12798 Mods: ParsedClause.getModifierList(), VarList: ParsedClause.getVarList(),
12799 EndLoc: ParsedClause.getEndLoc());
12800}
12801
12802template <typename Derived>
12803void OpenACCClauseTransform<Derived>::VisitCreateClause(
12804 const OpenACCCreateClause &C) {
12805 ParsedClause.setVarListDetails(VisitVarList(VarList: C.getVarList()),
12806 C.getModifierList());
12807
12808 NewClause = OpenACCCreateClause::Create(
12809 C: Self.getSema().getASTContext(), Spelling: ParsedClause.getClauseKind(),
12810 BeginLoc: ParsedClause.getBeginLoc(), LParenLoc: ParsedClause.getLParenLoc(),
12811 Mods: ParsedClause.getModifierList(), VarList: ParsedClause.getVarList(),
12812 EndLoc: ParsedClause.getEndLoc());
12813}
12814template <typename Derived>
12815void OpenACCClauseTransform<Derived>::VisitAttachClause(
12816 const OpenACCAttachClause &C) {
12817 llvm::SmallVector<Expr *> VarList = VisitVarList(VarList: C.getVarList());
12818
12819 // Ensure each var is a pointer type.
12820 llvm::erase_if(VarList, [&](Expr *E) {
12821 return Self.getSema().OpenACC().CheckVarIsPointerType(
12822 OpenACCClauseKind::Attach, E);
12823 });
12824
12825 ParsedClause.setVarListDetails(VarList, ModKind: OpenACCModifierKind::Invalid);
12826 NewClause = OpenACCAttachClause::Create(
12827 C: Self.getSema().getASTContext(), BeginLoc: ParsedClause.getBeginLoc(),
12828 LParenLoc: ParsedClause.getLParenLoc(), VarList: ParsedClause.getVarList(),
12829 EndLoc: ParsedClause.getEndLoc());
12830}
12831
12832template <typename Derived>
12833void OpenACCClauseTransform<Derived>::VisitDetachClause(
12834 const OpenACCDetachClause &C) {
12835 llvm::SmallVector<Expr *> VarList = VisitVarList(VarList: C.getVarList());
12836
12837 // Ensure each var is a pointer type.
12838 llvm::erase_if(VarList, [&](Expr *E) {
12839 return Self.getSema().OpenACC().CheckVarIsPointerType(
12840 OpenACCClauseKind::Detach, E);
12841 });
12842
12843 ParsedClause.setVarListDetails(VarList, ModKind: OpenACCModifierKind::Invalid);
12844 NewClause = OpenACCDetachClause::Create(
12845 C: Self.getSema().getASTContext(), BeginLoc: ParsedClause.getBeginLoc(),
12846 LParenLoc: ParsedClause.getLParenLoc(), VarList: ParsedClause.getVarList(),
12847 EndLoc: ParsedClause.getEndLoc());
12848}
12849
12850template <typename Derived>
12851void OpenACCClauseTransform<Derived>::VisitDeleteClause(
12852 const OpenACCDeleteClause &C) {
12853 ParsedClause.setVarListDetails(VisitVarList(VarList: C.getVarList()),
12854 OpenACCModifierKind::Invalid);
12855 NewClause = OpenACCDeleteClause::Create(
12856 C: Self.getSema().getASTContext(), BeginLoc: ParsedClause.getBeginLoc(),
12857 LParenLoc: ParsedClause.getLParenLoc(), VarList: ParsedClause.getVarList(),
12858 EndLoc: ParsedClause.getEndLoc());
12859}
12860
12861template <typename Derived>
12862void OpenACCClauseTransform<Derived>::VisitUseDeviceClause(
12863 const OpenACCUseDeviceClause &C) {
12864 ParsedClause.setVarListDetails(VisitVarList(VarList: C.getVarList()),
12865 OpenACCModifierKind::Invalid);
12866 NewClause = OpenACCUseDeviceClause::Create(
12867 C: Self.getSema().getASTContext(), BeginLoc: ParsedClause.getBeginLoc(),
12868 LParenLoc: ParsedClause.getLParenLoc(), VarList: ParsedClause.getVarList(),
12869 EndLoc: ParsedClause.getEndLoc());
12870}
12871
12872template <typename Derived>
12873void OpenACCClauseTransform<Derived>::VisitDevicePtrClause(
12874 const OpenACCDevicePtrClause &C) {
12875 llvm::SmallVector<Expr *> VarList = VisitVarList(VarList: C.getVarList());
12876
12877 // Ensure each var is a pointer type.
12878 llvm::erase_if(VarList, [&](Expr *E) {
12879 return Self.getSema().OpenACC().CheckVarIsPointerType(
12880 OpenACCClauseKind::DevicePtr, E);
12881 });
12882
12883 ParsedClause.setVarListDetails(VarList, ModKind: OpenACCModifierKind::Invalid);
12884 NewClause = OpenACCDevicePtrClause::Create(
12885 C: Self.getSema().getASTContext(), BeginLoc: ParsedClause.getBeginLoc(),
12886 LParenLoc: ParsedClause.getLParenLoc(), VarList: ParsedClause.getVarList(),
12887 EndLoc: ParsedClause.getEndLoc());
12888}
12889
12890template <typename Derived>
12891void OpenACCClauseTransform<Derived>::VisitNumWorkersClause(
12892 const OpenACCNumWorkersClause &C) {
12893 Expr *IntExpr = const_cast<Expr *>(C.getIntExpr());
12894 assert(IntExpr && "num_workers clause constructed with invalid int expr");
12895
12896 ExprResult Res = Self.TransformExpr(IntExpr);
12897 if (!Res.isUsable())
12898 return;
12899
12900 Res = Self.getSema().OpenACC().ActOnIntExpr(OpenACCDirectiveKind::Invalid,
12901 C.getClauseKind(),
12902 C.getBeginLoc(), Res.get());
12903 if (!Res.isUsable())
12904 return;
12905
12906 ParsedClause.setIntExprDetails(Res.get());
12907 NewClause = OpenACCNumWorkersClause::Create(
12908 C: Self.getSema().getASTContext(), BeginLoc: ParsedClause.getBeginLoc(),
12909 LParenLoc: ParsedClause.getLParenLoc(), IntExpr: ParsedClause.getIntExprs()[0],
12910 EndLoc: ParsedClause.getEndLoc());
12911}
12912
12913template <typename Derived>
12914void OpenACCClauseTransform<Derived>::VisitDeviceNumClause (
12915 const OpenACCDeviceNumClause &C) {
12916 Expr *IntExpr = const_cast<Expr *>(C.getIntExpr());
12917 assert(IntExpr && "device_num clause constructed with invalid int expr");
12918
12919 ExprResult Res = Self.TransformExpr(IntExpr);
12920 if (!Res.isUsable())
12921 return;
12922
12923 Res = Self.getSema().OpenACC().ActOnIntExpr(OpenACCDirectiveKind::Invalid,
12924 C.getClauseKind(),
12925 C.getBeginLoc(), Res.get());
12926 if (!Res.isUsable())
12927 return;
12928
12929 ParsedClause.setIntExprDetails(Res.get());
12930 NewClause = OpenACCDeviceNumClause::Create(
12931 C: Self.getSema().getASTContext(), BeginLoc: ParsedClause.getBeginLoc(),
12932 LParenLoc: ParsedClause.getLParenLoc(), IntExpr: ParsedClause.getIntExprs()[0],
12933 EndLoc: ParsedClause.getEndLoc());
12934}
12935
12936template <typename Derived>
12937void OpenACCClauseTransform<Derived>::VisitDefaultAsyncClause(
12938 const OpenACCDefaultAsyncClause &C) {
12939 Expr *IntExpr = const_cast<Expr *>(C.getIntExpr());
12940 assert(IntExpr && "default_async clause constructed with invalid int expr");
12941
12942 ExprResult Res = Self.TransformExpr(IntExpr);
12943 if (!Res.isUsable())
12944 return;
12945
12946 Res = Self.getSema().OpenACC().ActOnIntExpr(OpenACCDirectiveKind::Invalid,
12947 C.getClauseKind(),
12948 C.getBeginLoc(), Res.get());
12949 if (!Res.isUsable())
12950 return;
12951
12952 ParsedClause.setIntExprDetails(Res.get());
12953 NewClause = OpenACCDefaultAsyncClause::Create(
12954 C: Self.getSema().getASTContext(), BeginLoc: ParsedClause.getBeginLoc(),
12955 LParenLoc: ParsedClause.getLParenLoc(), IntExpr: ParsedClause.getIntExprs()[0],
12956 EndLoc: ParsedClause.getEndLoc());
12957}
12958
12959template <typename Derived>
12960void OpenACCClauseTransform<Derived>::VisitVectorLengthClause(
12961 const OpenACCVectorLengthClause &C) {
12962 Expr *IntExpr = const_cast<Expr *>(C.getIntExpr());
12963 assert(IntExpr && "vector_length clause constructed with invalid int expr");
12964
12965 ExprResult Res = Self.TransformExpr(IntExpr);
12966 if (!Res.isUsable())
12967 return;
12968
12969 Res = Self.getSema().OpenACC().ActOnIntExpr(OpenACCDirectiveKind::Invalid,
12970 C.getClauseKind(),
12971 C.getBeginLoc(), Res.get());
12972 if (!Res.isUsable())
12973 return;
12974
12975 ParsedClause.setIntExprDetails(Res.get());
12976 NewClause = OpenACCVectorLengthClause::Create(
12977 C: Self.getSema().getASTContext(), BeginLoc: ParsedClause.getBeginLoc(),
12978 LParenLoc: ParsedClause.getLParenLoc(), IntExpr: ParsedClause.getIntExprs()[0],
12979 EndLoc: ParsedClause.getEndLoc());
12980}
12981
12982template <typename Derived>
12983void OpenACCClauseTransform<Derived>::VisitAsyncClause(
12984 const OpenACCAsyncClause &C) {
12985 if (C.hasIntExpr()) {
12986 ExprResult Res = Self.TransformExpr(const_cast<Expr *>(C.getIntExpr()));
12987 if (!Res.isUsable())
12988 return;
12989
12990 Res = Self.getSema().OpenACC().ActOnIntExpr(OpenACCDirectiveKind::Invalid,
12991 C.getClauseKind(),
12992 C.getBeginLoc(), Res.get());
12993 if (!Res.isUsable())
12994 return;
12995 ParsedClause.setIntExprDetails(Res.get());
12996 }
12997
12998 NewClause = OpenACCAsyncClause::Create(
12999 C: Self.getSema().getASTContext(), BeginLoc: ParsedClause.getBeginLoc(),
13000 LParenLoc: ParsedClause.getLParenLoc(),
13001 IntExpr: ParsedClause.getNumIntExprs() != 0 ? ParsedClause.getIntExprs()[0]
13002 : nullptr,
13003 EndLoc: ParsedClause.getEndLoc());
13004}
13005
13006template <typename Derived>
13007void OpenACCClauseTransform<Derived>::VisitWorkerClause(
13008 const OpenACCWorkerClause &C) {
13009 if (C.hasIntExpr()) {
13010 // restrictions on this expression are all "does it exist in certain
13011 // situations" that are not possible to be dependent, so the only check we
13012 // have is that it transforms, and is an int expression.
13013 ExprResult Res = Self.TransformExpr(const_cast<Expr *>(C.getIntExpr()));
13014 if (!Res.isUsable())
13015 return;
13016
13017 Res = Self.getSema().OpenACC().ActOnIntExpr(OpenACCDirectiveKind::Invalid,
13018 C.getClauseKind(),
13019 C.getBeginLoc(), Res.get());
13020 if (!Res.isUsable())
13021 return;
13022 ParsedClause.setIntExprDetails(Res.get());
13023 }
13024
13025 NewClause = OpenACCWorkerClause::Create(
13026 Ctx: Self.getSema().getASTContext(), BeginLoc: ParsedClause.getBeginLoc(),
13027 LParenLoc: ParsedClause.getLParenLoc(),
13028 IntExpr: ParsedClause.getNumIntExprs() != 0 ? ParsedClause.getIntExprs()[0]
13029 : nullptr,
13030 EndLoc: ParsedClause.getEndLoc());
13031}
13032
13033template <typename Derived>
13034void OpenACCClauseTransform<Derived>::VisitVectorClause(
13035 const OpenACCVectorClause &C) {
13036 if (C.hasIntExpr()) {
13037 // restrictions on this expression are all "does it exist in certain
13038 // situations" that are not possible to be dependent, so the only check we
13039 // have is that it transforms, and is an int expression.
13040 ExprResult Res = Self.TransformExpr(const_cast<Expr *>(C.getIntExpr()));
13041 if (!Res.isUsable())
13042 return;
13043
13044 Res = Self.getSema().OpenACC().ActOnIntExpr(OpenACCDirectiveKind::Invalid,
13045 C.getClauseKind(),
13046 C.getBeginLoc(), Res.get());
13047 if (!Res.isUsable())
13048 return;
13049 ParsedClause.setIntExprDetails(Res.get());
13050 }
13051
13052 NewClause = OpenACCVectorClause::Create(
13053 Ctx: Self.getSema().getASTContext(), BeginLoc: ParsedClause.getBeginLoc(),
13054 LParenLoc: ParsedClause.getLParenLoc(),
13055 IntExpr: ParsedClause.getNumIntExprs() != 0 ? ParsedClause.getIntExprs()[0]
13056 : nullptr,
13057 EndLoc: ParsedClause.getEndLoc());
13058}
13059
13060template <typename Derived>
13061void OpenACCClauseTransform<Derived>::VisitWaitClause(
13062 const OpenACCWaitClause &C) {
13063 if (C.hasExprs()) {
13064 Expr *DevNumExpr = nullptr;
13065 llvm::SmallVector<Expr *> InstantiatedQueueIdExprs;
13066
13067 // Instantiate devnum expr if it exists.
13068 if (C.getDevNumExpr()) {
13069 ExprResult Res = Self.TransformExpr(C.getDevNumExpr());
13070 if (!Res.isUsable())
13071 return;
13072 Res = Self.getSema().OpenACC().ActOnIntExpr(OpenACCDirectiveKind::Invalid,
13073 C.getClauseKind(),
13074 C.getBeginLoc(), Res.get());
13075 if (!Res.isUsable())
13076 return;
13077
13078 DevNumExpr = Res.get();
13079 }
13080
13081 // Instantiate queue ids.
13082 for (Expr *CurQueueIdExpr : C.getQueueIdExprs()) {
13083 ExprResult Res = Self.TransformExpr(CurQueueIdExpr);
13084 if (!Res.isUsable())
13085 return;
13086 Res = Self.getSema().OpenACC().ActOnIntExpr(OpenACCDirectiveKind::Invalid,
13087 C.getClauseKind(),
13088 C.getBeginLoc(), Res.get());
13089 if (!Res.isUsable())
13090 return;
13091
13092 InstantiatedQueueIdExprs.push_back(Elt: Res.get());
13093 }
13094
13095 ParsedClause.setWaitDetails(DevNum: DevNumExpr, QueuesLoc: C.getQueuesLoc(),
13096 IntExprs: std::move(InstantiatedQueueIdExprs));
13097 }
13098
13099 NewClause = OpenACCWaitClause::Create(
13100 C: Self.getSema().getASTContext(), BeginLoc: ParsedClause.getBeginLoc(),
13101 LParenLoc: ParsedClause.getLParenLoc(), DevNumExpr: ParsedClause.getDevNumExpr(),
13102 QueuesLoc: ParsedClause.getQueuesLoc(), QueueIdExprs: ParsedClause.getQueueIdExprs(),
13103 EndLoc: ParsedClause.getEndLoc());
13104}
13105
13106template <typename Derived>
13107void OpenACCClauseTransform<Derived>::VisitDeviceTypeClause(
13108 const OpenACCDeviceTypeClause &C) {
13109 // Nothing to transform here, just create a new version of 'C'.
13110 NewClause = OpenACCDeviceTypeClause::Create(
13111 C: Self.getSema().getASTContext(), K: C.getClauseKind(),
13112 BeginLoc: ParsedClause.getBeginLoc(), LParenLoc: ParsedClause.getLParenLoc(),
13113 Archs: C.getArchitectures(), EndLoc: ParsedClause.getEndLoc());
13114}
13115
13116template <typename Derived>
13117void OpenACCClauseTransform<Derived>::VisitAutoClause(
13118 const OpenACCAutoClause &C) {
13119 // Nothing to do, so just create a new node.
13120 NewClause = OpenACCAutoClause::Create(Ctx: Self.getSema().getASTContext(),
13121 BeginLoc: ParsedClause.getBeginLoc(),
13122 EndLoc: ParsedClause.getEndLoc());
13123}
13124
13125template <typename Derived>
13126void OpenACCClauseTransform<Derived>::VisitIndependentClause(
13127 const OpenACCIndependentClause &C) {
13128 NewClause = OpenACCIndependentClause::Create(Ctx: Self.getSema().getASTContext(),
13129 BeginLoc: ParsedClause.getBeginLoc(),
13130 EndLoc: ParsedClause.getEndLoc());
13131}
13132
13133template <typename Derived>
13134void OpenACCClauseTransform<Derived>::VisitSeqClause(
13135 const OpenACCSeqClause &C) {
13136 NewClause = OpenACCSeqClause::Create(Ctx: Self.getSema().getASTContext(),
13137 BeginLoc: ParsedClause.getBeginLoc(),
13138 EndLoc: ParsedClause.getEndLoc());
13139}
13140template <typename Derived>
13141void OpenACCClauseTransform<Derived>::VisitFinalizeClause(
13142 const OpenACCFinalizeClause &C) {
13143 NewClause = OpenACCFinalizeClause::Create(Ctx: Self.getSema().getASTContext(),
13144 BeginLoc: ParsedClause.getBeginLoc(),
13145 EndLoc: ParsedClause.getEndLoc());
13146}
13147
13148template <typename Derived>
13149void OpenACCClauseTransform<Derived>::VisitIfPresentClause(
13150 const OpenACCIfPresentClause &C) {
13151 NewClause = OpenACCIfPresentClause::Create(Ctx: Self.getSema().getASTContext(),
13152 BeginLoc: ParsedClause.getBeginLoc(),
13153 EndLoc: ParsedClause.getEndLoc());
13154}
13155
13156template <typename Derived>
13157void OpenACCClauseTransform<Derived>::VisitReductionClause(
13158 const OpenACCReductionClause &C) {
13159 SmallVector<Expr *> TransformedVars = VisitVarList(VarList: C.getVarList());
13160 SmallVector<Expr *> ValidVars;
13161 llvm::SmallVector<OpenACCReductionRecipeWithStorage> Recipes;
13162
13163 for (const auto [Var, OrigRecipe] :
13164 llvm::zip(t&: TransformedVars, u: C.getRecipes())) {
13165 ExprResult Res = Self.getSema().OpenACC().CheckReductionVar(
13166 ParsedClause.getDirectiveKind(), C.getReductionOp(), Var);
13167 if (Res.isUsable()) {
13168 ValidVars.push_back(Elt: Res.get());
13169
13170 if (OrigRecipe.isSet())
13171 Recipes.emplace_back(Args: OrigRecipe.AllocaDecl, Args: OrigRecipe.CombinerRecipes);
13172 else
13173 Recipes.push_back(Self.getSema().OpenACC().CreateReductionInitRecipe(
13174 C.getReductionOp(), Res.get()));
13175 }
13176 }
13177
13178 NewClause = Self.getSema().OpenACC().CheckReductionClause(
13179 ExistingClauses, ParsedClause.getDirectiveKind(),
13180 ParsedClause.getBeginLoc(), ParsedClause.getLParenLoc(),
13181 C.getReductionOp(), ValidVars, Recipes, ParsedClause.getEndLoc());
13182}
13183
13184template <typename Derived>
13185void OpenACCClauseTransform<Derived>::VisitCollapseClause(
13186 const OpenACCCollapseClause &C) {
13187 Expr *LoopCount = const_cast<Expr *>(C.getLoopCount());
13188 assert(LoopCount && "collapse clause constructed with invalid loop count");
13189
13190 ExprResult NewLoopCount = Self.TransformExpr(LoopCount);
13191
13192 if (!NewLoopCount.isUsable())
13193 return;
13194
13195 NewLoopCount = Self.getSema().OpenACC().ActOnIntExpr(
13196 OpenACCDirectiveKind::Invalid, ParsedClause.getClauseKind(),
13197 NewLoopCount.get()->getBeginLoc(), NewLoopCount.get());
13198
13199 // FIXME: It isn't clear whether this is properly tested here, we should
13200 // probably see if we can come up with a test for this.
13201 if (!NewLoopCount.isUsable())
13202 return;
13203
13204 NewLoopCount =
13205 Self.getSema().OpenACC().CheckCollapseLoopCount(NewLoopCount.get());
13206
13207 // FIXME: It isn't clear whether this is properly tested here, we should
13208 // probably see if we can come up with a test for this.
13209 if (!NewLoopCount.isUsable())
13210 return;
13211
13212 ParsedClause.setCollapseDetails(IsForce: C.hasForce(), LoopCount: NewLoopCount.get());
13213 NewClause = OpenACCCollapseClause::Create(
13214 C: Self.getSema().getASTContext(), BeginLoc: ParsedClause.getBeginLoc(),
13215 LParenLoc: ParsedClause.getLParenLoc(), HasForce: ParsedClause.isForce(),
13216 LoopCount: ParsedClause.getLoopCount(), EndLoc: ParsedClause.getEndLoc());
13217}
13218
13219template <typename Derived>
13220void OpenACCClauseTransform<Derived>::VisitTileClause(
13221 const OpenACCTileClause &C) {
13222
13223 llvm::SmallVector<Expr *> TransformedExprs;
13224
13225 for (Expr *E : C.getSizeExprs()) {
13226 ExprResult NewSizeExpr = Self.TransformExpr(E);
13227
13228 if (!NewSizeExpr.isUsable())
13229 return;
13230
13231 NewSizeExpr = Self.getSema().OpenACC().ActOnIntExpr(
13232 OpenACCDirectiveKind::Invalid, ParsedClause.getClauseKind(),
13233 NewSizeExpr.get()->getBeginLoc(), NewSizeExpr.get());
13234
13235 // FIXME: It isn't clear whether this is properly tested here, we should
13236 // probably see if we can come up with a test for this.
13237 if (!NewSizeExpr.isUsable())
13238 return;
13239
13240 NewSizeExpr = Self.getSema().OpenACC().CheckTileSizeExpr(NewSizeExpr.get());
13241
13242 if (!NewSizeExpr.isUsable())
13243 return;
13244 TransformedExprs.push_back(Elt: NewSizeExpr.get());
13245 }
13246
13247 ParsedClause.setIntExprDetails(TransformedExprs);
13248 NewClause = OpenACCTileClause::Create(
13249 C: Self.getSema().getASTContext(), BeginLoc: ParsedClause.getBeginLoc(),
13250 LParenLoc: ParsedClause.getLParenLoc(), SizeExprs: ParsedClause.getIntExprs(),
13251 EndLoc: ParsedClause.getEndLoc());
13252}
13253template <typename Derived>
13254void OpenACCClauseTransform<Derived>::VisitGangClause(
13255 const OpenACCGangClause &C) {
13256 llvm::SmallVector<OpenACCGangKind> TransformedGangKinds;
13257 llvm::SmallVector<Expr *> TransformedIntExprs;
13258
13259 for (unsigned I = 0; I < C.getNumExprs(); ++I) {
13260 ExprResult ER = Self.TransformExpr(const_cast<Expr *>(C.getExpr(I).second));
13261 if (!ER.isUsable())
13262 continue;
13263
13264 ER = Self.getSema().OpenACC().CheckGangExpr(ExistingClauses,
13265 ParsedClause.getDirectiveKind(),
13266 C.getExpr(I).first, ER.get());
13267 if (!ER.isUsable())
13268 continue;
13269 TransformedGangKinds.push_back(Elt: C.getExpr(I).first);
13270 TransformedIntExprs.push_back(Elt: ER.get());
13271 }
13272
13273 NewClause = Self.getSema().OpenACC().CheckGangClause(
13274 ParsedClause.getDirectiveKind(), ExistingClauses,
13275 ParsedClause.getBeginLoc(), ParsedClause.getLParenLoc(),
13276 TransformedGangKinds, TransformedIntExprs, ParsedClause.getEndLoc());
13277}
13278} // namespace
13279template <typename Derived>
13280OpenACCClause *TreeTransform<Derived>::TransformOpenACCClause(
13281 ArrayRef<const OpenACCClause *> ExistingClauses,
13282 OpenACCDirectiveKind DirKind, const OpenACCClause *OldClause) {
13283
13284 SemaOpenACC::OpenACCParsedClause ParsedClause(
13285 DirKind, OldClause->getClauseKind(), OldClause->getBeginLoc());
13286 ParsedClause.setEndLoc(OldClause->getEndLoc());
13287
13288 if (const auto *WithParms = dyn_cast<OpenACCClauseWithParams>(Val: OldClause))
13289 ParsedClause.setLParenLoc(WithParms->getLParenLoc());
13290
13291 OpenACCClauseTransform<Derived> Transform{*this, ExistingClauses,
13292 ParsedClause};
13293 Transform.Visit(OldClause);
13294
13295 return Transform.CreatedClause();
13296}
13297
13298template <typename Derived>
13299llvm::SmallVector<OpenACCClause *>
13300TreeTransform<Derived>::TransformOpenACCClauseList(
13301 OpenACCDirectiveKind DirKind, ArrayRef<const OpenACCClause *> OldClauses) {
13302 llvm::SmallVector<OpenACCClause *> TransformedClauses;
13303 for (const auto *Clause : OldClauses) {
13304 if (OpenACCClause *TransformedClause = getDerived().TransformOpenACCClause(
13305 TransformedClauses, DirKind, Clause))
13306 TransformedClauses.push_back(Elt: TransformedClause);
13307 }
13308 return TransformedClauses;
13309}
13310
13311template <typename Derived>
13312StmtResult TreeTransform<Derived>::TransformOpenACCComputeConstruct(
13313 OpenACCComputeConstruct *C) {
13314 getSema().OpenACC().ActOnConstruct(C->getDirectiveKind(), C->getBeginLoc());
13315
13316 llvm::SmallVector<OpenACCClause *> TransformedClauses =
13317 getDerived().TransformOpenACCClauseList(C->getDirectiveKind(),
13318 C->clauses());
13319
13320 if (getSema().OpenACC().ActOnStartStmtDirective(
13321 C->getDirectiveKind(), C->getBeginLoc(), TransformedClauses))
13322 return StmtError();
13323
13324 // Transform Structured Block.
13325 SemaOpenACC::AssociatedStmtRAII AssocStmtRAII(
13326 getSema().OpenACC(), C->getDirectiveKind(), C->getDirectiveLoc(),
13327 C->clauses(), TransformedClauses);
13328 StmtResult StrBlock = getDerived().TransformStmt(C->getStructuredBlock());
13329 StrBlock = getSema().OpenACC().ActOnAssociatedStmt(
13330 C->getBeginLoc(), C->getDirectiveKind(), TransformedClauses, StrBlock);
13331
13332 return getDerived().RebuildOpenACCComputeConstruct(
13333 C->getDirectiveKind(), C->getBeginLoc(), C->getDirectiveLoc(),
13334 C->getEndLoc(), TransformedClauses, StrBlock);
13335}
13336
13337template <typename Derived>
13338StmtResult
13339TreeTransform<Derived>::TransformOpenACCLoopConstruct(OpenACCLoopConstruct *C) {
13340
13341 getSema().OpenACC().ActOnConstruct(C->getDirectiveKind(), C->getBeginLoc());
13342
13343 llvm::SmallVector<OpenACCClause *> TransformedClauses =
13344 getDerived().TransformOpenACCClauseList(C->getDirectiveKind(),
13345 C->clauses());
13346
13347 if (getSema().OpenACC().ActOnStartStmtDirective(
13348 C->getDirectiveKind(), C->getBeginLoc(), TransformedClauses))
13349 return StmtError();
13350
13351 // Transform Loop.
13352 SemaOpenACC::AssociatedStmtRAII AssocStmtRAII(
13353 getSema().OpenACC(), C->getDirectiveKind(), C->getDirectiveLoc(),
13354 C->clauses(), TransformedClauses);
13355 StmtResult Loop = getDerived().TransformStmt(C->getLoop());
13356 Loop = getSema().OpenACC().ActOnAssociatedStmt(
13357 C->getBeginLoc(), C->getDirectiveKind(), TransformedClauses, Loop);
13358
13359 return getDerived().RebuildOpenACCLoopConstruct(
13360 C->getBeginLoc(), C->getDirectiveLoc(), C->getEndLoc(),
13361 TransformedClauses, Loop);
13362}
13363
13364template <typename Derived>
13365StmtResult TreeTransform<Derived>::TransformOpenACCCombinedConstruct(
13366 OpenACCCombinedConstruct *C) {
13367 getSema().OpenACC().ActOnConstruct(C->getDirectiveKind(), C->getBeginLoc());
13368
13369 llvm::SmallVector<OpenACCClause *> TransformedClauses =
13370 getDerived().TransformOpenACCClauseList(C->getDirectiveKind(),
13371 C->clauses());
13372
13373 if (getSema().OpenACC().ActOnStartStmtDirective(
13374 C->getDirectiveKind(), C->getBeginLoc(), TransformedClauses))
13375 return StmtError();
13376
13377 // Transform Loop.
13378 SemaOpenACC::AssociatedStmtRAII AssocStmtRAII(
13379 getSema().OpenACC(), C->getDirectiveKind(), C->getDirectiveLoc(),
13380 C->clauses(), TransformedClauses);
13381 StmtResult Loop = getDerived().TransformStmt(C->getLoop());
13382 Loop = getSema().OpenACC().ActOnAssociatedStmt(
13383 C->getBeginLoc(), C->getDirectiveKind(), TransformedClauses, Loop);
13384
13385 return getDerived().RebuildOpenACCCombinedConstruct(
13386 C->getDirectiveKind(), C->getBeginLoc(), C->getDirectiveLoc(),
13387 C->getEndLoc(), TransformedClauses, Loop);
13388}
13389
13390template <typename Derived>
13391StmtResult
13392TreeTransform<Derived>::TransformOpenACCDataConstruct(OpenACCDataConstruct *C) {
13393 getSema().OpenACC().ActOnConstruct(C->getDirectiveKind(), C->getBeginLoc());
13394
13395 llvm::SmallVector<OpenACCClause *> TransformedClauses =
13396 getDerived().TransformOpenACCClauseList(C->getDirectiveKind(),
13397 C->clauses());
13398 if (getSema().OpenACC().ActOnStartStmtDirective(
13399 C->getDirectiveKind(), C->getBeginLoc(), TransformedClauses))
13400 return StmtError();
13401
13402 SemaOpenACC::AssociatedStmtRAII AssocStmtRAII(
13403 getSema().OpenACC(), C->getDirectiveKind(), C->getDirectiveLoc(),
13404 C->clauses(), TransformedClauses);
13405 StmtResult StrBlock = getDerived().TransformStmt(C->getStructuredBlock());
13406 StrBlock = getSema().OpenACC().ActOnAssociatedStmt(
13407 C->getBeginLoc(), C->getDirectiveKind(), TransformedClauses, StrBlock);
13408
13409 return getDerived().RebuildOpenACCDataConstruct(
13410 C->getBeginLoc(), C->getDirectiveLoc(), C->getEndLoc(),
13411 TransformedClauses, StrBlock);
13412}
13413
13414template <typename Derived>
13415StmtResult TreeTransform<Derived>::TransformOpenACCEnterDataConstruct(
13416 OpenACCEnterDataConstruct *C) {
13417 getSema().OpenACC().ActOnConstruct(C->getDirectiveKind(), C->getBeginLoc());
13418
13419 llvm::SmallVector<OpenACCClause *> TransformedClauses =
13420 getDerived().TransformOpenACCClauseList(C->getDirectiveKind(),
13421 C->clauses());
13422 if (getSema().OpenACC().ActOnStartStmtDirective(
13423 C->getDirectiveKind(), C->getBeginLoc(), TransformedClauses))
13424 return StmtError();
13425
13426 return getDerived().RebuildOpenACCEnterDataConstruct(
13427 C->getBeginLoc(), C->getDirectiveLoc(), C->getEndLoc(),
13428 TransformedClauses);
13429}
13430
13431template <typename Derived>
13432StmtResult TreeTransform<Derived>::TransformOpenACCExitDataConstruct(
13433 OpenACCExitDataConstruct *C) {
13434 getSema().OpenACC().ActOnConstruct(C->getDirectiveKind(), C->getBeginLoc());
13435
13436 llvm::SmallVector<OpenACCClause *> TransformedClauses =
13437 getDerived().TransformOpenACCClauseList(C->getDirectiveKind(),
13438 C->clauses());
13439 if (getSema().OpenACC().ActOnStartStmtDirective(
13440 C->getDirectiveKind(), C->getBeginLoc(), TransformedClauses))
13441 return StmtError();
13442
13443 return getDerived().RebuildOpenACCExitDataConstruct(
13444 C->getBeginLoc(), C->getDirectiveLoc(), C->getEndLoc(),
13445 TransformedClauses);
13446}
13447
13448template <typename Derived>
13449StmtResult TreeTransform<Derived>::TransformOpenACCHostDataConstruct(
13450 OpenACCHostDataConstruct *C) {
13451 getSema().OpenACC().ActOnConstruct(C->getDirectiveKind(), C->getBeginLoc());
13452
13453 llvm::SmallVector<OpenACCClause *> TransformedClauses =
13454 getDerived().TransformOpenACCClauseList(C->getDirectiveKind(),
13455 C->clauses());
13456 if (getSema().OpenACC().ActOnStartStmtDirective(
13457 C->getDirectiveKind(), C->getBeginLoc(), TransformedClauses))
13458 return StmtError();
13459
13460 SemaOpenACC::AssociatedStmtRAII AssocStmtRAII(
13461 getSema().OpenACC(), C->getDirectiveKind(), C->getDirectiveLoc(),
13462 C->clauses(), TransformedClauses);
13463 StmtResult StrBlock = getDerived().TransformStmt(C->getStructuredBlock());
13464 StrBlock = getSema().OpenACC().ActOnAssociatedStmt(
13465 C->getBeginLoc(), C->getDirectiveKind(), TransformedClauses, StrBlock);
13466
13467 return getDerived().RebuildOpenACCHostDataConstruct(
13468 C->getBeginLoc(), C->getDirectiveLoc(), C->getEndLoc(),
13469 TransformedClauses, StrBlock);
13470}
13471
13472template <typename Derived>
13473StmtResult
13474TreeTransform<Derived>::TransformOpenACCInitConstruct(OpenACCInitConstruct *C) {
13475 getSema().OpenACC().ActOnConstruct(C->getDirectiveKind(), C->getBeginLoc());
13476
13477 llvm::SmallVector<OpenACCClause *> TransformedClauses =
13478 getDerived().TransformOpenACCClauseList(C->getDirectiveKind(),
13479 C->clauses());
13480 if (getSema().OpenACC().ActOnStartStmtDirective(
13481 C->getDirectiveKind(), C->getBeginLoc(), TransformedClauses))
13482 return StmtError();
13483
13484 return getDerived().RebuildOpenACCInitConstruct(
13485 C->getBeginLoc(), C->getDirectiveLoc(), C->getEndLoc(),
13486 TransformedClauses);
13487}
13488
13489template <typename Derived>
13490StmtResult TreeTransform<Derived>::TransformOpenACCShutdownConstruct(
13491 OpenACCShutdownConstruct *C) {
13492 getSema().OpenACC().ActOnConstruct(C->getDirectiveKind(), C->getBeginLoc());
13493
13494 llvm::SmallVector<OpenACCClause *> TransformedClauses =
13495 getDerived().TransformOpenACCClauseList(C->getDirectiveKind(),
13496 C->clauses());
13497 if (getSema().OpenACC().ActOnStartStmtDirective(
13498 C->getDirectiveKind(), C->getBeginLoc(), TransformedClauses))
13499 return StmtError();
13500
13501 return getDerived().RebuildOpenACCShutdownConstruct(
13502 C->getBeginLoc(), C->getDirectiveLoc(), C->getEndLoc(),
13503 TransformedClauses);
13504}
13505template <typename Derived>
13506StmtResult
13507TreeTransform<Derived>::TransformOpenACCSetConstruct(OpenACCSetConstruct *C) {
13508 getSema().OpenACC().ActOnConstruct(C->getDirectiveKind(), C->getBeginLoc());
13509
13510 llvm::SmallVector<OpenACCClause *> TransformedClauses =
13511 getDerived().TransformOpenACCClauseList(C->getDirectiveKind(),
13512 C->clauses());
13513 if (getSema().OpenACC().ActOnStartStmtDirective(
13514 C->getDirectiveKind(), C->getBeginLoc(), TransformedClauses))
13515 return StmtError();
13516
13517 return getDerived().RebuildOpenACCSetConstruct(
13518 C->getBeginLoc(), C->getDirectiveLoc(), C->getEndLoc(),
13519 TransformedClauses);
13520}
13521
13522template <typename Derived>
13523StmtResult TreeTransform<Derived>::TransformOpenACCUpdateConstruct(
13524 OpenACCUpdateConstruct *C) {
13525 getSema().OpenACC().ActOnConstruct(C->getDirectiveKind(), C->getBeginLoc());
13526
13527 llvm::SmallVector<OpenACCClause *> TransformedClauses =
13528 getDerived().TransformOpenACCClauseList(C->getDirectiveKind(),
13529 C->clauses());
13530 if (getSema().OpenACC().ActOnStartStmtDirective(
13531 C->getDirectiveKind(), C->getBeginLoc(), TransformedClauses))
13532 return StmtError();
13533
13534 return getDerived().RebuildOpenACCUpdateConstruct(
13535 C->getBeginLoc(), C->getDirectiveLoc(), C->getEndLoc(),
13536 TransformedClauses);
13537}
13538
13539template <typename Derived>
13540StmtResult
13541TreeTransform<Derived>::TransformOpenACCWaitConstruct(OpenACCWaitConstruct *C) {
13542 getSema().OpenACC().ActOnConstruct(C->getDirectiveKind(), C->getBeginLoc());
13543
13544 ExprResult DevNumExpr;
13545 if (C->hasDevNumExpr()) {
13546 DevNumExpr = getDerived().TransformExpr(C->getDevNumExpr());
13547
13548 if (DevNumExpr.isUsable())
13549 DevNumExpr = getSema().OpenACC().ActOnIntExpr(
13550 OpenACCDirectiveKind::Wait, OpenACCClauseKind::Invalid,
13551 C->getBeginLoc(), DevNumExpr.get());
13552 }
13553
13554 llvm::SmallVector<Expr *> QueueIdExprs;
13555
13556 for (Expr *QE : C->getQueueIdExprs()) {
13557 assert(QE && "Null queue id expr?");
13558 ExprResult NewEQ = getDerived().TransformExpr(QE);
13559
13560 if (!NewEQ.isUsable())
13561 break;
13562 NewEQ = getSema().OpenACC().ActOnIntExpr(OpenACCDirectiveKind::Wait,
13563 OpenACCClauseKind::Invalid,
13564 C->getBeginLoc(), NewEQ.get());
13565 if (NewEQ.isUsable())
13566 QueueIdExprs.push_back(Elt: NewEQ.get());
13567 }
13568
13569 llvm::SmallVector<OpenACCClause *> TransformedClauses =
13570 getDerived().TransformOpenACCClauseList(C->getDirectiveKind(),
13571 C->clauses());
13572
13573 if (getSema().OpenACC().ActOnStartStmtDirective(
13574 C->getDirectiveKind(), C->getBeginLoc(), TransformedClauses))
13575 return StmtError();
13576
13577 return getDerived().RebuildOpenACCWaitConstruct(
13578 C->getBeginLoc(), C->getDirectiveLoc(), C->getLParenLoc(),
13579 DevNumExpr.isUsable() ? DevNumExpr.get() : nullptr, C->getQueuesLoc(),
13580 QueueIdExprs, C->getRParenLoc(), C->getEndLoc(), TransformedClauses);
13581}
13582template <typename Derived>
13583StmtResult TreeTransform<Derived>::TransformOpenACCCacheConstruct(
13584 OpenACCCacheConstruct *C) {
13585 getSema().OpenACC().ActOnConstruct(C->getDirectiveKind(), C->getBeginLoc());
13586
13587 llvm::SmallVector<Expr *> TransformedVarList;
13588 for (Expr *Var : C->getVarList()) {
13589 assert(Var && "Null var listexpr?");
13590
13591 ExprResult NewVar = getDerived().TransformExpr(Var);
13592
13593 if (!NewVar.isUsable())
13594 break;
13595
13596 NewVar = getSema().OpenACC().ActOnVar(
13597 C->getDirectiveKind(), OpenACCClauseKind::Invalid, NewVar.get());
13598 if (!NewVar.isUsable())
13599 break;
13600
13601 TransformedVarList.push_back(Elt: NewVar.get());
13602 }
13603
13604 if (getSema().OpenACC().ActOnStartStmtDirective(C->getDirectiveKind(),
13605 C->getBeginLoc(), {}))
13606 return StmtError();
13607
13608 return getDerived().RebuildOpenACCCacheConstruct(
13609 C->getBeginLoc(), C->getDirectiveLoc(), C->getLParenLoc(),
13610 C->getReadOnlyLoc(), TransformedVarList, C->getRParenLoc(),
13611 C->getEndLoc());
13612}
13613
13614template <typename Derived>
13615StmtResult TreeTransform<Derived>::TransformOpenACCAtomicConstruct(
13616 OpenACCAtomicConstruct *C) {
13617 getSema().OpenACC().ActOnConstruct(C->getDirectiveKind(), C->getBeginLoc());
13618
13619 llvm::SmallVector<OpenACCClause *> TransformedClauses =
13620 getDerived().TransformOpenACCClauseList(C->getDirectiveKind(),
13621 C->clauses());
13622
13623 if (getSema().OpenACC().ActOnStartStmtDirective(C->getDirectiveKind(),
13624 C->getBeginLoc(), {}))
13625 return StmtError();
13626
13627 // Transform Associated Stmt.
13628 SemaOpenACC::AssociatedStmtRAII AssocStmtRAII(
13629 getSema().OpenACC(), C->getDirectiveKind(), C->getDirectiveLoc(), {}, {});
13630
13631 StmtResult AssocStmt = getDerived().TransformStmt(C->getAssociatedStmt());
13632 AssocStmt = getSema().OpenACC().ActOnAssociatedStmt(
13633 C->getBeginLoc(), C->getDirectiveKind(), C->getAtomicKind(), {},
13634 AssocStmt);
13635
13636 return getDerived().RebuildOpenACCAtomicConstruct(
13637 C->getBeginLoc(), C->getDirectiveLoc(), C->getAtomicKind(),
13638 C->getEndLoc(), TransformedClauses, AssocStmt);
13639}
13640
13641template <typename Derived>
13642ExprResult TreeTransform<Derived>::TransformOpenACCAsteriskSizeExpr(
13643 OpenACCAsteriskSizeExpr *E) {
13644 if (getDerived().AlwaysRebuild())
13645 return getDerived().RebuildOpenACCAsteriskSizeExpr(E->getLocation());
13646 // Nothing can ever change, so there is never anything to transform.
13647 return E;
13648}
13649
13650//===----------------------------------------------------------------------===//
13651// Expression transformation
13652//===----------------------------------------------------------------------===//
13653template<typename Derived>
13654ExprResult
13655TreeTransform<Derived>::TransformConstantExpr(ConstantExpr *E) {
13656 return TransformExpr(E: E->getSubExpr());
13657}
13658
13659template <typename Derived>
13660ExprResult TreeTransform<Derived>::TransformSYCLUniqueStableNameExpr(
13661 SYCLUniqueStableNameExpr *E) {
13662 if (!E->isTypeDependent())
13663 return E;
13664
13665 TypeSourceInfo *NewT = getDerived().TransformType(E->getTypeSourceInfo());
13666
13667 if (!NewT)
13668 return ExprError();
13669
13670 if (!getDerived().AlwaysRebuild() && E->getTypeSourceInfo() == NewT)
13671 return E;
13672
13673 return getDerived().RebuildSYCLUniqueStableNameExpr(
13674 E->getLocation(), E->getLParenLocation(), E->getRParenLocation(), NewT);
13675}
13676
13677template <typename Derived>
13678StmtResult TreeTransform<Derived>::TransformUnresolvedSYCLKernelCallStmt(
13679 UnresolvedSYCLKernelCallStmt *S) {
13680 auto *FD = cast<FunctionDecl>(Val: SemaRef.CurContext);
13681 const auto *SKEPAttr = FD->template getAttr<SYCLKernelEntryPointAttr>();
13682 if (!SKEPAttr || SKEPAttr->isInvalidAttr())
13683 return StmtError();
13684
13685 ExprResult IdExpr = getDerived().TransformExpr(S->getKernelLaunchIdExpr());
13686 if (IdExpr.isInvalid())
13687 return StmtError();
13688
13689 StmtResult Body = getDerived().TransformStmt(S->getOriginalStmt());
13690 if (Body.isInvalid())
13691 return StmtError();
13692
13693 StmtResult SR = SemaRef.SYCL().BuildSYCLKernelCallStmt(
13694 FD: cast<FunctionDecl>(Val: SemaRef.CurContext), Body: cast<CompoundStmt>(Val: Body.get()),
13695 LaunchIdExpr: IdExpr.get());
13696 if (SR.isInvalid())
13697 return StmtError();
13698
13699 return SR;
13700}
13701
13702template <typename Derived>
13703ExprResult TreeTransform<Derived>::TransformCXXReflectExpr(CXXReflectExpr *E) {
13704 // TODO(reflection): Implement its transform
13705
13706 switch (E->getKind()) {
13707 case ReflectionKind::Type: {
13708 TypeSourceInfo *NewT = getDerived().TransformType(
13709 const_cast<TypeSourceInfo *>(E->getTypeSourceInfo()));
13710 if (!NewT)
13711 return ExprError();
13712 return SemaRef.BuildCXXReflectExpr(OperatorLoc: E->getOperatorLoc(), TSI: NewT);
13713 }
13714 case ReflectionKind::Null:
13715 llvm_unreachable("A null reflection should not reach here");
13716 }
13717
13718 assert(false && "unknown or unimplemented reflection entities");
13719 return ExprError();
13720}
13721
13722template<typename Derived>
13723ExprResult
13724TreeTransform<Derived>::TransformPredefinedExpr(PredefinedExpr *E) {
13725 if (!E->isTypeDependent())
13726 return E;
13727
13728 return getDerived().RebuildPredefinedExpr(E->getLocation(),
13729 E->getIdentKind());
13730}
13731
13732template<typename Derived>
13733ExprResult
13734TreeTransform<Derived>::TransformDeclRefExpr(DeclRefExpr *E) {
13735 NestedNameSpecifierLoc QualifierLoc;
13736 if (E->getQualifierLoc()) {
13737 QualifierLoc
13738 = getDerived().TransformNestedNameSpecifierLoc(E->getQualifierLoc());
13739 if (!QualifierLoc)
13740 return ExprError();
13741 }
13742
13743 ValueDecl *ND
13744 = cast_or_null<ValueDecl>(getDerived().TransformDecl(E->getLocation(),
13745 E->getDecl()));
13746 if (!ND || ND->isInvalidDecl())
13747 return ExprError();
13748
13749 NamedDecl *Found = ND;
13750 if (E->getFoundDecl() != E->getDecl()) {
13751 Found = cast_or_null<NamedDecl>(
13752 getDerived().TransformDecl(E->getLocation(), E->getFoundDecl()));
13753 if (!Found)
13754 return ExprError();
13755 }
13756
13757 DeclarationNameInfo NameInfo = E->getNameInfo();
13758 if (NameInfo.getName()) {
13759 NameInfo = getDerived().TransformDeclarationNameInfo(NameInfo);
13760 if (!NameInfo.getName())
13761 return ExprError();
13762 }
13763
13764 if (!getDerived().AlwaysRebuild() &&
13765 !E->isCapturedByCopyInLambdaWithExplicitObjectParameter() &&
13766 QualifierLoc == E->getQualifierLoc() && ND == E->getDecl() &&
13767 Found == E->getFoundDecl() &&
13768 NameInfo.getName() == E->getDecl()->getDeclName() &&
13769 !E->hasExplicitTemplateArgs()) {
13770
13771 // Mark it referenced in the new context regardless.
13772 // FIXME: this is a bit instantiation-specific.
13773 SemaRef.MarkDeclRefReferenced(E);
13774
13775 return E;
13776 }
13777
13778 TemplateArgumentListInfo TransArgs, *TemplateArgs = nullptr;
13779 if (E->hasExplicitTemplateArgs()) {
13780 TemplateArgs = &TransArgs;
13781 TransArgs.setLAngleLoc(E->getLAngleLoc());
13782 TransArgs.setRAngleLoc(E->getRAngleLoc());
13783 if (getDerived().TransformTemplateArguments(E->getTemplateArgs(),
13784 E->getNumTemplateArgs(),
13785 TransArgs))
13786 return ExprError();
13787 }
13788
13789 return getDerived().RebuildDeclRefExpr(QualifierLoc, ND, NameInfo,
13790 Found, TemplateArgs);
13791}
13792
13793template<typename Derived>
13794ExprResult
13795TreeTransform<Derived>::TransformIntegerLiteral(IntegerLiteral *E) {
13796 return E;
13797}
13798
13799template <typename Derived>
13800ExprResult TreeTransform<Derived>::TransformFixedPointLiteral(
13801 FixedPointLiteral *E) {
13802 return E;
13803}
13804
13805template<typename Derived>
13806ExprResult
13807TreeTransform<Derived>::TransformFloatingLiteral(FloatingLiteral *E) {
13808 return E;
13809}
13810
13811template<typename Derived>
13812ExprResult
13813TreeTransform<Derived>::TransformImaginaryLiteral(ImaginaryLiteral *E) {
13814 return E;
13815}
13816
13817template<typename Derived>
13818ExprResult
13819TreeTransform<Derived>::TransformStringLiteral(StringLiteral *E) {
13820 return E;
13821}
13822
13823template<typename Derived>
13824ExprResult
13825TreeTransform<Derived>::TransformCharacterLiteral(CharacterLiteral *E) {
13826 return E;
13827}
13828
13829template<typename Derived>
13830ExprResult
13831TreeTransform<Derived>::TransformUserDefinedLiteral(UserDefinedLiteral *E) {
13832 return getDerived().TransformCallExpr(E);
13833}
13834
13835template<typename Derived>
13836ExprResult
13837TreeTransform<Derived>::TransformGenericSelectionExpr(GenericSelectionExpr *E) {
13838 ExprResult ControllingExpr;
13839 TypeSourceInfo *ControllingType = nullptr;
13840 if (E->isExprPredicate())
13841 ControllingExpr = getDerived().TransformExpr(E->getControllingExpr());
13842 else
13843 ControllingType = getDerived().TransformType(E->getControllingType());
13844
13845 if (ControllingExpr.isInvalid() && !ControllingType)
13846 return ExprError();
13847
13848 SmallVector<Expr *, 4> AssocExprs;
13849 SmallVector<TypeSourceInfo *, 4> AssocTypes;
13850 for (const GenericSelectionExpr::Association Assoc : E->associations()) {
13851 TypeSourceInfo *TSI = Assoc.getTypeSourceInfo();
13852 if (TSI) {
13853 TypeSourceInfo *AssocType = getDerived().TransformType(TSI);
13854 if (!AssocType)
13855 return ExprError();
13856 AssocTypes.push_back(Elt: AssocType);
13857 } else {
13858 AssocTypes.push_back(Elt: nullptr);
13859 }
13860
13861 ExprResult AssocExpr =
13862 getDerived().TransformExpr(Assoc.getAssociationExpr());
13863 if (AssocExpr.isInvalid())
13864 return ExprError();
13865 AssocExprs.push_back(Elt: AssocExpr.get());
13866 }
13867
13868 if (!ControllingType)
13869 return getDerived().RebuildGenericSelectionExpr(E->getGenericLoc(),
13870 E->getDefaultLoc(),
13871 E->getRParenLoc(),
13872 ControllingExpr.get(),
13873 AssocTypes,
13874 AssocExprs);
13875 return getDerived().RebuildGenericSelectionExpr(
13876 E->getGenericLoc(), E->getDefaultLoc(), E->getRParenLoc(),
13877 ControllingType, AssocTypes, AssocExprs);
13878}
13879
13880template<typename Derived>
13881ExprResult
13882TreeTransform<Derived>::TransformParenExpr(ParenExpr *E) {
13883 ExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr());
13884 if (SubExpr.isInvalid())
13885 return ExprError();
13886
13887 if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getSubExpr())
13888 return E;
13889
13890 return getDerived().RebuildParenExpr(SubExpr.get(), E->getLParen(),
13891 E->getRParen());
13892}
13893
13894/// The operand of a unary address-of operator has special rules: it's
13895/// allowed to refer to a non-static member of a class even if there's no 'this'
13896/// object available.
13897template<typename Derived>
13898ExprResult
13899TreeTransform<Derived>::TransformAddressOfOperand(Expr *E) {
13900 if (DependentScopeDeclRefExpr *DRE = dyn_cast<DependentScopeDeclRefExpr>(Val: E))
13901 return getDerived().TransformDependentScopeDeclRefExpr(
13902 DRE, /*IsAddressOfOperand=*/true, nullptr);
13903 else if (UnresolvedLookupExpr *ULE = dyn_cast<UnresolvedLookupExpr>(Val: E))
13904 return getDerived().TransformUnresolvedLookupExpr(
13905 ULE, /*IsAddressOfOperand=*/true);
13906 else
13907 return getDerived().TransformExpr(E);
13908}
13909
13910template<typename Derived>
13911ExprResult
13912TreeTransform<Derived>::TransformUnaryOperator(UnaryOperator *E) {
13913 ExprResult SubExpr;
13914 if (E->getOpcode() == UO_AddrOf)
13915 SubExpr = TransformAddressOfOperand(E: E->getSubExpr());
13916 else
13917 SubExpr = TransformExpr(E: E->getSubExpr());
13918 if (SubExpr.isInvalid())
13919 return ExprError();
13920
13921 if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getSubExpr())
13922 return E;
13923
13924 return getDerived().RebuildUnaryOperator(E->getOperatorLoc(),
13925 E->getOpcode(),
13926 SubExpr.get());
13927}
13928
13929template<typename Derived>
13930ExprResult
13931TreeTransform<Derived>::TransformOffsetOfExpr(OffsetOfExpr *E) {
13932 // Transform the type.
13933 TypeSourceInfo *Type = getDerived().TransformType(E->getTypeSourceInfo());
13934 if (!Type)
13935 return ExprError();
13936
13937 // Transform all of the components into a Designation similar to what the
13938 // parser builds.
13939 // FIXME: It would be slightly more efficient in the non-dependent case to
13940 // just map FieldDecls, rather than requiring the rebuilder to look for
13941 // the fields again. However, __builtin_offsetof is rare enough in
13942 // template code that we don't care.
13943 bool ExprChanged = false;
13944 Designation Desig;
13945 for (unsigned I = 0, N = E->getNumComponents(); I != N; ++I) {
13946 const OffsetOfNode &ON = E->getComponent(Idx: I);
13947 switch (ON.getKind()) {
13948 case OffsetOfNode::Array: {
13949 Expr *FromIndex = E->getIndexExpr(Idx: ON.getArrayExprIndex());
13950 ExprResult Index = getDerived().TransformExpr(FromIndex);
13951 if (Index.isInvalid())
13952 return ExprError();
13953
13954 ExprChanged = ExprChanged || Index.get() != FromIndex;
13955 Designator AD =
13956 Designator::CreateArrayDesignator(Index: Index.get(), LBracketLoc: ON.getBeginLoc());
13957 AD.setRBracketLoc(ON.getEndLoc());
13958 Desig.AddDesignator(D: AD);
13959 break;
13960 }
13961
13962 case OffsetOfNode::Field:
13963 case OffsetOfNode::Identifier: {
13964 const IdentifierInfo *Name = ON.getFieldName();
13965 if (!Name)
13966 continue;
13967 // The leading designator has no '.'; subsequent ones do.
13968 SourceLocation DotLoc =
13969 Desig.empty() ? SourceLocation() : ON.getBeginLoc();
13970 Desig.AddDesignator(
13971 D: Designator::CreateFieldDesignator(FieldName: Name, DotLoc, FieldLoc: ON.getEndLoc()));
13972 break;
13973 }
13974
13975 case OffsetOfNode::Base:
13976 // Will be recomputed during the rebuild.
13977 continue;
13978 }
13979 }
13980
13981 // If nothing changed, retain the existing expression.
13982 if (!getDerived().AlwaysRebuild() &&
13983 Type == E->getTypeSourceInfo() &&
13984 !ExprChanged)
13985 return E;
13986
13987 // Build a new offsetof expression.
13988 return getDerived().RebuildOffsetOfExpr(E->getOperatorLoc(), Type, Desig,
13989 E->getRParenLoc());
13990}
13991
13992template<typename Derived>
13993ExprResult
13994TreeTransform<Derived>::TransformOpaqueValueExpr(OpaqueValueExpr *E) {
13995 assert((!E->getSourceExpr() || getDerived().AlreadyTransformed(E->getType())) &&
13996 "opaque value expression requires transformation");
13997 return E;
13998}
13999
14000template <typename Derived>
14001ExprResult TreeTransform<Derived>::TransformRecoveryExpr(RecoveryExpr *E) {
14002 llvm::SmallVector<Expr *, 8> Children;
14003 bool Changed = false;
14004 for (Expr *C : E->subExpressions()) {
14005 ExprResult NewC = getDerived().TransformExpr(C);
14006 if (NewC.isInvalid())
14007 return ExprError();
14008 Children.push_back(Elt: NewC.get());
14009
14010 Changed |= NewC.get() != C;
14011 }
14012 if (!getDerived().AlwaysRebuild() && !Changed)
14013 return E;
14014 return getDerived().RebuildRecoveryExpr(E->getBeginLoc(), E->getEndLoc(),
14015 Children, E->getType());
14016}
14017
14018template<typename Derived>
14019ExprResult
14020TreeTransform<Derived>::TransformPseudoObjectExpr(PseudoObjectExpr *E) {
14021 // Rebuild the syntactic form. The original syntactic form has
14022 // opaque-value expressions in it, so strip those away and rebuild
14023 // the result. This is a really awful way of doing this, but the
14024 // better solution (rebuilding the semantic expressions and
14025 // rebinding OVEs as necessary) doesn't work; we'd need
14026 // TreeTransform to not strip away implicit conversions.
14027 Expr *newSyntacticForm = SemaRef.PseudoObject().recreateSyntacticForm(E);
14028 ExprResult result = getDerived().TransformExpr(newSyntacticForm);
14029 if (result.isInvalid()) return ExprError();
14030
14031 // If that gives us a pseudo-object result back, the pseudo-object
14032 // expression must have been an lvalue-to-rvalue conversion which we
14033 // should reapply.
14034 if (result.get()->hasPlaceholderType(K: BuiltinType::PseudoObject))
14035 result = SemaRef.PseudoObject().checkRValue(E: result.get());
14036
14037 return result;
14038}
14039
14040template<typename Derived>
14041ExprResult
14042TreeTransform<Derived>::TransformUnaryExprOrTypeTraitExpr(
14043 UnaryExprOrTypeTraitExpr *E) {
14044 // C++0x [expr.sizeof]p1:
14045 // The operand is either an expression, which is an unevaluated operand
14046 // [...]
14047 EnterExpressionEvaluationContext Unevaluated(
14048 SemaRef, Sema::ExpressionEvaluationContext::Unevaluated,
14049 Sema::ReuseLambdaContextDecl);
14050
14051 if (E->isArgumentType()) {
14052 TypeSourceInfo *OldT = E->getArgumentTypeInfo();
14053
14054 TypeSourceInfo *NewT = getDerived().TransformType(OldT);
14055 if (!NewT)
14056 return ExprError();
14057
14058 if (!getDerived().AlwaysRebuild() && OldT == NewT)
14059 return E;
14060
14061 return getDerived().RebuildUnaryExprOrTypeTrait(NewT, E->getOperatorLoc(),
14062 E->getKind(),
14063 E->getSourceRange());
14064 }
14065
14066 // Try to recover if we have something like sizeof(T::X) where X is a type.
14067 // Notably, there must be *exactly* one set of parens if X is a type.
14068 TypeSourceInfo *RecoveryTSI = nullptr;
14069 ExprResult SubExpr;
14070 auto *PE = dyn_cast<ParenExpr>(Val: E->getArgumentExpr());
14071 if (auto *DRE =
14072 PE ? dyn_cast<DependentScopeDeclRefExpr>(Val: PE->getSubExpr()) : nullptr)
14073 SubExpr = getDerived().TransformParenDependentScopeDeclRefExpr(
14074 PE, DRE, false, &RecoveryTSI);
14075 else
14076 SubExpr = getDerived().TransformExpr(E->getArgumentExpr());
14077
14078 if (RecoveryTSI) {
14079 return getDerived().RebuildUnaryExprOrTypeTrait(
14080 RecoveryTSI, E->getOperatorLoc(), E->getKind(), E->getSourceRange());
14081 } else if (SubExpr.isInvalid())
14082 return ExprError();
14083
14084 if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getArgumentExpr())
14085 return E;
14086
14087 return getDerived().RebuildUnaryExprOrTypeTrait(SubExpr.get(),
14088 E->getOperatorLoc(),
14089 E->getKind(),
14090 E->getSourceRange());
14091}
14092
14093template<typename Derived>
14094ExprResult
14095TreeTransform<Derived>::TransformArraySubscriptExpr(ArraySubscriptExpr *E) {
14096 ExprResult LHS = getDerived().TransformExpr(E->getLHS());
14097 if (LHS.isInvalid())
14098 return ExprError();
14099
14100 ExprResult RHS = getDerived().TransformExpr(E->getRHS());
14101 if (RHS.isInvalid())
14102 return ExprError();
14103
14104
14105 if (!getDerived().AlwaysRebuild() &&
14106 LHS.get() == E->getLHS() &&
14107 RHS.get() == E->getRHS())
14108 return E;
14109
14110 return getDerived().RebuildArraySubscriptExpr(
14111 LHS.get(),
14112 /*FIXME:*/ E->getLHS()->getBeginLoc(), RHS.get(), E->getRBracketLoc());
14113}
14114
14115template <typename Derived>
14116ExprResult TreeTransform<Derived>::TransformMatrixSingleSubscriptExpr(
14117 MatrixSingleSubscriptExpr *E) {
14118 ExprResult Base = getDerived().TransformExpr(E->getBase());
14119 if (Base.isInvalid())
14120 return ExprError();
14121
14122 ExprResult RowIdx = getDerived().TransformExpr(E->getRowIdx());
14123 if (RowIdx.isInvalid())
14124 return ExprError();
14125
14126 if (!getDerived().AlwaysRebuild() && Base.get() == E->getBase() &&
14127 RowIdx.get() == E->getRowIdx())
14128 return E;
14129
14130 return getDerived().RebuildMatrixSingleSubscriptExpr(Base.get(), RowIdx.get(),
14131 E->getRBracketLoc());
14132}
14133
14134template <typename Derived>
14135ExprResult
14136TreeTransform<Derived>::TransformMatrixSubscriptExpr(MatrixSubscriptExpr *E) {
14137 ExprResult Base = getDerived().TransformExpr(E->getBase());
14138 if (Base.isInvalid())
14139 return ExprError();
14140
14141 ExprResult RowIdx = getDerived().TransformExpr(E->getRowIdx());
14142 if (RowIdx.isInvalid())
14143 return ExprError();
14144
14145 ExprResult ColumnIdx = getDerived().TransformExpr(E->getColumnIdx());
14146 if (ColumnIdx.isInvalid())
14147 return ExprError();
14148
14149 if (!getDerived().AlwaysRebuild() && Base.get() == E->getBase() &&
14150 RowIdx.get() == E->getRowIdx() && ColumnIdx.get() == E->getColumnIdx())
14151 return E;
14152
14153 return getDerived().RebuildMatrixSubscriptExpr(
14154 Base.get(), RowIdx.get(), ColumnIdx.get(), E->getRBracketLoc());
14155}
14156
14157template <typename Derived>
14158ExprResult
14159TreeTransform<Derived>::TransformArraySectionExpr(ArraySectionExpr *E) {
14160 ExprResult Base = getDerived().TransformExpr(E->getBase());
14161 if (Base.isInvalid())
14162 return ExprError();
14163
14164 ExprResult LowerBound;
14165 if (E->getLowerBound()) {
14166 LowerBound = getDerived().TransformExpr(E->getLowerBound());
14167 if (LowerBound.isInvalid())
14168 return ExprError();
14169 }
14170
14171 ExprResult Length;
14172 if (E->getLength()) {
14173 Length = getDerived().TransformExpr(E->getLength());
14174 if (Length.isInvalid())
14175 return ExprError();
14176 }
14177
14178 ExprResult Stride;
14179 if (E->isOMPArraySection()) {
14180 if (Expr *Str = E->getStride()) {
14181 Stride = getDerived().TransformExpr(Str);
14182 if (Stride.isInvalid())
14183 return ExprError();
14184 }
14185 }
14186
14187 if (!getDerived().AlwaysRebuild() && Base.get() == E->getBase() &&
14188 LowerBound.get() == E->getLowerBound() &&
14189 Length.get() == E->getLength() &&
14190 (E->isOpenACCArraySection() || Stride.get() == E->getStride()))
14191 return E;
14192
14193 return getDerived().RebuildArraySectionExpr(
14194 E->isOMPArraySection(), Base.get(), E->getBase()->getEndLoc(),
14195 LowerBound.get(), E->getColonLocFirst(),
14196 E->isOMPArraySection() ? E->getColonLocSecond() : SourceLocation{},
14197 Length.get(), Stride.get(), E->getRBracketLoc());
14198}
14199
14200template <typename Derived>
14201ExprResult
14202TreeTransform<Derived>::TransformOMPArrayShapingExpr(OMPArrayShapingExpr *E) {
14203 ExprResult Base = getDerived().TransformExpr(E->getBase());
14204 if (Base.isInvalid())
14205 return ExprError();
14206
14207 SmallVector<Expr *, 4> Dims;
14208 bool ErrorFound = false;
14209 for (Expr *Dim : E->getDimensions()) {
14210 ExprResult DimRes = getDerived().TransformExpr(Dim);
14211 if (DimRes.isInvalid()) {
14212 ErrorFound = true;
14213 continue;
14214 }
14215 Dims.push_back(Elt: DimRes.get());
14216 }
14217
14218 if (ErrorFound)
14219 return ExprError();
14220 return getDerived().RebuildOMPArrayShapingExpr(Base.get(), E->getLParenLoc(),
14221 E->getRParenLoc(), Dims,
14222 E->getBracketsRanges());
14223}
14224
14225template <typename Derived>
14226ExprResult
14227TreeTransform<Derived>::TransformOMPIteratorExpr(OMPIteratorExpr *E) {
14228 unsigned NumIterators = E->numOfIterators();
14229 SmallVector<SemaOpenMP::OMPIteratorData, 4> Data(NumIterators);
14230
14231 bool ErrorFound = false;
14232 bool NeedToRebuild = getDerived().AlwaysRebuild();
14233 for (unsigned I = 0; I < NumIterators; ++I) {
14234 auto *D = cast<VarDecl>(Val: E->getIteratorDecl(I));
14235 Data[I].DeclIdent = D->getIdentifier();
14236 Data[I].DeclIdentLoc = D->getLocation();
14237 if (D->getLocation() == D->getBeginLoc()) {
14238 assert(SemaRef.Context.hasSameType(D->getType(), SemaRef.Context.IntTy) &&
14239 "Implicit type must be int.");
14240 } else {
14241 TypeSourceInfo *TSI = getDerived().TransformType(D->getTypeSourceInfo());
14242 QualType DeclTy = getDerived().TransformType(D->getType());
14243 Data[I].Type = SemaRef.CreateParsedType(T: DeclTy, TInfo: TSI);
14244 }
14245 OMPIteratorExpr::IteratorRange Range = E->getIteratorRange(I);
14246 ExprResult Begin = getDerived().TransformExpr(Range.Begin);
14247 ExprResult End = getDerived().TransformExpr(Range.End);
14248 ExprResult Step = getDerived().TransformExpr(Range.Step);
14249 ErrorFound = ErrorFound ||
14250 !(!D->getTypeSourceInfo() || (Data[I].Type.getAsOpaquePtr() &&
14251 !Data[I].Type.get().isNull())) ||
14252 Begin.isInvalid() || End.isInvalid() || Step.isInvalid();
14253 if (ErrorFound)
14254 continue;
14255 Data[I].Range.Begin = Begin.get();
14256 Data[I].Range.End = End.get();
14257 Data[I].Range.Step = Step.get();
14258 Data[I].AssignLoc = E->getAssignLoc(I);
14259 Data[I].ColonLoc = E->getColonLoc(I);
14260 Data[I].SecColonLoc = E->getSecondColonLoc(I);
14261 NeedToRebuild =
14262 NeedToRebuild ||
14263 (D->getTypeSourceInfo() && Data[I].Type.get().getTypePtrOrNull() !=
14264 D->getType().getTypePtrOrNull()) ||
14265 Range.Begin != Data[I].Range.Begin || Range.End != Data[I].Range.End ||
14266 Range.Step != Data[I].Range.Step;
14267 }
14268 if (ErrorFound)
14269 return ExprError();
14270 if (!NeedToRebuild)
14271 return E;
14272
14273 ExprResult Res = getDerived().RebuildOMPIteratorExpr(
14274 E->getIteratorKwLoc(), E->getLParenLoc(), E->getRParenLoc(), Data);
14275 if (!Res.isUsable())
14276 return Res;
14277 auto *IE = cast<OMPIteratorExpr>(Val: Res.get());
14278 for (unsigned I = 0; I < NumIterators; ++I)
14279 getDerived().transformedLocalDecl(E->getIteratorDecl(I),
14280 IE->getIteratorDecl(I));
14281 return Res;
14282}
14283
14284template<typename Derived>
14285ExprResult
14286TreeTransform<Derived>::TransformCallExpr(CallExpr *E) {
14287 // Transform the callee.
14288 ExprResult Callee = getDerived().TransformExpr(E->getCallee());
14289 if (Callee.isInvalid())
14290 return ExprError();
14291
14292 // Transform arguments.
14293 bool ArgChanged = false;
14294 SmallVector<Expr*, 8> Args;
14295 if (getDerived().TransformExprs(E->getArgs(), E->getNumArgs(), true, Args,
14296 &ArgChanged))
14297 return ExprError();
14298
14299 if (!getDerived().AlwaysRebuild() &&
14300 Callee.get() == E->getCallee() &&
14301 !ArgChanged)
14302 return SemaRef.MaybeBindToTemporary(E);
14303
14304 // FIXME: Wrong source location information for the '('.
14305 SourceLocation FakeLParenLoc
14306 = ((Expr *)Callee.get())->getSourceRange().getBegin();
14307
14308 Sema::FPFeaturesStateRAII FPFeaturesState(getSema());
14309 if (E->hasStoredFPFeatures()) {
14310 FPOptionsOverride NewOverrides = E->getFPFeatures();
14311 getSema().CurFPFeatures =
14312 NewOverrides.applyOverrides(getSema().getLangOpts());
14313 getSema().FpPragmaStack.CurrentValue = NewOverrides;
14314 }
14315
14316 return getDerived().RebuildCallExpr(Callee.get(), FakeLParenLoc,
14317 Args,
14318 E->getRParenLoc());
14319}
14320
14321template<typename Derived>
14322ExprResult
14323TreeTransform<Derived>::TransformMemberExpr(MemberExpr *E) {
14324 ExprResult Base = getDerived().TransformExpr(E->getBase());
14325 if (Base.isInvalid())
14326 return ExprError();
14327
14328 NestedNameSpecifierLoc QualifierLoc;
14329 if (E->hasQualifier()) {
14330 QualifierLoc
14331 = getDerived().TransformNestedNameSpecifierLoc(E->getQualifierLoc());
14332
14333 if (!QualifierLoc)
14334 return ExprError();
14335 }
14336 SourceLocation TemplateKWLoc = E->getTemplateKeywordLoc();
14337
14338 ValueDecl *Member
14339 = cast_or_null<ValueDecl>(getDerived().TransformDecl(E->getMemberLoc(),
14340 E->getMemberDecl()));
14341 if (!Member)
14342 return ExprError();
14343
14344 NamedDecl *FoundDecl = E->getFoundDecl();
14345 if (FoundDecl == E->getMemberDecl()) {
14346 FoundDecl = Member;
14347 } else {
14348 FoundDecl = cast_or_null<NamedDecl>(
14349 getDerived().TransformDecl(E->getMemberLoc(), FoundDecl));
14350 if (!FoundDecl)
14351 return ExprError();
14352 }
14353
14354 if (!getDerived().AlwaysRebuild() &&
14355 Base.get() == E->getBase() &&
14356 QualifierLoc == E->getQualifierLoc() &&
14357 Member == E->getMemberDecl() &&
14358 FoundDecl == E->getFoundDecl() &&
14359 !E->hasExplicitTemplateArgs()) {
14360
14361 // Skip for member expression of (this->f), rebuilt thisi->f is needed
14362 // for Openmp where the field need to be privatizized in the case.
14363 if (!(isa<CXXThisExpr>(Val: E->getBase()) &&
14364 getSema().OpenMP().isOpenMPRebuildMemberExpr(
14365 cast<ValueDecl>(Val: Member)))) {
14366 // Mark it referenced in the new context regardless.
14367 // FIXME: this is a bit instantiation-specific.
14368 SemaRef.MarkMemberReferenced(E);
14369 return E;
14370 }
14371 }
14372
14373 TemplateArgumentListInfo TransArgs;
14374 if (E->hasExplicitTemplateArgs()) {
14375 TransArgs.setLAngleLoc(E->getLAngleLoc());
14376 TransArgs.setRAngleLoc(E->getRAngleLoc());
14377 if (getDerived().TransformTemplateArguments(E->getTemplateArgs(),
14378 E->getNumTemplateArgs(),
14379 TransArgs))
14380 return ExprError();
14381 }
14382
14383 // FIXME: Bogus source location for the operator
14384 SourceLocation FakeOperatorLoc =
14385 SemaRef.getLocForEndOfToken(Loc: E->getBase()->getSourceRange().getEnd());
14386
14387 // FIXME: to do this check properly, we will need to preserve the
14388 // first-qualifier-in-scope here, just in case we had a dependent
14389 // base (and therefore couldn't do the check) and a
14390 // nested-name-qualifier (and therefore could do the lookup).
14391 NamedDecl *FirstQualifierInScope = nullptr;
14392 DeclarationNameInfo MemberNameInfo = E->getMemberNameInfo();
14393 if (MemberNameInfo.getName()) {
14394 MemberNameInfo = getDerived().TransformDeclarationNameInfo(MemberNameInfo);
14395 if (!MemberNameInfo.getName())
14396 return ExprError();
14397 }
14398
14399 return getDerived().RebuildMemberExpr(Base.get(), FakeOperatorLoc,
14400 E->isArrow(),
14401 QualifierLoc,
14402 TemplateKWLoc,
14403 MemberNameInfo,
14404 Member,
14405 FoundDecl,
14406 (E->hasExplicitTemplateArgs()
14407 ? &TransArgs : nullptr),
14408 FirstQualifierInScope);
14409}
14410
14411template<typename Derived>
14412ExprResult
14413TreeTransform<Derived>::TransformBinaryOperator(BinaryOperator *E) {
14414 ExprResult LHS = getDerived().TransformExpr(E->getLHS());
14415 if (LHS.isInvalid())
14416 return ExprError();
14417
14418 ExprResult RHS =
14419 getDerived().TransformInitializer(E->getRHS(), /*NotCopyInit=*/false);
14420 if (RHS.isInvalid())
14421 return ExprError();
14422
14423 if (!getDerived().AlwaysRebuild() &&
14424 LHS.get() == E->getLHS() &&
14425 RHS.get() == E->getRHS())
14426 return E;
14427
14428 if (E->isCompoundAssignmentOp())
14429 // FPFeatures has already been established from trailing storage
14430 return getDerived().RebuildBinaryOperator(
14431 E->getOperatorLoc(), E->getOpcode(), LHS.get(), RHS.get());
14432 Sema::FPFeaturesStateRAII FPFeaturesState(getSema());
14433 FPOptionsOverride NewOverrides(E->getFPFeatures());
14434 getSema().CurFPFeatures =
14435 NewOverrides.applyOverrides(getSema().getLangOpts());
14436 getSema().FpPragmaStack.CurrentValue = NewOverrides;
14437 return getDerived().RebuildBinaryOperator(E->getOperatorLoc(), E->getOpcode(),
14438 LHS.get(), RHS.get());
14439}
14440
14441template <typename Derived>
14442ExprResult TreeTransform<Derived>::TransformCXXRewrittenBinaryOperator(
14443 CXXRewrittenBinaryOperator *E) {
14444 CXXRewrittenBinaryOperator::DecomposedForm Decomp = E->getDecomposedForm();
14445
14446 ExprResult LHS = getDerived().TransformExpr(const_cast<Expr*>(Decomp.LHS));
14447 if (LHS.isInvalid())
14448 return ExprError();
14449
14450 ExprResult RHS = getDerived().TransformExpr(const_cast<Expr*>(Decomp.RHS));
14451 if (RHS.isInvalid())
14452 return ExprError();
14453
14454 // Extract the already-resolved callee declarations so that we can restrict
14455 // ourselves to using them as the unqualified lookup results when rebuilding.
14456 UnresolvedSet<2> UnqualLookups;
14457 bool ChangedAnyLookups = false;
14458 Expr *PossibleBinOps[] = {E->getSemanticForm(),
14459 const_cast<Expr *>(Decomp.InnerBinOp)};
14460 for (Expr *PossibleBinOp : PossibleBinOps) {
14461 auto *Op = dyn_cast<CXXOperatorCallExpr>(Val: PossibleBinOp->IgnoreImplicit());
14462 if (!Op)
14463 continue;
14464 auto *Callee = dyn_cast<DeclRefExpr>(Val: Op->getCallee()->IgnoreImplicit());
14465 if (!Callee || isa<CXXMethodDecl>(Val: Callee->getDecl()))
14466 continue;
14467
14468 // Transform the callee in case we built a call to a local extern
14469 // declaration.
14470 NamedDecl *Found = cast_or_null<NamedDecl>(getDerived().TransformDecl(
14471 E->getOperatorLoc(), Callee->getFoundDecl()));
14472 if (!Found)
14473 return ExprError();
14474 if (Found != Callee->getFoundDecl())
14475 ChangedAnyLookups = true;
14476 UnqualLookups.addDecl(D: Found);
14477 }
14478
14479 if (!getDerived().AlwaysRebuild() && !ChangedAnyLookups &&
14480 LHS.get() == Decomp.LHS && RHS.get() == Decomp.RHS) {
14481 // Mark all functions used in the rewrite as referenced. Note that when
14482 // a < b is rewritten to (a <=> b) < 0, both the <=> and the < might be
14483 // function calls, and/or there might be a user-defined conversion sequence
14484 // applied to the operands of the <.
14485 // FIXME: this is a bit instantiation-specific.
14486 const Expr *StopAt[] = {Decomp.LHS, Decomp.RHS};
14487 SemaRef.MarkDeclarationsReferencedInExpr(E, SkipLocalVariables: false, StopAt);
14488 return E;
14489 }
14490
14491 return getDerived().RebuildCXXRewrittenBinaryOperator(
14492 E->getOperatorLoc(), Decomp.Opcode, UnqualLookups, LHS.get(), RHS.get());
14493}
14494
14495template<typename Derived>
14496ExprResult
14497TreeTransform<Derived>::TransformCompoundAssignOperator(
14498 CompoundAssignOperator *E) {
14499 Sema::FPFeaturesStateRAII FPFeaturesState(getSema());
14500 FPOptionsOverride NewOverrides(E->getFPFeatures());
14501 getSema().CurFPFeatures =
14502 NewOverrides.applyOverrides(getSema().getLangOpts());
14503 getSema().FpPragmaStack.CurrentValue = NewOverrides;
14504 return getDerived().TransformBinaryOperator(E);
14505}
14506
14507template<typename Derived>
14508ExprResult TreeTransform<Derived>::
14509TransformBinaryConditionalOperator(BinaryConditionalOperator *e) {
14510 // Just rebuild the common and RHS expressions and see whether we
14511 // get any changes.
14512
14513 ExprResult commonExpr = getDerived().TransformExpr(e->getCommon());
14514 if (commonExpr.isInvalid())
14515 return ExprError();
14516
14517 ExprResult rhs = getDerived().TransformExpr(e->getFalseExpr());
14518 if (rhs.isInvalid())
14519 return ExprError();
14520
14521 if (!getDerived().AlwaysRebuild() &&
14522 commonExpr.get() == e->getCommon() &&
14523 rhs.get() == e->getFalseExpr())
14524 return e;
14525
14526 return getDerived().RebuildConditionalOperator(commonExpr.get(),
14527 e->getQuestionLoc(),
14528 nullptr,
14529 e->getColonLoc(),
14530 rhs.get());
14531}
14532
14533template<typename Derived>
14534ExprResult
14535TreeTransform<Derived>::TransformConditionalOperator(ConditionalOperator *E) {
14536 ExprResult Cond = getDerived().TransformExpr(E->getCond());
14537 if (Cond.isInvalid())
14538 return ExprError();
14539
14540 ExprResult LHS = getDerived().TransformExpr(E->getLHS());
14541 if (LHS.isInvalid())
14542 return ExprError();
14543
14544 ExprResult RHS = getDerived().TransformExpr(E->getRHS());
14545 if (RHS.isInvalid())
14546 return ExprError();
14547
14548 if (!getDerived().AlwaysRebuild() &&
14549 Cond.get() == E->getCond() &&
14550 LHS.get() == E->getLHS() &&
14551 RHS.get() == E->getRHS())
14552 return E;
14553
14554 return getDerived().RebuildConditionalOperator(Cond.get(),
14555 E->getQuestionLoc(),
14556 LHS.get(),
14557 E->getColonLoc(),
14558 RHS.get());
14559}
14560
14561template<typename Derived>
14562ExprResult
14563TreeTransform<Derived>::TransformImplicitCastExpr(ImplicitCastExpr *E) {
14564 // Implicit casts are eliminated during transformation, since they
14565 // will be recomputed by semantic analysis after transformation.
14566 return getDerived().TransformExpr(E->getSubExprAsWritten());
14567}
14568
14569template<typename Derived>
14570ExprResult
14571TreeTransform<Derived>::TransformCStyleCastExpr(CStyleCastExpr *E) {
14572 TypeSourceInfo *Type = getDerived().TransformType(E->getTypeInfoAsWritten());
14573 if (!Type)
14574 return ExprError();
14575
14576 ExprResult SubExpr
14577 = getDerived().TransformExpr(E->getSubExprAsWritten());
14578 if (SubExpr.isInvalid())
14579 return ExprError();
14580
14581 if (!getDerived().AlwaysRebuild() &&
14582 Type == E->getTypeInfoAsWritten() &&
14583 SubExpr.get() == E->getSubExpr())
14584 return E;
14585
14586 return getDerived().RebuildCStyleCastExpr(E->getLParenLoc(),
14587 Type,
14588 E->getRParenLoc(),
14589 SubExpr.get());
14590}
14591
14592template<typename Derived>
14593ExprResult
14594TreeTransform<Derived>::TransformCompoundLiteralExpr(CompoundLiteralExpr *E) {
14595 TypeSourceInfo *OldT = E->getTypeSourceInfo();
14596 TypeSourceInfo *NewT = getDerived().TransformType(OldT);
14597 if (!NewT)
14598 return ExprError();
14599
14600 ExprResult Init = getDerived().TransformExpr(E->getInitializer());
14601 if (Init.isInvalid())
14602 return ExprError();
14603
14604 if (!getDerived().AlwaysRebuild() &&
14605 OldT == NewT &&
14606 Init.get() == E->getInitializer())
14607 return SemaRef.MaybeBindToTemporary(E);
14608
14609 // Note: the expression type doesn't necessarily match the
14610 // type-as-written, but that's okay, because it should always be
14611 // derivable from the initializer.
14612
14613 return getDerived().RebuildCompoundLiteralExpr(
14614 E->getLParenLoc(), NewT,
14615 /*FIXME:*/ E->getInitializer()->getEndLoc(), Init.get());
14616}
14617
14618template<typename Derived>
14619ExprResult
14620TreeTransform<Derived>::TransformExtVectorElementExpr(ExtVectorElementExpr *E) {
14621 ExprResult Base = getDerived().TransformExpr(E->getBase());
14622 if (Base.isInvalid())
14623 return ExprError();
14624
14625 if (!getDerived().AlwaysRebuild() &&
14626 Base.get() == E->getBase())
14627 return E;
14628
14629 // FIXME: Bad source location
14630 SourceLocation FakeOperatorLoc =
14631 SemaRef.getLocForEndOfToken(Loc: E->getBase()->getEndLoc());
14632 return getDerived().RebuildExtVectorOrMatrixElementExpr(
14633 Base.get(), FakeOperatorLoc, E->isArrow(), E->getAccessorLoc(),
14634 E->getAccessor());
14635}
14636
14637template <typename Derived>
14638ExprResult
14639TreeTransform<Derived>::TransformMatrixElementExpr(MatrixElementExpr *E) {
14640 ExprResult Base = getDerived().TransformExpr(E->getBase());
14641 if (Base.isInvalid())
14642 return ExprError();
14643
14644 if (!getDerived().AlwaysRebuild() && Base.get() == E->getBase())
14645 return E;
14646
14647 // FIXME: Bad source location
14648 SourceLocation FakeOperatorLoc =
14649 SemaRef.getLocForEndOfToken(Loc: E->getBase()->getEndLoc());
14650 return getDerived().RebuildExtVectorOrMatrixElementExpr(
14651 Base.get(), FakeOperatorLoc, /*isArrow*/ false, E->getAccessorLoc(),
14652 E->getAccessor());
14653}
14654
14655template<typename Derived>
14656ExprResult
14657TreeTransform<Derived>::TransformInitListExpr(InitListExpr *E) {
14658 if (InitListExpr *Syntactic = E->getSyntacticForm())
14659 E = Syntactic;
14660
14661 bool InitChanged = false;
14662
14663 EnterExpressionEvaluationContext Context(
14664 getSema(), EnterExpressionEvaluationContext::InitList);
14665
14666 SmallVector<Expr*, 4> Inits;
14667 if (getDerived().TransformExprs(E->getInits(), E->getNumInits(), false,
14668 Inits, &InitChanged))
14669 return ExprError();
14670
14671 if (!getDerived().AlwaysRebuild() && !InitChanged) {
14672 // FIXME: Attempt to reuse the existing syntactic form of the InitListExpr
14673 // in some cases. We can't reuse it in general, because the syntactic and
14674 // semantic forms are linked, and we can't know that semantic form will
14675 // match even if the syntactic form does.
14676 }
14677
14678 return getDerived().RebuildInitList(E->getLBraceLoc(), Inits,
14679 E->getRBraceLoc(), E->isExplicit());
14680}
14681
14682template<typename Derived>
14683ExprResult
14684TreeTransform<Derived>::TransformDesignatedInitExpr(DesignatedInitExpr *E) {
14685 Designation Desig;
14686
14687 // transform the initializer value
14688 ExprResult Init = getDerived().TransformExpr(E->getInit());
14689 if (Init.isInvalid())
14690 return ExprError();
14691
14692 // transform the designators.
14693 SmallVector<Expr*, 4> ArrayExprs;
14694 bool ExprChanged = false;
14695 for (const DesignatedInitExpr::Designator &D : E->designators()) {
14696 if (D.isFieldDesignator()) {
14697 if (D.getFieldDecl()) {
14698 FieldDecl *Field = cast_or_null<FieldDecl>(
14699 getDerived().TransformDecl(D.getFieldLoc(), D.getFieldDecl()));
14700 if (Field != D.getFieldDecl())
14701 // Rebuild the expression when the transformed FieldDecl is
14702 // different to the already assigned FieldDecl.
14703 ExprChanged = true;
14704 if (Field->isAnonymousStructOrUnion())
14705 continue;
14706 } else {
14707 // Ensure that the designator expression is rebuilt when there isn't
14708 // a resolved FieldDecl in the designator as we don't want to assign
14709 // a FieldDecl to a pattern designator that will be instantiated again.
14710 ExprChanged = true;
14711 }
14712 Desig.AddDesignator(D: Designator::CreateFieldDesignator(
14713 FieldName: D.getFieldName(), DotLoc: D.getDotLoc(), FieldLoc: D.getFieldLoc()));
14714 continue;
14715 }
14716
14717 if (D.isArrayDesignator()) {
14718 ExprResult Index = getDerived().TransformExpr(E->getArrayIndex(D));
14719 if (Index.isInvalid())
14720 return ExprError();
14721
14722 Desig.AddDesignator(
14723 D: Designator::CreateArrayDesignator(Index: Index.get(), LBracketLoc: D.getLBracketLoc()));
14724
14725 ExprChanged = ExprChanged || Index.get() != E->getArrayIndex(D);
14726 ArrayExprs.push_back(Elt: Index.get());
14727 continue;
14728 }
14729
14730 assert(D.isArrayRangeDesignator() && "New kind of designator?");
14731 ExprResult Start
14732 = getDerived().TransformExpr(E->getArrayRangeStart(D));
14733 if (Start.isInvalid())
14734 return ExprError();
14735
14736 ExprResult End = getDerived().TransformExpr(E->getArrayRangeEnd(D));
14737 if (End.isInvalid())
14738 return ExprError();
14739
14740 Desig.AddDesignator(D: Designator::CreateArrayRangeDesignator(
14741 Start: Start.get(), End: End.get(), LBracketLoc: D.getLBracketLoc(), EllipsisLoc: D.getEllipsisLoc()));
14742
14743 ExprChanged = ExprChanged || Start.get() != E->getArrayRangeStart(D) ||
14744 End.get() != E->getArrayRangeEnd(D);
14745
14746 ArrayExprs.push_back(Elt: Start.get());
14747 ArrayExprs.push_back(Elt: End.get());
14748 }
14749
14750 if (!getDerived().AlwaysRebuild() &&
14751 Init.get() == E->getInit() &&
14752 !ExprChanged)
14753 return E;
14754
14755 return getDerived().RebuildDesignatedInitExpr(Desig, ArrayExprs,
14756 E->getEqualOrColonLoc(),
14757 E->usesGNUSyntax(), Init.get());
14758}
14759
14760// Seems that if TransformInitListExpr() only works on the syntactic form of an
14761// InitListExpr, then a DesignatedInitUpdateExpr is not encountered.
14762template<typename Derived>
14763ExprResult
14764TreeTransform<Derived>::TransformDesignatedInitUpdateExpr(
14765 DesignatedInitUpdateExpr *E) {
14766 llvm_unreachable("Unexpected DesignatedInitUpdateExpr in syntactic form of "
14767 "initializer");
14768 return ExprError();
14769}
14770
14771template<typename Derived>
14772ExprResult
14773TreeTransform<Derived>::TransformNoInitExpr(
14774 NoInitExpr *E) {
14775 llvm_unreachable("Unexpected NoInitExpr in syntactic form of initializer");
14776 return ExprError();
14777}
14778
14779template<typename Derived>
14780ExprResult
14781TreeTransform<Derived>::TransformArrayInitLoopExpr(ArrayInitLoopExpr *E) {
14782 llvm_unreachable("Unexpected ArrayInitLoopExpr outside of initializer");
14783 return ExprError();
14784}
14785
14786template<typename Derived>
14787ExprResult
14788TreeTransform<Derived>::TransformArrayInitIndexExpr(ArrayInitIndexExpr *E) {
14789 llvm_unreachable("Unexpected ArrayInitIndexExpr outside of initializer");
14790 return ExprError();
14791}
14792
14793template<typename Derived>
14794ExprResult
14795TreeTransform<Derived>::TransformImplicitValueInitExpr(
14796 ImplicitValueInitExpr *E) {
14797 TemporaryBase Rebase(*this, E->getBeginLoc(), DeclarationName());
14798
14799 // FIXME: Will we ever have proper type location here? Will we actually
14800 // need to transform the type?
14801 QualType T = getDerived().TransformType(E->getType());
14802 if (T.isNull())
14803 return ExprError();
14804
14805 if (!getDerived().AlwaysRebuild() &&
14806 T == E->getType())
14807 return E;
14808
14809 return getDerived().RebuildImplicitValueInitExpr(T);
14810}
14811
14812template<typename Derived>
14813ExprResult
14814TreeTransform<Derived>::TransformVAArgExpr(VAArgExpr *E) {
14815 TypeSourceInfo *TInfo = getDerived().TransformType(E->getWrittenTypeInfo());
14816 if (!TInfo)
14817 return ExprError();
14818
14819 ExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr());
14820 if (SubExpr.isInvalid())
14821 return ExprError();
14822
14823 if (!getDerived().AlwaysRebuild() &&
14824 TInfo == E->getWrittenTypeInfo() &&
14825 SubExpr.get() == E->getSubExpr())
14826 return E;
14827
14828 return getDerived().RebuildVAArgExpr(E->getBuiltinLoc(), SubExpr.get(),
14829 TInfo, E->getRParenLoc());
14830}
14831
14832template<typename Derived>
14833ExprResult
14834TreeTransform<Derived>::TransformParenListExpr(ParenListExpr *E) {
14835 bool ArgumentChanged = false;
14836 SmallVector<Expr*, 4> Inits;
14837 if (TransformExprs(Inputs: E->getExprs(), NumInputs: E->getNumExprs(), IsCall: true, Outputs&: Inits,
14838 ArgChanged: &ArgumentChanged))
14839 return ExprError();
14840
14841 return getDerived().RebuildParenListExpr(E->getLParenLoc(),
14842 Inits,
14843 E->getRParenLoc());
14844}
14845
14846/// Transform an address-of-label expression.
14847///
14848/// By default, the transformation of an address-of-label expression always
14849/// rebuilds the expression, so that the label identifier can be resolved to
14850/// the corresponding label statement by semantic analysis.
14851template<typename Derived>
14852ExprResult
14853TreeTransform<Derived>::TransformAddrLabelExpr(AddrLabelExpr *E) {
14854 Decl *LD = getDerived().TransformDecl(E->getLabel()->getLocation(),
14855 E->getLabel());
14856 if (!LD)
14857 return ExprError();
14858
14859 return getDerived().RebuildAddrLabelExpr(E->getAmpAmpLoc(), E->getLabelLoc(),
14860 cast<LabelDecl>(Val: LD));
14861}
14862
14863template<typename Derived>
14864ExprResult
14865TreeTransform<Derived>::TransformStmtExpr(StmtExpr *E) {
14866 SemaRef.ActOnStartStmtExpr();
14867 StmtResult SubStmt
14868 = getDerived().TransformCompoundStmt(E->getSubStmt(), true);
14869 if (SubStmt.isInvalid()) {
14870 SemaRef.ActOnStmtExprError();
14871 return ExprError();
14872 }
14873
14874 unsigned OldDepth = E->getTemplateDepth();
14875 unsigned NewDepth = getDerived().TransformTemplateDepth(OldDepth);
14876
14877 if (!getDerived().AlwaysRebuild() && OldDepth == NewDepth &&
14878 SubStmt.get() == E->getSubStmt()) {
14879 // Calling this an 'error' is unintuitive, but it does the right thing.
14880 SemaRef.ActOnStmtExprError();
14881 return SemaRef.MaybeBindToTemporary(E);
14882 }
14883
14884 return getDerived().RebuildStmtExpr(E->getLParenLoc(), SubStmt.get(),
14885 E->getRParenLoc(), NewDepth);
14886}
14887
14888template<typename Derived>
14889ExprResult
14890TreeTransform<Derived>::TransformChooseExpr(ChooseExpr *E) {
14891 ExprResult Cond = getDerived().TransformExpr(E->getCond());
14892 if (Cond.isInvalid())
14893 return ExprError();
14894
14895 ExprResult LHS = getDerived().TransformExpr(E->getLHS());
14896 if (LHS.isInvalid())
14897 return ExprError();
14898
14899 ExprResult RHS = getDerived().TransformExpr(E->getRHS());
14900 if (RHS.isInvalid())
14901 return ExprError();
14902
14903 if (!getDerived().AlwaysRebuild() &&
14904 Cond.get() == E->getCond() &&
14905 LHS.get() == E->getLHS() &&
14906 RHS.get() == E->getRHS())
14907 return E;
14908
14909 return getDerived().RebuildChooseExpr(E->getBuiltinLoc(),
14910 Cond.get(), LHS.get(), RHS.get(),
14911 E->getRParenLoc());
14912}
14913
14914template<typename Derived>
14915ExprResult
14916TreeTransform<Derived>::TransformGNUNullExpr(GNUNullExpr *E) {
14917 return E;
14918}
14919
14920template<typename Derived>
14921ExprResult
14922TreeTransform<Derived>::TransformCXXOperatorCallExpr(CXXOperatorCallExpr *E) {
14923 switch (E->getOperator()) {
14924 case OO_New:
14925 case OO_Delete:
14926 case OO_Array_New:
14927 case OO_Array_Delete:
14928 llvm_unreachable("new and delete operators cannot use CXXOperatorCallExpr");
14929
14930 case OO_Subscript:
14931 case OO_Call: {
14932 // This is a call to an object's operator().
14933 assert(E->getNumArgs() >= 1 && "Object call is missing arguments");
14934
14935 // Transform the object itself.
14936 ExprResult Object = getDerived().TransformExpr(E->getArg(Arg: 0));
14937 if (Object.isInvalid())
14938 return ExprError();
14939
14940 // FIXME: Poor location information. Also, if the location for the end of
14941 // the token is within a macro expansion, getLocForEndOfToken() will return
14942 // an invalid source location. If that happens and we have an otherwise
14943 // valid end location, use the valid one instead of the invalid one.
14944 SourceLocation EndLoc = static_cast<Expr *>(Object.get())->getEndLoc();
14945 SourceLocation FakeLParenLoc = SemaRef.getLocForEndOfToken(Loc: EndLoc);
14946 if (FakeLParenLoc.isInvalid() && EndLoc.isValid())
14947 FakeLParenLoc = EndLoc;
14948
14949 // Transform the call arguments.
14950 SmallVector<Expr*, 8> Args;
14951 if (getDerived().TransformExprs(E->getArgs() + 1, E->getNumArgs() - 1, true,
14952 Args))
14953 return ExprError();
14954
14955 if (E->getOperator() == OO_Subscript)
14956 return getDerived().RebuildCxxSubscriptExpr(Object.get(), FakeLParenLoc,
14957 Args, E->getEndLoc());
14958
14959 return getDerived().RebuildCallExpr(Object.get(), FakeLParenLoc, Args,
14960 E->getEndLoc());
14961 }
14962
14963#define OVERLOADED_OPERATOR(Name, Spelling, Token, Unary, Binary, MemberOnly) \
14964 case OO_##Name: \
14965 break;
14966
14967#define OVERLOADED_OPERATOR_MULTI(Name,Spelling,Unary,Binary,MemberOnly)
14968#include "clang/Basic/OperatorKinds.def"
14969
14970 case OO_Conditional:
14971 llvm_unreachable("conditional operator is not actually overloadable");
14972
14973 case OO_None:
14974 case NUM_OVERLOADED_OPERATORS:
14975 llvm_unreachable("not an overloaded operator?");
14976 }
14977
14978 ExprResult First;
14979 if (E->getNumArgs() == 1 && E->getOperator() == OO_Amp)
14980 First = getDerived().TransformAddressOfOperand(E->getArg(Arg: 0));
14981 else
14982 First = getDerived().TransformExpr(E->getArg(Arg: 0));
14983 if (First.isInvalid())
14984 return ExprError();
14985
14986 ExprResult Second;
14987 if (E->getNumArgs() == 2) {
14988 Second =
14989 getDerived().TransformInitializer(E->getArg(Arg: 1), /*NotCopyInit=*/false);
14990 if (Second.isInvalid())
14991 return ExprError();
14992 }
14993
14994 Sema::FPFeaturesStateRAII FPFeaturesState(getSema());
14995 FPOptionsOverride NewOverrides(E->getFPFeatures());
14996 getSema().CurFPFeatures =
14997 NewOverrides.applyOverrides(getSema().getLangOpts());
14998 getSema().FpPragmaStack.CurrentValue = NewOverrides;
14999
15000 Expr *Callee = E->getCallee();
15001 if (UnresolvedLookupExpr *ULE = dyn_cast<UnresolvedLookupExpr>(Val: Callee)) {
15002 LookupResult R(SemaRef, ULE->getName(), ULE->getNameLoc(),
15003 Sema::LookupOrdinaryName);
15004 if (getDerived().TransformOverloadExprDecls(ULE, ULE->requiresADL(), R))
15005 return ExprError();
15006
15007 return getDerived().RebuildCXXOperatorCallExpr(
15008 E->getOperator(), E->getOperatorLoc(), Callee->getBeginLoc(),
15009 ULE->requiresADL(), R.asUnresolvedSet(), First.get(), Second.get());
15010 }
15011
15012 UnresolvedSet<1> Functions;
15013 if (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(Val: Callee))
15014 Callee = ICE->getSubExprAsWritten();
15015 NamedDecl *DR = cast<DeclRefExpr>(Val: Callee)->getDecl();
15016 ValueDecl *VD = cast_or_null<ValueDecl>(
15017 getDerived().TransformDecl(DR->getLocation(), DR));
15018 if (!VD)
15019 return ExprError();
15020
15021 if (!isa<CXXMethodDecl>(Val: VD))
15022 Functions.addDecl(D: VD);
15023
15024 return getDerived().RebuildCXXOperatorCallExpr(
15025 E->getOperator(), E->getOperatorLoc(), Callee->getBeginLoc(),
15026 /*RequiresADL=*/false, Functions, First.get(), Second.get());
15027}
15028
15029template<typename Derived>
15030ExprResult
15031TreeTransform<Derived>::TransformCXXMemberCallExpr(CXXMemberCallExpr *E) {
15032 return getDerived().TransformCallExpr(E);
15033}
15034
15035template <typename Derived>
15036ExprResult TreeTransform<Derived>::TransformSourceLocExpr(SourceLocExpr *E) {
15037 bool NeedRebuildFunc = SourceLocExpr::MayBeDependent(Kind: E->getIdentKind()) &&
15038 getSema().CurContext != E->getParentContext();
15039
15040 if (!getDerived().AlwaysRebuild() && !NeedRebuildFunc)
15041 return E;
15042
15043 return getDerived().RebuildSourceLocExpr(E->getIdentKind(), E->getType(),
15044 E->getBeginLoc(), E->getEndLoc(),
15045 getSema().CurContext);
15046}
15047
15048template <typename Derived>
15049ExprResult TreeTransform<Derived>::TransformEmbedExpr(EmbedExpr *E) {
15050 return E;
15051}
15052
15053template<typename Derived>
15054ExprResult
15055TreeTransform<Derived>::TransformCUDAKernelCallExpr(CUDAKernelCallExpr *E) {
15056 // Transform the callee.
15057 ExprResult Callee = getDerived().TransformExpr(E->getCallee());
15058 if (Callee.isInvalid())
15059 return ExprError();
15060
15061 // Transform exec config.
15062 ExprResult EC = getDerived().TransformCallExpr(E->getConfig());
15063 if (EC.isInvalid())
15064 return ExprError();
15065
15066 // Transform arguments.
15067 bool ArgChanged = false;
15068 SmallVector<Expr*, 8> Args;
15069 if (getDerived().TransformExprs(E->getArgs(), E->getNumArgs(), true, Args,
15070 &ArgChanged))
15071 return ExprError();
15072
15073 if (!getDerived().AlwaysRebuild() &&
15074 Callee.get() == E->getCallee() &&
15075 !ArgChanged)
15076 return SemaRef.MaybeBindToTemporary(E);
15077
15078 // FIXME: Wrong source location information for the '('.
15079 SourceLocation FakeLParenLoc
15080 = ((Expr *)Callee.get())->getSourceRange().getBegin();
15081 return getDerived().RebuildCallExpr(Callee.get(), FakeLParenLoc,
15082 Args,
15083 E->getRParenLoc(), EC.get());
15084}
15085
15086template<typename Derived>
15087ExprResult
15088TreeTransform<Derived>::TransformCXXNamedCastExpr(CXXNamedCastExpr *E) {
15089 TypeSourceInfo *Type = getDerived().TransformType(E->getTypeInfoAsWritten());
15090 if (!Type)
15091 return ExprError();
15092
15093 ExprResult SubExpr
15094 = getDerived().TransformExpr(E->getSubExprAsWritten());
15095 if (SubExpr.isInvalid())
15096 return ExprError();
15097
15098 if (!getDerived().AlwaysRebuild() &&
15099 Type == E->getTypeInfoAsWritten() &&
15100 SubExpr.get() == E->getSubExpr())
15101 return E;
15102 return getDerived().RebuildCXXNamedCastExpr(
15103 E->getOperatorLoc(), E->getStmtClass(), E->getAngleBrackets().getBegin(),
15104 Type, E->getAngleBrackets().getEnd(),
15105 // FIXME. this should be '(' location
15106 E->getAngleBrackets().getEnd(), SubExpr.get(), E->getRParenLoc());
15107}
15108
15109template<typename Derived>
15110ExprResult
15111TreeTransform<Derived>::TransformBuiltinBitCastExpr(BuiltinBitCastExpr *BCE) {
15112 TypeSourceInfo *TSI =
15113 getDerived().TransformType(BCE->getTypeInfoAsWritten());
15114 if (!TSI)
15115 return ExprError();
15116
15117 ExprResult Sub = getDerived().TransformExpr(BCE->getSubExpr());
15118 if (Sub.isInvalid())
15119 return ExprError();
15120
15121 return getDerived().RebuildBuiltinBitCastExpr(BCE->getBeginLoc(), TSI,
15122 Sub.get(), BCE->getEndLoc());
15123}
15124
15125template<typename Derived>
15126ExprResult
15127TreeTransform<Derived>::TransformCXXStaticCastExpr(CXXStaticCastExpr *E) {
15128 return getDerived().TransformCXXNamedCastExpr(E);
15129}
15130
15131template<typename Derived>
15132ExprResult
15133TreeTransform<Derived>::TransformCXXDynamicCastExpr(CXXDynamicCastExpr *E) {
15134 return getDerived().TransformCXXNamedCastExpr(E);
15135}
15136
15137template<typename Derived>
15138ExprResult
15139TreeTransform<Derived>::TransformCXXReinterpretCastExpr(
15140 CXXReinterpretCastExpr *E) {
15141 return getDerived().TransformCXXNamedCastExpr(E);
15142}
15143
15144template<typename Derived>
15145ExprResult
15146TreeTransform<Derived>::TransformCXXConstCastExpr(CXXConstCastExpr *E) {
15147 return getDerived().TransformCXXNamedCastExpr(E);
15148}
15149
15150template<typename Derived>
15151ExprResult
15152TreeTransform<Derived>::TransformCXXAddrspaceCastExpr(CXXAddrspaceCastExpr *E) {
15153 return getDerived().TransformCXXNamedCastExpr(E);
15154}
15155
15156template<typename Derived>
15157ExprResult
15158TreeTransform<Derived>::TransformCXXFunctionalCastExpr(
15159 CXXFunctionalCastExpr *E) {
15160 TypeSourceInfo *Type =
15161 getDerived().TransformTypeWithDeducedTST(E->getTypeInfoAsWritten());
15162 if (!Type)
15163 return ExprError();
15164
15165 ExprResult SubExpr
15166 = getDerived().TransformExpr(E->getSubExprAsWritten());
15167 if (SubExpr.isInvalid())
15168 return ExprError();
15169
15170 if (!getDerived().AlwaysRebuild() &&
15171 Type == E->getTypeInfoAsWritten() &&
15172 SubExpr.get() == E->getSubExpr())
15173 return E;
15174
15175 return getDerived().RebuildCXXFunctionalCastExpr(Type,
15176 E->getLParenLoc(),
15177 SubExpr.get(),
15178 E->getRParenLoc(),
15179 E->isListInitialization());
15180}
15181
15182template<typename Derived>
15183ExprResult
15184TreeTransform<Derived>::TransformCXXTypeidExpr(CXXTypeidExpr *E) {
15185 if (E->isTypeOperand()) {
15186 TypeSourceInfo *TInfo
15187 = getDerived().TransformType(E->getTypeOperandSourceInfo());
15188 if (!TInfo)
15189 return ExprError();
15190
15191 if (!getDerived().AlwaysRebuild() &&
15192 TInfo == E->getTypeOperandSourceInfo())
15193 return E;
15194
15195 return getDerived().RebuildCXXTypeidExpr(E->getType(), E->getBeginLoc(),
15196 TInfo, E->getEndLoc());
15197 }
15198
15199 // Typeid's operand is an unevaluated context, unless it's a polymorphic
15200 // type. We must not unilaterally enter unevaluated context here, as then
15201 // semantic processing can re-transform an already transformed operand.
15202 Expr *Op = E->getExprOperand();
15203 auto EvalCtx = Sema::ExpressionEvaluationContext::Unevaluated;
15204 if (E->isGLValue()) {
15205 QualType OpType = Op->getType();
15206 if (auto *RD = OpType->getAsCXXRecordDecl()) {
15207 if (SemaRef.RequireCompleteType(Loc: E->getBeginLoc(), T: OpType,
15208 DiagID: diag::err_incomplete_typeid))
15209 return ExprError();
15210
15211 if (RD->isPolymorphic())
15212 EvalCtx = SemaRef.ExprEvalContexts.back().Context;
15213 }
15214 }
15215
15216 EnterExpressionEvaluationContext Unevaluated(SemaRef, EvalCtx,
15217 Sema::ReuseLambdaContextDecl);
15218
15219 ExprResult SubExpr = getDerived().TransformExpr(Op);
15220 if (SubExpr.isInvalid())
15221 return ExprError();
15222
15223 if (!getDerived().AlwaysRebuild() &&
15224 SubExpr.get() == E->getExprOperand())
15225 return E;
15226
15227 return getDerived().RebuildCXXTypeidExpr(E->getType(), E->getBeginLoc(),
15228 SubExpr.get(), E->getEndLoc());
15229}
15230
15231template<typename Derived>
15232ExprResult
15233TreeTransform<Derived>::TransformCXXUuidofExpr(CXXUuidofExpr *E) {
15234 if (E->isTypeOperand()) {
15235 TypeSourceInfo *TInfo
15236 = getDerived().TransformType(E->getTypeOperandSourceInfo());
15237 if (!TInfo)
15238 return ExprError();
15239
15240 if (!getDerived().AlwaysRebuild() &&
15241 TInfo == E->getTypeOperandSourceInfo())
15242 return E;
15243
15244 return getDerived().RebuildCXXUuidofExpr(E->getType(), E->getBeginLoc(),
15245 TInfo, E->getEndLoc());
15246 }
15247
15248 EnterExpressionEvaluationContext Unevaluated(
15249 SemaRef, Sema::ExpressionEvaluationContext::Unevaluated);
15250
15251 ExprResult SubExpr = getDerived().TransformExpr(E->getExprOperand());
15252 if (SubExpr.isInvalid())
15253 return ExprError();
15254
15255 if (!getDerived().AlwaysRebuild() &&
15256 SubExpr.get() == E->getExprOperand())
15257 return E;
15258
15259 return getDerived().RebuildCXXUuidofExpr(E->getType(), E->getBeginLoc(),
15260 SubExpr.get(), E->getEndLoc());
15261}
15262
15263template<typename Derived>
15264ExprResult
15265TreeTransform<Derived>::TransformCXXBoolLiteralExpr(CXXBoolLiteralExpr *E) {
15266 return E;
15267}
15268
15269template<typename Derived>
15270ExprResult
15271TreeTransform<Derived>::TransformCXXNullPtrLiteralExpr(
15272 CXXNullPtrLiteralExpr *E) {
15273 return E;
15274}
15275
15276template<typename Derived>
15277ExprResult
15278TreeTransform<Derived>::TransformCXXThisExpr(CXXThisExpr *E) {
15279
15280 // In lambdas, the qualifiers of the type depends of where in
15281 // the call operator `this` appear, and we do not have a good way to
15282 // rebuild this information, so we transform the type.
15283 //
15284 // In other contexts, the type of `this` may be overrided
15285 // for type deduction, so we need to recompute it.
15286 //
15287 // Always recompute the type if we're in the body of a lambda, and
15288 // 'this' is dependent on a lambda's explicit object parameter; we
15289 // also need to always rebuild the expression in this case to clear
15290 // the flag.
15291 QualType T = [&]() {
15292 auto &S = getSema();
15293 if (E->isCapturedByCopyInLambdaWithExplicitObjectParameter())
15294 return S.getCurrentThisType();
15295 if (S.getCurLambda())
15296 return getDerived().TransformType(E->getType());
15297 return S.getCurrentThisType();
15298 }();
15299
15300 if (!getDerived().AlwaysRebuild() && T == E->getType() &&
15301 !E->isCapturedByCopyInLambdaWithExplicitObjectParameter()) {
15302 // Mark it referenced in the new context regardless.
15303 // FIXME: this is a bit instantiation-specific.
15304 getSema().MarkThisReferenced(E);
15305 return E;
15306 }
15307
15308 return getDerived().RebuildCXXThisExpr(E->getBeginLoc(), T, E->isImplicit());
15309}
15310
15311template<typename Derived>
15312ExprResult
15313TreeTransform<Derived>::TransformCXXThrowExpr(CXXThrowExpr *E) {
15314 ExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr());
15315 if (SubExpr.isInvalid())
15316 return ExprError();
15317
15318 getSema().DiagnoseExceptionUse(E->getThrowLoc(), /* IsTry= */ false);
15319
15320 if (!getDerived().AlwaysRebuild() &&
15321 SubExpr.get() == E->getSubExpr())
15322 return E;
15323
15324 return getDerived().RebuildCXXThrowExpr(E->getThrowLoc(), SubExpr.get(),
15325 E->isThrownVariableInScope());
15326}
15327
15328template<typename Derived>
15329ExprResult
15330TreeTransform<Derived>::TransformCXXDefaultArgExpr(CXXDefaultArgExpr *E) {
15331 ParmVarDecl *Param = cast_or_null<ParmVarDecl>(
15332 getDerived().TransformDecl(E->getBeginLoc(), E->getParam()));
15333 if (!Param)
15334 return ExprError();
15335
15336 ExprResult InitRes;
15337 if (E->hasRewrittenInit()) {
15338 InitRes = getDerived().TransformExpr(E->getRewrittenExpr());
15339 if (InitRes.isInvalid())
15340 return ExprError();
15341 }
15342
15343 if (!getDerived().AlwaysRebuild() && Param == E->getParam() &&
15344 E->getUsedContext() == SemaRef.CurContext &&
15345 InitRes.get() == E->getRewrittenExpr())
15346 return E;
15347
15348 return getDerived().RebuildCXXDefaultArgExpr(E->getUsedLocation(), Param,
15349 InitRes.get());
15350}
15351
15352template<typename Derived>
15353ExprResult
15354TreeTransform<Derived>::TransformCXXDefaultInitExpr(CXXDefaultInitExpr *E) {
15355 FieldDecl *Field = cast_or_null<FieldDecl>(
15356 getDerived().TransformDecl(E->getBeginLoc(), E->getField()));
15357 if (!Field)
15358 return ExprError();
15359
15360 ExprResult InitRes;
15361 if (E->hasRewrittenInit()) {
15362 // The initializer can refer to `this` and to other members, so it has to
15363 // be transformed in the scope of the field's class.
15364 Sema::CXXThisScopeRAII ThisScope(SemaRef, Field->getParent(), Qualifiers());
15365 InitRes = getDerived().TransformExpr(E->getRewrittenExpr());
15366 if (InitRes.isInvalid())
15367 return ExprError();
15368 }
15369
15370 if (!getDerived().AlwaysRebuild() && Field == E->getField() &&
15371 E->getUsedContext() == SemaRef.CurContext &&
15372 InitRes.get() == E->getExpr())
15373 return E;
15374
15375 return getDerived().RebuildCXXDefaultInitExpr(E->getExprLoc(), Field,
15376 InitRes.get());
15377}
15378
15379template<typename Derived>
15380ExprResult
15381TreeTransform<Derived>::TransformCXXScalarValueInitExpr(
15382 CXXScalarValueInitExpr *E) {
15383 TypeSourceInfo *T = getDerived().TransformType(E->getTypeSourceInfo());
15384 if (!T)
15385 return ExprError();
15386
15387 if (!getDerived().AlwaysRebuild() &&
15388 T == E->getTypeSourceInfo())
15389 return E;
15390
15391 return getDerived().RebuildCXXScalarValueInitExpr(T,
15392 /*FIXME:*/T->getTypeLoc().getEndLoc(),
15393 E->getRParenLoc());
15394}
15395
15396template<typename Derived>
15397ExprResult
15398TreeTransform<Derived>::TransformCXXNewExpr(CXXNewExpr *E) {
15399 // Transform the type that we're allocating
15400 TypeSourceInfo *AllocTypeInfo =
15401 getDerived().TransformTypeWithDeducedTST(E->getAllocatedTypeSourceInfo());
15402 if (!AllocTypeInfo)
15403 return ExprError();
15404
15405 // Transform the size of the array we're allocating (if any).
15406 std::optional<Expr *> ArraySize;
15407 if (E->isArray()) {
15408 ExprResult NewArraySize;
15409 if (std::optional<Expr *> OldArraySize = E->getArraySize()) {
15410 NewArraySize = getDerived().TransformExpr(*OldArraySize);
15411 if (NewArraySize.isInvalid())
15412 return ExprError();
15413 }
15414 ArraySize = NewArraySize.get();
15415 }
15416
15417 // Transform the placement arguments (if any).
15418 bool ArgumentChanged = false;
15419 SmallVector<Expr*, 8> PlacementArgs;
15420 if (getDerived().TransformExprs(E->getPlacementArgs(),
15421 E->getNumPlacementArgs(), true,
15422 PlacementArgs, &ArgumentChanged))
15423 return ExprError();
15424
15425 // Transform the initializer (if any).
15426 Expr *OldInit = E->getInitializer();
15427 ExprResult NewInit;
15428 if (OldInit)
15429 NewInit = getDerived().TransformInitializer(OldInit, true);
15430 if (NewInit.isInvalid())
15431 return ExprError();
15432
15433 // Transform new operator and delete operator.
15434 FunctionDecl *OperatorNew = nullptr;
15435 if (E->getOperatorNew()) {
15436 OperatorNew = cast_or_null<FunctionDecl>(
15437 getDerived().TransformDecl(E->getBeginLoc(), E->getOperatorNew()));
15438 if (!OperatorNew)
15439 return ExprError();
15440 }
15441
15442 FunctionDecl *OperatorDelete = nullptr;
15443 if (E->getOperatorDelete()) {
15444 OperatorDelete = cast_or_null<FunctionDecl>(
15445 getDerived().TransformDecl(E->getBeginLoc(), E->getOperatorDelete()));
15446 if (!OperatorDelete)
15447 return ExprError();
15448 }
15449
15450 if (!getDerived().AlwaysRebuild() &&
15451 AllocTypeInfo == E->getAllocatedTypeSourceInfo() &&
15452 ArraySize == E->getArraySize() &&
15453 NewInit.get() == OldInit &&
15454 OperatorNew == E->getOperatorNew() &&
15455 OperatorDelete == E->getOperatorDelete() &&
15456 !ArgumentChanged) {
15457 // Mark any declarations we need as referenced.
15458 // FIXME: instantiation-specific.
15459 if (OperatorNew)
15460 SemaRef.MarkFunctionReferenced(Loc: E->getBeginLoc(), Func: OperatorNew);
15461 if (OperatorDelete)
15462 SemaRef.MarkFunctionReferenced(Loc: E->getBeginLoc(), Func: OperatorDelete);
15463
15464 if (E->isArray() && !E->getAllocatedType()->isDependentType()) {
15465 QualType ElementType
15466 = SemaRef.Context.getBaseElementType(QT: E->getAllocatedType());
15467 if (CXXRecordDecl *Record = ElementType->getAsCXXRecordDecl()) {
15468 if (CXXDestructorDecl *Destructor = SemaRef.LookupDestructor(Class: Record))
15469 SemaRef.MarkFunctionReferenced(Loc: E->getBeginLoc(), Func: Destructor);
15470 }
15471 }
15472
15473 return E;
15474 }
15475
15476 QualType AllocType = AllocTypeInfo->getType();
15477 if (!ArraySize) {
15478 // If no array size was specified, but the new expression was
15479 // instantiated with an array type (e.g., "new T" where T is
15480 // instantiated with "int[4]"), extract the outer bound from the
15481 // array type as our array size. We do this with constant and
15482 // dependently-sized array types.
15483 const ArrayType *ArrayT = SemaRef.Context.getAsArrayType(T: AllocType);
15484 if (!ArrayT) {
15485 // Do nothing
15486 } else if (const ConstantArrayType *ConsArrayT
15487 = dyn_cast<ConstantArrayType>(Val: ArrayT)) {
15488 ArraySize = IntegerLiteral::Create(C: SemaRef.Context, V: ConsArrayT->getSize(),
15489 type: SemaRef.Context.getSizeType(),
15490 /*FIXME:*/ l: E->getBeginLoc());
15491 AllocType = ConsArrayT->getElementType();
15492 } else if (const DependentSizedArrayType *DepArrayT
15493 = dyn_cast<DependentSizedArrayType>(Val: ArrayT)) {
15494 if (DepArrayT->getSizeExpr()) {
15495 ArraySize = DepArrayT->getSizeExpr();
15496 AllocType = DepArrayT->getElementType();
15497 }
15498 }
15499 }
15500
15501 return getDerived().RebuildCXXNewExpr(
15502 E->getBeginLoc(), E->isGlobalNew(),
15503 /*FIXME:*/ E->getBeginLoc(), PlacementArgs,
15504 /*FIXME:*/ E->getBeginLoc(), E->getTypeIdParens(), AllocType,
15505 AllocTypeInfo, ArraySize, E->getDirectInitRange(), NewInit.get());
15506}
15507
15508template<typename Derived>
15509ExprResult
15510TreeTransform<Derived>::TransformCXXDeleteExpr(CXXDeleteExpr *E) {
15511 ExprResult Operand = getDerived().TransformExpr(E->getArgument());
15512 if (Operand.isInvalid())
15513 return ExprError();
15514
15515 // Transform the delete operator, if known.
15516 FunctionDecl *OperatorDelete = nullptr;
15517 if (E->getOperatorDelete()) {
15518 OperatorDelete = cast_or_null<FunctionDecl>(
15519 getDerived().TransformDecl(E->getBeginLoc(), E->getOperatorDelete()));
15520 if (!OperatorDelete)
15521 return ExprError();
15522 }
15523
15524 if (!getDerived().AlwaysRebuild() &&
15525 Operand.get() == E->getArgument() &&
15526 OperatorDelete == E->getOperatorDelete()) {
15527 // Mark any declarations we need as referenced.
15528 // FIXME: instantiation-specific.
15529 if (OperatorDelete)
15530 SemaRef.MarkFunctionReferenced(Loc: E->getBeginLoc(), Func: OperatorDelete);
15531
15532 if (!E->getArgument()->isTypeDependent()) {
15533 QualType Destroyed = SemaRef.Context.getBaseElementType(
15534 QT: E->getDestroyedType());
15535 if (auto *Record = Destroyed->getAsCXXRecordDecl())
15536 SemaRef.MarkFunctionReferenced(Loc: E->getBeginLoc(),
15537 Func: SemaRef.LookupDestructor(Class: Record));
15538 }
15539
15540 return E;
15541 }
15542
15543 return getDerived().RebuildCXXDeleteExpr(
15544 E->getBeginLoc(), E->isGlobalDelete(), E->isArrayForm(), Operand.get());
15545}
15546
15547template<typename Derived>
15548ExprResult
15549TreeTransform<Derived>::TransformCXXPseudoDestructorExpr(
15550 CXXPseudoDestructorExpr *E) {
15551 ExprResult Base = getDerived().TransformExpr(E->getBase());
15552 if (Base.isInvalid())
15553 return ExprError();
15554
15555 ParsedType ObjectTypePtr;
15556 bool MayBePseudoDestructor = false;
15557 Base = SemaRef.ActOnStartCXXMemberReference(S: nullptr, Base: Base.get(),
15558 OpLoc: E->getOperatorLoc(),
15559 OpKind: E->isArrow()? tok::arrow : tok::period,
15560 ObjectType&: ObjectTypePtr,
15561 MayBePseudoDestructor);
15562 if (Base.isInvalid())
15563 return ExprError();
15564
15565 QualType ObjectType = ObjectTypePtr.get();
15566 NestedNameSpecifierLoc QualifierLoc = E->getQualifierLoc();
15567 if (QualifierLoc) {
15568 QualifierLoc
15569 = getDerived().TransformNestedNameSpecifierLoc(QualifierLoc, ObjectType);
15570 if (!QualifierLoc)
15571 return ExprError();
15572 }
15573 CXXScopeSpec SS;
15574 SS.Adopt(Other: QualifierLoc);
15575
15576 PseudoDestructorTypeStorage Destroyed;
15577 if (E->getDestroyedTypeInfo()) {
15578 TypeSourceInfo *DestroyedTypeInfo = getDerived().TransformTypeInObjectScope(
15579 E->getDestroyedTypeInfo(), ObjectType,
15580 /*FirstQualifierInScope=*/nullptr);
15581 if (!DestroyedTypeInfo)
15582 return ExprError();
15583 Destroyed = DestroyedTypeInfo;
15584 } else if (!ObjectType.isNull() && ObjectType->isDependentType()) {
15585 // We aren't likely to be able to resolve the identifier down to a type
15586 // now anyway, so just retain the identifier.
15587 Destroyed = PseudoDestructorTypeStorage(E->getDestroyedTypeIdentifier(),
15588 E->getDestroyedTypeLoc());
15589 } else {
15590 // Look for a destructor known with the given name.
15591 ParsedType T = SemaRef.getDestructorName(
15592 II: *E->getDestroyedTypeIdentifier(), NameLoc: E->getDestroyedTypeLoc(),
15593 /*Scope=*/S: nullptr, SS, ObjectType: ObjectTypePtr, EnteringContext: false);
15594 if (!T)
15595 return ExprError();
15596
15597 Destroyed
15598 = SemaRef.Context.getTrivialTypeSourceInfo(T: SemaRef.GetTypeFromParser(Ty: T),
15599 Loc: E->getDestroyedTypeLoc());
15600 }
15601
15602 TypeSourceInfo *ScopeTypeInfo = nullptr;
15603 if (E->getScopeTypeInfo()) {
15604 ScopeTypeInfo = getDerived().TransformTypeInObjectScope(
15605 E->getScopeTypeInfo(), ObjectType, nullptr);
15606 if (!ScopeTypeInfo)
15607 return ExprError();
15608 }
15609
15610 return getDerived().RebuildCXXPseudoDestructorExpr(Base.get(),
15611 E->getOperatorLoc(),
15612 E->isArrow(),
15613 SS,
15614 ScopeTypeInfo,
15615 E->getColonColonLoc(),
15616 E->getTildeLoc(),
15617 Destroyed);
15618}
15619
15620template <typename Derived>
15621bool TreeTransform<Derived>::TransformOverloadExprDecls(OverloadExpr *Old,
15622 bool RequiresADL,
15623 LookupResult &R) {
15624 // Transform all the decls.
15625 bool AllEmptyPacks = true;
15626 for (auto *OldD : Old->decls()) {
15627 Decl *InstD = getDerived().TransformDecl(Old->getNameLoc(), OldD);
15628 if (!InstD) {
15629 // Silently ignore these if a UsingShadowDecl instantiated to nothing.
15630 // This can happen because of dependent hiding.
15631 if (isa<UsingShadowDecl>(Val: OldD))
15632 continue;
15633 else {
15634 R.clear();
15635 return true;
15636 }
15637 }
15638
15639 // Expand using pack declarations.
15640 NamedDecl *SingleDecl = cast<NamedDecl>(Val: InstD);
15641 ArrayRef<NamedDecl*> Decls = SingleDecl;
15642 if (auto *UPD = dyn_cast<UsingPackDecl>(Val: InstD))
15643 Decls = UPD->expansions();
15644
15645 // Expand using declarations.
15646 for (auto *D : Decls) {
15647 if (auto *UD = dyn_cast<UsingDecl>(Val: D)) {
15648 for (auto *SD : UD->shadows())
15649 R.addDecl(D: SD);
15650 } else {
15651 R.addDecl(D);
15652 }
15653 }
15654
15655 AllEmptyPacks &= Decls.empty();
15656 }
15657
15658 // C++ [temp.res]/8.4.2:
15659 // The program is ill-formed, no diagnostic required, if [...] lookup for
15660 // a name in the template definition found a using-declaration, but the
15661 // lookup in the corresponding scope in the instantiation odoes not find
15662 // any declarations because the using-declaration was a pack expansion and
15663 // the corresponding pack is empty
15664 if (AllEmptyPacks && !RequiresADL) {
15665 getSema().Diag(Old->getNameLoc(), diag::err_using_pack_expansion_empty)
15666 << isa<UnresolvedMemberExpr>(Val: Old) << Old->getName();
15667 return true;
15668 }
15669
15670 // Resolve a kind, but don't do any further analysis. If it's
15671 // ambiguous, the callee needs to deal with it.
15672 R.resolveKind();
15673
15674 if (Old->hasTemplateKeyword() && !R.empty()) {
15675 NamedDecl *FoundDecl = R.getRepresentativeDecl()->getUnderlyingDecl();
15676 getSema().FilterAcceptableTemplateNames(R,
15677 /*AllowFunctionTemplates=*/true,
15678 /*AllowDependent=*/true);
15679 if (R.empty()) {
15680 // If a 'template' keyword was used, a lookup that finds only non-template
15681 // names is an error.
15682 getSema().Diag(R.getNameLoc(),
15683 diag::err_template_kw_refers_to_non_template)
15684 << R.getLookupName() << Old->getQualifierLoc().getSourceRange()
15685 << Old->hasTemplateKeyword() << Old->getTemplateKeywordLoc();
15686 getSema().Diag(FoundDecl->getLocation(),
15687 diag::note_template_kw_refers_to_non_template)
15688 << R.getLookupName();
15689 return true;
15690 }
15691 }
15692
15693 return false;
15694}
15695
15696template <typename Derived>
15697ExprResult TreeTransform<Derived>::TransformUnresolvedLookupExpr(
15698 UnresolvedLookupExpr *Old) {
15699 return TransformUnresolvedLookupExpr(Old, /*IsAddressOfOperand=*/false);
15700}
15701
15702template <typename Derived>
15703ExprResult
15704TreeTransform<Derived>::TransformUnresolvedLookupExpr(UnresolvedLookupExpr *Old,
15705 bool IsAddressOfOperand) {
15706 LookupResult R(SemaRef, Old->getName(), Old->getNameLoc(),
15707 Sema::LookupOrdinaryName);
15708
15709 // Transform the declaration set.
15710 if (TransformOverloadExprDecls(Old, RequiresADL: Old->requiresADL(), R))
15711 return ExprError();
15712
15713 // Rebuild the nested-name qualifier, if present.
15714 CXXScopeSpec SS;
15715 if (Old->getQualifierLoc()) {
15716 NestedNameSpecifierLoc QualifierLoc
15717 = getDerived().TransformNestedNameSpecifierLoc(Old->getQualifierLoc());
15718 if (!QualifierLoc)
15719 return ExprError();
15720
15721 SS.Adopt(Other: QualifierLoc);
15722 }
15723
15724 if (Old->getNamingClass()) {
15725 CXXRecordDecl *NamingClass
15726 = cast_or_null<CXXRecordDecl>(getDerived().TransformDecl(
15727 Old->getNameLoc(),
15728 Old->getNamingClass()));
15729 if (!NamingClass) {
15730 R.clear();
15731 return ExprError();
15732 }
15733
15734 R.setNamingClass(NamingClass);
15735 }
15736
15737 // Rebuild the template arguments, if any.
15738 SourceLocation TemplateKWLoc = Old->getTemplateKeywordLoc();
15739 TemplateArgumentListInfo TransArgs(Old->getLAngleLoc(), Old->getRAngleLoc());
15740 if (Old->hasExplicitTemplateArgs() &&
15741 getDerived().TransformTemplateArguments(Old->getTemplateArgs(),
15742 Old->getNumTemplateArgs(),
15743 TransArgs)) {
15744 R.clear();
15745 return ExprError();
15746 }
15747
15748 // An UnresolvedLookupExpr can refer to a class member. This occurs e.g. when
15749 // a non-static data member is named in an unevaluated operand, or when
15750 // a member is named in a dependent class scope function template explicit
15751 // specialization that is neither declared static nor with an explicit object
15752 // parameter.
15753 if (SemaRef.isPotentialImplicitMemberAccess(SS, R, IsAddressOfOperand))
15754 return SemaRef.BuildPossibleImplicitMemberExpr(
15755 SS, TemplateKWLoc, R,
15756 TemplateArgs: Old->hasExplicitTemplateArgs() ? &TransArgs : nullptr,
15757 /*S=*/S: nullptr);
15758
15759 // If we have neither explicit template arguments, nor the template keyword,
15760 // it's a normal declaration name or member reference.
15761 if (!Old->hasExplicitTemplateArgs() && !TemplateKWLoc.isValid())
15762 return getDerived().RebuildDeclarationNameExpr(SS, R, Old->requiresADL());
15763
15764 // If we have template arguments, then rebuild the template-id expression.
15765 return getDerived().RebuildTemplateIdExpr(SS, TemplateKWLoc, R,
15766 Old->requiresADL(), &TransArgs);
15767}
15768
15769template<typename Derived>
15770ExprResult
15771TreeTransform<Derived>::TransformTypeTraitExpr(TypeTraitExpr *E) {
15772 bool ArgChanged = false;
15773 SmallVector<TypeSourceInfo *, 4> Args;
15774 for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I) {
15775 TypeSourceInfo *From = E->getArg(I);
15776 TypeLoc FromTL = From->getTypeLoc();
15777 if (!FromTL.getAs<PackExpansionTypeLoc>()) {
15778 TypeLocBuilder TLB;
15779 TLB.reserve(Requested: FromTL.getFullDataSize());
15780 QualType To = getDerived().TransformType(TLB, FromTL);
15781 if (To.isNull())
15782 return ExprError();
15783
15784 if (To == From->getType())
15785 Args.push_back(Elt: From);
15786 else {
15787 Args.push_back(Elt: TLB.getTypeSourceInfo(Context&: SemaRef.Context, T: To));
15788 ArgChanged = true;
15789 }
15790 continue;
15791 }
15792
15793 ArgChanged = true;
15794
15795 // We have a pack expansion. Instantiate it.
15796 PackExpansionTypeLoc ExpansionTL = FromTL.castAs<PackExpansionTypeLoc>();
15797 TypeLoc PatternTL = ExpansionTL.getPatternLoc();
15798 SmallVector<UnexpandedParameterPack, 2> Unexpanded;
15799 SemaRef.collectUnexpandedParameterPacks(TL: PatternTL, Unexpanded);
15800
15801 // Determine whether the set of unexpanded parameter packs can and should
15802 // be expanded.
15803 bool Expand = true;
15804 bool RetainExpansion = false;
15805 UnsignedOrNone OrigNumExpansions =
15806 ExpansionTL.getTypePtr()->getNumExpansions();
15807 UnsignedOrNone NumExpansions = OrigNumExpansions;
15808 if (getDerived().TryExpandParameterPacks(
15809 ExpansionTL.getEllipsisLoc(), PatternTL.getSourceRange(),
15810 Unexpanded, /*FailOnPackProducingTemplates=*/true, Expand,
15811 RetainExpansion, NumExpansions))
15812 return ExprError();
15813
15814 if (!Expand) {
15815 // The transform has determined that we should perform a simple
15816 // transformation on the pack expansion, producing another pack
15817 // expansion.
15818 Sema::ArgPackSubstIndexRAII SubstIndex(getSema(), std::nullopt);
15819
15820 TypeLocBuilder TLB;
15821 TLB.reserve(Requested: From->getTypeLoc().getFullDataSize());
15822
15823 QualType To = getDerived().TransformType(TLB, PatternTL);
15824 if (To.isNull())
15825 return ExprError();
15826
15827 To = getDerived().RebuildPackExpansionType(To,
15828 PatternTL.getSourceRange(),
15829 ExpansionTL.getEllipsisLoc(),
15830 NumExpansions);
15831 if (To.isNull())
15832 return ExprError();
15833
15834 PackExpansionTypeLoc ToExpansionTL
15835 = TLB.push<PackExpansionTypeLoc>(T: To);
15836 ToExpansionTL.setEllipsisLoc(ExpansionTL.getEllipsisLoc());
15837 Args.push_back(Elt: TLB.getTypeSourceInfo(Context&: SemaRef.Context, T: To));
15838 continue;
15839 }
15840
15841 // Expand the pack expansion by substituting for each argument in the
15842 // pack(s).
15843 for (unsigned I = 0; I != *NumExpansions; ++I) {
15844 Sema::ArgPackSubstIndexRAII SubstIndex(SemaRef, I);
15845 TypeLocBuilder TLB;
15846 TLB.reserve(Requested: PatternTL.getFullDataSize());
15847 QualType To = getDerived().TransformType(TLB, PatternTL);
15848 if (To.isNull())
15849 return ExprError();
15850
15851 if (To->containsUnexpandedParameterPack()) {
15852 To = getDerived().RebuildPackExpansionType(To,
15853 PatternTL.getSourceRange(),
15854 ExpansionTL.getEllipsisLoc(),
15855 NumExpansions);
15856 if (To.isNull())
15857 return ExprError();
15858
15859 PackExpansionTypeLoc ToExpansionTL
15860 = TLB.push<PackExpansionTypeLoc>(T: To);
15861 ToExpansionTL.setEllipsisLoc(ExpansionTL.getEllipsisLoc());
15862 }
15863
15864 Args.push_back(Elt: TLB.getTypeSourceInfo(Context&: SemaRef.Context, T: To));
15865 }
15866
15867 if (!RetainExpansion)
15868 continue;
15869
15870 // If we're supposed to retain a pack expansion, do so by temporarily
15871 // forgetting the partially-substituted parameter pack.
15872 ForgetPartiallySubstitutedPackRAII Forget(getDerived());
15873
15874 TypeLocBuilder TLB;
15875 TLB.reserve(Requested: From->getTypeLoc().getFullDataSize());
15876
15877 QualType To = getDerived().TransformType(TLB, PatternTL);
15878 if (To.isNull())
15879 return ExprError();
15880
15881 To = getDerived().RebuildPackExpansionType(To,
15882 PatternTL.getSourceRange(),
15883 ExpansionTL.getEllipsisLoc(),
15884 NumExpansions);
15885 if (To.isNull())
15886 return ExprError();
15887
15888 PackExpansionTypeLoc ToExpansionTL
15889 = TLB.push<PackExpansionTypeLoc>(T: To);
15890 ToExpansionTL.setEllipsisLoc(ExpansionTL.getEllipsisLoc());
15891 Args.push_back(Elt: TLB.getTypeSourceInfo(Context&: SemaRef.Context, T: To));
15892 }
15893
15894 if (!getDerived().AlwaysRebuild() && !ArgChanged)
15895 return E;
15896
15897 return getDerived().RebuildTypeTrait(E->getTrait(), E->getBeginLoc(), Args,
15898 E->getEndLoc());
15899}
15900
15901template<typename Derived>
15902ExprResult
15903TreeTransform<Derived>::TransformConceptSpecializationExpr(
15904 ConceptSpecializationExpr *E) {
15905 const ASTTemplateArgumentListInfo *Old = E->getTemplateArgsAsWritten();
15906 TemplateArgumentListInfo TransArgs(Old->LAngleLoc, Old->RAngleLoc);
15907 if (getDerived().TransformTemplateArguments(Old->getTemplateArgs(),
15908 Old->NumTemplateArgs, TransArgs))
15909 return ExprError();
15910
15911 return getDerived().RebuildConceptSpecializationExpr(
15912 E->getNestedNameSpecifierLoc(), E->getTemplateKWLoc(),
15913 E->getConceptNameInfo(), E->getFoundDecl(), E->getConceptDecl(),
15914 &TransArgs);
15915}
15916
15917template<typename Derived>
15918ExprResult
15919TreeTransform<Derived>::TransformRequiresExpr(RequiresExpr *E) {
15920 SmallVector<ParmVarDecl*, 4> TransParams;
15921 SmallVector<QualType, 4> TransParamTypes;
15922 Sema::ExtParameterInfoBuilder ExtParamInfos;
15923
15924 // C++2a [expr.prim.req]p2
15925 // Expressions appearing within a requirement-body are unevaluated operands.
15926 EnterExpressionEvaluationContext Ctx(
15927 SemaRef, Sema::ExpressionEvaluationContext::Unevaluated,
15928 Sema::ReuseLambdaContextDecl);
15929
15930 RequiresExprBodyDecl *Body = RequiresExprBodyDecl::Create(
15931 C&: getSema().Context, DC: getSema().CurContext,
15932 StartLoc: E->getBody()->getBeginLoc());
15933
15934 Sema::ContextRAII SavedContext(getSema(), Body, /*NewThisContext*/false);
15935
15936 ExprResult TypeParamResult = getDerived().TransformRequiresTypeParams(
15937 E->getRequiresKWLoc(), E->getRBraceLoc(), E, Body,
15938 E->getLocalParameters(), TransParamTypes, TransParams, ExtParamInfos);
15939
15940 for (ParmVarDecl *Param : TransParams)
15941 if (Param)
15942 Param->setDeclContext(Body);
15943
15944 // On failure to transform, TransformRequiresTypeParams returns an expression
15945 // in the event that the transformation of the type params failed in some way.
15946 // It is expected that this will result in a 'not satisfied' Requires clause
15947 // when instantiating.
15948 if (!TypeParamResult.isUnset())
15949 return TypeParamResult;
15950
15951 SmallVector<concepts::Requirement *, 4> TransReqs;
15952 if (getDerived().TransformRequiresExprRequirements(E->getRequirements(),
15953 TransReqs))
15954 return ExprError();
15955
15956 for (concepts::Requirement *Req : TransReqs) {
15957 if (auto *ER = dyn_cast<concepts::ExprRequirement>(Val: Req)) {
15958 if (ER->getReturnTypeRequirement().isTypeConstraint()) {
15959 ER->getReturnTypeRequirement()
15960 .getTypeConstraintTemplateParameterList()->getParam(Idx: 0)
15961 ->setDeclContext(Body);
15962 }
15963 }
15964 }
15965
15966 return getDerived().RebuildRequiresExpr(
15967 E->getRequiresKWLoc(), Body, E->getLParenLoc(), TransParams,
15968 E->getRParenLoc(), TransReqs, E->getRBraceLoc());
15969}
15970
15971template<typename Derived>
15972bool TreeTransform<Derived>::TransformRequiresExprRequirements(
15973 ArrayRef<concepts::Requirement *> Reqs,
15974 SmallVectorImpl<concepts::Requirement *> &Transformed) {
15975 for (concepts::Requirement *Req : Reqs) {
15976 concepts::Requirement *TransReq = nullptr;
15977 if (auto *TypeReq = dyn_cast<concepts::TypeRequirement>(Val: Req))
15978 TransReq = getDerived().TransformTypeRequirement(TypeReq);
15979 else if (auto *ExprReq = dyn_cast<concepts::ExprRequirement>(Val: Req))
15980 TransReq = getDerived().TransformExprRequirement(ExprReq);
15981 else
15982 TransReq = getDerived().TransformNestedRequirement(
15983 cast<concepts::NestedRequirement>(Val: Req));
15984 if (!TransReq)
15985 return true;
15986 Transformed.push_back(Elt: TransReq);
15987 }
15988 return false;
15989}
15990
15991template<typename Derived>
15992concepts::TypeRequirement *
15993TreeTransform<Derived>::TransformTypeRequirement(
15994 concepts::TypeRequirement *Req) {
15995 if (Req->isSubstitutionFailure()) {
15996 if (getDerived().AlwaysRebuild())
15997 return getDerived().RebuildTypeRequirement(
15998 Req->getSubstitutionDiagnostic());
15999 return Req;
16000 }
16001 TypeSourceInfo *TransType = getDerived().TransformType(Req->getType());
16002 if (!TransType)
16003 return nullptr;
16004 return getDerived().RebuildTypeRequirement(TransType);
16005}
16006
16007template<typename Derived>
16008concepts::ExprRequirement *
16009TreeTransform<Derived>::TransformExprRequirement(concepts::ExprRequirement *Req) {
16010 llvm::PointerUnion<Expr *, concepts::Requirement::SubstitutionDiagnostic *> TransExpr;
16011 if (Req->isExprSubstitutionFailure())
16012 TransExpr = Req->getExprSubstitutionDiagnostic();
16013 else {
16014 ExprResult TransExprRes = getDerived().TransformExpr(Req->getExpr());
16015 if (TransExprRes.isUsable() && TransExprRes.get()->hasPlaceholderType())
16016 TransExprRes = SemaRef.CheckPlaceholderExpr(E: TransExprRes.get());
16017 if (TransExprRes.isInvalid())
16018 return nullptr;
16019 TransExpr = TransExprRes.get();
16020 }
16021
16022 std::optional<concepts::ExprRequirement::ReturnTypeRequirement> TransRetReq;
16023 const auto &RetReq = Req->getReturnTypeRequirement();
16024 if (RetReq.isEmpty())
16025 TransRetReq.emplace();
16026 else if (RetReq.isSubstitutionFailure())
16027 TransRetReq.emplace(args: RetReq.getSubstitutionDiagnostic());
16028 else if (RetReq.isTypeConstraint()) {
16029 TemplateParameterList *OrigTPL =
16030 RetReq.getTypeConstraintTemplateParameterList();
16031 TemplateParameterList *TPL =
16032 getDerived().TransformTemplateParameterList(OrigTPL);
16033 if (!TPL)
16034 return nullptr;
16035 TransRetReq.emplace(args&: TPL);
16036 }
16037 assert(TransRetReq && "All code paths leading here must set TransRetReq");
16038 if (Expr *E = dyn_cast<Expr *>(Val&: TransExpr))
16039 return getDerived().RebuildExprRequirement(E, Req->isSimple(),
16040 Req->getNoexceptLoc(),
16041 std::move(*TransRetReq));
16042 return getDerived().RebuildExprRequirement(
16043 cast<concepts::Requirement::SubstitutionDiagnostic *>(Val&: TransExpr),
16044 Req->isSimple(), Req->getNoexceptLoc(), std::move(*TransRetReq));
16045}
16046
16047template<typename Derived>
16048concepts::NestedRequirement *
16049TreeTransform<Derived>::TransformNestedRequirement(
16050 concepts::NestedRequirement *Req) {
16051 if (Req->hasInvalidConstraint()) {
16052 if (getDerived().AlwaysRebuild())
16053 return getDerived().RebuildNestedRequirement(
16054 Req->getInvalidConstraintEntity(), Req->getConstraintSatisfaction());
16055 return Req;
16056 }
16057 ExprResult TransConstraint =
16058 getDerived().TransformExpr(Req->getConstraintExpr());
16059 if (TransConstraint.isInvalid())
16060 return nullptr;
16061 return getDerived().RebuildNestedRequirement(TransConstraint.get());
16062}
16063
16064template<typename Derived>
16065ExprResult
16066TreeTransform<Derived>::TransformArrayTypeTraitExpr(ArrayTypeTraitExpr *E) {
16067 TypeSourceInfo *T = getDerived().TransformType(E->getQueriedTypeSourceInfo());
16068 if (!T)
16069 return ExprError();
16070
16071 if (!getDerived().AlwaysRebuild() &&
16072 T == E->getQueriedTypeSourceInfo())
16073 return E;
16074
16075 ExprResult SubExpr;
16076 {
16077 EnterExpressionEvaluationContext Unevaluated(
16078 SemaRef, Sema::ExpressionEvaluationContext::Unevaluated);
16079 SubExpr = getDerived().TransformExpr(E->getDimensionExpression());
16080 if (SubExpr.isInvalid())
16081 return ExprError();
16082 }
16083
16084 return getDerived().RebuildArrayTypeTrait(E->getTrait(), E->getBeginLoc(), T,
16085 SubExpr.get(), E->getEndLoc());
16086}
16087
16088template<typename Derived>
16089ExprResult
16090TreeTransform<Derived>::TransformExpressionTraitExpr(ExpressionTraitExpr *E) {
16091 ExprResult SubExpr;
16092 {
16093 EnterExpressionEvaluationContext Unevaluated(
16094 SemaRef, Sema::ExpressionEvaluationContext::Unevaluated);
16095 SubExpr = getDerived().TransformExpr(E->getQueriedExpression());
16096 if (SubExpr.isInvalid())
16097 return ExprError();
16098
16099 if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getQueriedExpression())
16100 return E;
16101 }
16102
16103 return getDerived().RebuildExpressionTrait(E->getTrait(), E->getBeginLoc(),
16104 SubExpr.get(), E->getEndLoc());
16105}
16106
16107template <typename Derived>
16108ExprResult TreeTransform<Derived>::TransformParenDependentScopeDeclRefExpr(
16109 ParenExpr *PE, DependentScopeDeclRefExpr *DRE, bool AddrTaken,
16110 TypeSourceInfo **RecoveryTSI) {
16111 ExprResult NewDRE = getDerived().TransformDependentScopeDeclRefExpr(
16112 DRE, AddrTaken, RecoveryTSI);
16113
16114 // Propagate both errors and recovered types, which return ExprEmpty.
16115 if (!NewDRE.isUsable())
16116 return NewDRE;
16117
16118 // We got an expr, wrap it up in parens.
16119 if (!getDerived().AlwaysRebuild() && NewDRE.get() == DRE)
16120 return PE;
16121 return getDerived().RebuildParenExpr(NewDRE.get(), PE->getLParen(),
16122 PE->getRParen());
16123}
16124
16125template <typename Derived>
16126ExprResult TreeTransform<Derived>::TransformDependentScopeDeclRefExpr(
16127 DependentScopeDeclRefExpr *E) {
16128 return TransformDependentScopeDeclRefExpr(E, /*IsAddressOfOperand=*/false,
16129 nullptr);
16130}
16131
16132template <typename Derived>
16133ExprResult TreeTransform<Derived>::TransformDependentScopeDeclRefExpr(
16134 DependentScopeDeclRefExpr *E, bool IsAddressOfOperand,
16135 TypeSourceInfo **RecoveryTSI) {
16136 assert(E->getQualifierLoc());
16137 NestedNameSpecifierLoc QualifierLoc =
16138 getDerived().TransformNestedNameSpecifierLoc(E->getQualifierLoc());
16139 if (!QualifierLoc)
16140 return ExprError();
16141 SourceLocation TemplateKWLoc = E->getTemplateKeywordLoc();
16142
16143 // TODO: If this is a conversion-function-id, verify that the
16144 // destination type name (if present) resolves the same way after
16145 // instantiation as it did in the local scope.
16146
16147 DeclarationNameInfo NameInfo =
16148 getDerived().TransformDeclarationNameInfo(E->getNameInfo());
16149 if (!NameInfo.getName())
16150 return ExprError();
16151
16152 if (!E->hasExplicitTemplateArgs()) {
16153 if (!getDerived().AlwaysRebuild() && QualifierLoc == E->getQualifierLoc() &&
16154 // Note: it is sufficient to compare the Name component of NameInfo:
16155 // if name has not changed, DNLoc has not changed either.
16156 NameInfo.getName() == E->getDeclName())
16157 return E;
16158
16159 return getDerived().RebuildDependentScopeDeclRefExpr(
16160 QualifierLoc, TemplateKWLoc, NameInfo, /*TemplateArgs=*/nullptr,
16161 IsAddressOfOperand, RecoveryTSI);
16162 }
16163
16164 TemplateArgumentListInfo TransArgs(E->getLAngleLoc(), E->getRAngleLoc());
16165 if (getDerived().TransformTemplateArguments(
16166 E->getTemplateArgs(), E->getNumTemplateArgs(), TransArgs))
16167 return ExprError();
16168
16169 return getDerived().RebuildDependentScopeDeclRefExpr(
16170 QualifierLoc, TemplateKWLoc, NameInfo, &TransArgs, IsAddressOfOperand,
16171 RecoveryTSI);
16172}
16173
16174template<typename Derived>
16175ExprResult
16176TreeTransform<Derived>::TransformCXXConstructExpr(CXXConstructExpr *E) {
16177 // CXXConstructExprs other than for list-initialization and
16178 // CXXTemporaryObjectExpr are always implicit, so when we have
16179 // a 1-argument construction we just transform that argument.
16180 if (getDerived().AllowSkippingCXXConstructExpr() &&
16181 ((E->getNumArgs() == 1 ||
16182 (E->getNumArgs() > 1 && getDerived().DropCallArgument(E->getArg(Arg: 1)))) &&
16183 (!getDerived().DropCallArgument(E->getArg(Arg: 0))) &&
16184 !E->isListInitialization()))
16185 return getDerived().TransformInitializer(E->getArg(Arg: 0),
16186 /*DirectInit*/ false);
16187
16188 TemporaryBase Rebase(*this, /*FIXME*/ E->getBeginLoc(), DeclarationName());
16189
16190 QualType T = getDerived().TransformType(E->getType());
16191 if (T.isNull())
16192 return ExprError();
16193
16194 CXXConstructorDecl *Constructor = cast_or_null<CXXConstructorDecl>(
16195 getDerived().TransformDecl(E->getBeginLoc(), E->getConstructor()));
16196 if (!Constructor)
16197 return ExprError();
16198
16199 bool ArgumentChanged = false;
16200 SmallVector<Expr*, 8> Args;
16201 {
16202 EnterExpressionEvaluationContext Context(
16203 getSema(), EnterExpressionEvaluationContext::InitList,
16204 E->isListInitialization());
16205 if (getDerived().TransformExprs(E->getArgs(), E->getNumArgs(), true, Args,
16206 &ArgumentChanged))
16207 return ExprError();
16208 }
16209
16210 if (!getDerived().AlwaysRebuild() &&
16211 T == E->getType() &&
16212 Constructor == E->getConstructor() &&
16213 !ArgumentChanged) {
16214 // Mark the constructor as referenced.
16215 // FIXME: Instantiation-specific
16216 SemaRef.MarkFunctionReferenced(Loc: E->getBeginLoc(), Func: Constructor);
16217 return E;
16218 }
16219
16220 return getDerived().RebuildCXXConstructExpr(
16221 T, /*FIXME:*/ E->getBeginLoc(), Constructor, E->isElidable(), Args,
16222 E->hadMultipleCandidates(), E->isListInitialization(),
16223 E->isStdInitListInitialization(), E->requiresZeroInitialization(),
16224 E->getConstructionKind(), E->getParenOrBraceRange());
16225}
16226
16227template<typename Derived>
16228ExprResult TreeTransform<Derived>::TransformCXXInheritedCtorInitExpr(
16229 CXXInheritedCtorInitExpr *E) {
16230 QualType T = getDerived().TransformType(E->getType());
16231 if (T.isNull())
16232 return ExprError();
16233
16234 CXXConstructorDecl *Constructor = cast_or_null<CXXConstructorDecl>(
16235 getDerived().TransformDecl(E->getBeginLoc(), E->getConstructor()));
16236 if (!Constructor)
16237 return ExprError();
16238
16239 if (!getDerived().AlwaysRebuild() &&
16240 T == E->getType() &&
16241 Constructor == E->getConstructor()) {
16242 // Mark the constructor as referenced.
16243 // FIXME: Instantiation-specific
16244 SemaRef.MarkFunctionReferenced(Loc: E->getBeginLoc(), Func: Constructor);
16245 return E;
16246 }
16247
16248 return getDerived().RebuildCXXInheritedCtorInitExpr(
16249 T, E->getLocation(), Constructor,
16250 E->constructsVBase(), E->inheritedFromVBase());
16251}
16252
16253/// Transform a C++ temporary-binding expression.
16254///
16255/// Since CXXBindTemporaryExpr nodes are implicitly generated, we just
16256/// transform the subexpression and return that.
16257template<typename Derived>
16258ExprResult
16259TreeTransform<Derived>::TransformCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) {
16260 if (auto *Dtor = E->getTemporary()->getDestructor())
16261 SemaRef.MarkFunctionReferenced(Loc: E->getBeginLoc(),
16262 Func: const_cast<CXXDestructorDecl *>(Dtor));
16263 return getDerived().TransformExpr(E->getSubExpr());
16264}
16265
16266/// Transform a C++ expression that contains cleanups that should
16267/// be run after the expression is evaluated.
16268///
16269/// Since ExprWithCleanups nodes are implicitly generated, we
16270/// just transform the subexpression and return that.
16271template<typename Derived>
16272ExprResult
16273TreeTransform<Derived>::TransformExprWithCleanups(ExprWithCleanups *E) {
16274 return getDerived().TransformExpr(E->getSubExpr());
16275}
16276
16277template<typename Derived>
16278ExprResult
16279TreeTransform<Derived>::TransformCXXTemporaryObjectExpr(
16280 CXXTemporaryObjectExpr *E) {
16281 TypeSourceInfo *T =
16282 getDerived().TransformTypeWithDeducedTST(E->getTypeSourceInfo());
16283 if (!T)
16284 return ExprError();
16285
16286 CXXConstructorDecl *Constructor = cast_or_null<CXXConstructorDecl>(
16287 getDerived().TransformDecl(E->getBeginLoc(), E->getConstructor()));
16288 if (!Constructor)
16289 return ExprError();
16290
16291 bool ArgumentChanged = false;
16292 SmallVector<Expr*, 8> Args;
16293 Args.reserve(N: E->getNumArgs());
16294 {
16295 EnterExpressionEvaluationContext Context(
16296 getSema(), EnterExpressionEvaluationContext::InitList,
16297 E->isListInitialization());
16298 if (TransformExprs(Inputs: E->getArgs(), NumInputs: E->getNumArgs(), IsCall: true, Outputs&: Args,
16299 ArgChanged: &ArgumentChanged))
16300 return ExprError();
16301
16302 if (E->isListInitialization() && !E->isStdInitListInitialization()) {
16303 ExprResult Res = RebuildInitList(LBraceLoc: E->getBeginLoc(), Inits: Args, RBraceLoc: E->getEndLoc(),
16304 /*IsExplicit=*/IsExplicit: true);
16305 if (Res.isInvalid())
16306 return ExprError();
16307 Args = {Res.get()};
16308 }
16309 }
16310
16311 if (!getDerived().AlwaysRebuild() &&
16312 T == E->getTypeSourceInfo() &&
16313 Constructor == E->getConstructor() &&
16314 !ArgumentChanged) {
16315 // FIXME: Instantiation-specific
16316 SemaRef.MarkFunctionReferenced(Loc: E->getBeginLoc(), Func: Constructor);
16317 return SemaRef.MaybeBindToTemporary(E);
16318 }
16319
16320 SourceLocation LParenLoc = T->getTypeLoc().getEndLoc();
16321 return getDerived().RebuildCXXTemporaryObjectExpr(
16322 T, LParenLoc, Args, E->getEndLoc(), E->isListInitialization());
16323}
16324
16325template<typename Derived>
16326ExprResult
16327TreeTransform<Derived>::TransformLambdaExpr(LambdaExpr *E) {
16328 // Transform any init-capture expressions before entering the scope of the
16329 // lambda body, because they are not semantically within that scope.
16330 typedef std::pair<ExprResult, QualType> InitCaptureInfoTy;
16331 struct TransformedInitCapture {
16332 // The location of the ... if the result is retaining a pack expansion.
16333 SourceLocation EllipsisLoc;
16334 // Zero or more expansions of the init-capture.
16335 SmallVector<InitCaptureInfoTy, 4> Expansions;
16336 };
16337 SmallVector<TransformedInitCapture, 4> InitCaptures;
16338 InitCaptures.resize(E->explicit_capture_end() - E->explicit_capture_begin());
16339 for (LambdaExpr::capture_iterator C = E->capture_begin(),
16340 CEnd = E->capture_end();
16341 C != CEnd; ++C) {
16342 if (!E->isInitCapture(Capture: C))
16343 continue;
16344
16345 TransformedInitCapture &Result = InitCaptures[C - E->capture_begin()];
16346 auto *OldVD = cast<VarDecl>(Val: C->getCapturedVar());
16347
16348 auto SubstInitCapture = [&](SourceLocation EllipsisLoc,
16349 UnsignedOrNone NumExpansions) {
16350 ExprResult NewExprInitResult = getDerived().TransformInitializer(
16351 OldVD->getInit(), OldVD->getInitStyle() == VarDecl::CallInit);
16352
16353 if (NewExprInitResult.isInvalid()) {
16354 Result.Expansions.push_back(InitCaptureInfoTy(ExprError(), QualType()));
16355 return;
16356 }
16357 Expr *NewExprInit = NewExprInitResult.get();
16358
16359 QualType NewInitCaptureType =
16360 getSema().buildLambdaInitCaptureInitialization(
16361 C->getLocation(), C->getCaptureKind() == LCK_ByRef,
16362 EllipsisLoc, NumExpansions, OldVD->getIdentifier(),
16363 cast<VarDecl>(Val: C->getCapturedVar())->getInitStyle() !=
16364 VarDecl::CInit,
16365 NewExprInit);
16366 Result.Expansions.push_back(
16367 InitCaptureInfoTy(NewExprInit, NewInitCaptureType));
16368 };
16369
16370 // If this is an init-capture pack, consider expanding the pack now.
16371 if (OldVD->isParameterPack()) {
16372 PackExpansionTypeLoc ExpansionTL = OldVD->getTypeSourceInfo()
16373 ->getTypeLoc()
16374 .castAs<PackExpansionTypeLoc>();
16375 SmallVector<UnexpandedParameterPack, 2> Unexpanded;
16376 SemaRef.collectUnexpandedParameterPacks(E: OldVD->getInit(), Unexpanded);
16377
16378 // Determine whether the set of unexpanded parameter packs can and should
16379 // be expanded.
16380 bool Expand = true;
16381 bool RetainExpansion = false;
16382 UnsignedOrNone OrigNumExpansions =
16383 ExpansionTL.getTypePtr()->getNumExpansions();
16384 UnsignedOrNone NumExpansions = OrigNumExpansions;
16385 if (getDerived().TryExpandParameterPacks(
16386 ExpansionTL.getEllipsisLoc(), OldVD->getInit()->getSourceRange(),
16387 Unexpanded, /*FailOnPackProducingTemplates=*/true, Expand,
16388 RetainExpansion, NumExpansions))
16389 return ExprError();
16390 assert(!RetainExpansion && "Should not need to retain expansion after a "
16391 "capture since it cannot be extended");
16392 if (Expand) {
16393 for (unsigned I = 0; I != *NumExpansions; ++I) {
16394 Sema::ArgPackSubstIndexRAII SubstIndex(getSema(), I);
16395 SubstInitCapture(SourceLocation(), std::nullopt);
16396 }
16397 } else {
16398 SubstInitCapture(ExpansionTL.getEllipsisLoc(), NumExpansions);
16399 Result.EllipsisLoc = ExpansionTL.getEllipsisLoc();
16400 }
16401 } else {
16402 SubstInitCapture(SourceLocation(), std::nullopt);
16403 }
16404 }
16405
16406 LambdaScopeInfo *LSI = getSema().PushLambdaScope();
16407 Sema::FunctionScopeRAII FuncScopeCleanup(getSema());
16408
16409 // Create the local class that will describe the lambda.
16410
16411 // FIXME: DependencyKind below is wrong when substituting inside a templated
16412 // context that isn't a DeclContext (such as a variable template), or when
16413 // substituting an unevaluated lambda inside of a function's parameter's type
16414 // - as parameter types are not instantiated from within a function's DC. We
16415 // use evaluation contexts to distinguish the function parameter case.
16416 CXXRecordDecl::LambdaDependencyKind DependencyKind =
16417 CXXRecordDecl::LDK_Unknown;
16418 DeclContext *DC = getSema().CurContext;
16419 // A RequiresExprBodyDecl is not interesting for dependencies.
16420 // For the following case,
16421 //
16422 // template <typename>
16423 // concept C = requires { [] {}; };
16424 //
16425 // template <class F>
16426 // struct Widget;
16427 //
16428 // template <C F>
16429 // struct Widget<F> {};
16430 //
16431 // While we are substituting Widget<F>, the parent of DC would be
16432 // the template specialization itself. Thus, the lambda expression
16433 // will be deemed as dependent even if there are no dependent template
16434 // arguments.
16435 // (A ClassTemplateSpecializationDecl is always a dependent context.)
16436 while (DC->isRequiresExprBody() || isa<CXXExpansionStmtDecl>(Val: DC))
16437 DC = DC->getParent();
16438 if ((getSema().isUnevaluatedContext() ||
16439 getSema().isConstantEvaluatedContext()) &&
16440 !(dyn_cast_or_null<CXXRecordDecl>(Val: DC->getParent()) &&
16441 cast<CXXRecordDecl>(Val: DC->getParent())->isGenericLambda()) &&
16442 (DC->isFileContext() || !DC->getParent()->isDependentContext()))
16443 DependencyKind = CXXRecordDecl::LDK_NeverDependent;
16444
16445 CXXRecordDecl *OldClass = E->getLambdaClass();
16446 CXXRecordDecl *Class = getSema().createLambdaClosureType(
16447 E->getIntroducerRange(), /*Info=*/nullptr, DependencyKind,
16448 E->getCaptureDefault());
16449 getDerived().transformedLocalDecl(OldClass, {Class});
16450
16451 CXXMethodDecl *NewCallOperator =
16452 getSema().CreateLambdaCallOperator(E->getIntroducerRange(), Class);
16453
16454 // Enter the scope of the lambda.
16455 getSema().buildLambdaScope(LSI, NewCallOperator, E->getIntroducerRange(),
16456 E->getCaptureDefault(), E->getCaptureDefaultLoc(),
16457 E->hasExplicitParameters(), E->isMutable());
16458
16459 // Introduce the context of the call operator.
16460 Sema::ContextRAII SavedContext(getSema(), NewCallOperator,
16461 /*NewThisContext*/false);
16462
16463 bool Invalid = false;
16464
16465 // Transform captures.
16466 for (LambdaExpr::capture_iterator C = E->capture_begin(),
16467 CEnd = E->capture_end();
16468 C != CEnd; ++C) {
16469 // When we hit the first implicit capture, tell Sema that we've finished
16470 // the list of explicit captures.
16471 if (C->isImplicit())
16472 break;
16473
16474 // Capturing 'this' is trivial.
16475 if (C->capturesThis()) {
16476 // If this is a lambda that is part of a default member initialiser
16477 // and which we're instantiating outside the class that 'this' is
16478 // supposed to refer to, adjust the type of 'this' accordingly.
16479 //
16480 // Otherwise, leave the type of 'this' as-is.
16481 Sema::CXXThisScopeRAII ThisScope(
16482 getSema(),
16483 dyn_cast_if_present<CXXRecordDecl>(
16484 getSema().getFunctionLevelDeclContext()),
16485 Qualifiers());
16486 getSema().CheckCXXThisCapture(C->getLocation(), C->isExplicit(),
16487 /*BuildAndDiagnose*/ true, nullptr,
16488 C->getCaptureKind() == LCK_StarThis);
16489 continue;
16490 }
16491 // Captured expression will be recaptured during captured variables
16492 // rebuilding.
16493 if (C->capturesVLAType())
16494 continue;
16495
16496 // Rebuild init-captures, including the implied field declaration.
16497 if (E->isInitCapture(Capture: C)) {
16498 TransformedInitCapture &NewC = InitCaptures[C - E->capture_begin()];
16499
16500 auto *OldVD = cast<VarDecl>(Val: C->getCapturedVar());
16501 llvm::SmallVector<Decl*, 4> NewVDs;
16502
16503 for (InitCaptureInfoTy &Info : NewC.Expansions) {
16504 ExprResult Init = Info.first;
16505 QualType InitQualType = Info.second;
16506 if (Init.isInvalid() || InitQualType.isNull()) {
16507 Invalid = true;
16508 break;
16509 }
16510 VarDecl *NewVD = getSema().createLambdaInitCaptureVarDecl(
16511 OldVD->getLocation(), InitQualType, NewC.EllipsisLoc,
16512 OldVD->getIdentifier(), OldVD->getInitStyle(), Init.get(),
16513 getSema().CurContext);
16514 if (!NewVD) {
16515 Invalid = true;
16516 break;
16517 }
16518 NewVDs.push_back(Elt: NewVD);
16519 getSema().addInitCapture(LSI, NewVD, C->getCaptureKind() == LCK_ByRef);
16520 // Cases we want to tackle:
16521 // ([C(Pack)] {}, ...)
16522 // But rule out cases e.g.
16523 // [...C = Pack()] {}
16524 if (NewC.EllipsisLoc.isInvalid())
16525 LSI->ContainsUnexpandedParameterPack |=
16526 Init.get()->containsUnexpandedParameterPack();
16527 }
16528
16529 if (Invalid)
16530 break;
16531
16532 getDerived().transformedLocalDecl(OldVD, NewVDs);
16533 continue;
16534 }
16535
16536 assert(C->capturesVariable() && "unexpected kind of lambda capture");
16537
16538 // Determine the capture kind for Sema.
16539 TryCaptureKind Kind = C->isImplicit() ? TryCaptureKind::Implicit
16540 : C->getCaptureKind() == LCK_ByCopy
16541 ? TryCaptureKind::ExplicitByVal
16542 : TryCaptureKind::ExplicitByRef;
16543 SourceLocation EllipsisLoc;
16544 if (C->isPackExpansion()) {
16545 UnexpandedParameterPack Unexpanded(C->getCapturedVar(), C->getLocation());
16546 bool ShouldExpand = false;
16547 bool RetainExpansion = false;
16548 UnsignedOrNone NumExpansions = std::nullopt;
16549 if (getDerived().TryExpandParameterPacks(
16550 C->getEllipsisLoc(), C->getLocation(), Unexpanded,
16551 /*FailOnPackProducingTemplates=*/true, ShouldExpand,
16552 RetainExpansion, NumExpansions)) {
16553 Invalid = true;
16554 continue;
16555 }
16556
16557 if (ShouldExpand) {
16558 // The transform has determined that we should perform an expansion;
16559 // transform and capture each of the arguments.
16560 // expansion of the pattern. Do so.
16561 auto *Pack = cast<ValueDecl>(Val: C->getCapturedVar());
16562 for (unsigned I = 0; I != *NumExpansions; ++I) {
16563 Sema::ArgPackSubstIndexRAII SubstIndex(getSema(), I);
16564 ValueDecl *CapturedVar = cast_if_present<ValueDecl>(
16565 getDerived().TransformDecl(C->getLocation(), Pack));
16566 if (!CapturedVar) {
16567 Invalid = true;
16568 continue;
16569 }
16570
16571 // Capture the transformed variable.
16572 getSema().tryCaptureVariable(CapturedVar, C->getLocation(), Kind);
16573 }
16574
16575 // FIXME: Retain a pack expansion if RetainExpansion is true.
16576
16577 continue;
16578 }
16579
16580 EllipsisLoc = C->getEllipsisLoc();
16581 }
16582
16583 // Transform the captured variable.
16584 auto *CapturedVar = cast_or_null<ValueDecl>(
16585 getDerived().TransformDecl(C->getLocation(), C->getCapturedVar()));
16586 if (!CapturedVar || CapturedVar->isInvalidDecl()) {
16587 Invalid = true;
16588 continue;
16589 }
16590
16591 // This is not an init-capture; however it contains an unexpanded pack e.g.
16592 // ([Pack] {}(), ...)
16593 if (auto *VD = dyn_cast<VarDecl>(CapturedVar); VD && !C->isPackExpansion())
16594 LSI->ContainsUnexpandedParameterPack |= VD->isParameterPack();
16595
16596 // Capture the transformed variable.
16597 getSema().tryCaptureVariable(CapturedVar, C->getLocation(), Kind,
16598 EllipsisLoc);
16599 }
16600 getSema().finishLambdaExplicitCaptures(LSI);
16601
16602 // Transform the template parameters, and add them to the current
16603 // instantiation scope. The null case is handled correctly.
16604 auto TPL = getDerived().TransformTemplateParameterList(
16605 E->getTemplateParameterList());
16606 LSI->GLTemplateParameterList = TPL;
16607 if (TPL) {
16608 getSema().AddTemplateParametersToLambdaCallOperator(NewCallOperator, Class,
16609 TPL);
16610 LSI->ContainsUnexpandedParameterPack |=
16611 TPL->containsUnexpandedParameterPack();
16612 }
16613
16614 TypeLocBuilder NewCallOpTLBuilder;
16615 TypeLoc OldCallOpTypeLoc =
16616 E->getCallOperator()->getTypeSourceInfo()->getTypeLoc();
16617 QualType NewCallOpType =
16618 getDerived().TransformType(NewCallOpTLBuilder, OldCallOpTypeLoc);
16619 if (NewCallOpType.isNull())
16620 return ExprError();
16621 LSI->ContainsUnexpandedParameterPack |=
16622 NewCallOpType->containsUnexpandedParameterPack();
16623 TypeSourceInfo *NewCallOpTSI =
16624 NewCallOpTLBuilder.getTypeSourceInfo(Context&: getSema().Context, T: NewCallOpType);
16625
16626 // The type may be an AttributedType or some other kind of sugar;
16627 // get the actual underlying FunctionProtoType.
16628 auto FPTL = NewCallOpTSI->getTypeLoc().getAsAdjusted<FunctionProtoTypeLoc>();
16629 assert(FPTL && "Not a FunctionProtoType?");
16630
16631 AssociatedConstraint TRC = E->getCallOperator()->getTrailingRequiresClause();
16632 if (TRC) {
16633 ExprResult E = getDerived().TransformLambdaConstraint(
16634 const_cast<Expr *>(TRC.ConstraintExpr));
16635 if (E.isInvalid())
16636 return E;
16637 TRC.ConstraintExpr = E.get();
16638 }
16639
16640 LSI->BeforeCompoundStatement = false;
16641 getSema().CompleteLambdaCallOperator(
16642 NewCallOperator, E->getCallOperator()->getLocation(),
16643 E->getCallOperator()->getInnerLocStart(), TRC, NewCallOpTSI,
16644 E->getCallOperator()->getConstexprKind(),
16645 E->getCallOperator()->getStorageClass(), FPTL.getParams(),
16646 E->hasExplicitResultType());
16647
16648 getDerived().transformAttrs(E->getCallOperator(), NewCallOperator);
16649 getDerived().transformedLocalDecl(E->getCallOperator(), {NewCallOperator});
16650
16651 {
16652 // Number the lambda for linkage purposes if necessary.
16653 Sema::ContextRAII ManglingContext(getSema(), Class->getDeclContext());
16654
16655 std::optional<CXXRecordDecl::LambdaNumbering> Numbering;
16656 if (getDerived().ReplacingOriginal()) {
16657 Numbering = OldClass->getLambdaNumbering();
16658 }
16659
16660 getSema().handleLambdaNumbering(Class, NewCallOperator, Numbering);
16661 }
16662
16663 // FIXME: Sema's lambda-building mechanism expects us to push an expression
16664 // evaluation context even if we're not transforming the function body.
16665 getSema().PushExpressionEvaluationContextForFunction(
16666 Sema::ExpressionEvaluationContext::PotentiallyEvaluated,
16667 E->getCallOperator());
16668
16669 StmtResult Body;
16670 {
16671 Sema::NonSFINAEContext _(getSema());
16672 Sema::CodeSynthesisContext C;
16673 C.Kind = clang::Sema::CodeSynthesisContext::LambdaExpressionSubstitution;
16674 C.PointOfInstantiation = E->getBody()->getBeginLoc();
16675 getSema().pushCodeSynthesisContext(C);
16676
16677 // Instantiate the body of the lambda expression.
16678 Body = Invalid ? StmtError()
16679 : getDerived().TransformLambdaBody(E, E->getBody());
16680
16681 getSema().popCodeSynthesisContext();
16682 }
16683
16684 // ActOnLambda* will pop the function scope for us.
16685 FuncScopeCleanup.disable();
16686
16687 if (Body.isInvalid()) {
16688 SavedContext.pop();
16689 getSema().ActOnLambdaError(E->getBeginLoc(), /*CurScope=*/nullptr,
16690 /*IsInstantiation=*/true);
16691 return ExprError();
16692 }
16693
16694 getSema().ActOnFinishFunctionBody(NewCallOperator, Body.get(),
16695 /*IsInstantiation=*/true,
16696 /*RetainFunctionScopeInfo=*/true);
16697 SavedContext.pop();
16698
16699 // Recompute the dependency of the lambda so that we can defer the lambda call
16700 // construction until after we have all the necessary template arguments. For
16701 // example, given
16702 //
16703 // template <class> struct S {
16704 // template <class U>
16705 // using Type = decltype([](U){}(42.0));
16706 // };
16707 // void foo() {
16708 // using T = S<int>::Type<float>;
16709 // ^~~~~~
16710 // }
16711 //
16712 // We would end up here from instantiating S<int> when ensuring its
16713 // completeness. That would transform the lambda call expression regardless of
16714 // the absence of the corresponding argument for U.
16715 //
16716 // Going ahead with unsubstituted type U makes things worse: we would soon
16717 // compare the argument type (which is float) against the parameter U
16718 // somewhere in Sema::BuildCallExpr. Then we would quickly run into a bogus
16719 // error suggesting unmatched types 'U' and 'float'!
16720 //
16721 // That said, everything will be fine if we defer that semantic checking.
16722 // Fortunately, we have such a mechanism that bypasses it if the CallExpr is
16723 // dependent. Since the CallExpr's dependency boils down to the lambda's
16724 // dependency in this case, we can harness that by recomputing the dependency
16725 // from the instantiation arguments.
16726 //
16727 // FIXME: Creating the type of a lambda requires us to have a dependency
16728 // value, which happens before its substitution. We update its dependency
16729 // *after* the substitution in case we can't decide the dependency
16730 // so early, e.g. because we want to see if any of the *substituted*
16731 // parameters are dependent.
16732 DependencyKind = getDerived().ComputeLambdaDependency(LSI);
16733 Class->setLambdaDependencyKind(DependencyKind);
16734
16735 return getDerived().RebuildLambdaExpr(E->getBeginLoc(),
16736 Body.get()->getEndLoc(), LSI);
16737}
16738
16739template<typename Derived>
16740StmtResult
16741TreeTransform<Derived>::TransformLambdaBody(LambdaExpr *E, Stmt *S) {
16742 return TransformStmt(S);
16743}
16744
16745template<typename Derived>
16746StmtResult
16747TreeTransform<Derived>::SkipLambdaBody(LambdaExpr *E, Stmt *S) {
16748 // Transform captures.
16749 for (LambdaExpr::capture_iterator C = E->capture_begin(),
16750 CEnd = E->capture_end();
16751 C != CEnd; ++C) {
16752 // When we hit the first implicit capture, tell Sema that we've finished
16753 // the list of explicit captures.
16754 if (!C->isImplicit())
16755 continue;
16756
16757 // Capturing 'this' is trivial.
16758 if (C->capturesThis()) {
16759 getSema().CheckCXXThisCapture(C->getLocation(), C->isExplicit(),
16760 /*BuildAndDiagnose*/ true, nullptr,
16761 C->getCaptureKind() == LCK_StarThis);
16762 continue;
16763 }
16764 // Captured expression will be recaptured during captured variables
16765 // rebuilding.
16766 if (C->capturesVLAType())
16767 continue;
16768
16769 assert(C->capturesVariable() && "unexpected kind of lambda capture");
16770 assert(!E->isInitCapture(C) && "implicit init-capture?");
16771
16772 // Transform the captured variable.
16773 VarDecl *CapturedVar = cast_or_null<VarDecl>(
16774 getDerived().TransformDecl(C->getLocation(), C->getCapturedVar()));
16775 if (!CapturedVar || CapturedVar->isInvalidDecl())
16776 return StmtError();
16777
16778 // Capture the transformed variable.
16779 getSema().tryCaptureVariable(CapturedVar, C->getLocation());
16780 }
16781
16782 return S;
16783}
16784
16785template<typename Derived>
16786ExprResult
16787TreeTransform<Derived>::TransformCXXUnresolvedConstructExpr(
16788 CXXUnresolvedConstructExpr *E) {
16789 TypeSourceInfo *T =
16790 getDerived().TransformTypeWithDeducedTST(E->getTypeSourceInfo());
16791 if (!T)
16792 return ExprError();
16793
16794 bool ArgumentChanged = false;
16795 SmallVector<Expr*, 8> Args;
16796 Args.reserve(N: E->getNumArgs());
16797 {
16798 EnterExpressionEvaluationContext Context(
16799 getSema(), EnterExpressionEvaluationContext::InitList,
16800 E->isListInitialization());
16801 if (getDerived().TransformExprs(E->arg_begin(), E->getNumArgs(), true, Args,
16802 &ArgumentChanged))
16803 return ExprError();
16804 }
16805
16806 if (!getDerived().AlwaysRebuild() &&
16807 T == E->getTypeSourceInfo() &&
16808 !ArgumentChanged)
16809 return E;
16810
16811 // FIXME: we're faking the locations of the commas
16812 return getDerived().RebuildCXXUnresolvedConstructExpr(
16813 T, E->getLParenLoc(), Args, E->getRParenLoc(), E->isListInitialization());
16814}
16815
16816template <typename Derived>
16817ExprResult TreeTransform<Derived>::TransformDependentTemplateIdExpr(
16818 DependentTemplateIdExpr *E) {
16819
16820 TemplateName Name = getDerived().TransformConceptTemplateName(
16821 E->getTemplateName(), E->getNameLoc());
16822 if (Name.isNull())
16823 return ExprError();
16824
16825 TemplateArgumentListInfo TransArgs(E->getLAngleLoc(), E->getRAngleLoc());
16826 if (getDerived().TransformTemplateArguments(
16827 E->template_arguments().data(), E->getNumTemplateArgs(), TransArgs))
16828 return ExprError();
16829
16830 TemplateDecl *TD = Name.getAsTemplateDecl();
16831 if (!TD)
16832 return SemaRef.CheckVarOrConceptTemplateTemplateId(NameInfo: E->getNameInfo(), Template: Name,
16833 TemplateArgs: &TransArgs);
16834
16835 CXXScopeSpec SS;
16836
16837 LookupResult R(SemaRef, E->getNameInfo(), Sema::LookupOrdinaryName);
16838 R.addDecl(D: TD);
16839 R.resolveKind();
16840 return getDerived().RebuildTemplateIdExpr(
16841 SS, /*Template Keyword=*/SourceLocation(), R,
16842 /*RequiresADL=*/false, &TransArgs);
16843}
16844
16845template<typename Derived>
16846ExprResult
16847TreeTransform<Derived>::TransformCXXDependentScopeMemberExpr(
16848 CXXDependentScopeMemberExpr *E) {
16849 // Transform the base of the expression.
16850 ExprResult Base((Expr*) nullptr);
16851 Expr *OldBase;
16852 QualType BaseType;
16853 QualType ObjectType;
16854 if (!E->isImplicitAccess()) {
16855 OldBase = E->getBase();
16856 Base = getDerived().TransformExpr(OldBase);
16857 if (Base.isInvalid())
16858 return ExprError();
16859
16860 // Start the member reference and compute the object's type.
16861 ParsedType ObjectTy;
16862 bool MayBePseudoDestructor = false;
16863 Base = SemaRef.ActOnStartCXXMemberReference(S: nullptr, Base: Base.get(),
16864 OpLoc: E->getOperatorLoc(),
16865 OpKind: E->isArrow()? tok::arrow : tok::period,
16866 ObjectType&: ObjectTy,
16867 MayBePseudoDestructor);
16868 if (Base.isInvalid())
16869 return ExprError();
16870
16871 ObjectType = ObjectTy.get();
16872 BaseType = ((Expr*) Base.get())->getType();
16873 } else {
16874 OldBase = nullptr;
16875 BaseType = getDerived().TransformType(E->getBaseType());
16876 ObjectType = BaseType->castAs<PointerType>()->getPointeeType();
16877 }
16878
16879 // Transform the first part of the nested-name-specifier that qualifies
16880 // the member name.
16881 NamedDecl *FirstQualifierInScope
16882 = getDerived().TransformFirstQualifierInScope(
16883 E->getFirstQualifierFoundInScope(),
16884 E->getQualifierLoc().getBeginLoc());
16885
16886 NestedNameSpecifierLoc QualifierLoc;
16887 if (E->getQualifier()) {
16888 QualifierLoc
16889 = getDerived().TransformNestedNameSpecifierLoc(E->getQualifierLoc(),
16890 ObjectType,
16891 FirstQualifierInScope);
16892 if (!QualifierLoc)
16893 return ExprError();
16894 }
16895
16896 SourceLocation TemplateKWLoc = E->getTemplateKeywordLoc();
16897
16898 // TODO: If this is a conversion-function-id, verify that the
16899 // destination type name (if present) resolves the same way after
16900 // instantiation as it did in the local scope.
16901
16902 DeclarationNameInfo NameInfo
16903 = getDerived().TransformDeclarationNameInfo(E->getMemberNameInfo());
16904 if (!NameInfo.getName())
16905 return ExprError();
16906
16907 if (!E->hasExplicitTemplateArgs()) {
16908 // This is a reference to a member without an explicitly-specified
16909 // template argument list. Optimize for this common case.
16910 if (!getDerived().AlwaysRebuild() &&
16911 Base.get() == OldBase &&
16912 BaseType == E->getBaseType() &&
16913 QualifierLoc == E->getQualifierLoc() &&
16914 NameInfo.getName() == E->getMember() &&
16915 FirstQualifierInScope == E->getFirstQualifierFoundInScope())
16916 return E;
16917
16918 return getDerived().RebuildCXXDependentScopeMemberExpr(Base.get(),
16919 BaseType,
16920 E->isArrow(),
16921 E->getOperatorLoc(),
16922 QualifierLoc,
16923 TemplateKWLoc,
16924 FirstQualifierInScope,
16925 NameInfo,
16926 /*TemplateArgs*/nullptr);
16927 }
16928
16929 TemplateArgumentListInfo TransArgs(E->getLAngleLoc(), E->getRAngleLoc());
16930 if (getDerived().TransformTemplateArguments(E->getTemplateArgs(),
16931 E->getNumTemplateArgs(),
16932 TransArgs))
16933 return ExprError();
16934
16935 return getDerived().RebuildCXXDependentScopeMemberExpr(Base.get(),
16936 BaseType,
16937 E->isArrow(),
16938 E->getOperatorLoc(),
16939 QualifierLoc,
16940 TemplateKWLoc,
16941 FirstQualifierInScope,
16942 NameInfo,
16943 &TransArgs);
16944}
16945
16946template <typename Derived>
16947ExprResult TreeTransform<Derived>::TransformUnresolvedMemberExpr(
16948 UnresolvedMemberExpr *Old) {
16949 // Transform the base of the expression.
16950 ExprResult Base((Expr *)nullptr);
16951 QualType BaseType;
16952 if (!Old->isImplicitAccess()) {
16953 Base = getDerived().TransformExpr(Old->getBase());
16954 if (Base.isInvalid())
16955 return ExprError();
16956 Base =
16957 getSema().PerformMemberExprBaseConversion(Base.get(), Old->isArrow());
16958 if (Base.isInvalid())
16959 return ExprError();
16960 BaseType = Base.get()->getType();
16961 } else {
16962 BaseType = getDerived().TransformType(Old->getBaseType());
16963 }
16964
16965 NestedNameSpecifierLoc QualifierLoc;
16966 if (Old->getQualifierLoc()) {
16967 QualifierLoc =
16968 getDerived().TransformNestedNameSpecifierLoc(Old->getQualifierLoc());
16969 if (!QualifierLoc)
16970 return ExprError();
16971 }
16972
16973 SourceLocation TemplateKWLoc = Old->getTemplateKeywordLoc();
16974
16975 LookupResult R(SemaRef, Old->getMemberNameInfo(), Sema::LookupOrdinaryName);
16976
16977 // Transform the declaration set.
16978 if (TransformOverloadExprDecls(Old, /*RequiresADL*/ RequiresADL: false, R))
16979 return ExprError();
16980
16981 // Determine the naming class.
16982 if (Old->getNamingClass()) {
16983 CXXRecordDecl *NamingClass = cast_or_null<CXXRecordDecl>(
16984 getDerived().TransformDecl(Old->getMemberLoc(), Old->getNamingClass()));
16985 if (!NamingClass)
16986 return ExprError();
16987
16988 R.setNamingClass(NamingClass);
16989 }
16990
16991 TemplateArgumentListInfo TransArgs;
16992 if (Old->hasExplicitTemplateArgs()) {
16993 TransArgs.setLAngleLoc(Old->getLAngleLoc());
16994 TransArgs.setRAngleLoc(Old->getRAngleLoc());
16995 if (getDerived().TransformTemplateArguments(
16996 Old->getTemplateArgs(), Old->getNumTemplateArgs(), TransArgs))
16997 return ExprError();
16998 }
16999
17000 // FIXME: to do this check properly, we will need to preserve the
17001 // first-qualifier-in-scope here, just in case we had a dependent
17002 // base (and therefore couldn't do the check) and a
17003 // nested-name-qualifier (and therefore could do the lookup).
17004 NamedDecl *FirstQualifierInScope = nullptr;
17005
17006 return getDerived().RebuildUnresolvedMemberExpr(
17007 Base.get(), BaseType, Old->getOperatorLoc(), Old->isArrow(), QualifierLoc,
17008 TemplateKWLoc, FirstQualifierInScope, R,
17009 (Old->hasExplicitTemplateArgs() ? &TransArgs : nullptr));
17010}
17011
17012template<typename Derived>
17013ExprResult
17014TreeTransform<Derived>::TransformCXXNoexceptExpr(CXXNoexceptExpr *E) {
17015 EnterExpressionEvaluationContext Unevaluated(
17016 SemaRef, Sema::ExpressionEvaluationContext::Unevaluated);
17017 ExprResult SubExpr = getDerived().TransformExpr(E->getOperand());
17018 if (SubExpr.isInvalid())
17019 return ExprError();
17020
17021 if (!getDerived().AlwaysRebuild() && SubExpr.get() == E->getOperand())
17022 return E;
17023
17024 return getDerived().RebuildCXXNoexceptExpr(E->getSourceRange(),SubExpr.get());
17025}
17026
17027template<typename Derived>
17028ExprResult
17029TreeTransform<Derived>::TransformPackExpansionExpr(PackExpansionExpr *E) {
17030 ExprResult Pattern = getDerived().TransformExpr(E->getPattern());
17031 if (Pattern.isInvalid())
17032 return ExprError();
17033
17034 if (!getDerived().AlwaysRebuild() && Pattern.get() == E->getPattern())
17035 return E;
17036
17037 return getDerived().RebuildPackExpansion(Pattern.get(), E->getEllipsisLoc(),
17038 E->getNumExpansions());
17039}
17040
17041template <typename Derived>
17042UnsignedOrNone TreeTransform<Derived>::ComputeSizeOfPackExprWithoutSubstitution(
17043 ArrayRef<TemplateArgument> PackArgs) {
17044 UnsignedOrNone Result = 0u;
17045 for (const TemplateArgument &Arg : PackArgs) {
17046 if (!Arg.isPackExpansion()) {
17047 Result = *Result + 1;
17048 continue;
17049 }
17050
17051 TemplateArgumentLoc ArgLoc;
17052 InventTemplateArgumentLoc(Arg, Output&: ArgLoc);
17053
17054 // Find the pattern of the pack expansion.
17055 SourceLocation Ellipsis;
17056 UnsignedOrNone OrigNumExpansions = std::nullopt;
17057 TemplateArgumentLoc Pattern =
17058 getSema().getTemplateArgumentPackExpansionPattern(ArgLoc, Ellipsis,
17059 OrigNumExpansions);
17060
17061 // Substitute under the pack expansion. Do not expand the pack (yet).
17062 TemplateArgumentLoc OutPattern;
17063 Sema::ArgPackSubstIndexRAII SubstIndex(getSema(), std::nullopt);
17064 if (getDerived().TransformTemplateArgument(Pattern, OutPattern,
17065 /*Uneval*/ true))
17066 return 1u;
17067
17068 // See if we can determine the number of arguments from the result.
17069 UnsignedOrNone NumExpansions =
17070 getSema().getFullyPackExpandedSize(OutPattern.getArgument());
17071 if (!NumExpansions) {
17072 // No: we must be in an alias template expansion, and we're going to
17073 // need to actually expand the packs.
17074 Result = std::nullopt;
17075 break;
17076 }
17077
17078 Result = *Result + *NumExpansions;
17079 }
17080 return Result;
17081}
17082
17083template<typename Derived>
17084ExprResult
17085TreeTransform<Derived>::TransformSizeOfPackExpr(SizeOfPackExpr *E) {
17086 // If E is not value-dependent, then nothing will change when we transform it.
17087 // Note: This is an instantiation-centric view.
17088 if (!E->isValueDependent())
17089 return E;
17090
17091 EnterExpressionEvaluationContext Unevaluated(
17092 getSema(), Sema::ExpressionEvaluationContext::Unevaluated);
17093
17094 ArrayRef<TemplateArgument> PackArgs;
17095 TemplateArgument ArgStorage;
17096
17097 // Find the argument list to transform.
17098 if (E->isPartiallySubstituted()) {
17099 PackArgs = E->getPartialArguments();
17100 } else if (E->isValueDependent()) {
17101 UnexpandedParameterPack Unexpanded(E->getPack(), E->getPackLoc());
17102 bool ShouldExpand = false;
17103 bool RetainExpansion = false;
17104 UnsignedOrNone NumExpansions = std::nullopt;
17105 if (getDerived().TryExpandParameterPacks(
17106 E->getOperatorLoc(), E->getPackLoc(), Unexpanded,
17107 /*FailOnPackProducingTemplates=*/true, ShouldExpand,
17108 RetainExpansion, NumExpansions))
17109 return ExprError();
17110
17111 // If we need to expand the pack, build a template argument from it and
17112 // expand that.
17113 if (ShouldExpand) {
17114 auto *Pack = E->getPack();
17115 if (auto *TTPD = dyn_cast<TemplateTypeParmDecl>(Val: Pack)) {
17116 ArgStorage = getSema().Context.getPackExpansionType(
17117 getSema().Context.getTypeDeclType(TTPD), std::nullopt);
17118 } else if (auto *TTPD = dyn_cast<TemplateTemplateParmDecl>(Val: Pack)) {
17119 ArgStorage = TemplateArgument(TemplateName(TTPD), std::nullopt);
17120 } else {
17121 auto *VD = cast<ValueDecl>(Val: Pack);
17122 ExprResult DRE = getSema().BuildDeclRefExpr(
17123 VD, VD->getType().getNonLValueExprType(Context: getSema().Context),
17124 VD->getType()->isReferenceType() ? VK_LValue : VK_PRValue,
17125 E->getPackLoc());
17126 if (DRE.isInvalid())
17127 return ExprError();
17128 ArgStorage = TemplateArgument(
17129 new (getSema().Context)
17130 PackExpansionExpr(DRE.get(), E->getPackLoc(), std::nullopt),
17131 /*IsCanonical=*/false);
17132 }
17133 PackArgs = ArgStorage;
17134 }
17135 }
17136
17137 // If we're not expanding the pack, just transform the decl.
17138 if (!PackArgs.size()) {
17139 auto *Pack = cast_or_null<NamedDecl>(
17140 getDerived().TransformDecl(E->getPackLoc(), E->getPack()));
17141 if (!Pack)
17142 return ExprError();
17143 return getDerived().RebuildSizeOfPackExpr(
17144 E->getOperatorLoc(), Pack, E->getPackLoc(), E->getRParenLoc(),
17145 std::nullopt, {});
17146 }
17147
17148 // Try to compute the result without performing a partial substitution.
17149 UnsignedOrNone Result =
17150 getDerived().ComputeSizeOfPackExprWithoutSubstitution(PackArgs);
17151
17152 // Common case: we could determine the number of expansions without
17153 // substituting.
17154 if (Result)
17155 return getDerived().RebuildSizeOfPackExpr(E->getOperatorLoc(), E->getPack(),
17156 E->getPackLoc(),
17157 E->getRParenLoc(), *Result, {});
17158
17159 TemplateArgumentListInfo TransformedPackArgs(E->getPackLoc(),
17160 E->getPackLoc());
17161 {
17162 TemporaryBase Rebase(*this, E->getPackLoc(), getBaseEntity());
17163 typedef TemplateArgumentLocInventIterator<
17164 Derived, const TemplateArgument*> PackLocIterator;
17165 if (TransformTemplateArguments(PackLocIterator(*this, PackArgs.begin()),
17166 PackLocIterator(*this, PackArgs.end()),
17167 TransformedPackArgs, /*Uneval*/true))
17168 return ExprError();
17169 }
17170
17171 // Check whether we managed to fully-expand the pack.
17172 // FIXME: Is it possible for us to do so and not hit the early exit path?
17173 SmallVector<TemplateArgument, 8> Args;
17174 bool PartialSubstitution = false;
17175 for (auto &Loc : TransformedPackArgs.arguments()) {
17176 Args.push_back(Elt: Loc.getArgument());
17177 if (Loc.getArgument().isPackExpansion())
17178 PartialSubstitution = true;
17179 }
17180
17181 if (PartialSubstitution)
17182 return getDerived().RebuildSizeOfPackExpr(
17183 E->getOperatorLoc(), E->getPack(), E->getPackLoc(), E->getRParenLoc(),
17184 std::nullopt, Args);
17185
17186 return getDerived().RebuildSizeOfPackExpr(
17187 E->getOperatorLoc(), E->getPack(), E->getPackLoc(), E->getRParenLoc(),
17188 /*Length=*/static_cast<unsigned>(Args.size()),
17189 /*PartialArgs=*/{});
17190}
17191
17192template <typename Derived>
17193ExprResult
17194TreeTransform<Derived>::TransformPackIndexingExpr(PackIndexingExpr *E) {
17195 if (!E->isValueDependent())
17196 return E;
17197
17198 // Transform the index
17199 ExprResult IndexExpr;
17200 {
17201 EnterExpressionEvaluationContext ConstantContext(
17202 SemaRef, Sema::ExpressionEvaluationContext::ConstantEvaluated);
17203 IndexExpr = getDerived().TransformExpr(E->getIndexExpr());
17204 if (IndexExpr.isInvalid())
17205 return ExprError();
17206 }
17207
17208 SmallVector<Expr *, 5> ExpandedExprs;
17209 bool FullySubstituted = true;
17210 if (!E->expandsToEmptyPack() && E->getExpressions().empty()) {
17211 Expr *Pattern = E->getPackIdExpression();
17212 SmallVector<UnexpandedParameterPack, 2> Unexpanded;
17213 getSema().collectUnexpandedParameterPacks(E->getPackIdExpression(),
17214 Unexpanded);
17215 assert(!Unexpanded.empty() && "Pack expansion without parameter packs?");
17216
17217 // Determine whether the set of unexpanded parameter packs can and should
17218 // be expanded.
17219 bool ShouldExpand = true;
17220 bool RetainExpansion = false;
17221 UnsignedOrNone OrigNumExpansions = std::nullopt,
17222 NumExpansions = std::nullopt;
17223 if (getDerived().TryExpandParameterPacks(
17224 E->getEllipsisLoc(), Pattern->getSourceRange(), Unexpanded,
17225 /*FailOnPackProducingTemplates=*/true, ShouldExpand,
17226 RetainExpansion, NumExpansions))
17227 return true;
17228 if (!ShouldExpand) {
17229 Sema::ArgPackSubstIndexRAII SubstIndex(getSema(), std::nullopt);
17230 ExprResult Pack = getDerived().TransformExpr(Pattern);
17231 if (Pack.isInvalid())
17232 return ExprError();
17233 return getDerived().RebuildPackIndexingExpr(
17234 E->getEllipsisLoc(), E->getRSquareLoc(), Pack.get(), IndexExpr.get(),
17235 {}, /*FullySubstituted=*/false);
17236 }
17237 for (unsigned I = 0; I != *NumExpansions; ++I) {
17238 Sema::ArgPackSubstIndexRAII SubstIndex(getSema(), I);
17239 ExprResult Out = getDerived().TransformExpr(Pattern);
17240 if (Out.isInvalid())
17241 return true;
17242 if (Out.get()->containsUnexpandedParameterPack()) {
17243 Out = getDerived().RebuildPackExpansion(Out.get(), E->getEllipsisLoc(),
17244 OrigNumExpansions);
17245 if (Out.isInvalid())
17246 return true;
17247 FullySubstituted = false;
17248 }
17249 ExpandedExprs.push_back(Elt: Out.get());
17250 }
17251 // If we're supposed to retain a pack expansion, do so by temporarily
17252 // forgetting the partially-substituted parameter pack.
17253 if (RetainExpansion) {
17254 ForgetPartiallySubstitutedPackRAII Forget(getDerived());
17255
17256 ExprResult Out = getDerived().TransformExpr(Pattern);
17257 if (Out.isInvalid())
17258 return true;
17259
17260 Out = getDerived().RebuildPackExpansion(Out.get(), E->getEllipsisLoc(),
17261 OrigNumExpansions);
17262 if (Out.isInvalid())
17263 return true;
17264 FullySubstituted = false;
17265 ExpandedExprs.push_back(Elt: Out.get());
17266 }
17267 } else if (!E->expandsToEmptyPack()) {
17268 if (getDerived().TransformExprs(E->getExpressions().data(),
17269 E->getExpressions().size(), false,
17270 ExpandedExprs))
17271 return ExprError();
17272 }
17273
17274 return getDerived().RebuildPackIndexingExpr(
17275 E->getEllipsisLoc(), E->getRSquareLoc(), E->getPackIdExpression(),
17276 IndexExpr.get(), ExpandedExprs, FullySubstituted);
17277}
17278
17279template <typename Derived>
17280ExprResult TreeTransform<Derived>::TransformSubstNonTypeTemplateParmPackExpr(
17281 SubstNonTypeTemplateParmPackExpr *E) {
17282 if (!getSema().ArgPackSubstIndex)
17283 // We aren't expanding the parameter pack, so just return ourselves.
17284 return E;
17285
17286 TemplateArgument Pack = E->getArgumentPack();
17287 TemplateArgument Arg = SemaRef.getPackSubstitutedTemplateArgument(Arg: Pack);
17288 return getDerived().RebuildSubstNonTypeTemplateParmExpr(
17289 E->getAssociatedDecl(), E->getParameterPack()->getPosition(),
17290 E->getParameterPack()->getType(), E->getParameterPackLocation(), Arg,
17291 SemaRef.getPackIndex(Pack), E->getFinal());
17292}
17293
17294template <typename Derived>
17295ExprResult TreeTransform<Derived>::TransformSubstNonTypeTemplateParmExpr(
17296 SubstNonTypeTemplateParmExpr *E) {
17297 Expr *OrigReplacement = E->getReplacement()->IgnoreImplicitAsWritten();
17298
17299 // Insert a constant-evaluated context for the transform.
17300 // Otherwise, when a normalized constraint places the replacement inside
17301 // an unevaluated operand (e.g. decltype), entities it refers to are not
17302 // odr-used, and the constant evaluation performed by CheckTemplateArgument
17303 // below can spuriously fail for otherwise valid replacements,
17304 // e.g. when a call materializes a function parameter of class type whose
17305 // special members were never instantiated.
17306 EnterExpressionEvaluationContext ConstantEvaluated(
17307 SemaRef, Sema::ExpressionEvaluationContext::ConstantEvaluated,
17308 Sema::ReuseLambdaContextDecl,
17309 Sema::ExpressionEvaluationContextRecord::EK_TemplateArgument);
17310
17311 ExprResult Replacement = getDerived().TransformExpr(OrigReplacement);
17312 if (Replacement.isInvalid())
17313 return true;
17314
17315 Decl *AssociatedDecl =
17316 getDerived().TransformDecl(E->getNameLoc(), E->getAssociatedDecl());
17317 if (!AssociatedDecl)
17318 return true;
17319
17320 QualType ParamType = TransformType(E->getParameterType());
17321 if (ParamType.isNull())
17322 return true;
17323
17324 if (Replacement.get() == OrigReplacement &&
17325 AssociatedDecl == E->getAssociatedDecl() &&
17326 ParamType == E->getParameterType())
17327 return E;
17328
17329 if (Replacement.get() != OrigReplacement ||
17330 ParamType != E->getParameterType()) {
17331 auto *Param = cast<NonTypeTemplateParmDecl>(Val: std::get<0>(
17332 t: getReplacedTemplateParameter(D: AssociatedDecl, Index: E->getIndex())));
17333 // When transforming the replacement expression previously, all Sema
17334 // specific annotations, such as implicit casts, are discarded. Calling the
17335 // corresponding sema action is necessary to recover those. Otherwise,
17336 // equivalency of the result would be lost.
17337 TemplateArgument SugaredConverted, CanonicalConverted;
17338 Replacement = SemaRef.CheckTemplateArgument(
17339 Param, InstantiatedParamType: ParamType, Arg: Replacement.get(), SugaredConverted,
17340 CanonicalConverted,
17341 /*StrictCheck=*/StrictCheck: false, CTAK: Sema::CTAK_Specified);
17342 if (Replacement.isInvalid())
17343 return true;
17344 } else {
17345 // Otherwise, the same expression would have been produced.
17346 Replacement = E->getReplacement();
17347 }
17348
17349 return getDerived().RebuildSubstNonTypeTemplateParmExpr(
17350 AssociatedDecl, E->getIndex(), ParamType, E->getNameLoc(),
17351 TemplateArgument(Replacement.get(), /*IsCanonical=*/false),
17352 E->getPackIndex(), E->getFinal());
17353}
17354
17355template<typename Derived>
17356ExprResult
17357TreeTransform<Derived>::TransformFunctionParmPackExpr(FunctionParmPackExpr *E) {
17358 // Default behavior is to do nothing with this transformation.
17359 return E;
17360}
17361
17362template<typename Derived>
17363ExprResult
17364TreeTransform<Derived>::TransformMaterializeTemporaryExpr(
17365 MaterializeTemporaryExpr *E) {
17366 return getDerived().TransformExpr(E->getSubExpr());
17367}
17368
17369template<typename Derived>
17370ExprResult
17371TreeTransform<Derived>::TransformCXXFoldExpr(CXXFoldExpr *E) {
17372 UnresolvedLookupExpr *Callee = nullptr;
17373 if (Expr *OldCallee = E->getCallee()) {
17374 ExprResult CalleeResult = getDerived().TransformExpr(OldCallee);
17375 if (CalleeResult.isInvalid())
17376 return ExprError();
17377 Callee = cast<UnresolvedLookupExpr>(Val: CalleeResult.get());
17378 }
17379
17380 Expr *Pattern = E->getPattern();
17381
17382 SmallVector<UnexpandedParameterPack, 2> Unexpanded;
17383 getSema().collectUnexpandedParameterPacks(Pattern, Unexpanded);
17384 assert(!Unexpanded.empty() && "Pack expansion without parameter packs?");
17385
17386 // Determine whether the set of unexpanded parameter packs can and should
17387 // be expanded.
17388 bool Expand = true;
17389 bool RetainExpansion = false;
17390 UnsignedOrNone OrigNumExpansions = E->getNumExpansions(),
17391 NumExpansions = OrigNumExpansions;
17392 if (getDerived().TryExpandParameterPacks(
17393 E->getEllipsisLoc(), Pattern->getSourceRange(), Unexpanded,
17394 /*FailOnPackProducingTemplates=*/true, Expand, RetainExpansion,
17395 NumExpansions))
17396 return true;
17397
17398 if (!Expand) {
17399 // Do not expand any packs here, just transform and rebuild a fold
17400 // expression.
17401 Sema::ArgPackSubstIndexRAII SubstIndex(getSema(), std::nullopt);
17402
17403 ExprResult LHS =
17404 E->getLHS() ? getDerived().TransformExpr(E->getLHS()) : ExprResult();
17405 if (LHS.isInvalid())
17406 return true;
17407
17408 ExprResult RHS =
17409 E->getRHS() ? getDerived().TransformExpr(E->getRHS()) : ExprResult();
17410 if (RHS.isInvalid())
17411 return true;
17412
17413 if (!getDerived().AlwaysRebuild() &&
17414 LHS.get() == E->getLHS() && RHS.get() == E->getRHS())
17415 return E;
17416
17417 return getDerived().RebuildCXXFoldExpr(
17418 Callee, E->getBeginLoc(), LHS.get(), E->getOperator(),
17419 E->getEllipsisLoc(), RHS.get(), E->getEndLoc(), NumExpansions);
17420 }
17421
17422 // Formally a fold expression expands to nested parenthesized expressions.
17423 // Enforce this limit to avoid creating trees so deep we can't safely traverse
17424 // them.
17425 if (NumExpansions && SemaRef.getLangOpts().BracketDepth < *NumExpansions) {
17426 SemaRef.Diag(Loc: E->getEllipsisLoc(),
17427 DiagID: clang::diag::err_fold_expression_limit_exceeded)
17428 << *NumExpansions << SemaRef.getLangOpts().BracketDepth
17429 << E->getSourceRange();
17430 SemaRef.Diag(Loc: E->getEllipsisLoc(), DiagID: diag::note_bracket_depth);
17431 return ExprError();
17432 }
17433
17434 // The transform has determined that we should perform an elementwise
17435 // expansion of the pattern. Do so.
17436 ExprResult Result = getDerived().TransformExpr(E->getInit());
17437 if (Result.isInvalid())
17438 return true;
17439 bool LeftFold = E->isLeftFold();
17440
17441 // If we're retaining an expansion for a right fold, it is the innermost
17442 // component and takes the init (if any).
17443 if (!LeftFold && RetainExpansion) {
17444 ForgetPartiallySubstitutedPackRAII Forget(getDerived());
17445
17446 ExprResult Out = getDerived().TransformExpr(Pattern);
17447 if (Out.isInvalid())
17448 return true;
17449
17450 Result = getDerived().RebuildCXXFoldExpr(
17451 Callee, E->getBeginLoc(), Out.get(), E->getOperator(),
17452 E->getEllipsisLoc(), Result.get(), E->getEndLoc(), OrigNumExpansions);
17453 if (Result.isInvalid())
17454 return true;
17455 }
17456
17457 bool WarnedOnComparison = false;
17458 for (unsigned I = 0; I != *NumExpansions; ++I) {
17459 Sema::ArgPackSubstIndexRAII SubstIndex(
17460 getSema(), LeftFold ? I : *NumExpansions - I - 1);
17461 ExprResult Out = getDerived().TransformExpr(Pattern);
17462 if (Out.isInvalid())
17463 return true;
17464
17465 if (Out.get()->containsUnexpandedParameterPack()) {
17466 // We still have a pack; retain a pack expansion for this slice.
17467 Result = getDerived().RebuildCXXFoldExpr(
17468 Callee, E->getBeginLoc(), LeftFold ? Result.get() : Out.get(),
17469 E->getOperator(), E->getEllipsisLoc(),
17470 LeftFold ? Out.get() : Result.get(), E->getEndLoc(),
17471 OrigNumExpansions);
17472 } else if (Result.isUsable()) {
17473 // We've got down to a single element; build a binary operator.
17474 Expr *LHS = LeftFold ? Result.get() : Out.get();
17475 Expr *RHS = LeftFold ? Out.get() : Result.get();
17476 if (Callee) {
17477 UnresolvedSet<16> Functions;
17478 Functions.append(I: Callee->decls_begin(), E: Callee->decls_end());
17479 Result = getDerived().RebuildCXXOperatorCallExpr(
17480 BinaryOperator::getOverloadedOperator(Opc: E->getOperator()),
17481 E->getEllipsisLoc(), Callee->getBeginLoc(), Callee->requiresADL(),
17482 Functions, LHS, RHS);
17483 } else {
17484 Result = getDerived().RebuildBinaryOperator(E->getEllipsisLoc(),
17485 E->getOperator(), LHS, RHS,
17486 /*ForFoldExpresion=*/true);
17487 if (!WarnedOnComparison && Result.isUsable()) {
17488 if (auto *BO = dyn_cast<BinaryOperator>(Val: Result.get());
17489 BO && BO->isComparisonOp()) {
17490 WarnedOnComparison = true;
17491 SemaRef.Diag(Loc: BO->getBeginLoc(),
17492 DiagID: diag::warn_comparison_in_fold_expression)
17493 << BO->getOpcodeStr();
17494 }
17495 }
17496 }
17497 } else
17498 Result = Out;
17499
17500 if (Result.isInvalid())
17501 return true;
17502 }
17503
17504 // If we're retaining an expansion for a left fold, it is the outermost
17505 // component and takes the complete expansion so far as its init (if any).
17506 if (LeftFold && RetainExpansion) {
17507 ForgetPartiallySubstitutedPackRAII Forget(getDerived());
17508
17509 ExprResult Out = getDerived().TransformExpr(Pattern);
17510 if (Out.isInvalid())
17511 return true;
17512
17513 Result = getDerived().RebuildCXXFoldExpr(
17514 Callee, E->getBeginLoc(), Result.get(), E->getOperator(),
17515 E->getEllipsisLoc(), Out.get(), E->getEndLoc(), OrigNumExpansions);
17516 if (Result.isInvalid())
17517 return true;
17518 }
17519
17520 if (ParenExpr *PE = dyn_cast_or_null<ParenExpr>(Val: Result.get()))
17521 PE->setIsProducedByFoldExpansion();
17522
17523 // If we had no init and an empty pack, and we're not retaining an expansion,
17524 // then produce a fallback value or error.
17525 if (Result.isUnset())
17526 return getDerived().RebuildEmptyCXXFoldExpr(E->getEllipsisLoc(),
17527 E->getOperator());
17528 return Result;
17529}
17530
17531template <typename Derived>
17532ExprResult
17533TreeTransform<Derived>::TransformCXXParenListInitExpr(CXXParenListInitExpr *E) {
17534 SmallVector<Expr *, 4> TransformedInits;
17535 ArrayRef<Expr *> InitExprs = E->getInitExprs();
17536
17537 QualType T = getDerived().TransformType(E->getType());
17538
17539 bool ArgChanged = false;
17540
17541 if (getDerived().TransformExprs(InitExprs.data(), InitExprs.size(), true,
17542 TransformedInits, &ArgChanged))
17543 return ExprError();
17544
17545 if (!getDerived().AlwaysRebuild() && !ArgChanged && T == E->getType())
17546 return E;
17547
17548 return getDerived().RebuildCXXParenListInitExpr(
17549 TransformedInits, T, E->getUserSpecifiedInitExprs().size(),
17550 E->getInitLoc(), E->getBeginLoc(), E->getEndLoc());
17551}
17552
17553template<typename Derived>
17554ExprResult
17555TreeTransform<Derived>::TransformCXXStdInitializerListExpr(
17556 CXXStdInitializerListExpr *E) {
17557 return getDerived().TransformExpr(E->getSubExpr());
17558}
17559
17560template<typename Derived>
17561ExprResult
17562TreeTransform<Derived>::TransformObjCStringLiteral(ObjCStringLiteral *E) {
17563 return SemaRef.MaybeBindToTemporary(E);
17564}
17565
17566template<typename Derived>
17567ExprResult
17568TreeTransform<Derived>::TransformObjCBoolLiteralExpr(ObjCBoolLiteralExpr *E) {
17569 return E;
17570}
17571
17572template<typename Derived>
17573ExprResult
17574TreeTransform<Derived>::TransformObjCBoxedExpr(ObjCBoxedExpr *E) {
17575 ExprResult SubExpr = getDerived().TransformExpr(E->getSubExpr());
17576 if (SubExpr.isInvalid())
17577 return ExprError();
17578
17579 if (!getDerived().AlwaysRebuild() &&
17580 SubExpr.get() == E->getSubExpr())
17581 return E;
17582
17583 return getDerived().RebuildObjCBoxedExpr(E->getSourceRange(), SubExpr.get());
17584}
17585
17586template<typename Derived>
17587ExprResult
17588TreeTransform<Derived>::TransformObjCArrayLiteral(ObjCArrayLiteral *E) {
17589 // Transform each of the elements.
17590 SmallVector<Expr *, 8> Elements;
17591 bool ArgChanged = false;
17592 if (getDerived().TransformExprs(E->getElements(), E->getNumElements(),
17593 /*IsCall=*/false, Elements, &ArgChanged))
17594 return ExprError();
17595
17596 if (!getDerived().AlwaysRebuild() && !ArgChanged)
17597 return SemaRef.MaybeBindToTemporary(E);
17598
17599 return getDerived().RebuildObjCArrayLiteral(E->getSourceRange(),
17600 Elements.data(),
17601 Elements.size());
17602}
17603
17604template<typename Derived>
17605ExprResult
17606TreeTransform<Derived>::TransformObjCDictionaryLiteral(
17607 ObjCDictionaryLiteral *E) {
17608 // Transform each of the elements.
17609 SmallVector<ObjCDictionaryElement, 8> Elements;
17610 bool ArgChanged = false;
17611 for (unsigned I = 0, N = E->getNumElements(); I != N; ++I) {
17612 ObjCDictionaryElement OrigElement = E->getKeyValueElement(Index: I);
17613
17614 if (OrigElement.isPackExpansion()) {
17615 // This key/value element is a pack expansion.
17616 SmallVector<UnexpandedParameterPack, 2> Unexpanded;
17617 getSema().collectUnexpandedParameterPacks(OrigElement.Key, Unexpanded);
17618 getSema().collectUnexpandedParameterPacks(OrigElement.Value, Unexpanded);
17619 assert(!Unexpanded.empty() && "Pack expansion without parameter packs?");
17620
17621 // Determine whether the set of unexpanded parameter packs can
17622 // and should be expanded.
17623 bool Expand = true;
17624 bool RetainExpansion = false;
17625 UnsignedOrNone OrigNumExpansions = OrigElement.NumExpansions;
17626 UnsignedOrNone NumExpansions = OrigNumExpansions;
17627 SourceRange PatternRange(OrigElement.Key->getBeginLoc(),
17628 OrigElement.Value->getEndLoc());
17629 if (getDerived().TryExpandParameterPacks(
17630 OrigElement.EllipsisLoc, PatternRange, Unexpanded,
17631 /*FailOnPackProducingTemplates=*/true, Expand, RetainExpansion,
17632 NumExpansions))
17633 return ExprError();
17634
17635 if (!Expand) {
17636 // The transform has determined that we should perform a simple
17637 // transformation on the pack expansion, producing another pack
17638 // expansion.
17639 Sema::ArgPackSubstIndexRAII SubstIndex(getSema(), std::nullopt);
17640 ExprResult Key = getDerived().TransformExpr(OrigElement.Key);
17641 if (Key.isInvalid())
17642 return ExprError();
17643
17644 if (Key.get() != OrigElement.Key)
17645 ArgChanged = true;
17646
17647 ExprResult Value = getDerived().TransformExpr(OrigElement.Value);
17648 if (Value.isInvalid())
17649 return ExprError();
17650
17651 if (Value.get() != OrigElement.Value)
17652 ArgChanged = true;
17653
17654 ObjCDictionaryElement Expansion = {
17655 .Key: Key.get(), .Value: Value.get(), .EllipsisLoc: OrigElement.EllipsisLoc, .NumExpansions: NumExpansions
17656 };
17657 Elements.push_back(Elt: Expansion);
17658 continue;
17659 }
17660
17661 // Record right away that the argument was changed. This needs
17662 // to happen even if the array expands to nothing.
17663 ArgChanged = true;
17664
17665 // The transform has determined that we should perform an elementwise
17666 // expansion of the pattern. Do so.
17667 for (unsigned I = 0; I != *NumExpansions; ++I) {
17668 Sema::ArgPackSubstIndexRAII SubstIndex(getSema(), I);
17669 ExprResult Key = getDerived().TransformExpr(OrigElement.Key);
17670 if (Key.isInvalid())
17671 return ExprError();
17672
17673 ExprResult Value = getDerived().TransformExpr(OrigElement.Value);
17674 if (Value.isInvalid())
17675 return ExprError();
17676
17677 ObjCDictionaryElement Element = {
17678 .Key: Key.get(), .Value: Value.get(), .EllipsisLoc: SourceLocation(), .NumExpansions: NumExpansions
17679 };
17680
17681 // If any unexpanded parameter packs remain, we still have a
17682 // pack expansion.
17683 // FIXME: Can this really happen?
17684 if (Key.get()->containsUnexpandedParameterPack() ||
17685 Value.get()->containsUnexpandedParameterPack())
17686 Element.EllipsisLoc = OrigElement.EllipsisLoc;
17687
17688 Elements.push_back(Elt: Element);
17689 }
17690
17691 // FIXME: Retain a pack expansion if RetainExpansion is true.
17692
17693 // We've finished with this pack expansion.
17694 continue;
17695 }
17696
17697 // Transform and check key.
17698 ExprResult Key = getDerived().TransformExpr(OrigElement.Key);
17699 if (Key.isInvalid())
17700 return ExprError();
17701
17702 if (Key.get() != OrigElement.Key)
17703 ArgChanged = true;
17704
17705 // Transform and check value.
17706 ExprResult Value
17707 = getDerived().TransformExpr(OrigElement.Value);
17708 if (Value.isInvalid())
17709 return ExprError();
17710
17711 if (Value.get() != OrigElement.Value)
17712 ArgChanged = true;
17713
17714 ObjCDictionaryElement Element = {.Key: Key.get(), .Value: Value.get(), .EllipsisLoc: SourceLocation(),
17715 .NumExpansions: std::nullopt};
17716 Elements.push_back(Elt: Element);
17717 }
17718
17719 if (!getDerived().AlwaysRebuild() && !ArgChanged)
17720 return SemaRef.MaybeBindToTemporary(E);
17721
17722 return getDerived().RebuildObjCDictionaryLiteral(E->getSourceRange(),
17723 Elements);
17724}
17725
17726template<typename Derived>
17727ExprResult
17728TreeTransform<Derived>::TransformObjCEncodeExpr(ObjCEncodeExpr *E) {
17729 TypeSourceInfo *EncodedTypeInfo
17730 = getDerived().TransformType(E->getEncodedTypeSourceInfo());
17731 if (!EncodedTypeInfo)
17732 return ExprError();
17733
17734 if (!getDerived().AlwaysRebuild() &&
17735 EncodedTypeInfo == E->getEncodedTypeSourceInfo())
17736 return E;
17737
17738 return getDerived().RebuildObjCEncodeExpr(E->getAtLoc(),
17739 EncodedTypeInfo,
17740 E->getRParenLoc());
17741}
17742
17743template<typename Derived>
17744ExprResult TreeTransform<Derived>::
17745TransformObjCIndirectCopyRestoreExpr(ObjCIndirectCopyRestoreExpr *E) {
17746 // This is a kind of implicit conversion, and it needs to get dropped
17747 // and recomputed for the same general reasons that ImplicitCastExprs
17748 // do, as well a more specific one: this expression is only valid when
17749 // it appears *immediately* as an argument expression.
17750 return getDerived().TransformExpr(E->getSubExpr());
17751}
17752
17753template<typename Derived>
17754ExprResult TreeTransform<Derived>::
17755TransformObjCBridgedCastExpr(ObjCBridgedCastExpr *E) {
17756 TypeSourceInfo *TSInfo
17757 = getDerived().TransformType(E->getTypeInfoAsWritten());
17758 if (!TSInfo)
17759 return ExprError();
17760
17761 ExprResult Result = getDerived().TransformExpr(E->getSubExpr());
17762 if (Result.isInvalid())
17763 return ExprError();
17764
17765 if (!getDerived().AlwaysRebuild() &&
17766 TSInfo == E->getTypeInfoAsWritten() &&
17767 Result.get() == E->getSubExpr())
17768 return E;
17769
17770 return SemaRef.ObjC().BuildObjCBridgedCast(
17771 LParenLoc: E->getLParenLoc(), Kind: E->getBridgeKind(), BridgeKeywordLoc: E->getBridgeKeywordLoc(), TSInfo,
17772 SubExpr: Result.get());
17773}
17774
17775template <typename Derived>
17776ExprResult TreeTransform<Derived>::TransformObjCAvailabilityCheckExpr(
17777 ObjCAvailabilityCheckExpr *E) {
17778 return E;
17779}
17780
17781template<typename Derived>
17782ExprResult
17783TreeTransform<Derived>::TransformObjCMessageExpr(ObjCMessageExpr *E) {
17784 // Transform arguments.
17785 bool ArgChanged = false;
17786 SmallVector<Expr*, 8> Args;
17787 Args.reserve(N: E->getNumArgs());
17788 if (getDerived().TransformExprs(E->getArgs(), E->getNumArgs(), false, Args,
17789 &ArgChanged))
17790 return ExprError();
17791
17792 if (E->getReceiverKind() == ObjCMessageExpr::Class) {
17793 // Class message: transform the receiver type.
17794 TypeSourceInfo *ReceiverTypeInfo
17795 = getDerived().TransformType(E->getClassReceiverTypeInfo());
17796 if (!ReceiverTypeInfo)
17797 return ExprError();
17798
17799 // If nothing changed, just retain the existing message send.
17800 if (!getDerived().AlwaysRebuild() &&
17801 ReceiverTypeInfo == E->getClassReceiverTypeInfo() && !ArgChanged)
17802 return SemaRef.MaybeBindToTemporary(E);
17803
17804 // Build a new class message send.
17805 SmallVector<SourceLocation, 16> SelLocs;
17806 E->getSelectorLocs(SelLocs);
17807 return getDerived().RebuildObjCMessageExpr(ReceiverTypeInfo,
17808 E->getSelector(),
17809 SelLocs,
17810 E->getMethodDecl(),
17811 E->getLeftLoc(),
17812 Args,
17813 E->getRightLoc());
17814 }
17815 else if (E->getReceiverKind() == ObjCMessageExpr::SuperClass ||
17816 E->getReceiverKind() == ObjCMessageExpr::SuperInstance) {
17817 if (!E->getMethodDecl())
17818 return ExprError();
17819
17820 // Build a new class message send to 'super'.
17821 SmallVector<SourceLocation, 16> SelLocs;
17822 E->getSelectorLocs(SelLocs);
17823 return getDerived().RebuildObjCMessageExpr(E->getSuperLoc(),
17824 E->getSelector(),
17825 SelLocs,
17826 E->getReceiverType(),
17827 E->getMethodDecl(),
17828 E->getLeftLoc(),
17829 Args,
17830 E->getRightLoc());
17831 }
17832
17833 // Instance message: transform the receiver
17834 assert(E->getReceiverKind() == ObjCMessageExpr::Instance &&
17835 "Only class and instance messages may be instantiated");
17836 ExprResult Receiver
17837 = getDerived().TransformExpr(E->getInstanceReceiver());
17838 if (Receiver.isInvalid())
17839 return ExprError();
17840
17841 // If nothing changed, just retain the existing message send.
17842 if (!getDerived().AlwaysRebuild() &&
17843 Receiver.get() == E->getInstanceReceiver() && !ArgChanged)
17844 return SemaRef.MaybeBindToTemporary(E);
17845
17846 // Build a new instance message send.
17847 SmallVector<SourceLocation, 16> SelLocs;
17848 E->getSelectorLocs(SelLocs);
17849 return getDerived().RebuildObjCMessageExpr(Receiver.get(),
17850 E->getSelector(),
17851 SelLocs,
17852 E->getMethodDecl(),
17853 E->getLeftLoc(),
17854 Args,
17855 E->getRightLoc());
17856}
17857
17858template<typename Derived>
17859ExprResult
17860TreeTransform<Derived>::TransformObjCSelectorExpr(ObjCSelectorExpr *E) {
17861 return E;
17862}
17863
17864template<typename Derived>
17865ExprResult
17866TreeTransform<Derived>::TransformObjCProtocolExpr(ObjCProtocolExpr *E) {
17867 return E;
17868}
17869
17870template<typename Derived>
17871ExprResult
17872TreeTransform<Derived>::TransformObjCIvarRefExpr(ObjCIvarRefExpr *E) {
17873 // Transform the base expression.
17874 ExprResult Base = getDerived().TransformExpr(E->getBase());
17875 if (Base.isInvalid())
17876 return ExprError();
17877
17878 // We don't need to transform the ivar; it will never change.
17879
17880 // If nothing changed, just retain the existing expression.
17881 if (!getDerived().AlwaysRebuild() &&
17882 Base.get() == E->getBase())
17883 return E;
17884
17885 return getDerived().RebuildObjCIvarRefExpr(Base.get(), E->getDecl(),
17886 E->getLocation(),
17887 E->isArrow(), E->isFreeIvar());
17888}
17889
17890template<typename Derived>
17891ExprResult
17892TreeTransform<Derived>::TransformObjCPropertyRefExpr(ObjCPropertyRefExpr *E) {
17893 // 'super' and types never change. Property never changes. Just
17894 // retain the existing expression.
17895 if (!E->isObjectReceiver())
17896 return E;
17897
17898 // Transform the base expression.
17899 ExprResult Base = getDerived().TransformExpr(E->getBase());
17900 if (Base.isInvalid())
17901 return ExprError();
17902
17903 // We don't need to transform the property; it will never change.
17904
17905 // If nothing changed, just retain the existing expression.
17906 if (!getDerived().AlwaysRebuild() &&
17907 Base.get() == E->getBase())
17908 return E;
17909
17910 if (E->isExplicitProperty())
17911 return getDerived().RebuildObjCPropertyRefExpr(Base.get(),
17912 E->getExplicitProperty(),
17913 E->getLocation());
17914
17915 return getDerived().RebuildObjCPropertyRefExpr(Base.get(),
17916 SemaRef.Context.PseudoObjectTy,
17917 E->getImplicitPropertyGetter(),
17918 E->getImplicitPropertySetter(),
17919 E->getLocation());
17920}
17921
17922template<typename Derived>
17923ExprResult
17924TreeTransform<Derived>::TransformObjCSubscriptRefExpr(ObjCSubscriptRefExpr *E) {
17925 // Transform the base expression.
17926 ExprResult Base = getDerived().TransformExpr(E->getBaseExpr());
17927 if (Base.isInvalid())
17928 return ExprError();
17929
17930 // Transform the key expression.
17931 ExprResult Key = getDerived().TransformExpr(E->getKeyExpr());
17932 if (Key.isInvalid())
17933 return ExprError();
17934
17935 // If nothing changed, just retain the existing expression.
17936 if (!getDerived().AlwaysRebuild() &&
17937 Key.get() == E->getKeyExpr() && Base.get() == E->getBaseExpr())
17938 return E;
17939
17940 return getDerived().RebuildObjCSubscriptRefExpr(E->getRBracket(),
17941 Base.get(), Key.get(),
17942 E->getAtIndexMethodDecl(),
17943 E->setAtIndexMethodDecl());
17944}
17945
17946template<typename Derived>
17947ExprResult
17948TreeTransform<Derived>::TransformObjCIsaExpr(ObjCIsaExpr *E) {
17949 // Transform the base expression.
17950 ExprResult Base = getDerived().TransformExpr(E->getBase());
17951 if (Base.isInvalid())
17952 return ExprError();
17953
17954 // If nothing changed, just retain the existing expression.
17955 if (!getDerived().AlwaysRebuild() &&
17956 Base.get() == E->getBase())
17957 return E;
17958
17959 return getDerived().RebuildObjCIsaExpr(Base.get(), E->getIsaMemberLoc(),
17960 E->getOpLoc(),
17961 E->isArrow());
17962}
17963
17964template<typename Derived>
17965ExprResult
17966TreeTransform<Derived>::TransformShuffleVectorExpr(ShuffleVectorExpr *E) {
17967 bool ArgumentChanged = false;
17968 SmallVector<Expr*, 8> SubExprs;
17969 SubExprs.reserve(N: E->getNumSubExprs());
17970 if (getDerived().TransformExprs(E->getSubExprs(), E->getNumSubExprs(), false,
17971 SubExprs, &ArgumentChanged))
17972 return ExprError();
17973
17974 if (!getDerived().AlwaysRebuild() &&
17975 !ArgumentChanged)
17976 return E;
17977
17978 return getDerived().RebuildShuffleVectorExpr(E->getBuiltinLoc(),
17979 SubExprs,
17980 E->getRParenLoc());
17981}
17982
17983template<typename Derived>
17984ExprResult
17985TreeTransform<Derived>::TransformConvertVectorExpr(ConvertVectorExpr *E) {
17986 ExprResult SrcExpr = getDerived().TransformExpr(E->getSrcExpr());
17987 if (SrcExpr.isInvalid())
17988 return ExprError();
17989
17990 TypeSourceInfo *Type = getDerived().TransformType(E->getTypeSourceInfo());
17991 if (!Type)
17992 return ExprError();
17993
17994 if (!getDerived().AlwaysRebuild() &&
17995 Type == E->getTypeSourceInfo() &&
17996 SrcExpr.get() == E->getSrcExpr())
17997 return E;
17998
17999 return getDerived().RebuildConvertVectorExpr(E->getBuiltinLoc(),
18000 SrcExpr.get(), Type,
18001 E->getRParenLoc());
18002}
18003
18004template<typename Derived>
18005ExprResult
18006TreeTransform<Derived>::TransformBlockExpr(BlockExpr *E) {
18007 BlockDecl *oldBlock = E->getBlockDecl();
18008
18009 SemaRef.ActOnBlockStart(CaretLoc: E->getCaretLocation(), /*Scope=*/CurScope: nullptr);
18010 BlockScopeInfo *blockScope = SemaRef.getCurBlock();
18011
18012 blockScope->TheDecl->setIsVariadic(oldBlock->isVariadic());
18013 blockScope->TheDecl->setBlockMissingReturnType(
18014 oldBlock->blockMissingReturnType());
18015
18016 SmallVector<ParmVarDecl*, 4> params;
18017 SmallVector<QualType, 4> paramTypes;
18018
18019 const FunctionProtoType *exprFunctionType = E->getFunctionType();
18020
18021 // Parameter substitution.
18022 Sema::ExtParameterInfoBuilder extParamInfos;
18023 if (getDerived().TransformFunctionTypeParams(
18024 E->getCaretLocation(), oldBlock->parameters(), nullptr,
18025 exprFunctionType->getExtParameterInfosOrNull(), paramTypes, &params,
18026 extParamInfos)) {
18027 getSema().ActOnBlockError(E->getCaretLocation(), /*Scope=*/nullptr);
18028 return ExprError();
18029 }
18030
18031 QualType exprResultType =
18032 getDerived().TransformType(exprFunctionType->getReturnType());
18033
18034 auto epi = exprFunctionType->getExtProtoInfo();
18035 epi.ExtParameterInfos = extParamInfos.getPointerOrNull(numParams: paramTypes.size());
18036
18037 QualType functionType =
18038 getDerived().RebuildFunctionProtoType(exprResultType, paramTypes, epi);
18039 blockScope->FunctionType = functionType;
18040
18041 // Set the parameters on the block decl.
18042 if (!params.empty())
18043 blockScope->TheDecl->setParams(params);
18044
18045 if (!oldBlock->blockMissingReturnType()) {
18046 blockScope->HasImplicitReturnType = false;
18047 blockScope->ReturnType = exprResultType;
18048 }
18049
18050 // Transform the body
18051 StmtResult body = getDerived().TransformStmt(E->getBody());
18052 if (body.isInvalid()) {
18053 getSema().ActOnBlockError(E->getCaretLocation(), /*Scope=*/nullptr);
18054 return ExprError();
18055 }
18056
18057#ifndef NDEBUG
18058 // In builds with assertions, make sure that we captured everything we
18059 // captured before.
18060 if (!SemaRef.getDiagnostics().hasErrorOccurred()) {
18061 for (const auto &I : oldBlock->captures()) {
18062 VarDecl *oldCapture = I.getVariable();
18063
18064 // Ignore parameter packs.
18065 if (oldCapture->isParameterPack())
18066 continue;
18067
18068 VarDecl *newCapture =
18069 cast<VarDecl>(getDerived().TransformDecl(E->getCaretLocation(),
18070 oldCapture));
18071 assert(blockScope->CaptureMap.count(newCapture));
18072 }
18073 }
18074#endif
18075
18076 return SemaRef.ActOnBlockStmtExpr(CaretLoc: E->getCaretLocation(), Body: body.get(),
18077 /*Scope=*/CurScope: nullptr);
18078}
18079
18080template<typename Derived>
18081ExprResult
18082TreeTransform<Derived>::TransformAsTypeExpr(AsTypeExpr *E) {
18083 ExprResult SrcExpr = getDerived().TransformExpr(E->getSrcExpr());
18084 if (SrcExpr.isInvalid())
18085 return ExprError();
18086
18087 QualType Type = getDerived().TransformType(E->getType());
18088
18089 return SemaRef.BuildAsTypeExpr(E: SrcExpr.get(), DestTy: Type, BuiltinLoc: E->getBuiltinLoc(),
18090 RParenLoc: E->getRParenLoc());
18091}
18092
18093template<typename Derived>
18094ExprResult
18095TreeTransform<Derived>::TransformAtomicExpr(AtomicExpr *E) {
18096 bool ArgumentChanged = false;
18097 SmallVector<Expr*, 8> SubExprs;
18098 SubExprs.reserve(N: E->getNumSubExprs());
18099 if (getDerived().TransformExprs(E->getSubExprs(), E->getNumSubExprs(), false,
18100 SubExprs, &ArgumentChanged))
18101 return ExprError();
18102
18103 if (!getDerived().AlwaysRebuild() &&
18104 !ArgumentChanged)
18105 return E;
18106
18107 return getDerived().RebuildAtomicExpr(E->getBuiltinLoc(), SubExprs,
18108 E->getOp(), E->getRParenLoc());
18109}
18110
18111//===----------------------------------------------------------------------===//
18112// Type reconstruction
18113//===----------------------------------------------------------------------===//
18114
18115template<typename Derived>
18116QualType TreeTransform<Derived>::RebuildPointerType(QualType PointeeType,
18117 SourceLocation Star) {
18118 return SemaRef.BuildPointerType(T: PointeeType, Loc: Star,
18119 Entity: getDerived().getBaseEntity());
18120}
18121
18122template<typename Derived>
18123QualType TreeTransform<Derived>::RebuildBlockPointerType(QualType PointeeType,
18124 SourceLocation Star) {
18125 return SemaRef.BuildBlockPointerType(T: PointeeType, Loc: Star,
18126 Entity: getDerived().getBaseEntity());
18127}
18128
18129template<typename Derived>
18130QualType
18131TreeTransform<Derived>::RebuildReferenceType(QualType ReferentType,
18132 bool WrittenAsLValue,
18133 SourceLocation Sigil) {
18134 return SemaRef.BuildReferenceType(T: ReferentType, LValueRef: WrittenAsLValue,
18135 Loc: Sigil, Entity: getDerived().getBaseEntity());
18136}
18137
18138template <typename Derived>
18139QualType TreeTransform<Derived>::RebuildMemberPointerType(
18140 QualType PointeeType, const CXXScopeSpec &SS, CXXRecordDecl *Cls,
18141 SourceLocation Sigil) {
18142 return SemaRef.BuildMemberPointerType(T: PointeeType, SS, Cls, Loc: Sigil,
18143 Entity: getDerived().getBaseEntity());
18144}
18145
18146template<typename Derived>
18147QualType TreeTransform<Derived>::RebuildObjCTypeParamType(
18148 const ObjCTypeParamDecl *Decl,
18149 SourceLocation ProtocolLAngleLoc,
18150 ArrayRef<ObjCProtocolDecl *> Protocols,
18151 ArrayRef<SourceLocation> ProtocolLocs,
18152 SourceLocation ProtocolRAngleLoc) {
18153 return SemaRef.ObjC().BuildObjCTypeParamType(
18154 Decl, ProtocolLAngleLoc, Protocols, ProtocolLocs, ProtocolRAngleLoc,
18155 /*FailOnError=*/FailOnError: true);
18156}
18157
18158template<typename Derived>
18159QualType TreeTransform<Derived>::RebuildObjCObjectType(
18160 QualType BaseType,
18161 SourceLocation Loc,
18162 SourceLocation TypeArgsLAngleLoc,
18163 ArrayRef<TypeSourceInfo *> TypeArgs,
18164 SourceLocation TypeArgsRAngleLoc,
18165 SourceLocation ProtocolLAngleLoc,
18166 ArrayRef<ObjCProtocolDecl *> Protocols,
18167 ArrayRef<SourceLocation> ProtocolLocs,
18168 SourceLocation ProtocolRAngleLoc) {
18169 return SemaRef.ObjC().BuildObjCObjectType(
18170 BaseType, Loc, TypeArgsLAngleLoc, TypeArgs, TypeArgsRAngleLoc,
18171 ProtocolLAngleLoc, Protocols, ProtocolLocs, ProtocolRAngleLoc,
18172 /*FailOnError=*/FailOnError: true,
18173 /*Rebuilding=*/Rebuilding: true);
18174}
18175
18176template<typename Derived>
18177QualType TreeTransform<Derived>::RebuildObjCObjectPointerType(
18178 QualType PointeeType,
18179 SourceLocation Star) {
18180 return SemaRef.Context.getObjCObjectPointerType(OIT: PointeeType);
18181}
18182
18183template <typename Derived>
18184QualType TreeTransform<Derived>::RebuildArrayType(
18185 QualType ElementType, ArraySizeModifier SizeMod, const llvm::APInt *Size,
18186 Expr *SizeExpr, unsigned IndexTypeQuals, SourceRange BracketsRange) {
18187 if (SizeExpr || !Size)
18188 return SemaRef.BuildArrayType(T: ElementType, ASM: SizeMod, ArraySize: SizeExpr,
18189 Quals: IndexTypeQuals, Brackets: BracketsRange,
18190 Entity: getDerived().getBaseEntity());
18191
18192 QualType Types[] = {
18193 SemaRef.Context.UnsignedCharTy, SemaRef.Context.UnsignedShortTy,
18194 SemaRef.Context.UnsignedIntTy, SemaRef.Context.UnsignedLongTy,
18195 SemaRef.Context.UnsignedLongLongTy, SemaRef.Context.UnsignedInt128Ty
18196 };
18197 QualType SizeType;
18198 for (const auto &T : Types)
18199 if (Size->getBitWidth() == SemaRef.Context.getIntWidth(T)) {
18200 SizeType = T;
18201 break;
18202 }
18203
18204 // Note that we can return a VariableArrayType here in the case where
18205 // the element type was a dependent VariableArrayType.
18206 IntegerLiteral *ArraySize
18207 = IntegerLiteral::Create(C: SemaRef.Context, V: *Size, type: SizeType,
18208 /*FIXME*/l: BracketsRange.getBegin());
18209 return SemaRef.BuildArrayType(T: ElementType, ASM: SizeMod, ArraySize,
18210 Quals: IndexTypeQuals, Brackets: BracketsRange,
18211 Entity: getDerived().getBaseEntity());
18212}
18213
18214template <typename Derived>
18215QualType TreeTransform<Derived>::RebuildConstantArrayType(
18216 QualType ElementType, ArraySizeModifier SizeMod, const llvm::APInt &Size,
18217 Expr *SizeExpr, unsigned IndexTypeQuals, SourceRange BracketsRange) {
18218 return getDerived().RebuildArrayType(ElementType, SizeMod, &Size, SizeExpr,
18219 IndexTypeQuals, BracketsRange);
18220}
18221
18222template <typename Derived>
18223QualType TreeTransform<Derived>::RebuildIncompleteArrayType(
18224 QualType ElementType, ArraySizeModifier SizeMod, unsigned IndexTypeQuals,
18225 SourceRange BracketsRange) {
18226 return getDerived().RebuildArrayType(ElementType, SizeMod, nullptr, nullptr,
18227 IndexTypeQuals, BracketsRange);
18228}
18229
18230template <typename Derived>
18231QualType TreeTransform<Derived>::RebuildVariableArrayType(
18232 QualType ElementType, ArraySizeModifier SizeMod, Expr *SizeExpr,
18233 unsigned IndexTypeQuals, SourceRange BracketsRange) {
18234 return getDerived().RebuildArrayType(ElementType, SizeMod, nullptr,
18235 SizeExpr,
18236 IndexTypeQuals, BracketsRange);
18237}
18238
18239template <typename Derived>
18240QualType TreeTransform<Derived>::RebuildDependentSizedArrayType(
18241 QualType ElementType, ArraySizeModifier SizeMod, Expr *SizeExpr,
18242 unsigned IndexTypeQuals, SourceRange BracketsRange) {
18243 return getDerived().RebuildArrayType(ElementType, SizeMod, nullptr,
18244 SizeExpr,
18245 IndexTypeQuals, BracketsRange);
18246}
18247
18248template <typename Derived>
18249QualType TreeTransform<Derived>::RebuildDependentAddressSpaceType(
18250 QualType PointeeType, Expr *AddrSpaceExpr, SourceLocation AttributeLoc) {
18251 return SemaRef.BuildAddressSpaceAttr(T&: PointeeType, AddrSpace: AddrSpaceExpr,
18252 AttrLoc: AttributeLoc);
18253}
18254
18255template <typename Derived>
18256QualType TreeTransform<Derived>::RebuildVectorType(QualType ElementType,
18257 unsigned NumElements,
18258 VectorKind VecKind) {
18259 // FIXME: semantic checking!
18260 return SemaRef.Context.getVectorType(VectorType: ElementType, NumElts: NumElements, VecKind);
18261}
18262
18263template <typename Derived>
18264QualType TreeTransform<Derived>::RebuildDependentVectorType(
18265 QualType ElementType, Expr *SizeExpr, SourceLocation AttributeLoc,
18266 VectorKind VecKind) {
18267 return SemaRef.BuildVectorType(T: ElementType, VecSize: SizeExpr, AttrLoc: AttributeLoc);
18268}
18269
18270template<typename Derived>
18271QualType TreeTransform<Derived>::RebuildExtVectorType(QualType ElementType,
18272 unsigned NumElements,
18273 SourceLocation AttributeLoc) {
18274 llvm::APInt numElements(SemaRef.Context.getIntWidth(T: SemaRef.Context.IntTy),
18275 NumElements, true);
18276 IntegerLiteral *VectorSize
18277 = IntegerLiteral::Create(C: SemaRef.Context, V: numElements, type: SemaRef.Context.IntTy,
18278 l: AttributeLoc);
18279 return SemaRef.BuildExtVectorType(T: ElementType, ArraySize: VectorSize, AttrLoc: AttributeLoc);
18280}
18281
18282template<typename Derived>
18283QualType
18284TreeTransform<Derived>::RebuildDependentSizedExtVectorType(QualType ElementType,
18285 Expr *SizeExpr,
18286 SourceLocation AttributeLoc) {
18287 return SemaRef.BuildExtVectorType(T: ElementType, ArraySize: SizeExpr, AttrLoc: AttributeLoc);
18288}
18289
18290template <typename Derived>
18291QualType TreeTransform<Derived>::RebuildConstantMatrixType(
18292 QualType ElementType, unsigned NumRows, unsigned NumColumns,
18293 SourceLocation AttributeLoc) {
18294 ASTContext &Ctx = SemaRef.Context;
18295 QualType SizeTy = Ctx.getSizeType();
18296 unsigned SizeWidth = Ctx.getIntWidth(T: SizeTy);
18297 IntegerLiteral *RowExpr = IntegerLiteral::Create(
18298 C: Ctx, V: llvm::APInt(SizeWidth, NumRows), type: SizeTy, l: AttributeLoc);
18299 IntegerLiteral *ColumnExpr = IntegerLiteral::Create(
18300 C: Ctx, V: llvm::APInt(SizeWidth, NumColumns), type: SizeTy, l: AttributeLoc);
18301 return SemaRef.BuildMatrixType(T: ElementType, NumRows: RowExpr, NumColumns: ColumnExpr,
18302 AttrLoc: AttributeLoc);
18303}
18304
18305template <typename Derived>
18306QualType TreeTransform<Derived>::RebuildDependentSizedMatrixType(
18307 QualType ElementType, Expr *RowExpr, Expr *ColumnExpr,
18308 SourceLocation AttributeLoc) {
18309 return SemaRef.BuildMatrixType(T: ElementType, NumRows: RowExpr, NumColumns: ColumnExpr,
18310 AttrLoc: AttributeLoc);
18311}
18312
18313template <typename Derived>
18314QualType TreeTransform<Derived>::RebuildFunctionProtoType(
18315 QualType T, MutableArrayRef<QualType> ParamTypes,
18316 const FunctionProtoType::ExtProtoInfo &EPI) {
18317 return SemaRef.BuildFunctionType(T, ParamTypes,
18318 Loc: getDerived().getBaseLocation(),
18319 Entity: getDerived().getBaseEntity(),
18320 EPI);
18321}
18322
18323template<typename Derived>
18324QualType TreeTransform<Derived>::RebuildFunctionNoProtoType(QualType T) {
18325 return SemaRef.Context.getFunctionNoProtoType(ResultTy: T);
18326}
18327
18328template <typename Derived>
18329QualType TreeTransform<Derived>::RebuildUnresolvedUsingType(
18330 ElaboratedTypeKeyword Keyword, NestedNameSpecifier Qualifier,
18331 SourceLocation NameLoc, Decl *D) {
18332 assert(D && "no decl found");
18333 if (D->isInvalidDecl()) return QualType();
18334
18335 // FIXME: Doesn't account for ObjCInterfaceDecl!
18336 if (auto *UPD = dyn_cast<UsingPackDecl>(Val: D)) {
18337 // A valid resolved using typename pack expansion decl can have multiple
18338 // UsingDecls, but they must each have exactly one type, and it must be
18339 // the same type in every case. But we must have at least one expansion!
18340 if (UPD->expansions().empty()) {
18341 getSema().Diag(NameLoc, diag::err_using_pack_expansion_empty)
18342 << UPD->isCXXClassMember() << UPD;
18343 return QualType();
18344 }
18345
18346 // We might still have some unresolved types. Try to pick a resolved type
18347 // if we can. The final instantiation will check that the remaining
18348 // unresolved types instantiate to the type we pick.
18349 QualType FallbackT;
18350 QualType T;
18351 for (auto *E : UPD->expansions()) {
18352 QualType ThisT =
18353 RebuildUnresolvedUsingType(Keyword, Qualifier, NameLoc, D: E);
18354 if (ThisT.isNull())
18355 continue;
18356 if (ThisT->getAs<UnresolvedUsingType>())
18357 FallbackT = ThisT;
18358 else if (T.isNull())
18359 T = ThisT;
18360 else
18361 assert(getSema().Context.hasSameType(ThisT, T) &&
18362 "mismatched resolved types in using pack expansion");
18363 }
18364 return T.isNull() ? FallbackT : T;
18365 }
18366 if (auto *Using = dyn_cast<UsingDecl>(Val: D)) {
18367 assert(Using->hasTypename() &&
18368 "UnresolvedUsingTypenameDecl transformed to non-typename using");
18369
18370 // A valid resolved using typename decl points to exactly one type decl.
18371 assert(++Using->shadow_begin() == Using->shadow_end());
18372
18373 UsingShadowDecl *Shadow = *Using->shadow_begin();
18374 if (SemaRef.DiagnoseUseOfDecl(D: Shadow->getTargetDecl(), Locs: NameLoc))
18375 return QualType();
18376 return SemaRef.Context.getUsingType(Keyword, Qualifier, D: Shadow);
18377 }
18378 assert(isa<UnresolvedUsingTypenameDecl>(D) &&
18379 "UnresolvedUsingTypenameDecl transformed to non-using decl");
18380 return SemaRef.Context.getUnresolvedUsingType(
18381 Keyword, Qualifier, D: cast<UnresolvedUsingTypenameDecl>(Val: D));
18382}
18383
18384template <typename Derived>
18385QualType TreeTransform<Derived>::RebuildTypeOfExprType(Expr *E, SourceLocation,
18386 TypeOfKind Kind) {
18387 return SemaRef.BuildTypeofExprType(E, Kind);
18388}
18389
18390template<typename Derived>
18391QualType TreeTransform<Derived>::RebuildTypeOfType(QualType Underlying,
18392 TypeOfKind Kind) {
18393 return SemaRef.Context.getTypeOfType(QT: Underlying, Kind);
18394}
18395
18396template <typename Derived>
18397QualType TreeTransform<Derived>::RebuildDecltypeType(Expr *E, SourceLocation) {
18398 return SemaRef.BuildDecltypeType(E);
18399}
18400
18401template <typename Derived>
18402QualType TreeTransform<Derived>::RebuildPackIndexingType(
18403 QualType Pattern, Expr *IndexExpr, SourceLocation Loc,
18404 bool FullySubstituted, ArrayRef<QualType> Expansions) {
18405 return SemaRef.BuildPackIndexingType(Pattern, IndexExpr, Loc,
18406 FullySubstituted, Expansions);
18407}
18408
18409template<typename Derived>
18410QualType TreeTransform<Derived>::RebuildUnaryTransformType(QualType BaseType,
18411 UnaryTransformType::UTTKind UKind,
18412 SourceLocation Loc) {
18413 return SemaRef.BuildUnaryTransformType(BaseType, UKind, Loc);
18414}
18415
18416template <typename Derived>
18417QualType TreeTransform<Derived>::RebuildTemplateSpecializationType(
18418 ElaboratedTypeKeyword Keyword, TemplateName Template,
18419 SourceLocation TemplateNameLoc, TemplateArgumentListInfo &TemplateArgs) {
18420 return SemaRef.CheckTemplateIdType(
18421 Keyword, Template, TemplateLoc: TemplateNameLoc, TemplateArgs,
18422 /*Scope=*/Scope: nullptr, /*ForNestedNameSpecifier=*/ForNestedNameSpecifier: false);
18423}
18424
18425template<typename Derived>
18426QualType TreeTransform<Derived>::RebuildAtomicType(QualType ValueType,
18427 SourceLocation KWLoc) {
18428 return SemaRef.BuildAtomicType(T: ValueType, Loc: KWLoc);
18429}
18430
18431template<typename Derived>
18432QualType TreeTransform<Derived>::RebuildPipeType(QualType ValueType,
18433 SourceLocation KWLoc,
18434 bool isReadPipe) {
18435 return isReadPipe ? SemaRef.BuildReadPipeType(T: ValueType, Loc: KWLoc)
18436 : SemaRef.BuildWritePipeType(T: ValueType, Loc: KWLoc);
18437}
18438
18439template <typename Derived>
18440QualType TreeTransform<Derived>::RebuildBitIntType(bool IsUnsigned,
18441 unsigned NumBits,
18442 SourceLocation Loc) {
18443 llvm::APInt NumBitsAP(SemaRef.Context.getIntWidth(T: SemaRef.Context.IntTy),
18444 NumBits, true);
18445 IntegerLiteral *Bits = IntegerLiteral::Create(C: SemaRef.Context, V: NumBitsAP,
18446 type: SemaRef.Context.IntTy, l: Loc);
18447 return SemaRef.BuildBitIntType(IsUnsigned, BitWidth: Bits, Loc);
18448}
18449
18450template <typename Derived>
18451QualType TreeTransform<Derived>::RebuildDependentBitIntType(
18452 bool IsUnsigned, Expr *NumBitsExpr, SourceLocation Loc) {
18453 return SemaRef.BuildBitIntType(IsUnsigned, BitWidth: NumBitsExpr, Loc);
18454}
18455
18456template <typename Derived>
18457TemplateName TreeTransform<Derived>::RebuildTemplateName(CXXScopeSpec &SS,
18458 bool TemplateKW,
18459 TemplateName Name) {
18460 return SemaRef.Context.getQualifiedTemplateName(Qualifier: SS.getScopeRep(), TemplateKeyword: TemplateKW,
18461 Template: Name);
18462}
18463
18464template <typename Derived>
18465TemplateName TreeTransform<Derived>::RebuildTemplateName(
18466 CXXScopeSpec &SS, SourceLocation TemplateKWLoc, const IdentifierInfo &Name,
18467 SourceLocation NameLoc, QualType ObjectType, bool AllowInjectedClassName) {
18468 UnqualifiedId TemplateName;
18469 TemplateName.setIdentifier(Id: &Name, IdLoc: NameLoc);
18470 Sema::TemplateTy Template;
18471 getSema().ActOnTemplateName(/*Scope=*/nullptr, SS, TemplateKWLoc,
18472 TemplateName, ParsedType::make(P: ObjectType),
18473 /*EnteringContext=*/false, Template,
18474 AllowInjectedClassName);
18475 return Template.get();
18476}
18477
18478template<typename Derived>
18479TemplateName
18480TreeTransform<Derived>::RebuildTemplateName(CXXScopeSpec &SS,
18481 SourceLocation TemplateKWLoc,
18482 OverloadedOperatorKind Operator,
18483 SourceLocation NameLoc,
18484 QualType ObjectType,
18485 bool AllowInjectedClassName) {
18486 UnqualifiedId Name;
18487 // FIXME: Bogus location information.
18488 SourceLocation SymbolLocations[3] = { NameLoc, NameLoc, NameLoc };
18489 Name.setOperatorFunctionId(OperatorLoc: NameLoc, Op: Operator, SymbolLocations);
18490 Sema::TemplateTy Template;
18491 getSema().ActOnTemplateName(
18492 /*Scope=*/nullptr, SS, TemplateKWLoc, Name, ParsedType::make(P: ObjectType),
18493 /*EnteringContext=*/false, Template, AllowInjectedClassName);
18494 return Template.get();
18495}
18496
18497template <typename Derived>
18498ExprResult TreeTransform<Derived>::RebuildCXXOperatorCallExpr(
18499 OverloadedOperatorKind Op, SourceLocation OpLoc, SourceLocation CalleeLoc,
18500 bool RequiresADL, const UnresolvedSetImpl &Functions, Expr *First,
18501 Expr *Second) {
18502 bool isPostIncDec = Second && (Op == OO_PlusPlus || Op == OO_MinusMinus);
18503
18504 if (First->getObjectKind() == OK_ObjCProperty) {
18505 BinaryOperatorKind Opc = BinaryOperator::getOverloadedOpcode(OO: Op);
18506 if (BinaryOperator::isAssignmentOp(Opc))
18507 return SemaRef.PseudoObject().checkAssignment(/*Scope=*/S: nullptr, OpLoc,
18508 Opcode: Opc, LHS: First, RHS: Second);
18509 ExprResult Result = SemaRef.CheckPlaceholderExpr(E: First);
18510 if (Result.isInvalid())
18511 return ExprError();
18512 First = Result.get();
18513 }
18514
18515 if (Second && Second->getObjectKind() == OK_ObjCProperty) {
18516 ExprResult Result = SemaRef.CheckPlaceholderExpr(E: Second);
18517 if (Result.isInvalid())
18518 return ExprError();
18519 Second = Result.get();
18520 }
18521
18522 // Determine whether this should be a builtin operation.
18523 if (Op == OO_Subscript) {
18524 if (!First->getType()->isOverloadableType() &&
18525 !Second->getType()->isOverloadableType())
18526 return getSema().CreateBuiltinArraySubscriptExpr(First, CalleeLoc, Second,
18527 OpLoc);
18528 } else if (Op == OO_Arrow) {
18529 // It is possible that the type refers to a RecoveryExpr created earlier
18530 // in the tree transformation.
18531 if (First->getType()->isDependentType())
18532 return ExprError();
18533 // -> is never a builtin operation.
18534 return SemaRef.BuildOverloadedArrowExpr(S: nullptr, Base: First, OpLoc);
18535 } else if (Second == nullptr || isPostIncDec) {
18536 if (!First->getType()->isOverloadableType() ||
18537 (Op == OO_Amp && getSema().isQualifiedMemberAccess(First))) {
18538 // The argument is not of overloadable type, or this is an expression
18539 // of the form &Class::member, so try to create a built-in unary
18540 // operation.
18541 UnaryOperatorKind Opc
18542 = UnaryOperator::getOverloadedOpcode(OO: Op, Postfix: isPostIncDec);
18543
18544 return getSema().CreateBuiltinUnaryOp(OpLoc, Opc, First);
18545 }
18546 } else {
18547 if (!First->isTypeDependent() && !Second->isTypeDependent() &&
18548 !First->getType()->isOverloadableType() &&
18549 !Second->getType()->isOverloadableType()) {
18550 // Neither of the arguments is type-dependent or has an overloadable
18551 // type, so try to create a built-in binary operation.
18552 BinaryOperatorKind Opc = BinaryOperator::getOverloadedOpcode(OO: Op);
18553 ExprResult Result
18554 = SemaRef.CreateBuiltinBinOp(OpLoc, Opc, LHSExpr: First, RHSExpr: Second);
18555 if (Result.isInvalid())
18556 return ExprError();
18557
18558 return Result;
18559 }
18560 }
18561
18562 // Create the overloaded operator invocation for unary operators.
18563 if (!Second || isPostIncDec) {
18564 UnaryOperatorKind Opc
18565 = UnaryOperator::getOverloadedOpcode(OO: Op, Postfix: isPostIncDec);
18566 return SemaRef.CreateOverloadedUnaryOp(OpLoc, Opc, Fns: Functions, input: First,
18567 RequiresADL);
18568 }
18569
18570 // Create the overloaded operator invocation for binary operators.
18571 BinaryOperatorKind Opc = BinaryOperator::getOverloadedOpcode(OO: Op);
18572 ExprResult Result = SemaRef.CreateOverloadedBinOp(OpLoc, Opc, Fns: Functions,
18573 LHS: First, RHS: Second, RequiresADL);
18574 if (Result.isInvalid())
18575 return ExprError();
18576
18577 return Result;
18578}
18579
18580template<typename Derived>
18581ExprResult
18582TreeTransform<Derived>::RebuildCXXPseudoDestructorExpr(Expr *Base,
18583 SourceLocation OperatorLoc,
18584 bool isArrow,
18585 CXXScopeSpec &SS,
18586 TypeSourceInfo *ScopeType,
18587 SourceLocation CCLoc,
18588 SourceLocation TildeLoc,
18589 PseudoDestructorTypeStorage Destroyed) {
18590 QualType CanonicalBaseType = Base->getType().getCanonicalType();
18591 if (Base->isTypeDependent() || Destroyed.getIdentifier() ||
18592 (!isArrow && !isa<RecordType>(Val: CanonicalBaseType)) ||
18593 (isArrow && isa<PointerType>(Val: CanonicalBaseType) &&
18594 !cast<PointerType>(Val&: CanonicalBaseType)
18595 ->getPointeeType()
18596 ->getAsCanonical<RecordType>())) {
18597 // This pseudo-destructor expression is still a pseudo-destructor.
18598 return SemaRef.BuildPseudoDestructorExpr(
18599 Base, OpLoc: OperatorLoc, OpKind: isArrow ? tok::arrow : tok::period, SS, ScopeType,
18600 CCLoc, TildeLoc, DestroyedType: Destroyed);
18601 }
18602
18603 TypeSourceInfo *DestroyedType = Destroyed.getTypeSourceInfo();
18604 DeclarationName Name(SemaRef.Context.DeclarationNames.getCXXDestructorName(
18605 Ty: SemaRef.Context.getCanonicalType(T: DestroyedType->getType())));
18606 DeclarationNameInfo NameInfo(Name, Destroyed.getLocation());
18607 NameInfo.setNamedTypeInfo(DestroyedType);
18608
18609 // The scope type is now known to be a valid nested name specifier
18610 // component. Tack it on to the nested name specifier.
18611 if (ScopeType) {
18612 if (!isa<TagType>(Val: ScopeType->getType().getCanonicalType())) {
18613 getSema().Diag(ScopeType->getTypeLoc().getBeginLoc(),
18614 diag::err_expected_class_or_namespace)
18615 << ScopeType->getType() << getSema().getLangOpts().CPlusPlus;
18616 return ExprError();
18617 }
18618 SS.clear();
18619 SS.Make(Context&: SemaRef.Context, TL: ScopeType->getTypeLoc(), ColonColonLoc: CCLoc);
18620 }
18621
18622 SourceLocation TemplateKWLoc; // FIXME: retrieve it from caller.
18623 return getSema().BuildMemberReferenceExpr(
18624 Base, Base->getType(), OperatorLoc, isArrow, SS, TemplateKWLoc,
18625 /*FIXME: FirstQualifier*/ nullptr, NameInfo,
18626 /*TemplateArgs*/ nullptr,
18627 /*S*/ nullptr);
18628}
18629
18630template<typename Derived>
18631StmtResult
18632TreeTransform<Derived>::TransformCapturedStmt(CapturedStmt *S) {
18633 SourceLocation Loc = S->getBeginLoc();
18634 CapturedDecl *CD = S->getCapturedDecl();
18635 unsigned NumParams = CD->getNumParams();
18636 unsigned ContextParamPos = CD->getContextParamPosition();
18637 SmallVector<Sema::CapturedParamNameType, 4> Params;
18638 for (unsigned I = 0; I < NumParams; ++I) {
18639 if (I != ContextParamPos) {
18640 Params.push_back(
18641 Elt: std::make_pair(
18642 CD->getParam(i: I)->getName(),
18643 getDerived().TransformType(CD->getParam(i: I)->getType())));
18644 } else {
18645 Params.push_back(Elt: std::make_pair(x: StringRef(), y: QualType()));
18646 }
18647 }
18648 getSema().ActOnCapturedRegionStart(Loc, /*CurScope*/nullptr,
18649 S->getCapturedRegionKind(), Params);
18650 StmtResult Body;
18651 {
18652 Sema::CompoundScopeRAII CompoundScope(getSema());
18653 Body = getDerived().TransformStmt(S->getCapturedStmt());
18654 }
18655
18656 if (Body.isInvalid()) {
18657 getSema().ActOnCapturedRegionError();
18658 return StmtError();
18659 }
18660
18661 return getSema().ActOnCapturedRegionEnd(Body.get());
18662}
18663
18664template <typename Derived>
18665StmtResult
18666TreeTransform<Derived>::TransformSYCLKernelCallStmt(SYCLKernelCallStmt *S) {
18667 // SYCLKernelCallStmt nodes are inserted upon completion of a (non-template)
18668 // function definition or instantiation of a function template specialization
18669 // and will therefore never appear in a dependent context.
18670 llvm_unreachable("SYCL kernel call statement cannot appear in dependent "
18671 "context");
18672}
18673
18674template <typename Derived>
18675ExprResult TreeTransform<Derived>::TransformHLSLOutArgExpr(HLSLOutArgExpr *E) {
18676 // We can transform the base expression and allow argument resolution to fill
18677 // in the rest.
18678 return getDerived().TransformExpr(E->getArgLValue());
18679}
18680
18681} // end namespace clang
18682
18683#endif // LLVM_CLANG_LIB_SEMA_TREETRANSFORM_H
18684