Fix typos as detected by the rust "typos" tool

Author: c42f

docs/src/reference.md

@@ -80,7 +80,7 @@ class of tokenization errors and lets the parser deal with them.
 * We use flags rather than child nodes to represent the difference between `struct` and `mutable struct`, `module` and `baremodule` (#220)
 * Iterations are represented with the `iteration` and `in` heads rather than `=` within the header of a `for`. Thus `for i=is ; body end` parses to `(for (iteration (in i is)) (block body))`. Cartesian iteration as in `for a=as, b=bs body end` are represented with a nested `(iteration (in a as) (in b bs))` rather than a `block` containing `=` because these lists of iterators are neither semantically nor syntactically a sequence of statements, unlike other uses of `block`. Generators also use the `iteration` head - see information on that below.
 * Short form functions like `f(x) = x + 1` are represented with the `function` head rather than the `=` head. In this case the `SHORT_FORM_FUNCTION_FLAG` flag is set to allow the surface syntactic form to be easily distinguished from long form functions.
-* All kinds of updating assignment operators like `+=` are represented with a single `K"op="` head, with the operator itself in infix position. For example, `x += 1` is `(op= x + 1)`, where the plus token is of kind `K"Identifer"`. This greatly reduces the number of distinct forms here from a rather big list (`$=` `%=` `&=` `*=` `+=` `-=` `//=` `/=` `<<=` `>>=` `>>>=` `\=` `^=` `|=` `÷=` `⊻=`) and makes the operator itself appear in the AST as kind `K"Identifier"`, as it should. It also makes it possible to add further unicode updating operators while keeping the AST stable.
+* All kinds of updating assignment operators like `+=` are represented with a single `K"op="` head, with the operator itself in infix position. For example, `x += 1` is `(op= x + 1)`, where the plus token is of kind `K"Identifier"`. This greatly reduces the number of distinct forms here from a rather big list (`$=` `%=` `&=` `*=` `+=` `-=` `//=` `/=` `<<=` `>>=` `>>>=` `\=` `^=` `|=` `÷=` `⊻=`) and makes the operator itself appear in the AST as kind `K"Identifier"`, as it should. It also makes it possible to add further unicode updating operators while keeping the AST stable.
 
 ## More detail on tree differences
 

src/core/parse_stream.jl

@@ -269,7 +269,7 @@ mutable struct ParseStream
         lexer = Tokenize.Lexer(io)
         # To avoid keeping track of the exact Julia development version where new
         # features were added or comparing prerelease strings, we treat prereleases
-        # or dev versons as the release version using only major and minor version
+        # or dev versions as the release version using only major and minor version
         # numbers. This means we're inexact for old dev versions but that seems
         # like an acceptable tradeoff.
         ver = (version.major, version.minor)

src/julia/parser.jl

@@ -1418,7 +1418,7 @@ function parse_decl_with_initial_ex(ps::ParseState, mark)
             # (x) -> y
             # (x; a=1) -> y
         elseif kb == K"where"
-            # `where` and `->` have the "wrong" precedence when writing anon functons.
+            # `where` and `->` have the "wrong" precedence when writing anon functions.
             # So ignore this case to allow use of grouping brackets with `where`.
             # This needs to worked around in lowering :-(
             # (x where T) -> y  ==>  (-> (x where T) y)

test/diagnostics.jl

@@ -244,8 +244,8 @@ end
         tempdirname = mktempdir()
         cd(tempdirname) do
             rm(tempdirname)
-            # Test _file_url doesn't fail with nonexistant directories
-            @test isnothing(JuliaSyntax._file_url(joinpath("__nonexistant__", "test.jl")))
+            # Test _file_url doesn't fail with nonexistent directories
+            @test isnothing(JuliaSyntax._file_url(joinpath("__nonexistent__", "test.jl")))
         end
     end
 end

test/parser.jl

@@ -300,7 +300,7 @@ tests = [
         # `where` combined with `->` still parses strangely. However:
         # * It's extra hard to add a tuple around the `x` in this syntax corner case.
         # * The user already needs to add additional, ugly, parens to get this
-        #   to parse correctly because the precendence of `where` is
+        #   to parse correctly because the precedence of `where` is
         #   inconsistent with `::` and `->` in this case.
         "(x where T)->c" => "(-> (parens (where x T)) c)"
         "((x::T) where T)->c" => "(-> (parens (where (parens (::-i x T)) T)) c)"
@@ -963,7 +963,7 @@ tests = [
         "[a \n b]"  =>  "(vcat a b)"
         # Can't mix multiple ;'s and spaces
         ((v=v"1.7",), "[a ;; b c]")  =>  "(ncat-2 a (row b (error-t) c))"
-        # Empty nd arrays
+        # Empty N-dimensional arrays
         ((v=v"1.8",), "[;]")   =>  "(ncat-1)"
         ((v=v"1.8",), "[;;]")  =>  "(ncat-2)"
         ((v=v"1.8",), "[\n  ;; \n ]")  =>  "(ncat-2)"