Merge pull request #1521 from felixmulder/topic/better-errormessages

Operation beautify error messages

Author: felixmulder

.gitignore

@@ -3,7 +3,6 @@
 *.log
 *.swp
 *~
-*.swp
 
 # sbt specific
 dist/*
@@ -29,6 +28,7 @@ classes/
 /.worksheet/
 
 # Partest
+dotty.jar
 tests/partest-generated/
 tests/locks/
 /test-classes/

bin/dotr

@@ -29,9 +29,13 @@ function runMain {
     fi
 }
 
+first_arg=$1
+
 if [ -z "$1" ]; then
     echo "Starting dotty REPL..."
     eval "$DOTTY_ROOT/bin/dotc -repl"
+elif [[ ${first_arg:0:1} == "-" ]]; then
+    eval "$DOTTY_ROOT/bin/dotc -repl $@"
 else
     runMain "$@"
 fi

bridge/src/main/scala/xsbt/DelegatingReporter.scala

@@ -6,6 +6,8 @@ package xsbt
 import dotty.tools._
 import dotc._
 import reporting._
+import reporting.diagnostic.MessageContainer
+import reporting.diagnostic.messages
 import core.Contexts._
 
 import xsbti.{Maybe, Position}
@@ -16,19 +18,19 @@ final class DelegatingReporter(delegate: xsbti.Reporter) extends Reporter
 
   override def printSummary(implicit ctx: Context): Unit = delegate.printSummary()
 
-  def doReport(d: Diagnostic)(implicit ctx: Context): Unit = {
-    val severity = 
-      d match {
-        case _: Reporter.Error   => xsbti.Severity.Error
-        case _: Reporter.Warning => xsbti.Severity.Warn
+  def doReport(cont: MessageContainer)(implicit ctx: Context): Unit = {
+    val severity =
+      cont match {
+        case _: messages.Error   => xsbti.Severity.Error
+        case _: messages.Warning => xsbti.Severity.Warn
         case _                   => xsbti.Severity.Info
       }
-    val pos = 
-      if (d.pos.exists) Some(d.pos)
+    val pos =
+      if (cont.pos.exists) Some(cont.pos)
       else None
 
-    val file = 
-      if (d.pos.source.file.exists) Option(d.pos.source.file.file)
+    val file =
+      if (cont.pos.source.file.exists) Option(cont.pos.source.file.file)
       else None
 
     val offset0 = pos.map(_.point)
@@ -43,16 +45,16 @@ final class DelegatingReporter(delegate: xsbti.Reporter) extends Reporter
       def sourcePath: Maybe[String] = maybe(file.map(_.getPath))
     }
 
-    delegate.log(position, d.message, severity)
+    delegate.log(position, cont.message, severity)
   }
 
-  private[this] def maybe[T](opt: Option[T]): Maybe[T] = opt match { 
+  private[this] def maybe[T](opt: Option[T]): Maybe[T] = opt match {
     case None => Maybe.nothing[T]
     case Some(s) => Maybe.just[T](s)
   }
   import java.lang.{ Integer => I }
-  private[this] def maybeInt(opt: Option[Int]): Maybe[I] = opt match { 
+  private[this] def maybeInt(opt: Option[Int]): Maybe[I] = opt match {
     case None => Maybe.nothing[I]
     case Some(s) => Maybe.just[I](s)
   }
-}
+}

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

@@ -9,6 +9,7 @@ import Decorators._
 import language.higherKinds
 import collection.mutable.ListBuffer
 import util.Property
+import reporting.diagnostic.messages._
 
 object desugar {
   import untpd._
@@ -71,7 +72,9 @@ object desugar {
             val defctx = ctx.outersIterator.dropWhile(_.scope eq ctx.scope).next
             var local = defctx.denotNamed(tp.name).suchThat(_ is ParamOrAccessor).symbol
             if (local.exists) (defctx.owner.thisType select local).dealias
-            else throw new Error(s"no matching symbol for ${tp.symbol.showLocated} in ${defctx.owner} / ${defctx.effectiveScope}")
+            else throw new java.lang.Error(
+              s"no matching symbol for ${tp.symbol.showLocated} in ${defctx.owner} / ${defctx.effectiveScope}"
+            )
           case _ =>
             mapOver(tp)
         }
@@ -281,7 +284,7 @@ object desugar {
     val constrVparamss =
       if (constr1.vparamss.isEmpty) { // ensure parameter list is non-empty
         if (isCaseClass)
-          ctx.error("case class needs to have at least one parameter list", cdef.pos)
+          ctx.error(CaseClassMissingParamList(cdef), cdef.namePos)
         ListOfNil
       }
       else constr1.vparamss.nestedMap(toDefParam)

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

@@ -3,8 +3,8 @@ package dotc
 package ast
 
 import core._
-import Types._, Names._, Flags._, util.Positions._, Contexts._, Constants._, SymDenotations._, Symbols._
-import Denotations._, StdNames._, Comments._
+import Types._, Names._, Flags._, util.Positions._, Contexts._, Constants._
+import SymDenotations._, Symbols._, Denotations._, StdNames._, Comments._
 import annotation.tailrec
 import language.higherKinds
 import collection.IndexedSeqOptimized
@@ -308,8 +308,6 @@ object Trees {
         if (rawMods.is(Synthetic)) Position(pos.point, pos.point)
         else Position(pos.point, pos.point + name.length, pos.point)
       else pos
-
-
   }
 
   /** A ValDef or DefDef tree */

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

