Detect illegal refinements in Parser

Author: odersky

compiler/src/dotty/tools/dotc/parsing/Parsers.scala

@@ -2422,22 +2422,35 @@ object Parsers {
       (self, if (stats.isEmpty) List(EmptyTree) else stats.toList)
     }
 
-    /** RefineStatSeq    ::= RefineStat {semi RefineStat}
-     *  RefineStat       ::= Dcl
-     *                     |
-     *  (in reality we admit Defs and filter them out afterwards)
+    /** RefineStatSeq    ::=  RefineStat {semi RefineStat}
+     *  RefineStat       ::=  ‘val’ VarDcl
+     *                     |  ‘def’ DefDcl
+     *                     |  ‘type’ {nl} TypeDcl
+     *  (in reality we admit Defs and vars and filter them out afterwards in `checkLegal`)
      */
     def refineStatSeq(): List[Tree] = {
       val stats = new ListBuffer[Tree]
+      def checkLegal(tree: Tree): List[Tree] = {
+        val isLegal = tree match {
+          case tree: ValDef => tree.rhs.isEmpty && !tree.mods.flags.is(Mutable)
+          case tree: DefDef => tree.rhs.isEmpty
+          case tree: TypeDef => true
+          case _ => false
+        }
+        if (isLegal) tree :: Nil
+        else {
+          syntaxError("illegal refinement", tree.pos)
+          Nil
+        }
+      }
       while (!isStatSeqEnd) {
-        if (isDclIntro) {
-          stats += defOrDcl(in.offset, Modifiers())
-        } else if (!isStatSep) {
+        if (isDclIntro)
+          stats ++= checkLegal(defOrDcl(in.offset, Modifiers()))
+        else if (!isStatSep)
           syntaxErrorOrIncomplete(
             "illegal start of declaration" +
             (if (inFunReturnType) " (possible cause: missing `=' in front of current method body)"
              else ""))
-        }
         acceptStatSepUnlessAtEnd()
       }
       stats.toList

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

@@ -1194,7 +1194,7 @@ class Typer extends Namer
     val refineCls = createSymbol(refineClsDef).asClass
     val TypeDef(_, impl: Template) = typed(refineClsDef)
     val refinements1 = impl.body
-    assert(tree.refinements.length == refinements1.length, s"${tree.refinements} != $refinements1")
+    assert(tree.refinements.hasSameLengthAs(refinements1), i"${tree.refinements}%, % > $refinements1%, %")
     val seen = mutable.Set[Symbol]()
     for (refinement <- refinements1) { // TODO: get clarity whether we want to enforce these conditions
       typr.println(s"adding refinement $refinement")

docs/docs/internals/syntax.md

@@ -147,7 +147,7 @@ ParamValueType    ::=  Type [‘*’]
 TypeArgs          ::=  ‘[’ ArgTypes ‘]’                                         ts
 NamedTypeArg      ::=  id ‘=’ Type                                              NamedArg(id, t)
 NamedTypeArgs     ::=  ‘[’ NamedTypeArg {‘,’ NamedTypeArg} ‘]’                  nts
-Refinement        ::=  ‘{’ [Dcl] {semi [Dcl]} ‘}’                               ds
+Refinement        ::=  ‘{’ [RefineDcl] {semi [RefineDcl]} ‘}’                   ds
 TypeBounds        ::=  [‘>:’ Type] [‘<:’ Type] | INT                            TypeBoundsTree(lo, hi)
 TypeParamBounds   ::=  TypeBounds {‘<%’ Type} {‘:’ Type}                        ContextBounds(typeBounds, tps)
 ```
@@ -299,12 +299,12 @@ ImportSelector    ::=  id [‘=>’ id | ‘=>’ ‘_’]
 
 ### Declarations and Definitions
 ```ebnf
-Dcl               ::=  ‘val’ ValDcl
-                    |  ‘var’ VarDcl
+RefineDcl         ::=  ‘val’ VarDcl
                     |  ‘def’ DefDcl
                     |  ‘type’ {nl} TypeDcl
                     |  INT
-
+Dcl               ::=  RefineDcl
+                    |  ‘var’ VarDcl
 ValDcl            ::=  ids ‘:’ Type                                             PatDef(_, ids, tpe, EmptyTree)
 VarDcl            ::=  ids ‘:’ Type                                             PatDef(_, ids, tpe, EmptyTree)
 DefDcl            ::=  DefSig [‘:’ Type]                                        DefDef(_, name, tparams, vparamss, tpe, EmptyTree)

tests/neg/illegal-refinements.scala

@@ -0,0 +1,7 @@
+trait x0 {
+
+  type T = String { val x: Int = 1 }   // error: illegal refinement
+  type U = String { def x(): Int = 1 } // error: illegal refinement
+  type V = String { var x: Int }       // error: illegal refinement
+
+}

tests/neg/parser-stability-5.scala

@@ -0,0 +1,3 @@
+trait x0 {
+x1 : {   // error
+var x2   // error // error

tests/neg/structural.scala

@@ -3,7 +3,7 @@ object Test3 {
   def g(x: { type T ; def t: T ; def f(a: T): Boolean }) = x.f(x.t) // error: no ClassTag for x.T
   g(new { type T = Int; def t = 4; def f(a:T) = true })
   g(new { type T = Any; def t = 4; def f(a:T) = true })
-  val y: { type T = Int; def t = 4; def f(a:T) = true }
+  val y: { type T = Int; def t = 4; def f(a:T) = true }  // error: illegal refinement // error: illegal refinement
     = new { type T = Int; def t = 4; def f(a:T) = true }
 
   def h(x: { def f[T](a: T): Int }) = x.f[Int](4) // error: polymorphic refinement method ... no longer allowed