fix inlining expression usage in generated functions (#51)

* fix inlining expression usage in generated functions

* fix missing `@test`s

* test for zero-allocation

Author: rdeits

src/blockindices.jl

@@ -38,7 +38,7 @@ end
     @assert M < N
     α_ex = Expr(:tuple, [k <= M ? :(α[$k]) : :(1) for k = 1:N]...)
     return quote
-        $Expr(:meta, :inline)
+        $(Expr(:meta, :inline))
         @inbounds α2 = $α_ex
         BlockIndex(I, α2)
     end
@@ -54,7 +54,7 @@ Converts from global indices `inds` to a `BlockIndex`.
     I_ex = Expr(:tuple, [:(block_index[$k][1]) for k = 1:N]...)
     α_ex = Expr(:tuple, [:(block_index[$k][2]) for k = 1:N]...)
     return quote
-        $Expr(:meta, :inline)
+        $(Expr(:meta, :inline))
         @inbounds block_index = $block_index_ex
         @inbounds I = $I_ex
         @inbounds α = $α_ex
@@ -70,7 +70,7 @@ Converts from a block index to a tuple containing the global indices
 @generated function blockindex2global(block_sizes::BlockSizes{N}, block_index::BlockIndex{N}) where {N}
     ex = Expr(:tuple, [:(block_sizes[$k, block_index.I[$k]] + block_index.α[$k] - 1) for k = 1:N]...)
     return quote
-        $Expr(:meta, :inline)
+        $(Expr(:meta, :inline))
         @inbounds v = $ex
         return $ex
     end

src/blocksizes.jl

@@ -109,7 +109,7 @@ end
 @generated function globalrange(block_sizes::BlockSizes{N}, block_index::NTuple{N, Int}) where {N}
     indices_ex = Expr(:tuple, [:(block_sizes[$i, block_index[$i]]:block_sizes[$i, block_index[$i] + 1] - 1) for i = 1:N]...)
     return quote
-        $Expr(:meta, :inline)
+        $(Expr(:meta, :inline))
         @inbounds inds = $indices_ex
         return inds
     end

test/test_blockindices.jl

@@ -18,19 +18,29 @@ block_size = BlockSizes([1,2,3], [2, 3])
 @test nblocks(block_size, 1) == 3
 @test nblocks(block_size, 2) == 2
 
-@inferred globalrange(block_size, (1,1)) == (1:1, 1:2)
-@inferred globalrange(block_size, (1,2)) == (1:1, 3:5)
-@inferred globalrange(block_size, (2,1)) == (2:3, 1:2)
-@inferred globalrange(block_size, (2,2)) == (2:3, 3:5)
+@test @inferred(globalrange(block_size, (1,1))) == (1:1, 1:2)
+@test @inferred(globalrange(block_size, (1,2))) == (1:1, 3:5)
+@test @inferred(globalrange(block_size, (2,1))) == (2:3, 1:2)
+@test @inferred(globalrange(block_size, (2,2))) == (2:3, 3:5)
 
-@inferred global2blockindex(block_size, (3, 1)) == BlockIndex((2,1), (2,1))
-@inferred global2blockindex(block_size, (1, 4)) == BlockIndex((1,2), (1,2))
-@inferred global2blockindex(block_size, (4, 5)) == BlockIndex((3,2), (1,3))
+# Test for allocations inside a function to avoid noise due to global 
+# variable references
+wrapped_allocations = (bs, i) -> @allocated(globalrange(bs, i))
+@test wrapped_allocations(block_size, (1, 1)) == 0
 
-@inferred blockindex2global(block_size, BlockIndex((2,1), (2,1))) == (3, 1)
-@inferred blockindex2global(block_size, BlockIndex((1,2), (1,2))) == (1, 4)
-@inferred blockindex2global(block_size, BlockIndex((3,2), (1,3))) == (4, 5)
+@test @inferred(global2blockindex(block_size, (3, 1))) == BlockIndex((2,1), (2,1))
+@test @inferred(global2blockindex(block_size, (1, 4))) == BlockIndex((1,2), (1,2))
+@test @inferred(global2blockindex(block_size, (4, 5))) == BlockIndex((3,2), (1,3))
 
+wrapped_allocations = (bs, i) -> @allocated(global2blockindex(bs, i))
+@test wrapped_allocations(block_size, (3, 1)) == 0
+
+@test @inferred(blockindex2global(block_size, BlockIndex((2,1), (2,1)))) == (3, 1)
+@test @inferred(blockindex2global(block_size, BlockIndex((1,2), (1,2)))) == (1, 4)
+@test @inferred(blockindex2global(block_size, BlockIndex((3,2), (1,3)))) == (4, 5)
+
+wrapped_allocations = (bs, i) -> @allocated(blockindex2global(bs, i))
+@test wrapped_allocations(block_size, BlockIndex((2,1), (2,1))) == 0
 
 @test block_size == BlockSizes(1:3, 2:3)