Correct a large number of typos.

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

8 files changed, 18 insertions, 18 deletions

diff --git a/src/dotty/tools/dotc/typer/Applications.scala b/src/dotty/tools/dotc/typer/Applications.scala
index 114a494d1..855f265cc 100644
--- a/src/dotty/tools/dotc/typer/Applications.scala
+++ b/src/dotty/tools/dotc/typer/Applications.scala
@@ -144,7 +144,7 @@ trait Applications extends Compatibility { self: Typer =>
      */
     protected def liftFun(): Unit = ()
 
-    /** A flag signalling that the typechecking the application was so far succesful */
+    /** A flag signalling that the typechecking the application was so far successful */
     private[this] var _ok = true
 
     def ok = _ok
@@ -191,7 +191,7 @@ trait Applications extends Compatibility { self: Typer =>
         else fail(s"$methString does not take parameters")
     }
 
-    /** The application was succesful */
+    /** The application was successful */
     def success = ok
 
     protected def methodType = methType.asInstanceOf[MethodType]
@@ -203,7 +203,7 @@ trait Applications extends Compatibility { self: Typer =>
       /** @param pnames    The list of parameter names that are missing arguments
        *  @param args      The list of arguments that are not yet passed, or that are waiting to be dropped
        *  @param nameToArg A map from as yet unseen names to named arguments
-       *  @param toDrop    A set of names that have aready be passed as named arguments
+       *  @param toDrop    A set of names that have already be passed as named arguments
        *
        *  For a well-typed application we have the invariants
        *
@@ -638,7 +638,7 @@ trait Applications extends Compatibility { self: Typer =>
       untpd.EmptyTree
     }
 
-    /** A typed qual.unappy or qual.unappySeq tree, if this typechecks.
+    /** A typed qual.unapply or qual.unapplySeq tree, if this typechecks.
      *  Otherwise fallBack with (maltyped) qual.unapply as argument
      *  Note: requires special handling for overloaded occurrences of
      *  unapply or unapplySeq. We first try to find a non-overloaded
@@ -669,7 +669,7 @@ trait Applications extends Compatibility { self: Typer =>
       }
     }
 
-    /** Produce a typed qual.unappy or qual.unappySeq tree, or
+    /** Produce a typed qual.unapply or qual.unapplySeq tree, or
      *  else if this fails follow a type alias and try again.
      */
     val unapplyFn = trySelectUnapply(qual) { sel =>
@@ -780,7 +780,7 @@ trait Applications extends Compatibility { self: Typer =>
     new ApplicableToTrees(methRef, targs, args, resultType)(nestedContext).success
   }
 
-  /** Is given method reference applicable to type arguments `targs` and argument trees `args` without invfering views?
+  /** Is given method reference applicable to type arguments `targs` and argument trees `args` without inferring views?
     *  @param  resultType   The expected result type of the application
     */
   def isDirectlyApplicable(methRef: TermRef, targs: List[Type], args: List[Tree], resultType: Type)(implicit ctx: Context): Boolean = {
@@ -819,7 +819,7 @@ trait Applications extends Compatibility { self: Typer =>
   }
 
   /** In a set of overloaded applicable alternatives, is `alt1` at least as good as
-   *  `alt2`? `alt1` and `alt2` are nonoverloaded references.
+   *  `alt2`? `alt1` and `alt2` are non-overloaded references.
    */
   def isAsGood(alt1: TermRef, alt2: TermRef)(implicit ctx: Context): Boolean = track("isAsGood") { ctx.traceIndented(i"isAsGood($alt1, $alt2)", overload) {
 
diff --git a/src/dotty/tools/dotc/typer/Checking.scala b/src/dotty/tools/dotc/typer/Checking.scala
index ffb74839d..f28f3b09a 100644
--- a/src/dotty/tools/dotc/typer/Checking.scala
+++ b/src/dotty/tools/dotc/typer/Checking.scala
@@ -64,7 +64,7 @@ object Checking {
     /** Are cycles allowed within nested refinedInfos of currently checked type? */
     private var nestedCycleOK = false
 
-    /** Are cycles allwoed within currently checked type? */
+    /** Are cycles allowed within currently checked type? */
     private var cycleOK = false
 
     /** A diagnostic output string that indicates the position of the last
diff --git a/src/dotty/tools/dotc/typer/FrontEnd.scala b/src/dotty/tools/dotc/typer/FrontEnd.scala
index ceb806e52..056a57215 100644
--- a/src/dotty/tools/dotc/typer/FrontEnd.scala
+++ b/src/dotty/tools/dotc/typer/FrontEnd.scala
@@ -18,7 +18,7 @@ class FrontEnd extends Phase {
     try body
     catch {
       case NonFatal(ex) =>
-        println(s"exception occured while $doing ${ctx.compilationUnit}")
+        println(s"exception occurred while $doing ${ctx.compilationUnit}")
         throw ex
     }
 
diff --git a/src/dotty/tools/dotc/typer/Implicits.scala b/src/dotty/tools/dotc/typer/Implicits.scala
index cd3b633ac..b03bcfcf9 100644
--- a/src/dotty/tools/dotc/typer/Implicits.scala
+++ b/src/dotty/tools/dotc/typer/Implicits.scala
@@ -186,7 +186,7 @@ object Implicits {
   abstract class SearchResult
 
   /** A successful search
-   *  @param ref   The implicit reference that succeeeded
+   *  @param ref   The implicit reference that succeeded
    *  @param tree  The typed tree that can needs to be inserted
    *  @param ctx   The context after the implicit search
    */
@@ -299,7 +299,7 @@ trait ImplicitRunInfo { self: RunInfo =>
       }
 
     // todo: compute implicits directly, without going via companionRefs?
-    def collectCompanions(tp: Type): TermRefSet = track("computeImplicicScope") {
+    def collectCompanions(tp: Type): TermRefSet = track("computeImplicitScope") {
       ctx.traceIndented(i"collectCompanions($tp)", implicits) {
         val comps = new TermRefSet
         tp match {
diff --git a/src/dotty/tools/dotc/typer/Inferencing.scala b/src/dotty/tools/dotc/typer/Inferencing.scala
index 0223260a0..79e00db6b 100644
--- a/src/dotty/tools/dotc/typer/Inferencing.scala
+++ b/src/dotty/tools/dotc/typer/Inferencing.scala
@@ -45,9 +45,9 @@ trait Inferencing { this: Checking =>
 
   /** The accumulator which forces type variables using the policy encoded in `force`
    *  and returns whether the type is fully defined. Two phases:
-   *  1st Phase: Try to stantiate covariant and non-variant type variables to
-   *  their lower bound. Record whether succesful.
-   *  2nd Phase: If first phase was succesful, instantiate all remaining type variables
+   *  1st Phase: Try to instantiate covariant and non-variant type variables to
+   *  their lower bound. Record whether successful.
+   *  2nd Phase: If first phase was successful, instantiate all remaining type variables
    *  to their upper bound.
    */
   private class IsFullyDefinedAccumulator(force: ForceDegree.Value)(implicit ctx: Context) extends TypeAccumulator[Boolean] {
diff --git a/src/dotty/tools/dotc/typer/ProtoTypes.scala b/src/dotty/tools/dotc/typer/ProtoTypes.scala
index eb5758662..c7efe45b7 100644
--- a/src/dotty/tools/dotc/typer/ProtoTypes.scala
+++ b/src/dotty/tools/dotc/typer/ProtoTypes.scala
@@ -78,7 +78,7 @@ object ProtoTypes {
     def fold[T](x: T, ta: TypeAccumulator[T])(implicit ctx: Context): T = x
   }
 
-  /** A class marking ignored prototypes that can be reviealed by `deepenProto` */
+  /** A class marking ignored prototypes that can be revealed by `deepenProto` */
   case class IgnoredProto(ignored: Type) extends UncachedGroundType with MatchAlways {
     override def deepenProto(implicit ctx: Context): Type = ignored
   }
diff --git a/src/dotty/tools/dotc/typer/TypeAssigner.scala b/src/dotty/tools/dotc/typer/TypeAssigner.scala
index d3baad848..1ae0bec0c 100644
--- a/src/dotty/tools/dotc/typer/TypeAssigner.scala
+++ b/src/dotty/tools/dotc/typer/TypeAssigner.scala
@@ -135,7 +135,7 @@ trait TypeAssigner {
         val name = tpe.name
         val d = tpe.denot.accessibleFrom(pre, superAccess)
         if (!d.exists) {
-          // it could be that we found an inaccessbile private member, but there is
+          // it could be that we found an inaccessible private member, but there is
           // an inherited non-private member with the same name and signature.
           val d2 = pre.nonPrivateMember(name)
           if (reallyExists(d2) && firstTry)
diff --git a/src/dotty/tools/dotc/typer/Typer.scala b/src/dotty/tools/dotc/typer/Typer.scala
index 566e8289a..6033f580b 100644
--- a/src/dotty/tools/dotc/typer/Typer.scala
+++ b/src/dotty/tools/dotc/typer/Typer.scala
@@ -1141,11 +1141,11 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
   }
 
   /** Add apply node or implicit conversions. Two strategies are tried, and the first
-   *  that is succesful is picked. If neither of the strategies are succesful, continues with
+   *  that is successful is picked. If neither of the strategies are successful, continues with
    *  `fallBack`.
    *
    *  1st strategy: Try to insert `.apply` so that the result conforms to prototype `pt`.
-   *  2nd stratgey: If tree is a select `qual.name`, try to insert an implicit conversion
+   *  2nd stratgy: If tree is a select `qual.name`, try to insert an implicit conversion
    *    around the qualifier part `qual` so that the result conforms to the expected type
    *    with wildcard result type.
    */