Merge branch 'master' into ruby-binary-unary-fix

src/Analysis/Declaration.hs

@@ -27,10 +27,10 @@ import qualified Language.Markdown.Syntax as Markdown
 data Declaration
   = MethodDeclaration   { declarationIdentifier :: T.Text, declarationText :: T.Text, declarationLanguage :: Maybe Language, declarationReceiver :: Maybe T.Text }
   | ClassDeclaration    { declarationIdentifier :: T.Text, declarationText :: T.Text, declarationLanguage :: Maybe Language }
-  | ImportDeclaration   { declarationIdentifier :: T.Text, declarationAlias :: T.Text, declarationSymbols :: [(T.Text, T.Text)], declarationLanguage :: Maybe Language }
+  | ImportDeclaration   { declarationIdentifier :: T.Text, declarationText :: T.Text, declarationLanguage :: Maybe Language, declarationAlias :: T.Text, declarationSymbols :: [(T.Text, T.Text)] }
   | FunctionDeclaration { declarationIdentifier :: T.Text, declarationText :: T.Text, declarationLanguage :: Maybe Language }
   | HeadingDeclaration  { declarationIdentifier :: T.Text, declarationText :: T.Text, declarationLanguage :: Maybe Language, declarationLevel :: Int }
-  | CallReference       { declarationIdentifier :: T.Text, declarationImportIdentifier :: [T.Text] }
+  | CallReference       { declarationIdentifier :: T.Text, declarationText :: T.Text, declarationLanguage :: Maybe Language, declarationImportIdentifier :: [T.Text] }
   | ErrorDeclaration    { declarationIdentifier :: T.Text, declarationText :: T.Text, declarationLanguage :: Maybe Language }
   deriving (Eq, Generic, Show)
 
@@ -128,9 +128,9 @@ getSource blobSource = toText . flip Source.slice blobSource . getField
 
 instance (Syntax.Identifier :< fs, Expression.MemberAccess :< fs) => CustomHasDeclaration (Union fs) Expression.Call where
   customToDeclaration Blob{..} _ (Expression.Call _ (Term (In fromAnn fromF), _) _ _)
