Fix tests

script/generate-example

@@ -5,8 +5,8 @@
 #/ Generate expected output for a test fixture example or directory of examples.
 #/
 #/ Example:
-#/  script/generate-example test/fixtures/ruby/and-or.{A,B}.rb
-#/  script/generate-example test/fixtures/ruby
+#/  script/generate-example test/fixtures/ruby/corpus/and-or.{A,B}.rb
+#/  script/generate-example test/fixtures/ruby/corpus
 
 set -e
 [ $# -eq 0 ] && set -- --help

test/Data/Functor/Listable.hs

@@ -283,26 +283,95 @@ instance Listable1 Directive.File where
 instance Listable1 Directive.Line where
   liftTiers tiers = cons0 Directive.Line
 
-instance Listable1 Expression.Arithmetic where
-  liftTiers tiers = liftCons2 tiers tiers Expression.Plus \/ liftCons2 tiers tiers Expression.Minus \/ liftCons2 tiers tiers Expression.Times \/ liftCons2 tiers tiers Expression.DividedBy \/ liftCons2 tiers tiers Expression.FloorDivision \/ liftCons2 tiers tiers Expression.Modulo \/ liftCons2 tiers tiers Expression.Power \/ liftCons1 tiers Expression.Negate
+instance Listable1 Expression.Plus where
+  liftTiers tiers = liftCons2 tiers tiers Expression.Plus
 
-instance Listable1 Expression.Bitwise where
-  liftTiers tiers = liftCons2 tiers tiers Expression.BOr \/ liftCons2 tiers tiers Expression.BAnd \/ liftCons2 tiers tiers Expression.BXOr \/ liftCons2 tiers tiers Expression.LShift \/ liftCons2 tiers tiers Expression.RShift \/ liftCons2 tiers tiers Expression.UnsignedRShift \/ liftCons1 tiers Expression.Complement
+instance Listable1 Expression.Minus where
+  liftTiers tiers = liftCons2 tiers tiers Expression.Minus
 
-instance Listable1 Expression.BooleanOperator where
-  liftTiers tiers = liftCons2 tiers tiers Expression.Or \/ liftCons2 tiers tiers Expression.And \/ liftCons1 tiers Expression.Not \/ liftCons2 tiers tiers Expression.XOr
+instance Listable1 Expression.Times where
+  liftTiers tiers = liftCons2 tiers tiers Expression.Times
+
+instance Listable1 Expression.DividedBy where
+  liftTiers tiers = liftCons2 tiers tiers Expression.DividedBy
+
+instance Listable1 Expression.FloorDivision where
+  liftTiers tiers = liftCons2 tiers tiers Expression.FloorDivision
+
+instance Listable1 Expression.Modulo where
+  liftTiers tiers = liftCons2 tiers tiers Expression.Modulo
+
+instance Listable1 Expression.Power where
+  liftTiers tiers = liftCons2 tiers tiers Expression.Power
+
+instance Listable1 Expression.Negate where
+  liftTiers tiers = liftCons1 tiers Expression.Negate
+
+instance Listable1 Expression.BOr where
+  liftTiers tiers = liftCons2 tiers tiers Expression.BOr
+
+instance Listable1 Expression.BAnd where
+  liftTiers tiers = liftCons2 tiers tiers Expression.BAnd
+
+instance Listable1 Expression.BXOr where
+  liftTiers tiers = liftCons2 tiers tiers Expression.BXOr
+
+instance Listable1 Expression.LShift where
+  liftTiers tiers = liftCons2 tiers tiers Expression.LShift
+
+instance Listable1 Expression.RShift where
+  liftTiers tiers = liftCons2 tiers tiers Expression.RShift
+
+instance Listable1 Expression.UnsignedRShift where
+  liftTiers tiers = liftCons2 tiers tiers Expression.UnsignedRShift
+
+instance Listable1 Expression.Complement where
+  liftTiers tiers = liftCons1 tiers Expression.Complement
+
+instance Listable1 Expression.Or where
+  liftTiers tiers = liftCons2 tiers tiers Expression.Or
+
+instance Listable1 Expression.And where
+  liftTiers tiers = liftCons2 tiers tiers Expression.And
+
+instance Listable1 Expression.Not where
+  liftTiers tiers = liftCons1 tiers Expression.Not
+
+instance Listable1 Expression.XOr where
+  liftTiers tiers = liftCons2 tiers tiers Expression.XOr
 
 instance Listable1 Expression.Call where
   liftTiers tiers = liftCons4 (liftTiers tiers) tiers (liftTiers tiers) tiers Expression.Call
 
+instance Listable1 Expression.LessThan where
+  liftTiers tiers = liftCons2 tiers tiers Expression.LessThan
+
+instance Listable1 Expression.LessThanEqual where
+  liftTiers tiers = liftCons2 tiers tiers Expression.LessThanEqual
+
+instance Listable1 Expression.GreaterThan where
+  liftTiers tiers = liftCons2 tiers tiers Expression.GreaterThan
+
+instance Listable1 Expression.GreaterThanEqual where
+  liftTiers tiers = liftCons2 tiers tiers Expression.GreaterThanEqual
+
+instance Listable1 Expression.Equal where
+  liftTiers tiers = liftCons2 tiers tiers Expression.Equal
+
+instance Listable1 Expression.StrictEqual where
+  liftTiers tiers = liftCons2 tiers tiers Expression.StrictEqual
+
 instance Listable1 Expression.Comparison where
-  liftTiers tiers = liftCons2 tiers tiers Expression.LessThan \/ liftCons2 tiers tiers Expression.LessThanEqual \/ liftCons2 tiers tiers Expression.GreaterThan \/ liftCons2 tiers tiers Expression.GreaterThanEqual \/ liftCons2 tiers tiers Expression.Equal \/ liftCons2 tiers tiers Expression.StrictEqual \/ liftCons2 tiers tiers Expression.Comparison
+  liftTiers tiers = liftCons2 tiers tiers Expression.Comparison
 
 instance Listable1 Expression.Enumeration where
   liftTiers tiers = liftCons3 tiers tiers tiers Expression.Enumeration
 
-instance Listable1 Expression.RegexMatch where
-  liftTiers tiers = liftCons2 tiers tiers Expression.RegexMatches \/ liftCons2 tiers tiers Expression.NotMatches
+instance Listable1 Expression.Matches where
+  liftTiers tiers = liftCons2 tiers tiers Expression.Matches
+
+instance Listable1 Expression.NotMatches where
+  liftTiers tiers = liftCons2 tiers tiers Expression.NotMatches
 
 instance Listable1 Expression.MemberAccess where
   liftTiers tiers = liftCons2 tiers mempty Expression.MemberAccess
@@ -311,7 +380,10 @@ instance Listable1 Expression.ScopeResolution where
   liftTiers tiers = liftCons1 (liftTiers tiers) Expression.ScopeResolution
 
 instance Listable1 Expression.Subscript where
-  liftTiers tiers = liftCons2 tiers (liftTiers tiers) Expression.Subscript \/ liftCons2 tiers tiers Expression.Member
+  liftTiers tiers = liftCons2 tiers (liftTiers tiers) Expression.Subscript
+
+instance Listable1 Expression.Member where
+  liftTiers tiers = liftCons2 tiers tiers Expression.Member
 
 instance Listable1 Literal.Complex where
   liftTiers tiers = cons1 Literal.Complex
@@ -382,8 +454,11 @@ instance Listable1 Ruby.Syntax.Class where
 instance Listable1 Ruby.Syntax.Load where
   liftTiers tiers = liftCons2 tiers (liftTiers tiers) Ruby.Syntax.Load
 
-instance Listable1 Ruby.Syntax.LowPrecedenceBoolean where
-  liftTiers tiers = liftCons2 tiers tiers Ruby.Syntax.LowAnd \/ liftCons2 tiers tiers Ruby.Syntax.LowOr
+instance Listable1 Ruby.Syntax.LowPrecedenceOr where
+  liftTiers tiers = liftCons2 tiers tiers Ruby.Syntax.LowPrecedenceOr
+
+instance Listable1 Ruby.Syntax.LowPrecedenceAnd where
+  liftTiers tiers = liftCons2 tiers tiers Ruby.Syntax.LowPrecedenceAnd
 
 instance Listable1 Ruby.Syntax.Module where
   liftTiers tiers = liftCons2 tiers (liftTiers tiers) Ruby.Syntax.Module

test/Proto3/Roundtrip.hs

@@ -63,6 +63,10 @@ spec = parallel $ do
     prop "roundtrips" $
       \sp -> shouldRoundtrip @(Term (Sum '[Statement.Statements, Literal.Null]) ()) (unListableF sp)
 
+  describe "statements1" $
+    prop "roundtrips" $
+      \sp -> shouldRoundtrip' @Statement.Statements @(Term (Sum '[Statement.Statements, Literal.Null]) ()) (unListableF sp)
+
   describe "blobs" $ do
     it "should roundtrip given a Message instance" $ do
       let bl = Blob (fromUTF8 "puts 'hi'") "example.rb" Ruby

test/fixtures/cli/parse-tree.json

@@ -1 +1,62 @@
-{"trees":[{"tree":{"term":"Statements","statements":[{"term":"LowAnd","children":[{"term":"Send","sendArgs":[],"sendBlock":null,"sendReceiver":null,"sendSelector":{"term":"Identifier","name":"foo","sourceRange":[0,3],"sourceSpan":{"start":[1,1],"end":[1,4]}},"sourceRange":[0,3],"sourceSpan":{"start":[1,1],"end":[1,4]}},{"term":"Send","sendArgs":[],"sendBlock":null,"sendReceiver":null,"sendSelector":{"term":"Identifier","name":"bar","sourceRange":[8,11],"sourceSpan":{"start":[1,9],"end":[1,12]}},"sourceRange":[8,11],"sourceSpan":{"start":[1,9],"end":[1,12]}}],"sourceRange":[0,11],"sourceSpan":{"start":[1,1],"end":[1,12]}}],"sourceRange":[0,12],"sourceSpan":{"start":[1,1],"end":[2,1]}},"path":"test/fixtures/ruby/corpus/and-or.A.rb","language":"Ruby"}]}
+{
+  "trees": [{
+    "tree": {
+      "term": "Statements",
+      "statements": [{
+        "term": "LowPrecedenceAnd",
+        "lhs": {
+          "term": "Send",
+          "sendArgs": [],
+          "sendBlock": null,
+          "sendReceiver": null,
+          "sendSelector": {
+            "term": "Identifier",
+            "name": "foo",
+            "sourceRange": [0, 3],
+            "sourceSpan": {
+              "start": [1, 1],
+              "end": [1, 4]
+            }
+          },
+          "sourceRange": [0, 3],
+          "sourceSpan": {
+            "start": [1, 1],
+            "end": [1, 4]
+          }
+        },
+        "rhs": {
+          "term": "Send",
+          "sendArgs": [],
+          "sendBlock": null,
+          "sendReceiver": null,
+          "sendSelector": {
+            "term": "Identifier",
+            "name": "bar",
+            "sourceRange": [8, 11],
+            "sourceSpan": {
+              "start": [1, 9],
+              "end": [1, 12]
+            }
+          },
+          "sourceRange": [8, 11],
+          "sourceSpan": {
+            "start": [1, 9],
+            "end": [1, 12]
+          }
+        },
+        "sourceRange": [0, 11],
+        "sourceSpan": {
+          "start": [1, 1],
+          "end": [1, 12]
+        }
+      }],
+      "sourceRange": [0, 12],
+      "sourceSpan": {
+        "start": [1, 1],
+        "end": [2, 1]
+      }
+    },
+    "path": "test/fixtures/ruby/corpus/and-or.A.rb",
+    "language": "Ruby"
+  }]
+}

test/fixtures/cli/parse-trees.json

@@ -1 +1,196 @@
-{"trees":[{"tree":{"term":"Statements","statements":[{"term":"LowAnd","children":[{"term":"Send","sendArgs":[],"sendBlock":null,"sendReceiver":null,"sendSelector":{"term":"Identifier","name":"foo","sourceRange":[0,3],"sourceSpan":{"start":[1,1],"end":[1,4]}},"sourceRange":[0,3],"sourceSpan":{"start":[1,1],"end":[1,4]}},{"term":"Send","sendArgs":[],"sendBlock":null,"sendReceiver":null,"sendSelector":{"term":"Identifier","name":"bar","sourceRange":[8,11],"sourceSpan":{"start":[1,9],"end":[1,12]}},"sourceRange":[8,11],"sourceSpan":{"start":[1,9],"end":[1,12]}}],"sourceRange":[0,11],"sourceSpan":{"start":[1,1],"end":[1,12]}}],"sourceRange":[0,12],"sourceSpan":{"start":[1,1],"end":[2,1]}},"path":"test/fixtures/ruby/corpus/and-or.A.rb","language":"Ruby"},{"tree":{"term":"Statements","statements":[{"term":"LowOr","children":[{"term":"Send","sendArgs":[],"sendBlock":null,"sendReceiver":null,"sendSelector":{"term":"Identifier","name":"foo","sourceRange":[0,3],"sourceSpan":{"start":[1,1],"end":[1,4]}},"sourceRange":[0,3],"sourceSpan":{"start":[1,1],"end":[1,4]}},{"term":"Send","sendArgs":[],"sendBlock":null,"sendReceiver":null,"sendSelector":{"term":"Identifier","name":"bar","sourceRange":[7,10],"sourceSpan":{"start":[1,8],"end":[1,11]}},"sourceRange":[7,10],"sourceSpan":{"start":[1,8],"end":[1,11]}}],"sourceRange":[0,10],"sourceSpan":{"start":[1,1],"end":[1,11]}},{"term":"LowAnd","children":[{"term":"LowOr","children":[{"term":"Send","sendArgs":[],"sendBlock":null,"sendReceiver":null,"sendSelector":{"term":"Identifier","name":"a","sourceRange":[11,12],"sourceSpan":{"start":[2,1],"end":[2,2]}},"sourceRange":[11,12],"sourceSpan":{"start":[2,1],"end":[2,2]}},{"term":"Send","sendArgs":[],"sendBlock":null,"sendReceiver":null,"sendSelector":{"term":"Identifier","name":"b","sourceRange":[16,17],"sourceSpan":{"start":[2,6],"end":[2,7]}},"sourceRange":[16,17],"sourceSpan":{"start":[2,6],"end":[2,7]}}],"sourceRange":[11,17],"sourceSpan":{"start":[2,1],"end":[2,7]}},{"term":"Send","sendArgs":[],"sendBlock":null,"sendReceiver":null,"sendSelector":{"term":"Identifier","name":"c","sourceRange":[22,23],"sourceSpan":{"start":[2,12],"end":[2,13]}},"sourceRange":[22,23],"sourceSpan":{"start":[2,12],"end":[2,13]}}],"sourceRange":[11,23],"sourceSpan":{"start":[2,1],"end":[2,13]}}],"sourceRange":[0,24],"sourceSpan":{"start":[1,1],"end":[3,1]}},"path":"test/fixtures/ruby/corpus/and-or.B.rb","language":"Ruby"}]}
+{
+  "trees": [{
+    "tree": {
+      "term": "Statements",
+      "statements": [{
+        "term": "LowPrecedenceAnd",
+        "lhs": {
+          "term": "Send",
+          "sendArgs": [],
+          "sendBlock": null,
+          "sendReceiver": null,
+          "sendSelector": {
+            "term": "Identifier",
+            "name": "foo",
+            "sourceRange": [0, 3],
+            "sourceSpan": {
+              "start": [1, 1],
+              "end": [1, 4]
+            }
+          },
+          "sourceRange": [0, 3],
+          "sourceSpan": {
+            "start": [1, 1],
+            "end": [1, 4]
+          }
+        },
+        "rhs": {
+          "term": "Send",
+          "sendArgs": [],
+          "sendBlock": null,
+          "sendReceiver": null,
+          "sendSelector": {
+            "term": "Identifier",
+            "name": "bar",
+            "sourceRange": [8, 11],
+            "sourceSpan": {
+              "start": [1, 9],
+              "end": [1, 12]
+            }
+          },
+          "sourceRange": [8, 11],
+          "sourceSpan": {
+            "start": [1, 9],
+            "end": [1, 12]
+          }
+        },
+        "sourceRange": [0, 11],
+        "sourceSpan": {
+          "start": [1, 1],
+          "end": [1, 12]
+        }
+      }],
+      "sourceRange": [0, 12],
+      "sourceSpan": {
+        "start": [1, 1],
+        "end": [2, 1]
+      }
+    },
+    "path": "test/fixtures/ruby/corpus/and-or.A.rb",
+    "language": "Ruby"
+  }, {
+    "tree": {
+      "term": "Statements",
+      "statements": [{
+        "term": "LowPrecedenceOr",
+        "lhs": {
+          "term": "Send",
+          "sendArgs": [],
+          "sendBlock": null,
+          "sendReceiver": null,
+          "sendSelector": {
+            "term": "Identifier",
+            "name": "foo",
+            "sourceRange": [0, 3],
+            "sourceSpan": {
+              "start": [1, 1],
+              "end": [1, 4]
+            }
+          },
+          "sourceRange": [0, 3],
+          "sourceSpan": {
+            "start": [1, 1],
+            "end": [1, 4]
+          }
+        },
+        "rhs": {
+          "term": "Send",
+          "sendArgs": [],
+          "sendBlock": null,
+          "sendReceiver": null,
+          "sendSelector": {
+            "term": "Identifier",
+            "name": "bar",
+            "sourceRange": [7, 10],
+            "sourceSpan": {
+              "start": [1, 8],
+              "end": [1, 11]
+            }
+          },
+          "sourceRange": [7, 10],
+          "sourceSpan": {
+            "start": [1, 8],
+            "end": [1, 11]
+          }
+        },
+        "sourceRange": [0, 10],
+        "sourceSpan": {
+          "start": [1, 1],
+          "end": [1, 11]
+        }
+      }, {
+        "term": "LowPrecedenceAnd",
+        "lhs": {
+          "term": "LowPrecedenceOr",
+          "lhs": {
+            "term": "Send",
+            "sendArgs": [],
+            "sendBlock": null,
+            "sendReceiver": null,
+            "sendSelector": {
+              "term": "Identifier",
+              "name": "a",
+              "sourceRange": [11, 12],
+              "sourceSpan": {
+                "start": [2, 1],
+                "end": [2, 2]
+              }
+            },
+            "sourceRange": [11, 12],
+            "sourceSpan": {
+              "start": [2, 1],
+              "end": [2, 2]
+            }
+          },
+          "rhs": {
+            "term": "Send",
+            "sendArgs": [],
+            "sendBlock": null,
+            "sendReceiver": null,
+            "sendSelector": {
+              "term": "Identifier",
+              "name": "b",
+              "sourceRange": [16, 17],
+              "sourceSpan": {
+                "start": [2, 6],
+                "end": [2, 7]
+              }
+            },
+            "sourceRange": [16, 17],
+            "sourceSpan": {
+              "start": [2, 6],
+              "end": [2, 7]
+            }
+          },
+          "sourceRange": [11, 17],
+          "sourceSpan": {
+            "start": [2, 1],
+            "end": [2, 7]
+          }
+        },
+        "rhs": {
+          "term": "Send",
+          "sendArgs": [],
+          "sendBlock": null,
+          "sendReceiver": null,
+          "sendSelector": {
+            "term": "Identifier",
+            "name": "c",
+            "sourceRange": [22, 23],
+            "sourceSpan": {
+              "start": [2, 12],
+              "end": [2, 13]
+            }
+          },
+          "sourceRange": [22, 23],
+          "sourceSpan": {
+            "start": [2, 12],
+            "end": [2, 13]
+          }
+        },
+        "sourceRange": [11, 23],
+        "sourceSpan": {
+          "start": [2, 1],
+          "end": [2, 13]
+        }
+      }],
+      "sourceRange": [0, 24],
+      "sourceSpan": {
+        "start": [1, 1],
+        "end": [3, 1]
+      }
+    },
+    "path": "test/fixtures/ruby/corpus/and-or.B.rb",
+    "language": "Ruby"
+  }]
+}

test/fixtures/go/corpus/assignment-statements.diffA-B.txt

@@ -45,15 +45,11 @@
       {+(RShift
         {+(Identifier)+}
         {+(Integer)+})+})+}
