Flesh out dynamic invocation code

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 ddc.src.codegen.js_codegen;
 
 import 'dart:io' show Directory, File;
 
 import 'package:analyzer/analyzer.dart' hide ConstantEvaluator;
 import 'package:analyzer/src/generated/ast.dart' hide ConstantEvaluator;
@@ skipping 659 matching lines @@
     } else {
       result = new JS.VariableUse(name);
     }
 
     if (typeArgs != null) {
       result = js.call('#(#)', [result, typeArgs]);
     }
     return result;
   }
 
+  JS.Node _generateDPutIfDynamic(
+      Expression target, SimpleIdentifier id, Expression rhs) {
+    if (rules.isDynamicTarget(target)) {
+      return js.call('dart.dput(#, #, #)', [
+        target.accept(this),
+        js.string(id.name, "'"),
+        rhs.accept(this)
+      ]);
+    } else {
+      return null;
+    }
+  }
+
   @override
   JS.Node visitAssignmentExpression(AssignmentExpression node) {
     var lhs = node.leftHandSide;
     var rhs = node.rightHandSide;
+    return _generateAssignment(lhs, rhs, node.parent);
+  }
+
+  JS.Node _generateAssignment(Expression lhs, Expression rhs,

[Jennifer Messerly, 2015/02/26 20:53:16]

I've been using the "_emit" prefix. For better or worse. I like "generate"
better but it's too many characters :). I'd be happy with "_gen" if you prefer,
but then we should probably rename everything to be consistent

[vsm, 2015/03/03 21:06:12]

Done.

+      [AstNode parent]) {
     if (lhs is IndexExpression) {
       String code;
       var target = _getTarget(lhs);
       if (rules.isDynamicTarget(target)) {
         code = 'dart.dsetindex(#, #, #)';
       } else {
         code = '#.set(#, #)';
       }
       return js.call(code, [
         target.accept(this),
         lhs.index.accept(this),
         rhs.accept(this)
       ]);
     }
 
     if (lhs is PropertyAccess) {
-      var target = _getTarget(lhs);
-      if (rules.isDynamicTarget(target)) {
-        return js.call('dart.dput(#, #, #)', [
-          target.accept(this),
-          js.string(lhs.propertyName.name, "'"),
-          rhs.accept(this)
-        ]);
-      }
+      var result =
+          _generateDPutIfDynamic(_getTarget(lhs), lhs.propertyName, rhs);
+      if (result != null) return result;
+    } else if (lhs is PrefixedIdentifier) {

[Jennifer Messerly, 2015/02/26 20:53:16]

how does a prefixed identifier end up as a dynamic set? we should always be able
to resolve this statically, right?

[vsm, 2015/03/03 21:06:12]

In sunflower, notes.textContent shows up as a PrefixedIdentifier.  Without this,
I generate:

dart.dload(exports.notes, 'textContent') = `${exports.seeds} seeds`;

+      // TODO(vsm): Is this the right code if the prefix is a library?
+      var result = _generateDPutIfDynamic(lhs.prefix, lhs.identifier, rhs);
+      if (result != null) return result;
     }
 
-    if (node.parent is ExpressionStatement &&
+    if (parent is ExpressionStatement &&
         rhs is CascadeExpression &&
         _isStateless(lhs, rhs)) {
       // Special case: cascade assignment to a variable in a statement.
       // We can reuse the variable to desugar it:
       //    result = []..length = length;
       // becomes:
       //    result = [];
       //    result.length = length;
       var savedCascadeTemp = _cascadeTarget;
       _cascadeTarget = lhs;
@@ skipping 365 matching lines @@
       } else {
         // Generic static-dispatch, user-defined operator code path.
         return js.call(
             '#.#(#)', [left.accept(this), opString, right.accept(this)]);
       }
     }
   }
 
   bool _isNull(Expression expr) => expr is NullLiteral;
 
