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