don't use inferred return type

Author: KDr2

src/tapedfunction.jl

@@ -29,15 +29,15 @@ struct ReturnInstruction{T} <: AbstractInstruction
     arg::TypedVar{T}
 end
 
-mutable struct TapedFunction{F, T}
+mutable struct TapedFunction{F}
     func::F # maybe a function, a constructor, or a callable object
     arity::Int
     ir::Core.CodeInfo
     tape::RawTape
     unified_tape::Vector{FunctionWrapper{Nothing, Tuple{TapedFunction}}}
     counter::Int
     bindings::Dict{Symbol, Any}
-    retval::TypedVar{T}
+    retval::TypedVar{<:Any}
 
     function TapedFunction(f::F, args...; cache=false) where {F}
         args_type = _accurate_typeof.(args)
@@ -55,17 +55,16 @@ mutable struct TapedFunction{F, T}
         utape = Vector{FunctionWrapper{Nothing, Tuple{TapedFunction}}}()
         bindings = translate!(tape, ir)
 
-        T = isa(ir.rettype, Core.Const) ? typeof(ir.rettype.val) : ir.rettype
-        tf = new{F, T}(f, length(args), ir, tape, utape, 1,
-                                bindings, TypedVar{T}(:none))
+        tf = new{F}(f, length(args), ir, tape, utape, 1,
+                                bindings, TypedVar{Any}(:none))
         TRCache[cache_key] = tf # set cache
         # unify!(tf)
         return tf
     end
 
-    function TapedFunction(tf::TapedFunction{F, T}) where {F, T}
-        new{F, T}(tf.func, tf.arity, tf.ir, tf.tape, tf.unified_tape,
-                  tf.counter, tf.bindings, tf.retval)
+    function TapedFunction(tf::TapedFunction{F}) where {F}
+        new{F}(tf.func, tf.arity, tf.ir, tf.tape, tf.unified_tape,
+                  tf.counter, tf.bindings, TypedVar{Any}(:none))
     end
 end
 

test/tapedtask.jl

@@ -18,7 +18,7 @@
         @test consume(ttask) == 2
         @test consume(ttask) == 3
 
-        # @inferred Libtask.TapedFunction(f)
+        @inferred Libtask.TapedFunction(f)
     end
 
     # Test case 2: heap allocated objects are shallowly copied.