Merge branch 'master' into structured_opnorm

Author: mcognetta

.travis.yml

@@ -73,23 +73,18 @@ before_install:
         export PATH="$(brew --prefix ccache)/libexec:$PATH";
         BAR="pv -i 30";
         contrib/travis_fastfail.sh || exit 1;
-        brew tap staticfloat/julia > /dev/null;
-        brew rm --force $(brew deps --HEAD julia);
-        brew install -v ccache gcc gmp mpfr pcre2 staticfloat/julia/openblas-julia staticfloat/julia/suite-sparse-julia staticfloat/juliadeps/libgfortran;
-        BUILDOPTS="-j3 USECLANG=1 USECCACHE=1 USE_BINARYBUILDER_LLVM=1 USE_BINARYBUILDER_OPENBLAS=1 BINARYBUILDER_LLVM_ASSERTS=1";
-        BUILDOPTS="$BUILDOPTS LLVM_CONFIG=$TRAVIS_BUILD_DIR/usr/tools/llvm-config LLVM_SIZE=$TRAVIS_BUILD_DIR/usr/tools/llvm-size";
-        BUILDOPTS="$BUILDOPTS VERBOSE=1 USE_BLAS64=0 SUITESPARSE_INC=-I$(brew --prefix suite-sparse-julia)/include FORCE_ASSERTIONS=1";
-        BUILDOPTS="$BUILDOPTS LIBBLAS=-lopenblas LIBBLASNAME=libopenblas LIBLAPACK=-lopenblas LIBLAPACKNAME=libopenblas";
-        for lib in SUITESPARSE BLAS LAPACK GMP MPFR LIBUNWIND; do
+        brew rm --force gcc gmp mpfr pcre2;
+        brew install -v gcc gmp mpfr pcre2;
+        BUILDOPTS="-j3 USECLANG=1 USECCACHE=1 VERBOSE=1 FORCE_ASSERTIONS=1";
+        for proj in LLVM LLVM_ASSERTS OPENBLAS SUITESPARSE OPENLIBM; do
+            BUILDOPTS="$BUILDOPTS USE_BINARYBUILDER_${proj}=1";
+        done;
+        for lib in GMP MPFR LIBUNWIND; do
             BUILDOPTS="$BUILDOPTS USE_SYSTEM_$lib=1";
         done;
-        export LDFLAGS="-L$(brew --prefix openblas-julia)/lib -L$(brew --prefix suite-sparse-julia)/lib";
         spawn_DYLD_FALLBACK_LIBRARY_PATH="/usr/local/lib:/lib:/usr/lib";
-        spawn_DYLD_FALLBACK_LIBRARY_PATH+=":$(brew --prefix openblas-julia)/lib";
-        spawn_DYLD_FALLBACK_LIBRARY_PATH+=":$(brew --prefix suite-sparse-julia)/lib";
         export JULIA_MACOS_SPAWN="DYLD_FALLBACK_LIBRARY_PATH=\"$spawn_DYLD_FALLBACK_LIBRARY_PATH\" \$1";
         export BUILDOPTS="$BUILDOPTS spawn=\$(JULIA_MACOS_SPAWN)";
-        make $BUILDOPTS -C contrib -f repackage_system_suitesparse4.make;
         export JULIA_CPU_THREADS=2;
         export JULIA_TEST_MAXRSS_MB=600;
         TESTSTORUN="all --skip linalg/triangular subarray"; fi # TODO: re enable these if possible without timing out

NEWS.md

@@ -15,7 +15,7 @@ Multi-threading changes
 
 Language changes
 ----------------
