Also rename the bootstrap version

Author: helgee

base/bool.jl

@@ -32,7 +32,7 @@ julia> .![true false true]
 """
 function !(x::Bool)
     ## We need a better heuristic to detect this automatically
-    @_pure_meta
+    @_unsafe_pure_meta
     return not_int(x)
 end
 

base/essentials.jl

@@ -61,7 +61,7 @@ macro nospecialize(var, vars...)
     Expr(:meta, :nospecialize, var, vars...)
 end
 
-macro _pure_meta()
+macro _unsafe_pure_meta()
     Expr(:meta, :pure)
 end
 # another version of inlining that propagates an inbounds context
@@ -143,24 +143,24 @@ tail(x::Tuple) = argtail(x...)
 
 # TODO: a better / more infer-able definition would pehaps be
 #   tuple_type_head(T::Type) = fieldtype(T::Type{<:Tuple}, 1)
-tuple_type_head(T::UnionAll) = (@_pure_meta; UnionAll(T.var, tuple_type_head(T.body)))
+tuple_type_head(T::UnionAll) = (@_unsafe_pure_meta; UnionAll(T.var, tuple_type_head(T.body)))
 function tuple_type_head(T::Union)
-    @_pure_meta
+    @_unsafe_pure_meta
     return Union{tuple_type_head(T.a), tuple_type_head(T.b)}
 end
 function tuple_type_head(T::DataType)
-    @_pure_meta
+    @_unsafe_pure_meta
     T.name === Tuple.name || throw(MethodError(tuple_type_head, (T,)))
     return unwrapva(T.parameters[1])
 end
 
-tuple_type_tail(T::UnionAll) = (@_pure_meta; UnionAll(T.var, tuple_type_tail(T.body)))
+tuple_type_tail(T::UnionAll) = (@_unsafe_pure_meta; UnionAll(T.var, tuple_type_tail(T.body)))
 function tuple_type_tail(T::Union)
-    @_pure_meta
+    @_unsafe_pure_meta
     return Union{tuple_type_tail(T.a), tuple_type_tail(T.b)}
 end
 function tuple_type_tail(T::DataType)
-    @_pure_meta
+    @_unsafe_pure_meta
     T.name === Tuple.name || throw(MethodError(tuple_type_tail, (T,)))
     if isvatuple(T) && length(T.parameters) == 1
         return T
@@ -170,7 +170,7 @@ end
 
 tuple_type_cons(::Type, ::Type{Union{}}) = Union{}
 function tuple_type_cons(::Type{S}, ::Type{T}) where T<:Tuple where S
-    @_pure_meta
+    @_unsafe_pure_meta
     Tuple{S, T.parameters...}
 end
 

base/operators.jl

@@ -41,12 +41,12 @@ Signed
 ```
 """
 function supertype(T::DataType)
-    @_pure_meta
+    @_unsafe_pure_meta
     T.super
 end
 
 function supertype(T::UnionAll)
-    @_pure_meta
+    @_unsafe_pure_meta
     UnionAll(T.var, supertype(T.body))
 end
 
