Merge remote-tracking branch 'origin/master' into charliesome/ruby-method-calls

src/Language/Ruby/Assignment.hs

@@ -74,7 +74,6 @@ type Syntax = '[
   , Syntax.Identifier
   , Syntax.Paren
   , Syntax.Program
-  , Ruby.Syntax.Send
   , Ruby.Syntax.Class
   , Ruby.Syntax.Load
   , Ruby.Syntax.LowPrecedenceBoolean
@@ -84,8 +83,7 @@ type Syntax = '[
   ]
 
 type Term = Term.Term (Union Syntax) (Record Location)
-type Assignment' a = HasCallStack => Assignment.Assignment [] Grammar a
-type Assignment = Assignment' Term
+type Assignment = HasCallStack => Assignment.Assignment [] Grammar Term
 
 -- | Assignment from AST in Ruby’s grammar onto a program in Ruby’s syntax.
 assignment :: Assignment
@@ -293,12 +291,9 @@ pair :: Assignment
 pair =   makeTerm <$> symbol Pair <*> children (Literal.KeyValue <$> expression <*> (expression <|> emptyTerm))
 
 methodCall :: Assignment
-methodCall = makeTerm' <$> symbol MethodCall <*> children (require <|> load <|> funcCall <|> regularCall)
+methodCall = makeTerm' <$> symbol MethodCall <*> children (require <|> load <|> regularCall)
   where
-    funcCall = inj <$> (Ruby.Syntax.Send Nothing <$> methodSelector <*> args <*> optional block)
-
-    regularCall = inj <$> (symbol Call *> children (Ruby.Syntax.Send <$> (Just <$> expression) <*> methodSelector) <*> args <*> optional block)
-
+    regularCall = inj <$> (Expression.Call <$> pure [] <*> expression <*> args <*> (block <|> emptyTerm))
     require = inj <$> (symbol Identifier *> do
       s <- source
       guard (s `elem` ["require", "require_relative"])
@@ -307,17 +302,14 @@ methodCall = makeTerm' <$> symbol MethodCall <*> children (require <|> load <|>
       s <- source
       guard (s == "load")
       Ruby.Syntax.Load <$> loadArgs)
-    args = (symbol ArgumentList <|> symbol ArgumentListWithParens) *> children (many expression) <|> many expression
+    args = (symbol ArgumentList <|> symbol ArgumentListWithParens) *> children (many expression) <|> pure []
     loadArgs = (symbol ArgumentList <|> symbol ArgumentListWithParens)  *> children (some expression)
     nameExpression = (symbol ArgumentList <|> symbol ArgumentListWithParens) *> children expression
 
-methodSelector :: Assignment
-methodSelector = mk Identifier <|> mk Identifier'
-  where
-    mk s = makeTerm <$> symbol s <*> (Syntax.Identifier <$> (name <$> source))
-
 call :: Assignment
-call = makeTerm <$> symbol Call <*> children (Ruby.Syntax.Send <$> (Just <$> expression) <*> methodSelector <*> pure [] <*> optional block)
+call = makeTerm <$> symbol Call <*> children (Expression.MemberAccess <$> expression <*> (expressions <|> args))
+  where
+    args = (symbol ArgumentList <|> symbol ArgumentListWithParens) *> children expressions
 
 rescue :: Assignment
 rescue =  rescue'

src/Language/Ruby/Syntax.hs

@@ -36,22 +36,6 @@ maybeFailNotFound name = maybeFail notFound
 cleanNameOrPath :: ByteString -> String
 cleanNameOrPath = BC.unpack . dropRelativePrefix . stripQuotes
 
