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 1429 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) ||

[Jacob, 2015/04/13 23:23:16]

was !rules.isDynamic(t) never needed?

[Jennifer Messerly, 2015/04/14 17:44:02]

yeah, it didn't make sense to me (how can int/double/bool/num/String be
dynamic?!). Now I'm second guessing myself. Maybe this was for the
`options.ignoreTypes` flag which generates everything as `dynamic`. if true that
means: we aren't testing the flag at all, and it was broken already in other
places.
I filed https://github.com/dart-lang/dev_compiler/issues/134 to track

+      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 37 matching lines @@
       // 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 996 matching lines @@
     if (args.isNotEmpty && args[0] is NamedExpression) {
       NamedExpression named = args[0];
       if (named.name.label.name == argName &&
           named.expression is StringLiteral) {
         return (named.expression as StringLiteral).stringValue;
       }
     }
   }
   return null;
 }