[cfe-commits] r145447 - in /cfe/trunk: include/clang/AST/ExprCXX.h include/clang/Sema/Initialization.h include/clang/Sema/Sema.h lib/Sema/Sema.cpp lib/Sema/SemaCast.cpp lib/Sema/SemaExprCXX.cpp lib/Sema/SemaInit.cpp test/Index/preamble_macro_template.cpp test/Index/recursive-cxx-member-calls.cpp

Richard Smith richard-llvm at metafoo.co.uk
Tue Nov 29 14:48:16 PST 2011


Author: rsmith
Date: Tue Nov 29 16:48:16 2011
New Revision: 145447

URL: http://llvm.org/viewvc/llvm-project?rev=145447&view=rev
Log:
Revert r145244. It causes us to create broken ASTs with missing type information
for some cast expressions.

Original commit message:

Removed useless ImplicitCast nodes in explicit cstyle and static casts

Modified:
    cfe/trunk/include/clang/AST/ExprCXX.h
    cfe/trunk/include/clang/Sema/Initialization.h
    cfe/trunk/include/clang/Sema/Sema.h
    cfe/trunk/lib/Sema/Sema.cpp
    cfe/trunk/lib/Sema/SemaCast.cpp
    cfe/trunk/lib/Sema/SemaExprCXX.cpp
    cfe/trunk/lib/Sema/SemaInit.cpp
    cfe/trunk/test/Index/preamble_macro_template.cpp
    cfe/trunk/test/Index/recursive-cxx-member-calls.cpp

Modified: cfe/trunk/include/clang/AST/ExprCXX.h
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/include/clang/AST/ExprCXX.h?rev=145447&r1=145446&r2=145447&view=diff
==============================================================================
--- cfe/trunk/include/clang/AST/ExprCXX.h (original)
+++ cfe/trunk/include/clang/AST/ExprCXX.h Tue Nov 29 16:48:16 2011
@@ -178,11 +178,9 @@
   /// \brief Retrieve the location of the cast operator keyword, e.g.,
   /// "static_cast".
   SourceLocation getOperatorLoc() const { return Loc; }
-  void setOperatorLoc(SourceLocation const& OpLoc) { Loc = OpLoc; }
 
   /// \brief Retrieve the location of the closing parenthesis.
   SourceLocation getRParenLoc() const { return RParenLoc; }
-  void setRParenLoc(SourceLocation const& Loc) { RParenLoc = Loc; }
 
   SourceRange getSourceRange() const {
     return SourceRange(Loc, RParenLoc);

Modified: cfe/trunk/include/clang/Sema/Initialization.h
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/include/clang/Sema/Initialization.h?rev=145447&r1=145446&r2=145447&view=diff
==============================================================================
--- cfe/trunk/include/clang/Sema/Initialization.h (original)
+++ cfe/trunk/include/clang/Sema/Initialization.h Tue Nov 29 16:48:16 2011
@@ -340,7 +340,7 @@
     SIK_Default = IK_Default, ///< Default initialization
     SIK_Value = IK_Value,     ///< Value initialization
     SIK_ImplicitValue,        ///< Implicit value initialization
-    SIK_DirectStaticCast,  ///< Direct initialization due to a static cast
+    SIK_DirectCast,  ///< Direct initialization due to a cast
     /// \brief Direct initialization due to a C-style cast.
     SIK_DirectCStyleCast,
     /// \brief Direct initialization due to a functional-style cast.
@@ -372,8 +372,8 @@
 
   /// \brief Create a direct initialization due to a cast that isn't a C-style 
   /// or functional cast.
-  static InitializationKind CreateStaticCast(SourceRange TypeRange) {
-    return InitializationKind(SIK_DirectStaticCast,
+  static InitializationKind CreateCast(SourceRange TypeRange) {
+    return InitializationKind(SIK_DirectCast,
                               TypeRange.getBegin(), TypeRange.getBegin(), 
                               TypeRange.getEnd());
   }
@@ -425,7 +425,7 @@
   
   /// \brief Determine whether this initialization is an explicit cast.
   bool isExplicitCast() const {
-    return Kind == SIK_DirectStaticCast || 
+    return Kind == SIK_DirectCast || 
            Kind == SIK_DirectCStyleCast ||
            Kind == SIK_DirectFunctionalCast;
   }
@@ -440,11 +440,6 @@
     return Kind == SIK_DirectCStyleCast;
   }
 
-  /// brief Determine whether this is a static cast.
-  bool isStaticCast() const {
-    return Kind == SIK_DirectStaticCast;
-  }
-  
   /// brief Determine whether this is a functional-style cast.
   bool isFunctionalCast() const {
     return Kind == SIK_DirectFunctionalCast;

Modified: cfe/trunk/include/clang/Sema/Sema.h
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/include/clang/Sema/Sema.h?rev=145447&r1=145446&r2=145447&view=diff
==============================================================================
--- cfe/trunk/include/clang/Sema/Sema.h (original)
+++ cfe/trunk/include/clang/Sema/Sema.h Tue Nov 29 16:48:16 2011
@@ -5557,26 +5557,18 @@
     CCK_CStyleCast,
     /// \brief A functional-style cast.
     CCK_FunctionalCast,
-    /// \breif A static cast
-    CCK_StaticCast,
     /// \brief A cast other than a C-style cast.
     CCK_OtherCast
   };
 
-  /// CastExprToType - If Expr is not of type 'Type', insert a cast of the
-  /// specified kind.
-  /// Redundant implicit casts are merged together.
-  ExprResult CastExprToType(Expr *E, QualType Ty,
-                            CastKind Kind, ExprValueKind VK,
-                            const CXXCastPath *BasePath,
-                            CheckedConversionKind CCK);
-     
-  /// ImpCastExprToType - If Expr is not of type 'Type', insert an implicit cast.
-  /// If there is already an implicit cast, merge into the existing one.
-  /// The result is of the given category.
+  /// ImpCastExprToType - If Expr is not of type 'Type', insert an implicit
+  /// cast.  If there is already an implicit cast, merge into the existing one.
+  /// If isLvalue, the result of the cast is an lvalue.
   ExprResult ImpCastExprToType(Expr *E, QualType Type, CastKind CK,
                                ExprValueKind VK = VK_RValue,
-                               const CXXCastPath *BasePath = 0);
+                               const CXXCastPath *BasePath = 0,
+                               CheckedConversionKind CCK
+                                  = CCK_ImplicitConversion);
 
   /// ScalarTypeToBooleanCastKind - Returns the cast kind corresponding
   /// to the conversion from scalar type ScalarTy to the Boolean type.
@@ -5765,10 +5757,10 @@
                                        AssignmentAction Action,
                                        CheckedConversionKind CCK
                                           = CCK_ImplicitConversion);
