Merge branch 'master' into ws-optimize-string-interpolation

Author: Wojtechnology

AUTHORS.md

@@ -71,3 +71,7 @@ The majority of the dotty codebase is new code, with the exception of the compon
 > the [compiler bridge in sbt 0.13](https://github.com/sbt/sbt/tree/0.13/compile/interface/src/main/scala/xsbt),
 > but has been heavily adapted and refactored.
 > Original authors were Mark Harrah, Grzegorz Kossakowski, Martin Duhemm, Adriaan Moors and others.
+
+`dotty.tools.dotc.plugins`
+
+> Adapted from  [scala/scala](https://github.com/scala/scala) with some modifications. They were originally authored by Lex Spoon, Som Snytt, Adriaan Moors, Paul Phillips and others.

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

@@ -972,7 +972,7 @@ class DottyBackendInterface(outputDirectory: AbstractFile, val superCallsMap: Ma
         case tp =>
           ctx.warning(
             s"an unexpected type representation reached the compiler backend while compiling $currentUnit: $tp. " +
-              "If possible, please file a bug on issues.scala-lang.org.")
+              "If possible, please file a bug on https://github.com/lampepfl/dotty/issues")
 
           tp match {
             case tp: ThisType if tp.cls == ArrayClass => ObjectReference.asInstanceOf[ct.bTypes.ClassBType] // was introduced in 9b17332f11 to fix SI-999, but this code is not reached in its test, or any other test

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

@@ -159,7 +159,7 @@ class GenBCodePipeline(val entryPoints: List[Symbol], val int: DottyBackendInter
      */
     class Worker1(needsOutFolder: Boolean) {
 
-      val caseInsensitively = scala.collection.mutable.Map.empty[String, Symbol]
+      val caseInsensitively = scala.collection.mutable.HashMap.empty[String, Symbol]
 
       def run(): Unit = {
         while (true) {
@@ -190,18 +190,27 @@ class GenBCodePipeline(val entryPoints: List[Symbol], val int: DottyBackendInter
         val claszSymbol = cd.symbol
 
         // GenASM checks this before classfiles are emitted, https://github.com/scala/scala/commit/e4d1d930693ac75d8eb64c2c3c69f2fc22bec739
-        val lowercaseJavaClassName = claszSymbol.name.toString.toLowerCase
-        caseInsensitively.get(lowercaseJavaClassName) match {
-          case None =>
-            caseInsensitively.put(lowercaseJavaClassName, claszSymbol)
-          case Some(dupClassSym) =>
-            // Order is not deterministic so we enforce lexicographic order between the duplicates for error-reporting
-            if (claszSymbol.name.toString < dupClassSym.name.toString)
-              ctx.warning(s"Class ${claszSymbol.name} differs only in case from ${dupClassSym.name}. " +
-                          "Such classes will overwrite one another on case-insensitive filesystems.", claszSymbol.pos)
-            else
-              ctx.warning(s"Class ${dupClassSym.name} differs only in case from ${claszSymbol.name}. " +
-                          "Such classes will overwrite one another on case-insensitive filesystems.", dupClassSym.pos)
+        def checkName(claszSymbol: Symbol): Unit = {
+          val lowercaseJavaClassName = claszSymbol.effectiveName.toString.toLowerCase
+          caseInsensitively.get(lowercaseJavaClassName) match {
+            case None =>
+              caseInsensitively.put(lowercaseJavaClassName, claszSymbol)
+            case Some(dupClassSym) =>
+              if (claszSymbol.effectiveName.toString != dupClassSym.effectiveName.toString) {
+                // Order is not deterministic so we enforce lexicographic order between the duplicates for error-reporting
+                val (cl1, cl2) =
+                  if (claszSymbol.effectiveName.toString < dupClassSym.effectiveName.toString) (claszSymbol, dupClassSym)
+                  else (dupClassSym, claszSymbol)
+                ctx.warning(s"Class ${cl1.effectiveName} differs only in case from ${cl2.effectiveName}. " +
+                  "Such classes will overwrite one another on case-insensitive filesystems.", cl1.pos)
+              }
+          }
+        }
+        checkName(claszSymbol)
+        if (int.symHelper(claszSymbol).isModuleClass) {
+          val companionModule = claszSymbol.companionModule
+          if (int.symHelper(companionModule.owner).isPackageClass)
+            checkName(companionModule)
         }
 
         // -------------- mirror class, if needed --------------

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

@@ -66,6 +66,7 @@ class Compiler {
          new NormalizeFlags,         // Rewrite some definition flags
          new ExtensionMethods,       // Expand methods of value classes with extension methods
          new ExpandSAMs,             // Expand single abstract method closures to anonymous classes
+         new ShortcutImplicits,      // Allow implicit functions without creating closures
          new TailRec,                // Rewrite tail recursion to loops
          new ByNameClosures,         // Expand arguments to by-name parameters to closures
          new LiftTry,                // Put try expressions that might execute on non-empty stacks into their own methods
@@ -76,11 +77,11 @@ class Compiler {
          new PatternMatcher,         // Compile pattern matches
          new ExplicitOuter,          // Add accessors to outer classes from nested ones.
          new ExplicitSelf,           // Make references to non-trivial self types explicit as casts
-         new ShortcutImplicits,      // Allow implicit functions without creating closures
          new StringInterpolatorOpt,  // Optimizes raw and s string interpolators by rewriting them to string concatentations
          new CrossCastAnd,           // Normalize selections involving intersection types.
          new Splitter) ::            // Expand selections involving union types into conditionals
     List(new ErasedDecls,            // Removes all erased defs and vals decls (except for parameters)
+         new IsInstanceOfChecker,    // check runtime realisability for `isInstanceOf`
          new VCInlineMethods,        // Inlines calls to value class methods
          new SeqLiterals,            // Express vararg arguments as arrays
          new InterceptedMethods,     // Special handling of `==`, `|=`, `getClass` methods

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

@@ -157,7 +157,8 @@ class Run(comp: Compiler, ictx: Context) extends ImplicitRunInfo with Constraint
       if (ctx.settings.YtestPickler.value) List("pickler")
       else ctx.settings.YstopAfter.value
 
-    val phases = ctx.squashPhases(ctx.phasePlan,
+    val pluginPlan = ctx.addPluginPhases(ctx.phasePlan)
+    val phases = ctx.squashPhases(pluginPlan,
       ctx.settings.Yskip.value, ctx.settings.YstopBefore.value, stopAfter, ctx.settings.Ycheck.value)
     ctx.usePhases(phases)
 

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

@@ -50,7 +50,7 @@ object desugar {
    */
   class DerivedFromParamTree(suffix: String) extends DerivedTypeTree {
 
-    /** Make sure that for all enclosing module classes their companion lasses
+    /** Make sure that for all enclosing module classes their companion classes
      *  are completed. Reason: We need the constructor of such companion classes to
      *  be completed so that OriginalSymbol attachments are pushed to DerivedTypeTrees
      *  in apply/unapply methods.
@@ -429,7 +429,6 @@ object desugar {
         }
         val hasRepeatedParam = constrVparamss.exists(_.exists {
           case ValDef(_, tpt, _) => isRepeated(tpt)
-          case _ => false
         })
         if (mods.is(Abstract) || hasRepeatedParam) Nil  // cannot have default arguments for repeated parameters, hence copy method is not issued
         else {

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

@@ -771,7 +771,7 @@ object Trees {
   def flatten[T >: Untyped](trees: List[Tree[T]]): List[Tree[T]] = {
     var buf: ListBuffer[Tree[T]] = null
     var xs = trees
-    while (xs.nonEmpty) {
+    while (!xs.isEmpty) {
       xs.head match {
         case Thicket(elems) =>
           if (buf == null) {
@@ -805,7 +805,7 @@ object Trees {
     def unforced: AnyRef
     protected def force(x: AnyRef): Unit
     def forceIfLazy(implicit ctx: Context): T = unforced match {
-      case lzy: Lazy[T] =>
+      case lzy: Lazy[T @unchecked] =>
         val x = lzy.complete
         force(x)
         x

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

@@ -60,7 +60,7 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
   class NonEmptyFunction(args: List[Tree], body: Tree, val mods: Modifiers) extends Function(args, body)
 
   /** A function created from a wildcard expression
-   *  @param  placeHolderParams  a list of definitions of synthetic parameters
+   *  @param  placeholderParams  a list of definitions of synthetic parameters.
    *  @param  body               the function body where wildcards are replaced by
    *                             references to synthetic parameters.
    */

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

@@ -114,14 +114,15 @@ object CompilerCommand extends DotClass {
 
     def shouldStopWithInfo = {
       import settings._
-      Set(help, Xhelp, Yhelp) exists (_.value)
+      Set(help, Xhelp, Yhelp, showPlugins) exists (_.value)
     }
 
     def infoMessage: String = {
       import settings._
       if (help.value) usageMessage
       else if (Xhelp.value) xusageMessage
       else if (Yhelp.value) yusageMessage
+      else if (showPlugins.value) ctx.pluginDescriptions
       else ""
     }
 

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

@@ -28,6 +28,7 @@ object Printers {
   val overload: Printer = noPrinter
   val patmatch: Printer = noPrinter
   val pickling: Printer = noPrinter
+  val plugins: Printer = noPrinter
   val simplify: Printer = noPrinter
   val subtyping: Printer = noPrinter
   val transforms: Printer = noPrinter

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

@@ -56,7 +56,7 @@ trait PropertiesTrait {
   def scalaPropOrElse(name: String, alt: String): String = scalaProps.getProperty(name, alt)
   def scalaPropOrEmpty(name: String): String             = scalaPropOrElse(name, "")
   def scalaPropOrNone(name: String): Option[String]      = Option(scalaProps.getProperty(name))
-  
+
   /** Either the development or release version if known, otherwise
    *  the empty string.
    */
@@ -73,7 +73,15 @@ trait PropertiesTrait {
       } else ""
     }
   }
-  
+
+  /** Whether the current version of compiler is experimental
+   *
+   *  1. Snapshot and nightly releases are experimental.
+   *  2. Features supported by experimental versions of the compiler:
+   *     - research plugins
+   */
+  val experimental = versionString.contains("SNAPSHOT") || versionString.contains("NIGHTLY")
+
   val copyrightString       = scalaPropOrElse("copyright.string", "(c) 2002-2017 LAMP/EPFL")
 
   /** This is the encoding to use reading in source files, overridden with -encoding

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

@@ -50,6 +50,14 @@ class ScalaSettings extends Settings.SettingGroup {
   val printTasty = BooleanSetting("-print-tasty", "Prints the raw tasty when decompiling.")
   val printLines = BooleanSetting("-print-lines", "Show source code line numbers.")
 
+  /** Plugin-related setting */
+  val plugin             = MultiStringSetting  ("-Xplugin", "paths", "Load a plugin from each classpath.")
+  val disable            = MultiStringSetting  ("-Xplugin-disable", "plugin", "Disable plugins by name.")
+  val require            = MultiStringSetting  ("-Xplugin-require", "plugin", "Abort if a named plugin is not loaded.")
+  val showPlugins        = BooleanSetting      ("-Xplugin-list", "Print a synopsis of loaded plugins.")
+  val pluginsDir         = StringSetting       ("-Xpluginsdir", "path", "Path to search for plugin archives.", Defaults.scalaPluginPath)
+  val pluginOptions      = MultiStringSetting  ("-P", "plugin:opt", "Pass an option to a plugin, e.g. -P:<plugin>:<opt>")
+
   /** -X "Advanced" settings
    */
   val Xhelp = BooleanSetting("-X", "Print a synopsis of advanced options.")

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

@@ -30,8 +30,8 @@ object CheckRealizable {
   class NotFinal(sym: Symbol)(implicit ctx: Context)
   extends Realizability(i" refers to nonfinal $sym")
 
-  class HasProblemBounds(typ: SingleDenotation)(implicit ctx: Context)
-  extends Realizability(i" has a member $typ with possibly conflicting bounds ${typ.info.bounds.lo} <: ... <: ${typ.info.bounds.hi}")
+  class HasProblemBounds(name: Name, info: Type)(implicit ctx: Context)
+  extends Realizability(i" has a member $name with possibly conflicting bounds ${info.bounds.lo} <: ... <: ${info.bounds.hi}")
 
   class HasProblemBaseArg(typ: Type, argBounds: TypeBounds)(implicit ctx: Context)
   extends Realizability(i" has a base type $typ with possibly conflicting parameter bounds ${argBounds.lo} <: ... <: ${argBounds.hi}")
@@ -96,6 +96,14 @@ class CheckRealizable(implicit ctx: Context) {
       else boundsRealizability(tp).andAlso(memberRealizability(tp))
   }
 
+  private def refinedNames(tp: Type): Set[Name] = tp.dealias match {
+    case tp: RefinedType => refinedNames(tp.parent) + tp.refinedName
+    case tp: AndType => refinedNames(tp.tp1) ++ refinedNames(tp.tp2)
+    case tp: OrType  => refinedNames(tp.tp1) ++ refinedNames(tp.tp2)
+    case tp: TypeProxy => refinedNames(tp.underlying)
+    case _ => Set.empty
+  }
+
   /** `Realizable` if `tp` has good bounds, a `HasProblem...` instance
    *  pointing to a bad bounds member otherwise. "Has good bounds" means:
    *
@@ -107,12 +115,22 @@ class CheckRealizable(implicit ctx: Context) {
    *       also lead to base types with bad bounds).
    */
   private def boundsRealizability(tp: Type) = {
-    val mbrProblems =
+
+    val memberProblems =
       for {
         mbr <- tp.nonClassTypeMembers
         if !(mbr.info.loBound <:< mbr.info.hiBound)
       }
-      yield new HasProblemBounds(mbr)
+      yield new HasProblemBounds(mbr.name, mbr.info)
+
+    val refinementProblems =
+      for {
+        name <- refinedNames(tp)
+        if (name.isTypeName)
+        mbr <- tp.member(name).alternatives
+        if !(mbr.info.loBound <:< mbr.info.hiBound)
+      }
+      yield new HasProblemBounds(name, mbr.info)
 
     def baseTypeProblems(base: Type) = base match {
       case AndType(base1, base2) =>
@@ -126,12 +144,13 @@ class CheckRealizable(implicit ctx: Context) {
     val baseProblems =
       tp.baseClasses.map(_.baseTypeOf(tp)).flatMap(baseTypeProblems)
 
-    (((Realizable: Realizability)
-      /: mbrProblems)(_ andAlso _)
+    ((((Realizable: Realizability)
+      /: memberProblems)(_ andAlso _)
+      /: refinementProblems)(_ andAlso _)
       /: baseProblems)(_ andAlso _)
   }
 
-  /** `Realizable` if all of `tp`'s non-struct fields have realizable types,
+  /** `Realizable` if all of `tp`'s non-strict fields have realizable types,
    *  a `HasProblemField` instance pointing to a bad field otherwise.
    */
   private def memberRealizability(tp: Type) = {

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

@@ -35,6 +35,7 @@ import dotty.tools.dotc.profile.Profiler
 import util.Property.Key
 import util.Store
 import xsbti.AnalysisCallback
+import plugins._
 
 object Contexts {
 
@@ -76,6 +77,7 @@ object Contexts {
                             with SymDenotations
                             with Reporting
                             with NamerContextOps
+                            with Plugins
                             with Cloneable { thiscontext =>
     implicit def ctx: Context = this
 

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

@@ -1020,12 +1020,6 @@ object Denotations {
       interval
     }
 
-    /** For ClassDenotations only:
-     *  If caches influenced by parent classes are still valid, the denotation
-     *  itself, otherwise a freshly initialized copy.
-     */
-    def syncWithParents(implicit ctx: Context): SingleDenotation = this
-
     /** Show declaration string; useful for showing declarations
      *  as seen from subclasses.
      */

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

@@ -64,7 +64,7 @@ trait Hashable {
     var h = seed
     var xs = tps
     var len = arity
-    while (xs.nonEmpty) {
+    while (!xs.isEmpty) {
       val elemHash = typeHash(bs, xs.head)
       if (elemHash == NotCached) return NotCached
       h = hashing.mix(h, elemHash)

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

@@ -82,7 +82,7 @@ object Phases {
     final def squashPhases(phasess: List[List[Phase]],
                              phasesToSkip: List[String], stopBeforePhases: List[String], stopAfterPhases: List[String], YCheckAfter: List[String]): List[Phase] = {
       val squashedPhases = ListBuffer[Phase]()
-      var prevPhases: Set[Class[_ <: Phase]] = Set.empty
+      var prevPhases: Set[String] = Set.empty
       val YCheckAll = YCheckAfter.contains("all")
 
       var stop = false
@@ -99,7 +99,6 @@ object Phases {
           val filteredPhaseBlock = filteredPhases(i)
           val phaseToAdd =
             if (filteredPhaseBlock.length > 1) {
-              val phasesInBlock: Set[String] = filteredPhaseBlock.map(_.phaseName).toSet
               for (phase <- filteredPhaseBlock) {
                 phase match {
                   case p: MiniPhase =>
@@ -112,11 +111,11 @@ object Phases {
                 }
               }
               val superPhase = new MegaPhase(filteredPhaseBlock.asInstanceOf[List[MiniPhase]].toArray)
-              prevPhases ++= filteredPhaseBlock.map(_.getClazz)
+              prevPhases ++= filteredPhaseBlock.map(_.phaseName)
               superPhase
             } else { // block of a single phase, no squashing
               val phase = filteredPhaseBlock.head
-              prevPhases += phase.getClazz
+              prevPhases += phase.phaseName
               phase
             }
           squashedPhases += phaseToAdd
@@ -147,7 +146,7 @@ object Phases {
 
       phases = (NoPhase :: flatPhases.toList ::: new TerminalPhase :: Nil).toArray
       setSpecificPhases()
-      var phasesAfter:Set[Class[_ <: Phase]] = Set.empty
+      var phasesAfter: Set[String] = Set.empty
       nextDenotTransformerId = new Array[Int](phases.length)
       denotTransformers = new Array[DenotTransformer](phases.length)
 
@@ -161,7 +160,7 @@ object Phases {
         val unmetPrecedeRequirements = p.runsAfter -- phasesAfter
         assert(unmetPrecedeRequirements.isEmpty,
           s"phase ${p} has unmet requirement: ${unmetPrecedeRequirements.mkString(", ")} should precede this phase")
-        phasesAfter += p.getClazz
+        phasesAfter += p.phaseName
 
       }
       var i = 0
@@ -281,7 +280,7 @@ object Phases {
     def allowsImplicitSearch: Boolean = false
 
      /** List of names of phases that should precede this phase */
-    def runsAfter: Set[Class[_ <: Phase]] = Set.empty
+    def runsAfter: Set[String] = Set.empty
 
     /** @pre `isRunnable` returns true */
     def run(implicit ctx: Context): Unit
@@ -383,22 +382,10 @@ object Phases {
     override def toString = phaseName
   }
 
-  trait NeedsCompanions {
-    def isCompanionNeeded(cls: ClassSymbol)(implicit ctx: Context): Boolean
-  }
-
   /** Replace all instances of `oldPhaseClass` in `current` phases
    *  by the result of `newPhases` applied to the old phase.
    */
   def replace(oldPhaseClass: Class[_ <: Phase], newPhases: Phase => List[Phase], current: List[List[Phase]]): List[List[Phase]] =
     current.map(_.flatMap(phase =>
       if (oldPhaseClass.isInstance(phase)) newPhases(phase) else phase :: Nil))
-
-  /** Dotty deviation: getClass yields Class[_], instead of [Class <: <type of receiver>].
-   *  We can get back the old behavior using this decorator. We should also use the same
-   *  trick for standard getClass.
-   */
-  private implicit class getClassDeco[T](val x: T) extends AnyVal {
-    def getClazz: Class[_ <: T] = x.getClass.asInstanceOf[Class[_ <: T]]
-  }
 }