Add regression test for scala#10211

Author: rssh

tests/pos-macros/i10211/Macro_1.scala

@@ -0,0 +1,102 @@
+package x
+
+import scala.quoted._
+
+trait CB[T]:
+ def map[S](f: T=>S): CB[S] = ???
+
+
+class MyArr[A]:
+ def map[B](f: A=>B):MyArr[B] = ???
+ def mapOut[B](f: A=> CB[B]): CB[MyArr[B]] = ???
+ def flatMap[B](f: A=>MyArr[B]):MyArr[B] = ???
+ def flatMapOut[B](f: A=>CB[MyArr[B]]):MyArr[B] = ???
+ def withFilter(p: A=>Boolean): MyArr[A] = ???
+ def withFilterOut(p: A=>CB[Boolean]): DelayedWithFilter[A] = ???
+ def map2[B](f: A=>B):MyArr[B] = ???
+
+class DelayedWithFilter[A]:
+ def map[B](f: A=>B):MyArr[B] = ???
+ def mapOut[B](f: A=> CB[B]): CB[MyArr[B]] = ???
+ def flatMap[B](f: A=>MyArr[B]):MyArr[B] = ???
+ def flatMapOut[B](f: A=>CB[MyArr[B]]): CB[MyArr[B]] = ???
+ def map2[B](f: A=>B):CB[MyArr[B]] = ???
+
+
+def await[T](x:CB[T]):T = ???
+
+object CBM:
+  def pure[T](t:T):CB[T] = ???
+  def map[T,S](a:CB[T])(f:T=>S):CB[S] = ???
+
+object X:
+
+ inline def process[T](inline f:T) = ${
+   processImpl[T]('f)
+ }
+
+ def processImpl[T:Type](f:Expr[T])(using qctx: QuoteContext):Expr[CB[T]] = 
+   import qctx.reflect._
+
+   def transform(term:Term):Term =
+     term match
+        case ap@Apply(TypeApply(Select(obj,name),targs),args)
+               if (name=="map"||name=="flatMap") =>
+                  obj match
+                    case Apply(Select(obj1,"withFilter"),args1) =>
+                      val nObj = transform(obj)
+                      transform(Apply(TypeApply(Select.unique(nObj,name),targs),args))
+                    case _ =>
+                      val nArgs = args.map(x => shiftLambda(x))
+                      val nSelect = Select.unique(obj, name+"Out")
+                      Apply(TypeApply(nSelect,targs),nArgs)
+        case ap@Apply(Select(obj,"withFilter"),args) =>
+             val nArgs = args.map(x => shiftLambda(x))
+             val nSelect = Select.unique(obj, "withFilterOut")
+             Apply(nSelect,nArgs)
+        case ap@Apply(TypeApply(Select(obj,"map2"),targs),args) => 
+              val nObj = transform(obj)
+              Apply(TypeApply(
+                     Select.unique(nObj,"map2"),
+                     List(Type[Int].unseal)
+                   ),
+                   args
+              )
+        case Apply(TypeApply(Ident("await"),targs),args) => args.head
+        case Apply(Select(obj,"=="),List(b)) =>
+             val tb = transform(b).seal.cast[CB[Int]]
+             val mt = MethodType(List("p"))(_ => List(b.tpe.widen), _ => Type[Boolean].unseal.tpe)
+             val mapLambda = Lambda(mt, x => Select.overloaded(obj,"==",List(),List(x.head.asInstanceOf[Term]))).seal.cast[Int=>Boolean]
+             '{ CBM.map($tb)($mapLambda) }.unseal
+        case Block(stats, last) => Block(stats, transform(last))
+        case Inlined(x,List(),body) => transform(body)
+        case l@Literal(x) => 
+             '{ CBM.pure(${term.seal}) }.unseal
+        case other => 
+             throw RuntimeException(s"Not supported $other")
+          
+   def shiftLambda(term:Term): Term =
+        term match
+          case lt@Lambda(params, body) =>
+            val paramTypes = params.map(_.tpt.tpe)
+            val paramNames = params.map(_.name)
+            val mt = MethodType(paramNames)(_ => paramTypes, _ => Type[CB].unseal.tpe.appliedTo(body.tpe.widen) )
+            val r = Lambda(mt, args => changeArgs(params,args,transform(body)) )
+            r
+          case _ =>
+            throw RuntimeException("lambda expected")
+
+   def changeArgs(oldArgs:List[Tree], newArgs:List[Tree], body:Term):Term =
+         val association: Map[Symbol, Term] = (oldArgs zip newArgs).foldLeft(Map.empty){
+             case (m, (oldParam, newParam: Term)) => m.updated(oldParam.symbol, newParam)
+             case (m, (oldParam, newParam: Tree)) => throw RuntimeException("Term expected") 
+         }
+         val changes = new TreeMap() {
+             override def transformTerm(tree:Term)(using Context): Term =
+               tree match
+                 case ident@Ident(name) => association.getOrElse(ident.symbol, super.transformTerm(tree))
+                 case _ => super.transformTerm(tree)
+         }
+         changes.transformTerm(body)
+
+   transform(f.unseal).seal.cast[CB[T]]

tests/pos-macros/i10211/Test_2.scala

@@ -0,0 +1,18 @@
+package x
+
+
+object Main {
+
+ def main(args:Array[String]):Unit =
+   val arr1 = new MyArr[Int]()
+   val arr2 = new MyArr[Int]()
+   val r = X.process{
+       arr1.withFilter(x => x == await(CBM.pure(1)))
+           .flatMap(x =>
+              arr2.withFilter( y => y == await(CBM.pure(2)) ).
+                map2( y => x + y )
+           )
+   }
+   println(r)
+
+}