-      (Assignment
-      { (Identifier)
-      ->(Identifier) }
-      { (Times
-        {-(Identifier)-}
-        {-(Integer)-})
-      ->(DividedBy
+    {+(Assignment
+      {+(Identifier)+}
+      {+(DividedBy
         {+(Identifier)+}
-        {+(Integer)+}) })
+        {+(Integer)+})+})+}
     {+(Assignment
       {+(Identifier)+}
       {+(BXOr
@@ -82,6 +78,11 @@
               {+(KeyValue
                 {+(Identifier)+}
                 {+(Integer)+})+})+})+})+})+})+}
+    {-(Assignment
+      {-(Identifier)-}
+      {-(Times
+        {-(Identifier)-}
+        {-(Integer)-})-})-}
     {-(Assignment
       {-(Identifier)-}
       {-(Plus

test/fixtures/go/corpus/assignment-statements.diffB-A.txt

@@ -30,25 +30,29 @@
       {+(Times
         {+(Identifier)+}
         {+(Integer)+})+})+}
+    {+(Assignment
+      {+(Identifier)+}
+      {+(Plus
+        {+(Identifier)+}
+        {+(Integer)+})+})+}
       (Assignment
       { (Identifier)
       ->(Identifier) }
       { (Times
         {-(Identifier)-}
         {-(Integer)-})
-      ->(Plus
+      ->(LShift
         {+(Identifier)+}
         {+(Integer)+}) })
-    {+(Assignment
-      {+(Identifier)+}
-      {+(LShift
+      (Assignment
+      { (Identifier)
+      ->(Identifier) }
+      { (Plus
+        {-(Identifier)-}
+        {-(Integer)-})
+      ->(RShift
         {+(Identifier)+}
-        {+(Integer)+})+})+}
-    {+(Assignment
-      {+(Identifier)+}
-      {+(RShift
-        {+(Identifier)+}
-        {+(Integer)+})+})+}
+        {+(Integer)+}) })
     {+(Assignment
       {+(Identifier)+}
       {+(DividedBy
@@ -64,16 +68,12 @@
       {+(Modulo
         {+(Identifier)+}
         {+(Integer)+})+})+}
-      (Assignment
-      { (Identifier)
-      ->(Identifier) }
-      { (Plus
-        {-(Identifier)-}
-        {-(Integer)-})
-      ->(Not
+    {+(Assignment
+      {+(Identifier)+}
+      {+(Not
         {+(BAnd
           {+(Identifier)+}
-          {+(Integer)+})+}) })
+          {+(Integer)+})+})+})+}
     {+(Assignment
       {+(Identifier)+}
       {+(Statements

test/fixtures/go/corpus/const-with-implicit-values.diffA-B.txt

@@ -6,15 +6,21 @@
     (Identifier)
     (Statements)
     (Statements
-      (Assignment
-      { (Identifier)
-      ->(Identifier) }
-        (Identifier))
-      (Assignment
-      { (Identifier)
-      ->(Identifier) }
-        (Statements))
-      (Assignment
-      { (Identifier)
-      ->(Identifier) }
-        (Statements)))))
+    {+(Assignment
+      {+(Identifier)+}
+      {+(Identifier)+})+}
+    {+(Assignment
+      {+(Identifier)+}
+      {+(Statements)+})+}
+    {+(Assignment
+      {+(Identifier)+}
+      {+(Statements)+})+}
+    {-(Assignment
+      {-(Identifier)-}
+      {-(Identifier)-})-}
+    {-(Assignment
+      {-(Identifier)-}
+      {-(Statements)-})-}
+    {-(Assignment
+      {-(Identifier)-}
+      {-(Statements)-})-})))

test/fixtures/go/corpus/const-with-implicit-values.diffB-A.txt

@@ -6,15 +6,20 @@
     (Identifier)
     (Statements)
     (Statements
+    {+(Assignment
+      {+(Identifier)+}
+      {+(Identifier)+})+}
+    {+(Assignment
+      {+(Identifier)+}
+      {+(Statements)+})+}
       (Assignment
       { (Identifier)
       ->(Identifier) }
-        (Identifier))
-      (Assignment
       { (Identifier)
-      ->(Identifier) }
-        (Statements))
-      (Assignment
-      { (Identifier)
-      ->(Identifier) }
-        (Statements)))))
+      ->(Statements) })
+    {-(Assignment
+      {-(Identifier)-}
+      {-(Statements)-})-}
+    {-(Assignment
+      {-(Identifier)-}
+      {-(Statements)-})-})))

