Also fix asQuotes implicit context for methods

Author: joroKr21

compiler/src/dotty/tools/dotc/core/SymDenotations.scala

@@ -338,8 +338,13 @@ object SymDenotations {
 
       def recurWithoutParamss(info: Type): List[List[Symbol]] = info match
         case info: LambdaType =>
-          val params = info.paramNames.lazyZip(info.paramInfos).map((pname, ptype) =>
-            newSymbol(symbol, pname, SyntheticParam, ptype))
+          val commonFlags =
+            if info.isContextualMethod then Given | SyntheticParam
+            else if info.isImplicitMethod then Implicit | SyntheticParam
+            else SyntheticParam
+          val params = info.paramNames.lazyZip(info.paramInfos).map: (pname, ptype) =>
+            val flags = if ptype.hasAnnotation(defn.ErasedParamAnnot) then commonFlags | Erased else commonFlags
+            newSymbol(symbol, pname, flags, ptype)
           val prefs = params.map(_.namedType)
           for param <- params do
             param.info = param.info.substParams(info, prefs)

compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala

@@ -11,6 +11,7 @@ import dotty.tools.dotc.core.Contexts.*
 import dotty.tools.dotc.core.Decorators.*
 import dotty.tools.dotc.core.NameKinds
 import dotty.tools.dotc.core.NameOps.*
+import dotty.tools.dotc.core.Scopes.*
 import dotty.tools.dotc.core.StdNames.*
 import dotty.tools.dotc.core.Types
 import dotty.tools.dotc.NoCompilationUnit
@@ -2579,7 +2580,7 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
           modFlags | dotc.core.Flags.ModuleValCreationFlags,
           clsFlags | dotc.core.Flags.ModuleClassCreationFlags,
           parents,
-          dotc.core.Scopes.newScope,
+          newScope,
           privateWithin)
         val cls = mod.moduleClass.asClass
         cls.enter(dotc.core.Symbols.newConstructor(cls, dotc.core.Flags.Synthetic, Nil, Nil))
@@ -2592,7 +2593,9 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
         xCheckMacroAssert(!privateWithin.exists || privateWithin.isType, "privateWithin must be a type symbol or `Symbol.noSymbol`")
         val privateWithin1 = if privateWithin.isTerm then Symbol.noSymbol else privateWithin
         checkValidFlags(flags.toTermFlags, Flags.validMethodFlags)
-        dotc.core.Symbols.newSymbol(owner, name.toTermName, flags | dotc.core.Flags.Method, tpe, privateWithin1)
+        val method = dotc.core.Symbols.newSymbol(owner, name.toTermName, flags | dotc.core.Flags.Method, tpe, privateWithin1)
+        method.setParamss(method.paramSymss)
+        method
       def newVal(owner: Symbol, name: String, tpe: TypeRepr, flags: Flags, privateWithin: Symbol): Symbol =
         xCheckMacroAssert(!privateWithin.exists || privateWithin.isType, "privateWithin must be a type symbol or `Symbol.noSymbol`")
         val privateWithin1 = if privateWithin.isTerm then Symbol.noSymbol else privateWithin
@@ -2807,7 +2810,11 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
 
         def asQuotes: Nested =
           assert(self.ownersIterator.contains(ctx.owner), s"$self is not owned by ${ctx.owner}")
-          new QuotesImpl(using ctx.withOwner(self))
+          val newCtx = if ctx.owner eq self then ctx else
+            val newCtx = ctx.fresh.setOwner(self)
+            if !self.flags.is(Flags.Method) then newCtx
+            else newCtx.setScope(newScopeWith(self.paramSymss.flatten*))
+          new QuotesImpl(using newCtx)
 
       end extension
 

tests/run-macros/i22260.check

@@ -2,4 +2,5 @@
 42
 42
 42
+42
 42

tests/run-macros/i22260/Macros_1.scala

@@ -1,14 +1,22 @@
 import scala.quoted.*
 
 object Macros:
+  inline def crMethod: Int = ${ createMethod }
   inline def inMethod: Int = ${ insideMethod }
   inline def usMethod: Int = ${ usingMethod }
   inline def inObject: Int = ${ insideObject }
   inline def inClass: Int = ${ insideClass }
   inline def usClass: Int = ${ usingClass }
 
   def summon(using Quotes) =
-    Expr.summon[Int].getOrElse('{ 0 })
+    Expr.summon[Int].getOrElse('{0})
+
+  def createMethod(using Quotes): Expr[Int] =
+    import quotes.reflect.*
+    val tpe = MethodType(MethodTypeKind.Contextual)("x" :: Nil)(_ => TypeRepr.of[Int] :: Nil, _ => TypeRepr.of[Int])
+    val sym = Symbol.newMethod(Symbol.spliceOwner, "foo", tpe)
+    val method = DefDef(sym, _ => Some(summon(using sym.asQuotes).asTerm))
+    Block(method :: Nil, Apply(Ref(sym), '{42}.asTerm :: Nil)).asExprOf[Int]
 
   def insideMethod(using Quotes): Expr[Int] = '{
     def foo =

tests/run-macros/i22260/Test_2.scala

@@ -1,4 +1,5 @@
 @main def Test =
+  println(Macros.crMethod)
   println(Macros.inMethod)
   println(Macros.usMethod)
   println(Macros.inObject)