Make the universe parts into small libraries.

pkg/compiler/lib/src/inferrer/concrete_types_inferrer.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 concrete_types_inferrer;
 
 import 'dart:collection' show
     Queue,
     IterableBase;
 
 import '../native/native.dart' as native;
 import '../closure.dart' show
     BoxFieldElement;
 import '../compiler.dart' show
     Compiler;
 import '../dart_types.dart' show
     DartType,
     TypeKind;
 import '../diagnostics/spannable.dart' show
     Spannable;
 import '../elements/elements.dart';
 import '../tree/tree.dart';
 import '../types/types.dart' show
     FlatTypeMask,
     TypeMask,
     TypesInferrer,
     UnionTypeMask;
-import '../universe/universe.dart';
+import '../universe/selector.dart' show
+    Selector,
+    SelectorKind;
+import '../universe/side_effects.dart' show
+    SideEffects;
 import '../world.dart' show
     ClassWorld;
 
 import 'inferrer_visitor.dart';
 import 'simple_types_inferrer.dart';
 
 /**
  * A singleton concrete type. More precisely, a [BaseType] is one of the
  * following:
  *
@@ skipping 1965 matching lines @@
   @override
   ConcreteType registerCalledElement(Spannable node,
                                      Selector selector,
                                      TypeMask mask,
                                      Element caller,
                                      Element callee,
                                      ArgumentsTypes<ConcreteType> arguments,
                                      SideEffects sideEffects,
                                      bool inLoop) {
     caller = getRealCaller(caller);
-    if ((selector == null) || (selector.kind == SelectorKind.CALL)) {
+    if ((selector == null) || (selector.isCall)) {
       callee = callee.implementation;
       if (selector != null && selector.name == 'JS') {
         return null;
       }
       if (callee.isField) {  // toplevel closure call
         getFieldType(selector, callee);  // trigger toplevel field analysis
         addFieldReader(callee, caller);
         ConcreteType result = emptyConcreteType;
         for (FunctionElement function in closures.functionElements) {
           addCaller(function, caller);
@@ skipping 12 matching lines @@
             if (send.receiver.isSuper()) {
               receiverClass =
                   currentWorkItem.environment.classOfThis.superclass;
             } else {
               receiverClass = currentWorkItem.environment.classOfThis;
             }
           }
         }
         return getSendReturnType(selector, callee, receiverClass, arguments);
       }
-    } else if (selector.kind == SelectorKind.GETTER) {
+    } else if (selector.isGetter) {
       if (callee.isField) {
         addFieldReader(callee, caller);
         return getFieldType(selector, callee);
       } else if (callee.isGetter) {
         Element enclosing = callee.enclosingElement.isCompilationUnit
             ? null : callee.enclosingElement;
         addCaller(callee, caller);
         ArgumentsTypes noArguments = new ArgumentsTypes([], new Map());
         return getSendReturnType(selector, callee, enclosing, noArguments);
       } else if (callee.isFunction) {
         addClosure(callee, null, null);
         return singletonConcreteType(baseTypes.functionBaseType);
       }
-    } else if (selector.kind == SelectorKind.SETTER) {
+    } else if (selector.isSetter) {
       ConcreteType argumentType = arguments.positional.first;
       if (callee.isField) {
         augmentFieldType(callee, argumentType);
       } else if (callee.isSetter) {
         FunctionElement setter = callee;
         // TODO(polux): A setter always returns void so there's no need to
         // invalidate its callers even if it is called with new arguments.
         // However, if we start to record more than returned types, like
         // exceptions for instance, we need to do it by uncommenting the
         // following line.
@@ skipping 312 matching lines @@
   ConcreteType handleLocalGet(Send node, LocalElement local) {
     if (inferrer.testMode) {
       ConcreteType type = locals.use(local);
       if (type != null) {
         inferrer.augmentInferredType(node, type);
       }
     }
     return super.handleLocalGet(node, local);
   }
 }