dartfmt pkg/compiler

pkg/compiler/lib/src/js_backend/lookup_map_analysis.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.
 
 /// Analysis to determine how to generate code for `LookupMap`s.
 library compiler.src.js_backend.lookup_map_analysis;
 
 import '../common.dart';
 import '../common/registry.dart' show Registry;
 import '../compiler.dart' show Compiler;
-import '../constants/values.dart' show
-    ConstantValue,
-    ConstructedConstantValue,
-    ListConstantValue,
-    NullConstantValue,
-    StringConstantValue,
-    TypeConstantValue;
+import '../constants/values.dart'
+    show
+        ConstantValue,
+        ConstructedConstantValue,
+        ListConstantValue,
+        NullConstantValue,
+        StringConstantValue,
+        TypeConstantValue;
 import '../dart_types.dart' show DartType;
-import '../elements/elements.dart' show
-    ClassElement,
-    Element,
-    Elements,
-    FieldElement,
-    FunctionElement,
-    FunctionSignature,
-    LibraryElement,
-    VariableElement;
+import '../elements/elements.dart'
+    show
+        ClassElement,
+        Element,
+        Elements,
+        FieldElement,
+        FunctionElement,
+        FunctionSignature,
+        LibraryElement,
+        VariableElement;
 import 'js_backend.dart' show JavaScriptBackend;
 import '../dart_types.dart' show DynamicType, InterfaceType;
 import 'package:pub_semver/pub_semver.dart';
 
 /// An analysis and optimization to remove unused entries from a `LookupMap`.
 ///
 /// `LookupMaps` are defined in `package:lookup_map/lookup_map.dart`. They are
 /// simple maps that contain constant expressions as keys, and that only support
 /// the lookup operation.
 ///
