Compound literals, enums, et al require const expr

Summary:
Compound literals,  enums, file-scoped arrays, etc. require their
initializers and size specifiers to be constant. Wrap the initializer
expressions in a ConstantExpr so that we can easily check for this later
on.

Reviewers: rsmith, shafik

Reviewed By: rsmith

Subscribers: cfe-commits, jyknight, nickdesaulniers

Differential Revision: https://reviews.llvm.org/D53921

git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@346455 91177308-0d34-0410-b5e6-96231b3b80d8

diff --git a/include/clang/AST/Expr.h b/include/clang/AST/Expr.h
index 1347f008d9f6d2ea3e05ccac79191ef7b0ec6d87..acfa55c30f75e8043446d5048b1c8db36baf2b76 100644 (file)
--- a/include/clang/AST/Expr.h
+++ b/include/clang/AST/Expr.h
@@ -3024,8 +3024,7 @@ class ImplicitCastExpr final
 private:
   ImplicitCastExpr(QualType ty, CastKind kind, Expr *op,
                    unsigned BasePathLength, ExprValueKind VK)
-    : CastExpr(ImplicitCastExprClass, ty, VK, kind, op, BasePathLength) {
-  }
+    : CastExpr(ImplicitCastExprClass, ty, VK, kind, op, BasePathLength) { }
 
   /// Construct an empty implicit cast.
   explicit ImplicitCastExpr(EmptyShell Shell, unsigned PathSize)
@@ -3068,8 +3067,13 @@ public:
 
 inline Expr *Expr::IgnoreImpCasts() {
   Expr *e = this;
-  while (ImplicitCastExpr *ice = dyn_cast<ImplicitCastExpr>(e))
-    e = ice->getSubExpr();
+  while (true)
+    if (ImplicitCastExpr *ice = dyn_cast<ImplicitCastExpr>(e))
+      e = ice->getSubExpr();
+    else if (ConstantExpr *ce = dyn_cast<ConstantExpr>(e))
+      e = ce->getSubExpr();
+    else
+      break;
   return e;
 }
 

diff --git a/include/clang/ASTMatchers/ASTMatchers.h b/include/clang/ASTMatchers/ASTMatchers.h
index 6635f25d5572427bd47668610fc2c68ff20ec1f2..7a52ec50db0534e344af568e0869c09bb8d0a728 100644 (file)
--- a/include/clang/ASTMatchers/ASTMatchers.h
+++ b/include/clang/ASTMatchers/ASTMatchers.h
@@ -1574,6 +1574,18 @@ extern const internal::VariadicDynCastAllOfMatcher<Decl,
                                                    UnresolvedUsingTypenameDecl>
     unresolvedUsingTypenameDecl;
 
+/// Matches a constant expression wrapper.
+///
+/// Example matches the constant in the case statement:
+///     (matcher = constantExpr())
+/// \code
+///   switch (a) {
+///   case 37: break;
+///   }
+/// \endcode
+extern const internal::VariadicDynCastAllOfMatcher<Stmt, ConstantExpr>
+    constantExpr;
+
 /// Matches parentheses used in expressions.
 ///
 /// Example matches (foo() + 1)

diff --git a/lib/AST/ASTImporter.cpp b/lib/AST/ASTImporter.cpp
index 53568f1169aac97e815bfa28e23a7df4e86e6e65..486fd4d43ae36c4dda26186c5cf0df1d17035481 100644 (file)
--- a/lib/AST/ASTImporter.cpp
+++ b/lib/AST/ASTImporter.cpp
@@ -579,6 +579,7 @@ namespace clang {
     ExpectedStmt VisitCompoundLiteralExpr(CompoundLiteralExpr *E);
     ExpectedStmt VisitAtomicExpr(AtomicExpr *E);
     ExpectedStmt VisitAddrLabelExpr(AddrLabelExpr *E);
+    ExpectedStmt VisitConstantExpr(ConstantExpr *E);
     ExpectedStmt VisitParenExpr(ParenExpr *E);
     ExpectedStmt VisitParenListExpr(ParenListExpr *E);
     ExpectedStmt VisitStmtExpr(StmtExpr *E);
@@ -6366,6 +6367,17 @@ ExpectedStmt ASTNodeImporter::VisitAddrLabelExpr(AddrLabelExpr *E) {
       ToAmpAmpLoc, ToLabelLoc, ToLabel, ToType);
 }
 
+ExpectedStmt ASTNodeImporter::VisitConstantExpr(ConstantExpr *E) {
+  auto Imp = importSeq(E->getSubExpr());
+  if (!Imp)
+    return Imp.takeError();
+
+  Expr *ToSubExpr;
+  std::tie(ToSubExpr) = *Imp;
+
+  return new (Importer.getToContext()) ConstantExpr(ToSubExpr);
+}
+
 ExpectedStmt ASTNodeImporter::VisitParenExpr(ParenExpr *E) {
   auto Imp = importSeq(E->getLParen(), E->getRParen(), E->getSubExpr());
   if (!Imp)

diff --git a/lib/AST/Expr.cpp b/lib/AST/Expr.cpp
index 8b512815e812d0a4f018bd1e00e3871730bb30c7..c2351955ee15079fc478e40d3cf8626e226f8dc8 100644 (file)
--- a/lib/AST/Expr.cpp
+++ b/lib/AST/Expr.cpp
@@ -2585,6 +2585,10 @@ Expr *Expr::IgnoreParenCasts() {
       E = NTTP->getReplacement();
       continue;
     }
+    if (ConstantExpr *CE = dyn_cast<ConstantExpr>(E)) {
+      E = CE->getSubExpr();
+      continue;
+    }
     return E;
   }
 }
@@ -2606,6 +2610,10 @@ Expr *Expr::IgnoreCasts() {
       E = NTTP->getReplacement();
       continue;
     }
+    if (ConstantExpr *CE = dyn_cast<ConstantExpr>(E)) {
+      E = CE->getSubExpr();
+      continue;
+    }
     return E;
   }
 }
@@ -2631,6 +2639,9 @@ Expr *Expr::IgnoreParenLValueCasts() {
                                   = dyn_cast<SubstNonTypeTemplateParmExpr>(E)) {
       E = NTTP->getReplacement();
       continue;
+    } else if (ConstantExpr *CE = dyn_cast<ConstantExpr>(E)) {
+      E = CE->getSubExpr();
+      continue;
     }
     break;
   }
