Rename at-pure to at-unsafe_pure

Author: helgee

base/broadcast.jl

@@ -135,7 +135,7 @@ BroadcastStyle(a::AbstractArrayStyle, ::Style{Tuple})    = a
 BroadcastStyle(::A, ::A) where A<:ArrayStyle             = A()
 BroadcastStyle(::ArrayStyle, ::ArrayStyle)               = Unknown()
 BroadcastStyle(::A, ::A) where A<:AbstractArrayStyle     = A()
-Base.@pure function BroadcastStyle(a::A, b::B) where {A<:AbstractArrayStyle{M},B<:AbstractArrayStyle{N}} where {M,N}
+Base.@unsafe_pure function BroadcastStyle(a::A, b::B) where {A<:AbstractArrayStyle{M},B<:AbstractArrayStyle{N}} where {M,N}
     if Base.typename(A).wrapper == Base.typename(B).wrapper
         return A(_max(Val(M),Val(N)))
     end

base/compiler/abstractinterpretation.jl

@@ -670,11 +670,11 @@ function abstract_call(@nospecialize(f), fargs::Union{Tuple{},Vector{Any}}, argt
         rty = abstract_call(<:, fargs, argtypes, vtypes, sv)
         return rty
     elseif length(argtypes) == 2 && isa(argtypes[2], Const) && isa(argtypes[2].val, SimpleVector) && istopfunction(tm, f, :length)
-        # mark length(::SimpleVector) as @pure
+        # mark length(::SimpleVector) as @unsafe_pure
         return Const(length(argtypes[2].val))
     elseif length(argtypes) == 3 && isa(argtypes[2], Const) && isa(argtypes[3], Const) &&
             isa(argtypes[2].val, SimpleVector) && isa(argtypes[3].val, Int) && istopfunction(tm, f, :getindex)
-        # mark getindex(::SimpleVector, i::Int) as @pure
+        # mark getindex(::SimpleVector, i::Int) as @unsafe_pure
         svecval = argtypes[2].val::SimpleVector
         idx = argtypes[3].val::Int
         if 1 <= idx <= length(svecval) && isassigned(svecval, idx)

base/compiler/optimize.jl

@@ -196,7 +196,7 @@ function optimize(me::InferenceState)
         proven_pure = false
         # must be proven pure to use const_api; otherwise we might skip throwing errors
         # (issue #20704)
-        # TODO: Improve this analysis; if a function is marked @pure we should really
+        # TODO: Improve this analysis; if a function is marked @unsafe_pure we should really
         # only care about certain errors (e.g. method errors and type errors).
         if length(me.src.code) < 10
             proven_pure = true

base/compiler/typelattice.jl

@@ -8,7 +8,7 @@
 # The type of a value might be constant
 struct Const
     val
-    actual::Bool  # if true, we obtained `val` by actually calling a @pure function
+    actual::Bool  # if true, we obtained `val` by actually calling a @unsafe_pure function
     Const(@nospecialize(v)) = new(v, false)
     Const(@nospecialize(v), a::Bool) = new(v, a)
 end

base/expr.jl

@@ -200,7 +200,7 @@ macro noinline(ex)
     esc(isa(ex, Expr) ? pushmeta!(ex, :noinline) : ex)
 end
 
-macro pure(ex)
+macro unsafe_pure(ex)
     esc(isa(ex, Expr) ? pushmeta!(ex, :pure) : ex)
 end
 

base/irrationals.jl

@@ -29,7 +29,7 @@ AbstractFloat(x::AbstractIrrational) = Float64(x)
 Float16(x::AbstractIrrational) = Float16(Float32(x))
 Complex{T}(x::AbstractIrrational) where {T<:Real} = Complex{T}(T(x))
 
-@pure function Rational{T}(x::AbstractIrrational) where T<:Integer
+@unsafe_pure function Rational{T}(x::AbstractIrrational) where T<:Integer
     o = precision(BigFloat)
     p = 256
     while true
@@ -45,7 +45,7 @@ Complex{T}(x::AbstractIrrational) where {T<:Real} = Complex{T}(T(x))
 end
 (::Type{Rational{BigInt}})(x::AbstractIrrational) = throw(ArgumentError("Cannot convert an AbstractIrrational to a Rational{BigInt}: use rationalize(Rational{BigInt}, x) instead"))
 
-@pure function (t::Type{T})(x::AbstractIrrational, r::RoundingMode) where T<:Union{Float32,Float64}
+@unsafe_pure function (t::Type{T})(x::AbstractIrrational, r::RoundingMode) where T<:Union{Float32,Float64}
     setprecision(BigFloat, 256) do
         T(BigFloat(x), r)
     end
@@ -78,11 +78,11 @@ end
 <=(x::AbstractFloat, y::AbstractIrrational) = x < y
 
 # Irrational vs Rational
-@pure function rationalize(::Type{T}, x::AbstractIrrational; tol::Real=0) where T
+@unsafe_pure function rationalize(::Type{T}, x::AbstractIrrational; tol::Real=0) where T
     return rationalize(T, big(x), tol=tol)
 end
-@pure function lessrational(rx::Rational{<:Integer}, x::AbstractIrrational)
-    # an @pure version of `<` for determining if the rationalization of
+@unsafe_pure function lessrational(rx::Rational{<:Integer}, x::AbstractIrrational)
+    # an @unsafe_pure version of `<` for determining if the rationalization of
     # an irrational number required rounding up or down
     return rx < big(x)
 end

base/namedtuple.jl

@@ -186,14 +186,14 @@ function map(f, nt::NamedTuple{names}, nts::NamedTuple...) where names
 end
 
 # a version of `in` for the older world these generated functions run in
-@pure function sym_in(x::Symbol, itr::Tuple{Vararg{Symbol}})
+@unsafe_pure function sym_in(x::Symbol, itr::Tuple{Vararg{Symbol}})
     for y in itr
         y === x && return true
     end
     return false
 end
 
-@pure function merge_names(an::Tuple{Vararg{Symbol}}, bn::Tuple{Vararg{Symbol}})
+@unsafe_pure function merge_names(an::Tuple{Vararg{Symbol}}, bn::Tuple{Vararg{Symbol}})
     names = Symbol[an...]
     for n in bn
         if !sym_in(n, an)
@@ -203,7 +203,7 @@ end
     (names...,)
 end
 
-@pure function merge_types(names::Tuple{Vararg{Symbol}}, a::Type{<:NamedTuple}, b::Type{<:NamedTuple})
+@unsafe_pure function merge_types(names::Tuple{Vararg{Symbol}}, a::Type{<:NamedTuple}, b::Type{<:NamedTuple})
     bn = _nt_names(b)
     Tuple{Any[ fieldtype(sym_in(n, bn) ? b : a, n) for n in names ]...}
 end
@@ -270,7 +270,7 @@ haskey(nt::NamedTuple, key::Union{Integer, Symbol}) = isdefined(nt, key)
 get(nt::NamedTuple, key::Union{Integer, Symbol}, default) = haskey(nt, key) ? getfield(nt, key) : default
 get(f::Callable, nt::NamedTuple, key::Union{Integer, Symbol}) = haskey(nt, key) ? getfield(nt, key) : f()
 
-@pure function diff_names(an::Tuple{Vararg{Symbol}}, bn::Tuple{Vararg{Symbol}})
+@unsafe_pure function diff_names(an::Tuple{Vararg{Symbol}}, bn::Tuple{Vararg{Symbol}})
     names = Symbol[]
     for n in an
         if !sym_in(n, bn)

base/set.jl

@@ -460,7 +460,7 @@ promote_valuetype(x::Pair{K, V}, y::Pair...) where {K, V} =
     promote_type(V, promote_valuetype(y...))
 
 # Subtract singleton types which are going to be replaced
-@pure issingletontype(T::DataType) = isdefined(T, :instance)
+@unsafe_pure issingletontype(T::DataType) = isdefined(T, :instance)
 issingletontype(::Type) = false
 function subtract_singletontype(::Type{T}, x::Pair{K}) where {T, K}
     if issingletontype(K)

doc/src/manual/types.md

@@ -1374,7 +1374,7 @@ for cases where you don't need a more elaborate hierarchy.
 julia> struct Val{x}
        end
 
-julia> Base.@pure Val(x) = Val{x}()
+julia> Base.@unsafe_pure Val(x) = Val{x}()
 Val
 ```
 

stdlib/LinearAlgebra/src/LinearAlgebra.jl

@@ -18,7 +18,7 @@ import Base: USE_BLAS64, abs, acos, acosh, acot, acoth, acsc, acsch, adjoint, as
     setindex!, show, similar, sin, sincos, sinh, size, size_to_strides, sqrt, StridedReinterpretArray,
     StridedReshapedArray, strides, stride, tan, tanh, transpose, trunc, typed_hcat, vec
 using Base: hvcat_fill, iszero, IndexLinear, _length, promote_op, promote_typeof,
-    @propagate_inbounds, @pure, reduce, typed_vcat
+    @propagate_inbounds, @unsafe_pure, reduce, typed_vcat
 using Base.Broadcast: Broadcasted
 
 # We use `_length` because of non-1 indices; releases after julia 0.5

stdlib/LinearAlgebra/src/deprecated.jl

@@ -403,7 +403,7 @@ _RowVector_depstring() = string("`ConjRowVector` and `RowVector` have been depre
         "of the associated changes.")
 
 @inline check_types(::Type{T1}, ::AbstractVector{T2}) where {T1,T2} = check_types(T1, T2)
-@pure check_types(::Type{T1}, ::Type{T2}) where {T1,T2} = T1 === transpose_type(T2) ? nothing :
+@unsafe_pure check_types(::Type{T1}, ::Type{T2}) where {T1,T2} = T1 === transpose_type(T2) ? nothing :
     error("Element type mismatch. Tried to create a `RowVector{$T1}` from an `AbstractVector{$T2}`")
 
 # The element type may be transformed as transpose is recursive

test/compiler/compiler.jl

@@ -440,7 +440,7 @@ f18450() = ifelse(true, Tuple{Vararg{Int}}, Tuple{Vararg})
 @test !Core.Compiler.isconstType(Type{Tuple})
 
 # ensure pure attribute applies correctly to all signatures of fpure
-Base.@pure function fpure(a=rand(); b=rand())
+Base.@unsafe_pure function fpure(a=rand(); b=rand())
     # use the `rand` function since it is known to be `@inline`
     # but would be too big to inline
     return a + b + rand()
@@ -456,8 +456,8 @@ gpure(x::Irrational) = fpure(x)
 @test gpure() == gpure() == gpure()
 @test gpure(π) == gpure(π) == gpure(π)
 
-# Make sure @pure works for functions using the new syntax
-Base.@pure (fpure2(x::T) where T) = T
+# Make sure @unsafe_pure works for functions using the new syntax
+Base.@unsafe_pure (fpure2(x::T) where T) = T
 @test which(fpure2, (Int64,)).pure
 
 # issue #10880
@@ -752,7 +752,7 @@ f20267(x::T20267{T}, y::T) where (T) = f20267(Any[1][1], x.inds)
 
 # issue #20704
 f20704(::Int) = 1
-Base.@pure b20704(@nospecialize(x)) = f20704(x)
+Base.@unsafe_pure b20704(@nospecialize(x)) = f20704(x)
 @test b20704(42) === 1
 @test_throws MethodError b20704(42.0)
 
@@ -763,16 +763,16 @@ v20704() = Val{b20704(Any[1.0][1])}
 @test_throws MethodError v20704()
 @test Base.return_types(v20704, ()) == Any[Type{Val{1}}]
 
-Base.@pure g20704(::Int) = 1
+Base.@unsafe_pure g20704(::Int) = 1
 h20704(@nospecialize(x)) = g20704(x)
 @test g20704(1) === 1
 @test_throws MethodError h20704(1.2)
 
-Base.@pure c20704() = (f20704(1.0); 1)
+Base.@unsafe_pure c20704() = (f20704(1.0); 1)
 d20704() = c20704()
 @test_throws MethodError d20704()
 
-Base.@pure function a20704(x)
+Base.@unsafe_pure function a20704(x)
     rand()
     42
 end
@@ -1013,7 +1013,7 @@ typeargs = (Type{Int},Type{Int},Type{Int},Type{Int},Type{Int},Type{Int})
 
 # demonstrate that inference must converge
 # while doing constant propagation
-Base.@pure plus1(x) = x + 1
+Base.@unsafe_pure plus1(x) = x + 1
 f21933(x::Val{T}) where {T} = f(Val(plus1(T)))
 code_typed(f21933, (Val{1},))
 Base.return_types(f21933, (Val{1},))