Fix assorted typos (#18205)

that I've spotted over the past couple years

Author: nicolasstucki

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

@@ -774,7 +774,7 @@ object Trees {
   }
 
   /** Tree that replaces a level 1 splices in pickled (level 0) quotes.
-   *  It is only used when picking quotes (will never be in a TASTy file).
+   *  It is only used when pickling quotes (will never be in a TASTy file).
    *
    *  @param isTerm If this hole is a term, otherwise it is a type hole.
    *  @param idx The index of the hole in it's enclosing level 0 quote.

compiler/src/dotty/tools/dotc/core/ConstraintHandling.scala

@@ -110,7 +110,7 @@ trait ConstraintHandling {
    *
    *  If we trust bounds, then the lower bound of `X` is `x.M` since `x.M >: 1`.
    *  Then even if we correct levels on instantiation to eliminate the local `x`,
-   *  it is alreay too late, we'd get `Int & String` as instance, which does not
+   *  it is already too late, we'd get `Int & String` as instance, which does not
    *  satisfy the original constraint `X >: 1`.
    *
    *  But if `trustBounds` is false, we do not conclude the `x.M >: 1` since
@@ -716,8 +716,8 @@ trait ConstraintHandling {
       // Widening can add extra constraints, in particular the widened type might
       // be a type variable which is now instantiated to `param`, and therefore
       // cannot be used as an instantiation of `param` without creating a loop.
-      // If that happens, we run `instanceType` again to find a new instantation.
-      // (we do not check for non-toplevel occurences: those should never occur
+      // If that happens, we run `instanceType` again to find a new instantiation.
+      // (we do not check for non-toplevel occurrences: those should never occur
       // since `addOneBound` disallows recursive lower bounds).
       if constraint.occursAtToplevel(param, widened) then
         instanceType(param, fromBelow, widenUnions, maxLevel)

compiler/src/dotty/tools/dotc/core/Symbols.scala

@@ -78,7 +78,7 @@ object Symbols {
 
     /** Does this symbol retain its definition tree?
      *  A good policy for this needs to balance costs and benefits, where
-     *  costs are mainly memoty leaks, in particular across runs.
+     *  costs are mainly memory leaks, in particular across runs.
      */
     def retainsDefTree(using Context): Boolean =
       ctx.settings.YretainTrees.value ||

compiler/src/dotty/tools/dotc/core/TypeApplications.scala

@@ -406,7 +406,7 @@ class TypeApplications(val self: Type) extends AnyVal {
     if (typeParams.nonEmpty) appliedTo(args) else self
 
   /** A cycle-safe version of `appliedTo` where computing type parameters do not force
-   *  the typeconstructor. Instead, if the type constructor is completing, we make
+   *  the type constructor. Instead, if the type constructor is completing, we make
    *  up hk type parameters matching the arguments. This is needed when unpickling
    *  Scala2 files such as `scala.collection.generic.Mapfactory`.
    */

compiler/src/dotty/tools/dotc/core/TypeComparer.scala

@@ -1795,7 +1795,7 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
    *  any, or no constraint at all.
    *
    *  Otherwise, we infer _sufficient_ constraints: we try to keep the smaller of
-   *  the two constraints, but if never is smaller than the other, we just pick
+   *  the two constraints, but if neither is smaller than the other, we just pick
    *  the first one.
    */
   protected def either(op1: => Boolean, op2: => Boolean): Boolean =
@@ -2005,7 +2005,7 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
       // is that if the refinement does not refer to a member symbol, we will have to
       // resort to reflection to invoke the member. And Java reflection needs to know exact
       // erased parameter types. See neg/i12211.scala. Other reflection algorithms could
-      // conceivably dispatch without knowning precise parameter signatures. One can signal
+      // conceivably dispatch without knowing precise parameter signatures. One can signal
       // this by inheriting from the `scala.reflect.SignatureCanBeImprecise` marker trait,
       // in which case the signature test is elided.
       def sigsOK(symInfo: Type, info2: Type) =
@@ -2838,7 +2838,7 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
           else
             false
       case (AppliedType(tycon1, args1), AppliedType(tycon2, args2)) if isSame(tycon1, tycon2) =>
-        // It is possible to conclude that two types applies are disjoint by
+        // It is possible to conclude that two types applied are disjoint by
         // looking at covariant type parameters if the said type parameters
         // are disjoin and correspond to fields.
         // (Type parameter disjointness is not enough by itself as it could

compiler/src/dotty/tools/dotc/core/Types.scala

@@ -3357,7 +3357,7 @@ object Types {
     def isAnd: Boolean = true
     private var myBaseClassesPeriod: Period = Nowhere
     private var myBaseClasses: List[ClassSymbol] = _
-    /** Base classes of are the merge of the operand base classes. */
+    /** Base classes are the merge of the operand base classes. */
     override final def baseClasses(using Context): List[ClassSymbol] = {
       if (myBaseClassesPeriod != ctx.period) {
         val bcs1 = tp1.baseClasses
@@ -3450,7 +3450,7 @@ object Types {
     def isSoft: Boolean
     private var myBaseClassesPeriod: Period = Nowhere
     private var myBaseClasses: List[ClassSymbol] = _
-    /** Base classes of are the intersection of the operand base classes. */
+    /** Base classes are the intersection of the operand base classes. */
     override final def baseClasses(using Context): List[ClassSymbol] = {
       if (myBaseClassesPeriod != ctx.period) {
         val bcs1 = tp1.baseClasses

compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala

@@ -264,7 +264,7 @@ class TreeUnpickler(reader: TastyReader,
     /** Read reference to definition and return symbol created at that definition */
     def readSymRef()(using Context): Symbol = symbolAt(readAddr())
 
-    /** The symbol at given address; createa new one if none exists yet */
+    /** The symbol at given address; create a new one if none exists yet */
     def symbolAt(addr: Addr)(using Context): Symbol = symAtAddr.get(addr) match {
       case Some(sym) =>
         sym

compiler/src/dotty/tools/dotc/inlines/Inliner.scala

@@ -177,7 +177,7 @@ class Inliner(val call: tpd.Tree)(using Context):
   /** A map from the classes of (direct and outer) this references in `rhsToInline`
    *  to references of their proxies.
    *  Note that we can't index by the ThisType itself since there are several
-   *  possible forms to express what is logicaly the same ThisType. E.g.
+   *  possible forms to express what is logically the same ThisType. E.g.
    *
    *     ThisType(TypeRef(ThisType(p), cls))
    *
@@ -338,7 +338,7 @@ class Inliner(val call: tpd.Tree)(using Context):
 
   protected def hasOpaqueProxies = opaqueProxies.nonEmpty
 
-  /** Map first halfs of opaqueProxies pairs to second halfs, using =:= as equality */
+  /** Map first halves of opaqueProxies pairs to second halves, using =:= as equality */
   private def mapRef(ref: TermRef): Option[TermRef] =
     opaqueProxies.collectFirst {
       case (from, to) if from.symbol == ref.symbol && from =:= ref => to
@@ -1047,13 +1047,13 @@ class Inliner(val call: tpd.Tree)(using Context):
     val evaluatedSplice = inContext(quoted.MacroExpansion.context(inlinedFrom)) {
       Splicer.splice(body, splicePos, inlinedFrom.srcPos, MacroClassLoader.fromContext)
     }
-    val inlinedNormailizer = new TreeMap {
+    val inlinedNormalizer = new TreeMap {
       override def transform(tree: tpd.Tree)(using Context): tpd.Tree = tree match {
         case Inlined(EmptyTree, Nil, expr) if enclosingInlineds.isEmpty => transform(expr)
         case _ => super.transform(tree)
       }
     }
-    val normalizedSplice = inlinedNormailizer.transform(evaluatedSplice)
+    val normalizedSplice = inlinedNormalizer.transform(evaluatedSplice)
     if (normalizedSplice.isEmpty) normalizedSplice
     else normalizedSplice.withSpan(splicePos.span)
   }

compiler/src/dotty/tools/dotc/quoted/Interpreter.scala

@@ -47,7 +47,7 @@ class Interpreter(pos: SrcPos, classLoader0: ClassLoader)(using Context):
 
   /** Returns the result of interpreting the code in the tree.
    *  Return Some of the result or None if the result type is not consistent with the expected type.
-   *  Throws a StopInterpretation if the tree could not be interpreted or a runtime exception ocurred.
+   *  Throws a StopInterpretation if the tree could not be interpreted or a runtime exception occurred.
    */
   final def interpret[T](tree: Tree)(using ct: ClassTag[T]): Option[T] =
     interpretTree(tree)(using emptyEnv) match {
@@ -59,7 +59,7 @@ class Interpreter(pos: SrcPos, classLoader0: ClassLoader)(using Context):
     }
 
   /** Returns the result of interpreting the code in the tree.
-   *  Throws a StopInterpretation if the tree could not be interpreted or a runtime exception ocurred.
+   *  Throws a StopInterpretation if the tree could not be interpreted or a runtime exception occurred.
    */
   protected def interpretTree(tree: Tree)(using Env): Object = tree match {
     case Literal(Constant(value)) =>

compiler/src/dotty/tools/dotc/transform/MegaPhase.scala

@@ -26,7 +26,7 @@ object MegaPhase {
    *
    *   - Stats: to prepare/transform a statement sequence in a block, template, or package def,
    *   - Unit : to prepare/transform a whole compilation unit
-   *   - Other: to prepape/transform a tree that does not have a specific prepare/transform
+   *   - Other: to prepare/transform a tree that does not have a specific prepare/transform
    *     method pair.
    */
   abstract class MiniPhase extends Phase {