All unit tests pass without G variable, most file tests pass

3 files changed, 293 insertions, 271 deletions

diff --git a/scalaParser/src/main/scala/scalaParser/ScalaSyntax.scala b/scalaParser/src/main/scala/scalaParser/ScalaSyntax.scala
index 60b504b..dcfcd09 100644
--- a/scalaParser/src/main/scala/scalaParser/ScalaSyntax.scala
+++ b/scalaParser/src/main/scala/scalaParser/ScalaSyntax.scala
@@ -41,20 +41,13 @@ class ScalaSyntax(val input: ParserInput) extends Parser with Basic with Identif
   def WL = rule{ zeroOrMore(Basic.WhitespaceChar | Literals.Comment | Basic.Newline) }
 
 
-  /**
-   * Whitespace which captures or doesn't-capture
-   * newlines depending on the G that gets passed in
-   */
-  def W(G: B = t) =
-    if (G) WL
-    else WS
 
   /**
    * By default, all strings and characters greedily
    * capture all whitespace immediately after the token.
    */
-  implicit private[this] def wspStr(s: String): R0 = rule { str(s) ~ WL }
-  implicit private[this] def wspChar(s: Char): R0 = rule { ch(s) ~ WL }
+  implicit private[this] def wspStr(s: String): R0 = rule { WL ~ str(s)  }
+  implicit private[this] def wspChar(s: Char): R0 = rule { WL ~ ch(s) }
 
   /**
    * Most keywords don't just require the correct characters to match,
@@ -64,20 +57,14 @@ class ScalaSyntax(val input: ParserInput) extends Parser with Basic with Identif
    */
   object K {
     def W(s: String) = rule {
-      Key.W(s) ~ WL
+      WL ~ Key.W(s)
     }
 
     def O(s: String) = rule {
-      Key.O(s) ~ WL
+      WL ~ Key.O(s)
     }
   }
-  
-  /**
-   * Occasionally, you want to decide whether or not to
-   * capture newlines based on the context, so use this
-   * and pass in G manually.
-   */
-  def StrW(s: String, G: B): R0 = rule { str(s) ~ W(G) }
+
 
   def pos = cursor -> cursorChar
 
@@ -86,327 +73,338 @@ class ScalaSyntax(val input: ParserInput) extends Parser with Basic with Identif
    */
   def pr(s: String) = rule { run(println(s"LOGGING $cursor: $s")) }
 
-  def Id(G: B = t) = rule { Identifiers.Id ~ W(G) }
-  def VarId(G: B = t) = rule { Identifiers.VarId ~ W(G) }
-  def Literal(G: B = t) = rule { Literals.Literal ~ W(G) }
-  def Semi = rule { Basic.Semi ~ WL }
-  def Newline = rule { Basic.Newline ~ WL }
+  def Id = rule { WL ~ Identifiers.Id }
+  def VarId = rule { WL ~ Identifiers.VarId }
+  def Literal = rule { WL ~ Literals.Literal }
+  def Semi = rule { WS ~ Basic.Semi }
+  def Semis = rule { oneOrMore(Semi) }
+  def Newline = rule { WL ~ Basic.Newline }
 
-  def QualId(G: B = t) = rule { oneOrMore(Id(false)) separatedBy '.' ~ W(G) }
-  def Ids = rule { oneOrMore(Id()) separatedBy ',' }
+  def QualId = rule { WL ~ oneOrMore(Id).separatedBy('.') }
+  def Ids = rule { oneOrMore(Id) separatedBy ',' }
 
