InexactError->InvalidValueError, with more informative backtraces

Author: timholy

base/bool.jl

@@ -3,8 +3,8 @@
 ## boolean conversions ##
 
 convert(::Type{Bool}, x::Bool) = x
-convert(::Type{Bool}, x::Float16) = x==0 ? false : x==1 ? true : throw(InexactError())
-convert(::Type{Bool}, x::Real) = x==0 ? false : x==1 ? true : throw(InexactError())
+convert(::Type{Bool}, x::Float16) = x==0 ? false : x==1 ? true : throw(InvalidValueError(:convert, Bool, x))
+convert(::Type{Bool}, x::Real) = x==0 ? false : x==1 ? true : throw(InvalidValueError(:convert, Bool, x))
 
 # promote Bool to any other numeric type
 promote_rule(::Type{Bool}, ::Type{T}) where {T<:Number} = T

base/boot.jl

@@ -132,8 +132,9 @@ export
     Char, DirectIndexString, AbstractString, String, IO,
     # errors
     ErrorException, BoundsError, DivideError, DomainError, Exception, InexactError,
-    InterruptException, OutOfMemoryError, ReadOnlyMemoryError, OverflowError,
-    StackOverflowError, SegmentationFault, UndefRefError, UndefVarError, TypeError,
+    InterruptException, InvalidValueError, OutOfMemoryError, ReadOnlyMemoryError,
+    OverflowError, StackOverflowError, SegmentationFault, UndefRefError, UndefVarError,
+    TypeError,
     # AST representation
     Expr, GotoNode, LabelNode, LineNumberNode, QuoteNode,
     GlobalRef, NewvarNode, SSAValue, Slot, SlotNumber, TypedSlot,
@@ -221,6 +222,13 @@ mutable struct TypeError <: Exception
     expected::Type
     got
 end
+struct InvalidValueError <: Exception
+    func::Symbol
+    T::Type
+    val
+
+    InvalidValueError(f::Symbol, T::ANY, val::ANY) = (@_noinline_meta; new(f, T, val))
+end
 
 abstract type DirectIndexString <: AbstractString end
 

base/complex.jl

@@ -21,7 +21,7 @@ const Complex32  = Complex{Float16}
 convert(::Type{Complex{T}}, x::Real) where {T<:Real} = Complex{T}(x,0)
 convert(::Type{Complex{T}}, z::Complex) where {T<:Real} = Complex{T}(real(z),imag(z))
 convert(::Type{T}, z::Complex) where {T<:Real} =
-    isreal(z) ? convert(T,real(z)) : throw(InexactError())
+    isreal(z) ? convert(T,real(z)) : throw(InvalidValueError(:convert, T, z))
 
 convert(::Type{Complex}, z::Complex) = z
 convert(::Type{Complex}, x::Real) = Complex(x)

base/dates/arithmetic.jl

@@ -14,10 +14,10 @@
 
 The addition of a `Date` with a `Time` produces a `DateTime`. The hour, minute, second, and millisecond parts of
 the `Time` are used along with the year, month, and day of the `Date` to create the new `DateTime`.
