Use imperative form in docstrings

Compiler/src/abstractlattice.jl

@@ -183,7 +183,7 @@ end
 """
     has_nontrivial_extended_info(𝕃::AbstractLattice, t)::Bool
 
-Determines whether the given lattice element `t` of `𝕃` has non-trivial extended lattice
+Determine whether the given lattice element `t` of `𝕃` has non-trivial extended lattice
 information that would not be available from the type itself.
 """
 @nospecializeinfer has_nontrivial_extended_info(𝕃::AbstractLattice, @nospecialize t) =
@@ -206,7 +206,7 @@ end
 """
     is_const_prop_profitable_arg(𝕃::AbstractLattice, t)::Bool
 
-Determines whether the given lattice element `t` of `𝕃` has new extended lattice information
+Determine whether the given lattice element `t` of `𝕃` has new extended lattice information
 that should be forwarded along with constant propagation.
 """
 @nospecializeinfer is_const_prop_profitable_arg(𝕃::AbstractLattice, @nospecialize t) =

Compiler/src/ssair/EscapeAnalysis.jl

@@ -415,7 +415,7 @@ end
 """
     iridx(x, estate::EscapeState) -> xidx::Union{Int,Nothing}
 
-Tries to convert analyzable IR element `x::Union{Argument,SSAValue}` to
+Try to convert analyzable IR element `x::Union{Argument,SSAValue}` to
 its unique identifier number `xidx` that is valid in the analysis context of `estate`.
 Returns `nothing` if `x` isn't maintained by `estate` and thus unanalyzable (e.g. `x::GlobalRef`).
 

Compiler/src/ssair/domtree.jl

@@ -597,7 +597,7 @@ end
 """
     dominates(domtree::DomTree, bb1::Int, bb2::Int)::Bool
 
-Checks if `bb1` dominates `bb2`.
+Check if `bb1` dominates `bb2`.
 `bb1` and `bb2` are indexes into the `CFG` blocks.
 `bb1` dominates `bb2` if the only way to enter `bb2` is via `bb1`.
 (Other blocks may be in between, e.g `bb1->bbx->bb2`).
@@ -608,7 +608,7 @@ dominates(domtree::DomTree, bb1::BBNumber, bb2::BBNumber) =
 """
     postdominates(domtree::PostDomTree, bb1::Int, bb2::Int)::Bool
 
-Checks if `bb1` post-dominates `bb2`.
+Check if `bb1` post-dominates `bb2`.
 `bb1` and `bb2` are indexes into the `CFG` blocks.
 `bb1` post-dominates `bb2` if every pass from `bb2` to the exit is via `bb1`.
 (Other blocks may be in between, e.g `bb2->bbx->bb1->exit`).

base/abstractset.jl

@@ -401,7 +401,7 @@ function ⊋ end
     ⊊(a, b)::Bool
     ⊋(b, a)::Bool
 
-Determines if `a` is a subset of, but not equal to, `b`.
+Determine if `a` is a subset of, but not equal to, `b`.
 
 See also [`issubset`](@ref) (`⊆`), [`⊈`](@ref).
 

base/channels.jl

@@ -13,7 +13,7 @@ popfirst!(c::AbstractChannel) = take!(c)
 """
     Channel{T=Any}(size::Int=0)
 
-Constructs a `Channel` with an internal buffer that can hold a maximum of `size` objects
+Construct a `Channel` with an internal buffer that can hold a maximum of `size` objects
 of type `T`.
 [`put!`](@ref) calls on a full channel block until an object is removed with [`take!`](@ref).
 
@@ -214,7 +214,7 @@ end
 """
     isopen(c::Channel)
 
-Determines whether a [`Channel`](@ref) is open for new [`put!`](@ref) operations.
+Determine whether a [`Channel`](@ref) is open for new [`put!`](@ref) operations.
 Notice that a `Channel` can be closed and still have buffered elements which can be
 consumed with [`take!`](@ref).
 
@@ -555,7 +555,7 @@ end
 """
     isready(c::Channel)
 
-Determines whether a [`Channel`](@ref) has a value stored in it.
+Determine whether a [`Channel`](@ref) has a value stored in it.
 Returns immediately, does not block.
 
 For unbuffered channels, return `true` if there are tasks waiting on a [`put!`](@ref).
