dartfmt pkg/compiler

pkg/compiler/lib/src/universe/class_set.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.
 
 library dart2js.world.class_set;
 
-import 'dart:collection' show
-    IterableBase;
-import '../elements/elements.dart' show
-    ClassElement;
-import '../util/enumset.dart' show
-    EnumSet;
-import '../util/util.dart' show
-    Link;
+import 'dart:collection' show IterableBase;
+import '../elements/elements.dart' show ClassElement;
+import '../util/enumset.dart' show EnumSet;
+import '../util/util.dart' show Link;
 
 /// Enum for the different kinds of instantiation of a class.
 enum Instantiation {
   UNINSTANTIATED,
   DIRECTLY_INSTANTIATED,
   INDIRECTLY_INSTANTIATED,
 }
 
 /// Node for [cls] in a tree forming the subclass relation of [ClassElement]s.
 ///
@@ skipping 18 matching lines @@
 ///       |
 ///       D
 ///       |
 ///       E
 ///
 class ClassHierarchyNode {
   /// Enum set for selecting instantiated classes in
   /// [ClassHierarchyNode.subclassesByMask],
   /// [ClassHierarchyNode.subclassesByMask] and [ClassSet.subtypesByMask].
   static final EnumSet<Instantiation> INSTANTIATED =
-      new EnumSet<Instantiation>.fromValues(
-          const <Instantiation>[
-              Instantiation.DIRECTLY_INSTANTIATED,
-              Instantiation.INDIRECTLY_INSTANTIATED],
-          fixed: true);
+      new EnumSet<Instantiation>.fromValues(const <Instantiation>[
+    Instantiation.DIRECTLY_INSTANTIATED,
+    Instantiation.INDIRECTLY_INSTANTIATED
+  ], fixed: true);
 
   /// Enum set for selecting directly instantiated classes in
   /// [ClassHierarchyNode.subclassesByMask],
   /// [ClassHierarchyNode.subclassesByMask] and [ClassSet.subtypesByMask].
   static final EnumSet<Instantiation> DIRECTLY_INSTANTIATED =
       new EnumSet<Instantiation>.fromValues(
           const <Instantiation>[Instantiation.DIRECTLY_INSTANTIATED],
           fixed: true);
 
   /// Enum set for selecting all classes in
   /// [ClassHierarchyNode.subclassesByMask],
   /// [ClassHierarchyNode.subclassesByMask] and [ClassSet.subtypesByMask].
   static final EnumSet<Instantiation> ALL =
-      new EnumSet<Instantiation>.fromValues(
-          Instantiation.values,
-          fixed: true);
+      new EnumSet<Instantiation>.fromValues(Instantiation.values, fixed: true);
 
   /// Creates an enum set for selecting the returned classes in
   /// [ClassHierarchyNode.subclassesByMask],
   /// [ClassHierarchyNode.subclassesByMask] and [ClassSet.subtypesByMask].
   static EnumSet<Instantiation> createMask(
       {bool includeDirectlyInstantiated: true,
-       bool includeIndirectlyInstantiated: true,
-       bool includeUninstantiated: true}) {
+      bool includeIndirectlyInstantiated: true,
+      bool includeUninstantiated: true}) {
     EnumSet<Instantiation> mask = new EnumSet<Instantiation>();
     if (includeDirectlyInstantiated) {
       mask.add(Instantiation.DIRECTLY_INSTANTIATED);
     }
     if (includeIndirectlyInstantiated) {
       mask.add(Instantiation.INDIRECTLY_INSTANTIATED);
     }
     if (includeUninstantiated) {
       mask.add(Instantiation.UNINSTANTIATED);
     }
     return mask;
   }
 
   final ClassHierarchyNode parentNode;
   final ClassElement cls;
-  final EnumSet<Instantiation> _mask =
-      new EnumSet<Instantiation>.fromValues(
-          const <Instantiation>[Instantiation.UNINSTANTIATED]);
+  final EnumSet<Instantiation> _mask = new EnumSet<Instantiation>.fromValues(
+      const <Instantiation>[Instantiation.UNINSTANTIATED]);
 
   ClassElement _leastUpperInstantiatedSubclass;
   int _instantiatedSubclassCount = 0;
 
   /// `true` if [cls] has been directly instantiated.
   ///
   /// For instance `C` but _not_ `B` in:
   ///   class B {}
   ///   class C extends B {}
   ///   main() => new C();
