Correct a large number of typos.

I scanned the main sources with IntellIJ's spell checker and
corrected what showed up.

13 files changed, 27 insertions, 27 deletions

diff --git a/src/dotty/tools/dotc/core/Contexts.scala b/src/dotty/tools/dotc/core/Contexts.scala
index 61d4e9874..5d2750aa8 100644
--- a/src/dotty/tools/dotc/core/Contexts.scala
+++ b/src/dotty/tools/dotc/core/Contexts.scala
@@ -40,7 +40,7 @@ object Contexts {
    *      named `initctx`. They pass initctx to all positions where it is needed
    *      (and these positions should all be part of the intialization sequence of the class).
    *    - Classes that need contexts that survive initialization are instead passed
-   *      a "condensed context", typically named `cctx` (or they create one). Consensed contexts
+   *      a "condensed context", typically named `cctx` (or they create one). Condensed contexts
    *      just add some basic information to the context base without the
    *      risk of capturing complete trees.
    *    - To make sure these rules are kept, it would be good to do a sanity
@@ -290,7 +290,7 @@ object Contexts {
      *  - At the same time the context should see the parameter accessors of the current class,
      *    that's why they get added to the local scope. An alternative would have been to have the
      *    context see the constructor parameters instead, but then we'd need a final substitution step
-     *    from constructor parameters to class paramater accessors.
+     *    from constructor parameters to class parameter accessors.
      */
     def superCallContext: Context = {
       val locals = newScopeWith(owner.asClass.paramAccessors: _*)
@@ -567,7 +567,7 @@ object Contexts {
     /** Phases by id */
     private[core] var phases: Array[Phase] = _
 
-    /** Phases with consecutive Transforms groupped into a single phase, Empty array if squashing is disabled */
+    /** Phases with consecutive Transforms grouped into a single phase, Empty array if squashing is disabled */
     private[core] var squashedPhases: Array[Phase] = Array.empty[Phase]
 
     /** Next denotation transformer id */
@@ -576,7 +576,7 @@ object Contexts {
     private[core] var denotTransformers: Array[DenotTransformer] = _
 
     // Printers state
-    /** Number of recursive invocations of a show method on cuyrrent stack */
+    /** Number of recursive invocations of a show method on current stack */
     private[dotc] var toTextRecursions = 0
 
     // Reporters state
@@ -600,7 +600,7 @@ object Contexts {
     /** implicit conversion that injects all ContextBase members into a context */
     implicit def toBase(ctx: Context): ContextBase = ctx.base
 
-    val theBase = new ContextBase // !!! DEBUG, so that we can use a minimal context for reporting even in code that normallly cannot access a context
+    val theBase = new ContextBase // !!! DEBUG, so that we can use a minimal context for reporting even in code that normally cannot access a context
   }
 
   /** Info that changes on each compiler run */
diff --git a/src/dotty/tools/dotc/core/Decorators.scala b/src/dotty/tools/dotc/core/Decorators.scala
index 4e672ef40..8aaef985c 100644
--- a/src/dotty/tools/dotc/core/Decorators.scala
+++ b/src/dotty/tools/dotc/core/Decorators.scala
@@ -36,7 +36,7 @@ object Decorators {
   final val MaxFilterRecursions = 1000
 
   /** Implements filterConserve, zipWithConserve methods
-   *  on lists that avoid dupliation of list nodes where feasible.
+   *  on lists that avoid duplication of list nodes where feasible.
    */
   implicit class ListDecorator[T](val xs: List[T]) extends AnyVal {
 
diff --git a/src/dotty/tools/dotc/core/Denotations.scala b/src/dotty/tools/dotc/core/Denotations.scala
index 756e0b02d..6ac15dbca 100644
--- a/src/dotty/tools/dotc/core/Denotations.scala
+++ b/src/dotty/tools/dotc/core/Denotations.scala
@@ -583,7 +583,7 @@ object Denotations {
               else {
                 next match {
                   case next: ClassDenotation =>
-                    assert(!next.is(Package), s"illegal transfomation of package denotation by transformer ${ctx.withPhase(transformer).phase}")
+                    assert(!next.is(Package), s"illegal transformation of package denotation by transformer ${ctx.withPhase(transformer).phase}")
                     next.resetFlag(Frozen)
                   case _ =>
                 }
diff --git a/src/dotty/tools/dotc/core/Names.scala b/src/dotty/tools/dotc/core/Names.scala
index f0d3f02eb..ea30b1c3b 100644
--- a/src/dotty/tools/dotc/core/Names.scala
+++ b/src/dotty/tools/dotc/core/Names.scala
@@ -313,15 +313,15 @@ object Names {
   /** Create a term name from a string, without encoding operators */
   def termName(s: String): TermName = termName(s.toCharArray, 0, s.length)
 
-  /** Create a type name from a string, wihtout encoding operators */
+  /** Create a type name from a string, without encoding operators */
   def typeName(s: String): TypeName = typeName(s.toCharArray, 0, s.length)
 
-  /** The term name represented by the empoty string */
+  /** The term name represented by the empty string */
   val EmptyTermName = new TermName(-1, 0, null)
 
   table(0) = EmptyTermName
 
-  /** The type name represented by the empoty string */
+  /** The type name represented by the empty string */
   val EmptyTypeName = EmptyTermName.toTypeName
 
   // can't move CONSTRUCTOR/EMPTY_PACKAGE to `nme` because of bootstrap failures in `encode`.
diff --git a/src/dotty/tools/dotc/core/Phases.scala b/src/dotty/tools/dotc/core/Phases.scala
index e0496185e..0ec3320bb 100644
--- a/src/dotty/tools/dotc/core/Phases.scala
+++ b/src/dotty/tools/dotc/core/Phases.scala
@@ -161,9 +161,9 @@ object Phases {
       }
 
       def checkRequirements(p: Phase) = {
-        val unmetPreceedeRequirements = p.runsAfter -- phasesAfter
-        assert(unmetPreceedeRequirements.isEmpty,
-          s"phase ${p} has unmet requirement: ${unmetPreceedeRequirements.mkString(", ")} should precede this phase")
+        val unmetPrecedeRequirements = p.runsAfter -- phasesAfter
+        assert(unmetPrecedeRequirements.isEmpty,
+          s"phase ${p} has unmet requirement: ${unmetPrecedeRequirements.mkString(", ")} should precede this phase")
         phasesAfter += p.getClazz
 
       }
diff --git a/src/dotty/tools/dotc/core/Signature.scala b/src/dotty/tools/dotc/core/Signature.scala
index 8717c4f42..4d83a7963 100644
--- a/src/dotty/tools/dotc/core/Signature.scala
+++ b/src/dotty/tools/dotc/core/Signature.scala
@@ -25,7 +25,7 @@ import TypeErasure.sigName
  */
 case class Signature(paramsSig: List[TypeName], resSig: TypeName) {
 
-  /** Does this signature conincide with that signature on their parameter parts? */
+  /** Does this signature coincide with that signature on their parameter parts? */
   final def sameParams(that: Signature): Boolean = this.paramsSig == that.paramsSig
 
   /** The meaning of `matches` depends on the phase. If types are not erased,
diff --git a/src/dotty/tools/dotc/core/SymDenotations.scala b/src/dotty/tools/dotc/core/SymDenotations.scala
index 1ad718c29..064429c6b 100644
--- a/src/dotty/tools/dotc/core/SymDenotations.scala
+++ b/src/dotty/tools/dotc/core/SymDenotations.scala
@@ -743,7 +743,7 @@ object SymDenotations {
      *  Definitions flagged with InSuperCall are treated specially.
      *  Their enclosing class is not the lexically enclosing class,
      *  but in turn the enclosing class of the latter. This reflects
-     *  the context created by `Context#superCallContext`, `Contect#thisCallArgContext`
+     *  the context created by `Context#superCallContext`, `Context#thisCallArgContext`
      *  for these definitions.
      *
      *  Note, that as packages have ClassSymbols, top level classes will have an `enclosingClass`
@@ -839,7 +839,7 @@ object SymDenotations {
      *  Three alternative strategies:
      *  1. If owner is a class, look in its members, otherwise
      *  2. If current compilation unit has a typed tree,
-     *     determine the definining statement sequence and search its trees, otherwise
+     *     determine the defining statement sequence and search its trees, otherwise
      *  3. If context has an enclosing scope which defines this symbol,
      *     lookup its companion in the same scope.
      */
@@ -954,7 +954,7 @@ object SymDenotations {
       loop(base.info.baseClasses.dropWhile(owner != _).tail)
     }
 
-    /** A a member of class `base` is incomplete if
+    /** A member of class `base` is incomplete if
      *  (1) it is declared deferred or
      *  (2) it is abstract override and its super symbol in `base` is
      *      nonexistent or incomplete.
diff --git a/src/dotty/tools/dotc/core/SymbolLoaders.scala b/src/dotty/tools/dotc/core/SymbolLoaders.scala
index 7fb44a106..a62a88dfb 100644
--- a/src/dotty/tools/dotc/core/SymbolLoaders.scala
+++ b/src/dotty/tools/dotc/core/SymbolLoaders.scala
@@ -182,7 +182,7 @@ abstract class SymbolLoader extends LazyType {
 
   def sourceFileOrNull: AbstractFile = null
 
-  /** Description of the resource (ClassPath, AbstractFile, MsilFile)
+  /** Description of the resource (ClassPath, AbstractFile)
    *  being processed by this loader
    */
   def description: String
diff --git a/src/dotty/tools/dotc/core/Symbols.scala b/src/dotty/tools/dotc/core/Symbols.scala
index 14acf26f5..0478b1b7b 100644
--- a/src/dotty/tools/dotc/core/Symbols.scala
+++ b/src/dotty/tools/dotc/core/Symbols.scala
@@ -109,7 +109,7 @@ trait Symbols { this: Context =>
         ClassInfo(owner.thisType, _, parents, decls, selfInfo),
         privateWithin, coord, assocFile)
 
-  /** Same as `newCompleteClassSymbol` except that `parents` can be a list of arbitary
+  /** Same as `newCompleteClassSymbol` except that `parents` can be a list of arbitrary
    *  types which get normalized into type refs and parameter bindings.
    */
   def newNormalizedClassSymbol(
diff --git a/src/dotty/tools/dotc/core/TypeApplications.scala b/src/dotty/tools/dotc/core/TypeApplications.scala
index a5e24c5ff..8bd1651dc 100644
--- a/src/dotty/tools/dotc/core/TypeApplications.scala
+++ b/src/dotty/tools/dotc/core/TypeApplications.scala
@@ -235,13 +235,13 @@ class TypeApplications(val self: Type) extends AnyVal {
     baseArgInfos(base) mapConserve noBounds
 
   /** The type arguments of this type's base type instance wrt.`base`.
-   *  Existential types in arguments are approximanted by their lower bound.
+   *  Existential types in arguments are approximated by their lower bound.
    */
   final def baseArgTypesLo(base: Symbol)(implicit ctx: Context): List[Type] =
     baseArgInfos(base) mapConserve boundsToLo
 
   /** The type arguments of this type's base type instance wrt.`base`.
-   *  Existential types in arguments are approximanted by their upper bound.
+   *  Existential types in arguments are approximated by their upper bound.
    */
   final def baseArgTypesHi(base: Symbol)(implicit ctx: Context): List[Type] =
     baseArgInfos(base) mapConserve boundsToHi
diff --git a/src/dotty/tools/dotc/core/Types.scala b/src/dotty/tools/dotc/core/Types.scala
index 24f59ee43..3ab621db1 100644
--- a/src/dotty/tools/dotc/core/Types.scala
+++ b/src/dotty/tools/dotc/core/Types.scala
@@ -1194,7 +1194,7 @@ object Types {
     def denotationIsCurrent(implicit ctx: Context) =
       lastDenotation != null && lastDenotation.validFor.runId == ctx.runId
 
-    /** The the denotation is current, its symbol, otherwise NoDenotation.
+    /** The denotation is current, its symbol, otherwise NoDenotation.
      *
      *  Note: This operation does not force the denotation, and is therefore
      *  timing dependent. It should only be used if the outcome of the
@@ -2303,7 +2303,7 @@ object Types {
    */
   final class TypeVar(val origin: PolyParam, creatorState: TyperState, val owningTree: untpd.Tree, val owner: Symbol) extends CachedProxyType with ValueType {
 
-    /** The permanent instance type of the the variable, or NoType is none is given yet */
+    /** The permanent instance type of the variable, or NoType is none is given yet */
     private[core] var inst: Type = NoType
 
     /** The state owning the variable. This is at first `creatorState`, but it can
diff --git a/src/dotty/tools/dotc/core/tasty/TreeBuffer.scala b/src/dotty/tools/dotc/core/tasty/TreeBuffer.scala
index 6aba44d3b..d741c42c3 100644
--- a/src/dotty/tools/dotc/core/tasty/TreeBuffer.scala
+++ b/src/dotty/tools/dotc/core/tasty/TreeBuffer.scala
@@ -105,7 +105,7 @@ class TreeBuffer extends TastyBuffer(50000) {
 
   /** Adjust deltas to also take account references that will shrink (and thereby
    *  generate additional zeroes that can be skipped) due to previously
-   *  computed adjustements.
+   *  computed adjustments.
    */
   private def adjustDeltas(): Int = {
     val delta1 = new Array[Int](delta.length)
diff --git a/src/dotty/tools/dotc/core/unpickleScala2/Scala2Unpickler.scala b/src/dotty/tools/dotc/core/unpickleScala2/Scala2Unpickler.scala
index 56c1d90df..b4549a8d8 100644
--- a/src/dotty/tools/dotc/core/unpickleScala2/Scala2Unpickler.scala
+++ b/src/dotty/tools/dotc/core/unpickleScala2/Scala2Unpickler.scala
@@ -181,14 +181,14 @@ class Scala2Unpickler(bytes: Array[Byte], classRoot: ClassDenotation, moduleClas
   protected def errorBadSignature(msg: String, original: Option[RuntimeException] = None)(implicit ctx: Context) = {
     val ex = new BadSignature(
       sm"""error reading Scala signature of $classRoot from $source:
-          |error occured at position $readIndex: $msg""")
+          |error occurred at position $readIndex: $msg""")
     /*if (debug)*/ original.getOrElse(ex).printStackTrace() // !!! DEBUG
     throw ex
   }
 
   protected def handleRuntimeException(ex: RuntimeException)(implicit ctx: Context) = ex match {
     case ex: BadSignature => throw ex
-    case _ => errorBadSignature(s"a runtime exception occured: $ex", Some(ex))
+    case _ => errorBadSignature(s"a runtime exception occurred: $ex", Some(ex))
   }
 
   private var postReadOp: Context => Unit = null
@@ -884,7 +884,7 @@ class Scala2Unpickler(bytes: Array[Byte], classRoot: ClassDenotation, moduleClas
     deferredAnnot(end)
   }
 
-  /** A deferred annotation that can be comleted by reading
+  /** A deferred annotation that can be completed by reading
    *  the bytes between `readIndex` and `end`.
    */
   protected def deferredAnnot(end: Int)(implicit ctx: Context): Annotation = {