Handle AntiPolyType in Symbol.alternatives

som-snytt · som-snytt · commit 175256ba5174 · 2024-08-13T15:42:44.000-07:00
diff --git a/src/compiler/scala/tools/nsc/typechecker/Infer.scala b/src/compiler/scala/tools/nsc/typechecker/Infer.scala
@@ -1537,36 +1537,37 @@ trait Infer extends Checkable {
     def inferPolyAlternatives(tree: Tree, argtypes: List[Type]): Unit = {
       val OverloadedType(pre, alts) = tree.tpe: @unchecked
       // Alternatives with a matching length type parameter list
-      val matchingLength   = tree.symbol filter (alt => sameLength(alt.typeParams, argtypes))
-      def allMonoAlts      = alts forall (_.typeParams.isEmpty)
-      def errorKind        = matchingLength match {
+      val matchingLength = tree.symbol.filter(alt => sameLength(alt.typeParams, argtypes))
+      def allMonoAlts    = alts.forall(_.typeParams.isEmpty)
+      def errorKind      = matchingLength match {
         case NoSymbol if allMonoAlts => PolyAlternativeErrorKind.NoParams          // no polymorphic method alternative
         case NoSymbol                => PolyAlternativeErrorKind.WrongNumber       // wrong number of tparams
         case _                       => PolyAlternativeErrorKind.ArgsDoNotConform  // didn't conform to bounds
       }
       def fail() = PolyAlternativeError(tree, argtypes, matchingLength, errorKind)
-      def finish(sym: Symbol, tpe: Type) = tree setSymbol sym setType tpe
+      def finish(sym: Symbol, tpe: Type) = tree.setSymbol(sym).setType(tpe)
       // Alternatives which conform to bounds
       def checkWithinBounds(sym: Symbol): Unit = sym.alternatives match {
         case Nil            => if (!argtypes.exists(_.isErroneous)) fail()
-        case alt :: Nil     => finish(alt, pre memberType alt)
+        case alt :: Nil     => finish(alt, pre.memberType(alt))
         case alts @ hd :: _ =>
           log(s"Attaching AntiPolyType-carrying overloaded type to $sym")
           // Multiple alternatives which are within bounds; spin up an
           // overloaded type which carries an "AntiPolyType" as a prefix.
-          val tparams = new AsSeenFromMap(pre, hd.owner) mapOver hd.typeParams
-          val bounds  = tparams map (_.tpeHK) // see e.g., #1236
+          val tparams = new AsSeenFromMap(pre, hd.owner).mapOver(hd.typeParams)
+          val bounds  = tparams.map(_.tpeHK) // scala/bug#1236
           val tpe     = PolyType(tparams, OverloadedType(AntiPolyType(pre, bounds), alts))
-          finish(sym setInfo tpe, tpe)
+          finish(sym.setInfo(tpe), tpe)
       }
       matchingLength.alternatives match {
         case Nil        => fail()
-        case alt :: Nil => finish(alt, pre memberType alt)
+        case alt :: Nil => finish(alt, pre.memberType(alt))
         case _ =>
-          checkWithinBounds(matchingLength.filter { alt =>
+          val conforming = matchingLength.filter { alt =>
             isWithinBounds(pre, alt.owner, alt.typeParams, argtypes) &&
               kindsConform(alt.typeParams, argtypes, pre, alt.owner)
-          })
+          }
+          checkWithinBounds(conforming)
       }
     }
   }
diff --git a/src/compiler/scala/tools/nsc/typechecker/Typers.scala b/src/compiler/scala/tools/nsc/typechecker/Typers.scala
@@ -4515,7 +4515,7 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper
           val isClassOf = fun.symbol.rawname == nme.classOf && currentRun.runDefinitions.isPredefClassOf(fun.symbol)
           if (isJava && fun.symbol.isTerm) args.foreach(_.modifyType(rawToExistential)) // e.g. List.class, parsed as classOf[List]
           val targs = mapList(args)(_.tpe)
-          checkBounds(tree, NoPrefix, NoSymbol, tparams, targs, "")
+          checkBounds(tree, NoPrefix, NoSymbol, tparams, targs, prefix = "")
           if (isClassOf)
             typedClassOf(tree, args.head, noGen = true)
           else {
diff --git a/src/reflect/scala/reflect/internal/Symbols.scala b/src/reflect/scala/reflect/internal/Symbols.scala
@@ -2035,7 +2035,11 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
 // ------ overloaded alternatives ------------------------------------------------------
 
     def alternatives: List[Symbol] =
-      if (isOverloaded) info.asInstanceOf[OverloadedType].alternatives
+      if (isOverloaded) info match {
+        case OverloadedType(pre, alternatives) => alternatives
+        case PolyType(typeParams, OverloadedType(AntiPolyType(pre, targs), alternatives)) => alternatives
+        case _ => this :: Nil
+      }
       else this :: Nil
 
     def filter(cond: Symbol => Boolean): Symbol =
diff --git a/src/reflect/scala/reflect/internal/Types.scala b/src/reflect/scala/reflect/internal/Types.scala
@@ -71,7 +71,7 @@ import TypeConstants._
     // [tparams]result where result is a (Nullary)MethodType or ClassInfoType
 
   // The remaining types are not used after phase `typer`.
-  case OverloadedType(pre, tparams, alts) =>
+  case OverloadedType(pre, alternatives) =>
     // all alternatives of an overloaded ident
   case AntiPolyType(pre, targs) =>
     // rarely used, disappears when combined with a PolyType
@@ -2936,8 +2936,7 @@ trait Types
 
   object MethodType extends MethodTypeExtractor
 
-  // TODO: rename so it's more appropriate for the type that is for a method without argument lists
-  // ("nullary" erroneously implies it has an argument list with zero arguments, it actually has zero argument lists)
+  // Nullary not nilary, i.e., parameterlistless not merely parameterless
   case class NullaryMethodType(override val resultType: Type) extends Type with NullaryMethodTypeApi {
     override def isTrivial = resultType.isTrivial && (resultType eq resultType.withoutAnnotations)
     override def prefix: Type = resultType.prefix
@@ -4162,6 +4161,8 @@ trait Types
       case TypeRef(pre, sym, Nil)                         => copyTypeRef(tycon, pre, sym, args)
       case TypeRef(pre, sym, bogons)                      => devWarning(s"Dropping $bogons from $tycon in appliedType.") ; copyTypeRef(tycon, pre, sym, args)
       case PolyType(tparams, restpe)                      => restpe.instantiateTypeParams(tparams, args)
+      case MethodType(params, resultType)                 => resultType
+      case NullaryMethodType(resultType)                  => resultType
       case ExistentialType(tparams, restpe)               => newExistentialType(tparams, appliedType(restpe, args))
       case st: SingletonType                              => appliedType(st.widen, args) // @M TODO: what to do? see bug1
       case RefinedType(parents, decls)                    => RefinedType(parents map (appliedType(_, args)), decls)   // @PP: Can this be right?
diff --git a/test/files/neg/t10628.check b/test/files/neg/t10628.check
@@ -0,0 +1,7 @@
+t10628.scala:8: error: overloaded method a with alternatives:
+  Int <and>
+  Int
+ cannot be applied to (Int)
+  def f  = A.a[Int][String](0)
+                   ^
+1 error
diff --git a/test/files/neg/t10628.scala b/test/files/neg/t10628.scala
@@ -0,0 +1,9 @@
+
+object A {
+  def a[F](x: Int) = 0
+  def a[F](x: String) = 0
+}
+
+class C {
+  def f  = A.a[Int][String](0)
+}
diff --git a/test/files/pos/t10628.scala b/test/files/pos/t10628.scala
@@ -0,0 +1,15 @@
+
+class Apply {
+  def apply[A](x: Int) = 1
+}
+
+object A {
+  def a[F] = new Apply
+  def a[F](x: String) = 0
+}
+
+class C {
+  def f = A.a[String]("a") // 0
+  def g = A.a[String](2)   // 1
+  def k = A.a[String][Int](3)
+}
