Adapt transparent value checking to new restrictions

Author: odersky

compiler/src/dotty/tools/dotc/reporting/diagnostic/messages.scala

@@ -1748,7 +1748,7 @@ object messages {
     val kind = "Syntax"
     val msg = hl"no explicit ${"return"} allowed from transparent $owner"
     val explanation =
-      hl"""Methods marked with ${"inline"} modifier may not use ${"return"} statements.
+      hl"""Methods marked with ${"transparent"} modifier may not use ${"return"} statements.
           |Instead, you should rely on the last expression's value being
           |returned from a method.
           |"""
@@ -2057,7 +2057,7 @@ object messages {
   case class ParamsNoTransparent(owner: Symbol)(implicit ctx: Context)
     extends Message(ParamsNoTransparentID) {
     val kind = "Syntax"
-    val msg = hl"""${"transparent"} modifier cannot be used for a ${owner.showKind} parameter"""
+    val msg = hl"""${"transparent"} modifier cannot be used for a parameter of a non-transparent method"""
     val explanation = ""
   }
 

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

@@ -369,7 +369,10 @@ object Checking {
       if (!ok && !sym.is(Synthetic))
         fail(i"modifier `$flag` is not allowed for this definition")
 
-    if (sym.is(Transparent) && ((sym.is(ParamAccessor) && sym.owner.isClass) || sym.is(TermParam) && sym.owner.isClassConstructor))
+    if (sym.is(Transparent) &&
+          (  sym.is(ParamAccessor) && sym.owner.isClass
+          || sym.is(TermParam) && !sym.owner.isTransparentMethod
+          ))
       fail(ParamsNoTransparent(sym.owner))
 
     if (sym.is(ImplicitCommon)) {
@@ -669,14 +672,11 @@ trait Checking {
   def checkTransparentConformant(tree: Tree, isFinal: Boolean, what: => String)(implicit ctx: Context): Unit = {
     // final vals can be marked transparent even if they're not pure, see Typer#patchFinalVals
     val purityLevel = if (isFinal) Idempotent else Pure
-    tree.tpe match {
-      case tp: TermRef if tp.symbol.is(TransparentParam) => // ok
-      case tp => tp.widenTermRefExpr match {
-        case tp: ConstantType if exprPurity(tree) >= purityLevel => // ok
-        case _ =>
-          val allow = ctx.erasedTypes || ctx.owner.ownersIterator.exists(_.isTransparentMethod)
-          if (!allow) ctx.error(em"$what must be a constant expression", tree.pos)
-      }
+    tree.tpe.widenTermRefExpr match {
+      case tp: ConstantType if exprPurity(tree) >= purityLevel => // ok
+      case _ =>
+        val allow = ctx.erasedTypes || ctx.owner.ownersIterator.exists(_.isTransparentMethod)
+        if (!allow) ctx.error(em"$what must be a constant expression", tree.pos)
     }
   }
 

tests/neg/inlinevals.scala

@@ -1,6 +1,8 @@
 object Test {
 
-  def power(x: Double, transparent n: Int): Double = ???
+  def power0(x: Double, transparent n: Int): Double = ???  // error
+
+  transparent def power(x: Double, transparent n: Int): Double = ???  // ok
 
   transparent val N = 10
   def X = 20
@@ -19,12 +21,15 @@ object Test {
 
   transparent val xs = List(1, 2, 3) // error: must be a constant expression
 
-  def f(transparent xs: List[Int]) = xs
+  transparent def foo(x: Int) = {
+
+    def f(transparent xs: List[Int]) = xs // error
 
-  f(List(1, 2, 3)) // error: must be a constant expression
+    transparent val y = { println("hi"); 1 }  // ok
+    transparent val z = x // ok
 
-  def byname(transparent f: => String): Int = ??? // ok
+  }
 
-  byname("hello" ++ " world")
+  transparent def byname(transparent f: => String): Int = ??? // ok
 
 }