Several compilation fixes for MSVC and NVCC, basically:

- added explicit enum to int conversion where needed
- if a function is not defined as declared and the return type is "tricky"
  then the type must be typedefined somewhere. A "tricky return type" can be:
  * a template class with a default parameter which depends on another template parameter
  * a nested template class, or type of a nested template class

17 files changed, 219 insertions, 207 deletions

diff --git a/Eigen/src/Array/CwiseOperators.h b/Eigen/src/Array/CwiseOperators.h
index 185fa7b1a..0dd7bb01c 100644
--- a/Eigen/src/Array/CwiseOperators.h
+++ b/Eigen/src/Array/CwiseOperators.h
@@ -31,7 +31,7 @@
   * 
   * \returns an expression of the coefficient-wise square root of *this. */
 template<typename ExpressionType>
-inline const typename Cwise<ExpressionType>::template UnOp<ei_scalar_sqrt_op>::ReturnType
+inline const EIGEN_CWISE_UNOP_RETURN_TYPE(ei_scalar_sqrt_op)
 Cwise<ExpressionType>::sqrt() const
 {
   return _expression();
@@ -41,7 +41,7 @@ Cwise<ExpressionType>::sqrt() const
   * 
   * \returns an expression of the coefficient-wise exponential of *this. */
 template<typename ExpressionType>
-inline const typename Cwise<ExpressionType>::template UnOp<ei_scalar_exp_op>::ReturnType
+inline const EIGEN_CWISE_UNOP_RETURN_TYPE(ei_scalar_exp_op)
 Cwise<ExpressionType>::exp() const
 {
   return _expression();
@@ -51,7 +51,7 @@ Cwise<ExpressionType>::exp() const
   * 
   * \returns an expression of the coefficient-wise logarithm of *this. */
 template<typename ExpressionType>
-inline const typename Cwise<ExpressionType>::template UnOp<ei_scalar_log_op>::ReturnType
+inline const EIGEN_CWISE_UNOP_RETURN_TYPE(ei_scalar_log_op)
 Cwise<ExpressionType>::log() const
 {
   return _expression();
@@ -61,7 +61,7 @@ Cwise<ExpressionType>::log() const
   * 
   * \returns an expression of the coefficient-wise cosine of *this. */
 template<typename ExpressionType>
-inline const typename Cwise<ExpressionType>::template UnOp<ei_scalar_cos_op>::ReturnType
+inline const EIGEN_CWISE_UNOP_RETURN_TYPE(ei_scalar_cos_op)
 Cwise<ExpressionType>::cos() const
 {
   return _expression();
@@ -72,7 +72,7 @@ Cwise<ExpressionType>::cos() const
   * 
   * \returns an expression of the coefficient-wise sine of *this. */
 template<typename ExpressionType>
-inline const typename Cwise<ExpressionType>::template UnOp<ei_scalar_sin_op>::ReturnType
+inline const EIGEN_CWISE_UNOP_RETURN_TYPE(ei_scalar_sin_op)
 Cwise<ExpressionType>::sin() const
 {
   return _expression();
@@ -83,10 +83,10 @@ Cwise<ExpressionType>::sin() const
   * 
   * \returns an expression of the coefficient-wise power of *this to the given exponent. */
 template<typename ExpressionType>
-inline const typename Cwise<ExpressionType>::template UnOp<ei_scalar_pow_op>::ReturnType
+inline const EIGEN_CWISE_UNOP_RETURN_TYPE(ei_scalar_pow_op)
 Cwise<ExpressionType>::pow(const Scalar& exponent) const
 {
-  return typename UnOp<ei_scalar_pow_op>::ReturnType(_expression(), ei_scalar_pow_op<Scalar>(exponent));
+  return EIGEN_CWISE_UNOP_RETURN_TYPE(ei_scalar_pow_op)(_expression(), ei_scalar_pow_op<Scalar>(exponent));
 }
 
 
@@ -94,7 +94,7 @@ Cwise<ExpressionType>::pow(const Scalar& exponent) const
   * 
   * \returns an expression of the coefficient-wise inverse of *this. */
 template<typename ExpressionType>
-inline const typename Cwise<ExpressionType>::template UnOp<ei_scalar_inverse_op>::ReturnType
+inline const EIGEN_CWISE_UNOP_RETURN_TYPE(ei_scalar_inverse_op)
 Cwise<ExpressionType>::inverse() const
 {
   return _expression();
@@ -104,7 +104,7 @@ Cwise<ExpressionType>::inverse() const
   *
   * \returns an expression of the coefficient-wise square of *this. */
 template<typename ExpressionType>
-inline const typename Cwise<ExpressionType>::template UnOp<ei_scalar_square_op>::ReturnType
+inline const EIGEN_CWISE_UNOP_RETURN_TYPE(ei_scalar_square_op)
 Cwise<ExpressionType>::square() const
 {
   return _expression();
@@ -114,7 +114,7 @@ Cwise<ExpressionType>::square() const
   *
   * \returns an expression of the coefficient-wise cube of *this. */
 template<typename ExpressionType>
-inline const typename Cwise<ExpressionType>::template UnOp<ei_scalar_cube_op>::ReturnType
+inline const EIGEN_CWISE_UNOP_RETURN_TYPE(ei_scalar_cube_op)
 Cwise<ExpressionType>::cube() const
 {
   return _expression();
@@ -133,10 +133,10 @@ Cwise<ExpressionType>::cube() const
   */
 template<typename ExpressionType>
 template<typename OtherDerived>
-inline const typename Cwise<ExpressionType>::template BinOp<std::less, OtherDerived>::ReturnType
+inline const EIGEN_CWISE_BINOP_RETURN_TYPE(std::less)
 Cwise<ExpressionType>::operator<(const MatrixBase<OtherDerived> &other) const
 {
-  return typename BinOp<std::less, OtherDerived>::ReturnType(_expression(), other.derived());
+  return EIGEN_CWISE_BINOP_RETURN_TYPE(std::less)(_expression(), other.derived());
 }
 
 /** \array_module
@@ -147,10 +147,10 @@ Cwise<ExpressionType>::operator<(const MatrixBase<OtherDerived> &other) const
   */
 template<typename ExpressionType>
 template<typename OtherDerived>
-inline const typename Cwise<ExpressionType>::template BinOp<std::less_equal, OtherDerived>::ReturnType
+inline const EIGEN_CWISE_BINOP_RETURN_TYPE(std::less_equal)
 Cwise<ExpressionType>::operator<=(const MatrixBase<OtherDerived> &other) const
 {
-  return typename BinOp<std::less_equal, OtherDerived>::ReturnType(_expression(), other.derived());
+  return EIGEN_CWISE_BINOP_RETURN_TYPE(std::less_equal)(_expression(), other.derived());
 }
 
 /** \array_module
@@ -163,10 +163,10 @@ Cwise<ExpressionType>::operator<=(const MatrixBase<OtherDerived> &other) const
   */
 template<typename ExpressionType>
 template<typename OtherDerived>
-inline const typename Cwise<ExpressionType>::template BinOp<std::greater, OtherDerived>::ReturnType
+inline const EIGEN_CWISE_BINOP_RETURN_TYPE(std::greater)
 Cwise<ExpressionType>::operator>(const MatrixBase<OtherDerived> &other) const
 {
-  return typename BinOp<std::greater, OtherDerived>::ReturnType(_expression(), other.derived());
+  return EIGEN_CWISE_BINOP_RETURN_TYPE(std::greater)(_expression(), other.derived());
 }
 
 /** \array_module
@@ -177,10 +177,10 @@ Cwise<ExpressionType>::operator>(const MatrixBase<OtherDerived> &other) const
   */
 template<typename ExpressionType>
 template<typename OtherDerived>
-inline const typename Cwise<ExpressionType>::template BinOp<std::greater_equal, OtherDerived>::ReturnType
+inline const EIGEN_CWISE_BINOP_RETURN_TYPE(std::greater_equal)
 Cwise<ExpressionType>::operator>=(const MatrixBase<OtherDerived> &other) const
 {
-  return typename BinOp<std::greater_equal, OtherDerived>::ReturnType(_expression(), other.derived());
+  return EIGEN_CWISE_BINOP_RETURN_TYPE(std::greater_equal)(_expression(), other.derived());
 }
 
 /** \array_module
@@ -191,10 +191,10 @@ Cwise<ExpressionType>::operator>=(const MatrixBase<OtherDerived> &other) const
   */
 template<typename ExpressionType>
 template<typename OtherDerived>
-inline const typename Cwise<ExpressionType>::template BinOp<std::equal_to, OtherDerived>::ReturnType
+inline const EIGEN_CWISE_BINOP_RETURN_TYPE(std::equal_to)
 Cwise<ExpressionType>::operator==(const MatrixBase<OtherDerived> &other) const
 {
-  return typename BinOp<std::equal_to, OtherDerived>::ReturnType(_expression(), other.derived());
+  return EIGEN_CWISE_BINOP_RETURN_TYPE(std::equal_to)(_expression(), other.derived());
 }
 
 /** \array_module
@@ -205,10 +205,10 @@ Cwise<ExpressionType>::operator==(const MatrixBase<OtherDerived> &other) const
   */
 template<typename ExpressionType>
 template<typename OtherDerived>
-inline const typename Cwise<ExpressionType>::template BinOp<std::not_equal_to, OtherDerived>::ReturnType
+inline const EIGEN_CWISE_BINOP_RETURN_TYPE(std::not_equal_to)
 Cwise<ExpressionType>::operator!=(const MatrixBase<OtherDerived> &other) const
 {
-  return typename BinOp<std::not_equal_to, OtherDerived>::ReturnType(_expression(), other.derived());
+  return EIGEN_CWISE_BINOP_RETURN_TYPE(std::not_equal_to)(_expression(), other.derived());
 }
 
 
diff --git a/Eigen/src/Array/PartialRedux.h b/Eigen/src/Array/PartialRedux.h
index f7e2f628c..48daad770 100644
--- a/Eigen/src/Array/PartialRedux.h
+++ b/Eigen/src/Array/PartialRedux.h
@@ -61,9 +61,11 @@ struct ei_traits<PartialReduxExpr<MatrixType, MemberOp, Direction> >
     Flags = ((int(RowsAtCompileTime) == Dynamic || int(ColsAtCompileTime) == Dynamic)
           ? (unsigned int)_MatrixTypeNested::Flags
           : (unsigned int)_MatrixTypeNested::Flags & ~LargeBit) & HereditaryBits,
-    TraversalSize = Direction==Vertical ? RowsAtCompileTime : ColsAtCompileTime,
-    CoeffReadCost = TraversalSize * _MatrixTypeNested::CoeffReadCost
-                  + MemberOp::template Cost<InputScalar,TraversalSize>::value
+    TraversalSize = Direction==Vertical ? RowsAtCompileTime : ColsAtCompileTime
+  };
+  typedef typename MemberOp::template Cost<InputScalar,int(TraversalSize)> CostOpType;
+  enum {
+    CoeffReadCost = TraversalSize * _MatrixTypeNested::CoeffReadCost + CostOpType::value
   };
 };
 
diff --git a/Eigen/src/Cholesky/Cholesky.h b/Eigen/src/Cholesky/Cholesky.h
index 02dbed399..2907f5fa7 100644
--- a/Eigen/src/Cholesky/Cholesky.h
+++ b/Eigen/src/Cholesky/Cholesky.h
@@ -147,7 +147,7 @@ typename Derived::Eval Cholesky<MatrixType>::solve(const MatrixBase<Derived> &b)
   * \returns the Cholesky decomposition of \c *this
   */
 template<typename Derived>
-inline const Cholesky<typename ei_eval<Derived>::type>
+inline const Cholesky<typename MatrixBase<Derived>::EvalType>
 MatrixBase<Derived>::cholesky() const
 {
   return Cholesky<typename ei_eval<Derived>::type>(derived());
diff --git a/Eigen/src/Cholesky/CholeskyWithoutSquareRoot.h b/Eigen/src/Cholesky/CholeskyWithoutSquareRoot.h
index ac26c88b1..1eb9904fc 100644
--- a/Eigen/src/Cholesky/CholeskyWithoutSquareRoot.h
+++ b/Eigen/src/Cholesky/CholeskyWithoutSquareRoot.h
@@ -159,7 +159,7 @@ typename Derived::Eval CholeskyWithoutSquareRoot<MatrixType>::solve(const Matrix
   * \returns the Cholesky decomposition without square root of \c *this
   */
 template<typename Derived>
-inline const CholeskyWithoutSquareRoot<typename ei_eval<Derived>::type>
+inline const CholeskyWithoutSquareRoot<typename MatrixBase<Derived>::EvalType>
 MatrixBase<Derived>::choleskyNoSqrt() const
 {
   return derived();
diff --git a/Eigen/src/Core/Assign.h b/Eigen/src/Core/Assign.h
index ba53e299d..fdc6577fb 100644
--- a/Eigen/src/Core/Assign.h
+++ b/Eigen/src/Core/Assign.h
@@ -47,20 +47,20 @@ private:
 
   enum {
     MightVectorize = (int(Derived::Flags) & int(OtherDerived::Flags) & ActualPacketAccessBit)
-             && ((int(Derived::Flags)&RowMajorBit)==(int(OtherDerived::Flags)&RowMajorBit)),
-    MayInnerVectorize = MightVectorize && InnerSize!=Dynamic && int(InnerSize)%int(PacketSize)==0,
+                  && ((int(Derived::Flags)&RowMajorBit)==(int(OtherDerived::Flags)&RowMajorBit)),
+    MayInnerVectorize  = MightVectorize && int(InnerSize)!=Dynamic && int(InnerSize)%int(PacketSize)==0,
     MayLinearVectorize = MightVectorize && (int(Derived::Flags) & int(OtherDerived::Flags) & LinearAccessBit),
-    MaySliceVectorize = MightVectorize && InnerMaxSize==Dynamic /* slice vectorization can be slow, so we only
+    MaySliceVectorize  = MightVectorize && int(InnerMaxSize)==Dynamic /* slice vectorization can be slow, so we only
       want it if the slices are big, which is indicated by InnerMaxSize rather than InnerSize, think of the case
       of a dynamic block in a fixed-size matrix */
   };
 
 public:
   enum {
-    Vectorization = MayInnerVectorize  ? InnerVectorization
-                  : MayLinearVectorize ? LinearVectorization
-                  : MaySliceVectorize ? SliceVectorization
-                                       : NoVectorization
+    Vectorization = int(MayInnerVectorize)  ? int(InnerVectorization)
+                  : int(MayLinearVectorize) ? int(LinearVectorization)
+                  : int(MaySliceVectorize)  ? int(SliceVectorization)
+                                            : int(NoVectorization)
   };
 
 private:
@@ -74,13 +74,13 @@ public:
   enum {
     Unrolling = (int(Vectorization) == int(InnerVectorization) || int(Vectorization) == int(NoVectorization))
               ? (
-                   MayUnrollCompletely ? CompleteUnrolling
-                 : MayUnrollInner      ? InnerUnrolling
-                                       : NoUnrolling
+                   int(MayUnrollCompletely) ? int(CompleteUnrolling)
+                 : int(MayUnrollInner)      ? int(InnerUnrolling)
+                                            : int(NoUnrolling)
                 )
               : int(Vectorization) == int(LinearVectorization)
-              ? ( MayUnrollCompletely ? CompleteUnrolling : NoUnrolling )
-              : NoUnrolling
+              ? ( int(MayUnrollCompletely) ? int(CompleteUnrolling) : int(NoUnrolling) )
+              : int(NoUnrolling)
   };
 };
 
diff --git a/Eigen/src/Core/Block.h b/Eigen/src/Core/Block.h
index 9e15261b3..62617172e 100644
--- a/Eigen/src/Core/Block.h
+++ b/Eigen/src/Core/Block.h
@@ -336,7 +336,6 @@ template<typename MatrixType, int BlockRows, int BlockCols> class Block<MatrixTy
     const ei_int_if_dynamic<ColsAtCompileTime> m_blockCols;
 };
 
-
 /** \returns a dynamic-size expression of a block in *this.
   *
   * \param startRow the first row in the block
@@ -356,18 +355,18 @@ template<typename MatrixType, int BlockRows, int BlockCols> class Block<MatrixTy
   * \sa class Block, block(int,int)
   */
 template<typename Derived>
-inline Block<Derived> MatrixBase<Derived>
+inline typename BlockReturnType<Derived>::Type MatrixBase<Derived>
   ::block(int startRow, int startCol, int blockRows, int blockCols)
 {
-  return Block<Derived>(derived(), startRow, startCol, blockRows, blockCols);
+  return typename BlockReturnType<Derived>::Type(derived(), startRow, startCol, blockRows, blockCols);
 }
 
 /** This is the const version of block(int,int,int,int). */
 template<typename Derived>
-inline const Block<Derived> MatrixBase<Derived>
+inline const typename BlockReturnType<Derived>::Type MatrixBase<Derived>
   ::block(int startRow, int startCol, int blockRows, int blockCols) const
 {
-  return Block<Derived>(derived(), startRow, startCol, blockRows, blockCols);
+  return typename BlockReturnType<Derived>::Type(derived(), startRow, startCol, blockRows, blockCols);
 }
 
 /** \returns a dynamic-size expression of a block in *this.
@@ -389,11 +388,11 @@ inline const Block<Derived> MatrixBase<Derived>
   * \sa class Block, block(int)
   */
 template<typename Derived>
-inline Block<Derived> MatrixBase<Derived>
+inline typename BlockReturnType<Derived>::SubVectorType MatrixBase<Derived>
   ::block(int start, int size)
 {
   EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived);
-  return Block<Derived>(derived(), RowsAtCompileTime == 1 ? 0 : start,
+  return typename BlockReturnType<Derived>::SubVectorType(derived(), RowsAtCompileTime == 1 ? 0 : start,
                                    ColsAtCompileTime == 1 ? 0 : start,
                                    RowsAtCompileTime == 1 ? 1 : size,
                                    ColsAtCompileTime == 1 ? 1 : size);
@@ -401,11 +400,11 @@ inline Block<Derived> MatrixBase<Derived>
 
 /** This is the const version of block(int,int).*/
 template<typename Derived>
-inline const Block<Derived> MatrixBase<Derived>
-  ::block(int start, int size) const
+inline const typename BlockReturnType<Derived>::SubVectorType
+MatrixBase<Derived>::block(int start, int size) const
 {
   EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived);
-  return Block<Derived>(derived(), RowsAtCompileTime == 1 ? 0 : start,
+  return typename BlockReturnType<Derived>::SubVectorType(derived(), RowsAtCompileTime == 1 ? 0 : start,
                                    ColsAtCompileTime == 1 ? 0 : start,
                                    RowsAtCompileTime == 1 ? 1 : size,
                                    ColsAtCompileTime == 1 ? 1 : size);
@@ -429,7 +428,7 @@ inline const Block<Derived> MatrixBase<Derived>
   * \sa class Block, block(int,int)
   */
 template<typename Derived>
-inline typename MatrixBase<Derived>::template SubVectorReturnType<Dynamic>::Type
+inline typename BlockReturnType<Derived,Dynamic>::SubVectorType
 MatrixBase<Derived>::start(int size)
 {
   EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived);
@@ -443,7 +442,7 @@ MatrixBase<Derived>::start(int size)
 
 /** This is the const version of start(int).*/
 template<typename Derived>
-inline const typename MatrixBase<Derived>::template SubVectorReturnType<Dynamic>::Type
+inline const typename BlockReturnType<Derived,Dynamic>::SubVectorType
 MatrixBase<Derived>::start(int size) const
 {
   EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived);
@@ -473,7 +472,7 @@ MatrixBase<Derived>::start(int size) const
   * \sa class Block, block(int,int)
   */
 template<typename Derived>
-inline typename MatrixBase<Derived>::template SubVectorReturnType<Dynamic>::Type
+inline typename BlockReturnType<Derived,Dynamic>::SubVectorType
 MatrixBase<Derived>::end(int size)
 {
   EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived);
@@ -489,7 +488,7 @@ MatrixBase<Derived>::end(int size)
 
 /** This is the const version of end(int).*/
 template<typename Derived>
-inline const typename MatrixBase<Derived>::template SubVectorReturnType<Dynamic>::Type
+inline const typename BlockReturnType<Derived,Dynamic>::SubVectorType
 MatrixBase<Derived>::end(int size) const
 {
   EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived);
@@ -518,7 +517,7 @@ MatrixBase<Derived>::end(int size) const
   */
 template<typename Derived>
 template<int Size>
-inline typename MatrixBase<Derived>::template SubVectorReturnType<Size>::Type
+inline typename BlockReturnType<Derived,Size>::SubVectorType
 MatrixBase<Derived>::start()
 {
   EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived);
@@ -529,7 +528,7 @@ MatrixBase<Derived>::start()
 /** This is the const version of start<int>().*/
 template<typename Derived>
 template<int Size>
-inline const typename MatrixBase<Derived>::template SubVectorReturnType<Size>::Type
+inline const typename BlockReturnType<Derived,Size>::SubVectorType
 MatrixBase<Derived>::start() const
 {
   EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived);
@@ -550,7 +549,7 @@ MatrixBase<Derived>::start() const
   */
 template<typename Derived>
 template<int Size>
-inline typename MatrixBase<Derived>::template SubVectorReturnType<Size>::Type
+inline typename BlockReturnType<Derived,Size>::SubVectorType
 MatrixBase<Derived>::end()
 {
   EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived);
@@ -564,7 +563,7 @@ MatrixBase<Derived>::end()
 /** This is the const version of end<int>.*/
 template<typename Derived>
 template<int Size>
-inline const typename MatrixBase<Derived>::template SubVectorReturnType<Size>::Type
+inline const typename BlockReturnType<Derived,Size>::SubVectorType
 MatrixBase<Derived>::end() const
 {
   EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived);
@@ -594,7 +593,7 @@ MatrixBase<Derived>::end() const
   * \sa class Block, block(int,int,int,int)
   */
 template<typename Derived>
-inline Block<Derived> MatrixBase<Derived>
+inline typename BlockReturnType<Derived>::Type MatrixBase<Derived>
   ::corner(CornerType type, int cRows, int cCols)
 {
   switch(type)
@@ -602,33 +601,33 @@ inline Block<Derived> MatrixBase<Derived>
     default:
       ei_assert(false && "Bad corner type.");
     case TopLeft:
-      return Block<Derived>(derived(), 0, 0, cRows, cCols);
+      return typename BlockReturnType<Derived>::Type(derived(), 0, 0, cRows, cCols);
     case TopRight:
-      return Block<Derived>(derived(), 0, cols() - cCols, cRows, cCols);
+      return typename BlockReturnType<Derived>::Type(derived(), 0, cols() - cCols, cRows, cCols);
     case BottomLeft:
-      return Block<Derived>(derived(), rows() - cRows, 0, cRows, cCols);
+      return typename BlockReturnType<Derived>::Type(derived(), rows() - cRows, 0, cRows, cCols);
     case BottomRight:
-      return Block<Derived>(derived(), rows() - cRows, cols() - cCols, cRows, cCols);
+      return typename BlockReturnType<Derived>::Type(derived(), rows() - cRows, cols() - cCols, cRows, cCols);
   }
 }
 
 /** This is the const version of corner(CornerType, int, int).*/
 template<typename Derived>
-inline const Block<Derived> MatrixBase<Derived>
-  ::corner(CornerType type, int cRows, int cCols) const
+inline const typename BlockReturnType<Derived>::Type
+MatrixBase<Derived>::corner(CornerType type, int cRows, int cCols) const
 {
   switch(type)
   {
     default:
       ei_assert(false && "Bad corner type.");
     case TopLeft:
-      return Block<Derived>(derived(), 0, 0, cRows, cCols);
+      return typename BlockReturnType<Derived>::Type(derived(), 0, 0, cRows, cCols);
     case TopRight:
-      return Block<Derived>(derived(), 0, cols() - cCols, cRows, cCols);
+      return typename BlockReturnType<Derived>::Type(derived(), 0, cols() - cCols, cRows, cCols);
     case BottomLeft:
-      return Block<Derived>(derived(), rows() - cRows, 0, cRows, cCols);
+      return typename BlockReturnType<Derived>::Type(derived(), rows() - cRows, 0, cRows, cCols);
     case BottomRight:
-      return Block<Derived>(derived(), rows() - cRows, cols() - cCols, cRows, cCols);
+      return typename BlockReturnType<Derived>::Type(derived(), rows() - cRows, cols() - cCols, cRows, cCols);
   }
 }
 
@@ -646,8 +645,8 @@ inline const Block<Derived> MatrixBase<Derived>
   */
 template<typename Derived>
 template<int CRows, int CCols>
-inline Block<Derived, CRows, CCols> MatrixBase<Derived>
-  ::corner(CornerType type)
+inline typename BlockReturnType<Derived, CRows, CCols>::Type
+MatrixBase<Derived>::corner(CornerType type)
 {
   switch(type)
   {
@@ -667,8 +666,8 @@ inline Block<Derived, CRows, CCols> MatrixBase<Derived>
 /** This is the const version of corner<int, int>(CornerType).*/
 template<typename Derived>
 template<int CRows, int CCols>
-inline const Block<Derived, CRows, CCols> MatrixBase<Derived>
-  ::corner(CornerType type) const
+inline const typename BlockReturnType<Derived, CRows, CCols>::Type
+MatrixBase<Derived>::corner(CornerType type) const
 {
   switch(type)
   {
@@ -705,8 +704,8 @@ inline const Block<Derived, CRows, CCols> MatrixBase<Derived>
   */
 template<typename Derived>
 template<int BlockRows, int BlockCols>
-inline Block<Derived, BlockRows, BlockCols> MatrixBase<Derived>
-  ::block(int startRow, int startCol)
+inline typename BlockReturnType<Derived, BlockRows, BlockCols>::Type
+MatrixBase<Derived>::block(int startRow, int startCol)
 {
   return Block<Derived, BlockRows, BlockCols>(derived(), startRow, startCol);
 }
@@ -714,8 +713,8 @@ inline Block<Derived, BlockRows, BlockCols> MatrixBase<Derived>
 /** This is the const version of block<>(int, int). */
 template<typename Derived>
 template<int BlockRows, int BlockCols>
-inline const Block<Derived, BlockRows, BlockCols> MatrixBase<Derived>
-  ::block(int startRow, int startCol) const
+inline const typename BlockReturnType<Derived, BlockRows, BlockCols>::Type
+MatrixBase<Derived>::block(int startRow, int startCol) const
 {
   return Block<Derived, BlockRows, BlockCols>(derived(), startRow, startCol);
 }
@@ -729,18 +728,18 @@ inline const Block<Derived, BlockRows, BlockCols> MatrixBase<Derived>
   *
   * \sa row(), class Block */
 template<typename Derived>
-inline Block<Derived, ei_traits<Derived>::RowsAtCompileTime, 1>
+inline typename MatrixBase<Derived>::ColXpr
 MatrixBase<Derived>::col(int i)
 {
-  return Block<Derived, ei_traits<Derived>::RowsAtCompileTime, 1>(derived(), i);
+  return ColXpr(derived(), i);
 }
 
 /** This is the const version of col(). */
 template<typename Derived>
-inline const Block<Derived, ei_traits<Derived>::RowsAtCompileTime, 1>
+inline const typename MatrixBase<Derived>::ColXpr
 MatrixBase<Derived>::col(int i) const
 {
-  return Block<Derived, ei_traits<Derived>::RowsAtCompileTime, 1>(derived(), i);
+  return ColXpr(derived(), i);
 }
 
 /** \returns an expression of the \a i-th row of *this. Note that the numbering starts at 0.
@@ -752,18 +751,18 @@ MatrixBase<Derived>::col(int i) const
   *
   * \sa col(), class Block */
 template<typename Derived>
-inline Block<Derived, 1, ei_traits<Derived>::ColsAtCompileTime>
+inline typename MatrixBase<Derived>::RowXpr
 MatrixBase<Derived>::row(int i)
 {
-  return Block<Derived, 1, ei_traits<Derived>::ColsAtCompileTime>(derived(), i);
+  return RowXpr(derived(), i);
 }
 
 /** This is the const version of row(). */
 template<typename Derived>
-inline const Block<Derived, 1, ei_traits<Derived>::ColsAtCompileTime>
+inline const typename MatrixBase<Derived>::RowXpr
 MatrixBase<Derived>::row(int i) const
 {
-  return Block<Derived, 1, ei_traits<Derived>::ColsAtCompileTime>(derived(), i);
+  return RowXpr(derived(), i);
 }
 
 #endif // EIGEN_BLOCK_H
diff --git a/Eigen/src/Core/Cwise.h b/Eigen/src/Core/Cwise.h
index bd16b0230..adfcfb2e8 100644
--- a/Eigen/src/Core/Cwise.h
+++ b/Eigen/src/Core/Cwise.h
@@ -35,6 +35,16 @@
   */
 template<typename Scalar, bool PacketAccess = (int(ei_packet_traits<Scalar>::size)>1?true:false) > struct ei_scalar_add_op;
 
+/** \internal
+  * convenient macro to defined the return type of a cwise binary operation */
+#define EIGEN_CWISE_BINOP_RETURN_TYPE(OP) \
+    CwiseBinaryOp<OP<typename ei_traits<ExpressionType>::Scalar>, ExpressionType, OtherDerived>
+
+/** \internal
+  * convenient macro to defined the return type of a cwise unary operation */
+#define EIGEN_CWISE_UNOP_RETURN_TYPE(OP) \
+    CwiseUnaryOp<OP<typename ei_traits<ExpressionType>::Scalar>, ExpressionType>
+
 /** \class Cwise
   *
   * \brief Pseudo expression providing additional coefficient-wise operations
@@ -56,56 +66,40 @@ template<typename ExpressionType> class Cwise
     typedef typename ei_traits<ExpressionType>::Scalar Scalar;
     typedef typename ei_meta_if<ei_must_nest_by_value<ExpressionType>::ret,
         ExpressionType, const ExpressionType&>::ret ExpressionTypeNested;
-//     typedef NestByValue<typename ExpressionType::ConstantReturnType> ConstantReturnType;
     typedef CwiseUnaryOp<ei_scalar_add_op<Scalar>, ExpressionType> ScalarAddReturnType;
 
-    template<template<typename _Scalar> class Functor, typename OtherDerived> struct BinOp
-    {
-      typedef CwiseBinaryOp<Functor<typename ei_traits<ExpressionType>::Scalar>,
-                            ExpressionType,
-                            OtherDerived
-                           > ReturnType;
-    };
-
-    template<template<typename _Scalar> class Functor> struct UnOp
-    {
-      typedef CwiseUnaryOp<Functor<typename ei_traits<ExpressionType>::Scalar>,
-                           ExpressionType
-                          > ReturnType;
-    };
-
     inline Cwise(const ExpressionType& matrix) : m_matrix(matrix) {}
 
     /** \internal */
     inline const ExpressionType& _expression() const { return m_matrix; }
 
     template<typename OtherDerived>
-    const typename BinOp<ei_scalar_product_op, OtherDerived>::ReturnType
+	const EIGEN_CWISE_BINOP_RETURN_TYPE(ei_scalar_product_op)
     operator*(const MatrixBase<OtherDerived> &other) const;
 
     template<typename OtherDerived>
-    const typename BinOp<ei_scalar_quotient_op, OtherDerived>::ReturnType
+    const EIGEN_CWISE_BINOP_RETURN_TYPE(ei_scalar_quotient_op)
     operator/(const MatrixBase<OtherDerived> &other) const;
 
     template<typename OtherDerived>
-    const typename BinOp<ei_scalar_min_op, OtherDerived>::ReturnType
+    const EIGEN_CWISE_BINOP_RETURN_TYPE(ei_scalar_min_op)
     min(const MatrixBase<OtherDerived> &other) const;
 
     template<typename OtherDerived>
-    const typename BinOp<ei_scalar_max_op, OtherDerived>::ReturnType
+    const EIGEN_CWISE_BINOP_RETURN_TYPE(ei_scalar_max_op)
     max(const MatrixBase<OtherDerived> &other) const;
 
-    const typename UnOp<ei_scalar_abs_op>::ReturnType abs() const;
-    const typename UnOp<ei_scalar_abs2_op>::ReturnType abs2() const;
-    const typename UnOp<ei_scalar_square_op>::ReturnType square() const;
-    const typename UnOp<ei_scalar_cube_op>::ReturnType cube() const;
-    const typename UnOp<ei_scalar_inverse_op>::ReturnType inverse() const;
-    const typename UnOp<ei_scalar_sqrt_op>::ReturnType sqrt() const;
-    const typename UnOp<ei_scalar_exp_op>::ReturnType exp() const;
-    const typename UnOp<ei_scalar_log_op>::ReturnType log() const;
-    const typename UnOp<ei_scalar_cos_op>::ReturnType cos() const;
-    const typename UnOp<ei_scalar_sin_op>::ReturnType sin() const;
-    const typename UnOp<ei_scalar_pow_op>::ReturnType pow(const Scalar& exponent) const;
+    const EIGEN_CWISE_UNOP_RETURN_TYPE(ei_scalar_abs_op)      abs() const;
+    const EIGEN_CWISE_UNOP_RETURN_TYPE(ei_scalar_abs2_op)     abs2() const;
+    const EIGEN_CWISE_UNOP_RETURN_TYPE(ei_scalar_square_op)   square() const;
+    const EIGEN_CWISE_UNOP_RETURN_TYPE(ei_scalar_cube_op)     cube() const;
+    const EIGEN_CWISE_UNOP_RETURN_TYPE(ei_scalar_inverse_op)  inverse() const;
+    const EIGEN_CWISE_UNOP_RETURN_TYPE(ei_scalar_sqrt_op)     sqrt() const;
+    const EIGEN_CWISE_UNOP_RETURN_TYPE(ei_scalar_exp_op)      exp() const;
+    const EIGEN_CWISE_UNOP_RETURN_TYPE(ei_scalar_log_op)      log() const;
+    const EIGEN_CWISE_UNOP_RETURN_TYPE(ei_scalar_cos_op)      cos() const;
+    const EIGEN_CWISE_UNOP_RETURN_TYPE(ei_scalar_sin_op)      sin() const;
+    const EIGEN_CWISE_UNOP_RETURN_TYPE(ei_scalar_pow_op)      pow(const Scalar& exponent) const;
 
 
     const ScalarAddReturnType
@@ -123,22 +117,22 @@ template<typename ExpressionType> class Cwise
 
     ExpressionType& operator-=(const Scalar& scalar);
 
-    template<typename OtherDerived> const typename BinOp<std::less, OtherDerived>::ReturnType
+    template<typename OtherDerived> const EIGEN_CWISE_BINOP_RETURN_TYPE(std::less)
     operator<(const MatrixBase<OtherDerived>& other) const;
 
-    template<typename OtherDerived> const typename BinOp<std::less_equal, OtherDerived>::ReturnType
+    template<typename OtherDerived> const EIGEN_CWISE_BINOP_RETURN_TYPE(std::less_equal)
     operator<=(const MatrixBase<OtherDerived>& other) const;
 
-    template<typename OtherDerived> const typename BinOp<std::greater, OtherDerived>::ReturnType
+    template<typename OtherDerived> const EIGEN_CWISE_BINOP_RETURN_TYPE(std::greater)
     operator>(const MatrixBase<OtherDerived>& other) const;
 
-    template<typename OtherDerived> const typename BinOp<std::greater_equal, OtherDerived>::ReturnType
+    template<typename OtherDerived> const EIGEN_CWISE_BINOP_RETURN_TYPE(std::greater_equal)
     operator>=(const MatrixBase<OtherDerived>& other) const;
 
-    template<typename OtherDerived> const typename BinOp<std::equal_to, OtherDerived>::ReturnType
+    template<typename OtherDerived> const EIGEN_CWISE_BINOP_RETURN_TYPE(std::equal_to)
     operator==(const MatrixBase<OtherDerived>& other) const;
 
-    template<typename OtherDerived> const typename BinOp<std::not_equal_to, OtherDerived>::ReturnType
+    template<typename OtherDerived> const EIGEN_CWISE_BINOP_RETURN_TYPE(std::not_equal_to)
     operator!=(const MatrixBase<OtherDerived>& other) const;
 
 
diff --git a/Eigen/src/Core/CwiseBinaryOp.h b/Eigen/src/Core/CwiseBinaryOp.h
index ac5440c22..51c1f9e43 100644
--- a/Eigen/src/Core/CwiseBinaryOp.h
+++ b/Eigen/src/Core/CwiseBinaryOp.h
@@ -186,10 +186,10 @@ MatrixBase<Derived>::operator+=(const MatrixBase<OtherDerived>& other)
   */
 template<typename ExpressionType>
 template<typename OtherDerived>
-inline const typename Cwise<ExpressionType>::template BinOp<ei_scalar_product_op, OtherDerived>::ReturnType
+inline const EIGEN_CWISE_BINOP_RETURN_TYPE(ei_scalar_product_op)
 Cwise<ExpressionType>::operator*(const MatrixBase<OtherDerived> &other) const
 {
-  return typename BinOp<ei_scalar_product_op, OtherDerived>::ReturnType(_expression(), other.derived());
+  return EIGEN_CWISE_BINOP_RETURN_TYPE(ei_scalar_product_op)(_expression(), other.derived());
 }
 
 /** \returns an expression of the coefficient-wise quotient of *this and \a other
@@ -198,10 +198,10 @@ Cwise<ExpressionType>::operator*(const MatrixBase<OtherDerived> &other) const
   */
 template<typename ExpressionType>
 template<typename OtherDerived>
-inline const typename Cwise<ExpressionType>::template BinOp<ei_scalar_quotient_op, OtherDerived>::ReturnType
+inline const EIGEN_CWISE_BINOP_RETURN_TYPE(ei_scalar_quotient_op)
 Cwise<ExpressionType>::operator/(const MatrixBase<OtherDerived> &other) const
 {
-  return typename BinOp<ei_scalar_quotient_op, OtherDerived>::ReturnType(_expression(), other.derived());
+  return EIGEN_CWISE_BINOP_RETURN_TYPE(ei_scalar_quotient_op)(_expression(), other.derived());
 }
 
 /** \returns an expression of the coefficient-wise min of *this and \a other
@@ -210,10 +210,10 @@ Cwise<ExpressionType>::operator/(const MatrixBase<OtherDerived> &other) const
   */
 template<typename ExpressionType>
 template<typename OtherDerived>
-inline const typename Cwise<ExpressionType>::template BinOp<ei_scalar_min_op, OtherDerived>::ReturnType
+inline const EIGEN_CWISE_BINOP_RETURN_TYPE(ei_scalar_min_op)
 Cwise<ExpressionType>::min(const MatrixBase<OtherDerived> &other) const
 {
-  return typename BinOp<ei_scalar_min_op, OtherDerived>::ReturnType(_expression(), other.derived());
+  return EIGEN_CWISE_BINOP_RETURN_TYPE(ei_scalar_min_op)(_expression(), other.derived());
 }
 
 /** \returns an expression of the coefficient-wise max of *this and \a other
@@ -222,10 +222,10 @@ Cwise<ExpressionType>::min(const MatrixBase<OtherDerived> &other) const
   */
 template<typename ExpressionType>
 template<typename OtherDerived>
-inline const typename Cwise<ExpressionType>::template BinOp<ei_scalar_max_op, OtherDerived>::ReturnType
+inline const EIGEN_CWISE_BINOP_RETURN_TYPE(ei_scalar_max_op)
 Cwise<ExpressionType>::max(const MatrixBase<OtherDerived> &other) const
 {
-  return typename BinOp<ei_scalar_max_op, OtherDerived>::ReturnType(_expression(), other.derived());
+  return EIGEN_CWISE_BINOP_RETURN_TYPE(ei_scalar_max_op)(_expression(), other.derived());
 }
 
 /** \returns an expression of a custom coefficient-wise operator \a func of *this and \a other
diff --git a/Eigen/src/Core/CwiseUnaryOp.h b/Eigen/src/Core/CwiseUnaryOp.h
index b5a9e4d91..bb354958e 100644
--- a/Eigen/src/Core/CwiseUnaryOp.h
+++ b/Eigen/src/Core/CwiseUnaryOp.h
@@ -137,7 +137,7 @@ MatrixBase<Derived>::operator-() const
 /** \returns an expression of the coefficient-wise absolute value of \c *this
   */
 template<typename ExpressionType>
-inline const typename Cwise<ExpressionType>::template UnOp<ei_scalar_abs_op>::ReturnType
+inline const EIGEN_CWISE_UNOP_RETURN_TYPE(ei_scalar_abs_op)
 Cwise<ExpressionType>::abs() const
 {
   return _expression();
@@ -146,7 +146,7 @@ Cwise<ExpressionType>::abs() const
 /** \returns an expression of the coefficient-wise squared absolute value of \c *this
   */
 template<typename ExpressionType>
-inline const typename Cwise<ExpressionType>::template UnOp<ei_scalar_abs2_op>::ReturnType
+inline const EIGEN_CWISE_UNOP_RETURN_TYPE(ei_scalar_abs2_op)
 Cwise<ExpressionType>::abs2() const
 {
   return _expression();
diff --git a/Eigen/src/Core/MatrixBase.h b/Eigen/src/Core/MatrixBase.h
index 1e9d0d958..f15e560cb 100644
--- a/Eigen/src/Core/MatrixBase.h
+++ b/Eigen/src/Core/MatrixBase.h
@@ -175,34 +175,33 @@ template<typename Derived> class MatrixBase
       * i.e., the number of rows for a columns major matrix, and the number of cols otherwise */
     int innerSize() const { return (int(Flags)&RowMajorBit) ? this->cols() : this->rows(); }
 
-    /** Represents a constant matrix */
+    /** \internal the type to which the expression gets evaluated (needed by MSVC) */
+	typedef typename ei_eval<Derived>::type EvalType;
+    /** \internal Represents a constant matrix */
     typedef CwiseNullaryOp<ei_scalar_constant_op<Scalar>,Derived> ConstantReturnType;
-    /** Represents a vector block of a matrix  */
-    template<int Size> struct SubVectorReturnType
-    {
-      typedef Block<Derived, (ei_traits<Derived>::RowsAtCompileTime == 1 ? 1 : Size),
-                             (ei_traits<Derived>::ColsAtCompileTime == 1 ? 1 : Size)> Type;
-    };
-    /** Represents a scalar multiple of a matrix */
+    /** \internal Represents a scalar multiple of a matrix */
     typedef CwiseUnaryOp<ei_scalar_multiple_op<Scalar>, Derived> ScalarMultipleReturnType;
-    /** Represents a quotient of a matrix by a scalar*/
+    /** \internal Represents a quotient of a matrix by a scalar*/
     typedef CwiseUnaryOp<ei_scalar_quotient1_op<Scalar>, Derived> ScalarQuotient1ReturnType;
-
-    /** the return type of MatrixBase::conjugate() */
+    /** \internal the return type of MatrixBase::conjugate() */
     typedef typename ei_meta_if<NumTraits<Scalar>::IsComplex,
                         CwiseUnaryOp<ei_scalar_conjugate_op<Scalar>, Derived>,
                         Derived&
                      >::ret ConjugateReturnType;
-    /** the return type of MatrixBase::real() */
+    /** \internal the return type of MatrixBase::real() */
     typedef CwiseUnaryOp<ei_scalar_real_op<Scalar>, Derived> RealReturnType;
-    /** the return type of MatrixBase::adjoint() */
+    /** \internal the return type of MatrixBase::adjoint() */
     typedef Transpose<NestByValue<typename ei_unref<ConjugateReturnType>::type> >
             AdjointReturnType;
-    /** the return type of MatrixBase::eigenvalues() */
+    /** \internal the return type of MatrixBase::eigenvalues() */
     typedef Matrix<typename NumTraits<typename ei_traits<Derived>::Scalar>::Real, ei_traits<Derived>::ColsAtCompileTime, 1> EigenvaluesReturnType;
-    /** the return type of identity */
+	/** \internal expression tyepe of a column */
+	typedef Block<Derived, ei_traits<Derived>::RowsAtCompileTime, 1> ColXpr;
+	/** \internal expression tyepe of a column */
+	typedef Block<Derived, 1, ei_traits<Derived>::ColsAtCompileTime> RowXpr;
+    /** \internal the return type of identity */
     typedef CwiseNullaryOp<ei_scalar_identity_op<Scalar>,Derived> IdentityReturnType;
-    /** the return type of unit vectors */
+    /** \internal the return type of unit vectors */
     typedef Block<CwiseNullaryOp<ei_scalar_identity_op<Scalar>, SquareMatrixType>,
                   ei_traits<Derived>::RowsAtCompileTime,
                   ei_traits<Derived>::ColsAtCompileTime> BasisReturnType;
@@ -330,48 +329,46 @@ template<typename Derived> class MatrixBase
     const AdjointReturnType adjoint() const;
 
 
-    Block<Derived, 1, ei_traits<Derived>::ColsAtCompileTime> row(int i);
-    const Block<Derived, 1, ei_traits<Derived>::ColsAtCompileTime> row(int i) const;
+    RowXpr row(int i);
+    const RowXpr row(int i) const;
 
-    Block<Derived, ei_traits<Derived>::RowsAtCompileTime, 1> col(int i);
-    const Block<Derived, ei_traits<Derived>::RowsAtCompileTime, 1> col(int i) const;
+    ColXpr col(int i);
+    const ColXpr col(int i) const;
 
     Minor<Derived> minor(int row, int col);
     const Minor<Derived> minor(int row, int col) const;
 
-    Block<Derived> block(int startRow, int startCol, int blockRows, int blockCols);
-    const Block<Derived>
+    typename BlockReturnType<Derived>::Type block(int startRow, int startCol, int blockRows, int blockCols);
+    const typename BlockReturnType<Derived>::Type
     block(int startRow, int startCol, int blockRows, int blockCols) const;
 
-    Block<Derived> block(int start, int size);
-    const Block<Derived> block(int start, int size) const;
+    typename BlockReturnType<Derived>::SubVectorType block(int start, int size);
+    const typename BlockReturnType<Derived>::SubVectorType block(int start, int size) const;
 
-    typename SubVectorReturnType<Dynamic>::Type start(int size);
-    const typename SubVectorReturnType<Dynamic>::Type start(int size) const;
+    typename BlockReturnType<Derived,Dynamic>::SubVectorType start(int size);
+    const typename BlockReturnType<Derived,Dynamic>::SubVectorType start(int size) const;
 
-    typename SubVectorReturnType<Dynamic>::Type end(int size);
-    const typename SubVectorReturnType<Dynamic>::Type end(int size) const;
+    typename BlockReturnType<Derived,Dynamic>::SubVectorType end(int size);
+    const typename BlockReturnType<Derived,Dynamic>::SubVectorType end(int size) const;
 
-    Block<Derived> corner(CornerType type, int cRows, int cCols);
-    const Block<Derived> corner(CornerType type, int cRows, int cCols) const;
+    typename BlockReturnType<Derived>::Type corner(CornerType type, int cRows, int cCols);
+    const typename BlockReturnType<Derived>::Type corner(CornerType type, int cRows, int cCols) const;
 
     template<int BlockRows, int BlockCols>
-    Block<Derived, BlockRows, BlockCols> block(int startRow, int startCol);
+    typename BlockReturnType<Derived, BlockRows, BlockCols>::Type block(int startRow, int startCol);
     template<int BlockRows, int BlockCols>
-    const Block<Derived, BlockRows, BlockCols> block(int startRow, int startCol) const;
+    const typename BlockReturnType<Derived, BlockRows, BlockCols>::Type block(int startRow, int startCol) const;
 
-    template<int CRows, int CCols> Block<Derived, CRows, CCols> corner(CornerType type);
-    template<int CRows, int CCols> const Block<Derived, CRows, CCols> corner(CornerType type) const;
+    template<int CRows, int CCols>
+    typename BlockReturnType<Derived, CRows, CCols>::Type corner(CornerType type);
+    template<int CRows, int CCols>
+    const typename BlockReturnType<Derived, CRows, CCols>::Type corner(CornerType type) const;
 
-    template<int Size>
-    typename SubVectorReturnType<Size>::Type start(void);
-    template<int Size>
-    const typename SubVectorReturnType<Size>::Type start() const;
+    template<int Size> typename BlockReturnType<Derived,Size>::SubVectorType start(void);
+    template<int Size> const typename BlockReturnType<Derived,Size>::SubVectorType start() const;
 
-    template<int Size>
-    typename SubVectorReturnType<Size>::Type end();
-    template<int Size>
-    const typename SubVectorReturnType<Size>::Type end() const;
+    template<int Size> typename BlockReturnType<Derived,Size>::SubVectorType end();
+    template<int Size> const typename BlockReturnType<Derived,Size>::SubVectorType end() const;
 
     DiagonalCoeffs<Derived> diagonal();
     const DiagonalCoeffs<Derived> diagonal() const;
@@ -529,18 +526,18 @@ template<typename Derived> class MatrixBase
 
 /////////// LU module ///////////
 
-    const typename ei_eval<Derived>::type inverse() const;
-    void computeInverse(typename ei_eval<Derived>::type *result) const;
+    const EvalType inverse() const;
+    void computeInverse(EvalType *result) const;
     Scalar determinant() const;
 
 /////////// Cholesky module ///////////
 
-    const Cholesky<typename ei_eval<Derived>::type> cholesky() const;
-    const CholeskyWithoutSquareRoot<typename ei_eval<Derived>::type> choleskyNoSqrt() const;
+    const Cholesky<EvalType> cholesky() const;
+    const CholeskyWithoutSquareRoot<EvalType> choleskyNoSqrt() const;
 
 /////////// QR module ///////////
 
-    const QR<typename ei_eval<Derived>::type> qr() const;
+    const QR<EvalType> qr() const;
 
     EigenvaluesReturnType eigenvalues() const;
     RealScalar matrixNorm() const;
@@ -548,9 +545,14 @@ template<typename Derived> class MatrixBase
 /////////// Geometry module ///////////
 
     template<typename OtherDerived>
-    typename ei_eval<Derived>::type
-    cross(const MatrixBase<OtherDerived>& other) const;
-    typename ei_eval<Derived>::type someOrthogonal(void) const;
+    EvalType cross(const MatrixBase<OtherDerived>& other) const;
+    EvalType someOrthogonal(void) const;
+    
+    /**
+     */
+    #ifdef EIGEN_MATRIXBASE_PLUGIN
+    #include EIGEN_MATRIXBASE_PLUGIN
+    #endif
 };
 
 #endif // EIGEN_MATRIXBASE_H
diff --git a/Eigen/src/Core/util/Meta.h b/Eigen/src/Core/util/Meta.h
index e7bfc195d..2fb401c6c 100644
--- a/Eigen/src/Core/util/Meta.h
+++ b/Eigen/src/Core/util/Meta.h
@@ -240,4 +240,13 @@ template<unsigned int Flags> struct ei_are_flags_consistent
   };
 };
 
+/** \internal Gives the type of a sub-matrix or sub-vector of a matrix of type \a ExpressionType and size \a Size
+  * TODO: could be a good idea to define a big ReturnType struct ??
+  */
+template<typename ExpressionType, int RowsOrSize=Dynamic, int Cols=Dynamic> struct BlockReturnType {
+	typedef Block<ExpressionType, (ei_traits<ExpressionType>::RowsAtCompileTime == 1 ? 1 : RowsOrSize),
+                                  (ei_traits<ExpressionType>::ColsAtCompileTime == 1 ? 1 : RowsOrSize)> SubVectorType;
+	typedef Block<ExpressionType, RowsOrSize, Cols> Type;
+};
+
 #endif // EIGEN_META_H
diff --git a/Eigen/src/Geometry/OrthoMethods.h b/Eigen/src/Geometry/OrthoMethods.h
index ea71c12d2..b6206f7b2 100644
--- a/Eigen/src/Geometry/OrthoMethods.h
+++ b/Eigen/src/Geometry/OrthoMethods.h
@@ -30,7 +30,7 @@
   * \returns the cross product of \c *this and \a other */
 template<typename Derived>
 template<typename OtherDerived>
-inline typename ei_eval<Derived>::type
+inline typename MatrixBase<Derived>::EvalType
 MatrixBase<Derived>::cross(const MatrixBase<OtherDerived>& other) const
 {
   EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(Derived,3);
@@ -100,7 +100,7 @@ struct ei_perpendicular_selector<Derived,2>
   * \sa cross()
   */
 template<typename Derived>
-typename ei_eval<Derived>::type
+typename MatrixBase<Derived>::EvalType
 MatrixBase<Derived>::someOrthogonal() const
 {
   EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived);
diff --git a/Eigen/src/Geometry/Quaternion.h b/Eigen/src/Geometry/Quaternion.h
index 55d85ef57..e17e9ff4a 100644
--- a/Eigen/src/Geometry/Quaternion.h
+++ b/Eigen/src/Geometry/Quaternion.h
@@ -356,10 +356,10 @@ Quaternion<Scalar> Quaternion<Scalar>::slerp(Scalar t, const Quaternion& other)
   // 2 - Quaternion slerp(Scalar t, const Quaternion& other) const
   //     which returns the s-lerp between this and other
   // ??
-  if (*this == other)
+  if (m_coeffs == other.m_coeffs)
     return *this;
 
-  Scalar d = this->dot(other);
+  Scalar d = m_coeffs.dot(other.m_coeffs);
 
   // theta is the angle between the 2 quaternions
   Scalar theta = std::acos(ei_abs(d));
@@ -370,7 +370,7 @@ Quaternion<Scalar> Quaternion<Scalar>::slerp(Scalar t, const Quaternion& other)
   if (d<0)
     scale1 = -scale1;
 
-  return scale0 * (*this) + scale1 * other;
+  return Quaternion(scale0 * m_coeffs + scale1 * other.m_coeffs);
 }
 
 // set from a rotation matrix
diff --git a/Eigen/src/Geometry/Transform.h b/Eigen/src/Geometry/Transform.h
index 3da958aa7..846ec2c8d 100644
--- a/Eigen/src/Geometry/Transform.h
+++ b/Eigen/src/Geometry/Transform.h
@@ -120,9 +120,18 @@ public:
   /** \returns a writable expression of the translation vector of the transformation */
   inline TranslationPart translation() { return m_matrix.template block<Dim,1>(0,Dim); }
 
+  /** \returns an expression of the product between the transform \c *this and a matrix expression \a other
+  *
+  * The right hand side \a other might be either:
+  * \li a vector of size Dim,
+  * \li an homogeneous vector of size Dim+1,
+  * \li a transformation matrix of size Dim+1 x Dim+1.
+  */
+  // note: this function is defined here because some compilers cannot find the respective declaration
   template<typename OtherDerived>
   const typename ei_transform_product_impl<OtherDerived,_Dim,_Dim+1>::ResultType
-  operator * (const MatrixBase<OtherDerived> &other) const;
+  operator * (const MatrixBase<OtherDerived> &other) const
+  { return ei_transform_product_impl<OtherDerived,Dim,HDim>::run(*this,other.derived()); }
 
   /** Contatenates two transformations */
   const typename ProductReturnType<MatrixType,MatrixType>::Type
@@ -216,21 +225,6 @@ QMatrix Transform<Scalar,Dim>::toQMatrix(void) const
 }
 #endif
 
-/** \returns an expression of the product between the transform \c *this and a matrix expression \a other
-  *
-  * The right hand side \a other might be either:
-  * \li a vector of size Dim,
-  * \li an homogeneous vector of size Dim+1,
-  * \li a transformation matrix of size Dim+1 x Dim+1.
-  */
-template<typename Scalar, int Dim>
-template<typename OtherDerived>
-const typename ei_transform_product_impl<OtherDerived,Dim,Dim+1>::ResultType
-Transform<Scalar,Dim>::operator*(const MatrixBase<OtherDerived> &other) const
-{
-  return ei_transform_product_impl<OtherDerived,Dim,HDim>::run(*this,other.derived());
-}
-
 /** Applies on the right the non uniform scale transformation represented
   * by the vector \a other to \c *this and returns a reference to \c *this.
   * \sa prescale()
diff --git a/Eigen/src/LU/Inverse.h b/Eigen/src/LU/Inverse.h
index cfe90161a..68cac5985 100644
--- a/Eigen/src/LU/Inverse.h
+++ b/Eigen/src/LU/Inverse.h
@@ -301,7 +301,7 @@ struct ei_compute_inverse<MatrixType, 4>
   * \sa inverse()
   */
 template<typename Derived>
-inline void MatrixBase<Derived>::computeInverse(typename ei_eval<Derived>::type *result) const
+inline void MatrixBase<Derived>::computeInverse(typename MatrixBase<Derived>::EvalType *result) const
 {
   typedef typename ei_eval<Derived>::type MatrixType;
   ei_assert(rows() == cols());
@@ -324,10 +324,9 @@ inline void MatrixBase<Derived>::computeInverse(typename ei_eval<Derived>::type
   * \sa computeInverse()
   */
 template<typename Derived>
-inline const typename ei_eval<Derived>::type MatrixBase<Derived>::inverse() const
+inline const typename MatrixBase<Derived>::EvalType MatrixBase<Derived>::inverse() const
 {
-  typedef typename ei_eval<Derived>::type MatrixType;
-  MatrixType result(rows(), cols());
+  EvalType result(rows(), cols());
   computeInverse(&result);
   return result;
 }
diff --git a/Eigen/src/QR/QR.h b/Eigen/src/QR/QR.h
index 6e2f9c546..8ca787c2a 100644
--- a/Eigen/src/QR/QR.h
+++ b/Eigen/src/QR/QR.h
@@ -168,7 +168,7 @@ MatrixType QR<MatrixType>::matrixQ(void) const
   * \sa class QR
   */
 template<typename Derived>
-const QR<typename ei_eval<Derived>::type>
+const QR<typename MatrixBase<Derived>::EvalType>
 MatrixBase<Derived>::qr() const
 {
   return QR<typename ei_eval<Derived>::type>(derived());
diff --git a/Eigen/src/QR/SelfAdjointEigenSolver.h b/Eigen/src/QR/SelfAdjointEigenSolver.h
index 28eb59cbb..2d833bf13 100644
--- a/Eigen/src/QR/SelfAdjointEigenSolver.h
+++ b/Eigen/src/QR/SelfAdjointEigenSolver.h
@@ -41,6 +41,7 @@ template<typename _MatrixType> class SelfAdjointEigenSolver
 {
   public:
 
+    enum {Size = _MatrixType::RowsAtCompileTime };
     typedef _MatrixType MatrixType;
     typedef typename MatrixType::Scalar Scalar;
     typedef typename NumTraits<Scalar>::Real RealScalar;
@@ -49,6 +50,18 @@ template<typename _MatrixType> class SelfAdjointEigenSolver
     typedef Matrix<RealScalar, Dynamic, 1> RealVectorTypeX;
     typedef Tridiagonalization<MatrixType> TridiagonalizationType;
 
+    SelfAdjointEigenSolver()
+        : m_eivec(Size, Size),
+          m_eivalues(Size)
+    {
+      ei_assert(Size!=Dynamic);
+    }
+
+    SelfAdjointEigenSolver(int size)
+        : m_eivec(size, size),
+          m_eivalues(size)
+    {}
+
     /** Constructors computing the eigenvalues of the selfadjoint matrix \a matrix,
       * as well as the eigenvectors if \a computeEigenvectors is true.
       *