Home | History | Annotate | Download | only in Analysis

Lines Matching defs:Exp

142 const Stmt *ExprMutationAnalyzer::findMutation(const Expr *Exp) {
143   return findMutationMemoized(Exp,
158 const Stmt *ExprMutationAnalyzer::findPointeeMutation(const Expr *Exp) {
159   return findMutationMemoized(Exp, {/*TODO*/}, PointeeResults);
167     const Expr *Exp, llvm::ArrayRef<MutationFinder> Finders,
169   const auto Memoized = MemoizedResults.find(Exp);
173   if (isUnevaluated(Exp))
174     return MemoizedResults[Exp] = nullptr;
177     if (const Stmt *S = (this->*Finder)(Exp))
178       return MemoizedResults[Exp] = S;
181   return MemoizedResults[Exp] = nullptr;
197 bool ExprMutationAnalyzer::isUnevaluated(const Expr *Exp) {
202                      expr(canResolveToExpr(equalsNode(Exp)),
204                               // `Exp` is part of the underlying expression of
222                                       hasDescendant(equalsNode(Exp)))),
250 const Stmt *ExprMutationAnalyzer::findDirectMutation(const Expr *Exp) {
253       isAssignmentOperator(), hasLHS(canResolveToExpr(equalsNode(Exp))));
258                     hasUnaryOperand(canResolveToExpr(equalsNode(Exp))));
266                         on(canResolveToExpr(equalsNode(Exp)))),
268                           hasArgument(0, canResolveToExpr(equalsNode(Exp)))),
274           allOf(ignoringImpCasts(canResolveToExpr(equalsNode(Exp))),
281                                 canResolveToExpr(equalsNode(Exp)))),
283                                 canResolveToExpr(equalsNode(Exp)))))))),
289                                            equalsNode(Exp)))))))));
291   // Taking address of 'Exp'.
292   // We're assuming 'Exp' is mutated as soon as its address is taken, though in
299                     hasUnaryOperand(canResolveToExpr(equalsNode(Exp))));
303                has(canResolveToExpr(equalsNode(Exp))));
311       argumentCountIs(1), hasArgument(0, canResolveToExpr(equalsNode(Exp))));
319       anyOf(canResolveToExpr(equalsNode(Exp)),
320             memberExpr(hasObjectExpression(canResolveToExpr(equalsNode(Exp))))),
332                hasAnyArgument(canResolveToExpr(equalsNode(Exp)))),
334           hasAnyArgument(canResolveToExpr(equalsNode(Exp)))),
340       parenListExpr(hasDescendant(expr(canResolveToExpr(equalsNode(Exp))))),
343       initListExpr(hasAnyInit(expr(canResolveToExpr(equalsNode(Exp))))));
346   // If we're initializing a capture with 'Exp' directly then we're initializing
349   const auto AsLambdaRefCaptureInit = lambdaExpr(hasCaptureInit(Exp));
352   // If we're returning 'Exp' directly then it's returned as non-const-ref.
357       returnStmt(hasReturnValue(canResolveToExpr(equalsNode(Exp))));
361       hasRangeInit(declRefExpr(allOf(canResolveToExpr(equalsNode(Exp)),
376 const Stmt *ExprMutationAnalyzer::findMemberMutation(const Expr *Exp) {
377   // Check whether any member of 'Exp' is mutated.
380                                    canResolveToExpr(equalsNode(Exp)))),
382                                    canResolveToExpr(equalsNode(Exp))))))
388 const Stmt *ExprMutationAnalyzer::findArrayElementMutation(const Expr *Exp) {
392                         anyOf(hasBase(canResolveToExpr(equalsNode(Exp))),
396                                             equalsNode(Exp))))))))
402 const Stmt *ExprMutationAnalyzer::findCastMutation(const Expr *Exp) {
403   // If the 'Exp' is explicitly casted to a non-const reference type the
404   // 'Exp' is considered to be modified.
407           stmt(castExpr(hasSourceExpression(canResolveToExpr(equalsNode(Exp))),
416   // If 'Exp' is casted to any non-const reference type, check the castExpr.
419           expr(castExpr(hasSourceExpression(canResolveToExpr(equalsNode(Exp))),
433                              hasArgument(0, canResolveToExpr(equalsNode(Exp))))
439 const Stmt *ExprMutationAnalyzer::findRangeLoopMutation(const Expr *Exp) {
453                        hasRangeInit(canResolveToExpr(equalsNode(Exp)))))
481                              hasRangeInit(canResolveToExpr(equalsNode(Exp))))))
489   // If range for looping over 'Exp' with a non-const reference loop variable,
495                 hasRangeInit(canResolveToExpr(equalsNode(Exp))))),
500 const Stmt *ExprMutationAnalyzer::findReferenceMutation(const Expr *Exp) {
510                         hasArgument(0, canResolveToExpr(equalsNode(Exp))))
516   // If 'Exp' is bound to a non-const reference, check all declRefExpr to that.
521               hasInitializer(anyOf(canResolveToExpr(equalsNode(Exp)),
523                                        canResolveToExpr(equalsNode(Exp)))))),
534 const Stmt *ExprMutationAnalyzer::findFunctionArgMutation(const Expr *Exp) {
536       canResolveToExpr(equalsNode(Exp)),
552     const auto *Exp = Nodes.getNodeAs<Expr>(NodeID<Expr>::value);
555       return Exp;
577           return Exp;
582     return Exp;