Merge pull request #19 from JuliaComputing/dg/la_compat

build: update LinearAlgebra + julia compat

Author: DhairyaLGandhi

Project.toml

@@ -1,6 +1,6 @@
 name = "SymbolicCompilerPasses"
 uuid = "3384d301-0fbe-4b40-9ae0-b0e68bedb069"
-version = "0.1.0"
+version = "0.1.1"
 authors = ["Dhairya Gandhi <dhairya@juliahub.com>"]
 
 [deps]
@@ -20,12 +20,12 @@ url = "https://github.com/DhairyaLGandhi/SymbolicUtils.jl"
 SCPLinearSolveExt = ["LinearSolve"]
 
 [compat]
-LinearAlgebra = "1.11.0"
+LinearAlgebra = "1"
 LinearSolve = "3.53.0"
 PreallocationTools = "0.4.34, 1"
 StaticArrays = "1.9.15"
 SymbolicUtils = "4.1.0"
-julia = "1.11"
+julia = "1"
 
 [extras]
 Pkg = "44cfe95a-1eb2-52ea-b672-e2afdf69b78f"

src/hvncat_static_opt.jl

@@ -118,7 +118,7 @@ end
 is_small_hvncat(rows::Int) = rows <= 16  # For vectors
 
 """
-    detect_hvncat_pattern(expr::Code.Let, state::Code.CSEState) -> Union{Nothing, Vector{HvncatMatch}}
+    detect_hvncat_pattern(expr::Code.Let, state) -> Union{Nothing, Vector{HvncatMatch}}
 
 Detect hvncat/hcat/vcat operations that construct small literal arrays.
 
@@ -129,7 +129,7 @@ Examples of what this detects:
 
 For small arrays (≤ 4×4), these will be converted to StaticArrays.
 """
-function detect_hvncat_pattern(expr::Code.Let, state::Code.CSEState)
+function detect_hvncat_pattern(expr::Code.Let, state)
     matches = HvncatMatch[]
 
     for (idx, pair) in enumerate(expr.pairs)
@@ -176,17 +176,17 @@ end
 
 """
     transform_hvncat_to_static(expr::Code.Let, match_data::Union{Nothing, Vector{HvncatMatch}},
-                               state::Code.CSEState) -> Code.Let
+                               state) -> Code.Let
 
 Transform hvncat operations to StaticArray constructors.
 
 Converts:
 - `A = [1 2; 3 4]` → `A = SMatrix{2,2}(1, 2, 3, 4)`
 - `v = [1, 2, 3]` → `v = SVector{3}(1, 2, 3)`
 """
-transform_hvncat_to_static(expr, ::Nothing, state::Code.CSEState) = expr
+transform_hvncat_to_static(expr, ::Nothing, state) = expr
 function transform_hvncat_to_static(expr::Code.Let, match_data::Vector{HvncatMatch},
-                                   state::Code.CSEState)
+                                   state)
     isempty(match_data) && return expr
 
     # Build transformation plan

src/la_opt.jl

@@ -75,7 +75,7 @@ const TRIL_RULE = GenericRule("tril", LinearAlgebra.tril, LinearAlgebra.tril!, 8
 const NORMALIZE_RULE = GenericRule("normalize", LinearAlgebra.normalize, LinearAlgebra.normalize!, 8)
 # const CONJ_RULE = GenericRule("conj", LinearAlgebra.conj, LinearAlgebra.conj!, 8)
 
-function triu_opt(expr, state::CSEState)
+function triu_opt(expr, state)
     # Try to apply optimization rules
     optimized = apply_optimization_rules(expr, state, TRIU_RULE)
     if optimized !== nothing

src/ldiv_opt.jl

@@ -9,11 +9,11 @@ struct LdivMatch{Ta, Tb, S <: Assignment, P <: AbstractString} <: AbstractMatche
 end
 
 """
-    detect_ldiv_pattern(expr::Code.Let, state::Code.CSEState) -> Vector{LdivMatch}
+    detect_ldiv_pattern(expr::Code.Let, state) -> Vector{LdivMatch}
 
 Detect patterns of the form `result = A \\ B` where both A and B are arrays.
 """
-function detect_ldiv_pattern(expr::Code.Let, state::Code.CSEState)
+function detect_ldiv_pattern(expr::Code.Let, state)
     ldiv_candidates_idx = findall(expr.pairs) do x
         r = rhs(x)
         iscall(r) || return false
@@ -192,14 +192,14 @@ function ldiv_transformation(safe_matches, ::Val{false})
 end
 
 """
-    transform_to_ldiv_inplace(expr::Code.Let, match_data, state::Code.CSEState) -> Code.Let
+    transform_to_ldiv_inplace(expr::Code.Let, match_data, state) -> Code.Let
 
 Transform `result = A \\ B` to:
     result = ldiv!(A, B)
 
 This performs in-place linear solve, overwriting B with the result.
 """
-function transform_to_ldiv_inplace(expr::Code.Let, match_data::AbstractVector, state::Code.CSEState)
+function transform_to_ldiv_inplace(expr::Code.Let, match_data::AbstractVector, state)
     # Validate all matches
     safe_matches = filter(match_data) do match
         is_safe = is_safe_to_optimize_ldiv(match, expr)
@@ -217,7 +217,7 @@ function transform_to_ldiv_inplace(expr::Code.Let, match_data::AbstractVector, s
 
     return Code.Let(new_pairs, expr.body, expr.let_block)
 end
-transform_to_ldiv_inplace(expr::Code.Let, match_data::Nothing, state::Code.CSEState) = expr
+transform_to_ldiv_inplace(expr::Code.Let, match_data::Nothing, state) = expr
 
 # Create the optimization rule
 const LDIV_RULE = OptimizationRule(

src/matmuladd.jl

@@ -12,7 +12,7 @@ struct MatMulAddMatch{At, Bt, Ct} <: AbstractMatched
 end
 
 """
-    detect_matmul_add_pattern(expr::Code.Let, state::Code.CSEState) -> Union{Nothing, Vector{MatMulAddMatch}}
+    detect_matmul_add_pattern(expr::Code.Let, state) -> Union{Nothing, Vector{MatMulAddMatch}}
 
 Attempts to detect patterns of the form:
 
@@ -30,7 +30,7 @@ result = temp
 
 `A` and `B` must not be aliased.
 """
-function detect_matmul_add_pattern(expr::Code.Let, state::Code.CSEState)
+function detect_matmul_add_pattern(expr::Code.Let, state)
     mul_candidates_idx = findall(expr.pairs) do x
         r = rhs(x)
         iscall(r) || return false
@@ -88,8 +88,8 @@ function get_from_cache(x)
     end
 end
 
-transform_to_mul5_assignment(expr, ::Tuple{Union{Nothing, AbstractVector{Nothing}, Tuple{Nothing, Nothing}}, <:Any}, state::Code.CSEState) = expr
-function transform_to_mul5_assignment(expr, match_data_, state::Code.CSEState)
+transform_to_mul5_assignment(expr, ::Tuple{Union{Nothing, AbstractVector{Nothing}, Tuple{Nothing, Nothing}}, <:Any}, state) = expr
+function transform_to_mul5_assignment(expr, match_data_, state)
     match_data_, net_additive_terms = match_data_
     match_data_ === nothing && return expr
     Cset = Set(Iterators.flatten(getproperty.(match_data_, :Cs)))