From ad0ddc642fe0bbf46b387f967a8b510aa8855e73 Mon Sep 17 00:00:00 2001
From: Alex Arslan <ararslan@comcast.net>
Date: Wed, 20 Dec 2017 11:44:09 -0800
Subject: [PATCH 1/8] Add AbstractDict

---
 README.md        | 3 +++
 src/Compat.jl    | 6 ++++++
 test/runtests.jl | 3 +++
 3 files changed, 12 insertions(+)

diff --git a/README.md b/README.md
index 436a8e90c..5d7d2c348 100644
--- a/README.md
+++ b/README.md
@@ -244,6 +244,8 @@ Currently, the `@compat` macro supports the following syntaxes:
 * `Complex32`, `Complex64`, and `Complex128` are now `ComplexF16`, `ComplexF32`, and
   `ComplexF64`, respectively ([#24647]).
 
+* `Associative` is now `AbstractDict` ([#25012]).
+
 ## New macros
 
 * `@__DIR__` has been added ([#18380])
@@ -392,4 +394,5 @@ includes this fix. Find the minimum version from there.
 [#24652]: https://github.com/JuliaLang/julia/issues/24652
 [#24657]: https://github.com/JuliaLang/julia/issues/24657
 [#24785]: https://github.com/JuliaLang/julia/issues/24785
+[#25012]: https://github.com/JuliaLang/julia/issues/25012
 [#25021]: https://github.com/JuliaLang/julia/issues/25021
diff --git a/src/Compat.jl b/src/Compat.jl
index 258ea3dea..0fab08bf9 100644
--- a/src/Compat.jl
+++ b/src/Compat.jl
@@ -953,6 +953,12 @@ module Unicode
     end
 end
 
+# 0.7.0-DEV.2951
+@static if !isdefined(Base, :AbstractDict)
+    const AbstractDict = Associative
+    export AbstractDict
+end
+
 include("deprecated.jl")
 
 end # module Compat
diff --git a/test/runtests.jl b/test/runtests.jl
index a5f4306f9..0c61d2d94 100644
--- a/test/runtests.jl
+++ b/test/runtests.jl
@@ -997,6 +997,9 @@ module Test25021
     @test titlecase("firstname lastname") == "Firstname Lastname"
 end
 
+# 0.7.0-DEV.2951
+@test AbstractDict === (isdefined(Base, :AbstractDict) ? Base.AbstractDict : Base.Associative)
+
 if VERSION < v"0.6.0"
     include("deprecated.jl")
 end

From 6922b6f05e43e48dff296b3354c8421487445a0c Mon Sep 17 00:00:00 2001
From: Alex Arslan <ararslan@comcast.net>
Date: Wed, 20 Dec 2017 11:52:04 -0800
Subject: [PATCH 2/8] Add Printf

---
 README.md        |  4 ++++
 src/Compat.jl    |  6 ++++++
 test/runtests.jl | 10 ++++++++++
 3 files changed, 20 insertions(+)

diff --git a/README.md b/README.md
index 5d7d2c348..c7778cd80 100644
--- a/README.md
+++ b/README.md
@@ -98,6 +98,9 @@ Currently, the `@compat` macro supports the following syntaxes:
 * `using Compat.Unicode` is provided on versions older than 0.7, where this library is not
   yet a part of the standard library. ([#25021])
 
+* `using Compat.Printf` is provided on versions older than 0.7, where this library is not
+  yet a part of the standard library. ([#25056])
+
 ## New functions, macros, and methods
 
 * `@views` takes an expression and converts all slices to views ([#20164]), while
@@ -396,3 +399,4 @@ includes this fix. Find the minimum version from there.
 [#24785]: https://github.com/JuliaLang/julia/issues/24785
 [#25012]: https://github.com/JuliaLang/julia/issues/25012
 [#25021]: https://github.com/JuliaLang/julia/issues/25021
+[#25056]: https://github.com/JuliaLang/julia/issues/25056
diff --git a/src/Compat.jl b/src/Compat.jl
index 0fab08bf9..daad8f6cf 100644
--- a/src/Compat.jl
+++ b/src/Compat.jl
@@ -763,6 +763,12 @@ else
     import Dates
 end
 
+if VERSION < v"0.7.0-DEV.3052"
+    const Printf = Base.Printf
+else
+    import Printf
+end
+
 # 0.7.0-DEV.1993
 @static if !isdefined(Base, :EqualTo)
     if VERSION >= v"0.6.0"
diff --git a/test/runtests.jl b/test/runtests.jl
index 0c61d2d94..8d0e2894e 100644
--- a/test/runtests.jl
+++ b/test/runtests.jl
@@ -902,6 +902,16 @@ module Test24459
     @test isdefined(@__MODULE__, :Dates)
 end
 
+# 0.7
+module Test25056
+    using Compat
+    using Compat.Test
+    using Compat.Printf
+    @test isdefined(@__MODULE__, :Printf)
+    @test isdefined(@__MODULE__, Symbol("@printf"))
+    @test isdefined(@__MODULE__, Symbol("@sprintf"))
+end
+
 let a = [0,1,2,3,0,1,2,3]
     @test findfirst(equalto(3), [1,2,4,1,2,3,4]) == 6
     @test findfirst(!equalto(1), [1,2,4,1,2,3,4]) == 2

From 2ba0b740c7fbbdfca1be251925117bff862a1bf3 Mon Sep 17 00:00:00 2001
From: Alex Arslan <ararslan@comcast.net>
Date: Wed, 20 Dec 2017 12:29:22 -0800
Subject: [PATCH 3/8] Add IterativeEigensolvers

---
 README.md        |  4 ++++
 src/Compat.jl    | 12 ++++++++++++
 test/runtests.jl | 10 ++++++++++
 3 files changed, 26 insertions(+)

diff --git a/README.md b/README.md
index c7778cd80..c64a4013b 100644
--- a/README.md
+++ b/README.md
@@ -101,6 +101,9 @@ Currently, the `@compat` macro supports the following syntaxes:
 * `using Compat.Printf` is provided on versions older than 0.7, where this library is not
   yet a part of the standard library. ([#25056])
 
+* `using Compat.IterativeEigensolvers` is provided on versions older than 0.7, where this
+  library is not yet a part of the standard library. ([#24714])
+
 ## New functions, macros, and methods
 
 * `@views` takes an expression and converts all slices to views ([#20164]), while
@@ -396,6 +399,7 @@ includes this fix. Find the minimum version from there.
 [#24647]: https://github.com/JuliaLang/julia/issues/24647
 [#24652]: https://github.com/JuliaLang/julia/issues/24652
 [#24657]: https://github.com/JuliaLang/julia/issues/24657
+[#24714]: https://github.com/JuliaLang/julia/issues/24714
 [#24785]: https://github.com/JuliaLang/julia/issues/24785
 [#25012]: https://github.com/JuliaLang/julia/issues/25012
 [#25021]: https://github.com/JuliaLang/julia/issues/25021
diff --git a/src/Compat.jl b/src/Compat.jl
index daad8f6cf..d046efe7a 100644
--- a/src/Compat.jl
+++ b/src/Compat.jl
@@ -769,6 +769,18 @@ else
     import Printf
 end
 
+if VERSION < v"0.7.0-DEV.2655"
+    @eval module IterativeEigensolvers
+        using Base: eigs, svds
+        export eigs, svds
+    end
+elseif VERSION < v"0.7.0-DEV.3019"
+    import IterativeEigenSolvers
+    const IterativeEigensolvers = IterativeEigenSolvers
+else
+    import IterativeEigensolvers
+end
+
 # 0.7.0-DEV.1993
 @static if !isdefined(Base, :EqualTo)
     if VERSION >= v"0.6.0"
diff --git a/test/runtests.jl b/test/runtests.jl
index 8d0e2894e..be0161346 100644
--- a/test/runtests.jl
+++ b/test/runtests.jl
@@ -912,6 +912,16 @@ module Test25056
     @test isdefined(@__MODULE__, Symbol("@sprintf"))
 end
 
+# 0.7
+module Test24714
+    using Compat
+    using Compat.Test
+    using Compat.IterativeEigensolvers
+    @test isdefined(@__MODULE__, :IterativeEigensolvers)
+    @test isdefined(@__MODULE__, :eigs)
+    @test isdefined(@__MODULE__, :svds)
+end
+
 let a = [0,1,2,3,0,1,2,3]
     @test findfirst(equalto(3), [1,2,4,1,2,3,4]) == 6
     @test findfirst(!equalto(1), [1,2,4,1,2,3,4]) == 2

From 2ae78920298c62b33a055e9ca4bbef96fedd1391 Mon Sep 17 00:00:00 2001
From: Alex Arslan <ararslan@comcast.net>
Date: Wed, 20 Dec 2017 12:43:50 -0800
Subject: [PATCH 4/8] Add SuiteSparse

---
 README.md        |  4 ++++
 src/Compat.jl    | 11 +++++++++++
 test/runtests.jl |  8 ++++++++
 3 files changed, 23 insertions(+)

diff --git a/README.md b/README.md
index c64a4013b..ad13cbd05 100644
--- a/README.md
+++ b/README.md
@@ -104,6 +104,9 @@ Currently, the `@compat` macro supports the following syntaxes:
 * `using Compat.IterativeEigensolvers` is provided on versions older than 0.7, where this
   library is not yet a part of the standard library. ([#24714])
 
+* `using Compat.SuiteSparse` is provided on versions older than 0.7, where this library is
+  not yet part of the standard library ([#24648]).
+
 ## New functions, macros, and methods
 
 * `@views` takes an expression and converts all slices to views ([#20164]), while
@@ -397,6 +400,7 @@ includes this fix. Find the minimum version from there.
 [#24459]: https://github.com/JuliaLang/julia/issues/24459
 [#24605]: https://github.com/JuliaLang/julia/issues/24605
 [#24647]: https://github.com/JuliaLang/julia/issues/24647
+[#24648]: https://github.com/JuliaLang/julia/issues/24648
 [#24652]: https://github.com/JuliaLang/julia/issues/24652
 [#24657]: https://github.com/JuliaLang/julia/issues/24657
 [#24714]: https://github.com/JuliaLang/julia/issues/24714
diff --git a/src/Compat.jl b/src/Compat.jl
index d046efe7a..ee6365251 100644
--- a/src/Compat.jl
+++ b/src/Compat.jl
@@ -781,6 +781,17 @@ else
     import IterativeEigensolvers
 end
 
+if VERSION < v"0.7.0-DEV.2609"
+    @eval module SuiteSparse
+        if Base.USE_GPL_LIBS
+            using Base.SparseArrays: CHOLMOD, SPQR, UMFPACK
+        end
+        using Base.SparseArrays: increment, increment!, decrement, decrement!
+    end
+else
+    import SuiteSparse
+end
+
 # 0.7.0-DEV.1993
 @static if !isdefined(Base, :EqualTo)
     if VERSION >= v"0.6.0"
diff --git a/test/runtests.jl b/test/runtests.jl
index be0161346..1a62bece9 100644
--- a/test/runtests.jl
+++ b/test/runtests.jl
@@ -922,6 +922,14 @@ module Test24714
     @test isdefined(@__MODULE__, :svds)
 end
 
+# 0.7
+module Test24648
+    using Compat
+    using Compat.Test
+    using Compat.SuiteSparse
+    @test isdefined(@__MODULE__, :SuiteSparse)
+end
+
 let a = [0,1,2,3,0,1,2,3]
     @test findfirst(equalto(3), [1,2,4,1,2,3,4]) == 6
     @test findfirst(!equalto(1), [1,2,4,1,2,3,4]) == 2

From b11dd5d31ee0bc98d615d315282becd74e629478 Mon Sep 17 00:00:00 2001
From: Alex Arslan <ararslan@comcast.net>
Date: Wed, 20 Dec 2017 12:51:03 -0800
Subject: [PATCH 5/8] Add axes

---
 README.md        | 3 +++
 src/Compat.jl    | 6 ++++++
 test/runtests.jl | 5 +++++
 3 files changed, 14 insertions(+)

diff --git a/README.md b/README.md
index ad13cbd05..cb5531390 100644
--- a/README.md
+++ b/README.md
@@ -255,6 +255,8 @@ Currently, the `@compat` macro supports the following syntaxes:
 
 * `Associative` is now `AbstractDict` ([#25012]).
 
+* `indices` is now `axes` ([#25057]).
+
 ## New macros
 
 * `@__DIR__` has been added ([#18380])
@@ -408,3 +410,4 @@ includes this fix. Find the minimum version from there.
 [#25012]: https://github.com/JuliaLang/julia/issues/25012
 [#25021]: https://github.com/JuliaLang/julia/issues/25021
 [#25056]: https://github.com/JuliaLang/julia/issues/25056
+[#25057]: https://github.com/JuliaLang/julia/issues/25057
diff --git a/src/Compat.jl b/src/Compat.jl
index ee6365251..9dd468cb0 100644
--- a/src/Compat.jl
+++ b/src/Compat.jl
@@ -988,6 +988,12 @@ end
     export AbstractDict
 end
 
+# 0.7.0-DEV.2978
+@static if !isdefined(Base, :axes)
+    const axes = Base.indices
+    export axes
+end
+
 include("deprecated.jl")
 
 end # module Compat
diff --git a/test/runtests.jl b/test/runtests.jl
index 1a62bece9..d3a20baee 100644
--- a/test/runtests.jl
+++ b/test/runtests.jl
@@ -1028,6 +1028,11 @@ end
 # 0.7.0-DEV.2951
 @test AbstractDict === (isdefined(Base, :AbstractDict) ? Base.AbstractDict : Base.Associative)
 
+# 0.7.0-DEV.2978
+@test axes === (isdefined(Base, :axes) ? Base.axes : Base.indices)
+@test axes(1) == ()
+@test axes(1,1) == 1:1
+
 if VERSION < v"0.6.0"
     include("deprecated.jl")
 end

From 8e106e810d7e3cb21c1278a1b6bb64cacb2e4c38 Mon Sep 17 00:00:00 2001
From: Alex Arslan <ararslan@comcast.net>
Date: Wed, 20 Dec 2017 13:01:26 -0800
Subject: [PATCH 6/8] Disable Nullable tests when Nullable isn't defined

---
 test/runtests.jl | 106 ++++++++++++++++++++++++-----------------------
 1 file changed, 54 insertions(+), 52 deletions(-)

diff --git a/test/runtests.jl b/test/runtests.jl
index d3a20baee..19b962c07 100644
--- a/test/runtests.jl
+++ b/test/runtests.jl
@@ -213,58 +213,60 @@ mktemp() do fname, f
     end
 end
 
-types = [
-    Bool,
-    Float16,
-    Float32,
-    Float64,
-    Int128,
-    Int16,
-    Int32,
-    Int64,
-    Int8,
-    UInt16,
-    UInt32,
-    UInt64,
-    UInt8,
-]
-for T in types
-    # julia#18510, Nullable constructors
-    x = @compat Nullable(one(T), true)
-    @test isnull(x) === false
-    @test isa(x.value, T)
-    @test eltype(x) === T
-
-    x = @compat Nullable{T}(one(T), true)
-    y = @compat Nullable{Any}(one(T), true)
-    @test isnull(x) === false
-    @test isnull(y) === false
-    @test isa(x.value, T)
-    @test eltype(x) === T
-    @test eltype(y) === Any
-
-    x = @compat Nullable{T}(one(T), false)
-    y = @compat Nullable{Any}(one(T), false)
-    @test isnull(x) === true
-    @test isnull(y) === true
-    @test eltype(x) === T
-    @test eltype(y) === Any
-
-    x = @compat Nullable(one(T), false)
-    @test isnull(x) === true
-    @test eltype(x) === T
-
-    x = @compat Nullable{T}()
-    @test isnull(x) === true
-    @test eltype(x) === T
-
-    # julia#18484, generic isnull, unsafe_get
-    a = one(T)
-    x = @compat Nullable(a, true)
-    @test isequal(unsafe_get(x), a)
-
-    x = @compat Nullable{Array{T}}()
-    @test_throws UndefRefError unsafe_get(x)
+if VERSION < v"0.7.0-DEV.3017"
+    types = [
+        Bool,
+        Float16,
+        Float32,
+        Float64,
+        Int128,
+        Int16,
+        Int32,
+        Int64,
+        Int8,
+        UInt16,
+        UInt32,
+        UInt64,
+        UInt8,
+    ]
+    for T in types
+        # julia#18510, Nullable constructors
+        x = @compat Nullable(one(T), true)
+        @test isnull(x) === false
+        @test isa(x.value, T)
+        @test eltype(x) === T
+
+        x = @compat Nullable{T}(one(T), true)
+        y = @compat Nullable{Any}(one(T), true)
+        @test isnull(x) === false
+        @test isnull(y) === false
+        @test isa(x.value, T)
+        @test eltype(x) === T
+        @test eltype(y) === Any
+
+        x = @compat Nullable{T}(one(T), false)
+        y = @compat Nullable{Any}(one(T), false)
+        @test isnull(x) === true
+        @test isnull(y) === true
+        @test eltype(x) === T
+        @test eltype(y) === Any
+
+        x = @compat Nullable(one(T), false)
+        @test isnull(x) === true
+        @test eltype(x) === T
+
+        x = @compat Nullable{T}()
+        @test isnull(x) === true
+        @test eltype(x) === T
+
+        # julia#18484, generic isnull, unsafe_get
+        a = one(T)
+        x = @compat Nullable(a, true)
+        @test isequal(unsafe_get(x), a)
+
+        x = @compat Nullable{Array{T}}()
+        @test_throws UndefRefError unsafe_get(x)
+    end
 end
 
 @test xor(1,5) == 4

From 3832a22407c17e4608257fdde2d43da6e01d7582 Mon Sep 17 00:00:00 2001
From: Alex Arslan <ararslan@comcast.net>
Date: Wed, 20 Dec 2017 13:24:46 -0800
Subject: [PATCH 7/8] Add Some, coalesce, notnothing

---
 README.md        |  3 +++
 src/Compat.jl    | 42 ++++++++++++++++++++++++++++++++++++++++++
 test/runtests.jl | 12 ++++++++++++
 3 files changed, 57 insertions(+)

diff --git a/README.md b/README.md
index cb5531390..b327e6274 100644
--- a/README.md
+++ b/README.md
@@ -217,6 +217,8 @@ Currently, the `@compat` macro supports the following syntaxes:
 
 * `get` do-block syntax supported when using `ENV` ([#23412]).
 
+* `Some{T}` wraps `T` to signify that a result of `T<:Void` is expected ([#23642]).
+
 ## Renaming
 
 
@@ -391,6 +393,7 @@ includes this fix. Find the minimum version from there.
 [#23412]: https://github.com/JuliaLang/julia/issues/23412
 [#23427]: https://github.com/JuliaLang/julia/issues/23427
 [#23570]: https://github.com/JuliaLang/julia/issues/23570
+[#23642]: https://github.com/JuliaLang/julia/issues/23642
 [#23666]: https://github.com/JuliaLang/julia/issues/23666
 [#23757]: https://github.com/JuliaLang/julia/issues/23757
 [#23812]: https://github.com/JuliaLang/julia/issues/23812
diff --git a/src/Compat.jl b/src/Compat.jl
index 9dd468cb0..e4aef80c4 100644
--- a/src/Compat.jl
+++ b/src/Compat.jl
@@ -994,6 +994,48 @@ end
     export axes
 end
 
+@static if !isdefined(Base, :Some)
+    import Base: promote_rule, convert
+    if VERSION >= v"0.6.0"
+        include_string(@__MODULE__, """
+            struct Some{T}
+                value::T
+            end
+            promote_rule(::Type{Some{S}}, ::Type{Some{T}}) where {S,T} = Some{promote_type(S, T)}
+            promote_rule(::Type{Some{T}}, ::Type{Void}) where {T} = Union{Some{T}, Void}
+            convert(::Type{Some{T}}, x::Some) where {T} = Some{T}(convert(T, x.value))
+            convert(::Type{Union{Some{T}, Void}}, x::Some) where {T} = convert(Some{T}, x)
+            convert(::Type{Union{T, Void}}, x::Any) where {T} = convert(T, x)
+        """)
+    else
+        include_string(@__MODULE__, """
+            immutable Some{T}
+                value::T
+            end
+            promote_rule{S,T}(::Type{Some{S}}, ::Type{Some{T}}) = Some{promote_type(S, T)}
+            promote_rule{T}(::Type{Some{T}}, ::Type{Void}) = Union{Some{T}, Void}
+            convert{T}(::Type{Some{T}}, x::Some) = Some{T}(convert(T, x.value))
+            convert{T}(::Type{Union{Some{T}, Void}}, x::Some) = convert(Some{T}, x)
+            convert{T}(::Type{Union{T, Void}}, x::Any) = convert(T, x)
+        """)
+    end
+    convert(::Type{Void}, x::Any) = throw(MethodError(convert, (Void, x)))
+    convert(::Type{Void}, x::Void) = nothing
+    coalesce(x::Any) = x
+    coalesce(x::Some) = x.value
+    coalesce(x::Void) = nothing
+    #coalesce(x::Missing) = missing
+    coalesce(x::Any, y...) = x
+    coalesce(x::Some, y...) = x.value
+    coalesce(x::Void, y...) = coalesce(y...)
+    #coalesce(x::Union{Void, Missing}, y...) = coalesce(y...)
+    notnothing(x::Any) = x
+    notnothing(::Void) = throw(ArgumentError("nothing passed to notnothing"))
+    export Some, coalesce
+else
+    import Base: notnothing
+end
+
 include("deprecated.jl")
 
 end # module Compat
diff --git a/test/runtests.jl b/test/runtests.jl
index 19b962c07..b0bda88c0 100644
--- a/test/runtests.jl
+++ b/test/runtests.jl
@@ -1035,6 +1035,18 @@ end
 @test axes(1) == ()
 @test axes(1,1) == 1:1
 
+# 0.7.0-DEV.3017
+@test isa(Some(1), Some{Int})
+@test convert(Some{Float64}, Some(1)) == Some(1.0)
+@test convert(Void, nothing) == nothing
+@test_throws MethodError convert(Void, 1)
+@test Some(nothing) != nothing
+@test coalesce(Some(1)) == 1
+@test coalesce(nothing) == nothing
+@test coalesce(nothing, Some(1), Some(2)) == 1
+@test Compat.notnothing(1) == 1
+@test_throws ArgumentError Compat.notnothing(nothing)
+
 if VERSION < v"0.6.0"
     include("deprecated.jl")
 end

From 9ffecc0a4b8da31ae0d11bbfad1d5e0664cbef0f Mon Sep 17 00:00:00 2001
From: Alex Arslan <ararslan@comcast.net>
Date: Wed, 20 Dec 2017 16:45:33 -0800
Subject: [PATCH 8/8] Add Nothing and Cvoid

---
 README.md        |  3 +++
 src/Compat.jl    | 31 +++++++++++++++++++------------
 test/runtests.jl |  4 ++++
 3 files changed, 26 insertions(+), 12 deletions(-)

diff --git a/README.md b/README.md
index b327e6274..1a6108424 100644
--- a/README.md
+++ b/README.md
@@ -259,6 +259,8 @@ Currently, the `@compat` macro supports the following syntaxes:
 
 * `indices` is now `axes` ([#25057]).
 
+* `Void` is now `Nothing` with an alias `Cvoid` for C interop ([#25162]).
+
 ## New macros
 
 * `@__DIR__` has been added ([#18380])
@@ -414,3 +416,4 @@ includes this fix. Find the minimum version from there.
 [#25021]: https://github.com/JuliaLang/julia/issues/25021
 [#25056]: https://github.com/JuliaLang/julia/issues/25056
 [#25057]: https://github.com/JuliaLang/julia/issues/25057
+[#25162]: https://github.com/JuliaLang/julia/issues/25162
diff --git a/src/Compat.jl b/src/Compat.jl
index e4aef80c4..7b8533730 100644
--- a/src/Compat.jl
+++ b/src/Compat.jl
@@ -994,6 +994,13 @@ end
     export axes
 end
 
+# 0.7.0-DEV.3137
+@static if !isdefined(Base, :Nothing)
+    const Nothing = Void
+    const Cvoid = Void
+    export Nothing, Cvoid
+end
+
 @static if !isdefined(Base, :Some)
     import Base: promote_rule, convert
     if VERSION >= v"0.6.0"
@@ -1002,10 +1009,10 @@ end
                 value::T
             end
             promote_rule(::Type{Some{S}}, ::Type{Some{T}}) where {S,T} = Some{promote_type(S, T)}
-            promote_rule(::Type{Some{T}}, ::Type{Void}) where {T} = Union{Some{T}, Void}
+            promote_rule(::Type{Some{T}}, ::Type{Nothing}) where {T} = Union{Some{T}, Nothing}
             convert(::Type{Some{T}}, x::Some) where {T} = Some{T}(convert(T, x.value))
-            convert(::Type{Union{Some{T}, Void}}, x::Some) where {T} = convert(Some{T}, x)
-            convert(::Type{Union{T, Void}}, x::Any) where {T} = convert(T, x)
+            convert(::Type{Union{Some{T}, Nothing}}, x::Some) where {T} = convert(Some{T}, x)
+            convert(::Type{Union{T, Nothing}}, x::Any) where {T} = convert(T, x)
         """)
     else
         include_string(@__MODULE__, """
@@ -1013,24 +1020,24 @@ end
                 value::T
             end
             promote_rule{S,T}(::Type{Some{S}}, ::Type{Some{T}}) = Some{promote_type(S, T)}
-            promote_rule{T}(::Type{Some{T}}, ::Type{Void}) = Union{Some{T}, Void}
+            promote_rule{T}(::Type{Some{T}}, ::Type{Nothing}) = Union{Some{T}, Nothing}
             convert{T}(::Type{Some{T}}, x::Some) = Some{T}(convert(T, x.value))
-            convert{T}(::Type{Union{Some{T}, Void}}, x::Some) = convert(Some{T}, x)
-            convert{T}(::Type{Union{T, Void}}, x::Any) = convert(T, x)
+            convert{T}(::Type{Union{Some{T}, Nothing}}, x::Some) = convert(Some{T}, x)
+            convert{T}(::Type{Union{T, Nothing}}, x::Any) = convert(T, x)
         """)
     end
-    convert(::Type{Void}, x::Any) = throw(MethodError(convert, (Void, x)))
-    convert(::Type{Void}, x::Void) = nothing
+    convert(::Type{Nothing}, x::Any) = throw(MethodError(convert, (Nothing, x)))
+    convert(::Type{Nothing}, x::Nothing) = nothing
     coalesce(x::Any) = x
     coalesce(x::Some) = x.value
-    coalesce(x::Void) = nothing
+    coalesce(x::Nothing) = nothing
     #coalesce(x::Missing) = missing
     coalesce(x::Any, y...) = x
     coalesce(x::Some, y...) = x.value
-    coalesce(x::Void, y...) = coalesce(y...)
-    #coalesce(x::Union{Void, Missing}, y...) = coalesce(y...)
+    coalesce(x::Nothing, y...) = coalesce(y...)
+    #coalesce(x::Union{Nothing, Missing}, y...) = coalesce(y...)
     notnothing(x::Any) = x
-    notnothing(::Void) = throw(ArgumentError("nothing passed to notnothing"))
+    notnothing(::Nothing) = throw(ArgumentError("nothing passed to notnothing"))
     export Some, coalesce
 else
     import Base: notnothing
diff --git a/test/runtests.jl b/test/runtests.jl
index b0bda88c0..c3afca36e 100644
--- a/test/runtests.jl
+++ b/test/runtests.jl
@@ -1035,6 +1035,10 @@ end
 @test axes(1) == ()
 @test axes(1,1) == 1:1
 
+# 0.7.0-DEV.3137
+@test Nothing === (isdefined(Base, :Nothing) ? Base.Nothing : Base.Void)
+@test Nothing === Cvoid
+
 # 0.7.0-DEV.3017
 @test isa(Some(1), Some{Int})
 @test convert(Some{Float64}, Some(1)) == Some(1.0)