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

4 files changed, 25 insertions, 15 deletions

diff --git a/include/clang/AST/Expr.h b/include/clang/AST/Expr.h
index 23fd420914..e5aca24f5a 100644
--- a/include/clang/AST/Expr.h
+++ b/include/clang/AST/Expr.h
@@ -1184,11 +1184,20 @@ public:
     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 @@ protected:
          // 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 @@ class ImplicitCastExpr : public CastExpr {
   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 @@ class ExplicitCastExpr : public CastExpr {
   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) 
diff --git a/include/clang/AST/ExprCXX.h b/include/clang/AST/ExprCXX.h
index a254e9914a..c80169269b 100644
--- a/include/clang/AST/ExprCXX.h
+++ b/include/clang/AST/ExprCXX.h
@@ -112,9 +112,9 @@ private:
   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 @@ public:
 /// @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;
diff --git a/lib/Sema/Sema.cpp b/lib/Sema/Sema.cpp
index b839e76969..53a5f6d80f 100644
--- a/lib/Sema/Sema.cpp
+++ b/lib/Sema/Sema.cpp
@@ -195,7 +195,7 @@ Sema::Sema(Preprocessor &pp, ASTContext &ctxt, ASTConsumer &consumer,
 /// 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 @@ void Sema::ImpCastExprToType(Expr *&Expr, QualType Ty,
     ImpCast->setType(Ty);
     ImpCast->setLvalueCast(isLvalue);
   } else 
-    Expr = new (Context) ImplicitCastExpr(Ty, Kind, Expr, 
+    Expr = new (Context) ImplicitCastExpr(Ty, Info, Expr, 
                                           isLvalue);
 }
 
diff --git a/lib/Sema/Sema.h b/lib/Sema/Sema.h
index 4f7ae7ec0d..b237ac3b81 100644
--- a/lib/Sema/Sema.h
+++ b/lib/Sema/Sema.h
@@ -3016,7 +3016,8 @@ public:
   /// 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