Merge pull request #11617 from JuliaLang/teh/robustmeta

Check for :meta expressions more thoroughly, and improve indexing performance

Author: timholy

base/abstractarray.jl

@@ -123,6 +123,14 @@ macro _noinline_meta()
 end
 
 ## Bounds checking ##
+@generated function trailingsize{T,N,n}(A::AbstractArray{T,N}, ::Type{Val{n}})
+    ex = :(size(A, $n))
+    for m = n+1:N
+        ex = :($ex * size(A, $m))
+    end
+    Expr(:block, Expr(:meta, :inline), ex)
+end
+
 _checkbounds(sz, i::Integer) = 1 <= i <= sz
 _checkbounds(sz, i::Real) = 1 <= to_index(i) <= sz
 _checkbounds(sz, I::AbstractVector{Bool}) = length(I) == sz
@@ -149,17 +157,14 @@ function checkbounds(A::AbstractMatrix, I::Union(Real,AbstractArray,Colon), J::U
 end
 function checkbounds(A::AbstractArray, I::Union(Real,AbstractArray,Colon), J::Union(Real,AbstractArray,Colon))
     @_inline_meta
-    (_checkbounds(size(A,1), I) && _checkbounds(trailingsize(A,2), J)) || throw_boundserror(A, (I, J))
+    (_checkbounds(size(A,1), I) && _checkbounds(trailingsize(A,Val{2}), J)) || throw_boundserror(A, (I, J))
 end
-function checkbounds(A::AbstractArray, I::Union(Real,AbstractArray,Colon)...)
-    @_inline_meta
-    n = length(I)
-    if n > 0
-        for dim = 1:(n-1)
-            _checkbounds(size(A,dim), I[dim]) || throw_boundserror(A, I)
-        end
-        _checkbounds(trailingsize(A,n), I[n]) || throw_boundserror(A, I)
-    end
+@generated function checkbounds(A::AbstractArray, I::Union(Real,AbstractArray,Colon)...)
+    meta = Expr(:meta, :inline)
+    N = length(I)
+    args = Expr[:(_checkbounds(size(A,$dim), I[$dim]) || throw_boundserror(A, I)) for dim in 1:N-1]
+    push!(args, :(_checkbounds(trailingsize(A,Val{$N}), I[$N]) || throw_boundserror(A, I)))
+    Expr(:block, meta, args...)
 end
 
 ## Bounds-checking without errors ##

base/expr.jl

@@ -119,45 +119,58 @@ function pushmeta!(ex::Expr, sym::Symbol, args::Any...)
     else
         tag = Expr(sym, args...)
     end
-
-    if ex.head == :function
+    found, metaex = findmeta(ex)
+    if found
+        push!(metaex.args, tag)
+    else
         body::Expr = ex.args[2]
-        if !isempty(body.args) && isa(body.args[1], Expr) && (body.args[1]::Expr).head == :meta
-            push!((body.args[1]::Expr).args, tag)
-        elseif isempty(body.args)
-            push!(body.args, Expr(:meta, tag))
-            push!(body.args, nothing)
-        else
-            unshift!(body.args, Expr(:meta, tag))
-        end
-    elseif (ex.head == :(=) && typeof(ex.args[1]) == Expr && ex.args[1].head == :call)
-        ex = Expr(:function, ex.args[1], Expr(:block, Expr(:meta, tag), ex.args[2]))
-#     else
-#         ex = Expr(:withmeta, ex, sym)
+        unshift!(body.args, Expr(:meta, tag))
     end
     ex
 end
 
 function popmeta!(body::Expr, sym::Symbol)
-    if isa(body.args[1],Expr) && (body.args[1]::Expr).head === :meta
-        metaargs = (body.args[1]::Expr).args
-        for i = 1:length(metaargs)
-            if (isa(metaargs[i], Symbol) && metaargs[i] == sym) ||
-               (isa(metaargs[i], Expr) && metaargs[i].head == sym)
-                if length(metaargs) == 1
-                    shift!(body.args)        # get rid of :meta Expr
-                else
-                    deleteat!(metaargs, i)   # delete this portion of the metadata
-                end
+    body.head == :block || return false, []
+    found, metaex = findmeta_block(body)
+    if !found
+        return false, []
+    end
+    metaargs = metaex.args
+    for i = 1:length(metaargs)
+        if isa(metaargs[i], Symbol) && (metaargs[i]::Symbol) == sym
+            deleteat!(metaargs, i)
+            return true, []
+        elseif isa(metaargs[i], Expr) && (metaargs[i]::Expr).head == sym
+            ret = (metaargs[i]::Expr).args
+            deleteat!(metaargs, i)
+            return true, ret
+        end
+    end
+    false, []
+end
+popmeta!(arg, sym) = (false, [])
 
-                if isa(metaargs[i], Symbol)
-                    return (true, [])
-                elseif isa(metaargs[i], Expr)
-                    return (true, metaargs[i].args)
+function findmeta(ex::Expr)
+    if ex.head == :function || (ex.head == :(=) && typeof(ex.args[1]) == Expr && ex.args[1].head == :call)
+        body::Expr = ex.args[2]
+        body.head == :block || error(body, " is not a block expression")
+        return findmeta_block(ex)
+    end
+    error(ex, " is not a function expression")
+end
+
+function findmeta_block(ex::Expr)
+    for a in ex.args
+        if isa(a, Expr)
+            if (a::Expr).head == :meta
+                return true, a::Expr
+            elseif (a::Expr).head == :block
+                found, exb = findmeta_block(a)
+                if found
+                    return found, exb
                 end
             end
         end
     end
-    return (false, [])
+    return false, Expr(:block)
 end
-popmeta!(arg, sym) = (false, [])

doc/devdocs/meta.rst

@@ -10,8 +10,8 @@ that a given block of code has special properties: you might always
 want to inline it, or you might want to turn on special compiler
 optimization passes.  Starting with version 0.4, julia has a
 convention that these instructions can be placed inside a ``:meta``
-expression, which must be the first expression in the body of a
-function.
+expression, which is typically (but not necessarily) the first
+expression in the body of a function.
 
 ``:meta`` expressions are created with macros. As an example, consider
 the implementation of the ``@inline`` macro::

test/meta.jl

@@ -66,6 +66,29 @@ body.args = ast.args[3].args
 @test popmeta!(body, :test) == (true, [42])
 @test popmeta!(body, :nonexistent) == (false, [])
 
+metaex = Expr(:meta, :foo)
+ex1 = quote
+    $metaex
+    x*x+1
+end
+metaex = Expr(:meta, :foo)
+ex2 = quote
+    y = x
+    $metaex
+    y*y+1
+end
+metaex = Expr(:block, Expr(:meta, :foo))
+ex3 = quote
+    y = x
+    $metaex
+    x*x+1
+end
+
+@test popmeta!(ex1, :foo)[1]
+@test popmeta!(ex2, :foo)[1]
+@test popmeta!(ex3, :foo)[1]
+@test !(popmeta!(:(x*x+1), :foo)[1])
+
 end