Merge pull request scala#4559 from janekdb/2.11.x-scaladoc-2

Fix some typos (a-c)

Author: SethTisue

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

@@ -773,7 +773,7 @@ abstract class Inliners extends SubComponent {
 
         staleOut += block
 
-        tfa.remainingCALLs.remove(instr) // this bookkpeeping is done here and not in MTFAGrowable.reinit due to (1st) convenience and (2nd) necessity.
+        tfa.remainingCALLs.remove(instr) // this bookkeeping is done here and not in MTFAGrowable.reinit due to (1st) convenience and (2nd) necessity.
         tfa.isOnWatchlist.remove(instr)  // ditto
         tfa.warnIfInlineFails.remove(instr)
 

src/compiler/scala/tools/nsc/classpath/ZipAndJarFileLookupFactory.scala

@@ -61,7 +61,7 @@ object ZipAndJarFlatClassPathFactory extends ZipAndJarFileLookupFactory {
   }
 
   /**
-   * This type of classpath is closly related to the support for JSR-223.
+   * This type of classpath is closely related to the support for JSR-223.
    * Its usage can be observed e.g. when running:
    * jrunscript -classpath scala-compiler.jar;scala-reflect.jar;scala-library.jar -l scala
    * with a particularly prepared scala-library.jar. It should have all classes listed in the manifest like e.g. this entry:

src/compiler/scala/tools/nsc/symtab/SymbolLoaders.scala

@@ -373,7 +373,7 @@ abstract class SymbolLoaders {
     protected def doComplete(root: Symbol) { root.sourceModule.initialize }
   }
 
-  /** used from classfile parser to avoid cyclies */
+  /** used from classfile parser to avoid cycles */
   var parentsLevel = 0
   var pendingLoadActions: List[() => Unit] = Nil
 }

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