-    | Just (Expression.MemberAccess (Term (In leftAnn leftF)) (Term (In idenAnn _))) <- prj fromF = Just $ CallReference (getSource idenAnn) (memberAccess leftAnn leftF)
+    | Just (Expression.MemberAccess (Term (In leftAnn leftF)) (Term (In idenAnn _))) <- prj fromF = Just $ CallReference (getSource idenAnn) mempty blobLanguage (memberAccess leftAnn leftF)
-    | Just (Syntax.Identifier (Name name)) <- prj fromF = Just $ CallReference (T.decodeUtf8 name) []
+    | Just (Syntax.Identifier (Name name)) <- prj fromF = Just $ CallReference (T.decodeUtf8 name) mempty blobLanguage []
-    | otherwise = Just $ CallReference (getSource fromAnn) []
+    | otherwise = Just $ CallReference (getSource fromAnn) mempty blobLanguage []
     where
       memberAccess modAnn termFOut
         | Just (Expression.MemberAccess (Term (In leftAnn leftF)) (Term (In rightAnn rightF))) <- prj termFOut

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
@@ -290,11 +292,21 @@ subscript = makeTerm <$> symbol ElementReference <*> children (Expression.Subscr
 pair :: Assignment
 pair =   makeTerm <$> symbol Pair <*> children (Literal.KeyValue <$> expression <*> (expression <|> emptyTerm))
 
+args :: Assignment' [Term]
+args = (symbol ArgumentList <|> symbol ArgumentListWithParens) *> children (many expression) <|> many expression
+
 methodCall :: Assignment
-methodCall = makeTerm' <$> symbol MethodCall <*> children (require <|> load <|> regularCall)
+methodCall = makeTerm' <$> symbol MethodCall <*> children (require <|> load <|> send)
   where
-    regularCall = inj <$> (Expression.Call <$> pure [] <*> expression <*> args <*> (block <|> emptyTerm))
+    send = inj <$> ((regularCall <|> funcCall <|> scopeCall <|> dotCall) <*> optional block)
-    require = inj <$> (symbol Identifier *> do
+
+    funcCall = Ruby.Syntax.Send Nothing <$> selector <*> args
+    regularCall = symbol Call *> children (Ruby.Syntax.Send <$> (Just <$> postContextualize heredoc expression) <*> selector) <*> args
+    scopeCall = symbol ScopeResolution *> children (Ruby.Syntax.Send <$> (Just <$> expression) <*> selector) <*> args
+    dotCall = symbol Call *> children (Ruby.Syntax.Send <$> (Just <$> term expression) <*> pure Nothing <*> args)
+
+    selector = Just <$> term methodSelector
+    require = inj <$> ((symbol Identifier <|> symbol Identifier') *> do
       s <- source
       guard (s `elem` ["require", "require_relative"])
       Ruby.Syntax.Require (s == "require_relative") <$> nameExpression)
@@ -302,14 +314,22 @@ 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 []
     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 <*> (args <|> expressions))
+methodSelector = makeTerm <$> symbols <*> (Syntax.Identifier <$> (name <$> source))
   where
-    args = (symbol ArgumentList <|> symbol ArgumentListWithParens) *> children expressions
+    symbols = symbol Identifier
+          <|> symbol Identifier'
+          <|> symbol Constant
+          <|> symbol Operator
+          <|> symbol Super -- TODO(@charliesome): super calls are *not* method calls and need to be assigned into their own syntax terms
+
+call :: Assignment
+call = makeTerm <$> symbol Call <*> children (
+    (Ruby.Syntax.Send <$> (Just <$> term expression) <*> (Just <$> methodSelector) <*> pure [] <*> pure Nothing) <|>
+    (Ruby.Syntax.Send <$> (Just <$> term expression) <*> pure Nothing <*> args <*> pure Nothing))
 
 rescue :: Assignment
 rescue =  rescue'
@@ -405,7 +425,8 @@ invert term = makeTerm <$> location <*> fmap Expression.Not term
 
 -- | Match a term optionally preceded by comment(s), or a sequence of comments if the term is not present.
 term :: Assignment -> Assignment
-term term = contextualize comment term <|> makeTerm1 <$> (Syntax.Context <$> some1 comment <*> emptyTerm)
+term term = contextualize comment term <|> makeTerm1 <$> (Syntax.Context <$> some1 (comment <|> heredocEnd) <*> emptyTerm)
+  where heredocEnd = makeTerm <$> symbol HeredocEnd <*> (Literal.TextElement <$> source)
 
 -- | Match a series of terms or comments until a delimiter is matched.
 manyTermsTill :: Assignment.Assignment [] Grammar Term -> Assignment.Assignment [] Grammar b -> Assignment.Assignment [] Grammar [Term]

src/Language/Ruby/Syntax.hs

@@ -36,6 +36,27 @@ maybeFailNotFound name = maybeFail notFound
 cleanNameOrPath :: ByteString -> String
 cleanNameOrPath = BC.unpack . dropRelativePrefix . stripQuotes
 
+data Send a = Send { sendReceiver :: Maybe a, sendSelector :: Maybe 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
+    let sel = case sendSelector of
+          Just sel -> subtermValue sel
+          Nothing -> variable (name "call")
+
+    func <- case sendReceiver of
+      Just recv -> do
+        recvEnv <- subtermValue recv >>= scopedEnvironment
+        localEnv (mappend recvEnv) sel
+      Nothing -> sel -- 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,5 +1,5 @@
 (Program
-  (Call
+  (Send
     (Identifier)
     (Function
       (Empty)
@@ -8,12 +8,12 @@
     ->(Plus
       {+(Identifier)+}
       {+(Integer)+}) }))
-{-(Call
+{-(Send
   {-(Identifier)-}
   {-(Function
     {-(Empty)-}
     {-(Identifier)-})-})-}
-{-(Call
+{-(Send
   {-(Identifier)-}
   {-(Function
     {-(Empty)-}

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

@@ -1,5 +1,5 @@
 (Program
-  (Call
+  (Send
     (Identifier)
     (Function
       (Empty)
@@ -8,12 +8,12 @@
       {-(Identifier)-}
       {-(Integer)-})
     ->([]) }))
-{+(Call
+{+(Send
   {+(Identifier)+}
   {+(Function
     {+(Empty)+}
     {+(Identifier)+})+})+}
-{+(Call
+{+(Send
   {+(Identifier)+}
   {+(Function
     {+(Empty)+}

test/fixtures/ruby/lambda.parseA.txt

@@ -1,15 +1,15 @@
 (Program
-  (Call
+  (Send
     (Identifier)
     (Function
       (Empty)
       ([])))
-  (Call
+  (Send
     (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)))