Create fewer extension names

Author: odersky

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

@@ -1357,11 +1357,10 @@ trait Applications extends Compatibility {
       followApply && tp.member(nme.apply).hasAltWith(d => p(TermRef(tp, nme.apply, d)))
   }
 
-  /** Does `tp` have an extension method named `extension_name` with this-argument `argType` and
-   *  result matching `resultType`?
+  /** Does `tp` have an extension method named `xname` with this-argument `argType` and
+   *  result matching `resultType`? `xname` is supposed to start with `extension_`.
    */
-  def hasExtensionMethod(tp: Type, name: TermName, argType: Type, resultType: Type)(using Context) = {
-    val xname = name.toExtensionName
+  def hasExtensionMethodNamed(tp: Type, xname: TermName, argType: Type, resultType: Type)(using Context) = {
     def qualifies(mbr: Denotation) =
       mbr.exists && isApplicableType(tp.select(xname, mbr), argType :: Nil, resultType)
     tp.memberBasedOnFlags(xname, required = ExtensionMethod) match {

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

@@ -69,8 +69,8 @@ object Implicits:
    *  method with the selecting name? False otherwise.
    */
   def hasExtMethod(tp: Type, expected: Type)(using Context) = expected match
-    case SelectionProto(name, _, _, _) =>
-      tp.memberBasedOnFlags(name.toExtensionName, required = ExtensionMethod).exists
+    case selProto @ SelectionProto(_: TermName, _, _, _) =>
+      tp.memberBasedOnFlags(selProto.extensionName, required = ExtensionMethod).exists
     case _ => false
 
   def strictEquality(using Context): Boolean =
@@ -1034,9 +1034,9 @@ trait Implicits:
               pt, locked)
           }
           pt match
-            case SelectionProto(name: TermName, mbrType, _, _) if cand.isExtension =>
+            case selProto @ SelectionProto(_: TermName, mbrType, _, _) if cand.isExtension =>
               def tryExtension(using Context) =
-                extMethodApply(untpd.Select(untpdGenerated, name.toExtensionName), argument, mbrType)
+                extMethodApply(untpd.Select(untpdGenerated, selProto.extensionName), argument, mbrType)
               if cand.isConversion then
                 val extensionCtx, conversionCtx = ctx.fresh.setNewTyperState()
                 val extensionResult = tryExtension(using extensionCtx)

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

@@ -129,6 +129,11 @@ object ProtoTypes {
   abstract case class SelectionProto(name: Name, memberProto: Type, compat: Compatibility, privateOK: Boolean)
   extends CachedProxyType with ProtoType with ValueTypeOrProto {
 
+    private var myExtensionName: TermName = null
+    def extensionName: TermName =
+      if myExtensionName == null then myExtensionName = name.toExtensionName
+      myExtensionName
+
     /** Is the set of members of this type unknown? This is the case if:
      *  1. The type has Nothing or Wildcard as a prefix or underlying type
      *  2. The type has an uninstantiated TypeVar as a prefix or underlying type,
@@ -416,8 +421,8 @@ object ProtoTypes {
     def isMatchedBy(tp: Type, keepConstraint: Boolean)(using Context): Boolean =
       ctx.typer.isApplicableType(tp, argType :: Nil, resultType) || {
         resType match {
-          case SelectionProto(name: TermName, mbrType, _, _) =>
-            ctx.typer.hasExtensionMethod(tp, name, argType, mbrType)
+          case selProto @ SelectionProto(_: TermName, mbrType, _, _) =>
+            ctx.typer.hasExtensionMethodNamed(tp, selProto.extensionName, argType, mbrType)
               //.reporting(i"has ext $tp $name $argType $mbrType: $result")
           case _ =>
             false

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

@@ -3468,10 +3468,10 @@ class Typer extends Namer
 
       // try an extension method in scope
       pt match {
-        case SelectionProto(name, mbrType, _, _) =>
+        case selProto @ SelectionProto(_: TermName, mbrType, _, _) =>
           def tryExtension(using Context): Tree =
             try
-              findRef(name.toExtensionName, WildcardType, ExtensionMethod, tree.srcPos) match {
+              findRef(selProto.extensionName, WildcardType, ExtensionMethod, tree.srcPos) match {
                 case ref: TermRef =>
                   extMethodApply(untpd.ref(ref).withSpan(tree.span), tree, mbrType)
                 case _ => EmptyTree

tests/neg/i7813.scala

@@ -1,3 +1,3 @@
 implicit def f[X <: Undefined](implicit a: Int): X = ??? // error
-def g(arg: h.NonExistent): Int = ???
+def g(arg: h.NonExistent): Int = ??? // error
 val h: Int = ???