Handle apply on ContextualMethodTypes created with -Yimplicit-as-given as if it was implicit

Author: jchyb

compiler/src/dotty/tools/dotc/ast/untpd.scala

@@ -210,6 +210,8 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
 
     case class Given()(implicit @constructorOnly src: SourceFile) extends Mod(Flags.Given)
 
+    case class GivenFromImplicit()(implicit @constructorOnly src: SourceFile) extends Mod(Flags.Given | Flags.FromImplicit)
+
     case class Erased()(implicit @constructorOnly src: SourceFile) extends Mod(Flags.Erased)
 
     case class Final()(implicit @constructorOnly src: SourceFile) extends Mod(Flags.Final)

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

@@ -436,6 +436,9 @@ object Flags {
   /** Symbol is a constructor proxy (either companion, or apply method) */
   val (ConstructorProxy @ _, _, _) = newFlags(62, "<constructor proxy>") // (could be merged with Lifted)
 
+  /** Changed from implicit with -Yimplicits-as-given flags */
+  val (FromImplicit @ _, _,  _) = newFlags(63, "<from implicit>")
+
 // --------- Combined Flag Sets and Conjunctions ----------------------
 
   /** All possible flags */

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

@@ -78,10 +78,10 @@ object NamerOps:
       case Nil =>
         resultType
       case TermSymbols(params) :: paramss1 =>
-        val (isContextual, isImplicit) =
-          if params.isEmpty then (false, false)
-          else (params.head.is(Given), params.head.is(Implicit))
-        val make = MethodType.companion(isContextual = isContextual, isImplicit = isImplicit)
+        val (isContextual, isImplicit, fromImplicit) =
+          if params.isEmpty then (false, false, false)
+          else (params.head.is(Given), params.head.is(Implicit), params.head.is(FromImplicit))
+        val make = MethodType.companion(isContextual = isContextual, isImplicit = isImplicit, fromImplicit = fromImplicit)
         if isJava then
           for param <- params do
             if param.info.isDirectRef(defn.ObjectClass) then param.info = defn.AnyType

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

@@ -479,6 +479,8 @@ object Types extends TypeUtils {
     /** Is this a Method or PolyType which has implicit or contextual parameters? */
     def isImplicitMethod: Boolean = false
 
+    def wasImplicitMethod: Boolean = false
+
     /** Is this a Method or PolyType which has contextual parameters as first value parameter list? */
     def isContextualMethod: Boolean = false
 
@@ -4104,7 +4106,10 @@ object Types extends TypeUtils {
       paramInfos.exists(p => p.hasAnnotation(defn.ErasedParamAnnot))
 
     final override def isContextualMethod: Boolean =
-      companion.eq(ContextualMethodType)
+      companion.eq(ContextualMethodType) || companion.eq(ContextualFromImplicitMethodType)
+
+    final override def wasImplicitMethod: Boolean =
+      companion.eq(ContextualFromImplicitMethodType)
 
     def erasedParams(using Context): List[Boolean] =
       paramInfos.map(p => p.hasAnnotation(defn.ErasedParamAnnot))
@@ -4209,14 +4214,16 @@ object Types extends TypeUtils {
   }
 
   object MethodType extends MethodTypeCompanion("MethodType") {
-    def companion(isContextual: Boolean = false, isImplicit: Boolean = false): MethodTypeCompanion =
-      if (isContextual) ContextualMethodType
+    def companion(isContextual: Boolean = false, isImplicit: Boolean = false, fromImplicit: Boolean = false): MethodTypeCompanion =
+      if (fromImplicit) ContextualFromImplicitMethodType
+      else if (isContextual) ContextualMethodType
       else if (isImplicit) ImplicitMethodType
       else MethodType
   }
 
   object ContextualMethodType extends MethodTypeCompanion("ContextualMethodType")
   object ImplicitMethodType extends MethodTypeCompanion("ImplicitMethodType")
+  object ContextualFromImplicitMethodType extends MethodTypeCompanion("ContextualFromImplicitMethodType")
 
   /** A ternary extractor for MethodType */
   object MethodTpe {

compiler/src/dotty/tools/dotc/parsing/Parsers.scala

@@ -3283,7 +3283,7 @@ object Parsers {
     private def modOfToken(tok: Int, name: Name): Mod = tok match {
       case ABSTRACT    => Mod.Abstract()
       case FINAL       => Mod.Final()
-      case IMPLICIT if ctx.settings.YimplicitAsGiven.value => Mod.Given()
+      case IMPLICIT if ctx.settings.YimplicitAsGiven.value => Mod.GivenFromImplicit()
       case IMPLICIT    => Mod.Implicit()
       case GIVEN       => Mod.Given()
       case LAZY        => Mod.Lazy()
@@ -3553,7 +3553,7 @@ object Parsers {
 
       def paramMods() =
         if in.token == IMPLICIT then
-          addParamMod(() => if (ctx.settings.YimplicitAsGiven.value) Mod.Given() else Mod.Implicit())
+          addParamMod(() => if (ctx.settings.YimplicitAsGiven.value) Mod.GivenFromImplicit() else Mod.Implicit())
         else if isIdent(nme.using) then
           if initialMods.is(Given) then
             syntaxError(em"`using` is already implied here, should not be given explicitly", in.offset)

compiler/src/dotty/tools/dotc/typer/Typer.scala

@@ -4855,6 +4855,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
     val isUsingApply = pt.applyKind == ApplyKind.Using
     methType.isContextualMethod == isUsingApply
     || methType.isImplicitMethod && isUsingApply // for a transition allow `using` arguments for regular implicit parameters
+    || methType.wasImplicitMethod && !isUsingApply
 
   /** Check that `tree == x: pt` is typeable. Used when checking a pattern
    *  against a selector of type `pt`. This implementation accounts for

tests/pos/i22482.scala

@@ -0,0 +1,8 @@
+//> using options -Yimplicit-as-given
+
+def foo(implicit a: Int): Unit = ???
+def bar()(implicit a: Int) : Unit = ???
+
+def main() =
+  foo(0)
+  bar()(0)