@@ skipping 98 matching lines @@
   }
 
   /// Initializes this analysis by providing the resolved library. This is
   /// invoked during resolution when the `lookup_map` library is discovered.
   void init(LibraryElement library) {
     lookupMapLibrary = library;
     // We will enable the lookupMapAnalysis as long as we get a known version of
     // the lookup_map package. We otherwise produce a warning.
     lookupMapVersionVariable = library.implementation.findLocal('_version');
     if (lookupMapVersionVariable == null) {
-      reporter.reportInfo(library,
-          MessageKind.UNRECOGNIZED_VERSION_OF_LOOKUP_MAP);
+      reporter.reportInfo(
+          library, MessageKind.UNRECOGNIZED_VERSION_OF_LOOKUP_MAP);
     } else {
-      backend.compiler.enqueuer.resolution.addToWorkList(
-          lookupMapVersionVariable);
+      backend.compiler.enqueuer.resolution
+          .addToWorkList(lookupMapVersionVariable);
     }
   }
 
   /// Checks if the version of lookup_map is valid, and if so, enable this
   /// analysis during codegen.
   void onCodegenStart() {
     _inCodegen = true;
     if (lookupMapVersionVariable == null) return;
 
     // At this point, the lookupMapVersionVariable should be resolved and it's
@@ skipping 31 matching lines @@
   /// Whether [constant] is an instance of a `LookupMap`.
   bool isLookupMap(ConstantValue constant) =>
       _isEnabled &&
       constant is ConstructedConstantValue &&
       constant.type.asRaw().element.isSubclassOf(typeLookupMapClass);
 
   /// Registers an instance of a lookup-map with the analysis.
   void registerLookupMapReference(ConstantValue lookupMap) {
     if (!_isEnabled || !_inCodegen) return;
     assert(isLookupMap(lookupMap));
-    _lookupMaps.putIfAbsent(lookupMap,
-        () => new _LookupMapInfo(lookupMap, this).._updateUsed());
+    _lookupMaps.putIfAbsent(
+        lookupMap, () => new _LookupMapInfo(lookupMap, this).._updateUsed());
   }
 
   /// Whether [key] is a constant value whose type overrides equals.
   bool _overridesEquals(ConstantValue key) {
     if (key is ConstructedConstantValue) {
       ClassElement element = key.type.element;
-      return _typesWithEquals.putIfAbsent(element, () =>
-          !element.lookupMember('==').enclosingClass.isObject);
+      return _typesWithEquals.putIfAbsent(
+          element, () => !element.lookupMember('==').enclosingClass.isObject);
     }
     return false;
   }
 
   /// Whether we need to preserve [key]. This is true for keys that are not
   /// candidates for tree-shaking in the first place (primitives and non-type
   /// const values overriding equals) and keys that we have seen in the program.
   bool _shouldKeep(ConstantValue key) =>
       key.isPrimitive || _inUse.contains(key) || _overridesEquals(key);
 
@@ skipping 70 matching lines @@
   }
 
   /// Callback from the backend, invoked when reaching the end of the enqueuing
   /// process, but before emitting the code. At this moment we have discovered
   /// all types used in the program and we can tree-shake anything that is
   /// unused.
   void onQueueClosed() {
     if (!_isEnabled || !_inCodegen) return;
 
     _lookupMaps.values.forEach((info) {
-      assert (!info.emitted);
+      assert(!info.emitted);
       info.emitted = true;
       info._prepareForEmission();
     });
 
     // When --verbose is passed, we show the total number and set of keys that
     // were tree-shaken from lookup maps.
     Compiler compiler = backend.compiler;
     if (compiler.options.verbose) {
       var sb = new StringBuffer();
       int count = 0;
@@ skipping 36 matching lines @@
   /// Whether we have already emitted this constant.
   bool emitted = false;
 
   /// Whether the `LookupMap` constant was built using the `LookupMap.pair`
   /// constructor.
   bool singlePair;
 
   /// Entries in the lookup map whose keys have not been seen in the rest of the
   /// program.
   Map<ConstantValue, ConstantValue> unusedEntries =
-      <ConstantValue, ConstantValue> {};
+      <ConstantValue, ConstantValue>{};
 
   /// Entries that have been used, and thus will be part of the generated code.
   Map<ConstantValue, ConstantValue> usedEntries =
-      <ConstantValue, ConstantValue> {};
+      <ConstantValue, ConstantValue>{};
 
   /// Creates and initializes the information containing all keys of the
   /// original map marked as unused.
   _LookupMapInfo(this.original, this.analysis) {
     ConstantValue key = original.fields[analysis.keyField];
     singlePair = !key.isNull;
 
     if (singlePair) {
       unusedEntries[key] = original.fields[analysis.valueField];
 
@@ skipping 31 matching lines @@
   }
 
   /// Marks that [key] has been seen, and thus, the corresponding entry in this
   /// map should be considered reachable.
   _markUsed(ConstantValue key) {
     assert(!emitted);
     assert(unusedEntries.containsKey(key));
     assert(!usedEntries.containsKey(key));
     ConstantValue constant = unusedEntries.remove(key);
     usedEntries[key] = constant;
-    analysis.backend.registerCompileTimeConstant(constant,
-        analysis.backend.compiler.globalDependencies);
+    analysis.backend.registerCompileTimeConstant(
+        constant, analysis.backend.compiler.globalDependencies);
   }
 
   /// Restores [original] to contain all of the entries marked as possibly used.
   void _prepareForEmission() {
     ListConstantValue originalEntries = original.fields[analysis.entriesField];
     DartType listType = originalEntries.type;
     List<ConstantValue> keyValuePairs = <ConstantValue>[];
     usedEntries.forEach((key, value) {
       keyValuePairs.add(key);
       keyValuePairs.add(value);
     });
 
     // Note: we are restoring the entries here, see comment in [original].
     if (singlePair) {
-      assert (keyValuePairs.length == 0 || keyValuePairs.length == 2);
+      assert(keyValuePairs.length == 0 || keyValuePairs.length == 2);
       if (keyValuePairs.length == 2) {
         original.fields[analysis.keyField] = keyValuePairs[0];
         original.fields[analysis.valueField] = keyValuePairs[1];
       }
     } else {
       original.fields[analysis.entriesField] =
           new ListConstantValue(listType, keyValuePairs);
     }
   }
 }
 
-final _validLookupMapVersionConstraint =
-    new VersionConstraint.parse('^0.0.1');
+final _validLookupMapVersionConstraint = new VersionConstraint.parse('^0.0.1');