Merge pull request #32427 from JuliaLang/jn/Tuple-pure

reduce usage of _pure_meta macro annotation

Author: vtjnash

base/bool.jl

@@ -30,11 +30,7 @@ julia> .![true false true]
  0  1  0
 ```
 """
-function !(x::Bool)
-    ## We need a better heuristic to detect this automatically
-    @_pure_meta
-    return not_int(x)
-end
+!(x::Bool) = not_int(x)
 
 (~)(x::Bool) = !x
 (&)(x::Bool, y::Bool) = and_int(x, y)

base/compiler/compiler.jl

@@ -79,6 +79,13 @@ using .Iterators: zip, enumerate
 using .Iterators: Flatten, Filter, product  # for generators
 include("namedtuple.jl")
 
+ntuple(f, ::Val{0}) = ()
+ntuple(f, ::Val{1}) = (@_inline_meta; (f(1),))
+ntuple(f, ::Val{2}) = (@_inline_meta; (f(1), f(2)))
+ntuple(f, ::Val{3}) = (@_inline_meta; (f(1), f(2), f(3)))
+ntuple(f, ::Val{n}) where {n} = ntuple(f, n::Int)
+ntuple(f, n) = (Any[f(i) for i = 1:n]...,)
+
 # core docsystem
 include("docs/core.jl")
 

base/compiler/tfuncs.jl

@@ -927,12 +927,16 @@ function _fieldtype_nothrow(@nospecialize(s), exact::Bool, name::Const)
     isa(fld, Int) || return false
     ftypes = datatype_fieldtypes(u)
     nf = length(ftypes)
-    if u.name === Tuple.name && fld >= nf && isvarargtype(ftypes[nf])
-        # If we don't know the exact type, the length of the tuple will be determined
-        # at runtime and we can't say anything.
-        return exact
+    fld >= 1 || return false
+    if u.name === Tuple.name && nf > 0 && isvarargtype(ftypes[nf])
+        if !exact && fld >= nf
+            # If we don't know the exact type, the length of the tuple will be determined
+            # at runtime and we can't say anything.
+            return false
+        end
+    elseif fld > nf
+        return false
     end
-    (fld >= 1 && fld <= nf) || return false
     return true
 end
 

base/essentials.jl

@@ -106,6 +106,40 @@ macro specialize(vars...)
     return Expr(:meta, :specialize, vars...)
 end
 
+"""
+    @isdefined s -> Bool
+
+Tests whether variable `s` is defined in the current scope.
+
+See also [`isdefined`](@ref).
+
+# Examples
+```jldoctest
+julia> @isdefined newvar
+false
+
+julia> newvar = 1
+1
+
+julia> @isdefined newvar
+true
+
+julia> function f()
+           println(@isdefined x)
+           x = 3
+           println(@isdefined x)
+       end
+f (generic function with 1 method)
+
+julia> f()
+false
+true
+```
+"""
+macro isdefined(s::Symbol)
+    return Expr(:escape, Expr(:isdefined, s))
+end
+
 macro _pure_meta()
     return Expr(:meta, :pure)
 end
@@ -207,31 +241,6 @@ ERROR: ArgumentError: Cannot call tail on an empty tuple.
 tail(x::Tuple) = argtail(x...)
 tail(::Tuple{}) = throw(ArgumentError("Cannot call tail on an empty tuple."))
 
-tuple_type_head(T::Type) = (@_pure_meta; fieldtype(T, 1))
-
-function tuple_type_tail(T::Type)
-    @_pure_meta
-    if isa(T, UnionAll)
-        return UnionAll(T.var, tuple_type_tail(T.body))
-    elseif isa(T, Union)
-        return Union{tuple_type_tail(T.a), tuple_type_tail(T.b)}
-    else
-        T.name === Tuple.name || throw(MethodError(tuple_type_tail, (T,)))
-        if isvatuple(T) && length(T.parameters) == 1
-            va = T.parameters[1]
-            (isa(va, DataType) && isa(va.parameters[2], Int)) || return T
-            return Tuple{Vararg{va.parameters[1], va.parameters[2]-1}}
-        end
-        return Tuple{argtail(T.parameters...)...}
-    end
-end
-
-tuple_type_cons(::Type, ::Type{Union{}}) = Union{}
-function tuple_type_cons(::Type{S}, ::Type{T}) where T<:Tuple where S
-    @_pure_meta
-    Tuple{S, T.parameters...}
-end
-
 function unwrap_unionall(@nospecialize(a))
     while isa(a,UnionAll)
         a = a.body
@@ -248,7 +257,7 @@ end
 
 # replace TypeVars in all enclosing UnionAlls with fresh TypeVars
 function rename_unionall(@nospecialize(u))
-    if !isa(u,UnionAll)
+    if !isa(u, UnionAll)
         return u
     end
     body = rename_unionall(u.body)
@@ -301,52 +310,49 @@ function typename(a::Union)
 end
 typename(union::UnionAll) = typename(union.body)
 
-const AtLeast1 = Tuple{Any, Vararg{Any}}
-
-# converting to empty tuple type
-convert(::Type{Tuple{}}, ::Tuple{}) = ()
-convert(::Type{Tuple{}}, x::AtLeast1) = throw(MethodError(convert, (Tuple{}, x)))
-
-# converting to tuple types with at least one element
-convert(::Type{T}, x::T) where {T<:AtLeast1} = x
-convert(::Type{T}, x::AtLeast1) where {T<:AtLeast1} =
-    (convert(tuple_type_head(T), x[1]), convert(tuple_type_tail(T), tail(x))...)
-
-# converting to Vararg tuple types
-convert(::Type{Tuple{Vararg{V}}}, x::Tuple{Vararg{V}}) where {V} = x
-convert(T::Type{Tuple{Vararg{V}}}, x::Tuple) where {V} =
-    (convert(tuple_type_head(T), x[1]), convert(T, tail(x))...)
-
-# TODO: the following definitions are equivalent (behaviorally) to the above method
-# I think they may be faster / more efficient for inference,
-# if we could enable them, but are they?
-# TODO: These currently can't be used (#21026, #23017) since with
-#     z(::Type{<:Tuple{Vararg{T}}}) where {T} = T
-#   calling
-#     z(Tuple{Val{T}} where T)
-#   fails, even though `Type{Tuple{Val}} == Type{Tuple{Val{S}} where S}`
-#   and so T should be `Val` (aka `Val{S} where S`)
-#convert(_::Type{Tuple{S}}, x::Tuple{S}) where {S} = x
-#convert(_::Type{Tuple{S}}, x::Tuple{Any}) where {S} = (convert(S, x[1]),)
-#convert(_::Type{T}, x::T) where {S, N, T<:Tuple{S, Vararg{S, N}}} = x
-#convert(_::Type{Tuple{S, Vararg{S, N}}},
-#        x::Tuple{Any, Vararg{Any, N}}) where
-#       {S, N} = cnvt_all(S, x...)
-#convert(_::Type{Tuple{Vararg{S, N}}},
-#        x::Tuple{Vararg{Any, N}}) where
-#       {S, N} = cnvt_all(S, x...)
-# TODO: These are similar to the methods we currently use but cnvt_all might work better:
-#convert(_::Type{Tuple{Vararg{S}}},
-#        x::Tuple{Any, Vararg{Any}}) where
-#       {S} = cnvt_all(S, x...)
-#convert(_::Type{Tuple{Vararg{S}}},
-#        x::Tuple{Vararg{Any}}) where
-#       {S} = cnvt_all(S, x...)
-#cnvt_all(T) = ()
-#cnvt_all(T, x, rest...) = (convert(T, x), cnvt_all(T, rest...)...)
-# TODO: These may be necessary if the above are enabled
+_tuple_error(T::Type, x) = (@_noinline_meta; throw(MethodError(convert, (T, x))))
+
+convert(::Type{T}, x::T) where {T<:Tuple} = x
+function convert(::Type{T}, x::NTuple{N,Any}) where {N, T<:Tuple}
+    # First see if there could be any conversion of the input type that'd be a subtype of the output.
+    # If not, we'll throw an explicit MethodError (otherwise, it might throw a typeassert).
+    if typeintersect(NTuple{N,Any}, T) === Union{}
+        _tuple_error(T, x)
+    end
+    cvt1(n) = (@_inline_meta; convert(fieldtype(T, n), getfield(x, n, #=boundscheck=#false)))
+    return ntuple(cvt1, Val(N))::NTuple{N,Any}
+end
+
+# optimizations?
+# converting to tuple types of fixed length
+#convert(::Type{T}, x::T) where {N, T<:NTuple{N,Any}} = x
+#convert(::Type{T}, x::NTuple{N,Any}) where {N, T<:NTuple{N,Any}} =
+#    ntuple(n -> convert(fieldtype(T, n), x[n]), Val(N))
+#convert(::Type{T}, x::Tuple{Vararg{Any}}) where {N, T<:NTuple{N,Any}} =
+#    throw(MethodError(convert, (T, x)))
+# converting to tuple types of indefinite length
+#convert(::Type{Tuple{Vararg{V}}}, x::Tuple{Vararg{V}}) where {V} = x
+#convert(::Type{NTuple{N, V}}, x::NTuple{N, V}) where {N, V} = x
+#function convert(T::Type{Tuple{Vararg{V}}}, x::Tuple) where {V}
+#    @isdefined(V) || (V = fieldtype(T, 1))
+#    return map(t -> convert(V, t), x)
+#end
+#function convert(T::Type{NTuple{N, V}}, x::NTuple{N, Any}) where {N, V}
+#    @isdefined(V) || (V = fieldtype(T, 1))
+#    return map(t -> convert(V, t), x)
+#end
+# short tuples
 #convert(::Type{Tuple{}}, ::Tuple{}) = ()
-#convert(::Type{Tuple{Vararg{S}}} where S, ::Tuple{}) = ()
+#convert(::Type{Tuple{S}}, x::Tuple{S}) where {S} = x
+#convert(::Type{Tuple{S, T}}, x::Tuple{S, T}) where {S, T} = x
+#convert(::Type{Tuple{S, T, U}}, x::Tuple{S, T, U}) where {S, T, U} = x
+#convert(::Type{Tuple{S}}, x::Tuple{Any}) where {S} = (convert(S, x[1]),)
+#convert(::Type{Tuple{S, T}}, x::Tuple{Any, Any}) where {S, T} = (convert(S, x[1]), convert(T, x[2]),)
+#convert(::Type{Tuple{S, T, U}}, x::Tuple{Any, Any, Any}) where {S, T, U} = (convert(S, x[1]), convert(T, x[2]), convert(U, x[3]))
+#convert(::Type{Tuple{}}, x::Tuple) = _tuple_error(Tuple{}, x)
+#convert(::Type{Tuple{S}}, x::Tuple) = _tuple_error(Tuple{S}, x)
+#convert(::Type{Tuple{S, T}}, x::Tuple{Any, Any}) where {S, T} =_tuple_error(Tuple{S, T}, x)
+#convert(::Type{Tuple{S, T, U}}, x::Tuple{Any, Any, Any}) where {S, T, U} = _tuple_error(Tuple{S, T, U}, x)
 
 """
     oftype(x, y)
@@ -695,7 +701,7 @@ julia> f(Val(true))
 struct Val{x}
 end
 
-Val(x) = (@_pure_meta; Val{x}())
+Val(x) = Val{x}()
 
 """
     invokelatest(f, args...; kwargs...)