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.Statement buildReturnInterceptor(ClassElement cls) {
-      return js.return_(js(namer.isolateAccess(cls))['prototype']);
+    jsAst.Expression interceptorFor(ClassElement cls) {
+      return js('#.prototype', namer.elementAccess(cls));
     }
 
     /**
      * Build a JavaScrit AST node for doing a type check on
-     * [cls]. [cls] must be an interceptor class.
+     * [cls]. [cls] must be a non-native 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.if_(condition, buildReturnInterceptor(cls));
+      return js.statement('if (#) return #', [condition, interceptorFor(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;
     }
 
-    jsAst.Block block = new jsAst.Block.empty();
+    List<Statement> statements = <Statement>[];
 
     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.Return returnNumberClass = buildReturnInterceptor(
+      jsAst.Expression interceptorForNumber = interceptorFor(
           hasDouble ? backend.jsDoubleClass : backend.jsNumberClass);
 
       if (hasInt) {
-        jsAst.Expression isInt = js('Math.floor(receiver) == receiver');
-        whenNumber = js.block([
-            js.if_(isInt, buildReturnInterceptor(backend.jsIntClass)),
-            returnNumberClass]);
+        whenNumber = js.statement('''{
+            if (Math.floor(receiver) == receiver) return #;
+            return #;
+        }''', [interceptorFor(backend.jsIntClass), interceptorForNumber]);
       } else {
-        whenNumber = returnNumberClass;
+        whenNumber = js.statement('return #', interceptorForNumber);
       }
-      block.statements.add(
-          js.if_('(typeof receiver) == "number"',
-                 whenNumber));
+      statements.add(
+          js.statement('if (typeof receiver == "number") #;', whenNumber));
     }
 
     if (hasString) {
-      block.statements.add(buildInterceptorCheck(backend.jsStringClass));
+      statements.add(buildInterceptorCheck(backend.jsStringClass));
     }
     if (hasNull) {
-      block.statements.add(buildInterceptorCheck(backend.jsNullClass));
+      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.
-      block.statements.add(js.if_('receiver == null',
-                                  js.return_(js('receiver'))));
+      statements.add(
+          js.statement('if (receiver == null) return receiver'));
     }
     if (hasBool) {
-      block.statements.add(buildInterceptorCheck(backend.jsBoolClass));
+      statements.add(buildInterceptorCheck(backend.jsBoolClass));
     }
     // TODO(ahe): It might be faster to check for Array before
     // function and bool.
     if (hasArray) {
-      block.statements.add(buildInterceptorCheck(backend.jsArrayClass));
+      statements.add(buildInterceptorCheck(backend.jsArrayClass));
     }
 
     if (hasNative) {
-      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'])));
+      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)]));
 
     } else {
       ClassElement jsUnknown = backend.jsUnknownJavaScriptObjectClass;
       if (compiler.codegenWorld.instantiatedClasses.contains(jsUnknown)) {
-        block.statements.add(
-            js.if_(js('!(receiver instanceof #)',
-                      js(namer.isolateAccess(compiler.objectClass))),
-                   buildReturnInterceptor(jsUnknown)));
+        statements.add(
+            js.statement('if (!(receiver instanceof #)) return #;',
+                [namer.elementAccess(compiler.objectClass),
+                 interceptorFor(jsUnknown)]));
       }
 
-      block.statements.add(js.return_(js('receiver')));
+      statements.add(js.statement('return receiver'));
     }
 
     buffer.write(jsAst.prettyPrint(
-        js('${namer.globalObjectFor(compiler.interceptorsLibrary)}.$key = #',
-           js.fun(['receiver'], block)),
+        js('''${namer.globalObjectFor(compiler.interceptorsLibrary)}.# =
+              function(receiver) { #; }''',
+            [key, statements]),
         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 == '==') {
-        // 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);
+        return js.statement('''{
+          if (receiver == null) return a0 == null;
+          if (typeof receiver != "object")
+            return a0 != null && receiver === a0;
+        }''');
       }
       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').binary(name, js('a0'));
+        jsAst.Expression result = js('receiver $name a0');
         if (name == '&' || name == '|' || name == '^') {
-          result = tripleShiftZero(result);
+          result = js('# >>> 0', 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));
+        return js.statement(
+            'if (typeof receiver == "number" && typeof a0 == "number")'
+            '  return #;',
+            result);
       } else if (name == 'unary-') {
-        // [: if (typeof receiver == "number") return -receiver :].
-        return js.if_(isNumber('receiver'),
-                      js.return_(js('-receiver')));
+        return js.statement(
+            'if (typeof receiver == "number") return -receiver');
       } else {
         assert(name == '~');
-        return js.if_(isInt('receiver'),
-                      js.return_(js('~receiver >>> 0')));
+        return js.statement('''
+          if (typeof receiver == "number" && Math.floor(receiver) == receiver)
+            return (~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 : left.binary('||', right);
+        return left == null ? right : js('# || #', [left, right]);
       }
 
       if (selector.isIndex()) {
-        jsAst.Expression stringCheck = js('typeof receiver == "string"');
         jsAst.Expression typeCheck;
         if (containsArray) {
           typeCheck = arrayCheck;
         }
 
         if (containsString) {
-          typeCheck = orExp(typeCheck, stringCheck);
+          typeCheck = orExp(typeCheck, js('typeof receiver == "string"'));
         }
 
         if (containsJsIndexable) {
           typeCheck = orExp(typeCheck, indexableCheck);
         }
 
-        return js.if_(typeCheck,
-                      js.if_(isIntAndAboveZero.binary('&&', belowLength),
-                             js.return_(js('receiver[a0]'))));
+        return js.statement('''
+          if (#)
+            if ((a0 >>> 0) === a0 && a0 < receiver.length)
+              return receiver[a0];
+          ''', typeCheck);
       } else {
         jsAst.Expression typeCheck;
         if (containsArray) {
           typeCheck = arrayCheck;
         }
 
         if (containsJsIndexable) {
           typeCheck = orExp(typeCheck, indexableCheck);
         }
 
-        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 js.statement(r'''
+          if (# && !receiver.immutable$list &&
+              (a0 >>> 0) === a0 && a0 < receiver.length)
+            return receiver[a0] = a1;
+          ''', typeCheck);
       }
     }
     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<jsAst.Parameter> parameters = <jsAst.Parameter>[];
-      List<jsAst.Expression> arguments = <jsAst.Expression>[];
-      parameters.add(new jsAst.Parameter('receiver'));
-      arguments.add(js('receiver'));
+      List<String> parameterNames = <String>[];
+      parameterNames.add('receiver');
 
       if (selector.isSetter()) {
-        parameters.add(new jsAst.Parameter('value'));
-        arguments.add(js('value'));
+        parameterNames.add('value');
       } else {
         for (int i = 0; i < selector.argumentCount; i++) {
-          String argName = 'a$i';
-          parameters.add(new jsAst.Parameter(argName));
-          arguments.add(js(argName));
+          parameterNames.add('a$i');
         }
       }
 
-      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.Expression assignment =
-          js('${globalObject}.$name = #', js.fun(parameters, body));
+      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]);
 
       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);
   }
 }