metalet with postfix improvement

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 1525 matching lines @@
   }
 
   JS.Expression notNull(Expression expr) {
     if (_isNonNullableExpression(expr)) {
       return _visit(expr);
     } else {
       return js.call('dart.notNull(#)', _visit(expr));
     }
   }
 
+  JS.Expression _assignableNotNull(Expression expr) {
+    if (expr is IndexExpression) {
+      IndexExpression i = expr;
+      return js.call(
+          'dart.index(#, #).notNull', [_visit(i.target), _visit(i.index)]);
+    } else if (expr is PropertyAccess) {
+      PropertyAccess p = expr;
+      return js.call('dart.prop(#, #).notNull', [
+        _visit(p.target),
+        _emitMemberName(p.propertyName.name)
+      ]);
+    } else if (expr is PrefixedIdentifier) {
+      PrefixedIdentifier p = expr;
+      return js.call('dart.prop(#, #).notNull', [
+        _visit(p.prefix),
+        _emitMemberName(p.identifier.name)
+      ]);
+    }
+    return null;
+  }
+
   @override
   JS.Expression visitBinaryExpression(BinaryExpression node) {
     var op = node.operator;
     var left = node.leftOperand;
     var right = node.rightOperand;
     var leftType = rules.getStaticType(left);
     var rightType = rules.getStaticType(right);
 
     var code;
     if (op.type.isEqualityOperator) {
@@ skipping 184 matching lines @@
     return t;
   }
 
   @override
   JS.Expression visitPostfixExpression(PostfixExpression node) {
     var op = node.operator;
     var expr = node.operand;
 
     var dispatchType = rules.getStaticType(expr);
     if (unaryOperationIsPrimitive(dispatchType)) {
+      JS.Expression lvalue;
       if (_isNonNullableExpression(expr)) {
-        return js.call('#$op', _visit(expr));
+        // TODO(jmesserly): ensure that expr is generated as a lvalue.
+        // I think this works today because if the result type is primitive,
+        // it can't be a dynamic call. But worth checking.
+        lvalue = _visit(expr);
+      } else {
+        lvalue = _assignableNotNull(expr);
       }
+      if (lvalue != null) return new JS.Postfix(op.lexeme, lvalue);
     }
 
     assert(op.lexeme == '++' || op.lexeme == '--');
     return _emitPostfixIncrement(expr, op);
   }
 
   @override
   JS.Expression visitPrefixExpression(PrefixExpression node) {
     return _emitPrefixExpression(node.operator, node.operand);
   }
@@ skipping 754 matching lines @@
     if (parent is MethodInvocation &&
         identical(parent.methodName, node)) return;
     if (parent is ConstructorName) return;
     if (parent is Label) return;
 
     if (node.inSetterContext() && node.staticElement == _variable) {
       _potentiallyMutated = true;
     }
   }
 }