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

compiler/src/dotty/tools/dotc/parsing/Parsers.scala

@@ -262,7 +262,7 @@ object Parsers {
     def deprecationWarning(msg: => Message, offset: Int = in.offset) =
       ctx.deprecationWarning(msg, source atPos Position(offset))
 
-    /** Issue an error at current offset taht input is incomplete */
+    /** Issue an error at current offset that input is incomplete */
     def incompleteInputError(msg: => Message) =
       ctx.incompleteInputError(msg, source atPos Position(in.offset))
 

compiler/src/dotty/tools/dotc/printing/Formatting.scala

@@ -244,7 +244,7 @@ object Formatting {
     * ```
     * found:    List[Int]
     * required: List[T]
-    * where:    T is a type in the initalizer of value s which is an alias of
+    * where:    T is a type in the initializer of value s which is an alias of
     *           String
     * ```
     *

compiler/src/dotty/tools/dotc/printing/PlainPrinter.scala

@@ -435,7 +435,7 @@ class PlainPrinter(_ctx: Context) extends Printer {
         else if (ownr.isAnonymousFunction) nextOuter("function")
         else if (isEmptyPrefix(ownr)) ""
         else if (ownr.isLocalDummy) showLocation(ownr.owner, "locally defined in")
-        else if (ownr.isTerm && !ownr.is(Module | Method)) showLocation(ownr, "in the initalizer of")
+        else if (ownr.isTerm && !ownr.is(Module | Method)) showLocation(ownr, "in the initializer of")
         else showLocation(ownr, "in")
       }
       recur(sym.owner, "")

compiler/src/dotty/tools/dotc/printing/Printer.scala

@@ -34,7 +34,7 @@ abstract class Printer {
   def changePrec(prec: Precedence)(op: => Text): Text =
     if (prec < this.prec) atPrec(prec) ("(" ~ op ~ ")") else atPrec(prec)(op)
 
-  /** The name, possibley with with namespace suffix if debugNames is set:
+  /** The name, possibly with with namespace suffix if debugNames is set:
    *  /L for local names, /V for other term names, /T for type names
    */
   def nameString(name: Name): String

compiler/src/dotty/tools/dotc/tastyreflect/CaseDefOpsImpl.scala

@@ -0,0 +1,21 @@
+package dotty.tools.dotc.tastyreflect
+
+import dotty.tools.dotc.ast.tpd
+
+trait CaseDefOpsImpl extends scala.tasty.reflect.CaseDefOps with TastyCoreImpl with Helpers {
+
+  def CaseDefDeco(caseDef: CaseDef): CaseDefAPI = new CaseDefAPI {
+    def pattern(implicit ctx: Context): Pattern = caseDef.pat
+    def guard(implicit ctx: Context): Option[Term] = optional(caseDef.guard)
+    def rhs(implicit ctx: Context): Term = caseDef.body
+  }
+
+  object CaseDef extends CaseDefExtractor {
+    def unapply(x: CaseDef): Option[(Pattern, Option[Term], Term)] = x match {
+      case x: tpd.CaseDef =>
+        Some(x.pat, optional(x.guard), x.body)
+      case _ => None
+    }
+  }
+
+}

compiler/src/dotty/tools/dotc/tastyreflect/ConstantOpsImpl.scala

@@ -0,0 +1,107 @@
+package dotty.tools.dotc.tastyreflect
+
+import dotty.tools.dotc.core.Constants
+
+import scala.tasty.util.Show
+
+trait ConstantOpsImpl extends scala.tasty.reflect.ConstantOps with TastyCoreImpl {
+
+  def ConstantDeco(const: Constant): ConstantAPI = new ConstantAPI {
+    def value: Any = const.value
+  }
+
+  object Constant extends ConstantModule {
+
+    object Unit extends UnitExtractor {
+      def unapply(x: Constant): Boolean = x match {
+        case x: Constants.Constant => x.tag == Constants.UnitTag
+        case _ => false
+      }
+    }
+
+    object Null extends NullExtractor {
+      def unapply(x: Constant): Boolean =  x match {
+        case x: Constants.Constant => x.tag == Constants.NullTag
+        case _ => false
+      }
+    }
+
+    object Boolean extends BooleanExtractor {
+      def unapply(x: Constant): Option[Boolean] = x match {
+        case x: Constants.Constant if x.tag == Constants.BooleanTag => Some(x.booleanValue)
+        case _ => None
+      }
+    }
+
+    object Byte extends ByteExtractor {
+      def unapply(x: Constant): Option[Byte] = x match {
+        case x: Constants.Constant if x.tag == Constants.ByteTag => Some(x.byteValue)
+        case _ => None
+      }
+    }
+
+    object Short extends ShortExtractor {
+      def unapply(x: Constant): Option[Short] = x match {
+        case x: Constants.Constant if x.tag == Constants.ShortTag => Some(x.shortValue)
+        case _ => None
+      }
+    }
+
+    object Char extends CharExtractor {
+      def unapply(x: Constant): Option[Char] = x match {
+        case x: Constants.Constant if x.tag == Constants.CharTag => Some(x.charValue)
+        case _ => None
+      }
+    }
+
+    object Int extends IntExtractor {
+      def unapply(x: Constant): Option[Int] = x match {
+        case x: Constants.Constant if x.tag == Constants.IntTag => Some(x.intValue)
+        case _ => None
+      }
+    }
+
+    object Long extends LongExtractor {
+      def unapply(x: Constant): Option[Long] = x match {
+        case x: Constants.Constant if x.tag == Constants.LongTag => Some(x.longValue)
+        case _ => None
+      }
+    }
+
+    object Float extends FloatExtractor {
+      def unapply(x: Constant): Option[Float] = x match {
+        case x: Constants.Constant if x.tag == Constants.FloatTag => Some(x.floatValue)
+        case _ => None
+      }
+    }
+
+    object Double extends DoubleExtractor {
+      def unapply(x: Constant): Option[Double] = x match {
+        case x: Constants.Constant if x.tag == Constants.DoubleTag => Some(x.doubleValue)
+        case _ => None
+      }
+    }
+
+    object String extends StringExtractor {
+      def unapply(x: Constant): Option[String] = x match {
+        case x: Constants.Constant if x.tag == Constants.StringTag => Some(x.stringValue)
+        case _ => None
+      }
+    }
+
+    object ClassTag extends ClassTagExtractor {
+      def unapply(x: Constant): Option[Type] = x match {
+        case x: Constants.Constant if x.tag == Constants.ClazzTag => Some(x.typeValue)
+        case _ => None
+      }
+    }
+
+    object Symbol extends SymbolExtractor {
+      def unapply(x: Constant): Option[scala.Symbol] = x match {
+        case x: Constants.Constant if x.tag == Constants.ScalaSymbolTag => Some(x.scalaSymbolValue)
+        case _ => None
+      }
+    }
+  }
+
+}

compiler/src/dotty/tools/dotc/tastyreflect/ContextOpsImpl.scala

@@ -0,0 +1,19 @@
+package dotty.tools.dotc.tastyreflect
+
+import dotty.tools.dotc.core.Contexts
+import dotty.tools.dotc.tastyreflect.FromSymbol.definitionFromSym
+import dotty.tools.dotc.util.{Positions, SourcePosition}
+
+trait ContextOpsImpl extends scala.tasty.reflect.ContextOps with TastyCoreImpl {
+
+  val rootContext: Contexts.Context
+
+  def ContextDeco(ctx: Context): ContextAPI = new ContextAPI {
+    def owner: Definition = definitionFromSym(ctx.owner)(ctx)
+
+    def source: java.nio.file.Path = ctx.compilationUnit.source.file.jpath
+  }
+
+  def rootPosition: SourcePosition = SourcePosition(rootContext.source, Positions.NoPosition)
+
+}

compiler/src/dotty/tools/dotc/tastyreflect/FlagSet.scala

@@ -3,7 +3,7 @@ package dotty.tools.dotc.tastyreflect
 import dotty.tools.dotc.core.Flags
 import dotty.tools.dotc.core.Flags._
 
-class FlagSet(flags: Flags.FlagSet) extends scala.tasty.FlagSet {
+class FlagSet(flags: Flags.FlagSet) extends scala.tasty.reflect.FlagSet {
 
   def isProtected: Boolean = flags.is(Protected)
   def isAbstract: Boolean = flags.is(Abstract)

compiler/src/dotty/tools/dotc/tastyreflect/Helpers.scala

@@ -0,0 +1,10 @@
+package dotty.tools.dotc.tastyreflect
+
+import dotty.tools.dotc.ast.Trees
+
+trait Helpers {
+
+  protected final def optional[T <: Trees.Tree[_]](tree: T): Option[tree.type] =
+    if (tree.isEmpty) None else Some(tree)
+
+}

compiler/src/dotty/tools/dotc/tastyreflect/IdOpsImpl.scala

@@ -0,0 +1,16 @@
+package dotty.tools.dotc.tastyreflect
+
+import dotty.tools.dotc.core.Decorators._
+
+trait IdOpsImpl extends scala.tasty.reflect.IdOps with TastyCoreImpl {
+
+  def IdDeco(id: Id): IdAPI = new IdAPI {
+    def pos(implicit ctx: Context): Position = id.pos
+    def name(implicit ctx: Context): String = id.name.toString
+  }
+
+  object Id extends IdExtractor {
+    def unapply(id: Id): Option[String] = Some(id.name.toString)
+  }
+
+}