Merge branch 'master' into patch-9

NEWS.md

@@ -213,15 +213,28 @@ This section lists changes that do not have deprecation warnings.
   * The `openspecfun` library is no longer built and shipped with Julia, as it is no longer
     used internally ([#22390]).
 
+  * All loaded packges used to have bindings in `Main` (e.g. `Main.Package`). This is no
+    longer the case; now bindings will only exist for packages brought into scope by
+    typing `using Package` or `import Package` ([#17997]).
+
   * `slicedim(b::BitVector, 1, x)` now consistently returns the same thing that `b[x]` would,
     consistent with its documentation. Previously it would return a `BitArray{0}` for scalar
     `x` ([#20233]).
 
+  * The rules for mixed-signedness integer arithmetic (e.g. `Int32(1) + UInt64(1)`) have been
+    simplified: if the arguments have different sizes (in bits), then the type of the larger
+    argument is used. If the arguments have the same size, the unsigned type is used ([#9292]).
+
+  * All command line arguments passed via `-e`, `-E`, and `-L` will be executed in the order
+    given on the command line ([#23665]).
+
 Library improvements
 --------------------
 
   * The functions `strip`, `lstrip` and `rstrip` now return `SubString` ([#22496]).
 
+  * The functions `strwidth` and `charwidth` have been merged into `textwidth`([#20816]).
+
   * The functions `base` and `digits` digits now accept a negative
     base (like `ndigits` did) ([#21692]).
 
@@ -294,6 +307,11 @@ Deprecated or removed
   * The keyword `immutable` is fully deprecated to `struct`, and
     `type` is fully deprecated to `mutable struct` ([#19157], [#20418]).
 
+  * Indexing into multidimensional arrays with more than one index but fewer indices than there are
+    dimensions is no longer permitted when those trailing dimensions have lengths greater than 1.
+    Instead, reshape the array or add trailing indices so the dimensionality and number of indices
+    match ([#14770], [#23628]).
+
   * `writecsv(io, a; opts...)` has been deprecated in favor of
     `writedlm(io, a, ','; opts...)` ([#23529]).
 

base/abstractarray.jl

@@ -429,7 +429,7 @@ function checkbounds_indices(::Type{Bool}, ::Tuple{}, I::Tuple)
     @_inline_meta
     checkindex(Bool, OneTo(1), I[1]) & checkbounds_indices(Bool, (), tail(I))
 end
-checkbounds_indices(::Type{Bool}, ::Tuple,   ::Tuple{}) = true
+checkbounds_indices(::Type{Bool}, IA::Tuple, ::Tuple{}) = (@_inline_meta; all(x->unsafe_length(x)==1, IA))
 checkbounds_indices(::Type{Bool}, ::Tuple{}, ::Tuple{}) = true
 
 throw_boundserror(A, I) = (@_noinline_meta; throw(BoundsError(A, I)))

base/abstractarraymath.jl

@@ -67,18 +67,18 @@ julia> squeeze(a,3)
 function squeeze(A::AbstractArray, dims::Dims)
     for i in 1:length(dims)
         1 <= dims[i] <= ndims(A) || throw(ArgumentError("squeezed dims must be in range 1:ndims(A)"))
-        size(A, dims[i]) == 1 || throw(ArgumentError("squeezed dims must all be size 1"))
+        length(indices(A, dims[i])) == 1 || throw(ArgumentError("squeezed dims must all be size 1"))
         for j = 1:i-1
             dims[j] == dims[i] && throw(ArgumentError("squeezed dims must be unique"))
         end
     end
     d = ()
     for i = 1:ndims(A)
         if !in(i, dims)
-            d = tuple(d..., size(A, i))
+            d = tuple(d..., indices(A, i))
         end
     end
-    reshape(A, d::typeof(_sub(size(A), dims)))
+    reshape(A, d::typeof(_sub(indices(A), dims)))
 end
 
 squeeze(A::AbstractArray, dim::Integer) = squeeze(A, (Int(dim),))

base/client.jl

@@ -250,74 +250,82 @@ function process_options(opts::JLOptions)
         idxs = find(x -> x == "--", ARGS)
         length(idxs) > 0 && deleteat!(ARGS, idxs[1])
     end
-    repl                  = true
     quiet                 = (opts.quiet != 0)
     startup               = (opts.startupfile != 2)
     history_file          = (opts.historyfile != 0)
     color_set             = (opts.color != 0)
     global have_color     = (opts.color == 1)
     global is_interactive = (opts.isinteractive != 0)
 
+    # pre-process command line argument list
+    arg_is_program = !isempty(ARGS)
+    repl = !arg_is_program
+    cmds = unsafe_load_commands(opts.commands)
+    for (cmd, arg) in cmds
+        if cmd == 'e'
+            arg_is_program = false
+            repl = false
+        elseif cmd == 'E'
+            arg_is_program = false
+            repl = false
+        elseif cmd == 'L'
+            # nothing
+        else
+            warn("unexpected command -$cmd'$arg'")
+        end
+    end
+
     # remove filename from ARGS
-    arg_is_program = opts.eval == C_NULL && opts.print == C_NULL && !isempty(ARGS)
     global PROGRAM_FILE = arg_is_program ? shift!(ARGS) : ""
 
-    while true
-        # startup worker.
-        # opts.startupfile, opts.load, etc should should not be processed for workers.
-        if opts.worker == 1
-            # does not return
-            if opts.cookie != C_NULL
-                start_worker(unsafe_string(opts.cookie))
-            else
-                start_worker()
-            end
+    # startup worker.
+    # opts.startupfile, opts.load, etc should should not be processed for workers.
+    if opts.worker == 1
+        # does not return
+        if opts.cookie != C_NULL
+            start_worker(unsafe_string(opts.cookie))
+        else
+            start_worker()
         end
+    end
 
-        # add processors
-        if opts.nprocs > 0
-            addprocs(opts.nprocs)
-        end
-        # load processes from machine file
-        if opts.machinefile != C_NULL
-            addprocs(load_machine_file(unsafe_string(opts.machinefile)))
-        end
+    # add processors
+    if opts.nprocs > 0
+        addprocs(opts.nprocs)
+    end
+    # load processes from machine file
+    if opts.machinefile != C_NULL
+        addprocs(load_machine_file(unsafe_string(opts.machinefile)))
+    end
 
-        # load ~/.juliarc file
-        startup && load_juliarc()
+    # load ~/.juliarc file
+    startup && load_juliarc()
 
-        # load file immediately on all processors
-        if opts.load != C_NULL
+    # process cmds list
+    for (cmd, arg) in cmds
+        if cmd == 'e'
+            eval(Main, parse_input_line(arg))
+        elseif cmd == 'E'
+            invokelatest(show, eval(Main, parse_input_line(arg)))
+            println()
+        elseif cmd == 'L'
+            # load file immediately on all processors
             @sync for p in procs()
-                @async remotecall_fetch(include, p, Main, unsafe_string(opts.load))
+                @async remotecall_wait(include, p, Main, arg)
             end
         end
-        # eval expression
-        if opts.eval != C_NULL
-            repl = false
-            eval(Main, parse_input_line(unsafe_string(opts.eval)))
-            break
-        end
-        # eval expression and show result
-        if opts.print != C_NULL
-            repl = false
-            show(eval(Main, parse_input_line(unsafe_string(opts.print))))
-            println()
-            break
-        end
-        # load file
-        if !isempty(PROGRAM_FILE)
-            # program
-            repl = false
-            if !is_interactive
-                ccall(:jl_exit_on_sigint, Void, (Cint,), 1)
-            end
-            include(Main, PROGRAM_FILE)
+    end
+
+    # load file
+    if arg_is_program
+        # program
+        if !is_interactive
+            ccall(:jl_exit_on_sigint, Void, (Cint,), 1)
         end
-        break
+        include(Main, PROGRAM_FILE)
     end
     repl |= is_interactive
-    return (quiet,repl,startup,color_set,history_file)
+    return (quiet, repl, startup, color_set, history_file)
 end
 
 function load_juliarc()

base/deprecated.jl

@@ -1651,7 +1651,7 @@ end
 end
 
 # PR #23187
-@deprecate cpad(s, n::Integer, p=" ") rpad(lpad(s, div(n+strwidth(s), 2), p), n, p) false
+@deprecate cpad(s, n::Integer, p=" ") rpad(lpad(s, div(n+textwidth(s), 2), p), n, p) false
 
 # PR #22088
 function hex2num(s::AbstractString)
@@ -1746,6 +1746,24 @@ function countnz(x)
     return count(t -> t != 0, x)
 end
 
+# issue #14470
+# TODO: More deprecations must be removed in src/cgutils.cpp:emit_array_nd_index()
+# TODO: Re-enable the disabled tests marked PLI
+# On the Julia side, this definition will gracefully supercede the new behavior (already coded)
+@inline function checkbounds_indices(::Type{Bool}, IA::Tuple{Any,Vararg{Any}}, ::Tuple{})
+    any(x->unsafe_length(x)==0, IA) && return false
+    any(x->unsafe_length(x)!=1, IA) && return _depwarn_for_trailing_indices(IA)
+    return true
+end
+function _depwarn_for_trailing_indices(n::Integer) # Called by the C boundscheck
+    depwarn("omitting indices for non-singleton trailing dimensions is deprecated. Add `1`s as trailing indices or use `reshape(A, Val($n))` to make the dimensionality of the array match the number of indices.", (:getindex, :setindex!, :view))
+    true
+end
+function _depwarn_for_trailing_indices(t::Tuple)
+    depwarn("omitting indices for non-singleton trailing dimensions is deprecated. Add `$(join(map(first, t),','))` as trailing indices or use `reshape` to make the dimensionality of the array match the number of indices.", (:getindex, :setindex!, :view))
+    true
+end
+
 # issue #22791
 @deprecate select partialsort
 @deprecate select! partialsort!
@@ -1804,6 +1822,10 @@ import .Iterators.enumerate
     return p
 end
 
+# ease transition for return type change of e.g. indmax due to PR #22907 when used in the
+# common pattern `ind2sub(size(a), indmax(a))`
+@deprecate(ind2sub(dims::NTuple{N,Integer}, idx::CartesianIndex{N}) where N, Tuple(idx))
+
 @deprecate contains(eq::Function, itr, x) any(y->eq(y,x), itr)
 
 # PR #23690
@@ -1855,6 +1877,10 @@ end
     nothing
 end
 
+# issue #20816
+@deprecate strwidth textwidth
+@deprecate charwidth textwidth
+
 # END 0.7 deprecations
 
 # BEGIN 1.0 deprecations

base/dict.jl

@@ -1,15 +1,15 @@
 # This file is a part of Julia. License is MIT: https://julialang.org/license
 
 function _truncate_at_width_or_chars(str, width, chars="", truncmark="…")
-    truncwidth = strwidth(truncmark)
+    truncwidth = textwidth(truncmark)
     (width <= 0 || width < truncwidth) && return ""
 
     wid = truncidx = lastidx = 0
     idx = start(str)
     while !done(str, idx)
         lastidx = idx
         c, idx = next(str, idx)
-        wid += charwidth(c)
+        wid += textwidth(c)
         wid >= width - truncwidth && truncidx == 0 && (truncidx = lastidx)
         (wid >= width || c in chars) && break
     end

base/distributed/Distributed.jl

@@ -10,7 +10,8 @@ import Base: getindex, wait, put!, take!, fetch, isready, push!, length,
 using Base: Process, Semaphore, JLOptions, AnyDict, buffer_writes, wait_connected,
             VERSION_STRING, sync_begin, sync_add, sync_end, async_run_thunk,
             binding_module, notify_error, atexit, julia_exename, julia_cmd,
-            AsyncGenerator, display_error, acquire, release, invokelatest
+            AsyncGenerator, display_error, acquire, release, invokelatest, warn_once,
+            shell_escape, uv_error
 
 # NOTE: clusterserialize.jl imports additional symbols from Base.Serializer for use
 

base/distributed/managers.jl

@@ -188,15 +188,15 @@ function launch_on_machine(manager::SSHManager, machine, cnt, params, launched,
     cmd = `cd $dir '&&' $tval $exename $exeflags`
 
     # shell login (-l) with string command (-c) to launch julia process
-    cmd = `sh -l -c $(Base.shell_escape(cmd))`
+    cmd = `sh -l -c $(shell_escape(cmd))`
 
     # remote launch with ssh with given ssh flags / host / port information
     # -T → disable pseudo-terminal allocation
     # -a → disable forwarding of auth agent connection
     # -x → disable X11 forwarding
     # -o ClearAllForwardings → option if forwarding connections and
     #                          forwarded connections are causing collisions
-    cmd = `ssh -T -a -x -o ClearAllForwardings=yes $sshflags $host $(Base.shell_escape(cmd))`
+    cmd = `ssh -T -a -x -o ClearAllForwardings=yes $sshflags $host $(shell_escape(cmd))`
 
     # launch the remote Julia process
 
@@ -381,7 +381,7 @@ connection to worker with id `pid`, specified by `config` and return a pair of `
 objects. Messages from `pid` to current process will be read off `instrm`, while messages to
 be sent to `pid` will be written to `outstrm`. The custom transport implementation must
 ensure that messages are delivered and received completely and in order.
-`Base.connect(manager::ClusterManager.....)` sets up TCP/IP socket connections in-between
+`connect(manager::ClusterManager.....)` sets up TCP/IP socket connections in-between
 workers.
 """
 function connect(manager::ClusterManager, pid::Int, config::WorkerConfig)
@@ -485,7 +485,7 @@ end
 function bind_client_port(s)
     err = ccall(:jl_tcp_bind, Int32, (Ptr{Void}, UInt16, UInt32, Cuint),
                             s.handle, hton(client_port[]), hton(UInt32(0)), 0)
-    Base.uv_error("bind() failed", err)
+    uv_error("bind() failed", err)
 
     _addr, port = getsockname(s)
     client_port[] = port
@@ -520,7 +520,7 @@ end
 Implemented by cluster managers.
 It is called on the master process, by [`rmprocs`](@ref).
 It should cause the remote worker specified by `pid` to exit.
-`Base.kill(manager::ClusterManager.....)` executes a remote `exit()`
+`kill(manager::ClusterManager.....)` executes a remote `exit()`
 on `pid`.
 """
 function kill(manager::ClusterManager, pid::Int, config::WorkerConfig)

base/exports.jl

@@ -730,7 +730,6 @@ export
     bin,
     bits,
     bytes2hex,
-    charwidth,
     chomp,
     chop,
     chr2ind,
@@ -800,8 +799,8 @@ export
     sprint,
     string,
     strip,
-    strwidth,
     summary,
+    textwidth,
     titlecase,
     transcode,
     ucfirst,

base/inference.jl

@@ -837,7 +837,7 @@ function limit_type_depth(@nospecialize(t), d::Int, cov::Bool, vars::Vector{Type
             end
             ub = Any
         else
-            ub = limit_type_depth(v.ub, d - 1, true)
+            ub = limit_type_depth(v.ub, d - 1, cov, vars)
         end
         if v.lb === Bottom || type_depth(v.lb) > d
             # note: lower bounds need to be widened by making them lower
@@ -855,7 +855,8 @@ function limit_type_depth(@nospecialize(t), d::Int, cov::Bool, vars::Vector{Type
     if d < 0
         if isvarargtype(t)
             # never replace Vararg with non-Vararg
-            return Vararg{limit_type_depth(P[1], d, cov, vars), P[2]}
+            # passing depth=0 avoids putting a bare typevar here, for the diagonal rule
+            return Vararg{limit_type_depth(P[1], 0, cov, vars), P[2]}
         end
         widert = t.name.wrapper
         if !(t <: widert)
@@ -870,7 +871,11 @@ function limit_type_depth(@nospecialize(t), d::Int, cov::Bool, vars::Vector{Type
         return var
     end
     stillcov = cov && (t.name === Tuple.name)
-    Q = map(x -> limit_type_depth(x, d - 1, stillcov, vars), P)
+    newdepth = d - 1
+    if isvarargtype(t)
+        newdepth = max(newdepth, 0)
+    end
+    Q = map(x -> limit_type_depth(x, newdepth, stillcov, vars), P)
     R = t.name.wrapper{Q...}
     if cov && !stillcov
         for var in vars