test/fixtures/go/corpus/for-statements.diffB-A.txt

@@ -92,28 +92,31 @@
           {+(Identifier)+}
           {+(Identifier)+})+}
         {+(Empty)+})+})+}
-      (For
-        (Empty)
-      { (Empty)
-      ->(LessThan
+    {+(For
+      {+(Empty)+}
+      {+(LessThan
         {+(Integer)+}
-        {+(Integer)+}) }
-        (Empty)
-      { (Statements
+        {+(Integer)+})+}
+      {+(Empty)+}
+      {+(Call
+        {+(Identifier)+}
+        {+(Statements)+}
+        {+(Empty)+})+})+}
+    {+(ForEach
+      {+(Empty)+}
+      {+(Identifier)+}
+      {+(Statements)+})+}
+    {-(For
+      {-(Empty)-}
+      {-(Empty)-}
+      {-(Empty)-}
+      {-(Statements
         {-(Call
           {-(Identifier)-}
           {-(Statements)-}
           {-(Empty)-})-}
         {-(Continue
-          {-(Identifier)-})-})
-      ->(Call
-        {+(Identifier)+}
-        {+(Statements)+}
-        {+(Empty)+}) })
-    {+(ForEach
-      {+(Empty)+}
-      {+(Identifier)+}
-      {+(Statements)+})+}
+          {-(Identifier)-})-})-})-}
     {-(For
       {-(LessThan
         {-(Identifier)-}

test/fixtures/go/corpus/slice-expressions.diffA-B.txt

@@ -18,33 +18,24 @@
       { (Integer)
       ->(Integer) }
         (Empty))
-    {+(Slice
-      {+(Identifier)+}
-      {+(Integer)+}
-      {+(Integer)+}
-      {+(Empty)+})+}
-    {+(Slice
-      {+(Identifier)+}
-      {+(Integer)+}
-      {+(Integer)+}
-      {+(Integer)+})+}
-    {+(Slice
-      {+(Identifier)+}
-      {+(Integer)+}
-      {+(Integer)+}
-      {+(Empty)+})+}
-    {-(Slice
-      {-(Identifier)-}
-      {-(Empty)-}
-      {-(Empty)-}
-      {-(Empty)-})-}
-    {-(Slice
-      {-(Identifier)-}
-      {-(Integer)-}
-      {-(Integer)-}
-      {-(Integer)-})-}
-    {-(Slice
-      {-(Identifier)-}
-      {-(Integer)-}
-      {-(Integer)-}
-      {-(Empty)-})-})))
+      (Slice
+        (Identifier)
+      { (Empty)
+      ->(Integer) }
+      { (Empty)
+      ->(Integer) }
+        (Empty))
+      (Slice
+        (Identifier)
+      { (Integer)
+      ->(Integer) }
+      { (Integer)
+      ->(Integer) }
+      { (Integer)
+      ->(Integer) })
+      (Slice
+      { (Identifier)
+      ->(Identifier) }
+        (Integer)
+        (Integer)
+        (Empty)))))

test/fixtures/go/corpus/slice-expressions.diffB-A.txt

@@ -18,29 +18,24 @@
       { (Integer)
       ->(Integer) }
         (Empty))
