Minor optimization

Author: YingboMa

src/systems/abstractsystem.jl

@@ -389,25 +389,27 @@ function renamespace(sys, x)
     sys === nothing && return x
     x = unwrap(x)
     if x isa Symbolic
+        T = typeof(x)
         if istree(x) && operation(x) isa Operator
-            return similarterm(x, operation(x), Any[renamespace(sys, only(arguments(x)))])
+            return similarterm(x, operation(x),
+                               Any[renamespace(sys, only(arguments(x)))])::T
         end
         let scope = getmetadata(x, SymScope, LocalScope())
             if scope isa LocalScope
-                rename(x, renamespace(getname(sys), getname(x)))
+                rename(x, renamespace(getname(sys), getname(x)))::T
             elseif scope isa ParentScope
-                setmetadata(x, SymScope, scope.parent)
+                setmetadata(x, SymScope, scope.parent)::T
             elseif scope isa DelayParentScope
                 if scope.N > 0
                     x = setmetadata(x, SymScope,
                                     DelayParentScope(scope.parent, scope.N - 1))
-                    rename(x, renamespace(getname(sys), getname(x)))
+                    rename(x, renamespace(getname(sys), getname(x)))::T
                 else
                     #rename(x, renamespace(getname(sys), getname(x)))
-                    setmetadata(x, SymScope, scope.parent)
+                    setmetadata(x, SymScope, scope.parent)::T
                 end
             else # GlobalScope
-                x
+                x::T
             end
         end
     elseif x isa AbstractSystem
@@ -423,9 +425,8 @@ namespace_controls(sys::AbstractSystem) = controls(sys, controls(sys))
 
 function namespace_defaults(sys)
     defs = defaults(sys)
-    Dict((isparameter(k) ? parameters(sys, k) : states(sys, k)) => namespace_expr(defs[k],
-                                                                                  sys)
-         for k in keys(defs))
+    Dict((isparameter(k) ? parameters(sys, k) : states(sys, k)) => namespace_expr(v, sys)
+         for (k, v) in pairs(defs))
 end
 
 function namespace_equations(sys::AbstractSystem)
@@ -454,14 +455,19 @@ function namespace_expr(O, sys, n = nameof(sys))
     elseif isvariable(O)
         renamespace(n, O)
     elseif istree(O)
-        renamed = map(a -> namespace_expr(a, sys, n), arguments(O))
+        T = typeof(O)
         if symtype(operation(O)) <: FnType
-            renamespace(n, O)
+            renamespace(n, O)::T
         else
-            similarterm(O, operation(O), renamed)
+            renamed = let sys = sys, n = n, T = T
+                map(a -> namespace_expr(a, sys, n)::Any, arguments(O))
+            end
+            similarterm(O, operation(O), renamed)::T
         end
     elseif O isa Array
-        map(o -> namespace_expr(o, sys, n), O)
+        let sys = sys, n = n
+            map(o -> namespace_expr(o, sys, n), O)
+        end
     else
         O
     end

src/systems/validation.jl

@@ -40,7 +40,9 @@ 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::Num) = get_unit(value(x))
-get_unit(x::Union{Symbolics.ArrayOp, Symbolics.Arr, Symbolics.CallWithMetadata}) = get_literal_unit(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::Difference, args) = get_unit(args[1]) / get_unit(op.t)
 get_unit(op::typeof(getindex), args) = get_unit(args[1])

src/utils.jl

@@ -343,12 +343,13 @@ iv_from_nested_difference(x) = nothing
 
 var_from_nested_difference(x, i = 0) = (nothing, nothing)
 function var_from_nested_difference(x::Symbolic, i = 0)
-    istree(x) && operation(x) isa Difference ? var_from_nested_difference(arguments(x)[1], i + 1) :
+    istree(x) && operation(x) isa Difference ?
+    var_from_nested_difference(arguments(x)[1], i + 1) :
     (x, i)
 end
 
-isvariable(x::Num) = isvariable(value(x))
-function isvariable(x)
+isvariable(x::Num)::Bool = isvariable(value(x))
+function isvariable(x)::Bool
     x isa Symbolic || return false
     p = getparent(x, nothing)
     p === nothing || (x = p)
@@ -369,7 +370,9 @@ v  = ModelingToolkit.vars(D(y) ~ u)
 v == Set([D(y), u])
 ```
 """
-vars(exprs::Symbolic; op = Differential) = istree(exprs) ? vars([exprs]; op = op) : Set([exprs])
+function vars(exprs::Symbolic; op = Differential)
+    istree(exprs) ? vars([exprs]; op = op) : Set([exprs])
+end
 vars(exprs; op = Differential) = foldl((x, y) -> vars!(x, y; op = op), exprs; init = Set())
 vars(eq::Equation; op = Differential) = vars!(Set(), eq; op = op)
 function vars!(vars, eq::Equation; op = Differential)