LUFactorized Implemented?

Start with the LUFactorized::factorize_into and solve_inplace implementations shown in the issue, then trace the A::lu and A::solve entry points. Confirm whether the matrix passed to A::lu is mutated into factors and whether the stored ipiv is used; done when the behavior is explained or corrected with a regression test.

I was having a look at the code behind LUFactorized and it appears that there is no LU factorization done at all. For example, the factorize_into source is

fn factorize_into(mut self) -> Result<LUFactorized<S>> {
    let ipiv = A::lu(self.layout()?, self.as_allocated_mut()?)?;
    Ok(LUFactorized { a: self, ipiv })
}

where self here is the original matrix. While it is fine to be storing the original matrix A (perhaps the LU decomposition is lazily evaluated), the solve_inplace code indicates that this is actually not the case at all. Instead it just uses the standard solve function without actually doing any LU decomposition at any point.

fn solve_inplace<'a, Sb>(
    &self,
    rhs: &'a mut ArrayBase<Sb, Ix1>,
) -> Result<&'a mut ArrayBase<Sb, Ix1>>
where
    Sb: DataMut<Elem = A>,
{
    assert_eq!(
        rhs.len(),
        self.a.len_of(Axis(1)),
        "The length of `rhs` must be compatible with the shape of the factored matrix.",
    );
    A::solve(
        self.a.square_layout()?,
        Transpose::No,
        self.a.as_allocated()?,
        &self.ipiv,
        rhs.as_slice_mut().unwrap(),
    )?;
    Ok(rhs)
}

Am I missing something? Or is this a temporary implementation until an LU factorization can be properly implemented?