@@ skipping 86 matching lines @@
   }
 
   /// `true` if [cls] has been directly or indirectly instantiated.
   bool get isInstantiated => isDirectlyInstantiated || isIndirectlyInstantiated;
 
   /// Returns an [Iterable] of the subclasses of [cls] possibly including [cls].
   ///
   /// Subclasses are included if their instantiation properties intersect with
   /// their corresponding [Instantiation] values in [mask]. If [strict] is
   /// `true`, [cls] itself is _not_ returned.
-  Iterable<ClassElement> subclassesByMask(
-      EnumSet<Instantiation> mask,
+  Iterable<ClassElement> subclassesByMask(EnumSet<Instantiation> mask,
       {bool strict: false}) {
-    return new ClassHierarchyNodeIterable(
-        this, mask, includeRoot: !strict);
+    return new ClassHierarchyNodeIterable(this, mask, includeRoot: !strict);
   }
 
   /// Applies [predicate] to each subclass of [cls] matching the criteria
   /// specified by [mask] and [strict]. If [predicate] returns `true` on a
   /// class, visitation is stopped immediately and the function returns `true`.
   ///
   /// [predicate] is applied to subclasses if their instantiation properties
   /// intersect with their corresponding [Instantiation] values in [mask]. If
   /// [strict] is `true`, [predicate] is _not_ called on [cls] itself.
   bool anySubclass(
-      bool predicate(ClassElement cls),
-      EnumSet<Instantiation> mask,
+      bool predicate(ClassElement cls), EnumSet<Instantiation> mask,
       {bool strict: false}) {
-
     IterationStep wrapper(ClassElement cls) {
       return predicate(cls) ? IterationStep.STOP : IterationStep.CONTINUE;
     }
     return forEachSubclass(wrapper, mask, strict: strict) == IterationStep.STOP;
   }
 
   /// Applies [f] to each subclass of [cls] matching the criteria specified by
   /// [mask] and [strict].
   ///
   /// [f] is a applied to subclasses if their instantiation properties intersect
   /// with their corresponding [Instantiation] values in [mask]. If [strict] is
   /// `true`, [f] is _not_ called on [cls] itself.
   ///
   /// The visitation of subclasses can be cut short by the return value of [f].
   /// If [ForEach.STOP] is returned, no further classes are visited and the
   /// function stops immediately. If [ForEach.SKIP_SUBCLASSES] is returned, the
   /// subclasses of the last visited class are skipped, but visitation
   /// continues. The return value of the function is either [ForEach.STOP], if
   /// visitation was stopped, or [ForEach.CONTINUE] if visitation continued to
   /// the end.
-  IterationStep forEachSubclass(
-      ForEachFunction f,
-      EnumSet<Instantiation> mask,
+  IterationStep forEachSubclass(ForEachFunction f, EnumSet<Instantiation> mask,
       {bool strict: false}) {
     IterationStep nextStep;
     if (!strict && mask.intersects(_mask)) {
       nextStep = f(cls);
     }
     // Interpret `forEach == null` as `forEach == ForEach.CONTINUE`.
     nextStep ??= IterationStep.CONTINUE;
 
     if (nextStep == IterationStep.CONTINUE) {
       if (mask.contains(Instantiation.UNINSTANTIATED) || isInstantiated) {
@@ skipping 22 matching lines @@
     }
     return _leastUpperInstantiatedSubclass;
   }
 
   ClassElement _computeLeastUpperInstantiatedSubclass() {
     if (isDirectlyInstantiated) {
       return cls;
     }
     ClassHierarchyNode subclass;
     for (Link<ClassHierarchyNode> link = _directSubclasses;
-         !link.isEmpty;
-         link = link.tail) {
+        !link.isEmpty;
+        link = link.tail) {
       if (link.head.isInstantiated) {
         if (subclass == null) {
           subclass = link.head;
         } else {
           return cls;
         }
       }
     }
     if (subclass != null) {
       return subclass.getLubOfInstantiatedSubclasses();
     }
     return cls;
   }
 
   void printOn(StringBuffer sb, String indentation,
-               {bool instantiatedOnly: false,
-                bool sorted: true,
-                ClassElement withRespectTo}) {
-
+      {bool instantiatedOnly: false,
+      bool sorted: true,
+      ClassElement withRespectTo}) {
     bool isRelatedTo(ClassElement subclass) {
       return subclass == withRespectTo ||
           subclass.implementsInterface(withRespectTo);
     }
 
     sb.write(indentation);
     if (cls.isAbstract) {
       sb.write('abstract ');
     }
     sb.write('class ${cls.name}:');
     if (isDirectlyInstantiated) {
       sb.write(' directly');
     }
     if (isIndirectlyInstantiated) {
       sb.write(' indirectly');
     }
     sb.write(' [');
     if (_directSubclasses.isEmpty) {
       sb.write(']');
     } else {
       var subclasses = _directSubclasses;
       if (sorted) {
-        subclasses = _directSubclasses.toList()..sort((a, b) {
-          return a.cls.name.compareTo(b.cls.name);
-        });
+        subclasses = _directSubclasses.toList()
+          ..sort((a, b) {
+            return a.cls.name.compareTo(b.cls.name);
+          });
       }
       bool needsComma = false;
       for (ClassHierarchyNode child in subclasses) {
         if (instantiatedOnly && !child.isInstantiated) {
           continue;
         }
         if (withRespectTo != null &&
             !child.anySubclass(isRelatedTo, ClassHierarchyNode.ALL)) {
           continue;
         }
         if (needsComma) {
           sb.write(',\n');
         } else {
           sb.write('\n');
         }
-        child.printOn(
-            sb,
-            '$indentation  ',
+        child.printOn(sb, '$indentation  ',
             instantiatedOnly: instantiatedOnly,
             sorted: sorted,
             withRespectTo: withRespectTo);
         needsComma = true;
       }
       if (needsComma) {
         sb.write('\n');
         sb.write('$indentation]');
       } else {
         sb.write(']');
       }
     }
   }
 
-  String dump({String indentation: '',
-               bool instantiatedOnly: false,
-               ClassElement withRespectTo}) {
+  String dump(
+      {String indentation: '',
+      bool instantiatedOnly: false,
+      ClassElement withRespectTo}) {
     StringBuffer sb = new StringBuffer();
     printOn(sb, indentation,
-        instantiatedOnly: instantiatedOnly,
-        withRespectTo: withRespectTo);
+        instantiatedOnly: instantiatedOnly, withRespectTo: withRespectTo);
     return sb.toString();
   }
 
   String toString() => cls.toString();
 }
 
 /// Object holding the subclass and subtype relation for a single
 /// [ClassElement].
 ///
 /// The subclass relation for a class `C` is modelled through a reference to
@@ skipping 88 matching lines @@
       }
     }
     return true;
   }
 
   /// Returns an [Iterable] of the subclasses of [cls] possibly including [cls].
   ///
   /// Subclasses are included if their instantiation properties intersect with
   /// their corresponding [Instantiation] values in [mask]. If [strict] is
   /// `true`, [cls] itself is _not_ returned.