@@ -151,11 +151,11 @@ isless(x::AbstractFloat, y::Real         ) = (!isnan(x) & (isnan(y) | signless(x
 
 
 function ==(T::Type, S::Type)
-    @_pure_meta
+    @_unsafe_pure_meta
     T<:S && S<:T
 end
 function !=(T::Type, S::Type)
-    @_pure_meta
+    @_unsafe_pure_meta
     !(T == S)
 end
 ==(T::TypeVar, S::Type) = false

base/promotion.jl

@@ -9,11 +9,11 @@
 Return the closest common ancestor of `T` and `S`, i.e. the narrowest type from which
 they both inherit.
 """
-typejoin() = (@_pure_meta; Bottom)
-typejoin(@nospecialize(t)) = (@_pure_meta; t)
-typejoin(@nospecialize(t), ts...) = (@_pure_meta; typejoin(t, typejoin(ts...)))
+typejoin() = (@_unsafe_pure_meta; Bottom)
+typejoin(@nospecialize(t)) = (@_unsafe_pure_meta; t)
+typejoin(@nospecialize(t), ts...) = (@_unsafe_pure_meta; typejoin(t, typejoin(ts...)))
 function typejoin(@nospecialize(a), @nospecialize(b))
-    @_pure_meta
+    @_unsafe_pure_meta
     if a <: b
         return b
     elseif b <: a

base/reflection.jl

@@ -256,7 +256,7 @@ Memory allocation minimum alignment for instances of this type.
 Can be called on any `isconcretetype`.
 """
 function datatype_alignment(dt::DataType)
-    @_pure_meta
+    @_unsafe_pure_meta
     dt.layout == C_NULL && throw(UndefRefError())
     alignment = unsafe_load(convert(Ptr{DataTypeLayout}, dt.layout)).alignment
     return Int(alignment & 0x1FF)
@@ -270,7 +270,7 @@ with no intervening padding bytes.
 Can be called on any `isconcretetype`.
 """
 function datatype_haspadding(dt::DataType)
-    @_pure_meta
+    @_unsafe_pure_meta
     dt.layout == C_NULL && throw(UndefRefError())
     alignment = unsafe_load(convert(Ptr{DataTypeLayout}, dt.layout)).alignment
     return (alignment >> 9) & 1 == 1
@@ -283,7 +283,7 @@ Return whether instances of this type can contain references to gc-managed memor
 Can be called on any `isconcretetype`.
 """
 function datatype_pointerfree(dt::DataType)
-    @_pure_meta
+    @_unsafe_pure_meta
     dt.layout == C_NULL && throw(UndefRefError())
     alignment = unsafe_load(convert(Ptr{DataTypeLayout}, dt.layout)).alignment
     return (alignment >> 10) & 0xFFFFF == 0
@@ -299,7 +299,7 @@ Can be called on any `isconcretetype`.
 See also [`Base.fieldoffset`](@ref).
 """
 function datatype_fielddesc_type(dt::DataType)
-    @_pure_meta
+    @_unsafe_pure_meta
     dt.layout == C_NULL && throw(UndefRefError())
     alignment = unsafe_load(convert(Ptr{DataTypeLayout}, dt.layout)).alignment
     return (alignment >> 30) & 3
@@ -321,7 +321,7 @@ julia> isimmutable([1,2])
 false
 ```
 """
-isimmutable(@nospecialize(x)) = (@_pure_meta; !typeof(x).mutable)
+isimmutable(@nospecialize(x)) = (@_unsafe_pure_meta; !typeof(x).mutable)
 
 """
     Base.isstructtype(T) -> Bool
@@ -330,7 +330,7 @@ Determine whether type `T` was declared as a struct type
 (i.e. using the `struct` or `mutable struct` keyword).
 """
 function isstructtype(@nospecialize(t::Type))
-    @_pure_meta
+    @_unsafe_pure_meta
     t = unwrap_unionall(t)
     # TODO: what to do for `Union`?
     isa(t, DataType) || return false
@@ -344,7 +344,7 @@ Determine whether type `T` was declared as a primitive type
 (i.e. using the `primitive` keyword).
 """
 function isprimitivetype(@nospecialize(t::Type))
-    @_pure_meta
+    @_unsafe_pure_meta
     t = unwrap_unionall(t)
     # TODO: what to do for `Union`?
     isa(t, DataType) || return false
@@ -372,14 +372,14 @@ julia> isbitstype(Complex)
 false
 ```
 """
-isbitstype(@nospecialize(t::Type)) = (@_pure_meta; isa(t, DataType) && t.isbitstype)
+isbitstype(@nospecialize(t::Type)) = (@_unsafe_pure_meta; isa(t, DataType) && t.isbitstype)
 
 """
     isbits(x)
 
 Return `true` if `x` is an instance of an `isbitstype` type.
 """
-isbits(@nospecialize x) = (@_pure_meta; typeof(x).isbitstype)
+isbits(@nospecialize x) = (@_unsafe_pure_meta; typeof(x).isbitstype)
 
 """
     isdispatchtuple(T)
@@ -388,7 +388,7 @@ Determine whether type `T` is a tuple "leaf type",
 meaning it could appear as a type signature in dispatch
 and has no subtypes (or supertypes) which could appear in a call.
 """
-isdispatchtuple(@nospecialize(t)) = (@_pure_meta; isa(t, DataType) && t.isdispatchtuple)
+isdispatchtuple(@nospecialize(t)) = (@_unsafe_pure_meta; isa(t, DataType) && t.isdispatchtuple)
 
 """
     isconcretetype(T)
@@ -417,7 +417,7 @@ julia> isconcretetype(Union{Int,String})
 false
 ```
 """
-isconcretetype(@nospecialize(t)) = (@_pure_meta; isa(t, DataType) && t.isconcretetype)
+isconcretetype(@nospecialize(t)) = (@_unsafe_pure_meta; isa(t, DataType) && t.isconcretetype)
 
 """
     Base.isabstracttype(T)
@@ -435,7 +435,7 @@ false
 ```
 """
 function isabstracttype(@nospecialize(t))
-    @_pure_meta
+    @_unsafe_pure_meta
     t = unwrap_unionall(t)
     # TODO: what to do for `Union`?
     return isa(t, DataType) && t.abstract
@@ -462,7 +462,7 @@ Any
 ```
 """
 function parameter_upper_bound(t::UnionAll, idx)
-    @_pure_meta
+    @_unsafe_pure_meta
     return rewrap_unionall((unwrap_unionall(t)::DataType).parameters[idx], t)
 end
 
@@ -472,7 +472,7 @@ end
 Compute a type that contains the intersection of `T` and `S`. Usually this will be the
 smallest such type or one close to it.
 """
-typeintersect(@nospecialize(a),@nospecialize(b)) = (@_pure_meta; ccall(:jl_type_intersection, Any, (Any,Any), a, b))
+typeintersect(@nospecialize(a),@nospecialize(b)) = (@_unsafe_pure_meta; ccall(:jl_type_intersection, Any, (Any,Any), a, b))
 
 """
     fieldoffset(type, i)
@@ -499,7 +499,7 @@ julia> structinfo(Base.Filesystem.StatStruct)
  (0x0000000000000058, :ctime, Float64)
 ```
 """
-fieldoffset(x::DataType, idx::Integer) = (@_pure_meta; ccall(:jl_get_field_offset, Csize_t, (Any, Cint), x, idx))
+fieldoffset(x::DataType, idx::Integer) = (@_unsafe_pure_meta; ccall(:jl_get_field_offset, Csize_t, (Any, Cint), x, idx))
 
 """
     fieldtype(T, name::Symbol | index::Int)
@@ -611,7 +611,7 @@ julia> instances(Color)
 function instances end
 
 function to_tuple_type(@nospecialize(t))
-    @_pure_meta
+    @_unsafe_pure_meta
     if isa(t,Tuple) || isa(t,AbstractArray) || isa(t,SimpleVector)
         t = Tuple{t...}
     end

base/tuple.jl

@@ -86,7 +86,7 @@ function eltype(t::Type{<:Tuple{Vararg{E}}}) where {E}
 end
 eltype(t::Type{<:Tuple}) = _compute_eltype(t)
 function _compute_eltype(t::Type{<:Tuple})
-    @_pure_meta
+    @_unsafe_pure_meta
     t isa Union && return promote_typejoin(eltype(t.a), eltype(t.b))
     t´ = unwrap_unionall(t)
     r = Union{}

test/dimensionful.jl

@@ -16,7 +16,7 @@ Furlong{p}(v::Number) where {p} = Furlong{p,typeof(v)}(v)
 Furlong{p,T}(x::Furlong{p,S}) where {T,p,S} = Furlong{p,T}(T(x.val))
 
 Base.promote_type(::Type{Furlong{p,T}}, ::Type{Furlong{p,S}}) where {p,T,S} =
-    (Base.@_pure_meta; Furlong{p,promote_type(T,S)})
+    (Base.@_unsafe_pure_meta; Furlong{p,promote_type(T,S)})
 
 Base.one(x::Furlong{p,T}) where {p,T} = one(T)
 Base.one(::Type{Furlong{p,T}}) where {p,T} = one(T)