dartfmt pkg/compiler

pkg/compiler/lib/src/js_emitter/full_emitter/nsm_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.full_emitter;
 
 class NsmEmitter extends CodeEmitterHelper {
   final List<Selector> trivialNsmHandlers = <Selector>[];
 
   /// If this is true then we can generate the noSuchMethod handlers at startup
   /// time, instead of them being emitted as part of the Object class.
   bool get generateTrivialNsmHandlers => true;
 
   // If we need fewer than this many noSuchMethod handlers we can save space by
   // just emitting them in JS, rather than emitting the JS needed to generate
   // them at run time.
   static const VERY_FEW_NO_SUCH_METHOD_HANDLERS = 10;
 
   static const MAX_MINIFIED_LENGTH_FOR_DIFF_ENCODING = 4;
 
   void emitNoSuchMethodHandlers(AddPropertyFunction addProperty) {
-
     ClassStubGenerator generator =
         new ClassStubGenerator(compiler, namer, backend);
 
     // Keep track of the JavaScript names we've already added so we
     // do not introduce duplicates (bad for code size).
-    Map<jsAst.Name, Selector> addedJsNames
-        = generator.computeSelectorsForNsmHandlers();
+    Map<jsAst.Name, Selector> addedJsNames =
+        generator.computeSelectorsForNsmHandlers();
 
     // Set flag used by generateMethod helper below.  If we have very few
     // handlers we use addProperty for them all, rather than try to generate
     // them at runtime.
     bool haveVeryFewNoSuchMemberHandlers =
         (addedJsNames.length < VERY_FEW_NO_SUCH_METHOD_HANDLERS);
-    List<jsAst.Name> names = addedJsNames.keys.toList()
-        ..sort();
+    List<jsAst.Name> names = addedJsNames.keys.toList()..sort();
     for (jsAst.Name jsName in names) {
       Selector selector = addedJsNames[jsName];
       String reflectionName = emitter.getReflectionName(selector, jsName);
 
       if (reflectionName != null) {
         emitter.mangledFieldNames[jsName] = reflectionName;
       }
 
-      List<jsAst.Expression> argNames =
-          selector.callStructure.getOrderedNamedArguments().map((String name) =>
-              js.string(name)).toList();
+      List<jsAst.Expression> argNames = selector.callStructure
+          .getOrderedNamedArguments()
+          .map((String name) => js.string(name))
+          .toList();
       int type = selector.invocationMirrorKind;
       if (!haveVeryFewNoSuchMemberHandlers &&
           isTrivialNsmHandler(type, argNames, selector, jsName) &&
           reflectionName == null) {
         trivialNsmHandlers.add(selector);
       } else {
         StubMethod method =
             generator.generateStubForNoSuchMethod(jsName, selector);
         addProperty(method.name, method.code);
         if (reflectionName != null) {
-          bool accessible =
-              compiler.world.allFunctions.filter(selector, null).any(
-              (Element e) => backend.isAccessibleByReflection(e));
-          addProperty(namer.asName('+$reflectionName'),
-                      js(accessible ? '2' : '0'));
+          bool accessible = compiler.world.allFunctions
+              .filter(selector, null)
+              .any((Element e) => backend.isAccessibleByReflection(e));
+          addProperty(
+              namer.asName('+$reflectionName'), js(accessible ? '2' : '0'));
         }
       }
     }
   }
 
   // Identify the noSuchMethod handlers that are so simple that we can
   // generate them programatically.
   bool isTrivialNsmHandler(
       int type, List argNames, Selector selector, jsAst.Name internalName) {
     if (!generateTrivialNsmHandlers) return false;
@@ skipping 46 matching lines @@
    */
   List<jsAst.Statement> buildTrivialNsmHandlers() {
     List<jsAst.Statement> statements = <jsAst.Statement>[];
     if (trivialNsmHandlers.length == 0) return statements;
 
     bool minify = compiler.options.enableMinification;
     bool useDiffEncoding = minify && trivialNsmHandlers.length > 30;
 
     // Find out how many selectors there are with the special calling
     // convention.
-    Iterable<Selector> interceptedSelectors = trivialNsmHandlers.where(
-            (Selector s) => backend.isInterceptedName(s.name));
-    Iterable<Selector> ordinarySelectors = trivialNsmHandlers.where(
-            (Selector s) => !backend.isInterceptedName(s.name));
+    Iterable<Selector> interceptedSelectors = trivialNsmHandlers
+        .where((Selector s) => backend.isInterceptedName(s.name));
+    Iterable<Selector> ordinarySelectors = trivialNsmHandlers
+        .where((Selector s) => !backend.isInterceptedName(s.name));
 
     // Get the short names (JS names, perhaps minified).
     Iterable<jsAst.Name> interceptedShorts =
         interceptedSelectors.map(namer.invocationMirrorInternalName);
     Iterable<jsAst.Name> ordinaryShorts =
         ordinarySelectors.map(namer.invocationMirrorInternalName);
 
     jsAst.Expression sortedShorts;
     Iterable<String> sortedLongs;
     if (useDiffEncoding) {
       assert(minify);
-      sortedShorts = new _DiffEncodedListOfNames(
-          [interceptedShorts, ordinaryShorts]);
+      sortedShorts =
+          new _DiffEncodedListOfNames([interceptedShorts, ordinaryShorts]);
     } else {
       Iterable<Selector> sorted =
           [interceptedSelectors, ordinarySelectors].expand((e) => (e));
       sortedShorts = js.concatenateStrings(
-          js.joinLiterals(
-              sorted.map(namer.invocationMirrorInternalName),
+          js.joinLiterals(sorted.map(namer.invocationMirrorInternalName),
               js.stringPart(",")),
           addQuotes: true);
 
       if (!minify) {
-        sortedLongs = sorted.map((selector) =>
-            selector.invocationMirrorMemberName);
+        sortedLongs =
+            sorted.map((selector) => selector.invocationMirrorMemberName);
       }
     }
     // Startup code that loops over the method names and puts handlers on the
     // Object class to catch noSuchMethod invocations.
     ClassElement objectClass = compiler.coreClasses.objectClass;
     jsAst.Expression createInvocationMirror = backend.emitter
         .staticFunctionAccess(backend.helpers.createInvocationMirror);
     if (useDiffEncoding) {
-      statements.add(js.statement('''{
+      statements.add(js.statement(
+          '''{
           var objectClassObject = processedClasses.collected[#objectClass],
               nameSequences = #diffEncoding.split("."),
               shortNames = [];
           if (objectClassObject instanceof Array)
               objectClassObject = objectClassObject[1];
           for (var j = 0; j < nameSequences.length; ++j) {
               var sequence = nameSequences[j].split(","),
                 nameNumber = 0;
             // If we are loading a deferred library the object class will not be
             // in the collectedClasses so objectClassObject is undefined, and we
@@ skipping 19 matching lines @@
                    remaining = (remaining / 88) | 0) {
                 codes.unshift(${$HASH} + remaining % 88);
               }
               shortNames.push(
                 String.fromCharCode.apply(String, codes));
             }
             if (sequence.length > 1) {
               Array.prototype.push.apply(shortNames, sequence.shift());
             }
           }
-        }''', {'objectClass': js.quoteName(namer.className(objectClass)),
-               'diffEncoding': sortedShorts}));
+        }''',
+          {
+            'objectClass': js.quoteName(namer.className(objectClass)),
+            'diffEncoding': sortedShorts
+          }));
     } else {
       // No useDiffEncoding version.
       statements.add(js.statement(
           'var objectClassObject = processedClasses.collected[#objectClass],'
           '    shortNames = #diffEncoding.split(",")',
-          {'objectClass': js.quoteName(namer.className(objectClass)),
-           'diffEncoding': sortedShorts}));
+          {
+            'objectClass': js.quoteName(namer.className(objectClass)),
+            'diffEncoding': sortedShorts
+          }));
       if (!minify) {
         statements.add(js.statement('var longNames = #longs.split(",")',
-                {'longs': js.string(sortedLongs.join(','))}));
+            {'longs': js.string(sortedLongs.join(','))}));
       }
