dartfmt pkg/compiler

pkg/compiler/lib/src/resolution/registry.dart

 // Copyright (c) 2014, 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 dart2js.resolution.registry;
 
 import '../common.dart';
-import '../common/backend_api.dart' show
-    Backend,
-    ForeignResolver;
-import '../common/resolution.dart' show
-    Feature,
-    ListLiteralUse,
-    MapLiteralUse,
-    ResolutionImpact;
-import '../common/registry.dart' show
-    Registry;
-import '../compiler.dart' show
-    Compiler;
+import '../common/backend_api.dart' show Backend, ForeignResolver;
+import '../common/resolution.dart'
+    show Feature, ListLiteralUse, MapLiteralUse, ResolutionImpact;
+import '../common/registry.dart' show Registry;
+import '../compiler.dart' show Compiler;
 import '../constants/expressions.dart';
 import '../dart_types.dart';
 import '../diagnostics/source_span.dart';
-import '../enqueue.dart' show
-    ResolutionEnqueuer;
+import '../enqueue.dart' show ResolutionEnqueuer;
 import '../elements/elements.dart';
 import '../tree/tree.dart';
-import '../util/util.dart' show
-    Setlet;
-import '../universe/call_structure.dart' show
-    CallStructure;
-import '../universe/selector.dart' show
-    Selector;
-import '../universe/use.dart' show
-    DynamicUse,
-    StaticUse,
-    TypeUse;
-import '../universe/world_impact.dart' show
-    WorldImpactBuilder;
-import '../util/enumset.dart' show
-    EnumSet;
-import '../world.dart' show
-    World;
+import '../util/util.dart' show Setlet;
+import '../universe/call_structure.dart' show CallStructure;
+import '../universe/selector.dart' show Selector;
+import '../universe/use.dart' show DynamicUse, StaticUse, TypeUse;
+import '../universe/world_impact.dart' show WorldImpactBuilder;
+import '../util/enumset.dart' show EnumSet;
+import '../world.dart' show World;
 
 import 'send_structure.dart';
 
