Regression with newest Julia?

[PetrKryslUCSD]

One of the tests of my package fails with Julia Version 1.1.0-DEV.279, for Linux, Mac, and 32-bit Windows (64-bit Windows test passes okay):

 LoadError: type Nothing has no field m
  Stacktrace:
   [1] getproperty at .\sysimg.jl:18 [inlined]
   [2] size at C:\cygwin\home\Administrator\buildbot\worker\package_win32\build\usr\share\julia\stdlib\v1.1\SparseArrays\src\sparsematrix.jl:36 [inlined]
   [3] size at .\abstractarray.jl:38 [inlined]

[KristofferC]

Which package? In what test?

[PetrKryslUCSD]

Sorry: left that out by mistake. It is FinEtools. I put the failing test into test_test.jl. Example failure: https://travis-ci.org/PetrKryslUCSD/FinEtools.jl/jobs/430167610

[KristofferC]

typeof(K) = SparseArrays.SparseMatrixCSC{Float64,Int64}
K = nothing

That's interesting

[KristofferC]

Here is an MWE

function test(K)
    if true
          try
              error()
          catch e
          end
      end
      size(K,1)
end
K = rand(2,2)
test(K)

typeof(K) = Array{Float64,2}
K = nothing

julia> @code_typed optimize = false test(K)
CodeInfo(
2 1 ─      goto #6 if not true                                                                 │
3 2 ─      $(Expr(:enter, #4))                                                                 │
4 3 ─      (Main.error)()::Union{}                                                             │
  │        Const(:($(Expr(:leave, 1))), false)::Union{}                                        │
  └──      Const(:(goto %8), false)::Union{}                                                   │
  4 ┄      $(Expr(:leave, 1))                                                                  │
  5 ─      (e = $(Expr(:the_exception)))::Any                                                  │
8 6 ─ %8 = (Main.size)(K, 1)::Int64                                                            │
  └──      return %8                                                                           │
) => Int64

julia> @code_typed test(K)
CodeInfo(
  1 ─      nothing::Nothing                                                              │
3 2 ─      $(Expr(:enter, #4))                                                           │
4 3 ─      invoke Main.error()::Union{}                                                  │
  └──      $(Expr(:unreachable))::Union{}                                                │
  4 ┄      $(Expr(:leave, 1))                                                            │
  5 ─      nothing::Nothing                                                              │
8 │   %7 = (Base.arraysize)(nothing, 1)::Int64        <-----                                   │╻ size
  └──      return %7                                                                     │
) => Int64

cc @Keno

[KristofferC]

Bisected to fda953b.

[PetrKryslUCSD]

EDIT: After I posted the below: Oops, I just realized I ran it with 1.0! Which I guess explains why it runs fine.

Interestingly the MWE Kristoffer posted above works just fine on Windows 10.

julia> @code_typed optimize = false test(K)
CodeInfo(
2 1 ─      goto #6 if not true                                                                                                                                                                                     │
3 2 ─      $(Expr(:enter, #4))                                                                                                                                                                                     │
4 3 ─      (Main.error)()::Union{}                                                                                                                                                                                 │
  │        Const(:($(Expr(:leave, 1))), false)::Union{}                                                                                                                                                            │
  └──      Const(:(goto %8), false)::Union{}                                                                                                                                                                       │
  4 ┄      $(Expr(:leave, 1))                                                                                                                                                                                      │
  5 ─      (e = $(Expr(:the_exception)))::Any                                                                                                                                                                      │
8 6 ─ %8 = (Main.size)(K, 1)::Int64                                                                                                                                                                                │
  └──      return %8                                                                                                                                                                                               │
) => Int64

julia> @code_typed test(K)
CodeInfo(
2 1 ─       goto #6 if not true                                                                                │
3 2 ─       $(Expr(:enter, #4))                                                                                │
  3 ─ %3  = ϒ (K)::Array{Float64,2}                                                                            │
4 │         invoke Main.error()::Union{}                                                                       │
  └──       $(Expr(:unreachable))::Union{}                                                                     │
  4 ┄ %6  = φᶜ (%3)::Array{Float64,2}                                                                          │
  └──       $(Expr(:leave, 1))                                                                                 │
  5 ─       nothing::Nothing                                                                                   │
8 6 ─ %9  = φ (#5 => %6, #1 => _2)::Array{Float64,2}                                                           │
  │   %10 = (Base.arraysize)(%9, 1)::Int64                                                                     │╻ size
  └──       return %10                                                                                         │
  7 ─       goto #4                                                                                            │
) => Int64

[Keno]

I presume this is the same underlying problem as #29107, so should be temporarily worked around by #29265

[Nosferican]

Should this be closed?

[KristofferC]

Would be good to have a test for this first.