-    {+(Slice
-      {+(Identifier)+}
-      {+(Empty)+}
-      {+(Empty)+}
-      {+(Empty)+})+}
-    {+(Slice
-      {+(Identifier)+}
-      {+(Integer)+}
-      {+(Integer)+}
-      {+(Integer)+})+}
+      (Slice
+        (Identifier)
+      { (Integer)
+      ->(Empty) }
+      { (Integer)
+      ->(Empty) }
+        (Empty))
+      (Slice
+        (Identifier)
+      { (Integer)
+      ->(Integer) }
+      { (Integer)
+      ->(Integer) }
+      { (Integer)
+      ->(Integer) })
       (Slice
       { (Identifier)
       ->(Identifier) }
         (Integer)
         (Integer)
-        (Empty))
-    {-(Slice
-      {-(Identifier)-}
-      {-(Integer)-}
-      {-(Integer)-}
-      {-(Integer)-})-}
-    {-(Slice
-      {-(Identifier)-}
-      {-(Integer)-}
-      {-(Integer)-}
-      {-(Empty)-})-})))
+        (Empty)))))

test/fixtures/go/corpus/type-conversion-expressions.diffA-B.txt

@@ -65,17 +65,13 @@
         {-(Identifier)-})
       ->(MemberAccess
         {+(Identifier)+}) })
-      (TypeConversion
-        (Parenthesized
-          (Slice
-          { (MemberAccess
-            {-(Identifier)-})
-          ->(MemberAccess
-            {+(Identifier)+}) }))
-      { (MemberAccess
-        {-(Identifier)-})
-      ->(MemberAccess
-        {+(Identifier)+}) })
+    {+(TypeConversion
+      {+(Parenthesized
+        {+(Slice
+          {+(MemberAccess
+            {+(Identifier)+})+})+})+}
+      {+(MemberAccess
+        {+(Identifier)+})+})+}
     {+(Call
       {+(MemberAccess
         {+(Identifier)+})+}
@@ -86,6 +82,13 @@
         {+(Identifier)+})+}
       {+(Identifier)+}
       {+(Empty)+})+}
+    {-(TypeConversion
+      {-(Parenthesized
+        {-(Slice
+          {-(MemberAccess
+            {-(Identifier)-})-})-})-}
+      {-(MemberAccess
+        {-(Identifier)-})-})-}
     {-(Call
       {-(MemberAccess
         {-(Identifier)-})-}

test/fixtures/go/corpus/type-conversion-expressions.diffB-A.txt

@@ -65,17 +65,13 @@
         {-(Identifier)-})
       ->(MemberAccess
         {+(Identifier)+}) })
-      (TypeConversion
-        (Parenthesized
-          (Slice
-          { (MemberAccess
-            {-(Identifier)-})
-          ->(MemberAccess
-            {+(Identifier)+}) }))
-      { (MemberAccess
-        {-(Identifier)-})
-      ->(MemberAccess
-        {+(Identifier)+}) })
+    {+(TypeConversion
+      {+(Parenthesized
+        {+(Slice
+          {+(MemberAccess
+            {+(Identifier)+})+})+})+}
+      {+(MemberAccess
+        {+(Identifier)+})+})+}
     {+(Call
       {+(MemberAccess
         {+(Identifier)+})+}
@@ -86,6 +82,13 @@
         {+(Identifier)+})+}
       {+(Identifier)+}
       {+(Empty)+})+}
+    {-(TypeConversion
+      {-(Parenthesized
+        {-(Slice
+          {-(MemberAccess
+            {-(Identifier)-})-})-})-}
+      {-(MemberAccess
+        {-(Identifier)-})-})-}
     {-(Call
       {-(MemberAccess
         {-(Identifier)-})-}

test/fixtures/go/corpus/type-switch-statements.diffA-B.txt

@@ -61,12 +61,12 @@
               (Statements
               { (TextElement)
               ->(TextElement) }
-              { (Times
-                {-(Identifier)-}
-                {-(Integer)-})
-              ->(DividedBy
+              {+(DividedBy
                 {+(Integer)+}
-                {+(Identifier)+}) })
+                {+(Identifier)+})+}
+              {-(Times
+                {-(Identifier)-}
+                {-(Integer)-})-})
               (Empty)))
           (Pattern
           { (Identifier)
@@ -77,12 +77,12 @@
               (Statements
               { (TextElement)
               ->(TextElement) }
-              { (DividedBy
-                {-(Integer)-}
-                {-(Identifier)-})
-              ->(Times
+              {+(Times
                 {+(Identifier)+}
-                {+(Integer)+}) })
+                {+(Integer)+})+}
+              {-(DividedBy
+                {-(Integer)-}
+                {-(Identifier)-})-})
               (Empty)))
           (Pattern
             (Identifier)

test/fixtures/go/corpus/type-switch-statements.diffB-A.txt

@@ -61,12 +61,12 @@
               (Statements
               { (TextElement)
               ->(TextElement) }
-              { (DividedBy
-                {-(Integer)-}
-                {-(Identifier)-})
-              ->(Times
+              {+(Times
                 {+(Identifier)+}
-                {+(Integer)+}) })
+                {+(Integer)+})+}
+              {-(DividedBy
+                {-(Integer)-}
+                {-(Identifier)-})-})
               (Empty)))
           (Pattern
           { (Identifier)
@@ -77,12 +77,12 @@
               (Statements
               { (TextElement)
               ->(TextElement) }
-              { (Times
-                {-(Identifier)-}
-                {-(Integer)-})
-              ->(DividedBy
+              {+(DividedBy
                 {+(Integer)+}
-                {+(Identifier)+}) })
+                {+(Identifier)+})+}
+              {-(Times
+                {-(Identifier)-}
+                {-(Integer)-})-})
               (Empty)))
           (Pattern
             (Identifier)

test/fixtures/go/corpus/unary-expressions.diffA-B.txt

@@ -8,35 +8,25 @@
     (Statements
     { (Identifier)
     ->(Identifier) }
-    {+(Negate
-      {+(Identifier)+})+}
-    {+(Not
-      {+(ReceiveOperator
-        {+(Identifier)+})+})+}
-    {+(Pointer
-      {+(Call
-        {+(Identifier)+}
-        {+(Statements)+}
-        {+(Empty)+})+})+}
-    {+(Complement
-      {+(Identifier)+})+}
-    {+(Reference
-      {+(Identifier)+})+}
-    {+(ReceiveOperator
-      {+(Identifier)+})+}
-    {-(Negate
-      {-(Identifier)-})-}
-    {-(Not
-      {-(ReceiveOperator
-        {-(Identifier)-})-})-}
-    {-(Pointer
-      {-(Call
-        {-(Identifier)-}
-        {-(Statements)-}
-        {-(Empty)-})-})-}
-    {-(Complement
-      {-(Identifier)-})-}
-    {-(Reference
-      {-(Identifier)-})-}
-    {-(ReceiveOperator
-      {-(Identifier)-})-})))
+      (Negate
+      { (Identifier)
+      ->(Identifier) })
+      (Not
+        (ReceiveOperator
+        { (Identifier)
+        ->(Identifier) }))
+      (Pointer
+        (Call
+        { (Identifier)
+        ->(Identifier) }
+          (Statements)
+          (Empty)))
+      (Complement
+      { (Identifier)
+      ->(Identifier) })
+      (Reference
+      { (Identifier)
+      ->(Identifier) })
+      (ReceiveOperator
+      { (Identifier)
+      ->(Identifier) }))))

test/fixtures/go/corpus/unary-expressions.diffB-A.txt

@@ -8,35 +8,25 @@
     (Statements
     { (Identifier)
     ->(Identifier) }
-    {+(Negate
-      {+(Identifier)+})+}
-    {+(Not
-      {+(ReceiveOperator
-        {+(Identifier)+})+})+}
-    {+(Pointer
-      {+(Call
-        {+(Identifier)+}
-        {+(Statements)+}
-        {+(Empty)+})+})+}
-    {+(Complement
-      {+(Identifier)+})+}
-    {+(Reference
-      {+(Identifier)+})+}
-    {+(ReceiveOperator
-      {+(Identifier)+})+}
-    {-(Negate
-      {-(Identifier)-})-}
-    {-(Not
-      {-(ReceiveOperator
-        {-(Identifier)-})-})-}
-    {-(Pointer
-      {-(Call
-        {-(Identifier)-}
-        {-(Statements)-}
-        {-(Empty)-})-})-}
-    {-(Complement
-      {-(Identifier)-})-}
-    {-(Reference
-      {-(Identifier)-})-}
-    {-(ReceiveOperator
-      {-(Identifier)-})-})))
+      (Negate
+      { (Identifier)
+      ->(Identifier) })
+      (Not
+        (ReceiveOperator
+        { (Identifier)
+        ->(Identifier) }))
+      (Pointer
+        (Call
+        { (Identifier)
+        ->(Identifier) }
+          (Statements)
+          (Empty)))
+      (Complement
+      { (Identifier)
+      ->(Identifier) })
+      (Reference
+      { (Identifier)
+      ->(Identifier) })
+      (ReceiveOperator
+      { (Identifier)
+      ->(Identifier) }))))

test/fixtures/javascript/corpus/boolean-operator.diffA-B.txt

@@ -1,7 +1,7 @@
 (Statements
-{ (Or
-  {-(Identifier)-}
-  {-(Identifier)-})
-->(And
+{+(And
   {+(Identifier)+}
-  {+(Identifier)+}) })
+  {+(Identifier)+})+}
+{-(Or
+  {-(Identifier)-}
+  {-(Identifier)-})-})

test/fixtures/javascript/corpus/boolean-operator.diffB-A.txt

@@ -1,7 +1,7 @@
 (Statements
-{ (And
-  {-(Identifier)-}
-  {-(Identifier)-})
-->(Or
+{+(Or
   {+(Identifier)+}
-  {+(Identifier)+}) })
+  {+(Identifier)+})+}
+{-(And
+  {-(Identifier)-}
+  {-(Identifier)-})-})

