Minor cleanup in inferrer folder

pkg/compiler/lib/src/inferrer/node_tracer.dart

 // Copyright (c) 2013, 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.
 
-part of type_graph_inferrer;
+library compiler.src.inferrer.node_tracer;
+
+import '../common/names.dart' show Identifiers;
+import '../compiler.dart' show Compiler;
+import '../elements/elements.dart';
+import '../types/types.dart' show ContainerTypeMask, MapTypeMask;
+import '../util/util.dart' show Setlet;
+
+import 'type_graph_inferrer.dart' show TypeGraphInferrerEngine;
+import 'type_graph_nodes.dart';
+import 'debug.dart' as debug;
 
 // A set of selectors we know do not escape the elements inside the
 // list.
 Set<String> doesNotEscapeListSet = new Set<String>.from(
   const <String>[
     // From Object.
     '==',
     'hashCode',
     'toString',
     'noSuchMethod',
@@ skipping 41 matching lines @@
     'isNotEmpty',
     'length',
     'clear',
     'containsKey',
     'containsValue',
     '[]=',
     // [keys] only allows key values to escape, which we do not track.
     'keys'
   ]);
 
+/// Common logic to trace a value through the type inference graph nodes.
 abstract class TracerVisitor<T extends TypeInformation>
     implements TypeInformationVisitor {
   final T tracedType;
   final TypeGraphInferrerEngine inferrer;
   final Compiler compiler;
 
   static const int MAX_ANALYSIS_COUNT = 16;
   final Setlet<Element> analyzedElements = new Setlet<Element>();
 
   TracerVisitor(this.tracedType, TypeGraphInferrerEngine inferrer)
@@ skipping 52 matching lines @@
         analyzeStoredIntoList(listsToAnalyze.removeLast());
       }
       while (!mapsToAnalyze.isEmpty) {
         analyzeStoredIntoMap(mapsToAnalyze.removeLast());
       }
       if (!continueAnalyzing) break;
     }
   }
 
   void bailout(String reason) {
-    if (_VERBOSE) {
+    if (debug.VERBOSE) {
       print('Bailing out on $tracedType because: $reason');
     }
     continueAnalyzing = false;
   }
 
   void visitAwaitTypeInformation(AwaitTypeInformation info) {
     bailout("Passed through await");
   }
 
   void visitNarrowTypeInformation(NarrowTypeInformation info) {
@@ skipping 45 matching lines @@
 
   void analyzeStoredIntoList(ListTypeInformation list) {
     inferrer.analyzeListAndEnqueue(list);
     if (list.bailedOut) {
       bailout('Stored in a list that bailed out');
     } else {
       list.flowsInto.forEach((flow) {
         flow.users.forEach((user) {
           if (user is !DynamicCallSiteTypeInformation) return;
           if (user.receiver != flow) return;
-          if (inferrer._returnsListElementTypeSet.contains(user.selector)) {
+          if (inferrer.returnsListElementTypeSet.contains(user.selector)) {
             addNewEscapeInformation(user);
           } else if (!doesNotEscapeListSet.contains(user.selector.name)) {
             bailout('Escape from a list via [${user.selector.name}]');
           }
         });
       });
     }
   }
 
   void analyzeStoredIntoMap(MapTypeInformation map) {
@@ skipping 173 matching lines @@
     }
     if (isParameterOfListAddingMethod(info.element) ||
         isParameterOfMapAddingMethod(info.element)) {
       // These elements are being handled in
       // [visitDynamicCallSiteTypeInformation].
       return;
     }
     addNewEscapeInformation(info);
   }
 }