✔ Tracking down "multiple type declarations" · helpdesk (published)

julia> logdensityof(m(x), rand(m(x)))
ERROR: syntax: multiple type declarations for "x"
Stacktrace:
 [1] top-level scope
   @ REPL[74]:1

That's it, pretty useless stack trace. I could see this if you just type garbage at the REPL prompt, but I think what I entered is ok:

julia> dump(:(logdensityof(m(x), rand(m(x)))))
Expr
  head: Symbol call
  args: Array{Any}((3,))
    1: Symbol logdensityof
    2: Expr
      head: Symbol call
      args: Array{Any}((2,))
        1: Symbol m
        2: Symbol x
    3: Expr
      head: Symbol call
      args: Array{Any}((2,))
        1: Symbol rand
        2: Expr
          head: Symbol call
          args: Array{Any}((2,))
            1: Symbol m
            2: Symbol x

Has anyone seen this before? Why no real stack trace? How can I even begin to debug this?

Chad Scherrer (Apr 19 2022 at 13:32):

        ((decl)
         ;; handle var::T declaration by storing the type in the var-info
         ;; record. for non-symbols or globals, emit a type assertion.
         (let ((vi (get tab (cadr e) #f)))
           (if vi
               (begin (if (not (equal? (vinfo:type vi) '(core Any)))
                          (error (string "multiple type declarations for \""
                                         (cadr e) "\"")))
                      (if (assq (cadr e) captvars)
                          (error (string "type of \"" (cadr e)
                                         "\" declared in inner scope")))
                      (vinfo:set-type! vi (caddr e))))))

Sebastian Pfitzner (Apr 19 2022 at 13:33):

Is this a revise issue? The line you pasted isn't related to the error at all, no?

Chad Scherrer (Apr 19 2022 at 13:34):

Chad Scherrer (Apr 19 2022 at 13:35):

Maybe a parser bug? I mean, I may well have an error, but it's getting the stack trace wrong

Sebastian Pfitzner (Apr 19 2022 at 13:36):

Chad Scherrer (Apr 19 2022 at 13:38):

Takafumi Arakaki (tkf) (Apr 19 2022 at 14:44):

julia> logdensityof = m = x = rand = Returns(123);

julia> logdensityof(m(x), rand(m(x)))
123

Mason Protter (Apr 19 2022 at 14:47):

Takafumi Arakaki (tkf) (Apr 19 2022 at 14:50):

Just as yet another sanity check, did you try renaming the variable x to something else? Does the syntax error still report the variable name x? (Otherwise, maybe it's from some dynamically-generated code?)

(I know that these are kind of stupid things to ask but the error in the OP is very mind-boggling...)

Chad Scherrer (Apr 19 2022 at 14:51):

It's tricky, because the problem is in a generated function. I've just tricked it into printing what's generated instead of executing it, having a look at that now

Chad Scherrer (Apr 19 2022 at 14:55):

begin
    begin
        $(Expr(:meta, :inline))
        local _retn
        _args = argvals(_mc)
        _obs = observations(_mc)
        _cfg = merge(_cfg, (args = _args, obs = _obs, pars = _pars))
        x::Vector{Float64} = _args.x
        x::Vector{Float64} = _pars.x
        #= /home/chad/git/Tilde.jl/src/primitives/interpret.jl:52 =#
        (x, _ctx, _retn) = tilde(unsafe_logdensityof, (Accessors.opticcompose)((Accessors.IndexLens)((1,))), static(:x), x, Normal(), _cfg, _ctx)
        #= /home/chad/git/Tilde.jl/src/primitives/interpret.jl:53 =#
        isa(_retn, ReturnNow) && return _retn.value
        for j = :(:)(2, length(x))
            begin
                #= /home/chad/git/Tilde.jl/src/primitives/interpret.jl:52 =#
                (x, _ctx, _retn) = tilde(unsafe_logdensityof, (Accessors.opticcompose)((Accessors.IndexLens)((j,))), static(:x), x, Normal(μ = x[:-(j, 1)]), _cfg, _ctx)
                #= /home/chad/git/Tilde.jl/src/primitives/interpret.jl:53 =#
                isa(_retn, ReturnNow) && return _retn.value
            end
        end
        _retn
    end
end

This could use a little cleaning up, but I wouldn't think it would lead to the error I'm getting

Chad Scherrer (Apr 19 2022 at 14:57):

atreplinit() do repl
    repl.options.iocontext[:compact] = true
end

Chad Scherrer (Apr 19 2022 at 15:11):

julia> m1 = @model begin
           a ~ Uniform()
           b ~ Normal(a,2)
       end;

julia> r = rand(m1())
(a = 0.652999, b = 3.04375)

julia> logdensityof(m1(), r)
-2.32655

julia> m2 = @model x begin
           x[1] ~ Normal()
           for j in 2:length(x)
               x[j] ~ Normal(μ = x[j-1])
           end
       end;

julia> x = zeros(4);

julia> r2 = rand(m2(x))
(x = [0.333947, 1.06483, 2.35892, 1.45661],)

julia> logdensityof(m2(x), r2)
ERROR: syntax: multiple type declarations for "x"
Stacktrace:
 [1] top-level scope
   @ REPL[160]:1

julia> m2 = @model y begin
           y[1] ~ Normal()
           for j in 2:length(y)
               y[j] ~ Normal(μ = y[j-1])
           end
       end;

julia> y = zeros(4);

julia> r2 = rand(m2(x))
(y = [0.0852394, 0.492802, 0.68513, 0.760316],)

julia> logdensityof(m2(y), r2)
ERROR: syntax: multiple type declarations for "y"
Stacktrace:
 [1] top-level scope
   @ REPL[164]:1

Chad Scherrer (Apr 19 2022 at 16:10):

I think I got it. I pass in named tuples for arguments, observations, and parameters. Then in the generated function, I push some lines like

:($k::$T = _pars.$k)

I thought maybe I needed to get rid of the type annotation, but I think it might work out better to make sure the variable is treated as local. So I added

    for k in keys(args) ∪ keys(pars) ∪ keys(data)
        push!(loader.args, :(local $k))
    end

Stream: helpdesk (published)

Topic: ✔ Tracking down "multiple type declarations"

Chad Scherrer (Apr 19 2022 at 13:08):