| blob | 728ece3601ce1da9fe5385f317963af1285f79fb |
1 //===------- TreeTransform.h - Semantic Tree Transformation -----*- C++ -*-===/
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //===----------------------------------------------------------------------===/
8 //
9 // This file implements a semantic tree transformation that takes a given
10 // AST and rebuilds it, possibly transforming some nodes in the process.
11 //
12 //===----------------------------------------------------------------------===/
13 #ifndef LLVM_CLANG_SEMA_TREETRANSFORM_H
14 #define LLVM_CLANG_SEMA_TREETRANSFORM_H
34 #include <algorithm>
39 /// \brief A semantic tree transformation that allows one to transform one
40 /// abstract syntax tree into another.
41 ///
42 /// A new tree transformation is defined by creating a new subclass \c X of
43 /// \c TreeTransform<X> and then overriding certain operations to provide
44 /// behavior specific to that transformation. For example, template
45 /// instantiation is implemented as a tree transformation where the
46 /// transformation of TemplateTypeParmType nodes involves substituting the
47 /// template arguments for their corresponding template parameters; a similar
48 /// transformation is performed for non-type template parameters and
49 /// template template parameters.
50 ///
51 /// This tree-transformation template uses static polymorphism to allow
52 /// subclasses to customize any of its operations. Thus, a subclass can
53 /// override any of the transformation or rebuild operators by providing an
54 /// operation with the same signature as the default implementation. The
55 /// overridding function should not be virtual.
56 ///
57 /// Semantic tree transformations are split into two stages, either of which
58 /// can be replaced by a subclass. The "transform" step transforms an AST node
59 /// or the parts of an AST node using the various transformation functions,
60 /// then passes the pieces on to the "rebuild" step, which constructs a new AST
61 /// node of the appropriate kind from the pieces. The default transformation
62 /// routines recursively transform the operands to composite AST nodes (e.g.,
63 /// the pointee type of a PointerType node) and, if any of those operand nodes
64 /// were changed by the transformation, invokes the rebuild operation to create
65 /// a new AST node.
66 ///
67 /// Subclasses can customize the transformation at various levels. The
68 /// most coarse-grained transformations involve replacing TransformType(),
69 /// TransformExpr(), TransformDecl(), TransformNestedNameSpecifier(),
70 /// TransformTemplateName(), or TransformTemplateArgument() with entirely
71 /// new implementations.
72 ///
73 /// For more fine-grained transformations, subclasses can replace any of the
74 /// \c TransformXXX functions (where XXX is the name of an AST node, e.g.,
75 /// PointerType, StmtExpr) to alter the transformation. As mentioned previously,
76 /// replacing TransformTemplateTypeParmType() allows template instantiation
77 /// to substitute template arguments for their corresponding template
78 /// parameters. Additionally, subclasses can override the \c RebuildXXX
79 /// functions to control how AST nodes are rebuilt when their operands change.
80 /// By default, \c TreeTransform will invoke semantic analysis to rebuild
81 /// AST nodes. However, certain other tree transformations (e.g, cloning) may
82 /// be able to use more efficient rebuild steps.
83 ///
84 /// There are a handful of other functions that can be overridden, allowing one
85 /// to avoid traversing nodes that don't need any transformation
86 /// (\c AlreadyTransformed()), force rebuilding AST nodes even when their
87 /// operands have not changed (\c AlwaysRebuild()), and customize the
88 /// default locations and entity names used for type-checking
89 /// (\c getBaseLocation(), \c getBaseEntity()).
96 /// \brief Initializes a new tree transformer.
99 /// \brief Retrieves a reference to the derived class.
102 /// \brief Retrieves a reference to the derived class.
105 }
110 /// \brief Retrieves a reference to the semantic analysis object used for
111 /// this tree transform.
114 /// \brief Whether the transformation should always rebuild AST nodes, even
115 /// if none of the children have changed.
116 ///
117 /// Subclasses may override this function to specify when the transformation
118 /// should rebuild all AST nodes.
121 /// \brief Returns the location of the entity being transformed, if that
122 /// information was not available elsewhere in the AST.
123 ///
124 /// By default, returns no source-location information. Subclasses can
125 /// provide an alternative implementation that provides better location
126 /// information.
129 /// \brief Returns the name of the entity being transformed, if that
130 /// information was not available elsewhere in the AST.
131 ///
132 /// By default, returns an empty name. Subclasses can provide an alternative
133 /// implementation with a more precise name.
136 /// \brief Sets the "base" location and entity when that
137 /// information is known based on another transformation.
138 ///
139 /// By default, the source location and entity are ignored. Subclasses can
140 /// override this function to provide a customized implementation.
143 /// \brief RAII object that temporarily sets the base location and entity
144 /// used for reporting diagnostics in types.
147 SourceLocation OldLocation;
148 DeclarationName OldEntity;
156 }
160 }
161 };
163 /// \brief Determine whether the given type \p T has already been
164 /// transformed.
165 ///
166 /// Subclasses can provide an alternative implementation of this routine
167 /// to short-circuit evaluation when it is known that a given type will
168 /// not change. For example, template instantiation need not traverse
169 /// non-dependent types.
172 }
174 /// \brief Determine whether the given call argument should be dropped, e.g.,
175 /// because it is a default argument.
176 ///
177 /// Subclasses can provide an alternative implementation of this routine to
178 /// determine which kinds of call arguments get dropped. By default,
179 /// CXXDefaultArgument nodes are dropped (prior to transformation).
182 }
184 /// \brief Determine whether we should expand a pack expansion with the
185 /// given set of parameter packs into separate arguments by repeatedly
186 /// transforming the pattern.
187 ///
188 /// By default, the transformer never tries to expand pack expansions.
189 /// Subclasses can override this routine to provide different behavior.
190 ///
191 /// \param EllipsisLoc The location of the ellipsis that identifies the
192 /// pack expansion.
193 ///
194 /// \param PatternRange The source range that covers the entire pattern of
195 /// the pack expansion.
196 ///
197 /// \param Unexpanded The set of unexpanded parameter packs within the
198 /// pattern.
199 ///
200 /// \param NumUnexpanded The number of unexpanded parameter packs in
201 /// \p Unexpanded.
202 ///
203 /// \param ShouldExpand Will be set to \c true if the transformer should
204 /// expand the corresponding pack expansions into separate arguments. When
205 /// set, \c NumExpansions must also be set.
206 ///
207 /// \param NumExpansions The number of separate arguments that will be in
208 /// the expanded form of the corresponding pack expansion. Must be set when
209 /// \c ShouldExpand is \c true.
210 ///
211 /// \returns true if an error occurred (e.g., because the parameter packs
212 /// are to be instantiated with arguments of different lengths), false
213 /// otherwise. If false, \c ShouldExpand (and possibly \c NumExpansions)
214 /// must be set.
216 SourceRange PatternRange,
223 }
225 /// \brief Transforms the given type into another type.
226 ///
227 /// By default, this routine transforms a type by creating a
228 /// TypeSourceInfo for it and delegating to the appropriate
229 /// function. This is expensive, but we don't mind, because
230 /// this method is deprecated anyway; all users should be
231 /// switched to storing TypeSourceInfos.
232 ///
233 /// \returns the transformed type.
236 /// \brief Transforms the given type-with-location into a new
237 /// type-with-location.
238 ///
239 /// By default, this routine transforms a type by delegating to the
240 /// appropriate TransformXXXType to build a new type. Subclasses
241 /// may override this function (to take over all type
242 /// transformations) or some set of the TransformXXXType functions
243 /// to alter the transformation.
246 /// \brief Transform the given type-with-location into a new
247 /// type, collecting location information in the given builder
248 /// as necessary.
249 ///
252 /// \brief Transform the given statement.
253 ///
254 /// By default, this routine transforms a statement by delegating to the
255 /// appropriate TransformXXXStmt function to transform a specific kind of
256 /// statement or the TransformExpr() function to transform an expression.
257 /// Subclasses may override this function to transform statements using some
258 /// other mechanism.
259 ///
260 /// \returns the transformed statement.
263 /// \brief Transform the given expression.
264 ///
265 /// By default, this routine transforms an expression by delegating to the
266 /// appropriate TransformXXXExpr function to build a new expression.
267 /// Subclasses may override this function to transform expressions using some
268 /// other mechanism.
269 ///
270 /// \returns the transformed expression.
273 /// \brief Transform the given declaration, which is referenced from a type
274 /// or expression.
275 ///
276 /// By default, acts as the identity function on declarations. Subclasses
277 /// may override this function to provide alternate behavior.
280 /// \brief Transform the definition of the given declaration.
281 ///
282 /// By default, invokes TransformDecl() to transform the declaration.
283 /// Subclasses may override this function to provide alternate behavior.
286 }
288 /// \brief Transform the given declaration, which was the first part of a
289 /// nested-name-specifier in a member access expression.
290 ///
291 /// This specific declaration transformation only applies to the first
292 /// identifier in a nested-name-specifier of a member access expression, e.g.,
293 /// the \c T in \c x->T::member
294 ///
295 /// By default, invokes TransformDecl() to transform the declaration.
296 /// Subclasses may override this function to provide alternate behavior.
299 }
301 /// \brief Transform the given nested-name-specifier.
302 ///
303 /// By default, transforms all of the types and declarations within the
304 /// nested-name-specifier. Subclasses may override this function to provide
305 /// alternate behavior.
307 SourceRange Range,
311 /// \brief Transform the given declaration name.
312 ///
313 /// By default, transforms the types of conversion function, constructor,
314 /// and destructor names and then (if needed) rebuilds the declaration name.
315 /// Identifiers and selectors are returned unmodified. Sublcasses may
316 /// override this function to provide alternate behavior.
317 DeclarationNameInfo
320 /// \brief Transform the given template name.
321 ///
322 /// By default, transforms the template name by transforming the declarations
323 /// and nested-name-specifiers that occur within the template name.
324 /// Subclasses may override this function to provide alternate behavior.
329 /// \brief Transform the given template argument.
330 ///
331 /// By default, this operation transforms the type, expression, or
332 /// declaration stored within the template argument and constructs a
333 /// new template argument from the transformed result. Subclasses may
334 /// override this function to provide alternate behavior.
335 ///
336 /// Returns true if there was an error.
340 /// \brief Transform the given set of template arguments.
341 ///
342 /// By default, this operation transforms all of the template arguments
343 /// in the input set using \c TransformTemplateArgument(), and appends
344 /// the transformed arguments to the output list.
345 ///
346 /// Note that this overload of \c TransformTemplateArguments() is merely
347 /// a convenience function. Subclasses that wish to override this behavior
348 /// should override the iterator-based member template version.
349 ///
350 /// \param Inputs The set of template arguments to be transformed.
351 ///
352 /// \param NumInputs The number of template arguments in \p Inputs.
353 ///
354 /// \param Outputs The set of transformed template arguments output by this
355 /// routine.
356 ///
357 /// Returns true if an error occurred.
362 }
364 /// \brief Transform the given set of template arguments.
365 ///
366 /// By default, this operation transforms all of the template arguments
367 /// in the input set using \c TransformTemplateArgument(), and appends
368 /// the transformed arguments to the output list.
369 ///
370 /// \param First An iterator to the first template argument.
371 ///
372 /// \param Last An iterator one step past the last template argument.
373 ///
374 /// \param Outputs The set of transformed template arguments output by this
375 /// routine.
376 ///
377 /// Returns true if an error occurred.
380 InputIterator Last,
383 /// \brief Fakes up a TemplateArgumentLoc for a given TemplateArgument.
387 /// \brief Fakes up a TypeSourceInfo for a type.
391 }
393 #define ABSTRACT_TYPELOC(CLASS, PARENT)
394 #define TYPELOC(CLASS, PARENT) \
395 QualType Transform##CLASS##Type(TypeLocBuilder &TLB, CLASS##TypeLoc T);
398 QualType
400 TemplateSpecializationTypeLoc TL,
401 TemplateName Template);
403 QualType
405 DependentTemplateSpecializationTypeLoc TL,
408 /// \brief Transforms the parameters of a function type into the
409 /// given vectors.
410 ///
411 /// The result vectors should be kept in sync; null entries in the
412 /// variables vector are acceptable.
413 ///
414 /// Return true on error.
419 /// \brief Transforms a single function-type parameter. Return null
420 /// on error.
428 #define STMT(Node, Parent) \
429 StmtResult Transform##Node(Node *S);
430 #define EXPR(Node, Parent) \
431 ExprResult Transform##Node(Node *E);
432 #define ABSTRACT_STMT(Stmt)
435 /// \brief Build a new pointer type given its pointee type.
436 ///
437 /// By default, performs semantic analysis when building the pointer type.
438 /// Subclasses may override this routine to provide different behavior.
441 /// \brief Build a new block pointer type given its pointee type.
442 ///
443 /// By default, performs semantic analysis when building the block pointer
444 /// type. Subclasses may override this routine to provide different behavior.
447 /// \brief Build a new reference type given the type it references.
448 ///
449 /// By default, performs semantic analysis when building the
450 /// reference type. Subclasses may override this routine to provide
451 /// different behavior.
452 ///
453 /// \param LValue whether the type was written with an lvalue sigil
454 /// or an rvalue sigil.
457 SourceLocation Sigil);
459 /// \brief Build a new member pointer type given the pointee type and the
460 /// class type it refers into.
461 ///
462 /// By default, performs semantic analysis when building the member pointer
463 /// type. Subclasses may override this routine to provide different behavior.
465 SourceLocation Sigil);
467 /// \brief Build a new array type given the element type, size
468 /// modifier, size of the array (if known), size expression, and index type
469 /// qualifiers.
470 ///
471 /// By default, performs semantic analysis when building the array type.
472 /// Subclasses may override this routine to provide different behavior.
473 /// Also by default, all of the other Rebuild*Array
479 SourceRange BracketsRange);
481 /// \brief Build a new constant array type given the element type, size
482 /// modifier, (known) size of the array, and index type qualifiers.
483 ///
484 /// By default, performs semantic analysis when building the array type.
485 /// Subclasses may override this routine to provide different behavior.
490 SourceRange BracketsRange);
492 /// \brief Build a new incomplete array type given the element type, size
493 /// modifier, and index type qualifiers.
494 ///
495 /// By default, performs semantic analysis when building the array type.
496 /// Subclasses may override this routine to provide different behavior.
500 SourceRange BracketsRange);
502 /// \brief Build a new variable-length array type given the element type,
503 /// size modifier, size expression, and index type qualifiers.
504 ///
505 /// By default, performs semantic analysis when building the array type.
506 /// Subclasses may override this routine to provide different behavior.
511 SourceRange BracketsRange);
513 /// \brief Build a new dependent-sized array type given the element type,
514 /// size modifier, size expression, and index type qualifiers.
515 ///
516 /// By default, performs semantic analysis when building the array type.
517 /// Subclasses may override this routine to provide different behavior.
522 SourceRange BracketsRange);
524 /// \brief Build a new vector type given the element type and
525 /// number of elements.
526 ///
527 /// By default, performs semantic analysis when building the vector type.
528 /// Subclasses may override this routine to provide different behavior.
532 /// \brief Build a new extended vector type given the element type and
533 /// number of elements.
534 ///
535 /// By default, performs semantic analysis when building the vector type.
536 /// Subclasses may override this routine to provide different behavior.
538 SourceLocation AttributeLoc);
540 /// \brief Build a new potentially dependently-sized extended vector type
541 /// given the element type and number of elements.
542 ///
543 /// By default, performs semantic analysis when building the vector type.
544 /// Subclasses may override this routine to provide different behavior.
547 SourceLocation AttributeLoc);
549 /// \brief Build a new function type.
550 ///
551 /// By default, performs semantic analysis when building the function type.
552 /// Subclasses may override this routine to provide different behavior.
559 /// \brief Build a new unprototyped function type.
562 /// \brief Rebuild an unresolved typename type, given the decl that
563 /// the UnresolvedUsingTypenameDecl was transformed to.
566 /// \brief Build a new typedef type.
569 }
571 /// \brief Build a new class/struct/union type.
574 }
576 /// \brief Build a new Enum type.
579 }
581 /// \brief Build a new typeof(expr) type.
582 ///
583 /// By default, performs semantic analysis when building the typeof type.
584 /// Subclasses may override this routine to provide different behavior.
587 /// \brief Build a new typeof(type) type.
588 ///
589 /// By default, builds a new TypeOfType with the given underlying type.
592 /// \brief Build a new C++0x decltype type.
593 ///
594 /// By default, performs semantic analysis when building the decltype type.
595 /// Subclasses may override this routine to provide different behavior.
598 /// \brief Build a new template specialization type.
599 ///
600 /// By default, performs semantic analysis when building the template
601 /// specialization type. Subclasses may override this routine to provide
602 /// different behavior.
604 SourceLocation TemplateLoc,
607 /// \brief Build a new parenthesized type.
608 ///
609 /// By default, builds a new ParenType type from the inner type.
610 /// Subclasses may override this routine to provide different behavior.
613 }
615 /// \brief Build a new qualified name type.
616 ///
617 /// By default, builds a new ElaboratedType type from the keyword,
618 /// the nested-name-specifier and the named type.
619 /// Subclasses may override this routine to provide different behavior.
621 ElaboratedTypeKeyword Keyword,
624 }
626 /// \brief Build a new typename type that refers to a template-id.
627 ///
628 /// By default, builds a new DependentNameType type from the
629 /// nested-name-specifier and the given type. Subclasses may override
630 /// this routine to provide different behavior.
632 ElaboratedTypeKeyword Keyword,
634 SourceRange QualifierRange,
636 SourceLocation NameLoc,
638 // Rebuild the template name.
639 // TODO: avoid TemplateName abstraction
640 TemplateName InstName =
647 // If it's still dependent, make a dependent specialization.
652 // Otherwise, make an elaborated type wrapping a non-dependent
653 // specialization.
654 QualType T =
658 // NOTE: NNS is already recorded in template specialization type T.
660 }
662 /// \brief Build a new typename type that refers to an identifier.
663 ///
664 /// By default, performs semantic analysis when building the typename type
665 /// (or elaborated type). Subclasses may override this routine to provide
666 /// different behavior.
670 SourceLocation KeywordLoc,
671 SourceRange NNSRange,
672 SourceLocation IdLoc) {
673 CXXScopeSpec SS;
678 // If the name is still dependent, just build a new dependent name type.
681 }
689 // We had a dependent elaborated-type-specifier that has been transformed
690 // into a non-dependent elaborated-type-specifier. Find the tag we're
691 // referring to.
717 // Let the LookupResult structure handle ambiguities.
719 }
722 // FIXME: Would be nice to highlight just the source range.
726 }
732 }
734 // Build the elaborated-type-specifier type.
737 }
739 /// \brief Build a new nested-name-specifier given the prefix and an
740 /// identifier that names the next step in the nested-name-specifier.
741 ///
742 /// By default, performs semantic analysis when building the new
743 /// nested-name-specifier. Subclasses may override this routine to provide
744 /// different behavior.
746 SourceRange Range,
748 QualType ObjectType,
751 /// \brief Build a new nested-name-specifier given the prefix and the
752 /// namespace named in the next step in the nested-name-specifier.
753 ///
754 /// By default, performs semantic analysis when building the new
755 /// nested-name-specifier. Subclasses may override this routine to provide
756 /// different behavior.
758 SourceRange Range,
761 /// \brief Build a new nested-name-specifier given the prefix and the
762 /// type named in the next step in the nested-name-specifier.
763 ///
764 /// By default, performs semantic analysis when building the new
765 /// nested-name-specifier. Subclasses may override this routine to provide
766 /// different behavior.
768 SourceRange Range,
770 QualType T);
772 /// \brief Build a new template name given a nested name specifier, a flag
773 /// indicating whether the "template" keyword was provided, and the template
774 /// that the template name refers to.
775 ///
776 /// By default, builds the new template name directly. Subclasses may override
777 /// this routine to provide different behavior.
782 /// \brief Build a new template name given a nested name specifier and the
783 /// name that is referred to as a template.
784 ///
785 /// By default, performs semantic analysis to determine whether the name can
786 /// be resolved to a specific template, then builds the appropriate kind of
787 /// template name. Subclasses may override this routine to provide different
788 /// behavior.
790 SourceRange QualifierRange,
792 QualType ObjectType,
795 /// \brief Build a new template name given a nested name specifier and the
796 /// overloaded operator name that is referred to as a template.
797 ///
798 /// By default, performs semantic analysis to determine whether the name can
799 /// be resolved to a specific template, then builds the appropriate kind of
800 /// template name. Subclasses may override this routine to provide different
801 /// behavior.
803 OverloadedOperatorKind Operator,
804 QualType ObjectType);
806 /// \brief Build a new compound statement.
807 ///
808 /// By default, performs semantic analysis to build the new statement.
809 /// Subclasses may override this routine to provide different behavior.
811 MultiStmtArg Statements,
812 SourceLocation RBraceLoc,
815 IsStmtExpr);
816 }
818 /// \brief Build a new case statement.
819 ///
820 /// By default, performs semantic analysis to build the new statement.
821 /// Subclasses may override this routine to provide different behavior.
824 SourceLocation EllipsisLoc,
826 SourceLocation ColonLoc) {
828 ColonLoc);
829 }
831 /// \brief Attach the body to a new case statement.
832 ///
833 /// By default, performs semantic analysis to build the new statement.
834 /// Subclasses may override this routine to provide different behavior.
838 }
840 /// \brief Build a new default statement.
841 ///
842 /// By default, performs semantic analysis to build the new statement.
843 /// Subclasses may override this routine to provide different behavior.
845 SourceLocation ColonLoc,
849 }
851 /// \brief Build a new label statement.
852 ///
853 /// By default, performs semantic analysis to build the new statement.
854 /// Subclasses may override this routine to provide different behavior.
857 SourceLocation ColonLoc,
860 HasUnusedAttr);
861 }
863 /// \brief Build a new "if" statement.
864 ///
865 /// By default, performs semantic analysis to build the new statement.
866 /// Subclasses may override this routine to provide different behavior.
871 }
873 /// \brief Start building a new switch statement.
874 ///
875 /// By default, performs semantic analysis to build the new statement.
876 /// Subclasses may override this routine to provide different behavior.
880 CondVar);
881 }
883 /// \brief Attach the body to the switch statement.
884 ///
885 /// By default, performs semantic analysis to build the new statement.
886 /// Subclasses may override this routine to provide different behavior.
890 }
892 /// \brief Build a new while statement.
893 ///
894 /// By default, performs semantic analysis to build the new statement.
895 /// Subclasses may override this routine to provide different behavior.
901 }
903 /// \brief Build a new do-while statement.
904 ///
905 /// By default, performs semantic analysis to build the new statement.
906 /// Subclasses may override this routine to provide different behavior.
908 SourceLocation WhileLoc,
909 SourceLocation LParenLoc,
911 SourceLocation RParenLoc) {
914 }
916 /// \brief Build a new for statement.
917 ///
918 /// By default, performs semantic analysis to build the new statement.
919 /// Subclasses may override this routine to provide different behavior.
921 SourceLocation LParenLoc,
926 CondVar,
928 }
930 /// \brief Build a new goto statement.
931 ///
932 /// By default, performs semantic analysis to build the new statement.
933 /// Subclasses may override this routine to provide different behavior.
935 SourceLocation LabelLoc,
938 }
940 /// \brief Build a new indirect goto statement.
941 ///
942 /// By default, performs semantic analysis to build the new statement.
943 /// Subclasses may override this routine to provide different behavior.
945 SourceLocation StarLoc,
948 }
950 /// \brief Build a new return statement.
951 ///
952 /// By default, performs semantic analysis to build the new statement.
953 /// Subclasses may override this routine to provide different behavior.
958 }
960 /// \brief Build a new declaration statement.
961 ///
962 /// By default, performs semantic analysis to build the new statement.
963 /// Subclasses may override this routine to provide different behavior.
965 SourceLocation StartLoc,
966 SourceLocation EndLoc) {
972 }
974 /// \brief Build a new inline asm statement.
975 ///
976 /// By default, performs semantic analysis to build the new statement.
977 /// Subclasses may override this routine to provide different behavior.
984 MultiExprArg Constraints,
985 MultiExprArg Exprs,
987 MultiExprArg Clobbers,
988 SourceLocation RParenLoc,
994 }
996 /// \brief Build a new Objective-C @try statement.
997 ///
998 /// By default, performs semantic analysis to build the new statement.
999 /// Subclasses may override this routine to provide different behavior.
1002 MultiStmtArg CatchStmts,
1005 Finally);
1006 }
1008 /// \brief Rebuild an Objective-C exception declaration.
1009 ///
1010 /// By default, performs semantic analysis to build the new declaration.
1011 /// Subclasses may override this routine to provide different behavior.
1017 }
1019 /// \brief Build a new Objective-C @catch statement.
1020 ///
1021 /// By default, performs semantic analysis to build the new statement.
1022 /// Subclasses may override this routine to provide different behavior.
1024 SourceLocation RParenLoc,
1029 }
1031 /// \brief Build a new Objective-C @finally statement.
1032 ///
1033 /// By default, performs semantic analysis to build the new statement.
1034 /// Subclasses may override this routine to provide different behavior.
1038 }
1040 /// \brief Build a new Objective-C @throw statement.
1041 ///
1042 /// By default, performs semantic analysis to build the new statement.
1043 /// Subclasses may override this routine to provide different behavior.
1047 }
1049 /// \brief Build a new Objective-C @synchronized statement.
1050 ///
1051 /// By default, performs semantic analysis to build the new statement.
1052 /// Subclasses may override this routine to provide different behavior.
1057 Body);
1058 }
1060 /// \brief Build a new Objective-C fast enumeration statement.
1061 ///
1062 /// By default, performs semantic analysis to build the new statement.
1063 /// Subclasses may override this routine to provide different behavior.
1065 SourceLocation LParenLoc,
1068 SourceLocation RParenLoc,
1071 Element,
1072 Collection,
1073 RParenLoc,
1074 Body);
1075 }
1077 /// \brief Build a new C++ exception declaration.
1078 ///
1079 /// By default, performs semantic analysis to build the new decaration.
1080 /// Subclasses may override this routine to provide different behavior.
1084 SourceLocation Loc) {
1086 }
1088 /// \brief Build a new C++ catch statement.
1089 ///
1090 /// By default, performs semantic analysis to build the new statement.
1091 /// Subclasses may override this routine to provide different behavior.
1096 Handler));
1097 }
1099 /// \brief Build a new C++ try statement.
1100 ///
1101 /// By default, performs semantic analysis to build the new statement.
1102 /// Subclasses may override this routine to provide different behavior.
1105 MultiStmtArg Handlers) {
1107 }
1109 /// \brief Build a new expression that references a declaration.
1110 ///
1111 /// By default, performs semantic analysis to build the new expression.
1112 /// Subclasses may override this routine to provide different behavior.
1117 }
1120 /// \brief Build a new expression that references a declaration.
1121 ///
1122 /// By default, performs semantic analysis to build the new expression.
1123 /// Subclasses may override this routine to provide different behavior.
1125 SourceRange QualifierRange,
1129 CXXScopeSpec SS;
1133 // FIXME: loses template args.
1136 }
1138 /// \brief Build a new expression in parentheses.
1139 ///
1140 /// By default, performs semantic analysis to build the new expression.
1141 /// Subclasses may override this routine to provide different behavior.
1143 SourceLocation RParen) {
1145 }
1147 /// \brief Build a new pseudo-destructor expression.
1148 ///
1149 /// By default, performs semantic analysis to build the new expression.
1150 /// Subclasses may override this routine to provide different behavior.
1152 SourceLocation OperatorLoc,
1155 SourceRange QualifierRange,
1157 SourceLocation CCLoc,
1158 SourceLocation TildeLoc,
1159 PseudoDestructorTypeStorage Destroyed);
1161 /// \brief Build a new unary operator expression.
1162 ///
1163 /// By default, performs semantic analysis to build the new expression.
1164 /// Subclasses may override this routine to provide different behavior.
1166 UnaryOperatorKind Opc,
1169 }
1171 /// \brief Build a new builtin offsetof expression.
1172 ///
1173 /// By default, performs semantic analysis to build the new expression.
1174 /// Subclasses may override this routine to provide different behavior.
1179 SourceLocation RParenLoc) {
1182 }
1184 /// \brief Build a new sizeof or alignof expression with a type argument.
1185 ///
1186 /// By default, performs semantic analysis to build the new expression.
1187 /// Subclasses may override this routine to provide different behavior.
1189 SourceLocation OpLoc,
1192 }
1194 /// \brief Build a new sizeof or alignof expression with an expression
1195 /// argument.
1196 ///
1197 /// By default, performs semantic analysis to build the new expression.
1198 /// Subclasses may override this routine to provide different behavior.
1201 ExprResult Result
1207 }
1209 /// \brief Build a new array subscript expression.
1210 ///
1211 /// By default, performs semantic analysis to build the new expression.
1212 /// Subclasses may override this routine to provide different behavior.
1214 SourceLocation LBracketLoc,
1216 SourceLocation RBracketLoc) {
1219 RBracketLoc);
1220 }
1222 /// \brief Build a new call expression.
1223 ///
1224 /// By default, performs semantic analysis to build the new expression.
1225 /// Subclasses may override this routine to provide different behavior.
1227 MultiExprArg Args,
1228 SourceLocation RParenLoc) {
1231 }
1233 /// \brief Build a new member access expression.
1234 ///
1235 /// By default, performs semantic analysis to build the new expression.
1236 /// Subclasses may override this routine to provide different behavior.
1240 SourceRange QualifierRange,
1247 // We have a reference to an unnamed field. This is always the
1248 // base of an anonymous struct/union member access, i.e. the
1249 // field is always of record type.
1265 }
1267 CXXScopeSpec SS;
1271 }
1276 // FIXME: this involves duplicating earlier analysis in a lot of
1277 // cases; we should avoid this when possible.
1285 }
1287 /// \brief Build a new binary operator expression.
1288 ///
1289 /// By default, performs semantic analysis to build the new expression.
1290 /// Subclasses may override this routine to provide different behavior.
1292 BinaryOperatorKind Opc,
1295 }
1297 /// \brief Build a new conditional operator expression.
1298 ///
1299 /// By default, performs semantic analysis to build the new expression.
1300 /// Subclasses may override this routine to provide different behavior.
1302 SourceLocation QuestionLoc,
1304 SourceLocation ColonLoc,
1308 }
1310 /// \brief Build a new C-style cast expression.
1311 ///
1312 /// By default, performs semantic analysis to build the new expression.
1313 /// Subclasses may override this routine to provide different behavior.
1316 SourceLocation RParenLoc,
1319 SubExpr);
1320 }
1322 /// \brief Build a new compound literal expression.
1323 ///
1324 /// By default, performs semantic analysis to build the new expression.
1325 /// Subclasses may override this routine to provide different behavior.
1328 SourceLocation RParenLoc,
1331 Init);
1332 }
1334 /// \brief Build a new extended vector element access expression.
1335 ///
1336 /// By default, performs semantic analysis to build the new expression.
1337 /// Subclasses may override this routine to provide different behavior.
1339 SourceLocation OpLoc,
1340 SourceLocation AccessorLoc,
1343 CXXScopeSpec SS;
1348 NameInfo,
1350 }
1352 /// \brief Build a new initializer list expression.
1353 ///
1354 /// By default, performs semantic analysis to build the new expression.
1355 /// Subclasses may override this routine to provide different behavior.
1357 MultiExprArg Inits,
1358 SourceLocation RBraceLoc,
1359 QualType ResultTy) {
1360 ExprResult Result
1365 // Patch in the result type we were given, which may have been computed
1366 // when the initial InitListExpr was built.
1370 }
1372 /// \brief Build a new designated initializer expression.
1373 ///
1374 /// By default, performs semantic analysis to build the new expression.
1375 /// Subclasses may override this routine to provide different behavior.
1377 MultiExprArg ArrayExprs,
1378 SourceLocation EqualOrColonLoc,
1381 ExprResult Result
1383 Init);
1389 }
1391 /// \brief Build a new value-initialized expression.
1392 ///
1393 /// By default, builds the implicit value initialization without performing
1394 /// any semantic analysis. Subclasses may override this routine to provide
1395 /// different behavior.
1398 }
1400 /// \brief Build a new \c va_arg expression.
1401 ///
1402 /// By default, performs semantic analysis to build the new expression.
1403 /// Subclasses may override this routine to provide different behavior.
1406 SourceLocation RParenLoc) {
1409 RParenLoc);
1410 }
1412 /// \brief Build a new expression list in parentheses.
1413 ///
1414 /// By default, performs semantic analysis to build the new expression.
1415 /// Subclasses may override this routine to provide different behavior.
1417 MultiExprArg SubExprs,
1418 SourceLocation RParenLoc) {
1421 }
1423 /// \brief Build a new address-of-label expression.
1424 ///
1425 /// By default, performs semantic analysis, using the name of the label
1426 /// rather than attempting to map the label statement itself.
1427 /// Subclasses may override this routine to provide different behavior.
1429 SourceLocation LabelLoc,
1432 }
1434 /// \brief Build a new GNU statement expression.
1435 ///
1436 /// By default, performs semantic analysis to build the new expression.
1437 /// Subclasses may override this routine to provide different behavior.
1440 SourceLocation RParenLoc) {
1442 }
1444 /// \brief Build a new __builtin_choose_expr expression.
1445 ///
1446 /// By default, performs semantic analysis to build the new expression.
1447 /// Subclasses may override this routine to provide different behavior.
1450 SourceLocation RParenLoc) {
1453 RParenLoc);
1454 }
1456 /// \brief Build a new overloaded operator call expression.
1457 ///
1458 /// By default, performs semantic analysis to build the new expression.
1459 /// The semantic analysis provides the behavior of template instantiation,
1460 /// copying with transformations that turn what looks like an overloaded
1461 /// operator call into a use of a builtin operator, performing
1462 /// argument-dependent lookup, etc. Subclasses may override this routine to
1463 /// provide different behavior.
1465 SourceLocation OpLoc,
1470 /// \brief Build a new C++ "named" cast expression, such as static_cast or
1471 /// reinterpret_cast.
1472 ///
1473 /// By default, this routine dispatches to one of the more-specific routines
1474 /// for a particular named case, e.g., RebuildCXXStaticCastExpr().
1475 /// Subclasses may override this routine to provide different behavior.
1478 SourceLocation LAngleLoc,
1480 SourceLocation RAngleLoc,
1481 SourceLocation LParenLoc,
1483 SourceLocation RParenLoc) {
1498 SubExpr,
1499 RParenLoc);
1509 }
1512 }
1514 /// \brief Build a new C++ static_cast expression.
1515 ///
1516 /// By default, performs semantic analysis to build the new expression.
1517 /// Subclasses may override this routine to provide different behavior.
1519 SourceLocation LAngleLoc,
1521 SourceLocation RAngleLoc,
1522 SourceLocation LParenLoc,
1524 SourceLocation RParenLoc) {
1529 }
1531 /// \brief Build a new C++ dynamic_cast expression.
1532 ///
1533 /// By default, performs semantic analysis to build the new expression.
1534 /// Subclasses may override this routine to provide different behavior.
1536 SourceLocation LAngleLoc,
1538 SourceLocation RAngleLoc,
1539 SourceLocation LParenLoc,
1541 SourceLocation RParenLoc) {
1546 }
1548 /// \brief Build a new C++ reinterpret_cast expression.
1549 ///
1550 /// By default, performs semantic analysis to build the new expression.
1551 /// Subclasses may override this routine to provide different behavior.
1553 SourceLocation LAngleLoc,
1555 SourceLocation RAngleLoc,
1556 SourceLocation LParenLoc,
1558 SourceLocation RParenLoc) {
1563 }
1565 /// \brief Build a new C++ const_cast expression.
1566 ///
1567 /// By default, performs semantic analysis to build the new expression.
1568 /// Subclasses may override this routine to provide different behavior.
1570 SourceLocation LAngleLoc,
1572 SourceLocation RAngleLoc,
1573 SourceLocation LParenLoc,
1575 SourceLocation RParenLoc) {
1580 }
1582 /// \brief Build a new C++ functional-style cast expression.
1583 ///
1584 /// By default, performs semantic analysis to build the new expression.
1585 /// Subclasses may override this routine to provide different behavior.
1587 SourceLocation LParenLoc,
1589 SourceLocation RParenLoc) {
1592 RParenLoc);
1593 }
1595 /// \brief Build a new C++ typeid(type) expression.
1596 ///
1597 /// By default, performs semantic analysis to build the new expression.
1598 /// Subclasses may override this routine to provide different behavior.
1600 SourceLocation TypeidLoc,
1602 SourceLocation RParenLoc) {
1604 RParenLoc);
1605 }
1608 /// \brief Build a new C++ typeid(expr) expression.
1609 ///
1610 /// By default, performs semantic analysis to build the new expression.
1611 /// Subclasses may override this routine to provide different behavior.
1613 SourceLocation TypeidLoc,
1615 SourceLocation RParenLoc) {
1617 RParenLoc);
1618 }
1620 /// \brief Build a new C++ __uuidof(type) expression.
1621 ///
1622 /// By default, performs semantic analysis to build the new expression.
1623 /// Subclasses may override this routine to provide different behavior.
1625 SourceLocation TypeidLoc,
1627 SourceLocation RParenLoc) {
1629 RParenLoc);
1630 }
1632 /// \brief Build a new C++ __uuidof(expr) expression.
1633 ///
1634 /// By default, performs semantic analysis to build the new expression.
1635 /// Subclasses may override this routine to provide different behavior.
1637 SourceLocation TypeidLoc,
1639 SourceLocation RParenLoc) {
1641 RParenLoc);
1642 }
1644 /// \brief Build a new C++ "this" expression.
1645 ///
1646 /// By default, builds a new "this" expression without performing any
1647 /// semantic analysis. Subclasses may override this routine to provide
1648 /// different behavior.
1650 QualType ThisType,
1654 isImplicit));
1655 }
1657 /// \brief Build a new C++ throw expression.
1658 ///
1659 /// By default, performs semantic analysis to build the new expression.
1660 /// Subclasses may override this routine to provide different behavior.
1663 }
1665 /// \brief Build a new C++ default-argument expression.
1666 ///
1667 /// By default, builds a new default-argument expression, which does not
1668 /// require any semantic analysis. Subclasses may override this routine to
1669 /// provide different behavior.
1673 Param));
1674 }
1676 /// \brief Build a new C++ zero-initialization expression.
1677 ///
1678 /// By default, performs semantic analysis to build the new expression.
1679 /// Subclasses may override this routine to provide different behavior.
1681 SourceLocation LParenLoc,
1682 SourceLocation RParenLoc) {
1685 RParenLoc);
1686 }
1688 /// \brief Build a new C++ "new" expression.
1689 ///
1690 /// By default, performs semantic analysis to build the new expression.
1691 /// Subclasses may override this routine to provide different behavior.
1694 SourceLocation PlacementLParen,
1695 MultiExprArg PlacementArgs,
1696 SourceLocation PlacementRParen,
1697 SourceRange TypeIdParens,
1698 QualType AllocatedType,
1701 SourceLocation ConstructorLParen,
1702 MultiExprArg ConstructorArgs,
1703 SourceLocation ConstructorRParen) {
1705 PlacementLParen,
1707 PlacementRParen,
1708 TypeIdParens,
1709 AllocatedType,
1710 AllocatedTypeInfo,
1711 ArraySize,
1712 ConstructorLParen,
1714 ConstructorRParen);
1715 }
1717 /// \brief Build a new C++ "delete" expression.
1718 ///
1719 /// By default, performs semantic analysis to build the new expression.
1720 /// Subclasses may override this routine to provide different behavior.
1726 Operand);
1727 }
1729 /// \brief Build a new unary type trait expression.
1730 ///
1731 /// By default, performs semantic analysis to build the new expression.
1732 /// Subclasses may override this routine to provide different behavior.
1734 SourceLocation StartLoc,
1736 SourceLocation RParenLoc) {
1738 }
1740 /// \brief Build a new binary type trait expression.
1741 ///
1742 /// By default, performs semantic analysis to build the new expression.
1743 /// Subclasses may override this routine to provide different behavior.
1745 SourceLocation StartLoc,
1748 SourceLocation RParenLoc) {
1750 }
1752 /// \brief Build a new (previously unresolved) declaration reference
1753 /// expression.
1754 ///
1755 /// By default, performs semantic analysis to build the new expression.
1756 /// Subclasses may override this routine to provide different behavior.
1758 SourceRange QualifierRange,
1761 CXXScopeSpec SS;
1770 }
1772 /// \brief Build a new template-id expression.
1773 ///
1774 /// By default, performs semantic analysis to build the new expression.
1775 /// Subclasses may override this routine to provide different behavior.
1781 }
1783 /// \brief Build a new object-construction expression.
1784 ///
1785 /// By default, performs semantic analysis to build the new expression.
1786 /// Subclasses may override this routine to provide different behavior.
1788 SourceLocation Loc,
1791 MultiExprArg Args,
1794 SourceRange ParenRange) {
1797 ConvertedArgs))
1803 ParenRange);
1804 }
1806 /// \brief Build a new object-construction expression.
1807 ///
1808 /// By default, performs semantic analysis to build the new expression.
1809 /// Subclasses may override this routine to provide different behavior.
1811 SourceLocation LParenLoc,
1812 MultiExprArg Args,
1813 SourceLocation RParenLoc) {
1815 LParenLoc,
1817 RParenLoc);
1818 }
1820 /// \brief Build a new object-construction expression.
1821 ///
1822 /// By default, performs semantic analysis to build the new expression.
1823 /// Subclasses may override this routine to provide different behavior.
1825 SourceLocation LParenLoc,
1826 MultiExprArg Args,
1827 SourceLocation RParenLoc) {
1829 LParenLoc,
1831 RParenLoc);
1832 }
1834 /// \brief Build a new member reference expression.
1835 ///
1836 /// By default, performs semantic analysis to build the new expression.
1837 /// Subclasses may override this routine to provide different behavior.
1839 QualType BaseType,
1841 SourceLocation OperatorLoc,
1843 SourceRange QualifierRange,
1847 CXXScopeSpec SS;
1854 MemberNameInfo,
1855 TemplateArgs);
1856 }
1858 /// \brief Build a new member reference expression.
1859 ///
1860 /// By default, performs semantic analysis to build the new expression.
1861 /// Subclasses may override this routine to provide different behavior.
1863 QualType BaseType,
1864 SourceLocation OperatorLoc,
1867 SourceRange QualifierRange,
1871 CXXScopeSpec SS;
1879 }
1881 /// \brief Build a new noexcept expression.
1882 ///
1883 /// By default, performs semantic analysis to build the new expression.
1884 /// Subclasses may override this routine to provide different behavior.
1887 }
1889 /// \brief Build a new Objective-C @encode expression.
1890 ///
1891 /// By default, performs semantic analysis to build the new expression.
1892 /// Subclasses may override this routine to provide different behavior.
1895 SourceLocation RParenLoc) {
1897 RParenLoc));
1898 }
1900 /// \brief Build a new Objective-C class message.
1902 Selector Sel,
1903 SourceLocation SelectorLoc,
1905 SourceLocation LBracLoc,
1906 MultiExprArg Args,
1907 SourceLocation RBracLoc) {
1913 }
1915 /// \brief Build a new Objective-C instance message.
1917 Selector Sel,
1918 SourceLocation SelectorLoc,
1920 SourceLocation LBracLoc,
1921 MultiExprArg Args,
1922 SourceLocation RBracLoc) {
1928 }
1930 /// \brief Build a new Objective-C ivar reference expression.
1931 ///
1932 /// By default, performs semantic analysis to build the new expression.
1933 /// Subclasses may override this routine to provide different behavior.
1935 SourceLocation IvarLoc,
1937 // FIXME: We lose track of the IsFreeIvar bit.
1938 CXXScopeSpec SS;
1955 R,
1957 }
1959 /// \brief Build a new Objective-C property reference expression.
1960 ///
1961 /// By default, performs semantic analysis to build the new expression.
1962 /// Subclasses may override this routine to provide different behavior.
1965 SourceLocation PropertyLoc) {
1966 CXXScopeSpec SS;
1982 SS,
1984 R,
1986 }
1988 /// \brief Build a new Objective-C property reference expression.
1989 ///
1990 /// By default, performs semantic analysis to build the new expression.
1991 /// Subclasses may override this routine to provide different behavior.
1995 SourceLocation PropertyLoc) {
1996 // Since these expressions can only be value-dependent, we do not
1997 // need to perform semantic analysis again.
2002 }
2004 /// \brief Build a new Objective-C "isa" expression.
2005 ///
2006 /// By default, performs semantic analysis to build the new expression.
2007 /// Subclasses may override this routine to provide different behavior.
2010 CXXScopeSpec SS;
2026 R,
2028 }
2030 /// \brief Build a new shuffle vector expression.
2031 ///
2032 /// By default, performs semantic analysis to build the new expression.
2033 /// Subclasses may override this routine to provide different behavior.
2035 MultiExprArg SubExprs,
2036 SourceLocation RParenLoc) {
2037 // Find the declaration for __builtin_shufflevector
2044 // Build a reference to the __builtin_shufflevector builtin
2046 Expr *Callee
2051 // Build the CallExpr
2058 RParenLoc);
2061 // Type-check the __builtin_shufflevector expression.
2068 }
2070 /// \brief Build a new template argument pack expansion.
2071 ///
2072 /// By default, performs semantic analysis to build a new pack expansion
2073 /// for a template argument. Subclasses may override this routine to provide
2074 /// different behavior.
2076 SourceLocation EllipsisLoc) {
2091 EllipsisLoc))
2093 Expansion);
2095 }
2098 }
2102 QualType ObjectType,
2107 QualType ObjectType,
2110 };
2120 // Transform individual statement nodes
2121 #define STMT(Node, Parent) \
2122 case Stmt::Node##Class: return getDerived().Transform##Node(cast<Node>(S));
2123 #define EXPR(Node, Parent)
2126 // Transform expressions by calling TransformExpr.
2127 #define STMT(Node, Parent)
2128 #define ABSTRACT_STMT(Stmt)
2129 #define EXPR(Node, Parent) case Stmt::Node##Class:
2131 {
2137 }
2138 }
2141 }
2151 #define STMT(Node, Parent) case Stmt::Node##Class: break;
2152 #define ABSTRACT_STMT(Stmt)
2153 #define EXPR(Node, Parent) \
2154 case Stmt::Node##Class: return getDerived().Transform##Node(cast<Node>(E));
2156 }
2159 }
2162 NestedNameSpecifier *
2164 SourceRange Range,
2165 QualType ObjectType,
2169 // Transform the prefix of this nested name specifier.
2172 ObjectType,
2173 FirstQualifierInScope);
2176 }
2181 // The object type and qualifier-in-scope really apply to the
2182 // leftmost entity.
2185 }
2195 ObjectType,
2196 FirstQualifierInScope);
2199 NamespaceDecl *NS
2209 }
2212 // There is no meaningful transformation that one could perform on the
2213 // global scope.
2220 ObjectType,
2221 FirstQualifierInScope,
2222 Prefix);
2233 T);
2234 }
2235 }
2237 // Required to silence a GCC warning
2239 }
2242 DeclarationNameInfo
2263 CanQualType NewCanTy;
2269 }
2277 }
2279 DeclarationName NewName
2281 NewCanTy);
2286 }
2287 }
2291 }
2294 TemplateName
2296 QualType ObjectType,
2301 NestedNameSpecifier *NNS
2304 ObjectType,
2305 FirstQualifierInScope);
2310 TemplateDecl *TransTemplate
2321 TransTemplate);
2322 }
2324 // These should be getting filtered out before they make it into the AST.
2326 }
2333 ObjectType,
2334 FirstQualifierInScope);
2337 // These apply to the scope specifier, not the template.
2340 }
2348 // FIXME: Bad range
2352 ObjectType,
2353 FirstQualifierInScope);
2354 }
2357 ObjectType);
2358 }
2361 TemplateDecl *TransTemplate
2371 }
2373 // These should be getting filtered out before they reach the AST.
2376 }
2407 }
2408 }
2431 }
2434 // FIXME: we should never have to transform one of these.
2435 DeclarationName Name;
2448 }
2452 }
2456 TemplateName Template
2465 }
2468 // Template argument expressions are not potentially evaluated.
2475 ExprResult E
2480 }
2489 // FIXME: preserve source information here when we start
2490 // caring about parameter packs.
2492 TemplateArgumentLoc InputArg;
2493 TemplateArgumentLoc OutputArg;
2499 }
2501 TemplateArgument *TransformedArgsPtr
2504 TransformedArgsPtr);
2509 }
2510 }
2512 // Work around bogus GCC warning
2514 }
2516 /// \brief Iterator adaptor that invents template argument location information
2517 /// for each of the template arguments in its underlying iterator.
2521 InputIterator Iter;
2527 difference_type;
2531 TemplateArgumentLoc Arg;
2537 };
2542 InputIterator Iter)
2548 }
2554 }
2557 TemplateArgumentLoc Result;
2560 }
2567 }
2572 }
2573 };
2578 InputIterator Last,
2581 TemplateArgumentLoc Out;
2585 // Unpack argument packs, which we translate them into separate
2586 // arguments.
2587 // FIXME: We could do much better if we could guarantee that the
2588 // TemplateArgumentLocInfo for the pack expansion would be usable for
2589 // all of the template arguments in the argument pack.
2592 PackLocIterator;
2597 Outputs))
2601 }
2604 // We have a pack expansion, for which we will be substituting into
2605 // the pattern.
2606 SourceLocation Ellipsis;
2607 TemplateArgumentLoc Pattern
2614 // Determine whether the set of unexpanded parameter packs can and should
2615 // be expanded.
2626 // The transform has determined that we should perform a simple
2627 // transformation on the pack expansion, producing another pack
2628 // expansion.
2629 TemplateArgumentLoc OutPattern;
2640 }
2642 // The transform has determined that we should perform an elementwise
2643 // expansion of the pattern. Do so.
2651 }
2654 }
2656 // The simple case:
2661 }
2665 }
2667 //===----------------------------------------------------------------------===//
2668 // Type transformation
2669 //===----------------------------------------------------------------------===//
2676 // Temporary workaround. All of these transformations should
2677 // eventually turn into transformations on TypeLocs.
2687 }
2694 TypeLocBuilder TLB;
2704 }
2707 QualType
2710 #define ABSTRACT_TYPELOC(CLASS, PARENT)
2711 #define TYPELOC(CLASS, PARENT) \
2712 case TypeLoc::CLASS: \
2713 return getDerived().Transform##CLASS##Type(TLB, cast<CLASS##TypeLoc>(T));
2715 }
2719 }
2721 /// FIXME: By default, this routine adds type qualifiers only to types
2722 /// that can have qualifiers, and silently suppresses those qualifiers
2723 /// that are not permitted (e.g., qualifiers on reference or function
2724 /// types). This is the right thing for template instantiation, but
2725 /// probably not for other clients.
2727 QualType
2729 QualifiedTypeLoc T) {
2736 // Silently suppress qualifiers if the result type can't be qualified.
2737 // FIXME: this is the right thing for template instantiation, but
2738 // probably not for other clients.
2745 // No location information to preserve.
2746 }
2749 }
2751 /// \brief Transforms a type that was written in a scope specifier,
2752 /// given an object type, the results of unqualified lookup, and
2753 /// an already-instantiated prefix.
2754 ///
2755 /// The object type is provided iff the scope specifier qualifies the
2756 /// member of a dependent member-access expression. The prefix is
2757 /// provided iff the the scope specifier in which this appears has a
2758 /// prefix.
2759 ///
2760 /// This is private to TreeTransform.
2762 QualType
2764 QualType ObjectType,
2777 }
2780 TypeSourceInfo *
2782 QualType ObjectType,
2785 // TODO: in some cases, we might be some verification to do here.
2793 TypeLocBuilder TLB;
2794 QualType Result;
2797 TemplateSpecializationTypeLoc TL
2800 TemplateName Template =
2808 DependentTemplateSpecializationTypeLoc TL
2814 // Nothing special needs to be done for these.
2816 }
2820 }
2827 }
2831 BuiltinTypeLoc T) {
2837 }
2841 ComplexTypeLoc T) {
2842 // FIXME: recurse?
2844 }
2848 PointerTypeLoc TL) {
2849 QualType PointeeType
2856 // A dependent pointer type 'T *' has is being transformed such
2857 // that an Objective-C class type is being replaced for 'T'. The
2858 // resulting pointer type is an ObjCObjectPointerType, not a
2859 // PointerType.
2865 }
2872 }
2877 }
2880 QualType
2882 BlockPointerTypeLoc TL) {
2883 QualType PointeeType
2895 }
2900 }
2902 /// Transforms a reference type. Note that somewhat paradoxically we
2903 /// don't care whether the type itself is an l-value type or an r-value
2904 /// type; we only care if the type was *written* as an l-value type
2905 /// or an r-value type.
2907 QualType
2909 ReferenceTypeLoc TL) {
2912 // Note that this works with the pointee-as-written.
2925 }
2927 // r-value references can be rebuilt as l-value references.
2928 ReferenceTypeLoc NewTL;
2931 else
2936 }
2939 QualType
2941 LValueReferenceTypeLoc TL) {
2943 }
2946 QualType
2948 RValueReferenceTypeLoc TL) {
2950 }
2953 QualType
2955 MemberPointerTypeLoc TL) {
2962 // TODO: preserve source information for this.
2963 QualType ClassType
2976 }
2982 }
2985 QualType
2987 ConstantArrayTypeLoc TL) {
3003 }
3013 }
3017 }
3022 IncompleteArrayTypeLoc TL) {
3037 }
3045 }
3048 QualType
3050 VariableArrayTypeLoc TL) {
3056 // Array bounds are not potentially evaluated contexts
3059 ExprResult SizeResult
3072 Size,
3077 }
3085 }
3088 QualType
3090 DependentSizedArrayTypeLoc TL) {
3096 // Array bounds are not potentially evaluated contexts
3099 ExprResult SizeResult
3112 Size,
3117 }
3120 // We might have any sort of array type now, but fortunately they
3121 // all have the same location layout.
3128 }
3133 DependentSizedExtVectorTypeLoc TL) {
3136 // FIXME: ext vector locs should be nested
3141 // Vector sizes are not potentially evaluated contexts
3157 }
3159 // Result might be dependent or not.
3161 DependentSizedExtVectorTypeLoc NewTL
3167 }
3170 }
3174 VectorTypeLoc TL) {
3187 }
3193 }
3197 ExtVectorTypeLoc TL) {
3211 }
3217 }
3220 ParmVarDecl *
3229 else
3235 NewDI,
3239 }
3251 QualType NewType;
3260 // Deal with the possibility that we don't have a parameter
3261 // declaration for this parameter.
3269 }
3273 }
3276 }
3279 QualType
3281 FunctionProtoTypeLoc TL) {
3282 // Transform the parameters and return type.
3283 //
3284 // We instantiate in source order, with the return type first followed by
3285 // the parameters, because users tend to expect this (even if they shouldn't
3286 // rely on it!).
3287 //
3288 // When the function has a trailing return type, we instantiate the
3289 // parameters before the return type, since the return type can then refer
3290 // to the parameters themselves (via decltype, sizeof, etc.).
3291 //
3296 QualType ResultType;
3305 }
3313 }
3327 }
3337 }
3342 FunctionNoProtoTypeLoc TL) {
3359 }
3363 UnresolvedUsingTypeLoc TL) {
3374 }
3376 // We might get an arbitrary type spec type back. We should at
3377 // least always get a type spec type, though.
3382 }
3386 TypedefTypeLoc TL) {
3388 TypedefDecl *Typedef
3400 }
3406 }
3410 TypeOfExprTypeLoc TL) {
3411 // typeof expressions are not potentially evaluated contexts
3424 }
3433 }
3437 TypeOfTypeLoc TL) {
3448 }
3457 }
3461 DecltypeTypeLoc TL) {
3464 // decltype expressions are not potentially evaluated contexts
3477 }
3484 }
3488 RecordTypeLoc TL) {
3490 RecordDecl *Record
3502 }
3508 }
3512 EnumTypeLoc TL) {
3514 EnumDecl *Enum
3526 }
3532 }
3537 InjectedClassNameTypeLoc TL) {
3545 }
3551 TemplateTypeParmTypeLoc TL) {
3553 }
3558 SubstTemplateTypeParmTypeLoc TL) {
3560 }
3565 TemplateSpecializationTypeLoc TL) {
3568 TemplateName Template
3574 }
3577 /// \brief Simple iterator that traverses the template arguments in a
3578 /// container that provides a \c getArgLoc() member function.
3579 ///
3580 /// This iterator is intended to be used with the iterator form of
3581 /// \c TreeTransform<Derived>::TransformTemplateArguments().
3594 TemplateArgumentLoc Arg;
3601 }
3602 };
3614 }
3620 }
3624 }
3628 }
3633 }
3638 }
3639 };
3640 }
3646 TemplateSpecializationTypeLoc TL,
3647 TemplateName Template) {
3648 TemplateArgumentListInfo NewTemplateArgs;
3652 ArgIterator;
3655 NewTemplateArgs))
3658 // FIXME: maybe don't rebuild if all the template arguments are the same.
3660 QualType Result =
3663 NewTemplateArgs);
3666 TemplateSpecializationTypeLoc NewTL
3673 }
3676 }
3679 QualType
3681 ElaboratedTypeLoc TL) {
3685 // NOTE: the qualifier in an ElaboratedType is optional.
3691 }
3705 }
3712 }
3715 QualType
3717 ParenTypeLoc TL) {
3728 }
3734 }
3738 DependentNameTypeLoc TL) {
3741 NestedNameSpecifier *NNS
3747 QualType Result
3768 }
3770 }
3775 DependentTemplateSpecializationTypeLoc TL) {
3778 NestedNameSpecifier *NNS
3786 }
3791 DependentTemplateSpecializationTypeLoc TL,
3795 TemplateArgumentListInfo NewTemplateArgs;
3803 NewTemplateArgs))
3806 QualType Result
3808 NNS,
3812 NewTemplateArgs);
3819 // Copy information relevant to the template specialization.
3820 TemplateSpecializationTypeLoc NamedTL
3827 // Copy information relevant to the elaborated type.
3834 }
3836 }
3840 PackExpansionTypeLoc TL) {
3841 // FIXME: Implement!
3845 }
3848 QualType
3850 ObjCInterfaceTypeLoc TL) {
3851 // ObjCInterfaceType is never dependent.
3854 }
3857 QualType
3859 ObjCObjectTypeLoc TL) {
3860 // ObjCObjectType is never dependent.
3863 }
3866 QualType
3868 ObjCObjectPointerTypeLoc TL) {
3869 // ObjCObjectPointerType is never dependent.
3872 }
3874 //===----------------------------------------------------------------------===//
3875 // Statement transformation
3876 //===----------------------------------------------------------------------===//
3878 StmtResult
3881 }
3884 StmtResult
3887 }
3890 StmtResult
3900 // Immediately fail if this was a DeclStmt, since it's very
3901 // likely that this will cause problems for future statements.
3905 // Otherwise, just keep processing substatements and fail later.
3908 }
3912 }
3924 IsStmtExpr);
3925 }
3928 StmtResult
3931 {
3932 // The case value expressions are not potentially evaluated.
3935 // Transform the left-hand case value.
3940 // Transform the right-hand case value (for the GNU case-range extension).
3944 }
3946 // Build the case statement.
3947 // Case statements are always rebuilt so that they will attached to their
3948 // transformed switch statement.
3957 // Transform the statement following the case
3962 // Attach the body to the case statement
3964 }
3967 StmtResult
3969 // Transform the statement following the default case
3974 // Default statements are always rebuilt
3977 }
3980 StmtResult
3986 // FIXME: Pass the real colon location in.
3990 }
3993 StmtResult
3995 // Transform the condition
3996 ExprResult Cond;
3999 ConditionVar
4012 // Convert the condition to a boolean value.
4020 }
4021 }
4027 // Transform the "then" branch.
4032 // Transform the "else" branch.
4047 }
4050 StmtResult
4052 // Transform the condition.
4053 ExprResult Cond;
4056 ConditionVar
4068 }
4070 // Rebuild the switch statement.
4071 StmtResult Switch
4073 ConditionVar);
4077 // Transform the body of the switch statement.
4082 // Complete the switch statement.
4085 }
4088 StmtResult
4090 // Transform the condition
4091 ExprResult Cond;
4094 ConditionVar
4108 // Convert the condition to a boolean value.
4114 }
4115 }
4121 // Transform the body
4134 }
4137 StmtResult
4139 // Transform the body
4144 // Transform the condition
4157 }
4160 StmtResult
4162 // Transform the initialization statement
4167 // Transform the condition
4168 ExprResult Cond;
4171 ConditionVar
4185 // Convert the condition to a boolean value.
4192 }
4193 }
4199 // Transform the increment
4208 // Transform the body
4223 }
4226 StmtResult
4228 // Goto statements must always be rebuilt, to resolve the label.
4231 }
4234 StmtResult
4246 }
4249 StmtResult
4252 }
4255 StmtResult
4258 }
4261 StmtResult
4267 // FIXME: We always rebuild the return statement because there is no way
4268 // to tell whether the return type of the function has changed.
4270 }
4273 StmtResult
4288 }
4295 }
4298 StmtResult
4302 }
4305 StmtResult
4312 ExprResult AsmString;
4317 // Go through the outputs.
4321 // No need to transform the constraint literal.
4324 // Transform the output expr.
4333 }
4335 // Go through the inputs.
4339 // No need to transform the constraint literal.
4342 // Transform the input expr.
4351 }
4356 // Go through the clobbers.
4360 // No need to transform the asm string literal.
4375 }
4379 StmtResult
4381 // Transform the body of the @try.
4386 // Transform the @catch statements (if present).
4396 }
4398 // Transform the @finally statement (if present).
4399 StmtResult Finally;
4404 }
4406 // If nothing changed, just retain this statement.
4413 // Build a new statement.
4416 }
4419 StmtResult
4421 // Transform the @catch parameter, if there is one.
4429 }
4431 QualType T;
4438 }
4443 }
4452 }
4455 StmtResult
4457 // Transform the body.
4462 // If nothing changed, just retain this statement.
4467 // Build a new statement.
4470 }
4473 StmtResult
4475 ExprResult Operand;
4480 }
4487 }
4490 StmtResult
4493 // Transform the object we are locking.
4498 // Transform the body.
4503 // If nothing change, just retain the current statement.
4509 // Build a new statement.
4512 }
4515 StmtResult
4518 // Transform the element statement.
4523 // Transform the collection expression.
4528 // Transform the body.
4533 // If nothing changed, just retain this statement.
4540 // Build a new statement.
4547 }
4551 StmtResult
4553 // Transform the exception declaration, if any.
4567 }
4569 // Transform the actual exception handler.
4580 Var,
4582 }
4585 StmtResult
4587 // Transform the try block itself.
4588 StmtResult TryBlock
4593 // Transform the handlers.
4597 StmtResult Handler
4604 }
4613 }
4615 //===----------------------------------------------------------------------===//
4616 // Expression transformation
4617 //===----------------------------------------------------------------------===//
4619 ExprResult
4622 }
4625 ExprResult
4633 }
4635 ValueDecl *ND
4646 }
4654 // Mark it referenced in the new context regardless.
4655 // FIXME: this is a bit instantiation-specific.
4659 }
4668 TransArgs))
4670 }
4674 }
4677 ExprResult
4680 }
4683 ExprResult
4686 }
4689 ExprResult
4692 }
4695 ExprResult
4698 }
4701 ExprResult
4704 }
4707 ExprResult
4718 }
4721 ExprResult
4733 }
4736 ExprResult
4738 // Transform the type.
4743 // Transform all of the components into components similar to what the
4744 // parser uses.
4745 // FIXME: It would be slightly more efficient in the non-dependent case to
4746 // just map FieldDecls, rather than requiring the rebuilder to look for
4747 // the fields again. However, __builtin_offsetof is rare enough in
4748 // template code that we don't care.
4755 Component Comp;
4770 }
4782 // Will be recomputed during the rebuild.
4784 }
4787 }
4789 // If nothing changed, retain the existing expression.
4795 // Build a new offsetof expression.
4799 }
4802 ExprResult
4807 }
4810 ExprResult
4825 }
4827 ExprResult SubExpr;
4828 {
4829 // C++0x [expr.sizeof]p1:
4830 // The operand is either an expression, which is an unevaluated operand
4831 // [...]
4840 }
4845 }
4848 ExprResult
4868 }
4871 ExprResult
4873 // Transform the callee.
4878 // Transform arguments.
4888 }
4895 // FIXME: Wrong source location information for the '('.
4896 SourceLocation FakeLParenLoc
4901 }
4904 ExprResult
4912 Qualifier
4917 }
4919 ValueDecl *Member
4933 }
4942 // Mark it referenced in the new context regardless.
4943 // FIXME: this is a bit instantiation-specific.
4946 }
4948 TemplateArgumentListInfo TransArgs;
4954 TransArgs))
4956 }
4958 // FIXME: Bogus source location for the operator
4959 SourceLocation FakeOperatorLoc
4962 // FIXME: to do this check properly, we will need to preserve the
4963 // first-qualifier-in-scope here, just in case we had a dependent
4964 // base (and therefore couldn't do the check) and a
4965 // nested-name-qualifier (and therefore could do the lookup).
4970 Qualifier,
4973 Member,
4974 FoundDecl,
4977 FirstQualifierInScope);
4978 }
4981 ExprResult
4998 }
5001 ExprResult
5005 }
5008 ExprResult
5033 }
5036 ExprResult
5038 // Implicit casts are eliminated during transformation, since they
5039 // will be recomputed by semantic analysis after transformation.
5041 }
5044 ExprResult
5050 ExprResult SubExpr
5061 Type,
5064 }
5067 ExprResult
5083 // Note: the expression type doesn't necessarily match the
5084 // type-as-written, but that's okay, because it should always be
5085 // derivable from the initializer.
5090 }
5093 ExprResult
5103 // FIXME: Bad source location
5104 SourceLocation FakeOperatorLoc
5109 }
5112 ExprResult
5124 }
5131 }
5134 ExprResult
5136 Designation Desig;
5138 // transform the initializer value
5143 // transform the designators.
5154 }
5167 }
5170 ExprResult Start
5189 }
5199 }
5202 ExprResult
5207 // FIXME: Will we ever have proper type location here? Will we actually
5208 // need to transform the type?
5218 }
5221 ExprResult
5238 }
5241 ExprResult
5252 }
5257 }
5259 /// \brief Transform an address-of-label expression.
5260 ///
5261 /// By default, the transformation of an address-of-label expression always
5262 /// rebuilds the expression, so that the label identifier can be resolved to
5263 /// the corresponding label statement by semantic analysis.
5265 ExprResult
5269 }
5272 ExprResult
5274 StmtResult SubStmt
5286 }
5289 ExprResult
5312 }
5315 ExprResult
5318 }
5321 ExprResult
5332 // This is a call to an object's operator().
5335 // Transform the object itself.
5340 // FIXME: Poor location information
5341 SourceLocation FakeLParenLoc
5345 // Transform the call arguments.
5356 }
5361 }
5363 #define OVERLOADED_OPERATOR(Name,Spelling,Token,Unary,Binary,MemberOnly) \
5364 case OO_##Name:
5365 #define OVERLOADED_OPERATOR_MULTI(Name,Spelling,Unary,Binary,MemberOnly)
5368 // Handled below.
5379 }
5389 ExprResult Second;
5394 }
5407 }
5410 ExprResult
5413 }
5416 ExprResult
5422 ExprResult SubExpr
5432 // FIXME: Poor source location information here.
5433 SourceLocation FakeLAngleLoc
5436 SourceLocation FakeRParenLoc
5441 FakeLAngleLoc,
5442 Type,
5443 FakeRAngleLoc,
5444 FakeRAngleLoc,
5446 FakeRParenLoc);
5447 }
5450 ExprResult
5453 }
5456 ExprResult
5459 }
5462 ExprResult
5466 }
5469 ExprResult
5472 }
5475 ExprResult
5482 ExprResult SubExpr
5496 }
5499 ExprResult
5502 TypeSourceInfo *TInfo
5513 TInfo,
5515 }
5517 // We don't know whether the expression is potentially evaluated until
5518 // after we perform semantic analysis, so the expression is potentially
5519 // potentially evaluated.
5535 }
5538 ExprResult
5541 TypeSourceInfo *TInfo
5552 TInfo,
5554 }
5556 // We don't know whether the expression is potentially evaluated until
5557 // after we perform semantic analysis, so the expression is potentially
5558 // potentially evaluated.
5573 }
5576 ExprResult
5579 }
5582 ExprResult
5586 }
5589 ExprResult
5599 }
5602 ExprResult
5613 }
5616 ExprResult
5618 ParmVarDecl *Param
5629 }
5632 ExprResult
5646 }
5649 ExprResult
5651 // Transform the type that we're allocating
5652 TypeSourceInfo *AllocTypeInfo
5657 // Transform the size of the array we're allocating (if any).
5662 // Transform the placement arguments (if any).
5669 }
5677 }
5679 // transform the constructor arguments (if any).
5685 }
5693 }
5695 // Transform constructor, new operator, and delete operator.
5703 }
5712 }
5721 }
5730 // Mark any declarations we need as referenced.
5731 // FIXME: instantiation-specific.
5739 }
5743 // If no array size was specified, but the new expression was
5744 // instantiated with an array type (e.g., "new T" where T is
5745 // instantiated with "int[4]"), extract the outer bound from the
5746 // array type as our array size. We do this with constant and
5747 // dependently-sized array types.
5750 // Do nothing
5753 ArraySize
5764 }
5765 }
5766 }
5774 AllocType,
5775 AllocTypeInfo,
5780 }
5783 ExprResult
5789 // Transform the delete operator, if known.
5797 }
5802 // Mark any declarations we need as referenced.
5803 // FIXME: instantiation-specific.
5814 }
5815 }
5818 }
5824 }
5827 ExprResult
5834 ParsedType ObjectTypePtr;
5839 ObjectTypePtr,
5840 MayBePseudoDestructor);
5847 Qualifier
5850 ObjectType);
5853 }
5855 PseudoDestructorTypeStorage Destroyed;
5857 TypeSourceInfo *DestroyedTypeInfo
5864 // We aren't likely to be able to resolve the identifier down to a type
5865 // now anyway, so just retain the identifier.
5869 // Look for a destructor known with the given name.
5870 CXXScopeSpec SS;
5874 }
5885 Destroyed
5888 }
5895 }
5900 Qualifier,
5902 ScopeTypeInfo,
5905 Destroyed);
5906 }
5909 ExprResult
5917 // Transform all the decls.
5924 // Silently ignore these if a UsingShadowDecl instantiated to nothing.
5925 // This can happen because of dependent hiding.
5928 else
5930 }
5932 // Expand using declarations.
5939 }
5942 }
5944 // Resolve a kind, but don't do any further analysis. If it's
5945 // ambiguous, the callee needs to deal with it.
5948 // Rebuild the nested-name qualifier, if present.
5949 CXXScopeSpec SS;
5959 }
5962 CXXRecordDecl *NamingClass
5970 }
5972 // If we have no template arguments, it's a normal declaration name.
5976 // If we have template arguments, rebuild them, then rebuild the
5977 // templateid expression.
5981 TransArgs))
5985 TransArgs);
5986 }
5989 ExprResult
6001 T,
6003 }
6006 ExprResult
6024 }
6027 ExprResult
6030 NestedNameSpecifier *NNS
6036 // TODO: If this is a conversion-function-id, verify that the
6037 // destination type name (if present) resolves the same way after
6038 // instantiation as it did in the local scope.
6040 DeclarationNameInfo NameInfo
6048 // Note: it is sufficient to compare the Name component of NameInfo:
6049 // if name has not changed, DNLoc has not changed either.
6055 NameInfo,
6057 }
6062 TransArgs))
6067 NameInfo,
6069 }
6072 ExprResult
6074 // CXXConstructExprs are always implicit, so when we have a
6075 // 1-argument construction we just transform that argument.
6086 CXXConstructorDecl *Constructor
6101 }
6109 }
6115 // Mark the constructor as referenced.
6116 // FIXME: Instantiation-specific
6119 }
6127 }
6129 /// \brief Transform a C++ temporary-binding expression.
6130 ///
6131 /// Since CXXBindTemporaryExpr nodes are implicitly generated, we just
6132 /// transform the subexpression and return that.
6134 ExprResult
6137 }
6139 /// \brief Transform a C++ expression that contains cleanups that should
6140 /// be run after the expression is evaluated.
6141 ///
6142 /// Since ExprWithCleanups nodes are implicitly generated, we
6143 /// just transform the subexpression and return that.
6145 ExprResult
6148 }
6151 ExprResult
6158 CXXConstructorDecl *Constructor
6174 }
6182 }
6188 // FIXME: Instantiation-specific
6191 }
6197 }
6200 ExprResult
6218 }
6225 // FIXME: we're faking the locations of the commas
6230 }
6233 ExprResult
6236 // Transform the base of the expression.
6239 QualType BaseType;
6240 QualType ObjectType;
6247 // Start the member reference and compute the object's type.
6248 ParsedType ObjectTy;
6253 ObjectTy,
6254 MayBePseudoDestructor);
6264 }
6266 // Transform the first part of the nested-name-specifier that qualifies
6267 // the member name.
6268 NamedDecl *FirstQualifierInScope
6277 ObjectType,
6278 FirstQualifierInScope);
6281 }
6283 // TODO: If this is a conversion-function-id, verify that the
6284 // destination type name (if present) resolves the same way after
6285 // instantiation as it did in the local scope.
6287 DeclarationNameInfo NameInfo
6293 // This is a reference to a member without an explicitly-specified
6294 // template argument list. Optimize for this common case.
6304 BaseType,
6307 Qualifier,
6309 FirstQualifierInScope,
6310 NameInfo,
6312 }
6317 TransArgs))
6321 BaseType,
6324 Qualifier,
6326 FirstQualifierInScope,
6327 NameInfo,
6329 }
6332 ExprResult
6334 // Transform the base of the expression.
6336 QualType BaseType;
6344 }
6348 Qualifier
6353 }
6358 // Transform all the decls.
6365 // Silently ignore these if a UsingShadowDecl instantiated to nothing.
6366 // This can happen because of dependent hiding.
6369 else
6371 }
6373 // Expand using declarations.
6380 }
6383 }
6387 // Determine the naming class.
6389 CXXRecordDecl *NamingClass
6397 }
6399 TemplateArgumentListInfo TransArgs;
6405 TransArgs))
6407 }
6409 // FIXME: to do this check properly, we will need to preserve the
6410 // first-qualifier-in-scope here, just in case we had a dependent
6411 // base (and therefore couldn't do the check) and a
6412 // nested-name-qualifier (and therefore could do the lookup).
6416 BaseType,
6419 Qualifier,
6421 FirstQualifierInScope,
6422 R,
6425 }
6428 ExprResult
6438 }
6441 ExprResult
6444 }
6447 ExprResult
6449 TypeSourceInfo *EncodedTypeInfo
6459 EncodedTypeInfo,
6461 }
6464 ExprResult
6466 // Transform arguments.
6476 }
6479 // Class message: transform the receiver type.
6480 TypeSourceInfo *ReceiverTypeInfo
6485 // If nothing changed, just retain the existing message send.
6490 // Build a new class message send.
6498 }
6500 // Instance message: transform the receiver
6503 ExprResult Receiver
6508 // If nothing changed, just retain the existing message send.
6513 // Build a new instance message send.
6521 }
6524 ExprResult
6527 }
6530 ExprResult
6533 }
6536 ExprResult
6538 // Transform the base expression.
6543 // We don't need to transform the ivar; it will never change.
6545 // If nothing changed, just retain the existing expression.
6553 }
6556 ExprResult
6558 // 'super' and types never change. Property never changes. Just
6559 // retain the existing expression.
6563 // Transform the base expression.
6568 // We don't need to transform the property; it will never change.
6570 // If nothing changed, just retain the existing expression.
6585 }
6588 ExprResult
6590 // Transform the base expression.
6595 // If nothing changed, just retain the existing expression.
6602 }
6605 ExprResult
6616 }
6625 }
6628 ExprResult
6638 // Parameter substitution.
6647 }
6656 }
6658 // Transform the body
6662 // Set the parameters on the block decl.
6676 }
6679 ExprResult
6683 ValueDecl *ND
6691 // Mark it referenced in the new context regardless.
6692 // FIXME: this is a bit instantiation-specific.
6696 }
6701 }
6703 //===----------------------------------------------------------------------===//
6704 // Type reconstruction
6705 //===----------------------------------------------------------------------===//
6709 SourceLocation Star) {
6712 }
6716 SourceLocation Star) {
6719 }
6722 QualType
6725 SourceLocation Sigil) {
6728 }
6731 QualType
6733 QualType ClassType,
6734 SourceLocation Sigil) {
6737 }
6740 QualType
6746 SourceRange BracketsRange) {
6752 QualType Types[] = {
6756 };
6758 QualType SizeType;
6763 }
6770 }
6773 QualType
6778 SourceRange BracketsRange) {
6781 }
6784 QualType
6788 SourceRange BracketsRange) {
6791 }
6794 QualType
6799 SourceRange BracketsRange) {
6801 SizeExpr,
6803 }
6806 QualType
6811 SourceRange BracketsRange) {
6813 SizeExpr,
6815 }
6821 // FIXME: semantic checking!
6823 }
6828 SourceLocation AttributeLoc) {
6831 IntegerLiteral *VectorSize
6833 AttributeLoc);
6835 }
6838 QualType
6841 SourceLocation AttributeLoc) {
6843 }
6853 Quals,
6856 Info);
6857 }
6862 }
6869 // FIXME: Doesn't account for ObjCInterfaceDecl!
6876 // A valid resolved using typename decl points to exactly one type decl.
6884 }
6887 }
6891 SourceLocation Loc) {
6893 }
6898 }
6902 SourceLocation Loc) {
6904 }
6908 TemplateName Template,
6909 SourceLocation TemplateNameLoc,
6912 }
6915 NestedNameSpecifier *
6917 SourceRange Range,
6919 QualType ObjectType,
6921 CXXScopeSpec SS;
6922 // FIXME: The source location information is all wrong.
6928 ObjectType,
6929 FirstQualifierInScope,
6931 }
6934 NestedNameSpecifier *
6936 SourceRange Range,
6939 }
6942 NestedNameSpecifier *
6944 SourceRange Range,
6946 QualType T) {
6952 }
6956 }
6959 TemplateName
6964 Template);
6965 }
6968 TemplateName
6970 SourceRange QualifierRange,
6972 QualType ObjectType,
6974 CXXScopeSpec SS;
6977 UnqualifiedId Name;
6982 SS,
6983 Name,
6986 Template);
6988 }
6991 TemplateName
6993 OverloadedOperatorKind Operator,
6994 QualType ObjectType) {
6995 CXXScopeSpec SS;
6998 UnqualifiedId Name;
7005 SS,
7006 Name,
7009 Template);
7011 }
7014 ExprResult
7016 SourceLocation OpLoc,
7023 // Determine whether this should be a builtin operation.
7031 // -> is never a builtin operation.
7035 // The argument is not of overloadable type, so try to create a
7036 // built-in unary operation.
7037 UnaryOperatorKind Opc
7041 }
7045 // Neither of the arguments is an overloadable type, so try to
7046 // create a built-in binary operation.
7048 ExprResult Result
7054 }
7055 }
7057 // Compute the transformed set of functions (and function templates) to be
7058 // used during overload resolution.
7064 // FIXME: Do we have to check
7065 // IsAcceptableNonMemberOperatorCandidate for each of these?
7069 }
7071 // Add any functions found via argument-dependent lookup.
7075 // Create the overloaded operator invocation for unary operators.
7077 UnaryOperatorKind Opc
7080 }
7084 OpLoc,
7085 First,
7086 Second);
7088 // Create the overloaded operator invocation for binary operators.
7090 ExprResult Result
7096 }
7099 ExprResult
7101 SourceLocation OperatorLoc,
7104 SourceRange QualifierRange,
7106 SourceLocation CCLoc,
7107 SourceLocation TildeLoc,
7108 PseudoDestructorTypeStorage Destroyed) {
7109 CXXScopeSpec SS;
7113 }
7121 // This pseudo-destructor expression is still a pseudo-destructor.
7125 Destroyed,
7127 }
7135 // FIXME: the ScopeType should be tacked onto SS.
7140 NameInfo,
7142 }