Correct a large number of typos.

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

Author: retronym

src/dotty/tools/backend/jvm/CollectEntryPoints.scala

@@ -40,7 +40,7 @@ class CollectEntryPoints extends MiniPhaseTransform {
   def phaseName: String = "Collect entry points"
 
   override def transformDefDef(tree: tpd.DefDef)(implicit ctx: Context, info: TransformerInfo): tpd.Tree = {
-    if ((tree.symbol ne NoSymbol) && CollectEntryPoints.isJavaEntyPoint(tree.symbol)) {
+    if ((tree.symbol ne NoSymbol) && CollectEntryPoints.isJavaEntryPoint(tree.symbol)) {
       ctx.genBCodePhase.asInstanceOf[GenBCode].registerEntryPoint(tree.symbol)
     }
     tree
@@ -60,7 +60,7 @@ object CollectEntryPoints{
     })
   }
 
-  def isJavaEntyPoint(sym: Symbol)(implicit ctx: Context): Boolean = {
+  def isJavaEntryPoint(sym: Symbol)(implicit ctx: Context): Boolean = {
     import Types.MethodType
     val d = ctx.definitions
     val StringType = d.StringType
@@ -105,7 +105,7 @@ object CollectEntryPoints{
           failNoForwarder("companion contains its own main method (implementation restriction: no main is allowed, regardless of signature)")
         else if (companion.flags is Flags.Trait)
           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(x=> isJavaMainMethod(x.symbol))) || {
           possibles exists { m =>

src/dotty/tools/backend/jvm/DottyBackendInterface.scala

@@ -617,7 +617,7 @@ class DottyBackendInterface()(implicit ctx: Context) extends BackendInterface{
     def hasAnnotation(sym: Symbol): Boolean = false
     def shouldEmitForwarders: Boolean =  //exitingPickler { !(sym.name.toString contains '$')
       (sym is Flags.Module) && !(sym is Flags.ImplClass) /// !sym.isNestedClass
-    def isJavaEntryPoint: Boolean = CollectEntryPoints.isJavaEntyPoint(sym)
+    def isJavaEntryPoint: Boolean = CollectEntryPoints.isJavaEntryPoint(sym)
 
     def isClassConstructor: Boolean = toDenot(sym).isClassConstructor
 

src/dotty/tools/backend/jvm/GenBCode.scala

@@ -342,7 +342,7 @@ class GenBCodePipeline(val entryPoints: List[Symbol], val int: DottyBackendInter
         tree match {
           case EmptyTree            => ()
           case PackageDef(_, stats) => stats foreach gen
-          case ValDef(name, tpt, rhs) => () // module val not emmited
+          case ValDef(name, tpt, rhs) => () // module val not emitted
           case cd: TypeDef         =>
             q1 add Item1(arrivalPos, cd, int.currentUnit)
             arrivalPos += 1

src/dotty/tools/dotc/Run.scala

@@ -37,10 +37,10 @@ class Run(comp: Compiler)(implicit ctx: Context) {
       throw ex
   }
 
-  /** TODO: There's a fundamental design problem here: We assmble phases using `squash`
+  /** TODO: There's a fundamental design problem here: We assemble phases using `squash`
    *  when we first build the compiler. But we modify them with -Yskip, -Ystop
-   *  on each run. That modification needs to either trasnform the tree structure,
-   *  or we need to assmeble phases on each run, and take -Yskip, -Ystop into
+   *  on each run. That modification needs to either transform the tree structure,
+   *  or we need to assemble phases on each run, and take -Yskip, -Ystop into
    *  account. I think the latter would be preferable.
    */
   def compileSources(sources: List[SourceFile]) =
@@ -67,9 +67,9 @@ class Run(comp: Compiler)(implicit ctx: Context) {
   private def printTree(ctx: Context) = {
     val unit = ctx.compilationUnit
     val prevPhase = ctx.phase.prev // can be a mini-phase
-    val squahsedPhase = ctx.squashed(prevPhase)
+    val squashedPhase = ctx.squashed(prevPhase)
 
-    println(s"result of $unit after ${squahsedPhase}:")
+    println(s"result of $unit after ${squashedPhase}:")
     println(unit.tpdTree.show(ctx))
   }
 

src/dotty/tools/dotc/ast/Desugar.scala

@@ -36,7 +36,7 @@ object desugar {
     /** Make sure that for all enclosing module classes their companion lasses
      *  are completed. Reason: We need the constructor of such companion classes to
      *  be completed so that OriginalSymbol attachments are pushed to DerivedTypeTrees
-     *  in appy/unapply methods.
+     *  in apply/unapply methods.
      */
     override def ensureCompletions(implicit ctx: Context) =
       if (!(ctx.owner is Package))
@@ -335,7 +335,7 @@ object desugar {
             .withMods(synthetic))
       .withPos(cdef.pos).toList
 
-    // The companion object defifinitions, if a companion is needed, Nil otherwise.
+    // The companion object definitions, if a companion is needed, Nil otherwise.
     // companion definitions include:
     // 1. If class is a case class case class C[Ts](p1: T1, ..., pN: TN)(moreParams):
     //     def apply[Ts](p1: T1, ..., pN: TN)(moreParams) = new C[Ts](p1, ..., pN)(moreParams)  (unless C is abstract)

src/dotty/tools/dotc/ast/TreeInfo.scala

@@ -256,7 +256,7 @@ trait TreeInfo[T >: Untyped <: Type] { self: Trees.Instance[T] =>
     case y          => y
   }
 
-  /** Checks whether predicate `p` is true for all result parts of this epression,
+  /** Checks whether predicate `p` is true for all result parts of this expression,
    *  where we zoom into Ifs, Matches, and Blocks.
    */
   def forallResults(tree: Tree, p: Tree => Boolean): Boolean = tree match {

src/dotty/tools/dotc/ast/TreeTypeMap.scala

@@ -25,7 +25,7 @@ import dotty.tools.dotc.transform.SymUtils._
  *  The reason the substitution is broken out from the rest of the type map is
  *  that all symbols have to be substituted at the same time. If we do not do this,
  *  we risk data races on named types. Example: Say we have `outer#1.inner#2` and we
- *  have two substitutons S1 = [outer#1 := outer#3], S2 = [inner#2 := inner#4] where
+ *  have two substitutions S1 = [outer#1 := outer#3], S2 = [inner#2 := inner#4] where
  *  hashtags precede symbol ids. If we do S1 first, we get outer#2.inner#3. If we then
  *  do S2 we get outer#2.inner#4. But that means that the named type outer#2.inner
  *  gets two different denotations in the same period. Hence, if -Yno-double-bindings is

src/dotty/tools/dotc/ast/Trees.scala

@@ -32,7 +32,7 @@ object Trees {
    *  @param flags          The set flags
    *  @param privateWithin  If a private or protected has is followed by a
    *                        qualifier [q], the name q, "" as a typename otherwise.
-   *  @param annotations    The annotations preceding the modifers
+   *  @param annotations    The annotations preceding the modifiers
    */
   case class Modifiers[-T >: Untyped] (
     flags: FlagSet = EmptyFlags,
@@ -215,7 +215,7 @@ object Trees {
       s
     }
 
-    /** If this is a thicket, gerform `op` on each of its trees
+    /** If this is a thicket, perform `op` on each of its trees
      *  otherwise, perform `op` ion tree itself.
      */
     def foreachInThicket(op: Tree[T] => Unit): Unit = op(this)
@@ -361,7 +361,7 @@ object Trees {
   case class This[-T >: Untyped] private[ast] (qual: TypeName)
     extends DenotingTree[T] with TermTree[T] {
     type ThisTree[-T >: Untyped] = This[T]
-    // Denotation of a This tree is always the udnerlying class; needs correction for modules.
+    // Denotation of a This tree is always the underlying class; needs correction for modules.
     override def denot(implicit ctx: Context): Denotation = {
       tpe match {
         case tpe @ TermRef(pre, _) if tpe.symbol is Module =>

src/dotty/tools/dotc/ast/tpd.scala

@@ -865,7 +865,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
     }
   }
 
-  /** A traverser that passes the enlcosing class or method as an argumenr
+  /** A traverser that passes the enclosing class or method as an argument
    *  to the traverse method.
    */
   abstract class EnclosingMethodTraverser extends TreeAccumulator[Symbol] {

src/dotty/tools/dotc/config/Config.scala

@@ -10,7 +10,7 @@ object Config {
 
   final val checkCacheMembersNamed = false
 
-  /** When updating a connstraint bound, check that the constrained parameter
+  /** When updating a constraint bound, check that the constrained parameter
    *  does not appear at the top-level of either of its bounds.
    */
   final val checkConstraintsNonCyclic = false
@@ -56,7 +56,7 @@ object Config {
   final val fastPathForRefinedSubtype = true
 
   /** When set, use new signature-based matching.
-   *  Advantantage of doing so: It's supposed to be faster
+   *  Advantage of doing so: It's supposed to be faster
    *  Disadvantage: It might hide inconsistencies, so while debugging it's better to turn it off
    */
   final val newMatch = false

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 */

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 {
 

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 _ =>
                 }

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`.

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
 
       }

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,

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.

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

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(

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

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

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)

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 = {

src/dotty/tools/dotc/transform/CollectEntryPoints.scala

@@ -80,7 +80,7 @@ class CollectEntryPoints extends MiniPhaseTransform {
         failNoForwarder("companion contains its own main method (implementation restriction: no main is allowed, regardless of signature)")
       else if (companion.flags is Flags.Trait)
         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 (x => javaPlatform.isJavaMainMethod(x.symbol))) || {
         possibles exists {