Merge remote-tracking branch 'origin/2.10.x' into merge-210

* origin/2.10.x:
  Fix for paramaccessor alias regression.
  Expanded bytecode testing code.
  SI-5675 Discard duplicate feature warnings at a position
  accommodates pull request feedback
  term and type reftrees are now reified uniformly
  SI-6591 Reify and path-dependent types
  SI-7096 SubstSymMap copies trees before modifying their symbols
  SI-6961 no structural sharing in list serialization
  SI-6187 Make partial functions re-typable
  [backport] SI-6478 Fixing JavaTokenParser ident
  SI-7100 Fixed infinite recursion in duplicators
  SI-6146 More accurate prefixes for sealed subtypes.
  SI-5082 Cycle avoidance between case companions
  SI-6113 typeOf now works for type lambdas
  SI-5824 Fix crashes in reify with _*
  SI-7026: parseTree should never return a typed one
  SI-7070 Turn restriction on companions in pkg objs into warning

Conflicts:
	src/compiler/scala/reflect/reify/codegen/GenSymbols.scala
	src/compiler/scala/tools/nsc/typechecker/PatternMatching.scala
	src/compiler/scala/tools/nsc/typechecker/Typers.scala
	src/compiler/scala/tools/reflect/ToolBoxFactory.scala
	src/library/scala/collection/immutable/List.scala
	src/reflect/scala/reflect/internal/TreeInfo.scala
	src/reflect/scala/reflect/internal/Types.scala
	src/reflect/scala/reflect/internal/settings/MutableSettings.scala
	src/reflect/scala/reflect/runtime/Settings.scala
	test/files/buildmanager/t2650_1/t2650_1.check
	test/files/buildmanager/t2657/t2657.check
	test/files/neg/t3234.check
	test/files/run/idempotency-this.check
	test/files/run/macro-typecheck-macrosdisabled2.check
	test/files/run/showraw_tree.check
	test/files/run/showraw_tree_ids.check
	test/files/run/showraw_tree_kinds.check
	test/files/run/showraw_tree_types_ids.check
	test/files/run/showraw_tree_types_typed.check
	test/files/run/showraw_tree_types_untyped.check
	test/files/run/showraw_tree_ultimate.check
	test/files/run/t2886.check
	test/files/run/t5225_2.check
	test/files/run/t5374.check
	test/files/run/t5374.scala
	test/files/run/t6329_repl.check
	test/files/run/toolbox_typecheck_macrosdisabled2.check

Author: paulp

src/compiler/scala/reflect/reify/codegen/GenSymbols.scala

@@ -1,6 +1,8 @@
 package scala.reflect.reify
 package codegen
 
