Do some more cleanup

Author: Keno

src/builtins.c

@@ -897,7 +897,7 @@ static jl_value_t *get_fieldtype(jl_value_t *t, jl_value_t *f, int dothrow)
     int nf = jl_svec_len(types);
     if (nf > 0 && field_index >= nf-1 && st->name == jl_tuple_typename) {
         jl_value_t *ft = jl_field_type(st, nf-1);
-        if (jl_is_vararg_type(ft))
+        if (jl_is_vararg_marker(ft))
             return jl_unwrap_vararg(ft);
     }
     if (field_index < 0 || field_index >= nf) {
@@ -972,7 +972,7 @@ static int valid_type_param(jl_value_t *v)
         }
         return 1;
     }
-    if (jl_is_vararg_type(v))
+    if (jl_is_vararg_marker(v))
         return 0;
     // TODO: maybe more things
     return jl_is_type(v) || jl_is_typevar(v) || jl_is_symbol(v) || jl_isbits(jl_typeof(v));
@@ -987,7 +987,7 @@ JL_CALLABLE(jl_f_apply_type)
             jl_value_t *pi = args[i];
             // TODO: should possibly only allow Types and TypeVars, but see
             // https://github.com/JuliaLang/julia/commit/85f45974a581ab9af955bac600b90d9ab00f093b#commitcomment-13041922
