remove typ field from Expr

update optimization passes to keep IR in linear form

Author: JeffBezanson

base/boot.jl

@@ -82,7 +82,6 @@
 #mutable struct Expr
 #    head::Symbol
 #    args::Array{Any,1}
-#    typ::Any
 #end
 
 #struct LineNumberNode

base/expr.jl

@@ -34,7 +34,6 @@ end
 
 copy(e::Expr) = (n = Expr(e.head);
                  n.args = copy_exprargs(e.args);
-                 n.typ = e.typ;
                  n)
 
 # copy parts of an AST that the compiler mutates

base/inference.jl

@@ -386,7 +386,6 @@ function code_warntype(io::IO, f, @nospecialize(t))
         print(emph_io, "\nBody:\n  ")
         body = Expr(:body)
         body.args = src.code
-        body.typ = rettype
         # Fix slot names and types in function body
         show_unquoted(IOContext(emph_io, :SOURCEINFO => src, :SOURCE_SLOTNAMES => slotnames),
                       body, 2)

base/interactiveutil.jl

@@ -865,8 +865,6 @@ precompile(Tuple{typeof(Core.Inference.copy!), Array{Any, 1}, Core.Inference.Gen
 precompile(Tuple{typeof(Core.Inference._widen_all_consts!), Expr, Array{Bool, 1}})
 precompile(Tuple{typeof(Core.Inference._delete!), Core.Inference.IntSet, Int64})
 precompile(Tuple{typeof(Core.Inference.promote_type), Type{Float16}, Type{Int64}})
-precompile(Tuple{typeof(Core.Inference.mk_tuplecall), Array{Any, 1}, Core.Inference.InferenceState})
-precompile(Tuple{typeof(Core.Inference.inlining_pass), Expr, Core.Inference.InferenceState, Array{Any, 1}, Int64})
 precompile(Tuple{typeof(Core.Inference.annotate_slot_load!), Expr, Array{Any, 1}, Core.Inference.InferenceState, Array{Bool, 1}})
 precompile(Tuple{typeof(Core.Inference.record_slot_assign!), Core.Inference.InferenceState})
 precompile(Tuple{typeof(Core.Inference.type_annotate!), Core.Inference.InferenceState})
@@ -1078,7 +1076,6 @@ precompile(Tuple{typeof(Base.setindex!), Base.Dict{Any, Any}, Bool, Symbol})
 precompile(Tuple{typeof(Base._setindex!), Base.Dict{Any, Any}, Bool, Symbol, Int64})
 precompile(Tuple{typeof(Base.merge!), Base.Dict{Any, Any}, Base.Dict{Any, Any}, Base.Dict{Any, Any}})
 precompile(Tuple{Type{Symbol}, Symbol})
-precompile(Tuple{typeof(Core.Inference.mk_getfield), TypedSlot, Int64, Type{String}})
 precompile(Tuple{getfield(Core, Symbol("#kw#Type")), Array{Any, 1}, Type{Base.Cmd}, Base.Cmd})
 precompile(Tuple{typeof(Base.uv_status_string), Base.PipeEndpoint})
 precompile(Tuple{typeof(Base._fd), Base.PipeEndpoint})
@@ -1325,7 +1322,6 @@ precompile(Tuple{typeof(Base.convert), Type{Base.AbstractChannel}, Base.Channel{
 precompile(Tuple{typeof(Base.ndigits0z), UInt8})
 precompile(Tuple{typeof(Base.setindex!), Base.Dict{Any, Any}, Base.Distributed.RemoteValue, Base.Distributed.RRID})
 precompile(Tuple{typeof(Base.dec), UInt8, Int64, Bool})
-precompile(Tuple{typeof(Core.Inference.mk_getfield), TypedSlot, Int64, Type{Integer}})
 precompile(Tuple{typeof(Base.ht_keyindex2), Base.Dict{Any, Any}, Base.Distributed.RRID})
 precompile(Tuple{typeof(Base._setindex!), Base.Dict{Any, Any}, Base.Distributed.RemoteValue, Base.Distributed.RRID, Int64})
 precompile(Tuple{typeof(Core.Inference.length), Tuple{Core.Inference.Const, DataType, Core.Inference.Const}})

base/precompile.jl

@@ -331,7 +331,6 @@ function serialize(s::AbstractSerializer, ex::Expr)
         write(s.io, Int32(l))
     end
     serialize(s, ex.head)
-    serialize(s, ex.typ)
     for a in ex.args
         serialize(s, a)
     end
@@ -966,9 +965,7 @@ function deserialize_expr(s::AbstractSerializer, len)
     e = Expr(:temp)
     resolve_ref_immediately(s, e)
     e.head = deserialize(s)::Symbol
-    ty = deserialize(s)
     e.args = Any[ deserialize(s) for i = 1:len ]
-    e.typ = ty
     e
 end
 

base/serialize.jl

@@ -876,9 +876,9 @@ function show_unquoted(io::IO, ex::Expr, indent::Int, prec::Int)
         ex.head == :return)
         show_type = false
     end
-    if !emphstate && ex.typ === Any
+    #if !emphstate && ex.typ === Any
         show_type = false
-    end
+    #end
     # dot (i.e. "x.y"), but not compact broadcast exps
     if head === :(.) && !is_expr(args[2], :tuple)
         func_prec = operator_precedence(head)
@@ -1219,7 +1219,7 @@ function show_unquoted(io::IO, ex::Expr, indent::Int, prec::Int)
         end
         print(io, "))")
     end
-    show_type && show_expr_type(io, ex.typ, emphstate)
+         #show_type && show_expr_type(io, ex.typ, emphstate)
     nothing
 end
 

base/show.jl

@@ -1005,7 +1005,6 @@ jl_expr_t *jl_exprn(jl_sym_t *head, size_t n)
                                             jl_expr_type);
     ex->head = head;
     ex->args = ar;
-    ex->etype = (jl_value_t*)jl_any_type;
     JL_GC_POP();
     return ex;
 }
@@ -1023,7 +1022,6 @@ JL_CALLABLE(jl_f__expr)
                                             jl_expr_type);
     ex->head = (jl_sym_t*)args[0];
     ex->args = ar;
-    ex->etype = (jl_value_t*)jl_any_type;
     JL_GC_POP();
     return (jl_value_t*)ex;
 }

