Move Inline and Lazy checks to checkFlags

Author: nicolasstucki

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

@@ -550,27 +550,6 @@ trait Checking {
       tp
   }
 
-  /** Check that keywords are only used on valid trees */
-  def checkKeywords(tree: tpd.Tree)(implicit ctx: Context): Unit = {
-    val sym = tree.symbol
-    if (sym is Inline) {
-      def error() = ctx.error("inlined keyword cannot be used on " + ctx.kindString(sym), tree.pos)
-      tree match {
-        case _: TypeDef => error()
-        case _: ValDef if sym.is(Module) || sym.is(Mutable) || sym.is(Lazy) => error()
-        case _ =>
-      }
-    }
-    if (sym is Lazy) {
-      def error(kind: String) = ctx.error("lazy keyword cannot be used on " + kind, tree.pos)
-      tree match {
-        case _: DefDef if !sym.is(Accessor) => error("def")
-        case _: ValDef if sym.is(Mutable) && !sym.is(Synthetic) => error("var")
-        case _ =>
-      }
-    }
-  }
-
   /** Check that `tree` is a pure expression of constant type */
   def checkInlineConformant(tree: Tree, what: => String)(implicit ctx: Context): Unit =
     tree.tpe match {

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

@@ -246,13 +246,46 @@ class Namer { typer: Typer =>
     def checkFlags(flags: FlagSet) =
       if (flags.isEmpty) flags
       else {
-        val (ok, adapted, kind) = tree match {
-          case tree: TypeDef => (flags.isTypeFlags, flags.toTypeFlags, "type")
-          case _ => (flags.isTermFlags, flags.toTermFlags, "value")
+        def error(flags: FlagSet, illegalFlag: FlagSet, kind: String) = {
+          val wrongFlag = if (illegalFlag.isEmpty) flags else illegalFlag
+          ctx.error(i"modifier(s) `$wrongFlag' incompatible with $kind definition", tree.pos)
+          flags &~ wrongFlag
         }
-        if (!ok)
-          ctx.error(i"modifier(s) `$flags' incompatible with $kind definition", tree.pos)
-        adapted
+
+        def doCheck(fs: FlagSet, f: FlagSet): FlagSet = f match {
+          case Inline =>
+            tree match {
+              case _: TypeDef => error(fs, Inline, "type")
+              case _: ValDef =>
+                if (fs is Mutable) error(fs, Inline, "var")
+                else if (fs is Lazy) error(fs, Inline, "lazy val")
+                else if (fs is Module) error(fs, Inline, "object")
+                else fs
+              case _ => fs
+            }
+          case Lazy =>
+            tree match {
+              case _: DefDef if !fs.is(Accessor) => error(fs, Lazy, "def")
+              case _: ValDef if fs.is(Mutable) && !fs.is(Synthetic) => error(fs, Lazy, "var")
+              case _ => fs
+            }
+        }
+
+        def checked(flags: FlagSet, toCheck: Array[FlagSet]): FlagSet =
+          toCheck.foldLeft(flags)((acc, f) => if (acc.is(f)) doCheck(acc, f) else acc)
+
+        val adapted = tree match {
+          case _: TypeDef =>
+            if (!flags.isTypeFlags)
+              error(flags, EmptyFlags, "type")
+            flags.toTypeFlags
+          case _ =>
+            if (!flags.isTermFlags)
+              error(flags, EmptyFlags, "value")
+            flags.toTermFlags
+        }
+
+        checked(adapted, Array(Inline, Lazy))
       }
 
     /** Add moduleClass/sourceModule to completer if it is for a module val or class */

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

@@ -1228,7 +1228,6 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
       case rhs => typedExpr(rhs, tpt1.tpe)
     }
     val vdef1 = assignType(cpy.ValDef(vdef)(name, tpt1, rhs1), sym)
-    checkKeywords(vdef1)
     if (sym.is(Inline, butNot = DeferredOrParamAccessor))
       checkInlineConformant(rhs1, em"right-hand side of inline $sym")
     patchIfLazy(vdef1)
@@ -1296,11 +1295,7 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
       tpt1 = tpt1.withType(avoid(tpt1.tpe, vparamss1.flatMap(_.map(_.symbol))))
     }
 
-    val ddef1 = assignType(cpy.DefDef(ddef)(name, tparams1, vparamss1, tpt1, rhs1), sym)
-
-    checkKeywords(ddef1)
-
-    ddef1
+    assignType(cpy.DefDef(ddef)(name, tparams1, vparamss1, tpt1, rhs1), sym)
     //todo: make sure dependent method types do not depend on implicits or by-name params
   }
 
@@ -1315,9 +1310,7 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
       case rhs =>
         typedType(rhs)
     }
-    val tdef1 = assignType(cpy.TypeDef(tdef)(name, rhs1), sym)
-    checkKeywords(tdef1)
-    tdef1
+    assignType(cpy.TypeDef(tdef)(name, rhs1), sym)
   }
 
   def typedClassDef(cdef: untpd.TypeDef, cls: ClassSymbol)(implicit ctx: Context) = track("typedClassDef") {
@@ -1419,12 +1412,9 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
       // check value class constraints
       checkDerivedValueClass(cls, body1)
 
-      checkKeywords(cdef1)
-
       if (ctx.settings.YretainTrees.value) {
         cls.myTree = cdef1
       }
-
       cdef1
 
       // todo later: check that

tests/neg/i2421.scala

@@ -1,10 +1,10 @@
-inline object Foo // error: inlined keyword cannot be used on object
-inline class Bar // error: inlined keyword cannot be used on class
-inline abstract class Baz // error: inlined keyword cannot be used on abstract class
-inline trait Qux // error: inlined keyword cannot be used on trait
+inline object Foo // error: modifier(s) `inline' incompatible with type definition
+inline class Bar // error: modifier(s) `inline' incompatible with type definition
+inline abstract class Baz // error: modifier(s) `inline' incompatible with type definition
+inline trait Qux // error: modifier(s) `inline' incompatible with type definition
 
 object Quux {
-  inline type T // error: inlined keyword cannot be used on type
-  inline var x: Int = 42 // error: inlined keyword cannot be used on var
-  inline lazy val y: Int = 42 // error: inlined keyword cannot be used on lazy val
+  inline type T // error: modifier(s) `inline' incompatible with type definition
+  inline var x: Int = 42 // error: modifier(s) `inline' incompatible with var definition
+  inline lazy val y: Int = 43 // error: modifier(s) `inline' incompatible with lazy val definition
 }

tests/neg/i2712.scala

@@ -1,4 +1,12 @@
 object Foo {
-  lazy var x: Int = 42 // error
-  lazy def y: Int = 42 // error
+  lazy var x: Int = 42 // error: modifier(s) `lazy' incompatible with var definition
+  lazy def y: Int = 42 // error: modifier(s) `lazy' incompatible with def definition
+}
+
+lazy class Bar // error: modifier(s) `lazy' incompatible with type definition
+lazy abstract class Baz // error: modifier(s) `lazy abstract' incompatible with type definition
+lazy trait Qux // error: modifier(s) `lazy' not allowed for trait
+
+object Quux {
+  lazy type T // error: modifier(s) `lazy' incompatible with type definition
 }