@@ -2672,6 +2683,10 @@ Expr *Expr::IgnoreParenImpCasts() {
       E = NTTP->getReplacement();
       continue;
     }
+    if (ConstantExpr *CE = dyn_cast<ConstantExpr>(E)) {
+      E = CE->getSubExpr();
+      continue;
+    }
     return E;
   }
 }

diff --git a/lib/AST/ExprConstant.cpp b/lib/AST/ExprConstant.cpp
index 78c747196c026b0e6d2f9c047000e063993e488e..30800568a22a35cdbeafbb7686c345f40c267eeb 100644 (file)
--- a/lib/AST/ExprConstant.cpp
+++ b/lib/AST/ExprConstant.cpp
@@ -4719,6 +4719,8 @@ public:
     return Error(E);
   }
 
+  bool VisitConstantExpr(const ConstantExpr *E)
+    { return StmtVisitorTy::Visit(E->getSubExpr()); }
   bool VisitParenExpr(const ParenExpr *E)
     { return StmtVisitorTy::Visit(E->getSubExpr()); }
   bool VisitUnaryExtension(const UnaryOperator *E)

diff --git a/lib/ASTMatchers/ASTMatchersInternal.cpp b/lib/ASTMatchers/ASTMatchersInternal.cpp
index 38825257105476d7dba398cc13b2b763fabb2cf5..08fca5b46bdc76f185e2345710974fe56e4081b3 100644 (file)
--- a/lib/ASTMatchers/ASTMatchersInternal.cpp
+++ b/lib/ASTMatchers/ASTMatchersInternal.cpp
@@ -666,6 +666,7 @@ const internal::VariadicDynCastAllOfMatcher<Decl, UnresolvedUsingValueDecl>
     unresolvedUsingValueDecl;
 const internal::VariadicDynCastAllOfMatcher<Decl, UnresolvedUsingTypenameDecl>
     unresolvedUsingTypenameDecl;
+const internal::VariadicDynCastAllOfMatcher<Stmt, ConstantExpr> constantExpr;
 const internal::VariadicDynCastAllOfMatcher<Stmt, ParenExpr> parenExpr;
 const internal::VariadicDynCastAllOfMatcher<Stmt, CXXConstructExpr>
     cxxConstructExpr;