-  ExprResult PerformConversion(Expr *From, QualType ToType,
-                               const StandardConversionSequence& SCS,
-                               AssignmentAction Action,
-                               CheckedConversionKind CCK);
+  ExprResult PerformImplicitConversion(Expr *From, QualType ToType,
+                                       const StandardConversionSequence& SCS,
+                                       AssignmentAction Action,
+                                       CheckedConversionKind CCK);
 
   /// the following "Check" methods will return a valid/converted QualType
   /// or a null QualType (indicating an error diagnostic was issued).

Modified: cfe/trunk/lib/Sema/Sema.cpp
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/Sema/Sema.cpp?rev=145447&r1=145446&r2=145447&view=diff
==============================================================================
--- cfe/trunk/lib/Sema/Sema.cpp (original)
+++ cfe/trunk/lib/Sema/Sema.cpp Tue Nov 29 16:48:16 2011
@@ -234,16 +234,13 @@
   AnalysisWarnings.PrintStats();
 }
 
-/// CastExprToType - If Expr is not of type 'Type', insert a cast of the
-/// specified kind.
-/// Redundant implicit casts are merged together.
-/// Pay attention: if CCK != CCK_ImplicitConversion,
-/// users of this function must fill
-/// SourceTypeInfos and SourceLocations later
-ExprResult Sema::CastExprToType(Expr *E, QualType Ty,
-                                CastKind Kind, ExprValueKind VK,
-                                const CXXCastPath *BasePath,
-                                CheckedConversionKind CCK) {
+/// ImpCastExprToType - If Expr is not of type 'Type', insert an implicit cast.
+/// If there is already an implicit cast, merge into the existing one.
+/// The result is of the given category.
+ExprResult Sema::ImpCastExprToType(Expr *E, QualType Ty,
+                                   CastKind Kind, ExprValueKind VK,
+                                   const CXXCastPath *BasePath,
+                                   CheckedConversionKind CCK) {
 #ifndef NDEBUG
   if (VK == VK_RValue && !E->isRValue()) {
     switch (Kind) {
@@ -279,41 +276,16 @@
       MarkVTableUsed(E->getLocStart(), 
                      cast<CXXRecordDecl>(RecordTy->getDecl()));
   }
-  
-  switch(CCK) {
-    default:
-      llvm_unreachable("Unexpected CheckedConversionKind");
-    case CCK_ImplicitConversion:
-      if (ImplicitCastExpr *ImpCast = dyn_cast<ImplicitCastExpr>(E)) {
-        if (ImpCast->getCastKind() == Kind && (!BasePath || BasePath->empty())) {
-          ImpCast->setType(Ty);
-          ImpCast->setValueKind(VK);
-          return Owned(E);
-        }
-      }
-      return Owned(ImplicitCastExpr::Create(Context, Ty, Kind, E, BasePath, VK));
-    case CCK_CStyleCast:
-      return Owned(CStyleCastExpr::Create(Context, Ty, VK, Kind, E, BasePath,
-                                          0, SourceLocation(), SourceLocation()));
-    case CCK_FunctionalCast:
-      return Owned(CXXFunctionalCastExpr::Create(Context, Ty, VK, 0,
-                                                 SourceLocation(), Kind, E,
-                                                 BasePath, SourceLocation()));
-    case CCK_StaticCast:
-      return Owned(CXXStaticCastExpr::Create(Context, Ty, VK, Kind, E, BasePath,
-                                             0, SourceLocation(),
-                                             SourceLocation()));
+
+  if (ImplicitCastExpr *ImpCast = dyn_cast<ImplicitCastExpr>(E)) {
+    if (ImpCast->getCastKind() == Kind && (!BasePath || BasePath->empty())) {
+      ImpCast->setType(Ty);
+      ImpCast->setValueKind(VK);
+      return Owned(E);
+    }
   }
-  
-}
 
-/// ImpCastExprToType - If Expr is not of type 'Type', insert an implicit cast.
-/// If there is already an implicit cast, merge into the existing one.
-/// The result is of the given category.
-ExprResult Sema::ImpCastExprToType(Expr *E, QualType Ty,
-                                   CastKind Kind, ExprValueKind VK,
-                                   const CXXCastPath *BasePath) {
-  return CastExprToType(E, Ty, Kind, VK, BasePath, CCK_ImplicitConversion);
+  return Owned(ImplicitCastExpr::Create(Context, Ty, Kind, E, BasePath, VK));
 }
 
 /// ScalarTypeToBooleanCastKind - Returns the cast kind corresponding

Modified: cfe/trunk/lib/Sema/SemaCast.cpp
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/Sema/SemaCast.cpp?rev=145447&r1=145446&r2=145447&view=diff
==============================================================================
--- cfe/trunk/lib/Sema/SemaCast.cpp (original)
+++ cfe/trunk/lib/Sema/SemaCast.cpp Tue Nov 29 16:48:16 2011
@@ -75,9 +75,9 @@
     // Top-level semantics-checking routines.
     void CheckConstCast();
     void CheckReinterpretCast();
-    void CheckStaticCast(bool &CastNodesCreated);
+    void CheckStaticCast();
     void CheckDynamicCast();
-    void CheckCXXCStyleCast(bool FunctionalCast, bool &CastNodesCreated);
+    void CheckCXXCStyleCast(bool FunctionalCast);
     void CheckCStyleCast();
 
     /// Complete an apparently-successful cast operation that yields
@@ -283,28 +283,12 @@
                                                       Parens.getEnd()));
   }
   case tok::kw_static_cast: {
-    bool CastNodesCreated = false;
     if (!TypeDependent) {
-      Op.CheckStaticCast(CastNodesCreated);
+      Op.CheckStaticCast();
       if (Op.SrcExpr.isInvalid())
         return ExprError();
     }
     
-    // CheckStaticCast _may_ have already created the cast node. Let's check
-    if (CastNodesCreated) {
-      if (CXXStaticCastExpr *Cast =
-          dyn_cast<CXXStaticCastExpr>(Op.SrcExpr.get())) {
-        assert(!Cast->getTypeInfoAsWritten() &&
-               "The explicit cast node created by CheckStaticCast "
-               "has source type infos!");
-
-        Cast->setTypeInfoAsWritten(DestTInfo);
-        Cast->setOperatorLoc(OpLoc);
-        Cast->setRParenLoc(Parens.getEnd());
-        
-        return Op.complete(Cast);
-      }
-    }
     return Op.complete(CXXStaticCastExpr::Create(Context, Op.ResultType,
                                    Op.ValueKind, Op.Kind, Op.SrcExpr.take(),
                                                  &Op.BasePath, DestTInfo,
@@ -343,7 +327,7 @@
     = (CT == CT_CStyle)? InitializationKind::CreateCStyleCast(range.getBegin(),
                                                               range)
     : (CT == CT_Functional)? InitializationKind::CreateFunctionalCast(range)
-    : InitializationKind::CreateStaticCast(/*type range?*/ range);
+    : InitializationKind::CreateCast(/*type range?*/ range);
   InitializationSequence sequence(S, entity, initKind, &src, 1);
 
   assert(sequence.Failed() && "initialization succeeded on second try?");
@@ -730,7 +714,7 @@
 /// CheckStaticCast - Check that a static_cast\<DestType\>(SrcExpr) is valid.
 /// Refer to C++ 5.2.9 for details. Static casts are mostly used for making
 /// implicit conversions explicit and getting rid of data loss warnings.
-void CastOperation::CheckStaticCast(bool &CastNodesCreated) {
+void CastOperation::CheckStaticCast() {
   if (isPlaceholder()) {
     checkNonOverloadPlaceholders();
     if (SrcExpr.isInvalid())
@@ -763,10 +747,9 @@
       return;
   }
 
-  Expr *SrcExprOrig = SrcExpr.get();
   unsigned msg = diag::err_bad_cxx_cast_generic;
   TryCastResult tcr
-    = TryStaticCast(Self, SrcExpr, DestType, Sema::CCK_StaticCast, OpRange, msg,
+    = TryStaticCast(Self, SrcExpr, DestType, Sema::CCK_OtherCast, OpRange, msg,
                     Kind, BasePath);
   if (tcr != TC_Success && msg != 0) {
     if (SrcExpr.isInvalid())
@@ -784,12 +767,10 @@
     if (Kind == CK_BitCast)
       checkCastAlign();
     if (Self.getLangOptions().ObjCAutoRefCount)
-      checkObjCARCConversion(Sema::CCK_StaticCast);
+      checkObjCARCConversion(Sema::CCK_OtherCast);
   } else if (Kind == CK_BitCast) {
     checkCastAlign();
   }
-  
-  CastNodesCreated = (SrcExpr.get() != SrcExprOrig);
 }
 
 /// TryStaticCast - Check if a static cast can be performed, and do so if
@@ -1327,7 +1308,7 @@
         ? InitializationKind::CreateCStyleCast(OpRange.getBegin(), OpRange)
     : (CCK == Sema::CCK_FunctionalCast)
         ? InitializationKind::CreateFunctionalCast(OpRange)
-    : InitializationKind::CreateStaticCast(OpRange);
+    : InitializationKind::CreateCast(OpRange);
   Expr *SrcExprRaw = SrcExpr.get();
   InitializationSequence InitSeq(Self, Entity, InitKind, &SrcExprRaw, 1);
 
@@ -1761,9 +1742,7 @@
   return TC_Success;
 }                                     
 
-void CastOperation::CheckCXXCStyleCast(bool FunctionalStyle,
-                                       bool &CastNodesCreated) {
-  CastNodesCreated = false;
+void CastOperation::CheckCXXCStyleCast(bool FunctionalStyle) {
   // Handle placeholders.
   if (isPlaceholder()) {
     // C-style casts can resolve __unknown_any types.
@@ -1844,7 +1823,6 @@
     = FunctionalStyle? Sema::CCK_FunctionalCast
                      : Sema::CCK_CStyleCast;
   if (tcr == TC_NotApplicable) {
-    Expr *SrcExprOrig = SrcExpr.get();
     // ... or if that is not possible, a static_cast, ignoring const, ...
     tcr = TryStaticCast(Self, SrcExpr, DestType, CCK, OpRange,
                         msg, Kind, BasePath);
@@ -1858,8 +1836,6 @@
       if (SrcExpr.isInvalid())
         return;
     }
-    
-    CastNodesCreated = (SrcExpr.get() != SrcExprOrig);
   }
 
   if (Self.getLangOptions().ObjCAutoRefCount && tcr == TC_Success)
@@ -2077,9 +2053,8 @@
   Op.DestRange = CastTypeInfo->getTypeLoc().getSourceRange();
   Op.OpRange = SourceRange(LPLoc, CastExpr->getLocEnd());
 
-  bool CastNodesCreated = false;
   if (getLangOptions().CPlusPlus) {
-    Op.CheckCXXCStyleCast(/*FunctionalStyle=*/ false, CastNodesCreated);
+    Op.CheckCXXCStyleCast(/*FunctionalStyle=*/ false);
   } else {
     Op.CheckCStyleCast();
   }
@@ -2087,20 +2062,6 @@
   if (Op.SrcExpr.isInvalid())
     return ExprError();
 
-  // CheckCXXCStyleCast _may_ have already created the CStyleCastExpr
-  // node. Let's check.
-  if (CastNodesCreated) {
-    if (CStyleCastExpr *Cast = dyn_cast<CStyleCastExpr>(Op.SrcExpr.get())){
-      assert(!Cast->getTypeInfoAsWritten() &&
-             "The explicit cast node created by CheckStaticCast "
-             "has source type infos!");
-      Cast->setTypeInfoAsWritten(CastTypeInfo);
-      Cast->setLParenLoc(LPLoc);
-      Cast->setRParenLoc(RPLoc);
-      return Op.complete(Cast);
-    }
-  }
-  
   return Op.complete(CStyleCastExpr::Create(Context, Op.ResultType,
                               Op.ValueKind, Op.Kind, Op.SrcExpr.take(),
                               &Op.BasePath, CastTypeInfo, LPLoc, RPLoc));
@@ -2114,28 +2075,11 @@
   Op.DestRange = CastTypeInfo->getTypeLoc().getSourceRange();
   Op.OpRange = SourceRange(Op.DestRange.getBegin(), CastExpr->getLocEnd());
 
-  bool CastNodesCreated = false;
-  Op.CheckCXXCStyleCast(/*FunctionalStyle=*/ true, CastNodesCreated);
+  Op.CheckCXXCStyleCast(/*FunctionalStyle=*/ true);
   if (Op.SrcExpr.isInvalid())
     return ExprError();
 
-  // CheckCXXCStyleCast _may_ have already created the CXXFunctionalCastExpr
-  // node. Let's check.
-  if (CastNodesCreated) {
-    if (CXXFunctionalCastExpr *Cast =
-        dyn_cast<CXXFunctionalCastExpr>(Op.SrcExpr.get())){
-      assert(!Cast->getTypeInfoAsWritten() &&
-             "The explicit cast node created by CheckStaticCast "
-             "has source type infos!");
-      Cast->setTypeInfoAsWritten(CastTypeInfo);
-      Cast->setTypeBeginLoc(Op.DestRange.getBegin());
-      Cast->setRParenLoc(RPLoc);
-      return Op.complete(Cast);
-    }
-  }
-  
   return Op.complete(CXXFunctionalCastExpr::Create(Context, Op.ResultType,
                          Op.ValueKind, CastTypeInfo, Op.DestRange.getBegin(),
                          Op.Kind, Op.SrcExpr.take(), &Op.BasePath, RPLoc));
 }
-

Modified: cfe/trunk/lib/Sema/SemaExprCXX.cpp
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/Sema/SemaExprCXX.cpp?rev=145447&r1=145446&r2=145447&view=diff
==============================================================================
--- cfe/trunk/lib/Sema/SemaExprCXX.cpp (original)
+++ cfe/trunk/lib/Sema/SemaExprCXX.cpp Tue Nov 29 16:48:16 2011
@@ -2125,8 +2125,8 @@
                                 CheckedConversionKind CCK) {
   switch (ICS.getKind()) {
   case ImplicitConversionSequence::StandardConversion: {
-    ExprResult Res = PerformConversion(From, ToType, ICS.Standard,
-                                       Action, CCK);
+    ExprResult Res = PerformImplicitConversion(From, ToType, ICS.Standard,
+                                               Action, CCK);
     if (Res.isInvalid())
       return ExprError();
     From = Res.take();
@@ -2160,8 +2160,9 @@
       // Watch out for elipsis conversion.
       if (!ICS.UserDefined.EllipsisConversion) {
         ExprResult Res =
-          PerformConversion(From, BeforeToType,
-                            ICS.UserDefined.Before, AA_Converting, CCK);
+          PerformImplicitConversion(From, BeforeToType,
+                                    ICS.UserDefined.Before, AA_Converting,
+                                    CCK);
         if (Res.isInvalid())
           return ExprError();
         From = Res.take();
@@ -2181,8 +2182,8 @@
 
       From = CastArg.take();
 
-      return PerformConversion(From, ToType, ICS.UserDefined.After,
-                               AA_Converting, CCK);
+      return PerformImplicitConversion(From, ToType, ICS.UserDefined.After,
+                                       AA_Converting, CCK);
   }
 
   case ImplicitConversionSequence::AmbiguousConversion:
@@ -2202,13 +2203,13 @@
   return Owned(From);
 }
 
-/// PerformConversion - Perform a conversion of the
+/// PerformImplicitConversion - Perform an implicit conversion of the
 /// expression From to the type ToType by following the standard
 /// conversion sequence SCS. Returns the converted
 /// expression. Flavor is the context in which we're performing this
 /// conversion, for use in error messages.
 ExprResult
-Sema::PerformConversion(Expr *From, QualType ToType,
+Sema::PerformImplicitConversion(Expr *From, QualType ToType,
                                 const StandardConversionSequence& SCS,
                                 AssignmentAction Action, 
                                 CheckedConversionKind CCK) {
@@ -2262,7 +2263,7 @@
     FromType = From->getType();
   }
 
-  // Perform the first conversion step.
+  // Perform the first implicit conversion.
   switch (SCS.First) {
   case ICK_Identity:
     // Nothing to do.
@@ -2277,21 +2278,21 @@
 
   case ICK_Array_To_Pointer:
     FromType = Context.getArrayDecayedType(FromType);
-    From = CastExprToType(From, FromType, CK_ArrayToPointerDecay, 
-                          VK_RValue, /*BasePath=*/0, CCK).take();
+    From = ImpCastExprToType(From, FromType, CK_ArrayToPointerDecay, 
+                             VK_RValue, /*BasePath=*/0, CCK).take();
     break;
 
   case ICK_Function_To_Pointer:
     FromType = Context.getPointerType(FromType);
-    From = CastExprToType(From, FromType, CK_FunctionToPointerDecay, 
-                          VK_RValue, /*BasePath=*/0, CCK).take();
+    From = ImpCastExprToType(From, FromType, CK_FunctionToPointerDecay, 
+                             VK_RValue, /*BasePath=*/0, CCK).take();
     break;
 
   default:
     llvm_unreachable("Improper first standard conversion");
   }
 
-  // Perform the second conversion step
+  // Perform the second implicit conversion
   switch (SCS.Second) {
   case ICK_Identity:
     // If both sides are functions (or pointers/references to them), there could
@@ -2307,20 +2308,20 @@
     if (CheckExceptionSpecCompatibility(From, ToType))
       return ExprError();
 
-    From = CastExprToType(From, ToType, CK_NoOp, 
-                          VK_RValue, /*BasePath=*/0, CCK).take();
+    From = ImpCastExprToType(From, ToType, CK_NoOp, 
+                             VK_RValue, /*BasePath=*/0, CCK).take();
     break;
 
   case ICK_Integral_Promotion:
   case ICK_Integral_Conversion:
-    From = CastExprToType(From, ToType, CK_IntegralCast, 
-                          VK_RValue, /*BasePath=*/0, CCK).take();
+    From = ImpCastExprToType(From, ToType, CK_IntegralCast, 
+                             VK_RValue, /*BasePath=*/0, CCK).take();
     break;
 
   case ICK_Floating_Promotion:
   case ICK_Floating_Conversion:
-    From = CastExprToType(From, ToType, CK_FloatingCast, 
-                          VK_RValue, /*BasePath=*/0, CCK).take();
+    From = ImpCastExprToType(From, ToType, CK_FloatingCast, 
+                             VK_RValue, /*BasePath=*/0, CCK).take();
     break;
 
   case ICK_Complex_Promotion:
@@ -2338,23 +2339,23 @@
     } else {
       CK = CK_IntegralComplexCast;
     }
-    From = CastExprToType(From, ToType, CK, 
-                          VK_RValue, /*BasePath=*/0, CCK).take();
+    From = ImpCastExprToType(From, ToType, CK, 
+                             VK_RValue, /*BasePath=*/0, CCK).take();
     break;
   }
 
   case ICK_Floating_Integral:
     if (ToType->isRealFloatingType())
-      From = CastExprToType(From, ToType, CK_IntegralToFloating, 
-                            VK_RValue, /*BasePath=*/0, CCK).take();
+      From = ImpCastExprToType(From, ToType, CK_IntegralToFloating, 
+                               VK_RValue, /*BasePath=*/0, CCK).take();
     else
-      From = CastExprToType(From, ToType, CK_FloatingToIntegral, 
-                            VK_RValue, /*BasePath=*/0, CCK).take();
+      From = ImpCastExprToType(From, ToType, CK_FloatingToIntegral, 
+                               VK_RValue, /*BasePath=*/0, CCK).take();
     break;
 
   case ICK_Compatible_Conversion:
-      From = CastExprToType(From, ToType, CK_NoOp, 
-                            VK_RValue, /*BasePath=*/0, CCK).take();
+      From = ImpCastExprToType(From, ToType, CK_NoOp, 
+                               VK_RValue, /*BasePath=*/0, CCK).take();
     break;
 
   case ICK_Writeback_Conversion:
@@ -2402,7 +2403,8 @@
       From = E.take();
     }
 
-    From = CastExprToType(From, ToType, Kind, VK_RValue, &BasePath, CCK).take();
+    From = ImpCastExprToType(From, ToType, Kind, VK_RValue, &BasePath, CCK)
+             .take();
     break;
   }
 
@@ -2413,7 +2415,8 @@
       return ExprError();
     if (CheckExceptionSpecCompatibility(From, ToType))
       return ExprError();
-    From = CastExprToType(From, ToType, Kind, VK_RValue, &BasePath, CCK).take();
+    From = ImpCastExprToType(From, ToType, Kind, VK_RValue, &BasePath, CCK)
+             .take();
     break;
   }
 
@@ -2424,9 +2427,9 @@
       FromType = Context.FloatTy;
     }
 
-    From = CastExprToType(From, Context.BoolTy,
-                          ScalarTypeToBooleanCastKind(FromType), 
-                          VK_RValue, /*BasePath=*/0, CCK).take();
+    From = ImpCastExprToType(From, Context.BoolTy,
+                             ScalarTypeToBooleanCastKind(FromType), 
+                             VK_RValue, /*BasePath=*/0, CCK).take();
     break;
 
   case ICK_Derived_To_Base: {
@@ -2439,20 +2442,20 @@
                                      CStyle))
       return ExprError();
 
-    From = CastExprToType(From, ToType.getNonReferenceType(),
-                          CK_DerivedToBase, From->getValueKind(),
-                          &BasePath, CCK).take();
+    From = ImpCastExprToType(From, ToType.getNonReferenceType(),
+                      CK_DerivedToBase, From->getValueKind(),
+                      &BasePath, CCK).take();
     break;
   }
 
   case ICK_Vector_Conversion:
