don't store unnecessary arrays of Any for slottypes and gensymtypes

base/inference.jl

@@ -120,9 +120,6 @@ type InferenceState
 
         gensym_uses = find_gensym_uses(linfo.code)
         gensym_types = linfo.gensymtypes
-        for i = 1:length(gensym_types)
-            gensym_types[i] = NF
-        end
         gensym_init = copy(gensym_types)
 
         # exception handlers
@@ -1501,21 +1498,30 @@ end
 
 # copy a LambdaInfo just enough to make it not share data with li.def
 function unshare_linfo(li::LambdaInfo)
-    if li.nargs == 0
-        return li
+    if li.nargs > 0
+        if li === li.def
+            li = ccall(:jl_copy_lambda_info, Any, (Any,), li)::LambdaInfo
+        end
+        if !isa(li.code, Array{Any,1})
+            li.code = ccall(:jl_uncompress_ast, Any, (Any,Any), li, li.code)
+        elseif li.code === li.def.code && li !== li.def
+            li.code = astcopy(li.code)
+        end
+        li.slotnames = copy(li.slotnames)
+        li.slotflags = copy(li.slotflags)
+        if isa(li.slottypes,Array)
+            li.slottypes = copy(li.slottypes)
+        end
+        if isa(li.gensymtypes,Array)
+            li.gensymtypes = copy(li.gensymtypes)
+        end
     end
-    if li === li.def
-        li = ccall(:jl_copy_lambda_info, Any, (Any,), li)::LambdaInfo
+    if !isa(li.slottypes,Array)
+        li.slottypes = Any[ Any for i = 1:length(li.slotnames) ]
     end
-    if !isa(li.code, Array{Any,1})
-        li.code = ccall(:jl_uncompress_ast, Any, (Any,Any), li, li.code)
-    elseif li.code === li.def.code && li !== li.def
-        li.code = astcopy(li.code)
+    if !isa(li.gensymtypes,Array)
+        li.gensymtypes = Any[ NF for i = 1:(li.gensymtypes::Int) ]
     end
-    li.slotnames = copy(li.slotnames)
-    li.slottypes = copy(li.slottypes)
-    li.slotflags = copy(li.slotflags)
-    li.gensymtypes = copy(li.gensymtypes)
     return li
 end
 

base/interactiveutil.jl

@@ -229,7 +229,9 @@ function code_warntype(io::IO, f, t::ANY)
         println(emph_io, "Variables:")
         for i = 1:length(li.slotnames)
             print(emph_io, "  ", li.slotnames[i])
-            show_expr_type(emph_io, li.slottypes[i], true)
+            if isa(li.slottypes,Array)
+                show_expr_type(emph_io, li.slottypes[i], true)
+            end
             print(emph_io, '\n')
         end
         print(emph_io, "\nBody:\n  ")

base/serialize.jl

@@ -313,7 +313,7 @@ function serialize(s::SerializationState, linfo::LambdaInfo)
     serialize(s, linfo.slotnames)
     serialize(s, linfo.slottypes)
     serialize(s, linfo.slotflags)
-    serialize(s, length(linfo.gensymtypes))
+    serialize(s, linfo.gensymtypes)
     if isdefined(linfo.def, :roots)
         serialize(s, linfo.def.roots::Vector{Any})
     else
@@ -562,7 +562,7 @@ function deserialize(s::SerializationState, ::Type{LambdaInfo})
     slotnames = deserialize(s)
     slottypes = deserialize(s)
     slotflags = deserialize(s)
-    ngensym = deserialize(s)
+    gensymtypes = deserialize(s)
     roots = deserialize(s)::Vector{Any}
     sparam_syms = deserialize(s)::SimpleVector
     sparam_vals = deserialize(s)::SimpleVector
@@ -579,7 +579,7 @@ function deserialize(s::SerializationState, ::Type{LambdaInfo})
         linfo.slotnames = slotnames
         linfo.slottypes = slottypes
         linfo.slotflags = slotflags