-data Send a = Send { sendReceiver :: Maybe a, sendSelector :: a, sendArgs :: [a], sendBlock :: Maybe a }
-  deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Mergeable, Ord, Show, Traversable, FreeVariables1)
-
-instance Eq1 Send where liftEq = genericLiftEq
-instance Ord1 Send where liftCompare = genericLiftCompare
-instance Show1 Send where liftShowsPrec = genericLiftShowsPrec
-
-instance Evaluatable Send where
-  eval Send{..} = do
-    func <- case sendReceiver of
-      Just recv -> do
-        recvEnv <- subtermValue recv >>= scopedEnvironment
-        localEnv (mappend recvEnv) (subtermValue sendSelector)
-      Nothing -> subtermValue sendSelector -- TODO Does this require `localize` so we don't leak terms when resolving `sendSelector`?
-    call func (map subtermValue sendArgs) -- TODO pass through sendBlock
-
 data Require a = Require { requireRelative :: Bool, requirePath :: !a }
   deriving (Diffable, Eq, Foldable, Functor, GAlign, Generic1, Mergeable, Ord, Show, Traversable, FreeVariables1)
 

test/fixtures/ruby/begin.diffA-B.txt

@@ -5,6 +5,7 @@
     (
       (Try
       { ([])
-      ->(Send
+      ->(Call
         {+(Identifier)+}
-        {+(TextElement)+}) }))))
+        {+(TextElement)+}
+        {+(Empty)+}) }))))

test/fixtures/ruby/begin.diffB-A.txt

@@ -4,7 +4,8 @@
     (Identifier)
     (
       (Try
-      { (Send
+      { (Call
         {-(Identifier)-}
-        {-(TextElement)-})
+        {-(TextElement)-}
+        {-(Empty)-})
       ->([]) }))))

test/fixtures/ruby/begin.parseB.txt

@@ -4,6 +4,7 @@
     (Identifier)
     (
       (Try
-        (Send
+        (Call
           (Identifier)
-          (TextElement))))))
+          (TextElement)
+          (Empty))))))

test/fixtures/ruby/else.diffA-B.txt

@@ -1,10 +1,12 @@
 (Program
   (Try
     (
-      (Send
-        (Identifier))
+      (Call
+        (Identifier)
+        (Empty))
       (Else
         (Empty)
       { ([])
-      ->(Send
-        {+(Identifier)+}) }))))
+      ->(Call
+        {+(Identifier)+}
+        {+(Empty)+}) }))))

test/fixtures/ruby/else.diffB-A.txt

@@ -1,10 +1,12 @@
 (Program
   (Try
     (
-      (Send
-        (Identifier))
+      (Call
+        (Identifier)
+        (Empty))
       (Else
         (Empty)
-      { (Send
-        {-(Identifier)-})
+      { (Call
+        {-(Identifier)-}
+        {-(Empty)-})
       ->([]) }))))

test/fixtures/ruby/else.parseA.txt

@@ -1,8 +1,9 @@
 (Program
   (Try
     (
-      (Send
-        (Identifier))
+      (Call
+        (Identifier)
+        (Empty))
       (Else
         (Empty)
         ([])))))

test/fixtures/ruby/else.parseB.txt

@@ -1,9 +1,11 @@
 (Program
   (Try
     (
-      (Send
-        (Identifier))
+      (Call
+        (Identifier)
+        (Empty))
       (Else
         (Empty)
-        (Send
-          (Identifier))))))
+        (Call
+          (Identifier)
+          (Empty))))))

test/fixtures/ruby/elsif.diffA-B.txt

@@ -2,11 +2,13 @@
   (If
     (Identifier)
     (
-      (Send
-        (Identifier)))
+      (Call
+        (Identifier)
+        (Empty)))
     (If
       (Identifier)
       (
-      {+(Send
-        {+(Identifier)+})+})
+      {+(Call
+        {+(Identifier)+}
+        {+(Empty)+})+})
       (Empty))))

test/fixtures/ruby/elsif.diffB-A.txt

@@ -2,11 +2,13 @@
   (If
     (Identifier)
     (
-      (Send
-        (Identifier)))
+      (Call
+        (Identifier)
+        (Empty)))
     (If
       (Identifier)
       ([]
-      {-(Send
-        {-(Identifier)-})-})
+      {-(Call
+        {-(Identifier)-}
+        {-(Empty)-})-})
       (Empty))))

