Merge pull request scala#4461 from adriaanm/rebase-4446

Fix many typos

Author: adriaanm

src/compiler/scala/reflect/quasiquotes/Reifiers.scala

@@ -317,7 +317,7 @@ trait Reifiers { self: Quasiquotes =>
      *  Reification of non-trivial list is done in two steps:
      *
      *  1. split the list into groups where every placeholder is always
-     *     put in a group of it's own and all subsquent non-holeMap are
+     *     put in a group of its own and all subsquent non-holeMap are
      *     grouped together; element is considered to be a placeholder if it's
      *     in the domain of the fill function;
      *

src/compiler/scala/tools/nsc/PhaseAssembly.scala

@@ -127,7 +127,7 @@ trait PhaseAssembly {
     }
 
     /* Find all edges in the given graph that are hard links. For each hard link we
-     * need to check that its the only dependency. If not, then we will promote the
+     * need to check that it's the only dependency. If not, then we will promote the
      * other dependencies down
      */
     def validateAndEnforceHardlinks() {

src/compiler/scala/tools/nsc/ast/parser/Parsers.scala

@@ -1259,7 +1259,7 @@ self =>
         atPos(start) { Apply(t3, exprsBuf.toList) }
       }
       if (inPattern) stringCheese
-      else withPlaceholders(stringCheese, isAny = true) // strinterpolator params are Any* by definition
+      else withPlaceholders(stringCheese, isAny = true) // string interpolator params are Any* by definition
     }
 
 /* ------------- NEW LINES ------------------------------------------------- */

src/compiler/scala/tools/nsc/backend/icode/ICodeCheckers.scala

@@ -109,7 +109,7 @@ abstract class ICodeCheckers {
 
     /** Only called when m1 < m2, so already known that (m1 ne m2).
      */
-    private def isConfict(m1: IMember, m2: IMember, canOverload: Boolean) = (
+    private def isConflict(m1: IMember, m2: IMember, canOverload: Boolean) = (
       (m1.symbol.name == m2.symbol.name) &&
       (!canOverload || (m1.symbol.tpe =:= m2.symbol.tpe))
     )
@@ -119,11 +119,11 @@ abstract class ICodeCheckers {
       clasz = cls
 
       for (f1 <- cls.fields ; f2 <- cls.fields ; if f1 < f2)
-        if (isConfict(f1, f2, canOverload = false))
+        if (isConflict(f1, f2, canOverload = false))
           icodeError("Repetitive field name: " + f1.symbol.fullName)
 
       for (m1 <- cls.methods ; m2 <- cls.methods ; if m1 < m2)
-        if (isConfict(m1, m2, canOverload = true))
+        if (isConflict(m1, m2, canOverload = true))
           icodeError("Repetitive method: " + m1.symbol.fullName)
 
       clasz.methods foreach check
@@ -471,7 +471,7 @@ abstract class ICodeCheckers {
            pushStack(local.kind)
 
          case LOAD_FIELD(field, isStatic) =>
-           // the symbol's owner should contain it's field, but
+           // the symbol's owner should contain its field, but
            // this is already checked by the type checker, no need
            // to redo that here
            if (isStatic) ()

src/compiler/scala/tools/nsc/backend/icode/analysis/TypeFlowAnalysis.scala

@@ -572,7 +572,7 @@ abstract class TypeFlowAnalysis {
 
         - `inlined` : These blocks were spliced into the method's CFG as part of inlining. Being new blocks, they haven't been visited yet by the typeflow analysis.
 
-        - `staleIn` : These blocks are what `doInline()` calls `afterBlock`s, ie the new home for instructions that previously appearead
+        - `staleIn` : These blocks are what `doInline()` calls `afterBlock`s, ie the new home for instructions that previously appeared
                       after a callsite in a `staleOut` block.
 
       Based on the above information, we have to bring up-to-date the caches that `forwardAnalysis` and `blockTransfer` use to skip blocks and instructions.

src/compiler/scala/tools/nsc/backend/jvm/BTypes.scala

@@ -315,7 +315,7 @@ abstract class BTypes {
         case ArrayBType(component) =>
           if (other == ObjectReference || other == jlCloneableReference || other == jioSerializableReference) true
           else other match {
-            case ArrayBType(otherComponoent) => component.conformsTo(otherComponoent).orThrow
+            case ArrayBType(otherComponent) => component.conformsTo(otherComponent).orThrow
             case _ => false
           }
 

src/compiler/scala/tools/nsc/backend/opt/DeadCodeElimination.scala

@@ -173,7 +173,7 @@ abstract class DeadCodeElimination extends SubComponent {
               moveToWorkList()
 
             case LOAD_FIELD(sym, isStatic) if isStatic || !inliner.isClosureClass(sym.owner) =>
-              // static load may trigger static initization.
+              // static load may trigger static initialization.
               // non-static load can throw NPE (but we know closure fields can't be accessed via a
               // null reference.
               moveToWorkList()
@@ -191,7 +191,7 @@ abstract class DeadCodeElimination extends SubComponent {
                   case LOAD_EXCEPTION(_) | DUP(_) | LOAD_MODULE(_) => true
                   case _ =>
                     dropOf((bb1, idx1)) = (bb,idx) :: dropOf.getOrElse((bb1, idx1), Nil)
-                    debuglog("DROP is innessential: " + i + " because of: " + bb1(idx1) + " at " + bb1 + ":" + idx1)
+                    debuglog("DROP is inessential: " + i + " because of: " + bb1(idx1) + " at " + bb1 + ":" + idx1)
                     false
                 }
               }

src/compiler/scala/tools/nsc/transform/Constructors.scala

@@ -315,7 +315,7 @@ abstract class Constructors extends Statics with Transform with ast.TreeDSL {
     }
 
     def rewriteDelayedInit() {
-      /* XXX This is not corect: remainingConstrStats.nonEmpty excludes too much,
+      /* XXX This is not correct: remainingConstrStats.nonEmpty excludes too much,
        * but excluding it includes too much.  The constructor sequence being mimicked
        * needs to be reproduced with total fidelity.
        *

src/compiler/scala/tools/nsc/transform/Delambdafy.scala

@@ -77,7 +77,7 @@ abstract class Delambdafy extends Transform with TypingTransformers with ast.Tre
 
     // the result of the transformFunction method.
     sealed abstract class TransformedFunction
-    // A class definition for the lambda, an expression insantiating the lambda class
+    // A class definition for the lambda, an expression instantiating the lambda class
     case class DelambdafyAnonClass(lambdaClassDef: ClassDef, newExpr: Tree) extends TransformedFunction
 
     // here's the main entry point of the transform
@@ -86,7 +86,7 @@ abstract class Delambdafy extends Transform with TypingTransformers with ast.Tre
       case fun @ Function(_, _) =>
         transformFunction(fun) match {
           case DelambdafyAnonClass(lambdaClassDef, newExpr) =>
-            // a lambda beccomes a new class, an instantiation expression
+            // a lambda becomes a new class, an instantiation expression
             val pkg = lambdaClassDef.symbol.owner
 
             // we'll add the lambda class to the package later

src/compiler/scala/tools/nsc/transform/LazyVals.scala

@@ -219,7 +219,7 @@ abstract class LazyVals extends Transform with TypingTransformers with ast.TreeD
      *    l$
      *  } or
      *  <rhs> when the lazy value has type Unit (for which there is no field
-     *  to cache it's value.
+     *  to cache its value.
      *
      *  Similarly as for normal lazy val members (see Mixin), the result will be a tree of the form
      *  { if ((bitmap&n & MASK) == 0) this.l$compute()