Merge pull request #5043 from dongjoon-hyun/fix_typos_in_spec_and_comments

Fix some typos in `spec` documents and comments.

13 files changed, 18 insertions, 18 deletions

diff --git a/src/compiler/scala/tools/nsc/backend/jvm/CoreBTypes.scala b/src/compiler/scala/tools/nsc/backend/jvm/CoreBTypes.scala
index 3617f3d863..696a164c56 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/CoreBTypes.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/CoreBTypes.scala
@@ -11,7 +11,7 @@ import scala.tools.nsc.backend.jvm.BTypes.InternalName
  *
  * The symbols used to initialize the ClassBTypes may change from one compiler run to the next. To
  * make sure the definitions are consistent with the symbols in the current run, the
- * `intializeCoreBTypes` method in BTypesFromSymbols creates a new instance of CoreBTypes in each
+ * `initializeCoreBTypes` method in BTypesFromSymbols creates a new instance of CoreBTypes in each
  * compiler run.
  *
  * The class BTypesFromSymbols does not directly reference CoreBTypes, but CoreBTypesProxy. The
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 0d6ef93a26..bd7d5d2608 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/analysis/BackendUtils.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/analysis/BackendUtils.scala
@@ -273,7 +273,7 @@ class BackendUtils[BT <: BTypes](val btypes: BT) {
     }
 
     // we are only interested in the class references in the descriptor, so we can skip over
