Refactor *WorldBuilder.registerDynamicUse

pkg/compiler/lib/src/universe/world_builder.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 universe;
 
 import 'dart:collection';
 
 import '../cache_strategy.dart';
 import '../common.dart';
@@ skipping 460 matching lines @@
 
   final Map<ClassElement, Set<MixinApplicationElement>> _mixinUses =
       new Map<ClassElement, Set<MixinApplicationElement>>();
 
   // 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, Map<ClassElement, bool>> _subtypeCoveredByCache =

[Johnni Winther, 2016/12/21 14:37:19]

Only needed in ClosedWorldImpl

-      <ClassElement, Map<ClassElement, bool>>{};
-
   final Set<Element> alreadyPopulated;
 
   final CacheStrategy cacheStrategy;
 
   bool get isClosed => _closed;
 
   ResolutionWorldBuilderImpl(Backend backend, Resolution resolution,
       CacheStrategy cacheStrategy, this.selectorConstraintsStrategy)
       : this._backend = backend,
         this._resolution = resolution,
@@ skipping 180 matching lines @@
   }
 
   bool hasInvokedSetter(Element member) {
     return _hasMatchingSelector(_invokedSetters[member.name], member);
   }
 
   void registerDynamicUse(
       DynamicUse dynamicUse, MemberUsedCallback memberUsed) {
     Selector selector = dynamicUse.selector;
     String methodName = selector.name;
+
+    void _process(Map<String, Set<_MemberUsage>> memberMap,
+        EnumSet<MemberUse> action(_MemberUsage usage)) {
+      _processSet(memberMap, methodName, (_MemberUsage usage) {
+        if (dynamicUse.appliesUnnamed(usage.entity, this)) {
+          memberUsed(usage.entity, action(usage));
+          return true;
+        }
+        return false;
+      });
+    }
+
     switch (dynamicUse.kind) {
       case DynamicUseKind.INVOKE:
         if (_registerNewSelector(dynamicUse, _invokedNames)) {
-          _processInstanceMembers(methodName, (_MemberUsage usage) {
-            if (dynamicUse.appliesUnnamed(usage.entity, this)) {
-              memberUsed(usage.entity, usage.invoke());
-              return true;
-            }
-            return false;
-          });
+          _process(_instanceMembersByName, (m) => m.invoke());
         }
         break;
       case DynamicUseKind.GET:
         if (_registerNewSelector(dynamicUse, _invokedGetters)) {
-          _processInstanceMembers(methodName, (_MemberUsage usage) {
-            if (dynamicUse.appliesUnnamed(usage.entity, this)) {
-              memberUsed(usage.entity, usage.read());
-              return true;
-            }
-            return false;
-          });
-          _processInstanceFunctions(methodName, (_MemberUsage usage) {
-            if (dynamicUse.appliesUnnamed(usage.entity, this)) {
-              memberUsed(usage.entity, usage.read());
-              return true;
-            }
-            return false;
-          });
+          _process(_instanceMembersByName, (m) => m.read());
+          _process(_instanceFunctionsByName, (m) => m.read());
         }
         break;
       case DynamicUseKind.SET:
         if (_registerNewSelector(dynamicUse, _invokedSetters)) {
-          _processInstanceMembers(methodName, (_MemberUsage usage) {
-            if (dynamicUse.appliesUnnamed(usage.entity, this)) {
-              memberUsed(usage.entity, usage.write());
-              return true;
-            }
-            return false;
-          });
+          _process(_instanceMembersByName, (m) => m.write());
         }
         break;
     }
   }
 
   bool _registerNewSelector(DynamicUse dynamicUse,
       Map<String, Map<Selector, SelectorConstraints>> selectorMap) {
     Selector selector = dynamicUse.selector;
     String name = selector.name;
     ReceiverConstraint mask = dynamicUse.mask;
@@ skipping 154 matching lines @@
     // so we create a new list for [: map[memberName] :] and prepend the
     // [remaining] members after the loop.
     map[memberName] = new Set<_MemberUsage>();
     Set<_MemberUsage> remaining = new Set<_MemberUsage>();
     for (_MemberUsage usage in members) {
       if (!updateUsage(usage)) remaining.add(usage);
     }
     map[memberName].addAll(remaining);
   }
 
