Allow sealing method references as function types

Author: nicolasstucki

compiler/src/dotty/tools/dotc/tastyreflect/QuotedOpsImpl.scala

@@ -1,6 +1,12 @@
 package dotty.tools.dotc.tastyreflect
 
+import dotty.tools.dotc.ast.tpd
+import dotty.tools.dotc.ast.Trees
+import dotty.tools.dotc.core.Flags._
+import dotty.tools.dotc.core.Symbols.defn
+import dotty.tools.dotc.core.StdNames.nme
 import dotty.tools.dotc.core.quoted.PickledQuotes
+import dotty.tools.dotc.core.Types.MethodType
 
 trait QuotedOpsImpl extends scala.tasty.reflect.QuotedOps with CoreImpl {
 
@@ -15,16 +21,28 @@ trait QuotedOpsImpl extends scala.tasty.reflect.QuotedOps with CoreImpl {
   def TermToQuoteDeco(term: Term): TermToQuotedAPI = new TermToQuotedAPI {
 
     def seal[T: scala.quoted.Type](implicit ctx: Context): scala.quoted.Expr[T] = {
-      typecheck()
-      new scala.quoted.Exprs.TastyTreeExpr(term).asInstanceOf[scala.quoted.Expr[T]]
-    }
 
-    private def typecheck[T: scala.quoted.Type]()(implicit ctx: Context): Unit = {
-      val tpt = QuotedTypeDeco(implicitly[scala.quoted.Type[T]]).unseal
-      if (!(term.tpe <:< tpt.tpe)) {
+      val expectedType = QuotedTypeDeco(implicitly[scala.quoted.Type[T]]).unseal.tpe
+
+      def etaExpand(term: Term): Term = term.tpe.widen match {
+        case mtpe: MethodType =>
+          val closureResType = mtpe.resType match {
+            case t: MethodType => t.toFunctionType()
+            case t => t
+          }
+          val closureTpe = MethodType(mtpe.paramNames, mtpe.paramInfos, closureResType)
+          val closureMethod = ctx.newSymbol(ctx.owner, nme.ANON_FUN, Synthetic | Method, closureTpe)
+          tpd.Closure(closureMethod, tss => etaExpand(new tpd.TreeOps(term).appliedToArgs(tss.head)))
+        case _ => term
+      }
+
+      val expanded = etaExpand(term)
+      if (expanded.tpe <:< expectedType) {
+        new scala.quoted.Exprs.TastyTreeExpr(expanded).asInstanceOf[scala.quoted.Expr[T]]
+      } else {
         throw new scala.tasty.TastyTypecheckError(
           s"""Term: ${term.show}
-             |did not conform to type: ${tpt.tpe.show}
+             |did not conform to type: ${expectedType.show}
              |""".stripMargin
         )
       }

compiler/src/dotty/tools/dotc/tastyreflect/TypeOrBoundsOpsImpl.scala

@@ -7,6 +7,18 @@ trait TypeOrBoundsOpsImpl extends scala.tasty.reflect.TypeOrBoundsOps with CoreI
   def TypeDeco(tpe: Type): TypeAPI = new TypeAPI {
     def =:=(other: Type)(implicit ctx: Context): Boolean = tpe =:= other
     def <:<(other: Type)(implicit ctx: Context): Boolean = tpe <:< other
+
+    /** Widen from singleton type to its underlying non-singleton
+      *  base type by applying one or more `underlying` dereferences,
+      *  Also go from => T to T.
+      *  Identity for all other types. Example:
+      *
+      *  class Outer { class C ; val x: C }
+      *  def o: Outer
+      *  <o.x.type>.widen = o.C
+      */
+    def widen(implicit ctx: Context): Type = tpe.widen
+
   }
 
   def ConstantTypeDeco(x: ConstantType): Type.ConstantTypeAPI = new Type.ConstantTypeAPI {

library/src/scala/tasty/reflect/TypeOrBoundsOps.scala

@@ -52,6 +52,7 @@ trait TypeOrBoundsOps extends Core {
   trait TypeAPI {
     def =:=(other: Type)(implicit ctx: Context): Boolean
     def <:<(other: Type)(implicit ctx: Context): Boolean
+    def widen(implicit ctx: Context): Type
   }
 
   val IsType: IsTypeModule

tests/run/tasty-seal-method/quoted_1.scala

@@ -0,0 +1,51 @@
+import scala.quoted._
+
+import scala.tasty._
+
+object Asserts {
+
+  inline def zeroLastArgs(x: => Int): Int =
+    ~zeroLastArgsImpl('(x))
+
+  /** Replaces last argument list by 0s */
+  def zeroLastArgsImpl(x: Expr[Int])(implicit reflect: Reflection): Expr[Int] = {
+    import reflect._
+    // For simplicity assumes that all parameters are Int and parameter lists have no more than 3 elements
+    x.unseal.underlyingArgument match {
+      case Term.Apply(fn, args) =>
+        fn.tpe.widen match {
+          case Type.IsMethodType(_) =>
+            args.size match {
+              case 0 => fn.seal[() => Int].apply()
+              case 1 => fn.seal[Int => Int].apply('(0))
+              case 2 => fn.seal[(Int, Int) => Int].apply('(0), '(0))
+              case 3 => fn.seal[(Int, Int, Int) => Int].apply('(0), '(0), '(0))
+            }
+        }
+      case _ => x
+    }
+  }
+
+  inline def zeroAllArgs(x: => Int): Int =
+    ~zeroAllArgsImpl('(x))
+
+  /** Replaces all argument list by 0s */
+  def zeroAllArgsImpl(x: Expr[Int])(implicit reflect: Reflection): Expr[Int] = {
+    import reflect._
+    // For simplicity assumes that all parameters are Int and parameter lists have no more than 3 elements
+    def rec(term: Term): Term = term match {
+      case Term.Apply(fn, args) =>
+        val pre = rec(fn)
+        args.size match {
+          case 0 => pre.seal[() => Any].apply().unseal
+          case 1 => pre.seal[Int => Any].apply('(0)).unseal
+          case 2 => pre.seal[(Int, Int) => Any].apply('(0), '(0)).unseal
+          case 3 => pre.seal[(Int, Int, Int) => Any].apply('(0), '(0), '(0)).unseal
+        }
+      case _ => term
+    }
+
+    rec(x.unseal.underlyingArgument).seal[Int]
+  }
+
+}

tests/run/tasty-seal-method/quoted_2.scala

@@ -0,0 +1,28 @@
+
+import Asserts._
+
+object Test {
+  def main(args: Array[String]): Unit = {
+    assert(zeroLastArgs(-1) == -1)
+    assert(zeroLastArgs(f) == 41)
+    assert(zeroLastArgs(f0()) == 42)
+    assert(zeroLastArgs(f1(2)) == 1)
+    assert(zeroLastArgs(f2(2, 3)) == 2)
+    assert(zeroLastArgs(f3(2)(4, 5)) == 5)
+
+    assert(zeroAllArgs(-1) == -1)
+    assert(zeroAllArgs(f) == 41)
+    assert(zeroAllArgs(f0()) == 42)
+    assert(zeroAllArgs(f1(2)) == 1)
+    assert(zeroAllArgs(f2(2, 3)) == 2)
+    assert(zeroAllArgs(f3(2)(4, 5)) == 3)
+  }
+
+  def f: Int = 41
+  def f0(): Int = 42
+  def f1(i: Int): Int = 1 + i
+  def f2(i: Int, j: Int): Int = 2 + i + j
+  def f3(i: Int)(j: Int, k: Int): Int = 3 + i + j
+  def f4(i: Int, j: Int)(k: Int, l: Int): Int = 4 + i + j + k + l
+
+}