narrow array conversions. fixes #26294, fixes #26178.

Not all array types can convert from any AbstractArray via a
1-argument constructor call.

Author: JeffBezanson

base/abstractarray.jl

@@ -12,7 +12,6 @@ Supertype for `N`-dimensional arrays (or array-like types) with elements of type
 AbstractArray
 
 convert(::Type{T}, a::T) where {T<:AbstractArray} = a
-convert(::Type{T}, a::AbstractArray) where {T<:AbstractArray} = T(a)
 
 if nameof(@__MODULE__) === :Base  # avoid method overwrite
 # catch undefined constructors before the deprecation kicks in

base/array.jl

@@ -413,8 +413,11 @@ oneunit(x::AbstractMatrix{T}) where {T} = _one(oneunit(T), x)
 
 ## Conversions ##
 
-# arises in similar(dest, Pair{Union{},Union{}}) where dest::Dict:
-convert(::Type{Vector{Union{}}}, a::Vector{Union{}}) = a
+convert(::Type{T}, a::T) where {T<:Array} = a
+convert(::Type{T}, a::AbstractArray) where {T<:Array} = T(a)
+
+convert(::Type{AbstractArray{T}}, a::AbstractArray) where {T} = AbstractArray{T}(a)
+convert(::Type{AbstractArray{T,N}}, a::AbstractArray{<:Any,N}) where {T,N} = AbstractArray{T,N}(a)
 
 promote_rule(a::Type{Array{T,n}}, b::Type{Array{S,n}}) where {T,n,S} = el_same(promote_type(T,S), a, b)
 

base/bitarray.jl

@@ -532,6 +532,9 @@ julia> BitArray(x+y == 3 for x = 1:2 for y = 1:3)
 """
 BitArray(itr) = gen_bitarray(IteratorSize(itr), itr)
 
+convert(::Type{BitArray}, a::AbstractArray) = BitArray(a)
+convert(::Type{BitArray{N}}, a::AbstractArray{<:Any,N}) where {N} = BitArray{N}(a)
+
 # generic constructor from an iterable without compile-time info
 # (we pass start(itr) explicitly to avoid a type-instability with filters)
 gen_bitarray(isz::IteratorSize, itr) = gen_bitarray_from_itr(itr, start(itr))

base/range.jl

@@ -97,6 +97,9 @@ abstract type AbstractRange{T} <: AbstractArray{T,1} end
 RangeStepStyle(::Type{<:AbstractRange}) = RangeStepIrregular()
 RangeStepStyle(::Type{<:AbstractRange{<:Integer}}) = RangeStepRegular()
 
+convert(::Type{T}, r::T) where {T<:AbstractRange} = r
+convert(::Type{T}, r::AbstractRange) where {T<:AbstractRange} = T(r)
+
 ## ordinal ranges
 
 abstract type OrdinalRange{T,S} <: AbstractRange{T} end

stdlib/LinearAlgebra/test/diagonal.jl

@@ -27,6 +27,8 @@ srand(1)
             @test Diagonal{elty}(x)::Diagonal{elty,typeof(x)} == DM
             @test Diagonal{elty}(x).diag === x
         end
+        # issue #26178
+        @test_throws MethodError convert(Diagonal, [1, 2, 3, 4])
     end
 
     @testset "Basic properties" begin