rename dart_runtime.js helpers

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 1284 matching lines @@
   @override
   visitMethodInvocation(MethodInvocation node) {
     var target = node.isCascaded ? _cascadeTarget : node.target;
 
     var result = _emitForeignJS(node);
     if (result != null) return result;
 
     if (rules.isDynamicCall(node.methodName)) {
       var args = _visit(node.argumentList);
       if (target != null) {
-        return js.call('dart.dinvoke(#, #, #)', [
+        return js.call('dart.dsend(#, #, #)', [
           _visit(target),
           js.string(node.methodName.name, "'"),
           args
         ]);
       } else {
-        return js.call('dart.dinvokef(#, #)', [_visit(node.methodName), args]);
+        return js.call('dart.dcall(#, #)', [_visit(node.methodName), args]);
       }
     }
 
     // TODO(jmesserly): if this resolves to a getter returning a function with
     // a call method, we don't generate the `.call` correctly.
 
     var targetJs;
     if (target != null) {
       targetJs = js.call('#.#', [
         _visit(target),
@@ skipping 23 matching lines @@
       return result;
     }
     return null;
   }
 
   @override
   JS.Expression visitFunctionExpressionInvocation(
       FunctionExpressionInvocation node) {
     var code;
     if (rules.isDynamicCall(node.function)) {
-      code = 'dart.dinvokef(#, #)';
+      code = 'dart.dcall(#, #)';
     } else {
       code = '#(#)';
     }
     return js.call(code, [_visit(node.function), _visit(node.argumentList)]);
   }
 
   @override
   List<JS.Expression> visitArgumentList(ArgumentList node) {
     var args = <JS.Expression>[];
     var named = <JS.Property>[];
@@ skipping 276 matching lines @@
       } else {
         // TODO(vsm): When do Dart ops not map to JS?
         code = '# $op #';
       }
       return js.call(code, [notNull(left), notNull(right)]);
     } else {
       var opString = js.string(op.lexeme, "'");
       if (rules.isDynamicTarget(left)) {
         // dynamic dispatch
         return js.call(
-            'dart.dbinary(#, #, #)', [_visit(left), opString, _visit(right)]);
+            'dart.dsend(#, #, #)', [_visit(left), opString, _visit(right)]);
       } else if (_isJSBuiltinType(leftType)) {
         // TODO(jmesserly): we'd get better readability from the static-dispatch
         // pattern below. Consider:
         //
         //     "hello"['+']"world"
         // vs
         //     core.String['+']("hello", "world")
         //
         // Infix notation is much more readable, which is a bit part of why
         // C# added its extension methods feature. However this would require
@@ skipping 190 matching lines @@
       // (for example, x is IndexExpression) we evaluate those once.
       var one = AstBuilder.integerLiteral(1)
         ..staticType = rules.provider.intType;
       return _emitOpAssign(expr, one, op.lexeme[0], context: expr);
     }
 
     // Call the operator
     var opString = _emitMemberName(op.lexeme, unary: true);
     if (rules.isDynamicTarget(expr)) {
       // dynamic dispatch
-      return js.call('dart.dunary(#, #)', [opString, _visit(expr)]);
+      return js.call('dart.dsend(#, #)', [_visit(expr), opString]);
     } else if (_isJSBuiltinType(dispatchType)) {
       return js.call(
           '#.#(#)', [_emitTypeName(dispatchType), opString, _visit(expr)]);
     } else {
       // Generic static-dispatch, user-defined operator code path.
       return js.call('#.#()', [_visit(expr), opString]);
     }
   }
 
   // Cascades can contain [IndexExpression], [MethodInvocation] and
@@ skipping 726 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;
 }