-  void _processInstanceMembers(String name, bool updateUsage(_MemberUsage e)) {
-    _processSet(_instanceMembersByName, name, updateUsage);
-  }
-
-  void _processInstanceFunctions(
-      String name, bool updateUsage(_MemberUsage e)) {
-    _processSet(_instanceFunctionsByName, name, updateUsage);
-  }
-
   void _processInstantiatedClassMember(
       ClassElement cls, MemberElement member, MemberUsedCallback memberUsed) {
     assert(invariant(member, member.isDeclaration));
     if (!member.isInstanceMember) return;
     String memberName = member.name;
     member.computeType(_resolution);
     // The obvious thing to test here would be "member.isNative",
     // however, that only works after metadata has been parsed/analyzed,
     // and that may not have happened yet.
     // So instead we use the enclosing class, which we know have had
@@ skipping 397 matching lines @@
   }
 
   bool hasInvokedSetter(Element member, ClosedWorld world) {
     return _hasMatchingSelector(_invokedSetters[member.name], member, world);
   }
 
   bool registerDynamicUse(
       DynamicUse dynamicUse, MemberUsedCallback memberUsed) {
     Selector selector = dynamicUse.selector;
     String methodName = selector.name;
+
+    void _process(Map<String, Set<_MemberUsage>> memberMap,
+        EnumSet<MemberUse> action(_MemberUsage usage)) {
+      _processSet(memberMap, methodName, (_MemberUsage usage) {
+        if (dynamicUse.appliesUnnamed(usage.entity, _world)) {
+          memberUsed(usage.entity, action(usage));
+          return true;
+        }
+        return false;
+      });
+    }
+
     switch (dynamicUse.kind) {
       case DynamicUseKind.INVOKE:
         if (_registerNewSelector(dynamicUse, _invokedNames)) {
-          _processInstanceMembers(methodName, (_MemberUsage member) {
-            if (dynamicUse.appliesUnnamed(member.entity, _world)) {
-              memberUsed(member.entity, member.invoke());
-              return true;
-            }
-            return false;
-          });
+          _process(_instanceMembersByName, (m) => m.invoke());
           return true;
         }
         break;
       case DynamicUseKind.GET:
         if (_registerNewSelector(dynamicUse, _invokedGetters)) {
-          _processInstanceMembers(methodName, (_MemberUsage member) {
-            if (dynamicUse.appliesUnnamed(member.entity, _world)) {
-              memberUsed(member.entity, member.read());
-              return true;
-            }
-            return false;
-          });
-          _processInstanceFunctions(methodName, (_MemberUsage member) {
-            if (dynamicUse.appliesUnnamed(member.entity, _world)) {
-              memberUsed(member.entity, member.read());
-              return true;
-            }
-            return false;
-          });
+          _process(_instanceMembersByName, (m) => m.read());
+          _process(_instanceFunctionsByName, (m) => m.read());
           return true;
         }
         break;
       case DynamicUseKind.SET:
         if (_registerNewSelector(dynamicUse, _invokedSetters)) {
-          _processInstanceMembers(methodName, (_MemberUsage member) {
-            if (dynamicUse.appliesUnnamed(member.entity, _world)) {
-              memberUsed(member.entity, member.write());
-              return true;
-            }
-            return false;
-          });
+          _process(_instanceMembersByName, (m) => m.write());
           return true;
         }
         break;
     }
     return false;
   }
 
   bool _registerNewSelector(DynamicUse dynamicUse,
       Map<String, Map<Selector, SelectorConstraints>> selectorMap) {
     Selector selector = dynamicUse.selector;
@@ skipping 197 matching lines @@
     // so we create a new list for [: map[memberName] :] and prepend the
     // [remaining] members after the loop.
     map[memberName] = new Set<_MemberUsage>();
     Set<_MemberUsage> remaining = new Set<_MemberUsage>();
     for (_MemberUsage member in members) {
       if (!f(member)) remaining.add(member);
     }
     map[memberName].addAll(remaining);
   }
 
-  void _processInstanceMembers(String n, bool f(_MemberUsage e)) {
-    _processSet(_instanceMembersByName, n, f);
-  }
-
-  void _processInstanceFunctions(String n, bool f(_MemberUsage e)) {
-    _processSet(_instanceFunctionsByName, n, f);
-  }
-
   /// Return the canonical [_ClassUsage] for [cls].
   _ClassUsage _getClassUsage(ClassElement cls) {
     return _processedClasses.putIfAbsent(cls, () => new _ClassUsage(cls));
   }
 
   void _processInstantiatedClass(
       ClassElement cls, ClassUsedCallback classUsed) {
     // Registers [superclass] as instantiated. Returns `true` if it wasn't
     // already instantiated and we therefore have to process its superclass as
     // well.
@@ skipping 384 matching lines @@
   @override
   EnumSet<MemberUse> get _originalUse => MemberUses.ALL_STATIC;
 }
 
 void removeFromSet(Map<String, Set<_MemberUsage>> map, Element element) {
   Set<_MemberUsage> set = map[element.name];
   if (set == null) return;
   set.removeAll(
       set.where((_MemberUsage usage) => usage.entity == element).toList());
 }