Minor fixes for whitespace and typos for migration to the main Julia tree (#104)

* Fix whitespace using Julia contrib/check-whitespace.jl
* Fix typos as detected by the rust "typos" tool

Author: c42f

README.md

@@ -267,7 +267,7 @@ JuliaLowering our representation is the tuple `(name,scope_layer)`, also called
 `VarId` in the scope resolution pass.
 
 JuliaLowering's macro expander attaches a unique *scope layer* to each
-identifier in a piece of syntax. A "scope layer" is an integer identifer
+identifier in a piece of syntax. A "scope layer" is an integer identifier
 combined with the module in which the syntax was created.
 
 When expanding macros,
@@ -278,7 +278,7 @@ When expanding macros,
   in the syntax produced by the macro are tagged with this layer.
 
 Subsequently, the `(name,scope_layer)` pairs are used when resolving bindings.
-This ensures that, by default, we satisfy the basic rules for hygenic macros
+This ensures that, by default, we satisfy the basic rules for hygienic macros
 discussed in Adams' paper:
 
 1. A macro can't insert a binding that can capture references other than those
@@ -577,7 +577,7 @@ optimizations include:
 
 Properties of non-globals which are computed per-binding-per-closure include:
 * Read: the value of the binding is used.
-* Write: the binding is asssigned to.
+* Write: the binding is assigned to.
 * Captured: Bindings defined outside the closure which are either Read or Write
   within the closure are "captured" and need to be one of the closure's fields.
 * Called: the binding is called as a function, ie, `x()`. (TODO - what is this
@@ -621,7 +621,7 @@ begin
 end
 
 let
-    # f is local so this is a closure becuase `let ... end` introduces a scope
+    # f is local so this is a closure because `let ... end` introduces a scope
     function f()
         body
     end
@@ -831,7 +831,7 @@ runtime itself.
 ### Untyped IR (`CodeInfo` form)
 
 The final lowered IR is expressed as `CodeInfo` objects which are a sequence of
-`code` statments containing
+`code` statements containing
 * Literals
 * Restricted forms of `Expr` (with semantics different from surface syntax,
   even for the same `head`! for example the arguments to `Expr(:call)` in IR
@@ -890,7 +890,7 @@ In the current Julia runtime,
 - Uses `jl_toplevel_eval_in` which calls `jl_toplevel_eval_flex`
 
 `jl_toplevel_eval_flex(mod, ex)`
-- Lowers if necessay
+- Lowers if necessary
 - Evaluates certain blessed top level forms
   * `:.`
   * `:module`

src/ast.jl

@@ -168,7 +168,7 @@ end
 # TODO: Replace this with makeleaf variant?
 function mapleaf(ctx, src, kind)
     ex = makeleaf(syntax_graph(ctx), src, kind)
-    # TODO: Value coersion might be broken here due to use of `name_val` vs
+    # TODO: Value coercion might be broken here due to use of `name_val` vs
     # `value` vs ... ?
     copy_attrs!(ex, src)
     ex

src/bindings.jl

@@ -247,4 +247,3 @@ end
 function has_lambda_binding(ctx::AbstractLoweringContext, x)
     has_lambda_binding(current_lambda_bindings(ctx), x)
 end
-

src/closure_conversion.jl

@@ -494,7 +494,7 @@ function _convert_closures(ctx::ClosureConversionCtx, ex)
         is_closure = kind(name) == K"BindingId" && lookup_binding(ctx, name).kind === :local
         cap_rewrite = is_closure ? ctx.closure_infos[name.var_id] : nothing
         ctx2 = ClosureConversionCtx(ctx.graph, ctx.bindings, ctx.mod,
-                                    ctx.closure_bindings, cap_rewrite, ctx.lambda_bindings, 
+                                    ctx.closure_bindings, cap_rewrite, ctx.lambda_bindings,
                                     ctx.is_toplevel_seq_point, ctx.toplevel_pure, ctx.toplevel_stmts,
                                     ctx.closure_infos)
         body = map_cl_convert(ctx2, ex[2], false)
@@ -520,7 +520,7 @@ function _convert_closures(ctx::ClosureConversionCtx, ex)
         capture_rewrites = ClosureInfo(ex #=unused=#, field_syms, field_inds)
 
         ctx2 = ClosureConversionCtx(ctx.graph, ctx.bindings, ctx.mod,
-                                    ctx.closure_bindings, capture_rewrites, ctx.lambda_bindings, 
+                                    ctx.closure_bindings, capture_rewrites, ctx.lambda_bindings,
                                     false, ctx.toplevel_pure, ctx.toplevel_stmts, ctx.closure_infos)
 
         init_closure_args = SyntaxList(ctx)

src/desugaring.jl

@@ -794,7 +794,7 @@ function similar_tuples_or_identifiers(a, b)
 end
 
 # Return the anonymous function taking an iterated value, for use with the
-# first agument to `Base.Generator`
+# first argument to `Base.Generator`
 function func_for_generator(ctx, body, iter_value_destructuring)
     if similar_tuples_or_identifiers(iter_value_destructuring, body)
         # Use Base.identity for generators which are filters such as
@@ -1139,7 +1139,7 @@ end
 # ncat comes in various layouts which we need to lower to special cases
 # - one dimensional along some dimension
 # - balanced column first or row first
-# - ragged colum first or row first
+# - ragged column first or row first
 function expand_ncat(ctx, ex)
     is_typed = kind(ex) == K"typed_ncat"
     outer_dim = numeric_flags(ex)
@@ -1209,7 +1209,7 @@ function expand_ncat(ctx, ex)
         end
     else
         # For unbalanced/ragged concatenations, the shape is specified by the
-        # number of elements in each ND slice of the array, from layout
+        # number of elements in each N-dimensional slice of the array, from layout
         # dimension 1 to N. See the documentation for `hvncat` for details.
         i = 1
         while i <= length(nrow_spans)
@@ -1354,7 +1354,7 @@ function expand_assignment(ctx, ex, is_const=false)
                      convert_for_type_decl(ctx, ex, rhs, T, true)
                  ]])
         elseif is_identifier_like(x)
-            # Identifer in lhs[1] is a variable type declaration, eg
+            # Identifier in lhs[1] is a variable type declaration, eg
             # x::T = rhs
             @ast ctx ex [K"block"
                 [K"decl" lhs[1] lhs[2]]
@@ -2378,8 +2378,8 @@ end
 # Select static parameters which are used in function arguments `arg_types`, or
 # transitively used.
 #
-# The transitive usage check probably doesn't guarentee that the types are
-# inferrable during dispatch as they may only be part of the bounds of another
+# The transitive usage check probably doesn't guarantee that the types are
+# inferable during dispatch as they may only be part of the bounds of another
 # type. Thus we might get false positives here but we shouldn't get false
 # negatives.
 function select_used_typevars(arg_types, typevar_names, typevar_stmts)
@@ -3073,7 +3073,7 @@ function expand_function_def(ctx, ex, docs, rewrite_call=identity, rewrite_body=
             push!(sig_stmts, @ast(ctx, ex, [K"curly" "Tuple"::K"core" arg_types[2:i]...]))
         end
         sig_type = @ast ctx ex [K"where"
-            [K"curly" "Union"::K"core" sig_stmts...] 
+            [K"curly" "Union"::K"core" sig_stmts...]
             [K"_typevars" [K"block" typevar_names...] [K"block"]]
         ]
         out = @ast ctx docs [K"block"
@@ -3907,7 +3907,7 @@ function rewrite_new_calls(ctx, ex, struct_name, global_struct_name,
     )
 end
 
-function _constructor_min_initalized(ex::SyntaxTree)
+function _constructor_min_initialized(ex::SyntaxTree)
     if _is_new_call(ex)
         if any(kind(e) == K"..." for e in ex[2:end])
             # Lowering ensures new with splats always inits all fields
@@ -3917,7 +3917,7 @@ function _constructor_min_initalized(ex::SyntaxTree)
             numchildren(ex) - 1
         end
     elseif !is_leaf(ex)
-        minimum((_constructor_min_initalized(e) for e in children(ex)), init=typemax(Int))
+        minimum((_constructor_min_initialized(e) for e in children(ex)), init=typemax(Int))
     else
         typemax(Int)
     end
@@ -3958,7 +3958,7 @@ function expand_struct_def(ctx, ex, docs)
     _collect_struct_fields(ctx, field_names, field_types, field_attrs, field_docs,
                            inner_defs, children(type_body))
     is_mutable = has_flags(ex, JuliaSyntax.MUTABLE_FLAG)
-    min_initialized = minimum((_constructor_min_initalized(e) for e in inner_defs),
+    min_initialized = minimum((_constructor_min_initialized(e) for e in inner_defs),
                               init=length(field_names))
     newtype_var = ssavar(ctx, ex, "struct_type")
     hasprev = ssavar(ctx, ex, "hasprev")
@@ -3984,7 +3984,7 @@ function expand_struct_def(ctx, ex, docs)
     need_outer_constructor = false
     if isempty(inner_defs) && !isempty(typevar_names)
         # To generate an outer constructor each struct type parameter must be
-        # able to be inferred from the list of fields passed as constuctor
+        # able to be inferred from the list of fields passed as constructor
         # arguments.
         #
         # More precisely, it must occur in a field type, or in the bounds of a

src/eval.jl

@@ -216,7 +216,7 @@ function finish_ir_debug_info!(current_codelocs_stack)
     _compress_debuginfo(only(current_codelocs_stack))
 end
 
-# Convert SyntaxTree to the CodeInfo+Expr data stuctures understood by the
+# Convert SyntaxTree to the CodeInfo+Expr data structures understood by the
 # Julia runtime
 function to_code_info(ex::SyntaxTree, slots::Vector{Slot}, meta::CompileHints)
     stmts = Any[]

src/kinds.jl

@@ -8,7 +8,7 @@ function _register_kinds()
         "BEGIN_EXTENSION_KINDS"
             # atomic fields or accesses (see `@atomic`)
             "atomic"
-            # Flag for @generated parts of a functon
+            # Flag for @generated parts of a function
             "generated"
             # Temporary rooting of identifiers (GC.@preserve)
             "gc_preserve"

src/linear_ir.jl

@@ -890,7 +890,7 @@ function _remove_vars_with_isdefined_check!(vars, ex)
 end
 
 # Find newvar nodes that are unnecessary because
-# 1. The variable is not captured and 
+# 1. The variable is not captured and
 # 2. The variable is assigned before any branches.
 #
 # This is used to remove newvar nodes that are not needed for re-initializing

src/macro_expansion.jl

@@ -395,7 +395,7 @@ function expand_forms_1(ctx::MacroExpansionContext, ex::SyntaxTree)
             @ast ctx ex ex=>K"Placeholder"
         elseif is_ccall_or_cglobal(name_str)
             # Lower special identifiers `cglobal` and `ccall` to `K"core"`
-            # psuedo-refs very early so that cglobal and ccall can never be
+            # pseudo-refs very early so that cglobal and ccall can never be
             # turned into normal bindings (eg, assigned to)
             @ast ctx ex name_str::K"core"
         else

src/runtime.jl

@@ -73,9 +73,9 @@ function _interpolated_value(ctx::InterpolationContext, srcref, ex)
         end
         append_sourceref(ctx, ex, srcref)
     elseif ex isa Symbol
-        # Plain symbols become identifiers. This is an accomodation for
+        # Plain symbols become identifiers. This is an accommodation for
         # compatibility to allow `:x` (a Symbol) and `:(x)` (a SyntaxTree) to
-        # be used interchangably in macros.
+        # be used interchangeably in macros.
         makeleaf(ctx, srcref, K"Identifier", string(ex))
     else
         makeleaf(ctx, srcref, K"Value", ex)