Revert "JS templates"

sdk/lib/_internal/compiler/implementation/js_emitter/interceptor_emitter.dart

 // Copyright (c) 2013, 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.
 
 part of dart2js.js_emitter;
 
 class InterceptorEmitter extends CodeEmitterHelper {
   final Set<String> interceptorInvocationNames = new Set<String>();
 
   void recordMangledNameOfMemberMethod(FunctionElement member, String name) {
@@ skipping 11 matching lines @@
         InterceptorConstant interceptorConstant = constant;
         classes.add(interceptorConstant.dispatchedType.element);
       }
     }
     return classes;
   }
 
   void emitGetInterceptorMethod(CodeBuffer buffer,
                                 String key,
                                 Set<ClassElement> classes) {
-    jsAst.Expression interceptorFor(ClassElement cls) {
-      return js('#.prototype', namer.elementAccess(cls));
+    jsAst.Statement buildReturnInterceptor(ClassElement cls) {
+      return js.return_(js(namer.isolateAccess(cls))['prototype']);
     }
 
     /**
      * Build a JavaScrit AST node for doing a type check on
-     * [cls]. [cls] must be a non-native interceptor class.
+     * [cls]. [cls] must be an interceptor class.
      */
     jsAst.Statement buildInterceptorCheck(ClassElement cls) {
       jsAst.Expression condition;
       assert(backend.isInterceptorClass(cls));
       if (cls == backend.jsBoolClass) {
         condition = js('(typeof receiver) == "boolean"');
       } else if (cls == backend.jsIntClass ||
                  cls == backend.jsDoubleClass ||
                  cls == backend.jsNumberClass) {
         throw 'internal error';
       } else if (cls == backend.jsArrayClass ||
                  cls == backend.jsMutableArrayClass ||
                  cls == backend.jsFixedArrayClass ||
                  cls == backend.jsExtendableArrayClass) {
         condition = js('receiver.constructor == Array');
       } else if (cls == backend.jsStringClass) {
         condition = js('(typeof receiver) == "string"');
       } else if (cls == backend.jsNullClass) {
         condition = js('receiver == null');
       } else {
         throw 'internal error';
       }
-      return js.statement('if (#) return #', [condition, interceptorFor(cls)]);
+      return js.if_(condition, buildReturnInterceptor(cls));
     }
 
     bool hasArray = false;
     bool hasBool = false;
     bool hasDouble = false;
     bool hasInt = false;
     bool hasNull = false;
     bool hasNumber = false;
     bool hasString = false;
     bool hasNative = false;
@@ skipping 29 matching lines @@
     if (hasDouble) {
       hasNumber = true;
     }
     if (hasInt) hasNumber = true;
 
     if (classes.containsAll(backend.interceptedClasses)) {
       // I.e. this is the general interceptor.
       hasNative = anyNativeClasses;
     }
 
-    List<Statement> statements = <Statement>[];
+    jsAst.Block block = new jsAst.Block.empty();
 
     if (hasNumber) {
       jsAst.Statement whenNumber;
 
       /// Note: there are two number classes in play: Dart's [num],
       /// and JavaScript's Number (typeof receiver == 'number').  This
       /// is the fallback used when we have determined that receiver
       /// is a JavaScript Number.
-      jsAst.Expression interceptorForNumber = interceptorFor(
+      jsAst.Return returnNumberClass = buildReturnInterceptor(
           hasDouble ? backend.jsDoubleClass : backend.jsNumberClass);
 
       if (hasInt) {
-        whenNumber = js.statement('''{
-            if (Math.floor(receiver) == receiver) return #;
-            return #;
-        }''', [interceptorFor(backend.jsIntClass), interceptorForNumber]);
+        jsAst.Expression isInt = js('Math.floor(receiver) == receiver');
+        whenNumber = js.block([
+            js.if_(isInt, buildReturnInterceptor(backend.jsIntClass)),
+            returnNumberClass]);
       } else {
-        whenNumber = js.statement('return #', interceptorForNumber);
+        whenNumber = returnNumberClass;
       }
-      statements.add(
-          js.statement('if (typeof receiver == "number") #;', whenNumber));
+      block.statements.add(
+          js.if_('(typeof receiver) == "number"',
+                 whenNumber));
     }
 
     if (hasString) {
-      statements.add(buildInterceptorCheck(backend.jsStringClass));
+      block.statements.add(buildInterceptorCheck(backend.jsStringClass));
     }
     if (hasNull) {
-      statements.add(buildInterceptorCheck(backend.jsNullClass));
+      block.statements.add(buildInterceptorCheck(backend.jsNullClass));
     } else {
       // Returning "undefined" or "null" here will provoke a JavaScript
       // TypeError which is later identified as a null-error by
       // [unwrapException] in js_helper.dart.
-      statements.add(
-          js.statement('if (receiver == null) return receiver'));
+      block.statements.add(js.if_('receiver == null',
+                                  js.return_(js('receiver'))));
     }
     if (hasBool) {
-      statements.add(buildInterceptorCheck(backend.jsBoolClass));
+      block.statements.add(buildInterceptorCheck(backend.jsBoolClass));
     }
     // TODO(ahe): It might be faster to check for Array before
     // function and bool.
     if (hasArray) {
-      statements.add(buildInterceptorCheck(backend.jsArrayClass));
+      block.statements.add(buildInterceptorCheck(backend.jsArrayClass));
     }
 
     if (hasNative) {
-      statements.add(js.statement(r'''{
-          if (typeof receiver != "object") return receiver;
-          if (receiver instanceof #) return receiver;
-          return #(receiver);
-      }''', [
-          namer.elementAccess(compiler.objectClass),
-          namer.elementAccess(backend.getNativeInterceptorMethod)]));
+      block.statements.add(
+          js.if_(
+              js('(typeof receiver) != "object"'),
+              js.return_(js('receiver'))));
+
+      // if (receiver instanceof $.Object) return receiver;
+      // return $.getNativeInterceptor(receiver);
+      block.statements.add(
+          js.if_(js('receiver instanceof #',
+                    js(namer.isolateAccess(compiler.objectClass))),
+                 js.return_(js('receiver'))));
+      block.statements.add(
+          js.return_(
+              js(namer.isolateAccess(backend.getNativeInterceptorMethod))(
+                  ['receiver'])));
 
     } else {
       ClassElement jsUnknown = backend.jsUnknownJavaScriptObjectClass;
       if (compiler.codegenWorld.instantiatedClasses.contains(jsUnknown)) {
-        statements.add(
-            js.statement('if (!(receiver instanceof #)) return #;',
-                [namer.elementAccess(compiler.objectClass),
-                 interceptorFor(jsUnknown)]));
+        block.statements.add(
+            js.if_(js('!(receiver instanceof #)',
+                      js(namer.isolateAccess(compiler.objectClass))),
+                   buildReturnInterceptor(jsUnknown)));
       }
 
-      statements.add(js.statement('return receiver'));
+      block.statements.add(js.return_(js('receiver')));
     }
 
     buffer.write(jsAst.prettyPrint(
-        js('''${namer.globalObjectFor(compiler.interceptorsLibrary)}.# =
-              function(receiver) { #; }''',
-            [key, statements]),
+        js('${namer.globalObjectFor(compiler.interceptorsLibrary)}.$key = #',
+           js.fun(['receiver'], block)),
         compiler));
     buffer.write(N);
   }
 
   /**
    * Emit all versions of the [:getInterceptor:] method.
    */
   void emitGetInterceptorMethods(CodeBuffer buffer) {
     task.addComment('getInterceptor methods', buffer);
     Map<String, Set<ClassElement>> specializedGetInterceptors =
         backend.specializedGetInterceptors;
     for (String name in specializedGetInterceptors.keys.toList()..sort()) {
       Set<ClassElement> classes = specializedGetInterceptors[name];
       emitGetInterceptorMethod(buffer, name, classes);
     }
   }
 
   // Returns a statement that takes care of performance critical
   // common case for a one-shot interceptor, or null if there is no
   // fast path.
   jsAst.Statement fastPathForOneShotInterceptor(Selector selector,
                                                 Set<ClassElement> classes) {
+    jsAst.Expression isNumber(String variable) {
+      return js('typeof $variable == "number"');
+    }
+
+    jsAst.Expression isNotObject(String variable) {
+      return js('typeof $variable != "object"');
+    }
+
+    jsAst.Expression isInt(String variable) {
+      return isNumber(variable).binary('&&',
+          js('Math.floor($variable) == $variable'));
+    }
+
+    jsAst.Expression tripleShiftZero(jsAst.Expression receiver) {
+      return receiver.binary('>>>', js('0'));
+    }
 
     if (selector.isOperator()) {
       String name = selector.name;
       if (name == '==') {
-        return js.statement('''{
-          if (receiver == null) return a0 == null;
-          if (typeof receiver != "object")
-            return a0 != null && receiver === a0;
-        }''');
+        // Unfolds to:
+        //    if (receiver == null) return a0 == null;
+        //    if (typeof receiver != 'object') {
+        //      return a0 != null && receiver === a0;
+        //    }
+        List<jsAst.Statement> body = <jsAst.Statement>[];
+        body.add(js.if_('receiver == null', js.return_(js('a0 == null'))));
+        body.add(js.if_(
+            isNotObject('receiver'),
+            js.return_(js('a0 != null && receiver === a0'))));
+        return new jsAst.Block(body);
       }
       if (!classes.contains(backend.jsIntClass)
           && !classes.contains(backend.jsNumberClass)
           && !classes.contains(backend.jsDoubleClass)) {
         return null;
       }
       if (selector.argumentCount == 1) {
-        // The following operators do not map to a JavaScript operator.
+        // The following operators do not map to a JavaScript
+        // operator.
         if (name == '~/' || name == '<<' || name == '%' || name == '>>') {
           return null;
         }
-        jsAst.Expression result = js('receiver $name a0');
+        jsAst.Expression result = js('receiver').binary(name, js('a0'));
         if (name == '&' || name == '|' || name == '^') {
-          result = js('# >>> 0', result);
+          result = tripleShiftZero(result);
         }
-        return js.statement(
-            'if (typeof receiver == "number" && typeof a0 == "number")'
-            '  return #;',
-            result);
+        // Unfolds to:
+        //    if (typeof receiver == "number" && typeof a0 == "number")
+        //      return receiver op a0;
+        return js.if_(
+            isNumber('receiver').binary('&&', isNumber('a0')),
+            js.return_(result));
       } else if (name == 'unary-') {
-        return js.statement(
-            'if (typeof receiver == "number") return -receiver');
+        // [: if (typeof receiver == "number") return -receiver :].
+        return js.if_(isNumber('receiver'),
+                      js.return_(js('-receiver')));
       } else {
         assert(name == '~');
-        return js.statement('''
-          if (typeof receiver == "number" && Math.floor(receiver) == receiver)
-            return (~receiver) >>> 0;
-          ''');
+        return js.if_(isInt('receiver'),
+                      js.return_(js('~receiver >>> 0')));
       }
     } else if (selector.isIndex() || selector.isIndexSet()) {
       // For an index operation, this code generates:
       //
       //    if (receiver.constructor == Array || typeof receiver == "string") {
       //      if (a0 >>> 0 === a0 && a0 < receiver.length) {
       //        return receiver[a0];
       //      }
       //    }
       //
@@ skipping 13 matching lines @@
       // The index set operator requires a check on its set value in
       // checked mode, so we don't optimize the interceptor if the
       // compiler has type assertions enabled.
       if (selector.isIndexSet()
           && (compiler.enableTypeAssertions || !containsArray)) {
         return null;
       }
       if (!containsArray && !containsString) {
         return null;
       }
+      jsAst.Expression isIntAndAboveZero = js('a0 >>> 0 === a0');
+      jsAst.Expression belowLength = js('a0 < receiver.length');
       jsAst.Expression arrayCheck = js('receiver.constructor == Array');
       jsAst.Expression indexableCheck =
           backend.generateIsJsIndexableCall(js('receiver'), js('receiver'));
 
       jsAst.Expression orExp(left, right) {
-        return left == null ? right : js('# || #', [left, right]);
+        return left == null ? right : left.binary('||', right);
       }
 
       if (selector.isIndex()) {
+        jsAst.Expression stringCheck = js('typeof receiver == "string"');
         jsAst.Expression typeCheck;
         if (containsArray) {
           typeCheck = arrayCheck;
         }
 
         if (containsString) {
-          typeCheck = orExp(typeCheck, js('typeof receiver == "string"'));
+          typeCheck = orExp(typeCheck, stringCheck);
         }
 
         if (containsJsIndexable) {
           typeCheck = orExp(typeCheck, indexableCheck);
         }
 
-        return js.statement('''
-          if (#)
-            if ((a0 >>> 0) === a0 && a0 < receiver.length)
-              return receiver[a0];
-          ''', typeCheck);
+        return js.if_(typeCheck,
+                      js.if_(isIntAndAboveZero.binary('&&', belowLength),
+                             js.return_(js('receiver[a0]'))));
       } else {
         jsAst.Expression typeCheck;
         if (containsArray) {
           typeCheck = arrayCheck;
         }
 
         if (containsJsIndexable) {
           typeCheck = orExp(typeCheck, indexableCheck);
         }
 
-        return js.statement(r'''
-          if (# && !receiver.immutable$list &&
-              (a0 >>> 0) === a0 && a0 < receiver.length)
-            return receiver[a0] = a1;
-          ''', typeCheck);
+        jsAst.Expression isImmutableArray = typeCheck.binary(
+            '&&', js(r'!receiver.immutable$list'));
+        return js.if_(isImmutableArray.binary(
+                      '&&', isIntAndAboveZero.binary('&&', belowLength)),
+                      js.return_(js('receiver[a0] = a1')));
       }
     }
     return null;
   }
 
   void emitOneShotInterceptors(CodeBuffer buffer) {
     List<String> names = backend.oneShotInterceptors.keys.toList();
     names.sort();
     for (String name in names) {
       Selector selector = backend.oneShotInterceptors[name];
       Set<ClassElement> classes =
           backend.getInterceptedClassesOn(selector.name);
       String getInterceptorName =
           namer.getInterceptorName(backend.getInterceptorMethod, classes);
 
-      List<String> parameterNames = <String>[];
-      parameterNames.add('receiver');
+      List<jsAst.Parameter> parameters = <jsAst.Parameter>[];
+      List<jsAst.Expression> arguments = <jsAst.Expression>[];
+      parameters.add(new jsAst.Parameter('receiver'));
+      arguments.add(js('receiver'));
 
       if (selector.isSetter()) {
-        parameterNames.add('value');
+        parameters.add(new jsAst.Parameter('value'));
+        arguments.add(js('value'));
       } else {
         for (int i = 0; i < selector.argumentCount; i++) {
-          parameterNames.add('a$i');
+          String argName = 'a$i';
+          parameters.add(new jsAst.Parameter(argName));
+          arguments.add(js(argName));
         }
       }
 
+      List<jsAst.Statement> body = <jsAst.Statement>[];
+      jsAst.Statement optimizedPath =
+          fastPathForOneShotInterceptor(selector, classes);
+      if (optimizedPath != null) {
+        body.add(optimizedPath);
+      }
+
       String invocationName = backend.namer.invocationName(selector);
       String globalObject = namer.globalObjectFor(compiler.interceptorsLibrary);
+      body.add(js.return_(
+          js(globalObject)[getInterceptorName]('receiver')[invocationName](
+              arguments)));
 
-      jsAst.Statement optimizedPath =
-          fastPathForOneShotInterceptor(selector, classes);
-      if (optimizedPath == null) optimizedPath = js.statement(';');
-
-      jsAst.Expression assignment = js('${globalObject}.# = function(#) {'
-          '  #;'
-          '  return #.#(receiver).#(#) }',
-          [name, parameterNames,
-           optimizedPath,
-           globalObject, getInterceptorName, invocationName, parameterNames]);
+      jsAst.Expression assignment =
+          js('${globalObject}.$name = #', js.fun(parameters, body));
 
       buffer.write(jsAst.prettyPrint(assignment, compiler));
       buffer.write(N);
     }
   }
 
   /**
    * If [JSInvocationMirror._invokeOn] has been compiled, emit all the
    * possible selector names that are intercepted into the
    * [interceptedNames] top-level variable. The implementation of
@@ skipping 14 matching lines @@
     var invocationNames = interceptorInvocationNames.toList()..sort();
     List<jsAst.ArrayElement> elements = invocationNames.map(
       (String invocationName) {
         jsAst.Literal str = js.string(invocationName);
         return new jsAst.ArrayElement(index++, str);
       }).toList();
     jsAst.ArrayInitializer array =
         new jsAst.ArrayInitializer(invocationNames.length, elements);
 
     jsAst.Expression assignment =
-        js('${task.isolateProperties}.# = #', [name, array]);
+        js('${task.isolateProperties}.$name = #', array);
 
     buffer.write(jsAst.prettyPrint(assignment, compiler));
     buffer.write(N);
   }
 
   /**
    * Emit initializer for [mapTypeToInterceptor] data structure used by
    * [findInterceptorForType].  See declaration of [mapTypeToInterceptor] in
    * `interceptors.dart`.
    */
@@ skipping 44 matching lines @@
           var map = new jsAst.ObjectInitializer(properties);
           elements.add(map);
         }
       }
     }
 
     jsAst.ArrayInitializer array = new jsAst.ArrayInitializer.from(elements);
     String name =
         backend.namer.getNameOfGlobalField(backend.mapTypeToInterceptor);
     jsAst.Expression assignment =
-        js('${task.isolateProperties}.# = #', [name, array]);
+        js('${task.isolateProperties}.$name = #', array);
 
     buffer.write(jsAst.prettyPrint(assignment, compiler));
     buffer.write(N);
   }
 }