ERROR: TypeError: in <:, expected Type, got Vararg{Pair{String, String}} about cthulhu.jl HOT 13 CLOSED

Cthulhu. Basically, 1.7 broke Cthulhu. It works on 1.6.

from cthulhu.jl.

That would be great, but I'm sure we can figure it out. I am swamped by yet new SnoopCompile-related analyses (really excited about a new idea I want to try...) and the fact that I can continue to work on 1.6 is a disincentive for me to fix this...

from cthulhu.jl.

As for the documentation, I filed JuliaLang/julia#39239

from cthulhu.jl.

The Vararg change on 1.7 hasn't propagated to many packages that reach into Julia's internals. A PR would be great, but if you're not up for that you can either twiddle your thumbs until someone fixes it or use release-1.6 in the meantime.

from cthulhu.jl.

I am not sure I understand: where does this need to be fixed? In Cthulhu or in CxxWrap?

from cthulhu.jl.

For future reference, this is about the effects of JuliaLang/julia#38136

I'd like to help, and am now looking at the code, but it's (for me) not exactly self-explaining; in particular, the intent of various functions is unclear, making it hard to guess what the right way to adjust things is.

So for the immediate error here, stripType presumably needs to be adjusted, as the error occurs in there -- or the mistake is that stripType is called in the first place.

If stripType needs to be adjusted... then I am still not sure how so, as I don't know what the intent of stripType is?

Beyond that, it baffles me is Vararg{Pair{String, String}} <: Type now produces an error -- seemingly indicating that the VarArg isn't a type anymore?

So perhaps the deeper problem then is that Vararg apparently is not a type anymore? Comparing https://docs.julialang.org/en/v1/base/base/#Core.Vararg and https://docs.julialang.org/en/v1.7-dev/base/base/#Core.Vararg I notice in the top line that Core.Vararg changed from "type" to "constant"; but the text still says "The type Vararg{T,N} ". So it seems to me that at least one of the following holds:

1. there is a bug and Vararg{Pair{String, String}} should be a type after all
2. the above documentation needs to be fixed for 1.7
3. I am misunderstanding something (quite likely :-) ).

from cthulhu.jl.

I hope it is not inappropriate for me to tag @Keno here, but since he made those Vararg changes to Julia, he might be in the best position to answer the above?

from cthulhu.jl.

Beyond that, it baffles me is Vararg{Pair{String, String}} <: Type now produces an error -- seemingly indicating that the VarArg isn't a type anymore?

Isn't that almost precisely the title of JuliaLang/julia#38136?

from cthulhu.jl.

If that's what it says, great; I must admit that the role of DataType still is a bit fuzzy to me because of what its docstring says; I used to think it was the "type of types", but the "DataType represents explicitly declared types that have names, explicitly declared supertypes, and, optionally, parameters." which to me reads as if "but" follows, something like "... but there are other types". If that's wrong and my initial simpler assumption is true after all, I am glad to hear that!

But then I still think the manual is wrong for stating "The type Vararg{T,N} ..." ?

from cthulhu.jl.

If it says that in the 1.7 manual, yes, that should perhaps be changed. I don't know which spot you're referring to so I can't easily check.

from cthulhu.jl.

but there are other types

On 1.6 (I don't have 1.7 locally):

julia> subtypes(Type)
4-element Vector{Any}:
 Core.TypeofBottom
 DataType
 Union
 UnionAll

and then there's the confusing fact that Type{T} is a DataType.

from cthulhu.jl.

Indeed that's confusing:

julia> Type{Type} isa DataType
true   # as you wrote....

julia> supertypes(DataType)
(DataType, Type{T}, Any)    # whaaaat?!

Thanks for teaching me about subtypes ;-) I immediately learned that Any is a subtype of itself (which ... kinda makes some sense, perhaps, I guess.... my head hurts... but I guess that's what I get for getting involved with Cthulhu... ;-)

from cthulhu.jl.

I immediately learned that Any is a subtype of itself (which ... kinda makes some sense, perhaps, I guess.... my head hurts.

😄. Everything gets easier when you start thinking of types in terms of sets. Int is a set with one object in it, Integer is a set with several (and expandable to more). Despite the notation, :< is equivalent to the set-theoretic ⊆ rather than strict ⊂. typeintersect is just set-intersection.

from cthulhu.jl.