fixed tests

Author: rssh

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

@@ -2049,6 +2049,7 @@ class QuoteContextImpl private (ctx: Context) extends QuoteContext:
     object TypeBounds extends TypeBoundsModule:
       def apply(low: Type, hi: Type): TypeBounds = Types.TypeBounds(low, hi)
       def unapply(x: TypeBounds): Option[(Type, Type)] = Some((x.low, x.hi))
+      def minmax = TypeBounds(defn.NothingClass.tree.tpe, defn.AnyClass.tree.tpe)
     end TypeBounds
 
     object TypeBoundsMethodsImpl extends TypeBoundsMethods:

library/src/scala/tasty/Reflection.scala

@@ -2297,6 +2297,7 @@ trait Reflection { reflection =>
   trait TypeBoundsModule { this: TypeBounds.type =>
     def apply(low: Type, hi: Type): TypeBounds
     def unapply(x: TypeBounds): Option[(Type, Type)]
+    def minmax: TypeBounds
   }
 
   given TypeBoundsMethods as TypeBoundsMethods = TypeBoundsMethodsImpl

tests/neg-staging/i5941/macro_1.scala

@@ -17,7 +17,7 @@ object Lens {
     import util._
     // obj.copy(field = value)
     def setterBody(obj: Expr[S], value: Expr[T], field: String): Expr[S] =
-      Select.overloaded(obj.unseal, "copy", Nil, NamedArg(field, value.unseal) :: Nil).seal.cast[S]
+      Select.overloaded(obj.unseal, "copy", Nil, NamedArg(field, value.unseal) :: Nil, TypeBounds.minmax).seal.cast[S]
 
     // exception: getter.unseal.underlyingArgument
     getter.unseal match {
@@ -51,4 +51,4 @@ object GenLens {
   class MkGenLens[S] {
     inline def apply[T](get: => (S => T)): Lens[S, T] = ${ Lens.impl('get) }
   }
-}
+}

tests/pos-macros/i6535/Macro_1.scala

@@ -12,7 +12,7 @@ object scalatest {
       case t @ Apply(Select(lhs, op), rhs :: Nil) =>
         let(lhs) { left =>
           let(rhs) { right =>
-            val app = Select.overloaded(left, op, Nil, right :: Nil)
+            val app = Select.overloaded(left, op, Nil, right :: Nil, TypeBounds.minmax)
             let(app) { result =>
               val l = left.seal
               val r = right.seal

tests/run-macros/i5941/macro_1.scala

@@ -19,7 +19,7 @@ object Lens {
     def setterBody(obj: Term, value: Term, parts: List[String]): Term = {
       // o.copy(field = value)
       def helper(obj: Term, value: Term, field: String): Term =
-        Select.overloaded(obj, "copy", Nil, NamedArg(field, value) :: Nil)
+        Select.overloaded(obj, "copy", Nil, NamedArg(field, value) :: Nil, TypeBounds.minmax)
 
       parts match {
         case field :: Nil => helper(obj, value, field)
@@ -118,7 +118,7 @@ object Iso {
       // (p: S) => p._1
       val to = (p: S) =>  ${ Select.unique(('p).unseal, "_1").seal.cast[A] }
       // (p: A) => S(p)
-      val from = (p: A) =>  ${ Select.overloaded(Ident(companion), "apply", Nil, ('p).unseal :: Nil).seal.cast[S] }
+      val from = (p: A) =>  ${ Select.overloaded(Ident(companion), "apply", Nil, ('p).unseal :: Nil, TypeBounds.minmax).seal.cast[S] }
       apply(from)(to)
     }
   }
@@ -147,7 +147,7 @@ object Iso {
         case TypeRef(prefix, name) => TermRef(prefix, name)
       }
 
-      val obj = Select.overloaded(Ident(companion), "apply", Nil, Nil).seal.cast[S]
+      val obj = Select.overloaded(Ident(companion), "apply", Nil, Nil, TypeBounds.minmax).seal.cast[S]
 
       '{
         Iso[S, 1](Function.const($obj))(Function.const(1))
@@ -217,4 +217,4 @@ object GenPrism {
    *   }(jstr => jstr)
    */
   inline def apply[S, A <: S]: Prism[S, A] = ${ Prism.impl[S, A] }
-}
+}

tests/run-macros/i6171/Macro_1.scala

@@ -16,7 +16,7 @@ object scalatest {
       case t @ Apply(Select(lhs, op), rhs :: Nil) =>
         let(lhs) { left =>
           let(rhs) { right =>
-            val app = Select.overloaded(left, op, Nil, right :: Nil)
+            val app = Select.overloaded(left, op, Nil, right :: Nil, TypeBounds.minmax)
             let(app) { result =>
               val l = left.seal
               val r = right.seal
@@ -30,7 +30,7 @@ object scalatest {
         if isImplicitMethodType(f.tpe) =>
         let(lhs) { left =>
           let(rhs) { right =>
-            val app = Select.overloaded(Apply(qual, left :: Nil), op, Nil, right :: Nil)
+            val app = Select.overloaded(Apply(qual, left :: Nil), op, Nil, right :: Nil, TypeBounds.minmax)
             let(Apply(app, implicits)) { result =>
               val l = left.seal
               val r = right.seal

tests/run-macros/reflect-pos-fun/assert_1.scala

@@ -12,7 +12,7 @@ object scalatest {
       case t @ Apply(TypeApply(Select(lhs, op), targs), rhs) =>
         let(lhs) { left =>
           lets(rhs) { rs =>
-            val app = Select.overloaded(left, op, targs.map(_.tpe), rs)
+            val app = Select.overloaded(left, op, targs.map(_.tpe), rs, TypeBounds.minmax)
             val b = app.seal.cast[Boolean]
             '{ scala.Predef.assert($b) }.unseal
           }

tests/run-macros/reflect-select-constructor/assert_1.scala

@@ -16,7 +16,7 @@ object scalatest {
       case t @ Apply(Select(lhs, op), rhs :: Nil) =>
         let(lhs) { left =>
           let(rhs) { right =>
-            val app = Select.overloaded(left, op, Nil, right :: Nil)
+            val app = Select.overloaded(left, op, Nil, right :: Nil, TypeBounds.minmax)
             let(app) { result =>
               val l = left.seal
               val r = right.seal
@@ -30,7 +30,7 @@ object scalatest {
       if isImplicitMethodType(f.tpe) =>
         let(lhs) { left =>
           let(rhs) { right =>
-            val app = Select.overloaded(Apply(qual, left :: Nil), op, Nil, right :: Nil)
+            val app = Select.overloaded(Apply(qual, left :: Nil), op, Nil, right :: Nil, TypeBounds.minmax)
             let(Apply(app, implicits)) { result =>
               val l = left.seal
               val r = right.seal

tests/run-macros/reflect-select-value-class/assert_1.scala

@@ -16,7 +16,7 @@ object scalatest {
       case t @ Apply(Select(lhs, op), rhs :: Nil) =>
         let(lhs) { left =>
           let(rhs) { right =>
-            val app = Select.overloaded(left, op, Nil, right :: Nil)
+            val app = Select.overloaded(left, op, Nil, right :: Nil, TypeBounds.minmax)
             let(app) { result =>
               val l = left.seal
               val r = right.seal
@@ -30,7 +30,7 @@ object scalatest {
       if isImplicitMethodType(f.tpe) =>
         let(lhs) { left =>
           let(rhs) { right =>
-            val app = Select.overloaded(Apply(qual, left :: Nil), op, Nil, right :: Nil)
+            val app = Select.overloaded(Apply(qual, left :: Nil), op, Nil, right :: Nil, TypeBounds.minmax)
             let(Apply(app, implicits)) { result =>
               val l = left.seal
               val r = right.seal