diff --git a/include/clang/AST/Expr.h b/include/clang/AST/Expr.h
index 0314a66..e5fd752 100644
--- a/include/clang/AST/Expr.h
+++ b/include/clang/AST/Expr.h
@@ -142,6 +142,50 @@
 };
 
 //===----------------------------------------------------------------------===//
+// ExprIterator - Iterators for iterating over Stmt* arrays that contain
+//  only Expr*.  This is needed because AST nodes use Stmt* arrays to store
+//  references to children (to be compatible with StmtIterator).
+//===----------------------------------------------------------------------===//
+  
+class ExprIterator {
+  Stmt** I;
+public:
+  ExprIterator(Stmt** i) : I(i) {}
+  ExprIterator() : I(0) {}    
+  ExprIterator& operator++() { ++I; return *this; }
+  ExprIterator operator-(size_t i) { return I-i; }
+  ExprIterator operator+(size_t i) { return I+i; }
+  Expr* operator[](size_t idx) { return cast<Expr>(I[idx]); }
+  // FIXME: Verify that this will correctly return a signed distance.
+  signed operator-(const ExprIterator& R) const { return I - R.I; }
+  Expr* operator*() const { return cast<Expr>(*I); }
+  Expr* operator->() const { return cast<Expr>(*I); }
+  bool operator==(const ExprIterator& R) const { return I == R.I; }
+  bool operator!=(const ExprIterator& R) const { return I != R.I; }
+  bool operator>(const ExprIterator& R) const { return I > R.I; }
+  bool operator>=(const ExprIterator& R) const { return I >= R.I; }
+};
+
+class ConstExprIterator {
+  Stmt* const * I;
+public:
+  ConstExprIterator(Stmt* const* i) : I(i) {}
+  ConstExprIterator() : I(0) {}    
+  ConstExprIterator& operator++() { ++I; return *this; }
+  ConstExprIterator operator+(size_t i) { return I+i; }
+  ConstExprIterator operator-(size_t i) { return I-i; }
+  Expr * const operator[](size_t idx) { return cast<Expr>(I[idx]); }
+  signed operator-(const ConstExprIterator& R) const { return I - R.I; }
+  Expr * const operator*() const { return cast<Expr>(*I); }
+  Expr * const operator->() const { return cast<Expr>(*I); }
+  bool operator==(const ConstExprIterator& R) const { return I == R.I; }
+  bool operator!=(const ConstExprIterator& R) const { return I != R.I; }
+  bool operator>(const ConstExprIterator& R) const { return I > R.I; }
+  bool operator>=(const ConstExprIterator& R) const { return I >= R.I; }
+}; 
+  
+  
+//===----------------------------------------------------------------------===//
 // Primary Expressions.
 //===----------------------------------------------------------------------===//
 