-      statements.add(js.statement(
-          'if (objectClassObject instanceof Array)'
+      statements.add(js.statement('if (objectClassObject instanceof Array)'
           '  objectClassObject = objectClassObject[1];'));
     }
 
-    dynamic isIntercepted =  // jsAst.Expression or bool.
+    dynamic isIntercepted = // jsAst.Expression or bool.
         interceptedSelectors.isEmpty
         ? false
         : ordinarySelectors.isEmpty
             ? true
             : js('j < #', js.number(interceptedSelectors.length));
 
-    statements.add(js.statement('''
+    statements.add(js.statement(
+        '''
       // If we are loading a deferred library the object class will not be in
       // the collectedClasses so objectClassObject is undefined, and we skip
       // setting up the names.
       if (objectClassObject) {
         for (var j = 0; j < shortNames.length; j++) {
           var type = 0;
           var shortName = shortNames[j];
           if (shortName.indexOf("${namer.getterPrefix}") == 0) type = 1;
           if (shortName.indexOf("${namer.setterPrefix}") == 0) type = 2;
           // Generate call to:
@@ skipping 26 matching lines @@
                       // argument. We could pass anything in place of [this].
                       this,
                       #createInvocationMirror(name, shortName, type,
                           // Create proper Array with all arguments.
                           Array.prototype.slice.call(arguments, 0),
                           []));
                   }
                  })(#names[j], shortName, type);
           }
         }
