Despecialize make_tracer #540

wsmoses · 2025-01-16T05:13:46Z

Trying to speed up compile time

github-actions · 2025-01-16T06:14:05Z

src/Reactant.jl

@@ -23,14 +23,23 @@ else
    const ReactantFloat = Union{Float16,Float32,Float64}
 end

-const ReactantInt = Union{Int8,UInt8,Int16,UInt16,Int32,UInt32,Int64,UInt64}
+@static if isdefined(Core, :BFloat16)
+    const ReactantComplexFloat = Union{Complex{Float16},Complex{Core.BFloat16},Complex{Float32},Complex{Float64}}


[JuliaFormatter] _{reported by reviewdog 🐶}

Suggested change

const ReactantComplexFloat = Union{Complex{Float16},Complex{Core.BFloat16},Complex{Float32},Complex{Float64}}

const ReactantComplexFloat = Union{

Complex{Float16},Complex{Core.BFloat16},Complex{Float32},Complex{Float64}

}

github-actions · 2025-01-16T06:14:05Z

src/Reactant.jl

+
+const ReactantInt = Union{Int8,UInt8,Int16,UInt16,Int32,UInt32,Int64,UInt64,Int128,UInt128}
+
+const ReactantComplexInt = Union{Complex{Int8},Complex{UInt8},Complex{Int16},Complex{UInt16},Complex{Int32},Complex{UInt32},Complex{Int64},Complex{UInt64},Complex{Int128},Complex{UInt128}}


[JuliaFormatter] _{reported by reviewdog 🐶}

Suggested change

const ReactantComplexInt = Union{Complex{Int8},Complex{UInt8},Complex{Int16},Complex{UInt16},Complex{Int32},Complex{UInt32},Complex{Int64},Complex{UInt64},Complex{Int128},Complex{UInt128}}

const ReactantComplexInt = Union{

Complex{Int8},

Complex{UInt8},

Complex{Int16},

Complex{UInt16},

Complex{Int32},

Complex{UInt32},

Complex{Int64},

Complex{UInt64},

Complex{Int128},

Complex{UInt128},

}

github-actions · 2025-01-16T06:14:05Z

src/Reactant.jl

+    Bool,Base.uniontypes(ReactantFloatInt)...,
+    Base.uniontypes(ReactantComplexInt)...,Base.uniontypes(ReactantComplexFloat)...


[JuliaFormatter] _{reported by reviewdog 🐶}

Suggested change

Bool,Base.uniontypes(ReactantFloatInt)...,

Base.uniontypes(ReactantComplexInt)...,Base.uniontypes(ReactantComplexFloat)...

Bool,

Base.uniontypes(ReactantFloatInt)...,

Base.uniontypes(ReactantComplexInt)...,

Base.uniontypes(ReactantComplexFloat)...,

github-actions · 2025-01-16T06:14:07Z

test/tracing.jl

+                (ConcreteRArray{Float64,0}, TracedRArray{Float64,0}, TracedRArray{Float64, 0}),
+                (ConcreteRArray{Float64,1}, TracedRArray{Float64,1}, TracedRArray{Float64, 1}),
+                (ConcreteRArray{Float64,2}, TracedRArray{Float64,2}, TracedRArray{Float64, 2}),
+                (ConcreteRArray{Float64,3}, TracedRArray{Float64,3}, TracedRArray{Float64, 3}),


[JuliaFormatter] _{reported by reviewdog 🐶}

Suggested change

(ConcreteRArray{Float64,0}, TracedRArray{Float64,0}, TracedRArray{Float64, 0}),

(ConcreteRArray{Float64,1}, TracedRArray{Float64,1}, TracedRArray{Float64, 1}),

(ConcreteRArray{Float64,2}, TracedRArray{Float64,2}, TracedRArray{Float64, 2}),

(ConcreteRArray{Float64,3}, TracedRArray{Float64,3}, TracedRArray{Float64, 3}),

(

ConcreteRArray{Float64,0},

TracedRArray{Float64,0},

TracedRArray{Float64,0},

),

(

ConcreteRArray{Float64,1},

TracedRArray{Float64,1},

TracedRArray{Float64,1},

),

(

ConcreteRArray{Float64,2},

TracedRArray{Float64,2},

TracedRArray{Float64,2},

),

(

ConcreteRArray{Float64,3},

TracedRArray{Float64,3},

TracedRArray{Float64,3},

),

github-actions · 2025-01-16T06:14:07Z

test/tracing.jl

+                (Array{Float64,1}, Array{Float64,1}, Array{TracedRNumber{Float64}, 1}),
+                (Array{ConcreteRArray{Float64,2},1}, Array{TracedRArray{Float64,2},1}, Array{TracedRArray{Float64,2}, 1}),


[JuliaFormatter] _{reported by reviewdog 🐶}

Suggested change

(Array{Float64,1}, Array{Float64,1}, Array{TracedRNumber{Float64}, 1}),

(Array{ConcreteRArray{Float64,2},1}, Array{TracedRArray{Float64,2},1}, Array{TracedRArray{Float64,2}, 1}),

(Array{Float64,1}, Array{Float64,1}, Array{TracedRNumber{Float64},1}),

(

Array{ConcreteRArray{Float64,2},1},

Array{TracedRArray{Float64,2},1},

Array{TracedRArray{Float64,2},1},

),

github-actions · 2025-01-16T06:14:07Z

test/tracing.jl


                # Union types
-                (Union{Nothing,Int}, Union{Nothing,Int}),
+                (Union{Nothing,Int}, Union{Nothing,Int}, Union{Nothing, TracedRNumber{Int}}),


[JuliaFormatter] _{reported by reviewdog 🐶}

Suggested change

(Union{Nothing,Int}, Union{Nothing,Int}, Union{Nothing, TracedRNumber{Int}}),

(Union{Nothing,Int}, Union{Nothing,Int}, Union{Nothing,TracedRNumber{Int}}),

github-actions · 2025-01-16T06:14:07Z

