Merge branch 'master' into change-rewrite

Author: Blaisorblade

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

@@ -626,7 +626,7 @@ class DottyBackendInterface(outputDirectory: AbstractFile, val superCallsMap: Ma
 
     def symbol: Symbol = a.tree.symbol
 
-    def args: List[Tree] = List.empty // those arguments to scala-defined annotations. they are never emmited
+    def args: List[Tree] = List.empty // those arguments to scala-defined annotations. they are never emmitted
   }
 
   def assocsFromApply(tree: Tree): List[(Name, Tree)] = {
@@ -810,7 +810,7 @@ class DottyBackendInterface(outputDirectory: AbstractFile, val superCallsMap: Ma
     def annotations: List[Annotation] = toDenot(sym).annotations
     def companionModuleMembers: List[Symbol] =  {
       // phase travel to exitingPickler: this makes sure that memberClassesOf only sees member classes,
-      // not local classes of the companion module (E in the exmaple) that were lifted by lambdalift.
+      // not local classes of the companion module (E in the example) that were lifted by lambdalift.
       if (linkedClass.isTopLevelModuleClass) /*exitingPickler*/ linkedClass.memberClasses
       else Nil
     }

compiler/src/dotty/tools/dotc/Driver.scala

@@ -118,7 +118,7 @@ class Driver extends DotClass {
    *
    *  In most cases, you do not need a custom `Context` and should
    *  instead use one of the other overloads of `process`. However,
-   *  the other overloads cannot be overriden, instead you
+   *  the other overloads cannot be overridden, instead you
    *  should override this one which they call internally.
    *
    *  Usage example: [[https://github.com/lampepfl/dotty/tree/master/test/test/OtherEntryPointsTest.scala]]

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

@@ -168,7 +168,7 @@ abstract class Positioned extends DotClass with Product {
     def check(p: Any): Unit = p match {
       case p: Positioned =>
         assert(pos contains p.pos,
-          s"""position error, parent position does not contain child positon
+          s"""position error, parent position does not contain child position
              |parent          = $this,
              |parent position = $pos,
              |child           = $p,

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

@@ -1017,7 +1017,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
             lastParam.tpe match {
               case defn.ArrayOf(el2) if el2 <:< el =>
                 // we have a JavaSeqLiteral with a more precise type
-                // we cannot construct a tree as JavaSeqLiteral infered to precise type
+                // we cannot construct a tree as JavaSeqLiteral inferred to precise type
                 // if we add typed than it would be both type-correct and
                 // will pass Ycheck
                 prefix ::: List(tpd.Typed(lastParam, TypeTree(defn.ArrayOf(el))))

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

@@ -120,7 +120,7 @@ object Config {
 
   /** If this flag is set, it is checked that class type parameters are
    *  only references with NoPrefix or ThisTypes as prefixes. This option
-   *  is usally disabled, because there are still some legitimate cases where
+   *  is usually disabled, because there are still some legitimate cases where
    *  this can arise (e.g. for pos/Map.scala, in LambdaType.integrate).
    */
   final val checkTypeParamRefs = false

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

@@ -1233,7 +1233,7 @@ class Definitions {
       // Temporary measure, as long as we do not read these classes from Tasty.
       // Scala-2 classes don't have NoInits set even if they are pure. We override this
       // for Product and Serializable so that case classes can be pure. A full solution
-      // requiers that we read all Scala code from Tasty.
+      // requires that we read all Scala code from Tasty.
       ProductClass.setFlag(NoInits)
       SerializableClass.setFlag(NoInits)
 

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

@@ -1068,7 +1068,7 @@ object SymDenotations {
       if (!canMatchInheritedSymbols && (owner ne inClass)) NoSymbol
       else matchingDecl(inClass, owner.thisType)
 
-    /** All symbols overriden by this denotation. */
+    /** All symbols overridden by this denotation. */
     final def allOverriddenSymbols(implicit ctx: Context): Iterator[Symbol] =
       if (!canMatchInheritedSymbols) Iterator.empty
       else overriddenFromType(owner.info)

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

@@ -350,7 +350,7 @@ class TypeErasure(isJava: Boolean, semiEraseVCs: Boolean, isConstructor: Boolean
    *   - For a refined type scala.Array+[T]:
    *      - if T is Nothing or Null, []Object
    *      - otherwise, if T <: Object, []|T|
-   *      - otherwise, if T is a type paramter coming from Java, []Object
+   *      - otherwise, if T is a type parameter coming from Java, []Object
    *      - otherwise, Object
    *   - For a term ref p.x, the type <noprefix> # x.
    *   - For a typeref scala.Any, scala.AnyVal or scala.Singleton: |java.lang.Object|

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

@@ -2309,9 +2309,9 @@ object Types {
   }
 
   /** A refined type parent { refinement }
-   *  @param refinedName  The name of the refinement declaration
-   *  @param infoFn: A function that produces the info of the refinement declaration,
-   *                 given the refined type itself.
+   *  @param parent      The type being refined
+   *  @param refinedName The name of the refinement declaration
+   *  @param refinedInfo The info of the refinement declaration
    */
   abstract case class RefinedType(parent: Type, refinedName: Name, refinedInfo: Type) extends RefinedOrRecType {
 
@@ -2370,6 +2370,31 @@ object Types {
     }
   }
 
+  /** A recursive type. Instances should be constructed via the companion object.
+   *
+   *  @param parentExp A function that, given a recursive type R, produces a type
+   *                   that can refer to R via a `RecThis(R)` node. This is used to
+   *                   "tie the knot".
+   *
+   *  For example, in
+   *    class C { type T1; type T2 }
+   *    type C2 = C { type T1; type T2 = T1  }
+   *
+   *  The type of `C2` is a recursive type `{(x) => C{T1; T2 = x.T1}}`, written as
+   *
+   *    RecType(
+   *      RefinedType(
+   *        RefinedType(
+   *         TypeRef(...,class C),
+   *         T1,
+   *         TypeBounds(...)),
+   *        T2,
+   *        TypeBounds(
+   *          TypeRef(RecThis(...),T1),
+   *          TypeRef(RecThis(...),T1))))
+   *
+   *  Where `RecThis(...)` points back to the enclosing `RecType`.
+   */
   class RecType(parentExp: RecType => Type) extends RefinedOrRecType with BindingType {
 
     // See discussion in findMember#goRec why these vars are needed
@@ -2438,7 +2463,7 @@ object Types {
      *   1. Nested Rec types on the type's spine are merged with the outer one.
      *   2. Any refinement of the form `type T = z.T` on the spine of the type
      *      where `z` refers to the created rec-type is replaced by
-     *      `type T`. This avoids infinite recursons later when we
+     *      `type T`. This avoids infinite recursions later when we
      *      try to follow these references.
      *   TODO: Figure out how to guarantee absence of cycles
      *         of length > 1
@@ -2459,6 +2484,8 @@ object Types {
       }
       unique(rt.derivedRecType(normalize(rt.parent))).checkInst
     }
+
+    /** Create a `RecType`, but only if the type generated by `parentExp` is indeed recursive. */
     def closeOver(parentExp: RecType => Type)(implicit ctx: Context) = {
       val rt = this(parentExp)
       if (rt.isReferredToBy(rt.parent)) rt else rt.parent

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

@@ -274,7 +274,7 @@ object TastyFormat {
 
     final val OBJECTCLASS = 23       // The name of an object class (or: module class) `<name>$`.
 
-    final val SIGNED = 63            // A pair of a name and a signature, used to idenitfy
+    final val SIGNED = 63            // A pair of a name and a signature, used to idenitify
                                      // possibly overloaded methods.
   }
   object NameTags extends NameTags