Preliminary select refactorings

Move some code out of `adapt` and `assignType`, to be re-used later in `typedSelect`.

The aim of the refactoring is to move all select-dependent adaptations and re-tries into
typedSelect. Right now some are in `adapt` and some are in `assignType`. This is awkward
since it means that

 - we do too much in `TypeAssigner`. Sine it aims to be minimal `TypeAssigner` should have no business doing adaptations
   and retries.
 - wo do some adaptations too early in `adpt`. This means we need the cludge of wrapping
   trees in `ExtMethodApply` which causes scala#8182, among others.

Author: odersky

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

@@ -38,6 +38,11 @@ object Inferencing {
     result
   }
 
+  def canDefineFurther(tp: Type)(using Context): Boolean =
+    val prevConstraint = ctx.typerState.constraint
+    isFullyDefined(tp, force = ForceDegree.all)
+    && (ctx.typerState.constraint ne prevConstraint)
+
   /** The fully defined type, where all type variables are forced.
    *  Throws an error if type contains wildcards.
    */

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

@@ -141,7 +141,25 @@ trait TypeAssigner {
     else if (!qualType.isInstanceOf[TermType])
       qualType = errorType(em"$qualType is illegal as a selection prefix", qual1.srcPos)
 
+    def arrayElemType = qual1.tpe.widen match
+      case JavaArrayType(elemtp) => elemtp
+      case qualType =>
+        report.error("Expected Array but was " + qualType.show, tree.srcPos)
+        defn.NothingType
+
     val name = tree.name
+    val p = nme.primitive
+    name match
+      case p.arrayApply  => return MethodType(defn.IntType :: Nil, arrayElemType)
+      case p.arrayUpdate => return MethodType(defn.IntType :: arrayElemType :: Nil, defn.UnitType)
+      case p.arrayLength => return MethodType(Nil, defn.IntType)
+      // Note that we do not need to handle calls to Array[T]#clone() specially:
+      // The JLS section 10.7 says "The return type of the clone method of an array type
+      // T[] is T[]", but the actual return type at the bytecode level is Object which
+      // is casted to T[] by javac. Since the return type of Array[T]#clone() is Array[T],
+      // this is exactly what Erasure will do.
+      case _ =>
+
     val pre = maybeSkolemizePrefix(qualType, name)
     val mbr = qualType.findMember(name, pre)
     def isDynamicExpansion(tree: untpd.RefTree): Boolean = {
@@ -165,15 +183,19 @@ trait TypeAssigner {
       selectionType(tree, qual1)
     else if (name == nme.CONSTRUCTOR)
       errorType(ex"$qualType does not have a constructor", tree.srcPos)
-    else {
-      val kind = if (name.isTypeName) "type" else "value"
-      def addendum = err.selectErrorAddendum(tree, qual1, qualType, importSuggestionAddendum)
-      errorType(NotAMember(qualType, name, kind, addendum), tree.srcPos)
-    }
+    else
+      NoType
   }
 
   def importSuggestionAddendum(pt: Type)(using Context): String = ""
 
+  def notAMember(tree: untpd.Select, qual: Tree)(using Context): ErrorType =
+    val kind = if tree.isType then "type" else "value"
+    val qualType = qual.tpe.widenIfUnstable
+    def addendum = err.selectErrorAddendum(tree, qual, qualType, importSuggestionAddendum)
+    errorType(NotAMember(qualType, tree.name, kind, addendum), tree.srcPos)
+
+
   /** The type of the selection in `tree`, where `qual1` is the typed qualifier part.
    *  The selection type is additionally checked for accessibility.
    */
@@ -189,32 +211,12 @@ trait TypeAssigner {
   def assignType(tree: untpd.Ident, tp: Type)(using Context): Ident =
     tree.withType(tp)
 
-  def assignType(tree: untpd.Select, qual: Tree)(using Context): Select = {
-    def qualType = qual.tpe.widen
-    def arrayElemType = {
-      qualType match {
-        case JavaArrayType(elemtp) => elemtp
-        case _ =>
-          report.error("Expected Array but was " + qualType.show, tree.srcPos)
-          defn.NothingType
-      }
-    }
-    val p = nme.primitive
-    val tp = tree.name match {
-      case p.arrayApply => MethodType(defn.IntType :: Nil, arrayElemType)
-      case p.arrayUpdate => MethodType(defn.IntType :: arrayElemType :: Nil, defn.UnitType)
-      case p.arrayLength => MethodType(Nil, defn.IntType)
-
-      // Note that we do not need to handle calls to Array[T]#clone() specially:
-      // The JLS section 10.7 says "The return type of the clone method of an array type
-      // T[] is T[]", but the actual return type at the bytecode level is Object which
-      // is casted to T[] by javac. Since the return type of Array[T]#clone() is Array[T],
-      // this is exactly what Erasure will do.
-
-      case _ => accessibleSelectionType(tree, qual)
-    }
+  def assignType(tree: untpd.Select, tp: Type)(using Context): Select =
     ConstFold.Select(tree.withType(tp))
-  }
+
+  def assignType(tree: untpd.Select, qual: Tree)(using Context): Select =
+    val ownType = accessibleSelectionType(tree, qual).orElse(notAMember(tree, qual))
+    assignType(tree, ownType)
 
   /** Normalize type T appearing in a new T by following eta expansions to
    *  avoid higher-kinded types.

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

@@ -551,18 +551,22 @@ class Typer extends Namer
     case qual: ExtMethodApply =>
       qual.app
     case qual =>
-      val select = assignType(cpy.Select(tree)(qual, tree.name), qual)
-      val select1 = toNotNullTermRef(select, pt)
-
-      if (tree.name.isTypeName) checkStable(qual.tpe, qual.srcPos, "type prefix")
-
-      if select1.tpe ne TryDynamicCallType then
-        checkStableIdentPattern(select1, pt)
-        ConstFold(select1)
-      else if pt.isInstanceOf[FunOrPolyProto] || pt == AssignProto then
-        select1
-      else
-        typedDynamicSelect(tree, Nil, pt)
+      val untpdSelect = cpy.Select(tree)(qual, tree.name)
+      val ownType = accessibleSelectionType(untpdSelect, qual)
+      if ownType.exists then
+        val select = assignType(untpdSelect, ownType)
+        val select1 = toNotNullTermRef(select, pt)
+
+        if (tree.name.isTypeName) checkStable(qual.tpe, qual.srcPos, "type prefix")
+
+        if select1.tpe ne TryDynamicCallType then
+          checkStableIdentPattern(select1, pt)
+          ConstFold(select1)
+        else if pt.isInstanceOf[FunOrPolyProto] || pt == AssignProto then
+          select1
+        else
+          typedDynamicSelect(tree, Nil, pt)
+      else notAMember(untpdSelect, qual)
   }
 
   def typedSelect(tree: untpd.Select, pt: Type)(using Context): Tree = {
@@ -3439,7 +3443,7 @@ class Typer extends Namer
       case _ => tp
     }
 
-    def adaptToSubType(wtp: Type): Tree = {
+    def adaptToSubType(wtp: Type): Tree =
       // try converting a constant to the target type
       ConstFold(tree).tpe.widenTermRefExpr.normalized match
         case ConstantType(x) =>
@@ -3478,6 +3482,13 @@ class Typer extends Namer
         case _ =>
       }
 
+      // try an Any -> Matchable conversion
+      if pt.isMatchableBound && !wtp.derivesFrom(defn.MatchableClass) then
+        checkMatchable(wtp, tree.srcPos, pattern = false)
+        val target = AndType(tree.tpe.widenExpr, defn.MatchableType)
+        if target <:< pt then
+          return readapt(tree.cast(target))
+
       // try GADT approximation, but only if we're trying to select a member
       // Member lookup cannot take GADTs into account b/c of cache, so we
       // approximate types based on GADT constraints instead. For an example,
@@ -3520,18 +3531,9 @@ class Typer extends Namer
         case _ =>
       }
 
-      // try an Any -> Matchable conversion
-      if pt.isMatchableBound && !wtp.derivesFrom(defn.MatchableClass) then
-        checkMatchable(wtp, tree.srcPos, pattern = false)
-        val target = AndType(tree.tpe.widenExpr, defn.MatchableType)
-        if target <:< pt then
-          return readapt(tree.cast(target))
-
       // try an implicit conversion
-      val prevConstraint = ctx.typerState.constraint
       def recover(failure: SearchFailureType) =
-        if (isFullyDefined(wtp, force = ForceDegree.all) &&
-            ctx.typerState.constraint.ne(prevConstraint)) readapt(tree)
+        if canDefineFurther(wtp) then readapt(tree)
         else err.typeMismatch(tree, pt, failure)
 
       if ctx.mode.is(Mode.ImplicitsEnabled) && tree.typeOpt.isValueType then
@@ -3556,7 +3558,7 @@ class Typer extends Namer
             else recover(failure.reason)
         }
       else recover(NoMatchingImplicits)
-    }
+    end adaptToSubType
 
     def adaptType(tp: Type): Tree = {
       val tree1 =