Faster resolution of inductive implicits.

Author: milessabin

bincompat-forward.whitelist.conf

@@ -102,6 +102,14 @@ filter {
     {
       matchName="scala.util.Properties.coloredOutputEnabled"
       problemName=DirectMissingMethodProblem
+    },
+    {
+      matchName="scala.annotation.inductive"
+      problemName=MissingClassProblem
+    },
+    {
+      matchName="scala.reflect.runtime.Settings.YinductionHeuristics"
+      problemName=MissingMethodProblem
     }
   ]
 }

src/compiler/scala/tools/nsc/settings/ScalaSettings.scala

@@ -30,7 +30,7 @@ trait ScalaSettings extends AbsScalaSettings
   protected def defaultClasspath = sys.env.getOrElse("CLASSPATH", ".")
 
   /** Enabled under -Xexperimental. */
-  protected def experimentalSettings = List[BooleanSetting](YpartialUnification)
+  protected def experimentalSettings = List[BooleanSetting](YpartialUnification, YinductionHeuristics)
 
   /** Enabled under -Xfuture. */
   protected def futureSettings = List[BooleanSetting]()
@@ -221,6 +221,7 @@ trait ScalaSettings extends AbsScalaSettings
   val YdisableFlatCpCaching  = BooleanSetting    ("-YdisableFlatCpCaching", "Do not cache flat classpath representation of classpath elements from jars across compiler instances.")
   val YpartialUnification = BooleanSetting ("-Ypartial-unification", "Enable partial unification in type constructor inference")
   val Yvirtpatmat     = BooleanSetting    ("-Yvirtpatmat", "Enable pattern matcher virtualization")
+  val YinductionHeuristics = BooleanSetting ("-Yinduction-heuristics", "Enable induction heuristics in implicit resolution")
 
   val exposeEmptyPackage = BooleanSetting ("-Yexpose-empty-package", "Internal only: expose the empty package.").internalOnly()
   val Ydelambdafy        = ChoiceSetting  ("-Ydelambdafy", "strategy", "Strategy used for translating lambdas into JVM code.", List("inline", "method"), "method")

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

@@ -82,14 +82,25 @@ trait ContextErrors {
   //    (pt at the point of divergence gives less information to the user)
   // Note: it is safe to delay error message generation in this case
   // because we don't modify implicits' infos.
+  sealed abstract class ImplicitTypeError extends TreeTypeError
+
   case class DivergentImplicitTypeError(underlyingTree: Tree, pt0: Type, sym: Symbol)
-    extends TreeTypeError {
+    extends ImplicitTypeError {
     def errMsg: String   = errMsgForPt(pt0)
     def withPt(pt: Type): AbsTypeError = this.copy(pt0 = pt)
     private def errMsgForPt(pt: Type) =
       s"diverging implicit expansion for type ${pt}\nstarting with ${sym.fullLocationString}"
   }
 
+  case class NoninductiveImplicitTypeError(underlyingTree: Tree, pt: Type)
+    extends ImplicitTypeError {
+    def errMsg: String = s"Noninductive implicit expansion for type ${pt}"
+  }
+
+  case class IncompleteInductionImplicitTypeError(underlyingTree: Tree, pt: Type, aux: Type)
+    extends ImplicitTypeError {
+    def errMsg: String = s"Inductive implicit expansion for type ${pt} failed due to missing auxiliary implicit ${aux}"
+  }
 
   case class PosAndMsgTypeError(errPos: Position, errMsg: String)
     extends AbsTypeError
@@ -1306,6 +1317,12 @@ trait ContextErrors {
 
     def DivergingImplicitExpansionError(tree: Tree, pt: Type, sym: Symbol)(implicit context0: Context) =
       issueTypeError(DivergentImplicitTypeError(tree, pt, sym))
+
+    def NoninductiveImplicitExpansionError(tree: Tree, pt: Type)(implicit context0: Context) =
+      issueTypeError(NoninductiveImplicitTypeError(tree, pt))
+
+    def IncompleteInductionImplicitExpansionError(tree: Tree, pt: Type, aux: Type)(implicit context0: Context) =
+      issueTypeError(IncompleteInductionImplicitTypeError(tree, pt, aux))
   }
 
   object NamesDefaultsErrorsGen {

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

@@ -1309,15 +1309,23 @@ trait Contexts { self: Analyzer =>
     // have to pass in context because multiple contexts may share the same ReportBuffer
     def reportFirstDivergentError(fun: Tree, param: Symbol, paramTp: Type)(implicit context: Context): Unit =
       errors.collectFirst {
-        case dte: DivergentImplicitTypeError => dte
+        case ite: ImplicitTypeError => ite
       } match {
-        case Some(divergent) =>
+        case Some(divergent: DivergentImplicitTypeError) =>
           // DivergentImplicit error has higher priority than "no implicit found"
           // no need to issue the problem again if we are still in silent mode
           if (context.reportErrors) {
             context.issue(divergent.withPt(paramTp))
             errorBuffer.retain {
-              case dte: DivergentImplicitTypeError => false
+              case ite: ImplicitTypeError => false
+              case _ => true
+            }
+          }
+        case Some(ite) =>
+          if (context.reportErrors) {
+            context.issue(ite)
+            errorBuffer.retain {
+              case ite: ImplicitTypeError => false
               case _ => true
             }
           }
@@ -1333,7 +1341,7 @@ trait Contexts { self: Analyzer =>
 
     def propagateImplicitTypeErrorsTo(target: ContextReporter) = {
       errors foreach {
-        case err@(_: DivergentImplicitTypeError | _: AmbiguousImplicitTypeError) =>
+        case err@(_: ImplicitTypeError | _: AmbiguousImplicitTypeError) =>
           target.errorBuffer += err
         case _ =>
       }