Merge pull request #11862 from dotty-staging/fix-11859

Disallow context functions as case class elements

Author: liufengyun

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

@@ -541,7 +541,7 @@ class OrderingConstraint(private val boundsMap: ParamBounds,
         // HKLambdas are hash-consed, need to create an artificial difference by adding
         // a LazyRef to a bound.
         val TypeBounds(lo, hi) :: pinfos1 = tl.paramInfos
-        paramInfos = TypeBounds(lo, LazyRef(hi)) :: pinfos1
+        paramInfos = TypeBounds(lo, LazyRef.of(hi)) :: pinfos1
       }
       ensureFresh(tl.newLikeThis(tl.paramNames, paramInfos, tl.resultType))
     }

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

@@ -363,7 +363,7 @@ class TypeApplications(val self: Type) extends AnyVal {
       case dealiased: TypeBounds =>
         dealiased.derivedTypeBounds(dealiased.lo.appliedTo(args), dealiased.hi.appliedTo(args))
       case dealiased: LazyRef =>
-        LazyRef(dealiased.ref.appliedTo(args))
+        LazyRef.of(dealiased.ref.appliedTo(args))
       case dealiased: WildcardType =>
         WildcardType(dealiased.optBounds.orElse(TypeBounds.empty).appliedTo(args).bounds)
       case dealiased: TypeRef if dealiased.symbol == defn.NothingClass =>

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

@@ -687,8 +687,8 @@ object TypeOps:
           tp // break cycles
 
         case tp: TypeRef if !tp.symbol.isClass =>
-          def lo = LazyRef(apply(tp.underlying.loBound))
-          def hi = LazyRef(apply(tp.underlying.hiBound))
+          def lo = LazyRef.of(apply(tp.underlying.loBound))
+          def hi = LazyRef.of(apply(tp.underlying.hiBound))
           val lookup = boundTypeParams.lookup(tp)
           if lookup != null then lookup
           else

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

@@ -2800,7 +2800,7 @@ object Types {
     }
   }
 
-  case class LazyRef(private var refFn: Context ?=> Type) extends UncachedProxyType with ValueType {
+  case class LazyRef(private var refFn: Context => Type) extends UncachedProxyType with ValueType {
     private var myRef: Type = null
     private var computed = false
 
@@ -2813,7 +2813,7 @@ object Types {
           throw CyclicReference(NoDenotation)
       else
         computed = true
-        val result = refFn
+        val result = refFn(ctx)
         refFn = null
         if result != null then myRef = result
         else assert(myRef != null)  // must have been `update`d
@@ -2835,6 +2835,8 @@ object Types {
     override def equals(other: Any): Boolean = this.eq(other.asInstanceOf[AnyRef])
     override def hashCode: Int = System.identityHashCode(this)
   }
+  object LazyRef:
+    def of(refFn: Context ?=> Type): LazyRef = LazyRef(refFn(using _))
 
   // --- Refined Type and RecType ------------------------------------------------
 
@@ -4655,7 +4657,7 @@ object Types {
             RefinedType(selfType, sym.name,
               TypeAlias(
                 withMode(Mode.CheckCyclic)(
-                  LazyRef(force))))
+                  LazyRef.of(force))))
           cinfo.selfInfo match
             case self: Type =>
               cinfo.derivedClassInfo(
@@ -5254,7 +5256,8 @@ object Types {
           derivedSuperType(tp, this(thistp), this(supertp))
 
         case tp: LazyRef =>
-          LazyRef { refCtx ?=>
+          LazyRef { refCtx =>
+            given Context = refCtx
             val ref1 = tp.ref
             if refCtx.runId == mapCtx.runId then this(ref1)
             else // splice in new run into map context

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

@@ -301,7 +301,7 @@ object Checking {
         catch {
           case ex: CyclicReference =>
             report.debuglog(i"cycle detected for $tp, $nestedCycleOK, $cycleOK")
-            if (cycleOK) LazyRef(tp)
+            if (cycleOK) LazyRef.of(tp)
             else if (reportErrors) throw ex
             else tp
         }

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

@@ -2151,22 +2151,32 @@ class Typer extends Namer
       val rhsToInline = PrepareInlineable.wrapRHS(ddef, tpt1, rhs1)
       PrepareInlineable.registerInlineInfo(sym, rhsToInline)
 
-    if (sym.isConstructor && !sym.isPrimaryConstructor) {
-      if (sym.targetName != sym.name)
-        report.error(em"@targetName annotation may not be used on a constructor", ddef.srcPos)
-
-      for params <- paramss1; param <- params do
-        checkRefsLegal(param, sym.owner, (name, sym) => sym.is(TypeParam), "secondary constructor")
-
-      def checkThisConstrCall(tree: Tree): Unit = tree match {
-        case app: Apply if untpd.isSelfConstrCall(app) =>
-          if (sym.span.exists && app.symbol.span.exists && sym.span.start <= app.symbol.span.start)
-            report.error("secondary constructor must call a preceding constructor", app.srcPos)
-        case Block(call :: _, _) => checkThisConstrCall(call)
-        case _ =>
-      }
-      checkThisConstrCall(rhs1)
-    }
+    if sym.isConstructor then
+      if sym.isPrimaryConstructor then
+        if sym.owner.is(Case) then
+          for
+            params <- paramss1.dropWhile(TypeDefs.unapply(_).isDefined).take(1)
+            case param: ValDef <- params
+          do
+            if defn.isContextFunctionType(param.tpt.tpe) then
+              report.error("case class element cannot be a context function", param.srcPos)
+      else
+        if sym.targetName != sym.name then
+          report.error(em"@targetName annotation may not be used on a constructor", ddef.srcPos)
+
+        for params <- paramss1; param <- params do
+          checkRefsLegal(param, sym.owner, (name, sym) => sym.is(TypeParam), "secondary constructor")
+
+        def checkThisConstrCall(tree: Tree): Unit = tree match
+          case app: Apply if untpd.isSelfConstrCall(app) =>
+            if (sym.span.exists && app.symbol.span.exists && sym.span.start <= app.symbol.span.start)
+              report.error("secondary constructor must call a preceding constructor", app.srcPos)
+          case Block(call :: _, _) => checkThisConstrCall(call)
+          case _ =>
+
+        checkThisConstrCall(rhs1)
+      end if
+    end if
 
     if sym.is(Method) && sym.owner.denot.isRefinementClass then
       for annot <- sym.paramSymss.flatten.filter(_.isTerm).flatMap(_.getAnnotation(defn.ImplicitNotFoundAnnot)) do

tests/neg/i11859.scala

@@ -0,0 +1,9 @@
+class I
+case class C(x: I ?=> Object)  // error: case class element cannot be a context function
+
+type ITO = I ?=> Object
+case class D(x: ITO)  // error: case class element cannot be a context function
+
+@main def Test =
+  val c = C(new Object())
+  assert(c.hashCode == c.hashCode())