Consider implicit conversions for possible completions

Author: odersky

compiler/src/dotty/tools/dotc/interactive/Interactive.scala

@@ -156,7 +156,7 @@ object Interactive {
      *   - do not contain '$' except in prefix where it is explicitly written by user
      *   - have same term/type kind as name prefix given so far
      */
-    def include(sym: Symbol) = 
+    def include(sym: Symbol) =
       sym.name.startsWith(prefix) &&
       !sym.name.toString.drop(prefix.length).contains('$') &&
       (!termOnly || sym.isTerm) &&
@@ -182,6 +182,9 @@ object Interactive {
         }.filter(_.exists)
     }
 
+    def addAccessibleMembers(site: Type, superAccess: Boolean = true): Unit =
+      for (mbr <- accessibleMembers(site)) addMember(site, mbr.name)
+
     def getImportCompletions(ictx: Context): Unit = {
       implicit val ctx = ictx
       val imp = ctx.importInfo
@@ -221,12 +224,22 @@ object Interactive {
       if (outer `ne` NoContext) getScopeCompletions(outer)
     }
 
-    def getMemberCompletions(site: Type): Unit = {
-      for (mbr <- accessibleMembers(site)) addMember(site, mbr.name)
+    def implicitConversionTargets(qual: Tree)(implicit ctx: Context): Set[Type] = {
+      val typer = ctx.typer
+      val conversions = new typer.ImplicitSearch(defn.AnyType, qual, pos.pos).allImplicits
+      val targets = conversions.map(_.widen.finalResultType)
+      interactiv.println(i"implicit conversion targets considered: ${targets.toList}%, %")
+      targets
+    }
+
+    def getMemberCompletions(qual: Tree): Unit = {
+      addAccessibleMembers(qual.tpe)
+      implicitConversionTargets(qual)(ctx.fresh.setExploreTyperState())
+        .foreach(addAccessibleMembers(_))
     }
 
     path match {
-      case (sel @ Select(qual, name)) :: _ => getMemberCompletions(qual.tpe)
+      case (sel @ Select(qual, _)) :: _ => getMemberCompletions(qual)
       case _  => getScopeCompletions(ctx)
     }
     interactiv.println(i"completion with pos = $pos, prefix = $prefix, termOnly = $termOnly, typeOnly = $typeOnly = ${completions.toList}%, %")

compiler/src/dotty/tools/dotc/parsing/Parsers.scala

@@ -106,7 +106,6 @@ object Parsers {
     def sourcePos(off: Int = in.offset): SourcePosition =
       source atPos Position(off)
 
-
     /* ------------- ERROR HANDLING ------------------------------------------- */
     /** The offset where the last syntax error was reported, or if a skip to a
       *  safepoint occurred afterwards, the offset of the safe point.
@@ -128,7 +127,6 @@ object Parsers {
       */
     def syntaxError(msg: => Message, pos: Position): Unit =
       ctx.error(msg, source atPos pos)
-
   }
 
   class Parser(source: SourceFile)(implicit ctx: Context) extends ParserCommon(source) {

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

@@ -836,64 +836,63 @@ trait Implicits { self: Typer =>
 
     val isNot = wildProto.classSymbol == defn.NotClass
 
-    /** Search a list of eligible implicit references */
-    def searchImplicits(eligible: List[Candidate], contextual: Boolean): SearchResult = {
-      val constr = ctx.typerState.constraint
-
       //println(i"search implicits $pt / ${eligible.map(_.ref)}")
 
-      /** Try to typecheck an implicit reference */
-      def typedImplicit(cand: Candidate)(implicit ctx: Context): SearchResult = track("typedImplicit") { trace(i"typed implicit ${cand.ref}, pt = $pt, implicitsEnabled == ${ctx.mode is ImplicitsEnabled}", implicits, show = true) {
-        assert(constr eq ctx.typerState.constraint)
-        val ref = cand.ref
-        var generated: Tree = tpd.ref(ref).withPos(pos.startPos)
-        if (!argument.isEmpty)
-          generated = typedUnadapted(
-            untpd.Apply(untpd.TypedSplice(generated), untpd.TypedSplice(argument) :: Nil),
-            pt)
-        val generated1 = adapt(generated, pt)
-        lazy val shadowing =
-          typed(untpd.Ident(cand.implicitRef.implicitName) withPos pos.toSynthetic, funProto)(
-            nestedContext().addMode(Mode.ImplicitShadowing).setExploreTyperState())
-        def refSameAs(shadowing: Tree): Boolean =
-          ref.symbol == closureBody(shadowing).symbol || {
-            shadowing match {
-              case Trees.Select(qual, nme.apply) => refSameAs(qual)
-              case Trees.Apply(fn, _) => refSameAs(fn)
-              case Trees.TypeApply(fn, _) => refSameAs(fn)
-              case _ => false
-            }
+    /** Try to typecheck an implicit reference */
+    def typedImplicit(cand: Candidate, contextual: Boolean)(implicit ctx: Context): SearchResult = track("typedImplicit") { trace(i"typed implicit ${cand.ref}, pt = $pt, implicitsEnabled == ${ctx.mode is ImplicitsEnabled}", implicits, show = true) {
+      val ref = cand.ref
+      var generated: Tree = tpd.ref(ref).withPos(pos.startPos)
+      if (!argument.isEmpty)
+        generated = typedUnadapted(
+          untpd.Apply(untpd.TypedSplice(generated), untpd.TypedSplice(argument) :: Nil),
+          pt)
+      val generated1 = adapt(generated, pt)
+      lazy val shadowing =
+        typed(untpd.Ident(cand.implicitRef.implicitName) withPos pos.toSynthetic, funProto)(
+          nestedContext().addMode(Mode.ImplicitShadowing).setExploreTyperState())
+      def refSameAs(shadowing: Tree): Boolean =
+        ref.symbol == closureBody(shadowing).symbol || {
+          shadowing match {
+            case Trees.Select(qual, nme.apply) => refSameAs(qual)
+            case Trees.Apply(fn, _) => refSameAs(fn)
+            case Trees.TypeApply(fn, _) => refSameAs(fn)
+            case _ => false
           }
+        }
 
-        if (ctx.reporter.hasErrors) {
-          ctx.reporter.removeBufferedMessages
-          SearchFailure {
-            generated1.tpe match {
-              case _: SearchFailureType => generated1
-              case _ => generated1.withType(new MismatchedImplicit(ref, pt, argument))
-            }
+      if (ctx.reporter.hasErrors) {
+        ctx.reporter.removeBufferedMessages
+        SearchFailure {
+          generated1.tpe match {
+            case _: SearchFailureType => generated1
+            case _ => generated1.withType(new MismatchedImplicit(ref, pt, argument))
           }
         }
-        else if (contextual && !ctx.mode.is(Mode.ImplicitShadowing) &&
-                 !shadowing.tpe.isError && !refSameAs(shadowing)) {
-          implicits.println(i"SHADOWING $ref in ${ref.termSymbol.maybeOwner} is shadowed by $shadowing in ${shadowing.symbol.maybeOwner}")
-          SearchFailure(generated1.withTypeUnchecked(
-            new ShadowedImplicit(ref, methPart(shadowing).tpe, pt, argument)))
-        }
-        else
-          SearchSuccess(generated1, ref, cand.level)(ctx.typerState)
-      }}
-
-      /** Try to type-check implicit reference, after checking that this is not
-       *  a diverging search
-       */
-      def tryImplicit(cand: Candidate): SearchResult = {
-        val history = ctx.searchHistory nest wildProto
-        if (history eq ctx.searchHistory)
-          SearchFailure(new DivergingImplicit(cand.ref, pt, argument))
-        else
-          typedImplicit(cand)(nestedContext().setNewTyperState().setSearchHistory(history))
       }
+      else if (contextual && !ctx.mode.is(Mode.ImplicitShadowing) &&
+                !shadowing.tpe.isError && !refSameAs(shadowing)) {
+        implicits.println(i"SHADOWING $ref in ${ref.termSymbol.maybeOwner} is shadowed by $shadowing in ${shadowing.symbol.maybeOwner}")
+        SearchFailure(generated1.withTypeUnchecked(
+          new ShadowedImplicit(ref, methPart(shadowing).tpe, pt, argument)))
+      }
+      else
+        SearchSuccess(generated1, ref, cand.level)(ctx.typerState)
+    }}
+
+    /** Try to type-check implicit reference, after checking that this is not
+      *  a diverging search
+      */
+    def tryImplicit(cand: Candidate, contextual: Boolean): SearchResult = {
+      val history = ctx.searchHistory nest wildProto
+      if (history eq ctx.searchHistory)
+        SearchFailure(new DivergingImplicit(cand.ref, pt, argument))
+      else
+        typedImplicit(cand, contextual)(nestedContext().setNewTyperState().setSearchHistory(history))
+    }
+
+    /** Search a list of eligible implicit references */
+    def searchImplicits(eligible: List[Candidate], contextual: Boolean): SearchResult = {
+      val constr = ctx.typerState.constraint
 
       /** Compare previous success with reference and level to determine which one would be chosen, if
        *  an implicit starting with the reference was found.
@@ -966,7 +965,7 @@ trait Implicits { self: Typer =>
       def rank(pending: List[Candidate], found: SearchResult, rfailures: List[SearchFailure]): SearchResult =
         pending match  {
           case cand :: remaining =>
-            negateIfNot(tryImplicit(cand)) match {
+            negateIfNot(tryImplicit(cand, contextual)) match {
               case fail: SearchFailure =>
                 if (fail.isAmbiguous)
                   if (ctx.scala2Mode) {
@@ -1081,6 +1080,15 @@ trait Implicits { self: Typer =>
     }
 
     def implicitScope(tp: Type): OfTypeImplicits = ctx.run.implicitScope(tp, ctx)
+
+    /** All available implicits, without ranking */
+    def allImplicits: Set[TermRef] = {
+      val contextuals = ctx.implicits.eligible(wildProto).map(tryImplicit(_, contextual = true))
+      val inscope = implicitScope(wildProto).eligible.map(tryImplicit(_, contextual = false))
+      (contextuals.toSet ++ inscope).collect {
+        case success: SearchSuccess => success.ref
+      }
+    }
   }
 }