-  Iterable<ClassElement> subclassesByMask(
-      EnumSet<Instantiation> mask,
+  Iterable<ClassElement> subclassesByMask(EnumSet<Instantiation> mask,
       {bool strict: false}) {
     return node.subclassesByMask(mask, strict: strict);
   }
 
   /// Returns an [Iterable] of the subtypes of [cls] possibly including [cls].
   ///
   /// The directly instantiated, indirectly instantiated and uninstantiated
   /// subtypes of [cls] are returned if [includeDirectlyInstantiated],
   /// [includeIndirectlyInstantiated], and [includeUninstantiated] are `true`,
   /// respectively. If [strict] is `true`, [cls] itself is _not_ returned.
   Iterable<ClassElement> subtypes(
       {bool includeDirectlyInstantiated: true,
-       bool includeIndirectlyInstantiated: true,
-       bool includeUninstantiated: true,
-       bool strict: false}) {
+      bool includeIndirectlyInstantiated: true,
+      bool includeUninstantiated: true,
+      bool strict: false}) {
     EnumSet<Instantiation> mask = ClassHierarchyNode.createMask(
         includeDirectlyInstantiated: includeDirectlyInstantiated,
-        includeIndirectlyInstantiated:includeIndirectlyInstantiated,
+        includeIndirectlyInstantiated: includeIndirectlyInstantiated,
         includeUninstantiated: includeUninstantiated);
     return subtypesByMask(mask, strict: strict);
   }
 
   /// Returns an [Iterable] of the subtypes of [cls] possibly including [cls].
   ///
   /// Subtypes are included if their instantiation properties intersect with
   /// their corresponding [Instantiation] values in [mask]. If [strict] is
   /// `true`, [cls] itself is _not_ returned.
