Document Method reflection functions

base/docs/basedocs.jl

@@ -2586,6 +2586,35 @@ See also [`setpropertyonce!`](@ref Base.setpropertyonce!) and [`setglobal!`](@re
 """
 setglobalonce!
 
+
+"""
+`Method` represents a method definition of a function. A list of methods for a function
+can be retrieved using [`Base.methods`](@ref).
+
+To access the properties of a `Method`, use the following functions:
+
+```
+julia> m = methods(sum)[1]
+sum(r::StepRangeLen{<:Any, <:Base.TwicePrecision, <:Base.TwicePrecision})
+     @ Base twiceprecision.jl:605
+
+julia> nameof(m)
+:sum
+
+julia> parentmodule(m)
+Base
+
+julia> signature_type(m)
+Tuple{typeof(sum), StepRangeLen{<:Any, <:Base.TwicePrecision, <:Base.TwicePrecision}}
+
+julia> Base.method_argnames(m)
+2-element Vector{Symbol}:
+ Symbol("#self#")
+ :r
+```
+"""
+Core.Method
+
 """
     typeof(x)
 

base/methodshow.jl

@@ -46,6 +46,12 @@ function argtype_decl(env, n, @nospecialize(sig::DataType), i::Int, nargs, isva:
     return s, string_with_env(env, t)
 end
 
+"""
+    method_argnames(m::Method)
+
+Return the argument names of a `Method` as a `Vector{Symbol}`. The first element is `Symbol("#self#")`.
+The remaining elements are the argument names.
+"""
 function method_argnames(m::Method)
     argnames = ccall(:jl_uncompress_argnames, Vector{Symbol}, (Any,), m.slot_syms)
     isempty(argnames) && return argnames

base/public.jl

@@ -62,6 +62,8 @@ public
     isexported,
     ispublic,
     remove_linenums!,
+    method_argnames,
+    signature_type,
 
 # Opperators
     operator_associativity,

base/reflection.jl

@@ -1123,6 +1123,30 @@ function signature_type(@nospecialize(f), @nospecialize(argtypes))
     return rewrap_unionall(Tuple{ft, u.parameters...}, argtypes)
 end
 
+"""
+    signature_type(m::Method) -> Type{<:Tuple}
+
+Retrieve the signature type of a `Method`. Returns a `Tuple` type, the first element of which is
+the `typeof` the function for the method. The remaining elements are the types of the arguments.
+
+For methods that are `OpaqueClosure`s or `Builtin`s, `Tuple{}` is returned. However, this
+behavior is not stable because future improvements to the compiler may allow improved reflection for
+these types.
+
+# Examples
+```jldoctest
+julia> f(x::Int, y) = x + y
+
+julia> m = methods(f)[1]
+
+julia> signature_type(m)
+Tuple{typeof(f), Int, Any}
+```
+"""
+function signature_type(m::Method)
+    return m.sig
+end
+
 """
     code_lowered(f, types; generated=true, debuginfo=:default)
 
@@ -1198,14 +1222,18 @@ end
 
 # high-level, more convenient method lookup functions
 
-# type for reflecting and pretty-printing a subset of methods
+"""
+`MethodList` is a type for reflecting and pretty-printing a subset of methods. It is returned by
+[`methods`](@ref).
+"""
 mutable struct MethodList <: AbstractArray{Method,1}
     ms::Array{Method,1}
     mt::Core.MethodTable
 end
 
 size(m::MethodList) = size(m.ms)
 getindex(m::MethodList, i::Integer) = m.ms[i]
+collect(m::MethodList) = m.ms
 
 function MethodList(mt::Core.MethodTable)
     ms = Method[]
@@ -1216,9 +1244,10 @@ function MethodList(mt::Core.MethodTable)
 end
 
 """
-    methods(f, [types], [module])
+    methods(f, [types], [module]) -> AbstractVector{Method}
 
-Return the method table for `f`.
+Return a list of [`Method`](@ref)s for `f`. The returned container type is not specified.
+Use `collect(methods(f))` to construct a `Vector{Method}`.
 
 If `types` is specified, return an array of methods whose types match.
 If `module` is specified, return an array of methods defined in that module.
@@ -2314,6 +2343,15 @@ function nameof(f::Core.IntrinsicFunction)
     return ccall(:jl_symbol, Ref{Symbol}, (Ptr{UInt8},), name)
 end
 
+"""
+    nameof(f::Method) -> Symbol
+
+Get the name of a `Method` as a symbol.
+"""
+function nameof(m::Method)
+    return m.name
+end
+
 """
     parentmodule(f::Function) -> Module