Eliminate BigInt allocs in Int128 FDs: mul_with_overflow not widemul.

All 128-bit conversions look correct and we've eliminated the
allocations.

Also, the InexactError error message is nicer now:
```
Before: InexactError(:Int128, Int128, 34028236692093846346337460743176821145500)
 After: InexactError(:convert, FixedDecimal{Int128, 2}, 0xffffffffffffffffffffffffffffffff)

Before: InexactError: Int128(17014118346046923173168730371588410572700)
 After: InexactError: convert(FixedDecimal{Int128, 2}, 170141183460469231731687303715884105727)
```

Author: NHDaly

src/FixedPointDecimals.jl

@@ -296,7 +296,17 @@ end
 Base.convert(::Type{FD{T, f}}, x::FD{T, f}) where {T, f} = x  # Converting an FD to itself is a no-op
 
 function Base.convert(::Type{FD{T, f}}, x::Integer) where {T, f}
-    reinterpret(FD{T, f}, T(widemul(x, coefficient(FD{T, f}))))
+    C = coefficient(FD{T, f})
+    throw_inexact() = throw(InexactError(:convert, FD{T, f}, x))
+    typemin(T) <= x <= typemax(T) || throw_inexact()
+    xT = convert(T, x)  # This won't throw, since we already checked, above.
+    # Perform x * C, and check for overflow. This is cheaper than a widemul, especially for
+    # 128-bit T, since those widen into a BigInt.
+    v, overflow = Base.mul_with_overflow(xT, C)
+    if overflow
+        throw_inexact()
+    end
+    reinterpret(FD{T, f}, v)
 end
 
 Base.convert(::Type{T}, x::AbstractFloat) where {T <: FD} = round(T, x)

test/runtests.jl

@@ -314,11 +314,33 @@ end
     end
 end
 @testset "128-bit conversion performance" begin
-    #@test Base.convert(WFD2, 1) == WFD2(1)
-    #@test @allocated(Base.convert(WFD2, 1)) == 0
+    # Baseline cases
+    @test @allocated(Base.convert(FD2, Int8(-1))) == 0
+    @test @allocated(Base.convert(FD2, UInt8(1))) == 0
+    @test @allocated(Base.convert(SFD2, Int8(-1))) == 0
+
+    # Int 128 cases
+    @test @allocated(Base.convert(WFD2, 1)) == 0
+    @test @allocated(Base.convert(WFD2, 1)) == 0
+    @test @allocated(Base.convert(UWFD2, 1)) == 0
+    @test @allocated(Base.convert(WFD2, -1)) == 0
+    # @test @allocated(Base.convert(UWFD2, -1)) == 32   # not sure how best to test this
+    @test @allocated(Base.convert(WFD2, UInt(1))) == 0
+    @test @allocated(Base.convert(UWFD2, UInt(1))) == 0
+
+    @test @allocated(Base.convert(WFD2, Int128(1))) == 0
+    @test @allocated(Base.convert(UWFD2, Int128(1))) == 0
+    @test @allocated(Base.convert(WFD2, UInt128(1))) == 0
+    @test @allocated(Base.convert(UWFD2, UInt128(1))) == 0
+    @test @allocated(Base.convert(WFD2, Int128(-1))) == 0
+
+    @test @allocated(Base.convert(FD2, Int128(1))) == 0
+    @test @allocated(Base.convert(UFD2, Int128(1))) == 0
+    @test @allocated(Base.convert(FD2, UInt128(1))) == 0
+    @test @allocated(Base.convert(UFD2, UInt128(1))) == 0
+    @test @allocated(Base.convert(FD2, Int128(-1))) == 0
 end
 
-
 @testset "promotion" begin
     @test 1//10 + FD2(0.1) === 1//5
     @test 0.1 + FD2(0.1) === 0.2