-import 'members.dart' show
-    ResolverVisitor;
-import 'tree_elements.dart' show
-    TreeElementMapping;
+import 'members.dart' show ResolverVisitor;
+import 'tree_elements.dart' show TreeElementMapping;
 
 class _ResolutionWorldImpact extends ResolutionImpact with WorldImpactBuilder {
   final String name;
   EnumSet<Feature> _features;
   Setlet<MapLiteralUse> _mapLiterals;
   Setlet<ListLiteralUse> _listLiterals;
   Setlet<String> _constSymbolNames;
   Setlet<ConstantExpression> _constantLiterals;
 
   _ResolutionWorldImpact(this.name);
 
   void registerMapLiteral(MapLiteralUse mapLiteralUse) {
     assert(mapLiteralUse != null);
     if (_mapLiterals == null) {
       _mapLiterals = new Setlet<MapLiteralUse>();
     }
     _mapLiterals.add(mapLiteralUse);
   }
 
   @override
   Iterable<MapLiteralUse> get mapLiterals {
-    return _mapLiterals != null
-        ? _mapLiterals : const <MapLiteralUse>[];
+    return _mapLiterals != null ? _mapLiterals : const <MapLiteralUse>[];
   }
 
   void registerListLiteral(ListLiteralUse listLiteralUse) {
     assert(listLiteralUse != null);
     if (_listLiterals == null) {
       _listLiterals = new Setlet<ListLiteralUse>();
     }
     _listLiterals.add(listLiteralUse);
   }
 
   @override
   Iterable<ListLiteralUse> get listLiterals {
-    return _listLiterals != null
-        ? _listLiterals : const <ListLiteralUse>[];
+    return _listLiterals != null ? _listLiterals : const <ListLiteralUse>[];
   }
 
   void registerConstSymbolName(String name) {
     if (_constSymbolNames == null) {
       _constSymbolNames = new Setlet<String>();
     }
     _constSymbolNames.add(name);
   }
 
   @override
   Iterable<String> get constSymbolNames {
-    return _constSymbolNames != null
-        ? _constSymbolNames : const <String>[];
+    return _constSymbolNames != null ? _constSymbolNames : const <String>[];
   }
 
   void registerFeature(Feature feature) {
     if (_features == null) {
       _features = new EnumSet<Feature>();
     }
     _features.add(feature);
   }
 
   @override
   Iterable<Feature> get features {
     return _features != null
-        ? _features.iterable(Feature.values) : const <Feature>[];
+        ? _features.iterable(Feature.values)
+        : const <Feature>[];
   }
 
   void registerConstantLiteral(ConstantExpression constant) {
     if (_constantLiterals == null) {
       _constantLiterals = new Setlet<ConstantExpression>();
     }
     _constantLiterals.add(constant);
   }
 
   Iterable<ConstantExpression> get constantLiterals {
     return _constantLiterals != null
-        ? _constantLiterals : const <ConstantExpression>[];
+        ? _constantLiterals
+        : const <ConstantExpression>[];
   }
 
   String toString() => '_ResolutionWorldImpact($name)';
 }
 
 /// [ResolutionRegistry] collects all resolution information. It stores node
 /// related information in a [TreeElements] mapping and registers calls with
 /// [Backend], [World] and [Enqueuer].
 // TODO(johnniwinther): Split this into an interface and implementation class.
 class ResolutionRegistry extends Registry {
   final Compiler compiler;
   final TreeElementMapping mapping;
   final _ResolutionWorldImpact worldImpact;
 
   ResolutionRegistry(Compiler compiler, TreeElementMapping mapping)
       : this.compiler = compiler,
         this.mapping = mapping,
-        this.worldImpact = new _ResolutionWorldImpact(
-            mapping.analyzedElement.toString());
+        this.worldImpact =
+            new _ResolutionWorldImpact(mapping.analyzedElement.toString());
 
   bool get isForResolution => true;
 
   ResolutionEnqueuer get world => compiler.enqueuer.resolution;
 
   World get universe => compiler.world;
 
   Backend get backend => compiler.backend;
 
   String toString() => 'ResolutionRegistry for ${mapping.analyzedElement}';
@@ skipping 26 matching lines @@
   Element getDefinition(Node node) {
     return mapping[node];
   }
 
   /// Sets the loop variable of the for-in [node] to be [element].
   void setForInVariable(ForIn node, Element element) {
     mapping[node] = element;
   }
 
   /// Sets the target constructor [node] to be [element].
-  void setRedirectingTargetConstructor(RedirectingFactoryBody node,
-                                       ConstructorElement element) {
+  void setRedirectingTargetConstructor(
+      RedirectingFactoryBody node, ConstructorElement element) {
     useElement(node, element);
   }
 
   //////////////////////////////////////////////////////////////////////////////
   //  Node-to-Selector mapping functionality.
   //////////////////////////////////////////////////////////////////////////////
 
   void setSelector(Node node, Selector selector) {
     mapping.setSelector(node, selector);
   }
@@ skipping 74 matching lines @@
 
   /// Register the target of [node] to be [target].
   void registerTargetOf(GotoStatement node, JumpTarget target) {
     mapping.registerTargetOf(node, target);
   }
 
   //////////////////////////////////////////////////////////////////////////////
   //  Potential access registration.
   //////////////////////////////////////////////////////////////////////////////
 
-  void setAccessedByClosureIn(Node contextNode, VariableElement element,
-                              Node accessNode) {
+  void setAccessedByClosureIn(
+      Node contextNode, VariableElement element, Node accessNode) {
     mapping.setAccessedByClosureIn(contextNode, element, accessNode);
   }
 
   void registerPotentialMutation(VariableElement element, Node mutationNode) {
     mapping.registerPotentialMutation(element, mutationNode);
   }
 
-  void registerPotentialMutationInClosure(VariableElement element,
-                                           Node mutationNode) {
+  void registerPotentialMutationInClosure(
+      VariableElement element, Node mutationNode) {
     mapping.registerPotentialMutationInClosure(element, mutationNode);
   }
 
-  void registerPotentialMutationIn(Node contextNode, VariableElement element,
-                                    Node mutationNode) {
+  void registerPotentialMutationIn(
+      Node contextNode, VariableElement element, Node mutationNode) {
     mapping.registerPotentialMutationIn(contextNode, element, mutationNode);
   }
 
   //////////////////////////////////////////////////////////////////////////////
   //  Various Backend/Enqueuer/World registration.
   //////////////////////////////////////////////////////////////////////////////
 
   void registerStaticUse(StaticUse staticUse) {
     worldImpact.registerStaticUse(staticUse);
   }
 
   void registerMetadataConstant(MetadataAnnotation metadata) {
     backend.registerMetadataConstant(metadata, metadata.annotatedElement, this);
   }
 
   /// Register the use of a type.
   void registerTypeUse(TypeUse typeUse) {
     worldImpact.registerTypeUse(typeUse);
   }
 
   void registerSuperUse(SourceSpan span) {
     mapping.addSuperUse(span);
   }
 
   void registerTypeLiteral(Send node, DartType type) {
     mapping.setType(node, type);
     worldImpact.registerTypeUse(new TypeUse.typeLiteral(type));
   }
 
-  void registerLiteralList(Node node,
-                           InterfaceType type,
-                           {bool isConstant,
-                            bool isEmpty}) {
+  void registerLiteralList(Node node, InterfaceType type,
+      {bool isConstant, bool isEmpty}) {
     setType(node, type);
     worldImpact.registerListLiteral(
         new ListLiteralUse(type, isConstant: isConstant, isEmpty: isEmpty));
   }
 
-  void registerMapLiteral(Node node,
-                          InterfaceType type,
-                          {bool isConstant,
-                           bool isEmpty}) {
+  void registerMapLiteral(Node node, InterfaceType type,
+      {bool isConstant, bool isEmpty}) {
     setType(node, type);
     worldImpact.registerMapLiteral(
         new MapLiteralUse(type, isConstant: isConstant, isEmpty: isEmpty));
   }
 
-  void registerForeignCall(Node node,
-                           Element element,
-                           CallStructure callStructure,
-                           ResolverVisitor visitor) {
-    backend.registerForeignCall(
-        node, element, callStructure,
+  void registerForeignCall(Node node, Element element,
+      CallStructure callStructure, ResolverVisitor visitor) {
+    backend.registerForeignCall(node, element, callStructure,
         new ForeignResolutionResolver(visitor, this));
   }
 
   void registerDynamicUse(DynamicUse dynamicUse) {
     worldImpact.registerDynamicUse(dynamicUse);
   }
 
   void registerFeature(Feature feature) {
     worldImpact.registerFeature(feature);
   }
 
   void registerConstSymbol(String name) {
     worldImpact.registerConstSymbolName(name);
   }
 
   void registerConstantLiteral(ConstantExpression constant) {
     worldImpact.registerConstantLiteral(constant);
   }
 
   ClassElement defaultSuperclass(ClassElement element) {
     return backend.defaultSuperclass(element);
   }
 
-  void registerMixinUse(MixinApplicationElement mixinApplication,
-                        ClassElement mixin) {
+  void registerMixinUse(
+      MixinApplicationElement mixinApplication, ClassElement mixin) {
     universe.registerMixinUse(mixinApplication, mixin);
   }
 
   void registerInstantiation(InterfaceType type) {
     worldImpact.registerTypeUse(new TypeUse.instantiation(type));
   }
 
   void registerSendStructure(Send node, SendStructure sendStructure) {
     mapping.setSendStructure(node, sendStructure);
   }
@@ skipping 27 matching lines @@
   @override
   void registerInstantiatedType(InterfaceType type) {
     registry.registerInstantiation(type);
   }
 
   @override
   DartType resolveTypeFromString(Node node, String typeName) {
     return visitor.resolveTypeFromString(node, typeName);
   }
 }