test/fixtures/ruby/elsif.parseA.txt

@@ -2,8 +2,9 @@
   (If
     (Identifier)
     (
-      (Send
-        (Identifier)))
+      (Call
+        (Identifier)
+        (Empty)))
     (If
       (Identifier)
       ([])

test/fixtures/ruby/elsif.parseB.txt

@@ -2,11 +2,13 @@
   (If
     (Identifier)
     (
-      (Send
-        (Identifier)))
+      (Call
+        (Identifier)
+        (Empty)))
     (If
       (Identifier)
       (
-        (Send
-          (Identifier)))
+        (Call
+          (Identifier)
+          (Empty)))
       (Empty))))

test/fixtures/ruby/for.diffA-B.txt

@@ -6,9 +6,10 @@
     {+(Integer)+}
     {+(Integer)+}
     {+(Integer)+})+}
-  {+(Send
+  {+(Call
     {+(Identifier)+}
-    {+(Identifier)+})+})+}
+    {+(Identifier)+}
+    {+(Empty)+})+})+}
 {-(ForEach
   {-(
     {-(Identifier)-})-}

test/fixtures/ruby/for.diffB-A.txt

@@ -22,9 +22,10 @@
     {+(Integer)+}
     {+(Integer)+}
     {+(Empty)+}) }
-  { (Send
+  { (Call
     {-(Identifier)-}
-    {-(Identifier)-})
+    {-(Identifier)-}
+    {-(Empty)-})
   ->(Boolean) })
 {+(ForEach
   {+(

test/fixtures/ruby/for.parseB.txt

@@ -6,6 +6,7 @@
       (Integer)
       (Integer)
       (Integer))
-    (Send
+    (Call
       (Identifier)
-      (Identifier))))
+      (Identifier)
+      (Empty))))

test/fixtures/ruby/heredoc.diffA-B.txt

@@ -1,9 +1,12 @@
 (Program
-{+(Send
-  {+(Send
-    {+(Identifier)+}
-    {+(TextElement)+}
-    {+(TextElement)+})+}
-  {+(Identifier)+})+}
+{+(Call
+  {+(MemberAccess
+    {+(Call
+      {+(Identifier)+}
+      {+(TextElement)+}
+      {+(TextElement)+}
+      {+(Empty)+})+}
+    {+(Identifier)+})+}
+  {+(Empty)+})+}
 {-(TextElement)-}
 {-(TextElement)-})

test/fixtures/ruby/heredoc.diffB-A.txt

@@ -1,9 +1,12 @@
 (Program
 {+(TextElement)+}
 {+(TextElement)+}
-{-(Send
-  {-(Send
-    {-(Identifier)-}
-    {-(TextElement)-}
-    {-(TextElement)-})-}
-  {-(Identifier)-})-})
+{-(Call
+  {-(MemberAccess
+    {-(Call
+      {-(Identifier)-}
+      {-(TextElement)-}
+      {-(TextElement)-}
+      {-(Empty)-})-}
+    {-(Identifier)-})-}
+  {-(Empty)-})-})

test/fixtures/ruby/heredoc.parseB.txt

@@ -1,7 +1,10 @@
 (Program
-  (Send
-    (Send
-      (Identifier)
-      (TextElement)
-      (TextElement))
-    (Identifier)))
+  (Call
+    (MemberAccess
+      (Call
+        (Identifier)
+        (TextElement)
+        (TextElement)
+        (Empty))
+      (Identifier))
+    (Empty)))

test/fixtures/ruby/lambda.diffA-B.txt

