Merge commit 'refs/pull/543/head'; commit 'refs/pull/544/head'; commit 'refs/pull/546/head' into develop

Author: paulp

lib/scala-compiler.jar.desired.sha1

@@ -1 +1 @@
-c020eccb8cf37963725985f36b44d070915cf4d2 ?scala-compiler.jar
+5b3f50d124f84dcda869e17fb0cfd605ed40f385 ?scala-compiler.jar

lib/scala-library.jar.desired.sha1

@@ -1 +1 @@
-31c7188cef85c28b84b9ce35bc6780996e5dd139 ?scala-library.jar
+8f19876a8908e7d7d2a140a8434805cfec2c1346 ?scala-library.jar

src/compiler/scala/reflect/internal/Symbols.scala

@@ -3054,7 +3054,7 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
     override def originalEnclosingMethod = this
 
     override def owner: Symbol =
-      abort("no-symbol does not have an owner (this is a bug: scala " + scala.util.Properties.versionString + ")")
+      abort("no-symbol does not have an owner")
     override def typeConstructor: Type =
       abort("no-symbol does not have a type constructor (this may indicate scalac cannot find fundamental classes)")
   }

src/compiler/scala/tools/ant/templates/tool-unix.tmpl

@@ -9,10 +9,19 @@
 ##############################################################################
 
 findScalaHome () {
-  # see #2092
+  # see SI-2092
   local SOURCE="${BASH_SOURCE[0]}"
   while [ -h "$SOURCE" ] ; do SOURCE="$(readlink "$SOURCE")"; done
-  ( cd -P "$( dirname "$SOURCE" )"/.. && pwd )
+  local bindir="$( dirname "$SOURCE" )"
+  if [[ -d "$bindir"/.. ]]; then
+    ( cd -P "$bindir"/.. && pwd )
+  else
+    # See SI-5792
+    local dir=$(dirname "${BASH_SOURCE[0]}")
+    local link=$(dirname "$(readlink "${BASH_SOURCE[0]}")")
+    local path="$dir/$link/.."
+    ( cd "$path" && pwd )
+  fi
 }
 execCommand () {
   [[ -n $SCALA_RUNNER_DEBUG ]] && echo "" && for arg in "$@@"; do echo "$arg"; done && echo "";

src/compiler/scala/tools/nsc/Global.scala

@@ -130,7 +130,28 @@ class Global(var currentSettings: Settings, var reporter: Reporter) extends Symb
   object nodePrinters extends {
     val global: Global.this.type = Global.this
   } with NodePrinters {
+    var lastPrintedPhase: Phase = NoPhase
+    var lastPrintedSource: String = ""
     infolevel = InfoLevel.Verbose
+
+    def showUnit(unit: CompilationUnit) {
+      print(" // " + unit.source)
+      if (unit.body == null) println(": tree is null")
+      else {
+        val source = util.stringFromWriter(w => newTreePrinter(w) print unit.body)
+
+        // treePrinter show unit.body
+        if (lastPrintedSource == source)
+          println(": tree is unchanged since " + lastPrintedPhase)
+        else {
+          lastPrintedPhase = phase.prev // since we're running inside "afterPhase"
+          lastPrintedSource = source
+          println("")
+          println(source)
+          println("")
+        }
+      }
+    }
   }
 
   def withInfoLevel[T](infolevel: nodePrinters.InfoLevel.Value)(op: => T) = {
@@ -1588,8 +1609,10 @@ class Global(var currentSettings: Settings, var reporter: Reporter) extends Symb
   } // class Run
 
   def printAllUnits() {
-    print("[[syntax trees at end of " + phase + "]]")
-    afterPhase(phase) { currentRun.units foreach (treePrinter.print(_)) }
+    print("[[syntax trees at end of %25s]]".format(phase))
+    afterPhase(phase)(currentRun.units foreach { unit =>
+      nodePrinters showUnit unit
+    })
   }
 
   /** We resolve the class/object ambiguity by passing a type/term name.

src/compiler/scala/tools/nsc/typechecker/Implicits.scala

@@ -1133,16 +1133,27 @@ trait Implicits {
       * An EmptyTree is returned if materialization fails.
       */
     private def tagOfType(pre: Type, tp: Type, tagClass: Symbol): SearchResult = {
-      def success(arg: Tree) =
+      def success(arg: Tree) = {
+        def isMacroException(msg: String): Boolean =
+          // [Eugene] very unreliable, ask Hubert about a better way
+          msg contains "exception during macro expansion"
+
+        def processMacroExpansionError(pos: Position, msg: String): SearchResult = {
+          // giving up and reporting all macro exceptions regardless of their source
+          // this might lead to an avalanche of errors if one of your implicit macros misbehaves
+          if (isMacroException(msg)) context.error(pos, msg)
+          failure(arg, "failed to typecheck the materialized tag: %n%s".format(msg), pos)
+        }
+
         try {
           val tree1 = typed(atPos(pos.focus)(arg))
-          def isErroneous = tree exists (_.isErroneous)
-          if (context.hasErrors) failure(tp, "failed to typecheck the materialized typetag: %n%s".format(context.errBuffer.head.errMsg), context.errBuffer.head.errPos)
+          if (context.hasErrors) processMacroExpansionError(context.errBuffer.head.errPos, context.errBuffer.head.errMsg)
           else new SearchResult(tree1, EmptyTreeTypeSubstituter)
         } catch {
           case ex: TypeError =>
-            failure(arg, "failed to typecheck the materialized typetag: %n%s".format(ex.msg), ex.pos)
+            processMacroExpansionError(ex.pos, ex.msg)
         }
+      }
 
       val prefix = (
         // ClassTags only exist for scala.reflect.mirror, so their materializer