function parse_variable_arg: LoadError MethodError, No or invalid units provided

[wang890]

Describe the bug 🐞

I did a lot of testing and trying under the ENV of Julia v1.10 and the latest v1.11.1, vscode 1.94.2
and the latest 1.95.3, vscode julia extension v1.124.2 and the latest 1.127.2:

Only the following package combination (old version) can run my code, and DynamicQuantities v0.13.2 can work. If upgrade any of these packages, an error will occur. I guess this may not be a bug of vscode.

⌃ [d360d2e6] ChainRulesCore v1.24.0
⌃ [2b5f629d] DiffEqBase v6.151.4
⌅ [06fc5a27] DynamicQuantities v0.13.2
⌃ [961ee093] ModelingToolkit v9.19.0
⌃ [1dea7af3] OrdinaryDiffEq v6.84.0
⌃ [91a5bcdd] Plots v1.40.4

when I used the following package combination (compat version) of ModelingToolkit project.toml [compat], the same error occurred

⌃ [d360d2e6] ChainRulesCore v1
⌃ [2b5f629d] DiffEqBase v6.157
⌅[06fc5a27] DynamicQuantities v0.13.2
    [961ee093] ModelingToolkit v9.54
⌃  [1dea7af3] OrdinaryDiffEq v6.82.0

when I used all the latest version as follows, the same error occurred

    [d360d2e6] ChainRulesCore v1.25.0
    [2b5f629d] DiffEqBase v6.160.0
⌅[06fc5a27] DynamicQuantities v0.13.2  
    [961ee093] ModelingToolkit v9.54.0
    [1dea7af3] OrdinaryDiffEq v6.90.1
    [91a5bcdd] Plots v1.40.9