@@ -600,7 +600,7 @@ end
 """
     isfull(c::Channel)
 
-Determines if a [`Channel`](@ref) is full, in the sense
+Determine if a [`Channel`](@ref) is full, in the sense
 that calling `put!(c, some_value)` would have blocked.
 Returns immediately, does not block.
 
@@ -646,7 +646,7 @@ trylock(c::Channel) = trylock(c.cond_take)
 """
     wait(c::Channel)
 
-Blocks until the `Channel` [`isready`](@ref).
+Block until the `Channel` [`isready`](@ref).
 
 ```jldoctest
 julia> c = Channel(1);

base/deprecated.jl

@@ -538,7 +538,7 @@ end
 """
     isbindingresolved(m::Module, s::Symbol) -> Bool
 
-Returns whether the binding of a symbol in a module is resolved.
+Return whether the binding of a symbol in a module is resolved.
 
 See also: [`isexported`](@ref), [`ispublic`](@ref), [`isdeprecated`](@ref)
 

base/docs/basedocs.jl

@@ -3199,7 +3199,7 @@ undef
 """
     Ptr{T}()
 
-Creates a null pointer to type `T`.
+Create a null pointer to type `T`.
 """
 Ptr{T}()
 

base/essentials.jl

@@ -508,7 +508,7 @@ pairs(::Type{NamedTuple}) = Pairs{Symbol, V, Nothing, NT} where {V, NT <: NamedT
 """
     Base.Pairs(values, keys) <: AbstractDict{eltype(keys), eltype(values)}
 
-Transforms an indexable container into a Dictionary-view of the same data.
+Transform an indexable container into a Dictionary-view of the same data.
 Modifying the key-space of the underlying data may invalidate this object.
 """
 Pairs

base/experimental.jl

@@ -34,7 +34,7 @@ Base.axes(C::Const) = axes(C.a)
 """
     @aliasscope expr
 
-Allows the compiler to assume that all `Const`s are not being modified through stores
+Allow the compiler to assume that all `Const`s are not being modified through stores
 within this scope, even if the compiler can't prove this to be the case.
 
 !!! warning
@@ -543,7 +543,7 @@ This metric is only updated when `t` yields or completes unless `t` is the curre
 which it will be updated continuously.
 See also [`Base.Experimental.task_wall_time_ns`](@ref).
 
-Returns `nothing` if task timings are not enabled.
+Return `nothing` if task timings are not enabled.
 See [`Base.Experimental.task_metrics`](@ref).
 
 !!! note "This metric is from the Julia scheduler"
@@ -572,7 +572,7 @@ This is the time since the task first entered the run queue until the time at wh
 completed, or until the current time if the task has not yet completed.
 See also [`Base.Experimental.task_running_time_ns`](@ref).
 
-Returns `nothing` if task timings are not enabled.
+Return `nothing` if task timings are not enabled.
 See [`Base.Experimental.task_metrics`](@ref).
 
 !!! compat "Julia 1.12"

base/file.jl

@@ -554,7 +554,7 @@ end
 """
     tempdir()
 
-Gets the path of the temporary directory. On Windows, `tempdir()` uses the first environment
+Get the path of the temporary directory. On Windows, `tempdir()` uses the first environment
 variable found in the ordered list `TMP`, `TEMP`, `USERPROFILE`. On all other operating
 systems, `tempdir()` uses the first environment variable found in the ordered list `TMPDIR`,
 `TMP`, `TEMP`, and `TEMPDIR`. If none of these are found, the path `"/tmp"` is used.
@@ -1297,7 +1297,7 @@ end
 """
     hardlink(src::AbstractString, dst::AbstractString)
 
-Creates a hard link to an existing source file `src` with the name `dst`. The
+Create a hard link to an existing source file `src` with the name `dst`. The
 destination, `dst`, must not exist.
 
 See also: [`symlink`](@ref).
@@ -1317,7 +1317,7 @@ end
 """
     symlink(target::AbstractString, link::AbstractString; dir_target = false)
 
-Creates a symbolic link to `target` with the name `link`.
+Create a symbolic link to `target` with the name `link`.
 
 On Windows, symlinks must be explicitly declared as referring to a directory
 or not.  If `target` already exists, by default the type of `link` will be auto-
@@ -1490,7 +1490,7 @@ Base.show(io::IO, x::DiskStat) =
 """
     diskstat(path=pwd())
 
-Returns statistics in bytes about the disk that contains the file or directory pointed at by
+Return statistics in bytes about the disk that contains the file or directory pointed at by
 `path`. If no argument is passed, statistics about the disk that contains the current
 working directory are returned.
 

base/floatfuncs.jl

@@ -273,7 +273,7 @@ end
 """
     fma(x, y, z)
 
-Computes `x*y+z` without rounding the intermediate result `x*y`. On some systems this is
+Compute `x*y+z` without rounding the intermediate result `x*y`. On some systems this is
 significantly more expensive than `x*y+z`. `fma` is used to improve accuracy in certain
 algorithms. See [`muladd`](@ref).
 """

base/gcutils.jl

@@ -169,7 +169,7 @@ end
 """
     GC.in_finalizer()::Bool
 
-Returns `true` if the current task is running a finalizer, returns `false`
+Return `true` if the current task is running a finalizer, return `false`
 otherwise. Will also return `false` within a finalizer which was inlined by the
 compiler's eager finalization optimization, or if `finalize` is called on the
 finalizer directly.

base/int.jl

@@ -100,7 +100,7 @@ inv(x::Integer) = float(one(x)) / float(x)
 """
     mul_hi(a::T, b::T) where {T<:Base.Integer}
 
-Returns the higher half of the product of `a` and `b` where `T` is a fixed size integer.
+Return the higher half of the product of `a` and `b` where `T` is a fixed size integer.
 
 # Examples
 ```jldoctest

