Many typo fixes. (JuliaLang#27976)

HISTORY.md

@@ -930,7 +930,7 @@ Library improvements
     * Updating only a subset of the packages is now supported,
       e.g. `Pkg.update("Example")` ([#17132]).
 
-  * Miscellanous:
+  * Miscellaneous:
 
     * Prime number related functions have been moved from `Base` to the
       [Primes.jl package](https://github.com/JuliaMath/Primes.jl) ([#16481]).
@@ -1313,7 +1313,7 @@ Compiler/Runtime improvements
 
   * Accessing fields that are always initialized no longer produces undefined checks ([#8827]).
 
-  * New generational garbage collector which greatly reduces GC overhead for many commmon workloads ([#5227]).
+  * New generational garbage collector which greatly reduces GC overhead for many common workloads ([#5227]).
 
 Library improvements
 --------------------

NEWS.md

@@ -652,7 +652,7 @@ Library improvements
     Therefore custom string types may want to define direct `ncodeunits` methods.
 
   * `reverseind(s::AbstractString, i::Integer)` now has an efficient generic fallback, so
-    custom string types do not need to provide their own efficient defintions. The generic
+    custom string types do not need to provide their own efficient definitions. The generic
     definition relies on `ncodeunits` however, so for optimal performance you may need to
     define a custom method for that function.
 
@@ -693,7 +693,7 @@ Library improvements
       Use `unique` to get the old behavior.
 
   * The `linearindices` function has been deprecated in favor of the new
-    `LinearIndices` type, which additionnally provides conversion from
+    `LinearIndices` type, which additionally provides conversion from
     cartesian indices to linear indices using the normal indexing operation.
     ([#24715], [#26775]).
 
@@ -733,7 +733,7 @@ Compiler/Runtime improvements
     call. ([#22210], [#22732])
 
   * Inference recursion-detection heuristics are now more precise,
-    allowing them to be triggered less often, but being more agressive when they
+    allowing them to be triggered less often, but being more aggressive when they
     are triggered to drive the inference computation to a solution ([#23912]).
 
   * Inference now propagates constants inter-procedurally, and can compute

base/abstractarray.jl

@@ -1008,7 +1008,7 @@ error_if_canonical_setindex(::IndexCartesian, A::AbstractArray{T,N}, ::Vararg{In
     error("setindex! not defined for ", typeof(A))
 error_if_canonical_setindex(::IndexStyle, ::AbstractArray, ::Any...) = nothing
 
-## Internal defitions
+## Internal definitions
 _setindex!(::IndexStyle, A::AbstractArray, v, I...) =
     error("setindex! for $(typeof(A)) with types $(typeof(I)) is not supported")
 

base/atomics.jl

@@ -14,7 +14,7 @@ export
     atomic_max!, atomic_min!,
     atomic_fence
 
-# Disable 128-bit types on 32-bit Intel sytems due to LLVM problems;
+# Disable 128-bit types on 32-bit Intel systems due to LLVM problems;
 # see <https://github.com/JuliaLang/julia/issues/14818> (fixed on LLVM 3.9)
 # 128-bit atomics do not exist on AArch32.
 if (Base.libllvm_version < v"3.9-" && ARCH === :i686) ||

base/broadcast.jl

@@ -855,7 +855,7 @@ end
 # We could eventually allow for all broadcasting and other array types, but that
 # requires very careful consideration of all the edge effects.
 const ChunkableOp = Union{typeof(&), typeof(|), typeof(xor), typeof(~), typeof(identity),
-    typeof(!), typeof(*), typeof(==)} # these are convertable to chunkable ops by liftfuncs
+    typeof(!), typeof(*), typeof(==)} # these are convertible to chunkable ops by liftfuncs
 const BroadcastedChunkableOp{Style<:Union{Nothing,BroadcastStyle}, Axes, F<:ChunkableOp, Args<:Tuple} = Broadcasted{Style,Axes,F,Args}
 ischunkedbroadcast(R, bc::BroadcastedChunkableOp) = ischunkedbroadcast(R, bc.args)
 ischunkedbroadcast(R, args) = false

base/compiler/ssair/inlining.jl

@@ -55,7 +55,7 @@ struct UnionSplit
 end
 
 function ssa_inlining_pass!(ir::IRCode, linetable::Vector{LineInfoNode}, sv::OptimizationState)
-    # Go through the function, perfoming simple ininlingin (e.g. replacing call by constants
+    # Go through the function, performing simple ininlingin (e.g. replacing call by constants
     # and analyzing legality of inlining).
     @timeit "analysis" todo = assemble_inline_todo!(ir, linetable, sv)
     isempty(todo) && return ir
@@ -290,7 +290,7 @@ function ir_inline_item!(compact::IncrementalCompact, idx::Int, argexprs::Vector
         end
     end
     # If the iterator already moved on to the next basic block,
-    # temorarily re-open in again.
+    # temporarily re-open in again.
     local return_value
     # Special case inlining that maintains the current basic block if there's only one BB in the target
     if item.linear_inline_eligible

base/compiler/ssair/passes.jl

@@ -10,7 +10,7 @@
     struct. Somewhat counterintuitively, we don't actually need to make sure that the
     struct itself is live (or even allocated) at a ccall site. If there are no other places
     where the struct escapes (and thus e.g. where its address is taken), it need not be
-    allocated. We do however, need to make sure to preserve any elments of this struct.
+    allocated. We do however, need to make sure to preserve any elements of this struct.
 """
 struct SSADefUse
     uses::Vector{Int}

base/compiler/ssair/show.jl

@@ -159,7 +159,7 @@ example (taken from `@code_typed sin(1.0)`):
 ```
 
 The three annotations are indicated with `*`. The first one is the line number of the
-active function (printed once whenver the outer most line number changes). The second
+active function (printed once whenever the outer most line number changes). The second
 is the inlining indicator. The number of lines indicate the level of nesting, with a
 half-size line (╷) indicating the start of a scope and a full size line (│) indicating
 a continuing scope. The last annotation is the most complicated one. It is a heuristic

base/compiler/ssair/slot2ssa.jl

@@ -748,7 +748,7 @@ function construct_ssa!(ci::CodeInfo, code::Vector{Any}, ir::IRCode, domtree::Do
                     id = slot_id(stmt.args[1])
                     val = stmt.args[2]
                     typ = typ_for_val(val, ci, spvals, idx, slottypes)
-                    # Having undef_token appear on the RHS is possible if we're on a dead brach.
+                    # Having undef_token appear on the RHS is possible if we're on a dead branch.
                     # Do something reasonable here, by marking the LHS as undef as well.
                     if val !== undef_token
                         incoming_vals[id] = SSAValue(make_ssa!(ci, code, idx, id, typ))

base/deprecated.jl

@@ -540,7 +540,7 @@ end
 # issue #14470
 # TODO: More deprecations must be removed in src/cgutils.cpp:emit_array_nd_index()
 # TODO: Re-enable the disabled tests marked PLI
-# On the Julia side, this definition will gracefully supercede the new behavior (already coded)
+# On the Julia side, this definition will gracefully supersede the new behavior (already coded)
 @inline function checkbounds_indices(::Type{Bool}, IA::Tuple{Any,Vararg{Any}}, ::Tuple{})
     any(x->unsafe_length(x)==0, IA) && return false
     any(x->unsafe_length(x)!=1, IA) && return _depwarn_for_trailing_indices(IA)
@@ -1740,7 +1740,7 @@ function mapreduce(f, op, v0, itr; dims=nothing)
         depwarn("`mapreduce(f, op, v0, itr)` is deprecated, use `mapreduce(f, op, itr; init=v0)` instead", :mapreduce)
         return mapreduce(f, op, itr; init=v0)
     else # deprecate the old deprecation
-        depwarn("`mapreduce(f, op, v0, itr; dims=dims)` is deprecated, use `mapreduce(f, op, itr; init=v0, dims=dims)` intead", :mapreduce)
+        depwarn("`mapreduce(f, op, v0, itr; dims=dims)` is deprecated, use `mapreduce(f, op, itr; init=v0, dims=dims)` instead", :mapreduce)
         return mapreduce(f, op, itr; init=v0, dims=dims)
     end
 end

base/env.jl

@@ -115,7 +115,7 @@ else # !windows
     end
 end # os-test
 
-#TODO: Make these more efficent
+#TODO: Make these more efficient
 function length(::EnvDict)
     i = 0
     for (k,v) in ENV

base/essentials.jl

@@ -794,7 +794,7 @@ This function provides a fast-path hint for iterator completion.
 This is useful for mutable iterators that want to avoid having elements
 consumed, if they are not going to be exposed to the user (e.g. to check
 for done-ness in `isempty` or `zip`). Mutable iterators that want to
-opt into this feature shoud define an isdone method that returns
+opt into this feature should define an isdone method that returns
 true/false depending on whether the iterator is done or not. Stateless
 iterators need not implement this function. If the result is `missing`,
 callers may go ahead and compute `iterate(x, state...) === nothing` to

base/event.jl

@@ -333,7 +333,7 @@ end
 
 Create a timer that wakes up tasks waiting for it (by calling [`wait`](@ref) on the timer object).
 
-Waiting tasks are woken after an intial delay of `delay` seconds, and then repeating with the given
+Waiting tasks are woken after an initial delay of `delay` seconds, and then repeating with the given
 `interval` in seconds. If `interval` is equal to `0`, the timer is only triggered once. When
 the timer is closed (by [`close`](@ref) waiting tasks are woken with an error. Use [`isopen`](@ref)
 to check whether a timer is still active.
@@ -437,7 +437,7 @@ end
 Create a timer that wakes up tasks waiting for it (by calling [`wait`](@ref) on the timer object) and
 calls the function `callback`.
 
-Waiting tasks are woken and the function `callback` is called after an intial delay of `delay` seconds,
+Waiting tasks are woken and the function `callback` is called after an initial delay of `delay` seconds,
 and then repeating with the given `interval` in seconds. If `interval` is equal to `0`, the timer
 is only triggered once. The function `callback` is called with a single argument, the timer itself.
 When the timer is closed (by [`close`](@ref) waiting tasks are woken with an error. Use [`isopen`](@ref)

base/file.jl

@@ -273,7 +273,7 @@ function rm(path::AbstractString; force::Bool=false, recursive::Bool=false)
 end
 
 
-# The following use Unix command line facilites
+# The following use Unix command line facilities
 function checkfor_mv_cp_cptree(src::AbstractString, dst::AbstractString, txt::AbstractString;
                                                           force::Bool=false)
     if ispath(dst)

base/int.jl

@@ -471,7 +471,7 @@ for to in BitInteger_types, from in (BitInteger_types..., Bool)
 end
 
 # @doc isn't available when running in Core at this point.
-# Tuple syntax for documention two function signatures at the same time
+# Tuple syntax for documentation two function signatures at the same time
 # doesn't work either at this point.
 if nameof(@__MODULE__) === :Base
     for fname in (:mod, :rem)

base/iostream.jl

@@ -254,7 +254,7 @@ end
 
 Open a file in a mode specified by five boolean keyword arguments:
 
-| Keyword    | Desciption             | Default                                 |
+| Keyword    | Description             | Default                                 |
 |:-----------|:-----------------------|:----------------------------------------|
 | `read`     | open for reading       | `!write`                                |
 | `write`    | open for writing       | `truncate \\| append`                   |

base/loading.jl

@@ -1309,7 +1309,7 @@ function stale_cachefile(modpath::String, cachefile::String)
         (modules, (includes, requires), required_modules) = parse_cache_header(io)
         modules = Dict{PkgId, UInt64}(modules)
 
-        # Check if transitive dependencies can be fullfilled
+        # Check if transitive dependencies can be fulfilled
         ndeps = length(required_modules)
         depmods = Vector{Any}(undef, ndeps)
         for i in 1:ndeps

base/lock.jl

@@ -120,7 +120,7 @@ end
 
 Create a counting semaphore that allows at most `sem_size`
 acquires to be in use at any time.
-Each acquire must be mached with a release.
+Each acquire must be matched with a release.
 
 This construct is NOT threadsafe.
 """

base/math.jl

@@ -622,7 +622,7 @@ function ldexp(x::T, e::Integer) where T<:IEEEFloat
     end
     n = e % Int
     k += n
-    # overflow, if k is larger than maximum posible exponent
+    # overflow, if k is larger than maximum possible exponent
     if k >= exponent_raw_max(T)
         return flipsign(T(Inf), x)
     end

base/multidimensional.jl

@@ -721,7 +721,7 @@ end
 @inline function _indicesmightoverlap(A::Tuple{AbstractUnitRange, Vararg{Any}}, B::Tuple{AbstractUnitRange, Vararg{Any}})
     max(first(A[1]),first(B[1])) <= min(last(A[1]),last(B[1])) ? _indicesmightoverlap(tail(A), tail(B)) : false
 end
-# And we can check scalars against eachother and scalars against arrays quite easily
+# And we can check scalars against each other and scalars against arrays quite easily
 @inline _indicesmightoverlap(A::Tuple{Real, Vararg{Any}}, B::Tuple{Real, Vararg{Any}}) =
     A[1] == B[1] ? _indicesmightoverlap(tail(A), tail(B)) : false
 @inline _indicesmightoverlap(A::Tuple{Real, Vararg{Any}}, B::Tuple{AbstractArray, Vararg{Any}}) =
@@ -1475,7 +1475,7 @@ end
     return B
 end
 
-# Show for pairs() with Cartesian indicies. Needs to be here rather than show.jl for bootstrap order
+# Show for pairs() with Cartesian indices. Needs to be here rather than show.jl for bootstrap order
 function Base.showarg(io::IO, r::Iterators.Pairs{<:Integer, <:Any, <:Any, T}, toplevel) where T <: Union{AbstractVector, Tuple}
     print(io, "pairs(::$T)")
 end

base/reducedim.jl

@@ -647,7 +647,7 @@ for (fname, op) in [(:sum, :add_sum), (:prod, :mul_prod),
 end
 
 ##### findmin & findmax #####
-# The initial values of Rval are not used if the correponding indices in Rind are 0.
+# The initial values of Rval are not used if the corresponding indices in Rind are 0.
 #
 function findminmax!(f, Rval, Rind, A::AbstractArray{T,N}) where {T,N}
     (isempty(Rval) || isempty(A)) && return Rval, Rind

base/shell.jl

@@ -60,7 +60,7 @@ function shell_parse(str::AbstractString, interpolate::Bool=true;
             append_arg()
             while !isempty(st)
                 # We've made sure above that we don't end in whitespace,
-                # so updateing `i` here is ok
+                # so updating `i` here is ok
                 (i, c) = peek(st)
                 isspace(c) || break
                 popfirst!(st)

base/simdloop.jl

@@ -115,7 +115,7 @@ either case, your inner loop should have the following properties to allow vecto
     * The stride should be unit stride.
 
 !!! note
-    The `@simd` does not assert by default that the loop is completly free of loop-carried
+    The `@simd` does not assert by default that the loop is completely free of loop-carried
     memory dependencies, which is an assumption that can easily be violated in generic code.
     If you are writing non-generic code, you can use `@simd ivdep for ... end` to also assert that:
 

base/subarray.jl

@@ -37,7 +37,7 @@ check_parent_index_match(parent::AbstractArray{T,N}, ::NTuple{N, Bool}) where {T
 check_parent_index_match(parent, ::NTuple{N, Bool}) where {N} =
     throw(ArgumentError("number of indices ($N) must match the parent dimensionality ($(ndims(parent)))"))
 
-# This computes the linear indexing compatability for a given tuple of indices
+# This computes the linear indexing compatibility for a given tuple of indices
 viewindexing() = IndexLinear()
 # Leading scalar indices simply increase the stride
 viewindexing(I::Tuple{ScalarIndex, Vararg{Any}}) = (@_inline_meta; viewindexing(tail(I)))
@@ -350,7 +350,7 @@ function _indices_sub(S::SubArray, i1::AbstractArray, I...)
     (unsafe_indices(i1)..., _indices_sub(S, I...)...)
 end
 
-## Compatability
+## Compatibility
 # deprecate?
 function parentdims(s::SubArray)
     nd = ndims(s)

base/version_git.sh

@@ -36,15 +36,15 @@ git_time=$(git log -1 --pretty=format:%ct)
 commit=$(git rev-parse HEAD)
 commit_short=$(git rev-parse --short HEAD)
 if [ -n "$(git status --porcelain)" ]; then
-    # append dirty mark '*' if the repository has uncommited changes
+    # append dirty mark '*' if the repository has uncommitted changes
     commit_short="$commit_short"*
 fi
 branch=$(git branch | sed -n '/\* /s///p')
 
 topdir=$(git rev-parse --show-toplevel)
 verchanged=$(git blame -L ,1 -sl -- "$topdir/VERSION" | cut -f 1 -d " ")
 if [ $verchanged = 0000000000000000000000000000000000000000 ]; then
-    # uncommited change to VERSION
+    # uncommitted change to VERSION
     build_number=0
 else
     build_number=$(git rev-list --count HEAD "^$verchanged")
@@ -71,7 +71,7 @@ fi
 fork_master_distance=$(git rev-list HEAD ^"$(echo $origin)master" | wc -l | sed -e 's/[^[:digit:]]//g')
 fork_master_timestamp=$(git show -s $(git merge-base HEAD $(echo $origin)master) --format=format:"%ct")
 
-# Check for errrors and emit default value for missing numbers.
+# Check for errors and emit default value for missing numbers.
 if [ -z "$build_number" ]; then
     build_number="-1"
 fi

deps/valgrind/valgrind.h

@@ -1661,7 +1661,7 @@ typedef
 /* NB 9 Sept 07.  There is a nasty kludge here in all these CALL_FN_
    macros.  In order not to trash the stack redzone, we need to drop
    %rsp by 128 before the hidden call, and restore afterwards.  The
-   nastyness is that it is only by luck that the stack still appears
+   nastiness is that it is only by luck that the stack still appears
    to be unwindable during the hidden call - since then the behaviour
    of any routine using this macro does not match what the CFI data
    says.  Sigh.
@@ -6290,7 +6290,7 @@ VALGRIND_PRINTF_BACKTRACE(const char *format, ...)
 
 
 /* These requests allow control to move from the simulated CPU to the
-   real CPU, calling an arbitary function.
+   real CPU, calling an arbitrary function.
 
    Note that the current ThreadId is inserted as the first argument.
    So this call:

doc/src/devdocs/backtraces.md

@@ -102,7 +102,7 @@ the disk activity of the `julia` process:
     $ dtruss -f julia
     ```
 
-Create a [gist](https://gist.github.com) with the `strace`/ `dtruss` ouput, the [version info](@ref dev-version-info),
+Create a [gist](https://gist.github.com) with the `strace`/ `dtruss` output, the [version info](@ref dev-version-info),
 and any other pertinent information and open a new [issue](https://github.com/JuliaLang/julia/issues?q=is%3Aopen)
 on Github with a link to the gist.
 

doc/src/devdocs/callconv.md

@@ -21,7 +21,7 @@ signature.
 A small return values is returned as LLVM return values. A large return values is returned via
 the "structure return" (`sret`) convention, where the caller provides a pointer to a return slot.
 
-An argument or return values thta is a homogeneous tuple is sometimes represented as an LLVM vector
+An argument or return values that is a homogeneous tuple is sometimes represented as an LLVM vector
 instead of an LLVM array.
 
 ## JL Call Convention

doc/src/devdocs/llvm.md

@@ -45,7 +45,7 @@ a file called `Make.user` in the top-level directory and adding a line to it suc
 LLVM_VER = 3.5.0
 ```
 
-Besides the LLVM release numerals, you can also use `LLVM_VER = svn` to bulid against the latest
+Besides the LLVM release numerals, you can also use `LLVM_VER = svn` to build against the latest
 development version of LLVM.
 
 You can also specify to build a debug version of LLVM, by setting either `LLVM_DEBUG = 1` or

doc/src/devdocs/ssair.md

@@ -19,7 +19,7 @@ nodes as well as PhiC nodes and Upsilon nodes (the latter two are only used for
 
 ### Phi nodes and Pi nodes
 
-Phi nodes are part of generic SSA abstraction (see the link above if you're not familar with
+Phi nodes are part of generic SSA abstraction (see the link above if you're not familiar with
 the concept). In the Julia IR, these nodes are represented as:
 ```
 struct PhiNode
@@ -184,5 +184,5 @@ and return the new index of the node, as well as the node itself. It is legal at
 as well as make any modifications or deletions to the IR (insertions are disallowed however).
 
 The idea behind this arrangement is that, since the optimization passes need to touch the corresponding memory anyway,
-and incur the corresponding memory access penalty, performing the extra housekeeping should have comparitively little
+and incur the corresponding memory access penalty, performing the extra housekeeping should have comparatively little
 overhead (and save the overhead of maintaining these data structures during IR modification).