-      }''', {
+      }''',
+        {
           'noSuchMethodName': namer.noSuchMethodName,
           'createInvocationMirror': createInvocationMirror,
           'names': minify ? 'shortNames' : 'longNames',
-          'isIntercepted': isIntercepted}));
+          'isIntercepted': isIntercepted
+        }));
 
     return statements;
   }
 }
 
 /// When pretty printed, this node computes a diff-encoded string for the list
 /// of given names.
 ///
 /// See [buildTrivialNsmHandlers].
 class _DiffEncodedListOfNames extends jsAst.DeferredString
-                              implements jsAst.AstContainer {
+    implements jsAst.AstContainer {
   String _cachedValue;
   List<jsAst.ArrayInitializer> ast;
 
   Iterable<jsAst.Node> get containedNodes => ast;
 
   _DiffEncodedListOfNames(Iterable<Iterable<jsAst.Name>> names) {
     // Store the names in ArrayInitializer nodes to make them discoverable
     // by traversals of the ast.
-    ast = names.map((Iterable i) => new jsAst.ArrayInitializer(i.toList()))
-               .toList();
+    ast = names
+        .map((Iterable i) => new jsAst.ArrayInitializer(i.toList()))
+        .toList();
   }
 
-  void _computeDiffEncodingForList(Iterable<jsAst.Name> names,
-                                   StringBuffer diffEncoding) {
+  void _computeDiffEncodingForList(
+      Iterable<jsAst.Name> names, StringBuffer diffEncoding) {
     // Treat string as a number in base 88 with digits in ASCII order from # to
     // z.  The short name sorting is based on length, and uses ASCII order for
     // equal length strings so this means that names are ascending.  The hash
     // character, #, is never given as input, but we need it because it's the
     // implicit leading zero (otherwise we could not code names with leading
     // dollar signs).
     int fromBase88(String x) {
       int answer = 0;
       for (int i = 0; i < x.length; i++) {
         int c = x.codeUnitAt(i);
@@ skipping 18 matching lines @@
       }
       return new String.fromCharCodes(encodingChars.reversed.toList());
     }
 
     // Sort by length, then lexicographic.
     int compare(String a, String b) {
       if (a.length != b.length) return a.length - b.length;
       return a.compareTo(b);
     }
 
-    List<String> shorts =
-        names.map((jsAst.Name name) => name.name)
-        .toList()
-        ..sort(compare);
+    List<String> shorts = names.map((jsAst.Name name) => name.name).toList()
+      ..sort(compare);
 
     int previous = 0;
     for (String short in shorts) {
       if (short.length <= NsmEmitter.MAX_MINIFIED_LENGTH_FOR_DIFF_ENCODING) {
         int base63 = fromBase88(short);
         int diff = base63 - previous;
         previous = base63;
         String base26Diff = toBase26(diff);
         diffEncoding.write(base26Diff);
       } else {
@@ skipping 21 matching lines @@
   }
 
   String get value {
     if (_cachedValue == null) {
       _cachedValue = _computeDiffEncoding();
     }
 
     return _cachedValue;
   }
 }