Revert "improve performance issue of @nospecialize-d keyword func call (#47059)"

This reverts commit 95cfd62.

Author: KristofferC

base/boot.jl

@@ -620,8 +620,7 @@ end
 
 NamedTuple() = NamedTuple{(),Tuple{}}(())
 
-eval(Core, :(NamedTuple{names}(args::Tuple) where {names} =
-             $(Expr(:splatnew, :(NamedTuple{names,typeof(args)}), :args))))
+NamedTuple{names}(args::Tuple) where {names} = NamedTuple{names,typeof(args)}(args)
 
 using .Intrinsics: sle_int, add_int
 

base/compiler/abstractinterpretation.jl

@@ -2180,16 +2180,16 @@ function abstract_eval_statement_expr(interp::AbstractInterpreter, e::Expr, vtyp
     elseif ehead === :splatnew
         t, isexact = instanceof_tfunc(abstract_eval_value(interp, e.args[1], vtypes, sv))
         nothrow = false # TODO: More precision
-        if length(e.args) == 2 && isconcretedispatch(t) && !ismutabletype(t)
+        if length(e.args) == 2 && isconcretetype(t) && !ismutabletype(t)
             at = abstract_eval_value(interp, e.args[2], vtypes, sv)
             n = fieldcount(t)
             if isa(at, Const) && isa(at.val, Tuple) && n == length(at.val::Tuple) &&
-                let t = t, at = at; all(i::Int->getfield(at.val::Tuple, i) isa fieldtype(t, i), 1:n); end
-                nothrow = isexact
+                let t = t, at = at; _all(i->getfield(at.val::Tuple, i) isa fieldtype(t, i), 1:n); end
+                nothrow = isexact && isconcretedispatch(t)
                 t = Const(ccall(:jl_new_structt, Any, (Any, Any), t, at.val))
-            elseif isa(at, PartialStruct) && at ⊑ᵢ Tuple && n == length(at.fields::Vector{Any}) &&
-                let t = t, at = at; all(i::Int->(at.fields::Vector{Any})[i] ⊑ᵢ fieldtype(t, i), 1:n); end
-                nothrow = isexact
+            elseif isa(at, PartialStruct) && at ⊑ Tuple && n == length(at.fields::Vector{Any}) &&
+                let t = t, at = at; _all(i->(at.fields::Vector{Any})[i] ⊑ fieldtype(t, i), 1:n); end
+                nothrow = isexact && isconcretedispatch(t)
                 t = PartialStruct(t, at.fields::Vector{Any})
             end
         end

base/compiler/ssair/passes.jl

@@ -401,16 +401,6 @@ function lift_leaves(compact::IncrementalCompact,
                 end
                 lift_arg!(compact, leaf, cache_key, def, 1+field, lifted_leaves)
                 continue
-            # NOTE we can enable this, but most `:splatnew` expressions are transformed into
-            #      `:new` expressions by the inlinear
-            # elseif isexpr(def, :splatnew) && length(def.args) == 2 && isa(def.args[2], AnySSAValue)
-            #     tplssa = def.args[2]::AnySSAValue
-            #     tplexpr = compact[tplssa][:inst]
-            #     if is_known_call(tplexpr, tuple, compact) && 1 ≤ field < length(tplexpr.args)
-            #         lift_arg!(compact, tplssa, cache_key, tplexpr, 1+field, lifted_leaves)
-            #         continue
-            #     end
-            #     return nothing
             elseif is_getfield_captures(def, compact)
                 # Walk to new_opaque_closure
                 ocleaf = def.args[2]
@@ -479,7 +469,7 @@ function lift_arg!(
         end
     end
     lifted_leaves[cache_key] = LiftedValue(lifted)
-    return nothing
+    nothing
 end
 
 function walk_to_def(compact::IncrementalCompact, @nospecialize(leaf))

base/compiler/tfuncs.jl

@@ -407,19 +407,11 @@ add_tfunc(Core.sizeof, 1, 1, sizeof_tfunc, 1)
 function nfields_tfunc(@nospecialize(x))
     isa(x, Const) && return Const(nfields(x.val))
     isa(x, Conditional) && return Const(0)
-    xt = widenconst(x)
-    x = unwrap_unionall(xt)
+    x = unwrap_unionall(widenconst(x))
     isconstType(x) && return Const(nfields(x.parameters[1]))
     if isa(x, DataType) && !isabstracttype(x)
-        if x.name === Tuple.name
-            isvatuple(x) && return Int
-            return Const(length(x.types))
-        elseif x.name === _NAMEDTUPLE_NAME
-            length(x.parameters) == 2 || return Int
-            names = x.parameters[1]
-            isa(names, Tuple{Vararg{Symbol}}) || return nfields_tfunc(rewrap_unionall(x.parameters[2], xt))
-            return Const(length(names))
-        else
+        if !(x.name === Tuple.name && isvatuple(x)) &&
+           !(x.name === _NAMEDTUPLE_NAME && !isconcretetype(x))
             return Const(isdefined(x, :types) ? length(x.types) : length(x.name.names))
         end
     end
@@ -1660,12 +1652,6 @@ function apply_type_tfunc(@nospecialize(headtypetype), @nospecialize args...)
     end
     if istuple
         return Type{<:appl}
-    elseif isa(appl, DataType) && appl.name === _NAMEDTUPLE_NAME && length(appl.parameters) == 2 &&
-           (appl.parameters[1] === () || appl.parameters[2] === Tuple{})
-        # if the first/second parameter of `NamedTuple` is known to be empty,
-        # the second/first argument should also be empty tuple type,
-        # so refine it here
-        return Const(NamedTuple{(),Tuple{}})
     end
     ans = Type{appl}
     for i = length(outervars):-1:1

base/namedtuple.jl

@@ -335,27 +335,22 @@ reverse(nt::NamedTuple) = NamedTuple{reverse(keys(nt))}(reverse(values(nt)))
 end
 
 """
-    structdiff(a::NamedTuple, b::Union{NamedTuple,Type{NamedTuple}})
+    structdiff(a::NamedTuple{an}, b::Union{NamedTuple{bn},Type{NamedTuple{bn}}}) where {an,bn}
 
 Construct a copy of named tuple `a`, except with fields that exist in `b` removed.
 `b` can be a named tuple, or a type of the form `NamedTuple{field_names}`.
 """
 function structdiff(a::NamedTuple{an}, b::Union{NamedTuple{bn}, Type{NamedTuple{bn}}}) where {an, bn}
     if @generated
         names = diff_names(an, bn)
-        isempty(names) && return (;) # just a fast pass
         idx = Int[ fieldindex(a, names[n]) for n in 1:length(names) ]
         types = Tuple{Any[ fieldtype(a, idx[n]) for n in 1:length(idx) ]...}
         vals = Any[ :(getfield(a, $(idx[n]))) for n in 1:length(idx) ]
-        return :( NamedTuple{$names,$types}(($(vals...),)) )
+        :( NamedTuple{$names,$types}(($(vals...),)) )
     else
         names = diff_names(an, bn)
-        # N.B this early return is necessary to get a better type stability,
-        # and also allows us to cut off the cost from constructing
-        # potentially type unstable closure passed to the `map` below
-        isempty(names) && return (;)
         types = Tuple{Any[ fieldtype(typeof(a), names[n]) for n in 1:length(names) ]...}
-        return NamedTuple{names,types}(map(n::Symbol->getfield(a, n), names))
+        NamedTuple{names,types}(map(Fix1(getfield, a), names))
     end
 end
 

test/compiler/inference.jl

@@ -1540,11 +1540,6 @@ end
 @test nfields_tfunc(Tuple{Int, Vararg{Int}}) === Int
 @test nfields_tfunc(Tuple{Int, Integer}) === Const(2)
 @test nfields_tfunc(Union{Tuple{Int, Float64}, Tuple{Int, Int}}) === Const(2)
-@test nfields_tfunc(@NamedTuple{a::Int,b::Integer}) === Const(2)
-@test nfields_tfunc(NamedTuple{(:a,:b),T} where T<:Tuple{Int,Integer}) === Const(2)
-@test nfields_tfunc(NamedTuple{(:a,:b)}) === Const(2)
-@test nfields_tfunc(NamedTuple{names,Tuple{Any,Any}} where names) === Const(2)
-@test nfields_tfunc(Union{NamedTuple{(:a,:b)},NamedTuple{(:c,:d)}}) === Const(2)
 
 using Core.Compiler: typeof_tfunc
 @test typeof_tfunc(Tuple{Vararg{Int}}) == Type{Tuple{Vararg{Int,N}}} where N
@@ -2369,13 +2364,6 @@ end |> only === Int
 # Equivalence of Const(T.instance) and T for singleton types
 @test Const(nothing) ⊑ Nothing && Nothing ⊑ Const(nothing)
 
-# `apply_type_tfunc` should always return accurate result for empty NamedTuple case
-import Core: Const
-import Core.Compiler: apply_type_tfunc
-@test apply_type_tfunc(Const(NamedTuple), Const(()), Type{T} where T<:Tuple{}) === Const(typeof((;)))
-@test apply_type_tfunc(Const(NamedTuple), Const(()), Type{T} where T<:Tuple) === Const(typeof((;)))
-@test apply_type_tfunc(Const(NamedTuple), Tuple{Vararg{Symbol}}, Type{Tuple{}}) === Const(typeof((;)))
-
 # Don't pessimize apply_type to anything worse than Type and yield Bottom for invalid Unions
 @test only(Base.return_types(Core.apply_type, Tuple{Type{Union}})) == Type{Union{}}
 @test only(Base.return_types(Core.apply_type, Tuple{Type{Union},Any})) == Type

test/compiler/inline.jl

@@ -1749,48 +1749,6 @@ f_ifelse_3(a, b) = Core.ifelse(a, true, b)
 @test fully_eliminated(f_ifelse_2, Tuple{Any, Any}; retval=Core.Argument(3))
 @test !fully_eliminated(f_ifelse_3, Tuple{Any, Any})
 
-# inline_splatnew for abstract `NamedTuple`
-@eval construct_splatnew(T, fields) = $(Expr(:splatnew, :T, :fields))
-for tt = Any[(Int,Int), (Integer,Integer), (Any,Any)]
-    let src = code_typed1(tt) do a, b
-            construct_splatnew(NamedTuple{(:a,:b),typeof((a,b))}, (a,b))
-        end
-        @test count(issplatnew, src.code) == 0
-        @test count(isnew, src.code) == 1
-    end
-end
-
-# optimize away `NamedTuple`s used for handling `@nospecialize`d keyword-argument
-# https://github.com/JuliaLang/julia/pull/47059
-abstract type CallInfo end
-struct NewInstruction
-    stmt::Any
-    type::Any
-    info::CallInfo
-    line::Int32
-    flag::UInt8
-    function NewInstruction(@nospecialize(stmt), @nospecialize(type), @nospecialize(info::CallInfo),
-                            line::Int32, flag::UInt8)
-        return new(stmt, type, info, line, flag)
-    end
-end
-@nospecialize
-function NewInstruction(newinst::NewInstruction;
-    stmt=newinst.stmt,
-    type=newinst.type,
-    info::CallInfo=newinst.info,
-    line::Int32=newinst.line,
-    flag::UInt8=newinst.flag)
-    return NewInstruction(stmt, type, info, line, flag)
-end
-@specialize
-let src = code_typed1((NewInstruction,Any,Any,CallInfo)) do newinst, stmt, type, info
-        NewInstruction(newinst; stmt, type, info)
-    end
-    @test count(issplatnew, src.code) == 0
-    @test count(iscall((src,NamedTuple)), src.code) == 0
-    @test count(isnew, src.code) == 1
-end
 
 # Test that inlining can still use nothrow information from concrete-eval
 # even if the result itself is too big to be inlined, and nothrow is not

test/compiler/irutils.jl

@@ -8,7 +8,6 @@ get_code(args...; kwargs...) = code_typed1(args...; kwargs...).code
 
 # check if `x` is a statement with a given `head`
 isnew(@nospecialize x) = isexpr(x, :new)
-issplatnew(@nospecialize x) = isexpr(x, :splatnew)
 isreturn(@nospecialize x) = isa(x, ReturnNode)
 
 # check if `x` is a dynamic call of a given function