Rename inference files and classes post refactor

pkg/compiler/lib/src/inferrer/builder.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.
 
 library simple_types_inferrer;
 
 import '../closure.dart' show ClosureClassMap;
 import '../common.dart';
 import '../common/names.dart' show Identifiers, Selectors;
 import '../compiler.dart' show Compiler;
@@ skipping 10 matching lines @@
 import '../resolution/tree_elements.dart' show TreeElements;
 import '../tree/tree.dart' as ast;
 import '../types/constants.dart' show computeTypeMask;
 import '../types/types.dart' show TypeMask, GlobalTypeInferenceElementData;
 import '../universe/call_structure.dart' show CallStructure;
 import '../universe/selector.dart' show Selector;
 import '../universe/side_effects.dart' show SideEffects;
 import '../util/util.dart' show Link, Setlet;
 import '../world.dart' show ClosedWorld;
 import 'inferrer_engine.dart';
-import 'inferrer_visitor.dart';
+import 'locals_handler.dart';
 import 'type_graph_nodes.dart';
 import 'type_system.dart';
 
-/// [SimpleTypeInferrerVisitor] can be thought of as a type-inference graph
+/// [ElementGraphBuilder] can be thought of as a type-inference graph
 /// builder for a single element.
 ///
 /// Calling [run] will start the work of visiting the body of the code to
 /// construct a set of infernece-nodes that abstractly represent what the code
 /// is doing.
 ///
 /// This visitor is parameterized by an [InferenceEngine], which internally
 /// decides how to represent inference nodes.
-class SimpleTypeInferrerVisitor extends ast.Visitor<TypeInformation>
+class ElementGraphBuilder extends ast.Visitor<TypeInformation>
     with
         SemanticSendResolvedMixin<TypeInformation, dynamic>,
         CompoundBulkMixin<TypeInformation, dynamic>,
         SetIfNullBulkMixin<TypeInformation, dynamic>,
         PrefixBulkMixin<TypeInformation, dynamic>,
         PostfixBulkMixin<TypeInformation, dynamic>,
         ErrorBulkMixin<TypeInformation, dynamic>,
         NewBulkMixin<TypeInformation, dynamic>,
         SetBulkMixin<TypeInformation, dynamic>
     implements SemanticSendVisitor<TypeInformation, dynamic> {
@@ skipping 12 matching lines @@
   TypeInformation returnType;
   bool visitingInitializers = false;
   bool isConstructorRedirect = false;
   bool seenSuperConstructorCall = false;
   SideEffects sideEffects = new SideEffects.empty();
   final Element outermostElement;
   final InferrerEngine inferrer;
   final Setlet<Entity> capturedVariables = new Setlet<Entity>();
   final GlobalTypeInferenceElementData inTreeData;
 
-  SimpleTypeInferrerVisitor.internal(
+  ElementGraphBuilder.internal(
       AstElement analyzedElement,
       this.resolvedAst,
       this.outermostElement,
       InferrerEngine inferrer,
       this.compiler,
       this.locals)
       : this.analyzedElement = analyzedElement,
         this.inferrer = inferrer,
         this.types = inferrer.types,
         this.inTreeData = inferrer.dataOf(analyzedElement) {
     assert(outermostElement != null);
     if (locals != null) return;
     ast.Node node;
     if (resolvedAst.kind == ResolvedAstKind.PARSED) {
       node = resolvedAst.node;
     }
     FieldInitializationScope fieldScope =
         analyzedElement.isGenerativeConstructor
             ? new FieldInitializationScope(types)
             : null;
     locals =
         new LocalsHandler(inferrer, types, compiler.options, node, fieldScope);
   }
 
-  SimpleTypeInferrerVisitor(Element element, ResolvedAst resolvedAst,
+  ElementGraphBuilder(Element element, ResolvedAst resolvedAst,
       Compiler compiler, InferrerEngine inferrer, [LocalsHandler handler])
       : this.internal(
             element,
             resolvedAst,
             element.outermostEnclosingMemberOrTopLevel.implementation,
             inferrer,
             compiler,
             handler);
 
   TreeElements get elements => resolvedAst.elements;
@@ skipping 803 matching lines @@
     signature.forEachOptionalParameter((ParameterElement element) {
       ast.Expression defaultValue = element.initializer;
       // TODO(25566): The default value of a parameter of a redirecting factory
       // constructor comes from the corresponding parameter of the target.
 
       // If this is a default value from a different context (because
       // the current function is synthetic, e.g., a constructor from
       // a mixin application), we have to start a new inferrer visitor
       // with the correct context.
       // TODO(johnniwinther): Remove once function signatures are fixed.
-      SimpleTypeInferrerVisitor visitor = this;
+      ElementGraphBuilder visitor = this;
       if (inferrer.hasAlreadyComputedTypeOfParameterDefault(element)) return;
       if (element.functionDeclaration != analyzedElement) {
-        visitor = new SimpleTypeInferrerVisitor(element.functionDeclaration,
+        visitor = new ElementGraphBuilder(element.functionDeclaration,
             element.functionDeclaration.resolvedAst, compiler, inferrer);
       }
       TypeInformation type =
           (defaultValue == null) ? types.nullType : visitor.visit(defaultValue);
       inferrer.setDefaultTypeOfParameter(element, type);
     });
 
     if (compiler.backend.isNative(analyzedElement)) {
       // Native methods do not have a body, and we currently just say
       // they return dynamic.
@@ skipping 128 matching lines @@
     // the safe side, we mark [this] as exposed here. We could do better by
     // analyzing the closure.
     // TODO(herhut): Analyze whether closure exposes this.
     isThisExposed = true;
     LocalFunctionElement element = elements.getFunctionDefinition(node);
     // We don'TypeInformation put the closure in the work queue of the
     // inferrer, because it will share information with its enclosing
     // method, like for example the types of local variables.
     LocalsHandler closureLocals =
         new LocalsHandler.from(locals, node, useOtherTryBlock: false);
-    SimpleTypeInferrerVisitor visitor = new SimpleTypeInferrerVisitor(
+    ElementGraphBuilder visitor = new ElementGraphBuilder(
         element, element.resolvedAst, compiler, inferrer, closureLocals);
     visitor.run();
     inferrer.recordReturnType(element, visitor.returnType);
 
     // Record the types of captured non-boxed variables. Types of
     // these variables may already be there, because of an analysis of
     // a previous closure.
     ClosureClassMap nestedClosureData = compiler.closureToClassMapper
         .getClosureToClassMapping(element.resolvedAst);
     nestedClosureData.forEachCapturedVariable((variable, field) {
@@ skipping 1841 matching lines @@
     Selector moveNextSelector = Selectors.moveNext;
     TypeMask moveNextMask = inTreeData.typeOfIteratorMoveNext(node);
 
     TypeInformation iteratorType = handleDynamicSend(node, iteratorSelector,
         iteratorMask, expressionType, new ArgumentsTypes.empty());
 
     return handleForInLoop(node, iteratorType, currentSelector, currentMask,
         moveNextSelector, moveNextMask);
   }
 }