Address some issues reported by JET (#2248)

* Type param for FracField is RingElem, not RingElement

* Type param for TotFracRing is RingElem, not RingElement

* Fac type param is RingElement

  Of course this restriction is effectively enforced by the new{T}
  inside, but Julia is concerned about the Dict instantiation &
  resulting conversion anyway.

* Turn printer outer constructor into inner

  This ensures instance invariants hold that make JET happy

* Fix JET warning about deg being undefined

* Fix JET warnings triggered by parse_cycles

  This avoids JET warnings in Base

* Fix JET warning in Partition constructor

  JET is concerned about e.g. UnitRange arguments, on which the
  code before looked as if it might invoke sort! or issorted.

* Merge sqrt_classical(_char2) and Generic.sqrt_classical(_char2)

* Fix JET complaint in sqrt_classical

  JET is concerned `g2` might be used without initialization.

  However, in case of the method taking a `AbsPowerSeriesRingElem`
  that access is in a loop over `1:prec - aval2 - 1` which is
  empty unless `prec - aval2 - 1 >= 1`, i.e., `prec > aval2 + 1`.

  Therefore `prec > aval2` is a necessary precondition, and so we
  may move that loop inside the `if prec > aval2` block; or
  equivalently, skip the code if `prec <= aval2`.

  It is similar in the case of the `LaurentSeriesElem` and
  `RelPowerSeriesRingElem` methods.

Author: fingolfin

src/AbsSeries.jl

@@ -850,18 +850,20 @@ function sqrt_classical(a::AbsPowerSeriesRingElem; check::Bool=true)
    asqrt = parent(a)()
    fit!(asqrt, prec)
    asqrt = _set_precision_raw!(asqrt, prec)
+   if prec <= aval2
+      asqrt = set_length!(asqrt, normalise(asqrt, prec))
+      return true, asqrt
+   end
    for n = 1:aval2
       asqrt = setcoeff!(asqrt, n - 1, R())
    end
-   if prec > aval2
-      c = coeff(a, aval)
-      if check && !is_square(c)
-         return false, zero(S)
-      end
-      g = sqrt(c; check=check)
-      asqrt = setcoeff!(asqrt, aval2, g)
-      g2 = g + g
+   c = coeff(a, aval)
+   if check && !is_square(c)
+      return false, zero(S)
    end
+   g = sqrt(c; check=check)
+   asqrt = setcoeff!(asqrt, aval2, g)
+   g2 = g + g
    p = R()
    for n = 1:prec - aval2 - 1
       c = R()

src/Factor.jl

@@ -23,15 +23,15 @@ mutable struct Fac{T <: RingElement}
    unit::T
    arr::Vector{Pair{T, Int}}
 
-   function Fac{T}() where {T}
+   function Fac{T}() where {T <: RingElement}
      return new{T}(Dict{T, Int}())
    end
 
-   function Fac{T}(u::T, d::Dict{T, Int}) where {T}
+   function Fac{T}(u::T, d::Dict{T, Int}) where {T <: RingElement}
      return new{T}(d, u)
    end
 
-   function Fac{T}(u::T, a::Vector{Pair{T, Int}}) where {T}
+   function Fac{T}(u::T, a::Vector{Pair{T, Int}}) where {T <: RingElement}
      z = new{T}()
      z.unit = u
      z.arr = a

src/PrettyPrinting.jl

@@ -568,12 +568,12 @@ mutable struct printer{IOT <: IO}
    terse_level::Int
    size_limit_stack::Vector{Int}  # >= 0 for loosely-defined limit before ...
                                   # < 0 for unrestricted output
-end
-
-function printer(io::IO)
-   terse_level = get(io, :terse_level, 0)
-   size_limit = get(io, :size_limit, -1)
-   return printer{typeof(io)}(io, String[], terse_level, Int[size_limit])
+   
+   function printer(io::IO)
+      terse_level = get(io, :terse_level, 0)
+      size_limit = get(io, :size_limit, -1)
+      return new{typeof(io)}(io, String[], terse_level, Int[size_limit])
+   end
 end
 
 # TODO since the subexpressions are not changing much, cache the leaf_count

src/RelSeries.jl

@@ -1108,25 +1108,22 @@ function sqrt_classical(a::RelPowerSeriesRingElem; check::Bool=true)
    end
    aval2 = div(aval, 2)
    prec = precision(a) - aval
-   if prec == 0
-      asqrt = parent(a)()
+   asqrt = parent(a)()
+   if prec <= 0
       asqrt = _set_precision_raw!(asqrt, aval2)
       asqrt = set_valuation!(asqrt, aval2)
       return true, asqrt
    end
-   asqrt = parent(a)()
    fit!(asqrt, prec)
    asqrt = _set_precision_raw!(asqrt, prec + aval2)
    asqrt = set_valuation!(asqrt, aval2)
-   if prec > 0
-      c = polcoeff(a, 0)
-      if check && !is_square(c)
-         return false, zero(S)
-      end
-      g = sqrt(c; check=check)
-      asqrt = setcoeff!(asqrt, 0, g)
-      g2 = g + g
+   c = polcoeff(a, 0)
+   if check && !is_square(c)
+      return false, zero(S)
    end
+   g = sqrt(c; check=check)
+   asqrt = setcoeff!(asqrt, 0, g)
+   g2 = g + g
    p = R()
    for n = 1:prec - 1
       c = R()

src/algorithms/LaurentPoly.jl

@@ -88,7 +88,7 @@ end
 # return the degree of the unique term, throw if not a term
 function term_degree(p::LaurentPolyRingElem)
    isnull = true
-   local deg
+   deg = -1
    mds = terms_degrees(p)
    isempty(mds) && throw(DomainError(p, "not a term"))
    for d in mds
@@ -98,7 +98,7 @@ function term_degree(p::LaurentPolyRingElem)
          isnull = false
       end
    end
-   deg
+   return deg
 end
 
 function leading_coefficient(p::LaurentPolyRingElem)

src/generic/GenericTypes.jl

@@ -93,7 +93,10 @@ struct Partition{T} <: AbstractVector{T}
    Partition(part::AbstractVector{<:Integer}, check::Bool=true) =
       Partition(sum(part), part, check)
 
-   function Partition(n::Integer, part::AbstractVector{T}, check::Bool=true) where T
+   Partition(n::Integer, part::AbstractVector, check::Bool=true) =
+      Partition(n, collect(part), check)
+
+   function Partition(n::Integer, part::Vector{T}, check::Bool=true) where T
       if check
          issorted(part, rev=true) || sort!(part, rev=true)
          if length(part) > 0

src/generic/LaurentSeries.jl

@@ -1330,28 +1330,25 @@ function sqrt_classical(a::LaurentSeriesElem; check::Bool=true)
    end
    aval2 = div(aval, 2)
    prec = precision(a) - aval
-   if prec == 0
-      asqrt = parent(a)()
+   asqrt = parent(a)()
+   if prec <= 0
       asqrt = set_precision!(asqrt, aval2)
       asqrt = set_valuation!(asqrt, aval2)
       asqrt = set_scale!(asqrt, 1)
       return true, asqrt
    end
-   asqrt = parent(a)()
    s = scale(a)
    zlen = div(prec + s - 1, s)
    fit!(asqrt, zlen)
    asqrt = set_precision!(asqrt, prec + aval2)
    asqrt = set_valuation!(asqrt, aval2)
-   if prec > 0
-      c = polcoeff(a, 0)
-      if check && !is_square(c)
-         return false, zero(S)
-      end
-      g = sqrt(c; check=check)
-      asqrt = setcoeff!(asqrt, 0, g)
-      g2 = g + g
+   c = polcoeff(a, 0)
+   if check && !is_square(c)
+      return false, zero(S)
    end
+   g = sqrt(c; check=check)
+   asqrt = setcoeff!(asqrt, 0, g)
+   g2 = g + g
    p = R()
    for n = 1:zlen - 1
       c = R()

src/generic/PermGroups.jl

@@ -817,6 +817,10 @@ end
 ###############################################################################
 
 function parse_cycles(str::AbstractString)
+  return parse_cycles(string(str))
+end
+
+function parse_cycles(str::Union{String, SubString})
    ccycles = Int[]
    cptrs = Int[1]
    if startswith(str, "Cycle Decomposition: ")

src/generic/TotalFraction.jl

@@ -26,11 +26,11 @@ base_ring(a::TotFracRing{T}) where T <: RingElem = a.base_ring::parent_type(T)
 
 parent(a::TotFrac) = a.parent
 
-function is_domain_type(::Type{T}) where {S <: RingElement, T <: TotFrac{S}}
+function is_domain_type(::Type{T}) where {S <: RingElem, T <: TotFrac{S}}
    return is_domain_type(S)
 end
 
-function is_exact_type(a::Type{T}) where {S <: RingElement, T <: TotFrac{S}}
+function is_exact_type(a::Type{T}) where {S <: RingElem, T <: TotFrac{S}}
    return is_exact_type(S)
 end
 
@@ -530,7 +530,6 @@ rand(S::TotFracRing, v...) = rand(Random.default_rng(), S, v...)
 #
 ###############################################################################
 
-promote_rule(::Type{TotFrac{T}}, ::Type{TotFrac{T}}) where T <: RingElement = TotFrac{T}
 promote_rule(::Type{TotFrac{T}}, ::Type{TotFrac{T}}) where T <: RingElem = TotFrac{T}
 
 function promote_rule(::Type{TotFrac{T}}, ::Type{U}) where {T <: RingElem, U <: RingElem}
@@ -543,26 +542,26 @@ end
 #
 ###############################################################################
 
-function (a::TotFracRing{T})(b::RingElement) where {T <: RingElement}
+function (a::TotFracRing{T})(b::RingElement) where {T <: RingElem}
    return a(base_ring(a)(b))
 end
 
-function (a::TotFracRing{T})() where {T <: RingElement}
+function (a::TotFracRing{T})() where {T <: RingElem}
    R = base_ring(a)
    z = TotFrac{T}(zero(R), one(R))
    z.parent = a
    return z
 end
 
-function (a::TotFracRing{T})(b::T) where {T <: RingElement}
+function (a::TotFracRing{T})(b::T) where {T <: RingElem}
    R = base_ring(a)
    parent(b) != R && error("Could not coerce to fraction")
    z = TotFrac{T}(b, one(R))
    z.parent = a
    return z
 end
 
-function (a::TotFracRing{T})(b::T, c::T, check::Bool=true) where {T <: RingElement}
+function (a::TotFracRing{T})(b::T, c::T, check::Bool=true) where {T <: RingElem}
    R = base_ring(a)
    parent(b) != R && error("Could not coerce to fraction")
    parent(c) != R && error("Could not coerce to fraction")
@@ -575,23 +574,23 @@ function (a::TotFracRing{T})(b::T, c::T, check::Bool=true) where {T <: RingEleme
    return z
 end
 
-function (a::TotFracRing{T})(b::T, c::Union{Integer, Rational}, check::Bool=true) where {T <: RingElement}
+function (a::TotFracRing{T})(b::T, c::Union{Integer, Rational}, check::Bool=true) where {T <: RingElem}
    a(b, base_ring(a)(c), check)
 end
 
-function (a::TotFracRing{T})(b::Union{Integer, Rational}, c::T, check::Bool=true) where {T <: RingElement}
+function (a::TotFracRing{T})(b::Union{Integer, Rational}, c::T, check::Bool=true) where {T <: RingElem}
    a(base_ring(a)(b), c, check)
 end
 
-function (a::TotFracRing{T})(b::Union{Integer, Rational}) where {T <: RingElement}
+function (a::TotFracRing{T})(b::Union{Integer, Rational}) where {T <: RingElem}
    a(base_ring(a)(b))
 end
 
-function (a::TotFracRing{T})(b::Integer, c::Integer, check::Bool=true) where {T <: RingElement}
+function (a::TotFracRing{T})(b::Integer, c::Integer, check::Bool=true) where {T <: RingElem}
    a(base_ring(a)(b), base_ring(a)(c), check)
 end
 
-function (a::TotFracRing{T})(b::TotFrac{T}) where {T <: RingElement}
+function (a::TotFracRing{T})(b::TotFrac{T}) where {T <: RingElem}
    a != parent(b) && error("Could not coerce to fraction")
    return b
 end

src/generic/imports.jl

@@ -218,6 +218,8 @@ import ..AbstractAlgebra: shift_left
 import ..AbstractAlgebra: shift_right
 import ..AbstractAlgebra: snf
 import ..AbstractAlgebra: sqrt
+import ..AbstractAlgebra: sqrt_classical
+import ..AbstractAlgebra: sqrt_classical_char2
 import ..AbstractAlgebra: sub!
 import ..AbstractAlgebra: submul!
 import ..AbstractAlgebra: symbols