Move more post-processing out from TypeAssigner#selectionType

Author: odersky

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

@@ -150,39 +150,32 @@ trait TypeAssigner {
     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)
+      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 _ =>
-
-    val pre = maybeSkolemizePrefix(qualType, name)
-    val mbr = qualType.findMember(name, pre)
-    if (reallyExists(mbr))
-      qualType.select(name, mbr)
-    else if (qualType.isErroneous || name.toTermName == nme.ERROR)
-      UnspecifiedErrorType
-    else if couldInstantiateTypeVar(qualType) then
-      // try again with more defined qualifier type
-      selectionType(tree, qual1)
-    else if (name == nme.CONSTRUCTOR)
-      errorType(ex"$qualType does not have a constructor", tree.srcPos)
-    else
-      NoType
+        val pre = maybeSkolemizePrefix(qualType, name)
+        val mbr = qualType.findMember(name, pre)
+        if reallyExists(mbr) then qualType.select(name, mbr)
+        else if qualType.isErroneous || name.toTermName == nme.ERROR then UnspecifiedErrorType
+        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 kind = if tree.isType then "type" else "value"
     def addendum = err.selectErrorAddendum(tree, qual, qualType, importSuggestionAddendum)
-    errorType(NotAMember(qualType, tree.name, kind, addendum), tree.srcPos)
-
+    val msg: Message =
+      if tree.name == nme.CONSTRUCTOR then ex"$qualType does not have a constructor"
+      else NotAMember(qualType, tree.name, kind, addendum)
+    errorType(msg, tree.srcPos)
 
   /** The type of the selection in `tree`, where `qual1` is the typed qualifier part.
    *  The selection type is additionally checked for accessibility.

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

@@ -562,6 +562,9 @@ class Typer extends Namer
         if (tree.name.isTypeName) 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)
       else if qual.tpe.derivesFrom(defn.DynamicClass)
          && tree.name.isTermName && !isDynamicExpansion(untpdSelect)
       then