Add many @req !is_trivial checks

Author: lgoettgens

src/Fraction.jl

@@ -823,6 +823,7 @@ that it will always be returned by a call to the constructor when the same
 base ring $R$ is supplied.
 """
 function fraction_field(R::Ring; cached::Bool=true)
+   @req !is_trivial(R) "Zero rings are currently not supported as coefficient ring."
    return Generic.fraction_field(R; cached=cached)
 end
 

src/MPoly.jl

@@ -1508,5 +1508,7 @@ true
 Like [`polynomial_ring(R::Ring, s::Vector{Symbol})`](@ref) but return only the
 multivariate polynomial ring.
 """
-polynomial_ring_only(R::T, s::Vector{Symbol}; internal_ordering::Symbol=:lex, cached::Bool=true) where T<:Ring =
-   mpoly_ring_type(T)(R, s, internal_ordering, cached)
+function polynomial_ring_only(R::T, s::Vector{Symbol}; internal_ordering::Symbol=:lex, cached::Bool=true) where T<:Ring
+   @req !is_trivial(R) "Zero rings are currently not supported as coefficient ring."
+   return mpoly_ring_type(T)(R, s, internal_ordering, cached)
+end

src/MatRing.jl

@@ -446,5 +446,6 @@ Return parent object corresponding to the ring of $n\times n$ matrices over
 the ring $R$.
 """
 function matrix_ring(R::NCRing, n::Int)
-   Generic.matrix_ring(R, n)
+   @req !is_trivial(R) "Zero rings are currently not supported as base ring."
+   return Generic.matrix_ring(R, n)
 end

src/Matrix.jl

@@ -6653,6 +6653,7 @@ julia> using LinearAlgebra ; matrix(GF(5), I(2))
 """
 function matrix(R::NCRing, arr::AbstractMatrix{T}) where {T}
    Base.require_one_based_indexing(arr)
+   @req !is_trivial(R) "Zero rings are currently not supported as base ring."
    if elem_type(R) === T && all(e -> parent(e) === R, arr)
       z = Generic.MatSpaceElem{elem_type(R)}(R, arr)
       return z
@@ -6664,6 +6665,7 @@ function matrix(R::NCRing, arr::AbstractMatrix{T}) where {T}
 end
 
 function matrix(R::NCRing, arr::MatElem)
+   @req !is_trivial(R) "Zero rings are currently not supported as base ring."
    return map_entries(R, arr)
 end
 
@@ -6702,6 +6704,7 @@ Constructs the $r \times c$ matrix over $R$, where the entries are taken
 row-wise from `arr`.
 """
 function matrix(R::NCRing, r::Int, c::Int, arr::AbstractVecOrMat{T}) where T
+   @req !is_trivial(R) "Zero rings are currently not supported as base ring."
    _check_dim(r, c, arr)
    ndims(arr) == 2 && return matrix(R, arr)
    if elem_type(R) === T && all(e -> parent(e) === R, arr)
@@ -7086,6 +7089,7 @@ the ring $R$.
 function matrix_space(R::NCRing, r::Int, c::Int; cached::Bool = true)
   # TODO: the 'cached' argument is ignored and mainly here for backwards compatibility
   # (and perhaps future compatibility, in case we need it again)
+  @req !is_trivial(R) "Zero rings are currently not supported as base ring."
   (r < 0 || c < 0) && error("Dimensions must be non-negative")
   T = elem_type(R)
   return MatSpace{T}(R, r, c)

src/NCPoly.jl

@@ -764,8 +764,10 @@ end
 Like [`polynomial_ring(R::NCRing, s::Symbol)`](@ref) but return only the
 polynomial ring.
 """
-polynomial_ring_only(R::T, s::Symbol; cached::Bool=true) where T<:NCRing =
-   dense_poly_ring_type(T)(R, s, cached)
+function polynomial_ring_only(R::T, s::Symbol; cached::Bool=true) where T<:NCRing
+   @req !is_trivial(R) "Zero rings are currently not supported as coefficient ring."
+   return dense_poly_ring_type(T)(R, s, cached)
+end
 
 # Simplified constructor
 

src/Residue.jl

@@ -450,6 +450,7 @@ to the constructor with the same base ring $R$ and element $a$. A modulus
 of zero is not supported and throws an exception.
 """
 function residue_ring(R::Ring, a::RingElement; cached::Bool = true)
+   @req !is_trivial(R) "Zero rings are currently not supported as base ring."
    # Modulus of zero cannot be supported. E.g. A C library could not be expected to
    # do matrices over Z/0 using a Z/nZ type. The former is multiprecision, the latter not.
    iszero(a) && throw(DomainError(a, "Modulus must be nonzero"))
@@ -459,6 +460,7 @@ function residue_ring(R::Ring, a::RingElement; cached::Bool = true)
 end
 
 function residue_ring(R::PolyRing, a::RingElement; cached::Bool = true)
+   @req !is_trivial(R) "Zero rings are currently not supported as base ring."
    iszero(a) && throw(DomainError(a, "Modulus must be nonzero"))
    !is_unit(leading_coefficient(a)) && throw(DomainError(a, "Non-invertible leading coefficient"))
    T = elem_type(R)

src/ResidueField.jl

@@ -490,6 +490,7 @@ residue ring parent object is cached and returned for any subsequent calls
 to the constructor with the same base ring $R$ and element $a$.
 """
 function residue_field(R::Ring, a::RingElement; cached::Bool = true)
+   @req !is_trivial(R) "Zero rings are currently not supported as base ring."
    iszero(a) && throw(DivideError())
    T = elem_type(R)
    S = EuclideanRingResidueField{T}(R(a), cached)