Merge branch 'master' into sf/bb_bump

Author: staticfloat

LICENSE.md

@@ -52,11 +52,6 @@ own licenses:
 - [LLVM](https://releases.llvm.org/6.0.0/LICENSE.TXT) [BSD-3, effectively]
 - [UTF8PROC](https://github.com/JuliaStrings/utf8proc) [MIT]
 
-The following components included in `stdlib` have their own separate licenses:
-
-- stdlib/SuiteSparse/umfpack.jl (see [SUITESPARSE](http://suitesparse.com))
-- stdlib/SuiteSparse/cholmod.jl (see [SUITESPARSE](http://suitesparse.com))
-
 Julia's `stdlib` uses the following external libraries, which have their own licenses:
 
 - [DSFMT](http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/SFMT/LICENSE.txt) [BSD-3]

NEWS.md

@@ -27,10 +27,11 @@ New library features
 
 Standard library changes
 ------------------------
-
+* The `@timed` macro now returns a `NamedTuple` ([#34149])
 
 #### LinearAlgebra
-
+* The BLAS submodule now supports the level-2 BLAS subroutine `hpmv!` ([#34211]).
+* `normalize` now supports multidimensional arrays ([#34239])
 
 #### Markdown
 
@@ -42,6 +43,24 @@ Standard library changes
 
 
 #### SparseArrays
+* `lu!` accepts `UmfpackLU` as an argument to make use of its symbolic factorization.
+
+#### Dates
+
+#### Statistics
+
+
+#### Sockets
+
+
+Deprecated or removed
+---------------------
+
+External dependencies
+---------------------
+
+Tooling Improvements
+---------------------
 
 
 <!--- generated by NEWS-update.jl: -->

base/arrayshow.jl

@@ -122,7 +122,7 @@ but it also repeated every M elements if desired.
 """
 function print_matrix_vdots(io::IO, vdots::AbstractString,
                             A::Vector, sep::AbstractString, M::Integer, m::Integer,
-                            pad_right::Bool)
+                            pad_right::Bool = true)
     for k = 1:length(A)
         w = A[k][1] + A[k][2]
         if k % M == m

base/broadcast.jl

@@ -496,6 +496,7 @@ _bcsm(a::Number, b::Number) = a == b || b == 1
 # (We may not want to define general promotion rules between, say, OneTo and Slice, but if
 #  we get here we know the axes are at least consistent for the purposes of broadcasting)
 axistype(a::T, b::T) where T = a
+axistype(a::OneTo, b::OneTo) = OneTo{Int}(a)
 axistype(a, b) = UnitRange{Int}(a)
 
 ## Check that all arguments are broadcast compatible with shape

base/compiler/ssair/passes.jl

@@ -370,6 +370,13 @@ function lift_leaves(compact::IncrementalCompact, @nospecialize(stmt),
             end
         elseif isa(leaf, QuoteNode)
             leaf = leaf.value
+        elseif isa(leaf, GlobalRef)
+            mod, name = leaf.mod, leaf.name
+            if isdefined(mod, name) && isconst(mod, name)
+                leaf = getfield(mod, name)
+            else
+                return nothing
+            end
         elseif isa(leaf, Union{Argument, Expr})
             return nothing
         end

base/compiler/typelimits.jl

@@ -57,21 +57,6 @@ function is_derived_type(@nospecialize(t), @nospecialize(c), mindepth::Int)
         for p in cP
             is_derived_type(t, p, mindepth) && return true
         end
-        if isconcretetype(c) && isbitstype(c)
-            # see if it was extracted from a fieldtype
-            # however, only look through types that can be inlined
-            # to ensure monotonicity of derivation
-            # since we know that for immutable, concrete, bits types,
-            # the field types must have been constructed prior to the type,
-            # it cannot have a reference cycle in the type graph
-            cF = c.types
-            for f in cF
-                # often a parameter is also a field type; avoid searching twice
-                if !contains_is(c.parameters, f)
-                    is_derived_type(t, f, mindepth) && return true
-                end
-            end
-        end
     end
     return false
 end

base/div.jl

@@ -116,7 +116,17 @@ julia> divrem(7,3)
 ```
 """
 divrem(x, y) = divrem(x, y, RoundToZero)
-divrem(a, b, r::RoundingMode) = (div(a, b, r), rem(a, b, r))
+function divrem(a, b, r::RoundingMode)
+    if r == RoundToZero
+        # For compat. Remove in 2.0.
+        (div(a, b), rem(a, b))
+    elseif r === RoundDown
+        # For compat. Remove in 2.0.
+        (fld(a, b), mod(a, b))
+    else
+        (div(a, b, r), rem(a, b, r))
+    end
+end
 function divrem(x::Integer, y::Integer, rnd::typeof(RoundNearest))
     (q, r) = divrem(x, y)
     if x >= 0

base/docs/basedocs.jl

@@ -158,7 +158,8 @@ resulting expression is substituted directly into the program at the point where
 the macro is invoked.
 Macros are a way to run generated code without calling [`eval`](@ref Base.eval), since the generated
 code instead simply becomes part of the surrounding program.
-Macro arguments may include expressions, literal values, and symbols.
+Macro arguments may include expressions, literal values, and symbols. Macros can be defined for
+variable number of arguments (varargs), but do not accept keyword arguments.
 
 # Examples
 ```jldoctest
@@ -169,6 +170,14 @@ julia> macro sayhello(name)
 
 julia> @sayhello "Charlie"
 Hello, Charlie!
+
+julia> macro saylots(x...)
+           return :( println("Say: ", \$(x...)) )
+       end
+@saylots (macro with 1 method)
+
+julia> @saylots "hey " "there " "friend"
+Say: hey there friend
 ```
 """
 kw"macro"

base/gcutils.jl

@@ -49,29 +49,20 @@ Module with garbage collection utilities.
 """
 module GC
 
-# @enum-like structure
-struct CollectionType
-    x::Int
-end
-Base.cconvert(::Type{Cint}, collection::CollectionType) = Cint(collection.x)
-
-const Auto          = CollectionType(0)
-const Full          = CollectionType(1)
-const Incremental   = CollectionType(2)
-
 """
-    GC.gc(full::Bool=true)
-    GC.gc(collection::CollectionType)
+    GC.gc()
+    GC.gc(full::Bool)
 
-Perform garbage collection. The argument `full` determines whether a full, but more costly
-collection is performed. Otherwise, heuristics are used to determine which type of
-collection is needed. For exact control, pass an argument of type `CollectionType`.
+Perform garbage collection. The argument `full` determines the kind of collection: A full
+collection scans all objects, while an incremental collection only scans so-called young
+objects and is much quicker. If called without an argument, heuristics are used to determine
+which type of collection is needed.
 
 !!! warning
     Excessive use will likely lead to poor performance.
 """
-gc(full::Bool=true) = ccall(:jl_gc_collect, Cvoid, (Cint,), full)
-gc(collection::CollectionType) = ccall(:jl_gc_collect, Cvoid, (Cint,), collection)
+gc() = ccall(:jl_gc_collect, Cvoid, (Cint,), 0)
+gc(full::Bool) = ccall(:jl_gc_collect, Cvoid, (Cint,), full ? 1 : 2)
 
 """
     GC.enable(on::Bool)

base/int.jl

@@ -155,7 +155,7 @@ julia> signed(unsigned(-2))
 -2
 ```
 """
-unsigned(x) = convert(Unsigned, x)
+unsigned(x) = x % typeof(convert(Unsigned, zero(x)))
 unsigned(x::BitSigned) = reinterpret(typeof(convert(Unsigned, zero(x))), x)
 
 """
@@ -164,7 +164,7 @@ unsigned(x::BitSigned) = reinterpret(typeof(convert(Unsigned, zero(x))), x)
 Convert a number to a signed integer. If the argument is unsigned, it is reinterpreted as
 signed without checking for overflow.
 """
-signed(x) = convert(Signed, x)
+signed(x) = x % typeof(convert(Signed, zero(x)))
 signed(x::BitUnsigned) = reinterpret(typeof(convert(Signed, zero(x))), x)
 
 div(x::BitSigned, y::Unsigned) = flipsign(signed(div(unsigned(abs(x)), y)), x)