Disallow curried dependent context function types

Author: odersky

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

@@ -559,7 +559,7 @@ object desugar {
     val copiedAccessFlags = if migrateTo3 then EmptyFlags else AccessFlags
 
     // Methods to add to a case class C[..](p1: T1, ..., pN: Tn)(moreParams)
-    //     def _1: T1 = this.p1 
+    //     def _1: T1 = this.p1
     //     ...
     //     def _N: TN = this.pN (unless already given as valdef or parameterless defdef)
     //     def copy(p1: T1 = p1: @uncheckedVariance, ...,
@@ -572,7 +572,7 @@ object desugar {
     val caseClassMeths = {
       def syntheticProperty(name: TermName, tpt: Tree, rhs: Tree) =
         DefDef(name, Nil, Nil, tpt, rhs).withMods(synthetic)
-        
+
       def productElemMeths =
         val caseParams = derivedVparamss.head.toArray
         val selectorNamesInBody = normalizedBody.collect {

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

@@ -246,7 +246,10 @@ class Namer { typer: Typer =>
     val xtree = expanded(tree)
     xtree.getAttachment(TypedAhead) match {
       case Some(ttree) => ttree.symbol
-      case none => xtree.attachment(SymOfTree)
+      case none =>
+        xtree.getAttachment(SymOfTree) match
+          case Some(sym) => sym
+          case _ => throw IllegalArgumentException(i"$xtree does not have a symbol")
     }
   }
 
@@ -443,14 +446,11 @@ class Namer { typer: Typer =>
    /** If `sym` exists, enter it in effective scope. Check that
     *  package members are not entered twice in the same run.
     */
-  def enterSymbol(sym: Symbol)(using Context): Symbol = {
+  def enterSymbol(sym: Symbol)(using Context): Unit =
     // We do not enter Scala 2 macros defined in Scala 3 as they have an equivalent Scala 3 inline method.
-    if (sym.exists && !sym.isScala2MacroInScala3) {
+    if sym.exists && !sym.isScala2MacroInScala3 then
       typr.println(s"entered: $sym in ${ctx.owner}")
       ctx.enter(sym)
-    }
-    sym
-  }
 
   /** Create package if it does not yet exist. */
   private def createPackageSymbol(pid: RefTree)(using Context): Symbol = {
@@ -539,7 +539,8 @@ class Namer { typer: Typer =>
       case imp: Import =>
         ctx.importContext(imp, createSymbol(imp))
       case mdef: DefTree =>
-        val sym = enterSymbol(createSymbol(mdef))
+        val sym = createSymbol(mdef)
+        enterSymbol(sym)
         setDocstring(sym, origStat)
         addEnumConstants(mdef, sym)
         ctx

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

@@ -936,7 +936,7 @@ class Typer extends Namer
    *     def double(x: Char): String = s"$x$x"
    *     "abc" flatMap double
    */
-  private def decomposeProtoFunction(pt: Type, defaultArity: Int)(using Context): (List[Type], untpd.Tree) = {
+  private def decomposeProtoFunction(pt: Type, defaultArity: Int, tree: untpd.Tree)(using Context): (List[Type], untpd.Tree) = {
     def typeTree(tp: Type) = tp match {
       case _: WildcardType => untpd.TypeTree()
       case _ => untpd.TypeTree(tp)
@@ -947,7 +947,15 @@ class Typer extends Namer
           newTypeVar(apply(bounds.orElse(TypeBounds.empty)).bounds)
         case _ => mapOver(t)
     }
-    pt.stripTypeVar.dealias match {
+    val pt1 = pt.stripTypeVar.dealias
+    if (pt1 ne pt1.dropDependentRefinement)
+       && defn.isContextFunctionType(pt1.nonPrivateMember(nme.apply).info.finalResultType)
+    then
+      ctx.error(
+        i"""Implementation restriction: Expected result type $pt1
+           |is a curried dependent context function type. Such types are not yet supported.""",
+        tree.sourcePos)
+    pt1 match {
       case pt1 if defn.isNonRefinedFunction(pt1) =>
         // if expected parameter type(s) are wildcards, approximate from below.
         // if expected result type is a wildcard, approximate from above.
@@ -960,7 +968,7 @@ class Typer extends Namer
          else
            typeTree(restpe))
       case tp: TypeParamRef =>
-        decomposeProtoFunction(ctx.typerState.constraint.entry(tp).bounds.hi, defaultArity)
+        decomposeProtoFunction(ctx.typerState.constraint.entry(tp).bounds.hi, defaultArity, tree)
       case _ =>
         (List.tabulate(defaultArity)(alwaysWildcardType), untpd.TypeTree())
     }
@@ -1251,7 +1259,7 @@ class Typer extends Namer
           typedMatchFinish(tree, tpd.EmptyTree, defn.ImplicitScrutineeTypeRef, cases1, pt)
         }
         else {
-          val (protoFormals, _) = decomposeProtoFunction(pt, 1)
+          val (protoFormals, _) = decomposeProtoFunction(pt, 1, tree)
           val checkMode =
             if (pt.isRef(defn.PartialFunctionClass)) desugar.MatchCheck.None
             else desugar.MatchCheck.Exhaustive

tests/neg/curried-dependent-ift.scala

@@ -0,0 +1,17 @@
+trait Ctx1:
+  type T
+  val x: T
+  val y: T
+
+trait Ctx2:
+  type T
+  val x: T
+  val y: T
+
+trait A
+trait B
+
+def h(x: Boolean): A ?=> B ?=> (A, B) =
+  (summon[A], summon[B]) // OK
+
+def g(x: Boolean): (c1: Ctx1) ?=> Ctx2 ?=> (c1.T, Ctx2) = ??? // error

tests/neg/i4668.scala

@@ -8,4 +8,4 @@ trait Functor[F[_]] { def map[A,B](x: F[A])(f: A => B): F[B] }
 object Functor { implicit object listFun extends Functor[List] { def map[A,B](ls: List[A])(f: A => B) = ls.map(f) } }
 
 val map: (A:Type,B:Type,F:Type1) ?=>  (Functor[F.T]) ?=> (F.T[A.T]) => (A.T => B.T) => F.T[B.T] =
-  fun ?=> x => f => fun.map(x)(f) // error // error // error: Missing parameter type
+  fun ?=> x => f => fun.map(x)(f) // error