fix: simplify types before checking if implicit is underspecified

Author: hamzaremmal

compiler/src/dotty/tools/dotc/core/Types.scala

@@ -229,6 +229,7 @@ object Types extends TypeUtils {
 
     def isAny(using Context): Boolean     = isRef(defn.AnyClass, skipRefined = false)
     def isAnyRef(using Context): Boolean  = isRef(defn.ObjectClass, skipRefined = false)
+    def isAnyVal(using Context): Boolean  = isRef(defn.AnyValClass, skipRefined = false)
     def isAnyKind(using Context): Boolean = isRef(defn.AnyKindClass, skipRefined = false)
 
     def isTopType(using Context): Boolean = dealias match

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

@@ -1668,15 +1668,14 @@ trait Implicits:
     def isUnderSpecifiedArgument(tp: Type): Boolean =
       tp.isRef(defn.NothingClass) || tp.isRef(defn.NullClass) || (tp eq NoPrefix)
 
-    private def isUnderspecified(tp: Type): Boolean = tp.stripTypeVar match
+    private def isUnderspecified(tp: Type): Boolean = tp.simplified match
       case tp: WildcardType =>
         !tp.optBounds.exists || isUnderspecified(tp.optBounds.hiBound)
       case tp: ViewProto =>
         isUnderspecified(tp.resType)
         || tp.resType.isRef(defn.UnitClass)
         || isUnderSpecifiedArgument(tp.argType.widen)
-      case _ =>
-        tp.isAny || tp.isAnyRef
+      case tp => tp.isAny || tp.isAnyRef || tp.isAnyVal
 
     /** Search implicit in context `ctxImplicits` or else in implicit scope
      *  of expected type if `ctxImplicits == null`.

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

@@ -4952,10 +4952,6 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
         case _ if ctx.mode.is(Mode.ImplicitsEnabled) && tree.tpe.isValueType =>
           if tree.tpe.isNamedTupleType && pt.derivesFrom(defn.TupleClass) then
             readapt(typed(untpd.Select(untpd.TypedSplice(tree), nme.toTuple)))
-          else if pt.isRef(defn.AnyValClass, skipRefined = false)
-              || pt.isRef(defn.ObjectClass, skipRefined = false)
-          then
-            recover(TooUnspecific(pt))
           else inferView(tree, pt) match
             case SearchSuccess(found, _, _, isExtension) =>
               if isExtension then found

tests/neg/i21304.check

@@ -0,0 +1,23 @@
+-- [E007] Type Mismatch Error: tests/neg/i21304.scala:5:6 --------------------------------------------------------------
+5 |  foo(10) // error
+  |      ^^
+  |      Found:    (10 : Int)
+  |      Required: AnyRef | Null
+  |      Note that implicit conversions were not tried because the result of an implicit conversion
+  |      must be more specific than AnyRef | Null
+  |
+  |      One of the following imports might fix the problem:
+  |
+  |        import scala.math.BigDecimal.int2bigDecimal
+  |        import scala.math.BigInt.int2bigInt
+  |        import scala.math.Numeric.IntIsIntegral.mkNumericOps
+  |        import scala.math.Numeric.IntIsIntegral.mkOrderingOps
+  |        import scala.math.Ordering.Int.mkOrderingOps
+  |        import scala.math.Integral.Implicits.infixIntegralOps
+  |        import scala.math.Ordered.orderingToOrdered
+  |        import scala.math.Ordering.Implicits.infixOrderingOps
+  |        import scala.math.Numeric.Implicits.infixNumericOps
+  |        import scala.reflect.Selectable.reflectiveSelectable
+  |
+  |
+  | longer explanation available when compiling with `-explain`

tests/neg/i21304.scala

@@ -0,0 +1,5 @@
+def foo(x: AnyRef | Null): Unit =
+  println(x)
+
+@main def main(): Unit =
+  foo(10) // error

tests/neg/implicits-numeric.check

@@ -0,0 +1,5 @@
+-- [E172] Type Error: tests/neg/implicits-numeric.scala:6:28 -----------------------------------------------------------
+6 |  println(implicitly[AnyVal]) // error
+  |                            ^
+  |                            No implicit search was attempted for parameter e of method implicitly in object Predef
+  |                            since the expected type AnyVal is not specific enough

tests/run/implicits-numeric.scala renamed to tests/neg/implicits-numeric.scala

@@ -3,5 +3,5 @@ object Test extends App {
   implicit def _1: Long = 1L
   implicit def _2: Int = 0
 
-  println(implicitly[AnyVal])
+  println(implicitly[AnyVal]) // error
 }