@@ -1,8 +1,9 @@
 (Program
-{-(Send
+{-(Call
   {-(Identifier)-}
-  {-(Hash)-})-}
-  (Send
+  {-(Hash)-}
+  {-(Empty)-})-}
+  (Call
     (Identifier)
     (Function
       (Empty)
@@ -11,7 +12,7 @@
     ->(Plus
       {+(Identifier)+}
       {+(Integer)+}) }))
-{-(Send
+{-(Call
   {-(Identifier)-}
   {-(Function
     {-(Empty)-}

test/fixtures/ruby/lambda.diffB-A.txt

@@ -1,8 +1,9 @@
 (Program
-{+(Send
+{+(Call
   {+(Identifier)+}
-  {+(Hash)+})+}
-  (Send
+  {+(Hash)+}
+  {+(Empty)+})+}
+  (Call
     (Identifier)
     (Function
       (Empty)
@@ -11,7 +12,7 @@
       {-(Identifier)-}
       {-(Integer)-})
     ->(Identifier) }))
-{+(Send
+{+(Call
   {+(Identifier)+}
   {+(Function
     {+(Empty)+}

test/fixtures/ruby/lambda.parseA.txt

@@ -1,13 +1,14 @@
 (Program
-  (Send
+  (Call
     (Identifier)
-    (Hash))
-  (Send
+    (Hash)
+    (Empty))
+  (Call
     (Identifier)
     (Function
       (Empty)
       (Identifier)))
-  (Send
+  (Call
     (Identifier)
     (Function
       (Empty)

test/fixtures/ruby/lambda.parseB.txt

@@ -1,5 +1,5 @@
 (Program
-  (Send
+  (Call
     (Identifier)
     (Function
       (Empty)

test/fixtures/ruby/method-calls-hash-args.diffA-B.txt

@@ -1,9 +1,10 @@
 (Program
-  (Send
+  (Call
     (Identifier)
     (KeyValue
       (Symbol)
       (Boolean))
   {+(KeyValue
     {+(Symbol)+}
-    {+(Integer)+})+}))
+    {+(Integer)+})+}
+    (Empty)))

test/fixtures/ruby/method-calls-hash-args.diffB-A.txt

@@ -1,9 +1,10 @@
 (Program
-  (Send
+  (Call
     (Identifier)
     (KeyValue
       (Symbol)
       (Boolean))
   {-(KeyValue
     {-(Symbol)-}
-    {-(Integer)-})-}))
+    {-(Integer)-})-}
+    (Empty)))

test/fixtures/ruby/method-calls-hash-args.parseA.txt

@@ -1,6 +1,7 @@
 (Program
-  (Send
+  (Call
     (Identifier)
     (KeyValue
       (Symbol)
-      (Boolean))))
+      (Boolean))
+    (Empty)))

test/fixtures/ruby/method-calls-hash-args.parseB.txt

@@ -1,9 +1,10 @@
 (Program
-  (Send
+  (Call
     (Identifier)
     (KeyValue
       (Symbol)
       (Boolean))
     (KeyValue
       (Symbol)
-      (Integer))))
+      (Integer))
+    (Empty)))

test/fixtures/ruby/method-calls-keyword-args.diffA-B.txt

@@ -1,9 +1,10 @@
 (Program
-  (Send
+  (Call
     (Identifier)
     (KeyValue
       (Identifier)
       (Boolean))
   {+(KeyValue
     {+(Identifier)+}
-    {+(Integer)+})+}))
+    {+(Integer)+})+}
+    (Empty)))

test/fixtures/ruby/method-calls-keyword-args.diffB-A.txt

@@ -1,9 +1,10 @@
 (Program
-  (Send
+  (Call
     (Identifier)
     (KeyValue
       (Identifier)
       (Boolean))
   {-(KeyValue
     {-(Identifier)-}
-    {-(Integer)-})-}))
+    {-(Integer)-})-}
+    (Empty)))

test/fixtures/ruby/method-calls-keyword-args.parseA.txt

@@ -1,6 +1,7 @@
 (Program
-  (Send
+  (Call
     (Identifier)
     (KeyValue
       (Identifier)
-      (Boolean))))
+      (Boolean))
+    (Empty)))

test/fixtures/ruby/method-calls-keyword-args.parseB.txt

@@ -1,9 +1,10 @@
 (Program
-  (Send
+  (Call
     (Identifier)
     (KeyValue
       (Identifier)
       (Boolean))
     (KeyValue
       (Identifier)
-      (Integer))))
+      (Integer))
+    (Empty)))

test/fixtures/ruby/method-calls.diffA-B.txt

@@ -1,9 +1,11 @@
 (Program
-  (Send
-  {-(Identifier)-}
-  { (Identifier)
-  ->(Identifier) })
-{-(Send
+  (Call
+  { (MemberAccess
+    {-(Identifier)-}
+    {-(Identifier)-})
+  ->(Identifier) }
+    (Empty))
+{-(Call
   {-(Identifier)-}
   {-(Identifier)-}
   {-(Identifier)-}
@@ -12,13 +14,16 @@
     {-(Integer)-})-}
   {-(KeyValue
     {-(Identifier)-}
-    {-(Integer)-})-})-}
-{-(Send
+    {-(Integer)-})-}
+  {-(Empty)-})-}
+{-(Call
   {-(Identifier)-}
-  {-(Send
+  {-(Call
     {-(Identifier)-}
-    {-(Identifier)-})-})-}
-{-(Send
+    {-(Identifier)-}
+    {-(Empty)-})-}
+  {-(Empty)-})-}
+{-(Call
   {-(Identifier)-}
   {-(KeyValue
     {-(Array)-}
@@ -30,4 +35,5 @@
     {-(Identifier)-}
     {-(Function
       {-(Empty)-}
-      {-(Integer)-})-})-})-})
+      {-(Integer)-})-})-}
+  {-(Empty)-})-})

