SI-5751 cleans up toolboxes for the release

Removes the `freeTypes` parameters on `typeCheckExpr` and `runExpr`,
since we now have public `substituteTypes` on both trees and types.

Also implements long-awaited `inferImplicitValue` and `inferImplicitView`
(thanks to Miles Sabin for nudging me!)

Author: xeno-by

src/compiler/scala/reflect/makro/runtime/Typers.scala

@@ -10,8 +10,9 @@ trait Typers {
 
   def typeCheck(tree: Tree, pt: Type = universe.WildcardType, silent: Boolean = false, withImplicitViewsDisabled: Boolean = false, withMacrosDisabled: Boolean = false): Tree = {
     macroLogVerbose("typechecking %s with expected type %s, implicit views = %s, macros = %s".format(tree, pt, !withImplicitViewsDisabled, !withMacrosDisabled))
-    val wrapper1 = if (!withImplicitViewsDisabled) (callsiteTyper.context.withImplicitsEnabled[Tree] _) else (callsiteTyper.context.withImplicitsDisabled[Tree] _)
-    val wrapper2 = if (!withMacrosDisabled) (callsiteTyper.context.withMacrosEnabled[Tree] _) else (callsiteTyper.context.withMacrosDisabled[Tree] _)
+    val context = callsiteTyper.context
+    val wrapper1 = if (!withImplicitViewsDisabled) (context.withImplicitsEnabled[Tree] _) else (context.withImplicitsDisabled[Tree] _)
+    val wrapper2 = if (!withMacrosDisabled) (context.withMacrosEnabled[Tree] _) else (context.withMacrosDisabled[Tree] _)
     def wrapper (tree: => Tree) = wrapper1(wrapper2(tree))
     // if you get a "silent mode is not available past typer" here
     // don't rush to change the typecheck not to use the silent method when the silent parameter is false
@@ -31,29 +32,21 @@ trait Typers {
 
   def inferImplicitValue(pt: Type, silent: Boolean = true, withMacrosDisabled: Boolean = false, pos: Position = enclosingPosition): Tree = {
     macroLogVerbose("inferring implicit value of type %s, macros = %s".format(pt, !withMacrosDisabled))
-    import universe.analyzer.SearchResult
-    val context = callsiteTyper.context
-    val wrapper1 = if (!withMacrosDisabled) (context.withMacrosEnabled[SearchResult] _) else (context.withMacrosDisabled[SearchResult] _)
-    def wrapper (inference: => SearchResult) = wrapper1(inference)
-    wrapper(universe.analyzer.inferImplicit(universe.EmptyTree, pt, true, false, context, !silent, pos)) match {
-      case failure if failure.tree.isEmpty =>
-        macroLogVerbose("implicit search has failed. to find out the reason, turn on -Xlog-implicits")
-        if (context.hasErrors) throw new universe.TypeError(context.errBuffer.head.errPos, context.errBuffer.head.errMsg)
-        universe.EmptyTree
-      case success =>
-        success.tree
-    }
+    inferImplicit(universe.EmptyTree, pt, isView = false, silent = silent, withMacrosDisabled = withMacrosDisabled, pos = pos)
+  }
+
+  def inferImplicitView(tree: Tree, from: Type, to: Type, silent: Boolean = true, withMacrosDisabled: Boolean = false, pos: Position = enclosingPosition): Tree = {
+    macroLogVerbose("inferring implicit view from %s to %s for %s, macros = %s".format(from, to, tree, !withMacrosDisabled))
+    val viewTpe = universe.appliedType(universe.definitions.FunctionClass(1).asTypeConstructor, List(from, to))
+    inferImplicit(tree, viewTpe, isView = true, silent = silent, withMacrosDisabled = withMacrosDisabled, pos = pos)
   }
 
-  def inferImplicitView(tree: Tree, from: Type, to: Type, silent: Boolean = true, withMacrosDisabled: Boolean = false, reportAmbiguous: Boolean = true, pos: Position = enclosingPosition): Tree = {
-    macroLogVerbose("inferring implicit view from %s to %s for %s, macros = %s, reportAmbiguous = %s".format(from, to, tree, !withMacrosDisabled, reportAmbiguous))
+  private def inferImplicit(tree: Tree, pt: Type, isView: Boolean, silent: Boolean, withMacrosDisabled: Boolean, pos: Position): Tree = {
     import universe.analyzer.SearchResult
     val context = callsiteTyper.context
     val wrapper1 = if (!withMacrosDisabled) (context.withMacrosEnabled[SearchResult] _) else (context.withMacrosDisabled[SearchResult] _)
     def wrapper (inference: => SearchResult) = wrapper1(inference)
-    val fun1 = universe.definitions.FunctionClass(1)
-    val viewTpe = universe.TypeRef(fun1.typeConstructor.prefix, fun1, List(from, to))
-    wrapper(universe.analyzer.inferImplicit(tree, viewTpe, reportAmbiguous, true, context, !silent, pos)) match {
+    wrapper(universe.analyzer.inferImplicit(tree, pt, reportAmbiguous = true, isView = isView, context = context, saveAmbiguousDivergent = !silent, pos = pos)) match {
       case failure if failure.tree.isEmpty =>
         macroLogVerbose("implicit search has failed. to find out the reason, turn on -Xlog-implicits")
         if (context.hasErrors) throw new universe.TypeError(context.errBuffer.head.errPos, context.errBuffer.head.errMsg)

src/compiler/scala/tools/reflect/ToolBox.scala

@@ -24,40 +24,46 @@ trait ToolBox[U <: Universe] {
   /** Typechecks a tree using this ToolBox.
    *  This populates symbols and types of the tree and possibly transforms it to reflect certain desugarings.
    *
-   *  If the tree has unresolved type variables (represented as instances of ``FreeTypeSymbol'' symbols),
-   *  then they might, might be partially or might not be specified in the ``freeTypes'' parameter.
+   *  If the tree has unresolved type variables (represented as instances of `FreeTypeSymbol` symbols),
+   *  then they all have to be resolved first using `Tree.substituteTypes`, or an error occurs.
    *
-   *  If ``silent'' is false, ``TypeError'' will be thrown in case of a typecheck error.
-   *  If ``silent'' is true, the typecheck is silent and will return ``EmptyTree'' if an error occurs.
+   *  If `silent` is false, `TypeError` will be thrown in case of a typecheck error.
+   *  If `silent` is true, the typecheck is silent and will return `EmptyTree` if an error occurs.
    *  Such errors don't vanish and can be inspected by turning on -Ydebug.
    *
    *  Typechecking can be steered with the following optional parameters:
-   *    ``withImplicitViewsDisabled'' recursively prohibits implicit views (though, implicit vals will still be looked up and filled in), default value is false
-   *    ``withMacrosDisabled'' recursively prohibits macro expansions and macro-based implicits, default value is false
+   *    `withImplicitViewsDisabled` recursively prohibits implicit views (though, implicit vals will still be looked up and filled in), default value is false
+   *    `withMacrosDisabled` recursively prohibits macro expansions and macro-based implicits, default value is false
    */
-  def typeCheck(tree: u.Tree, pt: u.Type = u.WildcardType, freeTypes: Map[u.FreeTypeSymbol, u.Type] = Map[u.FreeTypeSymbol, u.Type](), silent: Boolean = false, withImplicitViewsDisabled: Boolean = false, withMacrosDisabled: Boolean = false): u.Tree
+  def typeCheck(tree: u.Tree, pt: u.Type = u.WildcardType, silent: Boolean = false, withImplicitViewsDisabled: Boolean = false, withMacrosDisabled: Boolean = false): u.Tree
 
-
-  /** Infers an implicit value of the expected type ``pt'' in the macro callsite context.
+  /** Infers an implicit value of the expected type `pt` in top-level context.
+   *  Optional `pos` parameter provides a position that will be associated with the implicit search.
+   *
+   *  As mentioned in https://groups.google.com/forum/#!topic/scala-internals/ta-vbUT6JE8
+   *  this API won't take into account the lexical context of the callsite, because
+   *  currently it's impossible to reify it.
    *
-   *  If ``silent'' is false, ``TypeError'' will be thrown in case of an inference error.
-   *  If ``silent'' is true, the typecheck is silent and will return ``EmptyTree'' if an error occurs.
+   *  If `silent` is false, `TypeError` will be thrown in case of an inference error.
+   *  If `silent` is true, the typecheck is silent and will return `EmptyTree` if an error occurs.
    *  Such errors don't vanish and can be inspected by turning on -Xlog-implicits.
-   *  Unlike in ``typeCheck'', ``silent'' is true by default.
+   *  Unlike in `typeCheck`, `silent` is true by default.
    */
-  def inferImplicitValue(pt: u.Type, silent: Boolean = true, withMacrosDisabled: Boolean = false): u.Tree
+  def inferImplicitValue(pt: u.Type, silent: Boolean = true, withMacrosDisabled: Boolean = false, pos: u.Position = u.NoPosition): u.Tree
 
-  /** Infers an implicit view from the provided tree ``tree'' from the type ``from'' to the type ``to'' in the macro callsite context.
+  /** Infers an implicit view from the provided tree `tree` from the type `from` to the type `to` in the toplevel context.
+   *  Optional `pos` parameter provides a position that will be associated with the implicit search.
    *
-   *  Otional parameter, ``reportAmbiguous`` controls whether ambiguous implicit errors should be reported.
-   *  If we search for a view simply to find out whether one type is coercible to another, it might be desirable to set this flag to ``false''.
+   *  As mentioned in https://groups.google.com/forum/#!topic/scala-internals/ta-vbUT6JE8
+   *  this API won't take into account the lexical context of the callsite, because
+   *  currently it's impossible to reify it.
    *
-   *  If ``silent'' is false, ``TypeError'' will be thrown in case of an inference error.
-   *  If ``silent'' is true, the typecheck is silent and will return ``EmptyTree'' if an error occurs.
+   *  If `silent` is false, `TypeError` will be thrown in case of an inference error.
+   *  If `silent` is true, the typecheck is silent and will return `EmptyTree` if an error occurs.
    *  Such errors don't vanish and can be inspected by turning on -Xlog-implicits.
-   *  Unlike in ``typeCheck'', ``silent'' is true by default.
+   *  Unlike in `typeCheck`, `silent` is true by default.
    */
-  def inferImplicitView(tree: u.Tree, from: u.Type, to: u.Type, silent: Boolean = true, withMacrosDisabled: Boolean = false, reportAmbiguous: Boolean = true): u.Tree
+  def inferImplicitView(tree: u.Tree, from: u.Type, to: u.Type, silent: Boolean = true, withMacrosDisabled: Boolean = false, pos: u.Position = u.NoPosition): u.Tree
 
   /** Recursively resets symbols and types in a given tree.
    *
@@ -78,14 +84,14 @@ trait ToolBox[U <: Universe] {
 
   /** Compiles and runs a tree using this ToolBox.
    *
-   *  If the tree has unresolved type variables (represented as instances of ``FreeTypeSymbol'' symbols),
-   *  then they all have to be specified in the ``freeTypes'' parameter or an error occurs.
+   *  If the tree has unresolved type variables (represented as instances of `FreeTypeSymbol` symbols),
+   *  then they all have to be resolved first using `Tree.substituteTypes`, or an error occurs.
    *
    *  This spawns the compiler at the Namer phase, and pipelines the tree through that compiler.
-   *  Currently ``runExpr'' does not accept trees that already typechecked, because typechecking isn't idempotent.
+   *  Currently `runExpr` does not accept trees that already typechecked, because typechecking isn't idempotent.
    *  For more info, take a look at https://issues.scala-lang.org/browse/SI-5464.
    */
-  def runExpr(tree: u.Tree, freeTypes: Map[u.FreeTypeSymbol, u.Type] = Map[u.FreeTypeSymbol, u.Type]()): Any
+  def runExpr(tree: u.Tree): Any
 }
 
 /** Represents an error during toolboxing