Merge branch 'master' into no-legacy-no-more

Author: OlivierBlanvillain

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

@@ -40,7 +40,7 @@ object CheckRealizable {
   extends Realizability(i" has conflicting base types $base1 and $base2")
 
   class HasProblemField(fld: SingleDenotation, problem: Realizability)(implicit ctx: Context)
-  extends Realizability(i" has a member $fld which is not a legal path\n since ${fld.symbol.name}: ${fld.info}${problem.msg}")
+  extends Realizability(i" has a member $fld which is not a legal path\nsince ${fld.symbol.name}: ${fld.info}${problem.msg}")
 
   class ProblemInUnderlying(tp: Type, problem: Realizability)(implicit ctx: Context)
   extends Realizability(i"s underlying type ${tp}${problem.msg}") {

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

@@ -234,7 +234,7 @@ trait ConstraintHandling {
         typr.println(s"approx ${param.show}, from below = $fromBelow, bound = ${bound.show}, inst = ${inst.show}")
         inst
       case inst =>
-        assert(inst.exists, i"param = $param\n constraint = $constraint")
+        assert(inst.exists, i"param = $param\nconstraint = $constraint")
         inst
     }
   }

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

@@ -82,7 +82,7 @@ trait SymDenotations { this: Context =>
     }
     denot match {
       case denot: SymDenotation =>
-        def explainSym(msg: String) = explain(s"$msg\n defined = ${denot.definedPeriodsString}")
+        def explainSym(msg: String) = explain(s"$msg\ndefined = ${denot.definedPeriodsString}")
         if (denot.is(ValidForever) || denot.isRefinementClass) true
         else {
           implicit val ctx = this

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

@@ -311,7 +311,7 @@ abstract class SymbolLoader extends LazyType {
       val msg = ex.getMessage()
       ctx.error(
         if (msg eq null) "i/o error while loading " + root.name
-        else "error while loading " + root.name + ",\n " + msg)
+        else "error while loading " + root.name + ",\n" + msg)
     }
     try {
       val start = currentTime

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

@@ -160,7 +160,7 @@ class LazyVals extends MiniPhase with IdentityDenotTransformer {
           ref(initSymbol).ensureApplied).ensureConforms(tpe)
 
         val methodTree = DefDef(x.symbol.asTerm, methodBody)
-        ctx.debuglog(s"found a lazy val ${x.show},\n rewrote with ${holderTree.show}")
+        ctx.debuglog(s"found a lazy val ${x.show},\nrewrote with ${holderTree.show}")
         Thicket(holderTree, initTree, methodTree)
     }
 

compiler/src/dotty/tools/dotc/typer/Applications.scala

@@ -94,7 +94,7 @@ object Applications {
     def fail = {
       val addendum =
         if (ctx.scala2Mode && unapplyName == nme.unapplySeq)
-          "\n You might want to try to rewrite the extractor to use `unapply` instead."
+          "\nYou might want to try to rewrite the extractor to use `unapply` instead."
       ctx.error(em"$unapplyResult is not a valid result type of an $unapplyName method of an extractor$addendum", pos)
       Nil
     }
@@ -785,7 +785,7 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
 
   /** Overridden in ReTyper to handle primitive operations that can be generated after erasure */
   protected def handleUnexpectedFunType(tree: untpd.Apply, fun: Tree)(implicit ctx: Context): Tree =
-    throw new Error(i"unexpected type.\n fun = $fun,\n methPart(fun) = ${methPart(fun)},\n methPart(fun).tpe = ${methPart(fun).tpe},\n tpe = ${fun.tpe}")
+    throw new Error(i"unexpected type.\n  fun = $fun,\n  methPart(fun) = ${methPart(fun)},\n  methPart(fun).tpe = ${methPart(fun).tpe},\n  tpe = ${fun.tpe}")
 
   def typedNamedArgs(args: List[untpd.Tree])(implicit ctx: Context) =
     for (arg @ NamedArg(id, argtpt) <- args) yield {
@@ -971,7 +971,7 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
                 args.init :+ argSeq
               case _ =>
                 val (regularArgs, varArgs) = args.splitAt(argTypes.length - 1)
-                regularArgs :+ untpd.SeqLiteral(varArgs, untpd.TypeTree())
+                regularArgs :+ untpd.SeqLiteral(varArgs, untpd.TypeTree()).withPos(tree.pos)
             }
           else if (argTypes.lengthCompare(1) == 0 && args.lengthCompare(1) > 0 && ctx.canAutoTuple)
             untpd.Tuple(args) :: Nil

compiler/src/dotty/tools/dotc/typer/Checking.scala

@@ -147,7 +147,7 @@ object Checking {
   def checkRealizable(tp: Type, pos: Position)(implicit ctx: Context): Unit = {
     val rstatus = realizability(tp)
     if (rstatus ne Realizable)
-      ctx.errorOrMigrationWarning(em"$tp is not a legal path\n since it${rstatus.msg}", pos)
+      ctx.errorOrMigrationWarning(em"$tp is not a legal path\nsince it${rstatus.msg}", pos)
   }
 
   /** A type map which checks that the only cycles in a type are F-bounds
@@ -434,7 +434,7 @@ object Checking {
           var tp1 =
             if (isLeaked(tp.symbol)) {
               errors =
-                (() => em"non-private $sym refers to private ${tp.symbol}\n in its type signature ${sym.info}") :: errors
+                (() => em"non-private $sym refers to private ${tp.symbol}\nin its type signature ${sym.info}") :: errors
               tp
             }
             else mapOver(tp)
@@ -623,7 +623,7 @@ trait Checking {
             def ofType = if (decl.isType) "" else em": ${other.info}"
             def explanation =
               if (!decl.isRealMethod) ""
-              else "\n (the definitions have matching type signatures)"
+              else "\n(the definitions have matching type signatures)"
             ctx.error(em"$decl is already defined as $other$ofType$explanation", decl.pos)
           }
           if (decl is Synthetic) doubleDefError(other, decl)

compiler/src/dotty/tools/dotc/typer/ErrorReporting.scala

@@ -120,9 +120,9 @@ object ErrorReporting {
       val found1 = dropJavaMethod(found)
       val expected1 = dropJavaMethod(expected)
       if ((found1 eq found) != (expected eq expected1) && (found1 <:< expected1))
-        "\n (Note that Scala's and Java's representation of this type differs)"
+        "\n(Note that Scala's and Java's representation of this type differs)"
       else if (found.topType != expected.topType)
-        "\n (Note that the types are in different universes, see Phantom types)"
+        "\n(Note that the types are in different universes, see Phantom types)"
       else if (ctx.settings.explainTypes.value)
         "\n" + ctx.typerState.show + "\n" + TypeComparer.explained((found <:< expected)(_))
       else

compiler/src/dotty/tools/dotc/typer/Implicits.scala

@@ -336,7 +336,7 @@ object Implicits {
       em"both ${err.refStr(alt1.ref)} and ${err.refStr(alt2.ref)} $qualify"
     override def whyNoConversion(implicit ctx: Context) =
       "\nNote that implicit conversions cannot be applied because they are ambiguous;" +
-      "\n " + explanation
+      "\n" + explanation
   }
 
   class MismatchedImplicit(ref: TermRef,
@@ -788,7 +788,7 @@ trait Implicits { self: Typer =>
             inferImplicit(pt, argument, pos)(ctx.addMode(Mode.OldOverloadingResolution)) match {
               case altResult: SearchSuccess =>
                 ctx.migrationWarning(
-                  s"According to new implicit resolution rules, this will be ambiguous:\n ${result.reason.explanation}",
+                  s"According to new implicit resolution rules, this will be ambiguous:\n${result.reason.explanation}",
                   pos)
                 altResult
               case _ =>

compiler/src/dotty/tools/dotc/typer/RefChecks.scala

@@ -177,7 +177,7 @@ object RefChecks {
               .filter(_.name != member.name)
               .map(_.show).distinct
             if (others1.isEmpty) ""
-            else i";\n other members with override errors are:: $others1%, %"
+            else i";\nother members with override errors are:: $others1%, %"
           }
           ctx.error(msg + othersMsg, clazz.pos)
       }
@@ -216,14 +216,14 @@ object RefChecks {
           (other.owner isSubClass member.owner) && other.is(Deferred) && !member.is(Deferred)
         val addendum =
           if (isConcreteOverAbstract)
-            ";\n (Note that %s is abstract,\n  and is therefore overridden by concrete %s)".format(
+            ";\n  (Note that %s is abstract,\n  and is therefore overridden by concrete %s)".format(
               infoStringWithLocation(other),
               infoStringWithLocation(member))
           else if (ctx.settings.Ydebug.value)
             err.typeMismatchMsg(memberTp(self), otherTp(self))
           else ""
 
-        "error overriding %s;\n %s %s%s".format(
+        "error overriding %s;\n  %s %s%s".format(
           infoStringWithLocation(other), infoString(member), msg, addendum)
       }
 

compiler/test/dotty/tools/StdLibSources.scala

@@ -10,10 +10,10 @@ object StdLibSources {
   /* For debug only */
   private val useExplicitWhiteList = false
 
-  private final val stdLibPath = "../scala2-library/src/library/"
+  private final val stdLibPath = "scala2-library/src/library/"
 
-  def blacklistFile: String = "../compiler/test/dotc/scala-collections.blacklist"
-  private def whitelistFile: String = "../compiler/test/dotc/scala-collections.whitelist"
+  def blacklistFile: String = "compiler/test/dotc/scala-collections.blacklist"
+  private def whitelistFile: String = "compiler/test/dotc/scala-collections.whitelist"
 
   def whitelisted: List[String] = {
     lazy val whitelistBasedOnBlacklist = all.diff(blacklisted)