deprecation fixes for Julia v0.7 (#110)

* deprecation fixes for Julia v0.7

* add note to warn new users

* rm old CI badges

* update Travis config for Pkg deprecation

Author: jrevels

Diff for: .travis.yml

@@ -1,18 +1,18 @@
 # Documentation: http://docs.travis-ci.com/user/languages/julia/
 language: julia
-os:
-  - linux
 julia:
-  - 0.6
-  - nightly
+    - 0.7
+    - 1.0
+    - nightly
 matrix:
   allow_failures:
     - julia: nightly
 notifications:
-  email: false
+    email: false
+sudo: false
 script:
- - if [[ -a .git/shallow ]]; then git fetch --unshallow; fi
- - julia -e 'Pkg.clone(pwd()); Pkg.build("ReverseDiff"); Pkg.test("ReverseDiff"; coverage=VERSION >= v"0.6-")'
+    - if [[ -a .git/shallow ]]; then git fetch --unshallow; fi
+    - julia -e 'using Pkg; Pkg.clone(pwd()); Pkg.build("ReverseDiff"); Pkg.test("ReverseDiff"; coverage=true)'
 after_success:
-  # push coverage results to Coveralls
-  - julia -e 'cd(Pkg.dir("ReverseDiff")); Pkg.add("Coverage"); using Coverage; Coveralls.submit(Coveralls.process_folder())'
+    # push coverage results to Coveralls
+    - julia -e 'using Pkg; cd(Pkg.dir("ReverseDiff")); Pkg.add("Coverage"); using Coverage; Coveralls.submit(Coveralls.process_folder())'

Diff for: README.md

@@ -1,14 +1,18 @@
 # ReverseDiff
 
 [![Build Status](https://travis-ci.org/JuliaDiff/ReverseDiff.jl.svg?branch=master)](https://travis-ci.org/JuliaDiff/ReverseDiff.jl)
-[![ReverseDiff](http://pkg.julialang.org/badges/ReverseDiff_0.5.svg)](http://pkg.julialang.org/?pkg=ReverseDiff)
-[![ReverseDiff](http://pkg.julialang.org/badges/ReverseDiff_0.6.svg)](http://pkg.julialang.org/?pkg=ReverseDiff)
 [![Coverage Status](https://coveralls.io/repos/github/JuliaDiff/ReverseDiff.jl/badge.svg?branch=master)](https://coveralls.io/github/JuliaDiff/ReverseDiff.jl?branch=master)
 
 [**Go To ReverseDiff's Documentation**](http://www.juliadiff.org/ReverseDiff.jl/)
 
 [**See ReverseDiff Usage Examples**](https://github.com/JuliaDiff/ReverseDiff.jl/tree/master/examples)
 
+**Note: While ReverseDiff technically supports Julia v0.7/v1.0 and is somewhat maintained, it
+is currently not actively developed. Instead, ForwardDiff/ReverseDiff's maintainers are
+focused on the development of a new AD package built on top of [Cassette](https://github.com/jrevels/Cassette.jl).
+In the meantime, it might be worth checking out other reverse-mode AD implementations in Nabla.jl,
+AutoGrad.jl, Flux.jl, or XGrad.jl.**
+
 ReverseDiff implements methods to take **gradients**, **Jacobians**, **Hessians**, and
 higher-order derivatives of native Julia functions (or any callable object, really) using
 **reverse mode automatic differentiation (AD)**.

Diff for: REQUIRE

@@ -1,9 +1,8 @@
-julia 0.6
+julia 0.7
 DiffResults 0.0.1
-DiffRules 0.0.1
+DiffRules 0.0.4
 NaNMath 0.2.2
 SpecialFunctions 0.1.0
-ForwardDiff 0.6.0
-StaticArrays 0.5.0
-Compat 0.19.0
-FunctionWrappers 0.1
+ForwardDiff 0.8.0
+StaticArrays 0.8.3
+FunctionWrappers 1.0.0

Diff for: src/ReverseDiff.jl

@@ -1,11 +1,11 @@
-__precompile__()
-
 module ReverseDiff
 
 using Base: RefValue
-using FunctionWrappers: FunctionWrapper
+using Random
+using LinearAlgebra
+using Statistics
 
-using Compat
+using FunctionWrappers: FunctionWrapper
 
 using DiffResults
 using DiffResults: DiffResult

Diff for: src/api/Config.jl

@@ -101,14 +101,14 @@ See `ReverseDiff.jacobian` for a description of acceptable types for `input`.
 """
 function JacobianConfig(output::AbstractArray{D}, input::Tuple, tp::InstructionTape = InstructionTape()) where D
     cfg_input = map(x -> track(similar(x), D, tp), input)
-    cfg_output = track!(similar(output, TrackedReal{D,D,Void}), output, tp)
+    cfg_output = track!(similar(output, TrackedReal{D,D,Nothing}), output, tp)
     return _JacobianConfig(cfg_input, cfg_output, tp)
 end
 
 # we dispatch on V<:Real here because InstructionTape is actually also an AbstractArray
 function JacobianConfig(output::AbstractArray{D}, input::AbstractArray{V}, tp::InstructionTape = InstructionTape()) where {D,V<:Real}
     cfg_input = track(similar(input), D, tp)
-    cfg_output = track!(similar(output, TrackedReal{D,D,Void}), output, tp)
+    cfg_output = track!(similar(output, TrackedReal{D,D,Nothing}), output, tp)
     return _JacobianConfig(cfg_input, cfg_output, tp)
 end
 

Diff for: src/api/tape.jl

@@ -54,8 +54,8 @@ end
 
 struct CompiledTape{T<:AbstractTape} <: AbstractTape
     tape::T
-    forward_exec::Vector{FunctionWrapper{Void, Tuple{}}}
-    reverse_exec::Vector{FunctionWrapper{Void, Tuple{}}}
+    forward_exec::Vector{FunctionWrapper{Nothing, Tuple{}}}
+    reverse_exec::Vector{FunctionWrapper{Nothing, Tuple{}}}
 end
 
 """
@@ -100,8 +100,8 @@ methods on each instruction in the tape.
 """
 function CompiledTape(t::T) where T<:AbstractTape
     CompiledTape{T}(t,
-        [FunctionWrapper{Void, Tuple{}}(ForwardExecutor(instruction)) for instruction in t.tape],
-        [FunctionWrapper{Void, Tuple{}}(ReverseExecutor(t.tape[i])) for i in length(t.tape):-1:1]
+        [FunctionWrapper{Nothing, Tuple{}}(ForwardExecutor(instruction)) for instruction in t.tape],
+        [FunctionWrapper{Nothing, Tuple{}}(ReverseExecutor(t.tape[i])) for i in length(t.tape):-1:1]
         )
 end
 

Diff for: src/api/utils.jl

@@ -89,13 +89,13 @@ function extract_result!(result::Tuple, output)
 end
 
 function extract_result!(result::AbstractArray, output::TrackedReal, input::TrackedArray)
-    copy!(result, deriv(input))
+    copyto!(result, deriv(input))
     return result
 end
 
 function extract_result!(result::DiffResult, output::TrackedReal, input::TrackedArray)
     result = DiffResults.value!(result, value(output))
-    copy!(DiffResults.gradient(result), deriv(input))
+    copyto!(DiffResults.gradient(result), deriv(input))
     return result
 end
 
@@ -133,7 +133,7 @@ function extract_result_value!(result::AbstractArray, output::AbstractArray)
 end
 
 function extract_result_value!(result::AbstractArray, output::TrackedArray)
-    copy!(result, value(output))
+    copyto!(result, value(output))
     return result
 end
 

Diff for: src/derivatives/elementwise.jl

@@ -358,11 +358,11 @@ function broadcast_plus(x, y, ::Type{D}) where D
     tp = tape(x, y)
     out = track(value(x) .+ value(y), D, tp)
     cache = (index_bound(x, out), index_bound(y, out))
-    record!(tp, SpecialInstruction, Base.:(.+), (x, y), out, cache)
+    record!(tp, SpecialInstruction, (broadcast, +), (x, y), out, cache)
     return out
 end
 
-@noinline function special_forward_exec!(instruction::SpecialInstruction{typeof(.+)})
+@noinline function special_forward_exec!(instruction::SpecialInstruction{Tuple{typeof(broadcast),typeof(+)}})
     a, b = instruction.input
     output = instruction.output
     pull_value!(a)
@@ -371,7 +371,7 @@ end
     return nothing
 end
 
-@noinline function special_reverse_exec!(instruction::SpecialInstruction{typeof(.+)})
+@noinline function special_reverse_exec!(instruction::SpecialInstruction{Tuple{typeof(broadcast),typeof(+)}})
     a, b = instruction.input
     output = instruction.output
     output_deriv = deriv(output)
@@ -389,11 +389,11 @@ function broadcast_minus(x, y, ::Type{D}) where D
     tp = tape(x, y)
     out = track(value(x) .- value(y), D, tp)
     cache = (index_bound(x, out), index_bound(y, out))
-    record!(tp, SpecialInstruction, Base.:(.-), (x, y), out, cache)
+    record!(tp, SpecialInstruction, (broadcast, -), (x, y), out, cache)
     return out
 end
 
-@noinline function special_forward_exec!(instruction::SpecialInstruction{typeof(.-)})
+@noinline function special_forward_exec!(instruction::SpecialInstruction{Tuple{typeof(broadcast),typeof(-)}})
     a, b = instruction.input
     output = instruction.output
     pull_value!(a)
@@ -402,7 +402,7 @@ end
     return nothing
 end
 
-@noinline function special_reverse_exec!(instruction::SpecialInstruction{typeof(.-)})
+@noinline function special_reverse_exec!(instruction::SpecialInstruction{Tuple{typeof(broadcast),typeof(-)}})
     a, b = instruction.input
     output = instruction.output
     output_deriv = deriv(output)
@@ -420,11 +420,11 @@ function broadcast_mul(x, y, ::Type{D}) where D
     tp = tape(x, y)
     out = track(value(x) .* value(y), D, tp)
     cache = (index_bound(x, out), index_bound(y, out))
-    record!(tp, SpecialInstruction, Base.:(.*), (x, y), out, cache)
+    record!(tp, SpecialInstruction, (broadcast, *), (x, y), out, cache)
     return out
 end
 
-@noinline function special_forward_exec!(instruction::SpecialInstruction{typeof(.*)})
+@noinline function special_forward_exec!(instruction::SpecialInstruction{Tuple{typeof(broadcast),typeof(*)}})
     a, b = instruction.input
     output = instruction.output
     pull_value!(a)
@@ -433,7 +433,7 @@ end
     return nothing
 end
 
-@noinline function special_reverse_exec!(instruction::SpecialInstruction{typeof(.*)})
+@noinline function special_reverse_exec!(instruction::SpecialInstruction{Tuple{typeof(broadcast),typeof(*)}})
     a, b = instruction.input
     output = instruction.output
     output_deriv = deriv(output)
@@ -467,11 +467,11 @@ function broadcast_rdiv(x, y, ::Type{D}) where D
     cache = (n_partials, d_partials,
              index_bound(x, out), index_bound(y, out),
              index_bound(n_partials, out), index_bound(d_partials, out))
-    record!(tp, SpecialInstruction, Base.:(./), (x, y), out, cache)
+    record!(tp, SpecialInstruction, (broadcast, /), (x, y), out, cache)
     return out
 end
 
-@noinline function special_forward_exec!(instruction::SpecialInstruction{typeof(./)})
+@noinline function special_forward_exec!(instruction::SpecialInstruction{Tuple{typeof(broadcast),typeof(/)}})
     a, b = instruction.input
     a_value, b_value = value(a), value(b)
     n_partials, d_partials = instruction.cache
@@ -484,7 +484,7 @@ end
     return nothing
 end
 
-@noinline function special_reverse_exec!(instruction::SpecialInstruction{typeof(./)})
+@noinline function special_reverse_exec!(instruction::SpecialInstruction{Tuple{typeof(broadcast),typeof(/)}})
     a, b = instruction.input
     output = instruction.output
     output_deriv = deriv(output)
@@ -506,11 +506,11 @@ function broadcast_ldiv(x, y, ::Type{D}) where D
     cache = (n_partials, d_partials,
              index_bound(x, out), index_bound(y, out),
              index_bound(n_partials, out), index_bound(d_partials, out))
-    record!(tp, SpecialInstruction, Base.:(.\), (x, y), out, cache)
+    record!(tp, SpecialInstruction, (broadcast, \), (x, y), out, cache)
     return out
 end
 
-@noinline function special_forward_exec!(instruction::SpecialInstruction{typeof(.\)})
+@noinline function special_forward_exec!(instruction::SpecialInstruction{Tuple{typeof(broadcast),typeof(\)}})
     a, b = instruction.input
     a_value, b_value = value(a), value(b)
     n_partials, d_partials = instruction.cache
@@ -523,7 +523,7 @@ end
     return nothing
 end
 
-@noinline function special_reverse_exec!(instruction::SpecialInstruction{typeof(.\)})
+@noinline function special_reverse_exec!(instruction::SpecialInstruction{Tuple{typeof(broadcast),typeof(\)}})
     a, b = instruction.input
     output = instruction.output
     output_deriv = deriv(output)
@@ -563,11 +563,11 @@ function broadcast_pow(x, y, ::Type{D}) where D
     cache = (bs_partials, ex_partials,
              index_bound(x, out), index_bound(y, out),
              index_bound(bs_partials, out), index_bound(ex_partials, out))
-    record!(tp, SpecialInstruction, Base.:(.^), (x, y), out, cache)
+    record!(tp, SpecialInstruction, (broadcast, ^), (x, y), out, cache)
     return out
 end
 
-@noinline function special_forward_exec!(instruction::SpecialInstruction{typeof(.^)})
+@noinline function special_forward_exec!(instruction::SpecialInstruction{Tuple{typeof(broadcast),typeof(^)}})
     a, b = instruction.input
     a_value, b_value = value(a), value(b)
     bs_partials, ex_partials = instruction.cache
@@ -580,7 +580,7 @@ end
     return nothing
 end
 
-@noinline function special_reverse_exec!(instruction::SpecialInstruction{typeof(.^)})
+@noinline function special_reverse_exec!(instruction::SpecialInstruction{Tuple{typeof(broadcast),typeof(^)}})
     a, b = instruction.input
     output = instruction.output
     output_deriv = deriv(output)