[WIP] refactor: update to SymbolicUtils@4 and Symbolics@7 #3953

AayushSabharwal · 2025-10-02T13:05:26Z

Checklist

Appropriate tests were added
Any code changes were done in a way that does not break public API
All documentation related to code changes were updated
The new code follows the
contributor guidelines, in particular the SciML Style Guide and
COLPRAC.
Any new documentation only uses public API

Additional context

Add any other context about the problem here.

github-actions

Remaining comments which cannot be posted as a review comment to avoid GitHub Rate Limit

JuliaFormatter

[JuliaFormatter] _{reported by reviewdog 🐶}

ModelingToolkit.jl/src/systems/connectors.jl

Line 1118 in bf11961

    
           SymbolicUtils.promote_symtype(::typeof(instream_rt), ::Type{T}, ::Type{S}, ::Type{R}) where {T, S, R} = Real

[JuliaFormatter] _{reported by reviewdog 🐶}

ModelingToolkit.jl/src/systems/imperative_affect.jl

Line 73 in bf11961

[JuliaFormatter] _{reported by reviewdog 🐶}

ModelingToolkit.jl/src/systems/index_cache.jl

Line 32 in bf11961

    
           const MaybeArrayIndexT = Union{Int, UnitRange{Int}, Base.ReshapedArray{Int, N, UnitRange{Int}} where {N}}

[JuliaFormatter] _{reported by reviewdog 🐶}

ModelingToolkit.jl/src/systems/index_cache.jl

Lines 114 to 115 in bf11961

    
           parse_callbacks_for_discretes!(cevs, disc_param_callbacks, constant_buffers, nonnumeric_buffers, 0) 
        
           parse_callbacks_for_discretes!(devs, disc_param_callbacks, constant_buffers, nonnumeric_buffers, length(cevs))

[JuliaFormatter] _{reported by reviewdog 🐶}

ModelingToolkit.jl/src/systems/index_cache.jl

Line 130 in bf11961

    
           push!(disc_syms_by_symtype_by_partition[i], filter(==(partition) ∘ Base.Fix1(getindex, disc_param_callbacks), buffer))

[JuliaFormatter] _{reported by reviewdog 🐶}

ModelingToolkit.jl/src/systems/index_cache.jl

Line 163 in bf11961

    
           push!(disc_buffer_templates, map(Base.Fix1(BufferTemplate, symtype) ∘ length, disc_syms_by_partition))

[JuliaFormatter] _{reported by reviewdog 🐶}

ModelingToolkit.jl/src/systems/index_cache.jl

Lines 298 to 301 in bf11961

    
           BSImpl.Term(; f, args) => begin 
        
               f === getindex && (idx = get(disc_idxs, args[1], nothing)) !== nothing 
        
           end 
        
           _ => false

[JuliaFormatter] _{reported by reviewdog 🐶}

ModelingToolkit.jl/src/systems/index_cache.jl

Line 370 in bf11961

    
           function parse_callbacks_for_discretes!(events::Vector, disc_param_callbacks::Dict{SymbolicT, BitSet}, constant_buffers::Dict{TypeT, Set{SymbolicT}}, nonnumeric_buffers::Dict{TypeT, Set{SymbolicT}}, offset::Int)

[JuliaFormatter] _{reported by reviewdog 🐶}

ModelingToolkit.jl/src/systems/index_cache.jl

Line 445 in bf11961

    
           function SymbolicIndexingInterface.parameter_index(ic::IndexCache, sym::Union{Num, Symbolics.Arr, Symbolics.CallAndWrap})

[JuliaFormatter] _{reported by reviewdog 🐶}

ModelingToolkit.jl/src/systems/index_cache.jl

Line 501 in bf11961

    
           function check_index_map(idxmap::Dict{SymbolicT, V}, sym::SymbolicT)::Union{V, Nothing} where {V}

[JuliaFormatter] _{reported by reviewdog 🐶}

ModelingToolkit.jl/src/systems/nonlinear/initializesystem.jl

Line 829 in bf11961

    
           mask[i] = !iscall(eq.rhs) || operation(eq.rhs) !== StructuralTransformations.change_origin

[JuliaFormatter] _{reported by reviewdog 🐶}

ModelingToolkit.jl/src/systems/system.jl

Line 282 in bf11961

    
           if (checks isa Bool && checks === true || checks isa Int && (checks & CheckComponents) > 0) && iv !== nothing

[JuliaFormatter] _{reported by reviewdog 🐶}

ModelingToolkit.jl/src/systems/system.jl

Line 448 in bf11961

[JuliaFormatter] _{reported by reviewdog 🐶}

ModelingToolkit.jl/src/systems/systemstructure.jl

Line 755 in bf11961

    
           fullvars[i], discmap; filterer = Symbolics.FPSubFilterer{Union{Sample, Hold, Pre}}()))

[JuliaFormatter] _{reported by reviewdog 🐶}

ModelingToolkit.jl/src/utils.jl

Line 36 in bf11961

    
           issym(op) && return SSym(nameof(op); type = FnType{Tuple{symtype(iv)}, Real}, shape = SU.ShapeVecT())(iv)

[JuliaFormatter] _{reported by reviewdog 🐶}

ModelingToolkit.jl/src/utils.jl

Line 193 in bf11961

BSImpl.Term(; f) && if f isa Differential end => begin

[JuliaFormatter] _{reported by reviewdog 🐶}

ModelingToolkit.jl/src/utils.jl

Line 288 in bf11961

    
           function process_variables!(var_to_name::Dict{Symbol, SymbolicT}, defs::SymmapT, guesses::SymmapT, vars::Vector{SymbolicT})

[JuliaFormatter] _{reported by reviewdog 🐶}

ModelingToolkit.jl/src/utils.jl

Line 328 in bf11961