src/builtins.c

@@ -576,7 +576,7 @@ class jl_codectx_t {
     }
 };
 
-static jl_cgval_t emit_expr(jl_codectx_t &ctx, jl_value_t *expr);
+static jl_cgval_t emit_expr(jl_codectx_t &ctx, jl_value_t *expr, jl_value_t *etype = (jl_value_t*)jl_any_type);
 static Value *global_binding_pointer(jl_codectx_t &ctx, jl_module_t *m, jl_sym_t *s,
                                      jl_binding_t **pbnd, bool assign);
 static jl_cgval_t emit_checked_var(jl_codectx_t &ctx, Value *bp, jl_sym_t *name, bool isvol, MDNode *tbaa);
@@ -2982,12 +2982,12 @@ static jl_cgval_t emit_call_function_object(jl_method_instance_t *li, jl_llvm_fu
     return mark_julia_type(ctx, ret, true, inferred_retty);
 }
 
-static jl_cgval_t emit_invoke(jl_codectx_t &ctx, jl_expr_t *ex)
+static jl_cgval_t emit_invoke(jl_codectx_t &ctx, jl_expr_t *ex, jl_value_t *etype)
 {
     jl_value_t **args = (jl_value_t**)jl_array_data(ex->args);
     size_t arglen = jl_array_dim0(ex->args);
     size_t nargs = arglen - 1;
-    jl_value_t *rt = ex->etype;
+    jl_value_t *rt = etype;
     assert(arglen >= 2);
 
     jl_cgval_t lival = emit_expr(ctx, args[0]);
@@ -3027,12 +3027,12 @@ static jl_cgval_t emit_invoke(jl_codectx_t &ctx, jl_expr_t *ex)
     return result;
 }
 