+  JS.Expression _generateIncrement(Token op, Expression expr, bool prefix) {
+    // TODO(vsm): Should we generate a runtime helper for this?

[Jennifer Messerly, 2015/02/26 20:53:16]

yeah, for now i think that's the pattern. this looks big enough I'd consider
putting it there.

[vsm, 2015/03/03 21:06:12]

Note - there is a free expression in the closure, so it's not trivial to
helperize.  I was also missing a side effect on the expression.  It appears
twice below, so the semantics will be wrong.  Unimplemented for now.  Ideas?

+    var tmp = '_';
+    var applied = prefix ? '$tmp$op' : '$op$tmp';
+    var id =
+        new SimpleIdentifier(new StringToken(TokenType.IDENTIFIER, tmp, 0));
+    id.staticElement = new LocalVariableElementImpl.forNode(id);
+    id.staticType = expr.staticType;
+    var assignment = _generateAssignment(expr, id);
+    return js.call('''
+(function () {
+  var $tmp = #;
+  if (typeof($tmp) != 'number') throw 'number expected';
+  var result = $applied;
+  #;
+  return result;
+})()
+''', [expr.accept(this), assignment]);
+  }
+
   @override
   JS.Expression visitPostfixExpression(PostfixExpression node) {
     var op = node.operator;
     var expr = node.operand;
 
     var dispatchType = rules.getStaticType(expr);
     if (unaryOperationIsPrimitive(dispatchType)) {
       // TODO(vsm): When do Dart ops not map to JS?
       return js.call('#$op', notNull(expr));
     } else {
-      // TODO(vsm): Figure out operator calling convention / dispatch.
-      return visitExpression(node);
+      assert(op.lexeme == '++' || op.lexeme == '--');
+      return _generateIncrement(op, expr, false);

[Jennifer Messerly, 2015/02/26 20:53:17]

nit: use named arg `prefix: false`

[vsm, 2015/03/03 21:06:12]

Done.

     }
   }
 
   @override
   JS.Expression visitPrefixExpression(PrefixExpression node) {
     var op = node.operator;
     var expr = node.operand;
 
     var dispatchType = rules.getStaticType(expr);
     if (unaryOperationIsPrimitive(dispatchType)) {
       // TODO(vsm): When do Dart ops not map to JS?
       return js.call('$op#', notNull(expr));
     } else {
-      // TODO(vsm): Figure out operator calling convention / dispatch.
-      return visitExpression(node);
+      if (op.lexeme == '++' || op.lexeme == '--') {
+        return _generateIncrement(op, expr, true);
+      }
     }
+    // TODO(vsm): Expand out.
+    return visitExpression(node);

[vsm, 2015/02/26 00:34:00]

Should this just be:
   x['-']()
?  Or similar?  This is one case where Dart kind of allows overloading ...
operator- can be defined in both no and one arg forms.  

[Jennifer Messerly, 2015/02/26 20:53:17]

IMO, name should be "unary-" unless we find a good reason not to ... from
language spec:

"The name of the unary operator - is unary-.
This device allows the two methods to be distinguished for purposes of method
lookup, override and reflection."

   }
 
   // Cascades can contain [IndexExpression], [MethodInvocation] and
   // [PropertyAccess]. The code generation for those is handled in their
   // respective visit methods.
   @override
   JS.Node visitCascadeExpression(CascadeExpression node) {
     var savedCascadeTemp = _cascadeTarget;
 
     var parent = node.parent;
@@ skipping 571 matching lines @@
 /// Choose a canonical name from the library element.
 /// This never uses the library's name (the identifier in the `library`
 /// declaration) as it doesn't have any meaningful rules enforced.
 String jsLibraryName(LibraryElement library) => canonicalLibraryName(library);
 
 /// Path to file that will be generated for [info].
 // TODO(jmesserly): library directory should be relative to its package
 // root. For example, "package:dev_compiler/src/codegen/js_codegen.dart" would be:
 // "ddc/src/codegen/js_codegen.js" under the output directory.
 String jsOutputPath(LibraryInfo info) => '${info.name}/${info.name}.js';