Fix type instability in LinearSolve QR factorization fallback

lib/NonlinearSolveBase/Project.toml

@@ -62,7 +62,7 @@ ForwardDiff = "0.10.36, 1"
 InteractiveUtils = "<0.0.1, 1"
 LineSearch = "0.1.4"
 LinearAlgebra = "1.10"
-LinearSolve = "2.36.1, 3"
+LinearSolve = "3.15"
 Markdown = "1.10"
 MaybeInplace = "0.1.4"
 Preferences = "1.4"

lib/NonlinearSolveBase/ext/NonlinearSolveBaseLinearSolveExt.jl

@@ -21,53 +21,11 @@ function (cache::LinearSolveJLCache)(;
     linu !== nothing && NonlinearSolveBase.set_lincache_u!(cache, linu)
 
     linres = solve!(cache.lincache)
-    cache.lincache = linres.cache
-    # Unfortunately LinearSolve.jl doesn't have the most uniform ReturnCode handling
     if linres.retcode === ReturnCode.Failure
-        structured_mat = ArrayInterface.isstructured(cache.lincache.A)
-        is_gpuarray = ArrayInterface.device(cache.lincache.A) isa ArrayInterface.GPU
-
-        if !(cache.linsolve isa QRFactorization{ColumnNorm}) && !is_gpuarray &&
-           !structured_mat
-            if verbose
-                @warn "Potential Rank Deficient Matrix Detected. Attempting to solve using \
-                       Pivoted QR Factorization."
-            end
-            @assert (A !== nothing)&&(b !== nothing) "This case is not yet supported. \
-                                                      Please open an issue at \
-                                                      https://github.com/SciML/NonlinearSolve.jl"
-            if cache.additional_lincache === nothing # First time
-                linprob = LinearProblem(A, b; u0 = linres.u)
-                cache.additional_lincache = init(
-                    linprob, QRFactorization(ColumnNorm()); alias_u0 = false,
-                    alias = LinearAliasSpecifier(alias_A = false, alias_b = false)
-                )
-            else
-                cache.additional_lincache.A = A
-                cache.additional_lincache.b = b
-                cache.additional_lincache.Pl = cache.lincache.Pl
-                cache.additional_lincache.Pr = cache.lincache.Pr
-            end
-            linres = solve!(cache.additional_lincache)
-            cache.additional_lincache = linres.cache
-            linres.retcode === ReturnCode.Failure &&
-                return LinearSolveResult(; linres.u, success = false)
-            return LinearSolveResult(; linres.u)
-        elseif !(cache.linsolve isa QRFactorization{ColumnNorm})
-            if verbose
-                if structured_mat || is_gpuarray
-                    mat_desc = structured_mat ? "Structured" : "GPU"
-                    @warn "Potential Rank Deficient Matrix Detected. But Matrix is \
-                           $(mat_desc). Currently, we don't attempt to solve Rank Deficient \
-                           $(mat_desc) Matrices. Please open an issue at \
-                           https://github.com/SciML/NonlinearSolve.jl"
-                end
-            end
-        end
         return LinearSolveResult(; linres.u, success = false)
+    else
+        return LinearSolveResult(; linres.u)
     end
-
-    return LinearSolveResult(; linres.u)
 end
 
 function NonlinearSolveBase.needs_square_A(linsolve::SciMLLinearSolveAlgorithm, ::Any)

lib/NonlinearSolveBase/src/linear_solve.jl

@@ -6,7 +6,6 @@ end
 @concrete mutable struct LinearSolveJLCache <: AbstractLinearSolverCache
     lincache
     linsolve
-    additional_lincache::Any
     stats::NLStats
 end
 
@@ -76,7 +75,7 @@ function construct_linear_solver(alg, linsolve, A, b, u; stats, kwargs...)
     # unlias here, we will later use these as caches
     lincache = init(
         linprob, linsolve; alias = LinearAliasSpecifier(alias_A = false, alias_b = false))
-    return LinearSolveJLCache(lincache, linsolve, nothing, stats)
+    return LinearSolveJLCache(lincache, linsolve, stats)
 end
 
 function (cache::NativeJLLinearSolveCache)(;