commit bd0fb30fa2a039439d1a30a83ea896801394d780
author Anders Carlsson <andersca@mac.com> Mon Aug 10 21:30:22 2009 +0000
committer Anders Carlsson <andersca@mac.com> Mon Aug 10 21:30:22 2009 +0000
tree 7625f5bc1646aa3a1451dd54dc9317f0b044c2c1
parent 797c3c4f5dc4fda735e55c6b5d6270a54cf6d263

Add a CastInfo struct that will be used for cast information when constructing cast expressions. Right now it only stores the cast kind, but in the future it might store conversion functions and constructors.

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

include/clang/AST/Expr.h

diff --git a/include/clang/AST/Expr.h b/include/clang/AST/Expr.h
index 23fd420..e5aca24 100644
--- a/include/clang/AST/Expr.h
+++ b/include/clang/AST/Expr.h
@@ -1184,11 +1184,20 @@
     CK_ArrayToPointerDecay
   };
   
+  struct CastInfo {
+    const CastKind Kind;
+    
+    // FIXME: This should assert that the CastKind does not require extra
+    // information.
+    CastInfo(CastKind Kind)
+      : Kind(Kind) { }
+  };
+  
 private:
   CastKind Kind;
   Stmt *Op;
 protected:
-  CastExpr(StmtClass SC, QualType ty, CastKind kind, Expr *op) : 
+  CastExpr(StmtClass SC, QualType ty, const CastInfo &info, Expr *op) : 
     Expr(SC, ty,
          // Cast expressions are type-dependent if the type is
          // dependent (C++ [temp.dep.expr]p3).
@@ -1196,7 +1205,7 @@
          // Cast expressions are value-dependent if the type is
          // dependent or if the subexpression is value-dependent.
          ty->isDependentType() || (op && op->isValueDependent())), 
-    Kind(kind), Op(op) {}
+    Kind(info.Kind), Op(op) {}
   
   /// \brief Construct an empty cast.
   CastExpr(StmtClass SC, EmptyShell Empty) 
@@ -1248,8 +1257,8 @@
   bool LvalueCast;
 
 public:
-  ImplicitCastExpr(QualType ty, CastKind kind, Expr *op, bool Lvalue) : 
-    CastExpr(ImplicitCastExprClass, ty, kind, op), LvalueCast(Lvalue) { }
+  ImplicitCastExpr(QualType ty, const CastInfo &info, Expr *op, bool Lvalue) : 
+    CastExpr(ImplicitCastExprClass, ty, info, op), LvalueCast(Lvalue) { }
 
   /// \brief Construct an empty implicit cast.
   explicit ImplicitCastExpr(EmptyShell Shell) 
@@ -1294,9 +1303,9 @@
   QualType TypeAsWritten;
 
 protected:
-  ExplicitCastExpr(StmtClass SC, QualType exprTy, CastKind kind, Expr *op, 
-                   QualType writtenTy) 
-    : CastExpr(SC, exprTy, kind, op), TypeAsWritten(writtenTy) {}
+  ExplicitCastExpr(StmtClass SC, QualType exprTy, const CastInfo &info,
+                   Expr *op, QualType writtenTy) 
+    : CastExpr(SC, exprTy, info, op), TypeAsWritten(writtenTy) {}
 
   /// \brief Construct an empty explicit cast.
   ExplicitCastExpr(StmtClass SC, EmptyShell Shell) 

include/clang/AST/ExprCXX.h

diff --git a/include/clang/AST/ExprCXX.h b/include/clang/AST/ExprCXX.h
index a254e99..c801692 100644
--- a/include/clang/AST/ExprCXX.h
+++ b/include/clang/AST/ExprCXX.h
@@ -112,9 +112,9 @@
   SourceLocation Loc; // the location of the casting op
 
 protected:
-  CXXNamedCastExpr(StmtClass SC, QualType ty, CastKind kind, Expr *op, 
+  CXXNamedCastExpr(StmtClass SC, QualType ty, const CastInfo &info, Expr *op, 
                    QualType writtenTy, SourceLocation l)
-    : ExplicitCastExpr(SC, ty, kind, op, writtenTy), Loc(l) {}
+    : ExplicitCastExpr(SC, ty, info, op, writtenTy), Loc(l) {}
 
 public:
   const char *getCastName() const;
@@ -148,9 +148,9 @@
 /// @c static_cast<int>(1.0).
 class CXXStaticCastExpr : public CXXNamedCastExpr {
 public:
-  CXXStaticCastExpr(QualType ty, CastKind kind, Expr *op, QualType writtenTy, 
-                    SourceLocation l)
-    : CXXNamedCastExpr(CXXStaticCastExprClass, ty, kind, op, writtenTy, l) {}
+  CXXStaticCastExpr(QualType ty, const CastInfo &info, Expr *op, 
+                    QualType writtenTy, SourceLocation l)
+    : CXXNamedCastExpr(CXXStaticCastExprClass, ty, info, op, writtenTy, l) {}
 
   static bool classof(const Stmt *T) { 
     return T->getStmtClass() == CXXStaticCastExprClass;

lib/Sema/Sema.cpp

diff --git a/lib/Sema/Sema.cpp b/lib/Sema/Sema.cpp
index b839e76..53a5f6d 100644
--- a/lib/Sema/Sema.cpp
+++ b/lib/Sema/Sema.cpp
@@ -195,7 +195,7 @@
 /// If there is already an implicit cast, merge into the existing one.
 /// If isLvalue, the result of the cast is an lvalue.
 void Sema::ImpCastExprToType(Expr *&Expr, QualType Ty, 
-                             CastExpr::CastKind Kind, bool isLvalue) {
+                             const CastExpr::CastInfo &Info, bool isLvalue) {
   QualType ExprTy = Context.getCanonicalType(Expr->getType());
   QualType TypeTy = Context.getCanonicalType(Ty);
   
@@ -218,7 +218,7 @@
     ImpCast->setType(Ty);
     ImpCast->setLvalueCast(isLvalue);
   } else 
-    Expr = new (Context) ImplicitCastExpr(Ty, Kind, Expr, 
+    Expr = new (Context) ImplicitCastExpr(Ty, Info, Expr, 
                                           isLvalue);
 }
 

lib/Sema/Sema.h

diff --git a/lib/Sema/Sema.h b/lib/Sema/Sema.h
index 4f7ae7e..b237ac3 100644
--- a/lib/Sema/Sema.h
+++ b/lib/Sema/Sema.h
@@ -3016,7 +3016,8 @@
   /// cast.  If there is already an implicit cast, merge into the existing one.
   /// If isLvalue, the result of the cast is an lvalue.
   void ImpCastExprToType(Expr *&Expr, QualType Type, 
-                         CastExpr::CastKind Kind = CastExpr::CK_Unknown,
+                         const CastExpr::CastInfo &Info = 
+                         CastExpr::CastInfo(CastExpr::CK_Unknown),
                          bool isLvalue = false);
 
   // UsualUnaryConversions - promotes integers (C99 6.3.1.1p2) and converts