test/tracing.jl

                (
                    Union{Nothing,ConcreteRArray{Float64,1}},
                    Union{Nothing,TracedRArray{Float64,1}},
+                    Union{Nothing, TracedRArray{Float64, 1}}


[JuliaFormatter] _{reported by reviewdog 🐶}

Suggested change

Union{Nothing, TracedRArray{Float64, 1}}

Union{Nothing,TracedRArray{Float64,1}},

github-actions · 2025-01-16T06:14:08Z

test/tracing.jl

+                (Ptr{ConcreteRArray{Float64,1}}, Ptr{TracedRArray{Float64,1}}, Ptr{TracedRArray{Float64,1}}),
+                (Core.LLVMPtr{Float64}, Core.LLVMPtr{Float64}, Core.LLVMPtr{TracedRNumber{Float64}}),


[JuliaFormatter] _{reported by reviewdog 🐶}

Suggested change

(Ptr{ConcreteRArray{Float64,1}}, Ptr{TracedRArray{Float64,1}}, Ptr{TracedRArray{Float64,1}}),

(Core.LLVMPtr{Float64}, Core.LLVMPtr{Float64}, Core.LLVMPtr{TracedRNumber{Float64}}),

(

Ptr{ConcreteRArray{Float64,1}},

Ptr{TracedRArray{Float64,1}},

Ptr{TracedRArray{Float64,1}},

),

(

Core.LLVMPtr{Float64},

Core.LLVMPtr{Float64},

Core.LLVMPtr{TracedRNumber{Float64}},

),

github-actions · 2025-01-16T06:14:08Z

test/tracing.jl

                (
                    Core.LLVMPtr{ConcreteRArray{Float64,1}},
                    Core.LLVMPtr{TracedRArray{Float64,1}},
+                    Core.LLVMPtr{TracedRArray{Float64,1}}


[JuliaFormatter] _{reported by reviewdog 🐶}

Suggested change

Core.LLVMPtr{TracedRArray{Float64,1}}

Core.LLVMPtr{TracedRArray{Float64,1}},

),

(

Base.RefValue{Float64},

Base.RefValue{Float64},

Base.RefValue{TracedRNumber{Float64}},

github-actions · 2025-01-16T06:14:08Z

test/tracing.jl

                ),
-                (Base.RefValue{Float64}, Base.RefValue{Float64}),
+                (Base.RefValue{Float64}, Base.RefValue{Float64}, Base.RefValue{TracedRNumber{Float64}}),


[JuliaFormatter] _{reported by reviewdog 🐶}

Suggested change

(Base.RefValue{Float64}, Base.RefValue{Float64}, Base.RefValue{TracedRNumber{Float64}}),

mofeing · 2025-01-16T07:57:09Z

ext/ReactantCUDAExt.jl

-    ::Type{A}, seen::ST, ::Val{mode}, track_numbers
-) where {T,N,A<:CUDA.CuArray{T,N},ST,mode}
+Base.@nospecializeinfer function Reactant.traced_type(
+    @nospecialize(A::Type{<:CUDA.CuArray}), seen::ST, ::Val{mode}, track_numbers


would @nospecialize on ::Val{mode} do sth?

mofeing · 2025-01-16T08:02:18Z

src/Tracing.jl

-    ::Type{<:ConcreteRNumber{T}}, seen, ::Val{mode}, track_numbers
-) where {T,mode}
+for T in (DataType, Module, Nothing, Symbol, AbstractChar, AbstractString, AbstractFloat, Integer, RNumber)
+    @eval Base.@nospecializeinfer function traced_type(@nospecialize(T::Type{<:$T}), seen, mode, track_numbers)


here different Val(mode) would provoke different specializations when its actually not used

Suggested change

@eval Base.@nospecializeinfer function traced_type(@nospecialize(T::Type{<:$T}), seen, mode, track_numbers)

@eval Base.@nospecializeinfer function traced_type(@nospecialize(T::Type{<:$T}), seen, @nospecialize(mode), track_numbers)

mofeing · 2025-01-16T08:03:48Z

src/Tracing.jl