-
+* Empty entries in `JULIA_DEPOT_PATH` are now expanded to default depot entries ([#31009]).
 * `Enum` now behaves like a scalar when used in broadcasting ([#30670]).
 
 Command-line option changes
@@ -33,10 +33,12 @@ New library functions
 Standard library changes
 ------------------------
 
-  * The `extrema` function now accepts a function argument in the same manner as `minimum` and
-    `maximum` ([#30323]).
-  * `hasmethod` can now check for matching keyword argument names ([#30712]).
-  * `startswith` and `endswith` now accept a `Regex` for the second argument ([#29790]).
+* The `extrema` function now accepts a function argument in the same manner as `minimum` and
+  `maximum` ([#30323]).
+* `hasmethod` can now check for matching keyword argument names ([#30712]).
+* `startswith` and `endswith` now accept a `Regex` for the second argument ([#29790]).
+* `retry` supports arbitrary callable objects ([#30382]).
+* A no-argument construct to `Ptr{T}` has been added which constructs a null pointer ([#30919])
 
 #### LinearAlgebra
 
@@ -78,6 +80,7 @@ Deprecated or removed
 [#21598]: https://github.com/JuliaLang/julia/issues/21598
 [#24980]: https://github.com/JuliaLang/julia/issues/24980
 [#28850]: https://github.com/JuliaLang/julia/issues/28850
+[#29777]: https://github.com/JuliaLang/julia/issues/29777
 [#29790]: https://github.com/JuliaLang/julia/issues/29790
 [#29998]: https://github.com/JuliaLang/julia/issues/29998
 [#30061]: https://github.com/JuliaLang/julia/issues/30061
@@ -86,6 +89,8 @@ Deprecated or removed
 [#30323]: https://github.com/JuliaLang/julia/issues/30323
 [#30349]: https://github.com/JuliaLang/julia/issues/30349
 [#30372]: https://github.com/JuliaLang/julia/issues/30372
+[#30382]: https://github.com/JuliaLang/julia/issues/30382
+[#30577]: https://github.com/JuliaLang/julia/issues/30577
 [#30583]: https://github.com/JuliaLang/julia/issues/30583
 [#30584]: https://github.com/JuliaLang/julia/issues/30584
 [#30593]: https://github.com/JuliaLang/julia/issues/30593
@@ -94,3 +99,4 @@ Deprecated or removed
 [#30712]: https://github.com/JuliaLang/julia/issues/30712
 [#30724]: https://github.com/JuliaLang/julia/issues/30724
 [#30915]: https://github.com/JuliaLang/julia/issues/30915
+[#30919]: https://github.com/JuliaLang/julia/issues/30919

base/Enums.jl

@@ -5,7 +5,7 @@ module Enums
 import Core.Intrinsics.bitcast
 export Enum, @enum
 
-function basetype end
+function namemap end
 
 """
     Enum{T<:Integer}
@@ -14,10 +14,48 @@ The abstract supertype of all enumerated types defined with [`@enum`](@ref).
 """
 abstract type Enum{T<:Integer} end
 
+basetype(::Type{<:Enum{T}}) where {T<:Integer} = T
+
 (::Type{T})(x::Enum{T2}) where {T<:Integer,T2<:Integer} = T(bitcast(T2, x))::T
 Base.cconvert(::Type{T}, x::Enum{T2}) where {T<:Integer,T2<:Integer} = T(x)
 Base.write(io::IO, x::Enum{T}) where {T<:Integer} = write(io, T(x))
-Base.read(io::IO, ::Type{T}) where {T<:Enum} = T(read(io, Enums.basetype(T)))
+Base.read(io::IO, ::Type{T}) where {T<:Enum} = T(read(io, basetype(T)))
+
+Base.isless(x::T, y::T) where {T<:Enum} = isless(basetype(T)(x), basetype(T)(y))
+
+Base.Symbol(x::Enum) = namemap(typeof(x))[Integer(x)]::Symbol
+
+Base.print(io::IO, x::Enum) = print(io, Symbol(x))
+
+function Base.show(io::IO, x::Enum)
+    sym = Symbol(x)
+    if !get(io, :compact, false)
+        from = get(io, :module, Main)
+        def = typeof(x).name.module
+        if from === nothing || !Base.isvisible(sym, def, from)
+            show(io, def)
+            print(io, ".")
+        end
+    end
+    print(io, sym)
+end
+
+function Base.show(io::IO, ::MIME"text/plain", x::Enum)
+    print(io, x, "::")
+    show(IOContext(io, :compact => true), typeof(x))
+    print(io, " = ")
+    show(io, Integer(x))
+end
+
+function Base.show(io::IO, ::MIME"text/plain", t::Type{<:Enum})
+    print(io, "Enum ")
+    Base.show_datatype(io, t)
+    print(io, ":")
+    for x in instances(t)
+        print(io, "\n", Symbol(x), " = ")
+        show(io, Integer(x))
+    end
+end
 
 # generate code to test whether expr is in the given set of values
 function membershiptest(expr, values)
@@ -74,7 +112,7 @@ To list all the instances of an enum use `instances`, e.g.
 
 ```jldoctest fruitenum
 julia> instances(Fruit)
-(apple::Fruit = 1, orange::Fruit = 2, kiwi::Fruit = 3)
+(apple, orange, kiwi)
 ```
 """
 macro enum(T, syms...)
@@ -92,7 +130,9 @@ macro enum(T, syms...)
     elseif !isa(T, Symbol)
         throw(ArgumentError("invalid type expression for enum $T"))
     end
-    vals = Vector{Tuple{Symbol,Integer}}()
+    values = basetype[]
+    seen = Set{Symbol}()
+    namemap = Dict{basetype,Symbol}()
     lo = hi = 0
     i = zero(basetype)
     hasexpr = false
@@ -103,7 +143,7 @@ macro enum(T, syms...)
     for s in syms
         s isa LineNumberNode && continue
         if isa(s, Symbol)
-            if i == typemin(basetype) && !isempty(vals)
+            if i == typemin(basetype) && !isempty(values)
                 throw(ArgumentError("overflow in value \"$s\" of Enum $typename"))
             end
         elseif isa(s, Expr) &&
@@ -120,64 +160,41 @@ macro enum(T, syms...)
             throw(ArgumentError(string("invalid argument for Enum ", typename, ": ", s)))
         end
         if !Base.isidentifier(s)
-            throw(ArgumentError("invalid name for Enum $typename; \"$s\" is not a valid identifier."))
+            throw(ArgumentError("invalid name for Enum $typename; \"$s\" is not a valid identifier"))
+        end
+        if hasexpr && haskey(namemap, i)
+            throw(ArgumentError("both $s and $(namemap[i]) have value $i in Enum $typename; values must be unique"))
         end
-        push!(vals, (s,i))
-        if length(vals) == 1
+        namemap[i] = s
+        push!(values, i)
+        if s in seen
+            throw(ArgumentError("name \"$s\" in Enum $typename is not unique"))
+        end
+        push!(seen, s)
+        if length(values) == 1
             lo = hi = i
         else
             lo = min(lo, i)
             hi = max(hi, i)
         end
         i += oneunit(i)
     end
-    values = basetype[i[2] for i in vals]
-    if hasexpr && values != unique(values)
-        throw(ArgumentError("values for Enum $typename are not unique"))
-    end
     blk = quote
         # enum definition
         Base.@__doc__(primitive type $(esc(typename)) <: Enum{$(basetype)} $(sizeof(basetype) * 8) end)
         function $(esc(typename))(x::Integer)
             $(membershiptest(:x, values)) || enum_argument_error($(Expr(:quote, typename)), x)
             return bitcast($(esc(typename)), convert($(basetype), x))
         end
-        Enums.basetype(::Type{$(esc(typename))}) = $(esc(basetype))
+        Enums.namemap(::Type{$(esc(typename))}) = $(esc(namemap))
         Base.typemin(x::Type{$(esc(typename))}) = $(esc(typename))($lo)
         Base.typemax(x::Type{$(esc(typename))}) = $(esc(typename))($hi)
-        Base.isless(x::$(esc(typename)), y::$(esc(typename))) = isless($basetype(x), $basetype(y))
-        let insts = ntuple(i->$(esc(typename))($values[i]), $(length(vals)))
+        let insts = ntuple(i->$(esc(typename))($values[i]), $(length(values)))
             Base.instances(::Type{$(esc(typename))}) = insts
         end
-        function Base.print(io::IO, x::$(esc(typename)))
-            for (sym, i) in $vals
-                if i == $(basetype)(x)
-                    print(io, sym); break
-                end
-            end
-        end
-        function Base.show(io::IO, x::$(esc(typename)))
-            if get(io, :compact, false)
-                print(io, x)
-            else
-                print(io, x, "::")
-                show(IOContext(io, :compact => true), typeof(x))
-                print(io, " = ")
-                show(io, $basetype(x))
-            end
-        end
-        function Base.show(io::IO, ::MIME"text/plain", t::Type{$(esc(typename))})
-            print(io, "Enum ")
-            Base.show_datatype(io, t)
-            print(io, ":")
-            for (sym, i) in $vals
-                print(io, "\n", sym, " = ")
-                show(io, i)
-            end
-        end
     end
     if isa(typename, Symbol)
-        for (sym,i) in vals
+        for (i, sym) in namemap
             push!(blk.args, :(const $(esc(sym)) = $(esc(typename))($i)))
         end
     end

base/abstractarraymath.jl

@@ -121,7 +121,7 @@ julia> selectdim(A, 2, 3)
 """
 @inline selectdim(A::AbstractArray, d::Integer, i) = _selectdim(A, d, i, setindex(map(Slice, axes(A)), i, d))
 @noinline function _selectdim(A, d, i, idxs)
-    d >= 1 || throw(ArgumentError("dimension must be ≥ 1"))
+    d >= 1 || throw(ArgumentError("dimension must be ≥ 1, got $d"))
     nd = ndims(A)
     d > nd && (i == 1 || throw(BoundsError(A, (ntuple(k->Colon(),d-1)..., i))))
     return view(A, idxs...)

base/arrayshow.jl

@@ -417,7 +417,7 @@ _show_empty(io, X) = nothing # by default, we don't know this constructor
 function show(io::IO, X::AbstractArray)
     ndims(X) == 1 && return show_vector(io, X)
     prefix = typeinfo_prefix(io, X)
-    io = IOContext(io, :typeinfo => eltype(X), :compact => get(io, :compact, true))
+    io = IOContext(io, :typeinfo => eltype(X))
     isempty(X) ?
         _show_empty(io, X) :
         _show_nonempty(io, X, prefix)
@@ -431,7 +431,7 @@ end
 function show_vector(io::IO, v, opn='[', cls=']')
     print(io, typeinfo_prefix(io, v))
     # directly or indirectly, the context now knows about eltype(v)
-    io = IOContext(io, :typeinfo => eltype(v), :compact => get(io, :compact, true))
+    io = IOContext(io, :typeinfo => eltype(v))
     limited = get(io, :limit, false)
     if limited && length(v) > 20
         inds = axes1(v)

base/boot.jl

@@ -90,8 +90,7 @@
 #end
 
 #struct LineInfoNode
-#    mod::Module
-#    method::Symbol
+#    method::Any
 #    file::Symbol
 #    line::Int
 #    inlined_at::Int
@@ -375,8 +374,8 @@ eval(Core, :(PiNode(val, typ) = $(Expr(:new, :PiNode, :val, :typ))))
 eval(Core, :(PhiCNode(values::Array{Any, 1}) = $(Expr(:new, :PhiCNode, :values))))
 eval(Core, :(UpsilonNode(val) = $(Expr(:new, :UpsilonNode, :val))))
 eval(Core, :(UpsilonNode() = $(Expr(:new, :UpsilonNode))))
-eval(Core, :(LineInfoNode(mod::Module, method::Symbol, file::Symbol, line::Int, inlined_at::Int) =
-             $(Expr(:new, :LineInfoNode, :mod, :method, :file, :line, :inlined_at))))
+eval(Core, :(LineInfoNode(@nospecialize(method), file::Symbol, line::Int, inlined_at::Int) =
+             $(Expr(:new, :LineInfoNode, :method, :file, :line, :inlined_at))))
 
 Module(name::Symbol=:anonymous, std_imports::Bool=true) = ccall(:jl_f_new_module, Ref{Module}, (Any, Bool), name, std_imports)
 

base/compiler/inferencestate.jl

@@ -58,7 +58,7 @@ mutable struct InferenceState
         s_types = Any[ nothing for i = 1:n ]
 
         # initial types
-        nslots = length(src.slotnames)
+        nslots = length(src.slotflags)
         argtypes = result.argtypes
         nargs = length(argtypes)
         s_argtypes = VarTable(undef, nslots)
@@ -122,7 +122,7 @@ end
 
 function sptypes_from_meth_instance(linfo::MethodInstance)
     toplevel = !isa(linfo.def, Method)
-    if !toplevel && isempty(linfo.sparam_vals) && !isempty(linfo.def.sparam_syms)
+    if !toplevel && isempty(linfo.sparam_vals) && isa(linfo.def.sig, UnionAll)
         # linfo is unspecialized
         sp = Any[]
         sig = linfo.def.sig

base/compiler/optimize.jl

@@ -37,8 +37,11 @@ mutable struct OptimizationState
         if nssavalues isa Int
             src.ssavaluetypes = Any[ Any for i = 1:nssavalues ]
         end
-        nslots = length(src.slotnames)
-        slottypes = Any[ Any for i = 1:nslots ]
+        nslots = length(src.slotflags)
+        slottypes = src.slottypes
+        if slottypes === nothing
+            slottypes = Any[ Any for i = 1:nslots ]
+        end
         s_edges = []
         # cache some useful state computations
         toplevel = !isa(linfo.def, Method)
@@ -73,7 +76,7 @@ end
 # This is implied by `SLOT_USEDUNDEF`.
 # If this is not set, all the uses are (statically) dominated by the defs.
 # In particular, if a slot has `AssignedOnce && !StaticUndef`, it is an SSA.
-const SLOT_STATICUNDEF  = 1
+const SLOT_STATICUNDEF  = 1 # slot might be used before it is defined (structurally)
 const SLOT_ASSIGNEDONCE = 16 # slot is assigned to only once
 const SLOT_USEDUNDEF    = 32 # slot has uses that might raise UndefVarError
 # const SLOT_CALLED      = 64
@@ -260,6 +263,9 @@ function is_pure_intrinsic_infer(f::IntrinsicFunction)
              f === Intrinsics.cglobal)  # cglobal lookup answer changes at runtime
 end
 
+# whether `f` is effect free if nothrow
+intrinsic_effect_free_if_nothrow(f) = f === Intrinsics.pointerref || is_pure_intrinsic_infer(f)
+
 ## Computing the cost of a function body
 
 # saturating sum (inputs are nonnegative), prevents overflow with typemax(Int) below

base/compiler/ssair/driver.jl

@@ -1,7 +1,6 @@
 # This file is a part of Julia. License is MIT: https://julialang.org/license
 
 using Core: LineInfoNode
-const NullLineInfo = LineInfoNode(@__MODULE__, Symbol(""), Symbol(""), 0, 0)
 
 if false
     import Base: Base, @show
@@ -103,8 +102,7 @@ function just_construct_ssa(ci::CodeInfo, code::Vector{Any}, nargs::Int, sv::Opt
     defuse_insts = scan_slot_def_use(nargs, ci, code)
     @timeit "domtree 1" domtree = construct_domtree(cfg)
     ir = let code = Any[nothing for _ = 1:length(code)]
-             argtypes = sv.slottypes[1:(nargs+1)]
-            IRCode(code, Any[], ci.codelocs, flags, cfg, collect(LineInfoNode, ci.linetable), argtypes, meta, sv.sptypes)
+            IRCode(code, Any[], ci.codelocs, flags, cfg, collect(LineInfoNode, ci.linetable), sv.slottypes, meta, sv.sptypes)
         end
     @timeit "construct_ssa" ir = construct_ssa!(ci, code, ir, domtree, defuse_insts, nargs, sv.sptypes, sv.slottypes)
     return ir