Improve error messages for @experimental on case classes

Author: nicolasstucki

compiler/src/dotty/tools/dotc/config/Feature.scala

@@ -105,7 +105,16 @@ object Feature:
 
   def checkExperimentalDef(sym: Symbol, srcPos: SrcPos)(using Context) =
     if !isExperimentalEnabled then
-      report.error(i"$sym is marked @experimental and therefore may only be used with a nightly or snapshot version of the compiler", srcPos)
+      val symMsg =
+        if sym eq defn.ExperimentalAnnot then
+          i"use of @experimental is experimental"
+        else if sym.hasAnnotation(defn.ExperimentalAnnot) then
+          i"$sym is marked @experimental"
+        else if sym.owner.hasAnnotation(defn.ExperimentalAnnot) then
+          i"${sym.owner} is marked @experimental"
+        else
+          i"$sym inherits @experimental"
+      report.error(s"$symMsg and therefore may only be used with a nightly or snapshot version of the compiler", srcPos)
 
   /** Check that experimental compiler options are only set for snapshot or nightly compiler versions. */
   def checkExperimentalSettings(using Context): Unit =

compiler/src/dotty/tools/dotc/transform/PostTyper.scala

@@ -447,6 +447,10 @@ class PostTyper extends MacroTransform with IdentityDenotTransformer { thisPhase
       if (sym.isEffectivelyErased) dropInlines.transform(rhs) else rhs
 
     private def annotateExperimental(sym: Symbol)(using Context): Unit =
+      if sym.is(Module) && sym.companionClass.hasAnnotation(defn.ExperimentalAnnot) then
+        sym.addAnnotation(defn.ExperimentalAnnot)
+        sym.companionModule.addAnnotation(defn.ExperimentalAnnot)
+
       if sym.is(Enum) && sym.hasAnnotation(defn.ExperimentalAnnot) then
         // Add @experimental annotation to enum class definitions
         val compMod = sym.companionModule.moduleClass

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

@@ -978,15 +978,15 @@ object RefChecks {
     then
       Feature.checkExperimentalDef(sym, pos)
 
-  private def checkExperimentalTypes(tpe: Type, pos: SrcPos)(using Context): Unit =
+  private def checkExperimentalSignature(sym: Symbol, pos: SrcPos)(using Context): Unit =
     val checker = new TypeTraverser:
       def traverse(tp: Type): Unit =
         if tp.typeSymbol.isExperimental then
           Feature.checkExperimentalDef(tp.typeSymbol, pos)
         else
           traverseChildren(tp)
-    if !pos.span.isSynthetic then // avoid double errors
-      checker.traverse(tpe)
+    if !sym.owner.isExperimental && !pos.span.isSynthetic then // avoid double errors
+      checker.traverse(sym.info)
 
   private def checkExperimentalAnnots(sym: Symbol)(using Context): Unit =
     for annot <- sym.annotations if annot.symbol.isExperimental && annot.tree.span.exists do
@@ -1230,7 +1230,7 @@ class RefChecks extends MiniPhase { thisPhase =>
     checkNoPrivateOverrides(tree)
     checkDeprecatedOvers(tree)
     checkExperimentalAnnots(tree.symbol)
-    checkExperimentalTypes(tree.symbol.info, tree)
+    checkExperimentalSignature(tree.symbol, tree)
     val sym = tree.symbol
     if (sym.exists && sym.owner.isTerm) {
       tree.rhs match {
@@ -1252,7 +1252,7 @@ class RefChecks extends MiniPhase { thisPhase =>
     checkNoPrivateOverrides(tree)
     checkDeprecatedOvers(tree)
     checkExperimentalAnnots(tree.symbol)
-    checkExperimentalTypes(tree.symbol.info, tree)
+    checkExperimentalSignature(tree.symbol, tree)
     checkImplicitNotFoundAnnotation.defDef(tree.symbol.denot)
     tree
   }

tests/neg-custom-args/no-experimental/experimentalCaseClass.scala

@@ -0,0 +1,26 @@
+import scala.annotation.experimental
+
+@experimental // error
+case class Foo(a: Int)
+
+@experimental // error
+case class Bar(a: Int)
+
+object Bar:
+  def f(): Unit = ()
+
+def test: Unit =
+  Foo(2) // error
+  val x: Foo = ??? // error
+
+  x match
+    case Foo(a) => // error
+
+
+  Bar(2) // error
+  val y: Bar = ??? // error
+
+  y match
+    case Bar(a) => // error
+
+  Bar.f() // error