insert_instruction -> insert_instruction_here

Not to confuse it with the nonlocal insertion

Author: serenity4

src/analysis/flattening.jl

@@ -18,7 +18,7 @@ function _flatten_parameter!(𝕃, compact, argtypes, ntharg, line, settings)
                 continue
             end
             this = ntharg(argn)
-            nthfield(i) = @insert_instruction compact line settings getfield(this, i)::Compiler.getfield_tfunc(𝕃, argextype(this, compact), Const(i))
+            nthfield(i) = @insert_instruction_here compact line settings getfield(this, i)::Compiler.getfield_tfunc(𝕃, argextype(this, compact), Const(i))
             if isa(argt, PartialStruct)
                 fields = _flatten_parameter!(𝕃, compact, argt.fields, nthfield, line, settings)
             else
@@ -31,7 +31,7 @@ function _flatten_parameter!(𝕃, compact, argtypes, ntharg, line, settings)
 end
 
 function flatten_parameter!(𝕃, compact, argtypes, ntharg, line, settings)
-    return @insert_instruction compact line settings tuple(_flatten_parameter!(𝕃, compact, argtypes, ntharg, line, settings)...)::Tuple
+    return @insert_instruction_here compact line settings tuple(_flatten_parameter!(𝕃, compact, argtypes, ntharg, line, settings)...)::Tuple
 end
 
 # Needs to match flatten_arguments!
