Fix missing UnitfulUnitCheck module by recreating it in extension

The UnitfulUnitCheck module was completely deleted from validation.jl but
needs to be available for backward compatibility when Unitful is loaded.
This commit:
- Adds the UnitfulUnitCheck module to the ModelingToolkitUnitfulExt extension
- Keeps validation.jl as an empty placeholder file for backward compatibility
- Ensures all Unitful-specific unit checking functions are available via the module

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <[email protected]>

Author: ChrisRackauckas

ext/ModelingToolkitUnitfulExt.jl

@@ -78,4 +78,140 @@ const D_unitful = MT.Differential(t_unitful)
 
 # Extension loaded - all Unitful-specific functionality is now available
 
-end # module
+end # module
+
+# Create the UnitfulUnitCheck module inside ModelingToolkit for backward compatibility
+@eval ModelingToolkit module UnitfulUnitCheck
+
+using ModelingToolkit, Symbolics, SciMLBase, Unitful, RecursiveArrayTools
+using ModelingToolkit: ValidationError, Connection, instream, JumpType, VariableUnit,
+                         get_systems, Conditional, Comparison, Integral, Differential
+using JumpProcesses: MassActionJump, ConstantRateJump, VariableRateJump
+using Symbolics: Symbolic, value, issym, isadd, ismul, ispow, iscall, operation, arguments, getmetadata
+
+const MT = ModelingToolkit
+
+Base.:*(x::Union{MT.Num, Symbolic}, y::Unitful.AbstractQuantity) = x * y
+Base.:/(x::Union{MT.Num, Symbolic}, y::Unitful.AbstractQuantity) = x / y
+
+"""
+Throw exception on invalid unit types, otherwise return argument.
+"""
+function screen_unit(result)
+    result isa Unitful.Unitlike ||
+        throw(ValidationError("Unit must be a subtype of Unitful.Unitlike, not $(typeof(result))."))
+    result isa Unitful.ScalarUnits ||
+        throw(ValidationError("Non-scalar units such as $result are not supported. Use a scalar unit instead."))
+    result == Unitful.u"°" &&
+        throw(ValidationError("Degrees are not supported. Use radians instead."))
+    result
+end
+
+"""
+Test unit equivalence.
+"""
+equivalent(x, y) = isequal(1 * x, 1 * y)
+const unitless = Unitful.unit(1)
+
+"""
+Find the unit of a symbolic item.
+"""
+get_unit(x::Real) = unitless
+get_unit(x::Unitful.Quantity) = screen_unit(Unitful.unit(x))
+get_unit(x::AbstractArray) = map(get_unit, x)
+get_unit(x::MT.Num) = get_unit(value(x))
+function get_unit(x::Union{Symbolics.ArrayOp, Symbolics.Arr, Symbolics.CallWithMetadata})
+    get_literal_unit(x)
+end
+get_unit(op::Differential, args) = get_unit(args[1]) / get_unit(op.x)
+get_unit(op::typeof(getindex), args) = get_unit(args[1])
+get_unit(x::SciMLBase.NullParameters) = unitless
+get_unit(op::typeof(instream), args) = get_unit(args[1])
+
+get_literal_unit(x) = screen_unit(getmetadata(x, VariableUnit, unitless))
+
+function get_unit(op, args) # Fallback
+    result = op(1 .* get_unit.(args)...)
+    try
+        Unitful.unit(result)
+    catch
+        throw(ValidationError("Unable to get unit for operation $op with arguments $args."))
+    end
+end
+
+function get_unit(op::Integral, args)
+    unit = 1
+    if op.domain.variables isa Vector
+        for u in op.domain.variables
+            unit *= get_unit(u)
+        end
+    else
+        unit *= get_unit(op.domain.variables)
+    end
+    return get_unit(args[1]) * unit
+end
+
+function get_unit(op::Conditional, args)
+    terms = get_unit.(args)
+    terms[1] == unitless ||
+        throw(ValidationError(", in $op, [$(terms[1])] is not dimensionless."))
+    equivalent(terms[2], terms[3]) ||
+        throw(ValidationError(", in $op, units [$(terms[2])] and [$(terms[3])] do not match."))
+    return terms[2]
+end
+
+function get_unit(op::typeof(Symbolics._mapreduce), args)
+    if args[2] == +
+        get_unit(args[3])
+    else
+        throw(ValidationError("Unsupported array operation $op"))
+    end
+end
+
+function get_unit(op::Comparison, args)
+    terms = get_unit.(args)
+    equivalent(terms[1], terms[2]) ||
+        throw(ValidationError(", in comparison $op, units [$(terms[1])] and [$(terms[2])] do not match."))
+    return unitless
+end
+
+function get_unit(x::Symbolic)
+    if issym(x)
+        get_literal_unit(x)
+    elseif isadd(x)
+        terms = get_unit.(arguments(x))
+        firstunit = terms[1]
+        for other in terms[2:end]
+            termlist = join(map(repr, terms), ", ")
+            equivalent(other, firstunit) ||
+                throw(ValidationError(", in sum $x, units [$termlist] do not match."))
+        end
+        return firstunit
+    elseif ispow(x)
+        pargs = arguments(x)
+        base, expon = get_unit.(pargs)
+        @assert expon isa Unitful.DimensionlessUnits
+        if base == unitless
+            unitless
+        else
+            pargs[2] isa Number ? base^pargs[2] : (1 * base)^pargs[2]
+        end
+    elseif iscall(x)
+        op = operation(x)
+        if issym(op) || (iscall(op) && iscall(operation(op))) # Dependent variables, not function calls
+            return screen_unit(getmetadata(x, VariableUnit, unitless)) # Like x(t) or x[i]
+        elseif iscall(op) && !iscall(operation(op))
+            gp = getmetadata(x, Symbolics.GetindexParent, nothing) # Like x[1](t)
+            return screen_unit(getmetadata(gp, VariableUnit, unitless))
+        end  # Actual function calls:
+        args = arguments(x)
+        return get_unit(op, args)
+    else # This function should only be reached by Terms, for which `iscall` is true
+        throw(ArgumentError("Unsupported value $x."))
+    end
+end
+
+# Re-use validation functions from main package
+using ModelingToolkit: safe_get_unit, _validate, validate
+
+end # module UnitfulUnitCheck

src/systems/validation.jl

@@ -0,0 +1,3 @@
+# This file is kept for backward compatibility
+# The UnitfulUnitCheck module is now provided by the ModelingToolkitUnitfulExt extension
+# when Unitful is loaded