Merge pull request JuliaLang#10884 from JuliaLang/mb/namebug

Rename stagedfunction → ＠generated function

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

@@ -1385,6 +1385,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))