Merge pull request scala#4571 from janekdb/2.11.x-typos-d-f

Fix 36 typos (d-f)

Author: SethTisue

src/compiler/scala/reflect/quasiquotes/Holes.scala

@@ -151,7 +151,7 @@ trait Holes { self: Quasiquotes =>
         else None
     }
 
-    /** Map high-rank unquotee onto an expression that eveluates as a list of given rank.
+    /** Map high-rank unquotee onto an expression that evaluates as a list of given rank.
      *
      *  All possible combinations of representations are given in the table below:
      *

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

@@ -226,7 +226,7 @@ trait PhaseAssembly {
   }
 
   /** Given the phases set, will build a dependency graph from the phases set
-   *  Using the aux. method of the DependencyGraph to create nodes and egdes.
+   *  Using the aux. method of the DependencyGraph to create nodes and edges.
    */
   private def phasesSetToDepGraph(phsSet: mutable.HashSet[SubComponent]): DependencyGraph = {
     val graph = new DependencyGraph()

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

@@ -1022,7 +1022,7 @@ abstract class GenICode extends SubComponent {
         tree match {
           case Literal(Constant(null)) if generatedType == NullReference && expectedType != UNIT =>
             // literal null on the stack (as opposed to a boxed null, see SI-8233),
-            // we can bypass `adapt` which would otherwise emitt a redundant [DROP, CONSTANT(null)]
+            // we can bypass `adapt` which would otherwise emit a redundant [DROP, CONSTANT(null)]
             // except one case: when expected type is UNIT (unboxed) where we need to emit just a DROP
           case _ =>
             adapt(generatedType, expectedType, resCtx, tree.pos)
@@ -2108,7 +2108,7 @@ abstract class GenICode extends SubComponent {
     /**
      * Represent a label in the current method code. In order
      * to support forward jumps, labels can be created without
-     * having a deisgnated target block. They can later be attached
+     * having a designated target block. They can later be attached
      * by calling `anchor`.
      */
     class Label(val symbol: Symbol) {

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

@@ -387,7 +387,7 @@ abstract class TypeFlowAnalysis {
 
       Moreover, it's often the case that the last CALL_METHOD of interest ("of interest" equates to "being tracked in `isOnWatchlist`) isn't the last instruction on the block.
       There are cases where the typeflows computed past this `lastInstruction` are needed, and cases when they aren't.
-      The reasoning behind this decsision is described in `populatePerimeter()`. All `blockTransfer()` needs to do (in order to know at which instruction it can stop)
+      The reasoning behind this decision is described in `populatePerimeter()`. All `blockTransfer()` needs to do (in order to know at which instruction it can stop)
       is querying `isOnPerimeter`.
 
       Upon visiting a CALL_METHOD that's an inlining candidate, the relevant pieces of information about the pre-instruction typestack are collected for future use.

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

@@ -90,7 +90,7 @@ abstract class BCodeSkelBuilder extends BCodeHelpers {
 
     override def getCurrentCUnit(): CompilationUnit = { cunit }
 
-    /* ---------------- helper utils for generating classes and fiels ---------------- */
+    /* ---------------- helper utils for generating classes and fields ---------------- */
 
     def genPlainClass(cd: ClassDef) {
       assert(cnode == null, "GenBCode detected nested methods.")

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

@@ -322,7 +322,7 @@ class BTypesFromSymbols[G <: Global](val global: G) extends BTypes {
         val javaCompatMembers = {
           if (linkedClass != NoSymbol && isTopLevelModuleClass(linkedClass))
           // phase travel to exitingPickler: this makes sure that memberClassesForInnerClassTable only sees member
-          // classes, not local classes of the companion module (E in the exmaple) that were lifted by lambdalift.
+          // classes, not local classes of the companion module (E in the example) that were lifted by lambdalift.
             exitingPickler(memberClassesForInnerClassTable(linkedClass))
           else
             Nil

src/compiler/scala/tools/nsc/backend/jvm/opt/ByteCodeRepository.scala

@@ -127,7 +127,7 @@ class ByteCodeRepository(val classPath: ClassFileLookup[AbstractFile], val isJav
       case Nil     => Left(failedClasses)
     }
 
-    // In a MethodInsnNode, the `owner` field may be an array descriptor, for exmple when invoking `clone`. We don't have a method node to return in this case.
+    // In a MethodInsnNode, the `owner` field may be an array descriptor, for example when invoking `clone`. We don't have a method node to return in this case.
     if (ownerInternalNameOrArrayDescriptor.charAt(0) == '[')
       Left(MethodNotFound(name, descriptor, ownerInternalNameOrArrayDescriptor, Nil))
     else

src/compiler/scala/tools/nsc/backend/jvm/opt/LocalOpt.scala

@@ -262,7 +262,7 @@ object LocalOptImpls {
    * the same index, but distinct start / end ranges are different variables, they may have not the
    * same type or name.
    */
-  def removeUnusedLocalVariableNodes(method: MethodNode)(fistLocalIndex: Int = parametersSize(method), renumber: Int => Int = identity): Boolean = {
+  def removeUnusedLocalVariableNodes(method: MethodNode)(firstLocalIndex: Int = parametersSize(method), renumber: Int => Int = identity): Boolean = {
     def variableIsUsed(start: AbstractInsnNode, end: LabelNode, varIndex: Int): Boolean = {
       start != end && (start match {
         case v: VarInsnNode if v.`var` == varIndex => true
@@ -276,7 +276,7 @@ object LocalOptImpls {
       val local = localsIter.next()
       val index = local.index
       // parameters and `this` (the lowest indices, starting at 0) are never removed or renumbered
-      if (index >= fistLocalIndex) {
+      if (index >= firstLocalIndex) {
         if (!variableIsUsed(local.start, local.end, index)) localsIter.remove()
         else if (renumber(index) != index) local.index = renumber(index)
       }

src/compiler/scala/tools/nsc/settings/ScalaSettings.scala

@@ -76,7 +76,7 @@ trait ScalaSettings extends AbsScalaSettings
     val implicitConversions = Choice("implicitConversions", "Allow definition of implicit functions called views")
     val higherKinds         = Choice("higherKinds",         "Allow higher-kinded types")
     val existentials        = Choice("existentials",        "Existential types (besides wildcard types) can be written and inferred")
-    val macros              = Choice("experimental.macros", "Allow macro defintion (besides implementation and application)")
+    val macros              = Choice("experimental.macros", "Allow macro definition (besides implementation and application)")
   }
   val language      = {
     val description = "Enable or disable language features"

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

@@ -444,7 +444,7 @@ abstract class Delambdafy extends Transform with TypingTransformers with ast.Tre
       def adaptAndPostErase(tree: Tree, pt: Type): (Boolean, Tree) = {
         val (needsAdapt, adaptedTree) = adapt(tree, pt)
         val trans = postErasure.newTransformer(unit)
-        val postErasedTree = trans.atOwner(currentOwner)(trans.transform(adaptedTree)) // SI-8017 elimnates ErasedValueTypes
+        val postErasedTree = trans.atOwner(currentOwner)(trans.transform(adaptedTree)) // SI-8017 eliminates ErasedValueTypes
         (needsAdapt, postErasedTree)
       }
 

src/compiler/scala/tools/nsc/transform/patmat/Logic.scala

@@ -510,7 +510,7 @@ trait ScalaLogic extends Interface with Logic with TreeAndTypeAnalysis {
       def propForEqualsTo(c: Const): Prop = {observed(); symForEqualsTo.getOrElse(c, False)}
 
       // [implementation NOTE: don't access until all potential equalities have been registered using registerEquality]p
-      /** the information needed to construct the boolean proposition that encods the equality proposition (V = C)
+      /** the information needed to construct the boolean proposition that encodes the equality proposition (V = C)
        *
        * that models a type test pattern `_: C` or constant pattern `C`, where the type test gives rise to a TypeConst C,
        * and the constant pattern yields a ValueConst C

src/compiler/scala/tools/nsc/transform/patmat/MatchTreeMaking.scala

@@ -642,7 +642,7 @@ trait MatchTreeMaking extends MatchCodeGen with Debugging {
       }
 
       // override def apply
-      // debug.patmat("before fixerupper: "+ xTree)
+      // debug.patmat("before fixerUpper: "+ xTree)
       // currentRun.trackerFactory.snapshot()
       // debug.patmat("after fixerupper")
       // currentRun.trackerFactory.snapshot()

src/library/scala/collection/immutable/Stream.scala

@@ -153,7 +153,7 @@ import scala.language.implicitConversions
  *
  *  - The fact that `tail` works at all is of interest.  In the definition of
  *  `fibs` we have an initial `(0, 1, Stream(...))` so `tail` is deterministic.
- *  If we deinfed `fibs` such that only `0` were concretely known then the act
+ *  If we defined `fibs` such that only `0` were concretely known then the act
  *  of determining `tail` would require the evaluation of `tail` which would
  *  cause an infinite recursion and stack overflow.  If we define a definition
  *  where the tail is not initially computable then we're going to have an

src/reflect/scala/reflect/internal/ReificationSupport.scala

@@ -802,7 +802,7 @@ trait ReificationSupport { self: SymbolTable =>
       require(enums.nonEmpty, "enumerators can't be empty")
       enums.head match {
         case SyntacticValFrom(_, _) =>
-        case t => throw new IllegalArgumentException(s"$t is not a valid fist enumerator of for loop")
+        case t => throw new IllegalArgumentException(s"$t is not a valid first enumerator of for loop")
       }
       enums.tail.foreach {
         case SyntacticValEq(_, _) | SyntacticValFrom(_, _) | SyntacticFilter(_) =>

src/scaladoc/scala/tools/nsc/doc/html/page/diagram/DotDiagramGenerator.scala

@@ -383,7 +383,7 @@ class DotDiagramGenerator(settings: doc.Settings, dotRunner: DotRunner) extends
       if (dotId.count(_ == '|') == 1) {
         val Array(klass, id) = dotId.toString.split("\\|")
         /* Sometimes dot "forgets" to add the image -- that's very annoying, but it seems pretty random, and simple
-         * tests like excute 20K times and diff the output don't trigger the bug -- so it's up to us to place the image
+         * tests like execute 20K times and diff the output don't trigger the bug -- so it's up to us to place the image
          * back in the node */
         val kind = getKind(klass)
         if (kind != "")

src/scaladoc/scala/tools/nsc/doc/model/ModelFactory.scala

@@ -478,7 +478,7 @@ class ModelFactory(val global: Global, val settings: doc.Settings) {
     override lazy val comment = {
       def nonRootTemplate(sym: Symbol): Option[DocTemplateImpl] =
         if (sym eq RootPackage) None else findTemplateMaybe(sym)
-      /* Variable precendence order for implicitly added members: Take the variable defifinitions from ...
+      /* Variable precendence order for implicitly added members: Take the variable definitions from ...
        * 1. the target of the implicit conversion
        * 2. the definition template (owner)
        * 3. the current template

test/files/jvm/unreachable/Test.scala

@@ -6,7 +6,7 @@ import scala.collection.JavaConverters._
 object Test extends BytecodeTest {
   def show: Unit = {
     val classNode = loadClassNode("Foo_1")
-    // Foo_1 is full of unreachable code which if not elimintated
+    // Foo_1 is full of unreachable code which if not eliminated
     // will result in NOPs as can be confirmed by adding -Ydisable-unreachable-prevention
     // to Foo_1.flags
     for (methodNode <- classNode.methods.asScala) {

test/files/neg/t3995.scala

@@ -27,6 +27,6 @@ object Test {
   // can be accessed with unambiguous stable prefixes, the implicits infos
   // which are members of these companion objects."
   //
-  // The skolem is stable, but it doen't seem much good to us
+  // The skolem is stable, but it does not seem much good to us
   (new Lift).apply("")
 }

test/files/neg/t8237-default.scala

@@ -1,4 +1,4 @@
-// This test case was extracte from `names-defaults-neg.scala`
+// This test case was extracted from `names-defaults-neg.scala`
 // It pinpoints an improvement an error message that results from
 // a type inference failure
 object Test extends App {

test/files/neg/t8463.scala

@@ -7,7 +7,7 @@ object Test {
 
 /* If SI-8230 is fixed, and `viewExists` is changed to no longer leak
    ambiguity errors, you might expect the check file for this test to
-   change as folloes:
+   change as follows:
 
 @@ -1,18 +1,10 @@
 -t8463.scala:5: error: no type parameters for method apply: (activity:

test/files/pos/SI-4012-b.scala

@@ -6,7 +6,7 @@ object Sub extends Super[Int] {
   // it is expected that super[Super].superb crashes, since 
   // specialization does parent class rewiring, and the super
   // of Sub becomes Super$mcII$sp and not Super. But I consider
-  // this normal behavior -- if you want, I can modify duplicatiors
+  // this normal behavior -- if you want, I can modify duplicators
   // to make this work, but I consider it's best to keep this
   // let the user know Super is not the superclass anymore.
   // super[Super].superb - Vlad

test/files/pos/delambdafy-patterns.scala

@@ -2,7 +2,7 @@ class DelambdafyPatterns {
   def bar: Unit = ()
   def wildcardPatternInTryCatch: Unit => Unit = (x: Unit) =>
     // patterns in try..catch are preserved so we need to be
-    // careful when it comes to free variable detction
+    // careful when it comes to free variable detection
     // in particular a is _not_ free variable, also the
     // `_` identifier has no symbol attached to it
     try bar catch {

test/files/pos/t7200b.scala

@@ -10,7 +10,7 @@ trait Foo {
 object O extends Foo {
   def coflatMap[A <: T](f: A) = {
     val f2 = coflatMap(f) // inferred in 2.9.2 / 2.10.0 as [Nothing]
-    f2.t                  // so this does't type check.
+    f2.t                  // so this fails to type check.
     f2
   }
 }

test/files/run/deeps.scala

@@ -3,7 +3,7 @@
 //############################################################################
 
 //############################################################################
-// need to revisit array equqality
+// need to revisit array equality
 object Test {
 
   def testEquals1 {

test/files/run/finally.scala

@@ -93,7 +93,7 @@ object Test extends App {
     }
   }
 
-  // nested finallies with return value
+  // nested finally blocks with return value
   def nestedFinalies: Int =
     try {
       try {

test/files/run/iq.scala

@@ -69,7 +69,7 @@ object iq {
     val (_, q7) = q6.dequeue
     //val q8 = q7 + 10 + 11  //deprecated
     val q8 = q7.enqueue(10).enqueue(11)
-    /* Test dequeu
+    /* Test dequeue
      * Expected: q8: Queue(2,3,4,5,6,7,8,9,10,11)
      */
     Console.println("q8: " + q8)

test/files/run/names-defaults.scala

@@ -86,7 +86,7 @@ object Test extends App {
     def f(a: Object) = "first"
     val f: String => String = a => "second"
   }
-  println(t5.f(new Sub1())) // firsst
+  println(t5.f(new Sub1())) // first
   println(t5.f("dfklj"))    // second
 
   object t6 {

test/files/run/nullable-lazyvals.scala

@@ -24,7 +24,7 @@ object Test extends App {
 
 	// test that try-finally does not generated a liftedTry
 	// helper. This would already fail the first part of the test,
-	// but this check will help diganose it (if the single access to a
+	// but this check will help diagnose it (if the single access to a
 	// private field does not happen directly in the lazy val, it won't
 	// be nulled).
 	for (f <- foo.getClass.getDeclaredMethods) {

test/files/run/t6240-universe-code-gen.scala

@@ -13,8 +13,8 @@ object Test extends App {
           (sym.isMethod && sym.asMethod.isLazy)
        || sym.isModule
     )
-    val forcables = tp.members.sorted.filter(isLazyAccessorOrObject)
-    forcables.map {
+    val forceables = tp.members.sorted.filter(isLazyAccessorOrObject)
+    forceables.map {
       sym =>
         val path = s"$prefix.${sym.name}"
         "    " + (

test/files/run/t8601-closure-elim.scala

@@ -11,7 +11,7 @@ object Test extends BytecodeTest {
       val classNode = loadClassNode("Foo")
       val methodNode = getMethod(classNode, "b")
       val ops = methodNode.instructions.iterator.asScala.map(_.getOpcode).toList
-      assert(!ops.contains(asm.Opcodes.NEW), ops)// should be allocation free if the closure is eliminiated
+      assert(!ops.contains(asm.Opcodes.NEW), ops)// should be allocation free if the closure is eliminated
     }
     test("b")
   }

test/files/run/t8708_b/Test_2.scala

@@ -13,7 +13,7 @@ object Test extends DirectTest {
       val c = g.rootMirror.getRequiredClass("p.C")
       println(c.info.decls)
       val t = c.info.member(g.newTypeName("T"))
-      // this test ensrues that the <local child> dummy class symbol is not entered in the
+      // this test ensures that the <local child> dummy class symbol is not entered in the
       // scope of trait T during unpickling.
       println(t.info.decls)
     })

test/files/specialized/constant_lambda.scala

@@ -1,4 +1,4 @@
-// during development of late delmabdafying there was a problem where
+// during development of late delambdafying there was a problem where
 // specialization would undo some of the work done in uncurry if the body of the
 // lambda had a constant type. That would result in a compiler crash as
 // when the delambdafy phase got a tree shape it didn't understand

test/scaladoc/run/groups.scala

@@ -38,7 +38,7 @@ object Test extends ScaladocModelTest {
            *  @groupdesc C Group C is introduced by B
            */
           trait B {
-            /** baz descriptopn
+            /** baz description
              *  @group C */
             def baz = 3
           }