Survive bad references when looking for completions

Author: odersky

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

@@ -85,9 +85,9 @@ object Completion {
    * @param content The source content that we'll check the positions for the prefix
    * @param start The start position we'll start to look for the prefix at
    * @param end The end position we'll look for the prefix at
-   * @return Either the full prefix including the ` or an empty string 
+   * @return Either the full prefix including the ` or an empty string
    */
-  private def checkBacktickPrefix(content: Array[Char], start: Int, end: Int): String = 
+  private def checkBacktickPrefix(content: Array[Char], start: Int, end: Int): String =
     content.lift(start) match
       case Some(char) if char == '`' =>
         content.slice(start, end).mkString
@@ -111,7 +111,7 @@ object Completion {
       // Foo.`se<TAB> will result in Select(Ident(Foo), <error>)
       case (select: untpd.Select) :: _ if select.name == nme.ERROR =>
         checkBacktickPrefix(select.source.content(), select.nameSpan.start, select.span.end)
-     
+
       // import scala.util.chaining.`s<TAB> will result in a Ident(<error>)
       case (ident: untpd.Ident) :: _ if ident.name == nme.ERROR =>
         checkBacktickPrefix(ident.source.content(), ident.span.start, ident.span.end)
@@ -177,14 +177,14 @@ object Completion {
   // https://github.com/com-lihaoyi/Ammonite/blob/73a874173cd337f953a3edc9fb8cb96556638fdd/amm/util/src/main/scala/ammonite/util/Model.scala
   private def needsBacktick(s: String) =
     val chunks = s.split("_", -1)
-    
+
     val validChunks = chunks.zipWithIndex.forall { case (chunk, index) =>
       chunk.forall(Chars.isIdentifierPart) ||
       (chunk.forall(Chars.isOperatorPart) &&
         index == chunks.length - 1 &&
         !(chunks.lift(index - 1).contains("") && index - 1 == 0))
     }
-    
+
     val validStart =
       Chars.isIdentifierStart(s(0)) || chunks(0).forall(Chars.isOperatorPart)
 
@@ -312,7 +312,7 @@ object Completion {
 
     /** Replaces underlying type with reduced one, when it's MatchType */
     def reduceUnderlyingMatchType(qual: Tree)(using Context): Tree=
-      qual.tpe.widen match 
+      qual.tpe.widen match
         case ctx.typer.MatchTypeInDisguise(mt) => qual.withType(mt)
         case _ => qual
 
@@ -392,11 +392,13 @@ object Completion {
         case _ => ExprType(tpe)
 
       def tryApplyingReceiverToExtension(termRef: TermRef): Option[SingleDenotation] =
-        ctx.typer.tryApplyingExtensionMethod(termRef, qual)
-          .map { tree =>
-            val tpe = asDefLikeType(tree.tpe.dealias)
-            termRef.denot.asSingleDenotation.mapInfo(_ => tpe)
-          }
+        try
+          ctx.typer.tryApplyingExtensionMethod(termRef, qual)
+            .map { tree =>
+              val tpe = asDefLikeType(tree.tpe.dealias)
+              termRef.denot.asSingleDenotation.mapInfo(_ => tpe)
+            }
+        catch case ex: TypeError => None
 
       def extractMemberExtensionMethods(types: Seq[Type]): Seq[(TermRef, TermName)] =
         object DenotWithMatchingName: