JuliaLang · ararslan · Nov 3, 2018 · Sep 16, 2018 · Sep 17, 2018 · Sep 17, 2018
diff --git a/Make.inc b/Make.inc
@@ -972,7 +972,7 @@ ifeq ($(OS), FreeBSD)
   RPATH += -Wl,-rpath,'$$ORIGIN/$(build_private_libdir_rel)'
 endif
   RPATH_ORIGIN := -Wl,-rpath,'$$ORIGIN' -Wl,-z,origin
-  RPATH_ESCAPED_ORIGIN := -Wl,-rpath,'\$$\$$ORIGIN' -Wl,-z,origin
+  RPATH_ESCAPED_ORIGIN := -Wl,-rpath,'\$$\$$ORIGIN' -Wl,-z,origin -Wl,-rpath-link,$(build_shlibdir)
   RPATH_LIB := -Wl,-rpath,'$$ORIGIN/julia' -Wl,-rpath,'$$ORIGIN' -Wl,-z,origin
 endif
 

diff --git a/Makefile b/Makefile
@@ -9,7 +9,7 @@ all: debug release
 # sort is used to remove potential duplicates
 DIRS := $(sort $(build_bindir) $(build_depsbindir) $(build_libdir) $(build_private_libdir) $(build_libexecdir) $(build_includedir) $(build_includedir)/julia $(build_sysconfdir)/julia $(build_datarootdir)/julia $(build_datarootdir)/julia/stdlib $(build_man1dir))
 ifneq ($(BUILDROOT),$(JULIAHOME))
-BUILDDIRS := $(BUILDROOT) $(addprefix $(BUILDROOT)/,base src ui doc deps test test/embedding)
+BUILDDIRS := $(BUILDROOT) $(addprefix $(BUILDROOT)/,base src ui doc deps stdlib test test/embedding)
 BUILDDIRMAKE := $(addsuffix /Makefile,$(BUILDDIRS))
 DIRS := $(DIRS) $(BUILDDIRS)
 $(BUILDDIRMAKE): | $(BUILDDIRS)
@@ -39,9 +39,6 @@ endif
 $(foreach dir,$(DIRS),$(eval $(call dir_target,$(dir))))
 $(foreach link,base $(JULIAHOME)/test,$(eval $(call symlink_target,$(link),$(build_datarootdir)/julia,$(notdir $(link)))))
 
-build_defaultpkgdir = $(build_datarootdir)/julia/stdlib/$(shell echo $(VERSDIR))
-$(eval $(call symlink_target,$(JULIAHOME)/stdlib,$(build_datarootdir)/julia/stdlib,$(shell echo $(VERSDIR))))
-
 julia_flisp.boot.inc.phony: julia-deps
 	@$(MAKE) $(QUIET_MAKE) -C $(BUILDROOT)/src julia_flisp.boot.inc.phony
 
@@ -56,9 +53,12 @@ ifndef JULIA_VAGRANT_BUILD
 endif
 endif
 
-julia-deps: | $(DIRS) $(build_datarootdir)/julia/base $(build_datarootdir)/julia/test $(build_defaultpkgdir)
+julia-deps: | $(DIRS) $(build_datarootdir)/julia/base $(build_datarootdir)/julia/test
 	@$(MAKE) $(QUIET_MAKE) -C $(BUILDROOT)/deps
 
+julia-stdlib: | $(DIRS)
+	@$(MAKE) $(QUIET_MAKE) -C $(BUILDROOT)/stdlib
+
 julia-base: julia-deps $(build_sysconfdir)/julia/startup.jl $(build_man1dir)/julia.1 $(build_datarootdir)/julia/julia-config.jl
 	@$(MAKE) $(QUIET_MAKE) -C $(BUILDROOT)/base
 
@@ -74,10 +74,10 @@ julia-ui-release julia-ui-debug : julia-ui-% : julia-src-%
 julia-sysimg : julia-base julia-ui-$(JULIA_BUILD_MODE)
 	@$(MAKE) $(QUIET_MAKE) -C $(BUILDROOT) $(build_private_libdir)/sys.ji JULIA_EXECUTABLE='$(JULIA_EXECUTABLE)'
 