-static jl_cgval_t emit_call(jl_codectx_t &ctx, jl_expr_t *ex)
+static jl_cgval_t emit_call(jl_codectx_t &ctx, jl_expr_t *ex, jl_value_t *etype)
 {
     jl_value_t **args = (jl_value_t**)jl_array_data(ex->args);
     size_t nargs = jl_array_dim0(ex->args);
     assert(nargs >= 1);
-    jl_value_t *rt = ex->etype;
+    jl_value_t *rt = etype;
     jl_cgval_t f = emit_expr(ctx, args[0]);
 
     if (f.constant && jl_typeis(f.constant, jl_intrinsic_type)) {
@@ -3453,18 +3453,13 @@ static void emit_assignment(jl_codectx_t &ctx, jl_value_t *l, jl_value_t *r)
         ssize_t idx = ((jl_ssavalue_t*)l)->id;
         assert(idx >= 0);
         assert(!ctx.ssavalue_assigned.at(idx));
-        jl_cgval_t slot = emit_expr(ctx, r); // slot could be a jl_value_t (unboxed) or jl_value_t* (ispointer)
-        if (slot.isboxed || slot.TIndex) {
-            // see if inference suggested a different type for the ssavalue than the expression
-            // e.g. sometimes the information is inconsistent after inlining getfield on a Tuple
-            jl_value_t *ssavalue_types = (jl_value_t*)ctx.source->ssavaluetypes;
-            if (jl_is_array(ssavalue_types)) {
-                jl_value_t *declType = jl_array_ptr_ref(ssavalue_types, idx);
-                if (declType != slot.typ) {
-                    slot = update_julia_type(ctx, slot, declType);
-                }
-            }
+        jl_value_t *declType = (jl_value_t*)jl_any_type;
+        // get expr type from its ssavalue
+        jl_value_t *ssavalue_types = (jl_value_t*)ctx.source->ssavaluetypes;
+        if (jl_is_array(ssavalue_types)) {
+            declType = jl_array_ptr_ref(ssavalue_types, idx);
         }
+        jl_cgval_t slot = emit_expr(ctx, r, declType); // slot could be a jl_value_t (unboxed) or jl_value_t* (ispointer)
         if (!slot.isboxed && !slot.isimmutable) {
             // emit a copy of values stored in mutable slots
             Value *dest;
@@ -3684,7 +3679,7 @@ static void emit_stmtpos(jl_codectx_t &ctx, jl_value_t *expr)
     }
 }
 
-static jl_cgval_t emit_expr(jl_codectx_t &ctx, jl_value_t *expr)
+static jl_cgval_t emit_expr(jl_codectx_t &ctx, jl_value_t *expr, jl_value_t *etype)
 {
     if (jl_is_symbol(expr)) {
         jl_sym_t *sym = (jl_sym_t*)expr;
@@ -3754,15 +3749,14 @@ static jl_cgval_t emit_expr(jl_codectx_t &ctx, jl_value_t *expr)
         return emit_isdefined(ctx, args[0]);
     }
     else if (head == invoke_sym) {
-        return emit_invoke(ctx, ex);
+        return emit_invoke(ctx, ex, etype);
     }
     else if (head == call_sym) {
-        jl_cgval_t res = emit_call(ctx, ex);
+        jl_cgval_t res = emit_call(ctx, ex, etype);
         // some intrinsics (e.g. typeassert) can return a wider type
         // than what's actually possible
-        jl_value_t *expr_t = ex->etype;
-        res = update_julia_type(ctx, res, expr_t);
-        if (res.typ == jl_bottom_type || expr_t == jl_bottom_type) {
+        res = update_julia_type(ctx, res, etype);
+        if (res.typ == jl_bottom_type || etype == jl_bottom_type) {
             CreateTrap(ctx.builder);
         }
         return res;

src/codegen.cpp

@@ -609,7 +609,6 @@ static void jl_serialize_value_(jl_serializer_state *s, jl_value_t *v, int as_li
             write_int32(s->s, l);
         }
         jl_serialize_value(s, e->head);
-        jl_serialize_value(s, e->etype);
         for (i = 0; i < l; i++) {
             jl_serialize_value(s, jl_exprarg(e, i));
         }
@@ -1385,8 +1384,6 @@ static jl_value_t *jl_deserialize_value_expr(jl_serializer_state *s, jl_value_t
     jl_expr_t *e = jl_exprn((jl_sym_t*)jl_deserialize_value(s, NULL), len);
     if (usetable)
         backref_list.items[pos] = e;
-    e->etype = jl_deserialize_value(s, &e->etype);
-    jl_gc_wb(e, e->etype);
     jl_value_t **data = (jl_value_t**)(e->args->data);
     for (i = 0; i < len; i++) {
         data[i] = jl_deserialize_value(s, &data[i]);

src/dump.c

@@ -1961,10 +1961,9 @@ void jl_init_types(void)
     jl_expr_type =
         jl_new_datatype(jl_symbol("Expr"), core,
                         jl_any_type, jl_emptysvec,
-                        jl_perm_symsvec(3, "head", "args", "typ"),
-                        jl_svec(3, jl_sym_type, jl_array_any_type,
-                                 jl_any_type),
-                        0, 1, 3);
+                        jl_perm_symsvec(2, "head", "args"),
+                        jl_svec(2, jl_sym_type, jl_array_any_type),
+                        0, 1, 2);
 
     jl_linenumbernode_type =
         jl_new_datatype(jl_symbol("LineNumberNode"), core, jl_any_type, jl_emptysvec,

src/jltypes.c

@@ -470,7 +470,6 @@ typedef struct {
     JL_DATA_TYPE
     jl_sym_t *head;
     jl_array_t *args;
-    jl_value_t *etype;
 } jl_expr_t;
 
 // constants and type objects -------------------------------------------------

src/julia.h

@@ -808,8 +808,7 @@ static size_t jl_static_show_x_(JL_STREAM *out, jl_value_t *v, jl_datatype_t *vt
                 n += jl_printf(out, ",%c", sep);
                 n += jl_static_show_x(out, jl_exprarg(e,i), depth);
             }
-            n += jl_printf(out, ")::");
-            n += jl_static_show_x(out, e->etype, depth);
+            n += jl_printf(out, ")");
         }
     }
     else if (jl_is_array_type(vt)) {

src/rtutils.c

@@ -411,34 +411,25 @@ end
 @inferred cat10880(Tuple{Int8,Int16}, Tuple{Int32})
 
 # issue #19348
-function is_typed_expr(e::Expr)
-    if e.head === :call ||
-       e.head === :invoke ||
-       e.head === :new ||
-       e.head === :copyast ||
-       e.head === :inert
-        return true
-    end
-    return false
-end
-test_inferred_static(@nospecialize(other)) = true
-test_inferred_static(slot::TypedSlot) = @test isleaftype(slot.typ)
-function test_inferred_static(expr::Expr)
-    if is_typed_expr(expr)
-        @test isleaftype(expr.typ)
-    end
-    for a in expr.args
-        test_inferred_static(a)
+function test_inferred_static(code::CodeInfo)
+    @test all(isleaftype, code.slottypes)
+    @test all(isleaftype, code.ssavaluetypes)
+    for e in code.code
+        test_inferred_static_expr(e)
     end
 end
 function test_inferred_static(arrow::Pair)
     code, rt = arrow
     @test isleaftype(rt)
     @test code.inferred
-    @test all(x->isleaftype(x), code.slottypes)
-    @test all(x->isleaftype(x), code.ssavaluetypes)
-    for e in code.code
-        test_inferred_static(e)
+    test_inferred_static(code)
+end
+
+test_inferred_static_expr(@nospecialize(other)) = true
+test_inferred_static_expr(slot::TypedSlot) = @test isleaftype(slot.typ)
+function test_inferred_static_expr(expr::Expr)
+    for a in expr.args
+        test_inferred_static_expr(a)
     end
 end
 
@@ -484,7 +475,6 @@ for codetype in Any[
     local notconst(@nospecialize(other)) = true
     notconst(slot::TypedSlot) = @test isa(slot.typ, Type)
     function notconst(expr::Expr)
-        @test isa(expr.typ, Type)
         for a in expr.args
             notconst(a)
         end
@@ -1049,12 +1039,24 @@ function test_const_return(@nospecialize(f), @nospecialize(t), @nospecialize(val
     end
 end
 
-function find_call(code, func, narg)
+function find_def(code, ssav::SSAValue)
+    for ex in code
+        if isa(ex, Expr) && ex.head === :(=) && ex.args[1] === ssav
+            return ex.args[2]
+        end
+    end
+    error("SSAValue assignment not found")
+end
+
+function find_call(code, func, narg, code0 = code)
     for ex in code
         isa(ex, Expr) || continue
         ex = ex::Expr
         if ex.head === :call && length(ex.args) == narg
             farg = ex.args[1]
+            while isa(farg, SSAValue)
+                farg = find_def(code0, farg)
+            end
             if isa(farg, GlobalRef)
                 farg = farg::GlobalRef
                 if isdefined(farg.mod, farg.name) && isconst(farg.mod, farg.name)
@@ -1067,7 +1069,7 @@ function find_call(code, func, narg)
         elseif Core.Inference.is_meta_expr(ex)
             continue
         end
-        find_call(ex.args, func, narg) && return true
+        find_call(ex.args, func, narg, code0) && return true
     end
     return false
 end