Subversion Repositories QNX 8.QNX8 LLVM/Clang compiler suite

Rev

Blame | Last modification | View Log | Download | RSS feed

  1. //===--- IgnoreExpr.h - Ignore intermediate Expressions -----------------===//
  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 defines common functions to ignore intermediate expression nodes
  10. //
  11. //===----------------------------------------------------------------------===//
  12.  
  13. #ifndef LLVM_CLANG_AST_IGNOREEXPR_H
  14. #define LLVM_CLANG_AST_IGNOREEXPR_H
  15.  
  16. #include "clang/AST/Expr.h"
  17. #include "clang/AST/ExprCXX.h"
  18.  
  19. namespace clang {
  20. namespace detail {
  21. /// Given an expression E and functions Fn_1,...,Fn_n : Expr * -> Expr *,
  22. /// Return Fn_n(...(Fn_1(E)))
  23. inline Expr *IgnoreExprNodesImpl(Expr *E) { return E; }
  24. template <typename FnTy, typename... FnTys>
  25. Expr *IgnoreExprNodesImpl(Expr *E, FnTy &&Fn, FnTys &&... Fns) {
  26.   return IgnoreExprNodesImpl(Fn(E), std::forward<FnTys>(Fns)...);
  27. }
  28. } // namespace detail
  29.  
  30. /// Given an expression E and functions Fn_1,...,Fn_n : Expr * -> Expr *,
  31. /// Recursively apply each of the functions to E until reaching a fixed point.
  32. /// Note that a null E is valid; in this case nothing is done.
  33. template <typename... FnTys> Expr *IgnoreExprNodes(Expr *E, FnTys &&... Fns) {
  34.   Expr *LastE = nullptr;
  35.   while (E != LastE) {
  36.     LastE = E;
  37.     E = detail::IgnoreExprNodesImpl(E, std::forward<FnTys>(Fns)...);
  38.   }
  39.   return E;
  40. }
  41.  
  42. template <typename... FnTys>
  43. const Expr *IgnoreExprNodes(const Expr *E, FnTys &&...Fns) {
  44.   return IgnoreExprNodes(const_cast<Expr *>(E), std::forward<FnTys>(Fns)...);
  45. }
  46.  
  47. inline Expr *IgnoreImplicitCastsSingleStep(Expr *E) {
  48.   if (auto *ICE = dyn_cast<ImplicitCastExpr>(E))
  49.     return ICE->getSubExpr();
  50.  
  51.   if (auto *FE = dyn_cast<FullExpr>(E))
  52.     return FE->getSubExpr();
  53.  
  54.   return E;
  55. }
  56.  
  57. inline Expr *IgnoreImplicitCastsExtraSingleStep(Expr *E) {
  58.   // FIXME: Skip MaterializeTemporaryExpr and SubstNonTypeTemplateParmExpr in
  59.   // addition to what IgnoreImpCasts() skips to account for the current
  60.   // behaviour of IgnoreParenImpCasts().
  61.   Expr *SubE = IgnoreImplicitCastsSingleStep(E);
  62.   if (SubE != E)
  63.     return SubE;
  64.  
  65.   if (auto *MTE = dyn_cast<MaterializeTemporaryExpr>(E))
  66.     return MTE->getSubExpr();
  67.  
  68.   if (auto *NTTP = dyn_cast<SubstNonTypeTemplateParmExpr>(E))
  69.     return NTTP->getReplacement();
  70.  
  71.   return E;
  72. }
  73.  
  74. inline Expr *IgnoreCastsSingleStep(Expr *E) {
  75.   if (auto *CE = dyn_cast<CastExpr>(E))
  76.     return CE->getSubExpr();
  77.  
  78.   if (auto *FE = dyn_cast<FullExpr>(E))
  79.     return FE->getSubExpr();
  80.  
  81.   if (auto *MTE = dyn_cast<MaterializeTemporaryExpr>(E))
  82.     return MTE->getSubExpr();
  83.  
  84.   if (auto *NTTP = dyn_cast<SubstNonTypeTemplateParmExpr>(E))
  85.     return NTTP->getReplacement();
  86.  
  87.   return E;
  88. }
  89.  
  90. inline Expr *IgnoreLValueCastsSingleStep(Expr *E) {
  91.   // Skip what IgnoreCastsSingleStep skips, except that only
  92.   // lvalue-to-rvalue casts are skipped.
  93.   if (auto *CE = dyn_cast<CastExpr>(E))
  94.     if (CE->getCastKind() != CK_LValueToRValue)
  95.       return E;
  96.  
  97.   return IgnoreCastsSingleStep(E);
  98. }
  99.  
  100. inline Expr *IgnoreBaseCastsSingleStep(Expr *E) {
  101.   if (auto *CE = dyn_cast<CastExpr>(E))
  102.     if (CE->getCastKind() == CK_DerivedToBase ||
  103.         CE->getCastKind() == CK_UncheckedDerivedToBase ||
  104.         CE->getCastKind() == CK_NoOp)
  105.       return CE->getSubExpr();
  106.  
  107.   return E;
  108. }
  109.  
  110. inline Expr *IgnoreImplicitSingleStep(Expr *E) {
  111.   Expr *SubE = IgnoreImplicitCastsSingleStep(E);
  112.   if (SubE != E)
  113.     return SubE;
  114.  
  115.   if (auto *MTE = dyn_cast<MaterializeTemporaryExpr>(E))
  116.     return MTE->getSubExpr();
  117.  
  118.   if (auto *BTE = dyn_cast<CXXBindTemporaryExpr>(E))
  119.     return BTE->getSubExpr();
  120.  
  121.   return E;
  122. }
  123.  
  124. inline Expr *IgnoreElidableImplicitConstructorSingleStep(Expr *E) {
  125.   auto *CCE = dyn_cast<CXXConstructExpr>(E);
  126.   if (CCE && CCE->isElidable() && !isa<CXXTemporaryObjectExpr>(CCE)) {
  127.     unsigned NumArgs = CCE->getNumArgs();
  128.     if ((NumArgs == 1 ||
  129.          (NumArgs > 1 && CCE->getArg(1)->isDefaultArgument())) &&
  130.         !CCE->getArg(0)->isDefaultArgument() && !CCE->isListInitialization())
  131.       return CCE->getArg(0);
  132.   }
  133.   return E;
  134. }
  135.  
  136. inline Expr *IgnoreImplicitAsWrittenSingleStep(Expr *E) {
  137.   if (auto *ICE = dyn_cast<ImplicitCastExpr>(E))
  138.     return ICE->getSubExprAsWritten();
  139.  
  140.   return IgnoreImplicitSingleStep(E);
  141. }
  142.  
  143. inline Expr *IgnoreParensOnlySingleStep(Expr *E) {
  144.   if (auto *PE = dyn_cast<ParenExpr>(E))
  145.     return PE->getSubExpr();
  146.   return E;
  147. }
  148.  
  149. inline Expr *IgnoreParensSingleStep(Expr *E) {
  150.   if (auto *PE = dyn_cast<ParenExpr>(E))
  151.     return PE->getSubExpr();
  152.  
  153.   if (auto *UO = dyn_cast<UnaryOperator>(E)) {
  154.     if (UO->getOpcode() == UO_Extension)
  155.       return UO->getSubExpr();
  156.   }
  157.  
  158.   else if (auto *GSE = dyn_cast<GenericSelectionExpr>(E)) {
  159.     if (!GSE->isResultDependent())
  160.       return GSE->getResultExpr();
  161.   }
  162.  
  163.   else if (auto *CE = dyn_cast<ChooseExpr>(E)) {
  164.     if (!CE->isConditionDependent())
  165.       return CE->getChosenSubExpr();
  166.   }
  167.  
  168.   return E;
  169. }
  170.  
  171. } // namespace clang
  172.  
  173. #endif // LLVM_CLANG_AST_IGNOREEXPR_H
  174.