1 //===- ExprCXX.cpp - (C++) Expression AST Node Implementation -------------===// 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 // This file implements the subclesses of Expr class declared in ExprCXX.h 10 // 11 //===----------------------------------------------------------------------===// 12 13 #include "clang/AST/ExprConcepts.h" 14 #include "clang/AST/ASTConcept.h" 15 #include "clang/AST/ASTContext.h" 16 #include "clang/AST/ComputeDependence.h" 17 #include "clang/AST/Decl.h" 18 #include "clang/AST/DeclTemplate.h" 19 #include "clang/AST/DeclarationName.h" 20 #include "clang/AST/DependenceFlags.h" 21 #include "clang/AST/Expr.h" 22 #include "clang/AST/NestedNameSpecifier.h" 23 #include "clang/AST/TemplateBase.h" 24 #include "clang/AST/Type.h" 25 #include "clang/Basic/SourceLocation.h" 26 #include "llvm/Support/TrailingObjects.h" 27 #include <algorithm> 28 #include <string> 29 #include <utility> 30 31 using namespace clang; 32 33 ConceptSpecializationExpr::ConceptSpecializationExpr( 34 const ASTContext &C, NestedNameSpecifierLoc NNS, 35 SourceLocation TemplateKWLoc, DeclarationNameInfo ConceptNameInfo, 36 NamedDecl *FoundDecl, ConceptDecl *NamedConcept, 37 const ASTTemplateArgumentListInfo *ArgsAsWritten, 38 ImplicitConceptSpecializationDecl *SpecDecl, 39 const ConstraintSatisfaction *Satisfaction) 40 : Expr(ConceptSpecializationExprClass, C.BoolTy, VK_PRValue, OK_Ordinary), 41 ConceptReference(NNS, TemplateKWLoc, ConceptNameInfo, FoundDecl, 42 NamedConcept, ArgsAsWritten), 43 SpecDecl(SpecDecl), 44 Satisfaction(Satisfaction 45 ? ASTConstraintSatisfaction::Create(C, *Satisfaction) 46 : nullptr) { 47 setDependence(computeDependence(this, /*ValueDependent=*/!Satisfaction)); 48 49 // Currently guaranteed by the fact concepts can only be at namespace-scope. 50 assert(!NestedNameSpec || 51 (!NestedNameSpec.getNestedNameSpecifier()->isInstantiationDependent() && 52 !NestedNameSpec.getNestedNameSpecifier() 53 ->containsUnexpandedParameterPack())); 54 assert((!isValueDependent() || isInstantiationDependent()) && 55 "should not be value-dependent"); 56 } 57 58 ConceptSpecializationExpr::ConceptSpecializationExpr(EmptyShell Empty) 59 : Expr(ConceptSpecializationExprClass, Empty) {} 60 61 ConceptSpecializationExpr *ConceptSpecializationExpr::Create( 62 const ASTContext &C, NestedNameSpecifierLoc NNS, 63 SourceLocation TemplateKWLoc, DeclarationNameInfo ConceptNameInfo, 64 NamedDecl *FoundDecl, ConceptDecl *NamedConcept, 65 const ASTTemplateArgumentListInfo *ArgsAsWritten, 66 ImplicitConceptSpecializationDecl *SpecDecl, 67 const ConstraintSatisfaction *Satisfaction) { 68 return new (C) ConceptSpecializationExpr( 69 C, NNS, TemplateKWLoc, ConceptNameInfo, FoundDecl, NamedConcept, 70 ArgsAsWritten, SpecDecl, Satisfaction); 71 } 72 73 ConceptSpecializationExpr::ConceptSpecializationExpr( 74 const ASTContext &C, ConceptDecl *NamedConcept, 75 ImplicitConceptSpecializationDecl *SpecDecl, 76 const ConstraintSatisfaction *Satisfaction, bool Dependent, 77 bool ContainsUnexpandedParameterPack) 78 : Expr(ConceptSpecializationExprClass, C.BoolTy, VK_PRValue, OK_Ordinary), 79 ConceptReference(NestedNameSpecifierLoc(), SourceLocation(), 80 DeclarationNameInfo(), NamedConcept, NamedConcept, 81 nullptr), 82 SpecDecl(SpecDecl), 83 Satisfaction(Satisfaction 84 ? ASTConstraintSatisfaction::Create(C, *Satisfaction) 85 : nullptr) { 86 ExprDependence D = ExprDependence::None; 87 if (!Satisfaction) 88 D |= ExprDependence::Value; 89 if (Dependent) 90 D |= ExprDependence::Instantiation; 91 if (ContainsUnexpandedParameterPack) 92 D |= ExprDependence::UnexpandedPack; 93 setDependence(D); 94 } 95 96 ConceptSpecializationExpr *ConceptSpecializationExpr::Create( 97 const ASTContext &C, ConceptDecl *NamedConcept, 98 ImplicitConceptSpecializationDecl *SpecDecl, 99 const ConstraintSatisfaction *Satisfaction, bool Dependent, 100 bool ContainsUnexpandedParameterPack) { 101 return new (C) 102 ConceptSpecializationExpr(C, NamedConcept, SpecDecl, Satisfaction, 103 Dependent, ContainsUnexpandedParameterPack); 104 } 105 106 const TypeConstraint * 107 concepts::ExprRequirement::ReturnTypeRequirement::getTypeConstraint() const { 108 assert(isTypeConstraint()); 109 auto TPL = 110 TypeConstraintInfo.getPointer().get<TemplateParameterList *>(); 111 return cast<TemplateTypeParmDecl>(TPL->getParam(0)) 112 ->getTypeConstraint(); 113 } 114 115 RequiresExpr::RequiresExpr(ASTContext &C, SourceLocation RequiresKWLoc, 116 RequiresExprBodyDecl *Body, 117 ArrayRef<ParmVarDecl *> LocalParameters, 118 ArrayRef<concepts::Requirement *> Requirements, 119 SourceLocation RBraceLoc) 120 : Expr(RequiresExprClass, C.BoolTy, VK_PRValue, OK_Ordinary), 121 NumLocalParameters(LocalParameters.size()), 122 NumRequirements(Requirements.size()), Body(Body), RBraceLoc(RBraceLoc) { 123 RequiresExprBits.IsSatisfied = false; 124 RequiresExprBits.RequiresKWLoc = RequiresKWLoc; 125 bool Dependent = false; 126 bool ContainsUnexpandedParameterPack = false; 127 for (ParmVarDecl *P : LocalParameters) { 128 Dependent |= P->getType()->isInstantiationDependentType(); 129 ContainsUnexpandedParameterPack |= 130 P->getType()->containsUnexpandedParameterPack(); 131 } 132 RequiresExprBits.IsSatisfied = true; 133 for (concepts::Requirement *R : Requirements) { 134 Dependent |= R->isDependent(); 135 ContainsUnexpandedParameterPack |= R->containsUnexpandedParameterPack(); 136 if (!Dependent) { 137 RequiresExprBits.IsSatisfied = R->isSatisfied(); 138 if (!RequiresExprBits.IsSatisfied) 139 break; 140 } 141 } 142 std::copy(LocalParameters.begin(), LocalParameters.end(), 143 getTrailingObjects<ParmVarDecl *>()); 144 std::copy(Requirements.begin(), Requirements.end(), 145 getTrailingObjects<concepts::Requirement *>()); 146 RequiresExprBits.IsSatisfied |= Dependent; 147 // FIXME: move the computing dependency logic to ComputeDependence.h 148 if (ContainsUnexpandedParameterPack) 149 setDependence(getDependence() | ExprDependence::UnexpandedPack); 150 // FIXME: this is incorrect for cases where we have a non-dependent 151 // requirement, but its parameters are instantiation-dependent. RequiresExpr 152 // should be instantiation-dependent if it has instantiation-dependent 153 // parameters. 154 if (Dependent) 155 setDependence(getDependence() | ExprDependence::ValueInstantiation); 156 } 157 158 RequiresExpr::RequiresExpr(ASTContext &C, EmptyShell Empty, 159 unsigned NumLocalParameters, 160 unsigned NumRequirements) 161 : Expr(RequiresExprClass, Empty), NumLocalParameters(NumLocalParameters), 162 NumRequirements(NumRequirements) { } 163 164 RequiresExpr * 165 RequiresExpr::Create(ASTContext &C, SourceLocation RequiresKWLoc, 166 RequiresExprBodyDecl *Body, 167 ArrayRef<ParmVarDecl *> LocalParameters, 168 ArrayRef<concepts::Requirement *> Requirements, 169 SourceLocation RBraceLoc) { 170 void *Mem = 171 C.Allocate(totalSizeToAlloc<ParmVarDecl *, concepts::Requirement *>( 172 LocalParameters.size(), Requirements.size()), 173 alignof(RequiresExpr)); 174 return new (Mem) RequiresExpr(C, RequiresKWLoc, Body, LocalParameters, 175 Requirements, RBraceLoc); 176 } 177 178 RequiresExpr * 179 RequiresExpr::Create(ASTContext &C, EmptyShell Empty, 180 unsigned NumLocalParameters, unsigned NumRequirements) { 181 void *Mem = 182 C.Allocate(totalSizeToAlloc<ParmVarDecl *, concepts::Requirement *>( 183 NumLocalParameters, NumRequirements), 184 alignof(RequiresExpr)); 185 return new (Mem) RequiresExpr(C, Empty, NumLocalParameters, NumRequirements); 186 } 187