Fix typos in compiler and reflect

Miscellania:

  Miscellania is a small island off the northernmost part
  of the Fremennik Isles - RunScape Wiki


Miscellanea:

  A collection of miscellaneous objects or writings - Merriam-Webster

15 files changed, 29 insertions, 28 deletions

diff --git a/src/compiler/scala/tools/nsc/backend/jvm/AsmUtils.scala b/src/compiler/scala/tools/nsc/backend/jvm/AsmUtils.scala
index 1982c7f643..402dc66a7f 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/AsmUtils.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/AsmUtils.scala
@@ -33,7 +33,7 @@ object AsmUtils {
   final val traceClassPattern = ""
 
   /**
-   * Print the bytedcode of classes as they are serialized by the ASM library. The serialization
+   * Print the bytecode of classes as they are serialized by the ASM library. The serialization
    * performed by `asm.ClassWriter` can change the code generated by GenBCode. For example, it
    * introduces stack map frames, it computes the maximal stack sizes, and it replaces dead
    * code by NOPs (see also https://github.com/scala/scala/pull/3726#issuecomment-42861780).
diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BCodeBodyBuilder.scala b/src/compiler/scala/tools/nsc/backend/jvm/BCodeBodyBuilder.scala
index c7952ffe94..76d042ce3b 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/BCodeBodyBuilder.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/BCodeBodyBuilder.scala
@@ -918,7 +918,7 @@ abstract class BCodeBodyBuilder extends BCodeSkelBuilder {
         (args zip params) filterNot isTrivial
       }
 
-      // first push *all* arguments. This makes sure muliple uses of the same labelDef-var will all denote the (previous) value.
+      // first push *all* arguments. This makes sure multiple uses of the same labelDef-var will all denote the (previous) value.
       aps foreach { case (arg, param) => genLoad(arg, locals(param).tk) } // `locals` is known to contain `param` because `genDefDef()` visited `labelDefsAtOrUnder`
 
       // second assign one by one to the LabelDef's variables.
diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BCodeHelpers.scala b/src/compiler/scala/tools/nsc/backend/jvm/BCodeHelpers.scala
index 18e7500172..a74c70a684 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/BCodeHelpers.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/BCodeHelpers.scala
@@ -188,7 +188,7 @@ abstract class BCodeHelpers extends BCodeIdiomatic with BytecodeWriters {
    * Data for emitting an EnclosingMethod attribute. None if `classSym` is a member class (not
    * an anonymous or local class). See doc in BTypes.
    *
-   * The class is parametrized by two functions to obtain a bytecode class descriptor for a class
+   * The class is parameterized by two functions to obtain a bytecode class descriptor for a class
    * symbol, and to obtain a method signature descriptor fro a method symbol. These function depend
    * on the implementation of GenASM / GenBCode, so they need to be passed in.
    */
@@ -332,7 +332,7 @@ abstract class BCodeHelpers extends BCodeIdiomatic with BytecodeWriters {
             failNoForwarder("companion contains its own main method (implementation restriction: no main is allowed, regardless of signature)")
           else if (companion.isTrait)
             failNoForwarder("companion is a trait")
-          // Now either succeeed, or issue some additional warnings for things which look like
+          // Now either succeed, or issue some additional warnings for things which look like
           // attempts to be java main methods.
         else (possibles exists definitions.isJavaMainMethod) || {
             possibles exists { m =>
@@ -541,9 +541,9 @@ abstract class BCodeHelpers extends BCodeIdiomatic with BytecodeWriters {
      * symbol (sym.annotations) or type (as an AnnotatedType, eliminated by erasure).
      *
      * For Scala annotations this is OK: they are stored in the pickle and ignored by the backend.
-     * Java annoations on the other hand are additionally emitted to the classfile in Java's format.
+     * Java annotations on the other hand are additionally emitted to the classfile in Java's format.
      *
-     * This means that [[Type]] instances within an AnnotaionInfo reach the backend non-erased. Examples:
+     * This means that [[Type]] instances within an AnnotationInfo reach the backend non-erased. Examples:
      *   - @(javax.annotation.Resource @annotation.meta.getter) val x = 0
      *     Here, annotationInfo.atp is an AnnotatedType.
      *   - @SomeAnnotation[T] val x = 0
diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BTypes.scala b/src/compiler/scala/tools/nsc/backend/jvm/BTypes.scala
index 121091fe4f..3e3229d2c3 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/BTypes.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/BTypes.scala
@@ -83,7 +83,7 @@ abstract class BTypes {
   val callsitePositions: concurrent.Map[MethodInsnNode, Position] = recordPerRunCache(TrieMap.empty)
 
   /**
-   * Stores callsite instructions of invocatinos annotated `f(): @inline/noinline`.
+   * Stores callsite instructions of invocations annotated `f(): @inline/noinline`.
    * Instructions are added during code generation (BCodeBodyBuilder). The maps are then queried
    * when building the CallGraph, every Callsite object has an annotated(No)Inline field.
    */
@@ -287,7 +287,7 @@ abstract class BTypes {
     }
 
     // The InlineInfo is built from the classfile (not from the symbol) for all classes that are NOT
-    // being compiled. For those classes, the info is only needed if the inliner is enabled, othewise
+    // being compiled. For those classes, the info is only needed if the inliner is enabled, otherwise
     // we can save the memory.
     if (!compilerSettings.optInlinerEnabled) BTypes.EmptyInlineInfo
     else fromClassfileAttribute getOrElse fromClassfileWithoutAttribute
@@ -653,7 +653,7 @@ abstract class BTypes {
    * Fields in the InnerClass entries:
    *  - inner class: the (nested) class C we are talking about
    *  - outer class: the class of which C is a member. Has to be null for non-members, i.e. for
-   *                 local and anonymous classes. NOTE: this co-incides with the presence of an
+   *                 local and anonymous classes. NOTE: this coincides with the presence of an
    *                 EnclosingMethod attribute (see below)
    *  - inner name:  A string with the simple name of the inner class. Null for anonymous classes.
    *  - flags:       access property flags, details in JVMS, table in 4.7.6. Static flag: see
@@ -702,7 +702,7 @@ abstract class BTypes {
    * local and anonymous classes, no matter if there is an enclosing method or not. Accordingly, the
    * "class" field (see below) must be always defined, while the "method" field may be null.
    *
-   * NOTE: When an EnclosingMethod attribute is requried (local and anonymous classes), the "outer"
+   * NOTE: When an EnclosingMethod attribute is required (local and anonymous classes), the "outer"
    * field in the InnerClass table must be null.
    *
    * Fields:
@@ -1144,7 +1144,7 @@ object BTypes {
   /**
    * Metadata about a ClassBType, used by the inliner.
    *
-   * More information may be added in the future to enable more elaborate inlinine heuristics.
+   * More information may be added in the future to enable more elaborate inline heuristics.
    * Note that this class should contain information that can only be obtained from the ClassSymbol.
    * Information that can be computed from the ClassNode should be added to the call graph instead.
    *
diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BytecodeWriters.scala b/src/compiler/scala/tools/nsc/backend/jvm/BytecodeWriters.scala
index 84f6d87c5c..2cf5cfcb8d 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/BytecodeWriters.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/BytecodeWriters.scala
@@ -78,7 +78,7 @@ trait BytecodeWriters {
   }
 
   /*
-   * The ASM textual representation for bytecode overcomes disadvantages of javap ouput in three areas:
+   * The ASM textual representation for bytecode overcomes disadvantages of javap output in three areas:
    *    (a) pickle dingbats undecipherable to the naked eye;
    *    (b) two constant pools, while having identical contents, are displayed differently due to physical layout.
    *    (c) stack maps (classfile version 50 and up) are displayed in encoded form by javap,
diff --git a/src/compiler/scala/tools/nsc/backend/jvm/analysis/BackendUtils.scala b/src/compiler/scala/tools/nsc/backend/jvm/analysis/BackendUtils.scala
index e25b55e7ab..90da570f01 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/analysis/BackendUtils.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/analysis/BackendUtils.scala
@@ -382,7 +382,8 @@ class BackendUtils[BT <: BTypes](val btypes: BT) {
    * but not for writing in the classfile. We let the ClassWriter recompute max's.
    *
    * NOTE 2: the maxStack value computed here may be larger than the smallest correct value
-   * that would allow running an analyzer, see `InstructionStackEffect.forAsmAnalysisConservative`.
+   * that would allow running an analyzer, see `InstructionStackEffect.forAsmAnalysis` and
+   * `InstructionStackEffect.maxStackGrowth`.
    *
    * NOTE 3: the implementation doesn't look at instructions that cannot be reached, it computes
    * the max local / stack size in the reachable code. These max's work just fine for running an
diff --git a/src/compiler/scala/tools/nsc/backend/jvm/analysis/package.scala b/src/compiler/scala/tools/nsc/backend/jvm/analysis/package.scala
index ef961941a0..999c686aac 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/analysis/package.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/analysis/package.scala
@@ -110,7 +110,7 @@ package scala.tools.nsc.backend.jvm
  *  - Use YourKit for finding hotspots (cpu profiling). when it comes to drilling down into the details
  *    of a hotspot, don't pay too much attention to the percentages / time counts.
  *  - Should also try other profilers.
- *  - Use timers. When a method showed up as a hotspot, i added a timer around that method, and a
+ *  - Use timers. When a method showed up as a hotspot, I added a timer around that method, and a
  *    second one within the method to measure specific parts. The timers slow things down, but the
  *    relative numbers show what parts of a method are slow.
  *
diff --git a/src/compiler/scala/tools/nsc/backend/jvm/opt/BoxUnbox.scala b/src/compiler/scala/tools/nsc/backend/jvm/opt/BoxUnbox.scala
index a4cd8fce1e..78fc7e1ecf 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/opt/BoxUnbox.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/opt/BoxUnbox.scala
@@ -69,7 +69,7 @@ class BoxUnbox[BT <: BTypes](val btypes: BT) {
    * E1: M1 only works if there's a single boxing operation.
    *   def e1(b: Boolean) = {
    *     val i: Integer = box(10) // 10 is stored into a new local, box operation and i removed
-   *     val j: Integer = box(20) // 20 is stored into a new local, box operation adn j removed
+   *     val j: Integer = box(20) // 20 is stored into a new local, box operation and j removed
    *     val r = if (b) i else j  // loads and stores of the box are eliminated, r no longer exists
    *     unbox(r)                 // cannot rewrite: we don't know which local to load
    *   }
@@ -138,7 +138,7 @@ class BoxUnbox[BT <: BTypes](val btypes: BT) {
    *   - note that the MatchError creation is dead code: local2 is never null. However, our nullness
    *     analysis cannot identify this: it does not track nullness through tuple stores and loads.
    *   - if we re-write the non-escaping consumers of the outer tuple, but keep the tuple allocation
-   *     and the escaping consumer, we get the follwoing:
+   *     and the escaping consumer, we get the following:
    *
    *   load 1, load 2
    *   val newLocal1 = new Tuple2; load newLocal1  // stack: Tuple2
@@ -188,7 +188,7 @@ class BoxUnbox[BT <: BTypes](val btypes: BT) {
 
       var maxStackGrowth = 0
 
-      /** Mehtod M1 for eliminating box-unbox pairs (see doc comment in the beginning of this file) */
+      /** Method M1 for eliminating box-unbox pairs (see doc comment in the beginning of this file) */
       def replaceBoxOperationsSingleCreation(creation: BoxCreation, finalCons: Set[BoxConsumer], boxKind: BoxKind, keepBox: Boolean): Unit = {
         /**
          * If the box is eliminated, all copy operations (loads, stores, others) of the box need to
diff --git a/src/compiler/scala/tools/nsc/backend/jvm/opt/ByteCodeRepository.scala b/src/compiler/scala/tools/nsc/backend/jvm/opt/ByteCodeRepository.scala
index 78acd72dba..f2ff73c44d 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/opt/ByteCodeRepository.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/opt/ByteCodeRepository.scala
@@ -167,7 +167,7 @@ class ByteCodeRepository[BT <: BTypes](val classPath: ClassPath, val btypes: BT)
    * the users (e.g. the inliner) have to be aware of method selection.
    *
    * Note that the returned method may be abstract (ACC_ABSTRACT), native (ACC_NATIVE) or signature
-   * polymorphic (methods `invoke` and `invokeExact` in class `MehtodHandles`).
+   * polymorphic (methods `invoke` and `invokeExact` in class `MethodHandles`).
    *
    * @return The [[MethodNode]] of the requested method and the [[InternalName]] of its declaring
    *         class, or an error message if the method could not be found. An error message is also
@@ -204,8 +204,8 @@ class ByteCodeRepository[BT <: BTypes](val classPath: ClassPath, val btypes: BT)
             visited += i
             // abstract and static methods are excluded, see jvms-5.4.3.3
             for (m <- findMethod(c) if !isPrivateMethod(m) && !isStaticMethod(m)) found += ((m, c))
-            val recusionResult = findIn(c)
-            if (recusionResult.isDefined) return recusionResult
+            val recursionResult = findIn(c)
+            if (recursionResult.isDefined) return recursionResult
         }
         None
       }
diff --git a/src/compiler/scala/tools/nsc/backend/jvm/opt/CallGraph.scala b/src/compiler/scala/tools/nsc/backend/jvm/opt/CallGraph.scala
index 9c0dfb0ee2..a740ca525c 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/opt/CallGraph.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/opt/CallGraph.scala
@@ -285,7 +285,7 @@ class CallGraph[BT <: BTypes](val btypes: BT) {
           //   final case class :: / final case object Nil
           //   (l: List).map // can be inlined
           // we need to know that
-          //   - the recevier is sealed
+          //   - the receiver is sealed
           //   - what are the children of the receiver
           //   - all children are final
           //   - none of the children overrides map
diff --git a/src/compiler/scala/tools/nsc/backend/jvm/opt/CopyProp.scala b/src/compiler/scala/tools/nsc/backend/jvm/opt/CopyProp.scala
index b05669ce89..518646812e 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/opt/CopyProp.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/opt/CopyProp.scala
@@ -273,7 +273,7 @@ class CopyProp[BT <: BTypes](val btypes: BT) {
       }
 
       /**
-       * Eliminate the `numArgs` inputs of the instruction `prod` (which was eliminated). Fo
+       * Eliminate the `numArgs` inputs of the instruction `prod` (which was eliminated). For
        * each input value
        *   - if the `prod` instruction is the single consumer, enqueue the producers of the input
        *   - otherwise, insert a POP instruction to POP the input value
@@ -465,7 +465,7 @@ class CopyProp[BT <: BTypes](val btypes: BT) {
   }
 
   /**
-   * Remove `xSTORE n; xLOAD n` paris if
+   * Remove `xSTORE n; xLOAD n` pairs if
    *   - the local variable n is not used anywhere else in the method (1), and
    *   - there are no executable instructions and no live labels (jump targets) between the two (2)
    *
diff --git a/src/compiler/scala/tools/nsc/backend/jvm/opt/InlineInfoAttribute.scala b/src/compiler/scala/tools/nsc/backend/jvm/opt/InlineInfoAttribute.scala
index 16ed9da0e4..7bc4ea2392 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/opt/InlineInfoAttribute.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/opt/InlineInfoAttribute.scala
@@ -82,7 +82,7 @@ case class InlineInfoAttribute(inlineInfo: InlineInfo) extends Attribute(InlineI
   }
 
   /**
-   * De-serialize the attribute into an InlineInfo. The attribute starts at cr.b(off), but we don't
+   * Deserialize the attribute into an InlineInfo. The attribute starts at cr.b(off), but we don't
    * need to access that array directly, we can use the `read` methods provided by the ClassReader.
    *
    * `buf` is a pre-allocated character array that is guaranteed to be long enough to hold any
diff --git a/src/compiler/scala/tools/nsc/backend/jvm/opt/Inliner.scala b/src/compiler/scala/tools/nsc/backend/jvm/opt/Inliner.scala
index b9f593a4d8..0ae8347dc5 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/opt/Inliner.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/opt/Inliner.scala
@@ -683,7 +683,7 @@ class Inliner[BT <: BTypes](val btypes: BT) {
    *  (A2) C and D are members of the same run-time package
    */
   def classIsAccessible(accessed: BType, from: ClassBType): Either[OptimizerWarning, Boolean] = (accessed: @unchecked) match {
-    // TODO: A2 requires "same run-time package", which seems to be package + classloader (JMVS 5.3.). is the below ok?
+    // TODO: A2 requires "same run-time package", which seems to be package + classloader (JVMS 5.3.). is the below ok?
     case c: ClassBType     => c.isPublic.map(_ || c.packageInternalName == from.packageInternalName)
     case a: ArrayBType     => classIsAccessible(a.elementType, from)
     case _: PrimitiveBType => Right(true)
@@ -725,7 +725,7 @@ class Inliner[BT <: BTypes](val btypes: BT) {
    * type from there (https://github.com/scala-opt/scala/issues/13).
    */
   def memberIsAccessible(memberFlags: Int, memberDeclClass: ClassBType, memberRefClass: ClassBType, from: ClassBType): Either[OptimizerWarning, Boolean] = {
-    // TODO: B3 requires "same run-time package", which seems to be package + classloader (JMVS 5.3.). is the below ok?
+    // TODO: B3 requires "same run-time package", which seems to be package + classloader (JVMS 5.3.). is the below ok?
     def samePackageAsDestination = memberDeclClass.packageInternalName == from.packageInternalName
     def targetObjectConformsToDestinationClass = false // needs type propagation analysis, see above
 
diff --git a/src/compiler/scala/tools/nsc/backend/jvm/opt/InlinerHeuristics.scala b/src/compiler/scala/tools/nsc/backend/jvm/opt/InlinerHeuristics.scala
index 4744cb9ab1..63360e17ff 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/opt/InlinerHeuristics.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/opt/InlinerHeuristics.scala
@@ -125,7 +125,7 @@ class InlinerHeuristics[BT <: BTypes](val bTypes: BT) {
         if (callsite.isInlineAnnotated && callee.canInlineFromSource) {
           // By default, we only emit inliner warnings for methods annotated @inline. However, we don't
           // want to be unnecessarily noisy with `-opt-warnings:_`: for example, the inliner heuristic
-          // would attempty to inline `Function1.apply$sp$II`, as it's higher-order (the receiver is
+          // would attempt to inline `Function1.apply$sp$II`, as it's higher-order (the receiver is
           // a function), and it's concrete (forwards to `apply`). But because it's non-final, it cannot
           // be inlined. So we only create warnings here for methods annotated @inline.
           Some(Left(CalleeNotFinal(
diff --git a/src/compiler/scala/tools/nsc/backend/jvm/opt/LocalOpt.scala b/src/compiler/scala/tools/nsc/backend/jvm/opt/LocalOpt.scala
index 65d1e20d69..9c22b09cdd 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/opt/LocalOpt.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/opt/LocalOpt.scala
@@ -61,7 +61,7 @@ import scala.tools.nsc.backend.jvm.opt.BytecodeUtils._
  *     - empty local variable descriptors (local variables that were holding the box may become unused)
  *
  * copy propagation (replaces LOAD n to the LOAD m for the smallest m that is an alias of n)
- *   + enables downstrem:
+ *   + enables downstream:
  *     - stale stores (a stored value may not be loaded anymore)
  *     - store-load pairs (a load n may now be right after a store n)
  *   + NOTE: copy propagation is only executed once, in the first fixpoint loop iteration. none of