-    // primitves and the brackets of array descriptors
+    // primitives and the brackets of array descriptors
     def visitDescriptor(desc: String): Unit = (desc.charAt(0): @switch) match {
       case '(' =>
         val internalNames = mutable.ListBuffer.empty[String]
@@ -455,7 +455,7 @@ class BackendUtils[BT <: BTypes](val btypes: BT) {
           insn match {
             case v: VarInsnNode =>
               val longSize = if (isSize2LoadOrStore(v.getOpcode)) 1 else 0
-              maxLocals = math.max(maxLocals, v.`var` + longSize + 1) // + 1 becauase local numbers are 0-based
+              maxLocals = math.max(maxLocals, v.`var` + longSize + 1) // + 1 because local numbers are 0-based
 
             case i: IincInsnNode =>
               maxLocals = math.max(maxLocals, i.`var` + 1)
diff --git a/src/compiler/scala/tools/nsc/backend/jvm/analysis/ProdConsAnalyzerImpl.scala b/src/compiler/scala/tools/nsc/backend/jvm/analysis/ProdConsAnalyzerImpl.scala
index 894799bf36..419c686bd8 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/analysis/ProdConsAnalyzerImpl.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/analysis/ProdConsAnalyzerImpl.scala
@@ -441,10 +441,10 @@ trait ProdConsAnalyzerImpl {
  *     return a;
  *   }
  *
- * In the first frame of the method, the SoruceValue for parameter `a` gives an empty set of
+ * In the first frame of the method, the SourceValue for parameter `a` gives an empty set of
  * producer instructions.
  *
- * In the frame of the `IRETURN` instruction, the SoruceValue for parameter `a` lists a single
+ * In the frame of the `IRETURN` instruction, the SourceValue for parameter `a` lists a single
  * producer instruction: the `ISTORE 1`. This makes it look as if there was a single producer for
  * `a`, where in fact it might still hold the parameter's initial value.
  */
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 f1ac703532..ef961941a0 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/analysis/package.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/analysis/package.scala
@@ -43,7 +43,7 @@ package scala.tools.nsc.backend.jvm
  *   - Stores a frame for each instruction
  *   - `merge` function takes an instruction and a frame, merges the existing frame for that instr
  *     (from the frames array) with the new frame passed as argument.
- *     if the frame changed, puts the instruction on the work queue (fixpiont).
+ *     if the frame changed, puts the instruction on the work queue (fixpoint).
  *   - initial frame: initialized for first instr by calling interpreter.new[...]Value
  *     for each slot (locals and params), stored in frames[firstInstr] by calling `merge`
  *   - work queue of instructions (`queue` array, `top` index for next instruction to analyze)
@@ -191,7 +191,7 @@ package scala.tools.nsc.backend.jvm
  * I measured nullness analysis (which tracks aliases) and a SimpleValue analysis. Nullness runs
  * roughly 5x slower (because of alias tracking) at every problem size - this factor doesn't change.
  *
- * The numbers below are for nullness. Note that the the last column is constant, i.e., the running
+ * The numbers below are for nullness. Note that the last column is constant, i.e., the running
  * time is proportional to #ins * #loc^2. Therefore we use this factor when limiting the maximal
  * method size for running an analysis.
  *
diff --git a/src/compiler/scala/tools/nsc/backend/jvm/opt/ClosureOptimizer.scala b/src/compiler/scala/tools/nsc/backend/jvm/opt/ClosureOptimizer.scala
index 58054f85ad..4935b9d1a0 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/opt/ClosureOptimizer.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/opt/ClosureOptimizer.scala
@@ -156,7 +156,7 @@ class ClosureOptimizer[BT <: BTypes](val btypes: BT) {
         // TODO: This is maybe over-cautious.
         // We are checking if the closure body method is accessible at the closure callsite.
         // If the closure allocation has access to the body method, then the callsite (in the same
-        // method as the alloction) should have access too.
+        // method as the allocation) should have access too.
         val bodyAccessible: Either[OptimizerWarning, Boolean] = for {
           (bodyMethodNode, declClass) <- byteCodeRepository.methodNode(lambdaBodyHandle.getOwner, lambdaBodyHandle.getName, lambdaBodyHandle.getDesc): Either[OptimizerWarning, (MethodNode, InternalName)]
           isAccessible                <- inliner.memberIsAccessible(bodyMethodNode.access, classBTypeFromParsedClassfile(declClass), classBTypeFromParsedClassfile(lambdaBodyHandle.getOwner), ownerClass)
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 f91530903d..f1eaebd27c 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/opt/CopyProp.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/opt/CopyProp.scala
@@ -52,7 +52,7 @@ class CopyProp[BT <: BTypes](val btypes: BT) {
           var r = init
           while (it.hasNext) {
             val n = it.next()
-            // knownUsed.lenght is the number of locals, `n` may be a stack slot
+            // knownUsed.length is the number of locals, `n` may be a stack slot
             if (n < knownUsed.length && knownUsed(n)) return n
             if (n < r) r = n
           }
@@ -171,7 +171,7 @@ class CopyProp[BT <: BTypes](val btypes: BT) {
    *
    * A special case eliminates the creation of unused objects with side-effect-free constructors:
    *   NEW scala/Tuple1; DUP; ALOAD 0; INVOKESPECIAL scala/Tuple1.<init>; POP
-   * The POP has a signle producer (the DUP), it's easy to eliminate these two. A special case
+   * The POP has a single producer (the DUP), it's easy to eliminate these two. A special case
    * is needed to eliminate the INVOKESPECIAL and NEW.
    */
   def eliminatePushPop(method: MethodNode, owner: InternalName): Boolean = {
@@ -533,7 +533,7 @@ class CopyProp[BT <: BTypes](val btypes: BT) {
     }
 
     /**
-     * Try to pair `insn` with its correspondant on the stack
+     * Try to pair `insn` with its correspondent on the stack
      *   - if the stack top is a store and `insn` is a corresponding load, create a pair
      *   - otherwise, check the two top stack values for `null; store`. if it matches, create
      *     a pair and continue pairing `insn` on the remaining stack
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 f486bb0cb9..085463633f 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/opt/LocalOpt.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/opt/LocalOpt.scala
@@ -504,7 +504,7 @@ class LocalOpt[BT <: BTypes](val btypes: BT) {
 
         case v: VarInsnNode if isLive =>
           val longSize = if (isSize2LoadOrStore(v.getOpcode)) 1 else 0
-          maxLocals = math.max(maxLocals, v.`var` + longSize + 1) // + 1 becauase local numbers are 0-based
+          maxLocals = math.max(maxLocals, v.`var` + longSize + 1) // + 1 because local numbers are 0-based
 
         case i: IincInsnNode if isLive =>
           maxLocals = math.max(maxLocals, i.`var` + 1)
diff --git a/src/compiler/scala/tools/nsc/javac/JavaParsers.scala b/src/compiler/scala/tools/nsc/javac/JavaParsers.scala
index 7224523a41..8cdc5944e8 100644
--- a/src/compiler/scala/tools/nsc/javac/JavaParsers.scala
+++ b/src/compiler/scala/tools/nsc/javac/JavaParsers.scala
@@ -509,7 +509,7 @@ trait JavaParsers extends ast.parser.ParsersCommon with JavaScanners {
                 EmptyTree
               }
             }
-          // for abstract methods (of classes), the `DEFERRED` flag is alredy set.
+          // for abstract methods (of classes), the `DEFERRED` flag is already set.
           // here we also set it for interface methods that are not static and not default.
           if (!isConcreteInterfaceMethod) mods1 |= Flags.DEFERRED
           List {
diff --git a/src/compiler/scala/tools/nsc/transform/Constructors.scala b/src/compiler/scala/tools/nsc/transform/Constructors.scala
index ece8109d3c..1e479d3f63 100644
--- a/src/compiler/scala/tools/nsc/transform/Constructors.scala
+++ b/src/compiler/scala/tools/nsc/transform/Constructors.scala
@@ -305,7 +305,7 @@ abstract class Constructors extends Statics with Transform with ast.TreeDSL {
       val delayedHook     = delayedEndpointDef(remainingConstrStats)
       val delayedHookSym  = delayedHook.symbol.asInstanceOf[MethodSymbol]
 
-      // transform to make the closure-class' default constructor assign the the outer instance to its param-accessor field.
+      // transform to make the closure-class' default constructor assign the outer instance to its param-accessor field.
       val hookCallerClass = (new ConstructorTransformer(unit)) transform delayedInitClosure(delayedHookSym)
       val delayedInitCall = localTyper.typedPos(impl.pos) {
         gen.mkMethodCall(This(clazz), delayedInitMethod, Nil, List(New(hookCallerClass.symbol.tpe, This(clazz))))
diff --git a/src/compiler/scala/tools/nsc/transform/Delambdafy.scala b/src/compiler/scala/tools/nsc/transform/Delambdafy.scala
index 4e073b65e5..67e3f67f2f 100644
--- a/src/compiler/scala/tools/nsc/transform/Delambdafy.scala
+++ b/src/compiler/scala/tools/nsc/transform/Delambdafy.scala
@@ -8,7 +8,7 @@ import scala.collection.mutable.LinkedHashMap
 
 /**
  * This transformer is responsible for preparing lambdas for runtime, by either translating to anonymous classes
- * or to a tree that will be convereted to invokedynamic by the JVM 1.8+ backend.
+ * or to a tree that will be converted to invokedynamic by the JVM 1.8+ backend.
  *
  * The main assumption it makes is that a lambda {args => body} has been turned into
  * {args => liftedBody()} where lifted body is a top level method that implements the body of the lambda.
diff --git a/src/compiler/scala/tools/nsc/transform/TailCalls.scala b/src/compiler/scala/tools/nsc/transform/TailCalls.scala
index 16ea3ea90f..fa7c503213 100644
--- a/src/compiler/scala/tools/nsc/transform/TailCalls.scala
+++ b/src/compiler/scala/tools/nsc/transform/TailCalls.scala
@@ -69,7 +69,7 @@ abstract class TailCalls extends Transform {
    *   are optimized. Since 'this' is not a local variable, a dummy local val
    *   is added and used as a label parameter. The backend knows to load
    *   the corresponding argument in the 'this' (local at index 0). This dummy local
-   *   is never used and should be cleand up by dead code elimination (when enabled).
+   *   is never used and should be cleaned up by dead code elimination (when enabled).
    * </p>
    * <p>
    *   This phase has been moved before pattern matching to catch more
diff --git a/src/compiler/scala/tools/nsc/transform/patmat/PatternMatching.scala b/src/compiler/scala/tools/nsc/transform/patmat/PatternMatching.scala
index b2f2516b5b..05f2d60be1 100644
--- a/src/compiler/scala/tools/nsc/transform/patmat/PatternMatching.scala
+++ b/src/compiler/scala/tools/nsc/transform/patmat/PatternMatching.scala
@@ -222,7 +222,7 @@ trait Interface extends ast.TreeDSL {
         object substIdentsForTrees extends Transformer {
           private def typedIfOrigTyped(to: Tree, origTp: Type): Tree =
             if (origTp == null || origTp == NoType) to
-            // important: only type when actually substing and when original tree was typed
+            // important: only type when actually substituting and when original tree was typed
             // (don't need to use origTp as the expected type, though, and can't always do this anyway due to unknown type params stemming from polymorphic extractors)
             else typer.typed(to)
 
diff --git a/src/compiler/scala/tools/nsc/typechecker/Typers.scala b/src/compiler/scala/tools/nsc/typechecker/Typers.scala
index 577d45c489..9446a45c06 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Typers.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Typers.scala
@@ -3155,7 +3155,7 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper
       if (phase.erasedTypes) stats1
       else {
         // As packages are open, it doesn't make sense to check double definitions here. Furthermore,
-        // it is expensive if the package is large. Instead, such double defininitions are checked in `Namers.enterInScope`
+        // it is expensive if the package is large. Instead, such double definitions are checked in `Namers.enterInScope`
         if (!context.owner.isPackageClass)
           checkNoDoubleDefs
         addSynthetics(stats1)