interpret structs correctly

src/TypeProfiler.jl

@@ -51,7 +51,7 @@ import LoweredCodeUtils:
     istypedef, ismethod
 
 import JuliaInterpreter:
-    evaluate_call_recurse!, bypass_builtins, maybe_evaluate_builtin, collect_args
+    evaluate_call_recurse!, bypass_builtins, maybe_evaluate_builtin, collect_args, is_return
 
 using FileWatching, Requires
 

src/abstractinterpretation.jl

@@ -339,6 +339,12 @@ function abstract_eval_value(interp::TPInterpreter, @nospecialize(e), vtypes::Va
 end
 
 function abstract_eval_statement(interp::TPInterpreter, @nospecialize(e), vtypes::VarTable, sv::InferenceState)
+    if istoplevel(sv)
+        if interp.not_abstracted[get_cur_pc(sv)]
+            return Any # bail out if it has been interpreted
+        end
+    end
+
     ret = @invoke abstract_eval_statement(interp::AbstractInterpreter, e, vtypes::VarTable, sv::InferenceState)
 
     # assign virtual global variable
@@ -371,7 +377,7 @@ function set_virtual_globalvar!(interp, mod, name, @nospecialize(t))
             update = true
             val.t, val.id, (val.edge_sym, val.li)
         else
-            @warn "TypeProfiler.jl can't trace updates of global variable that already have values"
+            @warn "TypeProfiler.jl can't trace updates of global variable that already have values" mod name val
             return
         end
     else

src/abstractinterpreterinterface.jl

@@ -23,6 +23,9 @@ struct TPInterpreter <: AbstractInterpreter
     # disables caching of native remarks (that may vastly speed up profiling time)
     filter_native_remarks::Bool
 
+    # toplevel profiling (skip inference on actually interpreted statements)
+    not_abstracted::BitVector
+
     function TPInterpreter(world                   = get_world_counter();
                            inf_params              = gen_inf_params(),
                            opt_params              = gen_opt_params(),
@@ -33,6 +36,7 @@ struct TPInterpreter <: AbstractInterpreter
                            reports                 = [],
                            exception_reports       = [],
                            filter_native_remarks   = true,
+                           not_abstracted          = [],
                            )
         @assert !opt_params.inlining "inlining should be disabled"
 
@@ -45,6 +49,7 @@ struct TPInterpreter <: AbstractInterpreter
                    reports,
                    exception_reports,
                    filter_native_remarks,
+                   not_abstracted,
                    )
     end
 end

src/virtualprocess.jl

@@ -215,7 +215,8 @@ function virtual_process!(toplevelex::Expr,
         not_abstracted = partial_interpret!(interp′, virtualmod, src)
 
         # TODO: construct partial `CodeInfo` from remaining abstract statements ?
-        all(not_abstracted) && continue # bail out if nothing to profile (just a performance optimization)
+        # bail out if nothing to profile (just a performance optimization)
+        all(is_return(last(src.code)) ? not_abstracted[begin:end-1] : not_abstracted) && continue
 
         interp = TPInterpreter(; # world age gets updated to take in newly added methods defined by `ActualInterpreter`
                                inf_params            = InferenceParams(interp),
@@ -224,6 +225,7 @@ function virtual_process!(toplevelex::Expr,
                                compress              = may_compress(interp),
                                discard_trees         = may_discard_trees(interp),
                                filter_native_remarks = interp.filter_native_remarks,
+                               not_abstracted        = not_abstracted,
                                )
 
         profile_toplevel!(interp, virtualmod, src)
@@ -257,14 +259,36 @@ end
 # select statements that should be not abstracted away, but rather actually interpreted
 function select_statements(src)
     stmts = src.code
+
     not_abstracted = map(stmts) do stmt
-        istypedef(stmt) && return true
-        ismethod(stmt) && return true
+        # special case `include` calls
         isinclude(stmt) && return true
+
+        # interpret method definitions
+        ismethod(stmt) && return true
+
+        # interpret type definitions
+        istypedef(stmt) && return true
+        # add more statements necessary for the first time interpretation of a type definition
+        # TODO: maybe upstream these into LoweredCodeUtils.jl ?
+        if isexpr(stmt, :(=))
+            stmt = stmt.args[2] # rhs
+        end
+        if isexpr(stmt, :call)
+            f = stmt.args[1]
+            if isa(f, GlobalRef)
+                f.mod === Core && f.name in (:_setsuper!, :_equiv_typedef, :_typebody!) && return true
+            end
+            if isa(f, QuoteNode)
+                f.value in (Core._setsuper!, Core._equiv_typedef, Core._typebody!) && return true
+            end
+        end
+
         return false
     end
 
     lines_required!(not_abstracted, src, CodeEdges(src))
+
     return not_abstracted
 end
 

test/test_virtualprocess.jl

@@ -93,19 +93,22 @@ end
     let
         vmod = gen_virtual_module()
         res, interp = @profile_toplevel vmod begin
-            foo = rand(Bool)
+            gb = rand(Bool)
 
             struct Foo
                 b::Bool
-                Foo(b = foo) = new(b)
+                Foo(b = gb) = new(b)
             end
 
-            Foo()
+            foo = Foo(gb)
         end
 
         # global variables aren't evaluated but kept in `interp` instead
-        @test get_virtual_globalvar(vmod, :foo) isa VirtualGlobalVariable
+        gb = get_virtual_globalvar(vmod, :gb)
+        @test gb isa VirtualGlobalVariable && gb.t ⊑ Bool
         @test isdefined(vmod, :Foo)
+        foo = get_virtual_globalvar(vmod, :foo)
+        @test foo isa VirtualGlobalVariable && foo.t ⊑ vmod.Foo
         @test isempty(res.toplevel_error_reports)
         @test isempty(res.inference_error_reports)
     end