+import scala.reflect.internal.Flags._
+
 trait GenSymbols {
   self: Reifier =>
 
@@ -99,6 +101,33 @@ trait GenSymbols {
     reifyIntoSymtab(binding.symbol) { sym =>
       if (reifyDebug) println("Free term" + (if (sym.isCapturedVariable) " (captured)" else "") + ": " + sym + "(" + sym.accurateKindString + ")")
       val name = newTermName("" + nme.REIFY_FREE_PREFIX + sym.name + (if (sym.isType) nme.REIFY_FREE_THIS_SUFFIX else ""))
+      // We need to note whether the free value being reified is stable or not to guide subsequent reflective compilation.
+      // Here's why reflection compilation needs our help.
+      //
+      // When dealing with a tree, which contain free values, toolboxes extract those and wrap the entire tree in a Function
+      // having parameters defined for every free values in the tree. For example, evaluating
+      //
+      //   Ident(setTypeSignature(newFreeTerm("x", 2), <Int>))
+      //
+      // Will generate something like
+      //
+      //   object wrapper {
+      //     def wrapper(x: () => Int) = {
+      //       x()
+      //     }
+      //   }
+      //
+      // Note that free values get transformed into, effectively, by-name parameters. This is done to make sure
+      // that evaluation order is kept intact. And indeed, we cannot just evaluate all free values at once in order
+      // to obtain arguments for wrapper.wrapper, because if some of the free values end up being unused during evaluation,
+      // we might end up doing unnecessary calculations.
+      //
+      // So far, so good - we didn't need any flags at all. However, if the code being reified contains path-dependent types,
+      // we're in trouble, because valid code like `free.T` ends up being transformed into `free.apply().T`, which won't compile.
+      //
+      // To overcome this glitch, we note whether a given free term is stable or not (because vars can also end up being free terms).
+      // Then, if a free term is stable, we tell the compiler to treat `free.apply()` specially and assume that it's stable.
+      if (!sym.isMutable) sym setFlag STABLE
       if (sym.isCapturedVariable) {
         assert(binding.isInstanceOf[Ident], showRaw(binding))
         val capturedBinding = referenceCapturedVariable(sym)

src/compiler/scala/reflect/reify/codegen/GenTrees.scala

@@ -155,29 +155,31 @@ trait GenTrees {
         else mirrorCall(nme.Ident, reify(name))
 
       case Select(qual, name) =>
-        if (sym == NoSymbol || sym.name == name)
-          reifyProduct(tree)
-        else
-          reifyProduct(Select(qual, sym.name))
+        if (qual.symbol != null && qual.symbol.isPackage) {
+          mirrorBuildCall(nme.Ident, reify(sym))
+        } else {
+          val effectiveName = if (sym != null && sym != NoSymbol) sym.name else name
+          reifyProduct(Select(qual, effectiveName))
+        }
 
       case _ =>
         throw new Error("internal error: %s (%s, %s) is not supported".format(tree, tree.productPrefix, tree.getClass))
     }
   }
 
-  private def reifyBoundType(tree: Tree): Tree = {
+  private def reifyBoundType(tree: RefTree): Tree = {
     val sym = tree.symbol
     val tpe = tree.tpe
 
-    def reifyBoundType(tree: Tree): Tree = {
+    def reifyBoundType(tree: RefTree): Tree = {
       assert(tpe != null, "unexpected: bound type that doesn't have a tpe: " + showRaw(tree))
 
       // if a symbol or a type of the scrutinee are local to reifee
       // (e.g. point to a locally declared class or to a path-dependent thingie that depends on a local variable)
       // then we can reify the scrutinee as a symless AST and that will definitely be hygienic
       // why? because then typechecking of a scrutinee doesn't depend on the environment external to the quasiquote
       // otherwise we need to reify the corresponding type
-      if (sym.isLocalToReifee || tpe.isLocalToReifee)
+      if (sym.isLocalToReifee || tpe.isLocalToReifee || treeInfo.isWildcardStarType(tree))
         reifyProduct(tree)
       else {
         if (reifyDebug) println("reifying bound type %s (underlying type is %s)".format(sym, tpe))
@@ -198,13 +200,19 @@ trait GenTrees {
               mirrorBuildCall(nme.TypeTree, spliced)
           }
         }
-        else if (sym.isLocatable) {
-          if (reifyDebug) println("tpe is locatable: reify as Ident(%s)".format(sym))
-          mirrorBuildCall(nme.Ident, reify(sym))
-        }
-        else {
-          if (reifyDebug) println("tpe is not locatable: reify as TypeTree(%s)".format(tpe))
-          mirrorBuildCall(nme.TypeTree, reify(tpe))
+        else tree match {
+          case Select(qual, name) if !qual.symbol.isPackage =>
+            if (reifyDebug) println(s"reifying Select($qual, $name)")
+            mirrorCall(nme.Select, reify(qual), reify(name))
+          case SelectFromTypeTree(qual, name) =>
+            if (reifyDebug) println(s"reifying SelectFromTypeTree($qual, $name)")
+            mirrorCall(nme.SelectFromTypeTree, reify(qual), reify(name))
+          case _ if sym.isLocatable =>
+            if (reifyDebug) println(s"tpe is locatable: reify as Ident($sym)")
+            mirrorBuildCall(nme.Ident, reify(sym))
+          case _ =>
+            if (reifyDebug) println(s"tpe is not locatable: reify as TypeTree($tpe)")
+            mirrorBuildCall(nme.TypeTree, reify(tpe))
         }
       }
     }

src/compiler/scala/reflect/reify/codegen/GenTypes.scala

@@ -69,8 +69,7 @@ trait GenTypes {
   def reificationIsConcrete: Boolean = state.reificationIsConcrete
 
   def spliceType(tpe: Type): Tree = {
-    val quantified = currentQuantified
-    if (tpe.isSpliceable && !(quantified contains tpe.typeSymbol)) {
+    if (tpe.isSpliceable && !(boundSymbolsInCallstack contains tpe.typeSymbol)) {
       if (reifyDebug) println("splicing " + tpe)
 
       val tagFlavor = if (concrete) tpnme.TypeTag.toString else tpnme.WeakTypeTag.toString

src/compiler/scala/reflect/reify/phases/Reify.scala

@@ -26,7 +26,10 @@ trait Reify extends GenSymbols
       finally currents = currents.tail
     }
   }
-  def currentQuantified = flatCollect(reifyStack.currents)({ case ExistentialType(quantified, _) => quantified })
+  def boundSymbolsInCallstack = flatCollect(reifyStack.currents) {
+    case ExistentialType(quantified, _) => quantified
+    case PolyType(typeParams, _) => typeParams
+  }
   def current = reifyStack.currents.head
   def currents = reifyStack.currents
 

src/compiler/scala/reflect/reify/phases/Reshape.scala

@@ -187,24 +187,28 @@ trait Reshape {
     }
 
     private def toPreTyperTypedOrAnnotated(tree: Tree): Tree = tree match {
-      case ty @ Typed(expr1, tt @ TypeTree()) =>
+      case ty @ Typed(expr1, tpt) =>
         if (reifyDebug) println("reify typed: " + tree)
+        val original = tpt match {
+          case tt @ TypeTree() => tt.original
+          case tpt => tpt
+        }
         val annotatedArg = {
           def loop(tree: Tree): Tree = tree match {
             case annotated1 @ Annotated(ann, annotated2 @ Annotated(_, _)) => loop(annotated2)
             case annotated1 @ Annotated(ann, arg) => arg
             case _ => EmptyTree
           }
 
-          loop(tt.original)
+          loop(original)
         }
         if (annotatedArg != EmptyTree) {
           if (annotatedArg.isType) {
             if (reifyDebug) println("verdict: was an annotated type, reify as usual")
             ty
           } else {
-            if (reifyDebug) println("verdict: was an annotated value, equivalent is " + tt.original)
-            toPreTyperTypedOrAnnotated(tt.original)
+            if (reifyDebug) println("verdict: was an annotated value, equivalent is " + original)
+            toPreTyperTypedOrAnnotated(original)
           }
         } else {
           if (reifyDebug) println("verdict: wasn't annotated, reify as usual")

src/compiler/scala/reflect/reify/utils/Extractors.scala

@@ -263,12 +263,12 @@ trait Extractors {
   }
 
   object BoundType {
-    def unapply(tree: Tree): Option[Tree] = tree match {
-      case Select(_, name) if name.isTypeName =>
+    def unapply(tree: Tree): Option[RefTree] = tree match {
+      case tree @ Select(_, name) if name.isTypeName =>
         Some(tree)
-      case SelectFromTypeTree(_, name) if name.isTypeName =>
+      case tree @ SelectFromTypeTree(_, _) =>
         Some(tree)
-      case Ident(name) if name.isTypeName =>
+      case tree @ Ident(name) if name.isTypeName =>
         Some(tree)
       case _ =>
         None

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

@@ -1107,13 +1107,13 @@ class Global(var currentSettings: Settings, var reporter: Reporter)
 
   /** Collects for certain classes of warnings during this run. */
   class ConditionalWarning(what: String, option: Settings#BooleanSetting) {
-    val warnings = new mutable.ListBuffer[(Position, String)]
+    val warnings = mutable.LinkedHashMap[Position, String]()
     def warn(pos: Position, msg: String) =
       if (option.value) reporter.warning(pos, msg)
-      else warnings += ((pos, msg))
+      else if (!(warnings contains pos)) warnings += ((pos, msg))
     def summarize() =
-      if (option.isDefault && warnings.nonEmpty)
-        reporter.warning(NoPosition, "there were %d %s warnings; re-run with %s for details".format(warnings.size, what, option.name))
+      if (warnings.nonEmpty && (option.isDefault || settings.fatalWarnings.value))
+        warning("there were %d %s warning(s); re-run with %s for details".format(warnings.size, what, option.name))
   }
 
   def newUnitParser(code: String)      = new syntaxAnalyzer.UnitParser(newCompilationUnit(code))

src/compiler/scala/tools/nsc/doc/ScaladocGlobal.scala

@@ -12,7 +12,7 @@ import typechecker.Analyzer
 import scala.reflect.internal.util.BatchSourceFile
 
 trait ScaladocAnalyzer extends Analyzer {
-  val global : ScaladocGlobal
+  val global : Global // generally, a ScaladocGlobal
   import global._
 
   override def newTyper(context: Context): ScaladocTyper = new ScaladocTyper(context)

src/compiler/scala/tools/nsc/interactive/CompilerControl.scala

@@ -256,15 +256,12 @@ trait CompilerControl { self: Global =>
   }
 
   /** Returns parse tree for source `source`. No symbols are entered. Syntax errors are reported.
-   *  Can be called asynchronously from presentation compiler.
+   *
+   *  This method is thread-safe and as such can safely run outside of the presentation
+   *  compiler thread.
    */
-  def parseTree(source: SourceFile): Tree = ask { () =>
-    getUnit(source) match {
-      case Some(unit) if unit.status >= JustParsed =>
-        unit.body
-      case _ =>
-        new UnitParser(new CompilationUnit(source)).parse()
-    }
+  def parseTree(source: SourceFile): Tree = {
+    new UnitParser(new CompilationUnit(source)).parse()
   }
 
   /** Asks for a computation to be done quickly on the presentation compiler thread */

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

@@ -221,7 +221,10 @@ class Global(settings: Settings, _reporter: Reporter, projectName: String = "")
   /** Called from parser, which signals hereby that a method definition has been parsed.
    */
   override def signalParseProgress(pos: Position) {
-    checkForMoreWork(pos)
+    // We only want to be interruptible when running on the PC thread.
+    if(onCompilerThread) {
+      checkForMoreWork(pos)
+    }
   }
 
   /** Called from typechecker, which signals hereby that a node has been completely typechecked.
@@ -408,7 +411,7 @@ class Global(settings: Settings, _reporter: Reporter, projectName: String = "")
    */
   @elidable(elidable.WARNING)
   override def assertCorrectThread() {
-    assert(initializing || (Thread.currentThread() eq compileRunner),
+    assert(initializing || onCompilerThread,
         "Race condition detected: You are running a presentation compiler method outside the PC thread.[phase: %s]".format(globalPhase) +
         " Please file a ticket with the current stack trace at https://www.assembla.com/spaces/scala-ide/support/tickets")
   }