anchor.diff:      ;
       
   block
  -    : '{' declarationOrStatement* directiveStatement? '}'
  -    -> ^(BLOCK declarationOrStatement* directiveStatement?)
  -    ;
  -
  -/*inlineClassDeclaration
  -    : 'new' 
  -      annotations?
  -      type
  -      positionalArguments?
  -      satisfiedTypes?
  -      inlineClassBody
  -    ;
  -
  -inlineClassBody
  -    : '{' declarationOrStatement* '}'
  -    ;*/
  -
  -declarationOrStatement
  -    : (annotatedDeclarationStart) => declaration | statement
  +    : '{' declarationsAndStatements (directiveStatement | expressions)? '}'
  +    -> ^(BLOCK declarationsAndStatements? directiveStatement? expressions?)
  +    ;
  +
  +declarationsAndStatements
  +    : 
  +    (
  +        controlStructure
  +      | (specificationOrExpressionStart) => specificationOrExpressionStatement
  +      | (annotatedDeclarationStart) => declaration
  +    )*
  +    ;
  +
  +//special rule for syntactic predicates
  +specificationOrExpressionStart
  +    : expression (';'|'=')
  +    ;
  +
  +//special rule for syntactic predicates
  +expressionListStart
  +    : expression (','|'}')
  +    ;
  +
  +//special rule for syntactic predicates
  +controlStructureStart 
  +    : 'if' | 'while' | 'do' | 'switch' | 'for' | 'try'
       ;
   
   //TODO: I don't understand why we need to distinguish
  
positive.code:       | typeDeclaration 
        -> ^(TYPE_DECL typeDeclaration annotations?)
      )
  /*    (((memberHeader memberParameters) => 
              (mem=memberDeclaration 
                  -> ^(METHOD_DECL $mem $ann?)))
      | (mem=memberDeclaration 
              -> ^(MEMBER_DECL $mem $ann?))
      | (typ=typeDeclaration 
              -> ^(TYPE_DECL $typ $ann?))
      | (inst=instance
              -> ^(INSTANCE $inst $ann?)))*/
      ;
  
  //special rule for syntactic predicates
  
negative.code:     | 'interface' 
      | 'class' 
      | 'object'
      ;
  
  //Note that this rule is way too permissive,
  