That's it NestByValue and .nestByValue() are both gone!

Eigen/Core

@@ -162,7 +162,6 @@ namespace Eigen {
 
 #include "src/Core/util/BlasUtil.h"
 #include "src/Core/MatrixStorage.h"
-#include "src/Core/NestByValue.h"
 #include "src/Core/ReturnByValue.h"
 #include "src/Core/Flagged.h"
 #include "src/Core/NoAlias.h"

Eigen/src/Core/MatrixBase.h

@@ -620,9 +620,6 @@ template<typename Derived> class MatrixBase
       */
     inline int stride(void) const { return derived().stride(); }
 
-    inline const NestByValue<Derived> nestByValue() const;
-
-
     ConjugateReturnType conjugate() const;
     RealReturnType real() const;
     NonConstRealReturnType real();

Eigen/src/Core/NestByValue.h

@@ -1,119 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2008 Gael Guennebaud <g.gael@free.fr>
-// Copyright (C) 2006-2008 Benoit Jacob <jacob.benoit.1@gmail.com>
-//
-// Eigen is free software; you can redistribute it and/or
-// modify it under the terms of the GNU Lesser General Public
-// License as published by the Free Software Foundation; either
-// version 3 of the License, or (at your option) any later version.
-//
-// Alternatively, you can redistribute it and/or
-// modify it under the terms of the GNU General Public License as
-// published by the Free Software Foundation; either version 2 of
-// the License, or (at your option) any later version.
-//
-// Eigen is distributed in the hope that it will be useful, but WITHOUT ANY
-// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
-// FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License or the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public
-// License and a copy of the GNU General Public License along with
-// Eigen. If not, see <http://www.gnu.org/licenses/>.
-
-#ifndef EIGEN_NESTBYVALUE_H
-#define EIGEN_NESTBYVALUE_H
-
-/** \class NestByValue
-  *
-  * \brief Expression which must be nested by value
-  *
-  * \param ExpressionType the type of the object of which we are requiring nesting-by-value
-  *
-  * This class is the return type of MatrixBase::nestByValue()
-  * and most of the time this is the only way it is used.
-  *
-  * \sa MatrixBase::nestByValue()
-  */
-template<typename ExpressionType>
-struct ei_traits<NestByValue<ExpressionType> > : public ei_traits<ExpressionType>
-{};
-
-template<typename ExpressionType> class NestByValue
-  : public MatrixBase<NestByValue<ExpressionType> >
-{
-  public:
-
-    EIGEN_GENERIC_PUBLIC_INTERFACE(NestByValue)
-
-    inline NestByValue(const ExpressionType& matrix) : m_expression(matrix) {}
-
-    inline int rows() const { return m_expression.rows(); }
-    inline int cols() const { return m_expression.cols(); }
-    inline int stride() const { return m_expression.stride(); }
-
-    inline const CoeffReturnType coeff(int row, int col) const
-    {
-      return m_expression.coeff(row, col);
-    }
-
-    inline Scalar& coeffRef(int row, int col)
-    {
-      return m_expression.const_cast_derived().coeffRef(row, col);
-    }
-
-    inline const CoeffReturnType coeff(int index) const
-    {
-      return m_expression.coeff(index);
-    }
-
-    inline Scalar& coeffRef(int index)
-    {
-      return m_expression.const_cast_derived().coeffRef(index);
-    }
-
-    template<int LoadMode>
-    inline const PacketScalar packet(int row, int col) const
-    {
-      return m_expression.template packet<LoadMode>(row, col);
-    }
-
-    template<int LoadMode>
-    inline void writePacket(int row, int col, const PacketScalar& x)
-    {
-      m_expression.const_cast_derived().template writePacket<LoadMode>(row, col, x);
-    }
-
-    template<int LoadMode>
-    inline const PacketScalar packet(int index) const
-    {
-      return m_expression.template packet<LoadMode>(index);
-    }
-
-    template<int LoadMode>
-    inline void writePacket(int index, const PacketScalar& x)
-    {
-      m_expression.const_cast_derived().template writePacket<LoadMode>(index, x);
-    }
-    
-    operator const ExpressionType&() const { return m_expression; }
-
-  protected:
-    const ExpressionType m_expression;
-
-  private:
-    NestByValue& operator=(const NestByValue&);
-};
-
-/** \returns an expression of the temporary version of *this.
-  */
-template<typename Derived>
-inline const NestByValue<Derived>
-MatrixBase<Derived>::nestByValue() const
-{
-  return NestByValue<Derived>(derived());
-}
-
-#endif // EIGEN_NESTBYVALUE_H

Eigen/src/Core/util/ForwardDeclarations.h

@@ -36,7 +36,6 @@ template<typename _Scalar, int _Rows, int _Cols,
 
 template<typename ExpressionType, unsigned int Added, unsigned int Removed> class Flagged;
 template<typename ExpressionType> class NoAlias;
-template<typename ExpressionType> class NestByValue;
 template<typename ExpressionType> class SwapWrapper;
 template<typename MatrixType> class Minor;
 template<typename MatrixType, int BlockRows=Dynamic, int BlockCols=Dynamic, int PacketAccess=AsRequested,

Eigen/src/Core/util/XprHelper.h

@@ -168,21 +168,8 @@ template<typename T> struct ei_plain_matrix_type_row_major
           > type;
 };
 
