Started to use TypeVar but not there yet. Seems to fail because of

JuliaLang/julia#9043

src/helpers.jl

@@ -1,14 +1,15 @@
-# helper useful for users
+# helpers useful for users
 export deparameterize_type
 
 @doc """Removes type parameters from types, e.g. Array{Int}->Array.
  
  It is often useful to make an associated type with this to match
  against methods which do not specialize on the type parameters.
- """ -> deparameterize_type(A::Type) = eval(A.name.module,
-  A.name.name)::DataType
+ """ ->
+deparameterize_type(A::Type) = eval(A.name.module, A.name.name)::DataType
 
-###############
+# Internal helpers
+##################
 function eval_curmod(expr::Union(Symbol,Expr,QuoteNode))
  # evaluates a symbol or expression in the current module.
  # I.e. the one where the macro definition is.
@@ -36,6 +37,53 @@ function Base.done(lns::Lines, nr)
  end
 end
 
+
+## Parsing
+####
+# translate a symbol in a array of expressions and/or symbols
+function translate!(ex::Vector{Any}, di::Dict)
+ for (i,e) in enumerate(ex)
+ if isa(e, Symbol)
+ ex[i] = get(di, e, e)
+ else
+ translate!(e.args, di)
+ end
+ end
+ nothing
+end
+
+# expressions like :(I<:Int) are not parsed into TypeVar expressions
+# but subtype comparisons. This function translates this
+function subt2tvar!(exs::Vector{Any})
+ for (i,ex) in enumerate(exs)
+ if isa(ex, Symbol)
+ # do nothing
+ elseif ex.head==:comparison
+ exs[i] = Expr(:<:, ex.args[1], ex.args[3])
+ else
+ subt2tvar!(ex.args)
+ end
+ end
+ nothing
+end
+
+function tvar2tvar!(exs::Vector{Any})
+ # tranlates x<:Int -> TypeVar(:X, Int)
+ for (i,ex) in enumerate(exs)
+ if isa(ex, Symbol)
+ # do nothing
+ elseif ex.head==:<:
+ var = ex.args[1]
+ exs[i] = :(TypeVar(symbol($(string(var))), $(ex.args[2])))
+ else
+ tvar2tvar!(ex.args)
+ end
+ end
+ nothing
+end
+
+
+
 # function return_types_v2(f::Function, typs::ANY)
 # # for some reason this function take forever to JIT. (about 4 secs!)
 # a = code_typed(f, typs)

src/traitdef.jl

@@ -135,18 +135,20 @@ function parsefnstypes!(outfns, ln)
  function parsefn(def)
  # Parse to get function signature.
  # parses f(X,Y), f{X <:T}(X,Y) and X+Y
+ tvars = Any[]
  if isa(def.args[1], Symbol)
- fn =  def.args[1]
+ fn = def.args[1]
  elseif def.args[1].head==:curly
- fn = def.args[1].args[1]
- # todo
+ fn = def.args[1].args[1]
+ # get
+ tvars = def.args[1].args[2:end]
  else
  throw(TraitException(
  "Something went wrong parsing the trait definition body with line:\n$ln"))
  end
  argtype = :()
  append!(argtype.args, def.args[2:end])
- return fn, argtype # typvars
+ return fn, argtype, tvars
  end
  function parseret!(rettype, ln)
  # parse to get return types
@@ -170,7 +172,7 @@ function parsefnstypes!(outfns, ln)
 
  if ln.head==:(->) # f1(X,Y) -> x
  parseret!(rettype, ln)
- fn, argtype = parsefn(ln.args[1])
+ fn, argtype, tvars = parsefn(ln.args[1])
  elseif ln.head==:call # either f1(X,Y) or X + Y -> Z
  if isa(ln.args[end], Expr) && ln.args[end].head==:(->) # X + Y -> Z
  def = Expr(:call)
@@ -185,13 +187,18 @@ function parsefnstypes!(outfns, ln)
  def = ln
  rettype = :((Any...))
  end
- fn, argtype = parsefn(def)
+ fn, argtype, tvars = parsefn(def)
  else
  throw(TraitException(
  "Something went wrong parsing the trait definition body with line:\n$ln"))
  end
  # replace types with constraints by TypeVars
- #...
+ trans = Dict(zip([t.args[1] for t in tvars], tvars)) # this will error if there is a type-var without constraints!
+ translate!(argtype.args, trans)
+ tvar2tvar!(argtype.args)
+ subt2tvar!(rettype.args)
+ translate!(rettype.args, trans)
+ tvar2tvar!(rettype.args)
 
  push!(outfns.args, :($fn => ($argtype, $rettype)))
 end

test/runtests.jl

@@ -10,6 +10,7 @@ type A2 end
 
 # BUG flags: set to false once fixed to activate tests
 method_exists_bug = true # see https://github.com/JuliaLang/julia/issues/8959
+method_exists_bug2 = true # see https://github.com/JuliaLang/julia/issues/9043
 
 # manual implementations
 include("manual-traitdef.jl")

test/traitdef.jl

@@ -50,6 +50,20 @@ end)
 a,b,c = Traits.parsebody(td3.args[end])
 @test a==Expr(:dict, :((fn) => ((X,),(Type{X},))))
 
+td4 = :(@traitdef Cr20{X} begin
+ fn{Y<:II}(X,Y) -> Type{X}
+ fn76{K<:FloatingPoint, I<:Integer}(X, Vector{I}, Vector{K}) -> I
+end)
+a,b,c = Traits.parsebody(td4.args[end])
+v = :(TypeVar(symbol("Y"),II))
+t = :(TypeVar(symbol("I"),Integer))
+k = :(TypeVar(symbol("K"),FloatingPoint))
+
+@test a==Expr(:dict, :(fn=>((X,$v),(Type{X},))),
+ :(fn76=>((X,Vector{$t},Vector{$k}),($t,)))
+ )
+
+
 ## test making traits
 
 @traitdef MyIter{X} begin
@@ -150,6 +164,33 @@ end
 
 #--> need to be able to do this in terms of type variables.
 
+# test functions parameterized on non-trait parameters
+
+@traitdef Pr0{X} begin
+ fn75{Y <: Integer}(X, Y) -> Y
+end
+fn75{Y <: Integer}(x::UInt8, y::Y) = y+x
+if method_exists_bug2
+ @test !istrait(Pr0{UInt8})
+else
+ @test istrait(Pr0{UInt8})
+end
+@test !istrait(Pr0{Int8})
+
+fn75(x::UInt8, y::Int8) = y+x
+@test !istrait(Pr0{UInt8}) # this works, not because only for y::Int8 not for all Integers
+
+@traitdef Pr1{X} begin
+ fn76{I<:Integer}(X, Vector{I}) -> I
+end
+fn76{I<:Integer}(x::Uint8, v::Vector{I}) = v[x]
+if method_exists_bug2
+ @test !istrait(Pr1{UInt8})
+else
+ @test istrait(Pr1{UInt8})
+end
+@test !istrait(Pr1{UInt8})
+
 # test constraints
 
 @traitdef Cr20{X} begin