Drop support for extension_ names

Author: odersky

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

@@ -137,21 +137,6 @@ object NameOps {
       else name.toTermName
     }
 
-    /** Does the name match `extension`? */
-    def isExtension: Boolean = name match
-      case name: SimpleName =>
-        name.length == "extension".length && name.startsWith("extension")
-      case _ => false
-
-    /** Does this name start with `extension_`? */
-    def isExtensionName: Boolean = name match
-      case name: SimpleName => name.startsWith("extension_")
-      case _ => false
-
-    // TODO: Drop next 3 methods once extension names have stabilized
-    /** Add an `extension_` in front of this name */
-    def toExtensionName(using Context): SimpleName = "extension_".concat(name)
-
     /** The expanded name.
      *  This is the fully qualified name of `base` with `ExpandPrefixName` as separator,
      *  followed by `kind` and the name.

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

@@ -383,8 +383,7 @@ class PostTyper extends MacroTransform with IdentityDenotTransformer { thisPhase
 
           def checkIdent(sel: untpd.ImportSelector): Unit =
             if !exprTpe.member(sel.name).exists
-               && !exprTpe.member(sel.name.toTypeName).exists
-               && !exprTpe.member(sel.name.toExtensionName).exists then
+               && !exprTpe.member(sel.name.toTypeName).exists then
               report.error(NotAMember(exprTpe, sel.name, "value"), sel.imported.srcPos)
             if seen.contains(sel.name) then
               report.error(ImportRenamedTwice(sel.imported), sel.imported.srcPos)

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

@@ -76,9 +76,9 @@ object Implicits:
    */
   def hasExtMethod(tp: Type, expected: Type)(using Context) = expected match
     case selProto @ SelectionProto(selName: TermName, _, _, _) =>
-         tp.memberBasedOnFlags(selName, required = ExtensionMethod).exists
-      || tp.memberBasedOnFlags(selProto.extensionName, required = ExtensionMethod).exists
-    case _ => false
+      tp.memberBasedOnFlags(selName, required = ExtensionMethod).exists
+    case _ =>
+      false
 
   def strictEquality(using Context): Boolean =
     ctx.mode.is(Mode.StrictEquality) || Feature.enabled(nme.strictEquality)
@@ -1023,12 +1023,7 @@ trait Implicits:
           pt match
             case selProto @ SelectionProto(selName: TermName, mbrType, _, _) if cand.isExtension =>
               def tryExtension(using Context) =
-                val xname =
-                  if ref.memberBasedOnFlags(selProto.extensionName, required = ExtensionMethod).exists then
-                    selProto.extensionName
-                  else
-                    selName
-                extMethodApply(untpd.Select(untpdGenerated, xname), argument, mbrType)
+                extMethodApply(untpd.Select(untpdGenerated, selName), 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

@@ -147,11 +147,6 @@ 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(using Context): 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,
@@ -447,8 +442,7 @@ object ProtoTypes {
       ctx.typer.isApplicableType(tp, argType :: Nil, resultType) || {
         resType match {
           case selProto @ SelectionProto(selName: TermName, mbrType, _, _) =>
-               ctx.typer.hasExtensionMethodNamed(tp, selName, argType, mbrType)
-            || ctx.typer.hasExtensionMethodNamed(tp, selProto.extensionName, argType, mbrType)
+            ctx.typer.hasExtensionMethodNamed(tp, selName, argType, mbrType)
               //.reporting(i"has ext $tp $name $argType $mbrType: $result")
           case _ =>
             false

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

@@ -3348,11 +3348,8 @@ class Typer extends Namer
     // implicit conversion to the receiver type.
     def sharpenedPt = pt match
       case pt: SelectionProto
-      if pt.name.isExtensionName
-         || pt.memberProto.revealIgnored.isExtensionApplyProto =>
-        pt.deepenProto
-      case _ =>
-        pt
+      if pt.memberProto.revealIgnored.isExtensionApplyProto => pt.deepenProto
+      case _ => pt
 
     def adaptNoArgs(wtp: Type): Tree = {
       val ptNorm = underlyingApplied(pt)
@@ -3504,10 +3501,8 @@ class Typer extends Namer
             findRef(selName, WildcardType, ExtensionMethod, EmptyFlags, tree.srcPos) match
               case ref: TermRef =>
                 extMethodApply(untpd.ref(ref).withSpan(tree.span), tree, mbrType)
-              case _ => findRef(selProto.extensionName, WildcardType, ExtensionMethod, EmptyFlags, tree.srcPos) match
-                case ref: TermRef =>
-                  extMethodApply(untpd.ref(ref).withSpan(tree.span), tree, mbrType)
-                case _ => EmptyTree
+              case _ =>
+                EmptyTree
 
           try
             val nestedCtx = ctx.fresh.setNewTyperState()