Rename stagedfunction → ＠generated function

This fixes the long-standing name "bug".  Note that it only affects surface syntax.  Internally, generated functions still use the old language (e.g., Expr(:stagedfunction, ...), isstaged, stagedcache, etc).

This adds a temporary deprecation to the `stagedfunction` keyword -- the keyword should be entirely removed before the 0.4 release.

Author: mbauman

base/array.jl

@@ -322,7 +322,7 @@ end
 # sure about the behaviour and use unsafe_getindex; in the general case
 # we can't and must use getindex, otherwise silent corruption can happen)
 
-stagedfunction getindex_bool_1d(A::Array, I::AbstractArray{Bool})
+@generated function getindex_bool_1d(A::Array, I::AbstractArray{Bool})
     idxop = I <: Union(Array{Bool}, BitArray) ? :unsafe_getindex : :getindex
     quote
         checkbounds(A, I)
@@ -401,7 +401,7 @@ end
 # sure about the behaviour and use unsafe_getindex; in the general case
 # we can't and must use getindex, otherwise silent corruption can happen)
 
-stagedfunction assign_bool_scalar_1d!(A::Array, x, I::AbstractArray{Bool})
+@generated function assign_bool_scalar_1d!(A::Array, x, I::AbstractArray{Bool})
     idxop = I <: Union(Array{Bool}, BitArray) ? :unsafe_getindex : :getindex
     quote
         checkbounds(A, I)
@@ -414,7 +414,7 @@ stagedfunction assign_bool_scalar_1d!(A::Array, x, I::AbstractArray{Bool})
     end
 end
 
-stagedfunction assign_bool_vector_1d!(A::Array, X::AbstractArray, I::AbstractArray{Bool})
+@generated function assign_bool_vector_1d!(A::Array, X::AbstractArray, I::AbstractArray{Bool})
     idxop = I <: Union(Array{Bool}, BitArray) ? :unsafe_getindex : :getindex
     quote
         checkbounds(A, I)

base/base.jl

@@ -43,15 +43,25 @@ convert{T}(::Type{Tuple{Vararg{T}}}, x::Tuple) = cnvt_all(T, x...)
 cnvt_all(T) = ()
 cnvt_all(T, x, rest...) = tuple(convert(T,x), cnvt_all(T, rest...)...)
 
-stagedfunction tuple_type_head{T<:Tuple}(::Type{T})
+macro generated(f)
+    isa(f, Expr) || error("invalid syntax; @generated must be used with a function definition")
+    if is(f.head, :function) || isdefined(:length) && is(f.head, :(=)) && length(f.args) == 2 && f.args[1].head == :call
+        f.head = :stagedfunction
+        return Expr(:escape, f)
+    else
+        error("invalid syntax; @generated must be used with a function definition")
+    end
+end
+
+@generated function tuple_type_head{T<:Tuple}(::Type{T})
     T.parameters[1]
 end
 
 isvarargtype(t::ANY) = isa(t,DataType)&&is((t::DataType).name,Vararg.name)
 isvatuple(t::DataType) = (n = length(t.parameters); n > 0 && isvarargtype(t.parameters[n]))
 unwrapva(t::ANY) = isvarargtype(t) ? t.parameters[1] : t
 
-stagedfunction tuple_type_tail{T<:Tuple}(::Type{T})
+@generated function tuple_type_tail{T<:Tuple}(::Type{T})
     if isvatuple(T) && length(T.parameters) == 1
         return T
     end

base/bitarray.jl

@@ -380,7 +380,7 @@ end
 # we can't and must use getindex, otherwise silent corruption can happen)
 # (multiple signatures for disambiguation)
 for IT in [AbstractVector{Bool}, AbstractArray{Bool}]
-    @eval stagedfunction getindex(B::BitArray, I::$IT)
+    @eval @generated function getindex(B::BitArray, I::$IT)
         idxop = I <: Union(Array{Bool}, BitArray) ? :unsafe_getindex : :getindex
         quote
             checkbounds(B, I)
@@ -446,7 +446,7 @@ function setindex!(B::BitArray, x, I::BitArray)
     return B
 end
 
