typename is not fully optimized away

[JeffBezanson]

see #30420

For example

julia> f() = Base.typename(Int)

julia> @code_typed f()
CodeInfo(
1 ─ %1 = Base.typename::Const(typename, false)
│   %2 = invoke %1(Main.Int::DataType)::Const(Int64, false)
└──      return %2
) => TypeName

The called method is just

typename(a::DataType) = a.name

so it should be inlineable, and we know accessing DataType's name is nothrow and constant, so it's not clear why this call isn't removed.

[JeffBezanson]

typename has its own t-func. Commenting that out at least leads to inlining:

julia> @code_typed f()
CodeInfo(
1 ─ %1 = Main.Int::Const(Int64, false)
│   %2 = (Base.getfield)(%1, :name)::TypeName
└──      return %2
) => TypeName

[timholy]

Has nothing to do with typename (though getfield seems close), but possibly related? #30222 (comment)

[martinholters]

Remarkably

julia> Core.Compiler.getfield_tfunc(Core.Compiler.Const(Int64, false), Core.Compiler.Const(:name, false))
Core.Compiler.Const(Int64, false)

So why is the getfield call inferred as Typename while typename is inferred to the narrower Const(Int64, false)?

typename has its own t-func.

After unsuccessfully looking for a tfunc in tfuncs.jl, I guess you are referring to

julia/base/compiler/abstractinterpretation.jl

Lines 764 to 765 in 59314a9

	elseif length(argtypes) == 2 && istopfunction(f, :typename)
	return typename_static(argtypes[2])

right?

[martinholters]

OTOH:

julia> f1() = Base.typename(Int)
f1 (generic function with 1 method)

julia> f2() = Int.name
f2 (generic function with 1 method)

julia> g1() = f1().wrapper
g1 (generic function with 1 method)

julia> g2() = f2().wrapper
g2 (generic function with 1 method)

julia> @code_typed f1()
CodeInfo(
1 ─ %1 = Base.typename::Const(typename, false)
│   %2 = invoke %1(Main.Int::DataType)::Const(Int64, false)
└──      return %2
) => TypeName

julia> @code_typed f2()
CodeInfo(
1 ─ %1 = Main.Int::Const(Int64, false)
│   %2 = (Base.getfield)(%1, :name)::TypeName
└──      return %2
) => TypeName

julia> @code_typed g1()
CodeInfo(
1 ─ %1 = Base.typename::typeof(typename)
│        invoke %1(Main.Int::DataType)::TypeName
└──      return Int64
) => Type{Int64}

julia> @code_typed g2()
CodeInfo(
1 ─     return Int64
) => Type{Int64}

So maybe the Typename vs. Const(...) difference noted above does not lead to any difference in practice and not special-casing typename is strictly better?

[laborg]

Apparently fixed on master:

julia> f1() = Base.typename(Int)
f1 (generic function with 1 method)

julia> f2() = Int.name
f2 (generic function with 1 method)

julia> g1() = f1().wrapper
g1 (generic function with 1 method)

julia> g2() = f2().wrapper
g2 (generic function with 1 method)

julia> @code_typed f1()
CodeInfo(
1 ─     return $(QuoteNode(typename(Int64)))
) => Core.TypeName

julia> @code_typed f2()
CodeInfo(
1 ─     return $(QuoteNode(typename(Int64)))
) => Core.TypeName

julia> @code_typed g1()
CodeInfo(
1 ─     return Int64
) => Type{Int64}

julia> @code_typed g2()
CodeInfo(
1 ─     return Int64
) => Type{Int64}