-Non-zero microseconds or nanoseconds in the `Time` type will result in an `InexactError` being thrown.
+Non-zero microseconds or nanoseconds in the `Time` type will result in an `InvalidValueError` being thrown.
 """
 function (+)(dt::Date, t::Time)
-    (microsecond(t) > 0 || nanosecond(t) > 0) && throw(InexactError())
+    (microsecond(t) > 0 || nanosecond(t) > 0) && throw(InvalidValueError(:+, DateTime, t))
     y, m, d = yearmonthday(dt)
     return DateTime(y, m, d, hour(t), minute(t), second(t), millisecond(t))
 end

base/dates/periods.jl

@@ -400,7 +400,7 @@ const FixedPeriod = Union{Week, Day, Hour, Minute, Second, Millisecond, Microsec
 # like div but throw an error if remainder is nonzero
 function divexact(x, y)
     q, r = divrem(x, y)
-    r == 0 || throw(InexactError())
+    r == 0 || throw(InvalidValueError(:divexact, Int, x/y))
     return q
 end
 
@@ -415,7 +415,7 @@ for i = 1:length(fixedperiod_conversions)
         vmax = typemax(Int64) ÷ N
         vmin = typemin(Int64) ÷ N
         @eval function Base.convert(::Type{$T}, x::$Tc)
-            $vmin ≤ value(x) ≤ $vmax || throw(InexactError())
+            $vmin ≤ value(x) ≤ $vmax || throw(InvalidValueError(:convert, $T, x))
             return $T(value(x) * $N)
         end
     end
@@ -432,7 +432,7 @@ end
 const OtherPeriod = Union{Month, Year}
 let vmax = typemax(Int64) ÷ 12, vmin = typemin(Int64) ÷ 12
     @eval function Base.convert(::Type{Month}, x::Year)
-        $vmin ≤ value(x) ≤ $vmax || throw(InexactError())
+        $vmin ≤ value(x) ≤ $vmax || throw(InvalidValueError(:convert, Month, x))
         Month(value(x) * 12)
     end
 end

base/distributed/pmap.jl

@@ -90,10 +90,10 @@ Example: On errors, retry `f` on an element a maximum of 3 times without any del
 pmap(f, c; retry_delays = zeros(3))
 ```
 
-Example: Retry `f` only if the exception is not of type `InexactError`, with exponentially increasing
-delays up to 3 times. Return a `NaN` in place for all `InexactError` occurrences.
+Example: Retry `f` only if the exception is not of type `InvalidValueError`, with exponentially increasing
+delays up to 3 times. Return a `NaN` in place for all `InvalidValueError` occurrences.
 ```julia
-pmap(f, c; on_error = e->(isa(e, InexactError) ? NaN : rethrow(e)), retry_delays = ExponentialBackOff(n = 3))
+pmap(f, c; on_error = e->(isa(e, InvalidValueError) ? NaN : rethrow(e)), retry_delays = ExponentialBackOff(n = 3))
 ```
 """
 function pmap(p::AbstractWorkerPool, f, c; distributed=true, batch_size=1, on_error=nothing,

base/docs/helpdb/Base.jl

@@ -359,7 +359,7 @@ ReadOnlyMemoryError
 `ceil(x)` returns the nearest integral value of the same type as `x` that is greater than or
 equal to `x`.
 
-`ceil(T, x)` converts the result to type `T`, throwing an `InexactError` if the value is not
+`ceil(T, x)` converts the result to type `T`, throwing an `InvalidValueError` if the value is not
 representable.
 
 `digits` and `base` work as for [`round`](@ref).
@@ -646,7 +646,7 @@ Mmap.Anonymous
 `floor(x)` returns the nearest integral value of the same type as `x` that is less than or
 equal to `x`.
 
-`floor(T, x)` converts the result to type `T`, throwing an `InexactError` if the value is
+`floor(T, x)` converts the result to type `T`, throwing an `InvalidValueError` if the value is
 not representable.
 
 `digits` and `base` work as for [`round`](@ref).
@@ -878,7 +878,7 @@ typeof
 `trunc(x)` returns the nearest integral value of the same type as `x` whose absolute value
 is less than or equal to `x`.
 
-`trunc(T, x)` converts the result to type `T`, throwing an `InexactError` if the value is
+`trunc(T, x)` converts the result to type `T`, throwing an `InvalidValueError` if the value is
 not representable.
 
 `digits` and `base` work as for [`round`](@ref).
@@ -1374,6 +1374,13 @@ Type conversion cannot be done exactly.
 """
 InexactError
 
+"""
+    InvalidValueError(name::Symbol, T, val)
+
+Cannot convert `val` to type `T` in a method of function `name`.
+"""
+InvalidValueError
+
 """
     typemax(T)
 
@@ -1946,7 +1953,7 @@ done
 
 Convert `x` to a value of type `T`.
 
-If `T` is an `Integer` type, an [`InexactError`](@ref) will be raised if `x`
+If `T` is an `Integer` type, an [`InvalidValueError`](@ref) will be raised if `x`
 is not representable by `T`, for example if `x` is not integer-valued, or is outside the
 range supported by `T`.
 
@@ -1955,9 +1962,9 @@ julia> convert(Int, 3.0)
 3
 
 julia> convert(Int, 3.5)
-ERROR: InexactError()
+ERROR: InvalidValueError: convert(Int64, 3.5::Float64)
 Stacktrace:
- [1] convert(::Type{Int64}, ::Float64) at ./float.jl:679
+ [1] convert(::Type{Int64}, ::Float64) at ./float.jl:680
 ```
 
 If `T` is a `AbstractFloat` or `Rational` type,

base/float.jl

@@ -649,14 +649,14 @@ for Ti in (Int8, Int16, Int32, Int64, Int128, UInt8, UInt16, UInt32, UInt64, UIn
                     if $(Tf(typemin(Ti))-one(Tf)) < x < $(Tf(typemax(Ti))+one(Tf))
                         return unsafe_trunc($Ti,x)
                     else
-                        throw(InexactError())
+                        throw(InvalidValueError(:trunc, $Ti, x))
                     end
                 end
                 function convert(::Type{$Ti}, x::$Tf)
                     if ($(Tf(typemin(Ti))) <= x <= $(Tf(typemax(Ti)))) && (trunc(x) == x)
                         return unsafe_trunc($Ti,x)
                     else
-                        throw(InexactError())
+                        throw(InvalidValueError(:convert, $Ti, x))
                     end
                 end
             end
@@ -670,14 +670,14 @@ for Ti in (Int8, Int16, Int32, Int64, Int128, UInt8, UInt16, UInt32, UInt64, UIn
                     if $(Tf(typemin(Ti))) <= x < $(Tf(typemax(Ti)))
                         return unsafe_trunc($Ti,x)
                     else
-                        throw(InexactError())
+                        throw(InvalidValueError(:trunc, $Ti, x))
                     end
                 end
                 function convert(::Type{$Ti}, x::$Tf)
                     if ($(Tf(typemin(Ti))) <= x < $(Tf(typemax(Ti)))) && (trunc(x) == x)
                         return unsafe_trunc($Ti,x)
                     else
-                        throw(InexactError())
+                        throw(InvalidValueError(:convert, $Ti, x))
                     end
                 end
             end

base/floatfuncs.jl

@@ -63,7 +63,7 @@ The optional [`RoundingMode`](@ref) argument will change how the number gets
 rounded.
 
 `round(T, x, [r::RoundingMode])` converts the result to type `T`, throwing an
-[`InexactError`](@ref) if the value is not representable.
+[`InvalidValueError`](@ref) if the value is not representable.
 
 `round(x, digits)` rounds to the specified number of digits after the decimal place (or
 before if negative). `round(x, digits, base)` rounds using a base other than 10.

base/gmp.jl

@@ -231,12 +231,12 @@ convert(::Type{BigInt}, x::Bool) = BigInt(UInt(x))
 unsafe_trunc(::Type{BigInt}, x::Union{Float32,Float64}) = MPZ.set_d(x)
 
 function convert(::Type{BigInt}, x::Union{Float32,Float64})
-    isinteger(x) || throw(InexactError())
+    isinteger(x) || throw(InvalidValueError(:convert, BigInt, x))
     unsafe_trunc(BigInt,x)
 end
 
 function trunc(::Type{BigInt}, x::Union{Float32,Float64})
-    isfinite(x) || throw(InexactError())
+    isfinite(x) || throw(InvalidValueError(:trunc, BigInt, x))
     unsafe_trunc(BigInt,x)
 end
 
@@ -287,7 +287,7 @@ function convert(::Type{T}, x::BigInt) where T<:Unsigned
     if sizeof(T) < sizeof(Limb)
         convert(T, convert(Limb,x))
     else
-        0 <= x.size <= cld(sizeof(T),sizeof(Limb)) || throw(InexactError())
+        0 <= x.size <= cld(sizeof(T),sizeof(Limb)) || throw(InvalidValueError(:convert, T, x))
         x % T
     end
 end
@@ -298,9 +298,9 @@ function convert(::Type{T}, x::BigInt) where T<:Signed
         SLimb = typeof(Signed(one(Limb)))
         convert(T, convert(SLimb, x))
     else
-        0 <= n <= cld(sizeof(T),sizeof(Limb)) || throw(InexactError())
+        0 <= n <= cld(sizeof(T),sizeof(Limb)) || throw(InvalidValueError(:convert, T, x))
         y = x % T
-        ispos(x) ⊻ (y > 0) && throw(InexactError()) # catch overflow
+        ispos(x) ⊻ (y > 0) && throw(InvalidValueError(:convert, T, x)) # catch overflow
         y
     end
 end