Merge pull request #1726 from github/charliesome/ruby-method-calls

Add special Ruby.Syntax.Send node type

src/Language/Ruby/Assignment.hs

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

src/Language/Ruby/Syntax.hs

@@ -36,6 +36,22 @@ 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,7 +5,6 @@
     (
       (Try
       { ([])
-      ->(Call
+      ->(Send
         {+(Identifier)+}
-        {+(TextElement)+}
+        {+(TextElement)+}) }))))
-        {+(Empty)+}) }))))

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

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

test/fixtures/ruby/begin.parseB.txt

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

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

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

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

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

test/fixtures/ruby/else.parseA.txt

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

test/fixtures/ruby/else.parseB.txt

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

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

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

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

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

test/fixtures/ruby/elsif.parseA.txt

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

test/fixtures/ruby/elsif.parseB.txt

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

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

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

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

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

test/fixtures/ruby/for.parseB.txt

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

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

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

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

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

test/fixtures/ruby/heredoc.parseB.txt

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

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

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

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

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

test/fixtures/ruby/lambda.parseA.txt

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

test/fixtures/ruby/lambda.parseB.txt

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -1,5 +1,5 @@
 (Program
-{(Equal
+{ (Equal
   {-(Identifier)-}
   {-(Identifier)-})
 ->(Comparison
@@ -10,11 +10,12 @@
   {+(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,4 +17,5 @@
   {-(Identifier)-})-}
 {-(Assignment
   {-(Identifier)-}
-  {-(Not{-(Identifier)-})-})- })
+  {-(Not
+    {-(Identifier)-})-})-})

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

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

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

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

test/fixtures/ruby/require.parseA.txt

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

test/fixtures/ruby/require.parseB.txt

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