Drop extension_ name mangling

For the moment will still support extension_name references to extension
methods in order to work with non-bootstrapped libraries. But we do not
generate these names anymore.

Author: odersky

compiler/src/dotty/tools/dotc/ast/Desugar.scala

@@ -895,7 +895,7 @@ object desugar {
           mdef.tparams.head.srcPos)
       defDef(
         cpy.DefDef(mdef)(
-          name = normalizeName(mdef, ext).toExtensionName,
+          name = normalizeName(mdef, ext).asTermName,
           tparams = ext.tparams ++ mdef.tparams,
           vparamss = mdef.vparamss match
             case vparams1 :: vparamss1 if mdef.name.isRightAssocOperatorName =>
@@ -928,10 +928,10 @@ object desugar {
 
   /** The normalized name of `mdef`. This means
    *   1. Check that the name does not redefine a Scala core class.
-   *      If it does redefine, issue an error and return a mangled name instead of the original one.
-   *   2. Check that the name does not start with `extension_` unless the
-   *      method is an extension method.
-   *   3. If the name is missing (this can be the case for instance definitions), invent one instead.
+   *      If it does redefine, issue an error and return a mangled name instead
+   *      of the original one.
+   *   2. If the name is missing (this can be the case for instance definitions),
+   *      invent one instead.
    */
   def normalizeName(mdef: MemberDef, impl: Tree)(using Context): Name = {
     var name = mdef.name
@@ -942,31 +942,16 @@ object desugar {
       report.error(IllegalRedefinitionOfStandardKind(kind, name), errPos)
       name = name.errorName
     }
-    mdef match {
-      case vdef: ValDef if name.isExtension && isSetterNeeded(vdef)  =>
-        report.error(em"illegal setter name: `extension_=`", errPos)
-      case memDef if name.isExtensionName && !mdef.mods.is(ExtensionMethod) =>
-        report.error(em"illegal name: $name may not start with `extension_`", errPos)
-      case _ =>
-    }
     name
   }
 
-  /** Invent a name for an anonympus given or extension of type or template `impl`. */
+  /** Invent a name for an anonympus given of type or template `impl`. */
   def inventGivenOrExtensionName(impl: Tree)(using Context): SimpleName =
     val str = impl match
       case impl: Template =>
         if impl.parents.isEmpty then
-          impl.body.find {
-            case dd: DefDef if dd.mods.is(ExtensionMethod) => true
-            case _ => false
-          }
-          match
-            case Some(DefDef(name, _, (vparam :: _) :: _, _, _)) =>
-              s"extension_${name}_${inventTypeName(vparam.tpt)}"
-            case _ =>
-              report.error(AnonymousInstanceCannotBeEmpty(impl), impl.srcPos)
-              nme.ERROR.toString
+          report.error(AnonymousInstanceCannotBeEmpty(impl), impl.srcPos)
+          nme.ERROR.toString
         else
           impl.parents.map(inventTypeName(_)).mkString("given_", "_", "")
       case impl: Tree =>

compiler/src/dotty/tools/dotc/ast/Trees.scala

@@ -343,10 +343,7 @@ object Trees {
         if (rawMods.is(Synthetic) || span.isSynthetic || name.toTermName == nme.ERROR) Span(point)
         else {
           val realName = name.stripModuleClassSuffix.lastPart
-          var length = realName.length
-          if (rawMods.is(ExtensionMethod) || symbol.is(ExtensionMethod)) && name.isExtensionName then
-            length -= "extension_".length
-          Span(point, point + length, point)
+          Span(point, point + realName.length, point)
         }
       }
       else span

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

@@ -229,7 +229,6 @@ class Definitions {
     @tu lazy val Compiletime_requireConst: Symbol = CompiletimePackageObject.requiredMethod("requireConst")
     @tu lazy val Compiletime_constValue   : Symbol = CompiletimePackageObject.requiredMethod("constValue")
     @tu lazy val Compiletime_constValueOpt: Symbol = CompiletimePackageObject.requiredMethod("constValueOpt")
-    @tu lazy val Compiletime_code         : Symbol = CompiletimePackageObject.requiredMethod("extension_code")
     @tu lazy val Compiletime_summonFrom   : Symbol = CompiletimePackageObject.requiredMethod("summonFrom")
   @tu lazy val CompiletimeTestingPackageObject: Symbol = requiredModule("scala.compiletime.testing.package")
     @tu lazy val CompiletimeTesting_typeChecks: Symbol = CompiletimeTestingPackageObject.requiredMethod("typeChecks")

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

@@ -152,6 +152,10 @@ object Flags {
     def flagsString: String = x.flagStrings("").mkString(" ")
   }
 
+  // Temporary while extension names are in flux
+  def or(x1: FlagSet, x2: FlagSet) = x1 | x2
+  def and(x1: FlagSet, x2: FlagSet) = x1 & x2
+
   def termFlagSet(x: Long) = FlagSet(TERMS | x)
 
   private inline val TYPESHIFT = 2

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

@@ -145,16 +145,10 @@ object NameOps {
       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)
 
-    /** Drop `extension_` in front of this name, if it has this prefix */
-    def dropExtension = name match
-      case name: SimpleName if name.startsWith("extension_") =>
-        name.drop("extension_".length)
-      case _ =>
-        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/printing/RefinedPrinter.scala

@@ -752,11 +752,9 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
   private def useSymbol(tree: untpd.Tree) =
     tree.hasType && tree.symbol.exists && ctx.settings.YprintSyms.value
 
-  protected def nameIdText[T >: Untyped](tree: NameTree[T], dropExtension: Boolean = false): Text =
+  protected def nameIdText[T >: Untyped](tree: NameTree[T]): Text =
     if (tree.hasType && tree.symbol.exists) {
-      var str = nameString(tree.symbol)
-      if tree.symbol.is(ExtensionMethod) && dropExtension && str.startsWith("extension_") then
-        str = str.drop("extension_".length)
+      val str = nameString(tree.symbol)
       tree match {
         case tree: RefTree => withPos(str, tree.sourcePos)
         case tree: MemberDef => withPos(str, tree.sourcePos.withSpan(tree.nameSpan))
@@ -808,7 +806,7 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
               case vparams1 :: rest =>
                 (vparams1, rest)
             (keywordStr("extension") ~~ paramsText(leadingParams)
-             ~~ (defKeyword ~~ valDefText(nameIdText(tree, dropExtension = true))).close,
+             ~~ (defKeyword ~~ valDefText(nameIdText(tree))).close,
              otherParamss)
           else (defKeyword ~~ valDefText(nameIdText(tree)), tree.vparamss)
 

compiler/src/dotty/tools/dotc/quoted/QuoteContextImpl.scala

@@ -2535,8 +2535,8 @@ class QuoteContextImpl private (ctx: Context) extends QuoteContext, scala.intern
     object FlagsMethodsImpl extends FlagsMethods:
       extension (self: Flags):
         def is(that: Flags): Boolean = self.isAllOf(that)
-        def |(that: Flags): Flags = dotc.core.Flags.extension_|(self)(that)
-        def &(that: Flags): Flags = dotc.core.Flags.extension_&(self)(that)
+        def |(that: Flags): Flags = dotc.core.Flags.or(self, that) // TODO: Replace with dotc.core.Flags.|(self)(that)  once extension names have stabilized
+        def &(that: Flags): Flags = dotc.core.Flags.and(self, that)// TODO: Replace with dotc.core.Flags.&(self)(that)  once extension names have stabilized
         def showExtractors: String =
           Extractors.showFlags(using QuoteContextImpl.this)(self)
         def show: String =

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

@@ -1392,7 +1392,7 @@ trait Applications extends Compatibility {
   }
 
   /** Does `tp` have an extension method named `xname` with this-argument `argType` and
-   *  result matching `resultType`? `xname` is supposed to start with `extension_`.
+   *  result matching `resultType`?
    */
   def hasExtensionMethodNamed(tp: Type, xname: TermName, argType: Type, resultType: Type)(using Context) = {
     def qualifies(mbr: Denotation) =

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

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

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

@@ -219,7 +219,7 @@ trait ImportSuggestions:
      *  applicable to `argType`.
      */
     def extensionMethod(site: TermRef, name: TermName, argType: Type): Option[TermRef] =
-      site.member(name.toExtensionName)
+      site.member(name)
         .alternatives
         .map(mbr => TermRef(site, mbr.symbol))
         .filter(ref =>
@@ -320,7 +320,7 @@ trait ImportSuggestions:
     def importString(ref: TermRef): String =
       val imported =
         if ref.symbol.is(ExtensionMethod) then
-          s"${ctx.printer.toTextPrefix(ref.prefix).show}${ref.symbol.name.dropExtension}"
+          s"${ctx.printer.toTextPrefix(ref.prefix).show}${ref.symbol.name}"
         else
           ctx.printer.toTextRef(ref).show
       s"  import $imported"