@@ -85,23 +85,23 @@ function flatten_argument!(compact::Compiler.IncrementalCompact, settings::Setti
         return TransformedArg(Argument(offset+1), offset+1, eqoffset)
     elseif argt === equation
         line = compact[Compiler.OldSSAValue(1)][:line]
-        ssa = @insert_instruction compact line settings (:invoke)(nothing, InternalIntrinsics.external_equation)::Eq(eqoffset+1)
+        ssa = @insert_instruction_here compact line settings (:invoke)(nothing, InternalIntrinsics.external_equation)::Eq(eqoffset+1)
         return TransformedArg(ssa, offset, eqoffset+1)
     elseif isabstracttype(argt) || ismutabletype(argt) || (!isa(argt, DataType) && !isa(argt, PartialStruct))
         line = compact[Compiler.OldSSAValue(1)][:line]
-        ssa = @insert_instruction compact line settings error("Cannot IPO model arg type $argt")::Union{}
+        ssa = @insert_instruction_here compact line settings error("Cannot IPO model arg type $argt")::Union{}
         return TransformedArg(ssa, -1, eqoffset)
     else
         if !isa(argt, PartialStruct) && Base.datatype_fieldcount(argt) === nothing
             line = compact[Compiler.OldSSAValue(1)][:line]
-            ssa = @insert_instruction compact line settings error("Cannot IPO model arg type $argt")::Union{}
+            ssa = @insert_instruction_here compact line settings error("Cannot IPO model arg type $argt")::Union{}
             return TransformedArg(ssa, -1, eqoffset)
         end
         (args, _, offset) = flatten_arguments!(compact, settings, isa(argt, PartialStruct) ? argt.fields : collect(Any, fieldtypes(argt)), offset, eqoffset, argtypes)
         offset == -1 && return TransformedArg(ssa, -1, eqoffset)
         this = Expr(:new, isa(argt, PartialStruct) ? argt.typ : argt, args...)
         line = compact[Compiler.OldSSAValue(1)][:line]
-        ssa = @insert_instruction compact line settings this::argt
+        ssa = @insert_instruction_here compact line settings this::argt
         return TransformedArg(ssa, offset, eqoffset)
     end
 end

src/analysis/structural.jl

@@ -362,7 +362,7 @@ function _structural_analysis!(ci::CodeInstance, world::UInt, settings::Settings
         compact.result_idx -= 1
         new_args = _flatten_parameter!(Compiler.optimizer_lattice(refiner), compact, callee_codeinst.inferred.ir.argtypes, arg->stmt.args[arg+1], line, settings)
 
-        new_call = insert_instruction!(compact, settings, @__SOURCE__,
+        new_call = insert_instruction_here!(compact, settings, @__SOURCE__,
                 NewInstruction(Expr(:invoke, (StructuralSSARef(compact.result_idx), callee_codeinst), new_args...), stmtype, info, line, stmtflags))
         compact.ssa_rename[compact.idx - 1] = new_call
 
@@ -387,7 +387,7 @@ function _structural_analysis!(ci::CodeInstance, world::UInt, settings::Settings
         Compiler.delete_inst_here!(compact)
 
         (new_ret, ultimate_rt) = rewrite_ipo_return!(Compiler.typeinf_lattice(refiner), compact, line, settings, ret_stmt.val, ultimate_rt, eqvars)
-        insert_instruction!(compact, settings, @__SOURCE__, NewInstruction(ReturnNode(new_ret), ultimate_rt, Compiler.NoCallInfo(), line, Compiler.IR_FLAG_REFINED), reverse_affinity = true)
+        insert_instruction_here!(compact, settings, @__SOURCE__, NewInstruction(ReturnNode(new_ret), ultimate_rt, Compiler.NoCallInfo(), line, Compiler.IR_FLAG_REFINED), reverse_affinity = true)
     elseif isa(ultimate_rt, Type)
         # If we don't have any internal variables (in which case we might have to to do a more aggressive rewrite), strengthen the incidence
         # by demoting to full incidence over the argument variables. Incidence is not allowed to propagate through global mutable state, so
@@ -425,7 +425,7 @@ function rewrite_ipo_return!(𝕃, compact::IncrementalCompact, line, settings,
         new_types = Any[]
         for i = 1:length(ultimate_rt.fields)
             ssa_type = Compiler.getfield_tfunc(𝕃, ultimate_rt, Const(i))
-            ssa_field = insert_instruction!(compact, settings, @__SOURCE__,
+            ssa_field = insert_instruction_here!(compact, settings, @__SOURCE__,
                 NewInstruction(Expr(:call, getfield, variable), ssa_type, Compiler.NoCallInfo(), line, Compiler.IR_FLAG_REFINED), reverse_affinity = true)
 
             (new_field, new_type) = rewrite_ipo_return!(𝕃, compact, line, settings, ssa_field, ssa_type, eqvars)
@@ -434,13 +434,13 @@ function rewrite_ipo_return!(𝕃, compact::IncrementalCompact, line, settings,
         end
         newT = Compiler.PartialStruct(ultimate_rt.typ, new_types)
         if widenconst(ultimate_rt) <: Tuple
-            retssa = insert_instruction!(compact, settings, @__SOURCE__,
+            retssa = insert_instruction_here!(compact, settings, @__SOURCE__,
                 NewInstruction(Expr(:call, tuple, new_fields...), newT, Compiler.NoCallInfo(), line, Compiler.IR_FLAG_REFINED), reverse_affinity = true)
         else
-            T = insert_instruction!(compact, settings, @__SOURCE__,
+            T = insert_instruction_here!(compact, settings, @__SOURCE__,
                 NewInstruction(Expr(:call, typeof, ssa), Type, Compiler.NoCallInfo(), line, Compiler.IR_FLAG_REFINED), reverse_affinity = true)
 
-            retssa = insert_instruction!(compact, settings, @__SOURCE__,
+            retssa = insert_instruction_here!(compact, settings, @__SOURCE__,
                 NewInstruction(Expr(:new, T, new_fields...), newT, Compiler.NoCallInfo(), line, Compiler.IR_FLAG_REFINED), reverse_affinity = true)
         end
         return Pair{Any, Any}(retssa, newT)
@@ -454,7 +454,7 @@ function rewrite_ipo_return!(𝕃, compact::IncrementalCompact, line, settings,
     push!(eqvars.varclassification, External)
     push!(eqvars.varkinds, Intrinsics.Continuous)
 
-    new_var_ssa = insert_instruction!(compact, settings,
+    new_var_ssa = insert_instruction_here!(compact, settings,
         NewInstruction(Expr(:invoke, nothing, variable), Incidence(nonlinrepl), Compiler.NoCallInfo(), line, Compiler.IR_FLAG_REFINED), true)
 
     eq_incidence = ultimate_rt - Incidence(nonlinrepl)
@@ -464,13 +464,13 @@ function rewrite_ipo_return!(𝕃, compact::IncrementalCompact, line, settings,
     push!(eqvars.eqkinds, Intrinsics.Always)
     new_eq = length(eqvars.total_incidence)
 
-    new_eq_ssa = insert_instruction!(compact, settings, @__SOURCE__,
+    new_eq_ssa = insert_instruction_here!(compact, settings, @__SOURCE__,
         NewInstruction(Expr(:invoke, nothing, equation), Eq(new_eq), Compiler.NoCallInfo(), LINE, Compiler.IR_FLAG_REFINED), true)
 
-    eq_val_ssa = insert_instruction!(compact, settings, @__SOURCE__,
+    eq_val_ssa = insert_instruction_here!(compact, settings, @__SOURCE__,
         NewInstruction(Expr(:call, InternalIntrinsics.assign_var, new_var_ssa, ssa), eq_incidence, Compiler.NoCallInfo(), LINE, Compiler.IR_FLAG_REFINED), true)
 
-    eq_call_ssa = insert_instruction!(compact, settings, @__SOURCE__,
+    eq_call_ssa = insert_instruction_here!(compact, settings, @__SOURCE__,
         NewInstruction(Expr(:invoke, nothing, new_eq_ssa, eq_val_ssa), Nothing, Compiler.NoCallInfo(), LINE, Compiler.IR_FLAG_REFINED), true)
 
     T = widenconst(ultimate_rt)

src/transform/codegen/dae_factory.jl

@@ -8,9 +8,9 @@ function sciml_dae_split_u!(compact, line, settings, arg, numstates)
     nassgn = numstates[AssignedDiff]
     ntotalstates = numstates[AssignedDiff] + numstates[UnassignedDiff] + numstates[Algebraic]
 
-    u_mm = @insert_instruction compact line settings view(arg, 1:nassgn)::VectorViewType
-    u_unassgn = @insert_instruction compact line settings view(arg, (nassgn+1):(nassgn+numstates[UnassignedDiff]))::VectorViewType
-    alg = @insert_instruction compact line settings view(arg, (nassgn+numstates[UnassignedDiff]+1):ntotalstates)::VectorViewType
+    u_mm = @insert_instruction_here compact line settings view(arg, 1:nassgn)::VectorViewType
+    u_unassgn = @insert_instruction_here compact line settings view(arg, (nassgn+1):(nassgn+numstates[UnassignedDiff]))::VectorViewType
+    alg = @insert_instruction_here compact line settings view(arg, (nassgn+numstates[UnassignedDiff]+1):ntotalstates)::VectorViewType
 
     return (u_mm, u_unassgn, alg)
 end
@@ -25,8 +25,8 @@ function sciml_dae_split_du!(compact, line, settings, arg, numstates)
     nassgn = numstates[AssignedDiff]
     ntotalstates = numstates[AssignedDiff] + numstates[UnassignedDiff] + numstates[Algebraic]
 
-    in_du_assgn = @insert_instruction compact line settings view(arg, 1:nassgn)::VectorViewType
-    in_du_unassgn = @insert_instruction compact line settings view(arg, (nassgn+1):(nassgn+numstates[UnassignedDiff]))::VectorViewType
+    in_du_assgn = @insert_instruction_here compact line settings view(arg, 1:nassgn)::VectorViewType
+    in_du_unassgn = @insert_instruction_here compact line settings view(arg, (nassgn+1):(nassgn+numstates[UnassignedDiff]))::VectorViewType
 
     return (in_du_assgn, in_du_unassgn)
 end
@@ -74,7 +74,7 @@ function dae_factory_gen(state::TransformationState, ci::CodeInstance, key::Torn
 
         line = result.ir[SSAValue(1)][:line]
         param_list = flatten_parameter!(Compiler.fallback_lattice, compact, ci.inferred.ir.argtypes[1:end], argn->Argument(2+argn), line, settings)
-        sicm = @insert_instruction compact line settings invoke(param_list, sicm_ci)::Tuple
+        sicm = @insert_instruction_here compact line settings invoke(param_list, sicm_ci)::Tuple
     else
         sicm = ()
     end
@@ -110,22 +110,22 @@ function dae_factory_gen(state::TransformationState, ci::CodeInstance, key::Torn
 
     # Zero the output
     line = ir_oc[SSAValue(1)][:line]
-    @insert_instruction oc_compact line settings zero!(Argument(2))::VectorViewType
+    @insert_instruction_here oc_compact line settings zero!(Argument(2))::VectorViewType
 
     # out_du_mm, out_eq, in_u_mm, in_u_unassgn, in_du_unassgn, in_alg
     nassgn = numstates[AssignedDiff]
     ntotalstates = numstates[AssignedDiff] + numstates[UnassignedDiff] + numstates[Algebraic]
-    out_du_mm = @insert_instruction oc_compact line settings view(Argument(2), 1:nassgn)::VectorViewType
-    out_eq = @insert_instruction oc_compact line settings view(Argument(2), (nassgn+1):ntotalstates)::VectorViewType
+    out_du_mm = @insert_instruction_here oc_compact line settings view(Argument(2), 1:nassgn)::VectorViewType
+    out_eq = @insert_instruction_here oc_compact line settings view(Argument(2), (nassgn+1):ntotalstates)::VectorViewType
 
     (in_du_assgn, in_du_unassgn) = sciml_dae_split_du!(oc_compact, line, settings, Argument(3), numstates)
     (in_u_mm, in_u_unassgn, in_alg) = sciml_dae_split_u!(oc_compact, line, settings, Argument(4), numstates)
 
     # Call DAECompiler-generated RHS with internal ABI
-    oc_sicm = @insert_instruction oc_compact line settings getfield(Argument(1), 1)::Core.OpaqueClosure
+    oc_sicm = @insert_instruction_here oc_compact line settings getfield(Argument(1), 1)::Core.OpaqueClosure
 
     # N.B: The ordering of arguments should match the ordering in the StateKind enum
-    @insert_instruction oc_compact line settings (:invoke)(daef_ci, oc_sicm, (), in_u_mm, in_u_unassgn, in_du_unassgn, in_alg, out_du_mm, out_eq, Argument(6))::Nothing
+    @insert_instruction_here oc_compact line settings (:invoke)(daef_ci, oc_sicm, (), in_u_mm, in_u_unassgn, in_du_unassgn, in_alg, out_du_mm, out_eq, Argument(6))::Nothing
 
     # TODO: We should not have to recompute this here
     var_eq_matching = matching_for_key(state, key)
@@ -146,15 +146,15 @@ function dae_factory_gen(state::TransformationState, ci::CodeInstance, key::Torn
         @assert kind == AssignedDiff
         @assert dkind in (AssignedDiff, UnassignedDiff)
 
-        v_val = @insert_instruction oc_compact line settings getindex(dkind == AssignedDiff ? in_u_mm : in_u_unassgn, dslot)::Any
-        @insert_instruction oc_compact line settings setindex!(out_du_mm, v_val, slot)::Any
+        v_val = @insert_instruction_here oc_compact line settings getindex(dkind == AssignedDiff ? in_u_mm : in_u_unassgn, dslot)::Any
+        @insert_instruction_here oc_compact line settings setindex!(out_du_mm, v_val, slot)::Any
     end
 
-    bc = @insert_instruction oc_compact line settings Base.Broadcast.broadcasted(-, out_du_mm, in_du_assgn)::Any
-    @insert_instruction oc_compact line settings Base.Broadcast.materialize!(out_du_mm, bc)::Nothing
+    bc = @insert_instruction_here oc_compact line settings Base.Broadcast.broadcasted(-, out_du_mm, in_du_assgn)::Any
+    @insert_instruction_here oc_compact line settings Base.Broadcast.materialize!(out_du_mm, bc)::Nothing
 
     # Return
-    @insert_instruction oc_compact line settings (return nothing)::Union{}
+    @insert_instruction_here oc_compact line settings (return nothing)::Union{}
 
     ir_oc = Compiler.finish(oc_compact)
     maybe_rewrite_debuginfo!(ir_oc, settings)
@@ -171,21 +171,21 @@ function dae_factory_gen(state::TransformationState, ci::CodeInstance, key::Torn
     @atomic oc_ci.max_world = @atomic ci.max_world
     @atomic oc_ci.min_world = 1 # @atomic ci.min_world
 
-    new_oc = @insert_instruction compact line settings (:new_opaque_closure)(argt, Union{}, Nothing, true, oc_source_method, sicm)::Core.OpaqueClosure true
+    new_oc = @insert_instruction_here compact line settings (:new_opaque_closure)(argt, Union{}, Nothing, true, oc_source_method, sicm)::Core.OpaqueClosure true
 
     differential_states = Bool[v in key.diff_states for v in all_states]
 
     if init_key !== nothing
         initf = init_uncompress_gen!(compact, result, ci, init_key, key, world, settings)
-        daef = @insert_instruction compact line settings make_daefunction(new_oc, initf)::DAEFunction true
+        daef = @insert_instruction_here compact line settings make_daefunction(new_oc, initf)::DAEFunction true
     else
-        daef = @insert_instruction compact line settings make_daefunction(new_oc)::DAEFunction true
+        daef = @insert_instruction_here compact line settings make_daefunction(new_oc)::DAEFunction true
     end
 
     # TODO: Ideally, this'd be in DAEFunction
-    daef_and_diff = @insert_instruction compact line settings tuple(daef, differential_states)::Tuple true
+    daef_and_diff = @insert_instruction_here compact line settings tuple(daef, differential_states)::Tuple true
 
-    @insert_instruction compact line settings (return daef_and_diff)::Tuple true
+    @insert_instruction_here compact line settings (return daef_and_diff)::Tuple true
 
     ir_factory = Compiler.finish(compact)
     resize!(ir_factory.cfg.blocks, 1)

src/transform/codegen/init_factory.jl

@@ -7,7 +7,7 @@ function init_uncompress_gen(result::DAEIPOResult, ci::CodeInstance, init_key::T
 
     new_oc = init_uncompress_gen!(compact, result, ci, init_key, diff_key, world, settings)
     line = result.ir[SSAValue(1)][:line]
-    @insert_instruction compact line settings (return new_oc)::Core.OpaqueClosure true
+    @insert_instruction_here compact line settings (return new_oc)::Core.OpaqueClosure true
 
     ir_factory = Compiler.finish(compact)
     Compiler.verify_ir(ir_factory)
@@ -28,7 +28,7 @@ function init_uncompress_gen!(compact::Compiler.IncrementalCompact, result::DAEI
 
         line = result.ir[SSAValue(1)][:line]
         param_list = flatten_parameter!(Compiler.fallback_lattice, compact, ci.inferred.ir.argtypes[1:end], argn->Argument(2+argn), line, settings)
-        sicm = @insert_instruction compact line settings invoke(param_list, sicm_ci)::Tuple
+        sicm = @insert_instruction_here compact line settings invoke(param_list, sicm_ci)::Tuple
     else
         sicm = ()
     end
@@ -61,13 +61,13 @@ function init_uncompress_gen!(compact::Compiler.IncrementalCompact, result::DAEI
 
     # Zero the output
     nout = numstates[UnassignedDiff] + numstates[AssignedDiff]
-    out_arr = @insert_instruction oc_compact line settings zeros(nout)::Vector{Float64}
+    out_arr = @insert_instruction_here oc_compact line settings zeros(nout)::Vector{Float64}
 
     nscratch = numstates[Algebraic] + numstates[AlgebraicDerivative]
-    scratch_arr = @insert_instruction oc_compact line settings zeros(nout)::Vector{Float64}
+    scratch_arr = @insert_instruction_here oc_compact line settings zeros(nout)::Vector{Float64}
 
     # Get the solution vector out of the solution object
-    in_nlsol_u = @insert_instruction oc_compact line settings getproperty(Argument(2), QuoteNode(:u0))::Vector{Float64}
+    in_nlsol_u = @insert_instruction_here oc_compact line settings getproperty(Argument(2), QuoteNode(:u0))::Vector{Float64}
 
     # Adapt to DAECompiler ABI
     nassgn = numstates[AssignedDiff]
@@ -77,11 +77,11 @@ function init_uncompress_gen!(compact::Compiler.IncrementalCompact, result::DAEI
     (out_du_unassgn, _) = sciml_dae_split_du!(oc_compact, line, settings, scratch_arr, numstates)
 
     # Call DAECompiler-generated RHS with internal ABI
-    oc_sicm = @insert_instruction oc_compact line settings getfield(Argument(1), 1)::Core.OpaqueClosure
-    @insert_instruction oc_compact line settings (:invoke)(daef_ci, oc_sicm, (), out_u_mm, out_u_unassgn, out_du_unassgn, out_alg, in_nlsol_u, 0.0)::Nothing
+    oc_sicm = @insert_instruction_here oc_compact line settings getfield(Argument(1), 1)::Core.OpaqueClosure
+    @insert_instruction_here oc_compact line settings (:invoke)(daef_ci, oc_sicm, (), out_u_mm, out_u_unassgn, out_du_unassgn, out_alg, in_nlsol_u, 0.0)::Nothing
 
     # Return
-    @insert_instruction oc_compact line settings (return out_arr)::Vector{Float64}
+    @insert_instruction_here oc_compact line settings (return out_arr)::Vector{Float64}
 
     ir_oc = Compiler.finish(oc_compact)
     oc = Core.OpaqueClosure(ir_oc)
@@ -94,7 +94,7 @@ function init_uncompress_gen!(compact::Compiler.IncrementalCompact, result::DAEI
     @atomic oc_ci.max_world = @atomic ci.max_world
     @atomic oc_ci.min_world = 1 # @atomic ci.min_world
 
-    new_oc = @insert_instruction compact line settings (:new_opaque_closure)(
+    new_oc = @insert_instruction_here compact line settings (:new_opaque_closure)(
         argt, Vector{Float64}, Vector{Float64}, true, oc_source_method, sicm)::Core.OpaqueClosure true
 
     return new_oc