Remove unneeded methods from InferrerEngine.

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 ClosureRepresentationInfo;
 import '../common.dart';
 import '../common/names.dart' show Identifiers, Selectors;
 import '../compiler.dart' show Compiler;
@@ skipping 960 matching lines @@
     }
 
     if (analyzedElement.isGenerativeConstructor) {
       isThisExposed = false;
       signature.forEachParameter((FormalElement _element) {
         ParameterElement element = _element;
         TypeInformation parameterType = inferrer.typeOfParameter(element);
         if (element.isInitializingFormal) {
           InitializingFormalElement initializingFormal = element;
           if (initializingFormal.fieldElement.isFinal) {
-            inferrer.recordTypeOfFinalField(
+            inferrer.recordTypeOfField(
                 initializingFormal.fieldElement, parameterType);
           } else {
             locals.updateField(initializingFormal.fieldElement, parameterType);
-            inferrer.recordTypeOfNonFinalField(
+            inferrer.recordTypeOfField(
                 initializingFormal.fieldElement, parameterType);
           }
         }
         locals.update(element, parameterType, node);
       });
       ClassElement cls = analyzedElement.enclosingClass;
       Spannable spannable = node;
       if (analyzedElement.isSynthesized) {
         spannable = analyzedElement;
         ConstructorElement constructor = analyzedElement;
@@ skipping 29 matching lines @@
         inferrer.recordExposesThis(analyzedElement, isThisExposed);
       }
       if (!isConstructorRedirect) {
         // Iterate over all instance fields, and give a null type to
         // fields that we haven'TypeInformation initialized for sure.
         cls.forEachInstanceField((_, FieldElement field) {
           if (field.isFinal) return;
           TypeInformation type = locals.fieldScope.readField(field);
           ResolvedAst resolvedAst = field.resolvedAst;
           if (type == null && resolvedAst.body == null) {
-            inferrer.recordTypeOfNonFinalField(field, types.nullType);
+            inferrer.recordTypeOfField(field, types.nullType);
           }
         });
       }
       if (analyzedElement.isGenerativeConstructor && cls.isAbstract) {
         if (closedWorld.isInstantiated(cls)) {
           returnType = types.nonNullSubclass(cls);
         } else {
           // TODO(johnniwinther): Avoid analyzing [analyzedElement] in this
           // case; it's never called.
           returnType = types.nonNullEmpty();
@@ skipping 164 matching lines @@
       if (element.isField) {
         ResolvedAst elementResolvedAst = element.resolvedAst;
         if (!selector.isSetter &&
             isInClassOrSubclass(element) &&
             !element.isFinal &&
             locals.fieldScope.readField(element) == null &&
             elementResolvedAst.body == null) {
           // If the field is being used before this constructor
           // actually had a chance to initialize it, say it can be
           // null.
-          inferrer.recordTypeOfNonFinalField(element, types.nullType);
+          inferrer.recordTypeOfField(element, types.nullType);
         }
         // Accessing a field does not expose [:this:].
         return true;
       }
       // TODO(ngeoffray): We could do better here if we knew what we
       // are calling does not expose this.
       isThisExposed = true;
       return false;
     });
   }
@@ skipping 764 matching lines @@
           MemberElement single = targets.first;
           if (single.isField) {
             locals.updateField(single, rhsType);
           }
         }
       }
       handleDynamicSend(
           node, setterSelector, setterMask, receiverType, arguments);
     } else if (element.isField) {
       if (element.isFinal) {
-        inferrer.recordTypeOfFinalField(element, rhsType);
+        inferrer.recordTypeOfField(element, rhsType);
       } else {
         if (analyzedElement.isGenerativeConstructor) {
           locals.updateField(element, rhsType);
         }
         if (visitingInitializers) {
-          inferrer.recordTypeOfNonFinalField(element, rhsType);
+          inferrer.recordTypeOfField(element, rhsType);
         } else {
           handleDynamicSend(
               node, setterSelector, setterMask, receiverType, arguments);
         }
       }
     } else if (element.isLocal) {
       locals.update(element, rhsType, node);
     }
     return rhsType;
   }
@@ skipping 925 matching lines @@
     Selector moveNextSelector = Selectors.moveNext;
     TypeMask moveNextMask = memberData.typeOfIteratorMoveNext(node);
 
     TypeInformation iteratorType = handleDynamicSend(node, iteratorSelector,
         iteratorMask, expressionType, new ArgumentsTypes.empty());
 
     return handleForInLoop(node, iteratorType, currentSelector, currentMask,
         moveNextSelector, moveNextMask);
   }
 }