diff --git a/Eigen/src/Core/Product.h b/Eigen/src/Core/Product.h
index 3c5c56f..cc75165 100644
--- a/Eigen/src/Core/Product.h
+++ b/Eigen/src/Core/Product.h
@@ -135,7 +135,7 @@
 {
   typedef typename ei_nested<Lhs,Rhs::ColsAtCompileTime>::type LhsNested;
   typedef typename ei_nested<Rhs,Lhs::RowsAtCompileTime>::type RhsNested;
-  typedef GeneralProduct<Lhs, Rhs, UnrolledProduct> Type;
+  typedef GeneralProduct<LhsNested, RhsNested, UnrolledProduct> Type;
 };
 
 
@@ -212,11 +212,6 @@
       ei_outer_product_selector<(int(Dest::Flags)&RowMajorBit) ? RowMajor : ColMajor>::run(*this, dest, alpha);
     }
 
-    Scalar coeff(int row, int col) const
-    {
-      return this->lhs().coeff(row) * this->rhs().coeff(col);
-    }
-
   private:
     GeneralProduct& operator=(const GeneralProduct&);
 };
diff --git a/test/product_extra.cpp b/test/product_extra.cpp
index a67e755..8e55c60 100644
--- a/test/product_extra.cpp
+++ b/test/product_extra.cpp
@@ -114,11 +114,6 @@
 
   VERIFY_IS_APPROX(m1.col(j2).adjoint() * m1.block(0,j,m1.rows(),c), m1.col(j2).adjoint().eval() * m1.block(0,j,m1.rows(),c).eval());
   VERIFY_IS_APPROX(m1.block(i,0,r,m1.cols()) * m1.row(i2).adjoint(), m1.block(i,0,r,m1.cols()).eval() * m1.row(i2).adjoint().eval());
-
-  // test (outer_product) * vector with and without temporary
-  ColVectorType vc3 = ColVectorType::Random(cols), vc4 = ColVectorType::Random(cols);
-  vcres = (vc2 * vc3.transpose()) * vc4; // without temporary
-  VERIFY_IS_APPROX(vcres, (vc2 * vc3.transpose()).eval() * vc4);
 }
 
 void test_product_extra()
diff --git a/test/product_small.cpp b/test/product_small.cpp
index 3aed5cf..182af71 100644
--- a/test/product_small.cpp
+++ b/test/product_small.cpp
@@ -34,4 +34,10 @@
     CALL_SUBTEST( product(Matrix4d()) );
     CALL_SUBTEST( product(Matrix4f()) );
   }
+
+  {
+    // test compilation of (outer_product) * vector
+    Vector3f v = Vector3f::Random();
+    VERIFY_IS_APPROX( (v * v.transpose()) * v, (v * v.transpose()).eval() * v);
+  }
 }