+end
+
+Base.@nospecializeinfer function traced_type(
+    @nospecialize(C::Type{<:Complex}), seen::ST, mode::Val{Mode}, track_numbers::TN


i think we would benefit here too because it's just passed

Suggested change

@nospecialize(C::Type{<:Complex}), seen::ST, mode::Val{Mode}, track_numbers::TN

@nospecialize(C::Type{<:Complex}), seen::ST, @nospecialize(mode::Val{Mode}), track_numbers::TN

mofeing · 2025-01-16T08:04:17Z

src/Tracing.jl

+    end
+end
+
+Base.@nospecializeinfer function traced_type(@nospecialize(T::Type{<:Function}), seen, mode, track_numbers)


Suggested change

Base.@nospecializeinfer function traced_type(@nospecialize(T::Type{<:Function}), seen, mode, track_numbers)

Base.@nospecializeinfer function traced_type(@nospecialize(T::Type{<:Function}), seen, @nospecialize(mode), track_numbers)

mofeing · 2025-01-16T08:08:16Z

src/Tracing.jl

+@inline is_concrete_tuple(x::T2) where {T2} =
+    (x <: Tuple) && !(x === Tuple) && !(x isa UnionAll)


isn't T2 just Type? and because Type is parametric, we could do @nospecialize and maybe @nospecializeinfer too (it always returns Bool)? wdyt @gbaraldi?

Suggested change

@inline is_concrete_tuple(x::T2) where {T2} =

(x <: Tuple) && !(x === Tuple) && !(x isa UnionAll)

@inline @nospecializeinfer is_concrete_tuple(@nospecialize(T)) =

(T <: Tuple) && !(T === Tuple) && !(T isa UnionAll)

mofeing · 2025-01-16T08:08:39Z

src/Tracing.jl

+@inline is_concrete_tuple(x::T2) where {T2} =
+    (x <: Tuple) && !(x === Tuple) && !(x isa UnionAll)
+
+Base.@nospecializeinfer function traced_type(@nospecialize(T::Type{<:Tuple}), seen, mode, track_numbers)


Suggested change

Base.@nospecializeinfer function traced_type(@nospecialize(T::Type{<:Tuple}), seen, mode, track_numbers)

Base.@nospecializeinfer function traced_type(@nospecialize(T::Type{<:Tuple}), seen, @nospecialize(mode), track_numbers)

mofeing · 2025-01-16T08:09:01Z

src/Tracing.jl

+    return Tuple{TT...}
+end
+
+Base.@nospecializeinfer function traced_type(@nospecialize(T::Type{<:NamedTuple}), seen, mode, track_numbers)


Suggested change

Base.@nospecializeinfer function traced_type(@nospecialize(T::Type{<:NamedTuple}), seen, mode, track_numbers)

Base.@nospecializeinfer function traced_type(@nospecialize(T::Type{<:NamedTuple}), seen, @nospecialize(mode), track_numbers)

mofeing · 2025-01-16T08:10:15Z

src/Tracing.jl

@@ -269,13 +271,15 @@ function traced_type(::Type{T}, seen, ::Val{mode}, track_numbers) where {T<:Trac
    end
 end

-function traced_type(::Type{T}, seen, mode, track_numbers) where {T<:XLAArray}
+Base.@nospecializeinfer function traced_type(@nospecialize(T::Type{<:XLAArray}), seen, mode, track_numbers)


Suggested change

Base.@nospecializeinfer function traced_type(@nospecialize(T::Type{<:XLAArray}), seen, mode, track_numbers)

Base.@nospecializeinfer function traced_type(@nospecialize(T::Type{<:XLAArray}), seen, @nospecialize(mode), track_numbers)

mofeing · 2025-01-16T08:10:35Z

src/Tracing.jl

@@ -284,12 +288,17 @@ function traced_type(
 end

 for P in (Ptr, Core.LLVMPtr, Base.RefValue)
-    @eval function traced_type(::Type{P}, seen, mode, track_numbers) where {T,P<:$P{T}}
+    @eval Base.@nospecializeinfer function traced_type(@nospecialize(PT::Type{<:$P}), seen, mode, track_numbers)


Suggested change

@eval Base.@nospecializeinfer function traced_type(@nospecialize(PT::Type{<:$P}), seen, mode, track_numbers)

@eval Base.@nospecializeinfer function traced_type(@nospecialize(PT::Type{<:$P}), seen, @nospecialize(mode), track_numbers)

mofeing · 2025-01-16T08:10:50Z

src/Tracing.jl

        return $P{traced_type(T, seen, mode, track_numbers)}
    end
 end

-function traced_type(::Type{Val{T}}, seen, mode, track_numbers) where {T}
+Base.@nospecializeinfer function traced_type(@nospecialize(VT::Type{<:Val}), seen, mode, track_numbers)


Suggested change

Base.@nospecializeinfer function traced_type(@nospecialize(VT::Type{<:Val}), seen, mode, track_numbers)

Base.@nospecializeinfer function traced_type(@nospecialize(VT::Type{<:Val}), seen, @nospecialize(mode), track_numbers)

mofeing · 2025-01-16T08:13:19Z

src/Tracing.jl

+    @nospecialize(prev::NamedTuple),
    @nospecialize(path),
    mode;
    track_numbers=(),
    kwargs...,
-) where {A,RT}
+)
+    NT = Core.Typeof(prev)
+    A = NT.parameters[1]
+    RT = NT.parameters[2]


what i understood from @nospecialize is that this change should be equivalent?
not 100% sure though

mofeing

didn't know about tracked_numbers... is that for passing the type of the result if using a TracedRArray or so? not sure what is for but probably you want to despecialize it too if you despecialize the T in traced_type

github-actions

Remaining comments which cannot be posted as a review comment to avoid GitHub Rate Limit

JuliaFormatter

[JuliaFormatter] _{reported by reviewdog 🐶}

Reactant.jl/src/Tracing.jl

Lines 353 to 354 in 5742e62

    
           empty!(new_ci.codelocs) 
        
           resize!(new_ci.linetable, 1)                # see note below

[JuliaFormatter] _{reported by reviewdog 🐶}

Reactant.jl/src/Tracing.jl

Line 368 in 5742e62

new_ci.slotflags = UInt8[0x00 for i = 1:4]

[JuliaFormatter] _{reported by reviewdog 🐶}

Reactant.jl/src/Tracing.jl

Line 376 in 5742e62

push!(new_ci.codelocs, 1) # see note below

[JuliaFormatter] _{reported by reviewdog 🐶}

Reactant.jl/src/Tracing.jl

Line 388 in 5742e62

    
           @eval Base.@assume_effects :removable :foldable :nothrow @inline function traced_type(T::Type, mode::Val, track_numbers::Type)

[JuliaFormatter] _{reported by reviewdog 🐶}

Reactant.jl/src/Tracing.jl

Line 390 in 5742e62

$(Expr(:meta, :generated, traced_type_generator))

[JuliaFormatter] _{reported by reviewdog 🐶}

Reactant.jl/src/Tracing.jl

Line 417 in 5742e62

@nospecialize(prev::Union{Base.ExceptionStack, Core.MethodInstance}),

[JuliaFormatter] _{reported by reviewdog 🐶}

Reactant.jl/src/Tracing.jl

Line 534 in 5742e62

    
           function make_tracer(seen, prev::ConcreteRNumber{T}, @nospecialize(path), mode; kwargs...) where {T}

[JuliaFormatter] _{reported by reviewdog 🐶}

Reactant.jl/src/Tracing.jl

Line 689 in 5742e62

    
           seen, @nospecialize(prev::Number), @nospecialize(path), mode; @nospecialize(track_numbers::Type), kwargs...

[JuliaFormatter] _{reported by reviewdog 🐶}

Reactant.jl/src/Tracing.jl

Line 744 in 5742e62

    
           seen, @nospecialize(prev::Array), @nospecialize(path), mode; @nospecialize(track_numbers::Type), kwargs...

[JuliaFormatter] _{reported by reviewdog 🐶}

Reactant.jl/src/Tracing.jl

Lines 774 to 776 in 5742e62

    
           function make_tracer( 
        
               seen, @nospecialize(prev::Tuple), @nospecialize(path), mode; kwargs... 
        
           )

[JuliaFormatter] _{reported by reviewdog 🐶}

Reactant.jl/src/Tracing.jl

Line 834 in 5742e62

    
           function to_rarray_internal(@nospecialize(::TracedRArray), @nospecialize(track_numbers::Type))

[JuliaFormatter] _{reported by reviewdog 🐶}

Reactant.jl/src/Tracing.jl

Lines 837 to 838 in 5742e62

    
           @inline to_rarray_internal(@nospecialize(x::ConcreteRArray), @nospecialize(track_numbers::Type)) = x 
        
           @inline function to_rarray_internal(@nospecialize(x::Array{<:ReactantPrimitive}), @nospecialize(track_numbers::Type))

[JuliaFormatter] _{reported by reviewdog 🐶}

Reactant.jl/src/Tracing.jl

Line 842 in 5742e62

    
           @inline to_rarray_internal(@nospecialize(x::ConcreteRNumber), @nospecialize(track_numbers::Type)) = x

[JuliaFormatter] _{reported by reviewdog 🐶}

Reactant.jl/test/tracing.jl

Lines 97 to 99 in 5742e62

    
           tracedty = traced_type( 
        
               origty, Val(ConcreteToTraced), () 
        
           )

[JuliaFormatter] _{reported by reviewdog 🐶}

Reactant.jl/test/tracing.jl

Lines 102 to 104 in 5742e62

    
           tracedty2 = traced_type( 
        
               origty, Val(ConcreteToTraced), ReactantPrimitive 
        
           )

[JuliaFormatter] _{reported by reviewdog 🐶}

Reactant.jl/test/tracing.jl

Lines 128 to 130 in 5742e62

    
           @test_throws NoFieldMatchError traced_type( 
        
               Node, Val(ArrayToConcrete), () 
        
           )

github-actions · 2025-01-16T15:51:11Z

src/Tracing.jl

-@inline getmap(::Val{T}, ::Val{T}, ::Val{T2}, args...) where {T,T2} = T2
-
-function traced_type(::Type{T}, seen, mode, track_numbers) where {T}
+Base.@nospecializeinfer function traced_type_inner(@nospecialize(T::Type), seen, mode::TraceMode, @nospecialize(track_numbers::Type))


[JuliaFormatter] _{reported by reviewdog 🐶}

Suggested change

Base.@nospecializeinfer function traced_type_inner(@nospecialize(T::Type), seen, mode::TraceMode, @nospecialize(track_numbers::Type))

Base.@nospecializeinfer function traced_type_inner(

@nospecialize(T::Type), seen, mode::TraceMode, @nospecialize(track_numbers::Type)

)

github-actions · 2025-01-16T15:51:11Z

src/Tracing.jl

+for T in (DataType, Module, Nothing, Symbol, AbstractChar, AbstractString, AbstractFloat, Integer, RNumber)
+    @eval Base.@nospecializeinfer function traced_type_inner(@nospecialize(T::Type{<:$T}), seen, mode::TraceMode, @nospecialize(track_numbers::Type))


[JuliaFormatter] _{reported by reviewdog 🐶}

Suggested change

for T in (DataType, Module, Nothing, Symbol, AbstractChar, AbstractString, AbstractFloat, Integer, RNumber)

@eval Base.@nospecializeinfer function traced_type_inner(@nospecialize(T::Type{<:$T}), seen, mode::TraceMode, @nospecialize(track_numbers::Type))

for T in (

DataType,

Module,

Nothing,

Symbol,

AbstractChar,

AbstractString,

AbstractFloat,

Integer,

RNumber,

)

@eval Base.@nospecializeinfer function traced_type_inner(

@nospecialize(T::Type{<:$T}),

seen,

mode::TraceMode,

@nospecialize(track_numbers::Type)

)

github-actions · 2025-01-16T15:51:12Z

src/Tracing.jl

+end
+
+Base.@nospecializeinfer function traced_type_inner(
+    @nospecialize(T::Type{<:ReactantPrimitive}), seen, @nospecialize(mode::TraceMode), @nospecialize(track_numbers::Type)


[JuliaFormatter] _{reported by reviewdog 🐶}

Suggested change

@nospecialize(T::Type{<:ReactantPrimitive}), seen, @nospecialize(mode::TraceMode), @nospecialize(track_numbers::Type)

@nospecialize(T::Type{<:ReactantPrimitive}),

seen,

@nospecialize(mode::TraceMode),

@nospecialize(track_numbers::Type)

github-actions · 2025-01-16T15:51:12Z

src/Tracing.jl

+end
+
+Base.@nospecializeinfer function traced_type_inner(
+    @nospecialize(C::Type{<:Complex}), seen, @nospecialize(mode::TraceMode), @nospecialize(track_numbers::Type)


[JuliaFormatter] _{reported by reviewdog 🐶}

Suggested change

@nospecialize(C::Type{<:Complex}), seen, @nospecialize(mode::TraceMode), @nospecialize(track_numbers::Type)

@nospecialize(C::Type{<:Complex}),

seen,

@nospecialize(mode::TraceMode),

@nospecialize(track_numbers::Type)

github-actions

Remaining comments which cannot be posted as a review comment to avoid GitHub Rate Limit

JuliaFormatter

[JuliaFormatter] _{reported by reviewdog 🐶}

Reactant.jl/src/Tracing.jl

Line 538 in c61d2e1

    
           function make_tracer(seen, prev::ConcreteRNumber{T}, @nospecialize(path), mode; kwargs...) where {T}

[JuliaFormatter] _{reported by reviewdog 🐶}

Reactant.jl/src/Tracing.jl

Line 693 in c61d2e1

    
           seen, @nospecialize(prev::Number), @nospecialize(path), mode; @nospecialize(track_numbers::Type=Union{}), kwargs...

[JuliaFormatter] _{reported by reviewdog 🐶}

Reactant.jl/src/Tracing.jl

Line 746 in c61d2e1

    
           seen, @nospecialize(prev::Array), @nospecialize(path), mode; @nospecialize(track_numbers::Type), kwargs...

[JuliaFormatter] _{reported by reviewdog 🐶}

Reactant.jl/src/Tracing.jl

Lines 776 to 778 in c61d2e1

    
           function make_tracer( 
        
               seen, @nospecialize(prev::Tuple), @nospecialize(path), mode; kwargs... 
        
           )

[JuliaFormatter] _{reported by reviewdog 🐶}

Reactant.jl/src/Tracing.jl

Line 792 in c61d2e1

@nospecialize(track_numbers::Type=Union{}),

[JuliaFormatter] _{reported by reviewdog 🐶}

Reactant.jl/src/Tracing.jl

Line 836 in c61d2e1

    
           function to_rarray_internal(@nospecialize(::TracedRArray), @nospecialize(track_numbers::Type))

[JuliaFormatter] _{reported by reviewdog 🐶}

Reactant.jl/src/Tracing.jl

Lines 839 to 840 in c61d2e1

    
           @inline to_rarray_internal(@nospecialize(x::ConcreteRArray), @nospecialize(track_numbers::Type)) = x 
        
           @inline function to_rarray_internal(@nospecialize(x::Array{<:ReactantPrimitive}), @nospecialize(track_numbers::Type))

[JuliaFormatter] _{reported by reviewdog 🐶}

Reactant.jl/src/Tracing.jl

Line 844 in c61d2e1

    
           @inline to_rarray_internal(@nospecialize(x::ConcreteRNumber), @nospecialize(track_numbers::Type)) = x

[JuliaFormatter] _{reported by reviewdog 🐶}

Reactant.jl/test/tracing.jl

Lines 97 to 99 in c61d2e1

    
           tracedty = traced_type( 
        
               origty, Val(ConcreteToTraced), Union{} 
        
           )

[JuliaFormatter] _{reported by reviewdog 🐶}

Reactant.jl/test/tracing.jl

Lines 102 to 104 in c61d2e1

    
           tracedty2 = traced_type( 
        
               origty, Val(ConcreteToTraced), ReactantPrimitive 
        
           )

[JuliaFormatter] _{reported by reviewdog 🐶}

Reactant.jl/test/tracing.jl

Line 115 in c61d2e1

type, Val(ConcreteToTraced), Union{}

[JuliaFormatter] _{reported by reviewdog 🐶}

Reactant.jl/test/tracing.jl

Line 121 in c61d2e1

Real, Val(Reactant.ArrayToConcrete), Union{}

[JuliaFormatter] _{reported by reviewdog 🐶}

Reactant.jl/test/tracing.jl

Lines 128 to 130 in c61d2e1

    
           @test_throws NoFieldMatchError traced_type( 
        
                  Node, Val(ArrayToConcrete), Union{} 
        
           )

github-actions · 2025-01-16T16:32:03Z

src/Tracing.jl

+    end
+end
+
+Base.@nospecializeinfer function traced_type_inner(@nospecialize(T::Type{<:Function}), seen, mode::TraceMode, @nospecialize(track_numbers::Type))


[JuliaFormatter] _{reported by reviewdog 🐶}

Suggested change

Base.@nospecializeinfer function traced_type_inner(@nospecialize(T::Type{<:Function}), seen, mode::TraceMode, @nospecialize(track_numbers::Type))

Base.@nospecializeinfer function traced_type_inner(

@nospecialize(T::Type{<:Function}),

seen,

mode::TraceMode,

@nospecialize(track_numbers::Type)

)

github-actions · 2025-01-16T16:32:03Z

src/Tracing.jl

+@inline is_concrete_tuple(x::T2) where {T2} =
+    (x <: Tuple) && !(x === Tuple) && !(x isa UnionAll)
+
+Base.@nospecializeinfer function traced_type_inner(@nospecialize(T::Type{<:Tuple}), seen, mode::TraceMode, @nospecialize(track_numbers::Type))


[JuliaFormatter] _{reported by reviewdog 🐶}

Suggested change

Base.@nospecializeinfer function traced_type_inner(@nospecialize(T::Type{<:Tuple}), seen, mode::TraceMode, @nospecialize(track_numbers::Type))

Base.@nospecializeinfer function traced_type_inner(

@nospecialize(T::Type{<:Tuple}),

seen,

mode::TraceMode,

@nospecialize(track_numbers::Type)

)

github-actions · 2025-01-16T16:32:03Z

src/Tracing.jl

+    return Tuple{TT...}
+end
+
+Base.@nospecializeinfer function traced_type_inner(@nospecialize(T::Type{<:NamedTuple}), seen, mode::TraceMode, @nospecialize(track_numbers::Type))


[JuliaFormatter] _{reported by reviewdog 🐶}

Suggested change

Base.@nospecializeinfer function traced_type_inner(@nospecialize(T::Type{<:NamedTuple}), seen, mode::TraceMode, @nospecialize(track_numbers::Type))

Base.@nospecializeinfer function traced_type_inner(

@nospecialize(T::Type{<:NamedTuple}),

seen,

mode::TraceMode,

@nospecialize(track_numbers::Type)

)

github-actions · 2025-01-16T16:32:03Z

src/Tracing.jl

+    return NamedTuple{N,traced_type_inner(V, seen, mode, track_numbers)}
+end
+
+Base.@nospecializeinfer function traced_type_inner(@nospecialize(T::Type{<:AbstractDict}), seen, mode::TraceMode, @nospecialize(track_numbers::Type))


[JuliaFormatter] _{reported by reviewdog 🐶}

Suggested change

Base.@nospecializeinfer function traced_type_inner(@nospecialize(T::Type{<:AbstractDict}), seen, mode::TraceMode, @nospecialize(track_numbers::Type))

Base.@nospecializeinfer function traced_type_inner(

@nospecialize(T::Type{<:AbstractDict}),

seen,

mode::TraceMode,

@nospecialize(track_numbers::Type)

)

github-actions · 2025-01-16T16:32:03Z

src/Tracing.jl

+end
+
+Base.@nospecializeinfer function traced_type_inner(
+    @nospecialize(T0::Type{<:ConcreteRNumber}), seen, mode::TraceMode, @nospecialize(track_numbers::Type)


[JuliaFormatter] _{reported by reviewdog 🐶}

Suggested change

@nospecialize(T0::Type{<:ConcreteRNumber}), seen, mode::TraceMode, @nospecialize(track_numbers::Type)

@nospecialize(T0::Type{<:ConcreteRNumber}),

seen,

mode::TraceMode,

@nospecialize(track_numbers::Type)

github-actions · 2025-01-16T16:32:04Z

src/Tracing.jl

@@ -269,33 +275,125 @@ function traced_type(::Type{T}, seen, ::Val{mode}, track_numbers) where {T<:Trac
    end
 end

-function traced_type(::Type{T}, seen, mode, track_numbers) where {T<:XLAArray}
+Base.@nospecializeinfer function traced_type_inner(@nospecialize(T::Type{<:XLAArray}), seen, mode::TraceMode, @nospecialize(track_numbers::Type))


[JuliaFormatter] _{reported by reviewdog 🐶}

Suggested change

Base.@nospecializeinfer function traced_type_inner(@nospecialize(T::Type{<:XLAArray}), seen, mode::TraceMode, @nospecialize(track_numbers::Type))

Base.@nospecializeinfer function traced_type_inner(

@nospecialize(T::Type{<:XLAArray}),

seen,

mode::TraceMode,

@nospecialize(track_numbers::Type)

)

github-actions · 2025-01-16T16:32:04Z

src/Tracing.jl

-    ::Type{A}, seen::ST, ::Val{mode}, track_numbers
-) where {T,N,A<:Array{T,N},ST,mode}
+Base.@nospecializeinfer function traced_type_inner(
+    @nospecialize(A::Type{<:Array}), seen, mode::TraceMode, @nospecialize(track_numbers::Type)


[JuliaFormatter] _{reported by reviewdog 🐶}

Suggested change

@nospecialize(A::Type{<:Array}), seen, mode::TraceMode, @nospecialize(track_numbers::Type)

@nospecialize(A::Type{<:Array}),

seen,

mode::TraceMode,

@nospecialize(track_numbers::Type)

github-actions · 2025-01-16T16:32:04Z

src/Tracing.jl

    end
 end

 for P in (Ptr, Core.LLVMPtr, Base.RefValue)
-    @eval function traced_type(::Type{P}, seen, mode, track_numbers) where {T,P<:$P{T}}
-        return $P{traced_type(T, seen, mode, track_numbers)}
+    @eval Base.@nospecializeinfer function traced_type_inner(@nospecialize(PT::Type{<:$P}), seen, mode::TraceMode, @nospecialize(track_numbers::Type))


[JuliaFormatter] _{reported by reviewdog 🐶}

Suggested change

@eval Base.@nospecializeinfer function traced_type_inner(@nospecialize(PT::Type{<:$P}), seen, mode::TraceMode, @nospecialize(track_numbers::Type))

@eval Base.@nospecializeinfer function traced_type_inner(

@nospecialize(PT::Type{<:$P}),

seen,

mode::TraceMode,

@nospecialize(track_numbers::Type)

)

github-actions · 2025-01-16T16:32:04Z

src/Tracing.jl

    end
 end

-function traced_type(::Type{Val{T}}, seen, mode, track_numbers) where {T}
-    if traced_type(typeof(T), seen, mode, track_numbers) == typeof(T)
+Base.@nospecializeinfer function traced_type_inner(@nospecialize(VT::Type{<:Val}), seen, @nospecialize(mode::TraceMode), @nospecialize(track_numbers::Type))


[JuliaFormatter] _{reported by reviewdog 🐶}

Suggested change

Base.@nospecializeinfer function traced_type_inner(@nospecialize(VT::Type{<:Val}), seen, @nospecialize(mode::TraceMode), @nospecialize(track_numbers::Type))

Base.@nospecializeinfer function traced_type_inner(

@nospecialize(VT::Type{<:Val}),

seen,

@nospecialize(mode::TraceMode),

@nospecialize(track_numbers::Type)

)

github-actions · 2025-01-16T16:32:04Z

src/Tracing.jl

        return Val{T}
    end
    throw("Val type $(Val{T}) cannot be traced")
 end

+const traced_type_cache = Dict{Tuple{TraceMode, Type}, Dict{Type, Type}}()


[JuliaFormatter] _{reported by reviewdog 🐶}

Suggested change

const traced_type_cache = Dict{Tuple{TraceMode, Type}, Dict{Type, Type}}()

const traced_type_cache = Dict{Tuple{TraceMode,Type},Dict{Type,Type}}()

github-actions · 2025-01-16T17:58:42Z

test/tracing.jl

                tracedty = traced_type(
-                    origty, Reactant.OrderedIdDict(), Val(ConcreteToTraced), ()
+                    origty, Val(ConcreteToTraced), Union{}
                )


[JuliaFormatter] _{reported by reviewdog 🐶}

Suggested change

tracedty = traced_type(

origty, Reactant.OrderedIdDict(), Val(ConcreteToTraced), ()

origty, Val(ConcreteToTraced), Union{}

)

tracedty = traced_type(origty, Val(ConcreteToTraced), Union{})

github-actions · 2025-01-16T17:58:42Z

test/tracing.jl

+                tracedty2 = traced_type(
+                    origty, Val(ConcreteToTraced), ReactantPrimitive
+                )


[JuliaFormatter] _{reported by reviewdog 🐶}

Suggested change

tracedty2 = traced_type(

origty, Val(ConcreteToTraced), ReactantPrimitive

)

tracedty2 = traced_type(origty, Val(ConcreteToTraced), ReactantPrimitive)

github-actions · 2025-01-16T17:58:42Z

test/tracing.jl

@@ -102,36 +112,36 @@ using Test
                TracedRArray{Float64,3},
            ]
                @test_throws Union{ErrorException,String} traced_type(
-                    type, Reactant.OrderedIdDict(), Val(ConcreteToTraced), ()
+                      type, Val(ConcreteToTraced), Union{}


[JuliaFormatter] _{reported by reviewdog 🐶}

Suggested change

type, Val(ConcreteToTraced), Union{}

type, Val(ConcreteToTraced), Union{}

github-actions · 2025-01-16T17:58:42Z

test/tracing.jl

                )
            end
        end
        @testset "traced_type exceptions" begin
            @test_throws TracedTypeError Reactant.traced_type(
-                Real, Reactant.OrderedIdDict(), Val(Reactant.ArrayToConcrete), ()
+                  Real, Val(Reactant.ArrayToConcrete), Union{}


[JuliaFormatter] _{reported by reviewdog 🐶}

Suggested change

Real, Val(Reactant.ArrayToConcrete), Union{}

Real, Val(Reactant.ArrayToConcrete), Union{}

github-actions · 2025-01-16T17:58:42Z

test/tracing.jl

            @test_throws NoFieldMatchError traced_type(
-                Node, Reactant.OrderedIdDict(), Val(ArrayToConcrete), ()
+                   Node, Val(ArrayToConcrete), Union{}
            )


[JuliaFormatter] _{reported by reviewdog 🐶}

Suggested change

@test_throws NoFieldMatchError traced_type(

Node, Reactant.OrderedIdDict(), Val(ArrayToConcrete), ()

Node, Val(ArrayToConcrete), Union{}

)

@test_throws NoFieldMatchError traced_type(Node, Val(ArrayToConcrete), Union{})

github-actions · 2025-01-16T19:39:43Z

ext/ReactantCUDAExt.jl

-    ::Type{A}, seen::ST, ::Val{mode}, track_numbers
-) where {A<:CuTracedArray,ST,mode}
+Base.@nospecializeinfer function Reactant.traced_type_inner(
+    @nospecialize(A::Type{<:CuTracedArray}), seen, mode::Reactant.TraceMode, @nospecialize(track_numbers::Type)


[JuliaFormatter] _{reported by reviewdog 🐶}

Suggested change

@nospecialize(A::Type{<:CuTracedArray}), seen, mode::Reactant.TraceMode, @nospecialize(track_numbers::Type)

@nospecialize(A::Type{<:CuTracedArray}),

seen,

mode::Reactant.TraceMode,

@nospecialize(track_numbers::Type)

github-actions · 2025-01-16T19:39:43Z

ext/ReactantCUDAExt.jl

-    ::Type{A}, seen::ST, ::Val{mode}, track_numbers
-) where {T,N,A<:CUDA.CuArray{T,N},ST,mode}
+Base.@nospecializeinfer function Reactant.traced_type_inner(
+    @nospecialize(A::Type{<:CUDA.CuArray}), seen, mode::Reactant.TraceMode, @nospecialize(track_numbers::Type)


[JuliaFormatter] _{reported by reviewdog 🐶}

Suggested change

@nospecialize(A::Type{<:CUDA.CuArray}), seen, mode::Reactant.TraceMode, @nospecialize(track_numbers::Type)

@nospecialize(A::Type{<:CUDA.CuArray}),

seen,

mode::Reactant.TraceMode,

@nospecialize(track_numbers::Type)

github-actions · 2025-01-16T22:22:36Z

ext/ReactantCUDAExt.jl

        end
    end
 end

 function Reactant.make_tracer(
-    seen, @nospecialize(prev::RT), @nospecialize(path), mode; track_numbers=(), kwargs...
-) where {RT<:CUDA.CuArray}
+    seen, @nospecialize(prev::CUDA.CuArray), @nospecialize(path), mode; @nospecialize(track_numbers::Type=Union{}), kwargs...


[JuliaFormatter] _{reported by reviewdog 🐶}

Suggested change

seen, @nospecialize(prev::CUDA.CuArray), @nospecialize(path), mode; @nospecialize(track_numbers::Type=Union{}), kwargs...

seen,

@nospecialize(prev::CUDA.CuArray),

@nospecialize(path),

mode;

@nospecialize(track_numbers::Type = Union{}),

kwargs...,

github-actions · 2025-01-16T22:22:36Z

ext/ReactantOffsetArraysExt.jl

-) where {T,N,ST,mode}
-    T2 = Reactant.traced_type(T, seen, Val(mode), track_numbers)
+Base.@nospecializeinfer function Reactant.traced_type_inner(
+    @nospecialize(OA::Type{<:OffsetArray}), seen, mode::Reactant.TraceMode, @nospecialize(track_numbers::Type=Union{})


[JuliaFormatter] _{reported by reviewdog 🐶}

Suggested change

@nospecialize(OA::Type{<:OffsetArray}), seen, mode::Reactant.TraceMode, @nospecialize(track_numbers::Type=Union{})

@nospecialize(OA::Type{<:OffsetArray}),

seen,

mode::Reactant.TraceMode,

@nospecialize(track_numbers::Type = Union{})

github-actions · 2025-01-16T22:22:36Z

src/Tracing.jl

+#     $(Expr(:meta, :generated, traced_type_generator))
+# end
+
+Base.@assume_effects :total @inline function traced_type(T::Type, ::Val{mode}, track_numbers::Type) where mode


[JuliaFormatter] _{reported by reviewdog 🐶}

Suggested change

Base.@assume_effects :total @inline function traced_type(T::Type, ::Val{mode}, track_numbers::Type) where mode

Base.@assume_effects :total @inline function traced_type(

T::Type, ::Val{mode}, track_numbers::Type

) where {mode}

github-actions · 2025-01-16T22:22:36Z

src/Tracing.jl

+    if haskey(traced_type_cache, cache_key)
+        cache = traced_type_cache[cache_key]
+    else
+        cache = Dict{Type, Type}()


[JuliaFormatter] _{reported by reviewdog 🐶}

Suggested change

cache = Dict{Type, Type}()

cache = Dict{Type,Type}()

github-actions · 2025-01-16T22:22:36Z

src/Tracing.jl

+        cache = Dict{Type, Type}()
+        traced_type_cache[cache_key] = cache
+    end
+    res1 = traced_type_inner(T, cache, mode, track_numbers)


[JuliaFormatter] _{reported by reviewdog 🐶}

Suggested change

res1 = traced_type_inner(T, cache, mode, track_numbers)

return res1 = traced_type_inner(T, cache, mode, track_numbers)

github-actions · 2025-01-16T22:22:37Z

src/Tracing.jl

    return make_tracer(OrderedIdDict(), x, (), Reactant.ArrayToConcrete; track_numbers)
 end

-function to_rarray_internal(@nospecialize(::TracedRArray), ::Tuple)
+function to_rarray_internal(@nospecialize(::TracedRArray), @nospecialize(track_numbers::Type))


[JuliaFormatter] _{reported by reviewdog 🐶}

Suggested change

function to_rarray_internal(@nospecialize(::TracedRArray), @nospecialize(track_numbers::Type))

function to_rarray_internal(

@nospecialize(::TracedRArray), @nospecialize(track_numbers::Type)

)

github-actions · 2025-01-16T22:22:37Z

src/Tracing.jl

+@inline to_rarray_internal(@nospecialize(x::ConcreteRArray), @nospecialize(track_numbers::Type)) = x
+@inline function to_rarray_internal(@nospecialize(x::Array{<:ReactantPrimitive}), @nospecialize(track_numbers::Type))


[JuliaFormatter] _{reported by reviewdog 🐶}

Suggested change

@inline to_rarray_internal(@nospecialize(x::ConcreteRArray), @nospecialize(track_numbers::Type)) = x

@inline function to_rarray_internal(@nospecialize(x::Array{<:ReactantPrimitive}), @nospecialize(track_numbers::Type))

@inline to_rarray_internal(

@nospecialize(x::ConcreteRArray), @nospecialize(track_numbers::Type)

) = x

@inline function to_rarray_internal(

@nospecialize(x::Array{<:ReactantPrimitive}), @nospecialize(track_numbers::Type)

)

github-actions · 2025-01-16T22:22:37Z

src/Tracing.jl

    return ConcreteRArray(x)
 end

-@inline to_rarray_internal(@nospecialize(x::ConcreteRNumber), ::Tuple) = x
+@inline to_rarray_internal(@nospecialize(x::ConcreteRNumber), @nospecialize(track_numbers::Type)) = x


[JuliaFormatter] _{reported by reviewdog 🐶}

Suggested change

@inline to_rarray_internal(@nospecialize(x::ConcreteRNumber), @nospecialize(track_numbers::Type)) = x

@inline to_rarray_internal(

@nospecialize(x::ConcreteRNumber), @nospecialize(track_numbers::Type)

) = x

github-actions · 2025-01-16T22:22:37Z

test/struct.jl

@@ -22,6 +22,12 @@ mutable struct MutableMockTensor{T,N,A<:AbstractArray{T,N}} <: AbstractArray{T,N
    inds::Vector{Symbol}
 end

+Base.@nospecializeinfer function Reactant.traced_type_inner(@nospecialize(A::Type{<:MockTensor}), seen, mode::Reactant.TraceMode, @nospecialize(track_numbers::Type))


[JuliaFormatter] _{reported by reviewdog 🐶}

Suggested change

Base.@nospecializeinfer function Reactant.traced_type_inner(@nospecialize(A::Type{<:MockTensor}), seen, mode::Reactant.TraceMode, @nospecialize(track_numbers::Type))

Base.@nospecializeinfer function Reactant.traced_type_inner(

@nospecialize(A::Type{<:MockTensor}),

seen,

mode::Reactant.TraceMode,

@nospecialize(track_numbers::Type)

)

github-actions · 2025-01-16T22:22:38Z

test/struct.jl

@@ -22,6 +22,12 @@ mutable struct MutableMockTensor{T,N,A<:AbstractArray{T,N}} <: AbstractArray{T,N
    inds::Vector{Symbol}
 end

+Base.@nospecializeinfer function Reactant.traced_type_inner(@nospecialize(A::Type{<:MockTensor}), seen, mode::Reactant.TraceMode, @nospecialize(track_numbers::Type))
+    T2 = Reactant.traced_type_inner(A.parameters[3], seen, mode, track_numbers)
+    MT = MockTensor{eltype(T2), ndims(A), T2}


[JuliaFormatter] _{reported by reviewdog 🐶}

Suggested change

MT = MockTensor{eltype(T2), ndims(A), T2}

MT = MockTensor{eltype(T2),ndims(A),T2}

Despecialize make_tracer

0adac3c

wsmoses requested review from mofeing, avik-pal and jumerckx January 16, 2025 05:13

wsmoses added 4 commits January 16, 2025 00:16

further despec

86c583c

even more

9639190

even more inference stop

6060012

more testinfra

81a1ace

github-actions bot reviewed Jan 16, 2025

View reviewed changes

fix

7f1d2a5

mofeing reviewed Jan 16, 2025

View reviewed changes

mofeing approved these changes Jan 16, 2025

View reviewed changes

more despec

5742e62

github-actions bot reviewed Jan 16, 2025

View reviewed changes

fixes

c61d2e1

wsmoses force-pushed the despec branch from 79d5029 to c61d2e1 Compare January 16, 2025 16:30

github-actions bot reviewed Jan 16, 2025

View reviewed changes

wsmoses added 2 commits January 16, 2025 12:54

fix

ed7d216

fix

0871a08

github-actions bot reviewed Jan 16, 2025

View reviewed changes

wsmoses added 3 commits January 16, 2025 13:00

fix

5d19fe8

fix

020ef87

fixup

e2238ca

github-actions bot reviewed Jan 16, 2025

View reviewed changes

wsmoses added 3 commits January 16, 2025 14:45

fix

deafe73

more stuff

4d1bd42

fix

67056b8

github-actions bot reviewed Jan 16, 2025

View reviewed changes

wsmoses merged commit 015a748 into main Jan 16, 2025
32 of 39 checks passed

wsmoses deleted the despec branch January 16, 2025 23:14


		const ReactantInt = Union{Int8,UInt8,Int16,UInt16,Int32,UInt32,Int64,UInt64,Int128,UInt128}

		const ReactantComplexInt = Union{Complex{Int8},Complex{UInt8},Complex{Int16},Complex{UInt16},Complex{Int32},Complex{UInt32},Complex{Int64},Complex{UInt64},Complex{Int128},Complex{UInt128}}

		Bool,Base.uniontypes(ReactantFloatInt)...,
		Base.uniontypes(ReactantComplexInt)...,Base.uniontypes(ReactantComplexFloat)...

		(Array{Float64,1}, Array{Float64,1}, Array{TracedRNumber{Float64}, 1}),
		(Array{ConcreteRArray{Float64,2},1}, Array{TracedRArray{Float64,2},1}, Array{TracedRArray{Float64,2}, 1}),

	(Union{Nothing,Int}, Union{Nothing,Int}, Union{Nothing, TracedRNumber{Int}}),
	(Union{Nothing,Int}, Union{Nothing,Int}, Union{Nothing,TracedRNumber{Int}}),

	Union{Nothing, TracedRArray{Float64, 1}}
	Union{Nothing,TracedRArray{Float64,1}},

		(Ptr{ConcreteRArray{Float64,1}}, Ptr{TracedRArray{Float64,1}}, Ptr{TracedRArray{Float64,1}}),
		(Core.LLVMPtr{Float64}, Core.LLVMPtr{Float64}, Core.LLVMPtr{TracedRNumber{Float64}}),

	@eval Base.@nospecializeinfer function traced_type(@nospecialize(T::Type{<:$T}), seen, mode, track_numbers)
	@eval Base.@nospecializeinfer function traced_type(@nospecialize(T::Type{<:$T}), seen, @nospecialize(mode), track_numbers)

	@nospecialize(C::Type{<:Complex}), seen::ST, mode::Val{Mode}, track_numbers::TN
	@nospecialize(C::Type{<:Complex}), seen::ST, @nospecialize(mode::Val{Mode}), track_numbers::TN

	Base.@nospecializeinfer function traced_type(@nospecialize(T::Type{<:Function}), seen, mode, track_numbers)
	Base.@nospecializeinfer function traced_type(@nospecialize(T::Type{<:Function}), seen, @nospecialize(mode), track_numbers)

		@inline is_concrete_tuple(x::T2) where {T2} =
		(x <: Tuple) && !(x === Tuple) && !(x isa UnionAll)

	empty!(new_ci.codelocs)
	resize!(new_ci.linetable, 1) # see note below

	function make_tracer(
	seen, @nospecialize(prev::Tuple), @nospecialize(path), mode; kwargs...
	)

	@inline to_rarray_internal(@nospecialize(x::ConcreteRArray), @nospecialize(track_numbers::Type)) = x
	@inline function to_rarray_internal(@nospecialize(x::Array{<:ReactantPrimitive}), @nospecialize(track_numbers::Type))

	tracedty2 = traced_type(
	origty, Val(ConcreteToTraced), ReactantPrimitive
	)

	@test_throws NoFieldMatchError traced_type(
	Node, Val(ArrayToConcrete), ()
	)

		for T in (DataType, Module, Nothing, Symbol, AbstractChar, AbstractString, AbstractFloat, Integer, RNumber)
		@eval Base.@nospecializeinfer function traced_type_inner(@nospecialize(T::Type{<:$T}), seen, mode::TraceMode, @nospecialize(track_numbers::Type))

	tracedty = traced_type(
	origty, Val(ConcreteToTraced), Union{}
	)

	@test_throws NoFieldMatchError traced_type(
	Node, Val(ArrayToConcrete), Union{}
	)

	const traced_type_cache = Dict{Tuple{TraceMode, Type}, Dict{Type, Type}}()
	const traced_type_cache = Dict{Tuple{TraceMode,Type},Dict{Type,Type}}()

	res1 = traced_type_inner(T, cache, mode, track_numbers)
	return res1 = traced_type_inner(T, cache, mode, track_numbers)

Despecialize make_tracer #540

Despecialize make_tracer #540

Conversation

wsmoses commented Jan 16, 2025

github-actions bot Jan 16, 2025

Choose a reason for hiding this comment

github-actions bot Jan 16, 2025

Choose a reason for hiding this comment

github-actions bot Jan 16, 2025

Choose a reason for hiding this comment

github-actions bot Jan 16, 2025

Choose a reason for hiding this comment

github-actions bot Jan 16, 2025

Choose a reason for hiding this comment

github-actions bot Jan 16, 2025

Choose a reason for hiding this comment

github-actions bot Jan 16, 2025

Choose a reason for hiding this comment

github-actions bot Jan 16, 2025

Choose a reason for hiding this comment

github-actions bot Jan 16, 2025

Choose a reason for hiding this comment

github-actions bot Jan 16, 2025

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

mofeing Jan 16, 2025 • edited Loading

Choose a reason for hiding this comment

mofeing left a comment

Choose a reason for hiding this comment

github-actions bot left a comment

Choose a reason for hiding this comment

github-actions bot Jan 16, 2025

Choose a reason for hiding this comment

github-actions bot Jan 16, 2025

Choose a reason for hiding this comment

github-actions bot Jan 16, 2025

Choose a reason for hiding this comment

github-actions bot Jan 16, 2025

Choose a reason for hiding this comment

github-actions bot left a comment

Choose a reason for hiding this comment

github-actions bot Jan 16, 2025

Choose a reason for hiding this comment

github-actions bot Jan 16, 2025

Choose a reason for hiding this comment

github-actions bot Jan 16, 2025

Choose a reason for hiding this comment

github-actions bot Jan 16, 2025

Choose a reason for hiding this comment

github-actions bot Jan 16, 2025

Choose a reason for hiding this comment

github-actions bot Jan 16, 2025

Choose a reason for hiding this comment

github-actions bot Jan 16, 2025

Choose a reason for hiding this comment

github-actions bot Jan 16, 2025

Choose a reason for hiding this comment

github-actions bot Jan 16, 2025

Choose a reason for hiding this comment

github-actions bot Jan 16, 2025

Choose a reason for hiding this comment

github-actions bot Jan 16, 2025

Choose a reason for hiding this comment

github-actions bot Jan 16, 2025

Choose a reason for hiding this comment

github-actions bot Jan 16, 2025

Choose a reason for hiding this comment

github-actions bot Jan 16, 2025

Choose a reason for hiding this comment

github-actions bot Jan 16, 2025

Choose a reason for hiding this comment

mofeing Jan 16, 2025 •

edited

Loading

	MT = MockTensor{eltype(T2), ndims(A), T2}
	MT = MockTensor{eltype(T2),ndims(A),T2}