test/fixtures/ruby/method-calls.diffB-A.txt

@@ -1,9 +1,11 @@
 (Program
-  (Send
-  {+(Identifier)+}
+  (Call
   { (Identifier)
-  ->(Identifier) })
-{+(Send
+  ->(MemberAccess
+    {+(Identifier)+}
+    {+(Identifier)+}) }
+    (Empty))
+{+(Call
   {+(Identifier)+}
   {+(Identifier)+}
   {+(Identifier)+}
@@ -12,13 +14,16 @@
     {+(Integer)+})+}
   {+(KeyValue
     {+(Identifier)+}
-    {+(Integer)+})+})+}
-{+(Send
+    {+(Integer)+})+}
+  {+(Empty)+})+}
+{+(Call
   {+(Identifier)+}
-  {+(Send
+  {+(Call
     {+(Identifier)+}
-    {+(Identifier)+})+})+}
-{+(Send
+    {+(Identifier)+}
+    {+(Empty)+})+}
+  {+(Empty)+})+}
+{+(Call
   {+(Identifier)+}
   {+(KeyValue
     {+(Array)+}
@@ -30,4 +35,5 @@
     {+(Identifier)+}
     {+(Function
       {+(Empty)+}
-      {+(Integer)+})+})+})+})
+      {+(Integer)+})+})+}
+  {+(Empty)+})+})

test/fixtures/ruby/method-calls.parseA.txt

@@ -1,8 +1,10 @@
 (Program
-  (Send
-    (Identifier)
-    (Identifier))
-  (Send
+  (Call
+    (MemberAccess
+      (Identifier)
+      (Identifier))
+    (Empty))
+  (Call
     (Identifier)
     (Identifier)
     (Identifier)
@@ -11,13 +13,16 @@
       (Integer))
     (KeyValue
       (Identifier)
-      (Integer)))
-  (Send
+      (Integer))
+    (Empty))
+  (Call
     (Identifier)
-    (Send
+    (Call
       (Identifier)
-      (Identifier)))
-  (Send
+      (Identifier)
+      (Empty))
+    (Empty))
+  (Call
     (Identifier)
     (KeyValue
       (Array)
@@ -29,4 +34,5 @@
       (Identifier)
       (Function
         (Empty)
-        (Integer)))))
+        (Integer)))
+    (Empty)))

