Fix inference on 1.6/1.7

Author: N5N3

src/FieldArray.jl

@@ -35,7 +35,7 @@ consider defining `similar_type` as in the `FieldVector` example.
         yyyy::Float64
     end
 """
-abstract type FieldArray{N, T, D} <: StaticArray{N, T, D} end
+abstract type FieldArray{N,T,D} <: StaticArray{N,T,D} end
 
 """
     abstract FieldMatrix{N1, N2, T} <: FieldArray{Tuple{N1, N2}, 2}
@@ -84,7 +84,7 @@ you may consider using the alternative
                       4.0 5.0 6.0;
                       7.0 8.0 9.0])
 """
-abstract type FieldMatrix{N1, N2, T} <: FieldArray{Tuple{N1, N2}, T, 2} end
+abstract type FieldMatrix{N1,N2,T} <: FieldArray{Tuple{N1,N2},T,2} end
 
 """
     abstract FieldVector{N, T} <: FieldArray{Tuple{N}, 1}
@@ -108,11 +108,11 @@ array operations as in the example below.
 
     StaticArrays.similar_type(::Type{<:Vec3D}, ::Type{T}, s::Size{(3,)}) where {T} = Vec3D{T}
 """
-abstract type FieldVector{N, T} <: FieldArray{Tuple{N}, T, 1} end
+abstract type FieldVector{N,T} <: FieldArray{Tuple{N},T,1} end
 
-@inline (::Type{FA})(x::Tuple) where {FA <: FieldArray} = construct_type(FA, x)(x...)
+@inline (::Type{FA})(x::Tuple) where {FA<:FieldArray} = construct_type(FA, x)(x...)
 
-function construct_type(::Type{FA}, x) where {FA <: FieldArray}
+function construct_type(::Type{FA}, x) where {FA<:FieldArray}
     has_size(FA) || error("$FA has no static size!")
     length_match_size(FA, x)
     return adapt_eltype(FA, x)
@@ -131,7 +131,7 @@ function similar_type(::Type{A}, ::Type{T}, S::Size) where {T,A<:FieldArray}
     # FieldArrays with parametric `eltype` would be adapted to the new `eltype` automatically.
     A′ = Base.typeintersect(base_type(A), StaticArray{Tuple{Tuple(S)...},T,length(S)})
     # But extra parameters are disallowed here. Also we check `fieldtypes` to make sure the result is valid.
-    isconcretetype(A′) && fieldtypes(A′) === ntuple(Returns(T), Val(prod(S))) && return A′
+    isconcretetype(A′) && fieldtypes(A′) === ntuple(_ -> T, Val(prod(S))) && return A′
     # Otherwise, we fallback to `S/MArray` based on it's mutability.
     if ismutabletype(A)
         return mutable_similar_type(T, S, length_val(S))
@@ -141,7 +141,12 @@ function similar_type(::Type{A}, ::Type{T}, S::Size) where {T,A<:FieldArray}
 end
 
 # return `Union{}` for Union Type. Otherwise return the constructor with no parameters.
-@pure base_type(@nospecialize(T::Type)) = (T′ = Base.unwrap_unionall(T); T′ isa DataType ? T′.name.wrapper : Union{})
-if VERSION < v"1.7"
-    @pure ismutabletype(@nospecialize(T::Type)) = (T′ = Base.unwrap_unionall(T); T′ isa DataType && T′.mutable)
+@pure base_type(@nospecialize(T::Type)) = (T′ = Base.unwrap_unionall(T);
+T′ isa DataType ? T′.name.wrapper : Union{})
+if VERSION < v"1.8"
+    fieldtypes(::Type{T}) where {T} = ntuple(i -> fieldtype(T, i), Val(fieldcount(T)))
+    @eval @pure function ismutabletype(@nospecialize(T::Type))
+        T′ = Base.unwrap_unionall(T)
+        T′ isa DataType && $(VERSION < v"1.7" ? :(T′.mutable) : :(T′.name.flags & 0x2 == 0x2))
+    end
 end