test/fixtures/javascript/corpus/export.diffA-B.txt

@@ -35,15 +35,15 @@
         (Identifier)
       { (Empty)
       ->(Identifier) })
+    {+(Assignment
+      {+(Empty)+}
+      {+(Identifier)+}
+      {+(Empty)+})+}
       (Assignment
         (Empty)
       { (Identifier)
       ->(Identifier) }
-        (Empty))
-    {+(Assignment
-      {+(Empty)+}
-      {+(Identifier)+}
-      {+(Empty)+})+}))
+        (Empty))))
   (DefaultExport
   { (Identifier)
   ->(Identifier) })

test/fixtures/javascript/corpus/export.diffB-A.txt

@@ -35,11 +35,14 @@
         (Identifier)
       { (Identifier)
       ->(Empty) })
-      (Assignment
-        (Empty)
-      { (Identifier)
-      ->(Identifier) }
-        (Empty))
+    {+(Assignment
+      {+(Empty)+}
+      {+(Identifier)+}
+      {+(Empty)+})+}
+    {-(Assignment
+      {-(Empty)-}
+      {-(Identifier)-}
+      {-(Empty)-})-}
     {-(Assignment
       {-(Empty)-}
       {-(Identifier)-}

test/fixtures/javascript/corpus/import.diffA-B.txt

@@ -1,12 +1,8 @@
 (Statements
-{ (Import)
-->(Import) }
-{ (QualifiedAliasedImport
-  {-(Identifier)-})
-->(QualifiedAliasedImport
-  {+(Identifier)+}) }
-{ (Import)
-->(Import) }
+{+(Import)+}
+{+(QualifiedAliasedImport
+  {+(Identifier)+})+}
+{+(Import)+}
 {+(Import)+}
 {+(Import)+}
 {+(Statements
@@ -18,6 +14,10 @@
     {+(Identifier)+})+})+}
 {+(SideEffectImport)+}
 {-(Import)-}
+{-(QualifiedAliasedImport
+  {-(Identifier)-})-}
+{-(Import)-}
+{-(Import)-}
 {-(Import)-}
 {-(Statements
   {-(Import)-}

test/fixtures/javascript/corpus/import.diffB-A.txt

@@ -1,13 +1,10 @@
 (Statements
-{ (Import)
-->(Import) }
-{ (QualifiedAliasedImport
-  {-(Identifier)-})
-->(QualifiedAliasedImport
-  {+(Identifier)+}) }
-{ (Import)
-->(Import) }
 {+(Import)+}
+{+(QualifiedAliasedImport
+  {+(Identifier)+})+}
+{+(Import)+}
+{ (Import)
+->(Import) }
 {+(Import)+}
 {+(Statements
   {+(Import)+}
@@ -17,6 +14,9 @@
   {+(QualifiedAliasedImport
     {+(Identifier)+})+})+}
 {+(SideEffectImport)+}
+{-(QualifiedAliasedImport
+  {-(Identifier)-})-}
+{-(Import)-}
 {-(Import)-}
 {-(Import)-}
 {-(Statements

test/fixtures/javascript/corpus/relational-operator.diffA-B.txt

@@ -1,7 +1,7 @@
 (Statements
-{ (LessThan
-  {-(Identifier)-}
-  {-(Identifier)-})
-->(LessThanEqual
+{+(LessThanEqual
   {+(Identifier)+}
-  {+(Identifier)+}) })
+  {+(Identifier)+})+}
+{-(LessThan
+  {-(Identifier)-}
+  {-(Identifier)-})-})

test/fixtures/javascript/corpus/relational-operator.diffB-A.txt

@@ -1,7 +1,7 @@
 (Statements
-{ (LessThanEqual
-  {-(Identifier)-}
-  {-(Identifier)-})
-->(LessThan
+{+(LessThan
   {+(Identifier)+}
-  {+(Identifier)+}) })
+  {+(Identifier)+})+}
+{-(LessThanEqual
+  {-(Identifier)-}
+  {-(Identifier)-})-})

test/fixtures/python/corpus/assignment.diffB-A.txt

@@ -10,13 +10,14 @@
     {-(Integer)-}
       (Integer)
     {+(Integer)+}))
-  (Assignment
-  { (Identifier)
-  ->(Identifier) }
-  { (Integer)
-  ->(Statements
+{+(Assignment
+  {+(Identifier)+}
+  {+(Statements
     {+(Integer)+}
-    {+(Integer)+}) })
+    {+(Integer)+})+})+}
+{-(Assignment
+  {-(Identifier)-}
+  {-(Integer)-})-}
 {-(Assignment
   {-(Identifier)-}
   {-(Statements

test/fixtures/python/corpus/binary-operator.diffA-B.txt

@@ -26,18 +26,12 @@
   (Modulo
     (Identifier)
     (Identifier))
-{ (FloorDivision
-  {-(Identifier)-}
-  {-(Identifier)-})
-->(Power
+{+(Power
   {+(Identifier)+}
-  {+(Identifier)+}) }
-{ (Power
-  {-(Identifier)-}
-  {-(Identifier)-})
-->(FloorDivision
+  {+(Identifier)+})+}
+{+(FloorDivision
   {+(Identifier)+}
-  {+(Identifier)+}) }
+  {+(Identifier)+})+}
 {+(Modulo
   {+(Identifier)+}
   {+(Identifier)+})+}
@@ -53,6 +47,12 @@
 {+(Plus
   {+(Identifier)+}
   {+(Identifier)+})+}
+{-(FloorDivision
+  {-(Identifier)-}
+  {-(Identifier)-})-}
+{-(Power
+  {-(Identifier)-}
+  {-(Identifier)-})-}
 {-(BOr
   {-(Identifier)-}
   {-(Identifier)-})-}

test/fixtures/python/corpus/binary-operator.diffB-A.txt

@@ -26,18 +26,12 @@
   (Modulo
     (Identifier)
     (Identifier))
-{ (Power
-  {-(Identifier)-}
-  {-(Identifier)-})
-->(FloorDivision
+{+(FloorDivision
   {+(Identifier)+}
-  {+(Identifier)+}) }
-{ (FloorDivision
-  {-(Identifier)-}
-  {-(Identifier)-})
-->(Power
+  {+(Identifier)+})+}
+{+(Power
   {+(Identifier)+}
-  {+(Identifier)+}) }
+  {+(Identifier)+})+}
 {+(BOr
   {+(Identifier)+}
   {+(Identifier)+})+}
@@ -53,6 +47,12 @@
 {+(RShift
   {+(Identifier)+}
   {+(Identifier)+})+}
+{-(Power
+  {-(Identifier)-}
+  {-(Identifier)-})-}
+{-(FloorDivision
+  {-(Identifier)-}
+  {-(Identifier)-})-}
 {-(Modulo
   {-(Identifier)-}
   {-(Identifier)-})-}

test/fixtures/python/corpus/boolean-operator.diffA-B.txt

@@ -1,13 +1,12 @@
 (Statements
-{ (And
-  {-(Identifier)-}
-  {-(Identifier)-})
-->(Or
+{+(Or
   {+(Identifier)+}
-  {+(Identifier)+}) }
-{ (Or
+  {+(Identifier)+})+}
+  (And
+  { (Identifier)
+  ->(Identifier) }
+  { (Identifier)
+  ->(Identifier) })
+{-(Or
   {-(Identifier)-}
-  {-(Identifier)-})
-->(And
-  {+(Identifier)+}
-  {+(Identifier)+}) })
+  {-(Identifier)-})-})

test/fixtures/python/corpus/boolean-operator.diffB-A.txt

@@ -1,13 +1,12 @@
 (Statements
-{ (Or
-  {-(Identifier)-}
-  {-(Identifier)-})
-->(And
+{+(And
   {+(Identifier)+}
-  {+(Identifier)+}) }
-{ (And
+  {+(Identifier)+})+}
+  (Or
+  { (Identifier)
+  ->(Identifier) }
+  { (Identifier)
+  ->(Identifier) })
+{-(And
   {-(Identifier)-}
-  {-(Identifier)-})
-->(Or
-  {+(Identifier)+}
-  {+(Identifier)+}) })
+  {-(Identifier)-})-})

test/fixtures/python/corpus/comparison-operator.diffB-A.txt

@@ -5,25 +5,20 @@
 {+(LessThanEqual
   {+(Identifier)+}
   {+(Identifier)+})+}
-  (Not
-    (Equal
-    { (Identifier)
-    ->(Identifier) }
-    { (Identifier)
-    ->(Identifier) }))
+{+(Not
+  {+(Equal
+    {+(Identifier)+}
+    {+(Identifier)+})+})+}
 {+(GreaterThanEqual
   {+(Identifier)+}
   {+(Identifier)+})+}
 {+(GreaterThan
   {+(Identifier)+}
   {+(Identifier)+})+}
-  (Not
-  { (Member
-    {-(Identifier)-}
-    {-(Identifier)-})
-  ->(Equal
+{+(Not
+  {+(Equal
     {+(Identifier)+}
-    {+(Identifier)+}) })
+    {+(Identifier)+})+})+}
 {+(Member
   {+(Identifier)+}
   {+(Identifier)+})+}
@@ -34,10 +29,16 @@
   {+(Member
     {+(Identifier)+}
     {+(Identifier)+})+})+}
-{+(Not
-  {+(Equal
-    {+(Identifier)+}
-    {+(Identifier)+})+})+}
+  (Not
+    (Equal
+    { (Identifier)
+    ->(Identifier) }
+    { (Identifier)
+    ->(Identifier) }))
+{-(Not
+  {-(Member
+    {-(Identifier)-}
+    {-(Identifier)-})-})-}
 {-(Equal
   {-(Identifier)-}
   {-(Identifier)-})-}

test/fixtures/python/corpus/exec-statement.diffA-B.txt

@@ -1,21 +1,28 @@
 (Statements
+{+(Call
+  {+(Identifier)+}
+  {+(TextElement)+}
+  {+(Identifier)+}
+  {+(Empty)+})+}
+{+(Call
+  {+(Identifier)+}
+  {+(TextElement)+}
+  {+(Identifier)+}
+  {+(Identifier)+}
+  {+(Empty)+})+}
   (Call
     (Identifier)
   { (TextElement)
   ->(TextElement) }
-  {+(Identifier)+}
     (Empty))
-  (Call
-    (Identifier)
-    (TextElement)
-  {+(Identifier)+}
-  {+(Identifier)+}
+{-(Call
+  {-(Identifier)-}
+  {-(TextElement)-}
   {-(Null)-}
-    (Empty))
-  (Call
-    (Identifier)
-  { (TextElement)
-  ->(TextElement) }
+  {-(Empty)-})-}
+{-(Call
+  {-(Identifier)-}
+  {-(TextElement)-}
   {-(Identifier)-}
   {-(Identifier)-}
-    (Empty)))
+  {-(Empty)-})-})

test/fixtures/python/corpus/exec-statement.diffB-A.txt

@@ -1,21 +1,22 @@
 (Statements
-  (Call
-    (Identifier)
-  { (TextElement)
-  ->(TextElement) }
-  {-(Identifier)-}
-    (Empty))
+{+(Call
+  {+(Identifier)+}
+  {+(TextElement)+}
+  {+(Empty)+})+}
   (Call
     (Identifier)
     (TextElement)
   {+(Null)+}
-  {-(Identifier)-}
   {-(Identifier)-}
     (Empty))
   (Call
     (Identifier)
-  { (TextElement)
-  ->(TextElement) }
+    (TextElement)
   {+(Identifier)+}
-  {+(Identifier)+}
-    (Empty)))
+    (Identifier)
+  {-(Identifier)-}
+    (Empty))
+{-(Call
+  {-(Identifier)-}
+  {-(TextElement)-}
+  {-(Empty)-})-})

