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

10 files changed, 15 insertions, 15 deletions

diff --git a/src/compiler/scala/tools/nsc/transform/AccessorSynthesis.scala b/src/compiler/scala/tools/nsc/transform/AccessorSynthesis.scala
index a0bba46398..e027b065ac 100644
--- a/src/compiler/scala/tools/nsc/transform/AccessorSynthesis.scala
+++ b/src/compiler/scala/tools/nsc/transform/AccessorSynthesis.scala
@@ -99,7 +99,7 @@ trait AccessorSynthesis extends Transform with ast.TreeDSL {
   }
 
 
-  // TODO: better way to communicate from info transform to tree transfor?
+  // TODO: better way to communicate from info transform to tree transform?
   private[this] val _bitmapInfo  = perRunCaches.newMap[Symbol, BitmapInfo]
   private[this] val _slowPathFor = perRunCaches.newMap[Symbol, Symbol]()
 
diff --git a/src/compiler/scala/tools/nsc/transform/Delambdafy.scala b/src/compiler/scala/tools/nsc/transform/Delambdafy.scala
index 855e53710b..2e7ab8a887 100644
--- a/src/compiler/scala/tools/nsc/transform/Delambdafy.scala
+++ b/src/compiler/scala/tools/nsc/transform/Delambdafy.scala
@@ -152,7 +152,7 @@ abstract class Delambdafy extends Transform with TypingTransformers with ast.Tre
       val resTpOk = (
            samResultType =:= UnitTpe
         || functionResultType =:= samResultType
-        || (isReferenceType(samResultType) && isReferenceType(functionResultType))) // yes, this is what the spec says -- no further correspondance required
+        || (isReferenceType(samResultType) && isReferenceType(functionResultType))) // yes, this is what the spec says -- no further correspondence required
       if (resTpOk && (samParamTypes corresponds functionParamTypes){ (samParamTp, funParamTp) =>
           funParamTp =:= samParamTp || (isReferenceType(funParamTp) && isReferenceType(samParamTp) && funParamTp <:< samParamTp) }) target
       else {
@@ -165,7 +165,7 @@ abstract class Delambdafy extends Transform with TypingTransformers with ast.Tre
         // whenever a type in the sam's signature is (erases to) a primitive type, we must pick the sam's version,
         // as we don't implement the logic regarding widening that's performed by LMF -- we require =:= for primitives
         //
-        // We use the sam's type for the check whether we're dealin with a reference type, as it could be a generic type,
+        // We use the sam's type for the check whether we're dealing with a reference type, as it could be a generic type,
         // which means the function's parameter -- even if it expects a value class -- will need to be
         // boxed on the generic call to the sam method.
 
diff --git a/src/compiler/scala/tools/nsc/transform/Fields.scala b/src/compiler/scala/tools/nsc/transform/Fields.scala
index fbf1e8cec1..b2bf9fad3f 100644
--- a/src/compiler/scala/tools/nsc/transform/Fields.scala
+++ b/src/compiler/scala/tools/nsc/transform/Fields.scala
@@ -58,7 +58,7 @@ import symtab.Flags._
   *
   * In the even longer term (Scala 3?), I agree with @DarkDimius that it would make sense
   * to hide the difference between strict and lazy vals. All vals are lazy,
-  * but the memoization overhead is removed when we statically know they are forced during initialiation.
+  * but the memoization overhead is removed when we statically know they are forced during initialization.
   * We could still expose the low-level field semantics through `private[this] val`s.
   *
   * In any case, the current behavior of overriding vals is pretty surprising.
diff --git a/src/compiler/scala/tools/nsc/transform/LambdaLift.scala b/src/compiler/scala/tools/nsc/transform/LambdaLift.scala
index 798cfcd072..169fe7588e 100644
--- a/src/compiler/scala/tools/nsc/transform/LambdaLift.scala
+++ b/src/compiler/scala/tools/nsc/transform/LambdaLift.scala
@@ -113,7 +113,7 @@ abstract class LambdaLift extends InfoTransform {
      *
      * For DelayedInit subclasses, constructor statements end up in the synthetic init method
      * instead of the constructor itself, so the access should go to the field. This method changes
-     * `logicallyEnclosingMember` in this case to return a temprorary symbol corresponding to that
+     * `logicallyEnclosingMember` in this case to return a temporary symbol corresponding to that
      * method.
      */
     private def logicallyEnclosingMember(sym: Symbol): Symbol = {
diff --git a/src/compiler/scala/tools/nsc/transform/Mixin.scala b/src/compiler/scala/tools/nsc/transform/Mixin.scala
index de0db51b6c..96e2135c52 100644
--- a/src/compiler/scala/tools/nsc/transform/Mixin.scala
+++ b/src/compiler/scala/tools/nsc/transform/Mixin.scala
@@ -32,7 +32,7 @@ abstract class Mixin extends InfoTransform with ast.TreeDSL with AccessorSynthes
     * we cannot emit PROTECTED methods in interfaces on the JVM,
     * but knowing that these trait methods are protected means we won't emit static forwarders.
     *
-    * JVMLS: "Methods of interfaces may have any of the flags in Table 4.6-A set
+    * JVMS: "Methods of interfaces may have any of the flags in Table 4.6-A set
     * except ACC_PROTECTED, ACC_FINAL, ACC_SYNCHRONIZED, and ACC_NATIVE (JLS §9.4)."
     *
     * TODO: can we just set the right flags from the start??
@@ -137,7 +137,7 @@ abstract class Mixin extends InfoTransform with ast.TreeDSL with AccessorSynthes
    */
   def addMember(clazz: Symbol, member: Symbol): Symbol = {
     debuglog(s"mixing into $clazz: ${member.defString}")
-    // This attachment is used to instruct the backend about which methids in traits require
+    // This attachment is used to instruct the backend about which methods in traits require
     // a static trait impl method. We remove this from the new symbol created for the method
     // mixed into the subclass.
     member.removeAttachment[NeedStaticImpl.type]
diff --git a/src/compiler/scala/tools/nsc/transform/SampleTransform.scala b/src/compiler/scala/tools/nsc/transform/SampleTransform.scala
index ba303f7c2b..4c1705e386 100644
--- a/src/compiler/scala/tools/nsc/transform/SampleTransform.scala
+++ b/src/compiler/scala/tools/nsc/transform/SampleTransform.scala
@@ -35,7 +35,7 @@ abstract class SampleTransform extends Transform {
               atPos(tree1.pos)(                 // `atPos` fills in position of its tree argument
                 Select(                         // The `Select` factory method is defined in class `Trees`
                   sup,
-                  currentOwner.newValue(        // creates a new term symbol owned by `currentowner`
+                  currentOwner.newValue(        // creates a new term symbol owned by `currentOwner`
                     newTermName("sample"),      // The standard term name creator
                     tree1.pos)))))
         case _ =>
diff --git a/src/compiler/scala/tools/nsc/transform/SpecializeTypes.scala b/src/compiler/scala/tools/nsc/transform/SpecializeTypes.scala
index 84f47c1caa..9161786d76 100644
--- a/src/compiler/scala/tools/nsc/transform/SpecializeTypes.scala
+++ b/src/compiler/scala/tools/nsc/transform/SpecializeTypes.scala
@@ -1992,7 +1992,7 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers {
       else exitingSpecialize(specializeCalls(unit).transform(tree))
 
       // Remove the final modifier and @inline annotation from anything in the
-      // original class (since it's being overridden in at least onesubclass).
+      // original class (since it's being overridden in at least one subclass).
       //
       // We do this here so that the specialized subclasses will correctly copy
       // final and @inline.
diff --git a/src/compiler/scala/tools/nsc/transform/UnCurry.scala b/src/compiler/scala/tools/nsc/transform/UnCurry.scala
index 096b6b9263..dcffd7a6ab 100644
--- a/src/compiler/scala/tools/nsc/transform/UnCurry.scala
+++ b/src/compiler/scala/tools/nsc/transform/UnCurry.scala
@@ -363,7 +363,7 @@ abstract class UnCurry extends InfoTransform
      *  mark the method symbol SYNCHRONIZED for bytecode generation.
      *
      *  Delambdafy targets are deemed ineligible as the Delambdafy phase will
-     *  replace `this.synchronized` with `$this.synchronzed` now that it emits
+     *  replace `this.synchronized` with `$this.synchronized` now that it emits
      *  all lambda impl methods as static.
      */
     private def translateSynchronized(tree: Tree) = tree match {
@@ -705,7 +705,7 @@ abstract class UnCurry extends InfoTransform
                 //
                 // So what we need to do is to use the pre-uncurry type when creating `l$1`, which is `c.Tree` and is
                 // correct. Now, there are two additional problems:
-                // 1. when varargs and byname params are involved, the uncurry transformation desugares these special
+                // 1. when varargs and byname params are involved, the uncurry transformation desugars these special
                 //    cases to actual typerefs, eg:
                 //    ```
                 //           T*  ~> Seq[T] (Scala-defined varargs)
diff --git a/src/compiler/scala/tools/nsc/transform/patmat/Logic.scala b/src/compiler/scala/tools/nsc/transform/patmat/Logic.scala
index cb3759e5fa..db6eac34cb 100644
--- a/src/compiler/scala/tools/nsc/transform/patmat/Logic.scala
+++ b/src/compiler/scala/tools/nsc/transform/patmat/Logic.scala
@@ -184,8 +184,8 @@ trait Logic extends Debugging  {
 
       // push negation inside formula
       def negationNormalFormNot(p: Prop): Prop = p match {
-        case And(ops) => Or(ops.map(negationNormalFormNot)) // De'Morgan
-        case Or(ops)  => And(ops.map(negationNormalFormNot)) // De'Morgan
+        case And(ops) => Or(ops.map(negationNormalFormNot)) // De Morgan
+        case Or(ops)  => And(ops.map(negationNormalFormNot)) // De Morgan
         case Not(p)   => negationNormalForm(p)
         case True     => False
         case False    => True
diff --git a/src/compiler/scala/tools/nsc/transform/patmat/MatchTreeMaking.scala b/src/compiler/scala/tools/nsc/transform/patmat/MatchTreeMaking.scala
index 89c793ec94..794d3d442a 100644
--- a/src/compiler/scala/tools/nsc/transform/patmat/MatchTreeMaking.scala
+++ b/src/compiler/scala/tools/nsc/transform/patmat/MatchTreeMaking.scala
@@ -564,11 +564,11 @@ trait MatchTreeMaking extends MatchCodeGen with Debugging {
           else scrut match {
             case Typed(tree, tpt) =>
               val suppressExhaustive = tpt.tpe hasAnnotation UncheckedClass
-              val supressUnreachable = tree match {
+              val suppressUnreachable = tree match {
                 case Ident(name) if name startsWith nme.CHECK_IF_REFUTABLE_STRING => true // SI-7183 don't warn for withFilter's that turn out to be irrefutable.
                 case _ => false
               }
-              val suppression = Suppression(suppressExhaustive, supressUnreachable)
+              val suppression = Suppression(suppressExhaustive, suppressUnreachable)
               val hasSwitchAnnotation = treeInfo.isSwitchAnnotation(tpt.tpe)
               // matches with two or fewer cases need not apply for switchiness (if-then-else will do)
               // `case 1 | 2` is considered as two cases.