Use special method for converting Select qualifiers

Author: odersky

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

@@ -133,12 +133,12 @@ trait TypeAssigner {
       qualType
 
   /** The type of the selection `tree`, where `qual1` is the typed qualifier part. */
-  def selectionType(tree: untpd.RefTree, qual1: Tree)(using Context): Type = {
+  def selectionType(tree: untpd.RefTree, qual1: Tree)(using Context): Type =
     var qualType = qual1.tpe.widenIfUnstable
-    if (!qualType.hasSimpleKind && tree.name != nme.CONSTRUCTOR)
+    if !qualType.hasSimpleKind && tree.name != nme.CONSTRUCTOR then
       // constructors are selected on typeconstructor, type arguments are passed afterwards
       qualType = errorType(em"$qualType takes type parameters", qual1.srcPos)
-    else if (!qualType.isInstanceOf[TermType])
+    else if !qualType.isInstanceOf[TermType] then
       qualType = errorType(em"$qualType is illegal as a selection prefix", qual1.srcPos)
 
     def arrayElemType = qual1.tpe.widen match
@@ -164,7 +164,7 @@ trait TypeAssigner {
         if reallyExists(mbr) then qualType.select(name, mbr)
         else if qualType.isErroneous || name.toTermName == nme.ERROR then UnspecifiedErrorType
         else NoType
-  }
+  end selectionType
 
   def importSuggestionAddendum(pt: Type)(using Context): String = ""
 

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

@@ -548,53 +548,32 @@ class Typer extends Namer
     then
       report.error(StableIdentPattern(tree, pt), tree.srcPos)
 
-  def typedSelect(tree: untpd.Select, pt: Type, qual: Tree)(using Context): Tree = qual match {
+  def typedSelect(tree0: untpd.Select, pt: Type, qual: Tree)(using Context): Tree = qual match
     case qual: ExtMethodApply =>
       qual.app
     case qual =>
-      val untpdSelect = cpy.Select(tree)(qual, tree.name)
-      def finalize(tp: Type) = assignType(untpdSelect, tp)
-      val ownType = accessibleSelectionType(untpdSelect, qual)
+      val selName = tree0.name
+      val tree = cpy.Select(tree0)(qual, selName)
+      def finalize(tp: Type) = assignType(tree, tp)
+      val ownType = accessibleSelectionType(tree, qual)
       if ownType.exists then
-        val select = assignType(untpdSelect, ownType)
+        val select = assignType(tree, ownType)
         val select1 = toNotNullTermRef(select, pt)
 
-        if (tree.name.isTypeName) checkStable(qual.tpe, qual.srcPos, "type prefix")
+        if selName.isTypeName then checkStable(qual.tpe, qual.srcPos, "type prefix")
         checkStableIdentPattern(select1, pt)
         ConstFold(select1)
       else if couldInstantiateTypeVar(qual.tpe.widen) then
         // try again with more defined qualifier type
-        typedSelect(untpdSelect, pt, qual)
+        typedSelect(tree, pt, qual)
       else if qual.tpe.derivesFrom(defn.DynamicClass)
-         && tree.name.isTermName && !isDynamicExpansion(untpdSelect)
+         && selName.isTermName && !isDynamicExpansion(tree)
       then
         if pt.isInstanceOf[FunOrPolyProto] || pt == AssignProto then finalize(TryDynamicCallType)
-        else typedDynamicSelect(tree, Nil, pt)
+        else typedDynamicSelect(tree0, Nil, pt)
       else
-        finalize(notAMember(untpdSelect, qual))
-/*
-        // try an extension method in scope
-        try
-          val nestedCtx = ctx.fresh.setNewTyperState()
-          findRef(selName, WildcardType, ExtensionMethod, EmptyFlags, tree.srcPos) match
-            case ref: TermRef =>
-              val app = extMethodApply(untpd.ref(ref).withSpan(tree.span), tree, pt)
-              if !nestedCtx.reporter.hasErrors then
-                nestedCtx.typerState.commit()
-                return app
-              else for err <- nestedCtx.reporter.allErrors.take(1) do
-                rememberSearchFailure(tree,
-                  SearchFailure(app.withType(FailedExtension(app, pt, err.msg))))
-        catch case ex: TypeError =>
-          rememberSearchFailure(tree,
-            SearchFailure(tree.withType(NestedFailure(ex.toMessage, pt))))
-
-
-            val nestedCtx = ctx.fresh.setNewTyperState()
-            case _ =>
-              EmptyTree*/
-
-  }
+        finalize(notAMember(tree, qual))
+  end typedSelect
 
   def typedSelect(tree: untpd.Select, pt: Type)(using Context): Tree = {
     record("typedSelect")
@@ -2911,23 +2890,75 @@ class Typer extends Namer
     }
   }
 
-  /** If this tree is a select node `qual.name`, try to insert an implicit conversion
-   *  `c` around `qual` so that `c(qual).name` conforms to `pt`.
+  /** If this tree is a select node `qual.name` that does not conform to `pt`,
+   *  try to insert an implicit conversion `c` around `qual` so that
+   *  `c(qual).name` conforms to `pt`.
    */
   def tryInsertImplicitOnQualifier(tree: Tree, pt: Type, locked: TypeVars)(using Context): Option[Tree] = trace(i"try insert impl on qualifier $tree $pt") {
     tree match {
-      case Select(qual, name) if name != nme.CONSTRUCTOR =>
-        val qualProto = SelectionProto(name, pt, NoViewsAllowed, privateOK = false)
-        tryEither {
-          val qual1 = adapt(qual, qualProto, locked)
-          if ((qual eq qual1) || summon[Context].reporter.hasErrors) None
-          else Some(typed(cpy.Select(tree)(untpd.TypedSplice(qual1), name), pt, locked))
-        } { (_, _) => None
-        }
+      case tree @ Select(qual, name) if name != nme.CONSTRUCTOR =>
+        val selProto = SelectionProto(name, pt, NoViewsAllowed, privateOK = false)
+        if selProto.isMatchedBy(qual.tpe) then None
+        else
+          tryEither {
+            val tree1 = tryExtensionOrConversion(tree, pt, qual, locked, NoViewsAllowed, privateOK = false)
+            if tree1.isEmpty then None
+            else Some(adapt(tree1, pt, locked))
+          } { (_, _) => None
+          }
       case _ => None
     }
   }
 
+  /** Given a selection `qual.name`, try to convert to an extension method
+   *  application `name(qual)` or insert an implicit conversion `c(qual).name`.
+   */
+  def tryExtensionOrConversion
+      (tree: untpd.Select, pt: Type, qual: Tree, locked: TypeVars, compat: Compatibility, privateOK: Boolean)
+      (using Context): Tree =
+
+    def selectionProto = SelectionProto(tree.name, pt, compat, privateOK)
+    // try an extension method in scope
+    try
+      val nestedCtx = ctx.fresh.setNewTyperState()
+      findRef(tree.name, WildcardType, ExtensionMethod, EmptyFlags, qual.srcPos) match
+        case ref: TermRef =>
+          val app = extMethodApply(untpd.ref(ref).withSpan(tree.span), qual, pt)
+          if !nestedCtx.reporter.hasErrors then
+            nestedCtx.typerState.commit()
+            return app
+          for err <- nestedCtx.reporter.allErrors.take(1) do
+            rememberSearchFailure(qual,
+              SearchFailure(app.withType(FailedExtension(app, selectionProto, err.msg))))
+        case _ =>
+    catch case ex: TypeError =>
+      rememberSearchFailure(qual,
+        SearchFailure(qual.withType(NestedFailure(ex.toMessage, selectionProto))))
+
+    // try an implicit conversion or given extension
+    if ctx.mode.is(Mode.ImplicitsEnabled) && qual.tpe.isValueType then
+      trace(i"try insert impl on qualifier $tree $pt") {
+        val selProto = selectionProto
+        inferView(qual, selProto) match
+          case SearchSuccess(found: ExtMethodApply, _, _) =>
+            return found.app // nothing to check or adapt for extension method applications
+          case SearchSuccess(found, _, _) =>
+            checkImplicitConversionUseOK(found)
+            val qual1 = withoutMode(Mode.ImplicitsEnabled)(adapt(found, selProto, locked))
+            return typedSelect(tree, pt, qual1)
+          case failure: SearchFailure =>
+            if failure.isAmbiguous then
+              return (
+                if canDefineFurther(qual.tpe.widen) then
+                  tryExtensionOrConversion(tree, pt, qual, locked, compat, privateOK)
+                else
+                  err.typeMismatch(qual, selProto, failure.reason) // TODO: report NotAMember instead, but need to be aware of failure
+              )
+            rememberSearchFailure(qual, failure)
+      }
+    EmptyTree
+  end tryExtensionOrConversion
+
   /** Perform the following adaptations of expression, pattern or type `tree` wrt to
    *  given prototype `pt`:
    *  (1) Resolve overloading