-    From = CastExprToType(From, ToType, CK_BitCast, 
-                          VK_RValue, /*BasePath=*/0, CCK).take();
+    From = ImpCastExprToType(From, ToType, CK_BitCast, 
+                             VK_RValue, /*BasePath=*/0, CCK).take();
     break;
 
   case ICK_Vector_Splat:
-    From = CastExprToType(From, ToType, CK_VectorSplat, 
-                          VK_RValue, /*BasePath=*/0, CCK).take();
+    From = ImpCastExprToType(From, ToType, CK_VectorSplat, 
+                             VK_RValue, /*BasePath=*/0, CCK).take();
     break;
 
   case ICK_Complex_Real:
@@ -2465,22 +2468,17 @@
       if (Context.hasSameUnqualifiedType(ElType, From->getType())) {
         // do nothing
       } else if (From->getType()->isRealFloatingType()) {
-        From = CastExprToType(From, ElType,
-                              isFloatingComplex ? CK_FloatingCast
-                                                : CK_FloatingToIntegral,
-                              VK_RValue, /*BasePath=*/0, CCK).take();
+        From = ImpCastExprToType(From, ElType,
+                isFloatingComplex ? CK_FloatingCast : CK_FloatingToIntegral).take();
       } else {
         assert(From->getType()->isIntegerType());
-        From = CastExprToType(From, ElType,
-                              isFloatingComplex ? CK_IntegralToFloating
-                                                : CK_IntegralCast,
-                              VK_RValue, /*BasePath=*/0, CCK).take();
+        From = ImpCastExprToType(From, ElType,
+                isFloatingComplex ? CK_IntegralToFloating : CK_IntegralCast).take();
       }
       // y -> _Complex y
-      From = CastExprToType(From, ToType,
-                            isFloatingComplex ? CK_FloatingRealToComplex
-                                              : CK_IntegralRealToComplex,
-                            VK_RValue, /*BasePath=*/ 0, CCK).take();
+      From = ImpCastExprToType(From, ToType,
+                   isFloatingComplex ? CK_FloatingRealToComplex
+                                     : CK_IntegralRealToComplex).take();
 
     // Case 2.  _Complex x -> y
     } else {
@@ -2491,32 +2489,30 @@
       bool isFloatingComplex = ElType->isRealFloatingType();
 
       // _Complex x -> x
-      From = CastExprToType(From, ElType,
-                            isFloatingComplex ? CK_FloatingComplexToReal
-                                              : CK_IntegralComplexToReal, 
-                            VK_RValue, /*BasePath=*/0, CCK).take();
+      From = ImpCastExprToType(From, ElType,
+                   isFloatingComplex ? CK_FloatingComplexToReal
+                                     : CK_IntegralComplexToReal, 
+                               VK_RValue, /*BasePath=*/0, CCK).take();
 
       // x -> y
       if (Context.hasSameUnqualifiedType(ElType, ToType)) {
         // do nothing
       } else if (ToType->isRealFloatingType()) {
-        From = CastExprToType(From, ToType,
-                              isFloatingComplex ? CK_FloatingCast 
-                                                : CK_IntegralToFloating, 
-                              VK_RValue, /*BasePath=*/0, CCK).take();
+        From = ImpCastExprToType(From, ToType,
+                   isFloatingComplex ? CK_FloatingCast : CK_IntegralToFloating, 
+                                 VK_RValue, /*BasePath=*/0, CCK).take();
       } else {
         assert(ToType->isIntegerType());
-        From = CastExprToType(From, ToType,
-                              isFloatingComplex ? CK_FloatingToIntegral
-                                                : CK_IntegralCast, 
-                              VK_RValue, /*BasePath=*/0, CCK).take();
+        From = ImpCastExprToType(From, ToType,
+                   isFloatingComplex ? CK_FloatingToIntegral : CK_IntegralCast, 
+                                 VK_RValue, /*BasePath=*/0, CCK).take();
       }
     }
     break;
   
   case ICK_Block_Pointer_Conversion: {
-    From = CastExprToType(From, ToType.getUnqualifiedType(), CK_BitCast,
-                          VK_RValue, /*BasePath=*/0, CCK).take();
+    From = ImpCastExprToType(From, ToType.getUnqualifiedType(), CK_BitCast,
+                             VK_RValue, /*BasePath=*/0, CCK).take();
     break;
   }
       