@@ -248,7 +248,7 @@ trait MatchTranslation {
       if (caseDefs forall treeInfo.isCatchCase) caseDefs
       else {
         val swatches = { // switch-catches
-          // SI-7459 must duplicate here as we haven't commited to switch emission, and just figuring out
+          // SI-7459 must duplicate here as we haven't committed to switch emission, and just figuring out
           //         if we can ends up mutating `caseDefs` down in the use of `substituteSymbols` in
           //         `TypedSubstitution#Substitution`. That is called indirectly by `emitTypeSwitch`.
           val bindersAndCases = caseDefs.map(_.duplicate) map { caseDef =>

src/compiler/scala/tools/nsc/typechecker/Typers.scala

@@ -4443,7 +4443,7 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper
         def onError(typeErrors: Seq[AbsTypeError], warnings: Seq[(Position, String)]): Tree = {
           if (Statistics.canEnable) Statistics.stopTimer(failedApplyNanos, start)
 
-          // If the problem is with raw types, copnvert to existentials and try again.
+          // If the problem is with raw types, convert to existentials and try again.
           // See #4712 for a case where this situation arises,
           if ((fun.symbol ne null) && fun.symbol.isJavaDefined) {
             val newtpe = rawToExistential(fun.tpe)
@@ -4988,7 +4988,7 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper
               TypeTreeWithDeferredRefCheck(){ () =>
                 // wrap the tree and include the bounds check -- refchecks will perform this check (that the beta reduction was indeed allowed) and unwrap
                 // we can't simply use original in refchecks because it does not contains types
-                // (and the only typed trees we have have been mangled so they're not quite the original tree anymore)
+                // (and the only typed trees we have been mangled so they're not quite the original tree anymore)
                 checkBounds(result, tpt1.tpe.prefix, tpt1.symbol.owner, tpt1.symbol.typeParams, argtypes, "")
                 result // you only get to see the wrapped tree after running this check :-p
               } setType (result.tpe) setPos(result.pos)

src/reflect/scala/reflect/internal/AnnotationCheckers.scala

@@ -60,7 +60,7 @@ trait AnnotationCheckers {
      * mode (see method adapt in trait Typers).
      *
      * An implementation cannot rely on canAdaptAnnotations being called before. If the implementing
-     * class cannot do the adaptiong, it should return the tree unchanged.
+     * class cannot do the adapting, it should return the tree unchanged.
      */
     @deprecated("Create an AnalyzerPlugin and use adaptAnnotations", "2.10.1")
     def adaptAnnotations(tree: Tree, mode: Mode, pt: Type): Tree = tree

src/reflect/scala/reflect/internal/Symbols.scala

@@ -987,7 +987,7 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
           || isLocalToBlock
          )
     )
-    /** Is this symbol effectively final or a concrete term member of sealed class whose childred do not override it */
+    /** Is this symbol effectively final or a concrete term member of sealed class whose children do not override it */
     final def isEffectivelyFinalOrNotOverridden: Boolean = isEffectivelyFinal || (isTerm && !isDeferred && isNotOverridden)
 
     /** Is this symbol owned by a package? */

src/scaladoc/scala/tools/nsc/doc/Settings.scala

@@ -143,7 +143,7 @@ class Settings(error: String => Unit, val printMsg: String => Unit = println(_))
     "dot" // by default, just pick up the system-wide dot
   )
 
-  /** The maxium nuber of normal classes to show in the diagram */
+  /** The maximum number of normal classes to show in the diagram */
   val docDiagramsMaxNormalClasses = IntSetting(
     "-diagrams-max-classes",
     "The maximum number of superclasses or subclasses to show in a diagram",
@@ -152,7 +152,7 @@ class Settings(error: String => Unit, val printMsg: String => Unit = println(_))
     _ => None
   )
 
-  /** The maxium nuber of implcit classes to show in the diagram */
+  /** The maximum number of implicit classes to show in the diagram */
   val docDiagramsMaxImplicitClasses = IntSetting(
     "-diagrams-max-implicits",
     "The maximum number of implicitly converted classes to show in a diagram",

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

@@ -298,7 +298,7 @@ trait DocTemplateEntity extends MemberTemplateEntity {
   /** The shadowing information for the implicitly added members */
   def implicitsShadowing: Map[MemberEntity, ImplicitMemberShadowing]
 
-  /** Classes that can be implcitly converted to this class */
+  /** Classes that can be implicitly converted to this class */
   def incomingImplicitlyConvertedClasses: List[(DocTemplateEntity, ImplicitConversion)]
 
   /** Classes to which this class can be implicitly converted to
@@ -484,10 +484,10 @@ trait ImplicitConversion {
   /** The entity for the method that performed the conversion, if it's documented (or just its name, otherwise) */
   def convertorMethod: Either[MemberEntity, String]
 
-  /** A short name of the convertion */
+  /** A short name of the conversion */
   def conversionShortName: String
 
-  /** A qualified name uniquely identifying the convertion (currently: the conversion method's qualified name) */
+  /** A qualified name uniquely identifying the conversion (currently: the conversion method's qualified name) */
   def conversionQualifiedName: String
 
   /** The entity that performed the conversion */

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

@@ -400,7 +400,7 @@ trait ModelFactoryImplicitSupport {
 
     def isHiddenConversion = settings.hiddenImplicits(conversionQualifiedName)
 
-    override def toString = "Implcit conversion from " + sym.tpe + " to " + toType + " done by " + convSym
+    override def toString = "Implicit conversion from " + sym.tpe + " to " + toType + " done by " + convSym
   }
 
   /* ========================= HELPER METHODS ========================== */
@@ -479,7 +479,7 @@ trait ModelFactoryImplicitSupport {
     }
 
   /**
-   *  Make implicits explicit - Not used curently
+   *  Make implicits explicit - Not used currently
    */
   // object implicitToExplicit extends TypeMap {
   //   def apply(tp: Type): Type = mapOver(tp) match {
@@ -561,7 +561,7 @@ trait ModelFactoryImplicitSupport {
    *
    * The trick here is that the resultType does not matter - the condition for removal it that paramss have the same
    * structure (A => B => C may not override (A, B) => C) and that all the types involved are
-   * of the implcit conversion's member are subtypes of the parent members' parameters */
+   * of the implicit conversion's member are subtypes of the parent members' parameters */
   def isDistinguishableFrom(t1: Type, t2: Type): Boolean = {
     // Vlad: I tried using matches but it's not exactly what we need:
     // (p: AnyRef)AnyRef matches ((t: String)AnyRef returns false -- but we want that to be true

src/scaladoc/scala/tools/nsc/doc/model/diagram/DiagramFactory.scala

@@ -51,7 +51,7 @@ trait DiagramFactory extends DiagramDirectiveParser {
             case p: (TemplateEntity, TypeEntity) if !classExcluded(p._1) => NormalNode(p._2, Some(p._1))()
           }.reverse
 
-        // incoming implcit conversions
+        // incoming implicit conversions
         lazy val incomingImplicitNodes = tpl.incomingImplicitlyConvertedClasses.map {
           case (incomingTpl, conv) =>
             ImplicitNode(makeType(incomingTpl.sym.tpe, tpl), Some(incomingTpl))(implicitTooltip(from=incomingTpl, to=tpl, conv=conv))

test/files/jvm/bytecode-test-example/Test.scala

@@ -17,7 +17,7 @@ object Test extends BytecodeTest {
   def countNullChecks(insnList: InsnList): Int = {
     /** Is given instruction a null check?
      *  NOTE
-     *   This will detect direct null compparsion as in
+     *   This will detect direct null comparison as in
      *    if (x == null) ...
      *   and not indirect as in
      *     val foo = null

test/files/jvm/t7006/Foo_1.scala

@@ -5,6 +5,6 @@ class Foo_1 {
     } finally {
       print("hello")
     }
-    while(true){} // ensure infinite loop doesn't break the algoirthm
+    while(true){} // ensure infinite loop doesn't break the algorithm
   }
 }

test/files/neg/names-defaults-neg.check

@@ -64,7 +64,7 @@ names-defaults-neg.scala:49: error: ambiguous reference to overloaded definition
 both method g in object t7 of type (a: B)String
 and  method g in object t7 of type (a: C, b: Int*)String
 match argument types (C)
-  t7.g(new C()) // ambigous reference
+  t7.g(new C()) // ambiguous reference
      ^
 names-defaults-neg.scala:53: error: parameter 'b' is already specified at parameter position 2
   test5(a = 1, b = "dkjl", b = "dkj")
@@ -79,7 +79,7 @@ names-defaults-neg.scala:61: error: ambiguous reference to overloaded definition
 both method f in object t8 of type (b: String, a: Int)String
 and  method f in object t8 of type (a: Int, b: Object)String
 match argument types (a: Int,b: String) and expected result type Any
-  println(t8.f(a = 0, b = "1")) // ambigous reference
+  println(t8.f(a = 0, b = "1")) // ambiguous reference
              ^
 names-defaults-neg.scala:69: error: wrong number of arguments for pattern A1(x: Int,y: String)
   A1() match { case A1(_) => () }

test/files/neg/names-defaults-neg.scala

@@ -46,7 +46,7 @@ object Test extends App {
     def g(a: C, b: Int*) = "third"
     def g(a: B) = "fourth"
   }
-  t7.g(new C()) // ambigous reference
+  t7.g(new C()) // ambiguous reference
 
   // vararg
   def test5(a: Int, b: String*) = a
@@ -58,7 +58,7 @@ object Test extends App {
     def f(a: Int, b: Object) = "first"
     def f(b: String, a: Int) = "second"
   }
-  println(t8.f(a = 0, b = "1")) // ambigous reference
+  println(t8.f(a = 0, b = "1")) // ambiguous reference
 
 
   // case class copy does not exist if there's a vararg

test/files/neg/t2866.check

@@ -5,7 +5,7 @@ t2866.scala:42: error: ambiguous implicit values:
  both value two of type Int
  and value one in object A of type => Int
  match expected type Int
-    assert(implicitly[Int] == 2) // !!! Not ambiguous in 2.8.0. Ambigous in 2.7.6
+    assert(implicitly[Int] == 2) // !!! Not ambiguous in 2.8.0. Ambiguous in 2.7.6
                      ^
 t2866.scala:50: error: ambiguous implicit values:
  both value two of type Int

test/files/neg/t2866.scala

@@ -39,7 +39,7 @@ object Test {
     import A.one
     assert(implicitly[Int] == 1)
     implicit val two = 2
-    assert(implicitly[Int] == 2) // !!! Not ambiguous in 2.8.0. Ambigous in 2.7.6
+    assert(implicitly[Int] == 2) // !!! Not ambiguous in 2.8.0. Ambiguous in 2.7.6
   }
 
   locally {

test/files/pos/t6575b.scala

@@ -1,5 +1,5 @@
 // inferred types were okay here as Function nodes aren't
-// translated into anoymous subclasses of AbstractFunctionN
+// translated into anonymous subclasses of AbstractFunctionN
 // until after the typer.
 //
 // So this test is just confirmation.

test/files/pos/t6648.scala

@@ -10,7 +10,7 @@ class Transformer {
 }
 
 object transformer1 extends Transformer {
-  // Adding explicit type arguments, or making the impilcit view
+  // Adding explicit type arguments, or making the implicit view
   // seqToNodeSeq explicit avoids the crash
   NodeSeq.foo {
     // These both avoid the crash:

test/files/run/t6502.scala

@@ -123,7 +123,7 @@ object Test extends StoreReporterDirectTest {
   }
 
   def test6(): Unit = {
-    // Avoid java.lang.NoClassDefFoundError triggered by the old appoach of using a Java
+    // Avoid java.lang.NoClassDefFoundError triggered by the old approach of using a Java
     // classloader to parse .class files in order to read their names.
     val jar = "test6.jar"
     compileCode(app6, jar)

test/pending/pos/t1786.scala

@@ -1,5 +1,5 @@
 /** This a consequence of the current type checking algorithm, where bounds are checked only after variables are instantiated.
- * I believe this will change once we go to contraint-based type inference.
+ * I believe this will change once we go to constraint-based type inference.
  * Alternatively, we can pursue a more extensive fix to SI-6169
  *
  * The below code shows a compiler flaw in that the wildcard "_" as value for a bounded type parameter either

test/pending/run/idempotency-partial-functions.scala

@@ -6,7 +6,7 @@ import scala.tools.reflect.Eval
 // Related to SI-6187
 //
 // Moved to pending as we are currently blocked by the inability
-// to reify the parent types of the anoymous function class,
+// to reify the parent types of the anonymous function class,
 // which are not part of the tree, but rather only part of the
 // ClassInfoType.
 object Test extends App {

test/scaladoc/resources/implicits-base-res.scala

@@ -52,7 +52,7 @@ object A {
  * def convToGtColonDoubleA(x: Double)      // enrichA3: no constraints
  * def convToManifestA(x: Double)           // enrichA7: no constraints
  * def convToMyNumericA(x: Double)          // enrichA6: (if showAll is set) with a constraint that there is x: MyNumeric[Double] implicit in scope
- * def convToNumericA(x: Double)            // enrichA1: no constraintsd
+ * def convToNumericA(x: Double)            // enrichA1: no constraints
  * def convToEnrichedA(x: Bar[Foo[Double]]) // enrichA5: no constraints, SHADOWED
  * def convToEnrichedA(x: Double)           // enrichA0: no constraints, SHADOWED
  * def convToTraversableOps(x: Double)      // enrichA7: no constraints

test/scaladoc/run/implicits-base.scala

@@ -94,7 +94,7 @@ object Test extends ScaladocModelTest {
     assert(isShadowed(conv._member("convToEnrichedA")))
     assert(conv._member("convToEnrichedA").resultType.name == "Double")
 
-    // def convToNumericA: Double          // enrichA1: no constraintsd
+    // def convToNumericA: Double          // enrichA1: no constraints
     conv = B._conversion(A.qualifiedName + ".enrichA1")
     assert(conv.members.length == 1)
     assert(conv.constraints.length == 0)

test/scaladoc/scalacheck/HtmlFactoryTest.scala

@@ -711,7 +711,7 @@ object Test extends Properties("HtmlFactory") {
 
     property("class") = files.get("com/example/p1/Clazz.html") match {
       case Some(node: scala.xml.Node) => {
-        property("implicit convertion") =
+        property("implicit conversion") =
           node.toString contains "<span class=\"modifier\">implicit </span>"
 
         property("gt4s") =