Merge pull request #245 from OlegYch/scala3-fixes

Fix getting deps from inherited members on scala3

Author: adamw

.gitignore

@@ -3,3 +3,5 @@
 *.ipr
 target
 out
+.sbt
+.bsp

macros/src/main/scala-3/com/softwaremill/macwire/internals/EligibleValuesFinder.scala

@@ -16,74 +16,32 @@ private[macwire] class EligibleValuesFinder[Q <: Quotes](log: Logger)(using val
     val wiredOwner = wiredDef.owner
 
     def doFind(symbol: Symbol, scope: Scope): EligibleValues = {
-      def hasModuleAnnotation(symbol: Symbol): Boolean =
-        symbol.annotations.map(_.tpe.show).exists(_ == "com.softwaremill.macwire.Module")
-
-      def inspectModule(scope: Scope, tpe: TypeRepr, expr: Tree): Option[EligibleValues] = {
-        // it might be a @Module, let's see
-        val hasSymbol = expr.symbol != null // sometimes expr has no symbol...
-        val valIsModule = hasSymbol && hasModuleAnnotation(expr.symbol)
-        // the java @Inherited meta-annotation does not seem to be understood by scala-reflect...
-        val valParentIsModule = hasSymbol && !valIsModule && tpe.baseClasses.exists(hasModuleAnnotation)
-
-        if (valIsModule || valParentIsModule) {
-          log.withBlock(s"Inspecting module $tpe") {
-            val r = expr.symbol.declarations.map(_.tree).map {
-              case m: ValDef =>
-                EligibleValue(
-                  m.tpt.tpe,
-                  This(expr.symbol.owner).select(expr.symbol).select(m.symbol)
-                )
-              case m: DefDef if m.termParamss.flatMap(_.params).isEmpty =>
-                EligibleValue(m.rhs.map(_.tpe).getOrElse(m.returnTpt.tpe), Select.unique(Ref(expr.symbol), m.name))
-            }
-            
-            Some(EligibleValues(Map(scope.widen -> r)))
-          }
-        } else {
-          None
-        }
-      }
-
-      def buildEligibleValue(scope: Scope): PartialFunction[Tree, EligibleValues] = {
-        case m: ValDef =>
-          merge(
-            inspectModule(scope.widen, m.rhs.map(_.tpe).getOrElse(m.tpt.tpe), m).getOrElse(EligibleValues.empty),
-            EligibleValues(Map(scope -> List(EligibleValue(m.rhs.map(_.tpe).getOrElse(m.tpt.tpe), m))))
-          )
-
-        case m: DefDef if m.termParamss.flatMap(_.params).isEmpty =>
-          merge(
-            inspectModule(scope.widen, m.rhs.map(_.tpe).getOrElse(m.returnTpt.tpe), m).getOrElse(EligibleValues.empty),
-            EligibleValues(Map(scope -> List(EligibleValue(m.rhs.map(_.tpe).getOrElse(m.returnTpt.tpe), m))))
-          )
-
-      }
-
       def handleClassDef(scope: Scope, s: Symbol): EligibleValues = {
-        (s.declaredMethods ::: s.declaredFields)
-          .filter(m => !m.fullName.startsWith("java.lang.Object") && !m.fullName.startsWith("scala.Any"))
-          .map(_.tree)
-          .foldLeft(EligibleValues.empty)((values, tree) =>
-            merge(values, buildEligibleValue(scope).applyOrElse(tree, _ => EligibleValues.empty))
-          )
-
+        val declared = EligibleValues.build(
+          symbol,
+          scope,
+          s.declarations.filter(nonSyntethic).map(_.tree)
+        )
+        val inherited = EligibleValues.build(
+          symbol,
+          scope.widen,
+          (s.memberFields ::: s.memberMethods)
+            .filter(m => nonSyntethic(m) && isPublic(m) && !s.declarations.contains(m))
+            .map(_.tree)
+        )
+        EligibleValues.merge(declared, inherited)
       }
 
       def handleDefDef(scope: Scope, s: Symbol): EligibleValues =
         s.tree match {
           case DefDef(_, _, _, Some(Match(_, cases))) =>
             report.throwError(s"Wire for deconstructed case is not supported yet") //TODO
           case DefDef(s, lpc, tt, ot) =>
-            lpc
-              .flatMap(_.params)
-              .foldLeft(EligibleValues.empty)((values, tree) =>
-                merge(values, buildEligibleValue(scope).applyOrElse(tree, _ => EligibleValues.empty))
-              )
+            EligibleValues.build(symbol, scope, lpc.flatMap(_.params))
         }
 
       if symbol.isNoSymbol then EligibleValues.empty
-      else if symbol.isDefDef then merge(handleDefDef(scope, symbol), doFind(symbol.maybeOwner, scope))
+      else if symbol.isDefDef then EligibleValues.merge(handleDefDef(scope, symbol), doFind(symbol.maybeOwner, scope))
       else if symbol.isClassDef && !symbol.isPackageDef then handleClassDef(scope.widen, symbol)
       else if symbol == defn.RootPackage then EligibleValues.empty
       else if symbol == defn.RootClass then EligibleValues.empty
@@ -93,17 +51,19 @@ private[macwire] class EligibleValuesFinder[Q <: Quotes](log: Logger)(using val
     doFind(Symbol.spliceOwner, Scope.init)
   }
 
-  private def merge(
-      ev1: EligibleValues,
-      ev2: EligibleValues
-  ): EligibleValues =
-    EligibleValues(merge(ev1.values, ev2.values))
+  private def nonSyntethic(member: Symbol): Boolean = {
+    !member.fullName.startsWith("java.lang.Object") &&
+    !member.fullName.startsWith("scala.Any") &&
+    !member.fullName.startsWith("scala.AnyRef") &&
+    !member.fullName.endsWith("<init>") &&
+    !member.fullName.endsWith("$init$") &&
+    !member.fullName.contains("$default$") && //default params for copy on case classes
+    !member.fullName.matches(".*_\\d+") //tuple methods on case classes
+  }
 
-  private def merge(
-      m1: Map[Scope, List[EligibleValue]],
-      m2: Map[Scope, List[EligibleValue]]
-  ): Map[Scope, List[EligibleValue]] =
-    (m1.toSeq ++ m2.toSeq).groupBy(_._1).view.mapValues(_.flatMap(_._2).toList).toMap
+  private def isPublic(member: Symbol): Boolean = {
+    !((member.flags is Flags.Private) || (member.flags is Flags.Protected))
+  }
 
   case class EligibleValue(tpe: TypeRepr, expr: Tree) {
     // equal trees should have equal hash codes; if trees are equal structurally they should have the same toString?
@@ -165,8 +125,79 @@ private[macwire] class EligibleValuesFinder[Q <: Quotes](log: Logger)(using val
 
   object EligibleValues {
     val empty: EligibleValues = new EligibleValues(Map.empty)
-  }
 
+    private def inspectModule(scope: Scope, tpe: TypeRepr, expr: Tree) = {
+      def hasModuleAnnotation(symbol: Symbol): Boolean =
+        symbol.annotations.map(_.tpe.show).exists(_ == "com.softwaremill.macwire.Module")
+
+      // it might be a @Module, let's see
+      val hasSymbol = expr.symbol != null // sometimes expr has no symbol...
+      val valIsModule = hasSymbol && hasModuleAnnotation(expr.symbol)
+      // the java @Inherited meta-annotation does not seem to be understood by scala-reflect...
+      val valParentIsModule = hasSymbol && !valIsModule && tpe.baseClasses.exists(hasModuleAnnotation)
+
+      if (valIsModule || valParentIsModule) {
+        log.withBlock(s"Inspecting module $tpe") {
+          val r = (expr.symbol.memberFields ::: expr.symbol.memberMethods)
+            .filter(m => nonSyntethic(m) && isPublic(m))
+            .map(_.tree)
+            .collect {
+              case m: ValDef =>
+                EligibleValue(
+                  m.tpt.tpe,
+                  This(expr.symbol.owner).select(expr.symbol).select(m.symbol)
+                )
+              case m: DefDef if m.termParamss.flatMap(_.params).isEmpty =>
+                EligibleValue(
+                  m.rhs.map(_.tpe).getOrElse(m.returnTpt.tpe),
+                  This(expr.symbol.owner).select(expr.symbol).select(m.symbol)
+                )
+            }
+          EligibleValues(Map(scope.widen -> r))
+        }
+      } else {
+        EligibleValues.empty
+      }
+    }
+
+    private def buildEligibleValue(symbol: Symbol, scope: Scope): PartialFunction[Tree, EligibleValues] = {
+      case m: ValDef =>
+        merge(
+          inspectModule(scope.widen, m.rhs.map(_.tpe).getOrElse(m.tpt.tpe), m),
+          EligibleValues(
+            Map(
+              scope -> List(
+                EligibleValue(
+                  m.rhs.map(_.tpe).getOrElse(m.tpt.tpe),
+                  if symbol.isClassDef then This(symbol).select(m.symbol) else m
+                )
+              )
+            )
+          )
+        )
+      case m: DefDef if m.termParamss.flatMap(_.params).isEmpty =>
+        merge(
+          inspectModule(scope.widen, m.rhs.map(_.tpe).getOrElse(m.returnTpt.tpe), m),
+          EligibleValues(
+            Map(
+              scope -> List(
+                EligibleValue(
+                  m.rhs.map(_.tpe).getOrElse(m.returnTpt.tpe),
+                  if symbol.isClassDef then This(symbol).select(m.symbol) else m
+                )
+              )
+            )
+          )
+        )
+    }
+
+    def build(symbol: Symbol, scope: Scope, l: Iterable[Tree]) = l.foldLeft(empty)((values, tree) =>
+      merge(values, buildEligibleValue(symbol, scope).applyOrElse(tree, _ => EligibleValues.empty))
+    )
+
+    def merge(ev1: EligibleValues, ev2: EligibleValues): EligibleValues =
+      EligibleValues((ev1.values.toSeq ++ ev2.values.toSeq).groupBy(_._1).view.mapValues(_.flatMap(_._2).toList).toMap)
+  }
 }
 
 object EligibleValuesFinder {

tests/src/test/resources/test-cases/diamondInheritance.scala2.success renamed to tests/src/test/resources/test-cases/diamondInheritance.success

@@ -0,0 +1,13 @@
+#include commonSimpleClasses
+
+trait Base {
+  protected lazy val protectedA: A = A()
+  lazy val publicA: A = A()
+}
+
+object Module extends Base {
+  lazy val b: B = wire[B]
+  lazy val c: C = wire[C]
+}
+
+require(Module.c.a eq Module.publicA)

tests/src/test/resources/test-cases/explicitDepsWiredWithImplicitValsFromParentsScope.scala2.success renamed to tests/src/test/resources/test-cases/explicitDepsWiredWithImplicitValsFromParentsScope.success

@@ -0,0 +1,13 @@
+#include commonSimpleClasses
+
+trait Base {
+  val aA: A = A()
+}
+
+object Module extends Base {
+  val theA: A = A()
+  lazy val b: B = wire[B]
+  lazy val c: C = wire[C]
+}
+
+require(Module.c.a eq Module.theA)

tests/src/test/resources/test-cases/inheritanceAbstractAndConcrete.scala2.success renamed to tests/src/test/resources/test-cases/inheritanceAbstractAndConcrete.success

@@ -0,0 +1,16 @@
+#include commonSimpleClasses
+
+@Module
+class AModule {
+    lazy val a = wire[A]
+}
+case class X(aModule: AModule) {
+    lazy val b = wire[B]
+    lazy val c = wire[C]
+}
+object CaseTest {
+    lazy val aModule = wire[AModule]
+    lazy val X = wire[X]
+}
+
+require(CaseTest.X.c.a eq CaseTest.aModule.a)

tests/src/test/resources/test-cases/inheritanceClassesWithTraitsLazyValsOkInTraits.scala2.success renamed to tests/src/test/resources/test-cases/inheritanceClassesWithTraitsLazyValsOkInTraits.success

@@ -0,0 +1,19 @@
+#include commonSimpleClasses
+
+class Parent {
+    protected def bb = wire[B]
+    lazy val b = wire[B]
+}
+@Module
+class AModule extends Parent {
+    protected def x(i:Int) = wire[B]
+    protected def d: D = ???
+    protected lazy val dd: D = ???
+    lazy val a = wire[A]
+}
+object ParentTest {
+    lazy val aModule = wire[AModule]
+    lazy val c = wire[C]
+}
+
+require(ParentTest.c.a eq ParentTest.aModule.a)