1 | //===- ExprConcepts.h - C++2a Concepts expressions --------------*- 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 | // |
9 | /// \file |
10 | /// Defines Expressions and AST nodes for C++2a concepts. |
11 | // |
12 | //===----------------------------------------------------------------------===// |
13 | |
14 | #ifndef LLVM_CLANG_AST_EXPRCONCEPTS_H |
15 | #define LLVM_CLANG_AST_EXPRCONCEPTS_H |
16 | |
17 | #include "clang/AST/ASTContext.h" |
18 | #include "clang/AST/ASTConcept.h" |
19 | #include "clang/AST/Decl.h" |
20 | #include "clang/AST/DeclarationName.h" |
21 | #include "clang/AST/DeclTemplate.h" |
22 | #include "clang/AST/Expr.h" |
23 | #include "clang/AST/NestedNameSpecifier.h" |
24 | #include "clang/AST/TemplateBase.h" |
25 | #include "clang/AST/Type.h" |
26 | #include "clang/Basic/SourceLocation.h" |
27 | #include "llvm/Support/TrailingObjects.h" |
28 | #include <utility> |
29 | #include <string> |
30 | |
31 | namespace clang { |
32 | class ASTStmtReader; |
33 | class ASTStmtWriter; |
34 | |
35 | /// \brief Represents the specialization of a concept - evaluates to a prvalue |
36 | /// of type bool. |
37 | /// |
38 | /// According to C++2a [expr.prim.id]p3 an id-expression that denotes the |
39 | /// specialization of a concept results in a prvalue of type bool. |
40 | class ConceptSpecializationExpr final : public Expr, public ConceptReference, |
41 | private llvm::TrailingObjects<ConceptSpecializationExpr, |
42 | TemplateArgument> { |
43 | friend class ASTStmtReader; |
44 | friend TrailingObjects; |
45 | public: |
46 | using SubstitutionDiagnostic = std::pair<SourceLocation, std::string>; |
47 | |
48 | protected: |
49 | /// \brief The number of template arguments in the tail-allocated list of |
50 | /// converted template arguments. |
51 | unsigned NumTemplateArgs; |
52 | |
53 | /// \brief Information about the satisfaction of the named concept with the |
54 | /// given arguments. If this expression is value dependent, this is to be |
55 | /// ignored. |
56 | ASTConstraintSatisfaction *Satisfaction; |
57 | |
58 | ConceptSpecializationExpr(const ASTContext &C, NestedNameSpecifierLoc NNS, |
59 | SourceLocation TemplateKWLoc, |
60 | DeclarationNameInfo ConceptNameInfo, |
61 | NamedDecl *FoundDecl, ConceptDecl *NamedConcept, |
62 | const ASTTemplateArgumentListInfo *ArgsAsWritten, |
63 | ArrayRef<TemplateArgument> ConvertedArgs, |
64 | const ConstraintSatisfaction *Satisfaction); |
65 | |
66 | ConceptSpecializationExpr(const ASTContext &C, ConceptDecl *NamedConcept, |
67 | ArrayRef<TemplateArgument> ConvertedArgs, |
68 | const ConstraintSatisfaction *Satisfaction, |
69 | bool Dependent, |
70 | bool ContainsUnexpandedParameterPack); |
71 | |
72 | ConceptSpecializationExpr(EmptyShell Empty, unsigned NumTemplateArgs); |
73 | |
74 | public: |
75 | |
76 | static ConceptSpecializationExpr * |
77 | Create(const ASTContext &C, NestedNameSpecifierLoc NNS, |
78 | SourceLocation TemplateKWLoc, DeclarationNameInfo ConceptNameInfo, |
79 | NamedDecl *FoundDecl, ConceptDecl *NamedConcept, |
80 | const ASTTemplateArgumentListInfo *ArgsAsWritten, |
81 | ArrayRef<TemplateArgument> ConvertedArgs, |
82 | const ConstraintSatisfaction *Satisfaction); |
83 | |
84 | static ConceptSpecializationExpr * |
85 | Create(const ASTContext &C, ConceptDecl *NamedConcept, |
86 | ArrayRef<TemplateArgument> ConvertedArgs, |
87 | const ConstraintSatisfaction *Satisfaction, |
88 | bool Dependent, |
89 | bool ContainsUnexpandedParameterPack); |
90 | |
91 | static ConceptSpecializationExpr * |
92 | Create(ASTContext &C, EmptyShell Empty, unsigned NumTemplateArgs); |
93 | |
94 | ArrayRef<TemplateArgument> getTemplateArguments() const { |
95 | return ArrayRef<TemplateArgument>(getTrailingObjects<TemplateArgument>(), |
96 | NumTemplateArgs); |
97 | } |
98 | |
99 | /// \brief Set new template arguments for this concept specialization. |
100 | void setTemplateArguments(ArrayRef<TemplateArgument> Converted); |
101 | |
102 | /// \brief Whether or not the concept with the given arguments was satisfied |
103 | /// when the expression was created. |
104 | /// The expression must not be dependent. |
105 | bool isSatisfied() const { |
106 | assert(!isValueDependent() |
107 | && "isSatisfied called on a dependent ConceptSpecializationExpr" ); |
108 | return Satisfaction->IsSatisfied; |
109 | } |
110 | |
111 | /// \brief Get elaborated satisfaction info about the template arguments' |
112 | /// satisfaction of the named concept. |
113 | /// The expression must not be dependent. |
114 | const ASTConstraintSatisfaction &getSatisfaction() const { |
115 | assert(!isValueDependent() |
116 | && "getSatisfaction called on dependent ConceptSpecializationExpr" ); |
117 | return *Satisfaction; |
118 | } |
119 | |
120 | static bool classof(const Stmt *T) { |
121 | return T->getStmtClass() == ConceptSpecializationExprClass; |
122 | } |
123 | |
124 | SourceLocation getBeginLoc() const LLVM_READONLY { |
125 | return ConceptName.getBeginLoc(); |
126 | } |
127 | |
128 | SourceLocation getEndLoc() const LLVM_READONLY { |
129 | // If the ConceptSpecializationExpr is the ImmediatelyDeclaredConstraint |
130 | // of a TypeConstraint written syntactically as a constrained-parameter, |
131 | // there may not be a template argument list. |
132 | return ArgsAsWritten->RAngleLoc.isValid() ? ArgsAsWritten->RAngleLoc |
133 | : ConceptName.getEndLoc(); |
134 | } |
135 | |
136 | // Iterators |
137 | child_range children() { |
138 | return child_range(child_iterator(), child_iterator()); |
139 | } |
140 | const_child_range children() const { |
141 | return const_child_range(const_child_iterator(), const_child_iterator()); |
142 | } |
143 | }; |
144 | |
145 | namespace concepts { |
146 | |
147 | /// \brief A static requirement that can be used in a requires-expression to |
148 | /// check properties of types and expression. |
149 | class Requirement { |
150 | public: |
151 | // Note - simple and compound requirements are both represented by the same |
152 | // class (ExprRequirement). |
153 | enum RequirementKind { RK_Type, RK_Simple, RK_Compound, RK_Nested }; |
154 | private: |
155 | const RequirementKind Kind; |
156 | // FIXME: use RequirementDependence to model dependence? |
157 | bool Dependent : 1; |
158 | bool ContainsUnexpandedParameterPack : 1; |
159 | bool Satisfied : 1; |
160 | public: |
161 | struct SubstitutionDiagnostic { |
162 | StringRef SubstitutedEntity; |
163 | // FIXME: Store diagnostics semantically and not as prerendered strings. |
164 | // Fixing this probably requires serialization of PartialDiagnostic |
165 | // objects. |
166 | SourceLocation DiagLoc; |
167 | StringRef DiagMessage; |
168 | }; |
169 | |
170 | Requirement(RequirementKind Kind, bool IsDependent, |
171 | bool ContainsUnexpandedParameterPack, bool IsSatisfied = true) : |
172 | Kind(Kind), Dependent(IsDependent), |
173 | ContainsUnexpandedParameterPack(ContainsUnexpandedParameterPack), |
174 | Satisfied(IsSatisfied) {} |
175 | |
176 | RequirementKind getKind() const { return Kind; } |
177 | |
178 | bool isSatisfied() const { |
179 | assert(!Dependent && |
180 | "isSatisfied can only be called on non-dependent requirements." ); |
181 | return Satisfied; |
182 | } |
183 | |
184 | void setSatisfied(bool IsSatisfied) { |
185 | assert(!Dependent && |
186 | "setSatisfied can only be called on non-dependent requirements." ); |
187 | Satisfied = IsSatisfied; |
188 | } |
189 | |
190 | void setDependent(bool IsDependent) { Dependent = IsDependent; } |
191 | bool isDependent() const { return Dependent; } |
192 | |
193 | void setContainsUnexpandedParameterPack(bool Contains) { |
194 | ContainsUnexpandedParameterPack = Contains; |
195 | } |
196 | bool containsUnexpandedParameterPack() const { |
197 | return ContainsUnexpandedParameterPack; |
198 | } |
199 | }; |
200 | |
201 | /// \brief A requires-expression requirement which queries the existence of a |
202 | /// type name or type template specialization ('type' requirements). |
203 | class TypeRequirement : public Requirement { |
204 | public: |
205 | enum SatisfactionStatus { |
206 | SS_Dependent, |
207 | SS_SubstitutionFailure, |
208 | SS_Satisfied |
209 | }; |
210 | private: |
211 | llvm::PointerUnion<SubstitutionDiagnostic *, TypeSourceInfo *> Value; |
212 | SatisfactionStatus Status; |
213 | public: |
214 | friend ASTStmtReader; |
215 | friend ASTStmtWriter; |
216 | |
217 | /// \brief Construct a type requirement from a type. If the given type is not |
218 | /// dependent, this indicates that the type exists and the requirement will be |
219 | /// satisfied. Otherwise, the SubstitutionDiagnostic constructor is to be |
220 | /// used. |
221 | TypeRequirement(TypeSourceInfo *T); |
222 | |
223 | /// \brief Construct a type requirement when the nested name specifier is |
224 | /// invalid due to a bad substitution. The requirement is unsatisfied. |
225 | TypeRequirement(SubstitutionDiagnostic *Diagnostic) : |
226 | Requirement(RK_Type, false, false, false), Value(Diagnostic), |
227 | Status(SS_SubstitutionFailure) {} |
228 | |
229 | SatisfactionStatus getSatisfactionStatus() const { return Status; } |
230 | void setSatisfactionStatus(SatisfactionStatus Status) { |
231 | this->Status = Status; |
232 | } |
233 | |
234 | bool isSubstitutionFailure() const { |
235 | return Status == SS_SubstitutionFailure; |
236 | } |
237 | |
238 | SubstitutionDiagnostic *getSubstitutionDiagnostic() const { |
239 | assert(Status == SS_SubstitutionFailure && |
240 | "Attempted to get substitution diagnostic when there has been no " |
241 | "substitution failure." ); |
242 | return Value.get<SubstitutionDiagnostic *>(); |
243 | } |
244 | |
245 | TypeSourceInfo *getType() const { |
246 | assert(!isSubstitutionFailure() && |
247 | "Attempted to get type when there has been a substitution failure." ); |
248 | return Value.get<TypeSourceInfo *>(); |
249 | } |
250 | |
251 | static bool classof(const Requirement *R) { |
252 | return R->getKind() == RK_Type; |
253 | } |
254 | }; |
255 | |
256 | /// \brief A requires-expression requirement which queries the validity and |
257 | /// properties of an expression ('simple' and 'compound' requirements). |
258 | class ExprRequirement : public Requirement { |
259 | public: |
260 | enum SatisfactionStatus { |
261 | SS_Dependent, |
262 | SS_ExprSubstitutionFailure, |
263 | SS_NoexceptNotMet, |
264 | SS_TypeRequirementSubstitutionFailure, |
265 | SS_ConstraintsNotSatisfied, |
266 | SS_Satisfied |
267 | }; |
268 | class ReturnTypeRequirement { |
269 | llvm::PointerIntPair< |
270 | llvm::PointerUnion<TemplateParameterList *, SubstitutionDiagnostic *>, |
271 | 1, bool> |
272 | TypeConstraintInfo; |
273 | public: |
274 | friend ASTStmtReader; |
275 | friend ASTStmtWriter; |
276 | |
277 | /// \brief No return type requirement was specified. |
278 | ReturnTypeRequirement() : TypeConstraintInfo(nullptr, 0) {} |
279 | |
280 | /// \brief A return type requirement was specified but it was a |
281 | /// substitution failure. |
282 | ReturnTypeRequirement(SubstitutionDiagnostic *SubstDiag) : |
283 | TypeConstraintInfo(SubstDiag, 0) {} |
284 | |
285 | /// \brief A 'type constraint' style return type requirement. |
286 | /// \param TPL an invented template parameter list containing a single |
287 | /// type parameter with a type-constraint. |
288 | // TODO: Can we maybe not save the whole template parameter list and just |
289 | // the type constraint? Saving the whole TPL makes it easier to handle in |
290 | // serialization but is less elegant. |
291 | ReturnTypeRequirement(TemplateParameterList *TPL); |
292 | |
293 | bool isDependent() const { |
294 | return TypeConstraintInfo.getInt(); |
295 | } |
296 | |
297 | bool containsUnexpandedParameterPack() const { |
298 | if (!isTypeConstraint()) |
299 | return false; |
300 | return getTypeConstraintTemplateParameterList() |
301 | ->containsUnexpandedParameterPack(); |
302 | } |
303 | |
304 | bool isEmpty() const { |
305 | return TypeConstraintInfo.getPointer().isNull(); |
306 | } |
307 | |
308 | bool isSubstitutionFailure() const { |
309 | return !isEmpty() && |
310 | TypeConstraintInfo.getPointer().is<SubstitutionDiagnostic *>(); |
311 | } |
312 | |
313 | bool isTypeConstraint() const { |
314 | return !isEmpty() && |
315 | TypeConstraintInfo.getPointer().is<TemplateParameterList *>(); |
316 | } |
317 | |
318 | SubstitutionDiagnostic *getSubstitutionDiagnostic() const { |
319 | assert(isSubstitutionFailure()); |
320 | return TypeConstraintInfo.getPointer().get<SubstitutionDiagnostic *>(); |
321 | } |
322 | |
323 | const TypeConstraint *getTypeConstraint() const; |
324 | |
325 | TemplateParameterList *getTypeConstraintTemplateParameterList() const { |
326 | assert(isTypeConstraint()); |
327 | return TypeConstraintInfo.getPointer().get<TemplateParameterList *>(); |
328 | } |
329 | }; |
330 | private: |
331 | llvm::PointerUnion<Expr *, SubstitutionDiagnostic *> Value; |
332 | SourceLocation NoexceptLoc; // May be empty if noexcept wasn't specified. |
333 | ReturnTypeRequirement TypeReq; |
334 | ConceptSpecializationExpr *SubstitutedConstraintExpr; |
335 | SatisfactionStatus Status; |
336 | public: |
337 | friend ASTStmtReader; |
338 | friend ASTStmtWriter; |
339 | |
340 | /// \brief Construct a compound requirement. |
341 | /// \param E the expression which is checked by this requirement. |
342 | /// \param IsSimple whether this was a simple requirement in source. |
343 | /// \param NoexceptLoc the location of the noexcept keyword, if it was |
344 | /// specified, otherwise an empty location. |
345 | /// \param Req the requirement for the type of the checked expression. |
346 | /// \param Status the satisfaction status of this requirement. |
347 | ExprRequirement( |
348 | Expr *E, bool IsSimple, SourceLocation NoexceptLoc, |
349 | ReturnTypeRequirement Req, SatisfactionStatus Status, |
350 | ConceptSpecializationExpr *SubstitutedConstraintExpr = nullptr); |
351 | |
352 | /// \brief Construct a compound requirement whose expression was a |
353 | /// substitution failure. The requirement is not satisfied. |
354 | /// \param E the diagnostic emitted while instantiating the original |
355 | /// expression. |
356 | /// \param IsSimple whether this was a simple requirement in source. |
357 | /// \param NoexceptLoc the location of the noexcept keyword, if it was |
358 | /// specified, otherwise an empty location. |
359 | /// \param Req the requirement for the type of the checked expression (omit |
360 | /// if no requirement was specified). |
361 | ExprRequirement(SubstitutionDiagnostic *E, bool IsSimple, |
362 | SourceLocation NoexceptLoc, ReturnTypeRequirement Req = {}); |
363 | |
364 | bool isSimple() const { return getKind() == RK_Simple; } |
365 | bool isCompound() const { return getKind() == RK_Compound; } |
366 | |
367 | bool hasNoexceptRequirement() const { return NoexceptLoc.isValid(); } |
368 | SourceLocation getNoexceptLoc() const { return NoexceptLoc; } |
369 | |
370 | SatisfactionStatus getSatisfactionStatus() const { return Status; } |
371 | |
372 | bool isExprSubstitutionFailure() const { |
373 | return Status == SS_ExprSubstitutionFailure; |
374 | } |
375 | |
376 | const ReturnTypeRequirement &getReturnTypeRequirement() const { |
377 | return TypeReq; |
378 | } |
379 | |
380 | ConceptSpecializationExpr * |
381 | getReturnTypeRequirementSubstitutedConstraintExpr() const { |
382 | assert(Status >= SS_TypeRequirementSubstitutionFailure); |
383 | return SubstitutedConstraintExpr; |
384 | } |
385 | |
386 | SubstitutionDiagnostic *getExprSubstitutionDiagnostic() const { |
387 | assert(isExprSubstitutionFailure() && |
388 | "Attempted to get expression substitution diagnostic when there has " |
389 | "been no expression substitution failure" ); |
390 | return Value.get<SubstitutionDiagnostic *>(); |
391 | } |
392 | |
393 | Expr *getExpr() const { |
394 | assert(!isExprSubstitutionFailure() && |
395 | "ExprRequirement has no expression because there has been a " |
396 | "substitution failure." ); |
397 | return Value.get<Expr *>(); |
398 | } |
399 | |
400 | static bool classof(const Requirement *R) { |
401 | return R->getKind() == RK_Compound || R->getKind() == RK_Simple; |
402 | } |
403 | }; |
404 | |
405 | /// \brief A requires-expression requirement which is satisfied when a general |
406 | /// constraint expression is satisfied ('nested' requirements). |
407 | class NestedRequirement : public Requirement { |
408 | llvm::PointerUnion<Expr *, SubstitutionDiagnostic *> Value; |
409 | const ASTConstraintSatisfaction *Satisfaction = nullptr; |
410 | |
411 | public: |
412 | friend ASTStmtReader; |
413 | friend ASTStmtWriter; |
414 | |
415 | NestedRequirement(SubstitutionDiagnostic *SubstDiag) : |
416 | Requirement(RK_Nested, /*Dependent=*/false, |
417 | /*ContainsUnexpandedParameterPack*/false, |
418 | /*Satisfied=*/false), Value(SubstDiag) {} |
419 | |
420 | NestedRequirement(Expr *Constraint) : |
421 | Requirement(RK_Nested, /*Dependent=*/true, |
422 | Constraint->containsUnexpandedParameterPack()), |
423 | Value(Constraint) { |
424 | assert(Constraint->isInstantiationDependent() && |
425 | "Nested requirement with non-dependent constraint must be " |
426 | "constructed with a ConstraintSatisfaction object" ); |
427 | } |
428 | |
429 | NestedRequirement(ASTContext &C, Expr *Constraint, |
430 | const ConstraintSatisfaction &Satisfaction) : |
431 | Requirement(RK_Nested, Constraint->isInstantiationDependent(), |
432 | Constraint->containsUnexpandedParameterPack(), |
433 | Satisfaction.IsSatisfied), |
434 | Value(Constraint), |
435 | Satisfaction(ASTConstraintSatisfaction::Create(C, Satisfaction)) {} |
436 | |
437 | bool isSubstitutionFailure() const { |
438 | return Value.is<SubstitutionDiagnostic *>(); |
439 | } |
440 | |
441 | SubstitutionDiagnostic *getSubstitutionDiagnostic() const { |
442 | assert(isSubstitutionFailure() && |
443 | "getSubstitutionDiagnostic() may not be called when there was no " |
444 | "substitution failure." ); |
445 | return Value.get<SubstitutionDiagnostic *>(); |
446 | } |
447 | |
448 | Expr *getConstraintExpr() const { |
449 | assert(!isSubstitutionFailure() && "getConstraintExpr() may not be called " |
450 | "on nested requirements with " |
451 | "substitution failures." ); |
452 | return Value.get<Expr *>(); |
453 | } |
454 | |
455 | const ASTConstraintSatisfaction &getConstraintSatisfaction() const { |
456 | assert(!isSubstitutionFailure() && "getConstraintSatisfaction() may not be " |
457 | "called on nested requirements with " |
458 | "substitution failures." ); |
459 | return *Satisfaction; |
460 | } |
461 | |
462 | static bool classof(const Requirement *R) { |
463 | return R->getKind() == RK_Nested; |
464 | } |
465 | }; |
466 | |
467 | } // namespace concepts |
468 | |
469 | /// C++2a [expr.prim.req]: |
470 | /// A requires-expression provides a concise way to express requirements on |
471 | /// template arguments. A requirement is one that can be checked by name |
472 | /// lookup (6.4) or by checking properties of types and expressions. |
473 | /// [...] |
474 | /// A requires-expression is a prvalue of type bool [...] |
475 | class RequiresExpr final : public Expr, |
476 | llvm::TrailingObjects<RequiresExpr, ParmVarDecl *, |
477 | concepts::Requirement *> { |
478 | friend TrailingObjects; |
479 | friend class ASTStmtReader; |
480 | |
481 | unsigned NumLocalParameters; |
482 | unsigned NumRequirements; |
483 | RequiresExprBodyDecl *Body; |
484 | SourceLocation RBraceLoc; |
485 | |
486 | unsigned numTrailingObjects(OverloadToken<ParmVarDecl *>) const { |
487 | return NumLocalParameters; |
488 | } |
489 | |
490 | unsigned numTrailingObjects(OverloadToken<concepts::Requirement *>) const { |
491 | return NumRequirements; |
492 | } |
493 | |
494 | RequiresExpr(ASTContext &C, SourceLocation RequiresKWLoc, |
495 | RequiresExprBodyDecl *Body, |
496 | ArrayRef<ParmVarDecl *> LocalParameters, |
497 | ArrayRef<concepts::Requirement *> Requirements, |
498 | SourceLocation RBraceLoc); |
499 | RequiresExpr(ASTContext &C, EmptyShell Empty, unsigned NumLocalParameters, |
500 | unsigned NumRequirements); |
501 | |
502 | public: |
503 | static RequiresExpr * |
504 | Create(ASTContext &C, SourceLocation RequiresKWLoc, |
505 | RequiresExprBodyDecl *Body, ArrayRef<ParmVarDecl *> LocalParameters, |
506 | ArrayRef<concepts::Requirement *> Requirements, |
507 | SourceLocation RBraceLoc); |
508 | static RequiresExpr * |
509 | Create(ASTContext &C, EmptyShell Empty, unsigned NumLocalParameters, |
510 | unsigned NumRequirements); |
511 | |
512 | ArrayRef<ParmVarDecl *> getLocalParameters() const { |
513 | return {getTrailingObjects<ParmVarDecl *>(), NumLocalParameters}; |
514 | } |
515 | |
516 | RequiresExprBodyDecl *getBody() const { return Body; } |
517 | |
518 | ArrayRef<concepts::Requirement *> getRequirements() const { |
519 | return {getTrailingObjects<concepts::Requirement *>(), NumRequirements}; |
520 | } |
521 | |
522 | /// \brief Whether or not the requires clause is satisfied. |
523 | /// The expression must not be dependent. |
524 | bool isSatisfied() const { |
525 | assert(!isValueDependent() |
526 | && "isSatisfied called on a dependent RequiresExpr" ); |
527 | return RequiresExprBits.IsSatisfied; |
528 | } |
529 | |
530 | SourceLocation getRequiresKWLoc() const { |
531 | return RequiresExprBits.RequiresKWLoc; |
532 | } |
533 | |
534 | SourceLocation getRBraceLoc() const { return RBraceLoc; } |
535 | |
536 | static bool classof(const Stmt *T) { |
537 | return T->getStmtClass() == RequiresExprClass; |
538 | } |
539 | |
540 | SourceLocation getBeginLoc() const LLVM_READONLY { |
541 | return RequiresExprBits.RequiresKWLoc; |
542 | } |
543 | SourceLocation getEndLoc() const LLVM_READONLY { |
544 | return RBraceLoc; |
545 | } |
546 | |
547 | // Iterators |
548 | child_range children() { |
549 | return child_range(child_iterator(), child_iterator()); |
550 | } |
551 | const_child_range children() const { |
552 | return const_child_range(const_child_iterator(), const_child_iterator()); |
553 | } |
554 | }; |
555 | |
556 | } // namespace clang |
557 | |
558 | #endif // LLVM_CLANG_AST_EXPRCONCEPTS_H |
559 | |