dartfmt pkg/compiler

pkg/compiler/lib/src/world.dart

 // Copyright (c) 2012, 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;
 
-import 'closure.dart' show
-    SynthesizedCallMethodElementX;
+import 'closure.dart' show SynthesizedCallMethodElementX;
 import 'common.dart';
-import 'common/backend_api.dart' show
-    Backend;
-import 'compiler.dart' show
-    Compiler;
-import 'core_types.dart' show
-    CoreClasses;
+import 'common/backend_api.dart' show Backend;
+import 'compiler.dart' show Compiler;
+import 'core_types.dart' show CoreClasses;
 import 'dart_types.dart';
-import 'elements/elements.dart' show
-    ClassElement,
-    Element,
-    FunctionElement,
-    MixinApplicationElement,
-    TypedefElement,
-    VariableElement;
+import 'elements/elements.dart'
+    show
+        ClassElement,
+        Element,
+        FunctionElement,
+        MixinApplicationElement,
+        TypedefElement,
+        VariableElement;
 import 'ordered_typeset.dart';
 import 'types/types.dart' as ti;
 import 'universe/class_set.dart';
-import 'universe/function_set.dart' show
-    FunctionSet;
-import 'universe/selector.dart' show
-    Selector;
-import 'universe/side_effects.dart' show
-    SideEffects;
-import 'util/util.dart' show
-    Link;
+import 'universe/function_set.dart' show FunctionSet;
+import 'universe/selector.dart' show Selector;
+import 'universe/side_effects.dart' show SideEffects;
+import 'util/util.dart' show Link;
 
 abstract class ClassWorld {
   // TODO(johnniwinther): Refine this into a `BackendClasses` interface.
   Backend get backend;
 
   // TODO(johnniwinther): Remove the need for this getter.
   @deprecated
   Compiler get compiler;
 
   /// The [ClassElement] for the [Object] class defined in 'dart:core'.
@@ skipping 47 matching lines @@
   /// Returns an iterable over the live classes that extend [cls] _not_
   /// including [cls] itself.
   Iterable<ClassElement> strictSubclassesOf(ClassElement cls);
 
   /// Returns the number of live classes that extend [cls] _not_
   /// including [cls] itself.
   int strictSubclassCount(ClassElement cls);
 
   /// Applies [f] to each live class that extend [cls] _not_ including [cls]
   /// itself.
-  void forEachStrictSubclassOf(ClassElement cls,
-                               IterationStep f(ClassElement cls));
+  void forEachStrictSubclassOf(
+      ClassElement cls, IterationStep f(ClassElement cls));
 
   /// Returns `true` if [predicate] applies to any live class that extend [cls]
   /// _not_ including [cls] itself.
   bool anyStrictSubclassOf(ClassElement cls, bool predicate(ClassElement cls));
 
   /// Returns an iterable over the directly instantiated that implement [cls]
   /// possibly including [cls] itself, if it is live.
   Iterable<ClassElement> subtypesOf(ClassElement cls);
 
   /// Returns an iterable over the live classes that implement [cls] _not_
   /// including [cls] if it is live.
   Iterable<ClassElement> strictSubtypesOf(ClassElement cls);
 
   /// Returns the number of live classes that implement [cls] _not_
   /// including [cls] itself.
   int strictSubtypeCount(ClassElement cls);
 
   /// Applies [f] to each live class that implements [cls] _not_ including [cls]
   /// itself.
-  void forEachStrictSubtypeOf(ClassElement cls,
-                              IterationStep f(ClassElement cls));
+  void forEachStrictSubtypeOf(
+      ClassElement cls, IterationStep f(ClassElement cls));
 
   /// Returns `true` if [predicate] applies to any live class that implements
   /// [cls] _not_ including [cls] itself.
   bool anyStrictSubtypeOf(ClassElement cls, bool predicate(ClassElement cls));
 
   /// Returns `true` if [a] and [b] have any known common subtypes.
   bool haveAnyCommonSubtypes(ClassElement a, ClassElement b);
 
   /// Returns `true` if any live class other than [cls] extends [cls].
   bool hasAnyStrictSubclass(ClassElement cls);
@@ skipping 17 matching lines @@
   /// Returns an iterable over the common supertypes of the [classes].
   Iterable<ClassElement> commonSupertypesOf(Iterable<ClassElement> classes);
 
   /// Returns an iterable over the live mixin applications that mixin [cls].
   Iterable<MixinApplicationElement> mixinUsesOf(ClassElement cls);
 
   /// Returns `true` if [cls] is mixed into a live class.
   bool isUsedAsMixin(ClassElement cls);
 
   /// Returns `true` if any live class that mixes in [cls] implements [type].
-  bool hasAnySubclassOfMixinUseThatImplements(ClassElement cls,
-                                              ClassElement type);
+  bool hasAnySubclassOfMixinUseThatImplements(
+      ClassElement cls, ClassElement type);
 
   /// Returns `true` if any live class that mixes in [mixin] is also a subclass
   /// of [superclass].
   bool hasAnySubclassThatMixes(ClassElement superclass, ClassElement mixin);
 
   /// Returns `true` if any subclass of [superclass] implements [type].
   bool hasAnySubclassThatImplements(ClassElement superclass, ClassElement type);
 
   /// Returns `true` if closed-world assumptions can be made, that is,
   /// incremental compilation isn't enabled.
@@ skipping 14 matching lines @@
   ClassElement get doubleClass => coreClasses.doubleClass;
   ClassElement get stringClass => coreClasses.stringClass;
   ClassElement get nullClass => coreClasses.nullClass;
 
   /// Cache of [ti.FlatTypeMask]s grouped by the 8 possible values of the
   /// [ti.FlatTypeMask.flags] property.
   List<Map<ClassElement, ti.TypeMask>> canonicalizedTypeMasks =
       new List<Map<ClassElement, ti.TypeMask>>.filled(8, null);
 
   bool checkInvariants(ClassElement cls, {bool mustBeInstantiated: true}) {
-    return
-      invariant(cls, cls.isDeclaration,
+    return invariant(cls, cls.isDeclaration,
                 message: '$cls must be the declaration.') &&
-      invariant(cls, cls.isResolved,
-                message: '$cls must be resolved.')/* &&
+            invariant(cls, cls.isResolved,
+                message:
+                    '$cls must be resolved.') /* &&
       // TODO(johnniwinther): Reinsert this or similar invariant.
       (!mustBeInstantiated ||
        invariant(cls, isInstantiated(cls),
-                 message: '$cls is not instantiated.'))*/;
- }
+                 message: '$cls is not instantiated.'))*/
+        ;
+  }
 
   /// Returns `true` if [x] is a subtype of [y], that is, if [x] implements an
   /// instance of [y].
   bool isSubtypeOf(ClassElement x, ClassElement y) {
     assert(checkInvariants(x));
     assert(checkInvariants(y, mustBeInstantiated: false));
 
     if (y == objectClass) return true;
     if (x == objectClass) return false;
     if (x.asInstanceOf(y) != null) return true;
@@ skipping 36 matching lines @@
   /// Returns `true` if [cls] is implemented by an instantiated class.
   bool isImplemented(ClassElement cls) {
     return compiler.resolverWorld.isImplemented(cls);
   }
 
   /// Returns an iterable over the directly instantiated classes that extend
   /// [cls] possibly including [cls] itself, if it is live.
   Iterable<ClassElement> subclassesOf(ClassElement cls) {
     ClassHierarchyNode hierarchy = _classHierarchyNodes[cls.declaration];
     if (hierarchy == null) return const <ClassElement>[];
-    return hierarchy.subclassesByMask(
-        ClassHierarchyNode.DIRECTLY_INSTANTIATED);
+    return hierarchy.subclassesByMask(ClassHierarchyNode.DIRECTLY_INSTANTIATED);
   }
 
   /// Returns an iterable over the directly instantiated classes that extend
   /// [cls] _not_ including [cls] itself.
   Iterable<ClassElement> strictSubclassesOf(ClassElement cls) {
     ClassHierarchyNode subclasses = _classHierarchyNodes[cls.declaration];
     if (subclasses == null) return const <ClassElement>[];
-    return subclasses.subclassesByMask(
-        ClassHierarchyNode.DIRECTLY_INSTANTIATED, strict: true);
+    return subclasses.subclassesByMask(ClassHierarchyNode.DIRECTLY_INSTANTIATED,
+        strict: true);
   }
 
   /// Returns the number of live classes that extend [cls] _not_
   /// including [cls] itself.
   int strictSubclassCount(ClassElement cls) {
     ClassHierarchyNode subclasses = _classHierarchyNodes[cls.declaration];
     if (subclasses == null) return 0;
     return subclasses.instantiatedSubclassCount;
   }
 
   /// Applies [f] to each live class that extend [cls] _not_ including [cls]
   /// itself.
-  void forEachStrictSubclassOf(ClassElement cls,
-                               IterationStep f(ClassElement cls)) {
+  void forEachStrictSubclassOf(
+      ClassElement cls, IterationStep f(ClassElement cls)) {
     ClassHierarchyNode subclasses = _classHierarchyNodes[cls.declaration];
     if (subclasses == null) return;
-    subclasses.forEachSubclass(
-        f,
-        ClassHierarchyNode.DIRECTLY_INSTANTIATED,
+    subclasses.forEachSubclass(f, ClassHierarchyNode.DIRECTLY_INSTANTIATED,
         strict: true);
   }
 
   /// Returns `true` if [predicate] applies to any live class that extend [cls]
   /// _not_ including [cls] itself.
   bool anyStrictSubclassOf(ClassElement cls, bool predicate(ClassElement cls)) {
     ClassHierarchyNode subclasses = _classHierarchyNodes[cls.declaration];
     if (subclasses == null) return false;
     return subclasses.anySubclass(
-        predicate,
-        ClassHierarchyNode.DIRECTLY_INSTANTIATED,
+        predicate, ClassHierarchyNode.DIRECTLY_INSTANTIATED,
         strict: true);
   }
 
   /// Returns an iterable over the directly instantiated that implement [cls]
   /// possibly including [cls] itself, if it is live.
   Iterable<ClassElement> subtypesOf(ClassElement cls) {
     ClassSet classSet = _classSets[cls.declaration];
     if (classSet == null) {
       return const <ClassElement>[];
     } else {
       return classSet.subtypesByMask(ClassHierarchyNode.DIRECTLY_INSTANTIATED);
     }
   }
 
   /// Returns an iterable over the directly instantiated that implement [cls]
   /// _not_ including [cls].
   Iterable<ClassElement> strictSubtypesOf(ClassElement cls) {
     ClassSet classSet = _classSets[cls.declaration];
     if (classSet == null) {
       return const <ClassElement>[];
     } else {
-      return classSet.subtypesByMask(
-          ClassHierarchyNode.DIRECTLY_INSTANTIATED,
+      return classSet.subtypesByMask(ClassHierarchyNode.DIRECTLY_INSTANTIATED,
           strict: true);
     }
   }
 
   /// Returns the number of live classes that implement [cls] _not_
   /// including [cls] itself.
   int strictSubtypeCount(ClassElement cls) {
     ClassSet classSet = _classSets[cls.declaration];
     if (classSet == null) return 0;
     return classSet.instantiatedSubtypeCount;
   }
 
   /// Applies [f] to each live class that implements [cls] _not_ including [cls]
   /// itself.
-  void forEachStrictSubtypeOf(ClassElement cls,
-                              IterationStep f(ClassElement cls)) {
+  void forEachStrictSubtypeOf(
+      ClassElement cls, IterationStep f(ClassElement cls)) {
     ClassSet classSet = _classSets[cls.declaration];
     if (classSet == null) return;
-    classSet.forEachSubtype(
-        f,
-        ClassHierarchyNode.DIRECTLY_INSTANTIATED,
+    classSet.forEachSubtype(f, ClassHierarchyNode.DIRECTLY_INSTANTIATED,
         strict: true);
   }
 
   /// Returns `true` if [predicate] applies to any live class that extend [cls]
   /// _not_ including [cls] itself.
   bool anyStrictSubtypeOf(ClassElement cls, bool predicate(ClassElement cls)) {
     ClassSet classSet = _classSets[cls.declaration];
     if (classSet == null) return false;
     return classSet.anySubtype(
-        predicate,
-        ClassHierarchyNode.DIRECTLY_INSTANTIATED,
+        predicate, ClassHierarchyNode.DIRECTLY_INSTANTIATED,
         strict: true);
   }
 
   /// Returns `true` if [a] and [b] have any known common subtypes.
   bool haveAnyCommonSubtypes(ClassElement a, ClassElement b) {
     ClassSet classSetA = _classSets[a.declaration];
     ClassSet classSetB = _classSets[b.declaration];
     if (classSetA == null || classSetB == null) return false;
     // TODO(johnniwinther): Implement an optimized query on [ClassSet].
     Set<ClassElement> subtypesOfB = classSetB.subtypes().toSet();
@@ skipping 29 matching lines @@
       // Vacuously true.
       return true;
     }
     return classSet.hasOnlyInstantiatedSubclasses;
   }
 
   @override
   ClassElement getLubOfInstantiatedSubclasses(ClassElement cls) {
     ClassHierarchyNode hierarchy = _classHierarchyNodes[cls.declaration];
     return hierarchy != null
-        ? hierarchy.getLubOfInstantiatedSubclasses() : null;
+        ? hierarchy.getLubOfInstantiatedSubclasses()
+        : null;
   }
 
   @override
   ClassElement getLubOfInstantiatedSubtypes(ClassElement cls) {
     ClassSet classSet = _classSets[cls.declaration];
-    return classSet != null
-        ? classSet.getLubOfInstantiatedSubtypes() : null;
+    return classSet != null ? classSet.getLubOfInstantiatedSubtypes() : null;
   }
 
   /// Returns an iterable over the common supertypes of the [classes].
   Iterable<ClassElement> commonSupertypesOf(Iterable<ClassElement> classes) {
     Iterator<ClassElement> iterator = classes.iterator;
     if (!iterator.moveNext()) return const <ClassElement>[];
 
     ClassElement cls = iterator.current;
     assert(checkInvariants(cls));
     OrderedTypeSet typeSet = cls.allSupertypesAndSelf;
     if (!iterator.moveNext()) return typeSet.types.map((type) => type.element);
 
     int depth = typeSet.maxDepth;
     Link<OrderedTypeSet> otherTypeSets = const Link<OrderedTypeSet>();
     do {
       ClassElement otherClass = iterator.current;
       assert(checkInvariants(otherClass));
       OrderedTypeSet otherTypeSet = otherClass.allSupertypesAndSelf;
       otherTypeSets = otherTypeSets.prepend(otherTypeSet);
       if (otherTypeSet.maxDepth < depth) {
         depth = otherTypeSet.maxDepth;
       }
     } while (iterator.moveNext());
 
     List<ClassElement> commonSupertypes = <ClassElement>[];
     OUTER: for (Link<DartType> link = typeSet[depth];
-                link.head.element != objectClass;
-                link = link.tail) {
+        link.head.element != objectClass;
+        link = link.tail) {
       ClassElement cls = link.head.element;
       for (Link<OrderedTypeSet> link = otherTypeSets;
           !link.isEmpty;
           link = link.tail) {
         if (link.head.asInstanceOf(cls) == null) {
           continue OUTER;
         }
       }
       commonSupertypes.add(cls);
     }
@@ skipping 35 matching lines @@
     Iterable<MixinApplicationElement> uses = _liveMixinUses[cls];
     return uses != null ? uses : const <MixinApplicationElement>[];
   }
 
   /// Returns `true` if [cls] is mixed into a live class.
   bool isUsedAsMixin(ClassElement cls) {
     return !mixinUsesOf(cls).isEmpty;
   }
 
   /// Returns `true` if any live class that mixes in [cls] implements [type].
-  bool hasAnySubclassOfMixinUseThatImplements(ClassElement cls,
-                                              ClassElement type) {
-    return mixinUsesOf(cls).any(
-        (use) => hasAnySubclassThatImplements(use, type));
+  bool hasAnySubclassOfMixinUseThatImplements(
+      ClassElement cls, ClassElement type) {
+    return mixinUsesOf(cls)
+        .any((use) => hasAnySubclassThatImplements(use, type));
   }
 
   /// Returns `true` if any live class that mixes in [mixin] is also a subclass
   /// of [superclass].
   bool hasAnySubclassThatMixes(ClassElement superclass, ClassElement mixin) {
     return mixinUsesOf(mixin).any((each) => each.isSubclassOf(superclass));
   }
 
   /// Returns `true` if any subclass of [superclass] implements [type].
-  bool hasAnySubclassThatImplements(ClassElement superclass,
-                                    ClassElement type) {
+  bool hasAnySubclassThatImplements(
+      ClassElement superclass, ClassElement type) {
     Set<ClassElement> subclasses = typesImplementedBySubclassesOf(superclass);
     if (subclasses == null) return false;
     return subclasses.contains(type);
   }
 
   final Compiler compiler;
   Backend get backend => compiler.backend;
   final FunctionSet allFunctions;
   final Set<Element> functionsCalledInLoop = new Set<Element>();
   final Map<Element, SideEffects> sideEffects = new Map<Element, SideEffects>();
 
   final Set<TypedefElement> allTypedefs = new Set<TypedefElement>();
 
   final Map<ClassElement, List<MixinApplicationElement>> _mixinUses =
       new Map<ClassElement, List<MixinApplicationElement>>();
   Map<ClassElement, List<MixinApplicationElement>> _liveMixinUses;
 
   final Map<ClassElement, Set<ClassElement>> _typesImplementedBySubclasses =
       new Map<ClassElement, Set<ClassElement>>();
 
   // We keep track of subtype and subclass relationships in four
   // distinct sets to make class hierarchy analysis faster.
   final Map<ClassElement, ClassHierarchyNode> _classHierarchyNodes =
       <ClassElement, ClassHierarchyNode>{};
-  final Map<ClassElement, ClassSet> _classSets =
-        <ClassElement, ClassSet>{};
+  final Map<ClassElement, ClassSet> _classSets = <ClassElement, ClassSet>{};
 
   final Set<Element> sideEffectsFreeElements = new Set<Element>();
 
   final Set<Element> elementsThatCannotThrow = new Set<Element>();
 
   final Set<Element> functionsThatMightBePassedToApply =
       new Set<FunctionElement>();
 
   final Set<Element> alreadyPopulated;
 
@@ skipping 80 matching lines @@
     if (cls != coreClasses.functionClass &&
         cls.implementsFunction(coreClasses)) {
       ClassSet subtypeSet = _ensureClassSet(coreClasses.functionClass);
       subtypeSet.addSubtype(node);
     }
     if (!node.isInstantiated && node.parentNode != null) {
       _updateSuperClassHierarchyNodeForClass(node.parentNode);
     }
   }
 
-  void _updateClassHierarchyNodeForClass(
-      ClassElement cls,
+  void _updateClassHierarchyNodeForClass(ClassElement cls,
       {bool directlyInstantiated: false}) {
     ClassHierarchyNode node = getClassHierarchyNode(cls);
     _updateSuperClassHierarchyNodeForClass(node);
     if (directlyInstantiated) {
       node.isDirectlyInstantiated = true;
     }
   }
 
   void populate() {
     /// Updates the `isDirectlyInstantiated` and `isIndirectlyInstantiated`
@@ skipping 38 matching lines @@
     if (cls != null) {
       sb.write("Classes in the closed world related to $cls:\n");
     } else {
       sb.write("Instantiated classes in the closed world:\n");
     }
     getClassHierarchyNode(coreClasses.objectClass)
         .printOn(sb, ' ', instantiatedOnly: cls == null, withRespectTo: cls);
     return sb.toString();
   }
 
-  void registerMixinUse(MixinApplicationElement mixinApplication,
-                        ClassElement mixin) {
+  void registerMixinUse(
+      MixinApplicationElement mixinApplication, ClassElement mixin) {
     // TODO(johnniwinther): Add map restricted to live classes.
     // We don't support patch classes as mixin.
     assert(mixin.isDeclaration);
-    List<MixinApplicationElement> users =
-        _mixinUses.putIfAbsent(mixin, () =>
-                               new List<MixinApplicationElement>());
+    List<MixinApplicationElement> users = _mixinUses.putIfAbsent(
+        mixin, () => new List<MixinApplicationElement>());
     users.add(mixinApplication);
   }
 
   bool hasAnyUserDefinedGetter(Selector selector, ti.TypeMask mask) {
     return allFunctions.filter(selector, mask).any((each) => each.isGetter);
   }
 
   void registerUsedElement(Element element) {
     if (element.isInstanceMember && !element.isAbstract) {
       allFunctions.add(element);
     }
   }
 
   VariableElement locateSingleField(Selector selector, ti.TypeMask mask) {
     Element result = locateSingleElement(selector, mask);
     return (result != null && result.isField) ? result : null;
   }
 
   Element locateSingleElement(Selector selector, ti.TypeMask mask) {
-    mask = mask == null
-        ? compiler.typesTask.dynamicType
-        : mask;
+    mask = mask == null ? compiler.typesTask.dynamicType : mask;
     return mask.locateSingleElement(selector, mask, compiler);
   }
 
   ti.TypeMask extendMaskIfReachesAll(Selector selector, ti.TypeMask mask) {
     bool canReachAll = true;
     if (mask != null) {
-      canReachAll =
-          compiler.enabledInvokeOn &&
+      canReachAll = compiler.enabledInvokeOn &&
           mask.needsNoSuchMethodHandling(selector, this);
     }
     return canReachAll ? compiler.typesTask.dynamicType : mask;
   }
 
   void addFunctionCalledInLoop(Element element) {
     functionsCalledInLoop.add(element.declaration);
   }
 
   bool isCalledInLoop(Element element) {
     return functionsCalledInLoop.contains(element.declaration);
   }
 
   bool fieldNeverChanges(Element element) {
     if (!element.isField) return false;
     if (backend.isNative(element)) {
       // Some native fields are views of data that may be changed by operations.
       // E.g. node.firstChild depends on parentNode.removeBefore(n1, n2).
       // TODO(sra): Refine the effect classification so that native effects are
       // distinct from ordinary Dart effects.
       return false;
     }
 
     if (element.isFinal || element.isConst) {
       return true;
     }
     if (element.isInstanceMember) {
       return !compiler.resolverWorld.hasInvokedSetter(element, this) &&
-             !compiler.resolverWorld.fieldSetters.contains(element);
+          !compiler.resolverWorld.fieldSetters.contains(element);
     }
     return false;
   }
 
   SideEffects getSideEffectsOfElement(Element element) {
     // The type inferrer (where the side effects are being computed),
     // does not see generative constructor bodies because they are
     // created by the backend. Also, it does not make any distinction
     // between a constructor and its body for side effects. This
     // implies that currently, the side effects of a constructor body
@@ skipping 59 matching lines @@
     // function expressions's element.
     // TODO(herhut): Generate classes for function expressions earlier.
     if (element is SynthesizedCallMethodElementX) {
       return getMightBePassedToApply(element.expression);
     }
     return functionsThatMightBePassedToApply.contains(element);
   }
 
   bool get hasClosedWorldAssumption => !compiler.options.hasIncrementalSupport;
 }