Make the SAMType extractor return a type, not a denot

Author: smarter

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

@@ -3783,8 +3783,8 @@ object Types {
    *     and PolyType not allowed!)
    *   - can be instantiated without arguments or with just () as argument.
    *
-   *  The pattern `SAMType(denot)` matches a SAM type, where `denot` is the
-   *  denotation of the single abstract method as a member of the type.
+   *  The pattern `SAMType(sam)` matches a SAM type, where `sam` is the
+   *  type of the single abstract method.
    */
   object SAMType {
     def zeroParamClass(tp: Type)(implicit ctx: Context): Type = tp match {
@@ -3817,14 +3817,16 @@ object Types {
       case _ =>
         false
     }
-    def unapply(tp: Type)(implicit ctx: Context): Option[SingleDenotation] =
+    def unapply(tp: Type)(implicit ctx: Context): Option[MethodType] =
       if (isInstantiatable(tp)) {
         val absMems = tp.abstractTermMembers
         // println(s"absMems: ${absMems map (_.show) mkString ", "}")
         if (absMems.size == 1)
           absMems.head.info match {
-            case mt: MethodType if !mt.isParamDependent => Some(absMems.head)
-            case _ => None
+            case mt: MethodType if !mt.isParamDependent =>
+              Some(mt)
+            case _ =>
+              None
           }
         else if (tp isRef defn.PartialFunctionClass)
           // To maintain compatibility with 2.x, we treat PartialFunction specially,
@@ -3833,7 +3835,7 @@ object Types {
           //     def isDefinedAt(x: T) = true
           // and overwrite that method whenever the function body is a sequence of
           // case clauses.
-          absMems.find(_.symbol.name == nme.apply)
+          absMems.find(_.symbol.name == nme.apply).map(_.info.asInstanceOf[MethodType])
         else None
       }
       else None

compiler/src/dotty/tools/dotc/transform/Erasure.scala

@@ -577,9 +577,9 @@ object Erasure {
           val implType = meth.tpe.widen.asInstanceOf[MethodType]
 
           val implParamTypes = implType.paramInfos
-          val List(samParamTypes) = sam.info.paramInfoss
+          val List(samParamTypes) = sam.paramInfoss
           val implResultType = implType.resultType
-          val samResultType = sam.info.resultType
+          val samResultType = sam.resultType
 
           // The following code:
           //
@@ -646,7 +646,7 @@ object Erasure {
             if (paramAdaptationNeeded || resultAdaptationNeeded) {
               val bridgeType =
                 if (paramAdaptationNeeded) {
-                  if (resultAdaptationNeeded) sam.info
+                  if (resultAdaptationNeeded) sam
                   else implType.derivedLambdaType(paramInfos = samParamTypes)
                 } else implType.derivedLambdaType(resType = samResultType)
               val bridge = ctx.newSymbol(ctx.owner, AdaptedClosureName(meth.symbol.name.asTermName), Flags.Synthetic | Flags.Method, bridgeType)

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

@@ -482,7 +482,7 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
         false
       case argtpe =>
         def SAMargOK = formal match {
-          case SAMType(meth) => argtpe <:< meth.info.toFunctionType()
+          case SAMType(sam) => argtpe <:< sam.toFunctionType()
           case _ => false
         }
         isCompatible(argtpe, formal) || ctx.mode.is(Mode.ImplicitsEnabled) && SAMargOK

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

@@ -740,11 +740,10 @@ class Typer extends Namer
         // this can type the greatest set of admissible closures.
         val funType = pt.dealias
         (funType.argTypesLo.init, typeTree(funType.argTypesHi.last))
-      case SAMType(meth) =>
-        val mt @ MethodTpe(_, formals, restpe) = meth.info
+      case SAMType(sam @ MethodTpe(_, formals, restpe)) =>
         (formals,
-         if (mt.isResultDependent)
-           untpd.DependentTypeTree(syms => restpe.substParams(mt, syms.map(_.termRef)))
+         if (sam.isResultDependent)
+           untpd.DependentTypeTree(syms => restpe.substParams(sam, syms.map(_.termRef)))
          else
            typeTree(restpe))
       case tp: TypeParamRef =>
@@ -936,8 +935,8 @@ class Typer extends Namer
         meth1.tpe.widen match {
           case mt: MethodType =>
             pt match {
-              case SAMType(meth)
-              if !defn.isFunctionType(pt) && mt <:< meth.info =>
+              case SAMType(sam)
+              if !defn.isFunctionType(pt) && mt <:< sam =>
                 if (!isFullyDefined(pt, ForceDegree.all))
                   ctx.error(ex"result type of closure is an underspecified SAM type $pt", tree.pos)
                 TypeTree(pt)
@@ -2406,8 +2405,8 @@ class Typer extends Namer
         case closure(Nil, id @ Ident(nme.ANON_FUN), _)
         if defn.isFunctionType(wtp) && !defn.isFunctionType(pt) =>
           pt match {
-            case SAMType(meth)
-            if wtp <:< meth.info.toFunctionType() =>
+            case SAMType(sam)
+            if wtp <:< sam.toFunctionType() =>
               // was ... && isFullyDefined(pt, ForceDegree.noBottom)
               // but this prevents case blocks from implementing polymorphic partial functions,
               // since we do not know the result parameter a priori. Have to wait until the