Don't unwrap conversion

Author: jishnub

Project.toml

@@ -1,6 +1,6 @@
 name = "ApproxFunBase"
 uuid = "fbd15aa5-315a-5a7d-a8a4-24992e37be05"
-version = "0.9.5"
+version = "0.9.6"
 
 [deps]
 AbstractFFTs = "621f4979-c628-5d54-868e-fcf4e3e8185c"

src/Operators/Operator.jl

@@ -81,6 +81,9 @@ for f in [:iswrapperstructure, :iswrapperindexing, :iswrapperspaces]
     @eval $f(@nospecialize(_)) = false
 end
 
+iswrapperstructure(A::Operator) = iswrapperstructure(typeof(A))
+iswrapperindexing(A::Operator) = iswrapperindexing(typeof(A))
+iswrapperspaces(A::Operator) = iswrapperspaces(typeof(A))
 iswrapper(A) = iswrapperstructure(A) || iswrapperindexing(A) || iswrapperspaces(A)
 
 struct Functional <: OperatorStyle end

src/Operators/banded/Conversion.jl

@@ -129,9 +129,12 @@ end
 domainspace(C::ConversionWrapper) = C.domainspace
 rangespace(C::ConversionWrapper) = C.rangespace
 
+ConversionWrapper(d::Space, r::Space, B::ConversionWrapper) =
+    ConversionWrapper(d, r, B.op)
+
 function ConversionWrapper(B::Operator,
         d::Space=domainspace(B), r::Space=rangespace(B))
-    ConversionWrapper(d, r, unwrap(B))
+    ConversionWrapper(d, r, B)
 end
 Conversion(A::Space,B::Space,C::Space) =
     ConversionWrapper(Conversion(B,C)*Conversion(A,B), A, C)

src/Operators/general/algebra.jl

@@ -619,7 +619,7 @@ end
 
 # Conversions we always assume are intentional: no need to promote
 function *(A::Conversion, B::Conversion)
-    T = TimesOperator(unwrap(A), unwrap(B))
+    T = TimesOperator(A, B)
     ConversionWrapper(T, domainspace(B), rangespace(A))
 end
 *(A::Conversion, B::TimesOperator) = TimesOperator(A, B)

test/runtests.jl

@@ -453,7 +453,14 @@ end
     end
     @testset "conversion and constantoperator" begin
         A = Conversion(PointSpace(1:4), PointSpace(1:4))
+        @test ApproxFunBase.iswrapper(A)
+        @test ApproxFunBase.iswrapperstructure(A)
+        @test ApproxFunBase.iswrapperindexing(A)
+        @test ApproxFunBase.iswrapperspaces(A)
         @test convert(Number, A) == 1
+        f = Fun(PointSpace(1:4))
+        @test (A * A) * f == A * f == f
+        @test ApproxFunBase.ConversionWrapper(A) === A
 
         C = I : PointSpace(1:4)
         C2 = C * C