Delete old component-parsing code

Author: cstjean

src/systems/model_parsing.jl

@@ -1316,164 +1316,6 @@ end
 
 ### Parsing Components:
 
-function component_args!(a, b, varexpr, kwargs; index_name = nothing)
-    # Whenever `b` is a function call, skip the first arg aka the function name.
-    # Whenever it is a kwargs list, include it.
-    start = b.head == :call ? 2 : 1
-    for i in start:lastindex(b.args)
-        arg = b.args[i]
-        arg isa LineNumberNode && continue
-        MLStyle.@match arg begin
-            x::Symbol ||
-            Expr(:kw, x) => begin
-                varname, _varname = _rename(a, x)
-                b.args[i] = Expr(:kw, x, _varname)
-                push!(varexpr.args, :((if $varname !== nothing
-                    $_varname = $varname
-                elseif @isdefined $x
-                    # Allow users to define a var in `structural_parameters` and set
-                    # that as positional arg of subcomponents; it is useful for cases
-                    # where it needs to be passed to multiple subcomponents.
-                    $_varname = $x
-                end)))
-                push!(kwargs, Expr(:kw, varname, nothing))
-                # dict[:kwargs][varname] = nothing
-            end
-            Expr(:parameters, x...) => begin
-                component_args!(a, arg, varexpr, kwargs)
-            end
-            Expr(:kw,
-                x,
-                y) => begin
-                varname, _varname = _rename(a, x)
-                b.args[i] = Expr(:kw, x, _varname)
-                if isnothing(index_name)
-                    push!(varexpr.args, :($_varname = $varname === nothing ? $y : $varname))
-                else
-                    push!(varexpr.args,
-                        :($_varname = $varname === nothing ? $y : $varname[$index_name]))
-                end
-                push!(kwargs, Expr(:kw, varname, nothing))
-                # dict[:kwargs][varname] = nothing
-            end
-            _ => error("Could not parse $arg of component $a")
-        end
-    end
-end
-
-model_name(name, range) = Symbol.(name, :_, collect(range))
-
-function _parse_components!(body, kwargs)
-    local expr
-    varexpr = Expr(:block)
-    comps = Vector{Union{Union{Expr, Symbol}, Expr}}[]
-    comp_names = []
-
-    Base.remove_linenums!(body)
-    arg = body.args[end]
-
-    MLStyle.@match arg begin
-        Expr(:(=),
-            a,
-            Expr(:comprehension, Expr(:generator, b, Expr(:(=), c, d)))) => begin
-            array_varexpr = Expr(:block)
-
-            push!(comp_names, :($a...))
-            push!(comps, [a, b.args[1], d])
-            b = deepcopy(b)
-
-            component_args!(a, b, array_varexpr, kwargs; index_name = c)
-
-            expr = _named_idxs(a, d, :($c -> $b); extra_args = array_varexpr)
-        end
-        Expr(:(=),
-            a,
-            Expr(:comprehension, Expr(:generator, b, Expr(:filter, e, Expr(:(=), c, d))))) => begin
-            error("List comprehensions with conditional statements aren't supported.")
-        end
-        Expr(:(=),
-            a,
-            Expr(:comprehension, Expr(:generator, b, Expr(:(=), c, d), e...))) => begin
-            # Note that `e` is of the form `Tuple{Expr(:(=), c, d)}`
-            error("More than one index isn't supported while building component array")
-        end
-        Expr(:block) => begin
-            # TODO: Do we need this?
-            error("Multiple `@components` block detected within a single block")
-        end
-        Expr(:(=),
-            a,
-            Expr(:for, Expr(:(=), c, d), b)) => begin
-            Base.remove_linenums!(b)
-            array_varexpr = Expr(:block)
-            push!(array_varexpr.args, b.args[1:(end - 1)]...)
-            push!(comp_names, :($a...))
-            push!(comps, [a, b.args[end].args[1], d])
-            b = deepcopy(b)
-
-            component_args!(a, b.args[end], array_varexpr, kwargs; index_name = c)
-
-            expr = _named_idxs(a, d, :($c -> $(b.args[end])); extra_args = array_varexpr)
-        end
-        Expr(:(=), a, b) => begin
-            arg = deepcopy(arg)
-            b = deepcopy(arg.args[2])
-
-            component_args!(a, b, varexpr, kwargs)
-
-            arg.args[2] = b
-            expr = :(@named $arg)
-            push!(comp_names, a)
-            if (isa(b.args[1], Symbol) || Meta.isexpr(b.args[1], :.))
-                push!(comps, [a, b.args[1]])
-            end
-        end
-        _ => error("Couldn't parse the component body: $arg")
-    end
-
-    return comp_names, comps, expr, varexpr
-end
-
-function push_conditional_component!(ifexpr, expr_vec, comp_names, varexpr)
-    blk = Expr(:block)
-    push!(blk.args, varexpr)
-    push!(blk.args, expr_vec)
-    push!(blk.args, :($push!(systems, $(comp_names...))))
-    push!(ifexpr.args, blk)
-end
-
-function handle_if_x!(mod, exprs, ifexpr, x, kwargs, condition = nothing)
-    push!(ifexpr.args, condition)
-    comp_names, comps, expr_vec, varexpr = _parse_components!(x, kwargs)
-    push_conditional_component!(ifexpr, expr_vec, comp_names, varexpr)
-    comps
-end
-
-function handle_if_y!(exprs, ifexpr, y, kwargs)
-    Base.remove_linenums!(y)
-    if Meta.isexpr(y, :elseif)
-        comps = [:elseif, y.args[1]]
-        elseifexpr = Expr(:elseif)
-        push!(comps, handle_if_x!(mod, exprs, elseifexpr, y.args[2], kwargs, y.args[1]))
-        get(y.args, 3, nothing) !== nothing &&
-            push!(comps, handle_if_y!(exprs, elseifexpr, y.args[3], kwargs))
-        push!(ifexpr.args, elseifexpr)
-        (comps...,)
-    else
-        comp_names, comps, expr_vec, varexpr = _parse_components!(y, kwargs)
-        push_conditional_component!(ifexpr, expr_vec, comp_names, varexpr)
-        comps
-    end
-end
-
-function handle_conditional_components(condition, dict, exprs, kwargs, x, y = nothing)
-    ifexpr = Expr(:if)
-    comps = handle_if_x!(mod, exprs, ifexpr, x, kwargs, condition)
-    ycomps = y === nothing ? [] : handle_if_y!(exprs, ifexpr, y, kwargs)
-    push!(exprs, ifexpr)
-    push!(dict[:components], (:if, condition, comps, ycomps))
-end
-
 """ `push!`, or `append!`, depending on `x`'s type """
 push_append!(vec, x::AbstractVector) = append!(vec, x)
 push_append!(vec, x) = push!(vec, x)