Subject implicit suggestion searches to timeouts

Currently:

 Max 1 sec to test a single implicit
 Max 10 secs to make suggestions for a missing implicit import

Author: odersky

compiler/src/dotty/tools/dotc/Run.scala

@@ -35,7 +35,7 @@ class Run(comp: Compiler, ictx: Context) extends ImplicitRunInfo with Constraint
    *  return immediately. Currently these early abort operatoons are
    *  `Typer.typed` and `Implicits.typedImplicit`.
    */
-  var isCancelled = false
+  @volatile var isCancelled = false
 
   /** Produces the following contexts, from outermost to innermost
    *

compiler/src/dotty/tools/dotc/typer/Implicits.scala

@@ -31,7 +31,7 @@ import transform.SymUtils._
 import transform.TypeUtils._
 import transform.SyntheticMembers._
 import Hashable._
-import util.{Property, SourceFile, NoSource}
+import util.{Property, SourceFile, NoSource, Scheduler}
 import config.Config
 import config.Printers.{implicits, implicitsDetailed}
 import collection.mutable
@@ -68,6 +68,9 @@ object Implicits {
     final val Extension = 4
   }
 
+  val testOneImplicitTimeOut = 1000
+  val suggestImplicitTimeOut = 10000
+
   /** A common base class of contextual implicits and of-type implicits which
    *  represents a set of references to implicit definitions.
    */
@@ -528,10 +531,29 @@ object Implicits {
       else Nil
 
     def search(given ctx: Context): List[TermRef] =
-      roots
-        .filterNot(root => defn.RootImportTypes.exists(_.symbol == root.symbol))
+      val scheduler = new Scheduler()
+      val deadLine = System.currentTimeMillis() + suggestImplicitTimeOut
+
+      def test(ref: TermRef)(given Context): Boolean =
+        System.currentTimeMillis < deadLine
+        && {
+          scheduler.scheduleAfter(testOneImplicitTimeOut) {
+            println(i"Cancelling test of $ref when making suggestions for error in ${ctx.source}")
+            ctx.run.isCancelled = true
+          }
+          try qualifies(ref)
+          finally
+            scheduler.cancel()
+            ctx.run.isCancelled = false
+        }
+
+      try
+        roots
+          .filterNot(root => defn.RootImportTypes.exists(_.symbol == root.symbol))
           // don't suggest things that are imported by default
-        .flatMap(_.implicitMembers.filter(qualifies))
+          .flatMap(_.implicitMembers.filter(test))
+      finally scheduler.shutdown()
+    end search
   end suggestions
 }
 

compiler/src/dotty/tools/dotc/util/Scheduler.scala

@@ -0,0 +1,33 @@
+package dotty.tools.dotc.util
+class Scheduler extends Thread with
+
+  private var execTime: Long = Long.MaxValue
+  private var task: () => Unit = _
+  private var stopped: Boolean = false
+
+  def scheduleAfter(after: Long)(task: => Unit) = synchronized {
+    this.task = () => task
+    this.execTime = System.currentTimeMillis + after
+  }
+
+  def cancel(): Unit = synchronized {
+    execTime = Long.MaxValue
+  }
+
+  def shutdown(): Unit = synchronized {
+    stopped = true
+  }
+
+  def poll(): Unit = synchronized {
+    if System.currentTimeMillis() > execTime then
+      task()
+      execTime = Long.MaxValue
+  }
+
+  override def run(): Unit =
+    while !stopped do
+      poll()
+      Thread.sleep(1)
+
+  start()
+end Scheduler