splatnew: ensure performance of struct users of it (JuliaLang#31550)

Types which permit nargs < nfields in their constructor are required by correctness
to take a notable performance hit. Since currently nobody is using currently that
ability (NamedTuples, for example, want it to be statically disallowed),
ensure that splatnew respects that we must have nargs >= ninitialized
in the most performance-preserving way we can.

base/compiler/abstractinterpretation.jl

@@ -944,7 +944,6 @@ function abstract_eval(@nospecialize(e), vtypes::VarTable, sv::InferenceState)
         end
     elseif e.head === :splatnew
         t = instanceof_tfunc(abstract_eval(e.args[1], vtypes, sv))[1]
-        # TODO: improve
     elseif e.head === :&
         abstract_eval(e.args[1], vtypes, sv)
         t = Any

base/compiler/ssair/inlining.jl

@@ -821,7 +821,7 @@ function is_valid_type_for_apply_rewrite(@nospecialize(typ), params::Params)
     end
 end
 
-function inline_splatnew!(ir::IRCode, idx)
+function inline_splatnew!(ir::IRCode, idx::Int)
     stmt = ir.stmts[idx]
     ty = ir.types[idx]
     nf = nfields_tfunc(ty)
@@ -830,7 +830,9 @@ function inline_splatnew!(ir::IRCode, idx)
         tup = eargs[2]
         tt = argextype(tup, ir, ir.sptypes)
         tnf = nfields_tfunc(tt)
-        if tnf isa Const && tnf.val <= nf.val
+        # TODO: hoisting this tnf.val == nf.val check into codegen
+        # would enable us to almost always do this transform
+        if tnf isa Const && tnf.val == nf.val
             n = tnf.val
             new_argexprs = Any[eargs[1]]
             for j = 1:n
@@ -843,6 +845,7 @@ function inline_splatnew!(ir::IRCode, idx)
             stmt.args = new_argexprs
         end
     end
+    nothing
 end
 
 function call_sig(ir::IRCode, stmt::Expr)

src/codegen.cpp

@@ -4153,6 +4153,8 @@ static jl_cgval_t emit_expr(jl_codectx_t &ctx, jl_value_t *expr, ssize_t ssaval)
         Value *typ = boxed(ctx, argv[0]);
         Value *tup = boxed(ctx, argv[1]);
         Value *val = ctx.builder.CreateCall(prepare_call(jlsplatnew_func), { typ, tup });
+        // temporarily mark as `Any`, expecting `emit_ssaval_assign` to update
+        // it to the inferred type.
         return mark_julia_type(ctx, val, true, (jl_value_t*)jl_any_type);
     }
     else if (head == exc_sym) {

src/datatype.c

@@ -848,13 +848,12 @@ JL_DLLEXPORT jl_value_t *jl_new_structt(jl_datatype_t *type, jl_value_t *tup)
     jl_ptls_t ptls = jl_get_ptls_states();
     if (!jl_is_tuple(tup))
         jl_type_error("new", (jl_value_t*)jl_tuple_type, tup);
-    size_t na = jl_nfields(tup);
+    size_t nargs = jl_nfields(tup);
     size_t nf = jl_datatype_nfields(type);
-    if (na > nf)
-        jl_too_many_args("new", nf);
+    JL_NARGS(new, nf, nf);
     if (type->instance != NULL) {
         jl_datatype_t *tupt = (jl_datatype_t*)jl_typeof(tup);
-        for (size_t i = 0; i < na; i++) {
+        for (size_t i = 0; i < nargs; i++) {
             jl_value_t *ft = jl_field_type(type, i);
             jl_value_t *et = jl_field_type(tupt, i);
             assert(jl_is_concrete_type(ft) && jl_is_concrete_type(et));
@@ -868,14 +867,13 @@ JL_DLLEXPORT jl_value_t *jl_new_structt(jl_datatype_t *type, jl_value_t *tup)
     jl_value_t *jv = jl_gc_alloc(ptls, jl_datatype_size(type), type);
     jl_value_t *fi = NULL;
     JL_GC_PUSH2(&jv, &fi);
-    for (size_t i = 0; i < na; i++) {
+    for (size_t i = 0; i < nargs; i++) {
         jl_value_t *ft = jl_field_type(type, i);
         fi = jl_get_nth_field(tup, i);
         if (!jl_isa(fi, ft))
             jl_type_error("new", ft, fi);
         jl_set_nth_field(jv, i, fi);
     }
-    init_struct_tail(type, jv, na);
     JL_GC_POP();
     return jv;
 }

test/core.jl

@@ -6854,31 +6854,28 @@ g29828() = 2::Any[String][1]
 struct SplatNew{T}
     x::Int8
     y::T
-    SplatNew{T}(args...) where {T} = new(0,args...,1)
+    SplatNew{T}(args...) where {T} = new(0, args..., 1)
     SplatNew(args...) = new{Float32}(args...)
     SplatNew{Any}(args...) = new(args...)
     SplatNew{Tuple{Int16}}(args...) = new([2]..., args...)
-    SplatNew{Int8}() = new(1,2,3)
+    SplatNew{Int8}() = new(1, 2, 3)
 end
 let x = SplatNew{Int16}()
     @test x.x === Int8(0)
     @test x.y === Int16(1)
 end
-@test_throws ArgumentError SplatNew{Int16}(1)
-let x = SplatNew(3,2)
+@test_throws ArgumentError("new: too many arguments (expected 2)") SplatNew{Int16}(1)
+let x = SplatNew(3, 2)
     @test x.x === Int8(3)
     @test x.y === 2.0f0
 end
-@test_throws ArgumentError SplatNew(1,2,3)
-let x = SplatNew{Any}(1)
-    @test x.x === Int8(1)
-    @test !isdefined(x, :y)
-end
+@test_throws ArgumentError("new: too many arguments (expected 2)") SplatNew(1, 2, 3)
+@test_throws ArgumentError("new: too few arguments (expected 2)") SplatNew{Any}(1)
 let x = SplatNew{Tuple{Int16}}((1,))
     @test x.x === Int8(2)
     @test x.y === (Int16(1),)
 end
-@test_throws ArgumentError SplatNew{Int8}()
+@test_throws ArgumentError("new: too many arguments (expected 2)")  SplatNew{Int8}()
 
 # Issue #31357 - Missed assignment in nested try/catch
 function foo31357(b::Bool)