Merge branch 'scala:main' into get-tree-rhs

lidaisy · web-flow · commit 88e83f91aaf7 · 2025-02-18T15:13:10.000-05:00
diff --git a/compiler/src/dotty/tools/dotc/interactive/Completion.scala b/compiler/src/dotty/tools/dotc/interactive/Completion.scala
@@ -663,7 +663,7 @@ object Completion:
      */
     private def implicitConversionTargets(qual: tpd.Tree)(using Context): Set[SearchSuccess] = {
       val typer = ctx.typer
-      val conversions = new typer.ImplicitSearch(defn.AnyType, qual, pos.span).allImplicits
+      val conversions = new typer.ImplicitSearch(defn.AnyType, qual, pos.span, Set.empty).allImplicits
 
       interactiv.println(i"implicit conversion targets considered: ${conversions.toList}%, %")
       conversions
diff --git a/compiler/src/dotty/tools/dotc/transform/Dependencies.scala b/compiler/src/dotty/tools/dotc/transform/Dependencies.scala
@@ -137,6 +137,7 @@ abstract class Dependencies(root: ast.tpd.Tree, @constructorOnly rootContext: Co
       if !enclosure.exists then throw NoPath()
       if enclosure == sym.enclosure then NoSymbol
       else
+        /** is sym a constructor or a term that is nested in a constructor? */
         def nestedInConstructor(sym: Symbol): Boolean =
           sym.isConstructor
           || sym.isTerm && nestedInConstructor(sym.enclosure)
@@ -237,6 +238,10 @@ abstract class Dependencies(root: ast.tpd.Tree, @constructorOnly rootContext: Co
         captureImplicitThis(tree.tpe)
       case tree: Select =>
         if isExpr(sym) && isLocal(sym) then markCalled(sym, enclosure)
+      case tree: New =>
+        val constr = tree.tpe.typeSymbol.primaryConstructor
+        if constr.exists then
+          symSet(called, enclosure) += constr
       case tree: This =>
         narrowTo(tree.symbol.asClass)
       case tree: MemberDef if isExpr(sym) && sym.owner.isTerm =>
@@ -291,7 +296,6 @@ abstract class Dependencies(root: ast.tpd.Tree, @constructorOnly rootContext: Co
         val calleeOwner = normalizedCallee.owner
         if calleeOwner.isTerm then narrowLogicOwner(caller, logicOwner(normalizedCallee))
         else
-          assert(calleeOwner.is(Trait))
           // methods nested inside local trait methods cannot be lifted out
           // beyond the trait. Note that we can also call a trait method through
           // a qualifier; in that case no restriction to lifted owner arises.
diff --git a/compiler/src/dotty/tools/dotc/transform/LambdaLift.scala b/compiler/src/dotty/tools/dotc/transform/LambdaLift.scala
@@ -129,9 +129,7 @@ object LambdaLift:
 
     private def proxy(sym: Symbol)(using Context): Symbol = {
       def liftedEnclosure(sym: Symbol) =
-        if sym.is(Method)
-        then deps.logicalOwner.getOrElse(sym, sym.enclosure)
-        else sym.enclosure
+        deps.logicalOwner.getOrElse(sym, sym.enclosure)
       def searchIn(enclosure: Symbol): Symbol = {
         if (!enclosure.exists) {
           def enclosures(encl: Symbol): List[Symbol] =
diff --git a/compiler/src/dotty/tools/dotc/typer/Implicits.scala b/compiler/src/dotty/tools/dotc/typer/Implicits.scala
@@ -928,8 +928,8 @@ trait Implicits:
   /** Find an implicit argument for parameter `formal`.
    *  Return a failure as a SearchFailureType in the type of the returned tree.
    */
-  def inferImplicitArg(formal: Type, span: Span)(using Context): Tree =
-    inferImplicit(formal, EmptyTree, span) match
+  def inferImplicitArg(formal: Type, span: Span, ignored: Set[Symbol] = Set.empty)(using Context): Tree =
+    inferImplicit(formal, EmptyTree, span, ignored) match
       case SearchSuccess(arg, _, _, _) => arg
       case fail @ SearchFailure(failed) =>
         if fail.isAmbiguous then failed
@@ -1082,7 +1082,7 @@ trait Implicits:
    *                         it should be applied, EmptyTree otherwise.
    *  @param span            The position where errors should be reported.
    */
-  def inferImplicit(pt: Type, argument: Tree, span: Span)(using Context): SearchResult = ctx.profiler.onImplicitSearch(pt):
+  def inferImplicit(pt: Type, argument: Tree, span: Span, ignored: Set[Symbol] = Set.empty)(using Context): SearchResult = ctx.profiler.onImplicitSearch(pt):
     trace(s"search implicit ${pt.show}, arg = ${argument.show}: ${argument.tpe.show}", implicits, show = true) {
       record("inferImplicit")
       assert(ctx.phase.allowsImplicitSearch,
@@ -1110,7 +1110,7 @@ trait Implicits:
           else i"conversion from ${argument.tpe} to $pt"
 
         CyclicReference.trace(i"searching for an implicit $searchStr"):
-          try ImplicitSearch(pt, argument, span)(using searchCtx).bestImplicit
+          try ImplicitSearch(pt, argument, span, ignored)(using searchCtx).bestImplicit
           catch case ce: CyclicReference =>
             ce.inImplicitSearch = true
             throw ce
@@ -1130,9 +1130,9 @@ trait Implicits:
             result
           case result: SearchFailure if result.isAmbiguous =>
             val deepPt = pt.deepenProto
-            if (deepPt ne pt) inferImplicit(deepPt, argument, span)
+            if (deepPt ne pt) inferImplicit(deepPt, argument, span, ignored)
             else if (migrateTo3 && !ctx.mode.is(Mode.OldImplicitResolution))
-              withMode(Mode.OldImplicitResolution)(inferImplicit(pt, argument, span)) match {
+              withMode(Mode.OldImplicitResolution)(inferImplicit(pt, argument, span, ignored)) match {
                 case altResult: SearchSuccess =>
                   report.migrationWarning(
                     result.reason.msg
@@ -1243,7 +1243,7 @@ trait Implicits:
     }
 
   /** An implicit search; parameters as in `inferImplicit` */
-  class ImplicitSearch(protected val pt: Type, protected val argument: Tree, span: Span)(using Context):
+  class ImplicitSearch(protected val pt: Type, protected val argument: Tree, span: Span, ignored: Set[Symbol])(using Context):
     assert(argument.isEmpty || argument.tpe.isValueType || argument.tpe.isInstanceOf[ExprType],
         em"found: $argument: ${argument.tpe}, expected: $pt")
 
@@ -1670,14 +1670,17 @@ trait Implicits:
         SearchFailure(TooUnspecific(pt), span)
       else
         val contextual = ctxImplicits != null
-        val preEligible = // the eligible candidates, ignoring positions
+        var preEligible = // the eligible candidates, ignoring positions
           if ctxImplicits != null then
             if ctx.gadt.isNarrowing then
               withoutMode(Mode.ImplicitsEnabled) {
                 ctxImplicits.uncachedEligible(wildProto)
               }
             else ctxImplicits.eligible(wildProto)
           else implicitScope(wildProto).eligible
+        if !ignored.isEmpty then
+          preEligible =
+            preEligible.filter(candidate => !ignored.contains(candidate.implicitRef.underlyingRef.symbol))
 
         /** Does candidate `cand` come too late for it to be considered as an
          *  eligible candidate? This is the case if `cand` appears in the same
diff --git a/compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala b/compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala
@@ -2544,6 +2544,14 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
         // See tests/pos-macros/exprSummonWithTypeVar with -Xcheck-macros.
         dotc.typer.Inferencing.fullyDefinedType(implicitTree.tpe, "", implicitTree)
         implicitTree
+      def searchIgnoring(tpe: TypeRepr)(ignored: Symbol*): ImplicitSearchResult =
+        import tpd.TreeOps
+        val implicitTree = ctx.typer.inferImplicitArg(tpe, Position.ofMacroExpansion.span, ignored.toSet)
+        // Make sure that we do not have any uninstantiated type variables.
+        // See tests/pos-macros/i16636.
+        // See tests/pos-macros/exprSummonWithTypeVar with -Xcheck-macros.
+        dotc.typer.Inferencing.fullyDefinedType(implicitTree.tpe, "", implicitTree)
+        implicitTree
     end Implicits
 
     type ImplicitSearchResult = Tree
diff --git a/docs/_docs/reference/dropped-features/this-qualifier.md b/docs/_docs/reference/dropped-features/this-qualifier.md
@@ -29,3 +29,15 @@ This can cause problems if a program tries to access the missing private field v
       // [C] needed if `field` is to be accessed through reflection
     val retained = field * field
 ```
+
+Class parameters are normally inferred object-private,
+so that members introduced by explicitly declaring them `val` or `var` are exempt from the rule described here.
+
+In particular, the following field is not excluded from variance checking:
+```scala
+  class C[-T](private val t: T) // error
+```
+And in contrast to the private field shown above, this field is not eliminated:
+```scala
+  class C(private val c: Int)
+```
diff --git a/library/src/scala/quoted/Expr.scala b/library/src/scala/quoted/Expr.scala
@@ -280,4 +280,23 @@ object Expr {
     }
   }
 
+  /** Find a given instance of type `T` in the current scope,
+   *  while excluding certain symbols from the initial implicit search.
+   *  Return `Some` containing the expression of the implicit or
+   * `None` if implicit resolution failed.
+   *
+   *  @tparam T type of the implicit parameter
+   *  @param ignored Symbols ignored during the initial implicit search
+   *
+   *  @note if the found given requires additional search for other given instances,
+   *  this additional search will NOT exclude the symbols from the `ignored` list.
+   */
+  def summonIgnoring[T](using Type[T])(using quotes: Quotes)(ignored: quotes.reflect.Symbol*): Option[Expr[T]] = {
+    import quotes.reflect._
+    Implicits.searchIgnoring(TypeRepr.of[T])(ignored*) match {
+      case iss: ImplicitSearchSuccess => Some(iss.tree.asExpr.asInstanceOf[Expr[T]])
+      case isf: ImplicitSearchFailure => None
+    }
+  }
+
 }
diff --git a/library/src/scala/quoted/Quotes.scala b/library/src/scala/quoted/Quotes.scala
@@ -3708,6 +3708,18 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
       *  @param tpe type of the implicit parameter
       */
       def search(tpe: TypeRepr): ImplicitSearchResult
+
+      /** Find a given instance of type `T` in the current scope provided by the current enclosing splice,
+      *  while excluding certain symbols from the initial implicit search.
+      *  Return an `ImplicitSearchResult`.
+      *
+      *  @param tpe type of the implicit parameter
+      *  @param ignored Symbols ignored during the initial implicit search
+      *
+      *  @note if an found given requires additional search for other given instances,
+      *  this additional search will NOT exclude the symbols from the `ignored` list.
+      */
+      def searchIgnoring(tpe: TypeRepr)(ignored: Symbol*): ImplicitSearchResult
     }
 
     /** Result of a given instance search */
diff --git a/project/MiMaFilters.scala b/project/MiMaFilters.scala
@@ -95,6 +95,7 @@ object MiMaFilters {
           ProblemFilters.exclude[ReversedMissingMethodProblem]("scala.quoted.Quotes#reflectModule#MethodTypeModule.apply"),
           ProblemFilters.exclude[ReversedMissingMethodProblem]("scala.quoted.Quotes#reflectModule#MethodTypeMethods.methodTypeKind"),
           ProblemFilters.exclude[ReversedMissingMethodProblem]("scala.quoted.Quotes#reflectModule#MethodTypeMethods.isContextual"),
+          ProblemFilters.exclude[ReversedMissingMethodProblem]("scala.quoted.Quotes#reflectModule#ImplicitsModule.searchIgnoring"),
           // Change `experimental` annotation to a final class
           ProblemFilters.exclude[FinalClassProblem]("scala.annotation.experimental"),
         ),
diff --git a/tests/neg/i22620.scala b/tests/neg/i22620.scala
@@ -0,0 +1,4 @@
+
+import scala.collection.mutable.ArrayBuffer
+
+class PrivateTest[-M](private val v: ArrayBuffer[M]) // error
diff --git a/tests/pos/i21931.scala b/tests/pos/i21931.scala
@@ -1,13 +1,18 @@
-def f() =
-  val NotFound: Char = 'a'
-  class crashing() {
-    class issue() {
-      NotFound
-    }
-    class Module() {
-      val obligatory =
-        class anonIssue() {
-          issue()
+object Test {
+  def f() = {
+    val NotFound: Char = 'a'
+    class crashing() {
+      class issue() {
+        NotFound
+      }
+      class Module() {
+        val obligatory = {
+          def anonIssue = {
+            issue()
+          }
+          anonIssue
         }
+      }
     }
   }
+}
diff --git a/tests/pos/i22470.scala b/tests/pos/i22470.scala
@@ -0,0 +1,17 @@
+trait A
+trait OuterClass
+trait MidClass
+trait InnerClass
+
+object Obj:
+  def outerDef(a: A) =
+    new OuterClass {
+      def midDef(): Unit = {
+        new MidClass {
+          val valdef = new InnerClass {
+            def innerDef() =
+              println(a)
+          }
+        }
+      }
+    }
diff --git a/tests/run-macros/summonIgnoring-nonrecursive.check b/tests/run-macros/summonIgnoring-nonrecursive.check
@@ -0,0 +1,3 @@
+TC[C2] generated in macro using:
+TC2[_] generated in macro using:
+TC[C1] generated in macro
diff --git a/tests/run-macros/summonIgnoring-nonrecursive/Macro_1.scala b/tests/run-macros/summonIgnoring-nonrecursive/Macro_1.scala
@@ -0,0 +1,50 @@
+//> using options -experimental
+import scala.quoted._
+class C1
+trait TC[T] {
+  def print(): Unit
+}
+
+object TC {
+  implicit transparent inline def auto[T]: TC[T] = ${autoImpl[T]}
+  def autoImpl[T: Type](using Quotes): Expr[TC[T]] =
+    import quotes.reflect._
+    if (TypeRepr.of[T].typeSymbol == Symbol.classSymbol("C1")){
+      '{
+        new TC[T] {
+          def print() = {
+            println("TC[C1] generated in macro")
+          }
+        }
+      }
+    } else {
+      Expr.summonIgnoring[TC2[C1]](Symbol.classSymbol("TC").companionModule.methodMember("auto")*) match
+        case Some(a) =>
+          '{
+            new TC[T] {
+              def print(): Unit =
+                println(s"TC[${${Expr(TypeRepr.of[T].show)}}] generated in macro using:")
+                $a.print()
+            }
+          }
+        case None =>
+          '{
+            new TC[T]{
+              def print(): Unit =
+                println(s"TC[${${Expr(TypeRepr.of[T].show)}}] generated in macro without TC2[_]")
+            }
+          }
+    }
+}
+
+trait TC2[T] {
+  def print(): Unit
+}
+
+object TC2 {
+  implicit def auto2[T](using tc: TC[T]): TC2[T] = new TC2[T] {
+    def print(): Unit =
+      println(s"TC2[_] generated in macro using:")
+      tc.print()
+  }
+}
diff --git a/tests/run-macros/summonIgnoring-nonrecursive/Test_2.scala b/tests/run-macros/summonIgnoring-nonrecursive/Test_2.scala
@@ -0,0 +1,6 @@
+//> using options -experimental
+
+@main def Test(): Unit = {
+  class C2
+  summon[TC[C2]].print()
+}
diff --git a/tests/run-macros/summonIgnoring.check b/tests/run-macros/summonIgnoring.check
@@ -0,0 +1,5 @@
+No given in scope:
+TC[C2] generated in macro without TC[C1]
+Given in scope:
+TC[C2] generated in macro using:
+TC[C1] defined by a user
diff --git a/tests/run-macros/summonIgnoring/Macro_1.scala b/tests/run-macros/summonIgnoring/Macro_1.scala
@@ -0,0 +1,38 @@
+//> using options -experimental
+import scala.quoted._
+class C1
+trait TC[T] {
+  def print(): Unit
+}
+object TC {
+  implicit transparent inline def auto[T]: TC[T] = ${autoImpl[T]}
+  def autoImpl[T: Type](using Quotes): Expr[TC[T]] =
+    import quotes.reflect._
+    if(TypeRepr.of[T].typeSymbol == Symbol.classSymbol("C1")){
+      '{
+        new TC[T] {
+          def print() = {
+            println("TC[C1] generated in macro")
+          }
+        }
+      }
+    } else {
+      Expr.summonIgnoring[TC[C1]](Symbol.classSymbol("TC").companionModule.methodMember("auto")*) match
+        case Some(a) =>
+          '{
+            new TC[T] {
+              def print(): Unit =
+                println(s"TC[${${Expr(TypeRepr.of[T].show)}}] generated in macro using:")
+                $a.print()
+            }
+          }
+        case None =>
+          '{
+            new TC[T]{
+              def print(): Unit =
+                println(s"TC[${${Expr(TypeRepr.of[T].show)}}] generated in macro without TC[C1]")
+            }
+          }
+    }
+
+}
diff --git a/tests/run-macros/summonIgnoring/Test_2.scala b/tests/run-macros/summonIgnoring/Test_2.scala
@@ -0,0 +1,15 @@
+//> using options -experimental
+
+@main def Test(): Unit = {
+  class C2
+  println("No given in scope:")
+  summon[TC[C2]].print()
+
+  {
+    println("Given in scope:")
+    given TC[C1] = new TC[C1] {
+      def print() = println("TC[C1] defined by a user")
+    }
+    summon[TC[C2]].print()
+  }
+}

-Original file line number
+Diff line change
@@ @@ -0,0 +1,4 @@ @@
++
 +import scala.collection.mutable.ArrayBuffer
++
 +class PrivateTest[-M](private val v: ArrayBuffer[M]) // error