Allow arbitrary chaining of () and []

lib/ahem/parser.rb

         raise "Unexpected token #{token.type}"
       end
 
-    while @current_token.type == TokenKinds::LPAREN
-      args = arguments
-      expr = AST::FunctionCall.new(expr, args)
-    end
-
-    while @current_token.type == TokenKinds::LBRACKET
-      eat(TokenKinds::LBRACKET)
-      key = expression
-      eat(TokenKinds::RBRACKET)
-      expr = AST::Index.new(expr, key)
+    while [TokenKinds::LPAREN, TokenKinds::LBRACKET].include?(@current_token.type)
+      case @current_token.type
+      when TokenKinds::LPAREN
+        args = arguments
+        expr = AST::FunctionCall.new(expr, args)
+      when TokenKinds::LBRACKET
+        eat(TokenKinds::LBRACKET)
+        key = expression
+        eat(TokenKinds::RBRACKET)
+        expr = AST::Index.new(expr, key)
+      end
     end
 
     expr

spec/parser_spec.rb

             [],
           ),
           []
-        )        
+        )
+      ]
+    )
+  end
+
+  it 'allows arbitrarily chaining function calls and indexes' do
+    expect(parse('func()[0]()[1][2]();')).to eq(
+      [
+        AST::FunctionCall.new(
+          AST::Index.new(
+            AST::Index.new(
+              AST::FunctionCall.new(
+                AST::Index.new(
+                  AST::FunctionCall.new(
+                    AST::Identifier.new('func'),
+                    []
+                  ),
+                  AST::Number.new(0.0)
+                ),
+                []
+              ),
+              AST::Number.new(1.0)
+            ),
+            AST::Number.new(2.0)
+          ),
+          []
+        )
       ]
     )
   end