-            if (jl_is_vararg_type(pi)) {
+            if (jl_is_vararg_marker(pi)) {
                 if (i != nargs-1)
                     jl_type_error_rt("Tuple", "non-final parameter", (jl_value_t*)jl_type_type, pi);
             }
@@ -1129,9 +1129,9 @@ JL_CALLABLE(jl_f__expr)
 // Typevar constructor for internal use
 JL_DLLEXPORT jl_tvar_t *jl_new_typevar(jl_sym_t *name, jl_value_t *lb, jl_value_t *ub)
 {
-    if ((lb != jl_bottom_type && !jl_is_type(lb) && !jl_is_typevar(lb)) || jl_is_vararg_type(lb))
+    if (lb != jl_bottom_type && !jl_is_type(lb) && !jl_is_typevar(lb))
         jl_type_error_rt("TypeVar", "lower bound", (jl_value_t *)jl_type_type, lb);
-    if ((ub != (jl_value_t *)jl_any_type && !jl_is_type(ub) && !jl_is_typevar(ub)) || jl_is_vararg_type(ub))
+    if (ub != (jl_value_t *)jl_any_type && !jl_is_type(ub) && !jl_is_typevar(ub))
         jl_type_error_rt("TypeVar", "upper bound", (jl_value_t *)jl_type_type, ub);
     jl_ptls_t ptls = jl_get_ptls_states();
     jl_tvar_t *tv = (jl_tvar_t *)jl_gc_alloc(ptls, sizeof(jl_tvar_t), jl_tvar_type);
@@ -1319,7 +1319,7 @@ JL_CALLABLE(jl_f__typebody)
         size_t nf = jl_svec_len(ft);
         for (size_t i = 0; i < nf; i++) {
             jl_value_t *elt = jl_svecref(ft, i);
-            if ((!jl_is_type(elt) && !jl_is_typevar(elt)) || jl_is_vararg_type(elt)) {
+            if (!jl_is_type(elt) && !jl_is_typevar(elt)) {
                 jl_type_error_rt(jl_symbol_name(dt->name->name),
                                  "type definition",
                                  (jl_value_t*)jl_type_type, elt);

src/cgutils.cpp

@@ -737,13 +737,13 @@ static bool is_tupletype_homogeneous(jl_svec_t *t, bool allow_va = false)
     if (l > 0) {
         jl_value_t *t0 = jl_svecref(t, 0);
         if (!jl_is_concrete_type(t0)) {
-            if (allow_va && jl_is_vararg_type(t0) &&
+            if (allow_va && jl_is_vararg_marker(t0) &&
                   jl_is_concrete_type(jl_unwrap_vararg(t0)))
                 return true;
             return false;
         }
         for (i = 1; i < l; i++) {
-            if (allow_va && i == l - 1 && jl_is_vararg_type(jl_svecref(t, i))) {
+            if (allow_va && i == l - 1 && jl_is_vararg_marker(jl_svecref(t, i))) {
                 if (t0 != jl_unwrap_vararg(jl_svecref(t, i)))
                     return false;
                 continue;

src/codegen.cpp

@@ -265,7 +265,7 @@ static bool type_has_unique_rep(jl_value_t *t)
         return true;
     if (jl_is_datatype(t)) {
         jl_datatype_t *dt = (jl_datatype_t*)t;
-        if (dt->name != jl_tuple_typename && !jl_is_vararg_type(t)) {
+        if (dt->name != jl_tuple_typename) {
             for (size_t i = 0; i < jl_nparams(dt); i++)
                 if (!type_has_unique_rep(jl_tparam(dt, i)))
                     return false;
@@ -1727,7 +1727,7 @@ static std::pair<bool, bool> uses_specsig(jl_method_instance_t *lam, jl_value_t
     if (jl_nparams(sig) == 0)
         return std::make_pair(false, false);
     if (va) {
-        if (jl_is_vararg_type(jl_tparam(sig, jl_nparams(sig) - 1)))
+        if (jl_is_vararg_marker(jl_tparam(sig, jl_nparams(sig) - 1)))
             return std::make_pair(false, false);
     }
     // not invalid, consider if specialized signature is worthwhile
@@ -2989,7 +2989,7 @@ static bool emit_builtin_call(jl_codectx_t &ctx, jl_cgval_t *ret, jl_value_t *f,
                     if (obj.ispointer()) {
                         // Determine which was the type that was homogenous
                         jl_value_t *jt = jl_tparam0(utt);
-                        if (jl_is_vararg_type(jt))
+                        if (jl_is_vararg_marker(jt))
                             jt = jl_unwrap_vararg(jt);
                         Value *vidx = emit_unbox(ctx, T_size, fld, (jl_value_t*)jl_long_type);
                         // This is not necessary for correctness, but allows to omit
@@ -5248,7 +5248,7 @@ static jl_cgval_t emit_cfunction(jl_codectx_t &ctx, jl_value_t *output_type, con
 
     // some sanity checking and check whether there's a vararg
     size_t nargt = jl_svec_len(argt);
-    bool isVa = (nargt > 0 && jl_is_vararg_type(jl_svecref(argt, nargt - 1)));
+    bool isVa = (nargt > 0 && jl_is_vararg_marker(jl_svecref(argt, nargt - 1)));
     if (isVa) {
         emit_error(ctx, "cfunction: Vararg syntax not allowed for argument list");
         return jl_cgval_t();

src/dump.c

@@ -567,11 +567,6 @@ static void jl_serialize_value_(jl_serializer_state *s, jl_value_t *v, int as_li
         jl_serialize_value(s, ((jl_tvar_t*)v)->lb);
         jl_serialize_value(s, ((jl_tvar_t*)v)->ub);
     }
-    else if (jl_is_vararg_marker(v)) {
-        write_uint8(s->s, TAG_VARARG);
-        jl_serialize_value(s, ((jl_vararg_marker_t*)v)->T);
-        jl_serialize_value(s, ((jl_vararg_marker_t*)v)->N);
-    }
     else if (jl_is_method(v)) {
         write_uint8(s->s, TAG_METHOD);
         jl_method_t *m = (jl_method_t*)v;
@@ -1752,15 +1747,6 @@ static jl_value_t *jl_deserialize_value(jl_serializer_state *s, jl_value_t **loc
         tv->ub = jl_deserialize_value(s, &tv->ub);
         jl_gc_wb(tv, tv->ub);
         return (jl_value_t*)tv;
-    case TAG_VARARG:
-        v = jl_gc_alloc(s->ptls, sizeof(jl_vararg_marker_t), jl_vararg_marker_type);
-        jl_vararg_marker_t *vm = (jl_vararg_marker_t*)v;
-        arraylist_push(&backref_list, vm);
-        vm->T = (jl_sym_t*)jl_deserialize_value(s, NULL);
-        jl_gc_wb(vm, vm->T);
-        vm->N = jl_deserialize_value(s, &vm->N);
-        jl_gc_wb(vm, vm->N);
-        return (jl_value_t*)vm;
     case TAG_METHOD:
         return jl_deserialize_value_method(s, loc);
     case TAG_METHOD_INSTANCE:
@@ -2644,7 +2630,6 @@ void jl_init_serializer(void)
     deser_tag[TAG_GOTOIFNOT] = (jl_value_t*)jl_gotoifnot_type;
     deser_tag[TAG_RETURNNODE] = (jl_value_t*)jl_returnnode_type;
     deser_tag[TAG_ARGUMENT] = (jl_value_t*)jl_argument_type;
-    deser_tag[TAG_VARARG] = (jl_value_t*)jl_vararg_marker_type;
 
     intptr_t i = 0;
     while (vals[i] != NULL) {

src/gf.c

@@ -534,7 +534,7 @@ jl_value_t *jl_nth_slot_type(jl_value_t *sig, size_t i) JL_NOTSAFEPOINT
         return NULL;
     if (i < len-1)
         return jl_tparam(sig, i);
-    if (jl_is_vararg_type(jl_tparam(sig, len-1)))
+    if (jl_is_vararg_marker(jl_tparam(sig, len-1)))
         return jl_unwrap_vararg(jl_tparam(sig, len-1));
     if (i == len-1)
         return jl_tparam(sig, i);
@@ -756,7 +756,7 @@ static void jl_compilation_sig(
         else {
             jl_value_t *unw = jl_unwrap_unionall(decl);
             jl_value_t *lastdeclt = jl_tparam(unw, nargs - 1);
-            assert(jl_is_vararg_type(lastdeclt) && jl_nparams(unw) == nargs);
+            assert(jl_is_vararg_marker(lastdeclt) && jl_nparams(unw) == nargs);
             int nsp = jl_svec_len(sparams);
             if (nsp > 0 && jl_has_free_typevars(lastdeclt)) {
                 assert(jl_subtype_env_size(decl) == nsp);
@@ -817,7 +817,7 @@ JL_DLLEXPORT int jl_isa_compileable_sig(
                 nspec_max = nspec_min;
         }
         int isbound = (jl_va_tuple_kind((jl_datatype_t*)decl) == JL_VARARG_UNBOUND);
-        if (jl_is_vararg_type(jl_tparam(type, np - 1))) {
+        if (jl_is_vararg_marker(jl_tparam(type, np - 1))) {
             if (!isbound || np < nspec_min || np > nspec_max)
                 return 0;
         }
@@ -826,7 +826,7 @@ JL_DLLEXPORT int jl_isa_compileable_sig(
                 return 0;
         }
     }
-    else if (np != nargs || jl_is_vararg_type(jl_tparam(type, np - 1))) {
+    else if (np != nargs || jl_is_vararg_marker(jl_tparam(type, np - 1))) {
         return 0;
     }
 
@@ -835,7 +835,7 @@ JL_DLLEXPORT int jl_isa_compileable_sig(
         jl_value_t *decl_i = jl_nth_slot_type((jl_value_t*)decl, i);
         size_t i_arg = (i < nargs - 1 ? i : nargs - 1);
 
-        if (jl_is_vararg_type(elt)) {
+        if (jl_is_vararg_marker(elt)) {
             elt = jl_unwrap_vararg(elt);
             if (jl_has_free_typevars(decl_i)) {
                 // TODO: in this case, answer semi-conservatively that these varargs are always compilable
@@ -959,7 +959,7 @@ static int concretesig_equal(jl_value_t *tt, jl_value_t *simplesig) JL_NOTSAFEPO
     jl_value_t **sigs = jl_svec_data(((jl_datatype_t*)simplesig)->parameters);
     size_t i, lensig = jl_nparams(simplesig);
     assert(lensig == jl_nparams(tt));
-    assert(lensig > 0 && !jl_is_vararg_type(jl_tparam(simplesig, lensig - 1)));
+    assert(lensig > 0 && !jl_is_vararg_marker(jl_tparam(simplesig, lensig - 1)));
     for (i = 0; i < lensig; i++) {
         jl_value_t *decl = sigs[i];
         jl_value_t *a = types[i];
@@ -1108,7 +1108,7 @@ static jl_method_instance_t *cache_method(
     newparams = NULL;
     for (i = 0; i < np; i++) {
         jl_value_t *elt = jl_svecref(cachett->parameters, i);
-        if (jl_is_vararg_type(elt)) {
+        if (jl_is_vararg_marker(elt)) {
         }
         else if (jl_is_type_type(elt)) {
             // TODO: if (!jl_is_singleton(elt)) ...
@@ -1229,7 +1229,7 @@ static jl_value_t *get_intersect_matches(jl_typemap_t *defs, jl_typemap_entry_t
     jl_value_t *va = NULL;
     if (l > 0) {
         va = jl_tparam(ttypes, l - 1);
-        if (jl_is_vararg_type(va))
+        if (jl_is_vararg_marker(va))
             va = jl_unwrap_vararg(va);
         else
             va = NULL;
@@ -2635,7 +2635,7 @@ static jl_value_t *ml_matches(jl_methtable_t *mt, int offs,
     jl_value_t *va = NULL;
     if (l > 0) {
         va = jl_tparam(unw, l - 1);
-        if (jl_is_vararg_type(va))
+        if (jl_is_vararg_marker(va))
             va = jl_unwrap_vararg(va);
         else
             va = NULL;
@@ -3088,7 +3088,7 @@ int jl_has_concrete_subtype(jl_value_t *typ)
     if (typ == jl_bottom_type)
         return 0;
     typ = jl_unwrap_unionall(typ);
-    if (jl_is_vararg_type(typ))
+    if (jl_is_vararg_marker(typ))
         typ = jl_unwrap_vararg(typ);
     if (!jl_is_datatype(typ))
         return 1;

src/jltypes.c

@@ -497,7 +497,7 @@ JL_DLLEXPORT jl_value_t *jl_type_union(jl_value_t **ts, size_t n)
     size_t i;
     for(i=0; i < n; i++) {
         jl_value_t *pi = ts[i];
-        if (!(jl_is_type(pi) || jl_is_typevar(pi)) || jl_is_vararg_type(pi))
+        if (!(jl_is_type(pi) || jl_is_typevar(pi)))
             jl_type_error("Union", (jl_value_t*)jl_type_type, pi);
     }
     if (n == 1) return ts[0];
@@ -1109,7 +1109,7 @@ static unsigned type_hash(jl_value_t *kj, int *failed) JL_NOTSAFEPOINT
             return 0;
         }
         jl_vararg_marker_t *vm = (jl_vararg_marker_t *)uw;
-        return bitmix(type_hash(vm->T ? vm->T : jl_any_type, failed), vm->N ? type_hash(vm->N, failed) : 0);
+        return bitmix(type_hash(vm->T ? vm->T : (jl_value_t*)jl_any_type, failed), vm->N ? type_hash(vm->N, failed) : 0);
     }
     else if (jl_is_uniontype(uw)) {
         if (!*failed) {
@@ -1257,7 +1257,7 @@ static jl_value_t *inst_datatype_inner(jl_datatype_t *dt, jl_svec_t *p, jl_value
                 continue;
             if (jl_is_datatype(pi))
                 continue;
-            if (jl_is_vararg_type(pi)) {
+            if (jl_is_vararg_marker(pi)) {
                 pi = jl_unwrap_vararg(pi);
                 if (jl_has_free_typevars(pi))
                     continue;
@@ -1268,7 +1268,7 @@ static jl_value_t *inst_datatype_inner(jl_datatype_t *dt, jl_svec_t *p, jl_value
                     jl_types_equal(pi, tw)) {
                 // This would require some special handling, but is never used at
                 // the moment.
-                assert(!jl_is_vararg_type(iparams[i]));
+                assert(!jl_is_vararg_marker(iparams[i]));
                 iparams[i] = tw;
                 if (p) jl_gc_wb(p, tw);
             }
@@ -1295,7 +1295,7 @@ static jl_value_t *inst_datatype_inner(jl_datatype_t *dt, jl_svec_t *p, jl_value
     JL_GC_PUSH3(&p, &ndt, &last);
 
     int isvatuple = 0;
-    if (istuple && ntp > 0 && jl_is_vararg_type(last)) {
+    if (istuple && ntp > 0 && jl_is_vararg_marker(last)) {
         isvatuple = 1;
         // normalize Tuple{..., Vararg{Int, 3}} to Tuple{..., Int, Int, Int}
         jl_value_t *va = jl_unwrap_unionall(last);
@@ -1661,7 +1661,7 @@ static jl_value_t *inst_type_w_(jl_value_t *t, jl_typeenv_t *env, jl_typestack_t
                 N = inst_type_w_(v->N, env, stack, check);
         }
         if (T != v->T || N != v->N) {
-            t = jl_wrap_vararg(T, N);
+            t = (jl_value_t*)jl_wrap_vararg(T, N);
         }
         JL_GC_POP();
         return t;
@@ -1752,7 +1752,7 @@ jl_vararg_marker_t *jl_wrap_vararg(jl_value_t *t, jl_value_t *n)
         }
     }
     jl_ptls_t ptls = jl_get_ptls_states();
-    jl_vararg_marker_t *vm = jl_gc_alloc(ptls, sizeof(jl_vararg_marker_t), jl_vararg_marker_type);
+    jl_vararg_marker_t *vm = (jl_vararg_marker_t *)jl_gc_alloc(ptls, sizeof(jl_vararg_marker_t), jl_vararg_marker_type);
     vm->T = t;
     vm->N = n;
     return vm;
@@ -2124,7 +2124,7 @@ void jl_init_types(void) JL_GC_DISABLED
     jl_function_type->name->mt = NULL; // subtypes of Function have independent method tables
     jl_builtin_type->name->mt = NULL;  // so they don't share the Any type table
 
-    jl_tvar_t *tv = jl_svec2(tvar("T"), tvar("N"));
+    jl_svec_t *tv = jl_svec2(tvar("T"), tvar("N"));
     jl_abstractarray_type = (jl_unionall_t*)
         jl_new_abstracttype((jl_value_t*)jl_symbol("AbstractArray"), core,
                             jl_any_type, tv)->name->wrapper;

src/julia_internal.h

@@ -533,31 +533,20 @@ STATIC_INLINE int jl_is_vararg_marker(jl_value_t *v) JL_NOTSAFEPOINT
     return jl_typeof(v) == (jl_value_t*)jl_vararg_marker_type;
 }
 
-STATIC_INLINE int jl_is_vararg_type(jl_value_t *v) JL_NOTSAFEPOINT
+STATIC_INLINE jl_value_t *jl_unwrap_vararg(jl_vararg_marker_t *v JL_PROPAGATES_ROOT) JL_NOTSAFEPOINT
 {
-    return jl_is_vararg_marker(jl_unwrap_unionall(v));
+    assert(jl_is_vararg_marker((jl_value_t*)v));
+    jl_value_t *T = ((jl_vararg_marker_t*)v)->T;
+    return T ? T : (jl_value_t*)jl_any_type;
 }
+#define jl_unwrap_vararg(v) (jl_unwrap_vararg)((jl_vararg_marker_t *)v)
 
-STATIC_INLINE jl_value_t *jl_unwrap_vararg(jl_value_t *v JL_PROPAGATES_ROOT) JL_NOTSAFEPOINT
+STATIC_INLINE jl_value_t *jl_unwrap_vararg_num(jl_vararg_marker_t *v JL_PROPAGATES_ROOT) JL_NOTSAFEPOINT
 {
-    assert(jl_is_vararg_type(v));
-    v = jl_unwrap_unionall(v);
-    if (jl_is_vararg_marker(v)) {
-        jl_value_t *T = ((jl_vararg_marker_t*)v)->T;
-        return T ? T : (jl_value_t*)jl_any_type;
-    }
-    return jl_tparam0(v);
-}
-
-STATIC_INLINE jl_value_t *jl_unwrap_vararg_num(jl_value_t *v JL_PROPAGATES_ROOT) JL_NOTSAFEPOINT
-{
-    assert(jl_is_vararg_type(v));
-    v = jl_unwrap_unionall(v);
-    if (jl_is_vararg_marker(v)) {
-        return ((jl_vararg_marker_t*)v)->N;
-    }
-    return jl_tparam1(v);
+    assert(jl_is_vararg_marker((jl_value_t*)v));
+    return ((jl_vararg_marker_t*)v)->N;
 }
+#define jl_unwrap_vararg_num(v) (jl_unwrap_vararg_num)((jl_vararg_marker_t *)v)
 
 STATIC_INLINE jl_vararg_kind_t jl_vararg_kind(jl_value_t *v) JL_NOTSAFEPOINT
 {
@@ -575,12 +564,12 @@ STATIC_INLINE int jl_is_va_tuple(jl_datatype_t *t) JL_NOTSAFEPOINT
 {
     assert(jl_is_tuple_type(t));
     size_t l = jl_svec_len(t->parameters);
-    return (l>0 && jl_is_vararg_type(jl_tparam(t,l-1)));
+    return (l>0 && jl_is_vararg_marker(jl_tparam(t,l-1)));
 }
 
 STATIC_INLINE size_t jl_vararg_length(jl_value_t *v) JL_NOTSAFEPOINT
 {
-    assert(jl_is_vararg_type(v));
+    assert(jl_is_vararg_marker(v));
     jl_value_t *len = jl_unwrap_vararg_num(v);
     assert(jl_is_long(len));
     return jl_unbox_long(len);

src/method.c

@@ -710,7 +710,7 @@ JL_DLLEXPORT void jl_method_def(jl_svec_t *argdata,
     jl_svec_t *tvars = (jl_svec_t*)jl_svecref(argdata, 1);
     jl_value_t *functionloc = jl_svecref(argdata, 2);
     size_t nargs = jl_svec_len(atypes);
-    int isva = jl_is_vararg_type(jl_svecref(atypes, nargs - 1));
+    int isva = jl_is_vararg_marker(jl_svecref(atypes, nargs - 1));
     assert(jl_is_svec(atypes));
     assert(nargs > 0);
     assert(jl_is_svec(tvars));
@@ -779,7 +779,7 @@ JL_DLLEXPORT void jl_method_def(jl_svec_t *argdata,
 
     for (i = 0; i < na; i++) {
         jl_value_t *elt = jl_svecref(atypes, i);
-        if (!jl_is_type(elt) && !jl_is_typevar(elt) && !jl_is_vararg_type(elt)) {
+        if (!jl_is_type(elt) && !jl_is_typevar(elt) && !jl_is_vararg_marker(elt)) {
             jl_sym_t *argname = (jl_sym_t*)jl_array_ptr_ref(f->slotnames, i);
             if (argname == unused_sym)
                 jl_exceptionf(jl_argumenterror_type,
@@ -796,7 +796,7 @@ JL_DLLEXPORT void jl_method_def(jl_svec_t *argdata,
                               jl_symbol_name(m->file),
                               m->line);
         }
-        if (jl_is_vararg_type(elt) && i < na-1)
+        if (jl_is_vararg_marker(elt) && i < na-1)
             jl_exceptionf(jl_argumenterror_type,
                           "Vararg on non-final argument in method definition for %s at %s:%d",
                           jl_symbol_name(name),

src/rtutils.c

@@ -1135,7 +1135,7 @@ JL_DLLEXPORT size_t jl_static_show_func_sig(JL_STREAM *s, jl_value_t *type) JL_N
             n += jl_printf(s, ", ");
         }
         else {
-            if (jl_is_vararg_type(tp)) {
+            if (jl_is_vararg_marker(tp)) {
                 n += jl_static_show(s, jl_unwrap_vararg(tp));
                 n += jl_printf(s, "...");
             }