Flesh out dynamic invocation code

lib/src/codegen/ast_builder.dart

 // Copyright (c) 2015, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 library ddc.src.codegen.ast_builder;
 
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/scanner.dart';
 import 'package:analyzer/src/generated/utilities_dart.dart';
 import 'package:logging/logging.dart' as logger;
@@ skipping 45 matching lines @@
   }
 
   static BooleanLiteral booleanLiteral(bool b) {
     return RawAstBuilder.booleanLiteral(b);
   }
 
   static NullLiteral nullLiteral() {
     return RawAstBuilder.nullLiteral();
   }
 
+  static IntegerLiteral integerLiteral(int i) {
+    return RawAstBuilder.integerLiteral(i);
+  }
+
   static StringLiteral stringLiteral(String s) {
     return RawAstBuilder.simpleStringLiteral(s);
   }
 
   static StringLiteral multiLineStringLiteral(String s) {
     return RawAstBuilder.tripleQuotedStringLiteral(s);
   }
 
   static AsExpression asExpression(Expression exp, TypeName type) {
     return RawAstBuilder.asExpression(exp, type);
   }
 
   static IsExpression isExpression(Expression exp, TypeName type) {
     return RawAstBuilder.isExpression(exp, type);
   }
 
   static ParenthesizedExpression parenthesizedExpression(Expression exp) {
     return RawAstBuilder.parenthesizedExpression(exp);
   }
 
   static Expression parenthesize(Expression exp) {
     if (exp is Identifier ||
         exp is ParenthesizedExpression ||
         exp is FunctionExpressionInvocation ||
         exp is MethodInvocation) return exp;
     return parenthesizedExpression(exp);
   }
 
+  static Token _binaryOperation(String oper) {
+    switch (oper) {
+      case '==':
+        return new Token(TokenType.EQ_EQ, 0);
+      case '+':
+        return new Token(TokenType.PLUS, 0);
+      case '-':
+        return new Token(TokenType.MINUS, 0);
+    }
+    // TODO(vsm): Add cases as needed.
+    assert(false);
+    return null;
+  }
+
   static BinaryExpression binaryExpression(
       Expression l, String oper, Expression r) {
-    if (oper == "==") return RawAstBuilder.equalityExpression(l, r);
-    assert(false);
-    return null;
+    Token token = _binaryOperation(oper);
+    return RawAstBuilder.binaryExpression(l, token, r);
   }
 
   static ConditionalExpression conditionalExpression(
       Expression cond, Expression tExp, Expression fExp) {
     return RawAstBuilder.conditionalExpression(cond, tExp, fExp);
   }
 
   static Expression application(Expression function, List<Expression> es) {
     ArgumentList args = argumentList(es);
     return RawAstBuilder.functionExpressionInvocation(function, args);
@@ skipping 136 matching lines @@
   static BooleanLiteral booleanLiteral(bool b) {
     var k = new KeywordToken(b ? Keyword.TRUE : Keyword.FALSE, 0);
     return new BooleanLiteral(k, b);
   }
 
   static NullLiteral nullLiteral() {
     var n = new KeywordToken(Keyword.NULL, 0);
     return new NullLiteral(n);
   }
 
+  static IntegerLiteral integerLiteral(int i) {
+    StringToken token = new StringToken(TokenType.INT, '$i', 0);
+    return new IntegerLiteral(token, i);
+  }
+
   static SimpleStringLiteral simpleStringLiteral(String s) {
     StringToken token = new StringToken(TokenType.STRING, "\"" + s + "\"", 0);
     return new SimpleStringLiteral(token, s);
   }
 
   static SimpleStringLiteral tripleQuotedStringLiteral(String s) {
     StringToken token = new StringToken(TokenType.STRING, '"""' + s + '"""', 0);
     return new SimpleStringLiteral(token, s);
   }
 
   static AsExpression asExpression(Expression exp, TypeName type) {
     Token token = new KeywordToken(Keyword.AS, 0);
     return new AsExpression(exp, token, type);
   }
 
   static IsExpression isExpression(Expression exp, TypeName type) {
     Token token = new KeywordToken(Keyword.IS, 0);
     return new IsExpression(exp, token, null, type);
   }
 
   static ParenthesizedExpression parenthesizedExpression(Expression exp) {
     Token lp = new BeginToken(TokenType.OPEN_PAREN, exp.offset);
     Token rp = new Token(TokenType.CLOSE_PAREN, exp.end);
     return new ParenthesizedExpression(lp, exp, rp);
   }
 
-  static BinaryExpression equalityExpression(Expression l, Expression r) {
-    var eq = new Token(TokenType.EQ_EQ, 0);
-    return new BinaryExpression(l, eq, r);
+  static BinaryExpression binaryExpression(
+      Expression l, Token op, Expression r) {
+    return new BinaryExpression(l, op, r);
   }
 
   static ConditionalExpression conditionalExpression(
       Expression cond, Expression tExp, Expression fExp) {
     var q = new Token(TokenType.QUESTION, 0);
     var c = new Token(TokenType.COLON, 0);
     return new ConditionalExpression(cond, q, tExp, c, fExp);
   }
 
   static Expression functionExpressionInvocation(
@@ skipping 88 matching lines @@
 
   static NamedExpression namedParameter(Identifier s, Expression e) {
     return namedExpression(s, e);
   }
 
   static NamedExpression namedExpression(Identifier s, Expression e) {
     Label l = new Label(s, new Token(TokenType.COLON, 0));
     return new NamedExpression(l, e);
   }
 }