BSImpl.Term(; f, args) && if f === getindex end => args[1]

[JuliaFormatter] _{reported by reviewdog 🐶}

ModelingToolkit.jl/src/utils.jl

Line 399 in bf11961

    
           hasmetadata(x, VariableSource) || iscall(x) && operation(x) === getindex && isvariable(arguments(x)[1])::Bool

[JuliaFormatter] _{reported by reviewdog 🐶}

ModelingToolkit.jl/src/utils.jl

Line 543 in bf11961

    
           function collect_scoped_vars!(unknowns::OrderedSet{SymbolicT}, parameters::OrderedSet{SymbolicT}, sys::AbstractSystem, iv::Union{SymbolicT, Nothing}; depth = 1, op = Differential)

[JuliaFormatter] _{reported by reviewdog 🐶}

ModelingToolkit.jl/src/utils.jl

Line 626 in bf11961

BSImpl.Term(; f) && if f isa O end => true

[JuliaFormatter] _{reported by reviewdog 🐶}

ModelingToolkit.jl/src/utils.jl

Line 635 in bf11961

BSImpl.Term(; f) && if f isa Operator end => f isa O

[JuliaFormatter] _{reported by reviewdog 🐶}

ModelingToolkit.jl/src/utils.jl

Line 654 in bf11961

    
           function collect_vars!(unknowns::OrderedSet{SymbolicT}, parameters::OrderedSet{SymbolicT}, expr::SymbolicT, iv::Union{SymbolicT, Nothing}; depth = 0, op = Symbolics.Operator)

[JuliaFormatter] _{reported by reviewdog 🐶}

ModelingToolkit.jl/src/utils.jl

Line 672 in bf11961

    
           function collect_vars!(unknowns::OrderedSet{SymbolicT}, parameters::OrderedSet{SymbolicT}, expr::AbstractArray{SymbolicT}, iv::Union{SymbolicT, Nothing}; depth = 0, op = Symbolics.Operator)

[JuliaFormatter] _{reported by reviewdog 🐶}

ModelingToolkit.jl/src/utils.jl

Line 724 in bf11961

    
           check_scope_depth(getmetadata(var, SymScope, LocalScope())::AllScopes, depth) || return nothing

[JuliaFormatter] _{reported by reviewdog 🐶}

ModelingToolkit.jl/src/variables.jl

Line 198 in bf11961

    
           iscall(x) && operation(x) === getindex && return safe_getmetadata(m, arguments(x)[1], default)

[JuliaFormatter] _{reported by reviewdog 🐶}

ModelingToolkit.jl/src/variables.jl

Line 259 in bf11961

BSImpl.Term(; f, args, shape, type, metadata) && if f isa Operator end => begin

[JuliaFormatter] _{reported by reviewdog 🐶}

ModelingToolkit.jl/src/variables.jl

Line 621 in bf11961

    
           getunshifted(x::SymbolicT) = Symbolics.getmetadata(x, VariableUnshifted, nothing)::Union{SymbolicT, Nothing}

github-actions · 2025-10-02T13:07:34Z

src/ModelingToolkit.jl