test/fixtures/python/corpus/float.diffA-B.txt

@@ -8,11 +8,11 @@
 {+(Float)+}
 {+(Float)+}
 {+(Float)+}
+{ (Float)
+->(Float) }
 {+(Float)+}
 {+(Float)+}
 {+(Float)+}
-{+(Float)+}
-{-(Float)-}
 {-(Float)-}
 {-(Float)-}
 {-(Float)-}

test/fixtures/python/corpus/float.diffB-A.txt

@@ -5,15 +5,15 @@
 { (Float)
 ->(Float) }
 {+(Float)+}
-{+(Float)+}
-{+(Float)+}
 { (Float)
 ->(Float) }
 {+(Float)+}
 {+(Float)+}
 {+(Float)+}
 {+(Float)+}
-{-(Float)-}
+{+(Float)+}
+{ (Float)
+->(Float) }
 {-(Float)-}
 {-(Float)-}
 {-(Float)-}

test/fixtures/python/corpus/import-from-statement.diffA-B.txt

@@ -1,11 +1,11 @@
 (Statements
+{+(Import)+}
+{+(Import)+}
+{+(Import)+}
+{+(Import)+}
 { (Import)
 ->(Import) }
 {+(Import)+}
-{+(Import)+}
-{+(Import)+}
-{+(Import)+}
-{+(Import)+}
 {-(Import)-}
 {-(Import)-}
 {-(Import)-}

test/fixtures/python/corpus/import-from-statement.diffB-A.txt

@@ -1,11 +1,11 @@
 (Statements
+{+(Import)+}
 { (Import)
 ->(Import) }
 {+(Import)+}
 {+(Import)+}
-{+(Import)+}
-{+(Import)+}
-{-(Import)-}
+{ (Import)
+->(Import) }
 {-(Import)-}
 {-(Import)-}
 {-(Import)-}

test/fixtures/python/corpus/integer.diffB-A.txt

@@ -13,11 +13,11 @@
 {+(Integer)+}
 {+(Integer)+}
 {+(Integer)+}
-{ (Integer)
-->(Integer) }
 {+(Integer)+}
 {+(Integer)+}
 {+(Integer)+}
+{+(Integer)+}
+{-(Integer)-}
 {-(Negate
   {-(Integer)-})-}
 {-(Integer)-}

test/fixtures/python/corpus/string.diffA-B.txt

@@ -1,12 +1,12 @@
 (Statements
 {+(TextElement)+}
   (TextElement)
+{+(TextElement)+}
+{+(TextElement)+}
 { (TextElement)
 ->(TextElement) }
 {+(TextElement)+}
 {+(TextElement)+}
-{+(TextElement)+}
-{+(TextElement)+}
 {-(TextElement)-}
 {-(TextElement)-}
 {-(TextElement)-}

test/fixtures/python/corpus/string.diffB-A.txt

@@ -1,15 +1,15 @@
 (Statements
 {-(TextElement)-}
   (TextElement)
-{ (TextElement)
-->(TextElement) }
-{+(TextElement)+}
 {+(TextElement)+}
 { (TextElement)
 ->(TextElement) }
 {+(TextElement)+}
-{ (TextElement)
-->(TextElement) }
+{+(TextElement)+}
+{+(TextElement)+}
+{+(TextElement)+}
+{-(TextElement)-}
+{-(TextElement)-}
 {-(TextElement)-}
 {-(TextElement)-}
   (TextElement)

test/fixtures/python/corpus/unary-operator.diffB-A.txt

@@ -2,10 +2,9 @@
 {+(Negate
   {+(Identifier)+})+}
 {+(Identifier)+}
-{+(Complement
-  {+(Identifier)+})+}
-{-(Complement
-  {-(Identifier)-})-}
+  (Complement
+  { (Identifier)
+  ->(Identifier) })
 {-(Negate
   {-(Identifier)-})-}
 {-(Identifier)-})

test/fixtures/ruby/corpus/and-or.diffA-B.txt

@@ -1,13 +1,13 @@
 (Statements
-{+(LowOr
+{+(LowPrecedenceOr
   {+(Send
     {+(Identifier)+})+}
   {+(Send
     {+(Identifier)+})+})+}
-  (LowAnd
+  (LowPrecedenceAnd
   { (Send
     {-(Identifier)-})
-  ->(LowOr
+  ->(LowPrecedenceOr
     {+(Send
       {+(Identifier)+})+}
     {+(Send

test/fixtures/ruby/corpus/and-or.diffB-A.txt

@@ -1,16 +1,16 @@
 (Statements
-{+(LowAnd
+{+(LowPrecedenceAnd
   {+(Send
     {+(Identifier)+})+}
   {+(Send
     {+(Identifier)+})+})+}
-{-(LowOr
+{-(LowPrecedenceOr
   {-(Send
     {-(Identifier)-})-}
   {-(Send
     {-(Identifier)-})-})-}
-{-(LowAnd
-  {-(LowOr
+{-(LowPrecedenceAnd
+  {-(LowPrecedenceOr
     {-(Send
       {-(Identifier)-})-}
     {-(Send

test/fixtures/ruby/corpus/and-or.parseA.txt

@@ -1,5 +1,5 @@
 (Statements
-  (LowAnd
+  (LowPrecedenceAnd
     (Send
       (Identifier))
     (Send

test/fixtures/ruby/corpus/and-or.parseB.txt

@@ -1,11 +1,11 @@
 (Statements
-  (LowOr
+  (LowPrecedenceOr
     (Send
       (Identifier))
     (Send
       (Identifier)))
-  (LowAnd
-    (LowOr
+  (LowPrecedenceAnd
+    (LowPrecedenceOr
       (Send
         (Identifier))
       (Send

test/fixtures/ruby/corpus/binary.parseA.txt

@@ -4,12 +4,12 @@
       (Identifier))
     (Send
       (Identifier)))
-  (LowAnd
+  (LowPrecedenceAnd
     (Send
       (Identifier))
     (Send
       (Identifier)))
-  (LowOr
+  (LowPrecedenceOr
     (Send
       (Identifier))
     (Send

test/fixtures/ruby/corpus/bitwise-operator.diffA-B.txt

@@ -1,19 +1,19 @@
 (Statements
-{ (BOr
-  {-(Send
-    {-(Identifier)-})-}
-  {-(Send
-    {-(Identifier)-})-})
-->(BAnd
+{+(BAnd
   {+(Send
     {+(Identifier)+})+}
   {+(Send
-    {+(Identifier)+})+}) }
+    {+(Identifier)+})+})+}
 {+(LShift
   {+(Send
     {+(Identifier)+})+}
   {+(Send
     {+(Identifier)+})+})+}
+{-(BOr
+  {-(Send
+    {-(Identifier)-})-}
+  {-(Send
+    {-(Identifier)-})-})-}
 {-(RShift
   {-(Send
     {-(Identifier)-})-}

test/fixtures/ruby/corpus/bitwise-operator.diffB-A.txt

@@ -1,14 +1,9 @@
 (Statements
-{ (BAnd
-  {-(Send
-    {-(Identifier)-})-}
-  {-(Send
-    {-(Identifier)-})-})
-->(BOr
+{+(BOr
   {+(Send
     {+(Identifier)+})+}
   {+(Send
-    {+(Identifier)+})+}) }
+    {+(Identifier)+})+})+}
 {+(RShift
   {+(Send
     {+(Identifier)+})+}
@@ -19,6 +14,11 @@
     {+(Identifier)+})+}
   {+(Send
     {+(Identifier)+})+})+}
+{-(BAnd
+  {-(Send
+    {-(Identifier)-})-}
+  {-(Send
+    {-(Identifier)-})-})-}
 {-(LShift
   {-(Send
     {-(Identifier)-})-}

test/fixtures/ruby/corpus/boolean-operator.diffA-B.txt

@@ -1,11 +1,11 @@
 (Statements
-{ (Or
-  {-(Send
-    {-(Identifier)-})-}
-  {-(Send
-    {-(Identifier)-})-})
-->(And
+{+(And
   {+(Send
     {+(Identifier)+})+}
   {+(Send
-    {+(Identifier)+})+}) })
+    {+(Identifier)+})+})+}
+{-(Or
+  {-(Send
+    {-(Identifier)-})-}
+  {-(Send
+    {-(Identifier)-})-})-})

test/fixtures/ruby/corpus/boolean-operator.diffB-A.txt

@@ -1,11 +1,11 @@
 (Statements
-{ (And
-  {-(Send
-    {-(Identifier)-})-}
-  {-(Send
-    {-(Identifier)-})-})
-->(Or
+{+(Or
   {+(Send
     {+(Identifier)+})+}
   {+(Send
-    {+(Identifier)+})+}) })
+    {+(Identifier)+})+})+}
+{-(And
+  {-(Send
+    {-(Identifier)-})-}
+  {-(Send
+    {-(Identifier)-})-})-})

test/fixtures/ruby/corpus/comparision-operator.diffA-B.txt

@@ -1,19 +1,19 @@
 (Statements
-{ (LessThan
-  {-(Send
-    {-(Identifier)-})-}
-  {-(Send
-    {-(Identifier)-})-})
-->(LessThanEqual
+{+(LessThanEqual
   {+(Send
     {+(Identifier)+})+}
   {+(Send
-    {+(Identifier)+})+}) }
+    {+(Identifier)+})+})+}
 {+(GreaterThanEqual
   {+(Send
     {+(Identifier)+})+}
   {+(Send
     {+(Identifier)+})+})+}
+{-(LessThan
+  {-(Send
+    {-(Identifier)-})-}
+  {-(Send
+    {-(Identifier)-})-})-}
 {-(GreaterThan
   {-(Send
     {-(Identifier)-})-}

test/fixtures/ruby/corpus/comparision-operator.diffB-A.txt

@@ -1,19 +1,19 @@
 (Statements
-{ (LessThanEqual
-  {-(Send
-    {-(Identifier)-})-}
-  {-(Send
-    {-(Identifier)-})-})
-->(LessThan
+{+(LessThan
   {+(Send
     {+(Identifier)+})+}
   {+(Send
-    {+(Identifier)+})+}) }
+    {+(Identifier)+})+})+}
 {+(GreaterThan
   {+(Send
     {+(Identifier)+})+}
   {+(Send
     {+(Identifier)+})+})+}
+{-(LessThanEqual
+  {-(Send
+    {-(Identifier)-})-}
+  {-(Send
+    {-(Identifier)-})-})-}
 {-(GreaterThanEqual
   {-(Send
     {-(Identifier)-})-}

test/fixtures/ruby/corpus/delimiter.diffA-B.txt

@@ -1,12 +1,12 @@
 (Statements
 {+(TextElement)+}
 {+(TextElement)+}
-{ (TextElement)
-->(TextElement) }
-{ (TextElement)
-->(TextElement) }
 {+(TextElement)+}
 {+(TextElement)+}
+{+(TextElement)+}
+{+(TextElement)+}
+{-(TextElement)-}
+{-(TextElement)-}
 {-(TextElement)-}
 {-(TextElement)-}
 {-(TextElement)-}

test/fixtures/ruby/corpus/delimiter.diffB-A.txt

@@ -4,8 +4,8 @@
 {+(TextElement)+}
 {+(TextElement)+}
 {+(TextElement)+}
-{ (TextElement)
-->(TextElement) }
+{+(TextElement)+}
+{-(TextElement)-}
 {-(TextElement)-}
 {-(TextElement)-}
 {-(TextElement)-}

test/fixtures/ruby/corpus/hash.diffA-B.txt

@@ -1,23 +1,20 @@
 (Statements
   (Hash
-  {+(KeyValue
-    {+(Symbol)+}
-    {+(TextElement)+})+}
-  {+(KeyValue
-    {+(Symbol)+}
-    {+(Integer)+})+}
-  {+(KeyValue
-    {+(Symbol)+}
-    {+(Boolean)+})+}
-  {-(KeyValue
-    {-(Symbol)-}
-    {-(TextElement)-})-}
-  {-(KeyValue
-    {-(Symbol)-}
-    {-(Integer)-})-}
-  {-(KeyValue
-    {-(TextElement)-}
-    {-(Boolean)-})-}
+    (KeyValue
+    { (Symbol)
+    ->(Symbol) }
+    { (TextElement)
+    ->(TextElement) })
+    (KeyValue
+    { (Symbol)
+    ->(Symbol) }
+    { (Integer)
+    ->(Integer) })
+    (KeyValue
+    { (TextElement)
+    ->(Symbol) }
+    { (Boolean)
+    ->(Boolean) })
   {-(KeyValue
     {-(Symbol)-}
     {-(Integer)-})-})

test/fixtures/ruby/corpus/hash.diffB-A.txt

@@ -1,25 +1,23 @@
 (Statements
   (Hash
-  {+(KeyValue
-    {+(Symbol)+}
-    {+(TextElement)+})+}
     (KeyValue
     { (Symbol)
     ->(Symbol) }
     { (TextElement)
+    ->(TextElement) })
+    (KeyValue
+    { (Symbol)
+    ->(Symbol) }
+    { (Integer)
     ->(Integer) })
-  {+(KeyValue
-    {+(TextElement)+}
-    {+(Boolean)+})+}
+    (KeyValue
+    { (Symbol)
+    ->(TextElement) }
+    { (Boolean)
+    ->(Boolean) })
   {+(KeyValue
     {+(Symbol)+}
-    {+(Integer)+})+}
-  {-(KeyValue
-    {-(Symbol)-}
-    {-(Integer)-})-}
-  {-(KeyValue
-    {-(Symbol)-}
-    {-(Boolean)-})-})
+    {+(Integer)+})+})
 {+(Hash)+}
 {+(Hash
   {+(Context

test/fixtures/ruby/corpus/number.diffA-B.txt

@@ -1,5 +1,6 @@
 (Statements
-{+(Integer)+}
+{ (Integer)
+->(Integer) }
 {+(Integer)+}
 {+(Integer)+}
 {+(Integer)+}
@@ -11,5 +12,4 @@
 {-(Integer)-}
 {-(Integer)-}
 {-(Integer)-}
-{-(Integer)-}
 {-(Float)-})

test/fixtures/ruby/corpus/number.diffB-A.txt

@@ -1,15 +1,15 @@
 (Statements
+{ (Integer)
+->(Integer) }
 {+(Integer)+}
 { (Integer)
 ->(Integer) }
 {+(Integer)+}
-{+(Integer)+}
-{+(Integer)+}
 { (Integer)
 ->(Integer) }
+{+(Integer)+}
 {+(Float)+}
 {-(Integer)-}
 {-(Integer)-}
 {-(Integer)-}
-{-(Integer)-}
 {-(Float)-})

test/fixtures/ruby/corpus/relational-operator.diffA-B.txt

@@ -1,14 +1,9 @@
 (Statements
-{ (Equal
-  {-(Send
-    {-(Identifier)-})-}
-  {-(Send
-    {-(Identifier)-})-})
-->(Comparison
+{+(Comparison
   {+(Send
     {+(Identifier)+})+}
   {+(Send
-    {+(Identifier)+})+}) }
+    {+(Identifier)+})+})+}
 {+(Matches
   {+(Send
     {+(Identifier)+})+}
@@ -19,6 +14,11 @@
   {+(Not
     {+(Send
       {+(Identifier)+})+})+})+}
+{-(Equal
+  {-(Send
+    {-(Identifier)-})-}
+  {-(Send
+    {-(Identifier)-})-})-}
 {-(Not
   {-(Equal
     {-(Send

test/fixtures/ruby/corpus/relational-operator.diffB-A.txt

@@ -1,14 +1,9 @@
 (Statements
-{ (Comparison
-  {-(Send
-    {-(Identifier)-})-}
-  {-(Send
-    {-(Identifier)-})-})
-->(Equal
+{+(Equal
   {+(Send
     {+(Identifier)+})+}
   {+(Send
-    {+(Identifier)+})+}) }
+    {+(Identifier)+})+})+}
 {+(Not
   {+(Equal
     {+(Send
@@ -20,6 +15,11 @@
     {+(Identifier)+})+}
   {+(Send
     {+(Identifier)+})+})+}
+{-(Comparison
+  {-(Send
+    {-(Identifier)-})-}
+  {-(Send
+    {-(Identifier)-})-})-}
 {-(Matches
   {-(Send
     {-(Identifier)-})-}

test/fixtures/ruby/corpus/symbol.diffA-B.txt

@@ -1,7 +1,7 @@
 (Statements
+{+(Symbol)+}
 { (Symbol)
 ->(Symbol) }
 { (Symbol)
 ->(Symbol) }
-{ (Symbol)
-->(Symbol) })
+{-(Symbol)-})

test/fixtures/ruby/corpus/symbol.diffB-A.txt

@@ -1,7 +1,7 @@
 (Statements
-{ (Symbol)
-->(Symbol) }
-{ (Symbol)
-->(Symbol) }
-{ (Symbol)
-->(Symbol) })
+{+(Symbol)+}
+{+(Symbol)+}
+{+(Symbol)+}
+{-(Symbol)-}
+{-(Symbol)-}
+{-(Symbol)-})

test/fixtures/typescript/corpus/boolean-operator.diffA-B.txt

@@ -1,7 +1,7 @@
 (Statements
-{ (Or
-  {-(Identifier)-}
-  {-(Identifier)-})
-->(And
+{+(And
   {+(Identifier)+}
-  {+(Identifier)+}) })
+  {+(Identifier)+})+}
+{-(Or
+  {-(Identifier)-}
+  {-(Identifier)-})-})

test/fixtures/typescript/corpus/boolean-operator.diffB-A.txt

@@ -1,7 +1,7 @@
 (Statements
-{ (And
-  {-(Identifier)-}
-  {-(Identifier)-})
-->(Or
+{+(Or
   {+(Identifier)+}
-  {+(Identifier)+}) })
+  {+(Identifier)+})+}
+{-(And
+  {-(Identifier)-}
+  {-(Identifier)-})-})

test/fixtures/typescript/corpus/export.diffA-B.txt

@@ -35,15 +35,15 @@
         (Identifier)
       { (Empty)
       ->(Identifier) })
+    {+(Assignment
+      {+(Empty)+}
+      {+(Identifier)+}
+      {+(Empty)+})+}
       (Assignment
         (Empty)
       { (Identifier)
       ->(Identifier) }
-        (Empty))
-    {+(Assignment
-      {+(Empty)+}
-      {+(Identifier)+}
-      {+(Empty)+})+}))
+        (Empty))))
   (DefaultExport
   { (Identifier)
   ->(Identifier) })

test/fixtures/typescript/corpus/export.diffB-A.txt

@@ -35,11 +35,14 @@
         (Identifier)
       { (Identifier)
       ->(Empty) })
-      (Assignment
-        (Empty)
-      { (Identifier)
-      ->(Identifier) }
-        (Empty))
+    {+(Assignment
+      {+(Empty)+}
+      {+(Identifier)+}
+      {+(Empty)+})+}
+    {-(Assignment
+      {-(Empty)-}
+      {-(Identifier)-}
+      {-(Empty)-})-}
     {-(Assignment
       {-(Empty)-}
       {-(Identifier)-}

test/fixtures/typescript/corpus/import.diffA-B.txt

@@ -1,12 +1,8 @@
 (Statements
-{ (Import)
-->(Import) }
-{ (QualifiedAliasedImport
-  {-(Identifier)-})
-->(QualifiedAliasedImport
-  {+(Identifier)+}) }
-{ (Import)
-->(Import) }
+{+(Import)+}
+{+(QualifiedAliasedImport
+  {+(Identifier)+})+}
+{+(Import)+}
 {+(Import)+}
 {+(Import)+}
 {+(Statements
@@ -18,6 +14,10 @@
     {+(Identifier)+})+})+}
 {+(SideEffectImport)+}
 {-(Import)-}
+{-(QualifiedAliasedImport
+  {-(Identifier)-})-}
+{-(Import)-}
+{-(Import)-}
 {-(Import)-}
 {-(Statements
   {-(Import)-}

test/fixtures/typescript/corpus/import.diffB-A.txt

@@ -1,13 +1,10 @@
 (Statements
-{ (Import)
-->(Import) }
-{ (QualifiedAliasedImport
-  {-(Identifier)-})
-->(QualifiedAliasedImport
-  {+(Identifier)+}) }
-{ (Import)
-->(Import) }
 {+(Import)+}
+{+(QualifiedAliasedImport
+  {+(Identifier)+})+}
+{+(Import)+}
+{ (Import)
+->(Import) }
 {+(Import)+}
 {+(Statements
   {+(Import)+}
@@ -19,6 +16,9 @@
 {+(SideEffectImport)+}
 {+(QualifiedAliasedImport
   {+(Identifier)+})+}
+{-(QualifiedAliasedImport
+  {-(Identifier)-})-}
+{-(Import)-}
 {-(Import)-}
 {-(Import)-}
 {-(Statements

test/fixtures/typescript/corpus/public-field-definition.diffA-B.txt

@@ -59,28 +59,43 @@
           (TypeIdentifier))
         (Identifier)
         (Float))
-      (PublicFieldDefinition
+    {+(PublicFieldDefinition
       {+(Identifier)+}
+      {+(Readonly)+}
+      {+(Annotation
+        {+(TypeIdentifier)+})+}
+      {+(Identifier)+}
+      {+(TextElement)+})+}
+    {+(PublicFieldDefinition
+      {+(Empty)+}
+      {+(Empty)+}
+      {+(Annotation
+        {+(TypeIdentifier)+})+}
+      {+(Identifier)+}
+      {+(Float)+})+}
+    {+(PublicFieldDefinition
+      {+(Empty)+}
+      {+(Empty)+}
+      {+(Empty)+}
+      {+(Identifier)+}
+      {+(Float)+})+}
+    {-(PublicFieldDefinition
       {-(Empty)-}
-        (Readonly)
-        (Annotation
-        { (TypeIdentifier)
-        ->(TypeIdentifier) })
-        (Identifier)
-      { (Float)
-      ->(TextElement) })
-      (PublicFieldDefinition
-        (Empty)
-        (Empty)
-        (Annotation
-          (TypeIdentifier))
-      { (Identifier)
-      ->(Identifier) }
-        (Float))
-      (PublicFieldDefinition
-        (Empty)
-        (Empty)
-        (Empty)
-        (Identifier)
-      { (Float)
-      ->(Float) }))))
+      {-(Readonly)-}
+      {-(Annotation
+        {-(TypeIdentifier)-})-}
+      {-(Identifier)-}
+      {-(Float)-})-}
+    {-(PublicFieldDefinition
+      {-(Empty)-}
+      {-(Empty)-}
+      {-(Annotation
+        {-(TypeIdentifier)-})-}
+      {-(Identifier)-}
+      {-(Float)-})-}
+    {-(PublicFieldDefinition
+      {-(Empty)-}
+      {-(Empty)-}
+      {-(Empty)-}
+      {-(Identifier)-}
+      {-(Float)-})-})))

test/fixtures/typescript/corpus/public-field-definition.diffB-A.txt

@@ -59,28 +59,43 @@
           (TypeIdentifier))
         (Identifier)
         (Float))
-      (PublicFieldDefinition
+    {+(PublicFieldDefinition
       {+(Empty)+}
+      {+(Readonly)+}
+      {+(Annotation
+        {+(TypeIdentifier)+})+}
+      {+(Identifier)+}
+      {+(Float)+})+}
+    {+(PublicFieldDefinition
+      {+(Empty)+}
+      {+(Empty)+}
+      {+(Annotation
+        {+(TypeIdentifier)+})+}
+      {+(Identifier)+}
+      {+(Float)+})+}
+    {+(PublicFieldDefinition
+      {+(Empty)+}
+      {+(Empty)+}
+      {+(Empty)+}
+      {+(Identifier)+}
+      {+(Float)+})+}
+    {-(PublicFieldDefinition
       {-(Identifier)-}
-        (Readonly)
-        (Annotation
-        { (TypeIdentifier)
-        ->(TypeIdentifier) })
-        (Identifier)
-      { (TextElement)
-      ->(Float) })
-      (PublicFieldDefinition
-        (Empty)
-        (Empty)
-        (Annotation
-          (TypeIdentifier))
-      { (Identifier)
-      ->(Identifier) }
-        (Float))
-      (PublicFieldDefinition
-        (Empty)
-        (Empty)
-        (Empty)
-        (Identifier)
-      { (Float)
-      ->(Float) }))))
+      {-(Readonly)-}
+      {-(Annotation
+        {-(TypeIdentifier)-})-}
+      {-(Identifier)-}
+      {-(TextElement)-})-}
+    {-(PublicFieldDefinition
+      {-(Empty)-}
+      {-(Empty)-}
+      {-(Annotation
+        {-(TypeIdentifier)-})-}
+      {-(Identifier)-}
+      {-(Float)-})-}
+    {-(PublicFieldDefinition
+      {-(Empty)-}
+      {-(Empty)-}
+      {-(Empty)-}
+      {-(Identifier)-}
+      {-(Float)-})-})))

test/fixtures/typescript/corpus/relational-operator.diffA-B.txt

@@ -1,7 +1,7 @@
 (Statements
-{ (LessThan
-  {-(Identifier)-}
-  {-(Identifier)-})
-->(LessThanEqual
+{+(LessThanEqual
   {+(Identifier)+}
-  {+(Identifier)+}) })
+  {+(Identifier)+})+}
+{-(LessThan
+  {-(Identifier)-}
+  {-(Identifier)-})-})

test/fixtures/typescript/corpus/relational-operator.diffB-A.txt

@@ -1,7 +1,7 @@
 (Statements
-{ (LessThanEqual
-  {-(Identifier)-}
-  {-(Identifier)-})
-->(LessThan
+{+(LessThan
   {+(Identifier)+}
-  {+(Identifier)+}) })
+  {+(Identifier)+})+}
+{-(LessThanEqual
+  {-(Identifier)-}
+  {-(Identifier)-})-})