Set Extension flag for collective extension instances

Author: odersky

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

@@ -301,7 +301,7 @@ object Flags {
   /** A method that has default params */
   val (_, DefaultParameterized @ _, _) = newFlags(27, "<defaultparam>")
 
-  /** An extension method */
+  /** An extension method, or a collective extension instance */
   val (_, Extension @ _, _) = newFlags(28, "<extension>")
 
   /** An inferable (`given`) parameter */
@@ -506,7 +506,7 @@ object Flags {
   val RetainedModuleClassFlags: FlagSet = RetainedModuleValAndClassFlags | Enum
 
   /** Flags retained in export forwarders */
-  val RetainedExportFlags = Given | Implicit | Extension | Inline
+  val RetainedExportFlags = Given | Implicit | Inline
 
   /** Flags that apply only to classes */
   val ClassOnlyFlags = Sealed | Open | Abstract.toTypeFlags

compiler/src/dotty/tools/dotc/parsing/Parsers.scala

@@ -3542,21 +3542,21 @@ object Parsers {
       in.nextToken()
       val name = if isIdent && !isIdent(nme.on) then ident() else EmptyTermName
       in.endMarkerScope(if name.isEmpty then nme.extension else name) {
-        val (tparams, vparamss) =
+        val (tparams, vparamss, extensionFlag) =
           if isIdent(nme.on) then
             in.nextToken()
             val tparams = typeParamClauseOpt(ParamOwner.Def)
             val extParams = paramClause(0, prefix = true)
             val givenParamss = paramClauses(givenOnly = true)
-            (tparams, extParams :: givenParamss)
+            (tparams, extParams :: givenParamss, Extension)
           else
-            (Nil, Nil)
+            (Nil, Nil, EmptyFlags)
         possibleTemplateStart()
         if !in.isNestedStart then syntaxError("Extension without extension methods")
         val templ = templateBodyOpt(makeConstructor(tparams, vparamss), Nil, Nil)
         templ.body.foreach(checkExtensionMethod(tparams, vparamss, _))
         val edef = ModuleDef(name, templ)
-        finalizeDef(edef, addFlag(mods, Given), start)
+        finalizeDef(edef, addFlag(mods, Given | extensionFlag), start)
       }
 
 /* -------- TEMPLATES ------------------------------------------- */

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

@@ -205,7 +205,7 @@ trait ImportSuggestions:
         .alternatives
         .map(mbr => TermRef(site, mbr.symbol))
         .filter(ref =>
-          ref.symbol.is(Extension)
+          ref.symbol.isAllOf(ExtensionMethod)
           && isApplicableMethodRef(ref, argType :: Nil, WildcardType))
         .headOption
 

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

@@ -1096,8 +1096,8 @@ class Namer { typer: Typer =>
                     (StableRealizable, ExprType(path.tpe.select(sym)))
                   else
                     (EmptyFlags, mbr.info.ensureMethodic)
-                val mbrFlags = Exported | Method | Final | maybeStable | sym.flags & RetainedExportFlags
-                val forwarderName = checkNoConflict(alias, isPrivate = false, span)
+                var mbrFlags = Exported | Method | Final | maybeStable | sym.flags & RetainedExportFlags
+                if sym.isAllOf(ExtensionMethod) then mbrFlags |= Extension
                 ctx.newSymbol(cls, forwarderName, mbrFlags, mbrInfo, coord = span)
               }
             forwarder.info = avoidPrivateLeaks(forwarder)

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

@@ -394,9 +394,9 @@ object RefChecks {
         overrideError("is erased, cannot override non-erased member")
       else if (other.is(Erased) && !member.isOneOf(Erased | Inline)) // (1.9.1)
         overrideError("is not erased, cannot override erased member")
-      else if (member.is(Extension) && !other.is(Extension)) // (1.9.2)
+      else if (member.isAllOf(ExtensionMethod) && !other.isAllOf(ExtensionMethod)) // (1.9.2)
         overrideError("is an extension method, cannot override a normal method")
-      else if (other.is(Extension) && !member.is(Extension)) // (1.9.2)
+      else if (other.isAllOf(ExtensionMethod) && !member.isAllOf(ExtensionMethod)) // (1.9.2)
         overrideError("is a normal method, cannot override an extension method")
       else if ((member.isInlineMethod || member.isScala2Macro) && other.is(Deferred) &&
                  member.extendedOverriddenSymbols.forall(_.is(Deferred))) // (1.10)