@@ -23,6 +23,7 @@ class ScalaSettings extends Settings.SettingGroup {
   val migration = BooleanSetting("-migration", "Emit warning and location for migration issues from Scala 2.")
   val encoding = StringSetting("-encoding", "encoding", "Specify character encoding used by source files.", Properties.sourceEncoding)
   val explaintypes = BooleanSetting("-explaintypes", "Explain type errors in more detail.")
+  val explain = BooleanSetting("-explain", "Explain errors in more detail.")
   val feature = BooleanSetting("-feature", "Emit warning and location for usages of features that should be imported explicitly.")
   val g = ChoiceSetting("-g", "level", "Set level of generated debugging info.", List("none", "source", "line", "vars", "notailcalls"), "vars")
   val help = BooleanSetting("-help", "Print a synopsis of standard options")

src/dotty/tools/dotc/core/Decorators.scala

@@ -176,6 +176,10 @@ object Decorators {
      */
     def ex(args: Any*)(implicit ctx: Context): String =
       explained2(implicit ctx => em(args: _*))
+
+    /** Formatter that adds syntax highlighting to all interpolated values */
+    def hl(args: Any*)(implicit ctx: Context): String =
+      new SyntaxFormatter(sc).assemble(args)
   }
 }
 

src/dotty/tools/dotc/core/TypeOps.scala

@@ -36,7 +36,7 @@ trait TypeOps { this: Context => // TODO: Make standalone object.
    *  Instead we produce an annotated type that marks the prefix as unsafe:
    *
    *     (x: (C @ UnsafeNonvariant)#T)C#T
-
+   *
    *  We also set a global state flag `unsafeNonvariant` to the current run.
    *  When typing a Select node, typer will check that flag, and if it
    *  points to the current run will scan the result type of the select for

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

@@ -27,6 +27,8 @@ import rewrite.Rewrites.patch
 object Parsers {
 
   import ast.untpd._
+  import reporting.diagnostic.Message
+  import reporting.diagnostic.messages._
 
   case class OpInfo(operand: Tree, operator: Name, offset: Offset)
 
@@ -97,7 +99,7 @@ object Parsers {
     /** Issue an error at given offset if beyond last error offset
       *  and update lastErrorOffset.
       */
-    def syntaxError(msg: String, offset: Int = in.offset): Unit =
+    def syntaxError(msg: Message, offset: Int = in.offset): Unit =
       if (offset > lastErrorOffset) {
         syntaxError(msg, Position(offset))
         lastErrorOffset = in.offset
@@ -106,7 +108,7 @@ object Parsers {
     /** Unconditionally issue an error at given position, without
       *  updating lastErrorOffset.
       */
-    def syntaxError(msg: String, pos: Position): Unit =
+    def syntaxError(msg: Message, pos: Position): Unit =
       ctx.error(msg, source atPos pos)
 
   }
@@ -213,20 +215,23 @@ object Parsers {
       }
     }
 
-    def warning(msg: String, offset: Int = in.offset) =
+    def warning(msg: Message, sourcePos: SourcePosition) =
+      ctx.warning(msg, sourcePos)
+
+    def warning(msg: Message, offset: Int = in.offset) =
       ctx.warning(msg, source atPos Position(offset))
 
-    def deprecationWarning(msg: String, offset: Int = in.offset) =
+    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 */
-    def incompleteInputError(msg: String) =
+    def incompleteInputError(msg: Message) =
       ctx.incompleteInputError(msg, source atPos Position(in.offset))
 
     /** If at end of file, issue an incompleteInputError.
      *  Otherwise issue a syntax error and skip to next safe point.
      */
-    def syntaxErrorOrIncomplete(msg: String) =
+    def syntaxErrorOrIncomplete(msg: Message) =
       if (in.token == EOF) incompleteInputError(msg)
       else {
         syntaxError(msg)
@@ -732,7 +737,7 @@ object Parsers {
 
     def withTypeRest(t: Tree): Tree =
       if (in.token == WITH) {
-        deprecationWarning("`with' as a type operator has been deprecated; use `&' instead")
+        deprecationWarning(DeprecatedWithOperator())
         in.nextToken()
         AndTypeTree(t, withType())
       }
@@ -1004,28 +1009,33 @@ object Parsers {
           DoWhile(body, cond)
         }
       case TRY =>
+        val tryOffset = in.offset
         atPos(in.skipToken()) {
           val body = expr()
-          val handler =
+          val (handler, handlerStart) =
             if (in.token == CATCH) {
+              val pos = in.offset
               in.nextToken()
-              expr()
-            } else EmptyTree
+              (expr(), pos)
+            } else (EmptyTree, -1)
 
           handler match {
-            case Block(Nil, EmptyTree) => syntaxError(
-              "`catch` block does not contain a valid expression, try adding a case like - `case e: Exception =>` to the block",
-              handler.pos
-            )
+            case Block(Nil, EmptyTree) =>
+              assert(handlerStart != -1)
+              syntaxError(
+                new EmptyCatchBlock(body),
+                Position(handlerStart, handler.pos.end)
+              )
             case _ =>
           }
 
           val finalizer =
             if (in.token == FINALLY) { accept(FINALLY); expr() }
             else {
-              if (handler.isEmpty)
-                warning("A try without `catch` or `finally` is equivalent to putting its body in a block; no exceptions are handled.")
-
+              if (handler.isEmpty) warning(
+                EmptyCatchAndFinallyBlock(body),
+                source atPos Position(tryOffset, body.pos.end)
+              )
               EmptyTree
             }
           ParsedTry(body, handler, finalizer)