test/fixtures/ruby/method-calls.parseB.txt

@@ -1,3 +1,4 @@
 (Program
-  (Send
-    (Identifier)))
+  (Call
+    (Identifier)
+    (Empty)))

test/fixtures/ruby/method-invocation.diffA-B.txt

@@ -1,17 +1,25 @@
 (Program
-{+(Send
+{+(Call
   {+(Identifier)+}
-  {+(TextElement)+})+}
+  {+(TextElement)+}
+  {+(Empty)+})+}
+{+(Call
+  {+(MemberAccess
+    {+(Identifier)+}
+    {+(Identifier)+})+}
+  {+(Empty)+})+}
+{+(Call
+  {+(Identifier)+}
+  {+(Integer)+}
+  {+(Integer)+}
+  {+(Empty)+})+}
+{+(Call
+  {+(Identifier)+}
+  {+(Integer)+}
+  {+(Integer)+}
+  {+(Empty)+})+}
 {-(Identifier)-}
-  (Send
-    (Identifier)
-    (Identifier))
-{+(Send
-  {+(Identifier)+}
-  {+(Integer)+}
-  {+(Integer)+})+}
-{+(Send
-  {+(Identifier)+}
-  {+(Integer)+}
-  {+(Integer)+})+}
+{-(MemberAccess
+  {-(Identifier)-}
+  {-(Identifier)-})-}
 {-(Identifier)-})

test/fixtures/ruby/method-invocation.diffB-A.txt

@@ -1,17 +1,25 @@
 (Program
 {+(Identifier)+}
-{-(Send
-  {-(Identifier)-}
-  {-(TextElement)-})-}
-  (Send
-    (Identifier)
-    (Identifier))
+{+(MemberAccess
+  {+(Identifier)+}
+  {+(Identifier)+})+}
 {+(Identifier)+}
-{-(Send
+{-(Call
+  {-(Identifier)-}
+  {-(TextElement)-}
+  {-(Empty)-})-}
+{-(Call
+  {-(MemberAccess
+    {-(Identifier)-}
+    {-(Identifier)-})-}
+  {-(Empty)-})-}
+{-(Call
   {-(Identifier)-}
   {-(Integer)-}
-  {-(Integer)-})-}
-{-(Send
+  {-(Integer)-}
+  {-(Empty)-})-}
+{-(Call
   {-(Identifier)-}
   {-(Integer)-}
-  {-(Integer)-})-})
+  {-(Integer)-}
+  {-(Empty)-})-})

test/fixtures/ruby/method-invocation.parseA.txt

@@ -1,6 +1,6 @@
 (Program
   (Identifier)
-  (Send
+  (MemberAccess
     (Identifier)
     (Identifier))
   (Identifier))

test/fixtures/ruby/method-invocation.parseB.txt

@@ -1,15 +1,20 @@
 (Program
-  (Send
+  (Call
     (Identifier)
-    (TextElement))
-  (Send
-    (Identifier)
-    (Identifier))
-  (Send
+    (TextElement)
+    (Empty))
+  (Call
+    (MemberAccess
+      (Identifier)
+      (Identifier))
+    (Empty))
+  (Call
     (Identifier)
     (Integer)
-    (Integer))
-  (Send
+    (Integer)
+    (Empty))
+  (Call
     (Identifier)
     (Integer)
-    (Integer)))
+    (Integer)
+    (Empty)))

test/fixtures/ruby/multiple-assignments.diffA-B.txt

