deprecate @pure and make it just alias to @assume_effects :foldable

Author: aviatesk

NEWS.md

@@ -10,7 +10,7 @@ Language changes
 
 Compiler/Runtime improvements
 -----------------------------
-
+* The `@pure` macro is now deprecated. Use `Base.@assume_effects :foldable` instead ([#48682]).
 
 Command-line option changes
 ---------------------------

base/compiler/abstractinterpretation.jl

@@ -96,15 +96,11 @@ function abstract_call_gf_by_type(interp::AbstractInterpreter, @nospecialize(f),
     all_effects = EFFECTS_TOTAL
     if !matches.nonoverlayed
         # currently we don't have a good way to execute the overlayed method definition,
-        # so we should give up pure/concrete eval when any of the matched methods is overlayed
+        # so we should give up concrete eval when any of the matched methods is overlayed
         f = nothing
         all_effects = Effects(all_effects; nonoverlayed=false)
     end
 
-    # try pure-evaluation
-    val = pure_eval_call(interp, f, applicable, arginfo)
-    val !== nothing && return CallMeta(val, all_effects, MethodResultPure(info)) # TODO: add some sort of edge(s)
-
     𝕃ₚ = ipo_lattice(interp)
     for i in 1:napplicable
         match = applicable[i]::MethodMatch
@@ -788,40 +784,6 @@ struct MethodCallResult
     end
 end
 
-function pure_eval_eligible(interp::AbstractInterpreter,
-    @nospecialize(f), applicable::Vector{Any}, arginfo::ArgInfo)
-    # XXX we need to check that this pure function doesn't call any overlayed method
-    return f !== nothing &&
-           length(applicable) == 1 &&
-           is_method_pure(applicable[1]::MethodMatch) &&
-           is_all_const_arg(arginfo, #=start=#2)
-end
-
-function is_method_pure(method::Method, @nospecialize(sig), sparams::SimpleVector)
-    if isdefined(method, :generator)
-        method.generator.expand_early || return false
-        mi = specialize_method(method, sig, sparams)
-        isa(mi, MethodInstance) || return false
-        staged = get_staged(mi)
-        (staged isa CodeInfo && (staged::CodeInfo).pure) || return false
-        return true
-    end
-    return method.pure
-end
-is_method_pure(match::MethodMatch) = is_method_pure(match.method, match.spec_types, match.sparams)
-
-function pure_eval_call(interp::AbstractInterpreter,
-    @nospecialize(f), applicable::Vector{Any}, arginfo::ArgInfo)
-    pure_eval_eligible(interp, f, applicable, arginfo) || return nothing
-    args = collect_const_args(arginfo, #=start=#2)
-    value = try
-        Core._apply_pure(f, args)
-    catch
-        return nothing
-    end
-    return Const(value)
-end
-
 # - true: eligible for concrete evaluation
 # - false: eligible for semi-concrete evaluation
 # - nothing: not eligible for either of it

base/compiler/ssair/EscapeAnalysis/EscapeAnalysis.jl

@@ -791,6 +791,7 @@ function compute_frameinfo(ir::IRCode, call_resolved::Bool)
             check_effect_free!(ir, idx, stmt, inst[:type], 𝕃ₒ)
         end
         if callinfo !== nothing && isexpr(stmt, :call)
+            # TODO: pass effects here
             callinfo[idx] = resolve_call(ir, stmt, inst[:info])
         elseif isexpr(stmt, :enter)
             @assert idx ≤ nstmts "try/catch inside new_nodes unsupported"

base/compiler/ssair/EscapeAnalysis/interprocedural.jl

@@ -14,6 +14,7 @@ struct EACallInfo
 end
 
 function resolve_call(ir::IRCode, stmt::Expr, @nospecialize(info::CallInfo))
+    # TODO: if effect free, return true
     sig = call_sig(ir, stmt)
     if sig === nothing
         return missing

base/compiler/typeinfer.jl

@@ -1010,7 +1010,6 @@ function typeinf_ext(interp::AbstractInterpreter, mi::MethodInstance)
                 tree.linetable = LineInfoNode[LineInfoNode(method.module, method.name, method.file, method.line, Int32(0))]
                 tree.inferred = true
                 tree.ssaflags = UInt8[0]
-                tree.pure = true
                 set_inlineable!(tree, true)
                 tree.parent = mi
                 tree.rettype = Core.Typeof(rettype_const)

base/deprecated.jl

@@ -362,3 +362,31 @@ end
 end
 
 # END 1.9 deprecations
+
+# BEGIN 1.10 deprecations
+
+"""
+    @pure ex
+
+`@pure` gives the compiler a hint for the definition of a pure function,
+helping for type inference.
+
+!!! warning
+    This macro is intended for internal compiler use and may be subject to changes.
+
+!!! warning
+    In Julia 1.8 and higher, it is favorable to use [`@assume_effects`](@ref) instead of `@pure`.
+    This is because `@assume_effects` allows a finer grained control over Julia's purity
+    modeling and the effect system enables a wider range of optimizations.
+
+!!! note
+    In Julia 1.10 this is deprecated in favor of [`@assume_effects`](@ref).
+    Specifically, `@assume_effects :foldable` provides similar guarentees.
+"""
+macro pure(ex)
+    f, l = __source__.file, __source__.line
+    @warn "`Base.@pure ex` at $f:$l is deprecated, use `Base.@assume_effects :foldable ex` instead."
+    return esc(:(Base.@assume_effects :foldable $ex))
+end
+
+# END 1.10 deprecations

base/essentials.jl

@@ -198,10 +198,6 @@ function _is_internal(__module__)
     return false
 end
 
-# can be used in place of `@pure` (supposed to be used for bootstrapping)
-macro _pure_meta()
-    return _is_internal(__module__) && Expr(:meta, :pure)
-end
 # can be used in place of `@assume_effects :total` (supposed to be used for bootstrapping)
 macro _total_meta()
     return _is_internal(__module__) && Expr(:meta, Expr(:purity,

base/expr.jl

@@ -339,23 +339,6 @@ macro noinline(x)
     return annotate_meta_def_or_block(x, :noinline)
 end
 
-"""
-    @pure ex
-
-`@pure` gives the compiler a hint for the definition of a pure function,
-helping for type inference.
-
-!!! warning
-    This macro is intended for internal compiler use and may be subject to changes.
-
-!!! warning
-    In Julia 1.8 and higher, it is favorable to use [`@assume_effects`](@ref) instead of `@pure`.
-    This is because `@assume_effects` allows a finer grained control over Julia's purity
-    modeling and the effect system enables a wider range of optimizations.
-"""
-macro pure(ex)
-    esc(isa(ex, Expr) ? pushmeta!(ex, :pure) : ex)
-end
 
 """
     @constprop setting [ex]
@@ -703,16 +686,6 @@ the following other `setting`s:
 Effect names may be prefixed by `!` to indicate that the effect should be removed
 from an earlier meta effect. For example, `:total !:nothrow` indicates that while
 the call is generally total, it may however throw.
-
----
-## Comparison to `@pure`
-
-`@assume_effects :foldable` is similar to [`@pure`](@ref) with the primary
-distinction that the `:consistent`-cy requirement applies world-age wise rather
-than globally as described above. However, in particular, a method annotated
-`@pure` should always be at least `:foldable`.
-Another advantage is that effects introduced by `@assume_effects` are propagated to
-callers interprocedurally while a purity defined by `@pure` is not.
 """
 macro assume_effects(args...)
     lastex = args[end]

doc/src/base/base.md

@@ -293,7 +293,6 @@ Base.@label
 Base.@simd
 Base.@polly
 Base.@generated
-Base.@pure
 Base.@assume_effects
 Base.@deprecate
 ```

doc/src/devdocs/ast.md

@@ -581,7 +581,7 @@ A unique'd container describing the shared metadata for a single method.
     Pointers to non-AST things that have been interpolated into the AST, required by
     compression of the AST, type-inference, or the generation of native code.
 
-  * `nargs`, `isva`, `called`, `isstaged`, `pure`
+  * `nargs`, `isva`, `called`, `is_for_opaque_closure`,
 
     Descriptive bit-fields for the source code of this Method.
 
@@ -759,11 +759,6 @@ Boolean properties:
     Whether this should propagate `@inbounds` when inlined for the purpose of eliding
     `@boundscheck` blocks.
 
-  * `pure`
-
-    Whether this is known to be a pure function of its arguments, without respect to the
-    state of the method caches or other mutable global state.
-
 
 `UInt8` settings: