Merge pull request #12979 from dotty-staging/fix-12949

Author: dwijnand

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

@@ -783,7 +783,7 @@ object desugar {
  DefDef(
  className.toTermName, joinParams(constrTparams, defParamss),
  classTypeRef, creatorExpr)
- .withMods(companionMods | mods.flags.toTermFlags & GivenOrImplicit | Synthetic | Final)
+ .withMods(companionMods | mods.flags.toTermFlags & GivenOrImplicit | Final)
  .withSpan(cdef.span) :: Nil
  }
 
@@ -809,7 +809,7 @@ object desugar {
  Nil
  }
  }
- val classMods = if mods.is(Given) then mods &~ Given | Synthetic else mods
+ val classMods = if mods.is(Given) then mods | Synthetic else mods
  cpy.TypeDef(cdef: TypeDef)(
  name = className,
  rhs = cpy.Template(impl)(constr, parents1, clsDerived, self1,

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

@@ -63,7 +63,7 @@ class TreeMapWithImplicits extends tpd.TreeMap {
  private def nestedScopeCtx(defs: List[Tree])(using Context): Context = {
  val nestedCtx = ctx.fresh.setNewScope
  defs foreach {
- case d: DefTree if d.symbol.isOneOf(GivenOrImplicit) => nestedCtx.enter(d.symbol)
+ case d: DefTree if d.symbol.isOneOf(GivenOrImplicitVal) => nestedCtx.enter(d.symbol)
  case _ =>
  }
  nestedCtx
@@ -74,7 +74,7 @@ class TreeMapWithImplicits extends tpd.TreeMap {
  new TreeTraverser {
  def traverse(tree: Tree)(using Context): Unit = {
  tree match {
- case d: DefTree if d.symbol.isOneOf(GivenOrImplicit) =>
+ case d: DefTree if d.symbol.isOneOf(GivenOrImplicitVal) =>
  nestedCtx.enter(d.symbol)
  case _ =>
  }

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

@@ -13,7 +13,6 @@ import Scopes._
 import Uniques._
 import ast.Trees._
 import ast.untpd
-import Flags.GivenOrImplicit
 import util.{NoSource, SimpleIdentityMap, SourceFile, HashSet, ReusableInstance}
 import typer.{Implicits, ImportInfo, Inliner, SearchHistory, SearchRoot, TypeAssigner, Typer, Nullables}
 import Nullables._

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

@@ -233,7 +233,7 @@ object Flags {
  val (Param @ _, TermParam @ _, TypeParam @ _) = newFlags(8, "<param>")
 
  /** Labeled with `implicit` modifier (implicit value) */
- val (Implicit @ _, ImplicitTerm @ _, _) = newFlags(9, "implicit")
+ val (Implicit @ _, ImplicitVal @ _, _) = newFlags(9, "implicit")
 
  /** Labeled with `lazy` (a lazy val) / a trait */
  val (LazyOrTrait @ _, Lazy @ _, Trait @ _) = newFlags(10, "lazy", "<trait>")
@@ -321,7 +321,7 @@ object Flags {
  val (Extension @ _, ExtensionMethod @ _, _) = newFlags(28, "<extension>")
 
  /** An inferable (`given`) parameter */
- val (Given @ _, _, _) = newFlags(29, "given")
+ val (Given @ _, GivenVal @ _,  _) = newFlags(29, "given")
 
  /** Symbol is defined by a Java class */
  val (JavaDefined @ _, JavaDefinedVal @ _, _) = newFlags(30, "<java>")
@@ -568,6 +568,7 @@ object Flags {
  val FinalOrSealed: FlagSet = Final | Sealed
  val GivenOrImplicit: FlagSet = Given | Implicit
  val GivenOrImplicitVal: FlagSet = GivenOrImplicit.toTermFlags
+ val GivenMethod: FlagSet = Given | Method
  val InlineOrProxy: FlagSet = Inline | InlineProxy // An inline method or inline argument proxy */
  val InlineMethod: FlagSet = Inline | Method
  val InlineParam: FlagSet = Inline | Param
@@ -600,7 +601,6 @@ object Flags {
  val Scala2Trait: FlagSet = Scala2x | Trait
  val SyntheticArtifact: FlagSet = Synthetic | Artifact
  val SyntheticCase: FlagSet = Synthetic | Case
- val SyntheticGivenMethod: FlagSet = Synthetic | Given | Method
  val SyntheticModule: FlagSet = Synthetic | Module
  val SyntheticOpaque: FlagSet = Synthetic | Opaque
  val SyntheticParam: FlagSet = Synthetic | Param

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

@@ -411,7 +411,7 @@ object Scopes {
  var irefs = new mutable.ListBuffer[TermRef]
  var e = lastEntry
  while (e ne null) {
- if (e.sym.isOneOf(GivenOrImplicit)) {
+ if (e.sym.isOneOf(GivenOrImplicitVal)) {
  val d = e.sym.denot
  irefs += TermRef(NoPrefix, d.symbol.asTerm).withDenot(d)
  }

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

@@ -711,6 +711,19 @@ object SymDenotations {
  }
  )
 
+ /** Do this symbol and `cls` represent a pair of a given or implicit method and
+ * its associated class that were defined by a single definition?
+ * This can mean one of two things:
+ * - the method and class are defined in a structural given instance, or
+ * - the class is an implicit class and the method is its implicit conversion.
+ */
+ final def isCoDefinedGiven(cls: Symbol)(using Context): Boolean =
+ is(Method) && isOneOf(GivenOrImplicit)
+ && ( is(Synthetic) // previous scheme used in 3.0
+ || cls.isOneOf(GivenOrImplicit) // new scheme from 3.1
+ )
+ && name == cls.name.toTermName && owner == cls.owner
+
  /** Is this a denotation of a stable term (or an arbitrary type)?
  * Terms are stable if they are idempotent (as in TreeInfo.Idempotent): that is, they always return the same value,
  * if any.
@@ -2231,7 +2244,7 @@ object SymDenotations {
  if (keepOnly eq implicitFilter)
  if (this.is(Package)) Iterator.empty
  // implicits in package objects are added by the overriding `memberNames` in `PackageClassDenotation`
- else info.decls.iterator.filter(_.isOneOf(GivenOrImplicit))
+ else info.decls.iterator.filter(_.isOneOf(GivenOrImplicitVal))
  else info.decls.iterator
  for (sym <- ownSyms) maybeAdd(sym.name)
  names

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

@@ -141,7 +141,7 @@ class CyclicReference private (val denot: SymDenotation) extends TypeError {
  }
 
  // Give up and give generic errors.
- else if (cycleSym.isOneOf(GivenOrImplicit, butNot = Method) && cycleSym.owner.isTerm)
+ else if (cycleSym.isOneOf(GivenOrImplicitVal, butNot = Method) && cycleSym.owner.isTerm)
  CyclicReferenceInvolvingImplicit(cycleSym)
  else
  CyclicReferenceInvolving(denot)

compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala

@@ -722,9 +722,9 @@ class TreePickler(pickler: TastyPickler) {
  if flags.is(Invisible) then writeModTag(INVISIBLE)
  if (flags.is(Erased)) writeModTag(ERASED)
  if (flags.is(Exported)) writeModTag(EXPORTED)
+ if (flags.is(Given)) writeModTag(GIVEN)
+ if (flags.is(Implicit)) writeModTag(IMPLICIT)
  if (isTerm) {
- if (flags.is(Implicit)) writeModTag(IMPLICIT)
- if (flags.is(Given)) writeModTag(GIVEN)
  if (flags.is(Lazy, butNot = Module)) writeModTag(LAZY)
  if (flags.is(AbsOverride)) { writeModTag(ABSTRACT); writeModTag(OVERRIDE) }
  if (flags.is(Mutable)) writeModTag(MUTABLE)

compiler/src/dotty/tools/dotc/interactive/Completion.scala

@@ -323,7 +323,7 @@ object Completion {
  val extMethodsFromImplicitScope = extractMemberExtensionMethods(implicitScopeCompanions)
 
  // 4. The reference is of the form r.m and the extension method is defined in some given instance in the implicit scope of the type of r.
- val givensInImplicitScope = implicitScopeCompanions.flatMap(_.membersBasedOnFlags(required = Given, excluded = EmptyFlags)).map(_.info)
+ val givensInImplicitScope = implicitScopeCompanions.flatMap(_.membersBasedOnFlags(required = GivenVal, excluded = EmptyFlags)).map(_.info)
  val extMethodsFromGivensInImplicitScope = extractMemberExtensionMethods(givensInImplicitScope)
 
  val availableExtMethods = extMethodsFromGivensInImplicitScope ++ extMethodsFromImplicitScope ++ extMethodsFromGivensInScope ++ extMethodsInScope

compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala

@@ -79,6 +79,8 @@ class ExtractSemanticDB extends Phase:
  || sym.isLocalDummy
  || sym.is(Synthetic)
  || sym.isSetter
+ || sym.isOldStyleImplicitConversion(forImplicitClassOnly = true)
+ || sym.owner.isGivenInstanceSummoner
  || excludeDefOrUse(sym)
 
  private def excludeDefOrUse(sym: Symbol)(using Context): Boolean =
@@ -102,6 +104,7 @@ class ExtractSemanticDB extends Phase:
  private def excludeChildren(sym: Symbol)(using Context): Boolean =
  !sym.exists
  || sym.is(Param) && sym.info.bounds.hi.isInstanceOf[Types.HKTypeLambda]
+ || sym.isOldStyleImplicitConversion(forImplicitClassOnly = true)
 
  /** Uses of this symbol where the reference has given span should be excluded from semanticdb */
  private def excludeUse(qualifier: Option[Symbol], sym: Symbol)(using Context): Boolean =