-  Iterable<ClassElement> subtypesByMask(
-      EnumSet<Instantiation> mask,
+  Iterable<ClassElement> subtypesByMask(EnumSet<Instantiation> mask,
       {bool strict: false}) {
     if (_subtypes == null) {
-      return node.subclassesByMask(
-          mask,
-          strict: strict);
+      return node.subclassesByMask(mask, strict: strict);
     }
 
-    return new SubtypesIterable.SubtypesIterator(this,
-        mask,
+    return new SubtypesIterable.SubtypesIterator(this, mask,
         includeRoot: !strict);
   }
 
   /// Applies [predicate] to each subclass of [cls] matching the criteria
   /// specified by [mask] and [strict]. If [predicate] returns `true` on a
   /// class, visitation is stopped immediately and the function returns `true`.
   ///
   /// [predicate] is applied to subclasses if their instantiation properties
   /// intersect with their corresponding [Instantiation] values in [mask]. If
   /// [strict] is `true`, [predicate] is _not_ called on [cls] itself.
   bool anySubclass(
-      bool predicate(ClassElement cls),
-      EnumSet<Instantiation> mask,
+      bool predicate(ClassElement cls), EnumSet<Instantiation> mask,
       {bool strict: false}) {
     return node.anySubclass(predicate, mask, strict: strict);
   }
 
   /// Applies [f] to each subclass of [cls] matching the criteria specified by
   /// [mask] and [strict].
   ///
   /// [f] is a applied to subclasses if their instantiation properties intersect
   /// with their corresponding [Instantiation] values in [mask]. If [strict] is
   /// `true`, [f] is _not_ called on [cls] itself.
   ///
   /// The visitation of subclasses can be cut short by the return value of [f].
   /// If [ForEach.STOP] is returned, no further classes are visited and the
   /// function stops immediately. If [ForEach.SKIP_SUBCLASSES] is returned, the
   /// subclasses of the last visited class are skipped, but visitation
   /// continues. The return value of the function is either [ForEach.STOP], if
   /// visitation was stopped, or [ForEach.CONTINUE] if visitation continued to
   /// the end.
-  IterationStep forEachSubclass(
-      ForEachFunction f,
-      EnumSet<Instantiation> mask,
+  IterationStep forEachSubclass(ForEachFunction f, EnumSet<Instantiation> mask,
       {bool strict: false}) {
     return node.forEachSubclass(f, mask, strict: strict);
   }
 
   /// Applies [predicate] to each subtype of [cls] matching the criteria
   /// specified by [mask] and [strict]. If [predicate] returns `true` on a
   /// class, visitation is stopped immediately and the function returns `true`.
   ///
   /// [predicate] is applied to subtypes if their instantiation properties
   /// intersect with their corresponding [Instantiation] values in [mask]. If
   /// [strict] is `true`, [predicate] is _not_ called on [cls] itself.
-  bool anySubtype(
-      bool predicate(ClassElement cls),
-      EnumSet<Instantiation> mask,
+  bool anySubtype(bool predicate(ClassElement cls), EnumSet<Instantiation> mask,
       {bool strict: false}) {
-
     IterationStep wrapper(ClassElement cls) {
       return predicate(cls) ? IterationStep.STOP : IterationStep.CONTINUE;
     }
     return forEachSubtype(wrapper, mask, strict: strict) == IterationStep.STOP;
   }
 
   /// Applies [f] to each subtype of [cls] matching the criteria specified by
   /// [mask] and [strict].
   ///
   /// [f] is a applied to subtypes if their instantiation properties intersect
   /// with their corresponding [Instantiation] values in [mask]. If [strict] is
   /// `true`, [f] is _not_ called on [cls] itself.
   ///
   /// The visitation of subtypes can be cut short by the return value of [f].
   /// If [ForEach.STOP] is returned, no further classes are visited and the
   /// function stops immediately. If [ForEach.SKIP_SUBCLASSES] is returned, the
   /// subclasses of the last visited class are skipped, but visitation
   /// continues. The return value of the function is either [ForEach.STOP], if
   /// visitation was stopped, or [ForEach.CONTINUE] if visitation continued to
   /// the end.
-  IterationStep forEachSubtype(
-      ForEachFunction f,
-      EnumSet<Instantiation> mask,
+  IterationStep forEachSubtype(ForEachFunction f, EnumSet<Instantiation> mask,
       {bool strict: false}) {
     IterationStep nextStep =
         node.forEachSubclass(f, mask, strict: strict) ?? IterationStep.CONTINUE;
     if (nextStep == IterationStep.CONTINUE && _subtypes != null) {
       for (ClassHierarchyNode subclass in _subtypes) {
         IterationStep subForEach = subclass.forEachSubclass(f, mask);
         if (subForEach == IterationStep.STOP) {
           return subForEach;
         }
       }
@@ skipping 103 matching lines @@
     return sb.toString();
   }
 }
 
 /// Iterable for subclasses of a [ClassHierarchyNode].
 class ClassHierarchyNodeIterable extends IterableBase<ClassElement> {
   final ClassHierarchyNode root;
   final EnumSet<Instantiation> mask;
   final bool includeRoot;
 
-  ClassHierarchyNodeIterable(
-      this.root,
-      this.mask,
-      {this.includeRoot: true}) {
+  ClassHierarchyNodeIterable(this.root, this.mask, {this.includeRoot: true}) {
     if (root == null) throw new StateError("No root for iterable.");
   }
 
   @override
   Iterator<ClassElement> get iterator {
     return new ClassHierarchyNodeIterator(this);
   }
 }
 
 /// Iterator for subclasses of a [ClassHierarchyNode].
@@ skipping 53 matching lines @@
         return false;
       }
       currentNode = stack.head;
       stack = stack.tail;
       if (!includeUninstantiated && !currentNode.isInstantiated) {
         // We're only iterating instantiated classes so there is no use in
         // visiting the current node and its subtree.
         continue;
       }
       for (Link<ClassHierarchyNode> link = currentNode._directSubclasses;
-           !link.isEmpty;
-           link = link.tail) {
+          !link.isEmpty;
+          link = link.tail) {
         stack = stack.prepend(link.head);
       }
       if (_isValid(currentNode)) {
         return true;
       }
     }
   }
 
   /// Returns `true` if the class of [node] is a valid result for this iterator.
   bool _isValid(ClassHierarchyNode node) {
     if (!includeRoot && node == root) return false;
     return mask.intersects(node._mask);
   }
 }
 
 /// Iterable for the subtypes in a [ClassSet].
 class SubtypesIterable extends IterableBase<ClassElement> {
   final ClassSet subtypeSet;
   final EnumSet<Instantiation> mask;
   final bool includeRoot;
 
-  SubtypesIterable.SubtypesIterator(
-      this.subtypeSet,
-      this.mask,
+  SubtypesIterable.SubtypesIterator(this.subtypeSet, this.mask,
       {this.includeRoot: true});
 
   @override
   Iterator<ClassElement> get iterator => new SubtypesIterator(this);
 }
 
 /// Iterator for the subtypes in a [ClassSet].
 class SubtypesIterator extends Iterator<ClassElement> {
   final SubtypesIterable iterable;
   Iterator<ClassElement> elements;
@@ skipping 10 matching lines @@
     if (elements != null) {
       return elements.current;
     }
     return null;
   }
 
   @override
   bool moveNext() {
     if (elements == null && hierarchyNodes == null) {
       // Initial state. Iterate through subclasses.
-      elements = iterable.subtypeSet.node.subclassesByMask(
-          mask,
-          strict: !includeRoot).iterator;
+      elements = iterable.subtypeSet.node
+          .subclassesByMask(mask, strict: !includeRoot)
+          .iterator;
     }
     if (elements != null && elements.moveNext()) {
       return true;
     }
     if (hierarchyNodes == null) {
       // Start iterating through subtypes.
       hierarchyNodes = iterable.subtypeSet._subtypes.iterator;
     }
     while (hierarchyNodes.moveNext()) {
       elements = hierarchyNodes.current.subclassesByMask(mask).iterator;
       if (elements.moveNext()) {
         return true;
       }
     }
     return false;
   }
 }
 
 /// Enum values returned from the [ForEachFunction] provided to the `forEachX`
 /// functions of [ClassHierarchyNode] and [ClassSet]. The value is used to
 /// control the continued iteration.
 enum IterationStep {
   /// Iteration continues.
   CONTINUE,
+
   /// Iteration stops immediately.
   STOP,
+
   /// Iteration skips the subclasses of the current class.
   SKIP_SUBCLASSES,
 }
 
 /// Visiting function used for the `forEachX` functions of [ClassHierarchyNode]
 /// and [ClassSet]. The return value controls the continued iteration. If `null`
 /// is returned, iteration continues to the end.
 typedef IterationStep ForEachFunction(ClassElement cls);