-  def Path(G: B = t): R0 = rule {
-    zeroOrMore(Id(G) ~ '.') ~ K.W("this") ~ zeroOrMore(Id(G)).separatedBy('.') |
-    StableId(G)
+  def Path: R0 = rule {
+    zeroOrMore(Id ~ '.') ~ K.W("this") ~ zeroOrMore(Id).separatedBy('.') |
+      StableId
   }
-  def StableId(G: B = t): R0 = rule {
-    zeroOrMore(Id() ~ '.') ~ (K.W("this") | K.W("super") ~ optional(ClassQualifier)) ~ '.' ~ oneOrMore(Id(G)).separatedBy('.') |
-    Id(false) ~ zeroOrMore(WL ~ '.' ~ WL ~ Id(false)) ~ W(G)
+  def StableId: R0 = rule {
+    zeroOrMore(Id ~ '.') ~ (K.W("this") | K.W("super") ~ optional(ClassQualifier)) ~ '.' ~ oneOrMore(Id).separatedBy('.') |
+      Id ~ zeroOrMore(WL ~ '.' ~ WL ~ Id)
   }
 
-  def ClassQualifier = rule { '[' ~ Id() ~ ']' }
+  def ClassQualifier = rule { '[' ~ Id ~ ']' }
 
-  def Type(G: B = t): R0 = rule {
-    FunctionArgTypes ~ K.O("=>") ~ Type(G) | InfixType(false) ~ optional(WL ~ ExistentialClause) ~ W(G)
+  def Type: R0 = rule {
+    FunctionArgTypes ~ K.O("=>") ~ Type | InfixType ~ optional(WL ~ ExistentialClause)
   }
   def FunctionArgTypes = rule {
-    InfixType() | '(' ~ optional(oneOrMore(ParamType) separatedBy ',') ~ ')'
+    InfixType | '(' ~ optional(oneOrMore(ParamType) separatedBy ',') ~ ')'
   }
 
-  def ExistentialClause = rule { "forSome" ~ '{' ~ oneOrMore(ExistentialDcl(false)).separatedBy(Semi) }
-  def ExistentialDcl(G: B = t) = rule { K.W("type") ~ TypeDcl(G) | K.W("val") ~ ValDcl(G) }
+  def ExistentialClause = rule { "forSome" ~ '{' ~ oneOrMore(ExistentialDcl).separatedBy(Semi) }
+  def ExistentialDcl = rule { K.W("type") ~ TypeDcl | K.W("val") ~ ValDcl }
 
-  def InfixType(G: B = t) = rule {
-    CompoundType(false) ~ zeroOrMore(WL ~ Id() ~ optional(Newline) ~ CompoundType(false)) ~ W(G)
+  def InfixType = rule {
+    CompoundType ~ zeroOrMore(WL ~ Id ~ optional(Newline) ~ CompoundType)
   }
-  def CompoundType(G: B = t) = rule {
-    oneOrMore(AnnotType(false)).separatedBy(WL ~ K.W("with")) ~ optional(Refinement(false)) ~ W(G)
+  def CompoundType = rule {
+    oneOrMore(AnnotType).separatedBy(WL ~ K.W("with")) ~ optional(Refinement)
   }
-  def AnnotType(G: B = t) = rule {
-    SimpleType(false) ~ zeroOrMore(WL ~ Annotation(false)) ~ W(G)
+  def AnnotType = rule {
+    SimpleType ~ zeroOrMore(WL ~ Annotation)
   }
-  def SimpleType(G: B = t): R0 = rule {
-    BasicType(false) ~
-    optional(WL ~ '#' ~ Id(false)) ~
-    optional(WL ~ TypeArgs(false)) ~
-    W(G)
+  def SimpleType: R0 = rule {
+    BasicType ~
+      optional(WL ~ '#' ~ Id) ~
+      optional(WL ~ TypeArgs)
   }
-  def BasicType(G: B = t): R0 = rule {
+  def BasicType: R0 = rule {
     '(' ~ Types ~ ')' |
-    Path() ~ '.' ~ K.W("type") |
-    StableId(G)
-  }
-  def TypeArgs(G: B = t) = rule { '[' ~ Types ~ StrW("]", G) }
-  def Types = rule { oneOrMore(Type()).separatedBy(',') }
-  def Refinement(G: B = t) = rule {
-    optional(Newline) ~ '{' ~ oneOrMore(RefineStat).separatedBy(Semi) ~ StrW("}", G)
-  }
-  def RefineStat = rule { "type" ~ TypeDef(false) | Dcl(false) | MATCH }
-  def TypePat = rule { CompoundType() }
-  def Ascription(G: B = t) = rule {
-    ":" ~ ("_" ~ StrW("*", G) | InfixType(G) | oneOrMore(Annotation(G)))
-  }
-
-  def ParamType = rule { K.O("=>") ~ Type() | Type() ~ "*" | Type() }
-
-  def Expr(G: B = t): R0 = rule { (Bindings | optional(K.W("implicit")) ~ Id() | "_") ~ K.O("=>") ~ Expr(G) | Expr1(G) }
-  def Expr1(G: B = t): R0 = rule {
-    IfCFlow(G) |
-    WhileCFlow(G) |
-    TryCFlow(G) |
-    DoWhileCFlow(G) |
-    ForCFlow(G) |
-    K.W("throw") ~ Expr(G) |
-    K.W("return") ~ optional(Expr(G)) |
-    SimpleExpr() ~ K.O("=") ~ Expr(G) |
-    PostfixExpr(false) ~ optional("match" ~ '{' ~ CaseClauses ~ StrW("}", false) | Ascription(false)) ~ W(G)
-  }
-  def IfCFlow(G: B = t) = rule { "if" ~ '(' ~ Expr() ~ ')' ~ zeroOrMore(Newline) ~ Expr(G) ~ optional(optional(Semi) ~ K.W("else") ~ Expr(G)) }
-  def WhileCFlow(G: B = t) = rule { "while" ~ '(' ~ Expr() ~ ')' ~ zeroOrMore(Newline) ~ Expr(G) }
-  def TryCFlow(G: B = t) = rule {
-    K.W("try") ~ Expr(false) ~
-    optional(WL ~ K.W("catch") ~ Expr(false)) ~
-    optional(WL ~ K.W("finally") ~ Expr(false)) ~
-    W(G)
-  }
-
-  def DoWhileCFlow(G: B = t) = rule { K.W("do") ~ Expr() ~ optional(Semi) ~ "while" ~ '(' ~ Expr() ~ StrW(")", G) }
-  def ForCFlow(G: B = t) = rule {
+      Path ~ '.' ~ K.W("type") |
+      StableId
+  }
+  def TypeArgs = rule { '[' ~ Types ~ "]" }
+  def Types = rule { oneOrMore(Type).separatedBy(',') }
+  def Refinement = rule {
+    optional(Newline) ~ '{' ~ oneOrMore(RefineStat).separatedBy(Semi) ~ "}"
+  }
+  def RefineStat = rule { "type" ~ TypeDef | Dcl | MATCH }
+  def TypePat = rule { CompoundType }
+  def Ascription = rule {
+    ":" ~ ("_" ~ "*" | InfixType | oneOrMore(Annotation))
+  }
+
+  def ParamType = rule { K.O("=>") ~ Type | Type ~ "*" | Type }
+
+  def Expr: R0 = rule { (Bindings | optional(K.W("implicit")) ~ Id | "_") ~ K.O("=>") ~ Expr | Expr1 }
+  def Expr1: R0 = rule {
+    IfCFlow |
+    WhileCFlow |
+    TryCFlow |
+    DoWhileCFlow |
+    ForCFlow |
+    K.W("throw") ~ Expr |
+    K.W("return") ~ optional(Expr) |
+    SimpleExpr ~ K.O("=") ~ Expr |
+    PostfixExpr ~ optional("match" ~ '{' ~ CaseClauses ~ "}" | Ascription)
+
+  }
+  def IfCFlow = rule { "if" ~ '(' ~ Expr ~ ')' ~ zeroOrMore(Newline) ~ Expr ~ optional(optional(Semi) ~ K.W("else") ~ Expr) }
+  def WhileCFlow = rule { "while" ~ '(' ~ Expr ~ ')' ~ zeroOrMore(Newline) ~ Expr }
+  def TryCFlow = rule {
+    K.W("try") ~ Expr ~
+      optional(WL ~ K.W("catch") ~ Expr) ~
+      optional(WL ~ K.W("finally") ~ Expr)
+  }
+
+  def DoWhileCFlow = rule { K.W("do") ~ Expr ~ optional(Semi) ~ "while" ~ '(' ~ Expr ~ ")" }
+  def ForCFlow = rule {
     "for" ~
-    ('(' ~ Enumerators ~ ')' | '{' ~ Enumerators ~ '}') ~
-    zeroOrMore(Newline) ~
-    optional(K.W("yield")) ~
-    Expr(G) }
-  def PostfixExpr(G: B = t): R0 = rule { InfixExpr(G) ~ optional(Id() ~ optional(Newline)) }
-  def InfixExpr(G: B = t): R0 = rule { PrefixExpr(G) ~ zeroOrMore(Id() ~ optional(Newline) ~ PrefixExpr(G)) }
-  def PrefixExpr(G: B = t) = rule { optional(anyOf("-+~!")) ~ SimpleExpr(G) }
-
-  def SimpleExpr(G: B = t): R0 = rule {
-    SimpleExpr1(false) ~
-    zeroOrMore(WL ~ ('.' ~ Id(false) | TypeArgs(false) | ArgumentExprs(false))) ~
-    optional(WL ~ StrW("_", false)) ~
-    W(G)
-  }
-
-  def SimpleExpr1(G: B = t) = rule{
-    K.W("new") ~ (ClassTemplate(G) | TemplateBody(G)) |
-    BlockExpr(G) |
-    Literal(G) ~ drop[String] |
-    Path(G) |
-    K.W("_") |
-    '(' ~ optional(Exprs) ~ StrW(")", G)
+      ('(' ~ Enumerators ~ ')' | '{' ~ Enumerators ~ '}') ~
+      zeroOrMore(Newline) ~
+      optional(K.W("yield")) ~
+      Expr }
+  def NotNewline: R0 = rule{ &( WS ~ noneOf("\n") )}
+  def PostfixExpr: R0 = rule { InfixExpr ~ optional(NotNewline ~ Id ~ optional(Newline)) }
+  def InfixExpr: R0 = rule {
+    PrefixExpr ~
+    zeroOrMore(
+      NotNewline ~
+      Id ~
+      optional(Newline) ~
+      PrefixExpr
+    )
   }
+  def PrefixExpr = rule { optional(WL ~ anyOf("-+~!")) ~ SimpleExpr }
 
+  def SimpleExpr: R0 = rule {
+    SimpleExpr1 ~
+      zeroOrMore(WL ~ ('.' ~ Id | TypeArgs | ArgumentExprs)) ~
+      optional(WL ~ "_")
+  }
 
+  def SimpleExpr1 = rule{
+    K.W("new") ~ (ClassTemplate | TemplateBody) |
+      BlockExpr |
+      Literal ~ drop[String] |
+      Path |
+      K.W("_") |
+      '(' ~ optional(Exprs) ~ ")"
+  }
 
-  def Exprs: R0 = rule { oneOrMore(Expr()).separatedBy(',') }
-  def ArgumentExprs(G: B = t): R0 = rule {
-    '(' ~ optional(Exprs ~ optional(K.O(":") ~ K.W("_") ~ '*')) ~ StrW(")", G) |
-    optional(Newline) ~ BlockExpr(G)
+
+
+  def Exprs: R0 = rule { oneOrMore(Expr).separatedBy(',') }
+  def ArgumentExprs: R0 = rule {
+    '(' ~ optional(Exprs ~ optional(K.O(":") ~ K.W("_") ~ '*')) ~ ")" |
+      optional(Newline) ~ BlockExpr
   }
 
-  def BlockExpr(G: B = t): R0 = rule { '{' ~ (CaseClauses | Block) ~ StrW("}", G) }
+  def BlockExpr: R0 = rule { '{' ~ (CaseClauses | Block) ~ "}" }
   def Block: R0 = rule {
-    zeroOrMore(BlockStat ~ Semi) ~ optional(ResultExpr())
+     optional(Semis) ~
+     (
+       BlockStats ~ Semis ~ ResultExpr |
+       BlockStats |
+       ResultExpr |
+       MATCH
+     ) ~
+     optional(Semis)
+  }
+  def BlockStats: R0 = rule{
+    oneOrMore(BlockStat).separatedBy(Semis)
   }
-
   def BlockStat: R0 = rule {
-    Semi |
-    Import(false) |
-    zeroOrMore(Annotation(false)) ~ (optional(K.W("implicit") | K.W("lazy")) ~ Def(false) | zeroOrMore(LocalModifier) ~ TmplDef(false)) |
-    Expr1(false)
-  }
-  def ResultExpr(G: B = t): R0 = rule { (Bindings | optional(K.W("implicit")) ~ Id() | "_") ~ K.W("=>") ~ Block | Expr1(t) }
-  def Enumerators: R0 = rule { Generator(false) ~ zeroOrMore(Semi ~ Enumerator(false)) ~ WL }
-  def Enumerator(G: B = t): R0 = rule { Generator(G) | Guard(G) | Pattern1 ~ K.O("=") ~ Expr(G) }
-  def Generator(G: B = t): R0 = rule { Pattern1 ~ K.O("<-") ~ Expr(false) ~ optional(WL ~ Guard(false)) ~ W(G) }
+    Import |
+    zeroOrMore(Annotation) ~ (optional(K.W("implicit") | K.W("lazy")) ~ Def | zeroOrMore(LocalModifier) ~ TmplDef) |
+    Expr1
+  }
+  def ResultExpr: R0 = rule { (Bindings | optional(K.W("implicit")) ~ Id | "_") ~ K.W("=>") ~ Block | Expr1 }
+  def Enumerators: R0 = rule { Generator ~ zeroOrMore(Semi ~ Enumerator) ~ WL }
+  def Enumerator: R0 = rule { Generator | Guard | Pattern1 ~ K.O("=") ~ Expr }
+  def Generator: R0 = rule { Pattern1 ~ K.O("<-") ~ Expr ~ optional(WL ~ Guard)  }
   def CaseClauses: R0 = rule { oneOrMore(CaseClause) }
-  def CaseClause: R0 = rule { K.W("case") ~ Pattern ~ optional(Guard(true)) ~ K.O("=>") ~ Block }
-  def Guard(G: B = t): R0 = rule { K.W("if") ~ PostfixExpr(G) }
+  def CaseClause: R0 = rule { K.W("case") ~ Pattern ~ optional(Guard) ~ K.O("=>") ~ Block }
+  def Guard: R0 = rule { K.W("if") ~ PostfixExpr }
   def Pattern: R0 = rule {
     oneOrMore(Pattern1).separatedBy('|')
   }
   def Pattern1: R0 = rule {
-    K.W("_") ~ K.O(":") ~ TypePat | VarId() ~ K.O(":") ~ TypePat | Pattern2
+    K.W("_") ~ K.O(":") ~ TypePat | VarId ~ K.O(":") ~ TypePat | Pattern2
   }
   def Pattern2: R0 = rule {
-    VarId() ~ "@" ~ Pattern3 | Pattern3 | VarId()
+    VarId ~ "@" ~ Pattern3 | Pattern3 | VarId
   }
   def Pattern3: R0 = rule {
-    SimplePattern ~ zeroOrMore(Id() ~ SimplePattern)
+    SimplePattern ~ zeroOrMore(Id ~ SimplePattern)
   }
   def SimplePattern: R0 = rule {
     K.W("_") |
-    Literal() ~ drop[String] |
-    '(' ~ optional(Patterns) ~ ')' |
-    (
-      StableId() ~
-      optional(
-        '(' ~
-        (optional(Patterns ~ ',') ~ optional(VarId() ~ '@') ~ K.W("_") ~ '*' | optional(Patterns)) ~
-        ')'
-      )
-    ) |
-    VarId()
+      Literal ~ drop[String] |
+      '(' ~ optional(Patterns) ~ ')' |
+      (
+        StableId ~
+          optional(
+            '(' ~
+              (optional(Patterns ~ ',') ~ optional(VarId ~ '@') ~ K.W("_") ~ '*' | optional(Patterns)) ~
+              ')'
+          )
+        ) |
+      VarId
   }
   def Patterns: R0 = rule { K.W("_") ~ '*' | oneOrMore(Pattern).separatedBy(',') }
 
   def TypeParamClause: R0 = rule { '[' ~ oneOrMore(VariantTypeParam).separatedBy(',') ~ ']' }
   def FunTypeParamClause: R0 = rule { '[' ~ oneOrMore(TypeParam).separatedBy(',') ~ ']' }
-  def VariantTypeParam: R0 = rule { zeroOrMore(Annotation()) ~ optional(anyOf("+-")) ~ TypeParam }
+  def VariantTypeParam: R0 = rule { zeroOrMore(Annotation) ~ optional(anyOf("+-")) ~ TypeParam }
   def TypeParam: R0 = rule {
-    (Id() | K.W("_")) ~
-    optional(TypeParamClause) ~
-    optional(K.O(">:") ~ Type()) ~
-    optional(K.O("<:") ~ Type()) ~
-    zeroOrMore(K.O("<%") ~ Type()) ~
-    zeroOrMore(K.O(":") ~ Type())
+    (Id | K.W("_")) ~
+      optional(TypeParamClause) ~
+      optional(K.O(">:") ~ Type) ~
+      optional(K.O("<:") ~ Type) ~
+      zeroOrMore(K.O("<%") ~ Type) ~
+      zeroOrMore(K.O(":") ~ Type)
   }
   def ParamClauses: R0 = rule { zeroOrMore(ParamClause) ~ optional(optional(Newline) ~ '(' ~ K.W("implicit") ~ Params ~ ')') }
   def ParamClause: R0 = rule { optional(Newline) ~ '(' ~ optional(Params) ~ ')' }
   def Params: R0 = rule { zeroOrMore(Param).separatedBy(',') }
-  def Param: R0 = rule { zeroOrMore(Annotation()) ~ Id() ~ optional(K.O(":") ~ ParamType) ~ optional(K.O("=") ~ Expr()) }
-  def ClassParamClauses(G: B = t): R0 = rule { zeroOrMore(ClassParamClause(G)) ~ optional(optional(Newline) ~ '(' ~ K.W("implicit") ~ ClassParam ~ StrW(")", G)) }
-  def ClassParamClause(G: B = t): R0 = rule { optional(Newline) ~ '(' ~ optional(ClassParams) ~ StrW(")", G) }
+  def Param: R0 = rule { zeroOrMore(Annotation) ~ Id ~ optional(K.O(":") ~ ParamType) ~ optional(K.O("=") ~ Expr) }
+  def ClassParamClauses: R0 = rule { zeroOrMore(ClassParamClause) ~ optional(optional(Newline) ~ '(' ~ K.W("implicit") ~ ClassParam ~ ")") }
+  def ClassParamClause: R0 = rule { optional(Newline) ~ '(' ~ optional(ClassParams) ~ ")" }
   def ClassParams: R0 = rule { oneOrMore(ClassParam).separatedBy(',') }
-  def ClassParam: R0 = rule { zeroOrMore(Annotation()) ~ optional(zeroOrMore(Modifier) ~ (K.W("val") | K.W("var"))) ~ Id() ~ K.O(":") ~ ParamType ~ optional(K.O("=") ~ Expr()) }
+  def ClassParam: R0 = rule { zeroOrMore(Annotation) ~ optional(zeroOrMore(Modifier) ~ (K.W("val") | K.W("var"))) ~ Id ~ K.O(":") ~ ParamType ~ optional(K.O("=") ~ Expr) }
 
   def Bindings: R0 = rule { '(' ~ oneOrMore(Binding).separatedBy(',') ~ ')' }
-  def Binding: R0 = rule { (Id() | K.W("_")) ~ optional(K.O(":") ~ Type()) }
+  def Binding: R0 = rule { (Id | K.W("_")) ~ optional(K.O(":") ~ Type) }
 
   def Modifier: R0 = rule { LocalModifier | AccessModifier | K.W("override") }
   def LocalModifier: R0 = rule { K.W("abstract") | K.W("final") | K.W("sealed") | K.W("implicit") | K.W("lazy") }
   def AccessModifier: R0 = rule { (K.W("private") | K.W("protected")) ~ optional(AccessQualifier) }
-  def AccessQualifier: R0 = rule { '[' ~ (K.W("this") | Id()) ~ ']' }
+  def AccessQualifier: R0 = rule { '[' ~ (K.W("this") | Id) ~ ']' }
 
-  def Annotation(G: B = t): R0 = rule { '@' ~ SimpleType(false) ~ zeroOrMore(WL ~ ArgumentExprs(false)) ~ W(G) }
-  def ConstrAnnotation: R0 = rule { '@' ~ SimpleType() ~ ArgumentExprs() }
+  def Annotation: R0 = rule { '@' ~ SimpleType ~ zeroOrMore(WL ~ ArgumentExprs) }
+  def ConstrAnnotation: R0 = rule { '@' ~ SimpleType ~ ArgumentExprs }
 
-  def TemplateBody(G: B = t): R0 = rule {
-    WL ~
+  def TemplateBody: R0 = rule {
     '{' ~
     optional(SelfType) ~
-    TemplateStat ~
-    zeroOrMore(Semi ~ TemplateStat) ~
-    WL ~
-    StrW("}", G)
+    zeroOrMore(TemplateStat).separatedBy(Semis) ~
+    '}'
   }
   def TemplateStat: R0 = rule {
-    Import(false) |
-    zeroOrMore(Annotation() ~ optional(Newline)) ~ zeroOrMore(Modifier) ~ (Def(false) | Dcl(false)) |
-    Expr(false) |
-    MATCH
-  }
-
-  def SelfType: R0 = rule { K.W("this") ~ K.O(":") ~ Type() ~ K.O("=>") | Id() ~ optional(K.O(":") ~ Type()) ~ K.O("=>") }
-
-  def Import(G: B = t): R0 = rule { K.W("import") ~ oneOrMore(ImportExpr(G)).separatedBy(',') }
-
-  def ImportExpr(G: B = t): R0 = rule { StableId(G) ~ optional('.' ~ (StrW("_", G) | ImportSelectors(G))) }
-  def ImportSelectors(G: B = t): R0 = rule { '{' ~ zeroOrMore(ImportSelector ~ ',') ~ (ImportSelector | K.W("_")) ~ StrW("}", G) }
-  def ImportSelector: R0 = rule { Id() ~ optional(K.O("=>") ~ (Id() | K.W("_"))) }
-
-  def Dcl(G: B = t): R0 = rule {
-    K.W("val") ~ ValDcl(G) |
-    K.W("var") ~ VarDcl(G) |
-    K.W("def") ~ FunDcl(G) |
-    K.W("type") ~ zeroOrMore(Newline) ~ TypeDcl(G)
-  }
-  def ValDcl(G: B = t): R0 = rule { Ids ~ K.O(":") ~ Type(G) }
-  def VarDcl(G: B = t): R0 = rule { Ids ~ K.O(":") ~ Type(G) }
-  def FunDcl(G: B = t): R0 = rule { FunSig(false) ~ optional(WL ~ K.O(":") ~ Type(G)) }
-  def FunSig(G: B = t): R0 = rule { Id() ~ optional(FunTypeParamClause) ~ ParamClauses }
-  def TypeDcl(G: B = t): R0 = rule {
-    Id(false) ~
-    optional(WL ~ TypeParamClause) ~
-    optional(WL ~ K.O(">:") ~ Type(false)) ~
-    optional(WL ~ K.O("<:") ~ Type(false)) ~
-    W(G)
-  }
-
-  def PatVarDef(G: B = t): R0 = rule { K.W("val") ~ PatDef(G) | K.W("var") ~ VarDef(G) }
-  def Def(G: B = t): R0 = rule { K.W("def") ~ FunDef(G) | K.W("type") ~ zeroOrMore(Newline) ~ TypeDef(G) | PatVarDef(G) | TmplDef(G) }
-  def PatDef(G: B = t): R0 = rule { oneOrMore(Pattern2).separatedBy(',') ~ optional(K.O(":") ~ Type()) ~ K.O("=") ~ Expr(G) }
-  def VarDef(G: B = t): R0 = rule { Ids ~ K.O(":") ~ Type() ~ K.O("=") ~ K.W("_") | PatDef(G) }
-  def FunDef(G: B = t): R0 = rule {
-    K.W("this") ~ ParamClause ~ ParamClauses ~ (K.O("=") ~ ConstrExpr | optional(Newline) ~ ConstrBlock) |
-    FunSig() ~
-    (
-      optional(K.O(":") ~ Type()) ~ K.O("=") ~ optional(K.W("macro")) ~ Expr(G) |
-      optional(Newline) ~ '{' ~ Block ~ StrW("}", G)
-    )
+    Import |
+    zeroOrMore(Annotation ~ optional(Newline)) ~ zeroOrMore(Modifier) ~ (Def | Dcl) |
+    Expr
   }
-  def TypeDef(G: B = t): R0 = rule { Id() ~ optional(TypeParamClause) ~ K.O("=") ~ Type(G) }
 
-  def TmplDef(G: B = t): R0 = rule {
-    K.W("trait") ~ TraitDef(G) |
-    optional(K.W("case")) ~ (K.W("class") ~ ClassDef(G) |
-    K.W("object") ~ ObjectDef(G))
+  def SelfType: R0 = rule { K.W("this") ~ K.O(":") ~ Type ~ K.O("=>") | Id ~ optional(K.O(":") ~ Type) ~ K.O("=>") }
+
+  def Import: R0 = rule { K.W("import") ~ oneOrMore(ImportExpr).separatedBy(',') }
+
+  def ImportExpr: R0 = rule {
+    StableId ~ optional('.' ~ ("_" | ImportSelectors))
   }
-  def ClassDef(G: B = t): R0 = rule {
-    Id() ~
-    optional(TypeParamClause) ~
-    zeroOrMore(ConstrAnnotation) ~
-    optional(AccessModifier) ~
-    ClassParamClauses(false) ~
-    ClassTemplateOpt(false) ~
-    W(G)
+  def ImportSelectors: R0 = rule { '{' ~ zeroOrMore(ImportSelector ~ ',') ~ (ImportSelector | K.W("_")) ~ "}" }
+  def ImportSelector: R0 = rule { Id ~ optional(K.O("=>") ~ (Id | K.W("_"))) }
 
+  def Dcl: R0 = rule {
+    K.W("val") ~ ValDcl |
+      K.W("var") ~ VarDcl |
+      K.W("def") ~ FunDcl |
+      K.W("type") ~ zeroOrMore(Newline) ~ TypeDcl
   }
-  def TraitDef(G: B = t): R0 = rule { Id() ~ optional(TypeParamClause) ~ TraitTemplateOpt(G) }
-  def ObjectDef(G: B = t): R0 = rule { Id() ~ ClassTemplateOpt(G) }
-  def ClassTemplateOpt(G: B = t): R0 = rule {
-    WL ~ K.W("extends") ~ ClassTemplate(G) |
-    optional(WL ~ optional(K.W("extends")) ~ TemplateBody(G))
+  def ValDcl: R0 = rule { Ids ~ K.O(":") ~ Type }
+  def VarDcl: R0 = rule { Ids ~ K.O(":") ~ Type }
+  def FunDcl: R0 = rule { FunSig ~ optional(WL ~ K.O(":") ~ Type) }
+  def FunSig: R0 = rule { Id ~ optional(FunTypeParamClause) ~ ParamClauses }
+  def TypeDcl: R0 = rule {
+    Id ~
+      optional(WL ~ TypeParamClause) ~
+      optional(WL ~ K.O(">:") ~ Type) ~
+      optional(WL ~ K.O("<:") ~ Type)
   }
-  def TraitTemplateOpt(G: B = t): R0 = rule { K.W("extends") ~ TraitTemplate(G) | optional(optional(K.W("extends")) ~ TemplateBody(G)) }
-  def ClassTemplate(G: B = t): R0 = rule {
+
+  def PatVarDef: R0 = rule { K.W("val") ~ PatDef | K.W("var") ~ VarDef }
+  def Def: R0 = rule { K.W("def") ~ FunDef | K.W("type") ~ zeroOrMore(Newline) ~ TypeDef | PatVarDef | TmplDef }
+  def PatDef: R0 = rule { oneOrMore(Pattern2).separatedBy(',') ~ optional(K.O(":") ~ Type) ~ K.O("=") ~ Expr }
+  def VarDef: R0 = rule { Ids ~ K.O(":") ~ Type ~ K.O("=") ~ K.W("_") | PatDef }
+  def FunDef: R0 = rule {
+    K.W("this") ~ ParamClause ~ ParamClauses ~ (K.O("=") ~ ConstrExpr | optional(Newline) ~ ConstrBlock) |
+      FunSig ~
+        (
+          optional(K.O(":") ~ Type) ~ K.O("=") ~ optional(K.W("macro")) ~ Expr |
+            optional(Newline) ~ '{' ~ Block ~ "}"
+          )
+  }
+  def TypeDef: R0 = rule { Id ~ optional(TypeParamClause) ~ K.O("=") ~ Type }
+
+  def TmplDef: R0 = rule {
+    K.W("trait") ~ TraitDef |
+      optional(K.W("case")) ~ (K.W("class") ~ ClassDef |
+        K.W("object") ~ ObjectDef)
+  }
+  def ClassDef: R0 = rule {
+    Id ~
+      optional(TypeParamClause) ~
+      zeroOrMore(ConstrAnnotation) ~
+      optional(AccessModifier) ~
+      ClassParamClauses ~
+      ClassTemplateOpt
+  }
+  def TraitDef: R0 = rule { Id ~ optional(TypeParamClause) ~ TraitTemplateOpt }
+  def ObjectDef: R0 = rule { Id ~ ClassTemplateOpt }
+  def ClassTemplateOpt: R0 = rule {
+    WL ~ K.W("extends") ~ ClassTemplate |
+      optional(WL ~ optional(K.W("extends")) ~ TemplateBody)
+  }
+  def TraitTemplateOpt: R0 = rule { K.W("extends") ~ TraitTemplate | optional(optional(K.W("extends")) ~ TemplateBody) }
+  def ClassTemplate: R0 = rule {
     optional(EarlyDefs) ~
-    ClassParents(false) ~
-    optional(WL ~ TemplateBody(false)) ~
-    W(G)
+      ClassParents ~
+      optional(WL ~ TemplateBody)
   }
 
-  def TraitTemplate(G: B = t): R0 = rule {
-    optional(EarlyDefs) ~ TraitParents(false) ~ optional(TemplateBody(false)) ~ W(G)
+  def TraitTemplate: R0 = rule {
+    optional(EarlyDefs) ~ TraitParents ~ optional(TemplateBody)
   }
-  def ClassParents(G: B = t): R0 = rule {
-    Constr(false) ~ zeroOrMore(WL ~ K.W("with") ~ AnnotType(G)) ~ W(G)
+  def ClassParents: R0 = rule {
+    Constr ~ zeroOrMore(WL ~ K.W("with") ~ AnnotType)
   }
-  def TraitParents(G: B = t): R0 = rule {
-    AnnotType(false) ~ zeroOrMore(WL ~ K.W("with") ~ AnnotType(false)) ~ W(G)
+  def TraitParents: R0 = rule {
+    AnnotType ~ zeroOrMore(WL ~ K.W("with") ~ AnnotType)
   }
-  def Constr(G: B = t): R0 = rule {
-    AnnotType(false) ~ zeroOrMore(WL ~ ArgumentExprs(false)) ~
-    W(G)
+  def Constr: R0 = rule {
+    AnnotType ~ zeroOrMore(WL ~ ArgumentExprs)
   }
   def EarlyDefs: R0 = rule {
-    '{' ~ optional(oneOrMore(EarlyDef).separatedBy(Semi)) ~ '}' ~ K.W("with")
+    '{' ~ optional(oneOrMore(EarlyDef).separatedBy(Semis)) ~ '}' ~ K.W("with")
   }
   def EarlyDef: R0 = rule {
-    zeroOrMore(Annotation() ~ optional(Newline)) ~ zeroOrMore(Modifier) ~ PatVarDef(false)
+    zeroOrMore(Annotation ~ optional(Newline)) ~ zeroOrMore(Modifier) ~ PatVarDef
   }
   def ConstrExpr: R0 = rule { ConstrBlock | SelfInvocation }
-  def ConstrBlock: R0 = rule { '{' ~ SelfInvocation ~ zeroOrMore(Semi ~ BlockStat) ~ '}' }
-  def SelfInvocation: R0 = rule { K.W("this") ~ oneOrMore(ArgumentExprs()) }
+  def ConstrBlock: R0 = rule { '{' ~ SelfInvocation ~ zeroOrMore(Semis ~ BlockStat) ~ '}' }
+  def SelfInvocation: R0 = rule { K.W("this") ~ oneOrMore(ArgumentExprs) }
 
-  def TopStatSeq: R0 = rule { zeroOrMore(TopStat).separatedBy(Semi) }
+  def TopStatSeq: R0 = rule { oneOrMore(TopStat).separatedBy(Semis) }
   def TopStat: R0 = rule {
     Packaging |
-    PackageObject(false) |
-    Import(false) |
-    zeroOrMore(Annotation(false) ~ optional(Newline)) ~ zeroOrMore(Modifier) ~ TmplDef(false) |
-    MATCH
+      PackageObject |
+      Import |
+      zeroOrMore(Annotation ~ optional(Newline)) ~ zeroOrMore(Modifier) ~ TmplDef
+  }
+  def Packaging: R0 = rule { K.W("package") ~ QualId ~ '{' ~ TopStatSeq ~ '}' }
+  def PackageObject: R0 = rule { K.W("package") ~ K.W("object") ~ ObjectDef }
+  def TopPackageSeq: R0 = rule{
+    oneOrMore(K.W("package") ~ QualId).separatedBy(Semis)
   }
-  def Packaging: R0 = rule { K.W("package") ~ QualId() ~ '{' ~ TopStatSeq ~ '}' }
-  def PackageObject(G: B = t): R0 = rule { K.W("package") ~ K.W("object") ~ ObjectDef(G) }
   def CompilationUnit: Rule1[String] = rule {
     capture(
-      WL ~
-      zeroOrMore(Semi) ~
-      zeroOrMore(K.W("package") ~ QualId(false)).separatedBy(Semi) ~
-      TopStatSeq ~
-      EOI
+      pr("CompulationUnit 0") ~
+      optional(Semis) ~
+      pr("CompulationUnit 1") ~
+      (TopPackageSeq ~ Semis ~ TopStatSeq | TopPackageSeq | TopStatSeq) ~
+      WL
     )
   }
 }
diff --git a/scalaParser/src/test/scala/scalaParser/SyntaxTest.scala b/scalaParser/src/test/scala/scalaParser/SyntaxTest.scala
index 99ec182..c747928 100644
--- a/scalaParser/src/test/scala/scalaParser/SyntaxTest.scala
+++ b/scalaParser/src/test/scala/scalaParser/SyntaxTest.scala
@@ -9,6 +9,7 @@ import scala.util.{Failure, Success}
 
 object SyntaxTest extends TestSuite{
   def check[T](input: String) = {
+    println("Checking...")
     new ScalaSyntax(input).CompilationUnit.run() match{
       case Failure(f: ParseError) =>
         println(f.position)
@@ -27,14 +28,16 @@ object SyntaxTest extends TestSuite{
 
       )
       * - check(
-        """
-          |package torimatomeru
+        """package torimatomeru
           |
-          |import org.parboiled2.ParseError
-          |import utest._
-          |import utest.framework.Test
+          |package lols
+        """.stripMargin
+      )
+      * - check(
+        """package torimatomeru
+          |import a
+          |import b
         """.stripMargin
-
       )
       * - check(
         """
@@ -70,16 +73,9 @@ object SyntaxTest extends TestSuite{
       * - check(
         """
           |object SyntaxTest extends TestSuite{
-          |  def check[T](input: String) = {
-          |    new ScalaSyntax(input).CompilationUnit.run() match{
-          |      case Failure(f: ParseError) =>
-          |        println(f.position)
-          |        println(f.formatExpectedAsString)
-          |        println(f.formatTraces)
-          |        throw new Exception(f.position + "\t" + f.formatTraces)
-          |      case Success(parsed) =>
-          |        assert(parsed == input)
-          |    }
+          |  {
+          |        println
+          |        throw 1
           |  }
           |}
         """.stripMargin
@@ -220,6 +216,15 @@ object SyntaxTest extends TestSuite{
         """.stripMargin
       )
       * - check(
+        """
+          |object L{
+          |  a b c
+          |  d = 1
+          |}
+        """.stripMargin
+      )
+
+      * - check(
         """/*                     __                                               *\
           |**     ________ ___   / /  ___      __ ____  Scala.js CLI               **
           |**    / __/ __// _ | / /  / _ | __ / // __/  (c) 2013-2014, LAMP/EPFL   **
@@ -360,11 +365,26 @@ object SyntaxTest extends TestSuite{
           |}
         """.stripMargin
       )
+      * - check(
+        """
+          |trait Basic {
+          |  b match {
+          |    case C => true; case _ => false
+          |  }
+          |}
+        """.stripMargin
+      )
+      * - check(
+        """trait Basic {
+          |  !a.b
+          |}
+        """.stripMargin
+      )
     }
     def checkFile(path: String) = check(io.Source.fromFile(path).mkString)
     'file{
 
-
+      * - checkFile("test.txt")
       * - checkFile("scalaParser/src/main/scala/scalaParser/syntax/Basic.scala")
       * - checkFile("scalaParser/src/main/scala/scalaParser/syntax/Identifiers.scala")
       * - checkFile("scalaParser/src/main/scala/scalaParser/syntax/Literals.scala")
diff --git a/test.txt b/test.txt
new file mode 100644
index 0000000..9e74c80
--- /dev/null
+++ b/test.txt
@@ -0,0 +1,4 @@
+
+trait Basic {
+  s ~ !Basic.OperatorChar
+}