base/intfuncs.jl

@@ -190,7 +190,7 @@ end
 """
     gcdx(a, b...)
 
-Computes the greatest common (positive) divisor of `a` and `b` and their Bézout
+Compute the greatest common (positive) divisor of `a` and `b` and their Bézout
 coefficients, i.e. the integer coefficients `u` and `v` that satisfy
 ``u*a + v*b = d = gcd(a, b)``. ``gcdx(a, b)`` returns ``(d, u, v)``.
 

base/libc.jl

@@ -280,7 +280,7 @@ end
 """
     time(t::TmStruct)::Float64
 
-Converts a `TmStruct` struct to a number of seconds since the epoch.
+Convert a `TmStruct` struct to a number of seconds since the epoch.
 """
 time(tm::TmStruct) = Float64(ccall(:mktime, Int, (Ref{TmStruct},), tm))
 

base/loading.jl

@@ -1934,7 +1934,7 @@ end
 """
     Base.isprecompiled(pkg::PkgId; ignore_loaded::Bool=false)
 
-Returns whether a given PkgId within the active project is precompiled.
+Return whether a given PkgId within the active project is precompiled.
 
 By default this check observes the same approach that code loading takes
 with respect to when different versions of dependencies are currently loaded
@@ -1952,7 +1952,7 @@ end
 """
     Base.isrelocatable(pkg::PkgId)
 
-Returns whether a given PkgId within the active project is precompiled and the
+Return whether a given PkgId within the active project is precompiled and the
 associated cache is relocatable.
 
 !!! compat "Julia 1.11"
@@ -3302,7 +3302,7 @@ end
 """
     Base.compilecache(module::PkgId)
 
-Creates a precompiled cache file for a module and all of its dependencies.
+Create a precompiled cache file for a module and all of its dependencies.
 This can be used to reduce package load times. Cache files are stored in
 `DEPOT_PATH[1]/compiled`. See [Module initialization and precompilation](@ref)
 for important notes.

base/lock.jl

@@ -21,7 +21,7 @@ const MAX_SPIN_ITERS = 40
 """
     ReentrantLock()
 
-Creates a re-entrant lock for synchronizing [`Task`](@ref)s. The same task can
+Create a re-entrant lock for synchronizing [`Task`](@ref)s. The same task can
 acquire the lock as many times as required (this is what the "Reentrant" part
 of the name means). Each [`lock`](@ref) must be matched with an [`unlock`](@ref).
 
@@ -400,7 +400,7 @@ end
 """
     Lockable(value, lock = ReentrantLock())
 
-Creates a `Lockable` object that wraps `value` and
+Create a `Lockable` object that wraps `value` and
 associates it with the provided `lock`. This object
 supports [`@lock`](@ref), [`lock`](@ref), [`trylock`](@ref),
 [`unlock`](@ref). To access the value, index the lockable object while

base/rational.jl

@@ -52,7 +52,7 @@ Rational(n::Integer) = unsafe_rational(n, one(n))
 """
     divgcd(x::Integer, y::Integer)
 
-Returns `(x÷gcd(x,y), y÷gcd(x,y))`.
+Return `(x÷gcd(x,y), y÷gcd(x,y))`.
 
 See also [`div`](@ref), [`gcd`](@ref).
 """

base/rawbigfloats.jl