@@ -299,13 +343,13 @@
 /// whose element type matches the subexpression.
 ///
 class ImaginaryLiteral : public Expr {
-  Expr *Val;
+  Stmt *Val;
 public:
   ImaginaryLiteral(Expr *val, QualType Ty)
     : Expr(ImaginaryLiteralClass, Ty), Val(val) {}
   
-  const Expr *getSubExpr() const { return Val; }
-  Expr *getSubExpr() { return Val; }
+  const Expr *getSubExpr() const { return cast<Expr>(Val); }
+  Expr *getSubExpr() { return cast<Expr>(Val); }
   
   virtual SourceRange getSourceRange() const { return Val->getSourceRange(); }
   static bool classof(const Stmt *T) { 
@@ -363,13 +407,13 @@
 /// AST node is only formed if full location information is requested.
 class ParenExpr : public Expr {
   SourceLocation L, R;
-  Expr *Val;
+  Stmt *Val;
 public:
   ParenExpr(SourceLocation l, SourceLocation r, Expr *val)
     : Expr(ParenExprClass, val->getType()), L(l), R(r), Val(val) {}
   
-  const Expr *getSubExpr() const { return Val; }
-  Expr *getSubExpr() { return Val; }
+  const Expr *getSubExpr() const { return cast<Expr>(Val); }
+  Expr *getSubExpr() { return cast<Expr>(Val); }
   virtual SourceRange getSourceRange() const { return SourceRange(L, R); }
 
   static bool classof(const Stmt *T) { 
@@ -415,7 +459,7 @@
     OffsetOf          // __builtin_offsetof
   };
 private:
-  Expr *Val;
+  Stmt *Val;
   Opcode Opc;
   SourceLocation Loc;
 public:  
@@ -424,7 +468,7 @@
     : Expr(UnaryOperatorClass, type), Val(input), Opc(opc), Loc(l) {}
 
   Opcode getOpcode() const { return Opc; }
-  Expr *getSubExpr() const { return Val; }
+  Expr *getSubExpr() const { return cast<Expr>(Val); }
   
   /// getOperatorLoc - Return the location of the operator.
   SourceLocation getOperatorLoc() const { return Loc; }
@@ -507,7 +551,7 @@
 /// ArraySubscriptExpr - [C99 6.5.2.1] Array Subscripting.
 class ArraySubscriptExpr : public Expr {
   enum { LHS, RHS, END_EXPR=2 };
-  Expr* SubExprs[END_EXPR]; 
+  Stmt* SubExprs[END_EXPR]; 
   SourceLocation RBracketLoc;
 public:
   ArraySubscriptExpr(Expr *lhs, Expr *rhs, QualType t,
@@ -526,26 +570,26 @@
   /// predicate the format conversion in getBase and getIdx only on the
   /// the type of the RHS, as it is possible for the LHS to be a vector of
   /// integer type
-  Expr *getLHS() { return SubExprs[LHS]; }
-  const Expr *getLHS() const { return SubExprs[LHS]; }
+  Expr *getLHS() { return cast<Expr>(SubExprs[LHS]); }
+  const Expr *getLHS() const { return cast<Expr>(SubExprs[LHS]); }
   
-  Expr *getRHS() { return SubExprs[RHS]; }
-  const Expr *getRHS() const { return SubExprs[RHS]; }
+  Expr *getRHS() { return cast<Expr>(SubExprs[RHS]); }
+  const Expr *getRHS() const { return cast<Expr>(SubExprs[RHS]); }
   
   Expr *getBase() { 
-    return (getRHS()->getType()->isIntegerType()) ? getLHS() : getRHS();
+    return cast<Expr>(getRHS()->getType()->isIntegerType() ? getLHS():getRHS());
   }
     
   const Expr *getBase() const { 
-    return (getRHS()->getType()->isIntegerType()) ? getLHS() : getRHS();
+    return cast<Expr>(getRHS()->getType()->isIntegerType() ? getLHS():getRHS());
   }
   
   Expr *getIdx() { 
-    return (getRHS()->getType()->isIntegerType()) ? getRHS() : getLHS();
+    return cast<Expr>(getRHS()->getType()->isIntegerType() ? getRHS():getLHS());
   }
   
   const Expr *getIdx() const {
-    return (getRHS()->getType()->isIntegerType()) ? getRHS() : getLHS(); 
+    return cast<Expr>(getRHS()->getType()->isIntegerType() ? getRHS():getLHS());
   }  
   
   virtual SourceRange getSourceRange() const { 
@@ -572,12 +616,12 @@
 ///
 class CallExpr : public Expr {
   enum { FN=0, ARGS_START=1 };
-  Expr **SubExprs;
+  Stmt **SubExprs;
   unsigned NumArgs;
   SourceLocation RParenLoc;
   
   // This version of the ctor is for deserialization.
-  CallExpr(Expr** subexprs, unsigned numargs, QualType t, 
+  CallExpr(Stmt** subexprs, unsigned numargs, QualType t, 
            SourceLocation rparenloc)
   : Expr(CallExprClass,t), SubExprs(subexprs), 
     NumArgs(numargs), RParenLoc(rparenloc) {}
@@ -589,8 +633,8 @@
     delete [] SubExprs;
   }
   
-  const Expr *getCallee() const { return SubExprs[FN]; }
-  Expr *getCallee() { return SubExprs[FN]; }
+  const Expr *getCallee() const { return cast<Expr>(SubExprs[FN]); }
+  Expr *getCallee() { return cast<Expr>(SubExprs[FN]); }
   void setCallee(Expr *F) { SubExprs[FN] = F; }
   
   /// getNumArgs - Return the number of actual arguments to this call.
@@ -600,11 +644,11 @@
   /// getArg - Return the specified argument.
   Expr *getArg(unsigned Arg) {
     assert(Arg < NumArgs && "Arg access out of range!");
-    return SubExprs[Arg+ARGS_START];
+    return cast<Expr>(SubExprs[Arg+ARGS_START]);
   }
   const Expr *getArg(unsigned Arg) const {
     assert(Arg < NumArgs && "Arg access out of range!");
-    return SubExprs[Arg+ARGS_START];
+    return cast<Expr>(SubExprs[Arg+ARGS_START]);
   }
   /// setArg - Set the specified argument.
   void setArg(unsigned Arg, Expr *ArgExpr) {
@@ -617,13 +661,13 @@
   /// to null.
   void setNumArgs(unsigned NumArgs);
   
-  typedef Expr **arg_iterator;
-  typedef Expr * const *arg_const_iterator;
+  typedef ExprIterator arg_iterator;
+  typedef ConstExprIterator const_arg_iterator;
+    
   arg_iterator arg_begin() { return SubExprs+ARGS_START; }
   arg_iterator arg_end() { return SubExprs+ARGS_START+getNumArgs(); }
-  arg_const_iterator arg_begin() const { return SubExprs+ARGS_START; }
-  arg_const_iterator arg_end() const { return SubExprs+ARGS_START+getNumArgs(); }
-  
+  const_arg_iterator arg_begin() const { return SubExprs+ARGS_START; }
+  const_arg_iterator arg_end() const { return SubExprs+ARGS_START+getNumArgs();}
   
   /// getNumCommas - Return the number of commas that must have been present in
   /// this function call.
@@ -656,7 +700,7 @@
 /// MemberExpr - [C99 6.5.2.3] Structure and Union Members.
 ///
 class MemberExpr : public Expr {
-  Expr *Base;
+  Stmt *Base;
   FieldDecl *MemberDecl;
   SourceLocation MemberLoc;
   bool IsArrow;      // True if this is "X->F", false if this is "X.F".
@@ -666,7 +710,7 @@
     : Expr(MemberExprClass, ty),
       Base(base), MemberDecl(memberdecl), MemberLoc(l), IsArrow(isarrow) {}
 
-  Expr *getBase() const { return Base; }
+  Expr *getBase() const { return cast<Expr>(Base); }
   FieldDecl *getMemberDecl() const { return MemberDecl; }
   bool isArrow() const { return IsArrow; }
 
@@ -694,7 +738,7 @@
 /// the following is legal:  "V.xy = V.zw" if V is a 4 element extended vector.
 ///
 class ExtVectorElementExpr : public Expr {
-  Expr *Base;
+  Stmt *Base;
   IdentifierInfo &Accessor;
   SourceLocation AccessorLoc;
 public:
@@ -703,8 +747,8 @@
     : Expr(ExtVectorElementExprClass, ty), 
       Base(base), Accessor(accessor), AccessorLoc(loc) {}
                      
-  const Expr *getBase() const { return Base; }
-  Expr *getBase() { return Base; }
+  const Expr *getBase() const { return cast<Expr>(Base); }
+  Expr *getBase() { return cast<Expr>(Base); }
   
   IdentifierInfo &getAccessor() const { return Accessor; }
   
@@ -740,14 +784,14 @@
   /// compound literal like "(int){4}".  This can be null if this is a
   /// synthesized compound expression.
   SourceLocation LParenLoc;
-  Expr *Init;
+  Stmt *Init;
   bool FileScope;
 public:
   CompoundLiteralExpr(SourceLocation lparenloc, QualType ty, Expr *init, bool fileScope) : 
     Expr(CompoundLiteralExprClass, ty), LParenLoc(lparenloc), Init(init), FileScope(fileScope) {}
   
-  const Expr *getInitializer() const { return Init; }
-  Expr *getInitializer() { return Init; }
+  const Expr *getInitializer() const { return cast<Expr>(Init); }
+  Expr *getInitializer() { return cast<Expr>(Init); }
 
   bool isFileScope() const { return FileScope; }
   
@@ -780,13 +824,13 @@
 /// float->double, short->int, etc.
 ///
 class ImplicitCastExpr : public Expr {
-  Expr *Op;
+  Stmt *Op;
 public:
   ImplicitCastExpr(QualType ty, Expr *op) : 
     Expr(ImplicitCastExprClass, ty), Op(op) {}
     
-  Expr *getSubExpr() { return Op; }
-  const Expr *getSubExpr() const { return Op; }
+  Expr *getSubExpr() { return cast<Expr>(Op); }
+  const Expr *getSubExpr() const { return cast<Expr>(Op); }
 
   virtual SourceRange getSourceRange() const { return Op->getSourceRange(); }
 
@@ -806,7 +850,7 @@
 /// CastExpr - [C99 6.5.4] Cast Operators.
 ///
 class CastExpr : public Expr {
-  Expr *Op;
+  Stmt *Op;
   SourceLocation Loc; // the location of the left paren
 public:
   CastExpr(QualType ty, Expr *op, SourceLocation l) : 
@@ -814,7 +858,7 @@
 
   SourceLocation getLParenLoc() const { return Loc; }
   
-  Expr *getSubExpr() const { return Op; }
+  Expr *getSubExpr() const { return cast<Expr>(Op); }
   
   virtual SourceRange getSourceRange() const {
     return SourceRange(Loc, getSubExpr()->getSourceRange().getEnd());
@@ -857,7 +901,7 @@
   };
 private:
   enum { LHS, RHS, END_EXPR };
-  Expr* SubExprs[END_EXPR];
+  Stmt* SubExprs[END_EXPR];
   Opcode Opc;
   SourceLocation OpLoc;
 public:  
@@ -873,8 +917,8 @@
 
   SourceLocation getOperatorLoc() const { return OpLoc; }
   Opcode getOpcode() const { return Opc; }
-  Expr *getLHS() const { return SubExprs[LHS]; }
-  Expr *getRHS() const { return SubExprs[RHS]; }
+  Expr *getLHS() const { return cast<Expr>(SubExprs[LHS]); }
+  Expr *getRHS() const { return cast<Expr>(SubExprs[RHS]); }
   virtual SourceRange getSourceRange() const {
     return SourceRange(getLHS()->getLocStart(), getRHS()->getLocEnd());
   }
@@ -952,7 +996,7 @@
 ///
 class ConditionalOperator : public Expr {
   enum { COND, LHS, RHS, END_EXPR };
-  Expr* SubExprs[END_EXPR]; // Left/Middle/Right hand sides.
+  Stmt* SubExprs[END_EXPR]; // Left/Middle/Right hand sides.
 public:
   ConditionalOperator(Expr *cond, Expr *lhs, Expr *rhs, QualType t)
     : Expr(ConditionalOperatorClass, t) {
@@ -963,7 +1007,7 @@
 
   // getCond - Return the expression representing the condition for
   //  the ?: operator.
-  Expr *getCond() const { return SubExprs[COND]; }
+  Expr *getCond() const { return cast<Expr>(SubExprs[COND]); }
 
   // getTrueExpr - Return the subexpression representing the value of the ?:
   //  expression if the condition evaluates to true.  In most cases this value
@@ -972,15 +1016,15 @@
   //  e.g: x ?: y is shorthand for x ? x : y, except that the expression "x"
   //  is only evaluated once.  
   Expr *getTrueExpr() const {
-    return SubExprs[LHS] ? SubExprs[LHS] : SubExprs[COND];
+    return cast<Expr>(SubExprs[LHS] ? SubExprs[LHS] : SubExprs[COND]);
   }
   
   // getTrueExpr - Return the subexpression representing the value of the ?:
   // expression if the condition evaluates to false. This is the same as getRHS.
-  Expr *getFalseExpr() const { return SubExprs[RHS]; }
+  Expr *getFalseExpr() const { return cast<Expr>(SubExprs[RHS]); }
   
-  Expr *getLHS() const { return SubExprs[LHS]; }
-  Expr *getRHS() const { return SubExprs[RHS]; }
+  Expr *getLHS() const { return cast_or_null<Expr>(SubExprs[LHS]); }
+  Expr *getRHS() const { return cast<Expr>(SubExprs[RHS]); }
 
   virtual SourceRange getSourceRange() const {
     return SourceRange(getCond()->getLocStart(), getRHS()->getLocEnd());
@@ -1030,15 +1074,15 @@
 /// The StmtExpr contains a single CompoundStmt node, which it evaluates and
 /// takes the value of the last subexpression.
 class StmtExpr : public Expr {
-  CompoundStmt *SubStmt;
+  Stmt *SubStmt;
   SourceLocation LParenLoc, RParenLoc;
 public:
   StmtExpr(CompoundStmt *substmt, QualType T,
            SourceLocation lp, SourceLocation rp) :
     Expr(StmtExprClass, T), SubStmt(substmt),  LParenLoc(lp), RParenLoc(rp) { }
   
-  CompoundStmt *getSubStmt() { return SubStmt; }
-  const CompoundStmt *getSubStmt() const { return SubStmt; }
+  CompoundStmt *getSubStmt() { return cast<CompoundStmt>(SubStmt); }
+  const CompoundStmt *getSubStmt() const { return cast<CompoundStmt>(SubStmt); }
   
   virtual SourceRange getSourceRange() const {
     return SourceRange(LParenLoc, RParenLoc);
@@ -1100,7 +1144,7 @@
   // function. The first two are vectors, and the rest are constant
   // indices.  The number of values in this list is always
   // 2+the number of indices in the vector type.
-  Expr **SubExprs;
+  Stmt **SubExprs;
   unsigned NumExprs;
 
 public:
@@ -1110,7 +1154,7 @@
     Expr(ShuffleVectorExprClass, Type), BuiltinLoc(BLoc),
     RParenLoc(RP), NumExprs(nexpr) {
       
-    SubExprs = new Expr*[nexpr];
+    SubExprs = new Stmt*[nexpr];
     for (unsigned i = 0; i < nexpr; i++)
       SubExprs[i] = args[i];
   }
@@ -1135,11 +1179,11 @@
   /// getExpr - Return the Expr at the specified index.
   Expr *getExpr(unsigned Index) {
     assert((Index < NumExprs) && "Arg access out of range!");
-    return SubExprs[Index];
+    return cast<Expr>(SubExprs[Index]);
   }
   const Expr *getExpr(unsigned Index) const {
     assert((Index < NumExprs) && "Arg access out of range!");
-    return SubExprs[Index];
+    return cast<Expr>(SubExprs[Index]);
   }
 
   unsigned getShuffleMaskIdx(ASTContext &Ctx, unsigned N) {
@@ -1163,7 +1207,7 @@
 /// - does not evaluate the expression that was not chosen.
 class ChooseExpr : public Expr {
   enum { COND, LHS, RHS, END_EXPR };
-  Expr* SubExprs[END_EXPR]; // Left/Middle/Right hand sides.
+  Stmt* SubExprs[END_EXPR]; // Left/Middle/Right hand sides.
   SourceLocation BuiltinLoc, RParenLoc;
 public:
   ChooseExpr(SourceLocation BLoc, Expr *cond, Expr *lhs, Expr *rhs, QualType t,
@@ -1179,9 +1223,9 @@
   /// statically knowable for a well-formed choosexpr.
   bool isConditionTrue(ASTContext &C) const;
   
-  Expr *getCond() const { return SubExprs[COND]; }
-  Expr *getLHS() const { return SubExprs[LHS]; }
-  Expr *getRHS() const { return SubExprs[RHS]; }
+  Expr *getCond() const { return cast<Expr>(SubExprs[COND]); }
+  Expr *getLHS() const { return cast<Expr>(SubExprs[LHS]); }
+  Expr *getRHS() const { return cast<Expr>(SubExprs[RHS]); }
 
   virtual SourceRange getSourceRange() const {
     return SourceRange(BuiltinLoc, RParenLoc);
@@ -1219,7 +1263,7 @@
   // SubExpr[0] is a constant expression
   // SubExpr[1-N] are the parameters to pass to the matching function call
   // SubExpr[N-...] are the candidate functions, of type pointer to function.
-  Expr **SubExprs;
+  Stmt **SubExprs;
 
   // NumExprs - the size of the SubExprs array
   unsigned NumExprs;
@@ -1234,7 +1278,7 @@
                SourceLocation bloc, SourceLocation rploc)
     : Expr(OverloadExprClass, t), NumExprs(nexprs), FnIndex(idx),
       BuiltinLoc(bloc), RParenLoc(rploc) {
-    SubExprs = new Expr*[nexprs];
+    SubExprs = new Stmt*[nexprs];
     for (unsigned i = 0; i != nexprs; ++i)
       SubExprs[i] = args[i];
   }
@@ -1245,14 +1289,17 @@
   /// arg_begin - Return a pointer to the list of arguments that will be passed
   /// to the matching candidate function, skipping over the initial constant
   /// expression.
-  typedef Expr * const *arg_const_iterator;
-  arg_const_iterator arg_begin() const { return SubExprs+1; }
-
+  typedef ConstExprIterator const_arg_iterator;
+  const_arg_iterator arg_begin() const { return &SubExprs[0]+1; }
+  const_arg_iterator arg_end(ASTContext& Ctx) const {
+    return &SubExprs[0]+1+getNumArgs(Ctx);
+  }
+  
   /// getNumArgs - Return the number of arguments to pass to the candidate
   /// functions.
   unsigned getNumArgs(ASTContext &Ctx) const {
     llvm::APSInt constEval(32);
-    (void) SubExprs[0]->isIntegerConstantExpr(constEval, Ctx);
+    (void) cast<Expr>(SubExprs[0])->isIntegerConstantExpr(constEval, Ctx);
     return constEval.getZExtValue();
   }
 
@@ -1264,11 +1311,11 @@
   /// getExpr - Return the Expr at the specified index.
   Expr *getExpr(unsigned Index) {
     assert((Index < NumExprs) && "Arg access out of range!");
-    return SubExprs[Index];
+    return cast<Expr>(SubExprs[Index]);
   }
   
   /// getFn - Return the matching candidate function for this OverloadExpr.
-  Expr *getFn() const { return SubExprs[FnIndex]; }
+  Expr *getFn() const { return cast<Expr>(SubExprs[FnIndex]); }
   
   virtual SourceRange getSourceRange() const {
     return SourceRange(BuiltinLoc, RParenLoc);
@@ -1285,7 +1332,7 @@
 
 /// VAArgExpr, used for the builtin function __builtin_va_start.
 class VAArgExpr : public Expr {
-  Expr *Val;
+  Stmt *Val;
   SourceLocation BuiltinLoc, RParenLoc;
 public:
   VAArgExpr(SourceLocation BLoc, Expr* e, QualType t, SourceLocation RPLoc)
@@ -1294,8 +1341,8 @@
       BuiltinLoc(BLoc),
       RParenLoc(RPLoc) { }
   
-  const Expr *getSubExpr() const { return Val; }
-  Expr *getSubExpr() { return Val; }
+  const Expr *getSubExpr() const { return cast<Expr>(Val); }
+  Expr *getSubExpr() { return cast<Expr>(Val); }
   virtual SourceRange getSourceRange() const {
     return SourceRange(BuiltinLoc, RParenLoc);
   }  
@@ -1329,7 +1376,7 @@
 ///         int x = { 1 };  int y[2] = { {1}, {2} };
 ///
 class InitListExpr : public Expr {
-  std::vector<Expr *> InitExprs;
+  std::vector<Stmt *> InitExprs;
   SourceLocation LBraceLoc, RBraceLoc;
 public:
   InitListExpr(SourceLocation lbraceloc, Expr **initexprs, unsigned numinits,
@@ -1339,12 +1386,12 @@
   
   const Expr* getInit(unsigned Init) const { 
     assert(Init < getNumInits() && "Initializer access out of range!");
-    return InitExprs[Init];
+    return cast<Expr>(InitExprs[Init]);
   }
   
   Expr* getInit(unsigned Init) { 
     assert(Init < getNumInits() && "Initializer access out of range!");
-    return InitExprs[Init];
+    return cast<Expr>(InitExprs[Init]);
   }
   
   void setInit(unsigned Init, Expr *expr) { 
diff --git a/include/clang/AST/ExprObjC.h b/include/clang/AST/ExprObjC.h
index 0118c38..12c5afc 100644
--- a/include/clang/AST/ExprObjC.h
+++ b/include/clang/AST/ExprObjC.h
@@ -152,7 +152,7 @@
 class ObjCIvarRefExpr : public Expr {
   class ObjCIvarDecl *D; 
   SourceLocation Loc;
-  Expr *Base;
+  Stmt *Base;
   bool IsArrow:1;      // True if this is "X->F", false if this is "X.F".
   bool IsFreeIvar:1;   // True if ivar reference has no base (self assumed).
   
@@ -168,8 +168,8 @@
     return isFreeIvar() ? SourceRange(Loc)
                         : SourceRange(getBase()->getLocStart(), Loc); 
   }
-  const Expr *getBase() const { return Base; }
-  Expr *getBase() { return Base; }
+  const Expr *getBase() const { return cast<Expr>(Base); }
+  Expr *getBase() { return cast<Expr>(Base); }
   void setBase(Expr * base) { Base = base; }
   bool isArrow() const { return IsArrow; }
   bool isFreeIvar() const { return IsFreeIvar; }
@@ -193,7 +193,7 @@
 class ObjCPropertyRefExpr : public Expr {
   class Decl *D; // an ObjCMethodDecl or ObjCPropertyDecl
   SourceLocation Loc;
-  Expr *Base;
+  Stmt *Base;
   
 public:
   ObjCPropertyRefExpr(Decl *d, QualType t, SourceLocation l, Expr *base) : 
@@ -205,8 +205,8 @@
   virtual SourceRange getSourceRange() const { 
     return SourceRange(getBase()->getLocStart(), Loc); 
   }
-  const Expr *getBase() const { return Base; }
-  Expr *getBase() { return Base; }
+  const Expr *getBase() const { return cast<Expr>(Base); }
+  Expr *getBase() { return cast<Expr>(Base); }
   void setBase(Expr * base) { Base = base; }
   
   SourceLocation getLocation() const { return Loc; }
@@ -227,7 +227,7 @@
 class ObjCMessageExpr : public Expr {
   enum { RECEIVER=0, ARGS_START=1 };
 
-  Expr **SubExprs;
+  Stmt **SubExprs;
   
   unsigned NumArgs;
   
@@ -297,11 +297,11 @@
   /// getArg - Return the specified argument.
   Expr *getArg(unsigned Arg) {
     assert(Arg < NumArgs && "Arg access out of range!");
-    return SubExprs[Arg+ARGS_START];
+    return cast<Expr>(SubExprs[Arg+ARGS_START]);
   }
   const Expr *getArg(unsigned Arg) const {
     assert(Arg < NumArgs && "Arg access out of range!");
-    return SubExprs[Arg+ARGS_START];
+    return cast<Expr>(SubExprs[Arg+ARGS_START]);
   }
   /// setArg - Set the specified argument.
   void setArg(unsigned Arg, Expr *ArgExpr) {
@@ -322,13 +322,13 @@
   virtual child_iterator child_begin();
   virtual child_iterator child_end();
   
-  typedef Expr** arg_iterator;
-  typedef const Expr* const* const_arg_iterator;
+  typedef ExprIterator arg_iterator;
+  typedef ConstExprIterator const_arg_iterator;
   
   arg_iterator arg_begin() { return &SubExprs[ARGS_START]; }
-  arg_iterator arg_end()   { return arg_begin() + NumArgs; }
+  arg_iterator arg_end()   { return &SubExprs[ARGS_START] + NumArgs; }
   const_arg_iterator arg_begin() const { return &SubExprs[ARGS_START]; }
-  const_arg_iterator arg_end() const { return arg_begin() + NumArgs; }
+  const_arg_iterator arg_end() const { return &SubExprs[ARGS_START] + NumArgs; }
   
   // Serialization.
   virtual void EmitImpl(llvm::Serializer& S) const;
diff --git a/lib/AST/Expr.cpp b/lib/AST/Expr.cpp
index 78c3050..496afd6 100644
--- a/lib/AST/Expr.cpp
+++ b/lib/AST/Expr.cpp
@@ -92,7 +92,7 @@
 CallExpr::CallExpr(Expr *fn, Expr **args, unsigned numargs, QualType t,
                    SourceLocation rparenloc)
   : Expr(CallExprClass, t), NumArgs(numargs) {
-  SubExprs = new Expr*[numargs+1];
+  SubExprs = new Stmt*[numargs+1];
   SubExprs[FN] = fn;
   for (unsigned i = 0; i != numargs; ++i)
     SubExprs[i+ARGS_START] = args[i];
@@ -115,7 +115,7 @@
   }
 
   // Otherwise, we are growing the # arguments.  New an bigger argument array.
-  Expr **NewSubExprs = new Expr*[NumArgs+1];
+  Stmt **NewSubExprs = new Stmt*[NumArgs+1];
   // Copy over args.
   for (unsigned i = 0; i != getNumArgs()+ARGS_START; ++i)
     NewSubExprs[i] = SubExprs[i];
@@ -1109,7 +1109,7 @@
   : Expr(ObjCMessageExprClass, retType), SelName(selInfo), 
     MethodProto(mproto) {
   NumArgs = nargs;
-  SubExprs = new Expr*[NumArgs+1];
+  SubExprs = new Stmt*[NumArgs+1];
   SubExprs[RECEIVER] = receiver;
   if (NumArgs) {
     for (unsigned i = 0; i != NumArgs; ++i)
@@ -1128,7 +1128,7 @@
   : Expr(ObjCMessageExprClass, retType), SelName(selInfo), 
     MethodProto(mproto) {
   NumArgs = nargs;
-  SubExprs = new Expr*[NumArgs+1];
+  SubExprs = new Stmt*[NumArgs+1];
   SubExprs[RECEIVER] = (Expr*) ((uintptr_t) clsName | 0x1);
   if (NumArgs) {
     for (unsigned i = 0; i != NumArgs; ++i)
@@ -1184,7 +1184,7 @@
   assert(Opc == OffsetOf && "Unary operator not offsetof!");
   
   unsigned CharSize = C.Target.getCharWidth();
-  return ::evaluateOffsetOf(C, Val) / CharSize;
+  return ::evaluateOffsetOf(C, cast<Expr>(Val)) / CharSize;
 }
 
 //===----------------------------------------------------------------------===//
@@ -1196,22 +1196,12 @@
 Stmt::child_iterator DeclRefExpr::child_end() { return child_iterator(); }
 
 // ObjCIvarRefExpr
-Stmt::child_iterator ObjCIvarRefExpr::child_begin() {
-  return reinterpret_cast<Stmt**>(&Base);
-}
-
-Stmt::child_iterator ObjCIvarRefExpr::child_end() {
-  return reinterpret_cast<Stmt**>(&Base)+1;
-}
+Stmt::child_iterator ObjCIvarRefExpr::child_begin() { return &Base; }
+Stmt::child_iterator ObjCIvarRefExpr::child_end() { return &Base+1; }
 
 // ObjCPropertyRefExpr
-Stmt::child_iterator ObjCPropertyRefExpr::child_begin() {
-  return reinterpret_cast<Stmt**>(&Base);
-}
-
-Stmt::child_iterator ObjCPropertyRefExpr::child_end() {
-  return reinterpret_cast<Stmt**>(&Base)+1;
-}
+Stmt::child_iterator ObjCPropertyRefExpr::child_begin() { return &Base; }
+Stmt::child_iterator ObjCPropertyRefExpr::child_end() { return &Base+1; }
 
 // ObjCSuperRefExpr
 Stmt::child_iterator ObjCSuperRefExpr::child_begin() { return child_iterator();}
@@ -1234,32 +1224,20 @@
 Stmt::child_iterator FloatingLiteral::child_end() { return child_iterator(); }
 
 // ImaginaryLiteral
-Stmt::child_iterator ImaginaryLiteral::child_begin() {
-  return reinterpret_cast<Stmt**>(&Val);
-}
-Stmt::child_iterator ImaginaryLiteral::child_end() {
-  return reinterpret_cast<Stmt**>(&Val)+1;
-}
+Stmt::child_iterator ImaginaryLiteral::child_begin() { return &Val; }
+Stmt::child_iterator ImaginaryLiteral::child_end() { return &Val+1; }
 
 // StringLiteral
 Stmt::child_iterator StringLiteral::child_begin() { return child_iterator(); }
 Stmt::child_iterator StringLiteral::child_end() { return child_iterator(); }
 
 // ParenExpr
-Stmt::child_iterator ParenExpr::child_begin() {
-  return reinterpret_cast<Stmt**>(&Val);
-}
-Stmt::child_iterator ParenExpr::child_end() {
-  return reinterpret_cast<Stmt**>(&Val)+1;
-}
+Stmt::child_iterator ParenExpr::child_begin() { return &Val; }
+Stmt::child_iterator ParenExpr::child_end() { return &Val+1; }
 
 // UnaryOperator
-Stmt::child_iterator UnaryOperator::child_begin() {
-  return reinterpret_cast<Stmt**>(&Val);
-}
-Stmt::child_iterator UnaryOperator::child_end() {
-  return reinterpret_cast<Stmt**>(&Val+1);
-}
+Stmt::child_iterator UnaryOperator::child_begin() { return &Val; }
+Stmt::child_iterator UnaryOperator::child_end() { return &Val+1; }
 
 // SizeOfAlignOfTypeExpr
 Stmt::child_iterator SizeOfAlignOfTypeExpr::child_begin() { 
@@ -1276,74 +1254,54 @@
 
 // ArraySubscriptExpr
 Stmt::child_iterator ArraySubscriptExpr::child_begin() {
-  return reinterpret_cast<Stmt**>(&SubExprs);
+  return &SubExprs[0];
 }
 Stmt::child_iterator ArraySubscriptExpr::child_end() {
-  return reinterpret_cast<Stmt**>(&SubExprs)+END_EXPR;
+  return &SubExprs[0]+END_EXPR;
 }
 
 // CallExpr
 Stmt::child_iterator CallExpr::child_begin() {
-  return reinterpret_cast<Stmt**>(&SubExprs[0]);
+  return &SubExprs[0];
 }
 Stmt::child_iterator CallExpr::child_end() {
-  return reinterpret_cast<Stmt**>(&SubExprs[NumArgs+ARGS_START]);
+  return &SubExprs[0]+NumArgs+ARGS_START;
 }
 
 // MemberExpr
-Stmt::child_iterator MemberExpr::child_begin() {
-  return reinterpret_cast<Stmt**>(&Base);
-}
-Stmt::child_iterator MemberExpr::child_end() {
-  return reinterpret_cast<Stmt**>(&Base)+1;
-}
+Stmt::child_iterator MemberExpr::child_begin() { return &Base; }
+Stmt::child_iterator MemberExpr::child_end() { return &Base+1; }
 
 // ExtVectorElementExpr
-Stmt::child_iterator ExtVectorElementExpr::child_begin() {
-  return reinterpret_cast<Stmt**>(&Base);
-}
-Stmt::child_iterator ExtVectorElementExpr::child_end() {
-  return reinterpret_cast<Stmt**>(&Base)+1;
-}
+Stmt::child_iterator ExtVectorElementExpr::child_begin() { return &Base; }
+Stmt::child_iterator ExtVectorElementExpr::child_end() { return &Base+1; }
 
 // CompoundLiteralExpr
-Stmt::child_iterator CompoundLiteralExpr::child_begin() {
-  return reinterpret_cast<Stmt**>(&Init);
-}
-Stmt::child_iterator CompoundLiteralExpr::child_end() {
-  return reinterpret_cast<Stmt**>(&Init)+1;
-}
+Stmt::child_iterator CompoundLiteralExpr::child_begin() { return &Init; }
+Stmt::child_iterator CompoundLiteralExpr::child_end() { return &Init+1; }
 
 // ImplicitCastExpr
-Stmt::child_iterator ImplicitCastExpr::child_begin() {
-  return reinterpret_cast<Stmt**>(&Op);
-}
-Stmt::child_iterator ImplicitCastExpr::child_end() {
-  return reinterpret_cast<Stmt**>(&Op)+1;
-}
+Stmt::child_iterator ImplicitCastExpr::child_begin() { return &Op; }
+Stmt::child_iterator ImplicitCastExpr::child_end() { return &Op+1; }
 
 // CastExpr
-Stmt::child_iterator CastExpr::child_begin() {
-  return reinterpret_cast<Stmt**>(&Op);
-}
-Stmt::child_iterator CastExpr::child_end() {
-  return reinterpret_cast<Stmt**>(&Op)+1;
-}
+Stmt::child_iterator CastExpr::child_begin() { return &Op; }
+Stmt::child_iterator CastExpr::child_end() { return &Op+1; }
 
 // BinaryOperator
 Stmt::child_iterator BinaryOperator::child_begin() {
-  return reinterpret_cast<Stmt**>(&SubExprs);
+  return &SubExprs[0];
 }
 Stmt::child_iterator BinaryOperator::child_end() {
-  return reinterpret_cast<Stmt**>(&SubExprs)+END_EXPR;
+  return &SubExprs[0]+END_EXPR;
 }
 
 // ConditionalOperator
 Stmt::child_iterator ConditionalOperator::child_begin() {
-  return reinterpret_cast<Stmt**>(&SubExprs);
+  return &SubExprs[0];
 }
 Stmt::child_iterator ConditionalOperator::child_end() {
-  return reinterpret_cast<Stmt**>(&SubExprs)+END_EXPR;
+  return &SubExprs[0]+END_EXPR;
 }
 
 // AddrLabelExpr
@@ -1351,12 +1309,8 @@
 Stmt::child_iterator AddrLabelExpr::child_end() { return child_iterator(); }
 
 // StmtExpr
-Stmt::child_iterator StmtExpr::child_begin() {
-  return reinterpret_cast<Stmt**>(&SubStmt);
-}
-Stmt::child_iterator StmtExpr::child_end() {
-  return reinterpret_cast<Stmt**>(&SubStmt)+1;
-}
+Stmt::child_iterator StmtExpr::child_begin() { return &SubStmt; }
+Stmt::child_iterator StmtExpr::child_end() { return &SubStmt+1; }
 
 // TypesCompatibleExpr
 Stmt::child_iterator TypesCompatibleExpr::child_begin() {
@@ -1368,47 +1322,31 @@
 }
 
 // ChooseExpr
-Stmt::child_iterator ChooseExpr::child_begin() {
-  return reinterpret_cast<Stmt**>(&SubExprs);
-}
-
-Stmt::child_iterator ChooseExpr::child_end() {
-  return reinterpret_cast<Stmt**>(&SubExprs)+END_EXPR;
-}
+Stmt::child_iterator ChooseExpr::child_begin() { return &SubExprs[0]; }
+Stmt::child_iterator ChooseExpr::child_end() { return &SubExprs[0]+END_EXPR; }
 
 // OverloadExpr
-Stmt::child_iterator OverloadExpr::child_begin() {
-  return reinterpret_cast<Stmt**>(&SubExprs[0]);
-}
-Stmt::child_iterator OverloadExpr::child_end() {
-  return reinterpret_cast<Stmt**>(&SubExprs[NumExprs]);
-}
+Stmt::child_iterator OverloadExpr::child_begin() { return &SubExprs[0]; }
+Stmt::child_iterator OverloadExpr::child_end() { return &SubExprs[0]+NumExprs; }
 
 // ShuffleVectorExpr
 Stmt::child_iterator ShuffleVectorExpr::child_begin() {
-  return reinterpret_cast<Stmt**>(&SubExprs[0]);
+  return &SubExprs[0];
 }
 Stmt::child_iterator ShuffleVectorExpr::child_end() {
-  return reinterpret_cast<Stmt**>(&SubExprs[NumExprs]);
+  return &SubExprs[0]+NumExprs;
 }
 
 // VAArgExpr
-Stmt::child_iterator VAArgExpr::child_begin() {
-  return reinterpret_cast<Stmt**>(&Val);
-}
-
-Stmt::child_iterator VAArgExpr::child_end() {
-  return reinterpret_cast<Stmt**>(&Val)+1;
-}
+Stmt::child_iterator VAArgExpr::child_begin() { return &Val; }
+Stmt::child_iterator VAArgExpr::child_end() { return &Val+1; }
 
 // InitListExpr
 Stmt::child_iterator InitListExpr::child_begin() {
-  return reinterpret_cast<Stmt**>(InitExprs.size() ? 
-                                  &InitExprs[0] : 0);
+  return InitExprs.size() ? &InitExprs[0] : 0;
 }
 Stmt::child_iterator InitListExpr::child_end() {
-  return reinterpret_cast<Stmt**>(InitExprs.size() ? 
-                                  &InitExprs[0] + InitExprs.size() : 0);
+  return InitExprs.size() ? &InitExprs[0] + InitExprs.size() : 0;
 }
 
 // ObjCStringLiteral
@@ -1441,9 +1379,9 @@
 
 // ObjCMessageExpr
 Stmt::child_iterator ObjCMessageExpr::child_begin() {  
-  return reinterpret_cast<Stmt**>(&SubExprs[ getReceiver() ? 0 : ARGS_START ]);
+  return getReceiver() ? &SubExprs[0] : &SubExprs[0] + ARGS_START;
 }
 Stmt::child_iterator ObjCMessageExpr::child_end() {
-  return reinterpret_cast<Stmt**>(&SubExprs[getNumArgs()+ARGS_START]);
+  return &SubExprs[0]+ARGS_START+getNumArgs();
 }
 
diff --git a/lib/AST/StmtSerialization.cpp b/lib/AST/StmtSerialization.cpp
index 6fcc1ef..cc794f0 100644
--- a/lib/AST/StmtSerialization.cpp
+++ b/lib/AST/StmtSerialization.cpp
@@ -338,7 +338,7 @@
   QualType t = QualType::ReadVal(D);
   SourceLocation L = SourceLocation::ReadVal(D);
   unsigned NumArgs = D.ReadInt();
-  Expr** SubExprs = new Expr*[NumArgs+1];
+  Stmt** SubExprs = new Stmt*[NumArgs+1];
   D.BatchReadOwnedPtrs(NumArgs+1, SubExprs, C);
 
   return new CallExpr(SubExprs,NumArgs,t,L);  
diff --git a/lib/Analysis/CFRefCount.cpp b/lib/Analysis/CFRefCount.cpp
index 24971ed..7207c13 100644
--- a/lib/Analysis/CFRefCount.cpp
+++ b/lib/Analysis/CFRefCount.cpp
@@ -194,10 +194,10 @@
     return Receiver;
   }
   
-  typedef ArgEffects::const_iterator arg_iterator;
+  typedef ArgEffects::const_iterator ExprIterator;
   
-  arg_iterator begin_args() const { return Args->begin(); }
-  arg_iterator end_args()   const { return Args->end(); }
+  ExprIterator begin_args() const { return Args->begin(); }
+  ExprIterator end_args()   const { return Args->end(); }
   
   static void Profile(llvm::FoldingSetNodeID& ID, ArgEffects* A,
                       RetEffect RetEff, ArgEffect DefaultEff,
@@ -998,7 +998,7 @@
                    Expr* Ex,
                    Expr* Receiver,
                    RetainSummary* Summ,
-                   Expr** arg_beg, Expr** arg_end,                             
+                   ExprIterator arg_beg, ExprIterator arg_end,                             
                    ExplodedNode<ValueState>* Pred);
     
   virtual void EvalCall(ExplodedNodeSet<ValueState>& Dst,
@@ -1129,7 +1129,7 @@
                              Expr* Ex,
                              Expr* Receiver,
                              RetainSummary* Summ,
-                             Expr** arg_beg, Expr** arg_end,                             
+                             ExprIterator arg_beg, ExprIterator arg_end,                             
                              ExplodedNode<ValueState>* Pred) {
   
   
@@ -1146,7 +1146,7 @@
   Expr* ErrorExpr = NULL;
   SymbolID ErrorSym = 0;                                        
   
-  for (Expr **I = arg_beg, **E = arg_end; I != E; ++I, ++idx) {
+  for (ExprIterator I = arg_beg; I != arg_end; ++I, ++idx) {
     
     RVal V = StateMgr.GetRVal(St, *I);
     
@@ -1235,9 +1235,9 @@
       
     case RetEffect::Alias: {
       unsigned idx = RE.getValue();
-      assert ((arg_end - arg_beg) >= 0);
+      assert (arg_end >= arg_beg);
       assert (idx < (unsigned) (arg_end - arg_beg));
-      RVal V = StateMgr.GetRVal(St, arg_beg[idx]);
+      RVal V = StateMgr.GetRVal(St, *(arg_beg+idx));
       St = StateMgr.SetRVal(St, Ex, V, Eng.getCFG().isBlkExpr(Ex), false);
       break;
     }
diff --git a/lib/CodeGen/CGBuiltin.cpp b/lib/CodeGen/CGBuiltin.cpp
index f8132f4..cd6b742 100644
--- a/lib/CodeGen/CGBuiltin.cpp
+++ b/lib/CodeGen/CGBuiltin.cpp
@@ -42,7 +42,7 @@
     if (getContext().BuiltinInfo.isLibFunction(BuiltinID))
       return EmitCallExpr(CGM.getBuiltinLibFunction(BuiltinID), 
                           E->getCallee()->getType(), E->arg_begin(),
-                          E->getNumArgs());
+                          E->arg_end());
   
     // See if we have a target specific intrinsic.
     Intrinsic::ID IntrinsicID;
diff --git a/lib/CodeGen/CGExpr.cpp b/lib/CodeGen/CGExpr.cpp
index 05a8972..5856531 100644
--- a/lib/CodeGen/CGExpr.cpp
+++ b/lib/CodeGen/CGExpr.cpp
@@ -650,13 +650,15 @@
         
   llvm::Value *Callee = EmitScalarExpr(E->getCallee());
   return EmitCallExpr(Callee, E->getCallee()->getType(),
-                      E->arg_begin(), E->getNumArgs());
+                      E->arg_begin(), E->arg_end());
 }
 
-RValue CodeGenFunction::EmitCallExpr(Expr *FnExpr, Expr *const *Args,
-                                     unsigned NumArgs) {
+RValue CodeGenFunction::EmitCallExpr(Expr *FnExpr,
+                                     CallExpr::const_arg_iterator ArgBeg,
+                                     CallExpr::const_arg_iterator ArgEnd) {
+
   llvm::Value *Callee = EmitScalarExpr(FnExpr);
-  return EmitCallExpr(Callee, FnExpr->getType(), Args, NumArgs);
+  return EmitCallExpr(Callee, FnExpr->getType(), ArgBeg, ArgEnd);
 }
 
 LValue CodeGenFunction::EmitCallExprLValue(const CallExpr *E) {
@@ -702,7 +704,9 @@
 }
 
 RValue CodeGenFunction::EmitCallExpr(llvm::Value *Callee, QualType FnType, 
-                                     Expr *const *ArgExprs, unsigned NumArgs) {
+                                     CallExpr::const_arg_iterator ArgBeg,
+                                     CallExpr::const_arg_iterator ArgEnd) {
+  
   // The callee type will always be a pointer to function type, get the function
   // type.
   FnType = cast<PointerType>(FnType.getCanonicalType())->getPointeeType();
@@ -718,20 +722,20 @@
     // FIXME: set the stret attribute on the argument.
   }
   
-  for (unsigned i = 0, e = NumArgs; i != e; ++i) {
-    QualType ArgTy = ArgExprs[i]->getType();
+  for (CallExpr::const_arg_iterator I = ArgBeg; I != ArgEnd; ++I) {
+    QualType ArgTy = I->getType();
 
     if (!hasAggregateLLVMType(ArgTy)) {
       // Scalar argument is passed by-value.
-      Args.push_back(EmitScalarExpr(ArgExprs[i]));
+      Args.push_back(EmitScalarExpr(*I));
     } else if (ArgTy->isAnyComplexType()) {
       // Make a temporary alloca to pass the argument.
       llvm::Value *DestMem = CreateTempAlloca(ConvertType(ArgTy));
-      EmitComplexExprIntoAddr(ArgExprs[i], DestMem, false);
+      EmitComplexExprIntoAddr(*I, DestMem, false);
       Args.push_back(DestMem);
     } else {
       llvm::Value *DestMem = CreateTempAlloca(ConvertType(ArgTy));
-      EmitAggExpr(ArgExprs[i], DestMem, false);
+      EmitAggExpr(*I, DestMem, false);
       Args.push_back(DestMem);
     }
   }
@@ -744,8 +748,10 @@
     ParamAttrList.push_back(
         llvm::ParamAttrsWithIndex::get(1, llvm::ParamAttr::StructRet));
   unsigned increment = hasAggregateLLVMType(ResultType) ? 2 : 1;
-  for (unsigned i = 0; i < NumArgs; i++) {
-    QualType ParamType = ArgExprs[i]->getType();
+  
+  unsigned i = 0;
+  for (CallExpr::const_arg_iterator I = ArgBeg; I != ArgEnd; ++I, ++i) {
+    QualType ParamType = I->getType();
     unsigned ParamAttrs = 0;
     if (ParamType->isRecordType())
       ParamAttrs |= llvm::ParamAttr::ByVal;
diff --git a/lib/CodeGen/CGExprAgg.cpp b/lib/CodeGen/CGExprAgg.cpp
index 924a5cf..748ddde 100644
--- a/lib/CodeGen/CGExprAgg.cpp
+++ b/lib/CodeGen/CGExprAgg.cpp
@@ -206,7 +206,8 @@
 void AggExprEmitter::VisitOverloadExpr(const OverloadExpr *E)
 {
   RValue RV = CGF.EmitCallExpr(E->getFn(), E->arg_begin(),
-                               E->getNumArgs(CGF.getContext()));
+                               E->arg_end(CGF.getContext()));
+  
   assert(RV.isAggregate() && "Return value must be aggregate value!");
   
   // If the result is ignored, don't copy from the value.
diff --git a/lib/CodeGen/CGExprComplex.cpp b/lib/CodeGen/CGExprComplex.cpp
index 8a8e798..6bf0d48 100644
--- a/lib/CodeGen/CGExprComplex.cpp
+++ b/lib/CodeGen/CGExprComplex.cpp
@@ -246,8 +246,8 @@
 }
 
 ComplexPairTy ComplexExprEmitter::VisitOverloadExpr(const OverloadExpr *E) {
-  return CGF.EmitCallExpr(E->getFn(), E->arg_begin(),
-                          E->getNumArgs(CGF.getContext())).getComplexVal();
+  return CGF.EmitCallExpr(E->getFn(), E->arg_begin(), 
+                          E->arg_end(CGF.getContext())).getComplexVal();
 }
 
 ComplexPairTy ComplexExprEmitter::VisitStmtExpr(const StmtExpr *E) {
diff --git a/lib/CodeGen/CGExprScalar.cpp b/lib/CodeGen/CGExprScalar.cpp
index ea92828..47bbd88 100644
--- a/lib/CodeGen/CGExprScalar.cpp
+++ b/lib/CodeGen/CGExprScalar.cpp
@@ -1095,7 +1095,7 @@
 
 Value *ScalarExprEmitter::VisitOverloadExpr(OverloadExpr *E) {
   return CGF.EmitCallExpr(E->getFn(), E->arg_begin(),
-                          E->getNumArgs(CGF.getContext())).getScalarVal();
+                          E->arg_end(CGF.getContext())).getScalarVal();
 }
 
 Value *ScalarExprEmitter::VisitVAArgExpr(VAArgExpr *VE) {
diff --git a/lib/CodeGen/CodeGenFunction.h b/lib/CodeGen/CodeGenFunction.h
index 313d2d1..6712d2f 100644
--- a/lib/CodeGen/CodeGenFunction.h
+++ b/lib/CodeGen/CodeGenFunction.h
@@ -18,6 +18,9 @@
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/Support/IRBuilder.h"
+#include "clang/AST/Expr.h"
+#include "clang/AST/ExprObjC.h"
+
 #include <vector>
 
 namespace llvm {
@@ -31,50 +34,7 @@
   class ObjCMethodDecl;
   class TargetInfo;
   class FunctionTypeProto;
-  
-  class Stmt;
-  class CompoundStmt;
-  class LabelStmt;
-  class GotoStmt;
-  class IfStmt;
-  class WhileStmt;
-  class DoStmt;
-  class ForStmt;
-  class ReturnStmt;
-  class DeclStmt;
-  class CaseStmt;
-  class DefaultStmt;
-  class SwitchStmt;
-  class AsmStmt;
-  
-  class Expr;
-  class DeclRefExpr;
-  class StringLiteral;
-  class IntegerLiteral;
-  class FloatingLiteral;
-  class CharacterLiteral;
-  class TypesCompatibleExpr;
-  
-  class ImplicitCastExpr;
-  class CastExpr;
-  class CallExpr;
-  class UnaryOperator;
-  class BinaryOperator;
-  class CompoundAssignOperator;
-  class ArraySubscriptExpr;
-  class ExtVectorElementExpr;
-  class ConditionalOperator;
-  class ChooseExpr;
-  class PreDefinedExpr;
-  class ObjCStringLiteral;
-  class ObjCIvarRefExpr;
-  class MemberExpr;
-  class CompoundLiteralExpr;
 
-  class VarDecl;
-  class EnumConstantDecl;
-  class ParmVarDecl;
-  class FieldDecl;
 namespace CodeGen {
   class CodeGenModule;
   class CodeGenTypes;
@@ -468,9 +428,14 @@
   //===--------------------------------------------------------------------===//
 
   RValue EmitCallExpr(const CallExpr *E);
-  RValue EmitCallExpr(Expr *FnExpr, Expr *const *Args, unsigned NumArgs);
+
+  RValue EmitCallExpr(Expr *FnExpr, CallExpr::const_arg_iterator ArgBeg,
+                      CallExpr::const_arg_iterator ArgEnd);
+
   RValue EmitCallExpr(llvm::Value *Callee, QualType FnType,
-                      Expr *const *Args, unsigned NumArgs);
+                      CallExpr::const_arg_iterator ArgBeg,
+                      CallExpr::const_arg_iterator ArgEnd);
+  
   RValue EmitBuiltinExpr(unsigned BuiltinID, const CallExpr *E);
 
   llvm::Value *EmitX86BuiltinExpr(unsigned BuiltinID, const CallExpr *E);