The error is following when Run Without Debugging. the paragraph of MethodError(DynamicQuantities.uconvert ...... before "ERROR: LoadError..." was the output when I added a line of println(e) at function parse_variable_arg in model_parsing.jl:

MethodError(DynamicQuantities.uconvert, (1.0 m² s⁻³ A⁻² kg, 1.0), 0x00000000000069c5)
ERROR: LoadError: MethodError: no method matching setmetadata(::Nothing, ::Type{ModelingToolkit.VariableUnit}, ::DynamicQuantities.Quantity{Float64, DynamicQuantities.Dimensions{DynamicQuantities.FixedRational{Int32, 25200}}})
The function `setmetadata` exists, but no method is defined for this combination of argument types.

Closest candidates are:
  setmetadata(::Num, ::Any, ::Any)
   @ Symbolics C:\Users\TCY\.julia\packages\Symbolics\YbNrd\src\Symbolics.jl:187
  setmetadata(::Complex{Num}, ::Any, ::Any)
   @ Symbolics C:\Users\TCY\.julia\packages\Symbolics\YbNrd\src\Symbolics.jl:187
  setmetadata(::SymbolicUtils.Symbolic, ::DataType, ::Any)
   @ SymbolicUtils C:\Users\TCY\.julia\packages\SymbolicUtils\jf8aQ\src\types.jl:685

ERROR: LoadError: No or invalid units provided for 'R'
Stacktrace:
  [1] set_scalar_metadata(x::Nothing, V::Type, val::DynamicQuantities.Quantity{Float64, DynamicQuantities.Dimensions{DynamicQuantities.FixedRational{Int32, 25200}}})
    @ Symbolics C:\Users\TCY\.julia\packages\Symbolics\YbNrd\src\variable.jl:43
  [2] #__Resistor__#11
    @ C:\Users\TCY\.julia\packages\UnPack\EkESO\src\UnPack.jl:905 [inlined]
  [3] __Resistor__(; name::Symbol, useHeatPort::Bool, conditionalHeatPort__useHeatPort::Nothing, R::Float64, T_ref::ModelingToolkit.NoValue, alpha::ModelingToolkit.NoValue, R_actual::ModelingToolkit.NoValue)
    @ Systemize.Electrical .\none:0
  [4] __Resistor__
    @ .\none:0 [inlined]
  [5] #_#441
    @ C:\Users\TCY\.julia\packages\ModelingToolkit\0O7FS\src\systems\model_parsing.jl:25 [inlined]
  [6] macro expansion
    @ C:\Users\TCY\.julia\packages\ModelingToolkit\0O7FS\src\systems\abstractsystem.jl:2113 [inlined]
  [7] __Rc__(; name::Symbol, useHeatPort::Bool, resistor__R::Nothing, resistor__useHeatPort::Nothing, capacitor__C::Nothing, source__V::Nothing, fixedTemperature__T::Nothing)
    @ Systemize.Electrical C:\Users\TCY\.julia\packages\ModelingToolkit\0O7FS\src\systems\model_parsing.jl:138
  [8] __Rc__
    @ C:\Users\TCY\.julia\packages\ModelingToolkit\0O7FS\src\systems\model_parsing.jl:138 [inlined]
  [9] #_#441
    @ C:\Users\TCY\.julia\packages\ModelingToolkit\0O7FS\src\systems\model_parsing.jl:25 [inlined]
 [10] top-level scope
    @ C:\Users\TCY\.julia\packages\ModelingToolkit\0O7FS\src\systems\abstractsystem.jl:2113
 [11] include(fname::String)
    @ Main .\sysimg.jl:38
 [12] run(debug_session::VSCodeDebugger.DebugAdapter.DebugSession, error_handler::VSCodeDebugger.var"#3#4"{String})
    @ VSCodeDebugger.DebugAdapter c:\Users\TCY\.vscode\extensions\julialang.language-julia-1.127.2\scripts\packages\DebugAdapter\src\packagedef.jl:122
 [13] startdebugger()
    @ VSCodeDebugger c:\Users\TCY\.vscode\extensions\julialang.language-julia-1.127.2\scripts\packages\VSCodeDebugger\src\VSCodeDebugger.jl:45
 [14] top-level scope
    @ c:\Users\TCY\.vscode\extensions\julialang.language-julia-1.127.2\scripts\debugger\run_debugger.jl:12
 [15] include(mod::Module, _path::String)
    @ Base .\Base.jl:557
 [16] exec_options(opts::Base.JLOptions)
    @ Base .\client.jl:323
 [17] _start()
    @ Base .\client.jl:531

error("No or invalid units provided for \'" * string(:($$vv)) is at the following function in model_parsing.jl

function parse_variable_arg(dict, mod, arg, varclass, kwargs, where_types)
    vv, def, metadata_with_exprs = parse_variable_def!(
        dict, mod, arg, varclass, kwargs, where_types)
    if !(vv isa Tuple)
        name = getname(vv)
        varexpr = if haskey(metadata_with_exprs, VariableUnit)
            unit = metadata_with_exprs[VariableUnit]
            quote
                $name = if $name === $NO_VALUE
                    $setdefault($vv, $def)
                else
                    try
                        $setdefault($vv, $convert_units($unit, $name))
                    catch e
                        if isa(e, $(DynamicQuantities.DimensionError)) ||
                           isa(e, $(Unitful.DimensionError))
                            error("Unable to convert units for \'" * string(:($$vv)) * "\'")
                        elseif isa(e, MethodError)
                            error("No or invalid units provided for \'" * string(:($$vv)) *
                                  "\'")
                            println(e)
                        else
                            rethrow(e)
                        end
                    end
                end
            end
        else

The Resistor code in my code is as following. My temporary Unit solution like unit = u("Resistance") had been described at the issue . After I learned Julia macro and mtk, I would also like to contribute some code.

@mtkmodel Resistor begin
    @structural_parameters begin
        useHeatPort=false 
      end
    @extend i,v,p,n = onePort = OnePort()

    @components begin        
        conditionalHeatPort = ConditionalHeatPort(; useHeatPort=useHeatPort)    
    end
        
    @parameters begin
        R,                      [unit = u("Resistance"), guess = 1, description = "Resistance at temperature T_ref"]

        T_ref = 300.15, [unit = u("ThermodynamicTemperature"), bounds = (0.0, Inf), guess = 288.15, 
                                  description = "Reference temperature"] # 27 celsius degree
                          
        alpha = 0,         [unit = u("LinearTemperatureCoefficient"), 
                                  description = "Temperature coefficient of resistance R_actual = R*(1 + alpha*(T_heatPort - T_ref))"] 
    end
    @variables begin
        R_actual(t),       [unit = u("Resistance"),
                                  description = "Actual resistance = R*(1 + alpha*(T_heatPort - T_ref))"]
    end
    @equations begin     
        R_actual ~ R*(1 + alpha*(conditionalHeatPort.T_heatPort - T_ref))
        v ~ R_actual * i
        conditionalHeatPort.LossPower ~ v * i        
    end
end

The error becomes as following when Start Debugging.

┌ Error: Some Julia code in the VS Code extension crashed
└ @ VSCodeDebugger c:\Users\TCY\.vscode\extensions\julialang.language-julia-1.127.2\scripts\error_handler.jl:15
ERROR: UndefVarError: `uuid4` not defined in `VSCodeDebugger.DebugAdapter`
Suggestion: check for spelling errors or missing imports.
Hint: a global variable of this name may be made accessible by importing UUIDs in the current active module Main
Stacktrace:
 [1] stack_trace_request(debug_session::VSCodeDebugger.DebugAdapter.DebugSession, params::VSCodeDebugger.DebugAdapter.StackTraceArguments)
   @ VSCodeDebugger.DebugAdapter c:\Users\TCY\.vscode\extensions\julialang.language-julia-1.127.2\scripts\packages\DebugAdapter\src\debugger_requests.jl:400
 [2] (::VSCodeDebugger.DebugAdapter.var"#110#139"{VSCodeDebugger.DebugAdapter.DebugSession})(params::VSCodeDebugger.DebugAdapter.StackTraceArguments)
   @ VSCodeDebugger.DebugAdapter c:\Users\TCY\.vscode\extensions\julialang.language-julia-1.127.2\scripts\packages\DebugAdapter\src\packagedef.jl:73
 [3] dispatch_msg(x::VSCodeDebugger.DebugAdapter.DAPRPC.DAPEndpoint{Base.PipeEndpoint, Base.PipeEndpoint}, dispatcher::VSCodeDebugger.DebugAdapter.DAPRPC.MsgDispatcher, msg::Dict{String, Any})
   @ VSCodeDebugger.DebugAdapter.DAPRPC c:\Users\TCY\.vscode\extensions\julialang.language-julia-1.127.2\scripts\packages\DebugAdapter\src\DAPRPC\typed.jl:89
 [4] (::VSCodeDebugger.DebugAdapter.var"#132#161"{Dict{String, Any}, VSCodeDebugger.var"#3#4"{String}, VSCodeDebugger.DebugAdapter.DAPRPC.MsgDispatcher, VSCodeDebugger.DebugAdapter.DAPRPC.DAPEndpoint{Base.PipeEndpoint, Base.PipeEndpoint}})()
   @ VSCodeDebugger.DebugAdapter c:\Users\TCY\.vscode\extensions\julialang.language-julia-1.127.2\scripts\packages\DebugAdapter\src\packagedef.jl:98

[wang890]

Julia 1.11.2,  VScode 1.96.2 (system setup), vscode julia extension pre-release 1.134.1
[d360d2e6] ChainRulesCore v1.25.0
[2b5f629d] DiffEqBase v6.161.0
[06fc5a27] DynamicQuantities v0.13.2
[961ee093] ModelingToolkit v9.59.0
[1dea7af3] OrdinaryDiffEq v6.90.1
[91a5bcdd] Plots v1.40.9

@AayushSabharwal Happy new year!

with the latest version, the bug still exists. when F5 Start Debugging, the following error happened at the file
.julia\juliaup\julia-1.11.2+0.x64.w64.mingw32\share\julia\base\error.jl.
My temporary Unit solution like unit = u("Resistance") had been described at the issue. The function u returns the DynamicQuantities Unit.

Exception has occurred: ErrorException
No or invalid units provided for 'R'

Stacktrace:
  [1] error(s::String)
    @ Base error.jl:35
  [2] __Resistor__(; name::Symbol, useHeatPort::Bool, conditionalHeatPort__useHeatPort::Nothing, R::Float64, T_ref::ModelingToolkit.NoValue, alpha::ModelingToolkit.NoValue, R_actual::ModelingToolkit.NoValue)
    @ Systemize.Electrical C:\Users\TCY\.julia\packages\UnPack\EkESO\src\UnPack.jl:901
  [3] kwcall(::@NamedTuple{name::Symbol, R::Float64, useHeatPort::Bool}, ::typeof(Systemize.Electrical.__Resistor__))
    @ Systemize.Electrical none:0
  [4] (::ModelingToolkit.Model{typeof(Systemize.Electrical.__Resistor__), Dict{Symbol, Any}})(args::Tuple{}; kw::@Kwargs{name::Symbol, R::Float64, useHeatPort::Bool})
    @ ModelingToolkit C:\Users\TCY\.julia\packages\ModelingToolkit\klLLV\src\systems\model_parsing.jl:25
  [5] kwcall(::@NamedTuple{name::Symbol, R::Float64, useHeatPort::Bool}, m::ModelingToolkit.Model{typeof(Systemize.Electrical.__Resistor__), Dict{Symbol, Any}}, args::Tuple{})
    @ ModelingToolkit C:\Users\TCY\.julia\packages\ModelingToolkit\klLLV\src\systems\model_parsing.jl:25
  [6] __Rc__(; name::Symbol, useHeatPort::Bool, resistor__R::Nothing, resistor__useHeatPort::Nothing, capacitor__C::Nothing, source__V::Nothing, fixedTemperature__T::Nothing)
    @ Systemize.Electrical C:\Users\TCY\.julia\packages\ModelingToolkit\klLLV\src\systems\abstractsystem.jl:2060
  [7] kwcall(::@NamedTuple{name::Symbol, useHeatPort::Bool}, ::typeof(Systemize.Electrical.__Rc__))
    @ Systemize.Electrical C:\Users\TCY\.julia\packages\ModelingToolkit\klLLV\src\systems\model_parsing.jl:138
  [8] (::ModelingToolkit.Model{typeof(Systemize.Electrical.__Rc__), Dict{Symbol, Any}})(args::Tuple{}; kw::@Kwargs{name::Symbol, useHeatPort::Bool})
    @ ModelingToolkit C:\Users\TCY\.julia\packages\ModelingToolkit\klLLV\src\systems\model_parsing.jl:25
  [9] kwcall(::@NamedTuple{name::Symbol, useHeatPort::Bool}, m::ModelingToolkit.Model{typeof(Systemize.Electrical.__Rc__), Dict{Symbol, Any}}, args::Tuple{})
    @ ModelingToolkit C:\Users\TCY\.julia\packages\ModelingToolkit\klLLV\src\systems\model_parsing.jl:25
 [10] top-level scope
    @ C:\Users\TCY\.julia\packages\ModelingToolkit\klLLV\src\systems\abstractsystem.jl:2060

[wang890]

I added some println for the debugging.

function parse_variable_arg(dict, mod, arg, varclass, kwargs, where_types)
    vv, def, metadata_with_exprs = parse_variable_def!(
        dict, mod, arg, varclass, kwargs, where_types)
    if !(vv isa Tuple)
        name = getname(vv)
        # if haskey(metadata_with_exprs, VariableUnit) # cancel the unit, added by wang890
        #     delete!(metadata_with_exprs, VariableUnit)
        # end
        varexpr = if haskey(metadata_with_exprs, VariableUnit)
            println(metadata_with_exprs) # for the debugging, added by wang890
            unit = metadata_with_exprs[VariableUnit]
            quote
                $name = if $name === $NO_VALUE
                    $setdefault($vv, $def)
                else
                    try
                        println($vv)   # for debugging, added by wang890
                        println($unit) 
                        println($name) # for debugging, added by wang890 
                        $setdefault($vv, $convert_units($unit, $name))

[wang890]

@AayushSabharwal
The error may come from the convert_units function in model_parsing.jl
println(metadata_with_exprs) , the element in the print like:

Dict{DataType, Expr}(ModelingToolkit.VariableUnit => :(u"ohm"))
Dict{DataType, Expr}(ModelingToolkit.VariableUnit => :(u("Resistance")))
# `u()` is my function, it returns u"ohm"

println($vv)   # for debugging, added by wang890
println($unit) 
println($name) # for debugging, added by wang890
# the prints were following:

R
1.0 m² kg s⁻³ A⁻² # SI unit of ohm
1.0

I added some println for the debugging.

    varexpr = if haskey(metadata_with_exprs, VariableUnit)
        println(metadata_with_exprs) # for the debugging, added by wang890
       ... ...
            else
                try
                    println($vv)   # for debugging, added by wang890
                    println($unit) 
                    println($name) # for debugging, added by wang890 
                    $setdefault($vv, $convert_units($unit, $name))

[wang890]

To avoid the unit errors #3248 (comment),
I temporarily commented out the body of the check_units function in unit_check.jl,
and canceled unit in the parse_variable_arg function in model_parsing.jl.

if haskey(metadata_with_exprs, VariableUnit)
   delete!(metadata_with_exprs, VariableUnit)
end

In the version ModelingToolkit 9.19.0, parse_variable_arg fuction as follows is right,
Of course, later versions have many new features.

function parse_variable_arg(dict, mod, arg, varclass, kwargs, where_types)
    vv, def, metadata_with_exprs = parse_variable_def!(
        dict, mod, arg, varclass, kwargs, where_types)
    name = getname(vv)

    varexpr = quote
        $name = if $name === nothing
            $setdefault($vv, $def)
        else
            $setdefault($vv, $name)
        end
    end

    metadata_expr = Expr(:block)
    for (k, v) in metadata_with_exprs
        push!(metadata_expr.args,
            :($name = $wrap($set_scalar_metadata($unwrap($name), $k, $v))))
    end

    push!(varexpr.args, metadata_expr)
    return vv isa Num ? name : :($name...), varexpr
end