Revert specific conversion checking

# Conflicts:
#	compiler/src/dotty/tools/dotc/typer/Typer.scala

Author: odersky

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

@@ -648,14 +648,11 @@ object Checking {
           else "Cannot override non-inline parameter with an inline parameter",
           p1.srcPos)
 
-  def checkConversionsSpecific(from: Type, to: Type, pos: SrcPos)(using Context): Unit =
-    def fail(part: String, tp: Type) =
-      report.error(em"the $part of an implicit conversion must be more specific than $tp", pos)
+  def checkConversionsSpecific(to: Type, pos: SrcPos)(using Context): Unit =
     if to.isRef(defn.AnyValClass, skipRefined = false)
        || to.isRef(defn.ObjectClass, skipRefined = false)
-    then fail("result", to)
-    if from.isBottomTypeAfterErasure
-    then fail("argument", from)
+    then
+      report.error(em"the result of an implicit conversion must be more specific than $to", pos)
 }
 
 trait Checking {

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

@@ -537,9 +537,6 @@ class Typer extends Namer
       errorTree(tree, MissingIdent(tree, kind, name))
   end typedIdent
 
-  val newScheme: Boolean = true
-  val dia: Boolean = false
-
   /** Check that a stable identifier pattern is indeed stable (SLS 8.1.5)
    */
   private def checkStableIdentPattern(tree: Tree, pt: Type)(using Context): Unit =
@@ -3581,27 +3578,40 @@ class Typer extends Namer
         if canDefineFurther(wtp) then readapt(tree)
         else err.typeMismatch(tree, pt, failure)
 
-      if pt.isInstanceOf[SelectionProto] then
-        tree // adaptations for selections are handled in typedSelect
-      else if ctx.mode.is(Mode.ImplicitsEnabled) && tree.tpe.isValueType then
-        checkConversionsSpecific(wtp, pt, tree.srcPos)
-        inferView(tree, pt) match {
-          case SearchSuccess(found, _, _, isExtension) =>
-            if isExtension then found
-            else
-              checkImplicitConversionUseOK(found)
-              withoutMode(Mode.ImplicitsEnabled)(readapt(found))
-          case failure: SearchFailure =>
-            if (pt.isInstanceOf[ProtoType] && !failure.isAmbiguous) then
-              // don't report the failure but return the tree unchanged. This
-              // will cause a failure at the next level out, which usually gives
-              // a better error message. To compensate, store the encountered failure
-              // as an attachment, so that it can be reported later as an addendum.
-              rememberSearchFailure(tree, failure)
-              tree
-            else recover(failure.reason)
-        }
-      else recover(NoMatchingImplicits)
+      pt match
+        case pt: SelectionProto =>
+          if ctx.gadt.nonEmpty then
+            // try GADT approximation 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,
+            // see MemberHealing in gadt-approximation-interaction.scala.
+            gadts.println(i"Trying to heal member selection by GADT-approximating $wtp")
+            val gadtApprox = Inferencing.approximateGADT(wtp)
+            gadts.println(i"GADT-approximated $wtp ~~ $gadtApprox")
+            if pt.isMatchedBy(gadtApprox) then
+              gadts.println(i"Member selection healed by GADT approximation")
+              tpd.Typed(tree, TypeTree(gadtApprox))
+            else tree
+          else tree // other adaptations for selections are handled in typedSelect
+        case _ if ctx.mode.is(Mode.ImplicitsEnabled) && tree.tpe.isValueType =>
+          checkConversionsSpecific(pt, tree.srcPos)
+          inferView(tree, pt) match
+            case SearchSuccess(found, _, _, isExtension) =>
+              if isExtension then found
+              else
+                checkImplicitConversionUseOK(found)
+                withoutMode(Mode.ImplicitsEnabled)(readapt(found))
+            case failure: SearchFailure =>
+              if (pt.isInstanceOf[ProtoType] && !failure.isAmbiguous) then
+                // don't report the failure but return the tree unchanged. This
+                // will cause a failure at the next level out, which usually gives
+                // a better error message. To compensate, store the encountered failure
+                // as an attachment, so that it can be reported later as an addendum.
+                rememberSearchFailure(tree, failure)
+                tree
+              else recover(failure.reason)
+        case _ =>
+          recover(NoMatchingImplicits)
     end adaptToSubType
 
     def adaptType(tp: Type): Tree = {