@@ -2551,8 +2547,8 @@
     // target type isn't a reference.
     ExprValueKind VK = ToType->isReferenceType() ?
                                   From->getValueKind() : VK_RValue;
-    From = CastExprToType(From, ToType.getNonLValueExprType(Context),
-                          CK_NoOp, VK, /*BasePath=*/0, CCK).take();
+    From = ImpCastExprToType(From, ToType.getNonLValueExprType(Context),
+                             CK_NoOp, VK, /*BasePath=*/0, CCK).take();
 
     if (SCS.DeprecatedStringLiteralToCharPtr &&
         !getLangOptions().WritableStrings)

Modified: cfe/trunk/lib/Sema/SemaInit.cpp
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/Sema/SemaInit.cpp?rev=145447&r1=145446&r2=145447&view=diff
==============================================================================
--- cfe/trunk/lib/Sema/SemaInit.cpp (original)
+++ cfe/trunk/lib/Sema/SemaInit.cpp Tue Nov 29 16:48:16 2011
@@ -4863,7 +4863,7 @@
       Sema::CheckedConversionKind CCK 
         = Kind.isCStyleCast()? Sema::CCK_CStyleCast
         : Kind.isFunctionalCast()? Sema::CCK_FunctionalCast
-        : Kind.isStaticCast()? Sema::CCK_StaticCast
+        : Kind.isExplicitCast()? Sema::CCK_OtherCast
         : Sema::CCK_ImplicitConversion;
       ExprResult CurInitExprRes =
         S.PerformImplicitConversion(CurInit.get(), Step->Type, *Step->ICS,

Modified: cfe/trunk/test/Index/preamble_macro_template.cpp
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/test/Index/preamble_macro_template.cpp?rev=145447&r1=145446&r2=145447&view=diff
==============================================================================
--- cfe/trunk/test/Index/preamble_macro_template.cpp (original)
+++ cfe/trunk/test/Index/preamble_macro_template.cpp Tue Nov 29 16:48:16 2011
@@ -9,6 +9,7 @@
 // CHECK: preamble_macro_template.h:4:16: CompoundStmt= Extent=[4:16 - 6:2]
 // CHECK: preamble_macro_template.h:5:3: CStyleCastExpr= Extent=[5:3 - 5:27]
 // CHECK: preamble_macro_template.h:1:21: CXXStaticCastExpr= Extent=[1:21 - 5:27]
+// CHECK: preamble_macro_template.h:5:25: UnexposedExpr= Extent=[5:25 - 5:26]
 // CHECK: preamble_macro_template.h:5:25: IntegerLiteral= Extent=[5:25 - 5:26]
 // CHECK: preamble_macro_template.cpp:3:5: FunctionDecl=main:3:5 (Definition) Extent=[3:1 - 3:15]
 // CHECK: preamble_macro_template.cpp:3:12: CompoundStmt= Extent=[3:12 - 3:15]

Modified: cfe/trunk/test/Index/recursive-cxx-member-calls.cpp
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/test/Index/recursive-cxx-member-calls.cpp?rev=145447&r1=145446&r2=145447&view=diff
==============================================================================
--- cfe/trunk/test/Index/recursive-cxx-member-calls.cpp (original)
+++ cfe/trunk/test/Index/recursive-cxx-member-calls.cpp Tue Nov 29 16:48:16 2011
@@ -1632,6 +1632,7 @@
 // CHECK: 41:30: UnaryOperator= Extent=[41:30 - 41:40]
 // CHECK: 41:31: CXXFunctionalCastExpr= Extent=[41:31 - 41:40]
 // CHECK: 41:31: TypeRef=size_t:2:25 Extent=[41:31 - 41:37]
+// CHECK: 41:38: UnexposedExpr= Extent=[41:38 - 41:39]
 // CHECK: 41:38: IntegerLiteral= Extent=[41:38 - 41:39]
 // CHECK: 42:1: CXXAccessSpecifier=:42:1 (Definition) Extent=[42:1 - 42:9]
 // CHECK: 43:15: FieldDecl=Data:43:15 (Definition) Extent=[43:3 - 43:19]
@@ -1803,6 +1804,7 @@
 // CHECK: 75:13: ParenExpr= Extent=[75:13 - 75:30]
 // CHECK: 75:14: CStyleCastExpr= Extent=[75:14 - 75:29]
 // CHECK: 75:25: UnexposedExpr= Extent=[75:25 - 75:29]
+// CHECK: 75:25: UnexposedExpr= Extent=[75:25 - 75:29]
 // CHECK: 75:25: ArraySubscriptExpr= Extent=[75:25 - 75:29]
 // CHECK: 75:25: DeclRefExpr=p:74:17 Extent=[75:25 - 75:26]
 // CHECK: 75:27: IntegerLiteral= Extent=[75:27 - 75:28]
@@ -1811,6 +1813,7 @@
 // CHECK: 75:34: ParenExpr= Extent=[75:34 - 75:51]
 // CHECK: 75:35: CStyleCastExpr= Extent=[75:35 - 75:50]
 // CHECK: 75:46: UnexposedExpr= Extent=[75:46 - 75:50]
+// CHECK: 75:46: UnexposedExpr= Extent=[75:46 - 75:50]
 // CHECK: 75:46: ArraySubscriptExpr= Extent=[75:46 - 75:50]
 // CHECK: 75:46: DeclRefExpr=p:74:17 Extent=[75:46 - 75:47]
 // CHECK: 75:48: IntegerLiteral= Extent=[75:48 - 75:49]





More information about the cfe-commits mailing list