-julia-sysimg-release : julia-sysimg julia-ui-release
+julia-sysimg-release : julia-stdlib julia-sysimg julia-ui-release
 	@$(MAKE) $(QUIET_MAKE) -C $(BUILDROOT) $(build_private_libdir)/sys.$(SHLIB_EXT)
 
-julia-sysimg-debug : julia-sysimg julia-ui-debug
+julia-sysimg-debug : julia-stdlib julia-sysimg julia-ui-debug
 	@$(MAKE) $(QUIET_MAKE) -C $(BUILDROOT) $(build_private_libdir)/sys-debug.$(SHLIB_EXT)
 
 julia-debug julia-release : julia-% : julia-ui-% julia-sysimg-% julia-symlink julia-libccalltest julia-base-cache
@@ -529,10 +529,11 @@ source-dist:
 full-source-dist: light-source-dist.tmp
 	# Get all the dependencies downloaded
 	@$(MAKE) -C deps getall NO_GIT=1
+	@$(MAKE) -C stdlib getall
 
 	# Create file full-source-dist.tmp to hold all the filenames that go into the tarball
 	cp light-source-dist.tmp full-source-dist.tmp
-	-ls deps/srccache/*.tar.gz deps/srccache/*.tar.bz2 deps/srccache/*.tar.xz deps/srccache/*.tgz deps/srccache/*.zip deps/srccache/*.pem >> full-source-dist.tmp
+	-ls deps/srccache/*.tar.gz deps/srccache/*.tar.bz2 deps/srccache/*.tar.xz deps/srccache/*.tgz deps/srccache/*.zip deps/srccache/*.pem stdlib/srccache/*.tar.gz >> full-source-dist.tmp
 
 	# Prefix everything with the current directory name (usually "julia"), then create tarball
 	DIRNAME=$$(basename $$(pwd)); \
@@ -545,6 +546,7 @@ clean: | $(CLEAN_TARGETS)
 	@-$(MAKE) -C $(BUILDROOT)/src clean
 	@-$(MAKE) -C $(BUILDROOT)/ui clean
 	@-$(MAKE) -C $(BUILDROOT)/test clean
+	@-$(MAKE) -C $(BUILDROOT)/stdlib clean-pkg
 	-rm -f $(BUILDROOT)/julia
 	-rm -f $(BUILDROOT)/*.tar.gz
 	-rm -f $(build_depsbindir)/stringreplace \

diff --git a/base/abstractarray.jl b/base/abstractarray.jl
@@ -2043,11 +2043,11 @@ collection. `destination` must be at least as large as the first collection.
 
 # Examples
 ```jldoctest
-julia> x = zeros(3);
+julia> a = zeros(3);
 
-julia> map!(x -> x * 2, x, [1, 2, 3]);
+julia> map!(x -> x * 2, a, [1, 2, 3]);
 
-julia> x
+julia> a
 3-element Array{Float64,1}:
  2.0
  4.0

diff --git a/base/bitarray.jl b/base/bitarray.jl
@@ -84,6 +84,7 @@ IndexStyle(::Type{<:BitArray}) = IndexLinear()
 const _msk64 = ~UInt64(0)
 @inline _div64(l) = l >> 6
 @inline _mod64(l) = l & 63
+@inline _blsr(x)= x & (x-1) #zeros the last set bit. Has native instruction on many archs. needed in multidimensional.jl
 @inline _msk_end(l::Integer) = _msk64 >>> _mod64(-l)
 @inline _msk_end(B::BitArray) = _msk_end(length(B))
 num_bit_chunks(n::Int) = _div64(n+63)

diff --git a/base/client.jl b/base/client.jl
@@ -226,7 +226,11 @@ function exec_options(opts)
     # Load Distributed module only if any of the Distributed options have been specified.
     distributed_mode = (opts.worker == 1) || (opts.nprocs > 0) || (opts.machine_file != C_NULL)
     if distributed_mode
-        Core.eval(Main, :(using Distributed))
+        let Distributed = require(PkgId(UUID((0x8ba89e20_285c_5b6f, 0x9357_94700520ee1b)), "Distributed"))
+            Core.eval(Main, :(const Distributed = $Distributed))
+            Core.eval(Main, :(using .Distributed))
+        end
+
         invokelatest(Main.Distributed.process_opts, opts)
     end
 

diff --git a/base/compiler/optimize.jl b/base/compiler/optimize.jl
@@ -145,10 +145,14 @@ end
 # These affect control flow within the function (so may not be removed
 # if there is no usage within the function), but don't affect the purity
 # of the function as a whole.
-function stmt_affects_purity(@nospecialize stmt)
-    if isa(stmt, GotoIfNot) || isa(stmt, GotoNode) || isa(stmt, ReturnNode)
+function stmt_affects_purity(@nospecialize(stmt), ir)
+    if isa(stmt, GotoNode) || isa(stmt, ReturnNode)
         return false
     end
+    if isa(stmt, GotoIfNot)
+        t = argextype(stmt.cond, ir, ir.spvals)
+        return !(t ⊑ Bool)
+    end
     if isa(stmt, Expr)
         return stmt.head != :simdloop && stmt.head != :enter
     end
@@ -173,7 +177,7 @@ function optimize(opt::OptimizationState, @nospecialize(result))
             proven_pure = true
             for i in 1:length(ir.stmts)
                 stmt = ir.stmts[i]
-                if stmt_affects_purity(stmt) && !stmt_effect_free(stmt, ir.types[i], ir, ir.spvals)
+                if stmt_affects_purity(stmt, ir) && !stmt_effect_free(stmt, ir.types[i], ir, ir.spvals)
                     proven_pure = false
                     break
                 end
@@ -230,15 +234,19 @@ function optimize(opt::OptimizationState, @nospecialize(result))
     if force_noinline
         opt.src.inlineable = false
     elseif isa(def, Method)
-        bonus = 0
-        if result ⊑ Tuple && !isbitstype(widenconst(result))
-            bonus = opt.params.inline_tupleret_bonus
-        end
-        if opt.src.inlineable
-            # For functions declared @inline, increase the cost threshold 20x
-            bonus += opt.params.inline_cost_threshold*19
+        if opt.src.inlineable && isdispatchtuple(opt.linfo.specTypes)
+            # obey @inline declaration if a dispatch barrier would not help
+        else
+            bonus = 0
+            if result ⊑ Tuple && !isbitstype(widenconst(result))
+                bonus = opt.params.inline_tupleret_bonus
+            end
+            if opt.src.inlineable
+                # For functions declared @inline, increase the cost threshold 20x
+                bonus += opt.params.inline_cost_threshold*19
+            end
+            opt.src.inlineable = isinlineable(def, opt, bonus)
         end
-        opt.src.inlineable = isinlineable(def, opt, bonus)
     end
     nothing
 end
@@ -312,7 +320,7 @@ function statement_cost(ex::Expr, line::Int, src::CodeInfo, spvals::SimpleVector
                 atyp = argextype(ex.args[3], src, spvals, slottypes)
                 return isknowntype(atyp) ? 4 : params.inline_nonleaf_penalty
             end
-            fidx = findfirst(x->x===f, T_FFUNC_KEY)
+            fidx = find_tfunc(f)
             if fidx === nothing
                 # unknown/unhandled builtin or anonymous function
                 # Use the generic cost of a direct function call

diff --git a/base/compiler/tfuncs.jl b/base/compiler/tfuncs.jl
@@ -18,6 +18,13 @@ const T_IFUNC_COST = Vector{Int}(undef, N_IFUNC)
 const T_FFUNC_KEY = Vector{Any}()
 const T_FFUNC_VAL = Vector{Tuple{Int, Int, Any}}()
 const T_FFUNC_COST = Vector{Int}()
+function find_tfunc(@nospecialize f)
+    for i = 1:length(T_FFUNC_KEY)
+        if T_FFUNC_KEY[i] === f
+            return i
+        end
+    end
+end
 
 const DATATYPE_NAME_FIELDINDEX = fieldindex(DataType, :name)
 const DATATYPE_PARAMETERS_FIELDINDEX = fieldindex(DataType, :parameters)
@@ -221,10 +228,11 @@ function egal_tfunc(@nospecialize(x), @nospecialize(y))
     if isa(x, Conditional) && isa(yy, Const)
         yy.val === false && return Conditional(x.var, x.elsetype, x.vtype)
         yy.val === true && return x
-        return x
+        return Const(false)
     elseif isa(y, Conditional) && isa(xx, Const)
         xx.val === false && return Conditional(y.var, y.elsetype, y.vtype)
         xx.val === true && return y
+        return Const(false)
     elseif isa(xx, Const) && isa(yy, Const)
         return Const(xx.val === yy.val)
     elseif typeintersect(widenconst(xx), widenconst(yy)) === Bottom
@@ -1151,7 +1159,7 @@ function builtin_tfunction(@nospecialize(f), argtypes::Array{Any,1},
         end
         tf = T_IFUNC[iidx]
     else
-        fidx = findfirst(x->x===f, T_FFUNC_KEY)
+        fidx = find_tfunc(f)
         if fidx === nothing
             # unknown/unhandled builtin function
             return Any

diff --git a/base/docs/basedocs.jl b/base/docs/basedocs.jl
@@ -794,7 +794,7 @@ devnull
 """
     Nothing
 
-A type with no fields that is the type [`nothing`](@ref).
+A type with no fields that is the type of [`nothing`](@ref).
 """
 Nothing
 
@@ -1867,13 +1867,19 @@ typeassert
     getproperty(value, name::Symbol)
 
 The syntax `a.b` calls `getproperty(a, :b)`.
+
+See also [`propertynames`](@ref Base.propertynames) and
+[`setproperty!`](@ref Base.setproperty!).
 """
 Base.getproperty
 
 """
     setproperty!(value, name::Symbol, x)
 
 The syntax `a.b = c` calls `setproperty!(a, :b, c)`.
+
+See also [`propertynames`](@ref Base.propertynames) and
+[`getproperty`](@ref Base.getproperty).
 """
 Base.setproperty!
 

diff --git a/base/floatfuncs.jl b/base/floatfuncs.jl
@@ -19,11 +19,13 @@ signbit(x::Float16) = signbit(bitcast(Int16, x))
 """
     maxintfloat(T=Float64)
 
-The largest consecutive integer that is exactly represented in the given floating-point type `T`
-(which defaults to `Float64`).
+The largest consecutive integer-valued floating-point number that is exactly represented in
+the given floating-point type `T` (which defaults to `Float64`).
 
-That is, `maxintfloat` returns the smallest positive integer `n` such that `n+1`
-is *not* exactly representable in the type `T`.
+That is, `maxintfloat` returns the smallest positive integer-valued floating-point number
+`n` such that `n+1` is *not* exactly representable in the type `T`.
+
+When an `Integer`-type value is needed, use `Integer(maxintfloat(T))`.
 """
 maxintfloat(::Type{Float64}) = 9007199254740992.
 maxintfloat(::Type{Float32}) = Float32(16777216.)

diff --git a/base/generator.jl b/base/generator.jl
@@ -126,4 +126,3 @@ IteratorEltype(::Type) = HasEltype()  # HasEltype is the default
 IteratorEltype(::Type{Generator{I,T}}) where {I,T} = EltypeUnknown()
 
 IteratorEltype(::Type{Any}) = EltypeUnknown()
-IteratorEltype(::Type{Union{}}) = EltypeUnknown()
diff --git a/base/initdefs.jl b/base/initdefs.jl
@@ -75,7 +75,7 @@ const DEFAULT_LOAD_PATH = ["@", "@v#.#", "@stdlib"]
 """
     LOAD_PATH
 
-An array of paths for `using` and `import` statements to consdier as project
+An array of paths for `using` and `import` statements to consider as project
 environments or package directories when loading code. See Code Loading.
 """
 const LOAD_PATH = copy(DEFAULT_LOAD_PATH)

diff --git a/base/intfuncs.jl b/base/intfuncs.jl
@@ -744,17 +744,25 @@ julia> digits!([2,2,2,2,2,2], 10, base = 2)
 ```
 """
 function digits!(a::AbstractVector{T}, n::Integer; base::Integer = 10) where T<:Integer
-    base < 0 && isa(n, Unsigned) && return digits!(a, convert(Signed, n), base = base)
     2 <= abs(base) || throw(ArgumentError("base must be ≥ 2 or ≤ -2, got $base"))
     hastypemax(T) && abs(base) - 1 > typemax(T) &&
         throw(ArgumentError("type $T too small for base $base"))
-    for i in eachindex(a)
-        if base > 0
-            a[i] = rem(n, base)
-            n = div(n, base)
-        else
-            a[i] = mod(n, -base)
-            n = cld(n, base)
+    isempty(a) && return a
+
+    if base > 0
+        for i in eachindex(a)
+            n, d = divrem(n, base)
+            a[i] = d
+        end
+    else
+        # manually peel one loop iteration for type stability
+        n, d = fldmod(n, -base)
+        a[firstindex(a)] = d
+        n = -signed(n)
+        for i in firstindex(a)+1:lastindex(a)
+            n, d = fldmod(n, -base)
+            a[i] = d
+            n = -n
         end
     end
     return a

diff --git a/base/iterators.jl b/base/iterators.jl
@@ -873,18 +873,20 @@ julia> collect(Iterators.flatten((1:2, 8:9)))
 flatten(itr) = Flatten(itr)
 
 eltype(::Type{Flatten{I}}) where {I} = eltype(eltype(I))
+eltype(::Type{Flatten{Tuple{}}}) = eltype(Tuple{})
 IteratorEltype(::Type{Flatten{I}}) where {I} = _flatteneltype(I, IteratorEltype(I))
+IteratorEltype(::Type{Flatten{Tuple{}}}) = IteratorEltype(Tuple{})
 _flatteneltype(I, ::HasEltype) = IteratorEltype(eltype(I))
 _flatteneltype(I, et) = EltypeUnknown()
 
 flatten_iteratorsize(::Union{HasShape, HasLength}, ::Type{<:NTuple{N,Any}}) where {N} = HasLength()
 flatten_iteratorsize(::Union{HasShape, HasLength}, ::Type{<:Tuple}) = SizeUnknown()
 flatten_iteratorsize(::Union{HasShape, HasLength}, ::Type{<:Number}) = HasLength()
-flatten_iteratorsize(::Union{HasShape, HasLength}, ::Type{Union{}}) = SizeUnknown()
 flatten_iteratorsize(a, b) = SizeUnknown()
 
 _flatten_iteratorsize(sz, ::EltypeUnknown, I) = SizeUnknown()
 _flatten_iteratorsize(sz, ::HasEltype, I) = flatten_iteratorsize(sz, eltype(I))
+_flatten_iteratorsize(sz, ::HasEltype, ::Type{Tuple{}}) = HasLength()
 
 IteratorSize(::Type{Flatten{I}}) where {I} = _flatten_iteratorsize(IteratorSize(I), IteratorEltype(I), I)
 
@@ -895,6 +897,7 @@ flatten_length(f, ::Type{<:Number}) = length(f.it)
 flatten_length(f, T) = throw(ArgumentError(
     "Iterates of the argument to Flatten are not known to have constant length"))
 length(f::Flatten{I}) where {I} = flatten_length(f, eltype(I))
+length(f::Flatten{Tuple{}}) = 0
 
 @propagate_inbounds function iterate(f::Flatten, state=())
     if state !== ()
@@ -903,7 +906,13 @@ length(f::Flatten{I}) where {I} = flatten_length(f, eltype(I))
     end
     x = (state === () ? iterate(f.it) : iterate(f.it, state[1]))
     x === nothing && return nothing
-    iterate(f, (x[2], x[1]))
+    y = iterate(x[1])
+    while y === nothing
+         x = iterate(f.it, x[2])
+         x === nothing && return nothing
+         y = iterate(x[1])
+    end
+    return y[1], (x[2], x[1], y[2])
 end
 
 reverse(f::Flatten) = Flatten(reverse(itr) for itr in reverse(f.it))

diff --git a/base/loading.jl b/base/loading.jl
@@ -615,6 +615,9 @@ end
 # and it reconnects the Base.Docs.META
 function _include_from_serialized(path::String, depmods::Vector{Any})
     sv = ccall(:jl_restore_incremental, Any, (Cstring, Any), path, depmods)
+    if isa(sv, Exception)
+        return sv
+    end
     restored = sv[1]
     if !isa(restored, Exception)
         for M in restored::Vector{Any}