Make constant propagation unconditional (#515)

Author: jishnub

ApproxFunBaseTest/Project.toml

@@ -14,7 +14,7 @@ LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
 Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
 
 [compat]
-ApproxFunBase = "0.5, 0.6, 0.7, 0.8"
+ApproxFunBase = "0.5, 0.6, 0.7, 0.8, 0.9"
 BandedMatrices = "0.16, 0.17"
 BlockArrays = "0.14, 0.15, 0.16"
 BlockBandedMatrices = "0.10, 0.11, 0.12"

src/Fun.jl

@@ -594,12 +594,7 @@ end
 
 \(c::Number, f::Fun) = Fun(f.space, c \ f.coefficients)
 
-@static if VERSION >= v"1.8"
-    Base.@constprop :aggressive intpow(f::Fun, k::Integer) = _intpow(f, k)
-else
-    intpow(f::Fun, k::Integer) = _intpow(f, k)
-end
-@inline function _intpow(f, k)
+Base.@constprop :aggressive function intpow(f, k)
     if k == 0
         ones(cfstype(f), space(f))
     elseif k==1

src/Multivariate/TensorSpace.jl

@@ -358,21 +358,14 @@ Space(sp::ProductDomain) = TensorSpace(sp)
 setdomain(sp::TensorSpace, d::ProductDomain) = TensorSpace(setdomain.(factors(sp), factors(d)))
 
 *(A::Space, B::Space) = A ⊗ B
-@inline function _powspace(A, p)
+Base.@constprop :aggressive function ^(A::Space, p::Integer)
     p >= 1 || throw(ArgumentError("exponent must be >= 1, received $p"))
     # Enumerate common cases to help with constant propagation
     p == 1 ? A :
     p == 2 ? A * A :
     p == 3 ? A * A * A :
     foldl(*, ntuple(_ -> A, p))
 end
-@static if VERSION >= v"1.8"
-    Base.@constprop :aggressive function ^(A::Space, p::Integer)
-        _powspace(A, p)
-    end
-else
-    ^(A::Space, p::Integer) = _powspace(A, p)
-end
 
 
 ## TODO: generalize

src/Operators/banded/CalculusOperator.jl

@@ -191,7 +191,7 @@ end
 
 
 ## Map to canonical
-@inline function _DefaultDerivative(sp::Space, k::Number)
+Base.@constprop :aggressive function DefaultDerivative(sp::Space, k::Number)
     assert_integer(k)
     if nameof(typeof(canonicaldomain(sp))) == nameof(typeof(domain(sp)))
         # this is the normal default constructor
@@ -222,19 +222,7 @@ end
     end
 end
 
-@static if VERSION >= v"1.8"
-    for f in (:DefaultDerivative, :DefaultIntegral)
-        _f = Symbol(:_, f)
-        @eval Base.@constprop :aggressive $f(sp::Space, k::Number) = $_f(sp, k)
-    end
-else
-    for f in (:DefaultDerivative, :DefaultIntegral)
-        _f = Symbol(:_, f)
-        @eval $f(sp::Space, k::Number) = $_f(sp, k)
-    end
-end
-
-@inline function _DefaultIntegral(sp::Space, k::Number)
+Base.@constprop :aggressive function DefaultIntegral(sp::Space, k::Number)
     assert_integer(k)
     if nameof(typeof(canonicaldomain(sp))) == nameof(typeof(domain(sp)))
         # this is the normal default constructor

src/Operators/general/CachedOperator.jl

@@ -24,16 +24,7 @@ CachedOperator(op::Operator,data::AbstractMatrix,sz::Tuple{Int,Int},pd=false) =
 CachedOperator(op::Operator,data::AbstractMatrix,padding=false) = CachedOperator(op,data,size(data),padding)
 
 
-@static if VERSION >= v"1.8"
-    Base.@constprop :aggressive function default_CachedOperator(op::Operator;padding::Bool=false)
-        _default_CachedOperator(op, padding)
-    end
-else
-    function default_CachedOperator(op::Operator;padding::Bool=false)
-        _default_CachedOperator(op, padding)
-    end
-end
-@inline function _default_CachedOperator(op::Operator, padding)
+Base.@constprop :aggressive function default_CachedOperator(op::Operator; padding::Bool=false)
     if isbanded(op)
         CachedOperator(BandedMatrix, op; padding=padding)
     elseif isbandedblockbanded(op) && !padding

src/Operators/general/InterlaceOperator.jl

@@ -90,12 +90,6 @@ end
 const VectorInterlaceOperator = InterlaceOperator{T,1,DS,RS} where {T,DS,RS<:Space{D,R}} where {D,R<:AbstractVector}
 const MatrixInterlaceOperator = InterlaceOperator{T,2,DS,RS} where {T,DS,RS<:Space{D,R}} where {D,R<:AbstractVector}
 
-@static if VERSION >= v"1.8"
-    Base.@constprop :aggressive interlace_bandwidths(args...) = _interlace_bandwidths(args...)
-else
-    interlace_bandwidths(args...) = _interlace_bandwidths(args...)
-end
-
 __interlace_ops_bandwidths(ops::AbstractMatrix) = bandwidths.(ops)
 __interlace_ops_bandwidths(ops::Diagonal) = bandwidths.(parent(ops))
 function __interlace_bandwidths_square(ops::AbstractMatrix, bw = __interlace_ops_bandwidths(ops))
@@ -119,8 +113,11 @@ function __interlace_bandwidths_square(ops::Diagonal, bw = __interlace_ops_bandw
     l,u
 end
 
-@inline function _interlace_bandwidths(ops::AbstractMatrix{<:Operator}, ds, rs,
-        allbanded = all(isbanded,ops), bw = allbanded ? __interlace_ops_bandwidths(ops) : nothing)
+Base.@constprop :aggressive function interlace_bandwidths(ops::AbstractMatrix{<:Operator},
+        ds, rs,
+        allbanded = all(isbanded, ops),
+        bw = allbanded ? __interlace_ops_bandwidths(ops) : nothing)
+
     p=size(ops,1)
     dsi = interlacer(ds)
     rsi = interlacer(rs)
@@ -159,7 +156,7 @@ function InterlaceOperator(ops::AbstractMatrix{<:Operator},ds::Space,rs::Space;
                         israggedbelow)
 end
 
-@inline function _interlace_bandwidths(ops::VectorOrTupleOfOp, ds, rs, allbanded = all(isbanded, ops))
+Base.@constprop :aggressive function interlace_bandwidths(ops::VectorOrTupleOfOp, ds, rs, allbanded = all(isbanded, ops))
     p=size(ops,1)
     ax1 = first(axes(ops))
     if allbanded
@@ -210,19 +207,10 @@ function InterlaceOperator(opsin::AbstractVector{<:Operator})
     ops = convert_vector(promotedomainspace(opsin))
     InterlaceOperator(ops, domainspace(first(ops)), rangespace(ops))
 end
-@inline function _InterlaceOperator(opsin, promotedomain)
+Base.@constprop :aggressive function InterlaceOperator(opsin, promotedomain = true)
     ops = promotedomain ? promotedomainspace(opsin) : opsin
     InterlaceOperator(ops, domainspace(first(ops)), rangespace(ops))
 end
-@static if VERSION >= v"1.8"
-    Base.@constprop :aggressive function InterlaceOperator(opsin::Tuple{Operator, Vararg{Operator}}, promotedomain = true)
-        _InterlaceOperator(opsin, promotedomain)
-    end
-else
-    function InterlaceOperator(opsin::Tuple{Operator, Vararg{Operator}}, promotedomain = true)
-        _InterlaceOperator(opsin, promotedomain)
-    end
-end
 
 InterlaceOperator(ops::AbstractArray, ds=NoSpace, rs=ds) =
     InterlaceOperator(Array{Operator{promote_eltypeof(ops)}, ndims(ops)}(ops), ds, rs)

src/Operators/general/algebra.jl

@@ -250,34 +250,18 @@ struct TimesOperator{T,BW,SZ,O<:Operator{T},BBW,SBBW} <: Operator{T}
     israggedbelow::Bool
     isafunctional::Bool
 
-    @static if VERSION >= v"1.8"
-        Base.@constprop :aggressive function TimesOperator{T,BW,SZ,O,BBW,SBBW}(ops::Vector{O}, bw::BW,
-                sz::SZ, bbw::BBW, sbbw::SBBW,
-                ibbb::Bool, irb::Bool, isaf::Bool;
-                anytimesop = any(x -> x isa TimesOperator, ops)) where {T,O<:Operator{T},BW,SZ,BBW,SBBW}
-
-            # check compatible
-            check_times(ops)
-
-            # remove TimesOperators buried inside ops
-            newops = anytimesop ? splice_times(ops) : ops
-
-            new{T,BW,SZ,O,BBW,SBBW}(newops, bw, sz, bbw, sbbw, ibbb, irb, isaf)
-        end
-    else
-        function TimesOperator{T,BW,SZ,O,BBW,SBBW}(ops::Vector{O}, bw::BW,
-                sz::SZ, bbw::BBW, sbbw::SBBW,
-                ibbb::Bool, irb::Bool, isaf::Bool;
-                anytimesop = any(x -> x isa TimesOperator, ops)) where {T,O<:Operator{T},BW,SZ,BBW,SBBW}
+    Base.@constprop :aggressive function TimesOperator{T,BW,SZ,O,BBW,SBBW}(ops::Vector{O}, bw::BW,
+            sz::SZ, bbw::BBW, sbbw::SBBW,
+            ibbb::Bool, irb::Bool, isaf::Bool;
+            anytimesop = any(x -> x isa TimesOperator, ops)) where {T,O<:Operator{T},BW,SZ,BBW,SBBW}
 
-            # check compatible
-            check_times(ops)
+        # check compatible
+        check_times(ops)
 
-            # remove TimesOperators buried inside ops
-            newops = anytimesop ? splice_times(ops) : ops
+        # remove TimesOperators buried inside ops
+        newops = anytimesop ? splice_times(ops) : ops
 
-            new{T,BW,SZ,O,BBW,SBBW}(newops, bw, sz, bbw, sbbw, ibbb, irb, isaf)
-        end
+        new{T,BW,SZ,O,BBW,SBBW}(newops, bw, sz, bbw, sbbw, ibbb, irb, isaf)
     end
 end
 
@@ -334,13 +318,7 @@ function convert(::Type{Operator{T}}, P::TimesOperator) where {T}
     end
 end
 
-
-@static if VERSION > v"1.8"
-    Base.@constprop :aggressive promotetimes(args...) = _promotetimes(args...)
-else
-    promotetimes(args...) = _promotetimes(args...)
-end
-@inline function _promotetimes(opsin,
+Base.@constprop :aggressive function promotetimes(opsin,
         dsp=domainspace(last(opsin)),
         anytimesop=true)
 
@@ -666,22 +644,14 @@ end
 -(A::Operator) = ConstantTimesOperator(-1, A)
 -(A::Operator, B::Operator) = A + (-B)
 
-@inline function _mulop(f::Fun, A::Operator)
+Base.@constprop :aggressive function *(f::Fun, A::Operator)
     if isafunctional(A) && (isinf(bandwidth(A, 1)) || isinf(bandwidth(A, 2)))
         LowRankOperator(f, A)
     else
         TimesOperator(Multiplication(f, rangespace(A)), A)
     end
 end
 
-@static if VERSION >= v"1.8"
-    Base.@constprop :aggressive function *(f::Fun, A::Operator)
-        _mulop(f, A)
-    end
-else
-    *(f::Fun, A::Operator) = _mulop(f, A)
-end
-
 *(c::Number, A::Operator) = ConstantTimesOperator(c, A)
 *(A::Operator, c::Number) = c * A
 

src/Spaces/ProductSpaceOperators.jl

@@ -245,32 +245,24 @@ _spacename(::PiecewiseSpace) = PiecewiseSpace
 end
 
 for (Op,OpWrap) in ((:Derivative,:DerivativeWrapper),(:Integral,:IntegralWrapper))
-    _Op = Symbol(:_, Op)
     @eval begin
-        @inline function $_Op(S::PiecewiseSpace, k::Number)
+        Base.@constprop :aggressive function $Op(S::PiecewiseSpace, k::Number)
             assert_integer(k)
             t = map(s->$Op(s,k),components(S))
             O = InterlaceOperator_Diagonal(t, S)
             $OpWrap(O,k)
         end
-        @inline function $_Op(S::ArraySpace, k::Number)
+        Base.@constprop :aggressive function $Op(S::ArraySpace, k::Number)
             assert_integer(k)
             ops = map(s->$Op(s,k),S)
             RS = ArraySpace(reshape(map(rangespace, ops), size(S)))
             O = InterlaceOperator(Diagonal(ops), S, RS)
             $OpWrap(O,k)
         end
-        @static if VERSION >= v"1.8"
-            Base.@constprop :aggressive $Op(s::PiecewiseSpace, k::Number) = $_Op(s, k)
-            Base.@constprop :aggressive $Op(s::ArraySpace, k::Number) = $_Op(s, k)
-        else
-            $Op(s::PiecewiseSpace, k::Number) = $_Op(s, k)
-            $Op(s::ArraySpace, k::Number) = $_Op(s, k)
-        end
     end
 end
 
-@inline function _Derivative(S::SumSpace, k::Number)
+Base.@constprop :aggressive function Derivative(S::SumSpace, k::Number)
     assert_integer(k)
     # we want to map before we decompose, as the map may introduce
     # mixed bases.
@@ -283,13 +275,8 @@ end
     end
 end
 
-@static if VERSION >= v"1.8"
-    Base.@constprop :aggressive Derivative(s::SumSpace, k::Number) = _Derivative(s, k)
-else
-    Derivative(s::SumSpace, k::Number) = _Derivative(s, k)
-end
-
-choosedomainspace(M::CalculusOperator{UnsetSpace},sp::SumSpace)=mapreduce(s->choosedomainspace(M,s),union,sp.spaces)
+choosedomainspace(M::CalculusOperator{UnsetSpace}, sp::SumSpace) =
+    mapreduce(s->choosedomainspace(M,s),union,sp.spaces)
 
 ## Multiplcation for Array*Vector