@@ -37,17 +37,17 @@
   {-(Identifier)-})-}
 {-(Assignment
   {-(
-    {-(Send
+    {-(MemberAccess
       {-(Identifier)-}
       {-(Identifier)-})-}
-    {-(Send
+    {-(MemberAccess
       {-(Identifier)-}
       {-(Identifier)-})-})-}
   {-(
-    {-(Send
+    {-(MemberAccess
       {-(Identifier)-}
       {-(Identifier)-})-}
-    {-(Send
+    {-(MemberAccess
       {-(Identifier)-}
       {-(Identifier)-})-})-})-}
 {-(Assignment

test/fixtures/ruby/multiple-assignments.diffB-A.txt

@@ -37,17 +37,17 @@
   {+(Identifier)+})+}
 {+(Assignment
   {+(
-    {+(Send
+    {+(MemberAccess
       {+(Identifier)+}
       {+(Identifier)+})+}
-    {+(Send
+    {+(MemberAccess
       {+(Identifier)+}
       {+(Identifier)+})+})+}
   {+(
-    {+(Send
+    {+(MemberAccess
       {+(Identifier)+}
       {+(Identifier)+})+}
-    {+(Send
+    {+(MemberAccess
       {+(Identifier)+}
       {+(Identifier)+})+})+})+}
 {+(Assignment

test/fixtures/ruby/multiple-assignments.parseA.txt

@@ -36,17 +36,17 @@
     (Identifier))
   (Assignment
     (
-      (Send
+      (MemberAccess
         (Identifier)
         (Identifier))
-      (Send
+      (MemberAccess
         (Identifier)
         (Identifier)))
     (
-      (Send
+      (MemberAccess
         (Identifier)
         (Identifier))
-      (Send
+      (MemberAccess
         (Identifier)
         (Identifier))))
   (Assignment

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

@@ -1,5 +1,5 @@
 (Program
-{ (Equal
+{(Equal
   {-(Identifier)-}
   {-(Identifier)-})
 ->(Comparison
@@ -10,12 +10,11 @@
   {+(Identifier)+})+}
 {+(Assignment
   {+(Identifier)+}
-  {+(Not
-    {+(Identifier)+})+})+}
+  {+(Not{+(Identifier)+})+})+}
 {-(Not
   {-(Equal
     {-(Identifier)-}
     {-(Identifier)-})-})-}
 {-(Equal
   {-(Identifier)-}
-  {-(Identifier)-})-})
+  {-(Identifier)-})- })

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

@@ -1,5 +1,5 @@
 (Program
-{ (Comparison
+{(Comparison
   {-(Identifier)-}
   {-(Identifier)-})
 ->(Equal
@@ -17,5 +17,4 @@
   {-(Identifier)-})-}
 {-(Assignment
   {-(Identifier)-}
-  {-(Not
-    {-(Identifier)-})-})-})
+  {-(Not{-(Identifier)-})-})- })

test/fixtures/ruby/require.diffA-B.txt

@@ -2,9 +2,10 @@
   (Require
   { (TextElement)
   ->(TextElement) })
-  (Send
+  (Call
   { (Identifier)
   ->(Identifier) }
   {+(Symbol)+}
   {+(TextElement)+}
-  {-(Identifier)-}))
+  {-(Identifier)-}
+    (Empty)))

test/fixtures/ruby/require.diffB-A.txt

@@ -2,9 +2,10 @@
   (Require
   { (TextElement)
   ->(TextElement) })
-  (Send
+  (Call
   { (Identifier)
   ->(Identifier) }
   {+(Identifier)+}
   {-(Symbol)-}
-  {-(TextElement)-}))
+  {-(TextElement)-}
+    (Empty)))

test/fixtures/ruby/require.parseA.txt

@@ -1,6 +1,7 @@
 (Program
   (Require
     (TextElement))
-  (Send
+  (Call
     (Identifier)
-    (Identifier)))
+    (Identifier)
+    (Empty)))

test/fixtures/ruby/require.parseB.txt

@@ -1,7 +1,8 @@
 (Program
   (Require
     (TextElement))
-  (Send
+  (Call
     (Identifier)
     (Symbol)
-    (TextElement)))
+    (TextElement)
+    (Empty)))