-        linfo.gensymtypes = Any[ Any for i=1:ngensym ]
+        linfo.gensymtypes = gensymtypes
         linfo.roots = roots
         linfo.sparam_syms = sparam_syms
         linfo.sparam_vals = sparam_vals

src/alloc.c

@@ -309,9 +309,9 @@ JL_DLLEXPORT void jl_lambda_info_set_ast(jl_lambda_info_t *li, jl_value_t *ast)
     jl_value_t *gensym_types = jl_lam_gensyms((jl_expr_t*)ast);
     size_t ngensym = (jl_is_array(gensym_types) ? jl_array_len(gensym_types) : jl_unbox_long(gensym_types));
     li->slotnames = jl_alloc_cell_1d(nslots);
-    li->slottypes = jl_alloc_cell_1d(nslots);
+    li->slottypes = jl_nothing;
     li->slotflags = jl_alloc_array_1d(jl_array_uint8_type, nslots);
-    li->gensymtypes = jl_alloc_cell_1d(ngensym);
+    li->gensymtypes = jl_box_long(ngensym);
     int i;
     for(i=0; i < nslots; i++) {
         jl_value_t *vi = jl_cellref(vis, i);
@@ -329,12 +329,8 @@ JL_DLLEXPORT void jl_lambda_info_set_ast(jl_lambda_info_t *li, jl_value_t *ast)
             }
         }
         jl_cellset(li->slotnames, i, name);
-        jl_cellset(li->slottypes, i, jl_any_type);//jl_cellref(vi, 1));
         jl_array_uint8_set(li->slotflags, i, jl_unbox_long(jl_cellref(vi, 2)));
     }
-    for(i=0; i < ngensym; i++) {
-        jl_cellset(li->gensymtypes, i, jl_any_type);
-    }
     jl_lambda_info_init_properties(li);
 }
 
