fixes for angular hello: String + and disable broken arg parsing

lib/src/codegen/js_codegen.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 dev_compiler.src.codegen.js_codegen;
 
 import 'dart:collection' show HashSet, HashMap;
 import 'dart:io' show Directory, File;
 
 import 'package:analyzer/analyzer.dart' hide ConstantEvaluator;
@@ skipping 1424 matching lines @@
   visitInstanceCreationExpression(InstanceCreationExpression node) {
     return js.call(
         'new #(#)', [_visit(node.constructorName), _visit(node.argumentList)]);
   }
 
   /// True if this type is built-in to JS, and we use the values unwrapped.
   /// For these types we generate a calling convention via static
   /// "extension methods". This allows types to be extended without adding
   /// extensions directly on the prototype.
   bool _isJSBuiltinType(DartType t) =>
-      rules.isNumType(t) || rules.isStringType(t) || rules.isBoolType(t);
+      typeIsPrimitiveInJS(t) || rules.isStringType(t);
 
-  bool typeIsPrimitiveInJS(DartType t) => !rules.isDynamic(t) &&
-      (rules.isIntType(t) ||
-          rules.isDoubleType(t) ||
-          rules.isBoolType(t) ||
-          rules.isNumType(t));
+  bool typeIsPrimitiveInJS(DartType t) => rules.isIntType(t) ||
+      rules.isDoubleType(t) ||
+      rules.isBoolType(t) ||
+      rules.isNumType(t);
 
   bool typeIsNonNullablePrimitiveInJS(DartType t) =>
       typeIsPrimitiveInJS(t) && rules.isNonNullableType(t);
 
   bool binaryOperationIsPrimitive(DartType leftT, DartType rightT) =>
       typeIsPrimitiveInJS(leftT) && typeIsPrimitiveInJS(rightT);
 
   bool unaryOperationIsPrimitive(DartType t) => typeIsPrimitiveInJS(t);
 
   bool _isNonNullableExpression(Expression expr) {
@@ skipping 12 matching lines @@
       return _isNonNullableExpression(expr.expression);
     }
     DartType type = null;
     if (expr is BinaryExpression) {
       type = getStaticType(expr.leftOperand);
     } else if (expr is PrefixExpression) {
       type = getStaticType(expr.operand);
     } else if (expr is PostfixExpression) {
       type = getStaticType(expr.operand);
     }
-    if (type != null && typeIsPrimitiveInJS(type)) {
+    if (type != null && _isJSBuiltinType(type)) {
       return true;
     }
     if (expr is MethodInvocation) {
       // TODO(vsm): This logic overlaps with the resolver.
       // Where is the best place to put this?
       var e = expr.methodName.staticElement;
       if (e is FunctionElement &&
           e.library.name == '_foreign_helper' &&
           e.name == 'JS') {
         // Fix types for JS builtin calls.
@@ skipping 24 matching lines @@
   }
 
   @override
   JS.Expression visitBinaryExpression(BinaryExpression node) {
     var op = node.operator;
     var left = node.leftOperand;
     var right = node.rightOperand;
     var leftType = getStaticType(left);
     var rightType = getStaticType(right);
 
+    // TODO(jmesserly): this may not work correctly with options.ignoreTypes,
+    // because that results in unreliable type annotations. See issue #134,
+    // probably the checker/resolver is the right place to implement that, by
+    // replacing staticTypes with `dynamic` as needed, so codegen "just works".
     var code;
     if (op.type.isEqualityOperator) {
       // If we statically know LHS or RHS is null we can generate a clean check.
       // We can also do this if both sides are the same primitive type.
       if (_canUsePrimitiveEquality(left, right)) {
         code = op.type == TokenType.EQ_EQ ? '# == #' : '# != #';
       } else {
         var bang = op.type == TokenType.BANG_EQ ? '!' : '';
         code = '${bang}dart.equals(#, #)';
       }
       return js.call(code, [_visit(left), _visit(right)]);
     }
 
-    if (binaryOperationIsPrimitive(leftType, rightType)) {
+    if (binaryOperationIsPrimitive(leftType, rightType) ||
+        rules.isStringType(leftType) && op.type == TokenType.PLUS) {
+
       // special cases where we inline the operation
       // these values are assumed to be non-null (determined by the checker)
       // TODO(jmesserly): it would be nice to just inline the method from core,
       // instead of special cases here.
       if (op.type == TokenType.TILDE_SLASH) {
         // `a ~/ b` is equivalent to `(a / b).truncate()`
         code = '(# / #).truncate()';
       } else {
         // TODO(vsm): When do Dart ops not map to JS?
         code = '# $op #';
@@ skipping 967 matching lines @@
   }
 }
 
 // TODO(jmesserly): validate the library. See issue #135.
 bool _isJsNameAnnotation(DartObjectImpl value) => value.type.name == 'JsName';
 
 // TODO(jacobr): we would like to do something like the following
 // but we don't have summary support yet.
 // bool _supportJsExtensionMethod(AnnotatedNode node) =>
 //    _getAnnotation(node, "SupportJsExtensionMethod") != null;