@@ -30,15 +30,15 @@ word_is_nonzero(x::BigFloatData, v::Val) = let x = x
 end
 
 """
-Returns a `Bool` indicating whether the `len` least significant words
+Return a `Bool` indicating whether the `len` least significant words
 of `x` are nonzero.
 """
 function tail_is_nonzero(x::BigFloatData, len::Int, ::Val{:words})
     any(word_is_nonzero(x, Val(:ascending)), 0:(len - 1))
 end
 
 """
-Returns a `Bool` indicating whether the `len` least significant bits of
+Return a `Bool` indicating whether the `len` least significant bits of
 the `i`-th (zero-based index) word of `x` are nonzero.
 """
 function tail_is_nonzero(x::BigFloatData, len::Int, i::Int, ::Val{:word})
@@ -47,7 +47,7 @@ function tail_is_nonzero(x::BigFloatData, len::Int, i::Int, ::Val{:word})
 end
 
 """
-Returns a `Bool` indicating whether the `len` least significant bits of
+Return a `Bool` indicating whether the `len` least significant bits of
 `x` are nonzero.
 """
 function tail_is_nonzero(x::BigFloatData, len::Int, ::Val{:bits})
@@ -61,14 +61,14 @@ function tail_is_nonzero(x::BigFloatData, len::Int, ::Val{:bits})
 end
 
 """
-Returns a `Bool` that is the `i`-th (zero-based index) bit of `x`.
+Return a `Bool` that is the `i`-th (zero-based index) bit of `x`.
 """
 function get_elem(x::Unsigned, i::Int, ::Val{:bits}, ::Val{:ascending})
     (x >>> i) % Bool
 end
 
 """
-Returns a `Bool` that is the `i`-th (zero-based index) bit of `x`.
+Return a `Bool` that is the `i`-th (zero-based index) bit of `x`.
 """
 function get_elem(x::BigFloatData, i::Int, ::Val{:bits}, v::Val{:ascending})
     vb = Val(:bits)
@@ -82,7 +82,7 @@ function get_elem(x::BigFloatData, i::Int, ::Val{:bits}, v::Val{:ascending})
 end
 
 """
-Returns an integer of type `R`, consisting of the `len` most
+Return an integer of type `R`, consisting of the `len` most
 significant bits of `x`. If there are less than `len` bits in `x`,
 the least significant bits are zeroed.
 """

base/reflection.jl

@@ -211,7 +211,7 @@ end
 """
     code_typed(f, types; kw...)
 
-Returns an array of type-inferred lowered form (IR) for the methods matching the given
+Return an array of type-inferred lowered form (IR) for the methods matching the given
 generic function and type signature.
 
 # Keyword Arguments
@@ -618,7 +618,7 @@ end
         world::UInt=get_world_counter(),
         interp::Core.Compiler.AbstractInterpreter=Core.Compiler.NativeInterpreter(world)) -> rt::Type
 
-Returns an inferred return type of the function call specified by `f` and `types`.
+Return an inferred return type of the function call specified by `f` and `types`.
 
 # Arguments
 - `f`: The function to analyze.
@@ -764,7 +764,7 @@ end
         world::UInt=get_world_counter(),
         interp::Core.Compiler.AbstractInterpreter=Core.Compiler.NativeInterpreter(world)) -> exct::Type
 
-Returns the type of exception potentially thrown by the function call specified by `f` and `types`.
+Return the type of exception potentially thrown by the function call specified by `f` and `types`.
 
 # Arguments
 - `f`: The function to analyze.
@@ -833,7 +833,7 @@ end
         world::UInt=get_world_counter(),
         interp::Core.Compiler.AbstractInterpreter=Core.Compiler.NativeInterpreter(world)) -> effects::Effects
 
-Returns the possible computation effects of the function call specified by `f` and `types`.
+Return the possible computation effects of the function call specified by `f` and `types`.
 
 # Arguments
 - `f`: The function to analyze.
@@ -963,7 +963,7 @@ end
 """
     which(f, types)
 
-Returns the method of `f` (a `Method` object) that would be called for arguments of the given `types`.
+Return the method of `f` (a `Method` object) that would be called for arguments of the given `types`.
 
 If `types` is an abstract type, then the method that would be called by `invoke` is returned.
 
@@ -987,7 +987,7 @@ end
 """
     which(types::Type{<:Tuple})
 
-Returns the method that would be called by the given type signature (as a tuple type).
+Return the method that would be called by the given type signature (as a tuple type).
 """
 function which(@nospecialize(tt#=::Type=#))
     return _which(tt).method