+// we should be able to get rid of this one too
 template<typename T> struct ei_must_nest_by_value { enum { ret = false }; };
-template<typename T> struct ei_must_nest_by_value<NestByValue<T> > { enum { ret = true }; };
-
-/**
-* Just a sanity check in order to verify that NestByValue is never
-* used in combination with Matrix. Currently, I don't see a use case
-* for nesting matrices by value. When an expression requires a temporary
-* this should be handled through PlainMatrixType (i.e. arithmetic cost 
-* check + eval before nesting check).
-* Note: If this were happening there were no harm but - if we are sure
-*       this does not happen, we can actually get rid of NestByValue!
-**/
-template <typename T> struct ei_is_nested_matrix { typedef int ok; };
-template<typename _Scalar, int _Rows, int _Cols, int _Options, int _MaxRows, int _MaxCols>
-struct ei_is_nested_matrix< NestByValue< Matrix<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols> > > {};
 
 /**
 * The reference selector for template expressions. The idea is that we don't
@@ -236,21 +223,11 @@ template<typename T, int n=1, typename PlainMatrixType = typename ei_eval<T>::ty
     CostNoEval = (n-1) * int(ei_traits<T>::CoeffReadCost)
   };
 
-  typedef typename ei_is_nested_matrix<T>::ok is_ok;
-
   typedef typename ei_meta_if<
-    ei_must_nest_by_value<T>::ret,
-      T,
-      typename ei_meta_if<
     ( int(ei_traits<T>::Flags) & EvalBeforeNestingBit ) || 
     ( int(CostEval) <= int(CostNoEval) ),
       PlainMatrixType,
-#ifdef EIGEN_OLD_NESTED
-        const T&
-#else
       typename ei_ref_selector<T>::type
-#endif
-      >::ret
   >::ret type;
 };
 
@@ -303,7 +280,7 @@ template<typename ExpressionType> struct HNormalizedReturnType {
                 ei_traits<ExpressionType>::ColsAtCompileTime==1 ? SizeMinusOne : 1,
                 ei_traits<ExpressionType>::ColsAtCompileTime==1 ? 1 : SizeMinusOne> StartMinusOne;
   typedef CwiseUnaryOp<ei_scalar_quotient1_op<typename ei_traits<ExpressionType>::Scalar>,
-              NestByValue<StartMinusOne> > Type;
+              StartMinusOne > Type;
 };
 
 template<typename XprType, typename CastType> struct ei_cast_return_type