-stagedfunction setindex!(B::BitArray, x, I::AbstractArray{Bool})
+@generated function setindex!(B::BitArray, x, I::AbstractArray{Bool})
     idxop = I <: Array{Bool} ? :unsafe_getindex : :getindex
     quote
         checkbounds(B, I)
@@ -493,7 +493,7 @@ function setindex!(B::BitArray, X::AbstractArray, I::BitArray)
     return B
 end
 
-stagedfunction setindex!(B::BitArray, X::AbstractArray, I::AbstractArray{Bool})
+@generated function setindex!(B::BitArray, X::AbstractArray, I::AbstractArray{Bool})
     idxop = I <: Array{Bool} ? :unsafe_getindex : :getindex
     quote
         checkbounds(B, I)

base/broadcast.jl

@@ -239,7 +239,7 @@ broadcast!_function(f::Function) = (B, As...) -> broadcast!(f, B, As...)
 broadcast_function(f::Function) = (As...) -> broadcast(f, As...)
 
 broadcast_getindex(src::AbstractArray, I::AbstractArray...) = broadcast_getindex!(Array(eltype(src), broadcast_shape(I...)), src, I...)
-stagedfunction broadcast_getindex!(dest::AbstractArray, src::AbstractArray, I::AbstractArray...)
+@generated function broadcast_getindex!(dest::AbstractArray, src::AbstractArray, I::AbstractArray...)
     N = length(I)
     Isplat = Expr[:(I[$d]) for d = 1:N]
     quote
@@ -254,7 +254,7 @@ stagedfunction broadcast_getindex!(dest::AbstractArray, src::AbstractArray, I::A
     end
 end
 
-stagedfunction broadcast_setindex!(A::AbstractArray, x, I::AbstractArray...)
+@generated function broadcast_setindex!(A::AbstractArray, x, I::AbstractArray...)
     N = length(I)
     Isplat = Expr[:(I[$d]) for d = 1:N]
     quote

base/constants.jl

@@ -13,7 +13,7 @@ convert(::Type{Float16}, x::MathConst) = Float16(Float32(x))
 convert{T<:Real}(::Type{Complex{T}}, x::MathConst) = convert(Complex{T}, convert(T,x))
 convert{T<:Integer}(::Type{Rational{T}}, x::MathConst) = convert(Rational{T}, Float64(x))
 
-stagedfunction call{T<:Union(Float32,Float64),s}(t::Type{T},c::MathConst{s},r::RoundingMode)
+@generated function call{T<:Union(Float32,Float64),s}(t::Type{T},c::MathConst{s},r::RoundingMode)
     f = T(big(c()),r())
     :($f)
 end
@@ -43,13 +43,13 @@ end
 <=(x::FloatingPoint,y::MathConst) = x < y
 
 # MathConst vs Rational
-stagedfunction <{T}(x::MathConst, y::Rational{T})
+@generated function <{T}(x::MathConst, y::Rational{T})
     bx = big(x())
     bx < 0 && T <: Unsigned && return true
     rx = rationalize(T,bx,tol=0)
     rx < bx ? :($rx < y) : :($rx <= y)
 end
-stagedfunction <{T}(x::Rational{T}, y::MathConst)
+@generated function <{T}(x::Rational{T}, y::MathConst)
     by = big(y())
     by < 0 && T <: Unsigned && return false
     ry = rationalize(T,by,tol=0)

base/exports.jl

@@ -1387,6 +1387,7 @@ export
     @parallel,
 
     # metaprogramming utilities
+    @generated,
     @gensym,
     @eval,
     @vectorize_1arg,

base/iterator.jl

@@ -43,7 +43,7 @@ immutable Zip{I, Z<:AbstractZipIterator} <: AbstractZipIterator
 end
 zip(a, b, c...) = Zip(a, zip(b, c...))
 length(z::Zip) = min(length(z.a), length(z.z))
-stagedfunction tuple_type_cons{S,T<:Tuple}(::Type{S}, ::Type{T})
+@generated function tuple_type_cons{S,T<:Tuple}(::Type{S}, ::Type{T})
     Tuple{S, T.parameters...}
 end
 eltype{I,Z}(::Type{Zip{I,Z}}) = tuple_type_cons(eltype(I), eltype(Z))