+        fold1 = Val{false}()
+        using SymbolicUtils
+        using SymbolicUtils: shape
+        using Symbolics
+        @syms x y f(t) q[1:5]
+        SymbolicUtils.Sym{SymReal}(:a; type = Real, shape = SymbolicUtils.ShapeVecT())
+        x + y
+        x * y
+        x / y
+        x ^ y
+        x ^ 5
+        6 ^ x
+        x - y
+        -y
+        2y
+        z = 2
+        dict = SymbolicUtils.ACDict{VartypeT}()
+        dict[x] = 1
+        dict[y] = 1
+        type::typeof(DataType) = rand() < 0.5 ? Real : Float64
+        nt = (; type, shape, unsafe = true)
+        Base.pairs(nt)
+        BSImpl.AddMul{VartypeT}(1, dict, SymbolicUtils.AddMulVariant.MUL; type, shape = SymbolicUtils.ShapeVecT(), unsafe = true)
+        *(y, z)
+        *(z, y)
+        SymbolicUtils.symtype(y)
+        f(x)
+        (5x / 5)
+        expand((x + y) ^ 2)
+        simplify(x ^ (1//2) + (sin(x) ^ 2 + cos(x) ^ 2) + 2(x + y) - x - y)
+        ex = x + 2y + sin(x)
+        rules1 = Dict(x => y)
+        rules2 = Dict(x => 1)
+        Dx = Differential(x)
+        Differential(y)(ex)
+        uex = unwrap(ex)
+        Symbolics.executediff(Dx, uex)
+        # Running `fold = Val(true)` invalidates the precompiled statements
+        # for `fold = Val(false)` and itself doesn't precompile anyway.
+        # substitute(ex, rules1)
+        substitute(ex, rules1; fold = fold1)
+        substitute(ex, rules2; fold = fold1)
+        @variables foo
+        f(foo)
+        @variables x y f(::Real) q[1:5]
+        x + y
+        x * y
+        x / y
+        x ^ y
+        x ^ 5
+        # 6 ^ x
+        x - y
+        -y
+        2y
+        symtype(y)
+        z = 2
+        *(y, z)
+        *(z, y)
+        f(x)
+        (5x / 5)
+        [x, y]
+        [x, f, f]
+        promote_type(Int, Num)
+        promote_type(Real, Num)
+        promote_type(Float64, Num)
+        # expand((x + y) ^ 2)
+        # simplify(x ^ (1//2) + (sin(x) ^ 2 + cos(x) ^ 2) + 2(x + y) - x - y)
+        ex = x + 2y + sin(x)
+        rules1 = Dict(x => y)
+        # rules2 = Dict(x => 1)
+        # Running `fold = Val(true)` invalidates the precompiled statements
+        # for `fold = Val(false)` and itself doesn't precompile anyway.
+        # substitute(ex, rules1)
+        substitute(ex, rules1; fold = fold1)
+        Symbolics.linear_expansion(ex, y)
+        # substitute(ex, rules2; fold = fold1)
+        # substitute(ex, rules2)
+        # substitute(ex, rules1; fold = fold2)
+        # substitute(ex, rules2; fold = fold2)
+        q[1]
+        q'q
+     using ModelingToolkit


[JuliaFormatter] _{reported by reviewdog 🐶}

Suggested change

fold1 = Val{false}()

using SymbolicUtils

using SymbolicUtils: shape

using Symbolics

@syms x y f(t) q[1:5]

SymbolicUtils.Sym{SymReal}(:a; type = Real, shape = SymbolicUtils.ShapeVecT())

x + y

x * y

x / y

x ^ y

x ^ 5

6 ^ x

x - y

-y

2y

z = 2

dict = SymbolicUtils.ACDict{VartypeT}()

dict[x] = 1

dict[y] = 1

type::typeof(DataType) = rand() < 0.5 ? Real : Float64

nt = (; type, shape, unsafe = true)

Base.pairs(nt)

BSImpl.AddMul{VartypeT}(1, dict, SymbolicUtils.AddMulVariant.MUL; type, shape = SymbolicUtils.ShapeVecT(), unsafe = true)

*(y, z)

*(z, y)

SymbolicUtils.symtype(y)

f(x)

(5x / 5)

expand((x + y) ^ 2)

simplify(x ^ (1//2) + (sin(x) ^ 2 + cos(x) ^ 2) + 2(x + y) - x - y)

ex = x + 2y + sin(x)

rules1 = Dict(x => y)

rules2 = Dict(x => 1)

Dx = Differential(x)

Differential(y)(ex)

uex = unwrap(ex)

Symbolics.executediff(Dx, uex)

# Running `fold = Val(true)` invalidates the precompiled statements

# for `fold = Val(false)` and itself doesn't precompile anyway.

# substitute(ex, rules1)

substitute(ex, rules1; fold = fold1)

substitute(ex, rules2; fold = fold1)

@variables foo

f(foo)

@variables x y f(::Real) q[1:5]

x + y

x * y

x / y

x ^ y

x ^ 5

# 6 ^ x

x - y

-y

2y

symtype(y)

z = 2

*(y, z)

*(z, y)

f(x)

(5x / 5)

[x, y]

[x, f, f]

promote_type(Int, Num)

promote_type(Real, Num)

promote_type(Float64, Num)

# expand((x + y) ^ 2)

# simplify(x ^ (1//2) + (sin(x) ^ 2 + cos(x) ^ 2) + 2(x + y) - x - y)

ex = x + 2y + sin(x)

rules1 = Dict(x => y)

# rules2 = Dict(x => 1)

# Running `fold = Val(true)` invalidates the precompiled statements

# for `fold = Val(false)` and itself doesn't precompile anyway.

# substitute(ex, rules1)

substitute(ex, rules1; fold = fold1)

Symbolics.linear_expansion(ex, y)

# substitute(ex, rules2; fold = fold1)

# substitute(ex, rules2)

# substitute(ex, rules1; fold = fold2)

# substitute(ex, rules2; fold = fold2)

q[1]

q'q

using ModelingToolkit

fold1 = Val{false}()

using SymbolicUtils

using SymbolicUtils: shape

using Symbolics

@syms x y f(t) q[1:5]

SymbolicUtils.Sym{SymReal}(:a; type = Real, shape = SymbolicUtils.ShapeVecT())

x + y

x * y

x / y

x ^ y

x ^ 5

6 ^ x

x - y

-y

2y

z = 2

dict = SymbolicUtils.ACDict{VartypeT}()

dict[x] = 1

dict[y] = 1

type::typeof(DataType) = rand() < 0.5 ? Real : Float64

nt = (; type, shape, unsafe = true)

Base.pairs(nt)

BSImpl.AddMul{VartypeT}(1, dict, SymbolicUtils.AddMulVariant.MUL; type,

shape = SymbolicUtils.ShapeVecT(), unsafe = true)

*(y, z)

*(z, y)

SymbolicUtils.symtype(y)

f(x)

(5x / 5)

expand((x + y) ^ 2)

simplify(x ^ (1//2) + (sin(x) ^ 2 + cos(x) ^ 2) + 2(x + y) - x - y)

ex = x + 2y + sin(x)

rules1 = Dict(x => y)

rules2 = Dict(x => 1)

Dx = Differential(x)

Differential(y)(ex)

uex = unwrap(ex)

Symbolics.executediff(Dx, uex)

# Running `fold = Val(true)` invalidates the precompiled statements

# for `fold = Val(false)` and itself doesn't precompile anyway.

# substitute(ex, rules1)

substitute(ex, rules1; fold = fold1)

substitute(ex, rules2; fold = fold1)

@variables foo

f(foo)

@variables x y f(::Real) q[1:5]

x + y

x * y

x / y

x ^ y

x ^ 5

# 6 ^ x

x - y

-y

2y

symtype(y)

z = 2

*(y, z)

*(z, y)

f(x)

(5x / 5)

[x, y]

[x, f, f]

promote_type(Int, Num)

promote_type(Real, Num)

promote_type(Float64, Num)

# expand((x + y) ^ 2)

# simplify(x ^ (1//2) + (sin(x) ^ 2 + cos(x) ^ 2) + 2(x + y) - x - y)

ex = x + 2y + sin(x)

rules1 = Dict(x => y)

# rules2 = Dict(x => 1)

# Running `fold = Val(true)` invalidates the precompiled statements

# for `fold = Val(false)` and itself doesn't precompile anyway.

# substitute(ex, rules1)

substitute(ex, rules1; fold = fold1)

Symbolics.linear_expansion(ex, y)

# substitute(ex, rules2; fold = fold1)

# substitute(ex, rules2)

# substitute(ex, rules1; fold = fold2)

# substitute(ex, rules2; fold = fold2)

q[1]

q'q

using ModelingToolkit

github-actions · 2025-10-02T13:07:34Z

src/ModelingToolkit.jl

-    @named sys = System([ModelingToolkit.D_nounits(x) ~ -x], ModelingToolkit.t_nounits)
-    prob = ODEProblem(mtkcompile(sys), [x => 30.0], (0, 100), jac = true)
+    isequal(ModelingToolkit.D_nounits.x, ModelingToolkit.t_nounits)
+    sys = System([ModelingToolkit.D_nounits(x) ~ x], ModelingToolkit.t_nounits, [x], Num[]; name = :sys)


[JuliaFormatter] _{reported by reviewdog 🐶}

Suggested change

sys = System([ModelingToolkit.D_nounits(x) ~ x], ModelingToolkit.t_nounits, [x], Num[]; name = :sys)

sys = System([ModelingToolkit.D_nounits(x) ~ x],

ModelingToolkit.t_nounits, [x], Num[]; name = :sys)

github-actions · 2025-10-02T13:07:34Z

src/ModelingToolkit.jl

+precompile(Tuple{typeof(Base.merge), NamedTuple{(:f, :args, :metadata, :hash, :hash2, :shape, :type, :id), Tuple{SymbolicUtils.BasicSymbolicImpl.var"typeof(BasicSymbolicImpl)"{SymbolicUtils.SymReal}, SymbolicUtils.SmallVec{SymbolicUtils.BasicSymbolicImpl.var"typeof(BasicSymbolicImpl)"{SymbolicUtils.SymReal}, Array{SymbolicUtils.BasicSymbolicImpl.var"typeof(BasicSymbolicImpl)"{SymbolicUtils.SymReal}, 1}}, Nothing, UInt64, UInt64, SymbolicUtils.SmallVec{Base.UnitRange{Int64}, Array{Base.UnitRange{Int64}, 1}}, DataType, SymbolicUtils.IDType}}, NamedTuple{(:metadata,), Tuple{Base.ImmutableDict{DataType, Any}}}})
+precompile(Tuple{typeof(Base.merge), NamedTuple{(:f, :args, :metadata, :hash, :hash2, :shape, :type, :id), Tuple{SymbolicUtils.BasicSymbolicImpl.var"typeof(BasicSymbolicImpl)"{SymbolicUtils.SymReal}, SymbolicUtils.SmallVec{SymbolicUtils.BasicSymbolicImpl.var"typeof(BasicSymbolicImpl)"{SymbolicUtils.SymReal}, Array{SymbolicUtils.BasicSymbolicImpl.var"typeof(BasicSymbolicImpl)"{SymbolicUtils.SymReal}, 1}}, Base.ImmutableDict{DataType, Any}, UInt64, UInt64, SymbolicUtils.SmallVec{Base.UnitRange{Int64}, Array{Base.UnitRange{Int64}, 1}}, DataType, SymbolicUtils.IDType}}, NamedTuple{(:id, :hash, :hash2), Tuple{Nothing, Int64, Int64}}})
+precompile(Tuple{typeof(Core.kwcall), NamedTuple{(:f, :args, :metadata, :hash, :hash2, :shape, :type, :id), Tuple{SymbolicUtils.BasicSymbolicImpl.var"typeof(BasicSymbolicImpl)"{SymbolicUtils.SymReal}, SymbolicUtils.SmallVec{SymbolicUtils.BasicSymbolicImpl.var"typeof(BasicSymbolicImpl)"{SymbolicUtils.SymReal}, Array{SymbolicUtils.BasicSymbolicImpl.var"typeof(BasicSymbolicImpl)"{SymbolicUtils.SymReal}, 1}}, Base.ImmutableDict{DataType, Any}, Int64, Int64, SymbolicUtils.SmallVec{Base.UnitRange{Int64}, Array{Base.UnitRange{Int64}, 1}}, DataType, Nothing}}, Type{SymbolicUtils.BasicSymbolicImpl.Term{SymbolicUtils.SymReal}}})
+precompile(Tuple{typeof(Symbolics.parse_vars), Symbol, Type, Tuple{Symbol, Symbol}, Function})
+precompile(Tuple{typeof(Base.merge), NamedTuple{(:name, :metadata, :hash, :hash2, :shape, :type, :id), Tuple{Symbol, Base.ImmutableDict{DataType, Any}, UInt64, UInt64, SymbolicUtils.SmallVec{Base.UnitRange{Int64}, Array{Base.UnitRange{Int64}, 1}}, DataType, SymbolicUtils.IDType}}, NamedTuple{(:metadata,), Tuple{Base.ImmutableDict{DataType, Any}}}})


[JuliaFormatter] _{reported by reviewdog 🐶}

Suggested change

precompile(Tuple{typeof(Base.merge), NamedTuple{(:f, :args, :metadata, :hash, :hash2, :shape, :type, :id), Tuple{SymbolicUtils.BasicSymbolicImpl.var"typeof(BasicSymbolicImpl)"{SymbolicUtils.SymReal}, SymbolicUtils.SmallVec{SymbolicUtils.BasicSymbolicImpl.var"typeof(BasicSymbolicImpl)"{SymbolicUtils.SymReal}, Array{SymbolicUtils.BasicSymbolicImpl.var"typeof(BasicSymbolicImpl)"{SymbolicUtils.SymReal}, 1}}, Nothing, UInt64, UInt64, SymbolicUtils.SmallVec{Base.UnitRange{Int64}, Array{Base.UnitRange{Int64}, 1}}, DataType, SymbolicUtils.IDType}}, NamedTuple{(:metadata,), Tuple{Base.ImmutableDict{DataType, Any}}}})

precompile(Tuple{typeof(Base.merge), NamedTuple{(:f, :args, :metadata, :hash, :hash2, :shape, :type, :id), Tuple{SymbolicUtils.BasicSymbolicImpl.var"typeof(BasicSymbolicImpl)"{SymbolicUtils.SymReal}, SymbolicUtils.SmallVec{SymbolicUtils.BasicSymbolicImpl.var"typeof(BasicSymbolicImpl)"{SymbolicUtils.SymReal}, Array{SymbolicUtils.BasicSymbolicImpl.var"typeof(BasicSymbolicImpl)"{SymbolicUtils.SymReal}, 1}}, Base.ImmutableDict{DataType, Any}, UInt64, UInt64, SymbolicUtils.SmallVec{Base.UnitRange{Int64}, Array{Base.UnitRange{Int64}, 1}}, DataType, SymbolicUtils.IDType}}, NamedTuple{(:id, :hash, :hash2), Tuple{Nothing, Int64, Int64}}})

precompile(Tuple{typeof(Core.kwcall), NamedTuple{(:f, :args, :metadata, :hash, :hash2, :shape, :type, :id), Tuple{SymbolicUtils.BasicSymbolicImpl.var"typeof(BasicSymbolicImpl)"{SymbolicUtils.SymReal}, SymbolicUtils.SmallVec{SymbolicUtils.BasicSymbolicImpl.var"typeof(BasicSymbolicImpl)"{SymbolicUtils.SymReal}, Array{SymbolicUtils.BasicSymbolicImpl.var"typeof(BasicSymbolicImpl)"{SymbolicUtils.SymReal}, 1}}, Base.ImmutableDict{DataType, Any}, Int64, Int64, SymbolicUtils.SmallVec{Base.UnitRange{Int64}, Array{Base.UnitRange{Int64}, 1}}, DataType, Nothing}}, Type{SymbolicUtils.BasicSymbolicImpl.Term{SymbolicUtils.SymReal}}})

precompile(Tuple{typeof(Symbolics.parse_vars), Symbol, Type, Tuple{Symbol, Symbol}, Function})

precompile(Tuple{typeof(Base.merge), NamedTuple{(:name, :metadata, :hash, :hash2, :shape, :type, :id), Tuple{Symbol, Base.ImmutableDict{DataType, Any}, UInt64, UInt64, SymbolicUtils.SmallVec{Base.UnitRange{Int64}, Array{Base.UnitRange{Int64}, 1}}, DataType, SymbolicUtils.IDType}}, NamedTuple{(:metadata,), Tuple{Base.ImmutableDict{DataType, Any}}}})

precompile(Tuple{typeof(Base.merge),

NamedTuple{(:f, :args, :metadata, :hash, :hash2, :shape, :type, :id),

Tuple{

SymbolicUtils.BasicSymbolicImpl.var"typeof(BasicSymbolicImpl)"{SymbolicUtils.SymReal},

SymbolicUtils.SmallVec{

SymbolicUtils.BasicSymbolicImpl.var"typeof(BasicSymbolicImpl)"{SymbolicUtils.SymReal},

Array{

SymbolicUtils.BasicSymbolicImpl.var"typeof(BasicSymbolicImpl)"{SymbolicUtils.SymReal},

1}},

Nothing,

UInt64,

UInt64,

SymbolicUtils.SmallVec{Base.UnitRange{Int64}, Array{Base.UnitRange{Int64}, 1}},

DataType,

SymbolicUtils.IDType}},

NamedTuple{(:metadata,), Tuple{Base.ImmutableDict{DataType, Any}}}})

precompile(Tuple{typeof(Base.merge),

NamedTuple{(:f, :args, :metadata, :hash, :hash2, :shape, :type, :id),

Tuple{

SymbolicUtils.BasicSymbolicImpl.var"typeof(BasicSymbolicImpl)"{SymbolicUtils.SymReal},

SymbolicUtils.SmallVec{

SymbolicUtils.BasicSymbolicImpl.var"typeof(BasicSymbolicImpl)"{SymbolicUtils.SymReal},

Array{

SymbolicUtils.BasicSymbolicImpl.var"typeof(BasicSymbolicImpl)"{SymbolicUtils.SymReal},

1}},

Base.ImmutableDict{DataType, Any},

UInt64,

UInt64,

SymbolicUtils.SmallVec{Base.UnitRange{Int64}, Array{Base.UnitRange{Int64}, 1}},

DataType,

SymbolicUtils.IDType}},

NamedTuple{(:id, :hash, :hash2), Tuple{Nothing, Int64, Int64}}})

precompile(Tuple{typeof(Core.kwcall),

NamedTuple{(:f, :args, :metadata, :hash, :hash2, :shape, :type, :id),

Tuple{

SymbolicUtils.BasicSymbolicImpl.var"typeof(BasicSymbolicImpl)"{SymbolicUtils.SymReal},

SymbolicUtils.SmallVec{

SymbolicUtils.BasicSymbolicImpl.var"typeof(BasicSymbolicImpl)"{SymbolicUtils.SymReal},

Array{

SymbolicUtils.BasicSymbolicImpl.var"typeof(BasicSymbolicImpl)"{SymbolicUtils.SymReal},

1}},

Base.ImmutableDict{DataType, Any},

Int64,

Int64,

SymbolicUtils.SmallVec{Base.UnitRange{Int64}, Array{Base.UnitRange{Int64}, 1}},

DataType,

Nothing}},

Type{SymbolicUtils.BasicSymbolicImpl.Term{SymbolicUtils.SymReal}}})

precompile(Tuple{

typeof(Symbolics.parse_vars), Symbol, Type, Tuple{Symbol, Symbol}, Function})

precompile(Tuple{typeof(Base.merge),

NamedTuple{(:name, :metadata, :hash, :hash2, :shape, :type, :id),

Tuple{Symbol, Base.ImmutableDict{DataType, Any}, UInt64, UInt64,

SymbolicUtils.SmallVec{Base.UnitRange{Int64}, Array{Base.UnitRange{Int64}, 1}},

DataType, SymbolicUtils.IDType}},

NamedTuple{(:metadata,), Tuple{Base.ImmutableDict{DataType, Any}}}})

github-actions · 2025-10-02T13:07:35Z

src/ModelingToolkit.jl

+precompile(Tuple{typeof(Core.kwcall), NamedTuple{(:name, :defaults), Tuple{Symbol, Base.Dict{Symbolics.Num, Float64}}}, Type{ModelingToolkit.System}, Array{Symbolics.Equation, 1}, Symbolics.Num, Array{Symbolics.Num, 1}, Array{Symbolics.Num, 1}})
+precompile(Tuple{Type{NamedTuple{(:name, :defaults), T} where T<:Tuple}, Tuple{Symbol, Base.Dict{Symbolics.Num, Float64}}})


[JuliaFormatter] _{reported by reviewdog 🐶}

Suggested change

precompile(Tuple{typeof(Core.kwcall), NamedTuple{(:name, :defaults), Tuple{Symbol, Base.Dict{Symbolics.Num, Float64}}}, Type{ModelingToolkit.System}, Array{Symbolics.Equation, 1}, Symbolics.Num, Array{Symbolics.Num, 1}, Array{Symbolics.Num, 1}})

precompile(Tuple{Type{NamedTuple{(:name, :defaults), T} where T<:Tuple}, Tuple{Symbol, Base.Dict{Symbolics.Num, Float64}}})

precompile(Tuple{typeof(Core.kwcall),

NamedTuple{(:name, :defaults), Tuple{Symbol, Base.Dict{Symbolics.Num, Float64}}},

Type{ModelingToolkit.System}, Array{Symbolics.Equation, 1},

Symbolics.Num, Array{Symbolics.Num, 1}, Array{Symbolics.Num, 1}})

precompile(Tuple{Type{NamedTuple{(:name, :defaults), T} where T <: Tuple},

Tuple{Symbol, Base.Dict{Symbolics.Num, Float64}}})

github-actions · 2025-10-02T13:07:35Z

src/ModelingToolkit.jl

+precompile(Tuple{Type{NamedTuple{(:name, :defaults, :guesses), T} where T<:Tuple}, Tuple{Symbol, Base.Dict{Symbolics.Num, Float64}, Base.Dict{Symbolics.Num, Float64}}})
+precompile(Tuple{typeof(Core.kwcall), NamedTuple{(:name, :defaults, :guesses), Tuple{Symbol, Base.Dict{Symbolics.Num, Float64}, Base.Dict{Symbolics.Num, Float64}}}, Type{ModelingToolkit.System}, Array{Symbolics.Equation, 1}, Symbolics.Num, Array{Symbolics.Num, 1}, Array{Symbolics.Num, 1}})
+precompile(Tuple{typeof(Core.kwcall), NamedTuple{(:type, :shape), Tuple{DataType, SymbolicUtils.SmallVec{Base.UnitRange{Int64}, Array{Base.UnitRange{Int64}, 1}}}}, typeof(SymbolicUtils.term), Any, SymbolicUtils.BasicSymbolicImpl.var"typeof(BasicSymbolicImpl)"{SymbolicUtils.SymReal}})


[JuliaFormatter] _{reported by reviewdog 🐶}

Suggested change

precompile(Tuple{Type{NamedTuple{(:name, :defaults, :guesses), T} where T<:Tuple}, Tuple{Symbol, Base.Dict{Symbolics.Num, Float64}, Base.Dict{Symbolics.Num, Float64}}})

precompile(Tuple{typeof(Core.kwcall), NamedTuple{(:name, :defaults, :guesses), Tuple{Symbol, Base.Dict{Symbolics.Num, Float64}, Base.Dict{Symbolics.Num, Float64}}}, Type{ModelingToolkit.System}, Array{Symbolics.Equation, 1}, Symbolics.Num, Array{Symbolics.Num, 1}, Array{Symbolics.Num, 1}})

precompile(Tuple{typeof(Core.kwcall), NamedTuple{(:type, :shape), Tuple{DataType, SymbolicUtils.SmallVec{Base.UnitRange{Int64}, Array{Base.UnitRange{Int64}, 1}}}}, typeof(SymbolicUtils.term), Any, SymbolicUtils.BasicSymbolicImpl.var"typeof(BasicSymbolicImpl)"{SymbolicUtils.SymReal}})

precompile(Tuple{Type{NamedTuple{(:name, :defaults, :guesses), T} where T <: Tuple},

Tuple{Symbol, Base.Dict{Symbolics.Num, Float64}, Base.Dict{Symbolics.Num, Float64}}})

precompile(Tuple{typeof(Core.kwcall),

NamedTuple{(:name, :defaults, :guesses),

Tuple{Symbol, Base.Dict{Symbolics.Num, Float64}, Base.Dict{Symbolics.Num, Float64}}},

Type{ModelingToolkit.System},

Array{Symbolics.Equation, 1},

Symbolics.Num,

Array{Symbolics.Num, 1},

Array{Symbolics.Num, 1}})

precompile(Tuple{typeof(Core.kwcall),

NamedTuple{(:type, :shape),

Tuple{DataType,

SymbolicUtils.SmallVec{Base.UnitRange{Int64}, Array{Base.UnitRange{Int64}, 1}}}},

typeof(SymbolicUtils.term),

Any,

SymbolicUtils.BasicSymbolicImpl.var"typeof(BasicSymbolicImpl)"{SymbolicUtils.SymReal}})

github-actions · 2025-10-02T13:07:41Z

src/systems/abstractsystem.jl

+                term = namespace_expr(term, sys, n; ivs)
+            end
+            expr = namespace_expr(expr, sys, n; ivs)
+            return BSImpl.ArrayOp{VartypeT}(output_idx, expr, reduce, term, ranges; type, shape, metadata)


[JuliaFormatter] _{reported by reviewdog 🐶}

Suggested change

return BSImpl.ArrayOp{VartypeT}(output_idx, expr, reduce, term, ranges; type, shape, metadata)

return BSImpl.ArrayOp{VartypeT}(

output_idx, expr, reduce, term, ranges; type, shape, metadata)

github-actions · 2025-10-02T13:07:41Z

src/systems/abstractsystem.jl

    for (i, eq) in enumerate(eqs)
        empty!(varsbuf)
-        vars!(varsbuf, eq; op = Union{Differential, Initial, Pre})
+        SU.search_variables!(varsbuf, eq; is_atomic = OperatorIsAtomic{Union{Differential, Initial, Pre}}())


[JuliaFormatter] _{reported by reviewdog 🐶}

Suggested change

SU.search_variables!(varsbuf, eq; is_atomic = OperatorIsAtomic{Union{Differential, Initial, Pre}}())

SU.search_variables!(varsbuf, eq; is_atomic = OperatorIsAtomic{Union{

Differential, Initial, Pre}}())

github-actions · 2025-10-02T13:07:41Z

src/systems/alias_elimination.jl

 end

-function observed2graph(eqs, unknowns)
+function observed2graph(eqs::Vector{Equation}, unknowns::Vector{SymbolicT})::Tuple{BipartiteGraph{Int, Nothing}, Vector{Int}}


[JuliaFormatter] _{reported by reviewdog 🐶}

Suggested change

function observed2graph(eqs::Vector{Equation}, unknowns::Vector{SymbolicT})::Tuple{BipartiteGraph{Int, Nothing}, Vector{Int}}

function observed2graph(eqs::Vector{Equation},

unknowns::Vector{SymbolicT})::Tuple{BipartiteGraph{Int, Nothing}, Vector{Int}}

github-actions · 2025-10-02T13:07:41Z

src/systems/callbacks.jl

+    @set! sys.unknowns = s(get_unknowns(sys))
+    @set! sys.ps = s(get_ps(sys))
+    AffectSystem(sys, s(aff.unknowns), s(aff.parameters), s(aff.discretes))
+


[JuliaFormatter] _{reported by reviewdog 🐶}

Suggested change

github-actions · 2025-10-02T13:07:42Z

src/systems/codegen_utils.jl

 """
-const DDE_HISTORY_FUN = Sym{Symbolics.FnType{Tuple{Any, <:Real}, Vector{Real}}}(:___history___)
-const BVP_SOLUTION = Sym{Symbolics.FnType{Tuple{<:Real}, Vector{Real}}}(:__sol__)
+const DDE_HISTORY_FUN = SSym(:___history___; type = SU.FnType{Tuple{Any, <:Real}, Vector{Real}}, shape = SU.Unknown(1))


[JuliaFormatter] _{reported by reviewdog 🐶}

Suggested change

const DDE_HISTORY_FUN = SSym(:___history___; type = SU.FnType{Tuple{Any, <:Real}, Vector{Real}}, shape = SU.Unknown(1))

const DDE_HISTORY_FUN = SSym(

:___history___; type = SU.FnType{Tuple{Any, <:Real}, Vector{Real}}, shape = SU.Unknown(1))

AayushSabharwal added 30 commits September 30, 2025 19:53

refactor: remove usages of Symbolic

51fa305

refactor: remove usages of _parse_vars

e933777

refactor: remove outdated imports

4ca242b

refactor: remove usages of fast_substitute

cf100b0

refactor: remove usages of CallWithMetadata

ad938e2

refactor: remove usages of old symtype syntax

a421336

refactor: remove usages of Difference

6e3bb48

refactor: remove usages of Symbolics._mapreduce

06c78b0

refactor: remove usages of Symbolics.getparent

63a6a39

fix: implement SII.getname for System

d3f1908

fix: remove usages of Symbolics.Unknown, Symbolics.shape

28cb220

refactor: remove usages of array_term

a4cf26e

fix: move ChainRulesCore to an extension

3410078

fix: move JuliaFormatter to an extension

ffec46c

fix: fix invalidations from promote_symtype method

19b3f5c

fix: remove usages of occursin for searching expressions

7b49807

fix: remove usages of deprecated children

56d0d39

fix: remove usages of deprecated DataStructures features

f8d20ad

fixup! refactor: remove usages of old symtype syntax

b5f1b6d

fixup! refactor: remove usages of old symtype syntax

7734445

refactor: concretely type some utility functions

3e9aab2

fix: handle Const in connection expansion

5732ce3

fixup! refactor: remove usages of array_term

a33a721

refactor: improve type-stability of renamespace

8393cb7

refactor: make System more concretely typed

587476c

fixup! refactor: remove usages of CallWithMetadata

f79523b

fix: fix usage of new get_variables in is_bound

0689b54

fixup! refactor: remove usages of array_term

1dd83b5

fix: handle removal of operator kwarg of substitute

d2a74a0

refactor: get System to precompile in a trivial case

5cad99f

AayushSabharwal added 21 commits October 1, 2025 19:30

fixup! fix: fix invalidations from promote_symtype method

28c3542

fixup! refactor: get System to precompile in a trivial case

8f1493f

fix: improve inference of variable metadata accessors

692928b

fix: make default_toterm type stable

82eb4ba

fix: improve inference of several utility functions

f7231ba

fix: make shift2term type-stable

b30bcc8

fix: make unhack_observed type-stable

5b47bea

fix: make independent_variables type-stable

b921da8

fix: improve type-stability of some SII functions

9161395

fix: improve type-stability of the Initial operator

badfb9f

fix: make add_initialization_parameters type-stable

41ca68b

fix: improve type-stability of discover_globalscoped

cef5f24

fix: make topsorting equations type-stable

a6ba3cd

fix: make SymbolicAffect and AffectSystem type-stable

27e1ec4

fix: improve type-stability of ImperativeAffect

9fa324b

fix: make reorder_parameters more type-stable

a2d9efa

fix: make some SII impls of IndexCache more type-stable

6b22f32

fix: make IndexCache constructor more type-stable

33d5fc3

fix: improve precompile-friendliness of complete

9b5fee9

refactor: miscellaneous improvements

01a2b9a

fix: minor fix for evaluate_varmap!

bf11961

github-actions bot reviewed Oct 2, 2025

View reviewed changes

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Uh oh!

Uh oh!

[WIP] refactor: update to SymbolicUtils@4 and Symbolics@7 #3953

[WIP] refactor: update to SymbolicUtils@4 and Symbolics@7 #3953

Uh oh!

AayushSabharwal commented Oct 2, 2025

Uh oh!

github-actions bot left a comment

Uh oh!

github-actions bot Oct 2, 2025

Uh oh!

github-actions bot Oct 2, 2025

Uh oh!

github-actions bot Oct 2, 2025

Uh oh!

github-actions bot Oct 2, 2025

Uh oh!

github-actions bot Oct 2, 2025

Uh oh!

github-actions bot Oct 2, 2025

Uh oh!

github-actions bot Oct 2, 2025

Uh oh!

github-actions bot Oct 2, 2025

Uh oh!

github-actions bot Oct 2, 2025

Uh oh!

github-actions bot Oct 2, 2025

Uh oh!

Uh oh!

	parse_callbacks_for_discretes!(cevs, disc_param_callbacks, constant_buffers, nonnumeric_buffers, 0)
	parse_callbacks_for_discretes!(devs, disc_param_callbacks, constant_buffers, nonnumeric_buffers, length(cevs))

	BSImpl.Term(; f, args) => begin
	f === getindex && (idx = get(disc_idxs, args[1], nothing)) !== nothing
	end
	_ => false

	sys = System([ModelingToolkit.D_nounits(x) ~ x], ModelingToolkit.t_nounits, [x], Num[]; name = :sys)
	sys = System([ModelingToolkit.D_nounits(x) ~ x],
	ModelingToolkit.t_nounits, [x], Num[]; name = :sys)

		precompile(Tuple{typeof(Core.kwcall), NamedTuple{(:name, :defaults), Tuple{Symbol, Base.Dict{Symbolics.Num, Float64}}}, Type{ModelingToolkit.System}, Array{Symbolics.Equation, 1}, Symbolics.Num, Array{Symbolics.Num, 1}, Array{Symbolics.Num, 1}})
		precompile(Tuple{Type{NamedTuple{(:name, :defaults), T} where T<:Tuple}, Tuple{Symbol, Base.Dict{Symbolics.Num, Float64}}})

	return BSImpl.ArrayOp{VartypeT}(output_idx, expr, reduce, term, ranges; type, shape, metadata)
	return BSImpl.ArrayOp{VartypeT}(
	output_idx, expr, reduce, term, ranges; type, shape, metadata)

	SU.search_variables!(varsbuf, eq; is_atomic = OperatorIsAtomic{Union{Differential, Initial, Pre}}())
	SU.search_variables!(varsbuf, eq; is_atomic = OperatorIsAtomic{Union{
	Differential, Initial, Pre}}())

	function observed2graph(eqs::Vector{Equation}, unknowns::Vector{SymbolicT})::Tuple{BipartiteGraph{Int, Nothing}, Vector{Int}}
	function observed2graph(eqs::Vector{Equation},
	unknowns::Vector{SymbolicT})::Tuple{BipartiteGraph{Int, Nothing}, Vector{Int}}

	const DDE_HISTORY_FUN = SSym(:___history___; type = SU.FnType{Tuple{Any, <:Real}, Vector{Real}}, shape = SU.Unknown(1))
	const DDE_HISTORY_FUN = SSym(
	:___history___; type = SU.FnType{Tuple{Any, <:Real}, Vector{Real}}, shape = SU.Unknown(1))

Uh oh!

[WIP] refactor: update to SymbolicUtils@4 and Symbolics@7 #3953

Are you sure you want to change the base?

[WIP] refactor: update to SymbolicUtils@4 and Symbolics@7 #3953

Uh oh!

Conversation

AayushSabharwal commented Oct 2, 2025

Checklist

Additional context

Uh oh!

github-actions bot left a comment

Choose a reason for hiding this comment

Uh oh!

github-actions bot Oct 2, 2025

Choose a reason for hiding this comment

Uh oh!

github-actions bot Oct 2, 2025

Choose a reason for hiding this comment

Uh oh!

github-actions bot Oct 2, 2025

Choose a reason for hiding this comment

Uh oh!

github-actions bot Oct 2, 2025

Choose a reason for hiding this comment

Uh oh!

github-actions bot Oct 2, 2025

Choose a reason for hiding this comment

Uh oh!

github-actions bot Oct 2, 2025

Choose a reason for hiding this comment

Uh oh!

github-actions bot Oct 2, 2025

Choose a reason for hiding this comment

Uh oh!

github-actions bot Oct 2, 2025

Choose a reason for hiding this comment

Uh oh!

github-actions bot Oct 2, 2025

Choose a reason for hiding this comment

Uh oh!

github-actions bot Oct 2, 2025

Choose a reason for hiding this comment

Uh oh!

Uh oh!