diff --git a/lib/ASTMatchers/Dynamic/Registry.cpp b/lib/ASTMatchers/Dynamic/Registry.cpp
index 318f39dee94e9450767f87d33afe0c820262a797..7493389fbdad5bf13acc8910b9c8475771da247f 100644 (file)
--- a/lib/ASTMatchers/Dynamic/Registry.cpp
+++ b/lib/ASTMatchers/Dynamic/Registry.cpp
@@ -153,6 +153,7 @@ RegistryMaps::RegistryMaps() {
   REGISTER_MATCHER(compoundStmt);
   REGISTER_MATCHER(conditionalOperator);
   REGISTER_MATCHER(constantArrayType);
+  REGISTER_MATCHER(constantExpr);
   REGISTER_MATCHER(containsDeclaration);
   REGISTER_MATCHER(continueStmt);
   REGISTER_MATCHER(cStyleCastExpr);

diff --git a/lib/Analysis/CFG.cpp b/lib/Analysis/CFG.cpp
index c7724e200b74e07e3eb77d9016f16b2285046e5f..cfda27dd37a25d49b93d657539d528df3cc5b29f 100644 (file)
--- a/lib/Analysis/CFG.cpp
+++ b/lib/Analysis/CFG.cpp
@@ -551,6 +551,7 @@ private:
   CFGBlock *VisitGotoStmt(GotoStmt *G);
   CFGBlock *VisitIfStmt(IfStmt *I);
   CFGBlock *VisitImplicitCastExpr(ImplicitCastExpr *E, AddStmtChoice asc);
+  CFGBlock *VisitConstantExpr(ConstantExpr *E, AddStmtChoice asc);
   CFGBlock *VisitIndirectGotoStmt(IndirectGotoStmt *I);
   CFGBlock *VisitLabelStmt(LabelStmt *L);
   CFGBlock *VisitBlockExpr(BlockExpr *E, AddStmtChoice asc);
@@ -2100,6 +2101,9 @@ CFGBlock *CFGBuilder::Visit(Stmt * S, AddStmtChoice asc) {
     case Stmt::ImplicitCastExprClass:
       return VisitImplicitCastExpr(cast<ImplicitCastExpr>(S), asc);
 
+    case Stmt::ConstantExprClass:
+      return VisitConstantExpr(cast<ConstantExpr>(S), asc);
+
     case Stmt::IndirectGotoStmtClass:
       return VisitIndirectGotoStmt(cast<IndirectGotoStmt>(S));
 
@@ -4380,6 +4384,10 @@ CFGBlock *CFGBuilder::VisitImplicitCastExpr(ImplicitCastExpr *E,
   return Visit(E->getSubExpr(), AddStmtChoice());
 }
 
+CFGBlock *CFGBuilder::VisitConstantExpr(ConstantExpr *E, AddStmtChoice asc) {
+  return Visit(E->getSubExpr(), AddStmtChoice());
+}
+
 CFGBlock *CFGBuilder::VisitIndirectGotoStmt(IndirectGotoStmt *I) {
   // Lazily create the indirect-goto dispatch block if there isn't one already.
   CFGBlock *IBlock = cfg->getIndirectGotoBlock();
@@ -4436,6 +4444,10 @@ tryAgain:
       E = cast<CXXFunctionalCastExpr>(E)->getSubExpr();
       goto tryAgain;
 
+    case Stmt::ConstantExprClass:
+      E = cast<ConstantExpr>(E)->getSubExpr();
+      goto tryAgain;
+
     case Stmt::ParenExprClass:
       E = cast<ParenExpr>(E)->getSubExpr();
       goto tryAgain;

diff --git a/lib/CodeGen/CGExpr.cpp b/lib/CodeGen/CGExpr.cpp
index 0fd19c9578e382c2848d13835be0350c86931362..dafca7cf7cce0228cac03e5938a95f98b673c0e1 100644 (file)
--- a/lib/CodeGen/CGExpr.cpp
+++ b/lib/CodeGen/CGExpr.cpp
@@ -1260,6 +1260,8 @@ LValue CodeGenFunction::EmitLValue(const Expr *E) {
     return EmitVAArgExprLValue(cast<VAArgExpr>(E));
   case Expr::DeclRefExprClass:
     return EmitDeclRefLValue(cast<DeclRefExpr>(E));
+  case Expr::ConstantExprClass:
+    return EmitLValue(cast<ConstantExpr>(E)->getSubExpr());
   case Expr::ParenExprClass:
     return EmitLValue(cast<ParenExpr>(E)->getSubExpr());
   case Expr::GenericSelectionExprClass:

diff --git a/lib/CodeGen/CGExprAgg.cpp b/lib/CodeGen/CGExprAgg.cpp
index 42481939fa13235a4c2a81b7f696caf9f71033e0..db49b3f28a59127a9a531e5d7d28a90fa57cb9d2 100644 (file)
--- a/lib/CodeGen/CGExprAgg.cpp
+++ b/lib/CodeGen/CGExprAgg.cpp
@@ -125,6 +125,10 @@ public:
     return Visit(E->getReplacement());
   }
 
+  void VisitConstantExpr(ConstantExpr *E) {
+    return Visit(E->getSubExpr());
+  }
+
   // l-values.
   void VisitDeclRefExpr(DeclRefExpr *E) { EmitAggLoadOfLValue(E); }
   void VisitMemberExpr(MemberExpr *ME) { EmitAggLoadOfLValue(ME); }

diff --git a/lib/CodeGen/CGExprComplex.cpp b/lib/CodeGen/CGExprComplex.cpp
index c0b87c850e978d5b8b151ee159aae0eaf6015084..2db693b44c90123b5acacef5e4c74db32b9c81ed 100644 (file)
--- a/lib/CodeGen/CGExprComplex.cpp
+++ b/lib/CodeGen/CGExprComplex.cpp
@@ -101,6 +101,9 @@ public:
     llvm_unreachable("Stmt can't have complex result type!");
   }
   ComplexPairTy VisitExpr(Expr *S);
+  ComplexPairTy VisitConstantExpr(ConstantExpr *E) {
+    return Visit(E->getSubExpr());
+  }
   ComplexPairTy VisitParenExpr(ParenExpr *PE) { return Visit(PE->getSubExpr());}
   ComplexPairTy VisitGenericSelectionExpr(GenericSelectionExpr *GE) {
     return Visit(GE->getResultExpr());

diff --git a/lib/CodeGen/CGExprConstant.cpp b/lib/CodeGen/CGExprConstant.cpp
index 1339c06646c8af2724244189e79b3f1e98724f88..eb5e010968430251b3fbd92b97abe0276266dd0f 100644 (file)
--- a/lib/CodeGen/CGExprConstant.cpp
+++ b/lib/CodeGen/CGExprConstant.cpp
@@ -723,6 +723,10 @@ public:
     return nullptr;
   }
 
+  llvm::Constant *VisitConstantExpr(ConstantExpr *CE, QualType T) {
+    return Visit(CE->getSubExpr(), T);
+  }
+
   llvm::Constant *VisitParenExpr(ParenExpr *PE, QualType T) {
     return Visit(PE->getSubExpr(), T);
   }
@@ -1601,6 +1605,7 @@ private:
   ConstantLValue tryEmitBase(const APValue::LValueBase &base);
 
   ConstantLValue VisitStmt(const Stmt *S) { return nullptr; }
+  ConstantLValue VisitConstantExpr(const ConstantExpr *E);
   ConstantLValue VisitCompoundLiteralExpr(const CompoundLiteralExpr *E);
   ConstantLValue VisitStringLiteral(const StringLiteral *E);
   ConstantLValue VisitObjCEncodeExpr(const ObjCEncodeExpr *E);
@@ -1755,6 +1760,11 @@ ConstantLValueEmitter::tryEmitBase(const APValue::LValueBase &base) {
   return Visit(base.get<const Expr*>());
 }
 
+ConstantLValue
+ConstantLValueEmitter::VisitConstantExpr(const ConstantExpr *E) {
+  return Visit(E->getSubExpr());
+}
+
 ConstantLValue
 ConstantLValueEmitter::VisitCompoundLiteralExpr(const CompoundLiteralExpr *E) {
   return tryEmitGlobalCompoundLiteral(CGM, Emitter.CGF, E);

diff --git a/lib/CodeGen/CGExprScalar.cpp b/lib/CodeGen/CGExprScalar.cpp
index 0611b9186af39c5b72b991f37f06de007790d0b6..801f4a9fc1aa1c9c2199dbd8a2fe99ce38d8b6ad 100644 (file)
--- a/lib/CodeGen/CGExprScalar.cpp
+++ b/lib/CodeGen/CGExprScalar.cpp
@@ -398,6 +398,9 @@ public:
   }
   Value *VisitExpr(Expr *S);
 
+  Value *VisitConstantExpr(ConstantExpr *E) {
+    return Visit(E->getSubExpr());
+  }
   Value *VisitParenExpr(ParenExpr *PE) {
     return Visit(PE->getSubExpr());
   }

diff --git a/lib/Sema/SemaExpr.cpp b/lib/Sema/SemaExpr.cpp
index 428bd7a5922301463736d798f9ea1126fb4a0c4f..c549514da83e46d027ba0aeaa10d748fd7cde1ef 100644 (file)
--- a/lib/Sema/SemaExpr.cpp
+++ b/lib/Sema/SemaExpr.cpp
@@ -5745,21 +5745,6 @@ Sema::BuildCompoundLiteralExpr(SourceLocation LParenLoc, TypeSourceInfo *TInfo,
   LiteralExpr = Result.get();
 
   bool isFileScope = !CurContext->isFunctionOrMethod();
-  if (isFileScope) {
-    if (!LiteralExpr->isTypeDependent() &&
-        !LiteralExpr->isValueDependent() &&
-        !literalType->isDependentType()) // C99 6.5.2.5p3
-      if (CheckForConstantInitializer(LiteralExpr, literalType))
-        return ExprError();
-  } else if (literalType.getAddressSpace() != LangAS::opencl_private &&
-             literalType.getAddressSpace() != LangAS::Default) {
-    // Embedded-C extensions to C99 6.5.2.5:
-    //   "If the compound literal occurs inside the body of a function, the
-    //   type name shall not be qualified by an address-space qualifier."
-    Diag(LParenLoc, diag::err_compound_literal_with_address_space)
-      << SourceRange(LParenLoc, LiteralExpr->getSourceRange().getEnd());
-    return ExprError();
-  }
 
   // In C, compound literals are l-values for some reason.
   // For GCC compatibility, in C++, file-scope array compound literals with
@@ -5784,9 +5769,26 @@ Sema::BuildCompoundLiteralExpr(SourceLocation LParenLoc, TypeSourceInfo *TInfo,
           ? VK_RValue
           : VK_LValue;
 
-  return MaybeBindToTemporary(
-      new (Context) CompoundLiteralExpr(LParenLoc, TInfo, literalType,
-                                        VK, LiteralExpr, isFileScope));
+  Expr *E = new (Context) CompoundLiteralExpr(LParenLoc, TInfo, literalType,
+                                              VK, LiteralExpr, isFileScope);
+  if (isFileScope) {
+    if (!LiteralExpr->isTypeDependent() &&
+        !LiteralExpr->isValueDependent() &&
+        !literalType->isDependentType()) // C99 6.5.2.5p3
+      if (CheckForConstantInitializer(LiteralExpr, literalType))
+        return ExprError();
+    E = new (Context) ConstantExpr(E);
+  } else if (literalType.getAddressSpace() != LangAS::opencl_private &&
+             literalType.getAddressSpace() != LangAS::Default) {
+    // Embedded-C extensions to C99 6.5.2.5:
+    //   "If the compound literal occurs inside the body of a function, the
+    //   type name shall not be qualified by an address-space qualifier."
+    Diag(LParenLoc, diag::err_compound_literal_with_address_space)
+      << SourceRange(LParenLoc, LiteralExpr->getSourceRange().getEnd());
+    return ExprError();
+  }
+
+  return MaybeBindToTemporary(E);
 }
 
 ExprResult
@@ -14144,7 +14146,7 @@ Sema::VerifyIntegerConstantExpression(Expr *E, llvm::APSInt *Result,
   if (!getLangOpts().CPlusPlus11 && E->isIntegerConstantExpr(Context)) {
     if (Result)
       *Result = E->EvaluateKnownConstIntCheckOverflow(Context);
-    return E;
+    return new (Context) ConstantExpr(E);
   }
 
   Expr::EvalResult EvalResult;
@@ -14162,7 +14164,7 @@ Sema::VerifyIntegerConstantExpression(Expr *E, llvm::APSInt *Result,
   if (Folded && getLangOpts().CPlusPlus11 && Notes.empty()) {
     if (Result)
       *Result = EvalResult.Val.getInt();
-    return E;
+    return new (Context) ConstantExpr(E);
   }
 
   // If our only note is the usual "invalid subexpression" note, just point
@@ -14190,7 +14192,7 @@ Sema::VerifyIntegerConstantExpression(Expr *E, llvm::APSInt *Result,
 
   if (Result)
     *Result = EvalResult.Val.getInt();
-  return E;
+  return new (Context) ConstantExpr(E);
 }
 
 namespace {
@@ -16634,4 +16636,4 @@ ExprResult Sema::ActOnObjCAvailabilityCheckExpr(
 
   return new (Context)
       ObjCAvailabilityCheckExpr(Version, AtLoc, RParen, Context.BoolTy);
-}
\ No newline at end of file
+}

diff --git a/lib/Sema/SemaInit.cpp b/lib/Sema/SemaInit.cpp
index 11a1f8509a1bd0950268351c4f7e420d88f2492f..438e90414d6db1b0db17edba1d4a7d2a7f0b2ade 100644 (file)
--- a/lib/Sema/SemaInit.cpp
+++ b/lib/Sema/SemaInit.cpp
@@ -5527,7 +5527,8 @@ void InitializationSequence::InitializeFrom(Sema &S,
     // array from a compound literal that creates an array of the same
     // type, so long as the initializer has no side effects.
     if (!S.getLangOpts().CPlusPlus && Initializer &&
-        isa<CompoundLiteralExpr>(Initializer->IgnoreParens()) &&
+        (isa<ConstantExpr>(Initializer->IgnoreParens()) ||
+         isa<CompoundLiteralExpr>(Initializer->IgnoreParens())) &&
         Initializer->getType()->isArrayType()) {
       const ArrayType *SourceAT
         = Context.getAsArrayType(Initializer->getType());

diff --git a/lib/Sema/SemaOverload.cpp b/lib/Sema/SemaOverload.cpp
index edb2ec21f0497c014f424736a82e8b5c7ef0a236..3466da6e5a71641cebf7416483209e4e2c30d75d 100644 (file)
--- a/lib/Sema/SemaOverload.cpp
+++ b/lib/Sema/SemaOverload.cpp
@@ -5444,7 +5444,7 @@ static ExprResult CheckConvertedConstantExpression(Sema &S, Expr *From,
 
     if (Notes.empty()) {
       // It's a constant expression.
-      return Result;
+      return new (S.Context) ConstantExpr(Result.get());
     }
   }
 

diff --git a/lib/Sema/SemaType.cpp b/lib/Sema/SemaType.cpp
index 200bab6c84bbe9a7dc4099d14493d137e3f67f98..957090c1be360e16f623a1ceeca4623776db3908 100644 (file)
--- a/lib/Sema/SemaType.cpp
+++ b/lib/Sema/SemaType.cpp
@@ -2233,6 +2233,10 @@ QualType Sema::BuildArrayType(QualType T, ArrayType::ArraySizeModifier ASM,
     T = Context.getConstantArrayType(T, ConstVal, ASM, Quals);
   }
 
+  if (ArraySize && !CurContext->isFunctionOrMethod())
+    // A file-scoped array must have a constant array size.
+    ArraySize = new (Context) ConstantExpr(ArraySize);
+
   // OpenCL v1.2 s6.9.d: variable length arrays are not supported.
   if (getLangOpts().OpenCL && T->isVariableArrayType()) {
     Diag(Loc, diag::err_opencl_vla);

diff --git a/lib/StaticAnalyzer/Core/Environment.cpp b/lib/StaticAnalyzer/Core/Environment.cpp
index da99dbc7acba619757e499fb56b4e4abb35039e9..43bbcd7c6af7ba2e5a110255d1b11ffcba047f5d 100644 (file)
--- a/lib/StaticAnalyzer/Core/Environment.cpp
+++ b/lib/StaticAnalyzer/Core/Environment.cpp
@@ -92,6 +92,7 @@ SVal Environment::getSVal(const EnvironmentEntry &Entry,
   case Stmt::ExprWithCleanupsClass:
   case Stmt::GenericSelectionExprClass:
   case Stmt::OpaqueValueExprClass:
+  case Stmt::ConstantExprClass:
   case Stmt::ParenExprClass:
   case Stmt::SubstNonTypeTemplateParmExprClass:
     llvm_unreachable("Should have been handled by ignoreTransparentExprs");

diff --git a/lib/StaticAnalyzer/Core/ExprEngine.cpp b/lib/StaticAnalyzer/Core/ExprEngine.cpp
index 2b48cd0f72d2983ab8af7f37081992e4046b35b9..91f022d1e445424b6e7fa7b5a442dd6ed6f2bb79 100644 (file)
--- a/lib/StaticAnalyzer/Core/ExprEngine.cpp
+++ b/lib/StaticAnalyzer/Core/ExprEngine.cpp
@@ -1267,9 +1267,6 @@ void ExprEngine::Visit(const Stmt *S, ExplodedNode *Pred,
     case Stmt::ObjCPropertyRefExprClass:
       llvm_unreachable("These are handled by PseudoObjectExpr");
 
-    case Expr::ConstantExprClass:
-      return Visit(cast<ConstantExpr>(S)->getSubExpr(), Pred, DstTop);
-
     case Stmt::GNUNullExprClass: {
       // GNU __null is a pointer-width integer, not an actual pointer.
       ProgramStateRef state = Pred->getState();
@@ -1285,6 +1282,10 @@ void ExprEngine::Visit(const Stmt *S, ExplodedNode *Pred,
       Bldr.addNodes(Dst);
       break;
 
+    case Expr::ConstantExprClass:
+      // Handled due to it being a wrapper class.
+      break;
+
     case Stmt::ExprWithCleanupsClass:
       // Handled due to fully linearised CFG.
       break;

diff --git a/test/Import/switch-stmt/test.cpp b/test/Import/switch-stmt/test.cpp
index 05132b7d9b1415fd7e71af33520194d8bb1ba118..e274e895c444e7e9dcdcd70da5798efc42acc7a2 100644 (file)
--- a/test/Import/switch-stmt/test.cpp
+++ b/test/Import/switch-stmt/test.cpp
@@ -4,15 +4,21 @@
 // CHECK-NEXT: IntegerLiteral
 // CHECK-NEXT: CompoundStmt
 // CHECK-NEXT: CaseStmt
+// CHECK-NEXT: ConstantExpr
 // CHECK-NEXT: IntegerLiteral
 // CHECK-NEXT: CaseStmt
+// CHECK-NEXT: ConstantExpr
 // CHECK-NEXT: IntegerLiteral
 // CHECK-NEXT: BreakStmt
 // CHECK-NEXT: CaseStmt
+// CHECK-NEXT: ConstantExpr
 // CHECK-NEXT: IntegerLiteral
+// CHECK-NEXT: ConstantExpr
 // CHECK-NEXT: IntegerLiteral
 // CHECK-NEXT: CaseStmt
+// CHECK-NEXT: ConstantExpr
 // CHECK-NEXT: IntegerLiteral
+// CHECK-NEXT: ConstantExpr
 // CHECK-NEXT: IntegerLiteral
 // CHECK-NEXT: BreakStmt
 
@@ -23,13 +29,17 @@
 // CHECK-NEXT: IntegerLiteral
 // CHECK-NEXT: CompoundStmt
 // CHECK-NEXT: CaseStmt
+// CHECK-NEXT: ConstantExpr
 // CHECK-NEXT: IntegerLiteral
 // CHECK-NEXT: BreakStmt
 // CHECK-NEXT: CaseStmt
+// CHECK-NEXT: ConstantExpr
 // CHECK-NEXT: IntegerLiteral
 // CHECK-NEXT: BreakStmt
 // CHECK-NEXT: CaseStmt
+// CHECK-NEXT: ConstantExpr
 // CHECK-NEXT: IntegerLiteral
+// CHECK-NEXT: ConstantExpr
 // CHECK-NEXT: IntegerLiteral
 // CHECK-NEXT: BreakStmt
 

diff --git a/test/Misc/ast-dump-attr.cpp b/test/Misc/ast-dump-attr.cpp
index 5ed3c73aa2370bf93f1a2d257c95ab7e835e5290..b0b08dd6f00eddf9a1d1725e8a6d89ee55a09ab7 100644 (file)
--- a/test/Misc/ast-dump-attr.cpp
+++ b/test/Misc/ast-dump-attr.cpp
@@ -35,7 +35,8 @@ int TestAlignedNull __attribute__((aligned));
 int TestAlignedExpr __attribute__((aligned(4)));\r
 // CHECK:      VarDecl{{.*}}TestAlignedExpr\r
 // CHECK-NEXT:   AlignedAttr {{.*}} aligned\r
-// CHECK-NEXT:     IntegerLiteral\r
+// CHECK-NEXT:     ConstantExpr\r
+// CHECK-NEXT:       IntegerLiteral\r
 \r
 int TestEnum __attribute__((visibility("default")));\r
 // CHECK:      VarDecl{{.*}}TestEnum\r

diff --git a/test/Misc/ast-dump-c-attr.c b/test/Misc/ast-dump-c-attr.c
index 701df78e61f991a90c80abf6a05a4f43b49275b5..8452b797e2bd3dcbb93cd20ee533642a67dbe5b8 100644 (file)
--- a/test/Misc/ast-dump-c-attr.c
+++ b/test/Misc/ast-dump-c-attr.c
@@ -23,7 +23,8 @@ struct [[deprecated]] Test4 {
 // CHECK-NEXT:   FieldDecl{{.*}}Test6\r
 // CHECK-NEXT:     DeprecatedAttr 0x{{[^ ]*}} <col:5, col:25> "Frobble" ""\r
 // CHECK-NEXT:   FieldDecl{{.*}}Test7\r
-// CHECK-NEXT:     IntegerLiteral{{.*}}'int' 12\r
+// CHECK-NEXT:     Constant{{.*}}'int'\r
+// CHECK-NEXT:       IntegerLiteral{{.*}}'int' 12\r
 // CHECK-NEXT:     DeprecatedAttr 0x{{[^ ]*}} <col:15> "" ""\r
 \r
 struct [[deprecated]] Test8;\r

diff --git a/test/Misc/ast-dump-color.cpp b/test/Misc/ast-dump-color.cpp
index f21a72858697c20246ffd74d74d2655fbc0de8d0..8cf52049251bdf4618ef48ed3672f82a430d7ec0 100644 (file)
--- a/test/Misc/ast-dump-color.cpp
+++ b/test/Misc/ast-dump-color.cpp
@@ -49,12 +49,14 @@ struct Invalid {
 //CHECK: {{^}}[[Blue]]| |   |-[[RESET]][[MAGENTA]]IntegerLiteral[[RESET]][[Yellow]] 0x{{[0-9a-fA-F]*}}[[RESET]] <[[Yellow]]line:10:11[[RESET]]> [[Green]]'int'[[RESET]][[Cyan:.\[0;36m]][[RESET]][[Cyan]][[RESET]][[CYAN]] 1[[RESET]]{{$}}
 //CHECK: {{^}}[[Blue]]| |   `-[[RESET]][[MAGENTA]]CompoundStmt[[RESET]][[Yellow]] 0x{{[0-9a-fA-F]*}}[[RESET]] <[[Yellow]]col:14[[RESET]], [[Yellow]]line:15:3[[RESET]]>{{$}}
 //CHECK: {{^}}[[Blue]]| |     |-[[RESET]][[MAGENTA]]CaseStmt[[RESET]][[Yellow]] 0x{{[0-9a-fA-F]*}}[[RESET]] <[[Yellow]]line:11:3[[RESET]], [[Yellow]]line:12:27[[RESET]]>{{$}}
-//CHECK: {{^}}[[Blue]]| |     | |-[[RESET]][[MAGENTA]]IntegerLiteral[[RESET]][[Yellow]] 0x{{[0-9a-fA-F]*}}[[RESET]] <[[Yellow]]line:11:8[[RESET]]> [[Green]]'int'[[RESET]][[Cyan]][[RESET]][[Cyan]][[RESET]][[CYAN]] 1[[RESET]]{{$}}
+//CHECK: {{^}}[[Blue]]| |     | |-[[RESET]][[MAGENTA]]ConstantExpr[[RESET]][[Yellow]] 0x{{[0-9a-fA-F]*}}[[RESET]] <[[Yellow]]line:11:8[[RESET]]> [[Green]]'int'[[RESET]][[Cyan]][[RESET]][[Cyan]][[RESET]]{{$}}
+//CHECK: {{^}}[[Blue]]| |     | | `-[[RESET]][[MAGENTA]]IntegerLiteral[[RESET]][[Yellow]] 0x{{[0-9a-fA-F]*}}[[RESET]] <[[Yellow]]col:8[[RESET]]> [[Green]]'int'[[RESET]][[Cyan]][[RESET]][[Cyan]][[RESET]][[CYAN]] 1[[RESET]]{{$}}
 //CHECK: {{^}}[[Blue]]| |     | `-[[RESET]][[MAGENTA]]AttributedStmt[[RESET]][[Yellow]] 0x{{[0-9a-fA-F]*}}[[RESET]] <[[Yellow]]line:12:5[[RESET]], [[Yellow]]col:27[[RESET]]>{{$}}
 //CHECK: {{^}}[[Blue]]| |     |   |-[[RESET]][[BLUE]]FallThroughAttr[[RESET]][[Yellow]] 0x{{[0-9a-fA-F]*}}[[RESET]] <[[Yellow]]col:7[[RESET]], [[Yellow]]col:14[[RESET]]>{{$}}
 //CHECK: {{^}}[[Blue]]| |     |   `-[[RESET]][[MAGENTA]]NullStmt[[RESET]][[Yellow]] 0x{{[0-9a-fA-F]*}}[[RESET]] <[[Yellow]]col:27[[RESET]]>{{$}}
 //CHECK: {{^}}[[Blue]]| |     `-[[RESET]][[MAGENTA]]CaseStmt[[RESET]][[Yellow]] 0x{{[0-9a-fA-F]*}}[[RESET]] <[[Yellow]]line:13:3[[RESET]], [[Yellow]]line:14:5[[RESET]]>{{$}}
-//CHECK: {{^}}[[Blue]]| |       |-[[RESET]][[MAGENTA]]IntegerLiteral[[RESET]][[Yellow]] 0x{{[0-9a-fA-F]*}}[[RESET]] <[[Yellow]]line:13:8[[RESET]]> [[Green]]'int'[[RESET]][[Cyan]][[RESET]][[Cyan]][[RESET]][[CYAN]] 2[[RESET]]{{$}}
+//CHECK: {{^}}[[Blue]]| |       |-[[RESET]][[MAGENTA]]ConstantExpr[[RESET]][[Yellow]] 0x{{[0-9a-fA-F]*}}[[RESET]] <[[Yellow]]line:13:8[[RESET]]> [[Green]]'int'[[RESET]][[Cyan]][[RESET]][[Cyan]][[RESET]]{{$}}
+//CHECK: {{^}}[[Blue]]| |       | `-[[RESET]][[MAGENTA]]IntegerLiteral[[RESET]][[Yellow]] 0x{{[0-9a-fA-F]*}}[[RESET]] <[[Yellow]]col:8[[RESET]]> [[Green]]'int'[[RESET]][[Cyan]][[RESET]][[Cyan]][[RESET]][[CYAN]] 2[[RESET]]{{$}}
 //CHECK: {{^}}[[Blue]]| |       `-[[RESET]][[MAGENTA]]NullStmt[[RESET]][[Yellow]] 0x{{[0-9a-fA-F]*}}[[RESET]] <[[Yellow]]line:14:5[[RESET]]>{{$}}
 //CHECK: {{^}}[[Blue]]| `-[[RESET]][[Blue]]FullComment[[RESET]][[Yellow]] 0x{{[0-9a-fA-F]*}}[[RESET]] <[[Yellow]]line:8:4[[RESET]], [[Yellow]]col:11[[RESET]]>{{$}}
 //CHECK: {{^}}[[Blue]]|   `-[[RESET]][[Blue]]ParagraphComment[[RESET]][[Yellow]] 0x{{[0-9a-fA-F]*}}[[RESET]] <[[Yellow]]col:4[[RESET]], [[Yellow]]col:11[[RESET]]>{{$}}

diff --git a/test/Misc/ast-dump-decl.c b/test/Misc/ast-dump-decl.c
index 71b98c9443cface0b7996d83d359a41a3fd40b8b..e0a8b56f70a59ed900761ebb26628e47c488443c 100644 (file)
--- a/test/Misc/ast-dump-decl.c
+++ b/test/Misc/ast-dump-decl.c
@@ -96,7 +96,8 @@ enum testEnumConstantDecl {
 };
 // CHECK:      EnumConstantDecl{{.*}} TestEnumConstantDecl 'int'
 // CHECK:      EnumConstantDecl{{.*}} TestEnumConstantDeclInit 'int'
-// CHECK-NEXT:   IntegerLiteral
+// CHECK-NEXT:   ConstantExpr
+// CHECK-NEXT:     IntegerLiteral
 
 struct testIndirectFieldDecl {
   struct {
@@ -140,7 +141,8 @@ struct testFieldDecl {
 };
 // CHECK:      FieldDecl{{.*}} TestFieldDecl 'int'
 // CHECK:      FieldDecl{{.*}} TestFieldDeclWidth 'int'
-// CHECK-NEXT:   IntegerLiteral
+// CHECK-NEXT:   ConstantExpr
+// CHECK-NEXT:     IntegerLiteral
 // CHECK-MODULE:      FieldDecl{{.*}} TestFieldDeclPrivate 'int' __module_private__
 
 int TestVarDecl;

diff --git a/test/Misc/ast-dump-decl.cpp b/test/Misc/ast-dump-decl.cpp
index 21ba7ec8dad2ae96d5d6952f4a8c5a600f04fdf6..adab91291e3a8488b69a3826a2d8bb2916ab7e1c 100644 (file)
--- a/test/Misc/ast-dump-decl.cpp
+++ b/test/Misc/ast-dump-decl.cpp
@@ -381,7 +381,8 @@ namespace TestNonTypeTemplateParmDecl {
 // CHECK-NEXT:   FunctionTemplateDecl\r
 // CHECK-NEXT:     NonTypeTemplateParmDecl{{.*}} 'int' depth 0 index 0 I\r
 // CHECK-NEXT:       TemplateArgument expr\r
-// CHECK-NEXT:         IntegerLiteral{{.*}} 'int' 1\r
+// CHECK-NEXT:         ConstantExpr{{.*}} 'int'\r
+// CHECK-NEXT:           IntegerLiteral{{.*}} 'int' 1\r
 // CHECK-NEXT:     NonTypeTemplateParmDecl{{.*}} 'int' depth 0 index 1 ... J\r
 \r
 namespace TestTemplateTemplateParmDecl {\r

diff --git a/test/SemaCXX/compound-literal.cpp b/test/SemaCXX/compound-literal.cpp
index be9ebee00c2fbf61fbaa8d60e4cd7af1eda3c8fc..8ef3f2c93051d821fd1e224c93754e2c4b2986d7 100644 (file)
--- a/test/SemaCXX/compound-literal.cpp
+++ b/test/SemaCXX/compound-literal.cpp
@@ -34,9 +34,18 @@ namespace brace_initializers {
     ~HasCtorDtor();\r
   };\r
 \r
+  POD p = (POD){1, 2};\r
+  // CHECK-NOT: CXXBindTemporaryExpr {{.*}} 'brace_initializers::POD'\r
+  // CHECK: ConstantExpr {{.*}} 'brace_initializers::POD'\r
+  // CHECK-NEXT: CompoundLiteralExpr {{.*}} 'brace_initializers::POD'\r
+  // CHECK-NEXT: InitListExpr {{.*}} 'brace_initializers::POD'\r
+  // CHECK-NEXT: IntegerLiteral {{.*}} 1{{$}}\r
+  // CHECK-NEXT: IntegerLiteral {{.*}} 2{{$}}\r
+\r
   void test() {\r
     (void)(POD){1, 2};\r
     // CHECK-NOT: CXXBindTemporaryExpr {{.*}} 'brace_initializers::POD'\r
+    // CHECK-NOT: ConstantExpr {{.*}} 'brace_initializers::POD'\r
     // CHECK: CompoundLiteralExpr {{.*}} 'brace_initializers::POD'\r
     // CHECK-NEXT: InitListExpr {{.*}} 'brace_initializers::POD'\r
     // CHECK-NEXT: IntegerLiteral {{.*}} 1{{$}}\r
@@ -52,6 +61,7 @@ namespace brace_initializers {
 #if __cplusplus >= 201103L\r
     (void)(HasCtor){1, 2};\r
     // CHECK-CXX11-NOT: CXXBindTemporaryExpr {{.*}} 'brace_initializers::HasCtor'\r
+    // CHECK-CXX11-NOT: ConstantExpr {{.*}} 'brace_initializers::HasCtor'\r
     // CHECK-CXX11: CompoundLiteralExpr {{.*}} 'brace_initializers::HasCtor'\r
     // CHECK-CXX11-NEXT: CXXTemporaryObjectExpr {{.*}} 'brace_initializers::HasCtor'\r
     // CHECK-CXX11-NEXT: IntegerLiteral {{.*}} 1{{$}}\r
@@ -59,7 +69,8 @@ namespace brace_initializers {
 \r
     (void)(HasCtorDtor){1, 2};\r
     // CHECK-CXX11: CXXBindTemporaryExpr {{.*}} 'brace_initializers::HasCtorDtor'\r
-    // CHECK-CXX11-NEXT: CompoundLiteralExpr {{.*}} 'brace_initializers::HasCtorDtor'\r
+    // CHECK-CXX11-NOT: ConstantExpr {{.*}} 'brace_initializers::HasCtorDtor'\r
+    // CHECK-CXX11: CompoundLiteralExpr {{.*}} 'brace_initializers::HasCtorDtor'\r
     // CHECK-CXX11-NEXT: CXXTemporaryObjectExpr {{.*}} 'brace_initializers::HasCtorDtor'\r
     // CHECK-CXX11-NEXT: IntegerLiteral {{.*}} 1{{$}}\r
     // CHECK-CXX11-NEXT: IntegerLiteral {{.*}} 2{{$}}\r

diff --git a/test/Tooling/clang-check-ast-dump.cpp b/test/Tooling/clang-check-ast-dump.cpp
index d8643c79428ed3b6291833226900d6fdfdb40b5b..496d489fd60904a073f327db483e821672d05179 100644 (file)
--- a/test/Tooling/clang-check-ast-dump.cpp
+++ b/test/Tooling/clang-check-ast-dump.cpp
@@ -32,7 +32,8 @@
 // CHECK-ATTR: test_namespace
 // CHECK-ATTR-NEXT: FieldDecl{{.*}}n
 // CHECK-ATTR-NEXT:   AlignedAttr
-// CHECK-ATTR-NEXT:     BinaryOperator
+// CHECK-ATTR-NEXT:     ConstantExpr
+// CHECK-ATTR-NEXT:       BinaryOperator
 //
 // RUN: clang-check -ast-dump -ast-dump-filter test_namespace::AfterNullNode "%s" -- 2>&1 | FileCheck -check-prefix CHECK-AFTER-NULL %s
 // CHECK-AFTER-NULL: class AfterNullNode

diff --git a/unittests/AST/ASTImporterTest.cpp b/unittests/AST/ASTImporterTest.cpp
index d1683cd0a678400ce3055df0de662b851f07f4ad..7cc43b5b3485685661ae5f0320e8cb332d34db92 100644 (file)
--- a/unittests/AST/ASTImporterTest.cpp
+++ b/unittests/AST/ASTImporterTest.cpp
@@ -140,6 +140,7 @@ class TestImportBase : public ParameterizedTestsFixture {
     if (!Imported)
       return testing::AssertionFailure() << "Import failed, nullptr returned!";
 
+
     return Verifier.match(Imported, WrapperMatcher);
   }
 
@@ -502,7 +503,6 @@ TEST_P(CanonicalRedeclChain, ShouldBeSameForAllDeclInTheChain) {
   EXPECT_THAT(RedeclsD1, ::testing::ContainerEq(RedeclsD2));
 }
 
-
 TEST_P(ImportExpr, ImportStringLiteral) {
   MatchVerifier<Decl> Verifier;
   testImport(
@@ -719,19 +719,18 @@ TEST_P(ImportExpr, ImportDesignatedInitExpr) {
           initListExpr(
               has(designatedInitExpr(
                   designatorCountIs(2),
-                  has(floatLiteral(equals(1.0))),
-                  has(integerLiteral(equals(2))))),
+                  hasDescendant(floatLiteral(equals(1.0))),
+                  hasDescendant(integerLiteral(equals(2))))),
               has(designatedInitExpr(
                   designatorCountIs(2),
-                  has(floatLiteral(equals(2.0))),
-                  has(integerLiteral(equals(2))))),
+                  hasDescendant(floatLiteral(equals(2.0))),
+                  hasDescendant(integerLiteral(equals(2))))),
               has(designatedInitExpr(
                   designatorCountIs(2),
-                  has(floatLiteral(equals(1.0))),
-                  has(integerLiteral(equals(0)))))))));
+                  hasDescendant(floatLiteral(equals(1.0))),
+                  hasDescendant(integerLiteral(equals(0)))))))));
 }
 
-
 TEST_P(ImportExpr, ImportPredefinedExpr) {
   MatchVerifier<Decl> Verifier;
   // __func__ expands as StringLiteral("declToImport")

diff --git a/unittests/ASTMatchers/ASTMatchersNodeTest.cpp b/unittests/ASTMatchers/ASTMatchersNodeTest.cpp
index b40289fcd59115a38a00408f0b7eaf4221a7e581..55f9a9ab695d169ed39e4bb53e63d9ff977ca29c 100644 (file)
--- a/unittests/ASTMatchers/ASTMatchersNodeTest.cpp
+++ b/unittests/ASTMatchers/ASTMatchersNodeTest.cpp
@@ -760,23 +760,23 @@ TEST(Matcher, Initializers) {
                                has(
                                  designatedInitExpr(
                                    designatorCountIs(2),
-                                   has(floatLiteral(
+                                   hasDescendant(floatLiteral(
                                      equals(1.0))),
-                                   has(integerLiteral(
+                                   hasDescendant(integerLiteral(
                                      equals(2))))),
                                has(
                                  designatedInitExpr(
                                    designatorCountIs(2),
-                                   has(floatLiteral(
+                                   hasDescendant(floatLiteral(
                                      equals(2.0))),
-                                   has(integerLiteral(
+                                   hasDescendant(integerLiteral(
                                      equals(2))))),
                                has(
                                  designatedInitExpr(
                                    designatorCountIs(2),
-                                   has(floatLiteral(
+                                   hasDescendant(floatLiteral(
                                      equals(1.0))),
-                                   has(integerLiteral(
+                                   hasDescendant(integerLiteral(
                                      equals(0)))))
                              )))));
 }

diff --git a/unittests/ASTMatchers/ASTMatchersTraversalTest.cpp b/unittests/ASTMatchers/ASTMatchersTraversalTest.cpp
index 713fb5a5924694126c60563fe20babad8a713142..5f6ecc0d0b8bbcf0d502a0b5e82983557d381c5b 100644 (file)
--- a/unittests/ASTMatchers/ASTMatchersTraversalTest.cpp
+++ b/unittests/ASTMatchers/ASTMatchersTraversalTest.cpp
@@ -1574,13 +1574,16 @@ TEST(SwitchCase, MatchesEachCase) {
     ifStmt(has(switchStmt(forEachSwitchCase(defaultStmt()))))));
   EXPECT_TRUE(matches("void x() { switch(42) { case 1+1: case 4:; } }",
                       switchStmt(forEachSwitchCase(
-                        caseStmt(hasCaseConstant(integerLiteral()))))));
+                        caseStmt(hasCaseConstant(
+                            constantExpr(has(integerLiteral()))))))));
   EXPECT_TRUE(notMatches("void x() { switch(42) { case 1+1: case 2+2:; } }",
                          switchStmt(forEachSwitchCase(
-                           caseStmt(hasCaseConstant(integerLiteral()))))));
+                           caseStmt(hasCaseConstant(
+                               constantExpr(has(integerLiteral()))))))));
   EXPECT_TRUE(notMatches("void x() { switch(42) { case 1 ... 2:; } }",
                          switchStmt(forEachSwitchCase(
-                           caseStmt(hasCaseConstant(integerLiteral()))))));
+                           caseStmt(hasCaseConstant(
+                               constantExpr(has(integerLiteral()))))))));
   EXPECT_TRUE(matchAndVerifyResultTrue(
     "void x() { switch (42) { case 1: case 2: case 3: default:; } }",
     switchStmt(forEachSwitchCase(caseStmt().bind("x"))),