| 1 |
//===- ComputeDependence.cpp ----------------------------------------------===// |
| 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 |
#include "clang/AST/ComputeDependence.h" |
| 10 |
#include "clang/AST/Attr.h" |
| 11 |
#include "clang/AST/DeclCXX.h" |
| 12 |
#include "clang/AST/DeclarationName.h" |
| 13 |
#include "clang/AST/DependenceFlags.h" |
| 14 |
#include "clang/AST/Expr.h" |
| 15 |
#include "clang/AST/ExprCXX.h" |
| 16 |
#include "clang/AST/ExprConcepts.h" |
| 17 |
#include "clang/AST/ExprObjC.h" |
| 18 |
#include "clang/AST/ExprOpenMP.h" |
| 19 |
#include "clang/Basic/ExceptionSpecificationType.h" |
| 20 |
#include "llvm/ADT/ArrayRef.h" |
| 21 |
|
| 22 |
using namespace clang; |
| 23 |
|
| 24 |
ExprDependence clang::computeDependence(FullExpr *E) { |
| 25 |
return E->getSubExpr()->getDependence(); |
| 26 |
} |
| 27 |
|
| 28 |
ExprDependence clang::computeDependence(OpaqueValueExpr *E) { |
| 29 |
auto D = toExprDependenceForImpliedType(E->getType()->getDependence()); |
| 30 |
if (auto *S = E->getSourceExpr()) |
| 31 |
D |= S->getDependence(); |
| 32 |
assert(!(D & ExprDependence::UnexpandedPack)); |
| 33 |
return D; |
| 34 |
} |
| 35 |
|
| 36 |
ExprDependence clang::computeDependence(ParenExpr *E) { |
| 37 |
return E->getSubExpr()->getDependence(); |
| 38 |
} |
| 39 |
|
| 40 |
ExprDependence clang::computeDependence(UnaryOperator *E, |
| 41 |
const ASTContext &Ctx) { |
| 42 |
ExprDependence Dep = |
| 43 |
// FIXME: Do we need to look at the type? |
| 44 |
toExprDependenceForImpliedType(E->getType()->getDependence()) | |
| 45 |
E->getSubExpr()->getDependence(); |
| 46 |
|
| 47 |
// C++ [temp.dep.constexpr]p5: |
| 48 |
// An expression of the form & qualified-id where the qualified-id names a |
| 49 |
// dependent member of the current instantiation is value-dependent. An |
| 50 |
// expression of the form & cast-expression is also value-dependent if |
| 51 |
// evaluating cast-expression as a core constant expression succeeds and |
| 52 |
// the result of the evaluation refers to a templated entity that is an |
| 53 |
// object with static or thread storage duration or a member function. |
| 54 |
// |
| 55 |
// What this amounts to is: constant-evaluate the operand and check whether it |
| 56 |
// refers to a templated entity other than a variable with local storage. |
| 57 |
if (Ctx.getLangOpts().CPlusPlus && E->getOpcode() == UO_AddrOf && |
| 58 |
!(Dep & ExprDependence::Value)) { |
| 59 |
Expr::EvalResult Result; |
| 60 |
SmallVector<PartialDiagnosticAt, 8> Diag; |
| 61 |
Result.Diag = &Diag; |
| 62 |
// FIXME: This doesn't enforce the C++98 constant expression rules. |
| 63 |
if (E->getSubExpr()->EvaluateAsConstantExpr(Result, Ctx) && Diag.empty() && |
| 64 |
Result.Val.isLValue()) { |
| 65 |
auto *VD = Result.Val.getLValueBase().dyn_cast<const ValueDecl *>(); |
| 66 |
if (VD && VD->isTemplated()) { |
| 67 |
auto *VarD = dyn_cast<VarDecl>(VD); |
| 68 |
if (!VarD || !VarD->hasLocalStorage()) |
| 69 |
Dep |= ExprDependence::Value; |
| 70 |
} |
| 71 |
} |
| 72 |
} |
| 73 |
|
| 74 |
return Dep; |
| 75 |
} |
| 76 |
|
| 77 |
ExprDependence clang::computeDependence(UnaryExprOrTypeTraitExpr *E) { |
| 78 |
// Never type-dependent (C++ [temp.dep.expr]p3). |
| 79 |
// Value-dependent if the argument is type-dependent. |
| 80 |
if (E->isArgumentType()) |
| 81 |
return turnTypeToValueDependence( |
| 82 |
toExprDependenceAsWritten(E->getArgumentType()->getDependence())); |
| 83 |
|
| 84 |
auto ArgDeps = E->getArgumentExpr()->getDependence(); |
| 85 |
auto Deps = ArgDeps & ~ExprDependence::TypeValue; |
| 86 |
// Value-dependent if the argument is type-dependent. |
| 87 |
if (ArgDeps & ExprDependence::Type) |
| 88 |
Deps |= ExprDependence::Value; |
| 89 |
// Check to see if we are in the situation where alignof(decl) should be |
| 90 |
// dependent because decl's alignment is dependent. |
| 91 |
auto ExprKind = E->getKind(); |
| 92 |
if (ExprKind != UETT_AlignOf && ExprKind != UETT_PreferredAlignOf) |
| 93 |
return Deps; |
| 94 |
if ((Deps & ExprDependence::Value) && (Deps & ExprDependence::Instantiation)) |
| 95 |
return Deps; |
| 96 |
|
| 97 |
auto *NoParens = E->getArgumentExpr()->IgnoreParens(); |
| 98 |
const ValueDecl *D = nullptr; |
| 99 |
if (const auto *DRE = dyn_cast<DeclRefExpr>(NoParens)) |
| 100 |
D = DRE->getDecl(); |
| 101 |
else if (const auto *ME = dyn_cast<MemberExpr>(NoParens)) |
| 102 |
D = ME->getMemberDecl(); |
| 103 |
if (!D) |
| 104 |
return Deps; |
| 105 |
for (const auto *I : D->specific_attrs<AlignedAttr>()) { |
| 106 |
if (I->isAlignmentErrorDependent()) |
| 107 |
Deps |= ExprDependence::Error; |
| 108 |
if (I->isAlignmentDependent()) |
| 109 |
Deps |= ExprDependence::ValueInstantiation; |
| 110 |
} |
| 111 |
return Deps; |
| 112 |
} |
| 113 |
|
| 114 |
ExprDependence clang::computeDependence(ArraySubscriptExpr *E) { |
| 115 |
return E->getLHS()->getDependence() | E->getRHS()->getDependence(); |
| 116 |
} |
| 117 |
|
| 118 |
ExprDependence clang::computeDependence(MatrixSubscriptExpr *E) { |
| 119 |
return E->getBase()->getDependence() | E->getRowIdx()->getDependence() | |
| 120 |
(E->getColumnIdx() ? E->getColumnIdx()->getDependence() |
| 121 |
: ExprDependence::None); |
| 122 |
} |
| 123 |
|
| 124 |
ExprDependence clang::computeDependence(CompoundLiteralExpr *E) { |
| 125 |
return toExprDependenceAsWritten( |
| 126 |
E->getTypeSourceInfo()->getType()->getDependence()) | |
| 127 |
toExprDependenceForImpliedType(E->getType()->getDependence()) | |
| 128 |
turnTypeToValueDependence(E->getInitializer()->getDependence()); |
| 129 |
} |
| 130 |
|
| 131 |
ExprDependence clang::computeDependence(ImplicitCastExpr *E) { |
| 132 |
// We model implicit conversions as combining the dependence of their |
| 133 |
// subexpression, apart from its type, with the semantic portion of the |
| 134 |
// target type. |
| 135 |
ExprDependence D = |
| 136 |
toExprDependenceForImpliedType(E->getType()->getDependence()); |
| 137 |
if (auto *S = E->getSubExpr()) |
| 138 |
D |= S->getDependence() & ~ExprDependence::Type; |
| 139 |
return D; |
| 140 |
} |
| 141 |
|
| 142 |
ExprDependence clang::computeDependence(ExplicitCastExpr *E) { |
| 143 |
// Cast expressions are type-dependent if the type is |
| 144 |
// dependent (C++ [temp.dep.expr]p3). |
| 145 |
// Cast expressions are value-dependent if the type is |
| 146 |
// dependent or if the subexpression is value-dependent. |
| 147 |
// |
| 148 |
// Note that we also need to consider the dependence of the actual type here, |
| 149 |
// because when the type as written is a deduced type, that type is not |
| 150 |
// dependent, but it may be deduced as a dependent type. |
| 151 |
ExprDependence D = |
| 152 |
toExprDependenceAsWritten( |
| 153 |
cast<ExplicitCastExpr>(E)->getTypeAsWritten()->getDependence()) | |
| 154 |
toExprDependenceForImpliedType(E->getType()->getDependence()); |
| 155 |
if (auto *S = E->getSubExpr()) |
| 156 |
D |= S->getDependence() & ~ExprDependence::Type; |
| 157 |
return D; |
| 158 |
} |
| 159 |
|
| 160 |
ExprDependence clang::computeDependence(BinaryOperator *E) { |
| 161 |
return E->getLHS()->getDependence() | E->getRHS()->getDependence(); |
| 162 |
} |
| 163 |
|
| 164 |
ExprDependence clang::computeDependence(ConditionalOperator *E) { |
| 165 |
// The type of the conditional operator depends on the type of the conditional |
| 166 |
// to support the GCC vector conditional extension. Additionally, |
| 167 |
// [temp.dep.expr] does specify state that this should be dependent on ALL sub |
| 168 |
// expressions. |
| 169 |
return E->getCond()->getDependence() | E->getLHS()->getDependence() | |
| 170 |
E->getRHS()->getDependence(); |
| 171 |
} |
| 172 |
|
| 173 |
ExprDependence clang::computeDependence(BinaryConditionalOperator *E) { |
| 174 |
return E->getCommon()->getDependence() | E->getFalseExpr()->getDependence(); |
| 175 |
} |
| 176 |
|
| 177 |
ExprDependence clang::computeDependence(StmtExpr *E, unsigned TemplateDepth) { |
| 178 |
auto D = toExprDependenceForImpliedType(E->getType()->getDependence()); |
| 179 |
// Propagate dependence of the result. |
| 180 |
if (const auto *CompoundExprResult = |
| 181 |
dyn_cast_or_null<ValueStmt>(E->getSubStmt()->getStmtExprResult())) |
| 182 |
if (const Expr *ResultExpr = CompoundExprResult->getExprStmt()) |
| 183 |
D |= ResultExpr->getDependence(); |
| 184 |
// Note: we treat a statement-expression in a dependent context as always |
| 185 |
// being value- and instantiation-dependent. This matches the behavior of |
| 186 |
// lambda-expressions and GCC. |
| 187 |
if (TemplateDepth) |
| 188 |
D |= ExprDependence::ValueInstantiation; |
| 189 |
// A param pack cannot be expanded over stmtexpr boundaries. |
| 190 |
return D & ~ExprDependence::UnexpandedPack; |
| 191 |
} |
| 192 |
|
| 193 |
ExprDependence clang::computeDependence(ConvertVectorExpr *E) { |
| 194 |
auto D = toExprDependenceAsWritten( |
| 195 |
E->getTypeSourceInfo()->getType()->getDependence()) | |
| 196 |
E->getSrcExpr()->getDependence(); |
| 197 |
if (!E->getType()->isDependentType()) |
| 198 |
D &= ~ExprDependence::Type; |
| 199 |
return D; |
| 200 |
} |
| 201 |
|
| 202 |
ExprDependence clang::computeDependence(ChooseExpr *E) { |
| 203 |
if (E->isConditionDependent()) |
| 204 |
return ExprDependence::TypeValueInstantiation | |
| 205 |
E->getCond()->getDependence() | E->getLHS()->getDependence() | |
| 206 |
E->getRHS()->getDependence(); |
| 207 |
|
| 208 |
auto Cond = E->getCond()->getDependence(); |
| 209 |
auto Active = E->getLHS()->getDependence(); |
| 210 |
auto Inactive = E->getRHS()->getDependence(); |
| 211 |
if (!E->isConditionTrue()) |
| 212 |
std::swap(Active, Inactive); |
| 213 |
// Take type- and value- dependency from the active branch. Propagate all |
| 214 |
// other flags from all branches. |
| 215 |
return (Active & ExprDependence::TypeValue) | |
| 216 |
((Cond | Active | Inactive) & ~ExprDependence::TypeValue); |
| 217 |
} |
| 218 |
|
| 219 |
ExprDependence clang::computeDependence(ParenListExpr *P) { |
| 220 |
auto D = ExprDependence::None; |
| 221 |
for (auto *E : P->exprs()) |
| 222 |
D |= E->getDependence(); |
| 223 |
return D; |
| 224 |
} |
| 225 |
|
| 226 |
ExprDependence clang::computeDependence(VAArgExpr *E) { |
| 227 |
auto D = toExprDependenceAsWritten( |
| 228 |
E->getWrittenTypeInfo()->getType()->getDependence()) | |
| 229 |
(E->getSubExpr()->getDependence() & ~ExprDependence::Type); |
| 230 |
return D & ~ExprDependence::Value; |
| 231 |
} |
| 232 |
|
| 233 |
ExprDependence clang::computeDependence(NoInitExpr *E) { |
| 234 |
return toExprDependenceForImpliedType(E->getType()->getDependence()) & |
| 235 |
(ExprDependence::Instantiation | ExprDependence::Error); |
| 236 |
} |
| 237 |
|
| 238 |
ExprDependence clang::computeDependence(ArrayInitLoopExpr *E) { |
| 239 |
auto D = E->getCommonExpr()->getDependence() | |
| 240 |
E->getSubExpr()->getDependence() | ExprDependence::Instantiation; |
| 241 |
if (!E->getType()->isInstantiationDependentType()) |
| 242 |
D &= ~ExprDependence::Instantiation; |
| 243 |
return turnTypeToValueDependence(D); |
| 244 |
} |
| 245 |
|
| 246 |
ExprDependence clang::computeDependence(ImplicitValueInitExpr *E) { |
| 247 |
return toExprDependenceForImpliedType(E->getType()->getDependence()) & |
| 248 |
ExprDependence::Instantiation; |
| 249 |
} |
| 250 |
|
| 251 |
ExprDependence clang::computeDependence(ExtVectorElementExpr *E) { |
| 252 |
return E->getBase()->getDependence(); |
| 253 |
} |
| 254 |
|
| 255 |
ExprDependence clang::computeDependence(BlockExpr *E) { |
| 256 |
auto D = toExprDependenceForImpliedType(E->getType()->getDependence()); |
| 257 |
if (E->getBlockDecl()->isDependentContext()) |
| 258 |
D |= ExprDependence::Instantiation; |
| 259 |
return D; |
| 260 |
} |
| 261 |
|
| 262 |
ExprDependence clang::computeDependence(AsTypeExpr *E) { |
| 263 |
// FIXME: AsTypeExpr doesn't store the type as written. Assume the expression |
| 264 |
// type has identical sugar for now, so is a type-as-written. |
| 265 |
auto D = toExprDependenceAsWritten(E->getType()->getDependence()) | |
| 266 |
E->getSrcExpr()->getDependence(); |
| 267 |
if (!E->getType()->isDependentType()) |
| 268 |
D &= ~ExprDependence::Type; |
| 269 |
return D; |
| 270 |
} |
| 271 |
|
| 272 |
ExprDependence clang::computeDependence(CXXRewrittenBinaryOperator *E) { |
| 273 |
return E->getSemanticForm()->getDependence(); |
| 274 |
} |
| 275 |
|
| 276 |
ExprDependence clang::computeDependence(CXXStdInitializerListExpr *E) { |
| 277 |
auto D = turnTypeToValueDependence(E->getSubExpr()->getDependence()); |
| 278 |
D |= toExprDependenceForImpliedType(E->getType()->getDependence()); |
| 279 |
return D; |
| 280 |
} |
| 281 |
|
| 282 |
ExprDependence clang::computeDependence(CXXTypeidExpr *E) { |
| 283 |
auto D = ExprDependence::None; |
| 284 |
if (E->isTypeOperand()) |
| 285 |
D = toExprDependenceAsWritten( |
| 286 |
E->getTypeOperandSourceInfo()->getType()->getDependence()); |
| 287 |
else |
| 288 |
D = turnTypeToValueDependence(E->getExprOperand()->getDependence()); |
| 289 |
// typeid is never type-dependent (C++ [temp.dep.expr]p4) |
| 290 |
return D & ~ExprDependence::Type; |
| 291 |
} |
| 292 |
|
| 293 |
ExprDependence clang::computeDependence(MSPropertyRefExpr *E) { |
| 294 |
return E->getBaseExpr()->getDependence() & ~ExprDependence::Type; |
| 295 |
} |
| 296 |
|
| 297 |
ExprDependence clang::computeDependence(MSPropertySubscriptExpr *E) { |
| 298 |
return E->getIdx()->getDependence(); |
| 299 |
} |
| 300 |
|
| 301 |
ExprDependence clang::computeDependence(CXXUuidofExpr *E) { |
| 302 |
if (E->isTypeOperand()) |
| 303 |
return turnTypeToValueDependence(toExprDependenceAsWritten( |
| 304 |
E->getTypeOperandSourceInfo()->getType()->getDependence())); |
| 305 |
|
| 306 |
return turnTypeToValueDependence(E->getExprOperand()->getDependence()); |
| 307 |
} |
| 308 |
|
| 309 |
ExprDependence clang::computeDependence(CXXThisExpr *E) { |
| 310 |
// 'this' is type-dependent if the class type of the enclosing |
| 311 |
// member function is dependent (C++ [temp.dep.expr]p2) |
| 312 |
auto D = toExprDependenceForImpliedType(E->getType()->getDependence()); |
| 313 |
assert(!(D & ExprDependence::UnexpandedPack)); |
| 314 |
return D; |
| 315 |
} |
| 316 |
|
| 317 |
ExprDependence clang::computeDependence(CXXThrowExpr *E) { |
| 318 |
auto *Op = E->getSubExpr(); |
| 319 |
if (!Op) |
| 320 |
return ExprDependence::None; |
| 321 |
return Op->getDependence() & ~ExprDependence::TypeValue; |
| 322 |
} |
| 323 |
|
| 324 |
ExprDependence clang::computeDependence(CXXBindTemporaryExpr *E) { |
| 325 |
return E->getSubExpr()->getDependence(); |
| 326 |
} |
| 327 |
|
| 328 |
ExprDependence clang::computeDependence(CXXScalarValueInitExpr *E) { |
| 329 |
auto D = toExprDependenceForImpliedType(E->getType()->getDependence()); |
| 330 |
if (auto *TSI = E->getTypeSourceInfo()) |
| 331 |
D |= toExprDependenceAsWritten(TSI->getType()->getDependence()); |
| 332 |
return D; |
| 333 |
} |
| 334 |
|
| 335 |
ExprDependence clang::computeDependence(CXXDeleteExpr *E) { |
| 336 |
return turnTypeToValueDependence(E->getArgument()->getDependence()); |
| 337 |
} |
| 338 |
|
| 339 |
ExprDependence clang::computeDependence(ArrayTypeTraitExpr *E) { |
| 340 |
auto D = toExprDependenceAsWritten(E->getQueriedType()->getDependence()); |
| 341 |
if (auto *Dim = E->getDimensionExpression()) |
| 342 |
D |= Dim->getDependence(); |
| 343 |
return turnTypeToValueDependence(D); |
| 344 |
} |
| 345 |
|
| 346 |
ExprDependence clang::computeDependence(ExpressionTraitExpr *E) { |
| 347 |
// Never type-dependent. |
| 348 |
auto D = E->getQueriedExpression()->getDependence() & ~ExprDependence::Type; |
| 349 |
// Value-dependent if the argument is type-dependent. |
| 350 |
if (E->getQueriedExpression()->isTypeDependent()) |
| 351 |
D |= ExprDependence::Value; |
| 352 |
return D; |
| 353 |
} |
| 354 |
|
| 355 |
ExprDependence clang::computeDependence(CXXNoexceptExpr *E, CanThrowResult CT) { |
| 356 |
auto D = E->getOperand()->getDependence() & ~ExprDependence::TypeValue; |
| 357 |
if (CT == CT_Dependent) |
| 358 |
D |= ExprDependence::ValueInstantiation; |
| 359 |
return D; |
| 360 |
} |
| 361 |
|
| 362 |
ExprDependence clang::computeDependence(PackExpansionExpr *E) { |
| 363 |
return (E->getPattern()->getDependence() & ~ExprDependence::UnexpandedPack) | |
| 364 |
ExprDependence::TypeValueInstantiation; |
| 365 |
} |
| 366 |
|
| 367 |
ExprDependence clang::computeDependence(SubstNonTypeTemplateParmExpr *E) { |
| 368 |
return E->getReplacement()->getDependence(); |
| 369 |
} |
| 370 |
|
| 371 |
ExprDependence clang::computeDependence(CoroutineSuspendExpr *E) { |
| 372 |
if (auto *Resume = E->getResumeExpr()) |
| 373 |
return (Resume->getDependence() & |
| 374 |
(ExprDependence::TypeValue | ExprDependence::Error)) | |
| 375 |
(E->getCommonExpr()->getDependence() & ~ExprDependence::TypeValue); |
| 376 |
return E->getCommonExpr()->getDependence() | |
| 377 |
ExprDependence::TypeValueInstantiation; |
| 378 |
} |
| 379 |
|
| 380 |
ExprDependence clang::computeDependence(DependentCoawaitExpr *E) { |
| 381 |
return E->getOperand()->getDependence() | |
| 382 |
ExprDependence::TypeValueInstantiation; |
| 383 |
} |
| 384 |
|
| 385 |
ExprDependence clang::computeDependence(ObjCBoxedExpr *E) { |
| 386 |
return E->getSubExpr()->getDependence(); |
| 387 |
} |
| 388 |
|
| 389 |
ExprDependence clang::computeDependence(ObjCEncodeExpr *E) { |
| 390 |
return toExprDependenceAsWritten(E->getEncodedType()->getDependence()); |
| 391 |
} |
| 392 |
|
| 393 |
ExprDependence clang::computeDependence(ObjCIvarRefExpr *E) { |
| 394 |
return turnTypeToValueDependence(E->getBase()->getDependence()); |
| 395 |
} |
| 396 |
|
| 397 |
ExprDependence clang::computeDependence(ObjCPropertyRefExpr *E) { |
| 398 |
if (E->isObjectReceiver()) |
| 399 |
return E->getBase()->getDependence() & ~ExprDependence::Type; |
| 400 |
if (E->isSuperReceiver()) |
| 401 |
return toExprDependenceForImpliedType( |
| 402 |
E->getSuperReceiverType()->getDependence()) & |
| 403 |
~ExprDependence::TypeValue; |
| 404 |
assert(E->isClassReceiver()); |
| 405 |
return ExprDependence::None; |
| 406 |
} |
| 407 |
|
| 408 |
ExprDependence clang::computeDependence(ObjCSubscriptRefExpr *E) { |
| 409 |
return E->getBaseExpr()->getDependence() | E->getKeyExpr()->getDependence(); |
| 410 |
} |
| 411 |
|
| 412 |
ExprDependence clang::computeDependence(ObjCIsaExpr *E) { |
| 413 |
return E->getBase()->getDependence() & ~ExprDependence::Type & |
| 414 |
~ExprDependence::UnexpandedPack; |
| 415 |
} |
| 416 |
|
| 417 |
ExprDependence clang::computeDependence(ObjCIndirectCopyRestoreExpr *E) { |
| 418 |
return E->getSubExpr()->getDependence(); |
| 419 |
} |
| 420 |
|
| 421 |
ExprDependence clang::computeDependence(OMPArraySectionExpr *E) { |
| 422 |
auto D = E->getBase()->getDependence(); |
| 423 |
if (auto *LB = E->getLowerBound()) |
| 424 |
D |= LB->getDependence(); |
| 425 |
if (auto *Len = E->getLength()) |
| 426 |
D |= Len->getDependence(); |
| 427 |
return D; |
| 428 |
} |
| 429 |
|
| 430 |
ExprDependence clang::computeDependence(OMPArrayShapingExpr *E) { |
| 431 |
auto D = E->getBase()->getDependence(); |
| 432 |
for (Expr *Dim: E->getDimensions()) |
| 433 |
if (Dim) |
| 434 |
D |= turnValueToTypeDependence(Dim->getDependence()); |
| 435 |
return D; |
| 436 |
} |
| 437 |
|
| 438 |
ExprDependence clang::computeDependence(OMPIteratorExpr *E) { |
| 439 |
auto D = toExprDependenceForImpliedType(E->getType()->getDependence()); |
| 440 |
for (unsigned I = 0, End = E->numOfIterators(); I < End; ++I) { |
| 441 |
if (auto *DD = cast_or_null<DeclaratorDecl>(E->getIteratorDecl(I))) { |
| 442 |
// If the type is omitted, it's 'int', and is not dependent in any way. |
| 443 |
if (auto *TSI = DD->getTypeSourceInfo()) { |
| 444 |
D |= toExprDependenceAsWritten(TSI->getType()->getDependence()); |
| 445 |
} |
| 446 |
} |
| 447 |
OMPIteratorExpr::IteratorRange IR = E->getIteratorRange(I); |
| 448 |
if (Expr *BE = IR.Begin) |
| 449 |
D |= BE->getDependence(); |
| 450 |
if (Expr *EE = IR.End) |
| 451 |
D |= EE->getDependence(); |
| 452 |
if (Expr *SE = IR.Step) |
| 453 |
D |= SE->getDependence(); |
| 454 |
} |
| 455 |
return D; |
| 456 |
} |
| 457 |
|
| 458 |
/// Compute the type-, value-, and instantiation-dependence of a |
| 459 |
/// declaration reference |
| 460 |
/// based on the declaration being referenced. |
| 461 |
ExprDependence clang::computeDependence(DeclRefExpr *E, const ASTContext &Ctx) { |
| 462 |
auto Deps = ExprDependence::None; |
| 463 |
|
| 464 |
if (auto *NNS = E->getQualifier()) |
| 465 |
Deps |= toExprDependence(NNS->getDependence() & |
| 466 |
~NestedNameSpecifierDependence::Dependent); |
| 467 |
|
| 468 |
if (auto *FirstArg = E->getTemplateArgs()) { |
| 469 |
unsigned NumArgs = E->getNumTemplateArgs(); |
| 470 |
for (auto *Arg = FirstArg, *End = FirstArg + NumArgs; Arg < End; ++Arg) |
| 471 |
Deps |= toExprDependence(Arg->getArgument().getDependence()); |
| 472 |
} |
| 473 |
|
| 474 |
auto *Decl = E->getDecl(); |
| 475 |
auto Type = E->getType(); |
| 476 |
|
| 477 |
if (Decl->isParameterPack()) |
| 478 |
Deps |= ExprDependence::UnexpandedPack; |
| 479 |
Deps |= toExprDependenceForImpliedType(Type->getDependence()) & |
| 480 |
ExprDependence::Error; |
| 481 |
|
| 482 |
// C++ [temp.dep.expr]p3: |
| 483 |
// An id-expression is type-dependent if it contains: |
| 484 |
|
| 485 |
// - an identifier associated by name lookup with one or more declarations |
| 486 |
// declared with a dependent type |
| 487 |
// |
| 488 |
// [The "or more" case is not modeled as a DeclRefExpr. There are a bunch |
| 489 |
// more bullets here that we handle by treating the declaration as having a |
| 490 |
// dependent type if they involve a placeholder type that can't be deduced.] |
| 491 |
if (Type->isDependentType()) |
| 492 |
return Deps | ExprDependence::TypeValueInstantiation; |
| 493 |
else if (Type->isInstantiationDependentType()) |
| 494 |
Deps |= ExprDependence::Instantiation; |
| 495 |
|
| 496 |
// - a conversion-function-id that specifies a dependent type |
| 497 |
if (Decl->getDeclName().getNameKind() == |
| 498 |
DeclarationName::CXXConversionFunctionName) { |
| 499 |
QualType T = Decl->getDeclName().getCXXNameType(); |
| 500 |
if (T->isDependentType()) |
| 501 |
return Deps | ExprDependence::TypeValueInstantiation; |
| 502 |
|
| 503 |
if (T->isInstantiationDependentType()) |
| 504 |
Deps |= ExprDependence::Instantiation; |
| 505 |
} |
| 506 |
|
| 507 |
// - a template-id that is dependent, |
| 508 |
// - a nested-name-specifier or a qualified-id that names a member of an |
| 509 |
// unknown specialization |
| 510 |
// [These are not modeled as DeclRefExprs.] |
| 511 |
|
| 512 |
// or if it names a dependent member of the current instantiation that is a |
| 513 |
// static data member of type "array of unknown bound of T" for some T |
| 514 |
// [handled below]. |
| 515 |
|
| 516 |
// C++ [temp.dep.constexpr]p2: |
| 517 |
// An id-expression is value-dependent if: |
| 518 |
|
| 519 |
// - it is type-dependent [handled above] |
| 520 |
|
| 521 |
// - it is the name of a non-type template parameter, |
| 522 |
if (isa<NonTypeTemplateParmDecl>(Decl)) |
| 523 |
return Deps | ExprDependence::ValueInstantiation; |
| 524 |
|
| 525 |
// - it names a potentially-constant variable that is initialized with an |
| 526 |
// expression that is value-dependent |
| 527 |
if (const auto *Var = dyn_cast<VarDecl>(Decl)) { |
| 528 |
if (Var->mightBeUsableInConstantExpressions(Ctx)) { |
| 529 |
if (const Expr *Init = Var->getAnyInitializer()) { |
| 530 |
if (Init->isValueDependent()) |
| 531 |
Deps |= ExprDependence::ValueInstantiation; |
| 532 |
if (Init->containsErrors()) |
| 533 |
Deps |= ExprDependence::Error; |
| 534 |
} |
| 535 |
} |
| 536 |
|
| 537 |
// - it names a static data member that is a dependent member of the |
| 538 |
// current instantiation and is not initialized in a member-declarator, |
| 539 |
if (Var->isStaticDataMember() && |
| 540 |
Var->getDeclContext()->isDependentContext() && |
| 541 |
!Var->getFirstDecl()->hasInit()) { |
| 542 |
const VarDecl *First = Var->getFirstDecl(); |
| 543 |
TypeSourceInfo *TInfo = First->getTypeSourceInfo(); |
| 544 |
if (TInfo->getType()->isIncompleteArrayType()) { |
| 545 |
Deps |= ExprDependence::TypeValueInstantiation; |
| 546 |
} else if (!First->hasInit()) { |
| 547 |
Deps |= ExprDependence::ValueInstantiation; |
| 548 |
} |
| 549 |
} |
| 550 |
|
| 551 |
return Deps; |
| 552 |
} |
| 553 |
|
| 554 |
// - it names a static member function that is a dependent member of the |
| 555 |
// current instantiation |
| 556 |
// |
| 557 |
// FIXME: It's unclear that the restriction to static members here has any |
| 558 |
// effect: any use of a non-static member function name requires either |
| 559 |
// forming a pointer-to-member or providing an object parameter, either of |
| 560 |
// which makes the overall expression value-dependent. |
| 561 |
if (auto *MD = dyn_cast<CXXMethodDecl>(Decl)) { |
| 562 |
if (MD->isStatic() && Decl->getDeclContext()->isDependentContext()) |
| 563 |
Deps |= ExprDependence::ValueInstantiation; |
| 564 |
} |
| 565 |
|
| 566 |
return Deps; |
| 567 |
} |
| 568 |
|
| 569 |
ExprDependence clang::computeDependence(RecoveryExpr *E) { |
| 570 |
// RecoveryExpr is |
| 571 |
// - always value-dependent, and therefore instantiation dependent |
| 572 |
// - contains errors (ExprDependence::Error), by definition |
| 573 |
// - type-dependent if we don't know the type (fallback to an opaque |
| 574 |
// dependent type), or the type is known and dependent, or it has |
| 575 |
// type-dependent subexpressions. |
| 576 |
auto D = toExprDependenceAsWritten(E->getType()->getDependence()) | |
| 577 |
ExprDependence::ErrorDependent; |
| 578 |
// FIXME: remove the type-dependent bit from subexpressions, if the |
| 579 |
// RecoveryExpr has a non-dependent type. |
| 580 |
for (auto *S : E->subExpressions()) |
| 581 |
D |= S->getDependence(); |
| 582 |
return D; |
| 583 |
} |
| 584 |
|
| 585 |
ExprDependence clang::computeDependence(SYCLUniqueStableNameExpr *E) { |
| 586 |
return toExprDependenceAsWritten( |
| 587 |
E->getTypeSourceInfo()->getType()->getDependence()); |
| 588 |
} |
| 589 |
|
| 590 |
ExprDependence clang::computeDependence(PredefinedExpr *E) { |
| 591 |
return toExprDependenceForImpliedType(E->getType()->getDependence()); |
| 592 |
} |
| 593 |
|
| 594 |
ExprDependence clang::computeDependence(CallExpr *E, |
| 595 |
llvm::ArrayRef<Expr *> PreArgs) { |
| 596 |
auto D = E->getCallee()->getDependence(); |
| 597 |
for (auto *A : llvm::ArrayRef(E->getArgs(), E->getNumArgs())) { |
| 598 |
if (A) |
| 599 |
D |= A->getDependence(); |
| 600 |
} |
| 601 |
for (auto *A : PreArgs) |
| 602 |
D |= A->getDependence(); |
| 603 |
return D; |
| 604 |
} |
| 605 |
|
| 606 |
ExprDependence clang::computeDependence(OffsetOfExpr *E) { |
| 607 |
auto D = turnTypeToValueDependence(toExprDependenceAsWritten( |
| 608 |
E->getTypeSourceInfo()->getType()->getDependence())); |
| 609 |
for (unsigned I = 0, N = E->getNumExpressions(); I < N; ++I) |
| 610 |
D |= turnTypeToValueDependence(E->getIndexExpr(I)->getDependence()); |
| 611 |
return D; |
| 612 |
} |
| 613 |
|
| 614 |
ExprDependence clang::computeDependence(MemberExpr *E) { |
| 615 |
auto *MemberDecl = E->getMemberDecl(); |
| 616 |
auto D = E->getBase()->getDependence(); |
| 617 |
if (FieldDecl *FD = dyn_cast<FieldDecl>(MemberDecl)) { |
| 618 |
DeclContext *DC = MemberDecl->getDeclContext(); |
| 619 |
// dyn_cast_or_null is used to handle objC variables which do not |
| 620 |
// have a declaration context. |
| 621 |
CXXRecordDecl *RD = dyn_cast_or_null<CXXRecordDecl>(DC); |
| 622 |
if (RD && RD->isDependentContext() && RD->isCurrentInstantiation(DC)) { |
| 623 |
if (!E->getType()->isDependentType()) |
| 624 |
D &= ~ExprDependence::Type; |
| 625 |
} |
| 626 |
|
| 627 |
// Bitfield with value-dependent width is type-dependent. |
| 628 |
if (FD && FD->isBitField() && FD->getBitWidth()->isValueDependent()) { |
| 629 |
D |= ExprDependence::Type; |
| 630 |
} |
| 631 |
} |
| 632 |
// FIXME: move remaining dependence computation from MemberExpr::Create() |
| 633 |
return D; |
| 634 |
} |
| 635 |
|
| 636 |
ExprDependence clang::computeDependence(InitListExpr *E) { |
| 637 |
auto D = ExprDependence::None; |
| 638 |
for (auto *A : E->inits()) |
| 639 |
D |= A->getDependence(); |
| 640 |
return D; |
| 641 |
} |
| 642 |
|
| 643 |
ExprDependence clang::computeDependence(ShuffleVectorExpr *E) { |
| 644 |
auto D = toExprDependenceForImpliedType(E->getType()->getDependence()); |
| 645 |
for (auto *C : llvm::ArrayRef(E->getSubExprs(), E->getNumSubExprs())) |
| 646 |
D |= C->getDependence(); |
| 647 |
return D; |
| 648 |
} |
| 649 |
|
| 650 |
ExprDependence clang::computeDependence(GenericSelectionExpr *E, |
| 651 |
bool ContainsUnexpandedPack) { |
| 652 |
auto D = ContainsUnexpandedPack ? ExprDependence::UnexpandedPack |
| 653 |
: ExprDependence::None; |
| 654 |
for (auto *AE : E->getAssocExprs()) |
| 655 |
D |= AE->getDependence() & ExprDependence::Error; |
| 656 |
D |= E->getControllingExpr()->getDependence() & ExprDependence::Error; |
| 657 |
|
| 658 |
if (E->isResultDependent()) |
| 659 |
return D | ExprDependence::TypeValueInstantiation; |
| 660 |
return D | (E->getResultExpr()->getDependence() & |
| 661 |
~ExprDependence::UnexpandedPack); |
| 662 |
} |
| 663 |
|
| 664 |
ExprDependence clang::computeDependence(DesignatedInitExpr *E) { |
| 665 |
auto Deps = E->getInit()->getDependence(); |
| 666 |
for (auto D : E->designators()) { |
| 667 |
auto DesignatorDeps = ExprDependence::None; |
| 668 |
if (D.isArrayDesignator()) |
| 669 |
DesignatorDeps |= E->getArrayIndex(D)->getDependence(); |
| 670 |
else if (D.isArrayRangeDesignator()) |
| 671 |
DesignatorDeps |= E->getArrayRangeStart(D)->getDependence() | |
| 672 |
E->getArrayRangeEnd(D)->getDependence(); |
| 673 |
Deps |= DesignatorDeps; |
| 674 |
if (DesignatorDeps & ExprDependence::TypeValue) |
| 675 |
Deps |= ExprDependence::TypeValueInstantiation; |
| 676 |
} |
| 677 |
return Deps; |
| 678 |
} |
| 679 |
|
| 680 |
ExprDependence clang::computeDependence(PseudoObjectExpr *O) { |
| 681 |
auto D = O->getSyntacticForm()->getDependence(); |
| 682 |
for (auto *E : O->semantics()) |
| 683 |
D |= E->getDependence(); |
| 684 |
return D; |
| 685 |
} |
| 686 |
|
| 687 |
ExprDependence clang::computeDependence(AtomicExpr *A) { |
| 688 |
auto D = ExprDependence::None; |
| 689 |
for (auto *E : llvm::ArrayRef(A->getSubExprs(), A->getNumSubExprs())) |
| 690 |
D |= E->getDependence(); |
| 691 |
return D; |
| 692 |
} |
| 693 |
|
| 694 |
ExprDependence clang::computeDependence(CXXNewExpr *E) { |
| 695 |
auto D = toExprDependenceAsWritten( |
| 696 |
E->getAllocatedTypeSourceInfo()->getType()->getDependence()); |
| 697 |
D |= toExprDependenceForImpliedType(E->getAllocatedType()->getDependence()); |
| 698 |
auto Size = E->getArraySize(); |
| 699 |
if (Size && *Size) |
| 700 |
D |= turnTypeToValueDependence((*Size)->getDependence()); |
| 701 |
if (auto *I = E->getInitializer()) |
| 702 |
D |= turnTypeToValueDependence(I->getDependence()); |
| 703 |
for (auto *A : E->placement_arguments()) |
| 704 |
D |= turnTypeToValueDependence(A->getDependence()); |
| 705 |
return D; |
| 706 |
} |
| 707 |
|
| 708 |
ExprDependence clang::computeDependence(CXXPseudoDestructorExpr *E) { |
| 709 |
auto D = E->getBase()->getDependence(); |
| 710 |
if (auto *TSI = E->getDestroyedTypeInfo()) |
| 711 |
D |= toExprDependenceAsWritten(TSI->getType()->getDependence()); |
| 712 |
if (auto *ST = E->getScopeTypeInfo()) |
| 713 |
D |= turnTypeToValueDependence( |
| 714 |
toExprDependenceAsWritten(ST->getType()->getDependence())); |
| 715 |
if (auto *Q = E->getQualifier()) |
| 716 |
D |= toExprDependence(Q->getDependence() & |
| 717 |
~NestedNameSpecifierDependence::Dependent); |
| 718 |
return D; |
| 719 |
} |
| 720 |
|
| 721 |
static inline ExprDependence getDependenceInExpr(DeclarationNameInfo Name) { |
| 722 |
auto D = ExprDependence::None; |
| 723 |
if (Name.isInstantiationDependent()) |
| 724 |
D |= ExprDependence::Instantiation; |
| 725 |
if (Name.containsUnexpandedParameterPack()) |
| 726 |
D |= ExprDependence::UnexpandedPack; |
| 727 |
return D; |
| 728 |
} |
| 729 |
|
| 730 |
ExprDependence |
| 731 |
clang::computeDependence(OverloadExpr *E, bool KnownDependent, |
| 732 |
bool KnownInstantiationDependent, |
| 733 |
bool KnownContainsUnexpandedParameterPack) { |
| 734 |
auto Deps = ExprDependence::None; |
| 735 |
if (KnownDependent) |
| 736 |
Deps |= ExprDependence::TypeValue; |
| 737 |
if (KnownInstantiationDependent) |
| 738 |
Deps |= ExprDependence::Instantiation; |
| 739 |
if (KnownContainsUnexpandedParameterPack) |
| 740 |
Deps |= ExprDependence::UnexpandedPack; |
| 741 |
Deps |= getDependenceInExpr(E->getNameInfo()); |
| 742 |
if (auto *Q = E->getQualifier()) |
| 743 |
Deps |= toExprDependence(Q->getDependence() & |
| 744 |
~NestedNameSpecifierDependence::Dependent); |
| 745 |
for (auto *D : E->decls()) { |
| 746 |
if (D->getDeclContext()->isDependentContext() || |
| 747 |
isa<UnresolvedUsingValueDecl>(D)) |
| 748 |
Deps |= ExprDependence::TypeValueInstantiation; |
| 749 |
} |
| 750 |
// If we have explicit template arguments, check for dependent |
| 751 |
// template arguments and whether they contain any unexpanded pack |
| 752 |
// expansions. |
| 753 |
for (auto A : E->template_arguments()) |
| 754 |
Deps |= toExprDependence(A.getArgument().getDependence()); |
| 755 |
return Deps; |
| 756 |
} |
| 757 |
|
| 758 |
ExprDependence clang::computeDependence(DependentScopeDeclRefExpr *E) { |
| 759 |
auto D = ExprDependence::TypeValue; |
| 760 |
D |= getDependenceInExpr(E->getNameInfo()); |
| 761 |
if (auto *Q = E->getQualifier()) |
| 762 |
D |= toExprDependence(Q->getDependence()); |
| 763 |
for (auto A : E->template_arguments()) |
| 764 |
D |= toExprDependence(A.getArgument().getDependence()); |
| 765 |
return D; |
| 766 |
} |
| 767 |
|
| 768 |
ExprDependence clang::computeDependence(CXXConstructExpr *E) { |
| 769 |
ExprDependence D = |
| 770 |
toExprDependenceForImpliedType(E->getType()->getDependence()); |
| 771 |
for (auto *A : E->arguments()) |
| 772 |
D |= A->getDependence() & ~ExprDependence::Type; |
| 773 |
return D; |
| 774 |
} |
| 775 |
|
| 776 |
ExprDependence clang::computeDependence(CXXTemporaryObjectExpr *E) { |
| 777 |
CXXConstructExpr *BaseE = E; |
| 778 |
return toExprDependenceAsWritten( |
| 779 |
E->getTypeSourceInfo()->getType()->getDependence()) | |
| 780 |
computeDependence(BaseE); |
| 781 |
} |
| 782 |
|
| 783 |
ExprDependence clang::computeDependence(CXXDefaultInitExpr *E) { |
| 784 |
return E->getExpr()->getDependence(); |
| 785 |
} |
| 786 |
|
| 787 |
ExprDependence clang::computeDependence(CXXDefaultArgExpr *E) { |
| 788 |
return E->getExpr()->getDependence(); |
| 789 |
} |
| 790 |
|
| 791 |
ExprDependence clang::computeDependence(LambdaExpr *E, |
| 792 |
bool ContainsUnexpandedParameterPack) { |
| 793 |
auto D = toExprDependenceForImpliedType(E->getType()->getDependence()); |
| 794 |
if (ContainsUnexpandedParameterPack) |
| 795 |
D |= ExprDependence::UnexpandedPack; |
| 796 |
return D; |
| 797 |
} |
| 798 |
|
| 799 |
ExprDependence clang::computeDependence(CXXUnresolvedConstructExpr *E) { |
| 800 |
auto D = ExprDependence::ValueInstantiation; |
| 801 |
D |= toExprDependenceAsWritten(E->getTypeAsWritten()->getDependence()); |
| 802 |
D |= toExprDependenceForImpliedType(E->getType()->getDependence()); |
| 803 |
for (auto *A : E->arguments()) |
| 804 |
D |= A->getDependence() & |
| 805 |
(ExprDependence::UnexpandedPack | ExprDependence::Error); |
| 806 |
return D; |
| 807 |
} |
| 808 |
|
| 809 |
ExprDependence clang::computeDependence(CXXDependentScopeMemberExpr *E) { |
| 810 |
auto D = ExprDependence::TypeValueInstantiation; |
| 811 |
if (!E->isImplicitAccess()) |
| 812 |
D |= E->getBase()->getDependence(); |
| 813 |
if (auto *Q = E->getQualifier()) |
| 814 |
D |= toExprDependence(Q->getDependence()); |
| 815 |
D |= getDependenceInExpr(E->getMemberNameInfo()); |
| 816 |
for (auto A : E->template_arguments()) |
| 817 |
D |= toExprDependence(A.getArgument().getDependence()); |
| 818 |
return D; |
| 819 |
} |
| 820 |
|
| 821 |
ExprDependence clang::computeDependence(MaterializeTemporaryExpr *E) { |
| 822 |
return E->getSubExpr()->getDependence(); |
| 823 |
} |
| 824 |
|
| 825 |
ExprDependence clang::computeDependence(CXXFoldExpr *E) { |
| 826 |
auto D = ExprDependence::TypeValueInstantiation; |
| 827 |
for (const auto *C : {E->getLHS(), E->getRHS()}) { |
| 828 |
if (C) |
| 829 |
D |= C->getDependence() & ~ExprDependence::UnexpandedPack; |
| 830 |
} |
| 831 |
return D; |
| 832 |
} |
| 833 |
|
| 834 |
ExprDependence clang::computeDependence(CXXParenListInitExpr *E) { |
| 835 |
auto D = ExprDependence::None; |
| 836 |
for (const auto *A : E->getInitExprs()) |
| 837 |
D |= A->getDependence(); |
| 838 |
return D; |
| 839 |
} |
| 840 |
|
| 841 |
ExprDependence clang::computeDependence(TypeTraitExpr *E) { |
| 842 |
auto D = ExprDependence::None; |
| 843 |
for (const auto *A : E->getArgs()) |
| 844 |
D |= toExprDependenceAsWritten(A->getType()->getDependence()) & |
| 845 |
~ExprDependence::Type; |
| 846 |
return D; |
| 847 |
} |
| 848 |
|
| 849 |
ExprDependence clang::computeDependence(ConceptSpecializationExpr *E, |
| 850 |
bool ValueDependent) { |
| 851 |
auto TA = TemplateArgumentDependence::None; |
| 852 |
const auto InterestingDeps = TemplateArgumentDependence::Instantiation | |
| 853 |
TemplateArgumentDependence::UnexpandedPack; |
| 854 |
for (const TemplateArgumentLoc &ArgLoc : |
| 855 |
E->getTemplateArgsAsWritten()->arguments()) { |
| 856 |
TA |= ArgLoc.getArgument().getDependence() & InterestingDeps; |
| 857 |
if (TA == InterestingDeps) |
| 858 |
break; |
| 859 |
} |
| 860 |
|
| 861 |
ExprDependence D = |
| 862 |
ValueDependent ? ExprDependence::Value : ExprDependence::None; |
| 863 |
auto Res = D | toExprDependence(TA); |
| 864 |
if(!ValueDependent && E->getSatisfaction().ContainsErrors) |
| 865 |
Res |= ExprDependence::Error; |
| 866 |
return Res; |
| 867 |
} |
| 868 |
|
| 869 |
ExprDependence clang::computeDependence(ObjCArrayLiteral *E) { |
| 870 |
auto D = ExprDependence::None; |
| 871 |
Expr **Elements = E->getElements(); |
| 872 |
for (unsigned I = 0, N = E->getNumElements(); I != N; ++I) |
| 873 |
D |= turnTypeToValueDependence(Elements[I]->getDependence()); |
| 874 |
return D; |
| 875 |
} |
| 876 |
|
| 877 |
ExprDependence clang::computeDependence(ObjCDictionaryLiteral *E) { |
| 878 |
auto Deps = ExprDependence::None; |
| 879 |
for (unsigned I = 0, N = E->getNumElements(); I < N; ++I) { |
| 880 |
auto KV = E->getKeyValueElement(I); |
| 881 |
auto KVDeps = turnTypeToValueDependence(KV.Key->getDependence() | |
| 882 |
KV.Value->getDependence()); |
| 883 |
if (KV.EllipsisLoc.isValid()) |
| 884 |
KVDeps &= ~ExprDependence::UnexpandedPack; |
| 885 |
Deps |= KVDeps; |
| 886 |
} |
| 887 |
return Deps; |
| 888 |
} |
| 889 |
|
| 890 |
ExprDependence clang::computeDependence(ObjCMessageExpr *E) { |
| 891 |
auto D = ExprDependence::None; |
| 892 |
if (auto *R = E->getInstanceReceiver()) |
| 893 |
D |= R->getDependence(); |
| 894 |
else |
| 895 |
D |= toExprDependenceForImpliedType(E->getType()->getDependence()); |
| 896 |
for (auto *A : E->arguments()) |
| 897 |
D |= A->getDependence(); |
| 898 |
return D; |
| 899 |
} |