@@ -346,7 +342,8 @@ jl_lambda_info_t *jl_new_lambda_info(jl_value_t *ast, jl_svec_t *tvars, jl_svec_
         (jl_lambda_info_t*)newobj((jl_value_t*)jl_lambda_info_type,
                                   NWORDS(sizeof(jl_lambda_info_t)));
     li->code = NULL;
-    li->slotnames = li->slottypes = li->slotflags = li->gensymtypes = NULL;
+    li->slotnames = li->slotflags = NULL;
+    li->slottypes = li->gensymtypes = NULL;
     li->rettype = (jl_value_t*)jl_any_type;
     li->file = null_sym;
     li->module = ctx;

src/cgutils.cpp

@@ -1460,8 +1460,11 @@ static inline jl_module_t *topmod(jl_codectx_t *ctx)
 static jl_value_t *expr_type(jl_value_t *e, jl_codectx_t *ctx)
 {
     if (jl_is_gensym(e)) {
+        if (jl_is_long(ctx->linfo->gensymtypes))
+            return (jl_value_t*)jl_any_type;
         int idx = ((jl_gensym_t*)e)->id;
-        jl_array_t *gensym_types = ctx->linfo->gensymtypes;
+        assert(jl_is_array(ctx->linfo->gensymtypes));
+        jl_array_t *gensym_types = (jl_array_t*)ctx->linfo->gensymtypes;
         return jl_cellref(gensym_types, idx);
     }
     if (jl_typeis(e, jl_slot_type)) {

src/codegen.cpp

@@ -4069,8 +4069,7 @@ static void emit_function(jl_lambda_info_t *lam, jl_llvm_functions_t *declaratio
     ctx.spvals_ptr = NULL;
 
     // step 2. process var-info lists to see what vars need boxing
-    jl_array_t *gensym_types = lam->gensymtypes;
-    int n_gensyms = jl_array_len(gensym_types);
+    int n_gensyms = jl_is_long(lam->gensymtypes) ? jl_unbox_long(lam->gensymtypes) : jl_array_len(lam->gensymtypes);
     size_t largslen = lam->nargs;
     size_t vinfoslen = jl_array_dim0(lam->slotnames);
     ctx.slots.resize(vinfoslen);
@@ -4114,7 +4113,7 @@ static void emit_function(jl_lambda_info_t *lam, jl_llvm_functions_t *declaratio
         varinfo.isSA = (jl_vinfo_sa(flags)!=0);
         varinfo.usedUndef = (jl_vinfo_usedundef(flags)!=0) || (!varinfo.isArgument && !lam->inferred);
         if (!varinfo.isArgument || varinfo.isAssigned) {
-            jl_value_t *typ = jl_cellref(lam->slottypes,i);
+            jl_value_t *typ = jl_is_array(lam->slottypes) ? jl_cellref(lam->slottypes,i) : (jl_value_t*)jl_any_type;
             if (!jl_is_type(typ))
                 typ = (jl_value_t*)jl_any_type;
             varinfo.value = mark_julia_type((Value*)NULL, false, typ, &ctx);

src/dump.c

@@ -1427,9 +1427,9 @@ static jl_value_t *jl_deserialize_value_(ios_t *s, jl_value_t *vtag, jl_value_t
             arraylist_push(&backref_list, li);
         li->code = (jl_array_t*)jl_deserialize_value(s, (jl_value_t**)&li->code); jl_gc_wb(li, li->code);
         li->slotnames = (jl_array_t*)jl_deserialize_value(s, (jl_value_t**)&li->slotnames); jl_gc_wb(li, li->slotnames);
-        li->slottypes = (jl_array_t*)jl_deserialize_value(s, (jl_value_t**)&li->slottypes); jl_gc_wb(li, li->slottypes);
+        li->slottypes = jl_deserialize_value(s, &li->slottypes); jl_gc_wb(li, li->slottypes);
         li->slotflags = (jl_array_t*)jl_deserialize_value(s, (jl_value_t**)&li->slotflags); jl_gc_wb(li, li->slotflags);
-        li->gensymtypes = (jl_array_t*)jl_deserialize_value(s, (jl_value_t**)&li->gensymtypes); jl_gc_wb(li, li->gensymtypes);
+        li->gensymtypes = jl_deserialize_value(s, &li->gensymtypes); jl_gc_wb(li, li->gensymtypes);
         li->rettype = jl_deserialize_value(s, &li->rettype);
         jl_gc_wb(li, li->rettype);
         li->sparam_syms = (jl_svec_t*)jl_deserialize_value(s, (jl_value_t**)&li->sparam_syms);

src/interpreter.c

@@ -119,7 +119,7 @@ static int jl_linfo_nslots(jl_lambda_info_t *li)
 
 static int jl_linfo_ngensyms(jl_lambda_info_t *li)
 {
-    return jl_array_len(li->gensymtypes);
+    return jl_is_long(li->gensymtypes) ? jl_unbox_long(li->gensymtypes) : jl_array_len(li->gensymtypes);
 }
 
 static jl_value_t *eval(jl_value_t *e, jl_value_t **locals, jl_lambda_info_t *lam)

src/jltypes.c

@@ -3508,8 +3508,8 @@ void jl_init_types(void)
                                 jl_symbol("pure"), jl_symbol("isva"),
                                 jl_symbol("inInference")),
                         jl_svec(23, jl_any_type, jl_array_any_type,
-                                jl_array_any_type, jl_array_uint8_type,
-                                jl_array_any_type, jl_any_type,
+                                jl_any_type, jl_array_uint8_type,
+                                jl_any_type, jl_any_type,
                                 jl_simplevector_type, jl_simplevector_type,
                                 jl_any_type, jl_sym_type,
                                 jl_any_type, jl_any_type,

src/julia.h

@@ -177,9 +177,9 @@ typedef struct _jl_lambda_info_t {
     // (different environments) of a closure.
     jl_array_t *code;  // compressed uint8 array, or Any array of statements
     jl_array_t *slotnames; // names of local variables
-    jl_array_t *slottypes;
+    jl_value_t *slottypes;
     jl_array_t *slotflags;  // local var bit flags
-    jl_array_t *gensymtypes;
+    jl_value_t *gensymtypes;
     jl_value_t *rettype;
     // sparams is a vector of values indexed by symbols
     jl_svec_t *sparam_syms;