fix spelling

Author: coke

src/NQP/Optimizer.nqp

@@ -395,7 +395,7 @@ class NQP::Optimizer {
                                     }
                                 }
 
-                                # If we reach here, unknown. Poision.
+                                # If we reach here, unknown. Poison.
                                 self.poison_lowering();
                                 return $node;
                             }),

src/QRegex/P6Regex/Actions.nqp

@@ -530,7 +530,7 @@ class QRegex::P6Regex::Actions is HLL::Actions {
         my $qast;
         my $name := ~$<identifier>;
         if $name eq 'c' {
-            # codepoint boundaries alway match in
+            # codepoint boundaries always match in
             # our current Unicode abstraction level
             $qast := 0;
         }

src/core/NQPRoutine.nqp

@@ -235,7 +235,7 @@ my knowhow NQPRoutine {
         # Initialize dispatcher state.
         my @possibles;
 
-        # Go thorugh candidates.
+        # Go through candidates.
         my int $type_mismatch;
         my int $type_check_count;
         my int $i;
@@ -260,13 +260,13 @@ my knowhow NQPRoutine {
                 }
             }
 
-            # Check if it's admissable by arity.
+            # Check if it's admissible by arity.
             if $num_args < $cur_candidate<min_arity> || $num_args > $cur_candidate<max_arity> {
                 $cur_idx++;
                 next;
             }
 
-            # Check if it's admissable by type.
+            # Check if it's admissible by type.
             $type_check_count := $cur_candidate<num_types> > $num_args
                              ?? $num_args
                              !! $cur_candidate<num_types>;
@@ -297,7 +297,7 @@ my knowhow NQPRoutine {
                 next;
             }
 
-            # If we get here, it's an admissable candidate; add to list. */
+            # If we get here, it's an admissible candidate; add to list. */
             nqp::push(@possibles, $cur_candidate);
             $cur_idx++;
         }

src/how/NQPClassHOW.nqp

@@ -336,7 +336,7 @@ knowhow NQPClassHOW {
             if nqp::elems(@immediate_parents) == 1 {
                 @result := compute_c3_mro(@immediate_parents[0]);
             } else {
-                # Build merge list of lineraizations of all our parents, add
+                # Build merge list of linearizations of all our parents, add
                 # immediate parents and merge.
                 my @merge_list;
                 for @immediate_parents {

src/vm/js/Compiler.nqp

@@ -293,7 +293,7 @@ class QAST::CompilerJS does DWIMYNameMangling does SerializeOnce {
         0;
     }
 
-    # turns a list of arguments for a call into a js code according to our most generall calling convention
+    # turns a list of arguments for a call into a js code according to our most general calling convention
     # $args is the list of QAST::Node arguments
     # returns a Chunk containing either a comma separated list of arguments or an expression that evaluates to a array of arguments
 
@@ -627,7 +627,7 @@ class QAST::CompilerJS does DWIMYNameMangling does SerializeOnce {
     }
 
 
-    # It's more usefull for me during this development to emit partial code instead of quiting
+    # It's more useful for me during this development to emit partial code instead of quitting
     method NYI($msg) {
         if $!nyi eq 'ignore' {
         }
@@ -1424,7 +1424,7 @@ class QAST::CompilerJS does DWIMYNameMangling does SerializeOnce {
 
         my @pre;
         {
-            # We create this context so that dependecies are loaded relative to this file
+            # We create this context so that dependencies are loaded relative to this file
             my $*CTX := 'ctxWithPath';
             @pre.push(
                 "var ctxWithPath = new nqp.Ctx(null, null, null, null);\n"

src/vm/js/Operations.nqp

@@ -717,7 +717,7 @@ class QAST::OperationsJS {
 
     add_simple_op('settypefinalize', $T_VOID, [$T_OBJ, $T_INT]);
 
-    # TODO - implement and bechmark different ways of preventing the try/catch from murdering performance 
+    # TODO - implement and benchmark different ways of preventing the try/catch from murdering performance 
     add_op('handle', :!inlinable, sub ($comp, $node, :$want, :$cps) {
         # TODO CPS
         my @children := nqp::clone($node.list());

src/vm/jvm/QAST/Compiler.nqp

@@ -896,7 +896,7 @@ for <if unless with without> -> $op_name {
             }
         }
 
-        # Add final label and load result if neded.
+        # Add final label and load result if needed.
         $il.append($end_lbl);
         if $res_temp {
             $il.append(JAST::Instruction.new( :op(load_ins($res_type)), $res_temp ));
@@ -1447,7 +1447,7 @@ my $call_codegen := sub ($qastcomp, $node) {
         # Ensure we have a thing to invoke.
         nqp::die("A 'call' node must have a name or at least one child") unless +@($node) >= 1;
 
-        # Proces arguments, making sure first one is an object (since that is
+        # Process arguments, making sure first one is an object (since that is
         # the thing to invoke).
         my @argstuff := process_args_onto_stack($qastcomp, @($node), $il, :inv_first);
         my $cs_idx := @argstuff[0];
@@ -5073,7 +5073,7 @@ class QAST::CompilerJAST {
         $il.append($LCMP);
         $il.append(JAST::Instruction.new( :op('ifgt'), %*REG<fail> ));
 
-        # Compile the regex body itself; if we make it thorugh it, we go to
+        # Compile the regex body itself; if we make it through it, we go to
         # the end and are finished.
         $il.append(self.regex_jast($node));
         $il.append(JAST::Instruction.new( :op('goto'), $endlabel ));
@@ -5209,7 +5209,7 @@ class QAST::CompilerJAST {
         $*STACK.obtain($il, $fail_res);
         $il.append($POP);
 
-        # Evaluate to the curosr.
+        # Evaluate to the cursor.
         $il.append($endlabel);
         $il.append(JAST::Instruction.new( :op('aload'), %*REG<cur> ));
         result($il, $RT_OBJ)

src/vm/moar/QAST/QASTCompilerMAST.nqp

@@ -995,7 +995,7 @@ my class MASTCompilerInstance {
                 # when we enter a QAST::Stmt, the contextual will be cloned, and the locals of
                 # newly declared QAST::Vars of local scope inside the Stmt will be stashed here,
                 # so they can be released at the end of the QAST::Stmt in which they were
-                # declared.  Inability to declare duplicate names is still enfoced, and types are
+                # declared.  Inability to declare duplicate names is still enforced, and types are
                 # still enforced.
                 my %*STMTTEMPS := nqp::hash();
                 my $*INSTMT := 0;

src/vm/moar/QAST/QASTOperationsMAST.nqp

@@ -208,7 +208,7 @@ class QAST::MASTOperations {
                 nqp::push(@release_kinds, $arg_kind);
             }
 
-            # put the arg exression's generation code in the instruction list
+            # put the arg expression's generation code in the instruction list
             nqp::splice(@all_ins, $arg.instructions, +@all_ins, 0)
                 unless $constant_operand;
             if @deconts[$arg_num] &&