Translate private Java members to private Dart members.

pkg/analyzer/lib/src/generated/resolver.dart

 // Copyright (c) 2014, 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.
 
 // This code was auto-generated, is not intended to be edited, and is subject to
 // significant change. Please see the README file for more information.
 
 library engine.resolver;
 
 import 'dart:collection';
@@ skipping 67 matching lines @@
     // prepare ClassElement
     ClassElement classElement = classDeclaration.element;
     if (classElement == null) {
       return null;
     }
     // check toolkit objects
     for (ToolkitObjectElement toolkitObject in classElement.toolkitObjects) {
       List<AngularPropertyElement> properties = AngularPropertyElement.EMPTY_ARRAY;
       // maybe name
       if (toolkitObject is AngularElement) {
-        if (isNameCoveredByLiteral(toolkitObject, node)) {
+        if (_isNameCoveredByLiteral(toolkitObject, node)) {
           return toolkitObject;
         }
       }
       // try selector
       if (toolkitObject is AngularHasSelectorElement) {
         AngularHasSelectorElement hasSelector = toolkitObject;
         AngularSelectorElement selector = hasSelector.selector;
-        if (isNameCoveredByLiteral(selector, node)) {
+        if (_isNameCoveredByLiteral(selector, node)) {
           return selector;
         }
       }
       // try properties of AngularComponentElement
       if (toolkitObject is AngularComponentElement) {
         AngularComponentElement component = toolkitObject;
         properties = component.properties;
       }
       // try properties of AngularDirectiveElement
       if (toolkitObject is AngularDirectiveElement) {
         AngularDirectiveElement directive = toolkitObject;
         properties = directive.properties;
       }
       // check properties
       for (AngularPropertyElement property in properties) {
         // property name (use complete node range)
-        if (isNameCoveredByLiteral(property, node)) {
+        if (_isNameCoveredByLiteral(property, node)) {
           return property;
         }
         // field name (use complete node range, including @, => and <=>)
         FieldElement field = property.field;
         if (field != null) {
           int fieldOffset = property.fieldNameOffset;
           int fieldEnd = fieldOffset + field.name.length;
           if (node.offset <= fieldOffset && fieldEnd < node.end) {
             return field;
           }
@@ skipping 36 matching lines @@
     // tag
     if (StringUtilities.isTagName(text)) {
       return new AngularTagSelectorElementImpl(text, offset);
     }
     return null;
   }
 
   /**
    * Returns the [FieldElement] of the first field in the given [FieldDeclaration].
    */
-  static FieldElement getOnlyFieldElement(FieldDeclaration fieldDeclaration) {
+  static FieldElement _getOnlyFieldElement(FieldDeclaration fieldDeclaration) {
     NodeList<VariableDeclaration> fields = fieldDeclaration.fields.variables;
     return fields[0].element as FieldElement;
   }
 
   /**
    * If given [Annotation] has one argument and it is [SimpleStringLiteral], returns it,
    * otherwise returns `null`.
    */
-  static SimpleStringLiteral getOnlySimpleStringLiteralArgument(Annotation annotation) {
+  static SimpleStringLiteral _getOnlySimpleStringLiteralArgument(Annotation annotation) {
     SimpleStringLiteral nameLiteral = null;
     ArgumentList argsNode = annotation.arguments;
     if (argsNode != null) {
       NodeList<Expression> args = argsNode.arguments;
       if (args.length == 1) {
         Expression arg = args[0];
         if (arg is SimpleStringLiteral) {
           nameLiteral = arg;
         }
       }
     }
     return nameLiteral;
   }
 
   /**
    * Checks if the name range of the given [Element] is completely covered by the given
    * [SimpleStringLiteral].
    */
-  static bool isNameCoveredByLiteral(Element element, AstNode node) {
+  static bool _isNameCoveredByLiteral(Element element, AstNode node) {
     if (element != null) {
       String name = element.name;
       if (name != null) {
         int nameOffset = element.nameOffset;
         int nameEnd = nameOffset + name.length;
         return node.offset <= nameOffset && nameEnd < node.end;
       }
     }
     return false;
   }
 
   /**
    * Parses given [SimpleStringLiteral] using [parseSelector].
    */
-  static AngularSelectorElement parseSelectorFromString(SimpleStringLiteral literal) {
+  static AngularSelectorElement _parseSelectorFromString(SimpleStringLiteral literal) {
     int offset = literal.valueOffset;
     String text = literal.stringValue;
     return parseSelector(offset, text);
   }
 
   /**
    * The listener to which errors will be reported.
    */
   AnalysisErrorListener _errorListener;
 
@@ skipping 37 matching lines @@
   AngularCompilationUnitBuilder(AnalysisErrorListener errorListener, Source source, CompilationUnit unit) {
     this._errorListener = errorListener;
     this._source = source;
     this._unit = unit;
   }
 
   /**
    * Builds Angular specific element models and adds them to the existing Dart elements.
    */
   void build() {
-    parseViews();
+    _parseViews();
     // process classes
     for (CompilationUnitMember unitMember in _unit.declarations) {
       if (unitMember is ClassDeclaration) {
         this._classDeclaration = unitMember;
         this._classElement = _classDeclaration.element as ClassElementImpl;
         this._classToolkitObjects.clear();
         // process annotations
         NodeList<Annotation> annotations = _classDeclaration.metadata;
         for (Annotation annotation in annotations) {
           // verify annotation
           if (annotation.arguments == null) {
             continue;
           }
           this._annotation = annotation;
           // @NgFilter
-          if (isAngularAnnotation(annotation, _NG_FILTER)) {
-            parseNgFilter();
+          if (_isAngularAnnotation(annotation, _NG_FILTER)) {
+            _parseNgFilter();
             continue;
           }
           // @NgComponent
-          if (isAngularAnnotation(annotation, _NG_COMPONENT)) {
-            parseNgComponent();
+          if (_isAngularAnnotation(annotation, _NG_COMPONENT)) {
+            _parseNgComponent();
             continue;
           }
           // @NgController
-          if (isAngularAnnotation(annotation, _NG_CONTROLLER)) {
-            parseNgController();
+          if (_isAngularAnnotation(annotation, _NG_CONTROLLER)) {
+            _parseNgController();
             continue;
           }
           // @NgDirective
-          if (isAngularAnnotation(annotation, _NG_DIRECTIVE)) {
-            parseNgDirective();
+          if (_isAngularAnnotation(annotation, _NG_DIRECTIVE)) {
+            _parseNgDirective();
             continue;
           }
         }
         // set toolkit objects
         if (!_classToolkitObjects.isEmpty) {
           List<ToolkitObjectElement> objects = _classToolkitObjects;
           _classElement.toolkitObjects = new List.from(objects);
         }
       }
     }
   }
 
   /**
    * @return the argument [Expression] with given name form [annotation], may be
    *         `null` if not found.
    */
-  Expression getArgument(String name) {
+  Expression _getArgument(String name) {
     List<Expression> arguments = _annotation.arguments.arguments;
     for (Expression argument in arguments) {
       if (argument is NamedExpression) {
         NamedExpression namedExpression = argument;
         String argumentName = namedExpression.name.label.name;
         if (name == argumentName) {
           return namedExpression.expression;
         }
       }
     }
     return null;
   }
 
   /**
    * @return the [String] value of the named argument.
    */
-  String getStringArgument(String name) => getStringLiteral(name).value;
+  String _getStringArgument(String name) => _getStringLiteral(name).value;
 
   /**
    * @return the offset of the value of the named argument.
    */
-  int getStringArgumentOffset(String name) {
-    Expression argument = getArgument(name);
+  int _getStringArgumentOffset(String name) {
+    Expression argument = _getArgument(name);
     return (argument as SimpleStringLiteral).valueOffset;
   }
 
   /**
    * @return the [SimpleStringLiteral] of the named argument.
    */
-  SimpleStringLiteral getStringLiteral(String name) {
-    Expression argument = getArgument(name);
+  SimpleStringLiteral _getStringLiteral(String name) {
+    Expression argument = _getArgument(name);
     return argument as SimpleStringLiteral;
   }
 
   /**
    * Checks if [namedArguments] has string value for the argument with the given name.
    */
-  bool hasStringArgument(String name) {
-    Expression argument = getArgument(name);
+  bool _hasStringArgument(String name) {
+    Expression argument = _getArgument(name);
     return argument is SimpleStringLiteral;
   }
 
   /**
    * Checks if given [Annotation] is an annotation with required name.
    */
-  bool isAngularAnnotation(Annotation annotation, String name) {
+  bool _isAngularAnnotation(Annotation annotation, String name) {
     Element element = annotation.element;
     if (element is ConstructorElement) {
       ConstructorElement constructorElement = element;
       return constructorElement.returnType.displayName == name;
     }
     return false;
   }
 
-  void parseNgComponent() {
+  void _parseNgComponent() {
     bool isValid = true;
     // publishAs
     String name = null;
     int nameOffset = -1;
-    if (hasStringArgument(_PUBLISH_AS)) {
-      name = getStringArgument(_PUBLISH_AS);
-      nameOffset = getStringArgumentOffset(_PUBLISH_AS);
+    if (_hasStringArgument(_PUBLISH_AS)) {
+      name = _getStringArgument(_PUBLISH_AS);
+      nameOffset = _getStringArgumentOffset(_PUBLISH_AS);
     }
     // selector
     AngularSelectorElement selector = null;
-    if (!hasStringArgument(_SELECTOR)) {
-      reportErrorForAnnotation(AngularCode.MISSING_SELECTOR, []);
+    if (!_hasStringArgument(_SELECTOR)) {
+      _reportErrorForAnnotation(AngularCode.MISSING_SELECTOR, []);
       isValid = false;
     } else {
-      SimpleStringLiteral selectorLiteral = getStringLiteral(_SELECTOR);
-      selector = parseSelectorFromString(selectorLiteral);
+      SimpleStringLiteral selectorLiteral = _getStringLiteral(_SELECTOR);
+      selector = _parseSelectorFromString(selectorLiteral);
       if (selector == null) {
-        reportErrorForArgument(_SELECTOR, AngularCode.CANNOT_PARSE_SELECTOR, [selectorLiteral]);
+        _reportErrorForArgument(_SELECTOR, AngularCode.CANNOT_PARSE_SELECTOR, [selectorLiteral]);
         isValid = false;
       }
     }
     // templateUrl
     String templateUri = null;
     int templateUriOffset = -1;
-    if (hasStringArgument(_TEMPLATE_URL)) {
-      templateUri = getStringArgument(_TEMPLATE_URL);
-      templateUriOffset = getStringArgumentOffset(_TEMPLATE_URL);
+    if (_hasStringArgument(_TEMPLATE_URL)) {
+      templateUri = _getStringArgument(_TEMPLATE_URL);
+      templateUriOffset = _getStringArgumentOffset(_TEMPLATE_URL);
     }
     // cssUrl
     String styleUri = null;
     int styleUriOffset = -1;
-    if (hasStringArgument(_CSS_URL)) {
-      styleUri = getStringArgument(_CSS_URL);
-      styleUriOffset = getStringArgumentOffset(_CSS_URL);
+    if (_hasStringArgument(_CSS_URL)) {
+      styleUri = _getStringArgument(_CSS_URL);
+      styleUriOffset = _getStringArgumentOffset(_CSS_URL);
     }
     // create
     if (isValid) {
       AngularComponentElementImpl element = new AngularComponentElementImpl(name, nameOffset, _annotation.offset);
       element.selector = selector;
       element.templateUri = templateUri;
       element.templateUriOffset = templateUriOffset;
       element.styleUri = styleUri;
       element.styleUriOffset = styleUriOffset;
-      element.properties = parseNgComponentProperties();
-      element.scopeProperties = parseScopeProperties();
+      element.properties = _parseNgComponentProperties();
+      element.scopeProperties = _parseScopeProperties();
       _classToolkitObjects.add(element);
     }
   }
 
   /**
    * Parses [AngularPropertyElement]s from [annotation] and [classDeclaration].
    */
-  List<AngularPropertyElement> parseNgComponentProperties() {
+  List<AngularPropertyElement> _parseNgComponentProperties() {
     List<AngularPropertyElement> properties = [];
-    parseNgComponentProperties_fromMap(properties);
-    parseNgComponentProperties_fromFields(properties);
+    _parseNgComponentProperties_fromMap(properties);
+    _parseNgComponentProperties_fromFields(properties);
     return new List.from(properties);
   }
 
   /**
    * Parses [AngularPropertyElement]s from [annotation].
    */
-  void parseNgComponentProperties_fromFields(List<AngularPropertyElement> properties) {
+  void _parseNgComponentProperties_fromFields(List<AngularPropertyElement> properties) {
     NodeList<ClassMember> members = _classDeclaration.members;
     for (ClassMember member in members) {
       if (member is FieldDeclaration) {
         FieldDeclaration fieldDeclaration = member;
         for (Annotation annotation in fieldDeclaration.metadata) {
           // prepare property kind (if property annotation at all)
           AngularPropertyKind kind = null;
-          if (isAngularAnnotation(annotation, _NG_ATTR)) {
+          if (_isAngularAnnotation(annotation, _NG_ATTR)) {
             kind = AngularPropertyKind.ATTR;
-          } else if (isAngularAnnotation(annotation, _NG_CALLBACK)) {
+          } else if (_isAngularAnnotation(annotation, _NG_CALLBACK)) {
             kind = AngularPropertyKind.CALLBACK;
-          } else if (isAngularAnnotation(annotation, _NG_ONE_WAY)) {
+          } else if (_isAngularAnnotation(annotation, _NG_ONE_WAY)) {
             kind = AngularPropertyKind.ONE_WAY;
-          } else if (isAngularAnnotation(annotation, _NG_ONE_WAY_ONE_TIME)) {
+          } else if (_isAngularAnnotation(annotation, _NG_ONE_WAY_ONE_TIME)) {
             kind = AngularPropertyKind.ONE_WAY_ONE_TIME;
-          } else if (isAngularAnnotation(annotation, _NG_TWO_WAY)) {
+          } else if (_isAngularAnnotation(annotation, _NG_TWO_WAY)) {
             kind = AngularPropertyKind.TWO_WAY;
           }
           // add property
           if (kind != null) {
-            SimpleStringLiteral nameLiteral = getOnlySimpleStringLiteralArgument(annotation);
-            FieldElement field = getOnlyFieldElement(fieldDeclaration);
+            SimpleStringLiteral nameLiteral = _getOnlySimpleStringLiteralArgument(annotation);
+            FieldElement field = _getOnlyFieldElement(fieldDeclaration);
             if (nameLiteral != null && field != null) {
               AngularPropertyElementImpl property = new AngularPropertyElementImpl(nameLiteral.value, nameLiteral.valueOffset);
               property.field = field;
               property.propertyKind = kind;
               properties.add(property);
             }
           }
         }
       }
     }
   }
 
   /**
    * Parses [AngularPropertyElement]s from [annotation].
    */
-  void parseNgComponentProperties_fromMap(List<AngularPropertyElement> properties) {
-    Expression mapExpression = getArgument("map");
+  void _parseNgComponentProperties_fromMap(List<AngularPropertyElement> properties) {
+    Expression mapExpression = _getArgument("map");
     // may be not properties
     if (mapExpression == null) {
       return;
     }
     // prepare map literal
     if (mapExpression is! MapLiteral) {
-      reportErrorForNode(AngularCode.INVALID_PROPERTY_MAP, mapExpression, []);
+      _reportErrorForNode(AngularCode.INVALID_PROPERTY_MAP, mapExpression, []);
       return;
     }
     MapLiteral mapLiteral = mapExpression as MapLiteral;
     // analyze map entries
     for (MapLiteralEntry entry in mapLiteral.entries) {
       // prepare property name
       Expression nameExpression = entry.key;
       if (nameExpression is! SimpleStringLiteral) {
-        reportErrorForNode(AngularCode.INVALID_PROPERTY_NAME, nameExpression, []);
+        _reportErrorForNode(AngularCode.INVALID_PROPERTY_NAME, nameExpression, []);
         continue;
       }
       SimpleStringLiteral nameLiteral = nameExpression as SimpleStringLiteral;
       String name = nameLiteral.value;
       int nameOffset = nameLiteral.valueOffset;
       // prepare field specification
       Expression specExpression = entry.value;
       if (specExpression is! SimpleStringLiteral) {
-        reportErrorForNode(AngularCode.INVALID_PROPERTY_SPEC, specExpression, []);
+        _reportErrorForNode(AngularCode.INVALID_PROPERTY_SPEC, specExpression, []);
         continue;
       }
       SimpleStringLiteral specLiteral = specExpression as SimpleStringLiteral;
       String spec = specLiteral.value;
       // parse binding kind and field name
       AngularPropertyKind kind;
       int fieldNameOffset;
       if (StringUtilities.startsWithChar(spec, 0x40)) {
         kind = AngularPropertyKind.ATTR;
         fieldNameOffset = 1;
       } else if (StringUtilities.startsWithChar(spec, 0x26)) {
         kind = AngularPropertyKind.CALLBACK;
         fieldNameOffset = 1;
       } else if (StringUtilities.startsWith3(spec, 0, 0x3D, 0x3E, 0x21)) {
         kind = AngularPropertyKind.ONE_WAY_ONE_TIME;
         fieldNameOffset = 3;
       } else if (StringUtilities.startsWith2(spec, 0, 0x3D, 0x3E)) {
         kind = AngularPropertyKind.ONE_WAY;
         fieldNameOffset = 2;
       } else if (StringUtilities.startsWith3(spec, 0, 0x3C, 0x3D, 0x3E)) {
         kind = AngularPropertyKind.TWO_WAY;
         fieldNameOffset = 3;
       } else {
-        reportErrorForNode(AngularCode.INVALID_PROPERTY_KIND, specLiteral, [spec]);
+        _reportErrorForNode(AngularCode.INVALID_PROPERTY_KIND, specLiteral, [spec]);
         continue;
       }
       String fieldName = spec.substring(fieldNameOffset);
       fieldNameOffset += specLiteral.valueOffset;
       // prepare field
       PropertyAccessorElement setter = _classElement.type.lookUpSetter(fieldName, _classElement.library);
       if (setter == null) {
-        reportErrorForOffset(AngularCode.INVALID_PROPERTY_FIELD, fieldNameOffset, fieldName.length, [fieldName]);
+        _reportErrorForOffset(AngularCode.INVALID_PROPERTY_FIELD, fieldNameOffset, fieldName.length, [fieldName]);
         continue;
       }
       FieldElement field = setter.variable as FieldElement;
       // add property
       AngularPropertyElementImpl property = new AngularPropertyElementImpl(name, nameOffset);
       property.field = field;
       property.propertyKind = kind;
       property.fieldNameOffset = fieldNameOffset;
       properties.add(property);
     }
   }
 
-  void parseNgController() {
+  void _parseNgController() {
     bool isValid = true;
     // publishAs
-    if (!hasStringArgument(_PUBLISH_AS)) {
-      reportErrorForAnnotation(AngularCode.MISSING_PUBLISH_AS, []);
+    if (!_hasStringArgument(_PUBLISH_AS)) {
+      _reportErrorForAnnotation(AngularCode.MISSING_PUBLISH_AS, []);
       isValid = false;
     }
     // selector
     AngularSelectorElement selector = null;
-    if (!hasStringArgument(_SELECTOR)) {
-      reportErrorForAnnotation(AngularCode.MISSING_SELECTOR, []);
+    if (!_hasStringArgument(_SELECTOR)) {
+      _reportErrorForAnnotation(AngularCode.MISSING_SELECTOR, []);
       isValid = false;
     } else {
-      SimpleStringLiteral selectorLiteral = getStringLiteral(_SELECTOR);
-      selector = parseSelectorFromString(selectorLiteral);
+      SimpleStringLiteral selectorLiteral = _getStringLiteral(_SELECTOR);
+      selector = _parseSelectorFromString(selectorLiteral);
       if (selector == null) {
-        reportErrorForArgument(_SELECTOR, AngularCode.CANNOT_PARSE_SELECTOR, [selectorLiteral]);
+        _reportErrorForArgument(_SELECTOR, AngularCode.CANNOT_PARSE_SELECTOR, [selectorLiteral]);
         isValid = false;
       }
     }
     // create
     if (isValid) {
-      String name = getStringArgument(_PUBLISH_AS);
-      int nameOffset = getStringArgumentOffset(_PUBLISH_AS);
+      String name = _getStringArgument(_PUBLISH_AS);
+      int nameOffset = _getStringArgumentOffset(_PUBLISH_AS);
       AngularControllerElementImpl element = new AngularControllerElementImpl(name, nameOffset);
       element.selector = selector;
       _classToolkitObjects.add(element);
     }
   }
 
-  void parseNgDirective() {
+  void _parseNgDirective() {
     bool isValid = true;
     // selector
     AngularSelectorElement selector = null;
-    if (!hasStringArgument(_SELECTOR)) {
-      reportErrorForAnnotation(AngularCode.MISSING_SELECTOR, []);
+    if (!_hasStringArgument(_SELECTOR)) {
+      _reportErrorForAnnotation(AngularCode.MISSING_SELECTOR, []);
       isValid = false;
     } else {
-      SimpleStringLiteral selectorLiteral = getStringLiteral(_SELECTOR);
-      selector = parseSelectorFromString(selectorLiteral);
+      SimpleStringLiteral selectorLiteral = _getStringLiteral(_SELECTOR);
+      selector = _parseSelectorFromString(selectorLiteral);
       if (selector == null) {
-        reportErrorForArgument(_SELECTOR, AngularCode.CANNOT_PARSE_SELECTOR, [selectorLiteral]);
+        _reportErrorForArgument(_SELECTOR, AngularCode.CANNOT_PARSE_SELECTOR, [selectorLiteral]);
         isValid = false;
       }
     }
     // create
     if (isValid) {
       int offset = _annotation.offset;
       AngularDirectiveElementImpl element = new AngularDirectiveElementImpl(offset);
       element.selector = selector;
-      element.properties = parseNgComponentProperties();
+      element.properties = _parseNgComponentProperties();
       _classToolkitObjects.add(element);
     }
   }
 
-  void parseNgFilter() {
+  void _parseNgFilter() {
     bool isValid = true;
     // name
-    if (!hasStringArgument(_NAME)) {
-      reportErrorForAnnotation(AngularCode.MISSING_NAME, []);
+    if (!_hasStringArgument(_NAME)) {
+      _reportErrorForAnnotation(AngularCode.MISSING_NAME, []);
       isValid = false;
     }
     // create
     if (isValid) {
-      String name = getStringArgument(_NAME);
-      int nameOffset = getStringArgumentOffset(_NAME);
+      String name = _getStringArgument(_NAME);
+      int nameOffset = _getStringArgumentOffset(_NAME);
       _classToolkitObjects.add(new AngularFilterElementImpl(name, nameOffset));
     }
   }
 
-  List<AngularScopePropertyElement> parseScopeProperties() {
+  List<AngularScopePropertyElement> _parseScopeProperties() {
     List<AngularScopePropertyElement> properties = [];
     _classDeclaration.accept(new RecursiveAstVisitor_AngularCompilationUnitBuilder_parseScopeProperties(properties));
     return new List.from(properties);
   }
 
   /**
    * Create [AngularViewElement] for each valid <code>view('template.html')</code> invocation,
    * where <code>view</code> is <code>ViewFactory</code>.
    */
-  void parseViews() {
+  void _parseViews() {
     List<AngularViewElement> views = [];
     _unit.accept(new RecursiveAstVisitor_AngularCompilationUnitBuilder_parseViews(views));
     if (!views.isEmpty) {
       List<AngularViewElement> viewArray = new List.from(views);
       (_unit.element as CompilationUnitElementImpl).angularViews = viewArray;
     }
   }
 
-  void reportErrorForAnnotation(ErrorCode errorCode, List<Object> arguments) {
-    reportErrorForNode(errorCode, _annotation, arguments);
+  void _reportErrorForAnnotation(ErrorCode errorCode, List<Object> arguments) {
+    _reportErrorForNode(errorCode, _annotation, arguments);
   }
 
-  void reportErrorForArgument(String argumentName, ErrorCode errorCode, List<Object> arguments) {
-    Expression argument = getArgument(argumentName);
-    reportErrorForNode(errorCode, argument, arguments);
+  void _reportErrorForArgument(String argumentName, ErrorCode errorCode, List<Object> arguments) {
+    Expression argument = _getArgument(argumentName);
+    _reportErrorForNode(errorCode, argument, arguments);
   }
 
-  void reportErrorForNode(ErrorCode errorCode, AstNode node, List<Object> arguments) {
+  void _reportErrorForNode(ErrorCode errorCode, AstNode node, List<Object> arguments) {
     int offset = node.offset;
     int length = node.length;
-    reportErrorForOffset(errorCode, offset, length, arguments);
+    _reportErrorForOffset(errorCode, offset, length, arguments);
   }
 
-  void reportErrorForOffset(ErrorCode errorCode, int offset, int length, List<Object> arguments) {
+  void _reportErrorForOffset(ErrorCode errorCode, int offset, int length, List<Object> arguments) {
     _errorListener.onError(new AnalysisError.con2(_source, offset, length, errorCode, arguments));
   }
 }
 
 class RecursiveAstVisitor_AngularCompilationUnitBuilder_parseScopeProperties extends RecursiveAstVisitor<Object> {
   List<AngularScopePropertyElement> properties;
 
   RecursiveAstVisitor_AngularCompilationUnitBuilder_parseScopeProperties(this.properties) : super();
 
   Object visitAssignmentExpression(AssignmentExpression node) {
-    addProperty(node);
+    _addProperty(node);
     return super.visitAssignmentExpression(node);
   }
 
-  void addProperty(AssignmentExpression node) {
+  void _addProperty(AssignmentExpression node) {
     // try to find "name" in scope[name]
-    SimpleStringLiteral nameNode = getNameNode(node.leftHandSide);
+    SimpleStringLiteral nameNode = _getNameNode(node.leftHandSide);
     if (nameNode == null) {
       return;
     }
     // prepare unique
     String name = nameNode.stringValue;
-    if (hasPropertyWithName(name)) {
+    if (_hasPropertyWithName(name)) {
       return;
     }
     // do add property
     int nameOffset = nameNode.valueOffset;
     AngularScopePropertyElement property = new AngularScopePropertyElementImpl(name, nameOffset, node.rightHandSide.bestType);
     nameNode.toolkitElement = property;
     properties.add(property);
   }
 
-  SimpleStringLiteral getNameNode(Expression node) {
+  SimpleStringLiteral _getNameNode(Expression node) {
     if (node is IndexExpression) {
       IndexExpression indexExpression = node;
       Expression target = indexExpression.target;
       Expression index = indexExpression.index;
-      if (index is SimpleStringLiteral && isContext(target)) {
+      if (index is SimpleStringLiteral && _isContext(target)) {
         return index;
       }
     }
     return null;
   }
 
-  bool hasPropertyWithName(String name) {
+  bool _hasPropertyWithName(String name) {
     for (AngularScopePropertyElement property in properties) {
       if (property.name == name) {
         return true;
       }
     }
     return false;
   }
 
-  bool isContext(Expression target) {
+  bool _isContext(Expression target) {
     if (target is PrefixedIdentifier) {
       PrefixedIdentifier prefixed = target;
       SimpleIdentifier prefix = prefixed.prefix;
       SimpleIdentifier identifier = prefixed.identifier;
-      return (identifier.name == "context") && isScope(prefix);
+      return (identifier.name == "context") && _isScope(prefix);
     }
     return false;
   }
 
-  bool isScope(Expression target) {
+  bool _isScope(Expression target) {
     if (target != null) {
       Type2 type = target.bestType;
       if (type is InterfaceType) {
         InterfaceType interfaceType = type;
         return interfaceType.name == "Scope";
       }
     }
     return false;
   }
 }
 
 class RecursiveAstVisitor_AngularCompilationUnitBuilder_parseViews extends RecursiveAstVisitor<Object> {
   List<AngularViewElement> views;
 
   RecursiveAstVisitor_AngularCompilationUnitBuilder_parseViews(this.views) : super();
 
   Object visitMethodInvocation(MethodInvocation node) {
-    addView(node);
+    _addView(node);
     return super.visitMethodInvocation(node);
   }
 
-  void addView(MethodInvocation node) {
+  void _addView(MethodInvocation node) {
     // only one argument
     List<Expression> arguments = node.argumentList.arguments;
     if (arguments.length != 1) {
       return;
     }
     // String literal
     Expression argument = arguments[0];
     if (argument is! SimpleStringLiteral) {
       return;
     }
     SimpleStringLiteral literal = argument as SimpleStringLiteral;
     // just view('template')
     if (node.realTarget != null) {
       return;
     }
     // should be ViewFactory
-    if (!isViewFactory(node.methodName)) {
+    if (!_isViewFactory(node.methodName)) {
       return;
     }
     // add AngularViewElement
     String templateUri = literal.stringValue;
     int templateUriOffset = literal.valueOffset;
     views.add(new AngularViewElementImpl(templateUri, templateUriOffset));
   }
 
-  bool isViewFactory(Expression target) {
+  bool _isViewFactory(Expression target) {
     if (target is SimpleIdentifier) {
       SimpleIdentifier identifier = target;
       Element element = identifier.staticElement;
       if (element is VariableElement) {
         VariableElement variable = element;
         Type2 type = variable.type;
         if (type is InterfaceType) {
           InterfaceType interfaceType = type;
           return interfaceType.name == "ViewFactory";
         }
@@ skipping 120 matching lines @@
     _functionTypesToFix = new List<FunctionTypeImpl>();
     //
     // Process field declarations before constructors and methods so that field formal parameters
     // can be correctly resolved to their fields.
     //
     ElementHolder previousHolder = _currentHolder;
     _currentHolder = holder;
     try {
       List<ClassMember> nonFields = new List<ClassMember>();
       node.visitChildren(new UnifyingAstVisitor_ElementBuilder_visitClassDeclaration(this, nonFields));
-      buildFieldMap(holder.fieldsWithoutFlushing);
+      _buildFieldMap(holder.fieldsWithoutFlushing);
       int count = nonFields.length;
       for (int i = 0; i < count; i++) {
         nonFields[i].accept(this);
       }
     } finally {
       _currentHolder = previousHolder;
     }
     SimpleIdentifier className = node.name;
     ClassElementImpl element = new ClassElementImpl(className);
     List<TypeParameterElement> typeParameters = holder.typeParameters;
-    List<Type2> typeArguments = createTypeParameterTypes(typeParameters);
+    List<Type2> typeArguments = _createTypeParameterTypes(typeParameters);
     InterfaceTypeImpl interfaceType = new InterfaceTypeImpl.con1(element);
     interfaceType.typeArguments = typeArguments;
     element.type = interfaceType;
     List<ConstructorElement> constructors = holder.constructors;
     if (constructors.length == 0) {
       //
       // Create the default constructor.
       //
-      constructors = createDefaultConstructors(interfaceType);
+      constructors = _createDefaultConstructors(interfaceType);
     }
     element.abstract = node.abstractKeyword != null;
     element.accessors = holder.accessors;
     element.constructors = constructors;
     element.fields = holder.fields;
     element.methods = holder.methods;
     element.typeParameters = typeParameters;
     element.validMixin = _isValidMixin;
     int functionTypeCount = _functionTypesToFix.length;
     for (int i = 0; i < functionTypeCount; i++) {
       _functionTypesToFix[i].typeArguments = typeArguments;
     }
     _functionTypesToFix = null;
     _currentHolder.addType(element);
     className.staticElement = element;
     _fieldMap = null;
     holder.validate();
     return null;
   }
 
   Object visitClassTypeAlias(ClassTypeAlias node) {
     ElementHolder holder = new ElementHolder();
     _functionTypesToFix = new List<FunctionTypeImpl>();
-    visitChildren(holder, node);
+    _visitChildren(holder, node);
     SimpleIdentifier className = node.name;
     ClassElementImpl element = new ClassElementImpl(className);
     element.abstract = node.abstractKeyword != null;
     element.typedef = true;
     List<TypeParameterElement> typeParameters = holder.typeParameters;
     element.typeParameters = typeParameters;
-    List<Type2> typeArguments = createTypeParameterTypes(typeParameters);
+    List<Type2> typeArguments = _createTypeParameterTypes(typeParameters);
     InterfaceTypeImpl interfaceType = new InterfaceTypeImpl.con1(element);
     interfaceType.typeArguments = typeArguments;
     element.type = interfaceType;
     // set default constructor
-    element.constructors = createDefaultConstructors(interfaceType);
+    element.constructors = _createDefaultConstructors(interfaceType);
     for (FunctionTypeImpl functionType in _functionTypesToFix) {
       functionType.typeArguments = typeArguments;
     }
     _functionTypesToFix = null;
     _currentHolder.addType(element);
     className.staticElement = element;
     holder.validate();
     return null;
   }
 
   Object visitConstructorDeclaration(ConstructorDeclaration node) {
     _isValidMixin = false;
     ElementHolder holder = new ElementHolder();
     bool wasInFunction = _inFunction;
     _inFunction = true;
     try {
-      visitChildren(holder, node);
+      _visitChildren(holder, node);
     } finally {
       _inFunction = wasInFunction;
     }
     SimpleIdentifier constructorName = node.name;
     ConstructorElementImpl element = new ConstructorElementImpl.con1(constructorName);
     if (node.factoryKeyword != null) {
       element.factory = true;
     }
     element.functions = holder.functions;
     element.labels = holder.labels;
@@ skipping 15 matching lines @@
   }
 
   Object visitDeclaredIdentifier(DeclaredIdentifier node) {
     SimpleIdentifier variableName = node.identifier;
     sc.Token keyword = node.keyword;
     LocalVariableElementImpl element = new LocalVariableElementImpl(variableName);
     ForEachStatement statement = node.parent as ForEachStatement;
     int declarationEnd = node.offset + node.length;
     int statementEnd = statement.offset + statement.length;
     element.setVisibleRange(declarationEnd, statementEnd - declarationEnd - 1);
-    element.const3 = matches(keyword, sc.Keyword.CONST);
-    element.final2 = matches(keyword, sc.Keyword.FINAL);
+    element.const3 = _matches(keyword, sc.Keyword.CONST);
+    element.final2 = _matches(keyword, sc.Keyword.FINAL);
     _currentHolder.addLocalVariable(element);
     variableName.staticElement = element;
     return super.visitDeclaredIdentifier(node);
   }
 
   Object visitDefaultFormalParameter(DefaultFormalParameter node) {
     ElementHolder holder = new ElementHolder();
     NormalFormalParameter normalParameter = node.parameter;
     SimpleIdentifier parameterName = normalParameter.identifier;
     ParameterElementImpl parameter;
     if (normalParameter is FieldFormalParameter) {
       parameter = new DefaultFieldFormalParameterElementImpl(parameterName);
       FieldElement field = _fieldMap == null ? null : _fieldMap[parameterName.name];
       if (field != null) {
         (parameter as DefaultFieldFormalParameterElementImpl).field = field;
       }
     } else {
       parameter = new DefaultParameterElementImpl(parameterName);
     }
     parameter.const3 = node.isConst;
     parameter.final2 = node.isFinal;
     parameter.parameterKind = node.kind;
     // set initializer, default value range
     Expression defaultValue = node.defaultValue;
     if (defaultValue != null) {
-      visit(holder, defaultValue);
+      _visit(holder, defaultValue);
       FunctionElementImpl initializer = new FunctionElementImpl.con2(defaultValue.beginToken.offset);
       initializer.functions = holder.functions;
       initializer.labels = holder.labels;
       initializer.localVariables = holder.localVariables;
       initializer.parameters = holder.parameters;
       initializer.synthetic = true;
       parameter.initializer = initializer;
       parameter.setDefaultValueRange(defaultValue.offset, defaultValue.length);
     }
     // visible range
-    setParameterVisibleRange(node, parameter);
+    _setParameterVisibleRange(node, parameter);
     _currentHolder.addParameter(parameter);
     parameterName.staticElement = parameter;
     normalParameter.accept(this);
     holder.validate();
     return null;
   }
 
   Object visitFieldDeclaration(FieldDeclaration node) {
     bool wasInField = _inFieldContext;
     _inFieldContext = true;
@@ skipping 16 matching lines @@
       if (field != null) {
         parameter.field = field;
       }
       _currentHolder.addParameter(parameter);
       parameterName.staticElement = parameter;
     }
     //
     // The children of this parameter include any parameters defined on the type of this parameter.
     //
     ElementHolder holder = new ElementHolder();
-    visitChildren(holder, node);
+    _visitChildren(holder, node);
     (node.element as ParameterElementImpl).parameters = holder.parameters;
     holder.validate();
     return null;
   }
 
   Object visitFunctionDeclaration(FunctionDeclaration node) {
     FunctionExpression expression = node.functionExpression;
     if (expression != null) {
       ElementHolder holder = new ElementHolder();
       bool wasInFunction = _inFunction;
       _inFunction = true;
       try {
-        visitChildren(holder, expression);
+        _visitChildren(holder, expression);
       } finally {
         _inFunction = wasInFunction;
       }
       sc.Token property = node.propertyKeyword;
       if (property == null) {
         SimpleIdentifier functionName = node.name;
         FunctionElementImpl element = new FunctionElementImpl.con1(functionName);
         element.functions = holder.functions;
         element.labels = holder.labels;
         element.localVariables = holder.localVariables;
@@ skipping 16 matching lines @@
           return null;
         }
         String propertyName = propertyNameNode.name;
         TopLevelVariableElementImpl variable = _currentHolder.getTopLevelVariable(propertyName) as TopLevelVariableElementImpl;
         if (variable == null) {
           variable = new TopLevelVariableElementImpl.con2(node.name.name);
           variable.final2 = true;
           variable.synthetic = true;
           _currentHolder.addTopLevelVariable(variable);
         }
-        if (matches(property, sc.Keyword.GET)) {
+        if (_matches(property, sc.Keyword.GET)) {
           PropertyAccessorElementImpl getter = new PropertyAccessorElementImpl.con1(propertyNameNode);
           getter.functions = holder.functions;
           getter.labels = holder.labels;
           getter.localVariables = holder.localVariables;
           getter.variable = variable;
           getter.getter = true;
           getter.static = true;
           variable.getter = getter;
           _currentHolder.addAccessor(getter);
           expression.element = getter;
@@ skipping 17 matching lines @@
       holder.validate();
     }
     return null;
   }
 
   Object visitFunctionExpression(FunctionExpression node) {
     ElementHolder holder = new ElementHolder();
     bool wasInFunction = _inFunction;
     _inFunction = true;
     try {
-      visitChildren(holder, node);
+      _visitChildren(holder, node);
     } finally {
       _inFunction = wasInFunction;
     }
     FunctionElementImpl element = new FunctionElementImpl.con2(node.beginToken.offset);
     element.functions = holder.functions;
     element.labels = holder.labels;
     element.localVariables = holder.localVariables;
     element.parameters = holder.parameters;
     if (_inFunction) {
       Block enclosingBlock = node.getAncestor((node) => node is Block);
       if (enclosingBlock != null) {
         int functionEnd = node.offset + node.length;
         int blockEnd = enclosingBlock.offset + enclosingBlock.length;
         element.setVisibleRange(functionEnd, blockEnd - functionEnd - 1);
       }
     }
     FunctionTypeImpl type = new FunctionTypeImpl.con1(element);
     if (_functionTypesToFix != null) {
       _functionTypesToFix.add(type);
     }
     element.type = type;
     _currentHolder.addFunction(element);
     node.element = element;
     holder.validate();
     return null;
   }
 
   Object visitFunctionTypeAlias(FunctionTypeAlias node) {
     ElementHolder holder = new ElementHolder();
-    visitChildren(holder, node);
+    _visitChildren(holder, node);
     SimpleIdentifier aliasName = node.name;
     List<ParameterElement> parameters = holder.parameters;
     List<TypeParameterElement> typeParameters = holder.typeParameters;
     FunctionTypeAliasElementImpl element = new FunctionTypeAliasElementImpl(aliasName);
     element.parameters = parameters;
     element.typeParameters = typeParameters;
     FunctionTypeImpl type = new FunctionTypeImpl.con2(element);
-    type.typeArguments = createTypeParameterTypes(typeParameters);
+    type.typeArguments = _createTypeParameterTypes(typeParameters);
     element.type = type;
     _currentHolder.addTypeAlias(element);
     aliasName.staticElement = element;
     holder.validate();
     return null;
   }
 
   Object visitFunctionTypedFormalParameter(FunctionTypedFormalParameter node) {
     if (node.parent is! DefaultFormalParameter) {
       SimpleIdentifier parameterName = node.identifier;
       ParameterElementImpl parameter = new ParameterElementImpl.con1(parameterName);
       parameter.parameterKind = node.kind;
-      setParameterVisibleRange(node, parameter);
+      _setParameterVisibleRange(node, parameter);
       _currentHolder.addParameter(parameter);
       parameterName.staticElement = parameter;
     }
     //
     // The children of this parameter include any parameters defined on the type of this parameter.
     //
     ElementHolder holder = new ElementHolder();
-    visitChildren(holder, node);
+    _visitChildren(holder, node);
     (node.element as ParameterElementImpl).parameters = holder.parameters;
     holder.validate();
     return null;
   }
 
   Object visitLabeledStatement(LabeledStatement node) {
     bool onSwitchStatement = node.statement is SwitchStatement;
     for (Label label in node.labels) {
       SimpleIdentifier labelName = label.label;
       LabelElementImpl element = new LabelElementImpl(labelName, onSwitchStatement, false);
       _currentHolder.addLabel(element);
       labelName.staticElement = element;
     }
     return super.visitLabeledStatement(node);
   }
 
   Object visitMethodDeclaration(MethodDeclaration node) {
     ElementHolder holder = new ElementHolder();
     bool wasInFunction = _inFunction;
     _inFunction = true;
     try {
-      visitChildren(holder, node);
+      _visitChildren(holder, node);
     } finally {
       _inFunction = wasInFunction;
     }
     bool isStatic = node.isStatic;
     sc.Token property = node.propertyKeyword;
     if (property == null) {
       SimpleIdentifier methodName = node.name;
       String nameOfMethod = methodName.name;
       if (nameOfMethod == sc.TokenType.MINUS.lexeme && node.parameters.parameters.length == 0) {
         nameOfMethod = "unary-";
@@ skipping 11 matching lines @@
       SimpleIdentifier propertyNameNode = node.name;
       String propertyName = propertyNameNode.name;
       FieldElementImpl field = _currentHolder.getField(propertyName) as FieldElementImpl;
       if (field == null) {
         field = new FieldElementImpl.con2(node.name.name);
         field.final2 = true;
         field.static = isStatic;
         field.synthetic = true;
         _currentHolder.addField(field);
       }
-      if (matches(property, sc.Keyword.GET)) {
+      if (_matches(property, sc.Keyword.GET)) {
         PropertyAccessorElementImpl getter = new PropertyAccessorElementImpl.con1(propertyNameNode);
         getter.functions = holder.functions;
         getter.labels = holder.labels;
         getter.localVariables = holder.localVariables;
         getter.variable = field;
         getter.abstract = node.body is EmptyFunctionBody && node.externalKeyword == null;
         getter.getter = true;
         getter.static = isStatic;
         field.getter = getter;
         _currentHolder.addAccessor(getter);
         propertyNameNode.staticElement = getter;
       } else {
         PropertyAccessorElementImpl setter = new PropertyAccessorElementImpl.con1(propertyNameNode);
         setter.functions = holder.functions;
         setter.labels = holder.labels;
         setter.localVariables = holder.localVariables;
         setter.parameters = holder.parameters;
         setter.variable = field;
-        setter.abstract = node.body is EmptyFunctionBody && !matches(node.externalKeyword, sc.Keyword.EXTERNAL);
+        setter.abstract = node.body is EmptyFunctionBody && !_matches(node.externalKeyword, sc.Keyword.EXTERNAL);
         setter.setter = true;
         setter.static = isStatic;
         field.setter = setter;
         field.final2 = false;
         _currentHolder.addAccessor(setter);
         propertyNameNode.staticElement = setter;
       }
     }
     holder.validate();
     return null;
   }
 
   Object visitSimpleFormalParameter(SimpleFormalParameter node) {
     if (node.parent is! DefaultFormalParameter) {
       SimpleIdentifier parameterName = node.identifier;
       ParameterElementImpl parameter = new ParameterElementImpl.con1(parameterName);
       parameter.const3 = node.isConst;
       parameter.final2 = node.isFinal;
       parameter.parameterKind = node.kind;
-      setParameterVisibleRange(node, parameter);
+      _setParameterVisibleRange(node, parameter);
       _currentHolder.addParameter(parameter);
       parameterName.staticElement = parameter;
     }
     return super.visitSimpleFormalParameter(node);
   }
 
   Object visitSuperExpression(SuperExpression node) {
     _isValidMixin = false;
     return super.visitSuperExpression(node);
   }
@@ skipping 23 matching lines @@
     TypeParameterElementImpl typeParameter = new TypeParameterElementImpl(parameterName);
     TypeParameterTypeImpl typeParameterType = new TypeParameterTypeImpl(typeParameter);
     typeParameter.type = typeParameterType;
     _currentHolder.addTypeParameter(typeParameter);
     parameterName.staticElement = typeParameter;
     return super.visitTypeParameter(node);
   }
 
   Object visitVariableDeclaration(VariableDeclaration node) {
     sc.Token keyword = (node.parent as VariableDeclarationList).keyword;
-    bool isConst = matches(keyword, sc.Keyword.CONST);
-    bool isFinal = matches(keyword, sc.Keyword.FINAL);
+    bool isConst = _matches(keyword, sc.Keyword.CONST);
+    bool isFinal = _matches(keyword, sc.Keyword.FINAL);
     bool hasInitializer = node.initializer != null;
     VariableElementImpl element;
     if (_inFieldContext) {
       SimpleIdentifier fieldName = node.name;
       FieldElementImpl field;
       if (isConst && hasInitializer) {
         field = new ConstFieldElementImpl(fieldName);
       } else {
         field = new FieldElementImpl.con1(fieldName);
       }
@@ skipping 28 matching lines @@
       _currentHolder.addTopLevelVariable(variable);
       variableName.staticElement = element;
     }
     element.const3 = isConst;
     element.final2 = isFinal;
     if (hasInitializer) {
       ElementHolder holder = new ElementHolder();
       bool wasInFieldContext = _inFieldContext;
       _inFieldContext = false;
       try {
-        visit(holder, node.initializer);
+        _visit(holder, node.initializer);
       } finally {
         _inFieldContext = wasInFieldContext;
       }
       FunctionElementImpl initializer = new FunctionElementImpl.con2(node.initializer.beginToken.offset);
       initializer.functions = holder.functions;
       initializer.labels = holder.labels;
       initializer.localVariables = holder.localVariables;
       initializer.synthetic = true;
       element.initializer = initializer;
       holder.validate();
     }
     if (element is PropertyInducingElementImpl) {
       PropertyInducingElementImpl variable = element as PropertyInducingElementImpl;
       if (_inFieldContext) {
-        (variable as FieldElementImpl).static = matches((node.parent.parent as FieldDeclaration).staticKeyword, sc.Keyword.STATIC);
+        (variable as FieldElementImpl).static = _matches((node.parent.parent as FieldDeclaration).staticKeyword, sc.Keyword.STATIC);
       }
       PropertyAccessorElementImpl getter = new PropertyAccessorElementImpl.con2(variable);
       getter.getter = true;
       getter.static = variable.isStatic;
       _currentHolder.addAccessor(getter);
       variable.getter = getter;
       if (!isFinal) {
         PropertyAccessorElementImpl setter = new PropertyAccessorElementImpl.con2(variable);
         setter.setter = true;
         setter.static = variable.isStatic;
         ParameterElementImpl parameter = new ParameterElementImpl.con2("_${variable.name}", variable.nameOffset);
         parameter.synthetic = true;
         parameter.parameterKind = ParameterKind.REQUIRED;
         setter.parameters = <ParameterElement> [parameter];
         _currentHolder.addAccessor(setter);
         variable.setter = setter;
       }
     }
     return null;
   }
 
   /**
    * Build the table mapping field names to field elements for the fields defined in the current
    * class.
    *
    * @param fields the field elements defined in the current class
    */
-  void buildFieldMap(List<FieldElement> fields) {
+  void _buildFieldMap(List<FieldElement> fields) {
     _fieldMap = new Map<String, FieldElement>();
     int count = fields.length;
     for (int i = 0; i < count; i++) {
       FieldElement field = fields[i];
       _fieldMap[field.name] = field;
     }
   }
 
   /**
    * Creates the [ConstructorElement]s array with the single default constructor element.
    *
    * @param interfaceType the interface type for which to create a default constructor
    * @return the [ConstructorElement]s array with the single default constructor element
    */
-  List<ConstructorElement> createDefaultConstructors(InterfaceTypeImpl interfaceType) {
+  List<ConstructorElement> _createDefaultConstructors(InterfaceTypeImpl interfaceType) {
     ConstructorElementImpl constructor = new ConstructorElementImpl.con1(null);
     constructor.synthetic = true;
     constructor.returnType = interfaceType;
     FunctionTypeImpl type = new FunctionTypeImpl.con1(constructor);
     _functionTypesToFix.add(type);
     constructor.type = type;
     return <ConstructorElement> [constructor];
   }
 
   /**
    * Create the types associated with the given type parameters, setting the type of each type
    * parameter, and return an array of types corresponding to the given parameters.
    *
    * @param typeParameters the type parameters for which types are to be created
    * @return an array of types corresponding to the given parameters
    */
-  List<Type2> createTypeParameterTypes(List<TypeParameterElement> typeParameters) {
+  List<Type2> _createTypeParameterTypes(List<TypeParameterElement> typeParameters) {
     int typeParameterCount = typeParameters.length;
     List<Type2> typeArguments = new List<Type2>(typeParameterCount);
     for (int i = 0; i < typeParameterCount; i++) {
       TypeParameterElementImpl typeParameter = typeParameters[i] as TypeParameterElementImpl;
       TypeParameterTypeImpl typeParameterType = new TypeParameterTypeImpl(typeParameter);
       typeParameter.type = typeParameterType;
       typeArguments[i] = typeParameterType;
     }
     return typeArguments;
   }
 
   /**
    * Return the body of the function that contains the given parameter, or `null` if no
    * function body could be found.
    *
    * @param node the parameter contained in the function whose body is to be returned
    * @return the body of the function that contains the given parameter
    */
-  FunctionBody getFunctionBody(FormalParameter node) {
+  FunctionBody _getFunctionBody(FormalParameter node) {
     AstNode parent = node.parent;
     while (parent != null) {
       if (parent is ConstructorDeclaration) {
         return (parent as ConstructorDeclaration).body;
       } else if (parent is FunctionExpression) {
         return (parent as FunctionExpression).body;
       } else if (parent is MethodDeclaration) {
         return (parent as MethodDeclaration).body;
       }
       parent = parent.parent;
     }
     return null;
   }
 
   /**
    * Return `true` if the given token is a token for the given keyword.
    *
    * @param token the token being tested
    * @param keyword the keyword being tested for
    * @return `true` if the given token is a token for the given keyword
    */
-  bool matches(sc.Token token, sc.Keyword keyword) => token != null && identical(token.type, sc.TokenType.KEYWORD) && identical((token as sc.KeywordToken).keyword, keyword);
+  bool _matches(sc.Token token, sc.Keyword keyword) => token != null && identical(token.type, sc.TokenType.KEYWORD) && identical((token as sc.KeywordToken).keyword, keyword);
 
   /**
    * Sets the visible source range for formal parameter.
    */
-  void setParameterVisibleRange(FormalParameter node, ParameterElementImpl element) {
-    FunctionBody body = getFunctionBody(node);
+  void _setParameterVisibleRange(FormalParameter node, ParameterElementImpl element) {
+    FunctionBody body = _getFunctionBody(node);
     if (body != null) {
       element.setVisibleRange(body.offset, body.length);
     }
   }
 
   /**
    * Make the given holder be the current holder while visiting the given node.
    *
    * @param holder the holder that will gather elements that are built while visiting the children
    * @param node the node to be visited
    */
-  void visit(ElementHolder holder, AstNode node) {
+  void _visit(ElementHolder holder, AstNode node) {
     if (node != null) {
       ElementHolder previousHolder = _currentHolder;
       _currentHolder = holder;
       try {
         node.accept(this);
       } finally {
         _currentHolder = previousHolder;
       }
     }
   }
 
   /**
    * Make the given holder be the current holder while visiting the children of the given node.
    *
    * @param holder the holder that will gather elements that are built while visiting the children
    * @param node the node whose children are to be visited
    */
-  void visitChildren(ElementHolder holder, AstNode node) {
+  void _visitChildren(ElementHolder holder, AstNode node) {
     if (node != null) {
       ElementHolder previousHolder = _currentHolder;
       _currentHolder = holder;
       try {
         node.visitChildren(this);
       } finally {
         _currentHolder = previousHolder;
       }
     }
   }
@@ skipping 441 matching lines @@
 
   /**
    * Return an array containing information about all of the libraries that were resolved.
    *
    * @return an array containing the libraries that were resolved
    */
   Set<Library> get resolvedLibraries => _resolvedLibraries;
 
   Object visitHtmlScriptTagNode(ht.HtmlScriptTagNode node) {
     if (_parentNodes.contains(node)) {
-      return reportCircularity(node);
+      return _reportCircularity(node);
     }
     _parentNodes.add(node);
     try {
       Source htmlSource = _htmlElement.source;
-      ht.XmlAttributeNode scriptAttribute = getScriptSourcePath(node);
+      ht.XmlAttributeNode scriptAttribute = _getScriptSourcePath(node);
       String scriptSourcePath = scriptAttribute == null ? null : scriptAttribute.text;
       if (identical(node.attributeEnd.type, ht.TokenType.GT) && scriptSourcePath == null) {
         EmbeddedHtmlScriptElementImpl script = new EmbeddedHtmlScriptElementImpl(node);
         try {
           LibraryResolver resolver = new LibraryResolver(_context);
           LibraryElementImpl library = resolver.resolveEmbeddedLibrary(htmlSource, _modificationStamp, node.script, true) as LibraryElementImpl;
           script.scriptLibrary = library;
           _resolvedLibraries.addAll(resolver.resolvedLibraries);
           _errorListener.addAll(resolver.errorListener);
         } on AnalysisException catch (exception) {
           //TODO (danrubel): Handle or forward the exception
           AnalysisEngine.instance.logger.logError2("Could not resolve script tag", exception);
         }
         node.scriptElement = script;
         _scripts.add(script);
       } else {
         ExternalHtmlScriptElementImpl script = new ExternalHtmlScriptElementImpl(node);
         if (scriptSourcePath != null) {
           try {
             scriptSourcePath = Uri.encodeFull(scriptSourcePath);
             // Force an exception to be thrown if the URI is invalid so that we can report the
             // problem.
             parseUriWithException(scriptSourcePath);
             Source scriptSource = _context.sourceFactory.resolveUri(htmlSource, scriptSourcePath);
             script.scriptSource = scriptSource;
             if (!_context.exists(scriptSource)) {
-              reportValueError(HtmlWarningCode.URI_DOES_NOT_EXIST, scriptAttribute, [scriptSourcePath]);
+              _reportValueError(HtmlWarningCode.URI_DOES_NOT_EXIST, scriptAttribute, [scriptSourcePath]);
             }
           } on URISyntaxException catch (exception) {
-            reportValueError(HtmlWarningCode.INVALID_URI, scriptAttribute, [scriptSourcePath]);
+            _reportValueError(HtmlWarningCode.INVALID_URI, scriptAttribute, [scriptSourcePath]);
           }
         }
         node.scriptElement = script;
         _scripts.add(script);
       }
     } finally {
       _parentNodes.remove(node);
     }
     return null;
   }
 
   Object visitHtmlUnit(ht.HtmlUnit node) {
     _parentNodes = new List<ht.XmlTagNode>();
     _scripts = new List<HtmlScriptElement>();
     try {
       node.visitChildren(this);
       _htmlElement.scripts = new List.from(_scripts);
     } finally {
       _scripts = null;
       _parentNodes = null;
     }
     return null;
   }
 
   Object visitXmlAttributeNode(ht.XmlAttributeNode node) => null;
 
   Object visitXmlTagNode(ht.XmlTagNode node) {
     if (_parentNodes.contains(node)) {
-      return reportCircularity(node);
+      return _reportCircularity(node);
     }
     _parentNodes.add(node);
     try {
       node.visitChildren(this);
     } finally {
       _parentNodes.remove(node);
     }
     return null;
   }
 
   /**
    * Return the first source attribute for the given tag node, or `null` if it does not exist.
    *
    * @param node the node containing attributes
    * @return the source attribute contained in the given tag
    */
-  ht.XmlAttributeNode getScriptSourcePath(ht.XmlTagNode node) {
+  ht.XmlAttributeNode _getScriptSourcePath(ht.XmlTagNode node) {
     for (ht.XmlAttributeNode attribute in node.attributes) {
       if (attribute.name == _SRC) {
         return attribute;
       }
     }
     return null;
   }
 
-  Object reportCircularity(ht.XmlTagNode node) {
+  Object _reportCircularity(ht.XmlTagNode node) {
     //
     // This should not be possible, but we have an error report that suggests that it happened at
     // least once. This code will guard against infinite recursion and might help us identify the
     // cause of the issue.
     //
     JavaStringBuilder builder = new JavaStringBuilder();
     builder.append("Found circularity in XML nodes: ");
     bool first = true;
     for (ht.XmlTagNode pathNode in _parentNodes) {
       if (first) {
@@ skipping 16 matching lines @@
 
   /**
    * Report an error with the given error code at the given location. Use the given arguments to
    * compose the error message.
    *
    * @param errorCode the error code of the error to be reported
    * @param offset the offset of the first character to be highlighted
    * @param length the number of characters to be highlighted
    * @param arguments the arguments used to compose the error message
    */
-  void reportErrorForOffset(ErrorCode errorCode, int offset, int length, List<Object> arguments) {
+  void _reportErrorForOffset(ErrorCode errorCode, int offset, int length, List<Object> arguments) {
     _errorListener.onError(new AnalysisError.con2(_htmlElement.source, offset, length, errorCode, arguments));
   }
 
   /**
    * Report an error with the given error code at the location of the value of the given attribute.
    * Use the given arguments to compose the error message.
    *
    * @param errorCode the error code of the error to be reported
    * @param offset the offset of the first character to be highlighted
    * @param length the number of characters to be highlighted
    * @param arguments the arguments used to compose the error message
    */
-  void reportValueError(ErrorCode errorCode, ht.XmlAttributeNode attribute, List<Object> arguments) {
+  void _reportValueError(ErrorCode errorCode, ht.XmlAttributeNode attribute, List<Object> arguments) {
     int offset = attribute.valueToken.offset + 1;
     int length = attribute.valueToken.length - 2;
-    reportErrorForOffset(errorCode, offset, length, arguments);
+    _reportErrorForOffset(errorCode, offset, length, arguments);
   }
 }
 
 /**
  * Instances of the class `BestPracticesVerifier` traverse an AST structure looking for
  * violations of Dart best practices.
  */
 class BestPracticesVerifier extends RecursiveAstVisitor<Object> {
   static String _GETTER = "getter";
 
@@ skipping 11 matching lines @@
    * Given a parenthesized expression, this returns the parent (or recursively grand-parent) of the
    * expression that is a parenthesized expression, but whose parent is not a parenthesized
    * expression.
    *
    * For example given the code `(((e)))`: `(e) -> (((e)))`.
    *
    * @param parenthesizedExpression some expression whose parent is a parenthesized expression
    * @return the first parent or grand-parent that is a parenthesized expression, that does not have
    *         a parenthesized expression parent
    */
-  static ParenthesizedExpression wrapParenthesizedExpression(ParenthesizedExpression parenthesizedExpression) {
+  static ParenthesizedExpression _wrapParenthesizedExpression(ParenthesizedExpression parenthesizedExpression) {
     if (parenthesizedExpression.parent is ParenthesizedExpression) {
-      return wrapParenthesizedExpression(parenthesizedExpression.parent as ParenthesizedExpression);
+      return _wrapParenthesizedExpression(parenthesizedExpression.parent as ParenthesizedExpression);
     }
     return parenthesizedExpression;
   }
 
   /**
    * The class containing the AST nodes being visited, or `null` if we are not in the scope of
    * a class.
    */
   ClassElement _enclosingClass;
 
   /**
    * The error reporter by which errors will be reported.
    */
   ErrorReporter _errorReporter;
 
   /**
    * Create a new instance of the [BestPracticesVerifier].
    *
    * @param errorReporter the error reporter
    */
   BestPracticesVerifier(ErrorReporter errorReporter) {
     this._errorReporter = errorReporter;
   }
 
   Object visitAsExpression(AsExpression node) {
-    checkForUnnecessaryCast(node);
+    _checkForUnnecessaryCast(node);
     return super.visitAsExpression(node);
   }
 
   Object visitAssignmentExpression(AssignmentExpression node) {
     sc.TokenType operatorType = node.operator.type;
     if (operatorType != sc.TokenType.EQ) {
-      checkForDeprecatedMemberUse(node.bestElement, node);
+      _checkForDeprecatedMemberUse(node.bestElement, node);
     } else {
-      checkForUseOfVoidResult(node.rightHandSide);
+      _checkForUseOfVoidResult(node.rightHandSide);
     }
     return super.visitAssignmentExpression(node);
   }
 
   Object visitBinaryExpression(BinaryExpression node) {
-    checkForDivisionOptimizationHint(node);
-    checkForDeprecatedMemberUse(node.bestElement, node);
+    _checkForDivisionOptimizationHint(node);
+    _checkForDeprecatedMemberUse(node.bestElement, node);
     return super.visitBinaryExpression(node);
   }
 
   Object visitClassDeclaration(ClassDeclaration node) {
     ClassElement outerClass = _enclosingClass;
     try {
       _enclosingClass = node.element;
       // Commented out until we decide that we want this hint in the analyzer
       //    checkForOverrideEqualsButNotHashCode(node);
       return super.visitClassDeclaration(node);
     } finally {
       _enclosingClass = outerClass;
     }
   }
 
   Object visitExportDirective(ExportDirective node) {
-    checkForDeprecatedMemberUse(node.uriElement, node);
+    _checkForDeprecatedMemberUse(node.uriElement, node);
     return super.visitExportDirective(node);
   }
 
   Object visitFunctionDeclaration(FunctionDeclaration node) {
-    checkForMissingReturn(node.returnType, node.functionExpression.body);
+    _checkForMissingReturn(node.returnType, node.functionExpression.body);
     return super.visitFunctionDeclaration(node);
   }
 
   Object visitImportDirective(ImportDirective node) {
-    checkForDeprecatedMemberUse(node.uriElement, node);
+    _checkForDeprecatedMemberUse(node.uriElement, node);
     return super.visitImportDirective(node);
   }
 
   Object visitIndexExpression(IndexExpression node) {
-    checkForDeprecatedMemberUse(node.bestElement, node);
+    _checkForDeprecatedMemberUse(node.bestElement, node);
     return super.visitIndexExpression(node);
   }
 
   Object visitInstanceCreationExpression(InstanceCreationExpression node) {
-    checkForDeprecatedMemberUse(node.staticElement, node);
+    _checkForDeprecatedMemberUse(node.staticElement, node);
     return super.visitInstanceCreationExpression(node);
   }
 
   Object visitIsExpression(IsExpression node) {
-    checkAllTypeChecks(node);
+    _checkAllTypeChecks(node);
     return super.visitIsExpression(node);
   }
 
   Object visitMethodDeclaration(MethodDeclaration node) {
     // This was determined to not be a good hint, see: dartbug.com/16029
     //checkForOverridingPrivateMember(node);
-    checkForMissingReturn(node.returnType, node.body);
+    _checkForMissingReturn(node.returnType, node.body);
     return super.visitMethodDeclaration(node);
   }
 
   Object visitPostfixExpression(PostfixExpression node) {
-    checkForDeprecatedMemberUse(node.bestElement, node);
+    _checkForDeprecatedMemberUse(node.bestElement, node);
     return super.visitPostfixExpression(node);
   }
 
   Object visitPrefixExpression(PrefixExpression node) {
-    checkForDeprecatedMemberUse(node.bestElement, node);
+    _checkForDeprecatedMemberUse(node.bestElement, node);
     return super.visitPrefixExpression(node);
   }
 
   Object visitRedirectingConstructorInvocation(RedirectingConstructorInvocation node) {
-    checkForDeprecatedMemberUse(node.staticElement, node);
+    _checkForDeprecatedMemberUse(node.staticElement, node);
     return super.visitRedirectingConstructorInvocation(node);
   }
 
   Object visitSimpleIdentifier(SimpleIdentifier node) {
-    checkForDeprecatedMemberUseAtIdentifier(node);
+    _checkForDeprecatedMemberUseAtIdentifier(node);
     return super.visitSimpleIdentifier(node);
   }
 
   Object visitSuperConstructorInvocation(SuperConstructorInvocation node) {
-    checkForDeprecatedMemberUse(node.staticElement, node);
+    _checkForDeprecatedMemberUse(node.staticElement, node);
     return super.visitSuperConstructorInvocation(node);
   }
 
   Object visitVariableDeclaration(VariableDeclaration node) {
-    checkForUseOfVoidResult(node.initializer);
+    _checkForUseOfVoidResult(node.initializer);
     return super.visitVariableDeclaration(node);
   }
 
   /**
    * Check for the passed is expression for the unnecessary type check hint codes as well as null
    * checks expressed using an is expression.
    *
    * @param node the is expression to check
    * @return `true` if and only if a hint code is generated on the passed node
    * @see HintCode#TYPE_CHECK_IS_NOT_NULL
    * @see HintCode#TYPE_CHECK_IS_NULL
    * @see HintCode#UNNECESSARY_TYPE_CHECK_TRUE
    * @see HintCode#UNNECESSARY_TYPE_CHECK_FALSE
    */
-  bool checkAllTypeChecks(IsExpression node) {
+  bool _checkAllTypeChecks(IsExpression node) {
     Expression expression = node.expression;
     TypeName typeName = node.type;
     Type2 lhsType = expression.staticType;
     Type2 rhsType = typeName.type;
     if (lhsType == null || rhsType == null) {
       return false;
     }
     String rhsNameStr = typeName.name.name;
     // if x is dynamic
     if (rhsType.isDynamic && rhsNameStr == sc.Keyword.DYNAMIC.syntax) {
@@ skipping 35 matching lines @@
 
   /**
    * Given some [Element], look at the associated metadata and report the use of the member if
    * it is declared as deprecated.
    *
    * @param element some element to check for deprecated use of
    * @param node the node use for the location of the error
    * @return `true` if and only if a hint code is generated on the passed node
    * @see HintCode#DEPRECATED_MEMBER_USE
    */
-  bool checkForDeprecatedMemberUse(Element element, AstNode node) {
+  bool _checkForDeprecatedMemberUse(Element element, AstNode node) {
     if (element != null && element.isDeprecated) {
       String displayName = element.displayName;
       if (element is ConstructorElement) {
         // TODO(jwren) We should modify ConstructorElement.getDisplayName(), or have the logic
         // centralized elsewhere, instead of doing this logic here.
         ConstructorElement constructorElement = element;
         displayName = constructorElement.enclosingElement.displayName;
         if (!constructorElement.displayName.isEmpty) {
           displayName = "${displayName}.${constructorElement.displayName}";
         }
@@ skipping 11 matching lines @@
    * Also, if the identifier is a constructor name in a constructor invocation, then calls to the
    * deprecated constructor will be caught by
    * [visitInstanceCreationExpression] and
    * [visitSuperConstructorInvocation], and can be ignored by
    * this visit method.
    *
    * @param identifier some simple identifier to check for deprecated use of
    * @return `true` if and only if a hint code is generated on the passed node
    * @see HintCode#DEPRECATED_MEMBER_USE
    */
-  bool checkForDeprecatedMemberUseAtIdentifier(SimpleIdentifier identifier) {
+  bool _checkForDeprecatedMemberUseAtIdentifier(SimpleIdentifier identifier) {
     if (identifier.inDeclarationContext()) {
       return false;
     }
     AstNode parent = identifier.parent;
     if ((parent is ConstructorName && identical(identifier, parent.name)) || (parent is SuperConstructorInvocation && identical(identifier, parent.constructorName)) || parent is HideCombinator) {
       return false;
     }
-    return checkForDeprecatedMemberUse(identifier.bestElement, identifier);
+    return _checkForDeprecatedMemberUse(identifier.bestElement, identifier);
   }
 
   /**
    * Check for the passed binary expression for the [HintCode#DIVISION_OPTIMIZATION].
    *
    * @param node the binary expression to check
    * @return `true` if and only if a hint code is generated on the passed node
    * @see HintCode#DIVISION_OPTIMIZATION
    */
-  bool checkForDivisionOptimizationHint(BinaryExpression node) {
+  bool _checkForDivisionOptimizationHint(BinaryExpression node) {
     // Return if the operator is not '/'
     if (node.operator.type != sc.TokenType.SLASH) {
       return false;
     }
     // Return if the '/' operator is not defined in core, or if we don't know its static or propagated type
     MethodElement methodElement = node.bestElement;
     if (methodElement == null) {
       return false;
     }
     LibraryElement libraryElement = methodElement.library;
     if (libraryElement != null && !libraryElement.isDartCore) {
       return false;
     }
     // Report error if the (x/y) has toInt() invoked on it
     if (node.parent is ParenthesizedExpression) {
-      ParenthesizedExpression parenthesizedExpression = wrapParenthesizedExpression(node.parent as ParenthesizedExpression);
+      ParenthesizedExpression parenthesizedExpression = _wrapParenthesizedExpression(node.parent as ParenthesizedExpression);
       if (parenthesizedExpression.parent is MethodInvocation) {
         MethodInvocation methodInvocation = parenthesizedExpression.parent as MethodInvocation;
         if (_TO_INT_METHOD_NAME == methodInvocation.methodName.name && methodInvocation.argumentList.arguments.isEmpty) {
           _errorReporter.reportErrorForNode(HintCode.DIVISION_OPTIMIZATION, methodInvocation, []);
           return true;
         }
       }
     }
     return false;
   }
 
   /**
    * Generate a hint for functions or methods that have a return type, but do not have a return
    * statement on all branches. At the end of blocks with no return, Dart implicitly returns
    * `null`, avoiding these implicit returns is considered a best practice.
    *
    * @param node the binary expression to check
    * @param body the function body
    * @return `true` if and only if a hint code is generated on the passed node
    * @see HintCode#MISSING_RETURN
    */
-  bool checkForMissingReturn(TypeName returnType, FunctionBody body) {
+  bool _checkForMissingReturn(TypeName returnType, FunctionBody body) {
     // Check that the method or function has a return type, and a function body
     if (returnType == null || body == null) {
       return false;
     }
     // Check that the body is a BlockFunctionBody
     if (body is! BlockFunctionBody) {
       return false;
     }
     // Check that the type is resolvable, and is not "void"
     Type2 returnTypeType = returnType.type;
@@ skipping 10 matching lines @@
   }
 
   /**
    * Check for the passed class declaration for the
    * [HintCode#OVERRIDE_EQUALS_BUT_NOT_HASH_CODE] hint code.
    *
    * @param node the class declaration to check
    * @return `true` if and only if a hint code is generated on the passed node
    * @see HintCode#OVERRIDE_EQUALS_BUT_NOT_HASH_CODE
    */
-  bool checkForOverrideEqualsButNotHashCode(ClassDeclaration node) {
+  bool _checkForOverrideEqualsButNotHashCode(ClassDeclaration node) {
     ClassElement classElement = node.element;
     if (classElement == null) {
       return false;
     }
     MethodElement equalsOperatorMethodElement = classElement.getMethod(sc.TokenType.EQ_EQ.lexeme);
     if (equalsOperatorMethodElement != null) {
       PropertyAccessorElement hashCodeElement = classElement.getGetter(_HASHCODE_GETTER_NAME);
       if (hashCodeElement == null) {
         _errorReporter.reportErrorForNode(HintCode.OVERRIDE_EQUALS_BUT_NOT_HASH_CODE, node.name, [classElement.displayName]);
         return true;
       }
     }
     return false;
   }
 
   /**
    * Checks that if the passed method declaration is private, it does not override a private member
    * in a superclass.
    *
    * @param node the method declaration to check
    * @return `true` if and only if a hint code is generated on the passed node
    * @see HintCode#OVERRIDDING_PRIVATE_MEMBER
    */
-  bool checkForOverridingPrivateMember(MethodDeclaration node) {
+  bool _checkForOverridingPrivateMember(MethodDeclaration node) {
     // If not in an enclosing class, return false
     if (_enclosingClass == null) {
       return false;
     }
     // If the member is not private, return false
     if (!Identifier.isPrivateName(node.name.name)) {
       return false;
     }
     // Get the element of the member, if null, return false
     ExecutableElement executableElement = node.element;
@@ skipping 47 matching lines @@
     return false;
   }
 
   /**
    * Check for the passed as expression for the [HintCode#UNNECESSARY_CAST] hint code.
    *
    * @param node the as expression to check
    * @return `true` if and only if a hint code is generated on the passed node
    * @see HintCode#UNNECESSARY_CAST
    */
-  bool checkForUnnecessaryCast(AsExpression node) {
+  bool _checkForUnnecessaryCast(AsExpression node) {
     Expression expression = node.expression;
     TypeName typeName = node.type;
     Type2 lhsType = expression.staticType;
     Type2 rhsType = typeName.type;
     // TODO(jwren) After dartbug.com/13732, revisit this, we should be able to remove the
     // !(x instanceof TypeParameterType) checks.
     if (lhsType != null && rhsType != null && !lhsType.isDynamic && !rhsType.isDynamic && lhsType is! TypeParameterType && rhsType is! TypeParameterType && lhsType.isSubtypeOf(rhsType)) {
       _errorReporter.reportErrorForNode(HintCode.UNNECESSARY_CAST, node, []);
       return true;
     }
     return false;
   }
 
   /**
    * Check for situations where the result of a method or function is used, when it returns 'void'.
    *
    * TODO(jwren) Many other situations of use could be covered. We currently cover the cases var x =
    * m() and x = m(), but we could also cover cases such as m().x, m()[k], a + m(), f(m()), return
    * m().
    *
    * @param node expression on the RHS of some assignment
    * @return `true` if and only if a hint code is generated on the passed node
    * @see HintCode#USE_OF_VOID_RESULT
    */
-  bool checkForUseOfVoidResult(Expression expression) {
+  bool _checkForUseOfVoidResult(Expression expression) {
     if (expression == null || expression is! MethodInvocation) {
       return false;
     }
     MethodInvocation methodInvocation = expression as MethodInvocation;
     if (identical(methodInvocation.staticType, VoidTypeImpl.instance)) {
       SimpleIdentifier methodName = methodInvocation.methodName;
       _errorReporter.reportErrorForNode(HintCode.USE_OF_VOID_RESULT, methodName, [methodName.name]);
       return true;
     }
     return false;
@@ skipping 18 matching lines @@
   /**
    * Create a new instance of the [Dart2JSVerifier].
    *
    * @param errorReporter the error reporter
    */
   Dart2JSVerifier(ErrorReporter errorReporter) {
     this._errorReporter = errorReporter;
   }
 
   Object visitIsExpression(IsExpression node) {
-    checkForIsDoubleHints(node);
+    _checkForIsDoubleHints(node);
     return super.visitIsExpression(node);
   }
 
   /**
    * Check for instances of `x is double`, `x is int`, `x is! double` and
    * `x is! int`.
    *
    * @param node the is expression to check
    * @return `true` if and only if a hint code is generated on the passed node
    * @see HintCode#IS_DOUBLE
    * @see HintCode#IS_INT
    * @see HintCode#IS_NOT_DOUBLE
    * @see HintCode#IS_NOT_INT
    */
-  bool checkForIsDoubleHints(IsExpression node) {
+  bool _checkForIsDoubleHints(IsExpression node) {
     TypeName typeName = node.type;
     Type2 type = typeName.type;
     if (type != null && type.element != null) {
       Element element = type.element;
       String typeNameStr = element.name;
       LibraryElement libraryElement = element.library;
       //      if (typeNameStr.equals(INT_TYPE_NAME) && libraryElement != null
       //          && libraryElement.isDartCore()) {
       //        if (node.getNotOperator() == null) {
       //          errorReporter.reportError(HintCode.IS_INT, node);
@@ skipping 33 matching lines @@
   DeadCodeVerifier(ErrorReporter errorReporter) {
     this._errorReporter = errorReporter;
   }
 
   Object visitBinaryExpression(BinaryExpression node) {
     sc.Token operator = node.operator;
     bool isAmpAmp = identical(operator.type, sc.TokenType.AMPERSAND_AMPERSAND);
     bool isBarBar = identical(operator.type, sc.TokenType.BAR_BAR);
     if (isAmpAmp || isBarBar) {
       Expression lhsCondition = node.leftOperand;
-      if (!isDebugConstant(lhsCondition)) {
-        ValidResult lhsResult = getConstantBooleanValue(lhsCondition);
+      if (!_isDebugConstant(lhsCondition)) {
+        ValidResult lhsResult = _getConstantBooleanValue(lhsCondition);
         if (lhsResult != null) {
           if (lhsResult.isTrue && isBarBar) {
             // report error on else block: true || !e!
             _errorReporter.reportErrorForNode(HintCode.DEAD_CODE, node.rightOperand, []);
             // only visit the LHS:
-            safelyVisit(lhsCondition);
+            _safelyVisit(lhsCondition);
             return null;
           } else if (lhsResult.isFalse && isAmpAmp) {
             // report error on if block: false && !e!
             _errorReporter.reportErrorForNode(HintCode.DEAD_CODE, node.rightOperand, []);
             // only visit the LHS:
-            safelyVisit(lhsCondition);
+            _safelyVisit(lhsCondition);
             return null;
           }
         }
       }
     }
     return super.visitBinaryExpression(node);
   }
 
   /**
    * For each [Block], this method reports and error on all statements between the end of the
    * block and the first return statement (assuming there it is not at the end of the block.)
    *
    * @param node the block to evaluate
    */
   Object visitBlock(Block node) {
     NodeList<Statement> statements = node.statements;
     int size = statements.length;
     for (int i = 0; i < size; i++) {
       Statement currentStatement = statements[i];
-      safelyVisit(currentStatement);
+      _safelyVisit(currentStatement);
       if (currentStatement is ReturnStatement && i != size - 1) {
         Statement nextStatement = statements[i + 1];
         Statement lastStatement = statements[size - 1];
         int offset = nextStatement.offset;
         int length = lastStatement.end - offset;
         _errorReporter.reportErrorForOffset(HintCode.DEAD_CODE, offset, length, []);
         return null;
       }
     }
     return null;
   }
 
   Object visitConditionalExpression(ConditionalExpression node) {
     Expression conditionExpression = node.condition;
-    safelyVisit(conditionExpression);
-    if (!isDebugConstant(conditionExpression)) {
-      ValidResult result = getConstantBooleanValue(conditionExpression);
+    _safelyVisit(conditionExpression);
+    if (!_isDebugConstant(conditionExpression)) {
+      ValidResult result = _getConstantBooleanValue(conditionExpression);
       if (result != null) {
         if (result.isTrue) {
           // report error on else block: true ? 1 : !2!
           _errorReporter.reportErrorForNode(HintCode.DEAD_CODE, node.elseExpression, []);
-          safelyVisit(node.thenExpression);
+          _safelyVisit(node.thenExpression);
           return null;
         } else {
           // report error on if block: false ? !1! : 2
           _errorReporter.reportErrorForNode(HintCode.DEAD_CODE, node.thenExpression, []);
-          safelyVisit(node.elseExpression);
+          _safelyVisit(node.elseExpression);
           return null;
         }
       }
     }
     return super.visitConditionalExpression(node);
   }
 
   Object visitIfStatement(IfStatement node) {
     Expression conditionExpression = node.condition;
-    safelyVisit(conditionExpression);
-    if (!isDebugConstant(conditionExpression)) {
-      ValidResult result = getConstantBooleanValue(conditionExpression);
+    _safelyVisit(conditionExpression);
+    if (!_isDebugConstant(conditionExpression)) {
+      ValidResult result = _getConstantBooleanValue(conditionExpression);
       if (result != null) {
         if (result.isTrue) {
           // report error on else block: if(true) {} else {!}
           Statement elseStatement = node.elseStatement;
           if (elseStatement != null) {
             _errorReporter.reportErrorForNode(HintCode.DEAD_CODE, elseStatement, []);
-            safelyVisit(node.thenStatement);
+            _safelyVisit(node.thenStatement);
             return null;
           }
         } else {
           // report error on if block: if (false) {!} else {}
           _errorReporter.reportErrorForNode(HintCode.DEAD_CODE, node.thenStatement, []);
-          safelyVisit(node.elseStatement);
+          _safelyVisit(node.elseStatement);
           return null;
         }
       }
     }
     return super.visitIfStatement(node);
   }
 
   Object visitTryStatement(TryStatement node) {
-    safelyVisit(node.body);
-    safelyVisit(node.finallyBlock);
+    _safelyVisit(node.body);
+    _safelyVisit(node.finallyBlock);
     NodeList<CatchClause> catchClauses = node.catchClauses;
     int numOfCatchClauses = catchClauses.length;
     List<Type2> visitedTypes = new List<Type2>();
     for (int i = 0; i < numOfCatchClauses; i++) {
       CatchClause catchClause = catchClauses[i];
       if (catchClause.onKeyword != null) {
         // on-catch clause found, verify that the exception type is not a subtype of a previous
         // on-catch exception type
         TypeName typeName = catchClause.exceptionType;
         if (typeName != null && typeName.type != null) {
           Type2 currentType = typeName.type;
           if (currentType.isObject) {
             // Found catch clause clause that has Object as an exception type, this is equivalent to
             // having a catch clause that doesn't have an exception type, visit the block, but
              // generate an error on any following catch clauses (and don't visit them).
-            safelyVisit(catchClause);
+            _safelyVisit(catchClause);
             if (i + 1 != numOfCatchClauses) {
                // this catch clause is not the last in the try statement
               CatchClause nextCatchClause = catchClauses[i + 1];
               CatchClause lastCatchClause = catchClauses[numOfCatchClauses - 1];
               int offset = nextCatchClause.offset;
               int length = lastCatchClause.end - offset;
               _errorReporter.reportErrorForOffset(HintCode.DEAD_CODE_CATCH_FOLLOWING_CATCH, offset, length, []);
               return null;
             }
           }
           for (Type2 type in visitedTypes) {
             if (currentType.isSubtypeOf(type)) {
               CatchClause lastCatchClause = catchClauses[numOfCatchClauses - 1];
               int offset = catchClause.offset;
               int length = lastCatchClause.end - offset;
               _errorReporter.reportErrorForOffset(HintCode.DEAD_CODE_ON_CATCH_SUBTYPE, offset, length, [currentType.displayName, type.displayName]);
               return null;
             }
           }
           visitedTypes.add(currentType);
         }
-        safelyVisit(catchClause);
+        _safelyVisit(catchClause);
       } else {
          // Found catch clause clause that doesn't have an exception type, visit the block, but
         // generate an error on any following catch clauses (and don't visit them).
-        safelyVisit(catchClause);
+        _safelyVisit(catchClause);
         if (i + 1 != numOfCatchClauses) {
           // this catch clause is not the last in the try statement
           CatchClause nextCatchClause = catchClauses[i + 1];
           CatchClause lastCatchClause = catchClauses[numOfCatchClauses - 1];
           int offset = nextCatchClause.offset;
           int length = lastCatchClause.end - offset;
           _errorReporter.reportErrorForOffset(HintCode.DEAD_CODE_CATCH_FOLLOWING_CATCH, offset, length, []);
           return null;
         }
       }
     }
     return null;
   }
 
   Object visitWhileStatement(WhileStatement node) {
     Expression conditionExpression = node.condition;
-    safelyVisit(conditionExpression);
-    if (!isDebugConstant(conditionExpression)) {
-      ValidResult result = getConstantBooleanValue(conditionExpression);
+    _safelyVisit(conditionExpression);
+    if (!_isDebugConstant(conditionExpression)) {
+      ValidResult result = _getConstantBooleanValue(conditionExpression);
       if (result != null) {
         if (result.isFalse) {
           // report error on if block: while (false) {!}
           _errorReporter.reportErrorForNode(HintCode.DEAD_CODE, node.body, []);
           return null;
         }
       }
     }
-    safelyVisit(node.body);
+    _safelyVisit(node.body);
     return null;
   }
 
   /**
    * Given some [Expression], this method returns [ValidResult#RESULT_TRUE] if it is
    * `true`, [ValidResult#RESULT_FALSE] if it is `false`, or `null` if the
    * expression is not a constant boolean value.
    *
    * @param expression the expression to evaluate
    * @return [ValidResult#RESULT_TRUE] if it is `true`, [ValidResult#RESULT_FALSE]
    *         if it is `false`, or `null` if the expression is not a constant boolean
    *         value
    */
-  ValidResult getConstantBooleanValue(Expression expression) {
+  ValidResult _getConstantBooleanValue(Expression expression) {
     if (expression is BooleanLiteral) {
       if (expression.value) {
         return new ValidResult(new DartObjectImpl(null, BoolState.from(true)));
       } else {
         return new ValidResult(new DartObjectImpl(null, BoolState.from(false)));
       }
     }
     // Don't consider situations where we could evaluate to a constant boolean expression with the
     // ConstantVisitor
 //
@@ skipping 16 matching lines @@
        // }
     return null;
   }
 
   /**
    * Return `true` if and only if the passed expression is resolved to a constant variable.
    *
    * @param expression some conditional expression
    * @return `true` if and only if the passed expression is resolved to a constant variable
    */
-  bool isDebugConstant(Expression expression) {
+  bool _isDebugConstant(Expression expression) {
     Element element = null;
     if (expression is Identifier) {
       Identifier identifier = expression;
       element = identifier.staticElement;
     } else if (expression is PropertyAccess) {
       PropertyAccess propertyAccess = expression;
       element = propertyAccess.propertyName.staticElement;
     }
     if (element is PropertyAccessorElement) {
       PropertyAccessorElement pae = element as PropertyAccessorElement;
       PropertyInducingElement variable = pae.variable;
       return variable != null && variable.isConst;
     }
     return false;
   }
 
   /**
    * If the given node is not `null`, visit this instance of the dead code verifier.
    *
    * @param node the node to be visited
    */
-  void safelyVisit(AstNode node) {
+  void _safelyVisit(AstNode node) {
     if (node != null) {
       node.accept(this);
     }
   }
 }
 
 /**
  * Instances of the class `ExitDetector` determine whether the visited AST node is guaranteed
  * to terminate by executing a `return` statement, `throw` expression, `rethrow`
  * expression, or simple infinite loop such as `while(true)`.
  */
 class ExitDetector extends GeneralizingAstVisitor<bool> {
   /**
    * Set to `true` when a `break` is encountered, and reset to `false` when a
    * `do`, `while`, `for` or `switch` block is entered.
    */
   bool _enclosingBlockContainsBreak = false;
 
-  bool visitArgumentList(ArgumentList node) => visitExpressions(node.arguments);
+  bool visitArgumentList(ArgumentList node) => _visitExpressions(node.arguments);
 
   bool visitAsExpression(AsExpression node) => node.expression.accept(this);
 
   bool visitAssertStatement(AssertStatement node) => node.condition.accept(this);
 
   bool visitAssignmentExpression(AssignmentExpression node) => node.leftHandSide.accept(this) || node.rightHandSide.accept(this);
 
   bool visitBinaryExpression(BinaryExpression node) {
     Expression lhsExpression = node.leftOperand;
     sc.TokenType operatorType = node.operator.type;
@@ skipping 15 matching lines @@
       if (lhsExpression is BooleanLiteral) {
         BooleanLiteral booleanLiteral = lhsExpression;
         if (booleanLiteral.value) {
           return false;
         }
       }
     }
     return lhsExpression.accept(this) || node.rightOperand.accept(this);
   }
 
-  bool visitBlock(Block node) => visitStatements(node.statements);
+  bool visitBlock(Block node) => _visitStatements(node.statements);
 
   bool visitBlockFunctionBody(BlockFunctionBody node) => node.block.accept(this);
 
   bool visitBreakStatement(BreakStatement node) {
     _enclosingBlockContainsBreak = true;
     return false;
   }
 
   bool visitCascadeExpression(CascadeExpression node) {
     Expression target = node.target;
     if (target.accept(this)) {
       return true;
     }
-    return visitExpressions(node.cascadeSections);
+    return _visitExpressions(node.cascadeSections);
   }
 
   bool visitConditionalExpression(ConditionalExpression node) {
     Expression conditionExpression = node.condition;
     Expression thenStatement = node.thenExpression;
     Expression elseStatement = node.elseExpression;
     // TODO(jwren) Do we want to take constant expressions into account, evaluate if(false) {}
     // differently than if(<condition>), when <condition> evaluates to a constant false value?
     if (conditionExpression.accept(this)) {
       return true;
@@ skipping 41 matching lines @@
       return node.iterator.accept(this);
     } finally {
       _enclosingBlockContainsBreak = outerBreakValue;
     }
   }
 
   bool visitForStatement(ForStatement node) {
     bool outerBreakValue = _enclosingBlockContainsBreak;
     _enclosingBlockContainsBreak = false;
     try {
-      if (node.variables != null && visitVariableDeclarations(node.variables.variables)) {
+      if (node.variables != null && _visitVariableDeclarations(node.variables.variables)) {
         return true;
       }
       if (node.initialization != null && node.initialization.accept(this)) {
         return true;
       }
       Expression conditionExpression = node.condition;
       if (conditionExpression != null && conditionExpression.accept(this)) {
         return true;
       }
-      if (visitExpressions(node.updaters)) {
+      if (_visitExpressions(node.updaters)) {
         return true;
       }
       // TODO(jwren) Do we want to take all constant expressions into account?
       // If for(; true; ) (or for(;;)), and the body doesn't return or the body doesn't have a
       // break, then return true.
       bool implicitOrExplictTrue = conditionExpression == null || (conditionExpression is BooleanLiteral && conditionExpression.value);
       if (implicitOrExplictTrue) {
         bool blockReturns = node.body.accept(this);
         if (blockReturns || !_enclosingBlockContainsBreak) {
           return true;
@@ skipping 86 matching lines @@
     }
     return false;
   }
 
   bool visitRethrowExpression(RethrowExpression node) => true;
 
   bool visitReturnStatement(ReturnStatement node) => true;
 
   bool visitSuperExpression(SuperExpression node) => false;
 
-  bool visitSwitchCase(SwitchCase node) => visitStatements(node.statements);
+  bool visitSwitchCase(SwitchCase node) => _visitStatements(node.statements);
 
-  bool visitSwitchDefault(SwitchDefault node) => visitStatements(node.statements);
+  bool visitSwitchDefault(SwitchDefault node) => _visitStatements(node.statements);
 
   bool visitSwitchStatement(SwitchStatement node) {
     bool outerBreakValue = _enclosingBlockContainsBreak;
     _enclosingBlockContainsBreak = false;
     try {
       bool hasDefault = false;
       NodeList<SwitchMember> memberList = node.members;
       List<SwitchMember> members = new List.from(memberList);
       for (int i = 0; i < members.length; i++) {
         SwitchMember switchMember = members[i];
@@ skipping 34 matching lines @@
   bool visitTypeName(TypeName node) => false;
 
   bool visitVariableDeclaration(VariableDeclaration node) {
     Expression initializer = node.initializer;
     if (initializer != null) {
       return initializer.accept(this);
     }
     return false;
   }
 
-  bool visitVariableDeclarationList(VariableDeclarationList node) => visitVariableDeclarations(node.variables);
+  bool visitVariableDeclarationList(VariableDeclarationList node) => _visitVariableDeclarations(node.variables);
 
   bool visitVariableDeclarationStatement(VariableDeclarationStatement node) {
     NodeList<VariableDeclaration> variables = node.variables.variables;
     for (int i = 0; i < variables.length; i++) {
       if (variables[i].accept(this)) {
         return true;
       }
     }
     return false;
   }
@@ skipping 15 matching lines @@
         if (booleanLiteral.value && (blockReturns || !_enclosingBlockContainsBreak)) {
           return true;
         }
       }
       return false;
     } finally {
       _enclosingBlockContainsBreak = outerBreakValue;
     }
   }
 
-  bool visitExpressions(NodeList<Expression> expressions) {
+  bool _visitExpressions(NodeList<Expression> expressions) {
     for (int i = expressions.length - 1; i >= 0; i--) {
       if (expressions[i].accept(this)) {
         return true;
       }
     }
     return false;
   }
 
-  bool visitStatements(NodeList<Statement> statements) {
+  bool _visitStatements(NodeList<Statement> statements) {
     for (int i = statements.length - 1; i >= 0; i--) {
       if (statements[i].accept(this)) {
         return true;
       }
     }
     return false;
   }
 
-  bool visitVariableDeclarations(NodeList<VariableDeclaration> variableDeclarations) {
+  bool _visitVariableDeclarations(NodeList<VariableDeclaration> variableDeclarations) {
     for (int i = variableDeclarations.length - 1; i >= 0; i--) {
       if (variableDeclarations[i].accept(this)) {
         return true;
       }
     }
     return false;
   }
 }
 
 /**
@@ skipping 29 matching lines @@
   }
 
   void generateForLibrary() {
     TimeCounter_TimeCounterHandle timeCounter = PerformanceStatistics.hints.start();
     try {
       for (int i = 0; i < _compilationUnits.length; i++) {
         CompilationUnitElement element = _compilationUnits[i].element;
         if (element != null) {
           if (i == 0) {
             _importsVerifier.inDefiningCompilationUnit = true;
-            generateForCompilationUnit(_compilationUnits[i], element.source);
+            _generateForCompilationUnit(_compilationUnits[i], element.source);
             _importsVerifier.inDefiningCompilationUnit = false;
           } else {
-            generateForCompilationUnit(_compilationUnits[i], element.source);
+            _generateForCompilationUnit(_compilationUnits[i], element.source);
           }
         }
       }
       ErrorReporter definingCompilationUnitErrorReporter = new ErrorReporter(_errorListener, _compilationUnits[0].element.source);
       _importsVerifier.generateDuplicateImportHints(definingCompilationUnitErrorReporter);
       _importsVerifier.generateUnusedImportHints(definingCompilationUnitErrorReporter);
     } finally {
       timeCounter.stop();
     }
   }
 
-  void generateForCompilationUnit(CompilationUnit unit, Source source) {
+  void _generateForCompilationUnit(CompilationUnit unit, Source source) {
     ErrorReporter errorReporter = new ErrorReporter(_errorListener, source);
     unit.accept(_importsVerifier);
     // dead code analysis
     unit.accept(new DeadCodeVerifier(errorReporter));
     // dart2js analysis
     if (_enableDart2JSHints) {
       unit.accept(new Dart2JSVerifier(errorReporter));
     }
     // Dart best practices
     unit.accept(new BestPracticesVerifier(errorReporter));
@@ skipping 138 matching lines @@
                 Element element = prefixIdentifier.staticElement;
                 if (element is PrefixElement) {
                   PrefixElement prefixElementKey = element;
                   _prefixElementMap[prefixElementKey] = importDirective;
                 }
               }
             }
             //
             // Initialize libraryMap: libraryElement -> importDirective
             //
-            putIntoLibraryMap(libraryElement, importDirective);
+            _putIntoLibraryMap(libraryElement, importDirective);
             //
             // For this new addition to the libraryMap, also recursively add any exports from the
             // libraryElement
             //
-            addAdditionalLibrariesForExports(libraryElement, importDirective, new List<LibraryElement>());
+            _addAdditionalLibrariesForExports(libraryElement, importDirective, new List<LibraryElement>());
           }
         }
       }
     }
     // If there are no imports in this library, don't visit the identifiers in the library- there
     // can be no unused imports.
     if (_unusedImports.isEmpty) {
       return null;
     }
     if (_unusedImports.length > 1) {
@@ skipping 12 matching lines @@
             _duplicateImports.add(currentDirective);
           }
         }
         currentDirective = nextDirective;
       }
     }
     return super.visitCompilationUnit(node);
   }
 
   Object visitExportDirective(ExportDirective node) {
-    visitMetadata(node.metadata);
+    _visitMetadata(node.metadata);
     return null;
   }
 
   Object visitImportDirective(ImportDirective node) {
-    visitMetadata(node.metadata);
+    _visitMetadata(node.metadata);
     return null;
   }
 
   Object visitLibraryDirective(LibraryDirective node) {
-    visitMetadata(node.metadata);
+    _visitMetadata(node.metadata);
     return null;
   }
 
   Object visitPrefixedIdentifier(PrefixedIdentifier node) {
     if (_unusedImports.isEmpty) {
       return null;
     }
     // If the prefixed identifier references some A.B, where A is a library prefix, then we can
     // lookup the associated ImportDirective in prefixElementMap and remove it from the
     // unusedImports list.
     SimpleIdentifier prefixIdentifier = node.prefix;
     Element element = prefixIdentifier.staticElement;
     if (element is PrefixElement) {
       _unusedImports.remove(_prefixElementMap[element]);
       return null;
     }
     // Otherwise, pass the prefixed identifier element and name onto visitIdentifier.
-    return visitIdentifier(element, prefixIdentifier.name);
+    return _visitIdentifier(element, prefixIdentifier.name);
   }
 
   Object visitSimpleIdentifier(SimpleIdentifier node) {
     if (_unusedImports.isEmpty) {
       return null;
     }
-    return visitIdentifier(node.staticElement, node.name);
+    return _visitIdentifier(node.staticElement, node.name);
   }
 
   void set inDefiningCompilationUnit(bool inDefiningCompilationUnit) {
     this._inDefiningCompilationUnit = inDefiningCompilationUnit;
   }
 
   /**
    * Recursively add any exported library elements into the [libraryMap].
    */
-  void addAdditionalLibrariesForExports(LibraryElement library, ImportDirective importDirective, List<LibraryElement> exportPath) {
+  void _addAdditionalLibrariesForExports(LibraryElement library, ImportDirective importDirective, List<LibraryElement> exportPath) {
     if (exportPath.contains(library)) {
       return;
     }
     exportPath.add(library);
     for (LibraryElement exportedLibraryElt in library.exportedLibraries) {
-      putIntoLibraryMap(exportedLibraryElt, importDirective);
-      addAdditionalLibrariesForExports(exportedLibraryElt, importDirective, exportPath);
+      _putIntoLibraryMap(exportedLibraryElt, importDirective);
+      _addAdditionalLibrariesForExports(exportedLibraryElt, importDirective, exportPath);
     }
   }
 
   /**
    * Lookup and return the [Namespace] from the [namespaceMap], if the map does not
    * have the computed namespace, compute it and cache it in the map. If the import directive is not
    * resolved or is not resolvable, `null` is returned.
    *
    * @param importDirective the import directive used to compute the returned namespace
    * @return the computed or looked up [Namespace]
    */
-  Namespace computeNamespace(ImportDirective importDirective) {
+  Namespace _computeNamespace(ImportDirective importDirective) {
     Namespace namespace = _namespaceMap[importDirective];
     if (namespace == null) {
       // If the namespace isn't in the namespaceMap, then compute and put it in the map
       ImportElement importElement = importDirective.element;
       if (importElement != null) {
         NamespaceBuilder builder = new NamespaceBuilder();
         namespace = builder.createImportNamespaceForDirective(importElement);
         _namespaceMap[importDirective] = namespace;
       }
     }
     return namespace;
   }
 
   /**
    * The [libraryMap] is a mapping between a library elements and a list of import
    * directives, but when adding these mappings into the [libraryMap], this method can be
    * used to simply add the mapping between the library element an an import directive without
    * needing to check to see if a list needs to be created.
    */
-  void putIntoLibraryMap(LibraryElement libraryElement, ImportDirective importDirective) {
+  void _putIntoLibraryMap(LibraryElement libraryElement, ImportDirective importDirective) {
     List<ImportDirective> importList = _libraryMap[libraryElement];
     if (importList == null) {
       importList = new List<ImportDirective>();
       _libraryMap[libraryElement] = importList;
     }
     importList.add(importDirective);
   }
 
-  Object visitIdentifier(Element element, String name) {
+  Object _visitIdentifier(Element element, String name) {
     if (element == null) {
       return null;
     }
     // If the element is multiply defined then call this method recursively for each of the conflicting elements.
     if (element is MultiplyDefinedElement) {
       MultiplyDefinedElement multiplyDefinedElement = element;
       for (Element elt in multiplyDefinedElement.conflictingElements) {
-        visitIdentifier(elt, name);
+        _visitIdentifier(elt, name);
       }
       return null;
     } else if (element is PrefixElement) {
       _unusedImports.remove(_prefixElementMap[element]);
       return null;
     } else if (element.enclosingElement is! CompilationUnitElement) {
       // Identifiers that aren't a prefix element and whose enclosing element isn't a
       // CompilationUnit are ignored- this covers the case the identifier is a relative-reference,
       // a reference to an identifier not imported by this library.
       return null;
@@ skipping 12 matching lines @@
     }
     if (importsFromSameLibrary.length == 1) {
       // If there is only one import directive for this library, then it must be the directive that
       // this element is imported with, remove it from the unusedImports list.
       ImportDirective usedImportDirective = importsFromSameLibrary[0];
       _unusedImports.remove(usedImportDirective);
     } else {
       // Otherwise, for each of the imported directives, use the namespaceMap to
       for (ImportDirective importDirective in importsFromSameLibrary) {
         // Get the namespace for this import
-        Namespace namespace = computeNamespace(importDirective);
+        Namespace namespace = _computeNamespace(importDirective);
         if (namespace != null && namespace.get(name) != null) {
           _unusedImports.remove(importDirective);
         }
       }
     }
     return null;
   }
 
   /**
    * Given some [NodeList] of [Annotation]s, ensure that the identifiers are visited by
    * this visitor. Specifically, this covers the cases where AST nodes don't have their identifiers
    * visited by this visitor, but still need their annotations visited.
    *
    * @param annotations the list of annotations to visit
    */
-  void visitMetadata(NodeList<Annotation> annotations) {
+  void _visitMetadata(NodeList<Annotation> annotations) {
     for (Annotation annotation in annotations) {
       Identifier name = annotation.name;
-      visitIdentifier(name.staticElement, name.name);
+      _visitIdentifier(name.staticElement, name.name);
     }
   }
 }
 
 /**
  * Instances of the class `OverrideVerifier` visit all of the declarations in a compilation
  * unit to verify that if they have an override annotation it is being used correctly.
  */
 class OverrideVerifier extends RecursiveAstVisitor<Object> {
   /**
@@ skipping 12 matching lines @@
    * @param manager the inheritance manager used to find overridden methods
    * @param errorReporter the error reporter used to report errors
    */
   OverrideVerifier(InheritanceManager manager, ErrorReporter errorReporter) {
     this._manager = manager;
     this._errorReporter = errorReporter;
   }
 
   Object visitMethodDeclaration(MethodDeclaration node) {
     ExecutableElement element = node.element;
-    if (isOverride(element)) {
-      if (getOverriddenMember(element) == null) {
+    if (_isOverride(element)) {
+      if (_getOverriddenMember(element) == null) {
         if (element is MethodElement) {
           _errorReporter.reportErrorForNode(HintCode.OVERRIDE_ON_NON_OVERRIDING_METHOD, node.name, []);
         } else if (element is PropertyAccessorElement) {
           if (element.isGetter) {
             _errorReporter.reportErrorForNode(HintCode.OVERRIDE_ON_NON_OVERRIDING_GETTER, node.name, []);
           } else {
             _errorReporter.reportErrorForNode(HintCode.OVERRIDE_ON_NON_OVERRIDING_SETTER, node.name, []);
           }
         }
       }
     }
     return super.visitMethodDeclaration(node);
   }
 
   /**
    * Return the member that overrides the given member.
    *
    * @param member the member that overrides the returned member
    * @return the member that overrides the given member
    */
-  ExecutableElement getOverriddenMember(ExecutableElement member) {
+  ExecutableElement _getOverriddenMember(ExecutableElement member) {
     LibraryElement library = member.library;
     if (library == null) {
       return null;
     }
     ClassElement classElement = member.getAncestor((element) => element is ClassElement);
     if (classElement == null) {
       return null;
     }
     return _manager.lookupInheritance(classElement, member.name);
   }
 
   /**
    * Return `true` if the given element has an override annotation associated with it.
    *
    * @param element the element being tested
    * @return `true` if the element has an override annotation associated with it
    */
-  bool isOverride(Element element) => element != null && element.isOverride;
+  bool _isOverride(Element element) => element != null && element.isOverride;
 }
 
 /**
  * Instances of the class `PubVerifier` traverse an AST structure looking for deviations from
  * pub best practices.
  */
 class PubVerifier extends RecursiveAstVisitor<Object> {
   static String _PUBSPEC_YAML = "pubspec.yaml";
 
   /**
@@ skipping 18 matching lines @@
   /**
    * This verifies that the passed file import directive is not contained in a source inside a
    * package "lib" directory hierarchy referencing a source outside that package "lib" directory
    * hierarchy.
    *
    * @param uriLiteral the import URL (not `null`)
    * @param path the file path being verified (not `null`)
    * @return `true` if and only if an error code is generated on the passed node
    * @see PubSuggestionCode.FILE_IMPORT_INSIDE_LIB_REFERENCES_FILE_OUTSIDE
    */
-  bool checkForFileImportInsideLibReferencesFileOutside(StringLiteral uriLiteral, String path) {
-    Source source = getSource(uriLiteral);
-    String fullName = getSourceFullName(source);
+  bool _checkForFileImportInsideLibReferencesFileOutside(StringLiteral uriLiteral, String path) {
+    Source source = _getSource(uriLiteral);
+    String fullName = _getSourceFullName(source);
     if (fullName != null) {
       int pathIndex = 0;
       int fullNameIndex = fullName.length;
       while (pathIndex < path.length && StringUtilities.startsWith3(path, pathIndex, 0x2E, 0x2E, 0x2F)) {
         fullNameIndex = JavaString.lastIndexOf(fullName, '/', fullNameIndex);
         if (fullNameIndex < 4) {
           return false;
         }
         // Check for "/lib" at a specified place in the fullName
         if (StringUtilities.startsWith4(fullName, fullNameIndex - 4, 0x2F, 0x6C, 0x69, 0x62)) {
@@ skipping 14 matching lines @@
   /**
    * This verifies that the passed file import directive is not contained in a source outside a
    * package "lib" directory hierarchy referencing a source inside that package "lib" directory
    * hierarchy.
    *
    * @param uriLiteral the import URL (not `null`)
    * @param path the file path being verified (not `null`)
    * @return `true` if and only if an error code is generated on the passed node
    * @see PubSuggestionCode.FILE_IMPORT_OUTSIDE_LIB_REFERENCES_FILE_INSIDE
    */
-  bool checkForFileImportOutsideLibReferencesFileInside(StringLiteral uriLiteral, String path) {
+  bool _checkForFileImportOutsideLibReferencesFileInside(StringLiteral uriLiteral, String path) {
     if (StringUtilities.startsWith4(path, 0, 0x6C, 0x69, 0x62, 0x2F)) {
-      if (checkForFileImportOutsideLibReferencesFileInsideAtIndex(uriLiteral, path, 0)) {
+      if (_checkForFileImportOutsideLibReferencesFileInsideAtIndex(uriLiteral, path, 0)) {
         return true;
       }
     }
     int pathIndex = StringUtilities.indexOf5(path, 0, 0x2F, 0x6C, 0x69, 0x62, 0x2F);
     while (pathIndex != -1) {
-      if (checkForFileImportOutsideLibReferencesFileInsideAtIndex(uriLiteral, path, pathIndex + 1)) {
+      if (_checkForFileImportOutsideLibReferencesFileInsideAtIndex(uriLiteral, path, pathIndex + 1)) {
         return true;
       }
       pathIndex = StringUtilities.indexOf5(path, pathIndex + 4, 0x2F, 0x6C, 0x69, 0x62, 0x2F);
     }
     return false;
   }
 
-  bool checkForFileImportOutsideLibReferencesFileInsideAtIndex(StringLiteral uriLiteral, String path, int pathIndex) {
-    Source source = getSource(uriLiteral);
+  bool _checkForFileImportOutsideLibReferencesFileInsideAtIndex(StringLiteral uriLiteral, String path, int pathIndex) {
+    Source source = _getSource(uriLiteral);
     String relativePubspecPath = path.substring(0, pathIndex) + _PUBSPEC_YAML;
     Source pubspecSource = _context.sourceFactory.resolveUri(source, relativePubspecPath);
     if (!_context.exists(pubspecSource)) {
       return false;
     }
-    String fullName = getSourceFullName(source);
+    String fullName = _getSourceFullName(source);
     if (fullName != null) {
       if (StringUtilities.indexOf5(fullName, 0, 0x2F, 0x6C, 0x69, 0x62, 0x2F) < 0) {
         // Files outside the lib directory hierarchy should not reference files inside
         // ... use package: url instead
         _errorReporter.reportErrorForNode(PubSuggestionCode.FILE_IMPORT_OUTSIDE_LIB_REFERENCES_FILE_INSIDE, uriLiteral, []);
         return true;
       }
     }
     return false;
   }
 
   /**
    * This verifies that the passed package import directive does not contain ".."
    *
    * @param uriLiteral the import URL (not `null`)
    * @param path the path to be validated (not `null`)
    * @return `true` if and only if an error code is generated on the passed node
    * @see PubSuggestionCode.PACKAGE_IMPORT_CONTAINS_DOT_DOT
    */
-  bool checkForPackageImportContainsDotDot(StringLiteral uriLiteral, String path) {
+  bool _checkForPackageImportContainsDotDot(StringLiteral uriLiteral, String path) {
     if (StringUtilities.startsWith3(path, 0, 0x2E, 0x2E, 0x2F) || StringUtilities.indexOf4(path, 0, 0x2F, 0x2E, 0x2E, 0x2F) >= 0) {
       // Package import should not to contain ".."
       _errorReporter.reportErrorForNode(PubSuggestionCode.PACKAGE_IMPORT_CONTAINS_DOT_DOT, uriLiteral, []);
       return true;
     }
     return false;
   }
 
   /**
    * Answer the source associated with the compilation unit containing the given AST node.
    *
    * @param node the node (not `null`)
    * @return the source or `null` if it could not be determined
    */
-  Source getSource(AstNode node) {
+  Source _getSource(AstNode node) {
     Source source = null;
     CompilationUnit unit = node.getAncestor((node) => node is CompilationUnit);
     if (unit != null) {
       CompilationUnitElement element = unit.element;
       if (element != null) {
         source = element.source;
       }
     }
     return source;
   }
 
   /**
    * Answer the full name of the given source. The returned value will have all
    * [File#separatorChar] replace by '/'.
    *
    * @param source the source
    * @return the full name or `null` if it could not be determined
    */
-  String getSourceFullName(Source source) {
+  String _getSourceFullName(Source source) {
     if (source != null) {
       String fullName = source.fullName;
       if (fullName != null) {
         return fullName.replaceAll(r'\', '/');
       }
     }
     return null;
   }
 }
 
@@ skipping 15 matching lines @@
     this._errorReporter = errorReporter;
   }
 
   /**
    * Search the comments in the given compilation unit for to-do comments and report an error for
    * each.
    *
    * @param unit the compilation unit containing the to-do comments
    */
   void findIn(CompilationUnit unit) {
-    gatherTodoComments(unit.beginToken);
+    _gatherTodoComments(unit.beginToken);
   }
 
   /**
    * Search the comment tokens reachable from the given token and create errors for each to-do
    * comment.
    *
    * @param token the head of the list of tokens being searched
    */
-  void gatherTodoComments(sc.Token token) {
+  void _gatherTodoComments(sc.Token token) {
     while (token != null && token.type != sc.TokenType.EOF) {
       sc.Token commentToken = token.precedingComments;
       while (commentToken != null) {
         if (identical(commentToken.type, sc.TokenType.SINGLE_LINE_COMMENT) || identical(commentToken.type, sc.TokenType.MULTI_LINE_COMMENT)) {
-          scrapeTodoComment(commentToken);
+          _scrapeTodoComment(commentToken);
         }
         commentToken = commentToken.next;
       }
       token = token.next;
     }
   }
 
   /**
    * Look for user defined tasks in comments and convert them into info level analysis issues.
    *
    * @param commentToken the comment token to analyze
    */
-  void scrapeTodoComment(sc.Token commentToken) {
+  void _scrapeTodoComment(sc.Token commentToken) {
     JavaPatternMatcher matcher = new JavaPatternMatcher(TodoCode.TODO_REGEX, commentToken.lexeme);
     if (matcher.find()) {
       int offset = commentToken.offset + matcher.start() + matcher.group(1).length;
       int length = matcher.group(2).length;
       _errorReporter.reportErrorForOffset(TodoCode.TODO, offset, length, [matcher.group(2)]);
     }
   }
 }
 
 /**
@@ skipping 46 matching lines @@
   /**
    * Return `true` if the declarations within the given AST structure define an element model
    * that is equivalent to the corresponding elements rooted at the given element.
    *
    * @param node the AST structure being compared to the element model
    * @param element the root of the element model being compared to the AST structure
    * @return `true` if the AST structure defines the same elements as those in the given
    *         element model
    */
   bool matches(AstNode node, Element element) {
-    captureEnclosingElements(element);
-    gatherElements(element);
+    _captureEnclosingElements(element);
+    _gatherElements(element);
     try {
       node.accept(this);
     } on DeclarationMatcher_DeclarationMismatchException catch (exception) {
       return false;
     }
     return _unmatchedElements.isEmpty;
   }
 
   Object visitCatchClause(CatchClause node) {
     SimpleIdentifier exceptionParameter = node.exceptionParameter;
     if (exceptionParameter != null) {
       List<LocalVariableElement> localVariables = _enclosingExecutable.localVariables;
-      LocalVariableElement exceptionElement = findIdentifier(localVariables, exceptionParameter);
+      LocalVariableElement exceptionElement = _findIdentifier(localVariables, exceptionParameter);
       processElement(exceptionElement);
       SimpleIdentifier stackTraceParameter = node.stackTraceParameter;
       if (stackTraceParameter != null) {
-        LocalVariableElement stackTraceElement = findIdentifier(localVariables, stackTraceParameter);
+        LocalVariableElement stackTraceElement = _findIdentifier(localVariables, stackTraceParameter);
         processElement(stackTraceElement);
       }
     }
     return super.visitCatchClause(node);
   }
 
   Object visitClassDeclaration(ClassDeclaration node) {
     ClassElement outerClass = _enclosingClass;
     try {
       SimpleIdentifier className = node.name;
-      _enclosingClass = findIdentifier(_enclosingUnit.types, className);
+      _enclosingClass = _findIdentifier(_enclosingUnit.types, className);
       processElement(_enclosingClass);
-      if (!hasConstructor(node)) {
+      if (!_hasConstructor(node)) {
         ConstructorElement constructor = _enclosingClass.unnamedConstructor;
         if (constructor.isSynthetic) {
           processElement(constructor);
         }
       }
       return super.visitClassDeclaration(node);
     } finally {
       _enclosingClass = outerClass;
     }
   }
 
   Object visitClassTypeAlias(ClassTypeAlias node) {
     ClassElement outerClass = _enclosingClass;
     try {
       SimpleIdentifier className = node.name;
-      _enclosingClass = findIdentifier(_enclosingUnit.types, className);
+      _enclosingClass = _findIdentifier(_enclosingUnit.types, className);
       processElement(_enclosingClass);
       return super.visitClassTypeAlias(node);
     } finally {
       _enclosingClass = outerClass;
     }
   }
 
   Object visitCompilationUnit(CompilationUnit node) {
     processElement(_enclosingUnit);
     return super.visitCompilationUnit(node);
@@ skipping 10 matching lines @@
       }
       processElement(_enclosingExecutable);
       return super.visitConstructorDeclaration(node);
     } finally {
       _enclosingExecutable = outerExecutable;
     }
   }
 
   Object visitDeclaredIdentifier(DeclaredIdentifier node) {
     SimpleIdentifier variableName = node.identifier;
-    LocalVariableElement element = findIdentifier(_enclosingExecutable.localVariables, variableName);
+    LocalVariableElement element = _findIdentifier(_enclosingExecutable.localVariables, variableName);
     processElement(element);
     return super.visitDeclaredIdentifier(node);
   }
 
   Object visitDefaultFormalParameter(DefaultFormalParameter node) {
     SimpleIdentifier parameterName = node.parameter.identifier;
-    ParameterElement element = getElementForParameter(node, parameterName);
+    ParameterElement element = _getElementForParameter(node, parameterName);
     Expression defaultValue = node.defaultValue;
     if (defaultValue != null) {
       ExecutableElement outerExecutable = _enclosingExecutable;
       try {
         if (element == null) {
         } else {
           _enclosingExecutable = element.initializer;
         }
         defaultValue.accept(this);
       } finally {
         _enclosingExecutable = outerExecutable;
       }
       processElement(_enclosingExecutable);
     }
     ParameterElement outerParameter = _enclosingParameter;
     try {
       _enclosingParameter = element;
       processElement(_enclosingParameter);
       return super.visitDefaultFormalParameter(node);
     } finally {
       _enclosingParameter = outerParameter;
     }
   }
 
   Object visitExportDirective(ExportDirective node) {
-    String uri = getStringValue(node.uri);
+    String uri = _getStringValue(node.uri);
     if (uri != null) {
       LibraryElement library = _enclosingUnit.library;
-      ExportElement exportElement = findExport(library.exports, _enclosingUnit.context.sourceFactory.resolveUri(_enclosingUnit.source, uri));
+      ExportElement exportElement = _findExport(library.exports, _enclosingUnit.context.sourceFactory.resolveUri(_enclosingUnit.source, uri));
       processElement(exportElement);
     }
     return super.visitExportDirective(node);
   }
 
   Object visitFieldFormalParameter(FieldFormalParameter node) {
     if (node.parent is! DefaultFormalParameter) {
       SimpleIdentifier parameterName = node.identifier;
-      ParameterElement element = getElementForParameter(node, parameterName);
+      ParameterElement element = _getElementForParameter(node, parameterName);
       ParameterElement outerParameter = _enclosingParameter;
       try {
         _enclosingParameter = element;
         processElement(_enclosingParameter);
         return super.visitFieldFormalParameter(node);
       } finally {
         _enclosingParameter = outerParameter;
       }
     } else {
       return super.visitFieldFormalParameter(node);
     }
   }
 
   Object visitFunctionDeclaration(FunctionDeclaration node) {
     ExecutableElement outerExecutable = _enclosingExecutable;
     try {
       SimpleIdentifier functionName = node.name;
       sc.Token property = node.propertyKeyword;
       if (property == null) {
         if (_enclosingExecutable != null) {
-          _enclosingExecutable = findIdentifier(_enclosingExecutable.functions, functionName);
+          _enclosingExecutable = _findIdentifier(_enclosingExecutable.functions, functionName);
         } else {
-          _enclosingExecutable = findIdentifier(_enclosingUnit.functions, functionName);
+          _enclosingExecutable = _findIdentifier(_enclosingUnit.functions, functionName);
         }
       } else {
-        PropertyAccessorElement accessor = findIdentifier(_enclosingUnit.accessors, functionName);
+        PropertyAccessorElement accessor = _findIdentifier(_enclosingUnit.accessors, functionName);
         if (identical((property as sc.KeywordToken).keyword, sc.Keyword.SET)) {
           accessor = accessor.variable.setter;
         }
         _enclosingExecutable = accessor;
       }
       processElement(_enclosingExecutable);
       return super.visitFunctionDeclaration(node);
     } finally {
       _enclosingExecutable = outerExecutable;
     }
   }
 
   Object visitFunctionExpression(FunctionExpression node) {
     if (node.parent is! FunctionDeclaration) {
-      FunctionElement element = findAtOffset(_enclosingExecutable.functions, node.beginToken.offset);
+      FunctionElement element = _findAtOffset(_enclosingExecutable.functions, node.beginToken.offset);
       processElement(element);
     }
     ExecutableElement outerExecutable = _enclosingExecutable;
     try {
       _enclosingExecutable = node.element;
       processElement(_enclosingExecutable);
       return super.visitFunctionExpression(node);
     } finally {
       _enclosingExecutable = outerExecutable;
     }
   }
 
   Object visitFunctionTypeAlias(FunctionTypeAlias node) {
     FunctionTypeAliasElement outerAlias = _enclosingAlias;
     try {
       SimpleIdentifier aliasName = node.name;
-      _enclosingAlias = findIdentifier(_enclosingUnit.functionTypeAliases, aliasName);
+      _enclosingAlias = _findIdentifier(_enclosingUnit.functionTypeAliases, aliasName);
       processElement(_enclosingAlias);
       return super.visitFunctionTypeAlias(node);
     } finally {
       _enclosingAlias = outerAlias;
     }
   }
 
   Object visitFunctionTypedFormalParameter(FunctionTypedFormalParameter node) {
     if (node.parent is! DefaultFormalParameter) {
       SimpleIdentifier parameterName = node.identifier;
-      ParameterElement element = getElementForParameter(node, parameterName);
+      ParameterElement element = _getElementForParameter(node, parameterName);
       ParameterElement outerParameter = _enclosingParameter;
       try {
         _enclosingParameter = element;
         processElement(_enclosingParameter);
         return super.visitFunctionTypedFormalParameter(node);
       } finally {
         _enclosingParameter = outerParameter;
       }
     } else {
       return super.visitFunctionTypedFormalParameter(node);
     }
   }
 
   Object visitImportDirective(ImportDirective node) {
-    String uri = getStringValue(node.uri);
+    String uri = _getStringValue(node.uri);
     if (uri != null) {
       LibraryElement library = _enclosingUnit.library;
-      ImportElement importElement = findImport(library.imports, _enclosingUnit.context.sourceFactory.resolveUri(_enclosingUnit.source, uri), node.prefix);
+      ImportElement importElement = _findImport(library.imports, _enclosingUnit.context.sourceFactory.resolveUri(_enclosingUnit.source, uri), node.prefix);
       processElement(importElement);
     }
     return super.visitImportDirective(node);
   }
 
   Object visitLabeledStatement(LabeledStatement node) {
     for (Label label in node.labels) {
       SimpleIdentifier labelName = label.label;
-      LabelElement element = findIdentifier(_enclosingExecutable.labels, labelName);
+      LabelElement element = _findIdentifier(_enclosingExecutable.labels, labelName);
       processElement(element);
     }
     return super.visitLabeledStatement(node);
   }
 
   Object visitMethodDeclaration(MethodDeclaration node) {
     ExecutableElement outerExecutable = _enclosingExecutable;
     try {
       sc.Token property = node.propertyKeyword;
       SimpleIdentifier methodName = node.name;
       String nameOfMethod = methodName.name;
       if (nameOfMethod == sc.TokenType.MINUS.lexeme && node.parameters.parameters.length == 0) {
         nameOfMethod = "unary-";
       }
       if (property == null) {
-        _enclosingExecutable = findWithNameAndOffset(_enclosingClass.methods, nameOfMethod, methodName.offset);
+        _enclosingExecutable = _findWithNameAndOffset(_enclosingClass.methods, nameOfMethod, methodName.offset);
         methodName.staticElement = _enclosingExecutable;
       } else {
-        PropertyAccessorElement accessor = findIdentifier(_enclosingClass.accessors, methodName);
+        PropertyAccessorElement accessor = _findIdentifier(_enclosingClass.accessors, methodName);
         if (identical((property as sc.KeywordToken).keyword, sc.Keyword.SET)) {
           accessor = accessor.variable.setter;
           methodName.staticElement = accessor;
         }
         _enclosingExecutable = accessor;
       }
       processElement(_enclosingExecutable);
       return super.visitMethodDeclaration(node);
     } finally {
       _enclosingExecutable = outerExecutable;
     }
   }
 
   Object visitPartDirective(PartDirective node) {
-    String uri = getStringValue(node.uri);
+    String uri = _getStringValue(node.uri);
     if (uri != null) {
       Source partSource = _enclosingUnit.context.sourceFactory.resolveUri(_enclosingUnit.source, uri);
-      CompilationUnitElement element = findPart(_enclosingUnit.library.parts, partSource);
+      CompilationUnitElement element = _findPart(_enclosingUnit.library.parts, partSource);
       processElement(element);
     }
     return super.visitPartDirective(node);
   }
 
   Object visitSimpleFormalParameter(SimpleFormalParameter node) {
     if (node.parent is! DefaultFormalParameter) {
       SimpleIdentifier parameterName = node.identifier;
-      ParameterElement element = getElementForParameter(node, parameterName);
+      ParameterElement element = _getElementForParameter(node, parameterName);
       ParameterElement outerParameter = _enclosingParameter;
       try {
         _enclosingParameter = element;
         processElement(_enclosingParameter);
         return super.visitSimpleFormalParameter(node);
       } finally {
         _enclosingParameter = outerParameter;
       }
     } else {
     }
     return super.visitSimpleFormalParameter(node);
   }
 
   Object visitSwitchCase(SwitchCase node) {
     for (Label label in node.labels) {
       SimpleIdentifier labelName = label.label;
-      LabelElement element = findIdentifier(_enclosingExecutable.labels, labelName);
+      LabelElement element = _findIdentifier(_enclosingExecutable.labels, labelName);
       processElement(element);
     }
     return super.visitSwitchCase(node);
   }
 
   Object visitSwitchDefault(SwitchDefault node) {
     for (Label label in node.labels) {
       SimpleIdentifier labelName = label.label;
-      LabelElement element = findIdentifier(_enclosingExecutable.labels, labelName);
+      LabelElement element = _findIdentifier(_enclosingExecutable.labels, labelName);
       processElement(element);
     }
     return super.visitSwitchDefault(node);
   }
 
   Object visitTypeParameter(TypeParameter node) {
     SimpleIdentifier parameterName = node.name;
     TypeParameterElement element = null;
     if (_enclosingClass != null) {
-      element = findIdentifier(_enclosingClass.typeParameters, parameterName);
+      element = _findIdentifier(_enclosingClass.typeParameters, parameterName);
     } else if (_enclosingAlias != null) {
-      element = findIdentifier(_enclosingAlias.typeParameters, parameterName);
+      element = _findIdentifier(_enclosingAlias.typeParameters, parameterName);
     }
     processElement(element);
     return super.visitTypeParameter(node);
   }
 
   Object visitVariableDeclaration(VariableDeclaration node) {
     VariableElement element = null;
     SimpleIdentifier variableName = node.name;
     if (_enclosingExecutable != null) {
-      element = findIdentifier(_enclosingExecutable.localVariables, variableName);
+      element = _findIdentifier(_enclosingExecutable.localVariables, variableName);
     }
     if (element == null && _enclosingClass != null) {
-      element = findIdentifier(_enclosingClass.fields, variableName);
+      element = _findIdentifier(_enclosingClass.fields, variableName);
     }
     if (element == null && _enclosingUnit != null) {
-      element = findIdentifier(_enclosingUnit.topLevelVariables, variableName);
+      element = _findIdentifier(_enclosingUnit.topLevelVariables, variableName);
     }
     Expression initializer = node.initializer;
     if (initializer != null) {
       ExecutableElement outerExecutable = _enclosingExecutable;
       try {
         if (element == null) {
         } else {
           _enclosingExecutable = element.initializer;
         }
         processElement(element);
@@ skipping 15 matching lines @@
     }
     _unmatchedElements.remove(element);
   }
 
   /**
    * Given that the comparison is to begin with the given element, capture the enclosing elements
    * that might be used while performing the comparison.
    *
    * @param element the element corresponding to the AST structure to be compared
    */
-  void captureEnclosingElements(Element element) {
+  void _captureEnclosingElements(Element element) {
     Element parent = element is CompilationUnitElement ? element : element.enclosingElement;
     while (parent != null) {
       if (parent is CompilationUnitElement) {
         _enclosingUnit = parent as CompilationUnitElement;
       } else if (parent is ClassElement) {
         if (_enclosingClass == null) {
           _enclosingClass = parent as ClassElement;
         }
       } else if (parent is FunctionTypeAliasElement) {
         if (_enclosingAlias == null) {
@@ skipping 13 matching lines @@
   }
 
   /**
    * Return the element in the given array of elements that was created for the declaration at the
    * given offset. This method should only be used when there is no name
    *
    * @param elements the elements of the appropriate kind that exist in the current context
    * @param offset the offset of the name of the element to be returned
    * @return the element at the given offset
    */
-  Element findAtOffset(List<Element> elements, int offset) => findWithNameAndOffset(elements, "", offset);
+  Element _findAtOffset(List<Element> elements, int offset) => _findWithNameAndOffset(elements, "", offset);
 
   /**
    * Return the export element from the given array whose library has the given source, or
    * `null` if there is no such export.
    *
    * @param exports the export elements being searched
    * @param source the source of the library associated with the export element to being searched
    *          for
    * @return the export element whose library has the given source
    */
-  ExportElement findExport(List<ExportElement> exports, Source source) {
+  ExportElement _findExport(List<ExportElement> exports, Source source) {
     for (ExportElement export in exports) {
       if (export.exportedLibrary.source == source) {
         return export;
       }
     }
     return null;
   }
 
   /**
    * Return the element in the given array of elements that was created for the declaration with the
    * given name.
    *
    * @param elements the elements of the appropriate kind that exist in the current context
    * @param identifier the name node in the declaration of the element to be returned
    * @return the element created for the declaration with the given name
    */
-  Element findIdentifier(List<Element> elements, SimpleIdentifier identifier) => findWithNameAndOffset(elements, identifier.name, identifier.offset);
+  Element _findIdentifier(List<Element> elements, SimpleIdentifier identifier) => _findWithNameAndOffset(elements, identifier.name, identifier.offset);
 
   /**
    * Return the import element from the given array whose library has the given source and that has
    * the given prefix, or `null` if there is no such import.
    *
    * @param imports the import elements being searched
    * @param source the source of the library associated with the import element to being searched
    *          for
    * @param prefix the prefix with which the library was imported
    * @return the import element whose library has the given source and prefix
    */
-  ImportElement findImport(List<ImportElement> imports, Source source, SimpleIdentifier prefix) {
+  ImportElement _findImport(List<ImportElement> imports, Source source, SimpleIdentifier prefix) {
     for (ImportElement element in imports) {
       if (element.importedLibrary.source == source) {
         PrefixElement prefixElement = element.prefix;
         if (prefix == null) {
           if (prefixElement == null) {
             return element;
           }
         } else {
           if (prefixElement != null && prefix.name == prefixElement.displayName) {
             return element;
           }
         }
       }
     }
     return null;
   }
 
   /**
    * Return the element for the part with the given source, or `null` if there is no element
    * for the given source.
    *
    * @param parts the elements for the parts
    * @param partSource the source for the part whose element is to be returned
    * @return the element for the part with the given source
    */
-  CompilationUnitElement findPart(List<CompilationUnitElement> parts, Source partSource) {
+  CompilationUnitElement _findPart(List<CompilationUnitElement> parts, Source partSource) {
     for (CompilationUnitElement part in parts) {
       if (part.source == partSource) {
         return part;
       }
     }
     return null;
   }
 
   /**
    * Return the element in the given array of elements that was created for the declaration with the
    * given name at the given offset.
    *
    * @param elements the elements of the appropriate kind that exist in the current context
    * @param name the name of the element to be returned
    * @param offset the offset of the name of the element to be returned
    * @return the element with the given name and offset
    */
-  Element findWithNameAndOffset(List<Element> elements, String name, int offset) {
+  Element _findWithNameAndOffset(List<Element> elements, String name, int offset) {
     for (Element element in elements) {
       if (element.displayName == name && element.nameOffset == offset) {
         return element;
       }
     }
     return null;
   }
 
-  void gatherElements(Element element) {
+  void _gatherElements(Element element) {
     element.accept(new GeneralizingElementVisitor_DeclarationMatcher_gatherElements(this));
   }
 
   /**
    * Search the most closely enclosing list of parameters for a parameter with the given name.
    *
    * @param node the node defining the parameter with the given name
    * @param parameterName the name of the parameter being searched for
    * @return the element representing the parameter with that name
    */
-  ParameterElement getElementForParameter(FormalParameter node, SimpleIdentifier parameterName) {
+  ParameterElement _getElementForParameter(FormalParameter node, SimpleIdentifier parameterName) {
     List<ParameterElement> parameters = null;
     if (_enclosingParameter != null) {
       parameters = _enclosingParameter.parameters;
     }
     if (parameters == null && _enclosingExecutable != null) {
       parameters = _enclosingExecutable.parameters;
     }
     if (parameters == null && _enclosingAlias != null) {
       parameters = _enclosingAlias.parameters;
     }
-    return parameters == null ? null : findIdentifier(parameters, parameterName);
+    return parameters == null ? null : _findIdentifier(parameters, parameterName);
   }
 
   /**
    * Return the value of the given string literal, or `null` if the string is not a constant
    * string without any string interpolation.
    *
    * @param literal the string literal whose value is to be returned
    * @return the value of the given string literal
    */
-  String getStringValue(StringLiteral literal) {
+  String _getStringValue(StringLiteral literal) {
     if (literal is StringInterpolation) {
       return null;
     }
     return literal.stringValue;
   }
 
   /**
    * Return `true` if the given class defines at least one constructor.
    *
    * @param node the class being tested
    * @return `true` if the class defines at least one constructor
    */
-  bool hasConstructor(ClassDeclaration node) {
+  bool _hasConstructor(ClassDeclaration node) {
     for (ClassMember member in node.members) {
       if (member is ConstructorDeclaration) {
         return true;
       }
     }
     return false;
   }
 }
 
 /**
@@ skipping 60 matching lines @@
   void resolve(CompilationUnit unit, CompilationUnitElement element) {
     _enclosingUnit = element;
     unit.element = element;
     unit.accept(this);
   }
 
   Object visitCatchClause(CatchClause node) {
     SimpleIdentifier exceptionParameter = node.exceptionParameter;
     if (exceptionParameter != null) {
       List<LocalVariableElement> localVariables = _enclosingExecutable.localVariables;
-      findIdentifier(localVariables, exceptionParameter);
+      _findIdentifier(localVariables, exceptionParameter);
       SimpleIdentifier stackTraceParameter = node.stackTraceParameter;
       if (stackTraceParameter != null) {
-        findIdentifier(localVariables, stackTraceParameter);
+        _findIdentifier(localVariables, stackTraceParameter);
       }
     }
     return super.visitCatchClause(node);
   }
 
   Object visitClassDeclaration(ClassDeclaration node) {
     ClassElement outerClass = _enclosingClass;
     try {
       SimpleIdentifier className = node.name;
-      _enclosingClass = findIdentifier(_enclosingUnit.types, className);
+      _enclosingClass = _findIdentifier(_enclosingUnit.types, className);
       return super.visitClassDeclaration(node);
     } finally {
       _enclosingClass = outerClass;
     }
   }
 
   Object visitClassTypeAlias(ClassTypeAlias node) {
     ClassElement outerClass = _enclosingClass;
     try {
       SimpleIdentifier className = node.name;
-      _enclosingClass = findIdentifier(_enclosingUnit.types, className);
+      _enclosingClass = _findIdentifier(_enclosingUnit.types, className);
       return super.visitClassTypeAlias(node);
     } finally {
       _enclosingClass = outerClass;
     }
   }
 
   Object visitConstructorDeclaration(ConstructorDeclaration node) {
     ExecutableElement outerExecutable = _enclosingExecutable;
     try {
       SimpleIdentifier constructorName = node.name;
       if (constructorName == null) {
         _enclosingExecutable = _enclosingClass.unnamedConstructor;
       } else {
         _enclosingExecutable = _enclosingClass.getNamedConstructor(constructorName.name);
         constructorName.staticElement = _enclosingExecutable;
       }
       node.element = _enclosingExecutable as ConstructorElement;
       return super.visitConstructorDeclaration(node);
     } finally {
       _enclosingExecutable = outerExecutable;
     }
   }
 
   Object visitDeclaredIdentifier(DeclaredIdentifier node) {
     SimpleIdentifier variableName = node.identifier;
-    findIdentifier(_enclosingExecutable.localVariables, variableName);
+    _findIdentifier(_enclosingExecutable.localVariables, variableName);
     return super.visitDeclaredIdentifier(node);
   }
 
   Object visitDefaultFormalParameter(DefaultFormalParameter node) {
     SimpleIdentifier parameterName = node.parameter.identifier;
-    ParameterElement element = getElementForParameter(node, parameterName);
+    ParameterElement element = _getElementForParameter(node, parameterName);
     Expression defaultValue = node.defaultValue;
     if (defaultValue != null) {
       ExecutableElement outerExecutable = _enclosingExecutable;
       try {
         if (element == null) {
         } else {
           _enclosingExecutable = element.initializer;
         }
         defaultValue.accept(this);
       } finally {
         _enclosingExecutable = outerExecutable;
       }
     }
     ParameterElement outerParameter = _enclosingParameter;
     try {
       _enclosingParameter = element;
       return super.visitDefaultFormalParameter(node);
     } finally {
       _enclosingParameter = outerParameter;
     }
   }
 
   Object visitExportDirective(ExportDirective node) {
-    String uri = getStringValue(node.uri);
+    String uri = _getStringValue(node.uri);
     if (uri != null) {
       LibraryElement library = _enclosingUnit.library;
-      ExportElement exportElement = findExport(library.exports, _enclosingUnit.context.sourceFactory.resolveUri(_enclosingUnit.source, uri));
+      ExportElement exportElement = _findExport(library.exports, _enclosingUnit.context.sourceFactory.resolveUri(_enclosingUnit.source, uri));
       node.element = exportElement;
     }
     return super.visitExportDirective(node);
   }
 
   Object visitFieldFormalParameter(FieldFormalParameter node) {
     if (node.parent is! DefaultFormalParameter) {
       SimpleIdentifier parameterName = node.identifier;
-      ParameterElement element = getElementForParameter(node, parameterName);
+      ParameterElement element = _getElementForParameter(node, parameterName);
       ParameterElement outerParameter = _enclosingParameter;
       try {
         _enclosingParameter = element;
         return super.visitFieldFormalParameter(node);
       } finally {
         _enclosingParameter = outerParameter;
       }
     } else {
       return super.visitFieldFormalParameter(node);
     }
   }
 
   Object visitFunctionDeclaration(FunctionDeclaration node) {
     ExecutableElement outerExecutable = _enclosingExecutable;
     try {
       SimpleIdentifier functionName = node.name;
       sc.Token property = node.propertyKeyword;
       if (property == null) {
         if (_enclosingExecutable != null) {
-          _enclosingExecutable = findIdentifier(_enclosingExecutable.functions, functionName);
+          _enclosingExecutable = _findIdentifier(_enclosingExecutable.functions, functionName);
         } else {
-          _enclosingExecutable = findIdentifier(_enclosingUnit.functions, functionName);
+          _enclosingExecutable = _findIdentifier(_enclosingUnit.functions, functionName);
         }
       } else {
-        PropertyAccessorElement accessor = findIdentifier(_enclosingUnit.accessors, functionName);
+        PropertyAccessorElement accessor = _findIdentifier(_enclosingUnit.accessors, functionName);
         if (identical((property as sc.KeywordToken).keyword, sc.Keyword.SET)) {
           accessor = accessor.variable.setter;
           functionName.staticElement = accessor;
         }
         _enclosingExecutable = accessor;
       }
       node.functionExpression.element = _enclosingExecutable;
       return super.visitFunctionDeclaration(node);
     } finally {
       _enclosingExecutable = outerExecutable;
     }
   }
 
   Object visitFunctionExpression(FunctionExpression node) {
     if (node.parent is! FunctionDeclaration) {
-      FunctionElement element = findAtOffset(_enclosingExecutable.functions, node.beginToken.offset);
+      FunctionElement element = _findAtOffset(_enclosingExecutable.functions, node.beginToken.offset);
       node.element = element;
     }
     ExecutableElement outerExecutable = _enclosingExecutable;
     try {
       _enclosingExecutable = node.element;
       return super.visitFunctionExpression(node);
     } finally {
       _enclosingExecutable = outerExecutable;
     }
   }
 
   Object visitFunctionTypeAlias(FunctionTypeAlias node) {
     FunctionTypeAliasElement outerAlias = _enclosingAlias;
     try {
       SimpleIdentifier aliasName = node.name;
-      _enclosingAlias = findIdentifier(_enclosingUnit.functionTypeAliases, aliasName);
+      _enclosingAlias = _findIdentifier(_enclosingUnit.functionTypeAliases, aliasName);
       return super.visitFunctionTypeAlias(node);
     } finally {
       _enclosingAlias = outerAlias;
     }
   }
 
   Object visitFunctionTypedFormalParameter(FunctionTypedFormalParameter node) {
     if (node.parent is! DefaultFormalParameter) {
       SimpleIdentifier parameterName = node.identifier;
-      ParameterElement element = getElementForParameter(node, parameterName);
+      ParameterElement element = _getElementForParameter(node, parameterName);
       ParameterElement outerParameter = _enclosingParameter;
       try {
         _enclosingParameter = element;
         return super.visitFunctionTypedFormalParameter(node);
       } finally {
         _enclosingParameter = outerParameter;
       }
     } else {
       return super.visitFunctionTypedFormalParameter(node);
     }
   }
 
   Object visitImportDirective(ImportDirective node) {
-    String uri = getStringValue(node.uri);
+    String uri = _getStringValue(node.uri);
     if (uri != null) {
       LibraryElement library = _enclosingUnit.library;
-      ImportElement importElement = findImport(library.imports, _enclosingUnit.context.sourceFactory.resolveUri(_enclosingUnit.source, uri), node.prefix);
+      ImportElement importElement = _findImport(library.imports, _enclosingUnit.context.sourceFactory.resolveUri(_enclosingUnit.source, uri), node.prefix);
       node.element = importElement;
     }
     return super.visitImportDirective(node);
   }
 
   Object visitLabeledStatement(LabeledStatement node) {
     for (Label label in node.labels) {
       SimpleIdentifier labelName = label.label;
-      findIdentifier(_enclosingExecutable.labels, labelName);
+      _findIdentifier(_enclosingExecutable.labels, labelName);
     }
     return super.visitLabeledStatement(node);
   }
 
   Object visitLibraryDirective(LibraryDirective node) {
     node.element = _enclosingUnit.library;
     return super.visitLibraryDirective(node);
   }
 
   Object visitMethodDeclaration(MethodDeclaration node) {
     ExecutableElement outerExecutable = _enclosingExecutable;
     try {
       sc.Token property = node.propertyKeyword;
       SimpleIdentifier methodName = node.name;
       String nameOfMethod = methodName.name;
       if (nameOfMethod == sc.TokenType.MINUS.lexeme && node.parameters.parameters.length == 0) {
         nameOfMethod = "unary-";
       }
       if (property == null) {
-        _enclosingExecutable = findWithNameAndOffset(_enclosingClass.methods, nameOfMethod, methodName.offset);
+        _enclosingExecutable = _findWithNameAndOffset(_enclosingClass.methods, nameOfMethod, methodName.offset);
         methodName.staticElement = _enclosingExecutable;
       } else {
-        PropertyAccessorElement accessor = findIdentifier(_enclosingClass.accessors, methodName);
+        PropertyAccessorElement accessor = _findIdentifier(_enclosingClass.accessors, methodName);
         if (identical((property as sc.KeywordToken).keyword, sc.Keyword.SET)) {
           accessor = accessor.variable.setter;
           methodName.staticElement = accessor;
         }
         _enclosingExecutable = accessor;
       }
       return super.visitMethodDeclaration(node);
     } finally {
       _enclosingExecutable = outerExecutable;
     }
   }
 
   Object visitPartDirective(PartDirective node) {
-    String uri = getStringValue(node.uri);
+    String uri = _getStringValue(node.uri);
     if (uri != null) {
       Source partSource = _enclosingUnit.context.sourceFactory.resolveUri(_enclosingUnit.source, uri);
-      node.element = findPart(_enclosingUnit.library.parts, partSource);
+      node.element = _findPart(_enclosingUnit.library.parts, partSource);
     }
     return super.visitPartDirective(node);
   }
 
   Object visitPartOfDirective(PartOfDirective node) {
     node.element = _enclosingUnit.library;
     return super.visitPartOfDirective(node);
   }
 
   Object visitSimpleFormalParameter(SimpleFormalParameter node) {
     if (node.parent is! DefaultFormalParameter) {
       SimpleIdentifier parameterName = node.identifier;
-      ParameterElement element = getElementForParameter(node, parameterName);
+      ParameterElement element = _getElementForParameter(node, parameterName);
       ParameterElement outerParameter = _enclosingParameter;
       try {
         _enclosingParameter = element;
         return super.visitSimpleFormalParameter(node);
       } finally {
         _enclosingParameter = outerParameter;
       }
     } else {
     }
     return super.visitSimpleFormalParameter(node);
   }
 
   Object visitSwitchCase(SwitchCase node) {
     for (Label label in node.labels) {
       SimpleIdentifier labelName = label.label;
-      findIdentifier(_enclosingExecutable.labels, labelName);
+      _findIdentifier(_enclosingExecutable.labels, labelName);
     }
     return super.visitSwitchCase(node);
   }
 
   Object visitSwitchDefault(SwitchDefault node) {
     for (Label label in node.labels) {
       SimpleIdentifier labelName = label.label;
-      findIdentifier(_enclosingExecutable.labels, labelName);
+      _findIdentifier(_enclosingExecutable.labels, labelName);
     }
     return super.visitSwitchDefault(node);
   }
 
   Object visitTypeParameter(TypeParameter node) {
     SimpleIdentifier parameterName = node.name;
     if (_enclosingClass != null) {
-      findIdentifier(_enclosingClass.typeParameters, parameterName);
+      _findIdentifier(_enclosingClass.typeParameters, parameterName);
     } else if (_enclosingAlias != null) {
-      findIdentifier(_enclosingAlias.typeParameters, parameterName);
+      _findIdentifier(_enclosingAlias.typeParameters, parameterName);
     }
     return super.visitTypeParameter(node);
   }
 
   Object visitVariableDeclaration(VariableDeclaration node) {
     VariableElement element = null;
     SimpleIdentifier variableName = node.name;
     if (_enclosingExecutable != null) {
-      element = findIdentifier(_enclosingExecutable.localVariables, variableName);
+      element = _findIdentifier(_enclosingExecutable.localVariables, variableName);
     }
     if (element == null && _enclosingClass != null) {
-      element = findIdentifier(_enclosingClass.fields, variableName);
+      element = _findIdentifier(_enclosingClass.fields, variableName);
     }
     if (element == null && _enclosingUnit != null) {
-      element = findIdentifier(_enclosingUnit.topLevelVariables, variableName);
+      element = _findIdentifier(_enclosingUnit.topLevelVariables, variableName);
     }
     Expression initializer = node.initializer;
     if (initializer != null) {
       ExecutableElement outerExecutable = _enclosingExecutable;
       try {
         if (element == null) {
         } else {
           _enclosingExecutable = element.initializer;
         }
         return super.visitVariableDeclaration(node);
       } finally {
         _enclosingExecutable = outerExecutable;
       }
     }
     return super.visitVariableDeclaration(node);
   }
 
   /**
    * Return the element in the given array of elements that was created for the declaration at the
    * given offset. This method should only be used when there is no name
    *
    * @param elements the elements of the appropriate kind that exist in the current context
    * @param offset the offset of the name of the element to be returned
    * @return the element at the given offset
    */
-  Element findAtOffset(List<Element> elements, int offset) => findWithNameAndOffset(elements, "", offset);
+  Element _findAtOffset(List<Element> elements, int offset) => _findWithNameAndOffset(elements, "", offset);
 
   /**
    * Return the export element from the given array whose library has the given source, or
    * `null` if there is no such export.
    *
    * @param exports the export elements being searched
    * @param source the source of the library associated with the export element to being searched
    *          for
    * @return the export element whose library has the given source
    */
-  ExportElement findExport(List<ExportElement> exports, Source source) {
+  ExportElement _findExport(List<ExportElement> exports, Source source) {
     for (ExportElement export in exports) {
       if (export.exportedLibrary.source == source) {
         return export;
       }
     }
     return null;
   }
 
   /**
    * Return the element in the given array of elements that was created for the declaration with the
    * given name.
    *
    * @param elements the elements of the appropriate kind that exist in the current context
    * @param identifier the name node in the declaration of the element to be returned
    * @return the element created for the declaration with the given name
    */
-  Element findIdentifier(List<Element> elements, SimpleIdentifier identifier) {
-    Element element = findWithNameAndOffset(elements, identifier.name, identifier.offset);
+  Element _findIdentifier(List<Element> elements, SimpleIdentifier identifier) {
+    Element element = _findWithNameAndOffset(elements, identifier.name, identifier.offset);
     identifier.staticElement = element;
     return element;
   }
 
   /**
    * Return the import element from the given array whose library has the given source and that has
    * the given prefix, or `null` if there is no such import.
    *
    * @param imports the import elements being searched
    * @param source the source of the library associated with the import element to being searched
    *          for
    * @param prefix the prefix with which the library was imported
    * @return the import element whose library has the given source and prefix
    */
-  ImportElement findImport(List<ImportElement> imports, Source source, SimpleIdentifier prefix) {
+  ImportElement _findImport(List<ImportElement> imports, Source source, SimpleIdentifier prefix) {
     for (ImportElement element in imports) {
       if (element.importedLibrary.source == source) {
         PrefixElement prefixElement = element.prefix;
         if (prefix == null) {
           if (prefixElement == null) {
             return element;
           }
         } else {
           if (prefixElement != null && prefix.name == prefixElement.displayName) {
             return element;
           }
         }
       }
     }
     return null;
   }
 
   /**
    * Return the element for the part with the given source, or `null` if there is no element
    * for the given source.
    *
    * @param parts the elements for the parts
    * @param partSource the source for the part whose element is to be returned
    * @return the element for the part with the given source
    */
-  CompilationUnitElement findPart(List<CompilationUnitElement> parts, Source partSource) {
+  CompilationUnitElement _findPart(List<CompilationUnitElement> parts, Source partSource) {
     for (CompilationUnitElement part in parts) {
       if (part.source == partSource) {
         return part;
       }
     }
     return null;
   }
 
   /**
    * Return the element in the given array of elements that was created for the declaration with the
    * given name at the given offset.
    *
    * @param elements the elements of the appropriate kind that exist in the current context
    * @param name the name of the element to be returned
    * @param offset the offset of the name of the element to be returned
    * @return the element with the given name and offset
    */
-  Element findWithNameAndOffset(List<Element> elements, String name, int offset) {
+  Element _findWithNameAndOffset(List<Element> elements, String name, int offset) {
     for (Element element in elements) {
       if (element.displayName == name && element.nameOffset == offset) {
         return element;
       }
     }
     return null;
   }
 
   /**
    * Search the most closely enclosing list of parameters for a parameter with the given name.
    *
    * @param node the node defining the parameter with the given name
    * @param parameterName the name of the parameter being searched for
    * @return the element representing the parameter with that name
    */
-  ParameterElement getElementForParameter(FormalParameter node, SimpleIdentifier parameterName) {
+  ParameterElement _getElementForParameter(FormalParameter node, SimpleIdentifier parameterName) {
     List<ParameterElement> parameters = null;
     if (_enclosingParameter != null) {
       parameters = _enclosingParameter.parameters;
     }
     if (parameters == null && _enclosingExecutable != null) {
       parameters = _enclosingExecutable.parameters;
     }
     if (parameters == null && _enclosingAlias != null) {
       parameters = _enclosingAlias.parameters;
     }
-    ParameterElement element = parameters == null ? null : findIdentifier(parameters, parameterName);
+    ParameterElement element = parameters == null ? null : _findIdentifier(parameters, parameterName);
     if (element == null) {
       PrintStringWriter writer = new PrintStringWriter();
       writer.println("Invalid state found in the Analysis Engine:");
       writer.println("DeclarationResolver.getElementForParameter() is visiting a parameter that does not appear to be in a method or function.");
       writer.println("Ancestors:");
       AstNode parent = node.parent;
       while (parent != null) {
         writer.println(parent.runtimeType.toString());
         writer.println("---------");
         parent = parent.parent;
       }
       AnalysisEngine.instance.logger.logError2(writer.toString(), new AnalysisException());
     }
     return element;
   }
 
   /**
    * Return the value of the given string literal, or `null` if the string is not a constant
    * string without any string interpolation.
    *
    * @param literal the string literal whose value is to be returned
    * @return the value of the given string literal
    */
-  String getStringValue(StringLiteral literal) {
+  String _getStringValue(StringLiteral literal) {
     if (literal is StringInterpolation) {
       return null;
     }
     return literal.stringValue;
   }
 }
 
 /**
  * Instances of the class `ElementResolver` are used by instances of [ResolverVisitor]
  * to resolve references within the AST structure to the elements being referenced. The requirements
@@ skipping 61 matching lines @@
       }
     }
     return null;
   }
 
   /**
    * Return `true` if the given identifier is the return type of a constructor declaration.
    *
    * @return `true` if the given identifier is the return type of a constructor declaration.
    */
-  static bool isConstructorReturnType(SimpleIdentifier identifier) {
+  static bool _isConstructorReturnType(SimpleIdentifier identifier) {
     AstNode parent = identifier.parent;
     if (parent is ConstructorDeclaration) {
       return identical(parent.returnType, identifier);
     }
     return false;
   }
 
   /**
    * Return `true` if the given identifier is the return type of a factory constructor.
    *
    * @return `true` if the given identifier is the return type of a factory constructor
    *         declaration.
    */
-  static bool isFactoryConstructorReturnType(SimpleIdentifier node) {
+  static bool _isFactoryConstructorReturnType(SimpleIdentifier node) {
     AstNode parent = node.parent;
     if (parent is ConstructorDeclaration) {
       ConstructorDeclaration constructor = parent;
       return identical(constructor.returnType, node) && constructor.factoryKeyword != null;
     }
     return false;
   }
 
   /**
    * Return `true` if the given 'super' expression is used in a valid context.
    *
    * @param node the 'super' expression to analyze
    * @return `true` if the 'super' expression is in a valid context
    */
-  static bool isSuperInValidContext(SuperExpression node) {
+  static bool _isSuperInValidContext(SuperExpression node) {
     for (AstNode n = node; n != null; n = n.parent) {
       if (n is CompilationUnit) {
         return false;
       }
       if (n is ConstructorDeclaration) {
         ConstructorDeclaration constructor = n as ConstructorDeclaration;
         return constructor.factoryKeyword == null;
       }
       if (n is ConstructorFieldInitializer) {
         return false;
@@ skipping 66 matching lines @@
     _dynamicType = resolver.typeProvider.dynamicType;
     _typeType = resolver.typeProvider.typeType;
     _subtypeManager = new SubtypeManager();
     _promoteManager = resolver.promoteManager;
   }
 
   Object visitAssignmentExpression(AssignmentExpression node) {
     sc.Token operator = node.operator;
     sc.TokenType operatorType = operator.type;
     if (operatorType != sc.TokenType.EQ) {
-      operatorType = operatorFromCompoundAssignment(operatorType);
+      operatorType = _operatorFromCompoundAssignment(operatorType);
       Expression leftHandSide = node.leftHandSide;
       if (leftHandSide != null) {
         String methodName = operatorType.lexeme;
-        Type2 staticType = getStaticType(leftHandSide);
-        MethodElement staticMethod = lookUpMethod(leftHandSide, staticType, methodName);
+        Type2 staticType = _getStaticType(leftHandSide);
+        MethodElement staticMethod = _lookUpMethod(leftHandSide, staticType, methodName);
         node.staticElement = staticMethod;
-        Type2 propagatedType = getPropagatedType(leftHandSide);
-        MethodElement propagatedMethod = lookUpMethod(leftHandSide, propagatedType, methodName);
+        Type2 propagatedType = _getPropagatedType(leftHandSide);
+        MethodElement propagatedMethod = _lookUpMethod(leftHandSide, propagatedType, methodName);
         node.propagatedElement = propagatedMethod;
-        if (shouldReportMissingMember(staticType, staticMethod)) {
+        if (_shouldReportMissingMember(staticType, staticMethod)) {
           _resolver.reportErrorProxyConditionalAnalysisError(staticType.element, StaticTypeWarningCode.UNDEFINED_METHOD, operator, [methodName, staticType.displayName]);
-        } else if (_enableHints && shouldReportMissingMember(propagatedType, propagatedMethod) && !memberFoundInSubclass(propagatedType.element, methodName, true, false)) {
+        } else if (_enableHints && _shouldReportMissingMember(propagatedType, propagatedMethod) && !_memberFoundInSubclass(propagatedType.element, methodName, true, false)) {
           _resolver.reportErrorProxyConditionalAnalysisError(propagatedType.element, HintCode.UNDEFINED_METHOD, operator, [methodName, propagatedType.displayName]);
         }
       }
     }
     return null;
   }
 
   Object visitBinaryExpression(BinaryExpression node) {
     sc.Token operator = node.operator;
     if (operator.isUserDefinableOperator) {
       Expression leftOperand = node.leftOperand;
       if (leftOperand != null) {
         String methodName = operator.lexeme;
-        Type2 staticType = getStaticType(leftOperand);
-        MethodElement staticMethod = lookUpMethod(leftOperand, staticType, methodName);
+        Type2 staticType = _getStaticType(leftOperand);
+        MethodElement staticMethod = _lookUpMethod(leftOperand, staticType, methodName);
         node.staticElement = staticMethod;
-        Type2 propagatedType = getPropagatedType(leftOperand);
-        MethodElement propagatedMethod = lookUpMethod(leftOperand, propagatedType, methodName);
+        Type2 propagatedType = _getPropagatedType(leftOperand);
+        MethodElement propagatedMethod = _lookUpMethod(leftOperand, propagatedType, methodName);
         node.propagatedElement = propagatedMethod;
-        if (shouldReportMissingMember(staticType, staticMethod)) {
+        if (_shouldReportMissingMember(staticType, staticMethod)) {
           _resolver.reportErrorProxyConditionalAnalysisError(staticType.element, StaticTypeWarningCode.UNDEFINED_OPERATOR, operator, [methodName, staticType.displayName]);
-        } else if (_enableHints && shouldReportMissingMember(propagatedType, propagatedMethod) && !memberFoundInSubclass(propagatedType.element, methodName, true, false)) {
+        } else if (_enableHints && _shouldReportMissingMember(propagatedType, propagatedMethod) && !_memberFoundInSubclass(propagatedType.element, methodName, true, false)) {
           _resolver.reportErrorProxyConditionalAnalysisError(propagatedType.element, HintCode.UNDEFINED_OPERATOR, operator, [methodName, propagatedType.displayName]);
         }
       }
     }
     return null;
   }
 
   Object visitBreakStatement(BreakStatement node) {
-    lookupLabel(node, node.label);
+    _lookupLabel(node, node.label);
     return null;
   }
 
   Object visitClassDeclaration(ClassDeclaration node) {
-    setMetadata(node.element, node);
+    _setMetadata(node.element, node);
     return null;
   }
 
   Object visitClassTypeAlias(ClassTypeAlias node) {
-    setMetadata(node.element, node);
+    _setMetadata(node.element, node);
     return null;
   }
 
   Object visitCommentReference(CommentReference node) {
     Identifier identifier = node.identifier;
     if (identifier is SimpleIdentifier) {
       SimpleIdentifier simpleIdentifier = identifier;
-      Element element = resolveSimpleIdentifier(simpleIdentifier);
+      Element element = _resolveSimpleIdentifier(simpleIdentifier);
       if (element == null) {
         //
         // This might be a reference to an imported name that is missing the prefix.
         //
-        element = findImportWithoutPrefix(simpleIdentifier);
+        element = _findImportWithoutPrefix(simpleIdentifier);
         if (element is MultiplyDefinedElement) {
           // TODO(brianwilkerson) Report this error?
           element = null;
         }
       }
       if (element == null) {
       } else {
         if (element.library == null || element.library != _definingLibrary) {
         }
         simpleIdentifier.staticElement = element;
         if (node.newKeyword != null) {
           if (element is ClassElement) {
             ConstructorElement constructor = (element as ClassElement).unnamedConstructor;
             if (constructor == null) {
             } else {
               simpleIdentifier.staticElement = constructor;
             }
           } else {
           }
         }
       }
     } else if (identifier is PrefixedIdentifier) {
       PrefixedIdentifier prefixedIdentifier = identifier;
       SimpleIdentifier prefix = prefixedIdentifier.prefix;
       SimpleIdentifier name = prefixedIdentifier.identifier;
-      Element element = resolveSimpleIdentifier(prefix);
+      Element element = _resolveSimpleIdentifier(prefix);
       if (element == null) {
       } else {
         if (element is PrefixElement) {
           prefix.staticElement = element;
           // TODO(brianwilkerson) Report this error?
           element = _resolver.nameScope.lookup(identifier, _definingLibrary);
           name.staticElement = element;
           return null;
         }
         LibraryElement library = element.library;
         if (library == null) {
           // TODO(brianwilkerson) We need to understand how the library could ever be null.
           AnalysisEngine.instance.logger.logError("Found element with null library: ${element.name}");
         } else if (library != _definingLibrary) {
         }
         name.staticElement = element;
         if (node.newKeyword == null) {
           if (element is ClassElement) {
-            Element memberElement = lookupGetterOrMethod((element as ClassElement).type, name.name);
+            Element memberElement = _lookupGetterOrMethod((element as ClassElement).type, name.name);
             if (memberElement == null) {
               memberElement = (element as ClassElement).getNamedConstructor(name.name);
               if (memberElement == null) {
-                memberElement = lookUpSetter(prefix, (element as ClassElement).type, name.name);
+                memberElement = _lookUpSetter(prefix, (element as ClassElement).type, name.name);
               }
             }
             if (memberElement == null) {
             } else {
               name.staticElement = memberElement;
             }
           } else {
           }
         } else {
           if (element is ClassElement) {
@@ skipping 22 matching lines @@
         constructorElement.redirectedConstructor = redirectedElement;
       } else {
         // set redirected generative constructor
         for (ConstructorInitializer initializer in node.initializers) {
           if (initializer is RedirectingConstructorInvocation) {
             ConstructorElement redirectedElement = initializer.staticElement;
             constructorElement.redirectedConstructor = redirectedElement;
           }
         }
       }
-      setMetadata(constructorElement, node);
+      _setMetadata(constructorElement, node);
     }
     return null;
   }
 
   Object visitConstructorFieldInitializer(ConstructorFieldInitializer node) {
     SimpleIdentifier fieldName = node.fieldName;
     ClassElement enclosingClass = _resolver.enclosingClass;
     FieldElement fieldElement = enclosingClass.getField(fieldName.name);
     fieldName.staticElement = fieldElement;
     return null;
@@ skipping 25 matching lines @@
       constructor = interfaceType.lookUpConstructor(null, _definingLibrary);
     } else {
       constructor = interfaceType.lookUpConstructor(name.name, _definingLibrary);
       name.staticElement = constructor;
     }
     node.staticElement = constructor;
     return null;
   }
 
   Object visitContinueStatement(ContinueStatement node) {
-    lookupLabel(node, node.label);
+    _lookupLabel(node, node.label);
     return null;
   }
 
   Object visitDeclaredIdentifier(DeclaredIdentifier node) {
-    setMetadata(node.element, node);
+    _setMetadata(node.element, node);
     return null;
   }
 
   Object visitExportDirective(ExportDirective node) {
     ExportElement exportElement = node.element;
     if (exportElement != null) {
       // The element is null when the URI is invalid
       // TODO(brianwilkerson) Figure out whether the element can ever be something other than an
       // ExportElement
-      resolveCombinators(exportElement.exportedLibrary, node.combinators);
-      setMetadata(exportElement, node);
+      _resolveCombinators(exportElement.exportedLibrary, node.combinators);
+      _setMetadata(exportElement, node);
     }
     return null;
   }
 
   Object visitFieldFormalParameter(FieldFormalParameter node) {
-    setMetadataForParameter(node.element, node);
+    _setMetadataForParameter(node.element, node);
     return super.visitFieldFormalParameter(node);
   }
 
   Object visitFunctionDeclaration(FunctionDeclaration node) {
-    setMetadata(node.element, node);
+    _setMetadata(node.element, node);
     return null;
   }
 
   Object visitFunctionExpressionInvocation(FunctionExpressionInvocation node) {
     // TODO(brianwilkerson) Can we ever resolve the function being invoked?
     Expression expression = node.function;
     if (expression is FunctionExpression) {
       FunctionExpression functionExpression = expression;
       ExecutableElement functionElement = functionExpression.element;
       ArgumentList argumentList = node.argumentList;
-      List<ParameterElement> parameters = resolveArgumentsToFunction(false, argumentList, functionElement);
+      List<ParameterElement> parameters = _resolveArgumentsToFunction(false, argumentList, functionElement);
       if (parameters != null) {
         argumentList.correspondingStaticParameters = parameters;
       }
     }
     return null;
   }
 
   Object visitFunctionTypeAlias(FunctionTypeAlias node) {
-    setMetadata(node.element, node);
+    _setMetadata(node.element, node);
     return null;
   }
 
   Object visitFunctionTypedFormalParameter(FunctionTypedFormalParameter node) {
-    setMetadataForParameter(node.element, node);
+    _setMetadataForParameter(node.element, node);
     return null;
   }
 
   Object visitImportDirective(ImportDirective node) {
     SimpleIdentifier prefixNode = node.prefix;
     if (prefixNode != null) {
       String prefixName = prefixNode.name;
       for (PrefixElement prefixElement in _definingLibrary.prefixes) {
         if (prefixElement.displayName == prefixName) {
           prefixNode.staticElement = prefixElement;
           break;
         }
       }
     }
     ImportElement importElement = node.element;
     if (importElement != null) {
       // The element is null when the URI is invalid
       LibraryElement library = importElement.importedLibrary;
       if (library != null) {
-        resolveCombinators(library, node.combinators);
+        _resolveCombinators(library, node.combinators);
       }
-      setMetadata(importElement, node);
+      _setMetadata(importElement, node);
     }
     return null;
   }
 
   Object visitIndexExpression(IndexExpression node) {
     Expression target = node.realTarget;
-    Type2 staticType = getStaticType(target);
-    Type2 propagatedType = getPropagatedType(target);
+    Type2 staticType = _getStaticType(target);
+    Type2 propagatedType = _getPropagatedType(target);
     String getterMethodName = sc.TokenType.INDEX.lexeme;
     String setterMethodName = sc.TokenType.INDEX_EQ.lexeme;
     bool isInGetterContext = node.inGetterContext();
     bool isInSetterContext = node.inSetterContext();
     if (isInGetterContext && isInSetterContext) {
       // lookup setter
-      MethodElement setterStaticMethod = lookUpMethod(target, staticType, setterMethodName);
-      MethodElement setterPropagatedMethod = lookUpMethod(target, propagatedType, setterMethodName);
+      MethodElement setterStaticMethod = _lookUpMethod(target, staticType, setterMethodName);
+      MethodElement setterPropagatedMethod = _lookUpMethod(target, propagatedType, setterMethodName);
       // set setter element
       node.staticElement = setterStaticMethod;
       node.propagatedElement = setterPropagatedMethod;
       // generate undefined method warning
-      checkForUndefinedIndexOperator(node, target, getterMethodName, setterStaticMethod, setterPropagatedMethod, staticType, propagatedType);
+      _checkForUndefinedIndexOperator(node, target, getterMethodName, setterStaticMethod, setterPropagatedMethod, staticType, propagatedType);
       // lookup getter method
-      MethodElement getterStaticMethod = lookUpMethod(target, staticType, getterMethodName);
-      MethodElement getterPropagatedMethod = lookUpMethod(target, propagatedType, getterMethodName);
+      MethodElement getterStaticMethod = _lookUpMethod(target, staticType, getterMethodName);
+      MethodElement getterPropagatedMethod = _lookUpMethod(target, propagatedType, getterMethodName);
       // set getter element
       AuxiliaryElements auxiliaryElements = new AuxiliaryElements(getterStaticMethod, getterPropagatedMethod);
       node.auxiliaryElements = auxiliaryElements;
       // generate undefined method warning
-      checkForUndefinedIndexOperator(node, target, getterMethodName, getterStaticMethod, getterPropagatedMethod, staticType, propagatedType);
+      _checkForUndefinedIndexOperator(node, target, getterMethodName, getterStaticMethod, getterPropagatedMethod, staticType, propagatedType);
     } else if (isInGetterContext) {
       // lookup getter method
-      MethodElement staticMethod = lookUpMethod(target, staticType, getterMethodName);
-      MethodElement propagatedMethod = lookUpMethod(target, propagatedType, getterMethodName);
+      MethodElement staticMethod = _lookUpMethod(target, staticType, getterMethodName);
+      MethodElement propagatedMethod = _lookUpMethod(target, propagatedType, getterMethodName);
       // set getter element
       node.staticElement = staticMethod;
       node.propagatedElement = propagatedMethod;
       // generate undefined method warning
-      checkForUndefinedIndexOperator(node, target, getterMethodName, staticMethod, propagatedMethod, staticType, propagatedType);
+      _checkForUndefinedIndexOperator(node, target, getterMethodName, staticMethod, propagatedMethod, staticType, propagatedType);
     } else if (isInSetterContext) {
       // lookup setter method
-      MethodElement staticMethod = lookUpMethod(target, staticType, setterMethodName);
-      MethodElement propagatedMethod = lookUpMethod(target, propagatedType, setterMethodName);
+      MethodElement staticMethod = _lookUpMethod(target, staticType, setterMethodName);
+      MethodElement propagatedMethod = _lookUpMethod(target, propagatedType, setterMethodName);
       // set setter element
       node.staticElement = staticMethod;
       node.propagatedElement = propagatedMethod;
       // generate undefined method warning
-      checkForUndefinedIndexOperator(node, target, setterMethodName, staticMethod, propagatedMethod, staticType, propagatedType);
+      _checkForUndefinedIndexOperator(node, target, setterMethodName, staticMethod, propagatedMethod, staticType, propagatedType);
     }
     return null;
   }
 
   Object visitInstanceCreationExpression(InstanceCreationExpression node) {
     ConstructorElement invokedConstructor = node.constructorName.staticElement;
     node.staticElement = invokedConstructor;
     ArgumentList argumentList = node.argumentList;
-    List<ParameterElement> parameters = resolveArgumentsToFunction(node.isConst, argumentList, invokedConstructor);
+    List<ParameterElement> parameters = _resolveArgumentsToFunction(node.isConst, argumentList, invokedConstructor);
     if (parameters != null) {
       argumentList.correspondingStaticParameters = parameters;
     }
     return null;
   }
 
   Object visitLibraryDirective(LibraryDirective node) {
-    setMetadata(node.element, node);
+    _setMetadata(node.element, node);
     return null;
   }
 
   Object visitMethodDeclaration(MethodDeclaration node) {
-    setMetadata(node.element, node);
+    _setMetadata(node.element, node);
     return null;
   }
 
   Object visitMethodInvocation(MethodInvocation node) {
     SimpleIdentifier methodName = node.methodName;
     //
     // Synthetic identifiers have been already reported during parsing.
     //
     if (methodName.isSynthetic) {
       return null;
     }
     //
     // We have a method invocation of one of two forms: 'e.m(a1, ..., an)' or 'm(a1, ..., an)'. The
     // first step is to figure out which executable is being invoked, using both the static and the
     // propagated type information.
     //
     Expression target = node.realTarget;
-    if (target is SuperExpression && !isSuperInValidContext(target)) {
+    if (target is SuperExpression && !_isSuperInValidContext(target)) {
       return null;
     }
     Element staticElement;
     Element propagatedElement;
     if (target == null) {
-      staticElement = resolveInvokedElement(methodName);
+      staticElement = _resolveInvokedElement(methodName);
       propagatedElement = null;
     } else {
-      Type2 staticType = getStaticType(target);
+      Type2 staticType = _getStaticType(target);
       //
       // If this method invocation is of the form 'C.m' where 'C' is a class, then we don't call
       // resolveInvokedElement(..) which walks up the class hierarchy, instead we just look for the
       // member in the type only.
       //
       ClassElementImpl typeReference = getTypeReference(target);
       if (typeReference != null) {
-        staticElement = propagatedElement = resolveElement(typeReference, methodName);
+        staticElement = propagatedElement = _resolveElement(typeReference, methodName);
       } else {
-        staticElement = resolveInvokedElementWithTarget(target, staticType, methodName);
-        propagatedElement = resolveInvokedElementWithTarget(target, getPropagatedType(target), methodName);
+        staticElement = _resolveInvokedElementWithTarget(target, staticType, methodName);
+        propagatedElement = _resolveInvokedElementWithTarget(target, _getPropagatedType(target), methodName);
       }
     }
-    staticElement = convertSetterToGetter(staticElement);
-    propagatedElement = convertSetterToGetter(propagatedElement);
+    staticElement = _convertSetterToGetter(staticElement);
+    propagatedElement = _convertSetterToGetter(propagatedElement);
     //
     // Record the results.
     //
     methodName.staticElement = staticElement;
     methodName.propagatedElement = propagatedElement;
     ArgumentList argumentList = node.argumentList;
     if (staticElement != null) {
-      List<ParameterElement> parameters = computeCorrespondingParameters(argumentList, staticElement);
+      List<ParameterElement> parameters = _computeCorrespondingParameters(argumentList, staticElement);
       if (parameters != null) {
         argumentList.correspondingStaticParameters = parameters;
       }
     }
     if (propagatedElement != null) {
-      List<ParameterElement> parameters = computeCorrespondingParameters(argumentList, propagatedElement);
+      List<ParameterElement> parameters = _computeCorrespondingParameters(argumentList, propagatedElement);
       if (parameters != null) {
         argumentList.correspondingPropagatedParameters = parameters;
       }
     }
     //
     // Then check for error conditions.
     //
-    ErrorCode errorCode = checkForInvocationError(target, true, staticElement);
+    ErrorCode errorCode = _checkForInvocationError(target, true, staticElement);
     bool generatedWithTypePropagation = false;
     if (_enableHints && errorCode == null && staticElement == null) {
-      errorCode = checkForInvocationError(target, false, propagatedElement);
+      errorCode = _checkForInvocationError(target, false, propagatedElement);
       if (identical(errorCode, StaticTypeWarningCode.UNDEFINED_METHOD)) {
         ClassElement classElementContext = null;
         if (target == null) {
           classElementContext = _resolver.enclosingClass;
         } else {
           Type2 type = target.bestType;
           if (type != null) {
             if (type.element is ClassElement) {
               classElementContext = type.element as ClassElement;
             }
@@ skipping 24 matching lines @@
         ClassElement enclosingClass = _resolver.enclosingClass;
         targetTypeName = enclosingClass.displayName;
         ErrorCode proxyErrorCode = (generatedWithTypePropagation ? HintCode.UNDEFINED_METHOD : StaticTypeWarningCode.UNDEFINED_METHOD) as ErrorCode;
         _resolver.reportProxyConditionalErrorForNode(_resolver.enclosingClass, proxyErrorCode, methodName, [methodName.name, targetTypeName]);
       } else {
         // ignore Function "call"
         // (if we are about to create a hint using type propagation, then we can use type
         // propagation here as well)
         Type2 targetType = null;
         if (!generatedWithTypePropagation) {
-          targetType = getStaticType(target);
+          targetType = _getStaticType(target);
         } else {
           // choose the best type
-          targetType = getPropagatedType(target);
+          targetType = _getPropagatedType(target);
           if (targetType == null) {
-            targetType = getStaticType(target);
+            targetType = _getStaticType(target);
           }
         }
         if (targetType != null && targetType.isDartCoreFunction && methodName.name == CALL_METHOD_NAME) {
           // TODO(brianwilkerson) Can we ever resolve the function being invoked?
           //resolveArgumentsToParameters(node.getArgumentList(), invokedFunction);
           return null;
         }
         targetTypeName = targetType == null ? null : targetType.displayName;
         ErrorCode proxyErrorCode = (generatedWithTypePropagation ? HintCode.UNDEFINED_METHOD : StaticTypeWarningCode.UNDEFINED_METHOD) as ErrorCode;
         _resolver.reportProxyConditionalErrorForNode(targetType.element, proxyErrorCode, methodName, [methodName.name, targetTypeName]);
       }
     } else if (identical(errorCode, StaticTypeWarningCode.UNDEFINED_SUPER_METHOD)) {
       // Generate the type name.
       // The error code will never be generated via type propagation
-      Type2 targetType = getStaticType(target);
+      Type2 targetType = _getStaticType(target);
       String targetTypeName = targetType == null ? null : targetType.name;
       _resolver.reportErrorForNode(StaticTypeWarningCode.UNDEFINED_SUPER_METHOD, methodName, [methodName.name, targetTypeName]);
     }
     return null;
   }
 
   Object visitPartDirective(PartDirective node) {
-    setMetadata(node.element, node);
+    _setMetadata(node.element, node);
     return null;
   }
 
   Object visitPartOfDirective(PartOfDirective node) {
-    setMetadata(node.element, node);
+    _setMetadata(node.element, node);
     return null;
   }
 
   Object visitPostfixExpression(PostfixExpression node) {
     Expression operand = node.operand;
-    String methodName = getPostfixOperator(node);
-    Type2 staticType = getStaticType(operand);
-    MethodElement staticMethod = lookUpMethod(operand, staticType, methodName);
+    String methodName = _getPostfixOperator(node);
+    Type2 staticType = _getStaticType(operand);
+    MethodElement staticMethod = _lookUpMethod(operand, staticType, methodName);
     node.staticElement = staticMethod;
-    Type2 propagatedType = getPropagatedType(operand);
-    MethodElement propagatedMethod = lookUpMethod(operand, propagatedType, methodName);
+    Type2 propagatedType = _getPropagatedType(operand);
+    MethodElement propagatedMethod = _lookUpMethod(operand, propagatedType, methodName);
     node.propagatedElement = propagatedMethod;
-    if (shouldReportMissingMember(staticType, staticMethod)) {
+    if (_shouldReportMissingMember(staticType, staticMethod)) {
       _resolver.reportErrorProxyConditionalAnalysisError(staticType.element, StaticTypeWarningCode.UNDEFINED_OPERATOR, node.operator, [methodName, staticType.displayName]);
-    } else if (_enableHints && shouldReportMissingMember(propagatedType, propagatedMethod) && !memberFoundInSubclass(propagatedType.element, methodName, true, false)) {
+    } else if (_enableHints && _shouldReportMissingMember(propagatedType, propagatedMethod) && !_memberFoundInSubclass(propagatedType.element, methodName, true, false)) {
       _resolver.reportErrorProxyConditionalAnalysisError(propagatedType.element, HintCode.UNDEFINED_OPERATOR, node.operator, [methodName, propagatedType.displayName]);
     }
     return null;
   }
 
   Object visitPrefixedIdentifier(PrefixedIdentifier node) {
     SimpleIdentifier prefix = node.prefix;
     SimpleIdentifier identifier = node.identifier;
     //
     // First, check to see whether the prefix is really a prefix.
@@ skipping 24 matching lines @@
             element = setter;
           }
         }
       }
       // TODO(brianwilkerson) The prefix needs to be resolved to the element for the import that
       // defines the prefix, not the prefix's element.
       identifier.staticElement = element;
       // Validate annotation element.
       if (node.parent is Annotation) {
         Annotation annotation = node.parent as Annotation;
-        resolveAnnotationElement(annotation);
+        _resolveAnnotationElement(annotation);
         return null;
       }
       return null;
     }
     // May be annotation, resolve invocation of "const" constructor.
     if (node.parent is Annotation) {
       Annotation annotation = node.parent as Annotation;
-      resolveAnnotationElement(annotation);
+      _resolveAnnotationElement(annotation);
     }
     //
     // Otherwise, the prefix is really an expression that happens to be a simple identifier and this
     // is really equivalent to a property access node.
     //
-    resolvePropertyAccess(prefix, identifier);
+    _resolvePropertyAccess(prefix, identifier);
     return null;
   }
 
   Object visitPrefixExpression(PrefixExpression node) {
     sc.Token operator = node.operator;
     sc.TokenType operatorType = operator.type;
     if (operatorType.isUserDefinableOperator || identical(operatorType, sc.TokenType.PLUS_PLUS) || identical(operatorType, sc.TokenType.MINUS_MINUS)) {
       Expression operand = node.operand;
-      String methodName = getPrefixOperator(node);
-      Type2 staticType = getStaticType(operand);
-      MethodElement staticMethod = lookUpMethod(operand, staticType, methodName);
+      String methodName = _getPrefixOperator(node);
+      Type2 staticType = _getStaticType(operand);
+      MethodElement staticMethod = _lookUpMethod(operand, staticType, methodName);
       node.staticElement = staticMethod;
-      Type2 propagatedType = getPropagatedType(operand);
-      MethodElement propagatedMethod = lookUpMethod(operand, propagatedType, methodName);
+      Type2 propagatedType = _getPropagatedType(operand);
+      MethodElement propagatedMethod = _lookUpMethod(operand, propagatedType, methodName);
       node.propagatedElement = propagatedMethod;
-      if (shouldReportMissingMember(staticType, staticMethod)) {
+      if (_shouldReportMissingMember(staticType, staticMethod)) {
         _resolver.reportErrorProxyConditionalAnalysisError(staticType.element, StaticTypeWarningCode.UNDEFINED_OPERATOR, operator, [methodName, staticType.displayName]);
-      } else if (_enableHints && shouldReportMissingMember(propagatedType, propagatedMethod) && !memberFoundInSubclass(propagatedType.element, methodName, true, false)) {
+      } else if (_enableHints && _shouldReportMissingMember(propagatedType, propagatedMethod) && !_memberFoundInSubclass(propagatedType.element, methodName, true, false)) {
         _resolver.reportErrorProxyConditionalAnalysisError(propagatedType.element, HintCode.UNDEFINED_OPERATOR, operator, [methodName, propagatedType.displayName]);
       }
     }
     return null;
   }
 
   Object visitPropertyAccess(PropertyAccess node) {
     Expression target = node.realTarget;
-    if (target is SuperExpression && !isSuperInValidContext(target)) {
+    if (target is SuperExpression && !_isSuperInValidContext(target)) {
       return null;
     }
     SimpleIdentifier propertyName = node.propertyName;
-    resolvePropertyAccess(target, propertyName);
+    _resolvePropertyAccess(target, propertyName);
     return null;
   }
 
   Object visitRedirectingConstructorInvocation(RedirectingConstructorInvocation node) {
     ClassElement enclosingClass = _resolver.enclosingClass;
     if (enclosingClass == null) {
       // TODO(brianwilkerson) Report this error.
       return null;
     }
     SimpleIdentifier name = node.constructorName;
     ConstructorElement element;
     if (name == null) {
       element = enclosingClass.unnamedConstructor;
     } else {
       element = enclosingClass.getNamedConstructor(name.name);
     }
     if (element == null) {
       // TODO(brianwilkerson) Report this error and decide what element to associate with the node.
       return null;
     }
     if (name != null) {
       name.staticElement = element;
     }
     node.staticElement = element;
     ArgumentList argumentList = node.argumentList;
-    List<ParameterElement> parameters = resolveArgumentsToFunction(false, argumentList, element);
+    List<ParameterElement> parameters = _resolveArgumentsToFunction(false, argumentList, element);
     if (parameters != null) {
       argumentList.correspondingStaticParameters = parameters;
     }
     return null;
   }
 
   Object visitSimpleFormalParameter(SimpleFormalParameter node) {
-    setMetadataForParameter(node.element, node);
+    _setMetadataForParameter(node.element, node);
     return null;
   }
 
   Object visitSimpleIdentifier(SimpleIdentifier node) {
     //
     // Synthetic identifiers have been already reported during parsing.
     //
     if (node.isSynthetic) {
       return null;
     }
     //
     // We ignore identifiers that have already been resolved, such as identifiers representing the
     // name in a declaration.
     //
     if (node.staticElement != null) {
       return null;
     }
     //
     // The name dynamic denotes a Type object even though dynamic is not a class.
     //
     if (node.name == _dynamicType.name) {
       node.staticElement = _dynamicType.element;
       node.staticType = _typeType;
       return null;
     }
     //
     // Otherwise, the node should be resolved.
     //
-    Element element = resolveSimpleIdentifier(node);
+    Element element = _resolveSimpleIdentifier(node);
     ClassElement enclosingClass = _resolver.enclosingClass;
-    if (isFactoryConstructorReturnType(node) && element != enclosingClass) {
+    if (_isFactoryConstructorReturnType(node) && element != enclosingClass) {
       _resolver.reportErrorForNode(CompileTimeErrorCode.INVALID_FACTORY_NAME_NOT_A_CLASS, node, []);
-    } else if (isConstructorReturnType(node) && element != enclosingClass) {
+    } else if (_isConstructorReturnType(node) && element != enclosingClass) {
       _resolver.reportErrorForNode(CompileTimeErrorCode.INVALID_CONSTRUCTOR_NAME, node, []);
       element = null;
-    } else if (element == null || (element is PrefixElement && !isValidAsPrefix(node))) {
+    } else if (element == null || (element is PrefixElement && !_isValidAsPrefix(node))) {
       // TODO(brianwilkerson) Recover from this error.
-      if (isConstructorReturnType(node)) {
+      if (_isConstructorReturnType(node)) {
         _resolver.reportErrorForNode(CompileTimeErrorCode.INVALID_CONSTRUCTOR_NAME, node, []);
       } else if (node.parent is Annotation) {
         Annotation annotation = node.parent as Annotation;
         _resolver.reportErrorForNode(CompileTimeErrorCode.INVALID_ANNOTATION, annotation, []);
       } else {
         _resolver.reportProxyConditionalErrorForNode(_resolver.enclosingClass, StaticWarningCode.UNDEFINED_IDENTIFIER, node, [node.name]);
       }
     }
     node.staticElement = element;
     if (node.inSetterContext() && node.inGetterContext() && enclosingClass != null) {
       InterfaceType enclosingType = enclosingClass.type;
-      AuxiliaryElements auxiliaryElements = new AuxiliaryElements(lookUpGetter(null, enclosingType, node.name), null);
+      AuxiliaryElements auxiliaryElements = new AuxiliaryElements(_lookUpGetter(null, enclosingType, node.name), null);
       node.auxiliaryElements = auxiliaryElements;
     }
     //
     // Validate annotation element.
     //
     if (node.parent is Annotation) {
       Annotation annotation = node.parent as Annotation;
-      resolveAnnotationElement(annotation);
+      _resolveAnnotationElement(annotation);
     }
     return null;
   }
 
   Object visitSuperConstructorInvocation(SuperConstructorInvocation node) {
     ClassElement enclosingClass = _resolver.enclosingClass;
     if (enclosingClass == null) {
       // TODO(brianwilkerson) Report this error.
       return null;
     }
@@ skipping 15 matching lines @@
     } else {
       if (element.isFactory) {
         _resolver.reportErrorForNode(CompileTimeErrorCode.NON_GENERATIVE_CONSTRUCTOR, node, [element]);
       }
     }
     if (name != null) {
       name.staticElement = element;
     }
     node.staticElement = element;
     ArgumentList argumentList = node.argumentList;
-    List<ParameterElement> parameters = resolveArgumentsToFunction(isInConstConstructor, argumentList, element);
+    List<ParameterElement> parameters = _resolveArgumentsToFunction(isInConstConstructor, argumentList, element);
     if (parameters != null) {
       argumentList.correspondingStaticParameters = parameters;
     }
     return null;
   }
 
   Object visitSuperExpression(SuperExpression node) {
-    if (!isSuperInValidContext(node)) {
+    if (!_isSuperInValidContext(node)) {
       _resolver.reportErrorForNode(CompileTimeErrorCode.SUPER_IN_INVALID_CONTEXT, node, []);
     }
     return super.visitSuperExpression(node);
   }
 
   Object visitTypeParameter(TypeParameter node) {
-    setMetadata(node.element, node);
+    _setMetadata(node.element, node);
     return null;
   }
 
   Object visitVariableDeclaration(VariableDeclaration node) {
-    setMetadata(node.element, node);
+    _setMetadata(node.element, node);
     return null;
   }
 
   /**
    * Generate annotation elements for each of the annotations in the given node list and add them to
    * the given list of elements.
    *
    * @param annotationList the list of elements to which new elements are to be added
    * @param annotations the AST nodes used to generate new elements
    */
-  void addAnnotations(List<ElementAnnotationImpl> annotationList, NodeList<Annotation> annotations) {
+  void _addAnnotations(List<ElementAnnotationImpl> annotationList, NodeList<Annotation> annotations) {
     int annotationCount = annotations.length;
     for (int i = 0; i < annotationCount; i++) {
       Element resolvedElement = annotations[i].element;
       if (resolvedElement != null) {
         annotationList.add(new ElementAnnotationImpl(resolvedElement));
       }
     }
   }
 
   /**
    * Given that we have found code to invoke the given element, return the error code that should be
    * reported, or `null` if no error should be reported.
    *
    * @param target the target of the invocation, or `null` if there was no target
    * @param useStaticContext
    * @param element the element to be invoked
    * @return the error code that should be reported
    */
-  ErrorCode checkForInvocationError(Expression target, bool useStaticContext, Element element) {
+  ErrorCode _checkForInvocationError(Expression target, bool useStaticContext, Element element) {
     // Prefix is not declared, instead "prefix.id" are declared.
     if (element is PrefixElement) {
       element = null;
     }
     if (element is PropertyAccessorElement) {
       //
       // This is really a function expression invocation.
       //
       // TODO(brianwilkerson) Consider the possibility of re-writing the AST.
       FunctionType getterType = element.type;
       if (getterType != null) {
         Type2 returnType = getterType.returnType;
-        if (!isExecutableType(returnType)) {
+        if (!_isExecutableType(returnType)) {
           return StaticTypeWarningCode.INVOCATION_OF_NON_FUNCTION;
         }
       }
     } else if (element is ExecutableElement) {
       return null;
     } else if (element == null && target is SuperExpression) {
       // TODO(jwren) We should split the UNDEFINED_METHOD into two error codes, this one, and
       // a code that describes the situation where the method was found, but it was not
       // accessible from the current library.
       return StaticTypeWarningCode.UNDEFINED_SUPER_METHOD;
     } else {
       //
       // This is really a function expression invocation.
       //
       // TODO(brianwilkerson) Consider the possibility of re-writing the AST.
       if (element is PropertyInducingElement) {
         PropertyAccessorElement getter = element.getter;
         FunctionType getterType = getter.type;
         if (getterType != null) {
           Type2 returnType = getterType.returnType;
-          if (!isExecutableType(returnType)) {
+          if (!_isExecutableType(returnType)) {
             return StaticTypeWarningCode.INVOCATION_OF_NON_FUNCTION;
           }
         }
       } else if (element is VariableElement) {
         Type2 variableType = element.type;
-        if (!isExecutableType(variableType)) {
+        if (!_isExecutableType(variableType)) {
           return StaticTypeWarningCode.INVOCATION_OF_NON_FUNCTION;
         }
       } else {
         if (target == null) {
           ClassElement enclosingClass = _resolver.enclosingClass;
           if (enclosingClass == null) {
             return CompileTimeErrorCode.UNDEFINED_FUNCTION;
           } else if (element == null) {
             // Proxy-conditional warning, based on state of resolver.getEnclosingClass()
             return StaticTypeWarningCode.UNDEFINED_METHOD;
           } else {
             return StaticTypeWarningCode.INVOCATION_OF_NON_FUNCTION;
           }
         } else {
           Type2 targetType;
           if (useStaticContext) {
-            targetType = getStaticType(target);
+            targetType = _getStaticType(target);
           } else {
             // Compute and use the propagated type, if it is null, then it may be the case that
             // static type is some type, in which the static type should be used.
             targetType = target.bestType;
           }
           if (targetType == null) {
             return CompileTimeErrorCode.UNDEFINED_FUNCTION;
           } else if (!targetType.isDynamic && !targetType.isBottom) {
             // Proxy-conditional warning, based on state of targetType.getElement()
             return StaticTypeWarningCode.UNDEFINED_METHOD;
           }
         }
       }
     }
     return null;
   }
 
   /**
    * Check that the for some index expression that the method element was resolved, otherwise a
    * [StaticWarningCode#UNDEFINED_OPERATOR] is generated.
    *
    * @param node the index expression to resolve
    * @param target the target of the expression
    * @param methodName the name of the operator associated with the context of using of the given
    *          index expression
    * @return `true` if and only if an error code is generated on the passed node
    */
-  bool checkForUndefinedIndexOperator(IndexExpression node, Expression target, String methodName, MethodElement staticMethod, MethodElement propagatedMethod, Type2 staticType, Type2 propagatedType) {
-    bool shouldReportMissingMember_static = shouldReportMissingMember(staticType, staticMethod);
-    bool shouldReportMissingMember_propagated = !shouldReportMissingMember_static && _enableHints && shouldReportMissingMember(propagatedType, propagatedMethod) && !memberFoundInSubclass(propagatedType.element, methodName, true, false);
+  bool _checkForUndefinedIndexOperator(IndexExpression node, Expression target, String methodName, MethodElement staticMethod, MethodElement propagatedMethod, Type2 staticType, Type2 propagatedType) {
+    bool shouldReportMissingMember_static = _shouldReportMissingMember(staticType, staticMethod);
+    bool shouldReportMissingMember_propagated = !shouldReportMissingMember_static && _enableHints && _shouldReportMissingMember(propagatedType, propagatedMethod) && !_memberFoundInSubclass(propagatedType.element, methodName, true, false);
     if (shouldReportMissingMember_static || shouldReportMissingMember_propagated) {
       sc.Token leftBracket = node.leftBracket;
       sc.Token rightBracket = node.rightBracket;
       ErrorCode errorCode = (shouldReportMissingMember_static ? StaticTypeWarningCode.UNDEFINED_OPERATOR : HintCode.UNDEFINED_OPERATOR) as ErrorCode;
       if (leftBracket == null || rightBracket == null) {
         _resolver.reportProxyConditionalErrorForNode(shouldReportMissingMember_static ? staticType.element : propagatedType.element, errorCode, node, [
             methodName,
             shouldReportMissingMember_static ? staticType.displayName : propagatedType.displayName]);
       } else {
         int offset = leftBracket.offset;
         int length = rightBracket.offset - offset + 1;
         _resolver.reportProxyConditionalErrorForOffset(shouldReportMissingMember_static ? staticType.element : propagatedType.element, errorCode, offset, length, [
             methodName,
             shouldReportMissingMember_static ? staticType.displayName : propagatedType.displayName]);
       }
       return true;
     }
     return false;
   }
 
   /**
    * Given a list of arguments and the element that will be invoked using those argument, compute
    * the list of parameters that correspond to the list of arguments. Return the parameters that
    * correspond to the arguments, or `null` if no correspondence could be computed.
    *
    * @param argumentList the list of arguments being passed to the element
    * @param executableElement the element that will be invoked with the arguments
    * @return the parameters that correspond to the arguments
    */
-  List<ParameterElement> computeCorrespondingParameters(ArgumentList argumentList, Element element) {
+  List<ParameterElement> _computeCorrespondingParameters(ArgumentList argumentList, Element element) {
     if (element is PropertyAccessorElement) {
       //
       // This is an invocation of the call method defined on the value returned by the getter.
       //
       FunctionType getterType = element.type;
       if (getterType != null) {
         Type2 getterReturnType = getterType.returnType;
         if (getterReturnType is InterfaceType) {
           MethodElement callMethod = getterReturnType.lookUpMethod(CALL_METHOD_NAME, _definingLibrary);
           if (callMethod != null) {
-            return resolveArgumentsToFunction(false, argumentList, callMethod);
+            return _resolveArgumentsToFunction(false, argumentList, callMethod);
           }
         } else if (getterReturnType is FunctionType) {
           Element functionElement = getterReturnType.element;
           if (functionElement is ExecutableElement) {
-            return resolveArgumentsToFunction(false, argumentList, functionElement);
+            return _resolveArgumentsToFunction(false, argumentList, functionElement);
           }
         }
       }
     } else if (element is ExecutableElement) {
-      return resolveArgumentsToFunction(false, argumentList, element);
+      return _resolveArgumentsToFunction(false, argumentList, element);
     } else if (element is VariableElement) {
       VariableElement variable = element;
       Type2 type = _promoteManager.getStaticType(variable);
       if (type is FunctionType) {
         FunctionType functionType = type;
         List<ParameterElement> parameters = functionType.parameters;
-        return resolveArgumentsToParameters(false, argumentList, parameters);
+        return _resolveArgumentsToParameters(false, argumentList, parameters);
       } else if (type is InterfaceType) {
         // "call" invocation
         MethodElement callMethod = type.lookUpMethod(CALL_METHOD_NAME, _definingLibrary);
         if (callMethod != null) {
           List<ParameterElement> parameters = callMethod.parameters;
-          return resolveArgumentsToParameters(false, argumentList, parameters);
+          return _resolveArgumentsToParameters(false, argumentList, parameters);
         }
       }
     }
     return null;
   }
 
   /**
    * If the given element is a setter, return the getter associated with it. Otherwise, return the
    * element unchanged.
    *
    * @param element the element to be normalized
    * @return a non-setter element derived from the given element
    */
-  Element convertSetterToGetter(Element element) {
+  Element _convertSetterToGetter(Element element) {
     // TODO(brianwilkerson) Determine whether and why the element could ever be a setter.
     if (element is PropertyAccessorElement) {
       return element.variable.getter;
     }
     return element;
   }
 
   /**
    * Look for any declarations of the given identifier that are imported using a prefix. Return the
    * element that was found, or `null` if the name is not imported using a prefix.
    *
    * @param identifier the identifier that might have been imported using a prefix
    * @return the element that was found
    */
-  Element findImportWithoutPrefix(SimpleIdentifier identifier) {
+  Element _findImportWithoutPrefix(SimpleIdentifier identifier) {
     Element element = null;
     Scope nameScope = _resolver.nameScope;
     for (ImportElement importElement in _definingLibrary.imports) {
       PrefixElement prefixElement = importElement.prefix;
       if (prefixElement != null) {
         Identifier prefixedIdentifier = new ElementResolver_SyntheticIdentifier("${prefixElement.name}.${identifier.name}");
         Element importedElement = nameScope.lookup(prefixedIdentifier, _definingLibrary);
         if (importedElement != null) {
           if (element == null) {
             element = importedElement;
           } else {
             element = MultiplyDefinedElementImpl.fromElements(_definingLibrary.context, element, importedElement);
           }
         }
       }
     }
     return element;
   }
 
   /**
    * Return the name of the method invoked by the given postfix expression.
    *
    * @param node the postfix expression being invoked
    * @return the name of the method invoked by the expression
    */
-  String getPostfixOperator(PostfixExpression node) => (identical(node.operator.type, sc.TokenType.PLUS_PLUS)) ? sc.TokenType.PLUS.lexeme : sc.TokenType.MINUS.lexeme;
+  String _getPostfixOperator(PostfixExpression node) => (identical(node.operator.type, sc.TokenType.PLUS_PLUS)) ? sc.TokenType.PLUS.lexeme : sc.TokenType.MINUS.lexeme;
 
   /**
    * Return the name of the method invoked by the given postfix expression.
    *
    * @param node the postfix expression being invoked
    * @return the name of the method invoked by the expression
    */
-  String getPrefixOperator(PrefixExpression node) {
+  String _getPrefixOperator(PrefixExpression node) {
     sc.Token operator = node.operator;
     sc.TokenType operatorType = operator.type;
     if (identical(operatorType, sc.TokenType.PLUS_PLUS)) {
       return sc.TokenType.PLUS.lexeme;
     } else if (identical(operatorType, sc.TokenType.MINUS_MINUS)) {
       return sc.TokenType.MINUS.lexeme;
     } else if (identical(operatorType, sc.TokenType.MINUS)) {
       return "unary-";
     } else {
       return operator.lexeme;
     }
   }
 
   /**
    * Return the propagated type of the given expression that is to be used for type analysis.
    *
    * @param expression the expression whose type is to be returned
    * @return the type of the given expression
    */
-  Type2 getPropagatedType(Expression expression) {
-    Type2 propagatedType = resolveTypeParameter(expression.propagatedType);
+  Type2 _getPropagatedType(Expression expression) {
+    Type2 propagatedType = _resolveTypeParameter(expression.propagatedType);
     if (propagatedType is FunctionType) {
       //
       // All function types are subtypes of 'Function', which is itself a subclass of 'Object'.
       //
       propagatedType = _resolver.typeProvider.functionType;
     }
     return propagatedType;
   }
 
   /**
    * Return the static type of the given expression that is to be used for type analysis.
    *
    * @param expression the expression whose type is to be returned
    * @return the type of the given expression
    */
-  Type2 getStaticType(Expression expression) {
+  Type2 _getStaticType(Expression expression) {
     if (expression is NullLiteral) {
       return _resolver.typeProvider.bottomType;
     }
-    Type2 staticType = resolveTypeParameter(expression.staticType);
+    Type2 staticType = _resolveTypeParameter(expression.staticType);
     if (staticType is FunctionType) {
       //
       // All function types are subtypes of 'Function', which is itself a subclass of 'Object'.
       //
       staticType = _resolver.typeProvider.functionType;
     }
     return staticType;
   }
 
   /**
    * Return `true` if the given type represents an object that could be invoked using the call
    * operator '()'.
    *
    * @param type the type being tested
    * @return `true` if the given type represents an object that could be invoked
    */
-  bool isExecutableType(Type2 type) {
+  bool _isExecutableType(Type2 type) {
     if (type.isDynamic || (type is FunctionType) || type.isDartCoreFunction || type.isObject) {
       return true;
     } else if (type is InterfaceType) {
       ClassElement classElement = type.element;
       MethodElement methodElement = classElement.lookUpMethod(CALL_METHOD_NAME, _definingLibrary);
       return methodElement != null;
     }
     return false;
   }
 
   /**
    * @return `true` iff current enclosing function is constant constructor declaration.
    */
   bool get isInConstConstructor {
     ExecutableElement function = _resolver.enclosingFunction;
     if (function is ConstructorElement) {
       return function.isConst;
     }
     return false;
   }
 
   /**
    * Return `true` if the given element is a static element.
    *
    * @param element the element being tested
    * @return `true` if the given element is a static element
    */
-  bool isStatic(Element element) {
+  bool _isStatic(Element element) {
     if (element is ExecutableElement) {
       return element.isStatic;
     } else if (element is PropertyInducingElement) {
       return element.isStatic;
     }
     return false;
   }
 
   /**
    * Return `true` if the given node can validly be resolved to a prefix:
    * * it is the prefix in an import directive, or
    * * it is the prefix in a prefixed identifier.
    *
    * @param node the node being tested
    * @return `true` if the given node is the prefix in an import directive
    */
-  bool isValidAsPrefix(SimpleIdentifier node) {
+  bool _isValidAsPrefix(SimpleIdentifier node) {
     AstNode parent = node.parent;
     if (parent is ImportDirective) {
       return identical(parent.prefix, node);
     } else if (parent is PrefixedIdentifier) {
       return true;
     } else if (parent is MethodInvocation) {
       return identical(parent.target, node);
     }
     return false;
   }
 
   /**
    * Look up the getter with the given name in the given type. Return the element representing the
    * getter that was found, or `null` if there is no getter with the given name.
    *
    * @param target the target of the invocation, or `null` if there is no target
    * @param type the type in which the getter is defined
    * @param getterName the name of the getter being looked up
    * @return the element representing the getter that was found
    */
-  PropertyAccessorElement lookUpGetter(Expression target, Type2 type, String getterName) {
-    type = resolveTypeParameter(type);
+  PropertyAccessorElement _lookUpGetter(Expression target, Type2 type, String getterName) {
+    type = _resolveTypeParameter(type);
     if (type is InterfaceType) {
       InterfaceType interfaceType = type;
       PropertyAccessorElement accessor;
       if (target is SuperExpression) {
         accessor = interfaceType.lookUpGetterInSuperclass(getterName, _definingLibrary);
       } else {
         accessor = interfaceType.lookUpGetter(getterName, _definingLibrary);
       }
       if (accessor != null) {
         return accessor;
       }
-      return lookUpGetterInInterfaces(interfaceType, false, getterName, new Set<ClassElement>());
+      return _lookUpGetterInInterfaces(interfaceType, false, getterName, new Set<ClassElement>());
     }
     return null;
   }
 
   /**
    * Look up the getter with the given name in the interfaces implemented by the given type, either
    * directly or indirectly. Return the element representing the getter that was found, or
    * `null` if there is no getter with the given name.
    *
    * @param targetType the type in which the getter might be defined
    * @param includeTargetType `true` if the search should include the target type
    * @param getterName the name of the getter being looked up
    * @param visitedInterfaces a set containing all of the interfaces that have been examined, used
    *          to prevent infinite recursion and to optimize the search
    * @return the element representing the getter that was found
    */
-  PropertyAccessorElement lookUpGetterInInterfaces(InterfaceType targetType, bool includeTargetType, String getterName, Set<ClassElement> visitedInterfaces) {
+  PropertyAccessorElement _lookUpGetterInInterfaces(InterfaceType targetType, bool includeTargetType, String getterName, Set<ClassElement> visitedInterfaces) {
     // TODO(brianwilkerson) This isn't correct. Section 8.1.1 of the specification (titled
     // "Inheritance and Overriding" under "Interfaces") describes a much more complex scheme for
     // finding the inherited member. We need to follow that scheme. The code below should cover the
     // 80% case.
     ClassElement targetClass = targetType.element;
     if (visitedInterfaces.contains(targetClass)) {
       return null;
     }
     visitedInterfaces.add(targetClass);
     if (includeTargetType) {
       PropertyAccessorElement getter = targetType.getGetter(getterName);
       if (getter != null && getter.isAccessibleIn(_definingLibrary)) {
         return getter;
       }
     }
     for (InterfaceType interfaceType in targetType.interfaces) {
-      PropertyAccessorElement getter = lookUpGetterInInterfaces(interfaceType, true, getterName, visitedInterfaces);
+      PropertyAccessorElement getter = _lookUpGetterInInterfaces(interfaceType, true, getterName, visitedInterfaces);
       if (getter != null) {
         return getter;
       }
     }
     for (InterfaceType mixinType in targetType.mixins) {
-      PropertyAccessorElement getter = lookUpGetterInInterfaces(mixinType, true, getterName, visitedInterfaces);
+      PropertyAccessorElement getter = _lookUpGetterInInterfaces(mixinType, true, getterName, visitedInterfaces);
       if (getter != null) {
         return getter;
       }
     }
     InterfaceType superclass = targetType.superclass;
     if (superclass == null) {
       return null;
     }
-    return lookUpGetterInInterfaces(superclass, true, getterName, visitedInterfaces);
+    return _lookUpGetterInInterfaces(superclass, true, getterName, visitedInterfaces);
   }
 
   /**
    * Look up the method or getter with the given name in the given type. Return the element
    * representing the method or getter that was found, or `null` if there is no method or
    * getter with the given name.
    *
    * @param type the type in which the method or getter is defined
    * @param memberName the name of the method or getter being looked up
    * @return the element representing the method or getter that was found
    */
-  ExecutableElement lookupGetterOrMethod(Type2 type, String memberName) {
-    type = resolveTypeParameter(type);
+  ExecutableElement _lookupGetterOrMethod(Type2 type, String memberName) {
+    type = _resolveTypeParameter(type);
     if (type is InterfaceType) {
       InterfaceType interfaceType = type;
       ExecutableElement member = interfaceType.lookUpMethod(memberName, _definingLibrary);
       if (member != null) {
         return member;
       }
       member = interfaceType.lookUpGetter(memberName, _definingLibrary);
       if (member != null) {
         return member;
       }
-      return lookUpGetterOrMethodInInterfaces(interfaceType, false, memberName, new Set<ClassElement>());
+      return _lookUpGetterOrMethodInInterfaces(interfaceType, false, memberName, new Set<ClassElement>());
     }
     return null;
   }
 
   /**
    * Look up the method or getter with the given name in the interfaces implemented by the given
    * type, either directly or indirectly. Return the element representing the method or getter that
    * was found, or `null` if there is no method or getter with the given name.
    *
    * @param targetType the type in which the method or getter might be defined
    * @param includeTargetType `true` if the search should include the target type
    * @param memberName the name of the method or getter being looked up
    * @param visitedInterfaces a set containing all of the interfaces that have been examined, used
    *          to prevent infinite recursion and to optimize the search
    * @return the element representing the method or getter that was found
    */
-  ExecutableElement lookUpGetterOrMethodInInterfaces(InterfaceType targetType, bool includeTargetType, String memberName, Set<ClassElement> visitedInterfaces) {
+  ExecutableElement _lookUpGetterOrMethodInInterfaces(InterfaceType targetType, bool includeTargetType, String memberName, Set<ClassElement> visitedInterfaces) {
     // TODO(brianwilkerson) This isn't correct. Section 8.1.1 of the specification (titled
     // "Inheritance and Overriding" under "Interfaces") describes a much more complex scheme for
     // finding the inherited member. We need to follow that scheme. The code below should cover the
     // 80% case.
     ClassElement targetClass = targetType.element;
     if (visitedInterfaces.contains(targetClass)) {
       return null;
     }
     visitedInterfaces.add(targetClass);
     if (includeTargetType) {
       ExecutableElement member = targetType.getMethod(memberName);
       if (member != null) {
         return member;
       }
       member = targetType.getGetter(memberName);
       if (member != null) {
         return member;
       }
     }
     for (InterfaceType interfaceType in targetType.interfaces) {
-      ExecutableElement member = lookUpGetterOrMethodInInterfaces(interfaceType, true, memberName, visitedInterfaces);
+      ExecutableElement member = _lookUpGetterOrMethodInInterfaces(interfaceType, true, memberName, visitedInterfaces);
       if (member != null) {
         return member;
       }
     }
     for (InterfaceType mixinType in targetType.mixins) {
-      ExecutableElement member = lookUpGetterOrMethodInInterfaces(mixinType, true, memberName, visitedInterfaces);
+      ExecutableElement member = _lookUpGetterOrMethodInInterfaces(mixinType, true, memberName, visitedInterfaces);
       if (member != null) {
         return member;
       }
     }
     InterfaceType superclass = targetType.superclass;
     if (superclass == null) {
       return null;
     }
-    return lookUpGetterOrMethodInInterfaces(superclass, true, memberName, visitedInterfaces);
+    return _lookUpGetterOrMethodInInterfaces(superclass, true, memberName, visitedInterfaces);
   }
 
   /**
    * Find the element corresponding to the given label node in the current label scope.
    *
    * @param parentNode the node containing the given label
    * @param labelNode the node representing the label being looked up
    * @return the element corresponding to the given label node in the current scope
    */
-  LabelElementImpl lookupLabel(AstNode parentNode, SimpleIdentifier labelNode) {
+  LabelElementImpl _lookupLabel(AstNode parentNode, SimpleIdentifier labelNode) {
     LabelScope labelScope = _resolver.labelScope;
     LabelElementImpl labelElement = null;
     if (labelNode == null) {
       if (labelScope == null) {
       } else {
         labelElement = labelScope.lookup(LabelScope.EMPTY_LABEL) as LabelElementImpl;
         if (labelElement == null) {
         }
         //
         // The label element that was returned was a marker for look-up and isn't stored in the
@@ skipping 25 matching lines @@
 
   /**
    * Look up the method with the given name in the given type. Return the element representing the
    * method that was found, or `null` if there is no method with the given name.
    *
    * @param target the target of the invocation, or `null` if there is no target
    * @param type the type in which the method is defined
    * @param methodName the name of the method being looked up
    * @return the element representing the method that was found
    */
-  MethodElement lookUpMethod(Expression target, Type2 type, String methodName) {
-    type = resolveTypeParameter(type);
+  MethodElement _lookUpMethod(Expression target, Type2 type, String methodName) {
+    type = _resolveTypeParameter(type);
     if (type is InterfaceType) {
       InterfaceType interfaceType = type;
       MethodElement method;
       if (target is SuperExpression) {
         method = interfaceType.lookUpMethodInSuperclass(methodName, _definingLibrary);
       } else {
         method = interfaceType.lookUpMethod(methodName, _definingLibrary);
       }
       if (method != null) {
         return method;
       }
-      return lookUpMethodInInterfaces(interfaceType, false, methodName, new Set<ClassElement>());
+      return _lookUpMethodInInterfaces(interfaceType, false, methodName, new Set<ClassElement>());
     }
     return null;
   }
 
   /**
    * Look up the method with the given name in the interfaces implemented by the given type, either
    * directly or indirectly. Return the element representing the method that was found, or
    * `null` if there is no method with the given name.
    *
    * @param targetType the type in which the member might be defined
    * @param includeTargetType `true` if the search should include the target type
    * @param methodName the name of the method being looked up
    * @param visitedInterfaces a set containing all of the interfaces that have been examined, used
    *          to prevent infinite recursion and to optimize the search
    * @return the element representing the method that was found
    */
-  MethodElement lookUpMethodInInterfaces(InterfaceType targetType, bool includeTargetType, String methodName, Set<ClassElement> visitedInterfaces) {
+  MethodElement _lookUpMethodInInterfaces(InterfaceType targetType, bool includeTargetType, String methodName, Set<ClassElement> visitedInterfaces) {
     // TODO(brianwilkerson) This isn't correct. Section 8.1.1 of the specification (titled
     // "Inheritance and Overriding" under "Interfaces") describes a much more complex scheme for
     // finding the inherited member. We need to follow that scheme. The code below should cover the
     // 80% case.
     ClassElement targetClass = targetType.element;
     if (visitedInterfaces.contains(targetClass)) {
       return null;
     }
     visitedInterfaces.add(targetClass);
     if (includeTargetType) {
       MethodElement method = targetType.getMethod(methodName);
       if (method != null && method.isAccessibleIn(_definingLibrary)) {
         return method;
       }
     }
     for (InterfaceType interfaceType in targetType.interfaces) {
-      MethodElement method = lookUpMethodInInterfaces(interfaceType, true, methodName, visitedInterfaces);
+      MethodElement method = _lookUpMethodInInterfaces(interfaceType, true, methodName, visitedInterfaces);
       if (method != null) {
         return method;
       }
     }
     for (InterfaceType mixinType in targetType.mixins) {
-      MethodElement method = lookUpMethodInInterfaces(mixinType, true, methodName, visitedInterfaces);
+      MethodElement method = _lookUpMethodInInterfaces(mixinType, true, methodName, visitedInterfaces);
       if (method != null) {
         return method;
       }
     }
     InterfaceType superclass = targetType.superclass;
     if (superclass == null) {
       return null;
     }
-    return lookUpMethodInInterfaces(superclass, true, methodName, visitedInterfaces);
+    return _lookUpMethodInInterfaces(superclass, true, methodName, visitedInterfaces);
   }
 
   /**
    * Look up the setter with the given name in the given type. Return the element representing the
    * setter that was found, or `null` if there is no setter with the given name.
    *
    * @param target the target of the invocation, or `null` if there is no target
    * @param type the type in which the setter is defined
    * @param setterName the name of the setter being looked up
    * @return the element representing the setter that was found
    */
-  PropertyAccessorElement lookUpSetter(Expression target, Type2 type, String setterName) {
-    type = resolveTypeParameter(type);
+  PropertyAccessorElement _lookUpSetter(Expression target, Type2 type, String setterName) {
+    type = _resolveTypeParameter(type);
     if (type is InterfaceType) {
       InterfaceType interfaceType = type;
       PropertyAccessorElement accessor;
       if (target is SuperExpression) {
         accessor = interfaceType.lookUpSetterInSuperclass(setterName, _definingLibrary);
       } else {
         accessor = interfaceType.lookUpSetter(setterName, _definingLibrary);
       }
       if (accessor != null) {
         return accessor;
       }
-      return lookUpSetterInInterfaces(interfaceType, false, setterName, new Set<ClassElement>());
+      return _lookUpSetterInInterfaces(interfaceType, false, setterName, new Set<ClassElement>());
     }
     return null;
   }
 
   /**
    * Look up the setter with the given name in the interfaces implemented by the given type, either
    * directly or indirectly. Return the element representing the setter that was found, or
    * `null` if there is no setter with the given name.
    *
    * @param targetType the type in which the setter might be defined
    * @param includeTargetType `true` if the search should include the target type
    * @param setterName the name of the setter being looked up
    * @param visitedInterfaces a set containing all of the interfaces that have been examined, used
    *          to prevent infinite recursion and to optimize the search
    * @return the element representing the setter that was found
    */
-  PropertyAccessorElement lookUpSetterInInterfaces(InterfaceType targetType, bool includeTargetType, String setterName, Set<ClassElement> visitedInterfaces) {
+  PropertyAccessorElement _lookUpSetterInInterfaces(InterfaceType targetType, bool includeTargetType, String setterName, Set<ClassElement> visitedInterfaces) {
     // TODO(brianwilkerson) This isn't correct. Section 8.1.1 of the specification (titled
     // "Inheritance and Overriding" under "Interfaces") describes a much more complex scheme for
     // finding the inherited member. We need to follow that scheme. The code below should cover the
     // 80% case.
     ClassElement targetClass = targetType.element;
     if (visitedInterfaces.contains(targetClass)) {
       return null;
     }
     visitedInterfaces.add(targetClass);
     if (includeTargetType) {
       PropertyAccessorElement setter = targetType.getSetter(setterName);
       if (setter != null && setter.isAccessibleIn(_definingLibrary)) {
         return setter;
       }
     }
     for (InterfaceType interfaceType in targetType.interfaces) {
-      PropertyAccessorElement setter = lookUpSetterInInterfaces(interfaceType, true, setterName, visitedInterfaces);
+      PropertyAccessorElement setter = _lookUpSetterInInterfaces(interfaceType, true, setterName, visitedInterfaces);
       if (setter != null) {
         return setter;
       }
     }
     for (InterfaceType mixinType in targetType.mixins) {
-      PropertyAccessorElement setter = lookUpSetterInInterfaces(mixinType, true, setterName, visitedInterfaces);
+      PropertyAccessorElement setter = _lookUpSetterInInterfaces(mixinType, true, setterName, visitedInterfaces);
       if (setter != null) {
         return setter;
       }
     }
     InterfaceType superclass = targetType.superclass;
     if (superclass == null) {
       return null;
     }
-    return lookUpSetterInInterfaces(superclass, true, setterName, visitedInterfaces);
+    return _lookUpSetterInInterfaces(superclass, true, setterName, visitedInterfaces);
   }
 
   /**
    * Given some class element, this method uses [subtypeManager] to find the set of all
    * subtypes; the subtypes are then searched for a member (method, getter, or setter), that matches
    * a passed
    *
    * @param element the class element to search the subtypes of, if a non-ClassElement element is
    *          passed, then `false` is returned
    * @param memberName the member name to search for
    * @param asMethod `true` if the methods should be searched for in the subtypes
    * @param asAccessor `true` if the accessors (getters and setters) should be searched for in
    *          the subtypes
    * @return `true` if and only if the passed memberName was found in a subtype
    */
-  bool memberFoundInSubclass(Element element, String memberName, bool asMethod, bool asAccessor) {
+  bool _memberFoundInSubclass(Element element, String memberName, bool asMethod, bool asAccessor) {
     if (element is ClassElement) {
       _subtypeManager.ensureLibraryVisited(_definingLibrary);
       Set<ClassElement> subtypeElements = _subtypeManager.computeAllSubtypes(element);
       for (ClassElement subtypeElement in subtypeElements) {
         if (asMethod && subtypeElement.getMethod(memberName) != null) {
           return true;
         } else if (asAccessor && (subtypeElement.getGetter(memberName) != null || subtypeElement.getSetter(memberName) != null)) {
           return true;
         }
       }
     }
     return false;
   }
 
   /**
    * Return the binary operator that is invoked by the given compound assignment operator.
    *
    * @param operator the assignment operator being mapped
    * @return the binary operator that invoked by the given assignment operator
    */
-  sc.TokenType operatorFromCompoundAssignment(sc.TokenType operator) {
+  sc.TokenType _operatorFromCompoundAssignment(sc.TokenType operator) {
     while (true) {
       if (operator == sc.TokenType.AMPERSAND_EQ) {
         return sc.TokenType.AMPERSAND;
       } else if (operator == sc.TokenType.BAR_EQ) {
         return sc.TokenType.BAR;
       } else if (operator == sc.TokenType.CARET_EQ) {
         return sc.TokenType.CARET;
       } else if (operator == sc.TokenType.GT_GT_EQ) {
         return sc.TokenType.GT_GT;
       } else if (operator == sc.TokenType.LT_LT_EQ) {
@@ skipping 12 matching lines @@
         return sc.TokenType.TILDE_SLASH;
       } else {
         // Internal error: Unmapped assignment operator.
         AnalysisEngine.instance.logger.logError("Failed to map ${operator.lexeme} to it's corresponding operator");
         return operator;
       }
       break;
     }
   }
 
-  void resolveAnnotationConstructorInvocationArguments(Annotation annotation, ConstructorElement constructor) {
+  void _resolveAnnotationConstructorInvocationArguments(Annotation annotation, ConstructorElement constructor) {
     ArgumentList argumentList = annotation.arguments;
     // error will be reported in ConstantVerifier
     if (argumentList == null) {
       return;
     }
     // resolve arguments to parameters
-    List<ParameterElement> parameters = resolveArgumentsToFunction(true, argumentList, constructor);
+    List<ParameterElement> parameters = _resolveArgumentsToFunction(true, argumentList, constructor);
     if (parameters != null) {
       argumentList.correspondingStaticParameters = parameters;
     }
   }
 
   /**
    * Continues resolution of the given [Annotation].
    *
    * @param annotation the [Annotation] to resolve
    */
-  void resolveAnnotationElement(Annotation annotation) {
+  void _resolveAnnotationElement(Annotation annotation) {
     SimpleIdentifier nameNode1;
     SimpleIdentifier nameNode2;
     {
       Identifier annName = annotation.name;
       if (annName is PrefixedIdentifier) {
         PrefixedIdentifier prefixed = annName;
         nameNode1 = prefixed.prefix;
         nameNode2 = prefixed.identifier;
       } else {
         nameNode1 = annName as SimpleIdentifier;
         nameNode2 = null;
       }
     }
     SimpleIdentifier nameNode3 = annotation.constructorName;
     ConstructorElement constructor = null;
     //
     // CONST or Class(args)
     //
     if (nameNode1 != null && nameNode2 == null && nameNode3 == null) {
       Element element1 = nameNode1.staticElement;
       // CONST
       if (element1 is PropertyAccessorElement) {
-        resolveAnnotationElementGetter(annotation, element1);
+        _resolveAnnotationElementGetter(annotation, element1);
         return;
       }
       // Class(args)
       if (element1 is ClassElement) {
         ClassElement classElement = element1;
         constructor = new InterfaceTypeImpl.con1(classElement).lookUpConstructor(null, _definingLibrary);
       }
     }
     //
     // prefix.CONST or prefix.Class() or Class.CONST or Class.constructor(args)
     //
     if (nameNode1 != null && nameNode2 != null && nameNode3 == null) {
       Element element1 = nameNode1.staticElement;
       Element element2 = nameNode2.staticElement;
       // Class.CONST - not resolved yet
       if (element1 is ClassElement) {
         ClassElement classElement = element1;
         element2 = classElement.lookUpGetter(nameNode2.name, _definingLibrary);
       }
       // prefix.CONST or Class.CONST
       if (element2 is PropertyAccessorElement) {
         nameNode2.staticElement = element2;
         annotation.element = element2;
-        resolveAnnotationElementGetter(annotation, element2 as PropertyAccessorElement);
+        _resolveAnnotationElementGetter(annotation, element2 as PropertyAccessorElement);
         return;
       }
       // prefix.Class()
       if (element2 is ClassElement) {
         ClassElement classElement = element2 as ClassElement;
         constructor = classElement.unnamedConstructor;
       }
       // Class.constructor(args)
       if (element1 is ClassElement) {
         ClassElement classElement = element1;
         constructor = new InterfaceTypeImpl.con1(classElement).lookUpConstructor(nameNode2.name, _definingLibrary);
         nameNode2.staticElement = constructor;
       }
     }
     //
     // prefix.Class.CONST or prefix.Class.constructor(args)
     //
     if (nameNode1 != null && nameNode2 != null && nameNode3 != null) {
       Element element2 = nameNode2.staticElement;
       // element2 should be ClassElement
       if (element2 is ClassElement) {
         ClassElement classElement = element2;
         String name3 = nameNode3.name;
         // prefix.Class.CONST
         PropertyAccessorElement getter = classElement.lookUpGetter(name3, _definingLibrary);
         if (getter != null) {
           nameNode3.staticElement = getter;
           annotation.element = element2;
-          resolveAnnotationElementGetter(annotation, getter);
+          _resolveAnnotationElementGetter(annotation, getter);
           return;
         }
         // prefix.Class.constructor(args)
         constructor = new InterfaceTypeImpl.con1(classElement).lookUpConstructor(name3, _definingLibrary);
         nameNode3.staticElement = constructor;
       }
     }
     // we need constructor
     if (constructor == null) {
       _resolver.reportErrorForNode(CompileTimeErrorCode.INVALID_ANNOTATION, annotation, []);
       return;
     }
     // record element
     annotation.element = constructor;
     // resolve arguments
-    resolveAnnotationConstructorInvocationArguments(annotation, constructor);
+    _resolveAnnotationConstructorInvocationArguments(annotation, constructor);
   }
 
-  void resolveAnnotationElementGetter(Annotation annotation, PropertyAccessorElement accessorElement) {
+  void _resolveAnnotationElementGetter(Annotation annotation, PropertyAccessorElement accessorElement) {
     // accessor should be synthetic
     if (!accessorElement.isSynthetic) {
       _resolver.reportErrorForNode(CompileTimeErrorCode.INVALID_ANNOTATION, annotation, []);
       return;
     }
     // variable should be constant
     VariableElement variableElement = accessorElement.variable;
     if (!variableElement.isConst) {
       _resolver.reportErrorForNode(CompileTimeErrorCode.INVALID_ANNOTATION, annotation, []);
     }
     // OK
     return;
   }
 
   /**
    * Given a list of arguments and the element that will be invoked using those argument, compute
    * the list of parameters that correspond to the list of arguments. Return the parameters that
    * correspond to the arguments, or `null` if no correspondence could be computed.
    *
    * @param reportError if `true` then compile-time error should be reported; if `false`
    *          then compile-time warning
    * @param argumentList the list of arguments being passed to the element
    * @param executableElement the element that will be invoked with the arguments
    * @return the parameters that correspond to the arguments
    */
-  List<ParameterElement> resolveArgumentsToFunction(bool reportError, ArgumentList argumentList, ExecutableElement executableElement) {
+  List<ParameterElement> _resolveArgumentsToFunction(bool reportError, ArgumentList argumentList, ExecutableElement executableElement) {
     if (executableElement == null) {
       return null;
     }
     List<ParameterElement> parameters = executableElement.parameters;
-    return resolveArgumentsToParameters(reportError, argumentList, parameters);
+    return _resolveArgumentsToParameters(reportError, argumentList, parameters);
   }
 
   /**
    * Given a list of arguments and the parameters related to the element that will be invoked using
    * those argument, compute the list of parameters that correspond to the list of arguments. Return
    * the parameters that correspond to the arguments.
    *
    * @param reportError if `true` then compile-time error should be reported; if `false`
    *          then compile-time warning
    * @param argumentList the list of arguments being passed to the element
    * @param parameters the of the function that will be invoked with the arguments
    * @return the parameters that correspond to the arguments
    */
-  List<ParameterElement> resolveArgumentsToParameters(bool reportError, ArgumentList argumentList, List<ParameterElement> parameters) {
+  List<ParameterElement> _resolveArgumentsToParameters(bool reportError, ArgumentList argumentList, List<ParameterElement> parameters) {
     List<ParameterElement> requiredParameters = new List<ParameterElement>();
     List<ParameterElement> positionalParameters = new List<ParameterElement>();
     Map<String, ParameterElement> namedParameters = new Map<String, ParameterElement>();
     for (ParameterElement parameter in parameters) {
       ParameterKind kind = parameter.parameterKind;
       if (identical(kind, ParameterKind.REQUIRED)) {
         requiredParameters.add(parameter);
       } else if (identical(kind, ParameterKind.POSITIONAL)) {
         positionalParameters.add(parameter);
       } else {
@@ skipping 41 matching lines @@
     }
     return resolvedParameters;
   }
 
   /**
    * Resolve the names in the given combinators in the scope of the given library.
    *
    * @param library the library that defines the names
    * @param combinators the combinators containing the names to be resolved
    */
-  void resolveCombinators(LibraryElement library, NodeList<Combinator> combinators) {
+  void _resolveCombinators(LibraryElement library, NodeList<Combinator> combinators) {
     if (library == null) {
       //
       // The library will be null if the directive containing the combinators has a URI that is not
       // valid.
       //
       return;
     }
     Namespace namespace = new NamespaceBuilder().createExportNamespaceForLibrary(library);
     for (Combinator combinator in combinators) {
       NodeList<SimpleIdentifier> names;
@@ skipping 11 matching lines @@
     }
   }
 
   /**
    * Given an invocation of the form 'C.x()' where 'C' is a class, find and return the element 'x'
    * in 'C'.
    *
    * @param classElement the class element
    * @param nameNode the member name node
    */
-  Element resolveElement(ClassElementImpl classElement, SimpleIdentifier nameNode) {
+  Element _resolveElement(ClassElementImpl classElement, SimpleIdentifier nameNode) {
     String name = nameNode.name;
     Element element = null;
     element = classElement.getMethod(name);
     if (element == null && nameNode.inSetterContext()) {
       element = classElement.getSetter(name);
     }
     if (element == null && nameNode.inGetterContext()) {
       element = classElement.getGetter(name);
     }
     if (element != null && element.isAccessibleIn(_definingLibrary)) {
       return element;
     }
     return null;
   }
 
   /**
    * Given an invocation of the form 'm(a1, ..., an)', resolve 'm' to the element being invoked. If
    * the returned element is a method, then the method will be invoked. If the returned element is a
    * getter, the getter will be invoked without arguments and the result of that invocation will
    * then be invoked with the arguments.
    *
    * @param methodName the name of the method being invoked ('m')
    * @return the element being invoked
    */
-  Element resolveInvokedElement(SimpleIdentifier methodName) {
+  Element _resolveInvokedElement(SimpleIdentifier methodName) {
     //
     // Look first in the lexical scope.
     //
     Element element = _resolver.nameScope.lookup(methodName, _definingLibrary);
     if (element == null) {
       //
       // If it isn't defined in the lexical scope, and the invocation is within a class, then look
       // in the inheritance scope.
       //
       ClassElement enclosingClass = _resolver.enclosingClass;
       if (enclosingClass != null) {
         InterfaceType enclosingType = enclosingClass.type;
-        element = lookUpMethod(null, enclosingType, methodName.name);
+        element = _lookUpMethod(null, enclosingType, methodName.name);
         if (element == null) {
           //
           // If there's no method, then it's possible that 'm' is a getter that returns a function.
           //
-          element = lookUpGetter(null, enclosingType, methodName.name);
+          element = _lookUpGetter(null, enclosingType, methodName.name);
         }
       }
     }
     // TODO(brianwilkerson) Report this error.
     return element;
   }
 
   /**
    * Given an invocation of the form 'e.m(a1, ..., an)', resolve 'e.m' to the element being invoked.
    * If the returned element is a method, then the method will be invoked. If the returned element
    * is a getter, the getter will be invoked without arguments and the result of that invocation
    * will then be invoked with the arguments.
    *
    * @param target the target of the invocation ('e')
    * @param targetType the type of the target
    * @param methodName the name of the method being invoked ('m')
    * @return the element being invoked
    */
-  Element resolveInvokedElementWithTarget(Expression target, Type2 targetType, SimpleIdentifier methodName) {
+  Element _resolveInvokedElementWithTarget(Expression target, Type2 targetType, SimpleIdentifier methodName) {
     if (targetType is InterfaceType) {
       InterfaceType classType = targetType;
-      Element element = lookUpMethod(target, classType, methodName.name);
+      Element element = _lookUpMethod(target, classType, methodName.name);
       if (element == null) {
         //
         // If there's no method, then it's possible that 'm' is a getter that returns a function.
         //
-        element = lookUpGetter(target, classType, methodName.name);
+        element = _lookUpGetter(target, classType, methodName.name);
       }
       return element;
     } else if (target is SimpleIdentifier) {
       Element targetElement = target.staticElement;
       if (targetElement is PrefixElement) {
         //
         // Look to see whether the name of the method is really part of a prefixed identifier for an
         // imported top-level function or top-level getter that returns a function.
         //
         String name = "${target.name}.${methodName}";
@@ skipping 12 matching lines @@
 
   /**
    * Given that we are accessing a property of the given type with the given name, return the
    * element that represents the property.
    *
    * @param target the target of the invocation ('e')
    * @param targetType the type in which the search for the property should begin
    * @param propertyName the name of the property being accessed
    * @return the element that represents the property
    */
-  ExecutableElement resolveProperty(Expression target, Type2 targetType, SimpleIdentifier propertyName) {
+  ExecutableElement _resolveProperty(Expression target, Type2 targetType, SimpleIdentifier propertyName) {
     ExecutableElement memberElement = null;
     if (propertyName.inSetterContext()) {
-      memberElement = lookUpSetter(target, targetType, propertyName.name);
+      memberElement = _lookUpSetter(target, targetType, propertyName.name);
     }
     if (memberElement == null) {
-      memberElement = lookUpGetter(target, targetType, propertyName.name);
+      memberElement = _lookUpGetter(target, targetType, propertyName.name);
     }
     if (memberElement == null) {
-      memberElement = lookUpMethod(target, targetType, propertyName.name);
+      memberElement = _lookUpMethod(target, targetType, propertyName.name);
     }
     return memberElement;
   }
 
-  void resolvePropertyAccess(Expression target, SimpleIdentifier propertyName) {
-    Type2 staticType = getStaticType(target);
-    Type2 propagatedType = getPropagatedType(target);
+  void _resolvePropertyAccess(Expression target, SimpleIdentifier propertyName) {
+    Type2 staticType = _getStaticType(target);
+    Type2 propagatedType = _getPropagatedType(target);
     Element staticElement = null;
     Element propagatedElement = null;
     //
     // If this property access is of the form 'C.m' where 'C' is a class, then we don't call
     // resolveProperty(..) which walks up the class hierarchy, instead we just look for the
     // member in the type only.
     //
     ClassElementImpl typeReference = getTypeReference(target);
     if (typeReference != null) {
-      staticElement = propagatedElement = resolveElement(typeReference, propertyName);
+      staticElement = propagatedElement = _resolveElement(typeReference, propertyName);
     } else {
-      staticElement = resolveProperty(target, staticType, propertyName);
-      propagatedElement = resolveProperty(target, propagatedType, propertyName);
+      staticElement = _resolveProperty(target, staticType, propertyName);
+      propagatedElement = _resolveProperty(target, propagatedType, propertyName);
     }
     // May be part of annotation, record property element only if exists.
     // Error was already reported in validateAnnotationElement().
     if (target.parent.parent is Annotation) {
       if (staticElement != null) {
         propertyName.staticElement = staticElement;
       }
       return;
     }
     propertyName.staticElement = staticElement;
     propertyName.propagatedElement = propagatedElement;
-    bool shouldReportMissingMember_static = shouldReportMissingMember(staticType, staticElement);
-    bool shouldReportMissingMember_propagated = !shouldReportMissingMember_static && _enableHints ? shouldReportMissingMember(propagatedType, propagatedElement) : false;
+    bool shouldReportMissingMember_static = _shouldReportMissingMember(staticType, staticElement);
+    bool shouldReportMissingMember_propagated = !shouldReportMissingMember_static && _enableHints ? _shouldReportMissingMember(propagatedType, propagatedElement) : false;
     // If we are about to generate the hint (propagated version of this warning), then check
     // that the member is not in a subtype of the propagated type.
     if (shouldReportMissingMember_propagated) {
-      if (memberFoundInSubclass(propagatedType.element, propertyName.name, false, true)) {
+      if (_memberFoundInSubclass(propagatedType.element, propertyName.name, false, true)) {
         shouldReportMissingMember_propagated = false;
       }
     }
     if (shouldReportMissingMember_static || shouldReportMissingMember_propagated) {
       if (staticType.isVoid) {
         if (propertyName.inSetterContext()) {
           ErrorCode errorCode = (shouldReportMissingMember_static ? StaticTypeWarningCode.UNDEFINED_SETTER : HintCode.UNDEFINED_SETTER) as ErrorCode;
           _resolver.reportErrorForNode(errorCode, propertyName, [propertyName.name, staticType.displayName]);
         } else if (propertyName.inGetterContext()) {
           ErrorCode errorCode = (shouldReportMissingMember_static ? StaticTypeWarningCode.UNDEFINED_GETTER : HintCode.UNDEFINED_GETTER) as ErrorCode;
           _resolver.reportErrorForNode(errorCode, propertyName, [propertyName.name, staticType.displayName]);
         } else {
           _resolver.reportErrorForNode(StaticWarningCode.UNDEFINED_IDENTIFIER, propertyName, [propertyName.name]);
         }
       }
       Element staticOrPropagatedEnclosingElt = shouldReportMissingMember_static ? staticType.element : propagatedType.element;
       if (staticOrPropagatedEnclosingElt != null) {
-        bool isStaticProperty = isStatic(staticOrPropagatedEnclosingElt);
+        bool isStaticProperty = _isStatic(staticOrPropagatedEnclosingElt);
         if (propertyName.inSetterContext()) {
           if (isStaticProperty) {
             ErrorCode errorCode = (shouldReportMissingMember_static ? StaticWarningCode.UNDEFINED_SETTER : HintCode.UNDEFINED_SETTER) as ErrorCode;
             _resolver.reportProxyConditionalErrorForNode(staticOrPropagatedEnclosingElt, errorCode, propertyName, [
                 propertyName.name,
                 staticOrPropagatedEnclosingElt.displayName]);
           } else {
             ErrorCode errorCode = (shouldReportMissingMember_static ? StaticTypeWarningCode.UNDEFINED_SETTER : HintCode.UNDEFINED_SETTER) as ErrorCode;
             _resolver.reportProxyConditionalErrorForNode(staticOrPropagatedEnclosingElt, errorCode, propertyName, [
                 propertyName.name,
@@ skipping 19 matching lines @@
   }
 
   /**
    * Resolve the given simple identifier if possible. Return the element to which it could be
    * resolved, or `null` if it could not be resolved. This does not record the results of the
    * resolution.
    *
    * @param node the identifier to be resolved
    * @return the element to which the identifier could be resolved
    */
-  Element resolveSimpleIdentifier(SimpleIdentifier node) {
+  Element _resolveSimpleIdentifier(SimpleIdentifier node) {
     Element element = _resolver.nameScope.lookup(node, _definingLibrary);
     if (element is PropertyAccessorElement && node.inSetterContext()) {
       PropertyInducingElement variable = (element as PropertyAccessorElement).variable;
       if (variable != null) {
         PropertyAccessorElement setter = variable.setter;
         if (setter == null) {
           //
           // Check to see whether there might be a locally defined getter and an inherited setter.
           //
           ClassElement enclosingClass = _resolver.enclosingClass;
           if (enclosingClass != null) {
-            setter = lookUpSetter(null, enclosingClass.type, node.name);
+            setter = _lookUpSetter(null, enclosingClass.type, node.name);
           }
         }
         if (setter != null) {
           element = setter;
         }
       }
     } else if (element == null && node.inSetterContext()) {
       element = _resolver.nameScope.lookup(new ElementResolver_SyntheticIdentifier("${node.name}="), _definingLibrary);
     }
     ClassElement enclosingClass = _resolver.enclosingClass;
     if (element == null && enclosingClass != null) {
       InterfaceType enclosingType = enclosingClass.type;
       if (element == null && node.inSetterContext()) {
-        element = lookUpSetter(null, enclosingType, node.name);
+        element = _lookUpSetter(null, enclosingType, node.name);
       }
       if (element == null && node.inGetterContext()) {
-        element = lookUpGetter(null, enclosingType, node.name);
+        element = _lookUpGetter(null, enclosingType, node.name);
       }
       if (element == null) {
-        element = lookUpMethod(null, enclosingType, node.name);
+        element = _lookUpMethod(null, enclosingType, node.name);
       }
     }
     return element;
   }
 
   /**
    * If the given type is a type parameter, resolve it to the type that should be used when looking
    * up members. Otherwise, return the original type.
    *
    * @param type the type that is to be resolved if it is a type parameter
    * @return the type that should be used in place of the argument if it is a type parameter, or the
    *         original argument if it isn't a type parameter
    */
-  Type2 resolveTypeParameter(Type2 type) {
+  Type2 _resolveTypeParameter(Type2 type) {
     if (type is TypeParameterType) {
       Type2 bound = type.element.bound;
       if (bound == null) {
         return _resolver.typeProvider.objectType;
       }
       return bound;
     }
     return type;
   }
 
   /**
    * Given a node that can have annotations associated with it and the element to which that node
    * has been resolved, create the annotations in the element model representing the annotations on
    * the node.
    *
    * @param element the element to which the node has been resolved
    * @param node the node that can have annotations associated with it
    */
-  void setMetadata(Element element, AnnotatedNode node) {
+  void _setMetadata(Element element, AnnotatedNode node) {
     if (element is! ElementImpl) {
       return;
     }
     List<ElementAnnotationImpl> annotationList = new List<ElementAnnotationImpl>();
-    addAnnotations(annotationList, node.metadata);
+    _addAnnotations(annotationList, node.metadata);
     if (node is VariableDeclaration && node.parent is VariableDeclarationList) {
       VariableDeclarationList list = node.parent as VariableDeclarationList;
-      addAnnotations(annotationList, list.metadata);
+      _addAnnotations(annotationList, list.metadata);
       if (list.parent is FieldDeclaration) {
         FieldDeclaration fieldDeclaration = list.parent as FieldDeclaration;
-        addAnnotations(annotationList, fieldDeclaration.metadata);
+        _addAnnotations(annotationList, fieldDeclaration.metadata);
       } else if (list.parent is TopLevelVariableDeclaration) {
         TopLevelVariableDeclaration variableDeclaration = list.parent as TopLevelVariableDeclaration;
-        addAnnotations(annotationList, variableDeclaration.metadata);
+        _addAnnotations(annotationList, variableDeclaration.metadata);
       }
     }
     if (!annotationList.isEmpty) {
       (element as ElementImpl).metadata = new List.from(annotationList);
     }
   }
 
   /**
    * Given a node that can have annotations associated with it and the element to which that node
    * has been resolved, create the annotations in the element model representing the annotations on
    * the node.
    *
    * @param element the element to which the node has been resolved
    * @param node the node that can have annotations associated with it
    */
-  void setMetadataForParameter(Element element, NormalFormalParameter node) {
+  void _setMetadataForParameter(Element element, NormalFormalParameter node) {
     if (element is! ElementImpl) {
       return;
     }
     List<ElementAnnotationImpl> annotationList = new List<ElementAnnotationImpl>();
-    addAnnotations(annotationList, node.metadata);
+    _addAnnotations(annotationList, node.metadata);
     if (!annotationList.isEmpty) {
       (element as ElementImpl).metadata = new List.from(annotationList);
     }
   }
 
   /**
    * Return `true` if we should report an error as a result of looking up a member in the
    * given type and not finding any member.
    *
    * @param type the type in which we attempted to perform the look-up
    * @param member the result of the look-up
    * @return `true` if we should report an error
    */
-  bool shouldReportMissingMember(Type2 type, Element member) {
+  bool _shouldReportMissingMember(Type2 type, Element member) {
     if (member != null || type == null || type.isDynamic || type.isBottom) {
       return false;
     }
     return true;
   }
 }
 
 /**
  * Instances of the class `SyntheticIdentifier` implement an identifier that can be used to
  * look up names in the lexical scope when there is no identifier in the AST structure. There is
@@ skipping 74 matching lines @@
     this._errorListener = errorListener;
   }
 
   /**
    * Resolve the given node, reporting any errors or warnings to the given listener.
    *
    * @param node the root of the AST structure to be resolved
    * @throws AnalysisException if the node could not be resolved
    */
   void resolve(AstNode node) {
-    AstNode rootNode = findResolutionRoot(node);
+    AstNode rootNode = _findResolutionRoot(node);
     Scope scope = ScopeBuilder.scopeFor(rootNode, _errorListener);
-    if (elementModelChanged(rootNode.parent)) {
+    if (_elementModelChanged(rootNode.parent)) {
       throw new AnalysisException.con1("Cannot resolve node: element model changed");
     }
-    resolveTypes(node, scope);
-    resolveVariables(node, scope);
-    resolveReferences(node, scope);
+    _resolveTypes(node, scope);
+    _resolveVariables(node, scope);
+    _resolveReferences(node, scope);
   }
 
   /**
    * Return `true` if the given node can be resolved independently of any other nodes.
    *
    * <b>Note:</b> This method needs to be kept in sync with [ScopeBuilder#scopeForAstNode].
    *
    * @param node the node being tested
    * @return `true` if the given node can be resolved independently of any other nodes
    */
-  bool canBeResolved(AstNode node) => node is ClassDeclaration || node is ClassTypeAlias || node is CompilationUnit || node is ConstructorDeclaration || node is FunctionDeclaration || node is FunctionTypeAlias || node is MethodDeclaration;
+  bool _canBeResolved(AstNode node) => node is ClassDeclaration || node is ClassTypeAlias || node is CompilationUnit || node is ConstructorDeclaration || node is FunctionDeclaration || node is FunctionTypeAlias || node is MethodDeclaration;
 
   /**
    * Return `true` if the portion of the element model defined by the given node has changed.
    *
    * @param node the node defining the portion of the element model being tested
    * @return `true` if the element model defined by the given node has changed
    * @throws AnalysisException if the correctness of the element model cannot be determined
    */
-  bool elementModelChanged(AstNode node) {
-    Element element = getElement(node);
+  bool _elementModelChanged(AstNode node) {
+    Element element = _getElement(node);
     if (element == null) {
       throw new AnalysisException.con1("Cannot resolve node: a ${node.runtimeType.toString()} does not define an element");
     }
     DeclarationMatcher matcher = new DeclarationMatcher();
     return !matcher.matches(node, element);
   }
 
   /**
    * Starting at the given node, find the smallest AST node that can be resolved independently of
    * any other nodes. Return the node that was found.
    *
    * @param node the node at which the search is to begin
    * @return the smallest AST node that can be resolved independently of any other nodes
    * @throws AnalysisException if there is no such node
    */
-  AstNode findResolutionRoot(AstNode node) {
+  AstNode _findResolutionRoot(AstNode node) {
     AstNode result = node;
     AstNode parent = result.parent;
-    while (parent != null && !canBeResolved(parent)) {
+    while (parent != null && !_canBeResolved(parent)) {
       result = parent;
       parent = result.parent;
     }
     if (parent == null) {
       throw new AnalysisException.con1("Cannot resolve node: no resolvable node");
     }
     return result;
   }
 
   /**
    * Return the element defined by the given node, or `null` if the node does not define an
    * element.
    *
    * @param node the node defining the element to be returned
    * @return the element defined by the given node
    */
-  Element getElement(AstNode node) {
+  Element _getElement(AstNode node) {
     if (node is Declaration) {
       return node.element;
     } else if (node is CompilationUnit) {
       return node.element;
     }
     return null;
   }
 
-  void resolveReferences(AstNode node, Scope scope) {
+  void _resolveReferences(AstNode node, Scope scope) {
     ResolverVisitor visitor = new ResolverVisitor.con3(_definingLibrary, _source, _typeProvider, scope, _errorListener);
     node.accept(visitor);
     for (ProxyConditionalAnalysisError conditionalCode in visitor.proxyConditionalAnalysisErrors) {
       if (conditionalCode.shouldIncludeErrorCode()) {
         visitor.reportError(conditionalCode.analysisError);
       }
     }
   }
 
-  void resolveTypes(AstNode node, Scope scope) {
+  void _resolveTypes(AstNode node, Scope scope) {
     TypeResolverVisitor visitor = new TypeResolverVisitor.con3(_definingLibrary, _source, _typeProvider, scope, _errorListener);
     node.accept(visitor);
   }
 
-  void resolveVariables(AstNode node, Scope scope) {
+  void _resolveVariables(AstNode node, Scope scope) {
     VariableResolverVisitor visitor = new VariableResolverVisitor.con2(_definingLibrary, _source, _typeProvider, scope, _errorListener);
     node.accept(visitor);
   }
 }
 
 /**
  * Instances of the class `InheritanceManager` manage the knowledge of where class members
  * (methods, getters & setters) are inherited from.
  */
 class InheritanceManager {
   /**
    * Given some array of [ExecutableElement]s, this method creates a synthetic element as
    * described in the Superinterfaces section of Inheritance and Overriding.
    *
    * TODO (jwren) Copy contents from the Spec into this javadoc.
    *
    * TODO (jwren) Associate a propagated type to the synthetic method element using least upper
    * bound calls
    */
-  static ExecutableElement computeMergedExecutableElement(List<ExecutableElement> elementArrayToMerge) {
-    int h = getNumOfPositionalParameters(elementArrayToMerge[0]);
-    int r = getNumOfRequiredParameters(elementArrayToMerge[0]);
+  static ExecutableElement _computeMergedExecutableElement(List<ExecutableElement> elementArrayToMerge) {
+    int h = _getNumOfPositionalParameters(elementArrayToMerge[0]);
+    int r = _getNumOfRequiredParameters(elementArrayToMerge[0]);
     Set<String> namedParametersList = new Set<String>();
     for (int i = 1; i < elementArrayToMerge.length; i++) {
       ExecutableElement element = elementArrayToMerge[i];
-      int numOfPositionalParams = getNumOfPositionalParameters(element);
+      int numOfPositionalParams = _getNumOfPositionalParameters(element);
       if (h < numOfPositionalParams) {
         h = numOfPositionalParams;
       }
-      int numOfRequiredParams = getNumOfRequiredParameters(element);
+      int numOfRequiredParams = _getNumOfRequiredParameters(element);
       if (r > numOfRequiredParams) {
         r = numOfRequiredParams;
       }
-      namedParametersList.addAll(getNamedParameterNames(element));
+      namedParametersList.addAll(_getNamedParameterNames(element));
     }
     if (r > h) {
       return null;
     }
-    return createSyntheticExecutableElement(elementArrayToMerge, elementArrayToMerge[0].displayName, r, h - r, new List.from(namedParametersList));
+    return _createSyntheticExecutableElement(elementArrayToMerge, elementArrayToMerge[0].displayName, r, h - r, new List.from(namedParametersList));
   }
 
   /**
    * Used by [computeMergedExecutableElement] to actually create the
    * synthetic element.
    *
    * @param elementArrayToMerge the array used to create the synthetic element
    * @param name the name of the method, getter or setter
    * @param numOfRequiredParameters the number of required parameters
    * @param numOfPositionalParameters the number of positional parameters
    * @param namedParameters the list of [String]s that are the named parameters
    * @return the created synthetic element
    */
-  static ExecutableElement createSyntheticExecutableElement(List<ExecutableElement> elementArrayToMerge, String name, int numOfRequiredParameters, int numOfPositionalParameters, List<String> namedParameters) {
+  static ExecutableElement _createSyntheticExecutableElement(List<ExecutableElement> elementArrayToMerge, String name, int numOfRequiredParameters, int numOfPositionalParameters, List<String> namedParameters) {
     DynamicTypeImpl dynamicType = DynamicTypeImpl.instance;
     SimpleIdentifier nameIdentifier = new SimpleIdentifier(new sc.StringToken(sc.TokenType.IDENTIFIER, name, 0));
     ExecutableElementImpl executable;
     if (elementArrayToMerge[0] is MethodElement) {
       MultiplyInheritedMethodElementImpl unionedMethod = new MultiplyInheritedMethodElementImpl(nameIdentifier);
       unionedMethod.inheritedElements = elementArrayToMerge;
       executable = unionedMethod;
     } else {
       MultiplyInheritedPropertyAccessorElementImpl unionedPropertyAccessor = new MultiplyInheritedPropertyAccessorElementImpl(nameIdentifier);
       unionedPropertyAccessor.getter = (elementArrayToMerge[0] as PropertyAccessorElement).isGetter;
@@ skipping 25 matching lines @@
     executable.returnType = dynamicType;
     executable.parameters = parameters;
     FunctionTypeImpl methodType = new FunctionTypeImpl.con1(executable);
     executable.type = methodType;
     return executable;
   }
 
   /**
    * Given some [ExecutableElement], return the list of named parameters.
    */
-  static List<String> getNamedParameterNames(ExecutableElement executableElement) {
+  static List<String> _getNamedParameterNames(ExecutableElement executableElement) {
     List<String> namedParameterNames = new List<String>();
     List<ParameterElement> parameters = executableElement.parameters;
     for (int i = 0; i < parameters.length; i++) {
       ParameterElement parameterElement = parameters[i];
       if (identical(parameterElement.parameterKind, ParameterKind.NAMED)) {
         namedParameterNames.add(parameterElement.name);
       }
     }
     return namedParameterNames;
   }
 
   /**
    * Given some [ExecutableElement] return the number of parameters of the specified kind.
    */
-  static int getNumOfParameters(ExecutableElement executableElement, ParameterKind parameterKind) {
+  static int _getNumOfParameters(ExecutableElement executableElement, ParameterKind parameterKind) {
     int parameterCount = 0;
     List<ParameterElement> parameters = executableElement.parameters;
     for (int i = 0; i < parameters.length; i++) {
       ParameterElement parameterElement = parameters[i];
       if (identical(parameterElement.parameterKind, parameterKind)) {
         parameterCount++;
       }
     }
     return parameterCount;
   }
 
   /**
    * Given some [ExecutableElement] return the number of positional parameters.
    *
    * Note: by positional we mean [ParameterKind#REQUIRED] or [ParameterKind#POSITIONAL].
    */
-  static int getNumOfPositionalParameters(ExecutableElement executableElement) => getNumOfParameters(executableElement, ParameterKind.REQUIRED) + getNumOfParameters(executableElement, ParameterKind.POSITIONAL);
+  static int _getNumOfPositionalParameters(ExecutableElement executableElement) => _getNumOfParameters(executableElement, ParameterKind.REQUIRED) + _getNumOfParameters(executableElement, ParameterKind.POSITIONAL);
 
   /**
    * Given some [ExecutableElement] return the number of required parameters.
    */
-  static int getNumOfRequiredParameters(ExecutableElement executableElement) => getNumOfParameters(executableElement, ParameterKind.REQUIRED);
+  static int _getNumOfRequiredParameters(ExecutableElement executableElement) => _getNumOfParameters(executableElement, ParameterKind.REQUIRED);
 
   /**
    * Given some [ExecutableElement] returns `true` if it is an abstract member of a
    * class.
    *
    * @param executableElement some [ExecutableElement] to evaluate
    * @return `true` if the given element is an abstract member of a class
    */
-  static bool isAbstract(ExecutableElement executableElement) {
+  static bool _isAbstract(ExecutableElement executableElement) {
     if (executableElement is MethodElement) {
       return executableElement.isAbstract;
     } else if (executableElement is PropertyAccessorElement) {
       return executableElement.isAbstract;
     }
     return false;
   }
 
   /**
    * The [LibraryElement] that is managed by this manager.
@@ skipping 40 matching lines @@
   Set<AnalysisError> getErrors(ClassElement classElt) => _errorsInClassElement[classElt];
 
   /**
    * Get and return a mapping between the set of all string names of the members inherited from the
    * passed [ClassElement] superclass hierarchy, and the associated [ExecutableElement].
    *
    * @param classElt the class element to query
    * @return a mapping between the set of all members inherited from the passed [ClassElement]
    *         superclass hierarchy, and the associated [ExecutableElement]
    */
-  MemberMap getMapOfMembersInheritedFromClasses(ClassElement classElt) => computeClassChainLookupMap(classElt, new Set<ClassElement>());
+  MemberMap getMapOfMembersInheritedFromClasses(ClassElement classElt) => _computeClassChainLookupMap(classElt, new Set<ClassElement>());
 
   /**
    * Get and return a mapping between the set of all string names of the members inherited from the
    * passed [ClassElement] interface hierarchy, and the associated [ExecutableElement].
    *
    * @param classElt the class element to query
    * @return a mapping between the set of all string names of the members inherited from the passed
    *         [ClassElement] interface hierarchy, and the associated [ExecutableElement].
    */
-  MemberMap getMapOfMembersInheritedFromInterfaces(ClassElement classElt) => computeInterfaceLookupMap(classElt, new Set<ClassElement>());
+  MemberMap getMapOfMembersInheritedFromInterfaces(ClassElement classElt) => _computeInterfaceLookupMap(classElt, new Set<ClassElement>());
 
   /**
    * Given some [ClassElement] and some member name, this returns the
    * [ExecutableElement] that the class inherits from the mixins,
    * superclasses or interfaces, that has the member name, if no member is inherited `null` is
    * returned.
    *
    * @param classElt the class element to query
    * @param memberName the name of the executable element to find and return
    * @return the inherited executable element with the member name, or `null` if no such
    *         member exists
    */
   ExecutableElement lookupInheritance(ClassElement classElt, String memberName) {
     if (memberName == null || memberName.isEmpty) {
       return null;
     }
-    ExecutableElement executable = computeClassChainLookupMap(classElt, new Set<ClassElement>()).get(memberName);
+    ExecutableElement executable = _computeClassChainLookupMap(classElt, new Set<ClassElement>()).get(memberName);
     if (executable == null) {
-      return computeInterfaceLookupMap(classElt, new Set<ClassElement>()).get(memberName);
+      return _computeInterfaceLookupMap(classElt, new Set<ClassElement>()).get(memberName);
     }
     return executable;
   }
 
   /**
    * Given some [ClassElement] and some member name, this returns the
    * [ExecutableElement] that the class either declares itself, or
    * inherits, that has the member name, if no member is inherited `null` is returned.
    *
    * @param classElt the class element to query
    * @param memberName the name of the executable element to find and return
    * @return the inherited executable element with the member name, or `null` if no such
    *         member exists
    */
   ExecutableElement lookupMember(ClassElement classElt, String memberName) {
-    ExecutableElement element = lookupMemberInClass(classElt, memberName);
+    ExecutableElement element = _lookupMemberInClass(classElt, memberName);
     if (element != null) {
       return element;
     }
     return lookupInheritance(classElt, memberName);
   }
 
   /**
    * Given some [InterfaceType] and some member name, this returns the
    * [FunctionType] of the [ExecutableElement] that the
    * class either declares itself, or inherits, that has the member name, if no member is inherited
@@ skipping 30 matching lines @@
    *          override
    * @param definingType the type that is overriding the member
    * @return the passed function type with any parameterized types substituted
    */
   FunctionType substituteTypeArgumentsInMemberFromInheritance(FunctionType baseFunctionType, String memberName, InterfaceType definingType) {
     if (baseFunctionType == null) {
       return baseFunctionType;
     }
     // First, generate the path from the defining type to the overridden member
     Queue<InterfaceType> inheritancePath = new Queue<InterfaceType>();
-    computeInheritancePath(inheritancePath, definingType, memberName);
+    _computeInheritancePath(inheritancePath, definingType, memberName);
     if (inheritancePath == null || inheritancePath.isEmpty) {
       // TODO(jwren) log analysis engine error
       return baseFunctionType;
     }
     FunctionType functionTypeToReturn = baseFunctionType;
     // loop backward through the list substituting as we go:
     while (!inheritancePath.isEmpty) {
       InterfaceType lastType = inheritancePath.removeLast();
       List<Type2> parameterTypes = lastType.element.type.typeArguments;
       List<Type2> argumentTypes = lastType.typeArguments;
       functionTypeToReturn = functionTypeToReturn.substitute2(argumentTypes, parameterTypes);
     }
     return functionTypeToReturn;
   }
 
   /**
    * Compute and return a mapping between the set of all string names of the members inherited from
    * the passed [ClassElement] superclass hierarchy, and the associated
    * [ExecutableElement].
    *
    * @param classElt the class element to query
    * @param visitedClasses a set of visited classes passed back into this method when it calls
    *          itself recursively
    * @return a mapping between the set of all string names of the members inherited from the passed
    *         [ClassElement] superclass hierarchy, and the associated [ExecutableElement]
    */
-  MemberMap computeClassChainLookupMap(ClassElement classElt, Set<ClassElement> visitedClasses) {
+  MemberMap _computeClassChainLookupMap(ClassElement classElt, Set<ClassElement> visitedClasses) {
     MemberMap resultMap = _classLookup[classElt];
     if (resultMap != null) {
       return resultMap;
     } else {
       resultMap = new MemberMap();
     }
     ClassElement superclassElt = null;
     InterfaceType supertype = classElt.supertype;
     if (supertype != null) {
       superclassElt = supertype.element;
     } else {
       // classElt is Object
       _classLookup[classElt] = resultMap;
       return resultMap;
     }
     if (superclassElt != null) {
       if (!visitedClasses.contains(superclassElt)) {
         visitedClasses.add(superclassElt);
         try {
-          resultMap = new MemberMap.con2(computeClassChainLookupMap(superclassElt, visitedClasses));
+          resultMap = new MemberMap.con2(_computeClassChainLookupMap(superclassElt, visitedClasses));
           //
           // Substitute the super types down the hierarchy.
           //
-          substituteTypeParametersDownHierarchy(supertype, resultMap);
+          _substituteTypeParametersDownHierarchy(supertype, resultMap);
           //
           // Include the members from the superclass in the resultMap.
           //
-          recordMapWithClassMembers(resultMap, supertype, false);
+          _recordMapWithClassMembers(resultMap, supertype, false);
         } finally {
           visitedClasses.remove(superclassElt);
         }
       } else {
         // This case happens only when the superclass was previously visited and not in the lookup,
         // meaning this is meant to shorten the compute for recursive cases.
         _classLookup[superclassElt] = resultMap;
         return resultMap;
       }
     }
     //
     // Include the members from the mixins in the resultMap
     //
     List<InterfaceType> mixins = classElt.mixins;
     for (int i = mixins.length - 1; i >= 0; i--) {
       ClassElement mixinElement = mixins[i].element;
       if (mixinElement != null) {
         if (!visitedClasses.contains(mixinElement)) {
           visitedClasses.add(mixinElement);
           try {
-            MemberMap map = new MemberMap.con2(computeClassChainLookupMap(mixinElement, visitedClasses));
+            MemberMap map = new MemberMap.con2(_computeClassChainLookupMap(mixinElement, visitedClasses));
             //
             // Substitute the super types down the hierarchy.
             //
-            substituteTypeParametersDownHierarchy(mixins[i], map);
+            _substituteTypeParametersDownHierarchy(mixins[i], map);
             //
             // Include the members from the superclass in the resultMap.
             //
-            recordMapWithClassMembers(map, mixins[i], false);
+            _recordMapWithClassMembers(map, mixins[i], false);
             //
             // Add the members from map into result map.
             //
             for (int j = 0; j < map.size; j++) {
               String key = map.getKey(j);
               ExecutableElement value = map.getValue(j);
               if (key != null) {
-                if (resultMap.get(key) == null || (resultMap.get(key) != null && !isAbstract(value))) {
+                if (resultMap.get(key) == null || (resultMap.get(key) != null && !_isAbstract(value))) {
                   resultMap.put(key, value);
                 }
               }
             }
           } finally {
             visitedClasses.remove(mixinElement);
           }
         } else {
           // This case happens only when the superclass was previously visited and not in the lookup,
           // meaning this is meant to shorten the compute for recursive cases.
           _classLookup[mixinElement] = resultMap;
           return resultMap;
         }
       }
     }
     _classLookup[classElt] = resultMap;
     return resultMap;
   }
 
   /**
    * Compute and return the inheritance path given the context of a type and a member that is
    * overridden in the inheritance path (for which the type is in the path).
    *
    * @param chain the inheritance path that is built up as this method calls itself recursively,
    *          when this method is called an empty [LinkedList] should be provided
    * @param currentType the current type in the inheritance path
    * @param memberName the name of the member that is being looked up the inheritance path
    */
-  void computeInheritancePath(Queue<InterfaceType> chain, InterfaceType currentType, String memberName) {
+  void _computeInheritancePath(Queue<InterfaceType> chain, InterfaceType currentType, String memberName) {
     // TODO (jwren) create a public version of this method which doesn't require the initial chain
     // to be provided, then provided tests for this functionality in InheritanceManagerTest
     chain.add(currentType);
     ClassElement classElt = currentType.element;
     InterfaceType supertype = classElt.supertype;
     // Base case- reached Object
     if (supertype == null) {
       // Looked up the chain all the way to Object, return null.
       // This should never happen.
       return;
     }
     // If we are done, return the chain
     // We are not done if this is the first recursive call on this method.
     if (chain.length != 1) {
       // We are done however if the member is in this classElt
-      if (lookupMemberInClass(classElt, memberName) != null) {
+      if (_lookupMemberInClass(classElt, memberName) != null) {
         return;
       }
     }
     // Mixins- note that mixins call lookupMemberInClass, not lookupMember
     List<InterfaceType> mixins = classElt.mixins;
     for (int i = mixins.length - 1; i >= 0; i--) {
       ClassElement mixinElement = mixins[i].element;
       if (mixinElement != null) {
-        ExecutableElement elt = lookupMemberInClass(mixinElement, memberName);
+        ExecutableElement elt = _lookupMemberInClass(mixinElement, memberName);
         if (elt != null) {
           // this is equivalent (but faster than) calling this method recursively
           // (return computeInheritancePath(chain, mixins[i], memberName);)
           chain.add(mixins[i]);
           return;
         }
       }
     }
     // Superclass
     ClassElement superclassElt = supertype.element;
     if (lookupMember(superclassElt, memberName) != null) {
-      computeInheritancePath(chain, supertype, memberName);
+      _computeInheritancePath(chain, supertype, memberName);
       return;
     }
     // Interfaces
     List<InterfaceType> interfaces = classElt.interfaces;
     for (InterfaceType interfaceType in interfaces) {
       ClassElement interfaceElement = interfaceType.element;
       if (interfaceElement != null && lookupMember(interfaceElement, memberName) != null) {
-        computeInheritancePath(chain, interfaceType, memberName);
+        _computeInheritancePath(chain, interfaceType, memberName);
         return;
       }
     }
   }
 
   /**
    * Compute and return a mapping between the set of all string names of the members inherited from
    * the passed [ClassElement] interface hierarchy, and the associated
    * [ExecutableElement].
    *
    * @param classElt the class element to query
    * @param visitedInterfaces a set of visited classes passed back into this method when it calls
    *          itself recursively
    * @return a mapping between the set of all string names of the members inherited from the passed
    *         [ClassElement] interface hierarchy, and the associated [ExecutableElement]
    */
-  MemberMap computeInterfaceLookupMap(ClassElement classElt, Set<ClassElement> visitedInterfaces) {
+  MemberMap _computeInterfaceLookupMap(ClassElement classElt, Set<ClassElement> visitedInterfaces) {
     MemberMap resultMap = _interfaceLookup[classElt];
     if (resultMap != null) {
       return resultMap;
     } else {
       resultMap = new MemberMap();
     }
     InterfaceType supertype = classElt.supertype;
     ClassElement superclassElement = supertype != null ? supertype.element : null;
     List<InterfaceType> mixins = classElt.mixins;
     List<InterfaceType> interfaces = classElt.interfaces;
     // Recursively collect the list of mappings from all of the interface types
     List<MemberMap> lookupMaps = new List<MemberMap>();
     //
     // Superclass element
     //
     if (superclassElement != null) {
       if (!visitedInterfaces.contains(superclassElement)) {
         try {
           visitedInterfaces.add(superclassElement);
           //
           // Recursively compute the map for the super type.
           //
-          MemberMap map = computeInterfaceLookupMap(superclassElement, visitedInterfaces);
+          MemberMap map = _computeInterfaceLookupMap(superclassElement, visitedInterfaces);
           map = new MemberMap.con2(map);
           //
           // Substitute the super type down the hierarchy.
           //
-          substituteTypeParametersDownHierarchy(supertype, map);
+          _substituteTypeParametersDownHierarchy(supertype, map);
           //
           // Add any members from the super type into the map as well.
           //
-          recordMapWithClassMembers(map, supertype, true);
+          _recordMapWithClassMembers(map, supertype, true);
           lookupMaps.add(map);
         } finally {
           visitedInterfaces.remove(superclassElement);
         }
       } else {
         MemberMap map = _interfaceLookup[classElt];
         if (map != null) {
           lookupMaps.add(map);
         } else {
           _interfaceLookup[superclassElement] = resultMap;
           return resultMap;
         }
       }
     }
     //
     // Mixin elements
     //
     for (int i = mixins.length - 1; i >= 0; i--) {
       InterfaceType mixinType = mixins[i];
       ClassElement mixinElement = mixinType.element;
       if (mixinElement != null) {
         if (!visitedInterfaces.contains(mixinElement)) {
           try {
             visitedInterfaces.add(mixinElement);
             //
             // Recursively compute the map for the mixin.
             //
-            MemberMap map = computeInterfaceLookupMap(mixinElement, visitedInterfaces);
+            MemberMap map = _computeInterfaceLookupMap(mixinElement, visitedInterfaces);
             map = new MemberMap.con2(map);
             //
             // Substitute the mixin type down the hierarchy.
             //
-            substituteTypeParametersDownHierarchy(mixinType, map);
+            _substituteTypeParametersDownHierarchy(mixinType, map);
             //
             // Add any members from the mixin type into the map as well.
             //
-            recordMapWithClassMembers(map, mixinType, true);
+            _recordMapWithClassMembers(map, mixinType, true);
             lookupMaps.add(map);
           } finally {
             visitedInterfaces.remove(mixinElement);
           }
         } else {
           MemberMap map = _interfaceLookup[classElt];
           if (map != null) {
             lookupMaps.add(map);
           } else {
             _interfaceLookup[mixinElement] = resultMap;
             return resultMap;
           }
         }
       }
     }
     //
     // Interface elements
     //
     for (InterfaceType interfaceType in interfaces) {
       ClassElement interfaceElement = interfaceType.element;
       if (interfaceElement != null) {
         if (!visitedInterfaces.contains(interfaceElement)) {
           try {
             visitedInterfaces.add(interfaceElement);
             //
             // Recursively compute the map for the interfaces.
             //
-            MemberMap map = computeInterfaceLookupMap(interfaceElement, visitedInterfaces);
+            MemberMap map = _computeInterfaceLookupMap(interfaceElement, visitedInterfaces);
             map = new MemberMap.con2(map);
             //
             // Substitute the supertypes down the hierarchy
             //
-            substituteTypeParametersDownHierarchy(interfaceType, map);
+            _substituteTypeParametersDownHierarchy(interfaceType, map);
             //
             // And add any members from the interface into the map as well.
             //
-            recordMapWithClassMembers(map, interfaceType, true);
+            _recordMapWithClassMembers(map, interfaceType, true);
             lookupMaps.add(map);
           } finally {
             visitedInterfaces.remove(interfaceElement);
           }
         } else {
           MemberMap map = _interfaceLookup[classElt];
           if (map != null) {
             lookupMaps.add(map);
           } else {
             _interfaceLookup[interfaceElement] = resultMap;
@@ skipping 132 matching lines @@
             //
             resultMap.put(key, elements[subtypesOfAllOtherTypesIndexes[0]]);
           } else {
             if (subtypesOfAllOtherTypesIndexes.isEmpty) {
               //
               // Example: class A inherited only 2 method named 'm'. One has the function type
               // '() -> int' and one has the function type '() -> String'. Since neither is a subtype
               // of the other, we create a warning, and have this class inherit nothing.
               //
               String firstTwoFuntionTypesStr = "${executableElementTypes[0].toString()}, ${executableElementTypes[1].toString()}";
-              reportError(classElt, classElt.nameOffset, classElt.displayName.length, StaticTypeWarningCode.INCONSISTENT_METHOD_INHERITANCE, [key, firstTwoFuntionTypesStr]);
+              _reportError(classElt, classElt.nameOffset, classElt.displayName.length, StaticTypeWarningCode.INCONSISTENT_METHOD_INHERITANCE, [key, firstTwoFuntionTypesStr]);
             } else {
               //
               // Example: class A inherits 2 methods named 'm'. One has the function type
               // '(int) -> dynamic' and one has the function type '(num) -> dynamic'. Since they are
               // both a subtype of the other, a synthetic function '(dynamic) -> dynamic' is
               // inherited.
               // Tests: test_getMapOfMembersInheritedFromInterfaces_union_multipleSubtypes_*
               //
               List<ExecutableElement> elementArrayToMerge = new List<ExecutableElement>(subtypesOfAllOtherTypesIndexes.length);
               for (int i = 0; i < elementArrayToMerge.length; i++) {
                 elementArrayToMerge[i] = elements[subtypesOfAllOtherTypesIndexes[i]];
               }
-              ExecutableElement mergedExecutableElement = computeMergedExecutableElement(elementArrayToMerge);
+              ExecutableElement mergedExecutableElement = _computeMergedExecutableElement(elementArrayToMerge);
               if (mergedExecutableElement != null) {
                 resultMap.put(key, mergedExecutableElement);
               }
             }
           }
         } else {
-          reportError(classElt, classElt.nameOffset, classElt.displayName.length, StaticWarningCode.INCONSISTENT_METHOD_INHERITANCE_GETTER_AND_METHOD, [key]);
+          _reportError(classElt, classElt.nameOffset, classElt.displayName.length, StaticWarningCode.INCONSISTENT_METHOD_INHERITANCE_GETTER_AND_METHOD, [key]);
         }
       }
     }
     _interfaceLookup[classElt] = resultMap;
     return resultMap;
   }
 
   /**
    * Given some [ClassElement], this method finds and returns the [ExecutableElement] of
    * the passed name in the class element. Static members, members in super types and members not
    * accessible from the current library are not considered.
    *
    * @param classElt the class element to query
    * @param memberName the name of the member to lookup in the class
    * @return the found [ExecutableElement], or `null` if no such member was found
    */
-  ExecutableElement lookupMemberInClass(ClassElement classElt, String memberName) {
+  ExecutableElement _lookupMemberInClass(ClassElement classElt, String memberName) {
     List<MethodElement> methods = classElt.methods;
     for (MethodElement method in methods) {
       if (memberName == method.name && method.isAccessibleIn(_library) && !method.isStatic) {
         return method;
       }
     }
     List<PropertyAccessorElement> accessors = classElt.accessors;
     for (PropertyAccessorElement accessor in accessors) {
       if (memberName == accessor.name && accessor.isAccessibleIn(_library) && !accessor.isStatic) {
         return accessor;
       }
     }
     return null;
   }
 
   /**
    * Record the passed map with the set of all members (methods, getters and setters) in the type
    * into the passed map.
    *
    * @param map some non-`null` map to put the methods and accessors from the passed
    *          [ClassElement] into
    * @param type the type that will be recorded into the passed map
    * @param doIncludeAbstract `true` if abstract members will be put into the map
    */
-  void recordMapWithClassMembers(MemberMap map, InterfaceType type, bool doIncludeAbstract) {
+  void _recordMapWithClassMembers(MemberMap map, InterfaceType type, bool doIncludeAbstract) {
     List<MethodElement> methods = type.methods;
     for (MethodElement method in methods) {
       if (method.isAccessibleIn(_library) && !method.isStatic && (doIncludeAbstract || !method.isAbstract)) {
         map.put(method.name, method);
       }
     }
     List<PropertyAccessorElement> accessors = type.accessors;
     for (PropertyAccessorElement accessor in accessors) {
       if (accessor.isAccessibleIn(_library) && !accessor.isStatic && (doIncludeAbstract || !accessor.isAbstract)) {
         map.put(accessor.name, accessor);
       }
     }
   }
 
   /**
    * This method is used to report errors on when they are found computing inheritance information.
    * See [ErrorVerifier#checkForInconsistentMethodInheritance] to see where these generated
    * error codes are reported back into the analysis engine.
    *
    * @param classElt the location of the source for which the exception occurred
    * @param offset the offset of the location of the error
    * @param length the length of the location of the error
    * @param errorCode the error code to be associated with this error
    * @param arguments the arguments used to build the error message
    */
-  void reportError(ClassElement classElt, int offset, int length, ErrorCode errorCode, List<Object> arguments) {
+  void _reportError(ClassElement classElt, int offset, int length, ErrorCode errorCode, List<Object> arguments) {
     Set<AnalysisError> errorSet = _errorsInClassElement[classElt];
     if (errorSet == null) {
       errorSet = new Set<AnalysisError>();
       _errorsInClassElement[classElt] = errorSet;
     }
     errorSet.add(new AnalysisError.con2(classElt.source, offset, length, errorCode, arguments));
   }
 
   /**
    * Loop through all of the members in some [MemberMap], performing type parameter
    * substitutions using a passed supertype.
    *
    * @param superType the supertype to substitute into the members of the [MemberMap]
    * @param map the MemberMap to perform the substitutions on
    */
-  void substituteTypeParametersDownHierarchy(InterfaceType superType, MemberMap map) {
+  void _substituteTypeParametersDownHierarchy(InterfaceType superType, MemberMap map) {
     for (int i = 0; i < map.size; i++) {
       ExecutableElement executableElement = map.getValue(i);
       if (executableElement is MethodMember) {
         executableElement = MethodMember.from(executableElement as MethodMember, superType);
         map.setValue(i, executableElement);
       } else if (executableElement is PropertyAccessorMember) {
         executableElement = PropertyAccessorMember.from(executableElement as PropertyAccessorMember, superType);
         map.setValue(i, executableElement);
       }
     }
@@ skipping 344 matching lines @@
    * @throws AnalysisException if the analysis could not be performed
    */
   LibraryElementImpl buildLibrary(Library library) {
     CompilationUnitBuilder builder = new CompilationUnitBuilder();
     Source librarySource = library.librarySource;
     CompilationUnit definingCompilationUnit = library.definingCompilationUnit;
     CompilationUnitElementImpl definingCompilationUnitElement = builder.buildCompilationUnit(librarySource, definingCompilationUnit);
     NodeList<Directive> directives = definingCompilationUnit.directives;
     LibraryIdentifier libraryNameNode = null;
     bool hasPartDirective = false;
-    FunctionElement entryPoint = findEntryPoint(definingCompilationUnitElement);
+    FunctionElement entryPoint = _findEntryPoint(definingCompilationUnitElement);
     List<Directive> directivesToResolve = new List<Directive>();
     List<CompilationUnitElementImpl> sourcedCompilationUnits = new List<CompilationUnitElementImpl>();
     for (Directive directive in directives) {
       //
       // We do not build the elements representing the import and export directives at this point.
       // That is not done until we get to LibraryResolver.buildDirectiveModels() because we need the
       // LibraryElements for the referenced libraries, which might not exist at this point (due to
       // the possibility of circular references).
       //
       if (directive is LibraryDirective) {
         if (libraryNameNode == null) {
           libraryNameNode = directive.name;
           directivesToResolve.add(directive);
         }
       } else if (directive is PartDirective) {
         PartDirective partDirective = directive;
         StringLiteral partUri = partDirective.uri;
         Source partSource = library.getSource(partDirective);
         if (_analysisContext.exists(partSource)) {
           hasPartDirective = true;
           CompilationUnitElementImpl part = builder.buildCompilationUnit(partSource, library.getAST(partSource));
           part.uri = library.getUri(partDirective);
           //
           // Validate that the part contains a part-of directive with the same name as the library.
           //
-          String partLibraryName = getPartLibraryName(library, partSource, directivesToResolve);
+          String partLibraryName = _getPartLibraryName(library, partSource, directivesToResolve);
           if (partLibraryName == null) {
             _errorListener.onError(new AnalysisError.con2(librarySource, partUri.offset, partUri.length, CompileTimeErrorCode.PART_OF_NON_PART, [partUri.toSource()]));
           } else if (libraryNameNode == null) {
           } else if (libraryNameNode.name != partLibraryName) {
             _errorListener.onError(new AnalysisError.con2(librarySource, partUri.offset, partUri.length, StaticWarningCode.PART_OF_DIFFERENT_LIBRARY, [libraryNameNode.name, partLibraryName]));
           }
           if (entryPoint == null) {
-            entryPoint = findEntryPoint(part);
+            entryPoint = _findEntryPoint(part);
           }
           directive.element = part;
           sourcedCompilationUnits.add(part);
         }
       }
     }
     if (hasPartDirective && libraryNameNode == null) {
       _errorListener.onError(new AnalysisError.con1(librarySource, ResolverErrorCode.MISSING_LIBRARY_DIRECTIVE_WITH_PART, []));
     }
     //
     // Create and populate the library element.
     //
     LibraryElementImpl libraryElement = new LibraryElementImpl(_analysisContext, libraryNameNode);
     libraryElement.definingCompilationUnit = definingCompilationUnitElement;
     if (entryPoint != null) {
       libraryElement.entryPoint = entryPoint;
     }
     int sourcedUnitCount = sourcedCompilationUnits.length;
     libraryElement.parts = new List.from(sourcedCompilationUnits);
     for (Directive directive in directivesToResolve) {
       directive.element = libraryElement;
     }
     library.libraryElement = libraryElement;
     if (sourcedUnitCount > 0) {
-      patchTopLevelAccessors(libraryElement);
+      _patchTopLevelAccessors(libraryElement);
     }
     return libraryElement;
   }
 
   /**
    * Add all of the non-synthetic getters and setters defined in the given compilation unit that
    * have no corresponding accessor to one of the given collections.
    *
    * @param getters the map to which getters are to be added
    * @param setters the list to which setters are to be added
    * @param unit the compilation unit defining the accessors that are potentially being added
    */
-  void collectAccessors(Map<String, PropertyAccessorElement> getters, List<PropertyAccessorElement> setters, CompilationUnitElement unit) {
+  void _collectAccessors(Map<String, PropertyAccessorElement> getters, List<PropertyAccessorElement> setters, CompilationUnitElement unit) {
     for (PropertyAccessorElement accessor in unit.accessors) {
       if (accessor.isGetter) {
         if (!accessor.isSynthetic && accessor.correspondingSetter == null) {
           getters[accessor.displayName] = accessor;
         }
       } else {
         if (!accessor.isSynthetic && accessor.correspondingGetter == null) {
           setters.add(accessor);
         }
       }
     }
   }
 
   /**
    * Search the top-level functions defined in the given compilation unit for the entry point.
    *
    * @param element the compilation unit to be searched
    * @return the entry point that was found, or `null` if the compilation unit does not define
    *         an entry point
    */
-  FunctionElement findEntryPoint(CompilationUnitElementImpl element) {
+  FunctionElement _findEntryPoint(CompilationUnitElementImpl element) {
     for (FunctionElement function in element.functions) {
       if (function.name == ENTRY_POINT_NAME) {
         return function;
       }
     }
     return null;
   }
 
   /**
    * Return the name of the library that the given part is declared to be a part of, or `null`
    * if the part does not contain a part-of directive.
    *
    * @param library the library containing the part
    * @param partSource the source representing the part
    * @param directivesToResolve a list of directives that should be resolved to the library being
    *          built
    * @return the name of the library that the given part is declared to be a part of
    */
-  String getPartLibraryName(Library library, Source partSource, List<Directive> directivesToResolve) {
+  String _getPartLibraryName(Library library, Source partSource, List<Directive> directivesToResolve) {
     try {
       CompilationUnit partUnit = library.getAST(partSource);
       for (Directive directive in partUnit.directives) {
         if (directive is PartOfDirective) {
           directivesToResolve.add(directive);
           LibraryIdentifier libraryName = directive.libraryName;
           if (libraryName != null) {
             return libraryName.name;
           }
         }
       }
     } on AnalysisException catch (exception) {
     }
     return null;
   }
 
   /**
    * Look through all of the compilation units defined for the given library, looking for getters
    * and setters that are defined in different compilation units but that have the same names. If
    * any are found, make sure that they have the same variable element.
    *
    * @param libraryElement the library defining the compilation units to be processed
    */
-  void patchTopLevelAccessors(LibraryElementImpl libraryElement) {
+  void _patchTopLevelAccessors(LibraryElementImpl libraryElement) {
     Map<String, PropertyAccessorElement> getters = new Map<String, PropertyAccessorElement>();
     List<PropertyAccessorElement> setters = new List<PropertyAccessorElement>();
-    collectAccessors(getters, setters, libraryElement.definingCompilationUnit);
+    _collectAccessors(getters, setters, libraryElement.definingCompilationUnit);
     for (CompilationUnitElement unit in libraryElement.parts) {
-      collectAccessors(getters, setters, unit);
+      _collectAccessors(getters, setters, unit);
     }
     for (PropertyAccessorElement setter in setters) {
       PropertyAccessorElement getter = getters[setter.displayName];
       if (getter != null) {
         PropertyInducingElementImpl variable = getter.variable as PropertyInducingElementImpl;
         variable.setter = setter;
         (setter as PropertyAccessorElementImpl).variable = variable;
       }
     }
   }
@@ skipping 79 matching lines @@
    * @throws AnalysisException if the library could not be resolved for some reason
    */
   LibraryElement resolveEmbeddedLibrary(Source librarySource, int modificationStamp, CompilationUnit unit, bool fullAnalysis) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("dart.engine.LibraryResolver.resolveEmbeddedLibrary");
     try {
       instrumentation.metric("fullAnalysis", fullAnalysis);
       instrumentation.data3("fullName", librarySource.fullName);
       //
       // Create the objects representing the library being resolved and the core library.
       //
-      Library targetLibrary = createLibraryWithUnit(librarySource, modificationStamp, unit);
+      Library targetLibrary = _createLibraryWithUnit(librarySource, modificationStamp, unit);
       _coreLibrary = _libraryMap[_coreLibrarySource];
       if (_coreLibrary == null) {
         // This will be true unless the library being analyzed is the core library.
         _coreLibrary = createLibrary(_coreLibrarySource);
       }
       instrumentation.metric3("createLibrary", "complete");
       //
       // Compute the set of libraries that need to be resolved together.
       //
-      computeEmbeddedLibraryDependencies(targetLibrary, unit);
-      _librariesInCycles = computeLibrariesInCycles(targetLibrary);
+      _computeEmbeddedLibraryDependencies(targetLibrary, unit);
+      _librariesInCycles = _computeLibrariesInCycles(targetLibrary);
       //
       // Build the element models representing the libraries being resolved. This is done in three
       // steps:
       //
       // 1. Build the basic element models without making any connections between elements other than
       //    the basic parent/child relationships. This includes building the elements representing the
       //    libraries.
       // 2. Build the elements for the import and export directives. This requires that we have the
       //    elements built for the referenced libraries, but because of the possibility of circular
       //    references needs to happen after all of the library elements have been created.
       // 3. Build the rest of the type model by connecting superclasses, mixins, and interfaces. This
       //    requires that we be able to compute the names visible in the libraries being resolved,
       //    which in turn requires that we have resolved the import directives.
       //
-      buildElementModels();
+      _buildElementModels();
       instrumentation.metric3("buildElementModels", "complete");
       LibraryElement coreElement = _coreLibrary.libraryElement;
       if (coreElement == null) {
         throw new AnalysisException.con1("Could not resolve dart:core");
       }
-      buildDirectiveModels();
+      _buildDirectiveModels();
       instrumentation.metric3("buildDirectiveModels", "complete");
       _typeProvider = new TypeProviderImpl(coreElement);
-      buildTypeHierarchies();
+      _buildTypeHierarchies();
       instrumentation.metric3("buildTypeHierarchies", "complete");
       //
       // Perform resolution and type analysis.
       //
       // TODO(brianwilkerson) Decide whether we want to resolve all of the libraries or whether we
       // want to only resolve the target library. The advantage to resolving everything is that we
       // have already done part of the work so we'll avoid duplicated effort. The disadvantage of
       // resolving everything is that we might do extra work that we don't really care about. Another
       // possibility is to add a parameter to this method and punt the decision to the clients.
       //
       //if (analyzeAll) {
-      resolveReferencesAndTypes();
+      _resolveReferencesAndTypes();
       instrumentation.metric3("resolveReferencesAndTypes", "complete");
       //} else {
       //  resolveReferencesAndTypes(targetLibrary);
       //}
-      performConstantEvaluation();
+      _performConstantEvaluation();
       instrumentation.metric3("performConstantEvaluation", "complete");
       return targetLibrary.libraryElement;
     } finally {
       instrumentation.log();
     }
   }
 
   /**
    * Resolve the library specified by the given source in the given context.
    *
@@ skipping 12 matching lines @@
     try {
       instrumentation.metric("fullAnalysis", fullAnalysis);
       instrumentation.data3("fullName", librarySource.fullName);
       //
       // Create the objects representing the library being resolved and the core library.
       //
       Library targetLibrary = createLibrary(librarySource);
       _coreLibrary = _libraryMap[_coreLibrarySource];
       if (_coreLibrary == null) {
         // This will be true unless the library being analyzed is the core library.
-        _coreLibrary = createLibraryOrNull(_coreLibrarySource);
+        _coreLibrary = _createLibraryOrNull(_coreLibrarySource);
         if (_coreLibrary == null) {
           throw new AnalysisException.con1("Core library does not exist");
         }
       }
       instrumentation.metric3("createLibrary", "complete");
       //
       // Compute the set of libraries that need to be resolved together.
       //
-      computeLibraryDependencies(targetLibrary);
-      _librariesInCycles = computeLibrariesInCycles(targetLibrary);
+      _computeLibraryDependencies(targetLibrary);
+      _librariesInCycles = _computeLibrariesInCycles(targetLibrary);
       //
       // Build the element models representing the libraries being resolved. This is done in three
       // steps:
       //
       // 1. Build the basic element models without making any connections between elements other than
       //    the basic parent/child relationships. This includes building the elements representing the
       //    libraries.
       // 2. Build the elements for the import and export directives. This requires that we have the
       //    elements built for the referenced libraries, but because of the possibility of circular
       //    references needs to happen after all of the library elements have been created.
       // 3. Build the rest of the type model by connecting superclasses, mixins, and interfaces. This
       //    requires that we be able to compute the names visible in the libraries being resolved,
       //    which in turn requires that we have resolved the import directives.
       //
-      buildElementModels();
+      _buildElementModels();
       instrumentation.metric3("buildElementModels", "complete");
       LibraryElement coreElement = _coreLibrary.libraryElement;
       if (coreElement == null) {
         throw new AnalysisException.con1("Could not resolve dart:core");
       }
-      buildDirectiveModels();
+      _buildDirectiveModels();
       instrumentation.metric3("buildDirectiveModels", "complete");
       _typeProvider = new TypeProviderImpl(coreElement);
-      buildTypeHierarchies();
+      _buildTypeHierarchies();
       instrumentation.metric3("buildTypeHierarchies", "complete");
       //
       // Perform resolution and type analysis.
       //
       // TODO(brianwilkerson) Decide whether we want to resolve all of the libraries or whether we
       // want to only resolve the target library. The advantage to resolving everything is that we
       // have already done part of the work so we'll avoid duplicated effort. The disadvantage of
       // resolving everything is that we might do extra work that we don't really care about. Another
       // possibility is to add a parameter to this method and punt the decision to the clients.
       //
       //if (analyzeAll) {
-      resolveReferencesAndTypes();
+      _resolveReferencesAndTypes();
       instrumentation.metric3("resolveReferencesAndTypes", "complete");
       //} else {
       //  resolveReferencesAndTypes(targetLibrary);
       //}
-      performConstantEvaluation();
+      _performConstantEvaluation();
       instrumentation.metric3("performConstantEvaluation", "complete");
       instrumentation.metric2("librariesInCycles", _librariesInCycles.length);
       for (Library lib in _librariesInCycles) {
         instrumentation.metric2("librariesInCycles-CompilationUnitSources-Size", lib.compilationUnitSources.length);
       }
       return targetLibrary.libraryElement;
     } finally {
       instrumentation.log();
     }
   }
 
   /**
+   * Create an object to represent the information about the library defined by the compilation unit
+   * with the given source.
+   *
+   * @param librarySource the source of the library's defining compilation unit
+   * @return the library object that was created
+   * @throws AnalysisException if the library source is not valid
+   */
+  Library createLibrary(Source librarySource) {
+    Library library = new Library(analysisContext, _errorListener, librarySource);
+    _libraryMap[librarySource] = library;
+    return library;
+  }
+
+  /**
    * Add a dependency to the given map from the referencing library to the referenced library.
    *
    * @param dependencyMap the map to which the dependency is to be added
    * @param referencingLibrary the library that references the referenced library
    * @param referencedLibrary the library referenced by the referencing library
    */
-  void addDependencyToMap(Map<Library, List<Library>> dependencyMap, Library referencingLibrary, Library referencedLibrary) {
+  void _addDependencyToMap(Map<Library, List<Library>> dependencyMap, Library referencingLibrary, Library referencedLibrary) {
     List<Library> dependentLibraries = dependencyMap[referencedLibrary];
     if (dependentLibraries == null) {
       dependentLibraries = new List<Library>();
       dependencyMap[referencedLibrary] = dependentLibraries;
     }
     dependentLibraries.add(referencingLibrary);
   }
 
   /**
    * Given a library that is part of a cycle that includes the root library, add to the given set of
    * libraries all of the libraries reachable from the root library that are also included in the
    * cycle.
    *
    * @param library the library to be added to the collection of libraries in cycles
    * @param librariesInCycle a collection of the libraries that are in the cycle
    * @param dependencyMap a table mapping libraries to the collection of libraries from which those
    *          libraries are referenced
    */
-  void addLibrariesInCycle(Library library, Set<Library> librariesInCycle, Map<Library, List<Library>> dependencyMap) {
+  void _addLibrariesInCycle(Library library, Set<Library> librariesInCycle, Map<Library, List<Library>> dependencyMap) {
     if (librariesInCycle.add(library)) {
       List<Library> dependentLibraries = dependencyMap[library];
       if (dependentLibraries != null) {
         for (Library dependentLibrary in dependentLibraries) {
-          addLibrariesInCycle(dependentLibrary, librariesInCycle, dependencyMap);
+          _addLibrariesInCycle(dependentLibrary, librariesInCycle, dependencyMap);
         }
       }
     }
   }
 
   /**
    * Add the given library, and all libraries reachable from it that have not already been visited,
    * to the given dependency map.
    *
    * @param library the library currently being added to the dependency map
    * @param dependencyMap the dependency map being computed
    * @param visitedLibraries the libraries that have already been visited, used to prevent infinite
    *          recursion
    */
-  void addToDependencyMap(Library library, Map<Library, List<Library>> dependencyMap, Set<Library> visitedLibraries) {
+  void _addToDependencyMap(Library library, Map<Library, List<Library>> dependencyMap, Set<Library> visitedLibraries) {
     if (visitedLibraries.add(library)) {
       for (Library referencedLibrary in library.importsAndExports) {
-        addDependencyToMap(dependencyMap, library, referencedLibrary);
-        addToDependencyMap(referencedLibrary, dependencyMap, visitedLibraries);
+        _addDependencyToMap(dependencyMap, library, referencedLibrary);
+        _addToDependencyMap(referencedLibrary, dependencyMap, visitedLibraries);
       }
       if (!library.explicitlyImportsCore && library != _coreLibrary) {
-        addDependencyToMap(dependencyMap, library, _coreLibrary);
+        _addDependencyToMap(dependencyMap, library, _coreLibrary);
       }
     }
   }
 
   /**
    * Build the element model representing the combinators declared by the given directive.
    *
    * @param directive the directive that declares the combinators
    * @return an array containing the import combinators that were built
    */
-  List<NamespaceCombinator> buildCombinators(NamespaceDirective directive) {
+  List<NamespaceCombinator> _buildCombinators(NamespaceDirective directive) {
     List<NamespaceCombinator> combinators = new List<NamespaceCombinator>();
     for (Combinator combinator in directive.combinators) {
       if (combinator is HideCombinator) {
         HideElementCombinatorImpl hide = new HideElementCombinatorImpl();
-        hide.hiddenNames = getIdentifiers(combinator.hiddenNames);
+        hide.hiddenNames = _getIdentifiers(combinator.hiddenNames);
         combinators.add(hide);
       } else {
         ShowElementCombinatorImpl show = new ShowElementCombinatorImpl();
         show.offset = combinator.offset;
         show.end = combinator.end;
-        show.shownNames = getIdentifiers((combinator as ShowCombinator).shownNames);
+        show.shownNames = _getIdentifiers((combinator as ShowCombinator).shownNames);
         combinators.add(show);
       }
     }
     return new List.from(combinators);
   }
 
   /**
    * Every library now has a corresponding [LibraryElement], so it is now possible to resolve
    * the import and export directives.
    *
    * @throws AnalysisException if the defining compilation unit for any of the libraries could not
    *           be accessed
    */
-  void buildDirectiveModels() {
+  void _buildDirectiveModels() {
     for (Library library in _librariesInCycles) {
       Map<String, PrefixElementImpl> nameToPrefixMap = new Map<String, PrefixElementImpl>();
       List<ImportElement> imports = new List<ImportElement>();
       List<ExportElement> exports = new List<ExportElement>();
       for (Directive directive in library.definingCompilationUnit.directives) {
         if (directive is ImportDirective) {
           ImportDirective importDirective = directive;
           Source importedSource = library.getSource(importDirective);
           if (importedSource != null) {
             // The imported source will be null if the URI in the import directive was invalid.
             Library importedLibrary = _libraryMap[importedSource];
             if (importedLibrary != null) {
               ImportElementImpl importElement = new ImportElementImpl(directive.offset);
               StringLiteral uriLiteral = importDirective.uri;
               if (uriLiteral != null) {
                 importElement.uriEnd = uriLiteral.end;
               }
               importElement.uri = library.getUri(importDirective);
-              importElement.combinators = buildCombinators(importDirective);
+              importElement.combinators = _buildCombinators(importDirective);
               LibraryElement importedLibraryElement = importedLibrary.libraryElement;
               if (importedLibraryElement != null) {
                 importElement.importedLibrary = importedLibraryElement;
               }
               SimpleIdentifier prefixNode = directive.prefix;
               if (prefixNode != null) {
                 importElement.prefixOffset = prefixNode.offset;
                 String prefixName = prefixNode.name;
                 PrefixElementImpl prefix = nameToPrefixMap[prefixName];
                 if (prefix == null) {
@@ skipping 12 matching lines @@
           }
         } else if (directive is ExportDirective) {
           ExportDirective exportDirective = directive;
           Source exportedSource = library.getSource(exportDirective);
           if (exportedSource != null) {
             // The exported source will be null if the URI in the export directive was invalid.
             Library exportedLibrary = _libraryMap[exportedSource];
             if (exportedLibrary != null) {
               ExportElementImpl exportElement = new ExportElementImpl();
               exportElement.uri = library.getUri(exportDirective);
-              exportElement.combinators = buildCombinators(exportDirective);
+              exportElement.combinators = _buildCombinators(exportDirective);
               LibraryElement exportedLibraryElement = exportedLibrary.libraryElement;
               if (exportedLibraryElement != null) {
                 exportElement.exportedLibrary = exportedLibraryElement;
               }
               directive.element = exportElement;
               exports.add(exportElement);
               if (analysisContext.computeKindOf(exportedSource) != SourceKind.LIBRARY) {
                 StringLiteral uriLiteral = exportDirective.uri;
                 _errorListener.onError(new AnalysisError.con2(library.librarySource, uriLiteral.offset, uriLiteral.length, CompileTimeErrorCode.EXPORT_OF_NON_LIBRARY, [uriLiteral.toSource()]));
               }
@@ skipping 19 matching lines @@
         }
       }
     }
   }
 
   /**
    * Build element models for all of the libraries in the current cycle.
    *
    * @throws AnalysisException if any of the element models cannot be built
    */
-  void buildElementModels() {
+  void _buildElementModels() {
     for (Library library in _librariesInCycles) {
       LibraryElementBuilder builder = new LibraryElementBuilder(this);
       LibraryElementImpl libraryElement = builder.buildLibrary(library);
       library.libraryElement = libraryElement;
     }
   }
 
   /**
    * Resolve the type hierarchy across all of the types declared in the libraries in the current
    * cycle.
    *
    * @throws AnalysisException if any of the type hierarchies could not be resolved
    */
-  void buildTypeHierarchies() {
+  void _buildTypeHierarchies() {
     TimeCounter_TimeCounterHandle timeCounter = PerformanceStatistics.resolve.start();
     try {
       for (Library library in _librariesInCycles) {
         for (Source source in library.compilationUnitSources) {
           TypeResolverVisitor visitor = new TypeResolverVisitor.con1(library, source, _typeProvider);
           library.getAST(source).accept(visitor);
         }
       }
     } finally {
       timeCounter.stop();
     }
   }
 
   /**
    * Compute a dependency map of libraries reachable from the given library. A dependency map is a
    * table that maps individual libraries to a list of the libraries that either import or export
    * those libraries.
    *
    * This map is used to compute all of the libraries involved in a cycle that include the root
    * library. Given that we only add libraries that are reachable from the root library, when we
    * work backward we are guaranteed to only get libraries in the cycle.
    *
    * @param library the library currently being added to the dependency map
    */
-  Map<Library, List<Library>> computeDependencyMap(Library library) {
+  Map<Library, List<Library>> _computeDependencyMap(Library library) {
     Map<Library, List<Library>> dependencyMap = new Map<Library, List<Library>>();
-    addToDependencyMap(library, dependencyMap, new Set<Library>());
+    _addToDependencyMap(library, dependencyMap, new Set<Library>());
     return dependencyMap;
   }
 
   /**
    * Recursively traverse the libraries reachable from the given library, creating instances of the
    * class [Library] to represent them, and record the references in the library objects.
    *
    * @param library the library to be processed to find libraries that have not yet been traversed
    * @throws AnalysisException if some portion of the library graph could not be traversed
    */
-  void computeEmbeddedLibraryDependencies(Library library, CompilationUnit unit) {
+  void _computeEmbeddedLibraryDependencies(Library library, CompilationUnit unit) {
     Source librarySource = library.librarySource;
     Set<Source> exportedSources = new Set<Source>();
     Set<Source> importedSources = new Set<Source>();
     for (Directive directive in unit.directives) {
       if (directive is ExportDirective) {
-        Source exportSource = resolveSource(librarySource, directive);
+        Source exportSource = _resolveSource(librarySource, directive);
         if (exportSource != null) {
           exportedSources.add(exportSource);
         }
       } else if (directive is ImportDirective) {
-        Source importSource = resolveSource(librarySource, directive);
+        Source importSource = _resolveSource(librarySource, directive);
         if (importSource != null) {
           importedSources.add(importSource);
         }
       }
     }
-    computeLibraryDependenciesFromDirectives(library, new List.from(importedSources), new List.from(exportedSources));
+    _computeLibraryDependenciesFromDirectives(library, new List.from(importedSources), new List.from(exportedSources));
   }
 
   /**
    * Return a collection containing all of the libraries reachable from the given library that are
    * contained in a cycle that includes the given library.
    *
    * @param library the library that must be included in any cycles whose members are to be returned
    * @return all of the libraries referenced by the given library that have a circular reference
    *         back to the given library
    */
-  Set<Library> computeLibrariesInCycles(Library library) {
-    Map<Library, List<Library>> dependencyMap = computeDependencyMap(library);
+  Set<Library> _computeLibrariesInCycles(Library library) {
+    Map<Library, List<Library>> dependencyMap = _computeDependencyMap(library);
     Set<Library> librariesInCycle = new Set<Library>();
-    addLibrariesInCycle(library, librariesInCycle, dependencyMap);
+    _addLibrariesInCycle(library, librariesInCycle, dependencyMap);
     return librariesInCycle;
   }
 
   /**
    * Recursively traverse the libraries reachable from the given library, creating instances of the
    * class [Library] to represent them, and record the references in the library objects.
    *
    * @param library the library to be processed to find libraries that have not yet been traversed
    * @throws AnalysisException if some portion of the library graph could not be traversed
    */
-  void computeLibraryDependencies(Library library) {
+  void _computeLibraryDependencies(Library library) {
     Source librarySource = library.librarySource;
-    computeLibraryDependenciesFromDirectives(library, analysisContext.computeImportedLibraries(librarySource), analysisContext.computeExportedLibraries(librarySource));
+    _computeLibraryDependenciesFromDirectives(library, analysisContext.computeImportedLibraries(librarySource), analysisContext.computeExportedLibraries(librarySource));
   }
 
   /**
    * Recursively traverse the libraries reachable from the given library, creating instances of the
    * class [Library] to represent them, and record the references in the library objects.
    *
    * @param library the library to be processed to find libraries that have not yet been traversed
    * @param importedSources an array containing the sources that are imported into the given library
    * @param exportedSources an array containing the sources that are exported from the given library
    * @throws AnalysisException if some portion of the library graph could not be traversed
    */
-  void computeLibraryDependenciesFromDirectives(Library library, List<Source> importedSources, List<Source> exportedSources) {
+  void _computeLibraryDependenciesFromDirectives(Library library, List<Source> importedSources, List<Source> exportedSources) {
     List<Library> importedLibraries = new List<Library>();
     bool explicitlyImportsCore = false;
     for (Source importedSource in importedSources) {
       if (importedSource == _coreLibrarySource) {
         explicitlyImportsCore = true;
       }
       Library importedLibrary = _libraryMap[importedSource];
       if (importedLibrary == null) {
-        importedLibrary = createLibraryOrNull(importedSource);
+        importedLibrary = _createLibraryOrNull(importedSource);
         if (importedLibrary != null) {
-          computeLibraryDependencies(importedLibrary);
+          _computeLibraryDependencies(importedLibrary);
         }
       }
       if (importedLibrary != null) {
         importedLibraries.add(importedLibrary);
       }
     }
     library.importedLibraries = new List.from(importedLibraries);
     List<Library> exportedLibraries = new List<Library>();
     for (Source exportedSource in exportedSources) {
       Library exportedLibrary = _libraryMap[exportedSource];
       if (exportedLibrary == null) {
-        exportedLibrary = createLibraryOrNull(exportedSource);
+        exportedLibrary = _createLibraryOrNull(exportedSource);
         if (exportedLibrary != null) {
-          computeLibraryDependencies(exportedLibrary);
+          _computeLibraryDependencies(exportedLibrary);
         }
       }
       if (exportedLibrary != null) {
         exportedLibraries.add(exportedLibrary);
       }
     }
     library.exportedLibraries = new List.from(exportedLibraries);
     library.explicitlyImportsCore = explicitlyImportsCore;
     if (!explicitlyImportsCore && _coreLibrarySource != library.librarySource) {
       Library importedLibrary = _libraryMap[_coreLibrarySource];
       if (importedLibrary == null) {
-        importedLibrary = createLibraryOrNull(_coreLibrarySource);
+        importedLibrary = _createLibraryOrNull(_coreLibrarySource);
         if (importedLibrary != null) {
-          computeLibraryDependencies(importedLibrary);
+          _computeLibraryDependencies(importedLibrary);
         }
       }
     }
   }
 
   /**
    * Create an object to represent the information about the library defined by the compilation unit
-   * with the given source.
-   *
-   * @param librarySource the source of the library's defining compilation unit
-   * @return the library object that was created
-   * @throws AnalysisException if the library source is not valid
-   */
-  Library createLibrary(Source librarySource) {
-    Library library = new Library(analysisContext, _errorListener, librarySource);
-    _libraryMap[librarySource] = library;
-    return library;
-  }
-
-  /**
-   * Create an object to represent the information about the library defined by the compilation unit
    * with the given source. Return the library object that was created, or `null` if the
    * source is not valid.
    *
    * @param librarySource the source of the library's defining compilation unit
    * @return the library object that was created
    */
-  Library createLibraryOrNull(Source librarySource) {
+  Library _createLibraryOrNull(Source librarySource) {
     if (!analysisContext.exists(librarySource)) {
       return null;
     }
     Library library = new Library(analysisContext, _errorListener, librarySource);
     _libraryMap[librarySource] = library;
     return library;
   }
 
   /**
    * Create an object to represent the information about the library defined by the compilation unit
    * with the given source.
    *
    * @param librarySource the source of the library's defining compilation unit
    * @param modificationStamp the modification time of the source from which the compilation unit
    *          was created
    * @param unit the compilation unit that defines the library
    * @return the library object that was created
    * @throws AnalysisException if the library source is not valid
    */
-  Library createLibraryWithUnit(Source librarySource, int modificationStamp, CompilationUnit unit) {
+  Library _createLibraryWithUnit(Source librarySource, int modificationStamp, CompilationUnit unit) {
     Library library = new Library(analysisContext, _errorListener, librarySource);
     library.setDefiningCompilationUnit(modificationStamp, unit);
     _libraryMap[librarySource] = library;
     return library;
   }
 
   /**
    * Return an array containing the lexical identifiers associated with the nodes in the given list.
    *
    * @param names the AST nodes representing the identifiers
    * @return the lexical identifiers associated with the nodes in the list
    */
-  List<String> getIdentifiers(NodeList<SimpleIdentifier> names) {
+  List<String> _getIdentifiers(NodeList<SimpleIdentifier> names) {
     int count = names.length;
     List<String> identifiers = new List<String>(count);
     for (int i = 0; i < count; i++) {
       identifiers[i] = names[i].name;
     }
     return identifiers;
   }
 
   /**
    * Compute a value for all of the constants in the libraries being analyzed.
    */
-  void performConstantEvaluation() {
+  void _performConstantEvaluation() {
     TimeCounter_TimeCounterHandle timeCounter = PerformanceStatistics.resolve.start();
     try {
       ConstantValueComputer computer = new ConstantValueComputer(_typeProvider);
       for (Library library in _librariesInCycles) {
         for (Source source in library.compilationUnitSources) {
           try {
             CompilationUnit unit = library.getAST(source);
             if (unit != null) {
               computer.add(unit);
             }
           } on AnalysisException catch (exception) {
             AnalysisEngine.instance.logger.logError2("Internal Error: Could not access AST for ${source.fullName} during constant evaluation", exception);
           }
         }
       }
       computer.computeValues();
     } finally {
       timeCounter.stop();
     }
   }
 
   /**
    * Resolve the identifiers and perform type analysis in the libraries in the current cycle.
    *
    * @throws AnalysisException if any of the identifiers could not be resolved or if any of the
    *           libraries could not have their types analyzed
    */
-  void resolveReferencesAndTypes() {
+  void _resolveReferencesAndTypes() {
     for (Library library in _librariesInCycles) {
-      resolveReferencesAndTypesInLibrary(library);
+      _resolveReferencesAndTypesInLibrary(library);
     }
   }
 
   /**
    * Resolve the identifiers and perform type analysis in the given library.
    *
    * @param library the library to be resolved
    * @throws AnalysisException if any of the identifiers could not be resolved or if the types in
    *           the library cannot be analyzed
    */
-  void resolveReferencesAndTypesInLibrary(Library library) {
+  void _resolveReferencesAndTypesInLibrary(Library library) {
     TimeCounter_TimeCounterHandle timeCounter = PerformanceStatistics.resolve.start();
     try {
       for (Source source in library.compilationUnitSources) {
         CompilationUnit ast = library.getAST(source);
         ast.accept(new VariableResolverVisitor.con1(library, source, _typeProvider));
         ResolverVisitor visitor = new ResolverVisitor.con1(library, source, _typeProvider);
         ast.accept(visitor);
         for (ProxyConditionalAnalysisError conditionalCode in visitor.proxyConditionalAnalysisErrors) {
           if (conditionalCode.shouldIncludeErrorCode()) {
             visitor.reportError(conditionalCode.analysisError);
@@ skipping 16 matching lines @@
   }
 
   /**
    * Return the result of resolving the URI of the given URI-based directive against the URI of the
    * given library, or `null` if the URI is not valid.
    *
    * @param librarySource the source representing the library containing the directive
    * @param directive the directive which URI should be resolved
    * @return the result of resolving the URI against the URI of the library
    */
-  Source resolveSource(Source librarySource, UriBasedDirective directive) {
+  Source _resolveSource(Source librarySource, UriBasedDirective directive) {
     StringLiteral uriLiteral = directive.uri;
     if (uriLiteral is StringInterpolation) {
       return null;
     }
     String uriContent = uriLiteral.stringValue.trim();
     if (uriContent == null || uriContent.isEmpty) {
       return null;
     }
     uriContent = Uri.encodeFull(uriContent);
     return analysisContext.sourceFactory.resolveUri(librarySource, uriContent);
@@ skipping 24 matching lines @@
    * Default constructor.
    */
   MemberMap() : this.con1(10);
 
   /**
    * This constructor takes an initial capacity of the map.
    *
    * @param initialCapacity the initial capacity
    */
   MemberMap.con1(int initialCapacity) {
-    initArrays(initialCapacity);
+    _initArrays(initialCapacity);
   }
 
   /**
    * Copy constructor.
    */
   MemberMap.con2(MemberMap memberMap) {
-    initArrays(memberMap._size + 5);
+    _initArrays(memberMap._size + 5);
     for (int i = 0; i < memberMap._size; i++) {
       _keys[i] = memberMap._keys[i];
       _values[i] = memberMap._values[i];
     }
     _size = memberMap._size;
   }
 
   /**
    * Given some key, return the ExecutableElement value from the map, if the key does not exist in
    * the map, `null` is returned.
@@ skipping 98 matching lines @@
    * @param i some non-zero value less than size
    * @param value the ExecutableElement value to store in the map
    */
   void setValue(int i, ExecutableElement value) {
     _values[i] = value;
   }
 
   /**
    * Initializes [keys] and [values].
    */
-  void initArrays(int initialCapacity) {
+  void _initArrays(int initialCapacity) {
     _keys = new List<String>(initialCapacity);
     _values = new List<ExecutableElement>(initialCapacity);
   }
 }
 
 /**
  * This class is a wrapper for an [AnalysisError] which can also be queried after resolution
  * to find out if the error should actually be reported. In this case, these errors are conditional
  * on the non-existence of an `@proxy` annotation.
  *
@@ skipping 152 matching lines @@
   List<ProxyConditionalAnalysisError> get proxyConditionalAnalysisErrors => _proxyConditionalAnalysisErrors;
 
   Object visitAsExpression(AsExpression node) {
     super.visitAsExpression(node);
     overrideExpression(node.expression, node.type.type);
     return null;
   }
 
   Object visitAssertStatement(AssertStatement node) {
     super.visitAssertStatement(node);
-    propagateTrueState(node.condition);
+    _propagateTrueState(node.condition);
     return null;
   }
 
   Object visitBinaryExpression(BinaryExpression node) {
     sc.TokenType operatorType = node.operator.type;
     Expression leftOperand = node.leftOperand;
     Expression rightOperand = node.rightOperand;
     if (identical(operatorType, sc.TokenType.AMPERSAND_AMPERSAND)) {
       safelyVisit(leftOperand);
       if (rightOperand != null) {
         try {
           _overrideManager.enterScope();
           _promoteManager.enterScope();
-          propagateTrueState(leftOperand);
+          _propagateTrueState(leftOperand);
           // Type promotion.
-          promoteTypes(leftOperand);
-          clearTypePromotionsIfPotentiallyMutatedIn(leftOperand);
-          clearTypePromotionsIfPotentiallyMutatedIn(rightOperand);
-          clearTypePromotionsIfAccessedInClosureAndProtentiallyMutated(rightOperand);
+          _promoteTypes(leftOperand);
+          _clearTypePromotionsIfPotentiallyMutatedIn(leftOperand);
+          _clearTypePromotionsIfPotentiallyMutatedIn(rightOperand);
+          _clearTypePromotionsIfAccessedInClosureAndProtentiallyMutated(rightOperand);
           // Visit right operand.
           rightOperand.accept(this);
         } finally {
           _overrideManager.exitScope();
           _promoteManager.exitScope();
         }
       }
     } else if (identical(operatorType, sc.TokenType.BAR_BAR)) {
       safelyVisit(leftOperand);
       if (rightOperand != null) {
         try {
           _overrideManager.enterScope();
-          propagateFalseState(leftOperand);
+          _propagateFalseState(leftOperand);
           rightOperand.accept(this);
         } finally {
           _overrideManager.exitScope();
         }
       }
     } else {
       safelyVisit(leftOperand);
       safelyVisit(rightOperand);
     }
     node.accept(_elementResolver);
@@ skipping 94 matching lines @@
   }
 
   Object visitConditionalExpression(ConditionalExpression node) {
     Expression condition = node.condition;
     safelyVisit(condition);
     Expression thenExpression = node.thenExpression;
     if (thenExpression != null) {
       try {
         _overrideManager.enterScope();
         _promoteManager.enterScope();
-        propagateTrueState(condition);
+        _propagateTrueState(condition);
         // Type promotion.
-        promoteTypes(condition);
-        clearTypePromotionsIfPotentiallyMutatedIn(thenExpression);
-        clearTypePromotionsIfAccessedInClosureAndProtentiallyMutated(thenExpression);
+        _promoteTypes(condition);
+        _clearTypePromotionsIfPotentiallyMutatedIn(thenExpression);
+        _clearTypePromotionsIfAccessedInClosureAndProtentiallyMutated(thenExpression);
         // Visit "then" expression.
         thenExpression.accept(this);
       } finally {
         _overrideManager.exitScope();
         _promoteManager.exitScope();
       }
     }
     Expression elseExpression = node.elseExpression;
     if (elseExpression != null) {
       try {
         _overrideManager.enterScope();
-        propagateFalseState(condition);
+        _propagateFalseState(condition);
         elseExpression.accept(this);
       } finally {
         _overrideManager.exitScope();
       }
     }
     node.accept(_elementResolver);
     node.accept(_typeAnalyzer);
-    bool thenIsAbrupt = isAbruptTerminationExpression(thenExpression);
-    bool elseIsAbrupt = isAbruptTerminationExpression(elseExpression);
+    bool thenIsAbrupt = _isAbruptTerminationExpression(thenExpression);
+    bool elseIsAbrupt = _isAbruptTerminationExpression(elseExpression);
     if (elseIsAbrupt && !thenIsAbrupt) {
-      propagateTrueState(condition);
-      propagateState(thenExpression);
+      _propagateTrueState(condition);
+      _propagateState(thenExpression);
     } else if (thenIsAbrupt && !elseIsAbrupt) {
-      propagateFalseState(condition);
-      propagateState(elseExpression);
+      _propagateFalseState(condition);
+      _propagateState(elseExpression);
     }
     return null;
   }
 
   Object visitConstructorDeclaration(ConstructorDeclaration node) {
     ExecutableElement outerFunction = _enclosingFunction;
     try {
       _enclosingFunction = node.element;
       super.visitConstructorDeclaration(node);
     } finally {
@@ skipping 113 matching lines @@
     } finally {
       _overrideManager.exitScope();
       _enclosingFunction = outerFunction;
     }
     return null;
   }
 
   Object visitFunctionExpressionInvocation(FunctionExpressionInvocation node) {
     safelyVisit(node.function);
     node.accept(_elementResolver);
-    inferFunctionExpressionsParametersTypes(node.argumentList);
+    _inferFunctionExpressionsParametersTypes(node.argumentList);
     safelyVisit(node.argumentList);
     node.accept(_typeAnalyzer);
     return null;
   }
 
   Object visitHideCombinator(HideCombinator node) => null;
 
   Object visitIfStatement(IfStatement node) {
     Expression condition = node.condition;
     safelyVisit(condition);
     Map<Element, Type2> thenOverrides = null;
     Statement thenStatement = node.thenStatement;
     if (thenStatement != null) {
       try {
         _overrideManager.enterScope();
         _promoteManager.enterScope();
-        propagateTrueState(condition);
+        _propagateTrueState(condition);
         // Type promotion.
-        promoteTypes(condition);
-        clearTypePromotionsIfPotentiallyMutatedIn(thenStatement);
-        clearTypePromotionsIfAccessedInClosureAndProtentiallyMutated(thenStatement);
+        _promoteTypes(condition);
+        _clearTypePromotionsIfPotentiallyMutatedIn(thenStatement);
+        _clearTypePromotionsIfAccessedInClosureAndProtentiallyMutated(thenStatement);
         // Visit "then".
         visitStatementInScope(thenStatement);
       } finally {
         thenOverrides = _overrideManager.captureLocalOverrides();
         _overrideManager.exitScope();
         _promoteManager.exitScope();
       }
     }
     Map<Element, Type2> elseOverrides = null;
     Statement elseStatement = node.elseStatement;
     if (elseStatement != null) {
       try {
         _overrideManager.enterScope();
-        propagateFalseState(condition);
+        _propagateFalseState(condition);
         visitStatementInScope(elseStatement);
       } finally {
         elseOverrides = _overrideManager.captureLocalOverrides();
         _overrideManager.exitScope();
       }
     }
     node.accept(_elementResolver);
     node.accept(_typeAnalyzer);
-    bool thenIsAbrupt = isAbruptTerminationStatement(thenStatement);
-    bool elseIsAbrupt = isAbruptTerminationStatement(elseStatement);
+    bool thenIsAbrupt = _isAbruptTerminationStatement(thenStatement);
+    bool elseIsAbrupt = _isAbruptTerminationStatement(elseStatement);
     if (elseIsAbrupt && !thenIsAbrupt) {
-      propagateTrueState(condition);
+      _propagateTrueState(condition);
       if (thenOverrides != null) {
         _overrideManager.applyOverrides(thenOverrides);
       }
     } else if (thenIsAbrupt && !elseIsAbrupt) {
-      propagateFalseState(condition);
+      _propagateFalseState(condition);
       if (elseOverrides != null) {
         _overrideManager.applyOverrides(elseOverrides);
       }
     }
     return null;
   }
 
   Object visitLabel(Label node) => null;
 
   Object visitLibraryIdentifier(LibraryIdentifier node) => null;
 
   Object visitMethodDeclaration(MethodDeclaration node) {
     ExecutableElement outerFunction = _enclosingFunction;
     try {
       _enclosingFunction = node.element;
       super.visitMethodDeclaration(node);
     } finally {
       _enclosingFunction = outerFunction;
     }
     return null;
   }
 
   Object visitMethodInvocation(MethodInvocation node) {
     //
     // We visit the target and argument list, but do not visit the method name because it needs to
     // be visited in the context of the invocation.
     //
     safelyVisit(node.target);
     node.accept(_elementResolver);
-    inferFunctionExpressionsParametersTypes(node.argumentList);
+    _inferFunctionExpressionsParametersTypes(node.argumentList);
     safelyVisit(node.argumentList);
     node.accept(_typeAnalyzer);
     return null;
   }
 
   Object visitNode(AstNode node) {
     node.visitChildren(this);
     node.accept(_elementResolver);
     node.accept(_typeAnalyzer);
     return null;
@@ skipping 79 matching lines @@
 
   Object visitTypeName(TypeName node) => null;
 
   Object visitWhileStatement(WhileStatement node) {
     Expression condition = node.condition;
     safelyVisit(condition);
     Statement body = node.body;
     if (body != null) {
       try {
         _overrideManager.enterScope();
-        propagateTrueState(condition);
+        _propagateTrueState(condition);
         visitStatementInScope(body);
       } finally {
         _overrideManager.exitScope();
       }
     }
     // TODO(brianwilkerson) If the loop can only be exited because the condition is false, then
     // propagateFalseState(condition);
     node.accept(_elementResolver);
     node.accept(_typeAnalyzer);
     return null;
@@ skipping 119 matching lines @@
   void overrideVariable(VariableElement element, Type2 potentialType) {
     if (potentialType == null || potentialType.isBottom) {
       return;
     }
     if (element is PropertyInducingElement) {
       PropertyInducingElement variable = element;
       if (!variable.isConst && !variable.isFinal) {
         return;
       }
     }
-    Type2 currentType = getBestType(element);
+    Type2 currentType = _getBestType(element);
     if (currentType == null || !currentType.isMoreSpecificThan(potentialType)) {
       _overrideManager.setType(element, potentialType);
     }
   }
 
   /**
    * Report a conditional analysis error with the given error code and arguments.
    *
    * @param enclosingElement the enclosing element
    * @param errorCode the error code of the error to be reported
@@ skipping 40 matching lines @@
     SimpleIdentifier identifier = node.identifier;
     safelyVisit(loopVariable);
     safelyVisit(identifier);
     Statement body = node.body;
     if (body != null) {
       try {
         _overrideManager.enterScope();
         if (loopVariable != null && iterator != null) {
           LocalVariableElement loopElement = loopVariable.element;
           if (loopElement != null) {
-            Type2 iteratorElementType = getIteratorElementType(iterator);
+            Type2 iteratorElementType = _getIteratorElementType(iterator);
             overrideVariable(loopElement, iteratorElementType);
-            recordPropagatedType(loopVariable.identifier, iteratorElementType);
+            _recordPropagatedType(loopVariable.identifier, iteratorElementType);
           }
         } else if (identifier != null && iterator != null) {
           Element identifierElement = identifier.staticElement;
           if (identifierElement is VariableElement) {
-            Type2 iteratorElementType = getIteratorElementType(iterator);
+            Type2 iteratorElementType = _getIteratorElementType(iterator);
             overrideVariable(identifierElement, iteratorElementType);
-            recordPropagatedType(identifier, iteratorElementType);
+            _recordPropagatedType(identifier, iteratorElementType);
           }
         }
         visitStatementInScope(body);
       } finally {
         _overrideManager.exitScope();
       }
     }
     node.accept(_elementResolver);
     node.accept(_typeAnalyzer);
   }
 
   void visitForStatementInScope(ForStatement node) {
     safelyVisit(node.variables);
     safelyVisit(node.initialization);
     safelyVisit(node.condition);
     _overrideManager.enterScope();
     try {
-      propagateTrueState(node.condition);
+      _propagateTrueState(node.condition);
       visitStatementInScope(node.body);
       node.updaters.accept(this);
     } finally {
       _overrideManager.exitScope();
     }
   }
 
   /**
    * Checks each promoted variable in the current scope for compliance with the following
    * specification statement:
    *
    * If the variable <i>v</i> is accessed by a closure in <i>s<sub>1</sub></i> then the variable
    * <i>v</i> is not potentially mutated anywhere in the scope of <i>v</i>.
    */
-  void clearTypePromotionsIfAccessedInClosureAndProtentiallyMutated(AstNode target) {
+  void _clearTypePromotionsIfAccessedInClosureAndProtentiallyMutated(AstNode target) {
     for (Element element in _promoteManager.promotedElements) {
       if ((element as VariableElementImpl).isPotentiallyMutatedInScope) {
-        if (isVariableAccessedInClosure(element, target)) {
+        if (_isVariableAccessedInClosure(element, target)) {
           _promoteManager.setType(element, null);
         }
       }
     }
   }
 
   /**
    * Checks each promoted variable in the current scope for compliance with the following
    * specification statement:
    *
    * <i>v</i> is not potentially mutated in <i>s<sub>1</sub></i> or within a closure.
    */
-  void clearTypePromotionsIfPotentiallyMutatedIn(AstNode target) {
+  void _clearTypePromotionsIfPotentiallyMutatedIn(AstNode target) {
     for (Element element in _promoteManager.promotedElements) {
-      if (isVariablePotentiallyMutatedIn(element, target)) {
+      if (_isVariablePotentiallyMutatedIn(element, target)) {
         _promoteManager.setType(element, null);
       }
     }
   }
 
   /**
    * Return the best type information available for the given element. If the type of the element
    * has been overridden, then return the overriding type. Otherwise, return the static type.
    *
    * @param element the element for which type information is to be returned
    * @return the best type information available for the given element
    */
-  Type2 getBestType(Element element) {
+  Type2 _getBestType(Element element) {
     Type2 bestType = _overrideManager.getType(element);
     if (bestType == null) {
       if (element is LocalVariableElement) {
         bestType = element.type;
       } else if (element is ParameterElement) {
         bestType = element.type;
       }
     }
     return bestType;
   }
 
   /**
    * The given expression is the expression used to compute the iterator for a for-each statement.
    * Attempt to compute the type of objects that will be assigned to the loop variable and return
    * that type. Return `null` if the type could not be determined.
    *
    * @param iterator the iterator for a for-each statement
    * @return the type of objects that will be assigned to the loop variable
    */
-  Type2 getIteratorElementType(Expression iteratorExpression) {
+  Type2 _getIteratorElementType(Expression iteratorExpression) {
     Type2 expressionType = iteratorExpression.staticType;
     if (expressionType is InterfaceType) {
       InterfaceType interfaceType = expressionType;
       FunctionType iteratorFunction = _inheritanceManager.lookupMemberType(interfaceType, "iterator");
       if (iteratorFunction == null) {
         // TODO(brianwilkerson) Should we report this error?
         return null;
       }
       Type2 iteratorType = iteratorFunction.returnType;
       if (iteratorType is InterfaceType) {
         InterfaceType iteratorInterfaceType = iteratorType;
         FunctionType currentFunction = _inheritanceManager.lookupMemberType(iteratorInterfaceType, "current");
         if (currentFunction == null) {
           // TODO(brianwilkerson) Should we report this error?
           return null;
         }
         return currentFunction.returnType;
       }
     }
     return null;
   }
 
   /**
    * If given "mayBeClosure" is [FunctionExpression] without explicit parameters types and its
    * required type is [FunctionType], then infer parameters types from [FunctionType].
    */
-  void inferFunctionExpressionParametersTypes(Expression mayBeClosure, Type2 mayByFunctionType) {
+  void _inferFunctionExpressionParametersTypes(Expression mayBeClosure, Type2 mayByFunctionType) {
     // prepare closure
     if (mayBeClosure is! FunctionExpression) {
       return;
     }
     FunctionExpression closure = mayBeClosure as FunctionExpression;
     // prepare expected closure type
     if (mayByFunctionType is! FunctionType) {
       return;
     }
     FunctionType expectedClosureType = mayByFunctionType as FunctionType;
     // set propagated type for the closure
     closure.propagatedType = expectedClosureType;
     // set inferred types for parameters
     NodeList<FormalParameter> parameters = closure.parameters.parameters;
     List<ParameterElement> expectedParameters = expectedClosureType.parameters;
     for (int i = 0; i < parameters.length && i < expectedParameters.length; i++) {
       FormalParameter parameter = parameters[i];
       ParameterElement element = parameter.element;
-      Type2 currentType = getBestType(element);
+      Type2 currentType = _getBestType(element);
       // may be override the type
       Type2 expectedType = expectedParameters[i].type;
       if (currentType == null || expectedType.isMoreSpecificThan(currentType)) {
         _overrideManager.setType(element, expectedType);
       }
     }
   }
 
   /**
    * Try to infer types of parameters of the [FunctionExpression] arguments.
    */
-  void inferFunctionExpressionsParametersTypes(ArgumentList argumentList) {
+  void _inferFunctionExpressionsParametersTypes(ArgumentList argumentList) {
     for (Expression argument in argumentList.arguments) {
       ParameterElement parameter = argument.propagatedParameterElement;
       if (parameter == null) {
         parameter = argument.staticParameterElement;
       }
       if (parameter != null) {
-        inferFunctionExpressionParametersTypes(argument, parameter.type);
+        _inferFunctionExpressionParametersTypes(argument, parameter.type);
       }
     }
   }
 
   /**
    * Return `true` if the given expression terminates abruptly (that is, if any expression
    * following the given expression will not be reached).
    *
    * @param expression the expression being tested
    * @return `true` if the given expression terminates abruptly
    */
-  bool isAbruptTerminationExpression(Expression expression) {
+  bool _isAbruptTerminationExpression(Expression expression) {
     // TODO(brianwilkerson) This needs to be significantly improved. Ideally we would eventually
     // turn this into a method on Expression that returns a termination indication (normal, abrupt
     // with no exception, abrupt with an exception).
     while (expression is ParenthesizedExpression) {
       expression = (expression as ParenthesizedExpression).expression;
     }
     return expression is ThrowExpression || expression is RethrowExpression;
   }
 
   /**
    * Return `true` if the given statement terminates abruptly (that is, if any statement
    * following the given statement will not be reached).
    *
    * @param statement the statement being tested
    * @return `true` if the given statement terminates abruptly
    */
-  bool isAbruptTerminationStatement(Statement statement) {
+  bool _isAbruptTerminationStatement(Statement statement) {
     // TODO(brianwilkerson) This needs to be significantly improved. Ideally we would eventually
     // turn this into a method on Statement that returns a termination indication (normal, abrupt
     // with no exception, abrupt with an exception).
     if (statement is ReturnStatement || statement is BreakStatement || statement is ContinueStatement) {
       return true;
     } else if (statement is ExpressionStatement) {
-      return isAbruptTerminationExpression(statement.expression);
+      return _isAbruptTerminationExpression(statement.expression);
     } else if (statement is Block) {
       NodeList<Statement> statements = statement.statements;
       int size = statements.length;
       if (size == 0) {
         return false;
       }
-      return isAbruptTerminationStatement(statements[size - 1]);
+      return _isAbruptTerminationStatement(statements[size - 1]);
     }
     return false;
   }
 
   /**
    * Return `true` if the given variable is accessed within a closure in the given
    * [AstNode] and also mutated somewhere in variable scope. This information is only
    * available for local variables (including parameters).
    *
    * @param variable the variable to check
    * @param target the [AstNode] to check within
    * @return `true` if this variable is potentially mutated somewhere in the given ASTNode
    */
-  bool isVariableAccessedInClosure(Element variable, AstNode target) {
+  bool _isVariableAccessedInClosure(Element variable, AstNode target) {
     List<bool> result = [false];
     target.accept(new RecursiveAstVisitor_ResolverVisitor_isVariableAccessedInClosure(result, variable));
     return result[0];
   }
 
   /**
    * Return `true` if the given variable is potentially mutated somewhere in the given
    * [AstNode]. This information is only available for local variables (including parameters).
    *
    * @param variable the variable to check
    * @param target the [AstNode] to check within
    * @return `true` if this variable is potentially mutated somewhere in the given ASTNode
    */
-  bool isVariablePotentiallyMutatedIn(Element variable, AstNode target) {
+  bool _isVariablePotentiallyMutatedIn(Element variable, AstNode target) {
     List<bool> result = [false];
     target.accept(new RecursiveAstVisitor_ResolverVisitor_isVariablePotentiallyMutatedIn(result, variable));
     return result[0];
   }
 
   /**
    * If it is appropriate to do so, promotes the current type of the static element associated with
    * the given expression with the given type. Generally speaking, it is appropriate if the given
    * type is more specific than the current type.
    *
    * @param expression the expression used to access the static element whose types might be
    *          promoted
    * @param potentialType the potential type of the elements
    */
-  void promote(Expression expression, Type2 potentialType) {
+  void _promote(Expression expression, Type2 potentialType) {
     VariableElement element = getPromotionStaticElement(expression);
     if (element != null) {
       // may be mutated somewhere in closure
       if ((element as VariableElementImpl).isPotentiallyMutatedInClosure) {
         return;
       }
       // prepare current variable type
       Type2 type = _promoteManager.getType(element);
       if (type == null) {
         type = expression.staticType;
@@ skipping 11 matching lines @@
         return;
       }
       // Do promote type of variable.
       _promoteManager.setType(element, potentialType);
     }
   }
 
   /**
    * Promotes type information using given condition.
    */
-  void promoteTypes(Expression condition) {
+  void _promoteTypes(Expression condition) {
     if (condition is BinaryExpression) {
       BinaryExpression binary = condition;
       if (identical(binary.operator.type, sc.TokenType.AMPERSAND_AMPERSAND)) {
         Expression left = binary.leftOperand;
         Expression right = binary.rightOperand;
-        promoteTypes(left);
-        promoteTypes(right);
-        clearTypePromotionsIfPotentiallyMutatedIn(right);
+        _promoteTypes(left);
+        _promoteTypes(right);
+        _clearTypePromotionsIfPotentiallyMutatedIn(right);
       }
     } else if (condition is IsExpression) {
       IsExpression is2 = condition;
       if (is2.notOperator == null) {
-        promote(is2.expression, is2.type.type);
+        _promote(is2.expression, is2.type.type);
       }
     } else if (condition is ParenthesizedExpression) {
-      promoteTypes(condition.expression);
+      _promoteTypes(condition.expression);
     }
   }
 
   /**
    * Propagate any type information that results from knowing that the given condition will have
    * been evaluated to 'false'.
    *
    * @param condition the condition that will have evaluated to 'false'
    */
-  void propagateFalseState(Expression condition) {
+  void _propagateFalseState(Expression condition) {
     if (condition is BinaryExpression) {
       BinaryExpression binary = condition;
       if (identical(binary.operator.type, sc.TokenType.BAR_BAR)) {
-        propagateFalseState(binary.leftOperand);
-        propagateFalseState(binary.rightOperand);
+        _propagateFalseState(binary.leftOperand);
+        _propagateFalseState(binary.rightOperand);
       }
     } else if (condition is IsExpression) {
       IsExpression is2 = condition;
       if (is2.notOperator != null) {
         overrideExpression(is2.expression, is2.type.type);
       }
     } else if (condition is PrefixExpression) {
       PrefixExpression prefix = condition;
       if (identical(prefix.operator.type, sc.TokenType.BANG)) {
-        propagateTrueState(prefix.operand);
+        _propagateTrueState(prefix.operand);
       }
     } else if (condition is ParenthesizedExpression) {
-      propagateFalseState(condition.expression);
+      _propagateFalseState(condition.expression);
     }
   }
 
   /**
    * Propagate any type information that results from knowing that the given expression will have
    * been evaluated without altering the flow of execution.
    *
    * @param expression the expression that will have been evaluated
    */
-  void propagateState(Expression expression) {
+  void _propagateState(Expression expression) {
   }
 
   /**
    * Propagate any type information that results from knowing that the given condition will have
    * been evaluated to 'true'.
    *
    * @param condition the condition that will have evaluated to 'true'
    */
-  void propagateTrueState(Expression condition) {
+  void _propagateTrueState(Expression condition) {
     if (condition is BinaryExpression) {
       BinaryExpression binary = condition;
       if (identical(binary.operator.type, sc.TokenType.AMPERSAND_AMPERSAND)) {
-        propagateTrueState(binary.leftOperand);
-        propagateTrueState(binary.rightOperand);
+        _propagateTrueState(binary.leftOperand);
+        _propagateTrueState(binary.rightOperand);
       }
     } else if (condition is IsExpression) {
       IsExpression is2 = condition;
       if (is2.notOperator == null) {
         overrideExpression(is2.expression, is2.type.type);
       }
     } else if (condition is PrefixExpression) {
       PrefixExpression prefix = condition;
       if (identical(prefix.operator.type, sc.TokenType.BANG)) {
-        propagateFalseState(prefix.operand);
+        _propagateFalseState(prefix.operand);
       }
     } else if (condition is ParenthesizedExpression) {
-      propagateTrueState(condition.expression);
+      _propagateTrueState(condition.expression);
     }
   }
 
   /**
    * Record that the propagated type of the given node is the given type.
    *
    * @param expression the node whose type is to be recorded
    * @param type the propagated type of the node
    */
-  void recordPropagatedType(Expression expression, Type2 type) {
+  void _recordPropagatedType(Expression expression, Type2 type) {
     if (type != null && !type.isDynamic) {
       expression.propagatedType = type;
     }
   }
 
   get elementResolver_J2DAccessor => _elementResolver;
 
   set elementResolver_J2DAccessor(__v) => _elementResolver = __v;
 
   get labelScope_J2DAccessor => _labelScope;
@@ skipping 180 matching lines @@
    * @param errorCode analysis error
    */
   void reportError(AnalysisError analysisError) {
     _errorListener.onError(analysisError);
   }
 
   Object visitBlock(Block node) {
     Scope outerScope = _nameScope;
     try {
       EnclosedScope enclosedScope = new EnclosedScope(_nameScope);
-      hideNamesDefinedInBlock(enclosedScope, node);
+      _hideNamesDefinedInBlock(enclosedScope, node);
       _nameScope = enclosedScope;
       super.visitBlock(node);
     } finally {
       _nameScope = outerScope;
     }
     return null;
   }
 
   Object visitCatchClause(CatchClause node) {
     SimpleIdentifier exception = node.exceptionParameter;
@@ skipping 157 matching lines @@
   }
 
   Object visitIfStatement(IfStatement node) {
     safelyVisit(node.condition);
     visitStatementInScope(node.thenStatement);
     visitStatementInScope(node.elseStatement);
     return null;
   }
 
   Object visitLabeledStatement(LabeledStatement node) {
-    LabelScope outerScope = addScopesFor(node.labels);
+    LabelScope outerScope = _addScopesFor(node.labels);
     try {
       super.visitLabeledStatement(node);
     } finally {
       _labelScope = outerScope;
     }
     return null;
   }
 
   Object visitMethodDeclaration(MethodDeclaration node) {
     Scope outerScope = _nameScope;
@@ skipping 186 matching lines @@
       }
     }
   }
 
   /**
    * Add scopes for each of the given labels.
    *
    * @param labels the labels for which new scopes are to be added
    * @return the scope that was in effect before the new scopes were added
    */
-  LabelScope addScopesFor(NodeList<Label> labels) {
+  LabelScope _addScopesFor(NodeList<Label> labels) {
     LabelScope outerScope = _labelScope;
     for (Label label in labels) {
       SimpleIdentifier labelNameNode = label.label;
       String labelName = labelNameNode.name;
       LabelElement labelElement = labelNameNode.staticElement as LabelElement;
       _labelScope = new LabelScope.con2(_labelScope, labelName, labelElement);
     }
     return outerScope;
   }
 
   /**
    * Marks the local declarations of the given [Block] hidden in the enclosing scope.
    * According to the scoping rules name is hidden if block defines it, but name is defined after
    * its declaration statement.
    */
-  void hideNamesDefinedInBlock(EnclosedScope scope, Block block) {
+  void _hideNamesDefinedInBlock(EnclosedScope scope, Block block) {
     NodeList<Statement> statements = block.statements;
     int statementCount = statements.length;
     for (int i = 0; i < statementCount; i++) {
       Statement statement = statements[i];
       if (statement is VariableDeclarationStatement) {
         VariableDeclarationStatement vds = statement;
         NodeList<VariableDeclaration> variables = vds.variables.variables;
         int variableCount = variables.length;
         for (int j = 0; j < variableCount; j++) {
           scope.hide(variables[j].element);
@@ skipping 15 matching lines @@
  * * Every node representing an expression should be resolved to the Type of the expression.
  * </ol>
  */
 class StaticTypeAnalyzer extends SimpleAstVisitor<Object> {
   /**
    * Create a table mapping HTML tag names to the names of the classes (in 'dart:html') that
    * implement those tags.
    *
    * @return the table that was created
    */
-  static Map<String, String> createHtmlTagToClassMap() {
+  static Map<String, String> _createHtmlTagToClassMap() {
     Map<String, String> map = new Map<String, String>();
     map["a"] = "AnchorElement";
     map["area"] = "AreaElement";
     map["br"] = "BRElement";
     map["base"] = "BaseElement";
     map["body"] = "BodyElement";
     map["button"] = "ButtonElement";
     map["canvas"] = "CanvasElement";
     map["content"] = "ContentElement";
     map["dl"] = "DListElement";
@@ skipping 82 matching lines @@
 
   /**
    * A table mapping [ExecutableElement]s to their propagated return types.
    */
   Map<ExecutableElement, Type2> _propagatedReturnTypes = new Map<ExecutableElement, Type2>();
 
   /**
    * A table mapping HTML tag names to the names of the classes (in 'dart:html') that implement
    * those tags.
    */
-  static Map<String, String> _HTML_ELEMENT_TO_CLASS_MAP = createHtmlTagToClassMap();
+  static Map<String, String> _HTML_ELEMENT_TO_CLASS_MAP = _createHtmlTagToClassMap();
 
   /**
    * Initialize a newly created type analyzer.
    *
    * @param resolver the resolver driving this participant
    */
   StaticTypeAnalyzer(ResolverVisitor resolver) {
     this._resolver = resolver;
     _typeProvider = resolver.typeProvider;
     _dynamicType = _typeProvider.dynamicType;
     _overrideManager = resolver.overrideManager;
     _promoteManager = resolver.promoteManager;
   }
 
   /**
    * Set the type of the class being analyzed to the given type.
    *
    * @param thisType the type representing the class containing the nodes being analyzed
    */
   void set thisType(InterfaceType thisType) {
     this._thisType = thisType;
   }
 
   /**
    * The Dart Language Specification, 12.5: <blockquote>The static type of a string literal is
    * `String`.</blockquote>
    */
   Object visitAdjacentStrings(AdjacentStrings node) {
-    recordStaticType(node, _typeProvider.stringType);
+    _recordStaticType(node, _typeProvider.stringType);
     return null;
   }
 
   /**
    * The Dart Language Specification, 12.33: <blockquote>The static type of an argument definition
    * test is `bool`.</blockquote>
    */
   Object visitArgumentDefinitionTest(ArgumentDefinitionTest node) {
-    recordStaticType(node, _typeProvider.boolType);
+    _recordStaticType(node, _typeProvider.boolType);
     return null;
   }
 
   /**
    * The Dart Language Specification, 12.32: <blockquote>... the cast expression <i>e as T</i> ...
    *
    * It is a static warning if <i>T</i> does not denote a type available in the current lexical
    * scope.
    *
    * The static type of a cast expression <i>e as T</i> is <i>T</i>.</blockquote>
    */
   Object visitAsExpression(AsExpression node) {
-    recordStaticType(node, getType(node.type));
+    _recordStaticType(node, _getType(node.type));
     return null;
   }
 
   /**
    * The Dart Language Specification, 12.18: <blockquote>... an assignment <i>a</i> of the form <i>v
    * = e</i> ...
    *
    * It is a static type warning if the static type of <i>e</i> may not be assigned to the static
    * type of <i>v</i>.
    *
@@ skipping 26 matching lines @@
    * = x.v op e<sub>2</sub>)(e<sub>1</sub>)</i> where <i>x</i> is a variable that is not used in
    * <i>e<sub>2</sub></i>. A compound assignment of the form <i>e<sub>1</sub>[e<sub>2</sub>] op=
    * e<sub>3</sub></i> is equivalent to <i>((a, i) => a[i] = a[i] op e<sub>3</sub>)(e<sub>1</sub>,
    * e<sub>2</sub>)</i> where <i>a</i> and <i>i</i> are a variables that are not used in
    * <i>e<sub>3</sub></i>.</blockquote>
    */
   Object visitAssignmentExpression(AssignmentExpression node) {
     sc.TokenType operator = node.operator.type;
     if (identical(operator, sc.TokenType.EQ)) {
       Expression rightHandSide = node.rightHandSide;
-      Type2 staticType = getStaticType(rightHandSide);
-      recordStaticType(node, staticType);
+      Type2 staticType = _getStaticType(rightHandSide);
+      _recordStaticType(node, staticType);
       Type2 overrideType = staticType;
       Type2 propagatedType = rightHandSide.propagatedType;
       if (propagatedType != null) {
         if (propagatedType.isMoreSpecificThan(staticType)) {
-          recordPropagatedType(node, propagatedType);
+          _recordPropagatedType(node, propagatedType);
         }
         overrideType = propagatedType;
       }
       _resolver.overrideExpression(node.leftHandSide, overrideType);
     } else {
       ExecutableElement staticMethodElement = node.staticElement;
-      Type2 staticType = computeStaticReturnType(staticMethodElement);
-      recordStaticType(node, staticType);
+      Type2 staticType = _computeStaticReturnType(staticMethodElement);
+      _recordStaticType(node, staticType);
       MethodElement propagatedMethodElement = node.propagatedElement;
       if (propagatedMethodElement != staticMethodElement) {
-        Type2 propagatedType = computeStaticReturnType(propagatedMethodElement);
+        Type2 propagatedType = _computeStaticReturnType(propagatedMethodElement);
         if (propagatedType != null && propagatedType.isMoreSpecificThan(staticType)) {
-          recordPropagatedType(node, propagatedType);
+          _recordPropagatedType(node, propagatedType);
         }
       }
     }
     return null;
   }
 
   /**
    * The Dart Language Specification, 12.20: <blockquote>The static type of a logical boolean
    * expression is `bool`.</blockquote>
    *
@@ skipping 25 matching lines @@
    * <i>super.op(e<sub>2</sub>)</i>.</blockquote>
    *
    * The Dart Language Specification, 12.26: <blockquote>A multiplicative expression of the form
    * <i>e<sub>1</sub> op e<sub>2</sub></i> is equivalent to the method invocation
    * <i>e<sub>1</sub>.op(e<sub>2</sub>)</i>. A multiplicative expression of the form <i>super op
    * e<sub>2</sub></i> is equivalent to the method invocation
    * <i>super.op(e<sub>2</sub>)</i>.</blockquote>
    */
   Object visitBinaryExpression(BinaryExpression node) {
     ExecutableElement staticMethodElement = node.staticElement;
-    Type2 staticType = computeStaticReturnType(staticMethodElement);
-    staticType = refineBinaryExpressionType(node, staticType);
-    recordStaticType(node, staticType);
+    Type2 staticType = _computeStaticReturnType(staticMethodElement);
+    staticType = _refineBinaryExpressionType(node, staticType);
+    _recordStaticType(node, staticType);
     MethodElement propagatedMethodElement = node.propagatedElement;
     if (propagatedMethodElement != staticMethodElement) {
-      Type2 propagatedType = computeStaticReturnType(propagatedMethodElement);
+      Type2 propagatedType = _computeStaticReturnType(propagatedMethodElement);
       if (propagatedType != null && propagatedType.isMoreSpecificThan(staticType)) {
-        recordPropagatedType(node, propagatedType);
+        _recordPropagatedType(node, propagatedType);
       }
     }
     return null;
   }
 
   /**
    * The Dart Language Specification, 12.4: <blockquote>The static type of a boolean literal is
    * bool.</blockquote>
    */
   Object visitBooleanLiteral(BooleanLiteral node) {
-    recordStaticType(node, _typeProvider.boolType);
+    _recordStaticType(node, _typeProvider.boolType);
     return null;
   }
 
   /**
    * The Dart Language Specification, 12.15.2: <blockquote>A cascaded method invocation expression
    * of the form <i>e..suffix</i> is equivalent to the expression <i>(t) {t.suffix; return
    * t;}(e)</i>.</blockquote>
    */
   Object visitCascadeExpression(CascadeExpression node) {
-    recordStaticType(node, getStaticType(node.target));
-    recordPropagatedType(node, node.target.propagatedType);
+    _recordStaticType(node, _getStaticType(node.target));
+    _recordPropagatedType(node, node.target.propagatedType);
     return null;
   }
 
   /**
    * The Dart Language Specification, 12.19: <blockquote> ... a conditional expression <i>c</i> of
    * the form <i>e<sub>1</sub> ? e<sub>2</sub> : e<sub>3</sub></i> ...
    *
    * It is a static type warning if the type of e<sub>1</sub> may not be assigned to `bool`.
    *
    * The static type of <i>c</i> is the least upper bound of the static type of <i>e<sub>2</sub></i>
    * and the static type of <i>e<sub>3</sub></i>.</blockquote>
    */
   Object visitConditionalExpression(ConditionalExpression node) {
-    Type2 staticThenType = getStaticType(node.thenExpression);
-    Type2 staticElseType = getStaticType(node.elseExpression);
+    Type2 staticThenType = _getStaticType(node.thenExpression);
+    Type2 staticElseType = _getStaticType(node.elseExpression);
     if (staticThenType == null) {
       // TODO(brianwilkerson) Determine whether this can still happen.
       staticThenType = _dynamicType;
     }
     if (staticElseType == null) {
       // TODO(brianwilkerson) Determine whether this can still happen.
       staticElseType = _dynamicType;
     }
     Type2 staticType = staticThenType.getLeastUpperBound(staticElseType);
     if (staticType == null) {
       staticType = _dynamicType;
     }
-    recordStaticType(node, staticType);
+    _recordStaticType(node, staticType);
     Type2 propagatedThenType = node.thenExpression.propagatedType;
     Type2 propagatedElseType = node.elseExpression.propagatedType;
     if (propagatedThenType != null || propagatedElseType != null) {
       if (propagatedThenType == null) {
         propagatedThenType = staticThenType;
       }
       if (propagatedElseType == null) {
         propagatedElseType = staticElseType;
       }
       Type2 propagatedType = propagatedThenType.getLeastUpperBound(propagatedElseType);
       if (propagatedType != null && propagatedType.isMoreSpecificThan(staticType)) {
-        recordPropagatedType(node, propagatedType);
+        _recordPropagatedType(node, propagatedType);
       }
     }
     return null;
   }
 
   /**
    * The Dart Language Specification, 12.3: <blockquote>The static type of a literal double is
    * double.</blockquote>
    */
   Object visitDoubleLiteral(DoubleLiteral node) {
-    recordStaticType(node, _typeProvider.doubleType);
+    _recordStaticType(node, _typeProvider.doubleType);
     return null;
   }
 
   Object visitFunctionDeclaration(FunctionDeclaration node) {
     FunctionExpression function = node.functionExpression;
     ExecutableElementImpl functionElement = node.element as ExecutableElementImpl;
-    functionElement.returnType = computeStaticReturnTypeOfFunctionDeclaration(node);
-    recordPropagatedTypeOfFunction(functionElement, function.body);
-    recordStaticType(function, functionElement.type);
+    functionElement.returnType = _computeStaticReturnTypeOfFunctionDeclaration(node);
+    _recordPropagatedTypeOfFunction(functionElement, function.body);
+    _recordStaticType(function, functionElement.type);
     return null;
   }
 
   /**
    * The Dart Language Specification, 12.9: <blockquote>The static type of a function literal of the
    * form <i>(T<sub>1</sub> a<sub>1</sub>, &hellip;, T<sub>n</sub> a<sub>n</sub>, [T<sub>n+1</sub>
    * x<sub>n+1</sub> = d1, &hellip;, T<sub>n+k</sub> x<sub>n+k</sub> = dk]) => e</i> is
    * <i>(T<sub>1</sub>, &hellip;, Tn, [T<sub>n+1</sub> x<sub>n+1</sub>, &hellip;, T<sub>n+k</sub>
    * x<sub>n+k</sub>]) &rarr; T<sub>0</sub></i>, where <i>T<sub>0</sub></i> is the static type of
    * <i>e</i>. In any case where <i>T<sub>i</sub>, 1 &lt;= i &lt;= n</i>, is not specified, it is
@@ skipping 19 matching lines @@
    * x<sub>n+1</sub>, &hellip;, T<sub>n+k</sub> x<sub>n+k</sub>}) &rarr; dynamic</i>. In any case
    * where <i>T<sub>i</sub>, 1 &lt;= i &lt;= n</i>, is not specified, it is considered to have been
    * specified as dynamic.</blockquote>
    */
   Object visitFunctionExpression(FunctionExpression node) {
     if (node.parent is FunctionDeclaration) {
       // The function type will be resolved and set when we visit the parent node.
       return null;
     }
     ExecutableElementImpl functionElement = node.element as ExecutableElementImpl;
-    functionElement.returnType = computeStaticReturnTypeOfFunctionExpression(node);
-    recordPropagatedTypeOfFunction(functionElement, node.body);
-    recordStaticType(node, node.element.type);
+    functionElement.returnType = _computeStaticReturnTypeOfFunctionExpression(node);
+    _recordPropagatedTypeOfFunction(functionElement, node.body);
+    _recordStaticType(node, node.element.type);
     return null;
   }
 
   /**
    * The Dart Language Specification, 12.14.4: <blockquote>A function expression invocation <i>i</i>
    * has the form <i>e<sub>f</sub>(a<sub>1</sub>, &hellip;, a<sub>n</sub>, x<sub>n+1</sub>:
    * a<sub>n+1</sub>, &hellip;, x<sub>n+k</sub>: a<sub>n+k</sub>)</i>, where <i>e<sub>f</sub></i> is
    * an expression.
    *
    * It is a static type warning if the static type <i>F</i> of <i>e<sub>f</sub></i> may not be
    * assigned to a function type.
    *
    * If <i>F</i> is not a function type, the static type of <i>i</i> is dynamic. Otherwise the
    * static type of <i>i</i> is the declared return type of <i>F</i>.</blockquote>
    */
   Object visitFunctionExpressionInvocation(FunctionExpressionInvocation node) {
     ExecutableElement staticMethodElement = node.staticElement;
     // Record static return type of the static element.
-    Type2 staticStaticType = computeStaticReturnType(staticMethodElement);
-    recordStaticType(node, staticStaticType);
+    Type2 staticStaticType = _computeStaticReturnType(staticMethodElement);
+    _recordStaticType(node, staticStaticType);
     // Record propagated return type of the static element.
-    Type2 staticPropagatedType = computePropagatedReturnType(staticMethodElement);
+    Type2 staticPropagatedType = _computePropagatedReturnType(staticMethodElement);
     if (staticPropagatedType != null && (staticStaticType == null || staticPropagatedType.isMoreSpecificThan(staticStaticType))) {
-      recordPropagatedType(node, staticPropagatedType);
+      _recordPropagatedType(node, staticPropagatedType);
     }
     ExecutableElement propagatedMethodElement = node.propagatedElement;
     if (propagatedMethodElement != staticMethodElement) {
       // Record static return type of the propagated element.
-      Type2 propagatedStaticType = computeStaticReturnType(propagatedMethodElement);
+      Type2 propagatedStaticType = _computeStaticReturnType(propagatedMethodElement);
       if (propagatedStaticType != null && (staticStaticType == null || propagatedStaticType.isMoreSpecificThan(staticStaticType)) && (staticPropagatedType == null || propagatedStaticType.isMoreSpecificThan(staticPropagatedType))) {
-        recordPropagatedType(node, propagatedStaticType);
+        _recordPropagatedType(node, propagatedStaticType);
       }
       // Record propagated return type of the propagated element.
-      Type2 propagatedPropagatedType = computePropagatedReturnType(propagatedMethodElement);
+      Type2 propagatedPropagatedType = _computePropagatedReturnType(propagatedMethodElement);
       if (propagatedPropagatedType != null && (staticStaticType == null || propagatedPropagatedType.isMoreSpecificThan(staticStaticType)) && (staticPropagatedType == null || propagatedPropagatedType.isMoreSpecificThan(staticPropagatedType)) && (propagatedStaticType == null || propagatedPropagatedType.isMoreSpecificThan(propagatedStaticType))) {
-        recordPropagatedType(node, propagatedPropagatedType);
+        _recordPropagatedType(node, propagatedPropagatedType);
       }
     }
     return null;
   }
 
   /**
    * The Dart Language Specification, 12.29: <blockquote>An assignable expression of the form
    * <i>e<sub>1</sub>[e<sub>2</sub>]</i> is evaluated as a method invocation of the operator method
    * <i>[]</i> on <i>e<sub>1</sub></i> with argument <i>e<sub>2</sub></i>.</blockquote>
    */
   Object visitIndexExpression(IndexExpression node) {
     if (node.inSetterContext()) {
       ExecutableElement staticMethodElement = node.staticElement;
-      Type2 staticType = computeArgumentType(staticMethodElement);
-      recordStaticType(node, staticType);
+      Type2 staticType = _computeArgumentType(staticMethodElement);
+      _recordStaticType(node, staticType);
       MethodElement propagatedMethodElement = node.propagatedElement;
       if (propagatedMethodElement != staticMethodElement) {
-        Type2 propagatedType = computeArgumentType(propagatedMethodElement);
+        Type2 propagatedType = _computeArgumentType(propagatedMethodElement);
         if (propagatedType != null && propagatedType.isMoreSpecificThan(staticType)) {
-          recordPropagatedType(node, propagatedType);
+          _recordPropagatedType(node, propagatedType);
         }
       }
     } else {
       ExecutableElement staticMethodElement = node.staticElement;
-      Type2 staticType = computeStaticReturnType(staticMethodElement);
-      recordStaticType(node, staticType);
+      Type2 staticType = _computeStaticReturnType(staticMethodElement);
+      _recordStaticType(node, staticType);
       MethodElement propagatedMethodElement = node.propagatedElement;
       if (propagatedMethodElement != staticMethodElement) {
-        Type2 propagatedType = computeStaticReturnType(propagatedMethodElement);
+        Type2 propagatedType = _computeStaticReturnType(propagatedMethodElement);
         if (propagatedType != null && propagatedType.isMoreSpecificThan(staticType)) {
-          recordPropagatedType(node, propagatedType);
+          _recordPropagatedType(node, propagatedType);
         }
       }
     }
     return null;
   }
 
   /**
    * The Dart Language Specification, 12.11.1: <blockquote>The static type of a new expression of
    * either the form <i>new T.id(a<sub>1</sub>, &hellip;, a<sub>n</sub>)</i> or the form <i>new
    * T(a<sub>1</sub>, &hellip;, a<sub>n</sub>)</i> is <i>T</i>.</blockquote>
    *
    * The Dart Language Specification, 12.11.2: <blockquote>The static type of a constant object
    * expression of either the form <i>const T.id(a<sub>1</sub>, &hellip;, a<sub>n</sub>)</i> or the
    * form <i>const T(a<sub>1</sub>, &hellip;, a<sub>n</sub>)</i> is <i>T</i>. </blockquote>
    */
   Object visitInstanceCreationExpression(InstanceCreationExpression node) {
-    recordStaticType(node, node.constructorName.type.type);
+    _recordStaticType(node, node.constructorName.type.type);
     ConstructorElement element = node.staticElement;
     if (element != null && "Element" == element.enclosingElement.name) {
       LibraryElement library = element.library;
-      if (isHtmlLibrary(library)) {
+      if (_isHtmlLibrary(library)) {
         String constructorName = element.name;
         if ("tag" == constructorName) {
-          Type2 returnType = getFirstArgumentAsTypeWithMap(library, node.argumentList, _HTML_ELEMENT_TO_CLASS_MAP);
+          Type2 returnType = _getFirstArgumentAsTypeWithMap(library, node.argumentList, _HTML_ELEMENT_TO_CLASS_MAP);
           if (returnType != null) {
-            recordPropagatedType(node, returnType);
+            _recordPropagatedType(node, returnType);
           }
         } else {
-          Type2 returnType = getElementNameAsType(library, constructorName, _HTML_ELEMENT_TO_CLASS_MAP);
+          Type2 returnType = _getElementNameAsType(library, constructorName, _HTML_ELEMENT_TO_CLASS_MAP);
           if (returnType != null) {
-            recordPropagatedType(node, returnType);
+            _recordPropagatedType(node, returnType);
           }
         }
       }
     }
     return null;
   }
 
   /**
    * The Dart Language Specification, 12.3: <blockquote>The static type of an integer literal is
    * `int`.</blockquote>
    */
   Object visitIntegerLiteral(IntegerLiteral node) {
-    recordStaticType(node, _typeProvider.intType);
+    _recordStaticType(node, _typeProvider.intType);
     return null;
   }
 
   /**
    * The Dart Language Specification, 12.31: <blockquote>It is a static warning if <i>T</i> does not
    * denote a type available in the current lexical scope.
    *
    * The static type of an is-expression is `bool`.</blockquote>
    */
   Object visitIsExpression(IsExpression node) {
-    recordStaticType(node, _typeProvider.boolType);
+    _recordStaticType(node, _typeProvider.boolType);
     return null;
   }
 
   /**
    * The Dart Language Specification, 12.6: <blockquote>The static type of a list literal of the
    * form <i><b>const</b> &lt;E&gt;[e<sub>1</sub>, &hellip;, e<sub>n</sub>]</i> or the form
    * <i>&lt;E&gt;[e<sub>1</sub>, &hellip;, e<sub>n</sub>]</i> is `List&lt;E&gt;`. The static
    * type a list literal of the form <i><b>const</b> [e<sub>1</sub>, &hellip;, e<sub>n</sub>]</i> or
    * the form <i>[e<sub>1</sub>, &hellip;, e<sub>n</sub>]</i> is `List&lt;dynamic&gt;`
    * .</blockquote>
    */
   Object visitListLiteral(ListLiteral node) {
     Type2 staticType = _dynamicType;
     TypeArgumentList typeArguments = node.typeArguments;
     if (typeArguments != null) {
       NodeList<TypeName> arguments = typeArguments.arguments;
       if (arguments != null && arguments.length == 1) {
         TypeName argumentTypeName = arguments[0];
-        Type2 argumentType = getType(argumentTypeName);
+        Type2 argumentType = _getType(argumentTypeName);
         if (argumentType != null) {
           staticType = argumentType;
         }
       }
     }
-    recordStaticType(node, _typeProvider.listType.substitute4(<Type2> [staticType]));
+    _recordStaticType(node, _typeProvider.listType.substitute4(<Type2> [staticType]));
     NodeList<Expression> elements = node.elements;
     int count = elements.length;
     if (count > 0) {
       Type2 propagatedType = elements[0].bestType;
       for (int i = 1; i < count; i++) {
         Type2 elementType = elements[i].bestType;
         if (propagatedType != elementType) {
           propagatedType = _dynamicType;
         } else {
           propagatedType = propagatedType.getLeastUpperBound(elementType);
           if (propagatedType == null) {
             propagatedType = _dynamicType;
           }
         }
       }
       if (propagatedType.isMoreSpecificThan(staticType)) {
-        recordPropagatedType(node, _typeProvider.listType.substitute4(<Type2> [propagatedType]));
+        _recordPropagatedType(node, _typeProvider.listType.substitute4(<Type2> [propagatedType]));
       }
     }
     return null;
   }
 
   /**
    * The Dart Language Specification, 12.7: <blockquote>The static type of a map literal of the form
    * <i><b>const</b> &lt;String, V&gt; {k<sub>1</sub>:e<sub>1</sub>, &hellip;,
    * k<sub>n</sub>:e<sub>n</sub>}</i> or the form <i>&lt;String, V&gt; {k<sub>1</sub>:e<sub>1</sub>,
    * &hellip;, k<sub>n</sub>:e<sub>n</sub>}</i> is `Map&lt;String, V&gt;`. The static type a
    * map literal of the form <i><b>const</b> {k<sub>1</sub>:e<sub>1</sub>, &hellip;,
    * k<sub>n</sub>:e<sub>n</sub>}</i> or the form <i>{k<sub>1</sub>:e<sub>1</sub>, &hellip;,
    * k<sub>n</sub>:e<sub>n</sub>}</i> is `Map&lt;String, dynamic&gt;`.
    *
    * It is a compile-time error if the first type argument to a map literal is not
    * <i>String</i>.</blockquote>
    */
   Object visitMapLiteral(MapLiteral node) {
     Type2 staticKeyType = _dynamicType;
     Type2 staticValueType = _dynamicType;
     TypeArgumentList typeArguments = node.typeArguments;
     if (typeArguments != null) {
       NodeList<TypeName> arguments = typeArguments.arguments;
       if (arguments != null && arguments.length == 2) {
         TypeName entryKeyTypeName = arguments[0];
-        Type2 entryKeyType = getType(entryKeyTypeName);
+        Type2 entryKeyType = _getType(entryKeyTypeName);
         if (entryKeyType != null) {
           staticKeyType = entryKeyType;
         }
         TypeName entryValueTypeName = arguments[1];
-        Type2 entryValueType = getType(entryValueTypeName);
+        Type2 entryValueType = _getType(entryValueTypeName);
         if (entryValueType != null) {
           staticValueType = entryValueType;
         }
       }
     }
-    recordStaticType(node, _typeProvider.mapType.substitute4(<Type2> [staticKeyType, staticValueType]));
+    _recordStaticType(node, _typeProvider.mapType.substitute4(<Type2> [staticKeyType, staticValueType]));
     NodeList<MapLiteralEntry> entries = node.entries;
     int count = entries.length;
     if (count > 0) {
       MapLiteralEntry entry = entries[0];
       Type2 propagatedKeyType = entry.key.bestType;
       Type2 propagatedValueType = entry.value.bestType;
       for (int i = 1; i < count; i++) {
         entry = entries[i];
         Type2 elementKeyType = entry.key.bestType;
         if (propagatedKeyType != elementKeyType) {
@@ skipping 16 matching lines @@
       }
       bool betterKey = propagatedKeyType != null && propagatedKeyType.isMoreSpecificThan(staticKeyType);
       bool betterValue = propagatedValueType != null && propagatedValueType.isMoreSpecificThan(staticValueType);
       if (betterKey || betterValue) {
         if (!betterKey) {
           propagatedKeyType = staticKeyType;
         }
         if (!betterValue) {
           propagatedValueType = staticValueType;
         }
-        recordPropagatedType(node, _typeProvider.mapType.substitute4(<Type2> [propagatedKeyType, propagatedValueType]));
+        _recordPropagatedType(node, _typeProvider.mapType.substitute4(<Type2> [propagatedKeyType, propagatedValueType]));
       }
     }
     return null;
   }
 
   /**
    * The Dart Language Specification, 12.15.1: <blockquote>An ordinary method invocation <i>i</i>
    * has the form <i>o.m(a<sub>1</sub>, &hellip;, a<sub>n</sub>, x<sub>n+1</sub>: a<sub>n+1</sub>,
    * &hellip;, x<sub>n+k</sub>: a<sub>n+k</sub>)</i>.
    *
@@ skipping 28 matching lines @@
    * <i>i</i> is dynamic. Otherwise the static type of <i>i</i> is the declared return type of
    * <i>F</i>.</blockquote>
    */
   Object visitMethodInvocation(MethodInvocation node) {
     SimpleIdentifier methodNameNode = node.methodName;
     Element staticMethodElement = methodNameNode.staticElement;
     // Record types of the local variable invoked as a function.
     if (staticMethodElement is LocalVariableElement) {
       LocalVariableElement variable = staticMethodElement;
       Type2 staticType = variable.type;
-      recordStaticType(methodNameNode, staticType);
+      _recordStaticType(methodNameNode, staticType);
       Type2 propagatedType = _overrideManager.getType(variable);
       if (propagatedType != null && propagatedType.isMoreSpecificThan(staticType)) {
-        recordPropagatedType(methodNameNode, propagatedType);
+        _recordPropagatedType(methodNameNode, propagatedType);
       }
     }
     // Record static return type of the static element.
-    Type2 staticStaticType = computeStaticReturnType(staticMethodElement);
-    recordStaticType(node, staticStaticType);
+    Type2 staticStaticType = _computeStaticReturnType(staticMethodElement);
+    _recordStaticType(node, staticStaticType);
     // Record propagated return type of the static element.
-    Type2 staticPropagatedType = computePropagatedReturnType(staticMethodElement);
+    Type2 staticPropagatedType = _computePropagatedReturnType(staticMethodElement);
     if (staticPropagatedType != null && (staticStaticType == null || staticPropagatedType.isMoreSpecificThan(staticStaticType))) {
-      recordPropagatedType(node, staticPropagatedType);
+      _recordPropagatedType(node, staticPropagatedType);
     }
     String methodName = methodNameNode.name;
     // Future.then(closure) return type is:
     // 1) the returned Future type, if the closure returns a Future;
     // 2) Future<valueType>, if the closure returns a value.
     if (methodName == "then") {
       Expression target = node.realTarget;
       Type2 targetType = target == null ? null : target.bestType;
-      if (isAsyncFutureType(targetType)) {
+      if (_isAsyncFutureType(targetType)) {
         NodeList<Expression> arguments = node.argumentList.arguments;
         if (arguments.length == 1) {
           // TODO(brianwilkerson) Handle the case where both arguments are provided.
           Expression closureArg = arguments[0];
           if (closureArg is FunctionExpression) {
             FunctionExpression closureExpr = closureArg;
-            Type2 returnType = computePropagatedReturnType(closureExpr.element);
+            Type2 returnType = _computePropagatedReturnType(closureExpr.element);
             if (returnType != null) {
               // prepare the type of the returned Future
               InterfaceTypeImpl newFutureType;
-              if (isAsyncFutureType(returnType)) {
+              if (_isAsyncFutureType(returnType)) {
                 newFutureType = returnType as InterfaceTypeImpl;
               } else {
                 InterfaceType futureType = targetType as InterfaceType;
                 newFutureType = new InterfaceTypeImpl.con1(futureType.element);
                 newFutureType.typeArguments = <Type2> [returnType];
               }
               // set the 'then' invocation type
-              recordPropagatedType(node, newFutureType);
+              _recordPropagatedType(node, newFutureType);
               return null;
             }
           }
         }
       }
     }
     if (methodName == "\$dom_createEvent") {
       Expression target = node.realTarget;
       if (target != null) {
         Type2 targetType = target.bestType;
         if (targetType is InterfaceType && (targetType.name == "HtmlDocument" || targetType.name == "Document")) {
           LibraryElement library = targetType.element.library;
-          if (isHtmlLibrary(library)) {
-            Type2 returnType = getFirstArgumentAsType(library, node.argumentList);
+          if (_isHtmlLibrary(library)) {
+            Type2 returnType = _getFirstArgumentAsType(library, node.argumentList);
             if (returnType != null) {
-              recordPropagatedType(node, returnType);
+              _recordPropagatedType(node, returnType);
             }
           }
         }
       }
     } else if (methodName == "query") {
       Expression target = node.realTarget;
       if (target == null) {
         Element methodElement = methodNameNode.bestElement;
         if (methodElement != null) {
           LibraryElement library = methodElement.library;
-          if (isHtmlLibrary(library)) {
-            Type2 returnType = getFirstArgumentAsQuery(library, node.argumentList);
+          if (_isHtmlLibrary(library)) {
+            Type2 returnType = _getFirstArgumentAsQuery(library, node.argumentList);
             if (returnType != null) {
-              recordPropagatedType(node, returnType);
+              _recordPropagatedType(node, returnType);
             }
           }
         }
       } else {
         Type2 targetType = target.bestType;
         if (targetType is InterfaceType && (targetType.name == "HtmlDocument" || targetType.name == "Document")) {
           LibraryElement library = targetType.element.library;
-          if (isHtmlLibrary(library)) {
-            Type2 returnType = getFirstArgumentAsQuery(library, node.argumentList);
+          if (_isHtmlLibrary(library)) {
+            Type2 returnType = _getFirstArgumentAsQuery(library, node.argumentList);
             if (returnType != null) {
-              recordPropagatedType(node, returnType);
+              _recordPropagatedType(node, returnType);
             }
           }
         }
       }
     } else if (methodName == "\$dom_createElement") {
       Expression target = node.realTarget;
       Type2 targetType = target.bestType;
       if (targetType is InterfaceType && (targetType.name == "HtmlDocument" || targetType.name == "Document")) {
         LibraryElement library = targetType.element.library;
-        if (isHtmlLibrary(library)) {
-          Type2 returnType = getFirstArgumentAsQuery(library, node.argumentList);
+        if (_isHtmlLibrary(library)) {
+          Type2 returnType = _getFirstArgumentAsQuery(library, node.argumentList);
           if (returnType != null) {
-            recordPropagatedType(node, returnType);
+            _recordPropagatedType(node, returnType);
           }
         }
       }
     } else if (methodName == "JS") {
-      Type2 returnType = getFirstArgumentAsType(_typeProvider.objectType.element.library, node.argumentList);
+      Type2 returnType = _getFirstArgumentAsType(_typeProvider.objectType.element.library, node.argumentList);
       if (returnType != null) {
-        recordPropagatedType(node, returnType);
+        _recordPropagatedType(node, returnType);
       }
     } else {
       Element propagatedElement = methodNameNode.propagatedElement;
       if (propagatedElement != staticMethodElement) {
         // Record static return type of the propagated element.
-        Type2 propagatedStaticType = computeStaticReturnType(propagatedElement);
+        Type2 propagatedStaticType = _computeStaticReturnType(propagatedElement);
         if (propagatedStaticType != null && (staticStaticType == null || propagatedStaticType.isMoreSpecificThan(staticStaticType)) && (staticPropagatedType == null || propagatedStaticType.isMoreSpecificThan(staticPropagatedType))) {
-          recordPropagatedType(node, propagatedStaticType);
+          _recordPropagatedType(node, propagatedStaticType);
         }
         // Record propagated return type of the propagated element.
-        Type2 propagatedPropagatedType = computePropagatedReturnType(propagatedElement);
+        Type2 propagatedPropagatedType = _computePropagatedReturnType(propagatedElement);
         if (propagatedPropagatedType != null && (staticStaticType == null || propagatedPropagatedType.isMoreSpecificThan(staticStaticType)) && (staticPropagatedType == null || propagatedPropagatedType.isMoreSpecificThan(staticPropagatedType)) && (propagatedStaticType == null || propagatedPropagatedType.isMoreSpecificThan(propagatedStaticType))) {
-          recordPropagatedType(node, propagatedPropagatedType);
+          _recordPropagatedType(node, propagatedPropagatedType);
         }
       }
     }
     return null;
   }
 
   Object visitNamedExpression(NamedExpression node) {
     Expression expression = node.expression;
-    recordStaticType(node, getStaticType(expression));
-    recordPropagatedType(node, expression.propagatedType);
+    _recordStaticType(node, _getStaticType(expression));
+    _recordPropagatedType(node, expression.propagatedType);
     return null;
   }
 
   /**
    * The Dart Language Specification, 12.2: <blockquote>The static type of `null` is bottom.
    * </blockquote>
    */
   Object visitNullLiteral(NullLiteral node) {
-    recordStaticType(node, _typeProvider.bottomType);
+    _recordStaticType(node, _typeProvider.bottomType);
     return null;
   }
 
   Object visitParenthesizedExpression(ParenthesizedExpression node) {
     Expression expression = node.expression;
-    recordStaticType(node, getStaticType(expression));
-    recordPropagatedType(node, expression.propagatedType);
+    _recordStaticType(node, _getStaticType(expression));
+    _recordPropagatedType(node, expression.propagatedType);
     return null;
   }
 
   /**
    * The Dart Language Specification, 12.28: <blockquote>A postfix expression of the form
    * <i>v++</i>, where <i>v</i> is an identifier, is equivalent to <i>(){var r = v; v = r + 1;
    * return r}()</i>.
    *
    * A postfix expression of the form <i>C.v++</i> is equivalent to <i>(){var r = C.v; C.v = r + 1;
    * return r}()</i>.
@@ skipping 11 matching lines @@
    * return r}()</i>.
    *
    * A postfix expression of the form <i>e1.v--</i> is equivalent to <i>(x){var r = x.v; x.v = r -
    * 1; return r}(e1)</i>.
    *
    * A postfix expression of the form <i>e1[e2]--</i> is equivalent to <i>(a, i){var r = a[i]; a[i]
    * = r - 1; return r}(e1, e2)</i></blockquote>
    */
   Object visitPostfixExpression(PostfixExpression node) {
     Expression operand = node.operand;
-    Type2 staticType = getStaticType(operand);
+    Type2 staticType = _getStaticType(operand);
     sc.TokenType operator = node.operator.type;
     if (identical(operator, sc.TokenType.MINUS_MINUS) || identical(operator, sc.TokenType.PLUS_PLUS)) {
       Type2 intType = _typeProvider.intType;
-      if (identical(getStaticType(node.operand), intType)) {
+      if (identical(_getStaticType(node.operand), intType)) {
         staticType = intType;
       }
     }
-    recordStaticType(node, staticType);
-    recordPropagatedType(node, operand.propagatedType);
+    _recordStaticType(node, staticType);
+    _recordPropagatedType(node, operand.propagatedType);
     return null;
   }
 
   /**
    * See [visitSimpleIdentifier].
    */
   Object visitPrefixedIdentifier(PrefixedIdentifier node) {
     SimpleIdentifier prefixedIdentifier = node.identifier;
     Element staticElement = prefixedIdentifier.staticElement;
     Type2 staticType = _dynamicType;
     if (staticElement is ClassElement) {
-      if (isNotTypeLiteral(node)) {
+      if (_isNotTypeLiteral(node)) {
         staticType = staticElement.type;
       } else {
         staticType = _typeProvider.typeType;
       }
     } else if (staticElement is FunctionTypeAliasElement) {
-      if (isNotTypeLiteral(node)) {
+      if (_isNotTypeLiteral(node)) {
         staticType = staticElement.type;
       } else {
         staticType = _typeProvider.typeType;
       }
     } else if (staticElement is MethodElement) {
       staticType = staticElement.type;
     } else if (staticElement is PropertyAccessorElement) {
-      staticType = getTypeOfProperty(staticElement, node.prefix.staticType);
+      staticType = _getTypeOfProperty(staticElement, node.prefix.staticType);
     } else if (staticElement is ExecutableElement) {
       staticType = staticElement.type;
     } else if (staticElement is TypeParameterElement) {
       staticType = staticElement.type;
     } else if (staticElement is VariableElement) {
       staticType = staticElement.type;
     }
-    recordStaticType(prefixedIdentifier, staticType);
-    recordStaticType(node, staticType);
+    _recordStaticType(prefixedIdentifier, staticType);
+    _recordStaticType(node, staticType);
     Element propagatedElement = prefixedIdentifier.propagatedElement;
     Type2 propagatedType = null;
     if (propagatedElement is ClassElement) {
-      if (isNotTypeLiteral(node)) {
+      if (_isNotTypeLiteral(node)) {
         propagatedType = propagatedElement.type;
       } else {
         propagatedType = _typeProvider.typeType;
       }
     } else if (propagatedElement is FunctionTypeAliasElement) {
       propagatedType = propagatedElement.type;
     } else if (propagatedElement is MethodElement) {
       propagatedType = propagatedElement.type;
     } else if (propagatedElement is PropertyAccessorElement) {
-      propagatedType = getTypeOfProperty(propagatedElement, node.prefix.staticType);
+      propagatedType = _getTypeOfProperty(propagatedElement, node.prefix.staticType);
     } else if (propagatedElement is ExecutableElement) {
       propagatedType = propagatedElement.type;
     } else if (propagatedElement is TypeParameterElement) {
       propagatedType = propagatedElement.type;
     } else if (propagatedElement is VariableElement) {
       propagatedType = propagatedElement.type;
     }
     Type2 overriddenType = _overrideManager.getType(propagatedElement);
     if (propagatedType == null || (overriddenType != null && overriddenType.isMoreSpecificThan(propagatedType))) {
       propagatedType = overriddenType;
     }
     if (propagatedType != null && propagatedType.isMoreSpecificThan(staticType)) {
-      recordPropagatedType(prefixedIdentifier, propagatedType);
-      recordPropagatedType(node, propagatedType);
+      _recordPropagatedType(prefixedIdentifier, propagatedType);
+      _recordPropagatedType(node, propagatedType);
     }
     return null;
   }
 
   /**
    * The Dart Language Specification, 12.27: <blockquote>A unary expression <i>u</i> of the form
    * <i>op e</i> is equivalent to a method invocation <i>expression e.op()</i>. An expression of the
    * form <i>op super</i> is equivalent to the method invocation <i>super.op()<i>.</blockquote>
    */
   Object visitPrefixExpression(PrefixExpression node) {
     sc.TokenType operator = node.operator.type;
     if (identical(operator, sc.TokenType.BANG)) {
-      recordStaticType(node, _typeProvider.boolType);
+      _recordStaticType(node, _typeProvider.boolType);
     } else {
       // The other cases are equivalent to invoking a method.
       ExecutableElement staticMethodElement = node.staticElement;
-      Type2 staticType = computeStaticReturnType(staticMethodElement);
+      Type2 staticType = _computeStaticReturnType(staticMethodElement);
       if (identical(operator, sc.TokenType.MINUS_MINUS) || identical(operator, sc.TokenType.PLUS_PLUS)) {
         Type2 intType = _typeProvider.intType;
-        if (identical(getStaticType(node.operand), intType)) {
+        if (identical(_getStaticType(node.operand), intType)) {
           staticType = intType;
         }
       }
-      recordStaticType(node, staticType);
+      _recordStaticType(node, staticType);
       MethodElement propagatedMethodElement = node.propagatedElement;
       if (propagatedMethodElement != staticMethodElement) {
-        Type2 propagatedType = computeStaticReturnType(propagatedMethodElement);
+        Type2 propagatedType = _computeStaticReturnType(propagatedMethodElement);
         if (propagatedType != null && propagatedType.isMoreSpecificThan(staticType)) {
-          recordPropagatedType(node, propagatedType);
+          _recordPropagatedType(node, propagatedType);
         }
       }
     }
     return null;
   }
 
   /**
    * The Dart Language Specification, 12.13: <blockquote> Property extraction allows for a member of
    * an object to be concisely extracted from the object. If <i>o</i> is an object, and if <i>m</i>
    * is the name of a method member of <i>o</i>, then
@@ skipping 35 matching lines @@
    * The static type of <i>i</i> is the declared return type of <i>m</i>.</blockquote>
    */
   Object visitPropertyAccess(PropertyAccess node) {
     SimpleIdentifier propertyName = node.propertyName;
     Element staticElement = propertyName.staticElement;
     Type2 staticType = _dynamicType;
     if (staticElement is MethodElement) {
       staticType = staticElement.type;
     } else if (staticElement is PropertyAccessorElement) {
       Expression realTarget = node.realTarget;
-      staticType = getTypeOfProperty(staticElement, realTarget != null ? getStaticType(realTarget) : null);
+      staticType = _getTypeOfProperty(staticElement, realTarget != null ? _getStaticType(realTarget) : null);
     } else {
     }
-    recordStaticType(propertyName, staticType);
-    recordStaticType(node, staticType);
+    _recordStaticType(propertyName, staticType);
+    _recordStaticType(node, staticType);
     Element propagatedElement = propertyName.propagatedElement;
     Type2 propagatedType = _overrideManager.getType(propagatedElement);
     if (propagatedElement is MethodElement) {
       propagatedType = propagatedElement.type;
     } else if (propagatedElement is PropertyAccessorElement) {
       Expression realTarget = node.realTarget;
-      propagatedType = getTypeOfProperty(propagatedElement, realTarget != null ? realTarget.bestType : null);
+      propagatedType = _getTypeOfProperty(propagatedElement, realTarget != null ? realTarget.bestType : null);
     } else {
     }
     if (propagatedType != null && propagatedType.isMoreSpecificThan(staticType)) {
-      recordPropagatedType(propertyName, propagatedType);
-      recordPropagatedType(node, propagatedType);
+      _recordPropagatedType(propertyName, propagatedType);
+      _recordPropagatedType(node, propagatedType);
     }
     return null;
   }
 
   /**
    * The Dart Language Specification, 12.9: <blockquote>The static type of a rethrow expression is
    * bottom.</blockquote>
    */
   Object visitRethrowExpression(RethrowExpression node) {
-    recordStaticType(node, _typeProvider.bottomType);
+    _recordStaticType(node, _typeProvider.bottomType);
     return null;
   }
 
   /**
    * The Dart Language Specification, 12.30: <blockquote>Evaluation of an identifier expression
    * <i>e</i> of the form <i>id</i> proceeds as follows:
    *
    * Let <i>d</i> be the innermost declaration in the enclosing lexical scope whose name is
    * <i>id</i>. If no such declaration exists in the lexical scope, let <i>d</i> be the declaration
    * of the inherited member named <i>id</i> if it exists.
@@ skipping 25 matching lines @@
    * * Otherwise, if <i>e</i> occurs inside a top level or static function (be it function,
    * method, getter, or setter) or variable initializer, evaluation of e causes a NoSuchMethodError
    * to be thrown.
    * * Otherwise <i>e</i> is equivalent to the property extraction <i>this.id</i>.
    * </blockquote>
    */
   Object visitSimpleIdentifier(SimpleIdentifier node) {
     Element element = node.staticElement;
     Type2 staticType = _dynamicType;
     if (element is ClassElement) {
-      if (isNotTypeLiteral(node)) {
+      if (_isNotTypeLiteral(node)) {
         staticType = element.type;
       } else {
         staticType = _typeProvider.typeType;
       }
     } else if (element is FunctionTypeAliasElement) {
-      if (isNotTypeLiteral(node)) {
+      if (_isNotTypeLiteral(node)) {
         staticType = element.type;
       } else {
         staticType = _typeProvider.typeType;
       }
     } else if (element is MethodElement) {
       staticType = element.type;
     } else if (element is PropertyAccessorElement) {
-      staticType = getTypeOfProperty(element, null);
+      staticType = _getTypeOfProperty(element, null);
     } else if (element is ExecutableElement) {
       staticType = element.type;
     } else if (element is TypeParameterElement) {
       //      if (isTypeName(node)) {
       staticType = element.type;
     } else if (element is VariableElement) {
       VariableElement variable = element;
       staticType = _promoteManager.getStaticType(variable);
     } else if (element is PrefixElement) {
       return null;
     } else {
       staticType = _dynamicType;
     }
-    recordStaticType(node, staticType);
+    _recordStaticType(node, staticType);
     // TODO(brianwilkerson) I think we want to repeat the logic above using the propagated element
     // to get another candidate for the propagated type.
     Type2 propagatedType = _overrideManager.getType(element);
     if (propagatedType != null && propagatedType.isMoreSpecificThan(staticType)) {
-      recordPropagatedType(node, propagatedType);
+      _recordPropagatedType(node, propagatedType);
     }
     return null;
   }
 
   /**
    * The Dart Language Specification, 12.5: <blockquote>The static type of a string literal is
    * `String`.</blockquote>
    */
   Object visitSimpleStringLiteral(SimpleStringLiteral node) {
-    recordStaticType(node, _typeProvider.stringType);
+    _recordStaticType(node, _typeProvider.stringType);
     return null;
   }
 
   /**
    * The Dart Language Specification, 12.5: <blockquote>The static type of a string literal is
    * `String`.</blockquote>
    */
   Object visitStringInterpolation(StringInterpolation node) {
-    recordStaticType(node, _typeProvider.stringType);
+    _recordStaticType(node, _typeProvider.stringType);
     return null;
   }
 
   Object visitSuperExpression(SuperExpression node) {
     if (_thisType == null) {
       // TODO(brianwilkerson) Report this error if it hasn't already been reported
-      recordStaticType(node, _dynamicType);
+      _recordStaticType(node, _dynamicType);
     } else {
-      recordStaticType(node, _thisType);
+      _recordStaticType(node, _thisType);
     }
     return null;
   }
 
   Object visitSymbolLiteral(SymbolLiteral node) {
-    recordStaticType(node, _typeProvider.symbolType);
+    _recordStaticType(node, _typeProvider.symbolType);
     return null;
   }
 
   /**
    * The Dart Language Specification, 12.10: <blockquote>The static type of `this` is the
    * interface of the immediately enclosing class.</blockquote>
    */
   Object visitThisExpression(ThisExpression node) {
     if (_thisType == null) {
       // TODO(brianwilkerson) Report this error if it hasn't already been reported
-      recordStaticType(node, _dynamicType);
+      _recordStaticType(node, _dynamicType);
     } else {
-      recordStaticType(node, _thisType);
+      _recordStaticType(node, _thisType);
     }
     return null;
   }
 
   /**
    * The Dart Language Specification, 12.8: <blockquote>The static type of a throw expression is
    * bottom.</blockquote>
    */
   Object visitThrowExpression(ThrowExpression node) {
-    recordStaticType(node, _typeProvider.bottomType);
+    _recordStaticType(node, _typeProvider.bottomType);
     return null;
   }
 
   Object visitVariableDeclaration(VariableDeclaration node) {
     Expression initializer = node.initializer;
     if (initializer != null) {
       Type2 rightType = initializer.bestType;
       SimpleIdentifier name = node.name;
-      recordPropagatedType(name, rightType);
+      _recordPropagatedType(name, rightType);
       VariableElement element = name.staticElement as VariableElement;
       if (element != null) {
         _resolver.overrideVariable(element, rightType);
       }
     }
     return null;
   }
 
   /**
    * Record that the static type of the given node is the type of the second argument to the method
    * represented by the given element.
    *
    * @param element the element representing the method invoked by the given node
    */
-  Type2 computeArgumentType(ExecutableElement element) {
+  Type2 _computeArgumentType(ExecutableElement element) {
     if (element != null) {
       List<ParameterElement> parameters = element.parameters;
       if (parameters != null && parameters.length == 2) {
         return parameters[1].type;
       }
     }
     return _dynamicType;
   }
 
   /**
    * Compute the propagated return type of the method or function represented by the given element.
    *
    * @param element the element representing the method or function invoked by the given node
    * @return the propagated return type that was computed
    */
-  Type2 computePropagatedReturnType(Element element) {
+  Type2 _computePropagatedReturnType(Element element) {
     if (element is ExecutableElement) {
       return _propagatedReturnTypes[element];
     }
     return null;
   }
 
   /**
    * Given a function body, compute the propagated return type of the function. The propagated
    * return type of functions with a block body is the least upper bound of all
    * [ReturnStatement] expressions, with an expression body it is the type of the expression.
    *
    * @param body the boy of the function whose propagated return type is to be computed
    * @return the propagated return type that was computed
    */
-  Type2 computePropagatedReturnTypeOfFunction(FunctionBody body) {
+  Type2 _computePropagatedReturnTypeOfFunction(FunctionBody body) {
     if (body is ExpressionFunctionBody) {
       ExpressionFunctionBody expressionBody = body;
       return expressionBody.expression.bestType;
     }
     if (body is BlockFunctionBody) {
       List<Type2> result = [null];
       body.accept(new GeneralizingAstVisitor_StaticTypeAnalyzer_computePropagatedReturnTypeOfFunction(result));
       return result[0];
     }
     return null;
   }
 
   /**
    * Compute the static return type of the method or function represented by the given element.
    *
    * @param element the element representing the method or function invoked by the given node
    * @return the static return type that was computed
    */
-  Type2 computeStaticReturnType(Element element) {
+  Type2 _computeStaticReturnType(Element element) {
     if (element is PropertyAccessorElement) {
       //
       // This is a function invocation expression disguised as something else. We are invoking a
       // getter and then invoking the returned function.
       //
       FunctionType propertyType = element.type;
       if (propertyType != null) {
         Type2 returnType = propertyType.returnType;
         if (returnType.isDartCoreFunction) {
           return _dynamicType;
@@ skipping 29 matching lines @@
   }
 
   /**
    * Given a function declaration, compute the return static type of the function. The return type
    * of functions with a block body is `dynamicType`, with an expression body it is the type
    * of the expression.
    *
    * @param node the function expression whose static return type is to be computed
    * @return the static return type that was computed
    */
-  Type2 computeStaticReturnTypeOfFunctionDeclaration(FunctionDeclaration node) {
+  Type2 _computeStaticReturnTypeOfFunctionDeclaration(FunctionDeclaration node) {
     TypeName returnType = node.returnType;
     if (returnType == null) {
       return _dynamicType;
     }
     return returnType.type;
   }
 
   /**
    * Given a function expression, compute the return type of the function. The return type of
    * functions with a block body is `dynamicType`, with an expression body it is the type of
    * the expression.
    *
    * @param node the function expression whose return type is to be computed
    * @return the return type that was computed
    */
-  Type2 computeStaticReturnTypeOfFunctionExpression(FunctionExpression node) {
+  Type2 _computeStaticReturnTypeOfFunctionExpression(FunctionExpression node) {
     FunctionBody body = node.body;
     if (body is ExpressionFunctionBody) {
-      return getStaticType(body.expression);
+      return _getStaticType(body.expression);
     }
     return _dynamicType;
   }
 
   /**
    * If the given element name can be mapped to the name of a class defined within the given
    * library, return the type specified by the argument.
    *
    * @param library the library in which the specified type would be defined
    * @param elementName the name of the element for which a type is being sought
    * @param nameMap an optional map used to map the element name to a type name
    * @return the type specified by the first argument in the argument list
    */
-  Type2 getElementNameAsType(LibraryElement library, String elementName, Map<String, String> nameMap) {
+  Type2 _getElementNameAsType(LibraryElement library, String elementName, Map<String, String> nameMap) {
     if (elementName != null) {
       if (nameMap != null) {
         elementName = nameMap[elementName.toLowerCase()];
       }
       ClassElement returnType = library.getType(elementName);
       if (returnType != null) {
         return returnType.type;
       }
     }
     return null;
   }
 
   /**
    * If the given argument list contains at least one argument, and if the argument is a simple
    * string literal, then parse that argument as a query string and return the type specified by the
    * argument.
    *
    * @param library the library in which the specified type would be defined
    * @param argumentList the list of arguments from which a type is to be extracted
    * @return the type specified by the first argument in the argument list
    */
-  Type2 getFirstArgumentAsQuery(LibraryElement library, ArgumentList argumentList) {
-    String argumentValue = getFirstArgumentAsString(argumentList);
+  Type2 _getFirstArgumentAsQuery(LibraryElement library, ArgumentList argumentList) {
+    String argumentValue = _getFirstArgumentAsString(argumentList);
     if (argumentValue != null) {
       //
       // If the query has spaces, full parsing is required because it might be:
       //   E[text='warning text']
       //
       if (StringUtilities.indexOf1(argumentValue, 0, 0x20) >= 0) {
         return null;
       }
       //
       // Otherwise, try to extract the tag based on http://www.w3.org/TR/CSS2/selector.html.
@@ skipping 12 matching lines @@
     return null;
   }
 
   /**
    * If the given argument list contains at least one argument, and if the argument is a simple
    * string literal, return the String value of the argument.
    *
    * @param argumentList the list of arguments from which a string value is to be extracted
    * @return the string specified by the first argument in the argument list
    */
-  String getFirstArgumentAsString(ArgumentList argumentList) {
+  String _getFirstArgumentAsString(ArgumentList argumentList) {
     NodeList<Expression> arguments = argumentList.arguments;
     if (arguments.length > 0) {
       Expression argument = arguments[0];
       if (argument is SimpleStringLiteral) {
         return argument.value;
       }
     }
     return null;
   }
 
   /**
    * If the given argument list contains at least one argument, and if the argument is a simple
    * string literal, and if the value of the argument is the name of a class defined within the
    * given library, return the type specified by the argument.
    *
    * @param library the library in which the specified type would be defined
    * @param argumentList the list of arguments from which a type is to be extracted
    * @return the type specified by the first argument in the argument list
    */
-  Type2 getFirstArgumentAsType(LibraryElement library, ArgumentList argumentList) => getFirstArgumentAsTypeWithMap(library, argumentList, null);
+  Type2 _getFirstArgumentAsType(LibraryElement library, ArgumentList argumentList) => _getFirstArgumentAsTypeWithMap(library, argumentList, null);
 
   /**
    * If the given argument list contains at least one argument, and if the argument is a simple
    * string literal, and if the value of the argument is the name of a class defined within the
    * given library, return the type specified by the argument.
    *
    * @param library the library in which the specified type would be defined
    * @param argumentList the list of arguments from which a type is to be extracted
    * @param nameMap an optional map used to map the element name to a type name
    * @return the type specified by the first argument in the argument list
    */
-  Type2 getFirstArgumentAsTypeWithMap(LibraryElement library, ArgumentList argumentList, Map<String, String> nameMap) => getElementNameAsType(library, getFirstArgumentAsString(argumentList), nameMap);
+  Type2 _getFirstArgumentAsTypeWithMap(LibraryElement library, ArgumentList argumentList, Map<String, String> nameMap) => _getElementNameAsType(library, _getFirstArgumentAsString(argumentList), nameMap);
 
   /**
    * Return the static type of the given expression.
    *
    * @param expression the expression whose type is to be returned
    * @return the static type of the given expression
    */
-  Type2 getStaticType(Expression expression) {
+  Type2 _getStaticType(Expression expression) {
     Type2 type = expression.staticType;
     if (type == null) {
       // TODO(brianwilkerson) Determine the conditions for which the static type is null.
       return _dynamicType;
     }
     return type;
   }
 
   /**
    * Return the type represented by the given type name.
    *
    * @param typeName the type name representing the type to be returned
    * @return the type represented by the type name
    */
-  Type2 getType(TypeName typeName) {
+  Type2 _getType(TypeName typeName) {
     Type2 type = typeName.type;
     if (type == null) {
       //TODO(brianwilkerson) Determine the conditions for which the type is null.
       return _dynamicType;
     }
     return type;
   }
 
   /**
    * Return the type that should be recorded for a node that resolved to the given accessor.
    *
    * @param accessor the accessor that the node resolved to
    * @param context if the accessor element has context [by being the RHS of a
    *          [PrefixedIdentifier] or [PropertyAccess]], and the return type of the
    *          accessor is a parameter type, then the type of the LHS can be used to get more
    *          specific type information
    * @return the type that should be recorded for a node that resolved to the given accessor
    */
-  Type2 getTypeOfProperty(PropertyAccessorElement accessor, Type2 context) {
+  Type2 _getTypeOfProperty(PropertyAccessorElement accessor, Type2 context) {
     FunctionType functionType = accessor.type;
     if (functionType == null) {
       // TODO(brianwilkerson) Report this internal error. This happens when we are analyzing a
       // reference to a property before we have analyzed the declaration of the property or when
       // the property does not have a defined type.
       return _dynamicType;
     }
     if (accessor.isSetter) {
       List<Type2> parameterTypes = functionType.normalParameterTypes;
       if (parameterTypes != null && parameterTypes.length > 0) {
@@ skipping 24 matching lines @@
         }
       }
     }
     return returnType;
   }
 
   /**
    * Return `true` if the given [Type] is the `Future` form the 'dart:async'
    * library.
    */
-  bool isAsyncFutureType(Type2 type) => type is InterfaceType && type.name == "Future" && isAsyncLibrary(type.element.library);
+  bool _isAsyncFutureType(Type2 type) => type is InterfaceType && type.name == "Future" && _isAsyncLibrary(type.element.library);
 
   /**
    * Return `true` if the given library is the 'dart:async' library.
    *
    * @param library the library being tested
    * @return `true` if the library is 'dart:async'
    */
-  bool isAsyncLibrary(LibraryElement library) => library.name == "dart.async";
+  bool _isAsyncLibrary(LibraryElement library) => library.name == "dart.async";
 
   /**
    * Return `true` if the given library is the 'dart:html' library.
    *
    * @param library the library being tested
    * @return `true` if the library is 'dart:html'
    */
-  bool isHtmlLibrary(LibraryElement library) => library != null && "dart.dom.html" == library.name;
+  bool _isHtmlLibrary(LibraryElement library) => library != null && "dart.dom.html" == library.name;
 
   /**
    * Return `true` if the given node is not a type literal.
    *
    * @param node the node being tested
    * @return `true` if the given node is not a type literal
    */
-  bool isNotTypeLiteral(Identifier node) {
+  bool _isNotTypeLiteral(Identifier node) {
     AstNode parent = node.parent;
     return parent is TypeName || (parent is PrefixedIdentifier && (parent.parent is TypeName || identical(parent.prefix, node))) || (parent is PropertyAccess && identical(parent.target, node)) || (parent is MethodInvocation && identical(node, parent.target));
   }
 
   /**
    * Record that the propagated type of the given node is the given type.
    *
    * @param expression the node whose type is to be recorded
    * @param type the propagated type of the node
    */
-  void recordPropagatedType(Expression expression, Type2 type) {
+  void _recordPropagatedType(Expression expression, Type2 type) {
     if (type != null && !type.isDynamic) {
       expression.propagatedType = type;
     }
   }
 
   /**
    * Given a function element and its body, compute and record the propagated return type of the
    * function.
    *
    * @param functionElement the function element to record propagated return type for
    * @param body the boy of the function whose propagated return type is to be computed
    * @return the propagated return type that was computed, may be `null` if it is not more
    *         specific than the static return type.
    */
-  void recordPropagatedTypeOfFunction(ExecutableElement functionElement, FunctionBody body) {
-    Type2 propagatedReturnType = computePropagatedReturnTypeOfFunction(body);
+  void _recordPropagatedTypeOfFunction(ExecutableElement functionElement, FunctionBody body) {
+    Type2 propagatedReturnType = _computePropagatedReturnTypeOfFunction(body);
     if (propagatedReturnType == null) {
       return;
     }
     // Ignore 'bottom' type.
     if (propagatedReturnType.isBottom) {
       return;
     }
     // Record only if we inferred more specific type.
     Type2 staticReturnType = functionElement.returnType;
     if (!propagatedReturnType.isMoreSpecificThan(staticReturnType)) {
       return;
     }
     // OK, do record.
     _propagatedReturnTypes[functionElement] = propagatedReturnType;
   }
 
   /**
    * Record that the static type of the given node is the given type.
    *
    * @param expression the node whose type is to be recorded
    * @param type the static type of the node
    */
-  void recordStaticType(Expression expression, Type2 type) {
+  void _recordStaticType(Expression expression, Type2 type) {
     if (type == null) {
       expression.staticType = _dynamicType;
     } else {
       expression.staticType = type;
     }
   }
 
   /**
    * Attempts to make a better guess for the static type of the given binary expression.
    *
    * @param node the binary expression to analyze
    * @param staticType the static type of the expression as resolved
    * @return the better type guess, or the same static type as given
    */
-  Type2 refineBinaryExpressionType(BinaryExpression node, Type2 staticType) {
+  Type2 _refineBinaryExpressionType(BinaryExpression node, Type2 staticType) {
     sc.TokenType operator = node.operator.type;
     // bool
     if (identical(operator, sc.TokenType.AMPERSAND_AMPERSAND) || identical(operator, sc.TokenType.BAR_BAR) || identical(operator, sc.TokenType.EQ_EQ) || identical(operator, sc.TokenType.BANG_EQ)) {
       return _typeProvider.boolType;
     }
     Type2 intType = _typeProvider.intType;
-    if (getStaticType(node.leftOperand) == intType) {
+    if (_getStaticType(node.leftOperand) == intType) {
       // int op double
       if (identical(operator, sc.TokenType.MINUS) || identical(operator, sc.TokenType.PERCENT) || identical(operator, sc.TokenType.PLUS) || identical(operator, sc.TokenType.STAR)) {
         Type2 doubleType = _typeProvider.doubleType;
-        if (getStaticType(node.rightOperand) == doubleType) {
+        if (_getStaticType(node.rightOperand) == doubleType) {
           return doubleType;
         }
       }
       // int op int
       if (identical(operator, sc.TokenType.MINUS) || identical(operator, sc.TokenType.PERCENT) || identical(operator, sc.TokenType.PLUS) || identical(operator, sc.TokenType.STAR) || identical(operator, sc.TokenType.TILDE_SLASH)) {
-        if (getStaticType(node.rightOperand) == intType) {
+        if (_getStaticType(node.rightOperand) == intType) {
           staticType = intType;
         }
       }
     }
     // default
     return staticType;
   }
 
   get thisType_J2DAccessor => _thisType;
 
@@ skipping 43 matching lines @@
    */
   Set<LibraryElement> _visitedLibraries = new Set<LibraryElement>();
 
   /**
    * Given some [ClassElement], return the set of all subtypes, and subtypes of subtypes.
    *
    * @param classElement the class to recursively return the set of subtypes of
    */
   Set<ClassElement> computeAllSubtypes(ClassElement classElement) {
     // Ensure that we have generated the subtype map for the library
-    computeSubtypesInLibrary(classElement.library);
+    _computeSubtypesInLibrary(classElement.library);
     // use the subtypeMap to compute the set of all subtypes and subtype's subtypes
     Set<ClassElement> allSubtypes = new Set<ClassElement>();
-    safelyComputeAllSubtypes(classElement, new Set<ClassElement>(), allSubtypes);
+    _safelyComputeAllSubtypes(classElement, new Set<ClassElement>(), allSubtypes);
     return allSubtypes;
   }
 
   /**
    * Given some [LibraryElement], visit all of the types in the library, the passed library,
    * and any imported libraries, will be in the [visitedLibraries] set.
    *
    * @param libraryElement the library to visit, it it hasn't been visited already
    */
   void ensureLibraryVisited(LibraryElement libraryElement) {
-    computeSubtypesInLibrary(libraryElement);
+    _computeSubtypesInLibrary(libraryElement);
   }
 
   /**
    * Given some [ClassElement], this method adds all of the pairs combinations of itself and
    * all of its supertypes to the [subtypeMap] map.
    *
    * @param classElement the class element
    */
-  void computeSubtypesInClass(ClassElement classElement) {
+  void _computeSubtypesInClass(ClassElement classElement) {
     InterfaceType supertypeType = classElement.supertype;
     if (supertypeType != null) {
       ClassElement supertypeElement = supertypeType.element;
       if (supertypeElement != null) {
-        putInSubtypeMap(supertypeElement, classElement);
+        _putInSubtypeMap(supertypeElement, classElement);
       }
     }
     List<InterfaceType> interfaceTypes = classElement.interfaces;
     for (InterfaceType interfaceType in interfaceTypes) {
       ClassElement interfaceElement = interfaceType.element;
       if (interfaceElement != null) {
-        putInSubtypeMap(interfaceElement, classElement);
+        _putInSubtypeMap(interfaceElement, classElement);
       }
     }
     List<InterfaceType> mixinTypes = classElement.mixins;
     for (InterfaceType mixinType in mixinTypes) {
       ClassElement mixinElement = mixinType.element;
       if (mixinElement != null) {
-        putInSubtypeMap(mixinElement, classElement);
+        _putInSubtypeMap(mixinElement, classElement);
       }
     }
   }
 
   /**
    * Given some [CompilationUnitElement], this method calls
    * [computeAllSubtypes] on all of the [ClassElement]s in the
    * compilation unit.
    *
    * @param unitElement the compilation unit element
    */
-  void computeSubtypesInCompilationUnit(CompilationUnitElement unitElement) {
+  void _computeSubtypesInCompilationUnit(CompilationUnitElement unitElement) {
     List<ClassElement> classElements = unitElement.types;
     for (ClassElement classElement in classElements) {
-      computeSubtypesInClass(classElement);
+      _computeSubtypesInClass(classElement);
     }
   }
 
   /**
    * Given some [LibraryElement], this method calls
    * [computeAllSubtypes] on all of the [ClassElement]s in the
    * compilation unit, and itself for all imported and exported libraries. All visited libraries are
    * added to the [visitedLibraries] set.
    *
    * @param libraryElement the library element
    */
-  void computeSubtypesInLibrary(LibraryElement libraryElement) {
+  void _computeSubtypesInLibrary(LibraryElement libraryElement) {
     if (libraryElement == null || _visitedLibraries.contains(libraryElement)) {
       return;
     }
     _visitedLibraries.add(libraryElement);
-    computeSubtypesInCompilationUnit(libraryElement.definingCompilationUnit);
+    _computeSubtypesInCompilationUnit(libraryElement.definingCompilationUnit);
     List<CompilationUnitElement> parts = libraryElement.parts;
     for (CompilationUnitElement part in parts) {
-      computeSubtypesInCompilationUnit(part);
+      _computeSubtypesInCompilationUnit(part);
     }
     List<LibraryElement> imports = libraryElement.importedLibraries;
     for (LibraryElement importElt in imports) {
-      computeSubtypesInLibrary(importElt.library);
+      _computeSubtypesInLibrary(importElt.library);
     }
     List<LibraryElement> exports = libraryElement.exportedLibraries;
     for (LibraryElement exportElt in exports) {
-      computeSubtypesInLibrary(exportElt.library);
+      _computeSubtypesInLibrary(exportElt.library);
     }
   }
 
   /**
    * Add some key/ value pair into the [subtypeMap] map.
    *
    * @param supertypeElement the key for the [subtypeMap] map
    * @param subtypeElement the value for the [subtypeMap] map
    */
-  void putInSubtypeMap(ClassElement supertypeElement, ClassElement subtypeElement) {
+  void _putInSubtypeMap(ClassElement supertypeElement, ClassElement subtypeElement) {
     Set<ClassElement> subtypes = _subtypeMap[supertypeElement];
     if (subtypes == null) {
       subtypes = new Set<ClassElement>();
       _subtypeMap[supertypeElement] = subtypes;
     }
     subtypes.add(subtypeElement);
   }
 
   /**
    * Given some [ClassElement] and a [HashSet<ClassElement>], this method recursively
    * adds all of the subtypes of the [ClassElement] to the passed array.
    *
    * @param classElement the type to compute the set of subtypes of
    * @param visitedClasses the set of class elements that this method has already recursively seen
    * @param allSubtypes the computed set of subtypes of the passed class element
    */
-  void safelyComputeAllSubtypes(ClassElement classElement, Set<ClassElement> visitedClasses, Set<ClassElement> allSubtypes) {
+  void _safelyComputeAllSubtypes(ClassElement classElement, Set<ClassElement> visitedClasses, Set<ClassElement> allSubtypes) {
     if (!visitedClasses.add(classElement)) {
       // if this class has already been called on this class element
       return;
     }
     Set<ClassElement> subtypes = _subtypeMap[classElement];
     if (subtypes == null) {
       return;
     }
     for (ClassElement subtype in subtypes) {
-      safelyComputeAllSubtypes(subtype, visitedClasses, allSubtypes);
+      _safelyComputeAllSubtypes(subtype, visitedClasses, allSubtypes);
     }
     allSubtypes.addAll(subtypes);
   }
 }
 
 /**
  * Instances of the class `TypeOverrideManager` manage the ability to override the type of an
  * element within a given context.
  */
 class TypeOverrideManager {
@@ skipping 518 matching lines @@
    * The type representing the built-in type 'Type'.
    */
   InterfaceType _typeType;
 
   /**
    * Initialize a newly created type provider to provide the types defined in the given library.
    *
    * @param coreLibrary the element representing the core library (dart:core).
    */
   TypeProviderImpl(LibraryElement coreLibrary) {
-    initializeFrom(coreLibrary);
+    _initializeFrom(coreLibrary);
   }
 
   InterfaceType get boolType => _boolType;
 
   Type2 get bottomType => _bottomType;
 
   InterfaceType get deprecatedType => _deprecatedType;
 
   InterfaceType get doubleType => _doubleType;
 
@@ skipping 22 matching lines @@
   InterfaceType get typeType => _typeType;
 
   /**
    * Return the type with the given name from the given namespace, or `null` if there is no
    * class with the given name.
    *
    * @param namespace the namespace in which to search for the given name
    * @param typeName the name of the type being searched for
    * @return the type that was found
    */
-  InterfaceType getType(Namespace namespace, String typeName) {
+  InterfaceType _getType(Namespace namespace, String typeName) {
     Element element = namespace.get(typeName);
     if (element == null) {
       AnalysisEngine.instance.logger.logInformation("No definition of type ${typeName}");
       return null;
     }
     return (element as ClassElement).type;
   }
 
   /**
    * Initialize the types provided by this type provider from the given library.
    *
    * @param library the library containing the definitions of the core types
    */
-  void initializeFrom(LibraryElement library) {
+  void _initializeFrom(LibraryElement library) {
     Namespace namespace = new NamespaceBuilder().createPublicNamespaceForLibrary(library);
-    _boolType = getType(namespace, "bool");
+    _boolType = _getType(namespace, "bool");
     _bottomType = BottomTypeImpl.instance;
-    _deprecatedType = getType(namespace, "Deprecated");
-    _doubleType = getType(namespace, "double");
+    _deprecatedType = _getType(namespace, "Deprecated");
+    _doubleType = _getType(namespace, "double");
     _dynamicType = DynamicTypeImpl.instance;
-    _functionType = getType(namespace, "Function");
-    _intType = getType(namespace, "int");
-    _listType = getType(namespace, "List");
-    _mapType = getType(namespace, "Map");
-    _nullType = getType(namespace, "Null");
-    _numType = getType(namespace, "num");
-    _objectType = getType(namespace, "Object");
-    _stackTraceType = getType(namespace, "StackTrace");
-    _stringType = getType(namespace, "String");
-    _symbolType = getType(namespace, "Symbol");
-    _typeType = getType(namespace, "Type");
+    _functionType = _getType(namespace, "Function");
+    _intType = _getType(namespace, "int");
+    _listType = _getType(namespace, "List");
+    _mapType = _getType(namespace, "Map");
+    _nullType = _getType(namespace, "Null");
+    _numType = _getType(namespace, "num");
+    _objectType = _getType(namespace, "Object");
+    _stackTraceType = _getType(namespace, "StackTrace");
+    _stringType = _getType(namespace, "String");
+    _symbolType = _getType(namespace, "Symbol");
+    _typeType = _getType(namespace, "Type");
   }
 }
 
 /**
  * Instances of the class `TypeResolverVisitor` are used to resolve the types associated with
  * the elements in the element model. This includes the types of superclasses, mixins, interfaces,
  * fields, methods, parameters, and local variables. As a side-effect, this also finishes building
  * the type hierarchy.
  */
 class TypeResolverVisitor extends ScopedVisitor {
   /**
    * @return `true` if the name of the given [TypeName] is an built-in identifier.
    */
-  static bool isBuiltInIdentifier(TypeName node) {
+  static bool _isBuiltInIdentifier(TypeName node) {
     sc.Token token = node.name.beginToken;
     return identical(token.type, sc.TokenType.KEYWORD);
   }
 
   /**
    * @return `true` if given [TypeName] is used as a type annotation.
    */
-  static bool isTypeAnnotation(TypeName node) {
+  static bool _isTypeAnnotation(TypeName node) {
     AstNode parent = node.parent;
     if (parent is VariableDeclarationList) {
       return identical(parent.type, node);
     }
     if (parent is FieldFormalParameter) {
       return identical(parent.type, node);
     }
     if (parent is SimpleFormalParameter) {
       return identical(parent.type, node);
     }
@@ skipping 53 matching lines @@
     super.visitCatchClause(node);
     SimpleIdentifier exception = node.exceptionParameter;
     if (exception != null) {
       // If an 'on' clause is provided the type of the exception parameter is the type in the 'on'
       // clause. Otherwise, the type of the exception parameter is 'Object'.
       TypeName exceptionTypeName = node.exceptionType;
       Type2 exceptionType;
       if (exceptionTypeName == null) {
         exceptionType = typeProvider.dynamicType;
       } else {
-        exceptionType = getType(exceptionTypeName);
+        exceptionType = _getType(exceptionTypeName);
       }
-      recordType(exception, exceptionType);
+      _recordType(exception, exceptionType);
       Element element = exception.staticElement;
       if (element is VariableElementImpl) {
         element.type = exceptionType;
       } else {
       }
     }
     SimpleIdentifier stackTrace = node.stackTraceParameter;
     if (stackTrace != null) {
-      recordType(stackTrace, typeProvider.stackTraceType);
+      _recordType(stackTrace, typeProvider.stackTraceType);
     }
     return null;
   }
 
   Object visitClassDeclaration(ClassDeclaration node) {
     _hasReferenceToSuper = false;
     super.visitClassDeclaration(node);
-    ClassElementImpl classElement = getClassElement(node.name);
+    ClassElementImpl classElement = _getClassElement(node.name);
     InterfaceType superclassType = null;
     ExtendsClause extendsClause = node.extendsClause;
     if (extendsClause != null) {
       ErrorCode errorCode = (node.withClause == null ? CompileTimeErrorCode.EXTENDS_NON_CLASS : CompileTimeErrorCode.MIXIN_WITH_NON_CLASS_SUPERCLASS);
-      superclassType = resolveType(extendsClause.superclass, errorCode, errorCode);
+      superclassType = _resolveType(extendsClause.superclass, errorCode, errorCode);
       if (superclassType != typeProvider.objectType) {
         classElement.validMixin = false;
       }
     }
     if (classElement != null) {
       if (superclassType == null) {
         InterfaceType objectType = typeProvider.objectType;
         if (classElement.type != objectType) {
           superclassType = objectType;
         }
       }
       classElement.supertype = superclassType;
       classElement.hasReferenceToSuper = _hasReferenceToSuper;
     }
-    resolve(classElement, node.withClause, node.implementsClause);
+    _resolve(classElement, node.withClause, node.implementsClause);
     return null;
   }
 
   Object visitClassTypeAlias(ClassTypeAlias node) {
     super.visitClassTypeAlias(node);
-    ClassElementImpl classElement = getClassElement(node.name);
+    ClassElementImpl classElement = _getClassElement(node.name);
     ErrorCode errorCode = CompileTimeErrorCode.MIXIN_WITH_NON_CLASS_SUPERCLASS;
-    InterfaceType superclassType = resolveType(node.superclass, errorCode, errorCode);
+    InterfaceType superclassType = _resolveType(node.superclass, errorCode, errorCode);
     if (superclassType == null) {
       superclassType = typeProvider.objectType;
     }
     if (classElement != null && superclassType != null) {
       classElement.supertype = superclassType;
       ClassElement superclassElement = superclassType.element;
       if (superclassElement != null) {
         List<ConstructorElement> constructors = superclassElement.constructors;
         int count = constructors.length;
         if (count > 0) {
           List<Type2> parameterTypes = TypeParameterTypeImpl.getTypes(superclassType.typeParameters);
-          List<Type2> argumentTypes = getArgumentTypes(node.superclass.typeArguments, parameterTypes);
+          List<Type2> argumentTypes = _getArgumentTypes(node.superclass.typeArguments, parameterTypes);
           InterfaceType classType = classElement.type;
           List<ConstructorElement> implicitConstructors = new List<ConstructorElement>();
           for (int i = 0; i < count; i++) {
             ConstructorElement explicitConstructor = constructors[i];
             if (!explicitConstructor.isFactory) {
-              implicitConstructors.add(createImplicitContructor(classType, explicitConstructor, parameterTypes, argumentTypes));
+              implicitConstructors.add(_createImplicitContructor(classType, explicitConstructor, parameterTypes, argumentTypes));
             }
           }
           classElement.constructors = new List.from(implicitConstructors);
         }
       }
     }
-    resolve(classElement, node.withClause, node.implementsClause);
+    _resolve(classElement, node.withClause, node.implementsClause);
     return null;
   }
 
   Object visitConstructorDeclaration(ConstructorDeclaration node) {
     super.visitConstructorDeclaration(node);
     ExecutableElementImpl element = node.element as ExecutableElementImpl;
     ClassElement definingClass = element.enclosingElement as ClassElement;
     element.returnType = definingClass.type;
     FunctionTypeImpl type = new FunctionTypeImpl.con1(element);
     type.typeArguments = definingClass.type.typeArguments;
     element.type = type;
     return null;
   }
 
   Object visitDeclaredIdentifier(DeclaredIdentifier node) {
     super.visitDeclaredIdentifier(node);
     Type2 declaredType;
     TypeName typeName = node.type;
     if (typeName == null) {
       declaredType = _dynamicType;
     } else {
-      declaredType = getType(typeName);
+      declaredType = _getType(typeName);
     }
     LocalVariableElementImpl element = node.element as LocalVariableElementImpl;
     element.type = declaredType;
     return null;
   }
 
   Object visitFieldFormalParameter(FieldFormalParameter node) {
     super.visitFieldFormalParameter(node);
     Element element = node.identifier.staticElement;
     if (element is ParameterElementImpl) {
       ParameterElementImpl parameter = element;
       FormalParameterList parameterList = node.parameters;
       if (parameterList == null) {
         Type2 type;
         TypeName typeName = node.type;
         if (typeName == null) {
           type = _dynamicType;
           if (parameter is FieldFormalParameterElement) {
             FieldElement fieldElement = (parameter as FieldFormalParameterElement).field;
             if (fieldElement != null) {
               type = fieldElement.type;
             }
           }
         } else {
-          type = getType(typeName);
+          type = _getType(typeName);
         }
         parameter.type = type;
       } else {
-        setFunctionTypedParameterType(parameter, node.type, node.parameters);
+        _setFunctionTypedParameterType(parameter, node.type, node.parameters);
       }
     } else {
     }
     return null;
   }
 
   Object visitFunctionDeclaration(FunctionDeclaration node) {
     super.visitFunctionDeclaration(node);
     ExecutableElementImpl element = node.element as ExecutableElementImpl;
-    element.returnType = computeReturnType(node.returnType);
+    element.returnType = _computeReturnType(node.returnType);
     FunctionTypeImpl type = new FunctionTypeImpl.con1(element);
     ClassElement definingClass = element.getAncestor((element) => element is ClassElement);
     if (definingClass != null) {
       type.typeArguments = definingClass.type.typeArguments;
     }
     element.type = type;
     return null;
   }
 
   Object visitFunctionTypeAlias(FunctionTypeAlias node) {
     super.visitFunctionTypeAlias(node);
     FunctionTypeAliasElementImpl element = node.element as FunctionTypeAliasElementImpl;
-    element.returnType = computeReturnType(node.returnType);
+    element.returnType = _computeReturnType(node.returnType);
     return null;
   }
 
   Object visitFunctionTypedFormalParameter(FunctionTypedFormalParameter node) {
     super.visitFunctionTypedFormalParameter(node);
     Element element = node.identifier.staticElement;
     if (element is ParameterElementImpl) {
-      setFunctionTypedParameterType(element, node.returnType, node.parameters);
+      _setFunctionTypedParameterType(element, node.returnType, node.parameters);
     } else {
     }
     return null;
   }
 
   Object visitMethodDeclaration(MethodDeclaration node) {
     super.visitMethodDeclaration(node);
     ExecutableElementImpl element = node.element as ExecutableElementImpl;
-    element.returnType = computeReturnType(node.returnType);
+    element.returnType = _computeReturnType(node.returnType);
     FunctionTypeImpl type = new FunctionTypeImpl.con1(element);
     ClassElement definingClass = element.getAncestor((element) => element is ClassElement);
     if (definingClass != null) {
       type.typeArguments = definingClass.type.typeArguments;
     }
     element.type = type;
     if (element is PropertyAccessorElement) {
       PropertyAccessorElement accessor = element as PropertyAccessorElement;
       PropertyInducingElementImpl variable = accessor.variable as PropertyInducingElementImpl;
       if (accessor.isGetter) {
         variable.type = type.returnType;
       } else if (variable.type == null) {
         List<Type2> parameterTypes = type.normalParameterTypes;
         if (parameterTypes != null && parameterTypes.length > 0) {
           variable.type = parameterTypes[0];
         }
       }
     }
     return null;
   }
 
   Object visitSimpleFormalParameter(SimpleFormalParameter node) {
     super.visitSimpleFormalParameter(node);
     Type2 declaredType;
     TypeName typeName = node.type;
     if (typeName == null) {
       declaredType = _dynamicType;
     } else {
-      declaredType = getType(typeName);
+      declaredType = _getType(typeName);
     }
     Element element = node.identifier.staticElement;
     if (element is ParameterElement) {
       (element as ParameterElementImpl).type = declaredType;
     } else {
     }
     return null;
   }
 
   Object visitSuperExpression(SuperExpression node) {
     _hasReferenceToSuper = true;
     return super.visitSuperExpression(node);
   }
 
   Object visitTypeName(TypeName node) {
     super.visitTypeName(node);
     Identifier typeName = node.name;
     TypeArgumentList argumentList = node.typeArguments;
     Element element = nameScope.lookup(typeName, definingLibrary);
     if (element == null) {
       //
       // Check to see whether the type name is either 'dynamic' or 'void', neither of which are in
       // the name scope and hence will not be found by normal means.
       //
-      if (typeName.name == this._dynamicType.name) {
-        setElement(typeName, this._dynamicType.element);
+      if (typeName.name == _dynamicType.name) {
+        _setElement(typeName, _dynamicType.element);
         if (argumentList != null) {
         }
-        typeName.staticType = this._dynamicType;
-        node.type = this._dynamicType;
+        typeName.staticType = _dynamicType;
+        node.type = _dynamicType;
         return null;
       }
       VoidTypeImpl voidType = VoidTypeImpl.instance;
       if (typeName.name == voidType.name) {
         // There is no element for 'void'.
         if (argumentList != null) {
         }
         typeName.staticType = voidType;
         node.type = voidType;
         return null;
@@ skipping 11 matching lines @@
           element = nameScope.lookup(prefix, definingLibrary);
           if (element is PrefixElement) {
             if (parent.parent is InstanceCreationExpression && (parent.parent as InstanceCreationExpression).isConst) {
               // If, if this is a const expression, then generate a
               // CompileTimeErrorCode.CONST_WITH_NON_TYPE error.
               reportErrorForNode(CompileTimeErrorCode.CONST_WITH_NON_TYPE, prefixedIdentifier.identifier, [prefixedIdentifier.identifier.name]);
             } else {
               // Else, if this expression is a new expression, report a NEW_WITH_NON_TYPE warning.
               reportErrorForNode(StaticWarningCode.NEW_WITH_NON_TYPE, prefixedIdentifier.identifier, [prefixedIdentifier.identifier.name]);
             }
-            setElement(prefix, element);
+            _setElement(prefix, element);
             return null;
           } else if (element != null) {
             //
             // Rewrite the constructor name. The parser, when it sees a constructor named "a.b",
             // cannot tell whether "a" is a prefix and "b" is a class name, or whether "a" is a
             // class name and "b" is a constructor name. It arbitrarily chooses the former, but
             // in this case was wrong.
             //
             name.name = prefixedIdentifier.identifier;
             name.period = prefixedIdentifier.period;
             node.name = prefix;
             typeName = prefix;
           }
         }
       }
     }
     // check element
     bool elementValid = element is! MultiplyDefinedElement;
-    if (elementValid && element is! ClassElement && isTypeNameInInstanceCreationExpression(node)) {
-      SimpleIdentifier typeNameSimple = getTypeSimpleIdentifier(typeName);
+    if (elementValid && element is! ClassElement && _isTypeNameInInstanceCreationExpression(node)) {
+      SimpleIdentifier typeNameSimple = _getTypeSimpleIdentifier(typeName);
       InstanceCreationExpression creation = node.parent.parent as InstanceCreationExpression;
       if (creation.isConst) {
         if (element == null) {
           reportErrorForNode(CompileTimeErrorCode.UNDEFINED_CLASS, typeNameSimple, [typeName]);
         } else {
           reportErrorForNode(CompileTimeErrorCode.CONST_WITH_NON_TYPE, typeNameSimple, [typeName]);
         }
         elementValid = false;
       } else {
         if (element != null) {
           reportErrorForNode(StaticWarningCode.NEW_WITH_NON_TYPE, typeNameSimple, [typeName]);
           elementValid = false;
         }
       }
     }
     if (elementValid && element == null) {
       // We couldn't resolve the type name.
       // TODO(jwren) Consider moving the check for CompileTimeErrorCode.BUILT_IN_IDENTIFIER_AS_TYPE
       // from the ErrorVerifier, so that we don't have two errors on a built in identifier being
       // used as a class name. See CompileTimeErrorCodeTest.test_builtInIdentifierAsType().
-      SimpleIdentifier typeNameSimple = getTypeSimpleIdentifier(typeName);
+      SimpleIdentifier typeNameSimple = _getTypeSimpleIdentifier(typeName);
       RedirectingConstructorKind redirectingConstructorKind;
-      if (isBuiltInIdentifier(node) && isTypeAnnotation(node)) {
+      if (_isBuiltInIdentifier(node) && _isTypeAnnotation(node)) {
         reportErrorForNode(CompileTimeErrorCode.BUILT_IN_IDENTIFIER_AS_TYPE, typeName, [typeName.name]);
       } else if (typeNameSimple.name == "boolean") {
         reportErrorForNode(StaticWarningCode.UNDEFINED_CLASS_BOOLEAN, typeNameSimple, []);
-      } else if (isTypeNameInCatchClause(node)) {
+      } else if (_isTypeNameInCatchClause(node)) {
         reportErrorForNode(StaticWarningCode.NON_TYPE_IN_CATCH_CLAUSE, typeName, [typeName.name]);
-      } else if (isTypeNameInAsExpression(node)) {
+      } else if (_isTypeNameInAsExpression(node)) {
         reportErrorForNode(StaticWarningCode.CAST_TO_NON_TYPE, typeName, [typeName.name]);
-      } else if (isTypeNameInIsExpression(node)) {
+      } else if (_isTypeNameInIsExpression(node)) {
         reportErrorForNode(StaticWarningCode.TYPE_TEST_NON_TYPE, typeName, [typeName.name]);
-      } else if ((redirectingConstructorKind = getRedirectingConstructorKind(node)) != null) {
+      } else if ((redirectingConstructorKind = _getRedirectingConstructorKind(node)) != null) {
         ErrorCode errorCode = (identical(redirectingConstructorKind, RedirectingConstructorKind.CONST) ? CompileTimeErrorCode.REDIRECT_TO_NON_CLASS : StaticWarningCode.REDIRECT_TO_NON_CLASS) as ErrorCode;
         reportErrorForNode(errorCode, typeName, [typeName.name]);
-      } else if (isTypeNameInTypeArgumentList(node)) {
+      } else if (_isTypeNameInTypeArgumentList(node)) {
         reportErrorForNode(StaticTypeWarningCode.NON_TYPE_AS_TYPE_ARGUMENT, typeName, [typeName.name]);
       } else {
         reportErrorForNode(StaticWarningCode.UNDEFINED_CLASS, typeName, [typeName.name]);
       }
       elementValid = false;
     }
     if (!elementValid) {
       if (element is MultiplyDefinedElement) {
-        setElement(typeName, element);
+        _setElement(typeName, element);
       } else {
-        setElement(typeName, this._dynamicType.element);
+        _setElement(typeName, _dynamicType.element);
       }
-      typeName.staticType = this._dynamicType;
-      node.type = this._dynamicType;
+      typeName.staticType = _dynamicType;
+      node.type = _dynamicType;
       return null;
     }
     Type2 type = null;
     if (element is ClassElement) {
-      setElement(typeName, element);
+      _setElement(typeName, element);
       type = (element as ClassElement).type;
     } else if (element is FunctionTypeAliasElement) {
-      setElement(typeName, element);
+      _setElement(typeName, element);
       type = (element as FunctionTypeAliasElement).type;
     } else if (element is TypeParameterElement) {
-      setElement(typeName, element);
+      _setElement(typeName, element);
       type = (element as TypeParameterElement).type;
       if (argumentList != null) {
       }
     } else if (element is MultiplyDefinedElement) {
       List<Element> elements = (element as MultiplyDefinedElement).conflictingElements;
-      type = getTypeWhenMultiplyDefined(elements);
+      type = _getTypeWhenMultiplyDefined(elements);
       if (type != null) {
         node.type = type;
       }
     } else {
       // The name does not represent a type.
       RedirectingConstructorKind redirectingConstructorKind;
-      if (isTypeNameInCatchClause(node)) {
+      if (_isTypeNameInCatchClause(node)) {
         reportErrorForNode(StaticWarningCode.NON_TYPE_IN_CATCH_CLAUSE, typeName, [typeName.name]);
-      } else if (isTypeNameInAsExpression(node)) {
+      } else if (_isTypeNameInAsExpression(node)) {
         reportErrorForNode(StaticWarningCode.CAST_TO_NON_TYPE, typeName, [typeName.name]);
-      } else if (isTypeNameInIsExpression(node)) {
+      } else if (_isTypeNameInIsExpression(node)) {
         reportErrorForNode(StaticWarningCode.TYPE_TEST_NON_TYPE, typeName, [typeName.name]);
-      } else if ((redirectingConstructorKind = getRedirectingConstructorKind(node)) != null) {
+      } else if ((redirectingConstructorKind = _getRedirectingConstructorKind(node)) != null) {
         ErrorCode errorCode = (identical(redirectingConstructorKind, RedirectingConstructorKind.CONST) ? CompileTimeErrorCode.REDIRECT_TO_NON_CLASS : StaticWarningCode.REDIRECT_TO_NON_CLASS) as ErrorCode;
         reportErrorForNode(errorCode, typeName, [typeName.name]);
-      } else if (isTypeNameInTypeArgumentList(node)) {
+      } else if (_isTypeNameInTypeArgumentList(node)) {
         reportErrorForNode(StaticTypeWarningCode.NON_TYPE_AS_TYPE_ARGUMENT, typeName, [typeName.name]);
       } else {
         AstNode parent = typeName.parent;
         while (parent is TypeName) {
           parent = parent.parent;
         }
         if (parent is ExtendsClause || parent is ImplementsClause || parent is WithClause || parent is ClassTypeAlias) {
         } else {
           reportErrorForNode(StaticWarningCode.NOT_A_TYPE, typeName, [typeName.name]);
         }
       }
-      setElement(typeName, this._dynamicType.element);
-      typeName.staticType = this._dynamicType;
-      node.type = this._dynamicType;
+      _setElement(typeName, _dynamicType.element);
+      typeName.staticType = _dynamicType;
+      node.type = _dynamicType;
       return null;
     }
     if (argumentList != null) {
       NodeList<TypeName> arguments = argumentList.arguments;
       int argumentCount = arguments.length;
-      List<Type2> parameters = getTypeArguments(type);
+      List<Type2> parameters = _getTypeArguments(type);
       int parameterCount = parameters.length;
       int count = Math.min(argumentCount, parameterCount);
       List<Type2> typeArguments = new List<Type2>();
       for (int i = 0; i < count; i++) {
-        Type2 argumentType = getType(arguments[i]);
+        Type2 argumentType = _getType(arguments[i]);
         if (argumentType != null) {
           typeArguments.add(argumentType);
         }
       }
       if (argumentCount != parameterCount) {
-        reportErrorForNode(getInvalidTypeParametersErrorCode(node), node, [typeName.name, parameterCount, argumentCount]);
+        reportErrorForNode(_getInvalidTypeParametersErrorCode(node), node, [typeName.name, parameterCount, argumentCount]);
       }
       argumentCount = typeArguments.length;
       if (argumentCount < parameterCount) {
         //
         // If there were too many arguments, we already handled it by not adding the values of the
         // extra arguments to the list. If there are too few, we handle it by adding 'dynamic'
         // enough times to make the count equal.
         //
         for (int i = argumentCount; i < parameterCount; i++) {
-          typeArguments.add(this._dynamicType);
+          typeArguments.add(_dynamicType);
         }
       }
       if (type is InterfaceTypeImpl) {
         InterfaceTypeImpl interfaceType = type as InterfaceTypeImpl;
         type = interfaceType.substitute4(new List.from(typeArguments));
       } else if (type is FunctionTypeImpl) {
         FunctionTypeImpl functionType = type as FunctionTypeImpl;
         type = functionType.substitute3(new List.from(typeArguments));
       } else {
       }
     } else {
       //
       // Check for the case where there are no type arguments given for a parameterized type.
       //
-      List<Type2> parameters = getTypeArguments(type);
+      List<Type2> parameters = _getTypeArguments(type);
       int parameterCount = parameters.length;
       if (parameterCount > 0) {
         DynamicTypeImpl dynamicType = DynamicTypeImpl.instance;
         List<Type2> arguments = new List<Type2>(parameterCount);
         for (int i = 0; i < parameterCount; i++) {
           arguments[i] = dynamicType;
         }
         type = type.substitute2(arguments, parameters);
       }
     }
@@ skipping 14 matching lines @@
     return null;
   }
 
   Object visitVariableDeclaration(VariableDeclaration node) {
     super.visitVariableDeclaration(node);
     Type2 declaredType;
     TypeName typeName = (node.parent as VariableDeclarationList).type;
     if (typeName == null) {
       declaredType = _dynamicType;
     } else {
-      declaredType = getType(typeName);
+      declaredType = _getType(typeName);
     }
     Element element = node.name.staticElement;
     if (element is VariableElement) {
       (element as VariableElementImpl).type = declaredType;
       if (element is PropertyInducingElement) {
         PropertyInducingElement variableElement = element;
         PropertyAccessorElementImpl getter = variableElement.getter as PropertyAccessorElementImpl;
         getter.returnType = declaredType;
         FunctionTypeImpl getterType = new FunctionTypeImpl.con1(getter);
         ClassElement definingClass = element.getAncestor((element) => element is ClassElement);
@@ skipping 33 matching lines @@
     }
   }
 
   /**
    * Given a type name representing the return type of a function, compute the return type of the
    * function.
    *
    * @param returnType the type name representing the return type of the function
    * @return the return type that was computed
    */
-  Type2 computeReturnType(TypeName returnType) {
+  Type2 _computeReturnType(TypeName returnType) {
     if (returnType == null) {
       return _dynamicType;
     } else {
       return returnType.type;
     }
   }
 
   /**
    * Create an implicit constructor that is copied from the given constructor, but that is in the
    * given class.
    *
    * @param classType the class in which the implicit constructor is defined
    * @param explicitConstructor the constructor on which the implicit constructor is modeled
    * @param parameterTypes the types to be replaced when creating parameters
    * @param argumentTypes the types with which the parameters are to be replaced
    * @return the implicit constructor that was created
    */
-  ConstructorElement createImplicitContructor(InterfaceType classType, ConstructorElement explicitConstructor, List<Type2> parameterTypes, List<Type2> argumentTypes) {
+  ConstructorElement _createImplicitContructor(InterfaceType classType, ConstructorElement explicitConstructor, List<Type2> parameterTypes, List<Type2> argumentTypes) {
     ConstructorElementImpl implicitConstructor = new ConstructorElementImpl.con2(explicitConstructor.name, -1);
     implicitConstructor.synthetic = true;
     implicitConstructor.redirectedConstructor = explicitConstructor;
     implicitConstructor.const2 = explicitConstructor.isConst;
     implicitConstructor.returnType = classType;
     List<ParameterElement> explicitParameters = explicitConstructor.parameters;
     int count = explicitParameters.length;
     if (count > 0) {
       List<ParameterElement> implicitParameters = new List<ParameterElement>(count);
       for (int i = 0; i < count; i++) {
@@ skipping 15 matching lines @@
   }
 
   /**
    * Return an array of argument types that corresponds to the array of parameter types and that are
    * derived from the given list of type arguments.
    *
    * @param typeArguments the type arguments from which the types will be taken
    * @param parameterTypes the parameter types that must be matched by the type arguments
    * @return the argument types that correspond to the parameter types
    */
-  List<Type2> getArgumentTypes(TypeArgumentList typeArguments, List<Type2> parameterTypes) {
+  List<Type2> _getArgumentTypes(TypeArgumentList typeArguments, List<Type2> parameterTypes) {
     DynamicTypeImpl dynamic = DynamicTypeImpl.instance;
     int parameterCount = parameterTypes.length;
     List<Type2> types = new List<Type2>(parameterCount);
     if (typeArguments == null) {
       for (int i = 0; i < parameterCount; i++) {
         types[i] = dynamic;
       }
     } else {
       NodeList<TypeName> arguments = typeArguments.arguments;
       int argumentCount = Math.min(arguments.length, parameterCount);
       for (int i = 0; i < argumentCount; i++) {
         types[i] = arguments[i].type;
       }
       for (int i = argumentCount; i < parameterCount; i++) {
         types[i] = dynamic;
       }
     }
     return types;
   }
 
   /**
    * Return the class element that represents the class whose name was provided.
    *
    * @param identifier the name from the declaration of a class
    * @return the class element that represents the class
    */
-  ClassElementImpl getClassElement(SimpleIdentifier identifier) {
+  ClassElementImpl _getClassElement(SimpleIdentifier identifier) {
     // TODO(brianwilkerson) Seems like we should be using ClassDeclaration.getElement().
     if (identifier == null) {
       // TODO(brianwilkerson) Report this
       // Internal error: We should never build a class declaration without a name.
       return null;
     }
     Element element = identifier.staticElement;
     if (element is! ClassElementImpl) {
       // TODO(brianwilkerson) Report this
       // Internal error: Failed to create an element for a class declaration.
       return null;
     }
     return element as ClassElementImpl;
   }
 
   /**
    * Return an array containing all of the elements associated with the parameters in the given
    * list.
    *
    * @param parameterList the list of parameters whose elements are to be returned
    * @return the elements associated with the parameters
    */
-  List<ParameterElement> getElements(FormalParameterList parameterList) {
+  List<ParameterElement> _getElements(FormalParameterList parameterList) {
     List<ParameterElement> elements = new List<ParameterElement>();
     for (FormalParameter parameter in parameterList.parameters) {
       ParameterElement element = parameter.identifier.staticElement as ParameterElement;
       // TODO(brianwilkerson) Understand why the element would be null.
       if (element != null) {
         elements.add(element);
       }
     }
     return new List.from(elements);
   }
 
   /**
    * The number of type arguments in the given type name does not match the number of parameters in
    * the corresponding class element. Return the error code that should be used to report this
    * error.
    *
    * @param node the type name with the wrong number of type arguments
    * @return the error code that should be used to report that the wrong number of type arguments
    *         were provided
    */
-  ErrorCode getInvalidTypeParametersErrorCode(TypeName node) {
+  ErrorCode _getInvalidTypeParametersErrorCode(TypeName node) {
     AstNode parent = node.parent;
     if (parent is ConstructorName) {
       parent = parent.parent;
       if (parent is InstanceCreationExpression) {
         if ((parent as InstanceCreationExpression).isConst) {
           return CompileTimeErrorCode.CONST_WITH_INVALID_TYPE_PARAMETERS;
         } else {
           return StaticWarningCode.NEW_WITH_INVALID_TYPE_PARAMETERS;
         }
       }
     }
     return StaticTypeWarningCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS;
   }
 
   /**
    * Checks if the given type name is the target in a redirected constructor.
    *
    * @param typeName the type name to analyze
    * @return some [RedirectingConstructorKind] if the given type name is used as the type in a
    *         redirected constructor, or `null` otherwise
    */
-  RedirectingConstructorKind getRedirectingConstructorKind(TypeName typeName) {
+  RedirectingConstructorKind _getRedirectingConstructorKind(TypeName typeName) {
     AstNode parent = typeName.parent;
     if (parent is ConstructorName) {
       ConstructorName constructorName = parent as ConstructorName;
       parent = constructorName.parent;
       if (parent is ConstructorDeclaration) {
         ConstructorDeclaration constructorDeclaration = parent as ConstructorDeclaration;
         if (identical(constructorDeclaration.redirectedConstructor, constructorName)) {
           if (constructorDeclaration.constKeyword != null) {
             return RedirectingConstructorKind.CONST;
           }
           return RedirectingConstructorKind.NORMAL;
         }
       }
     }
     return null;
   }
 
   /**
    * Return the type represented by the given type name.
    *
    * @param typeName the type name representing the type to be returned
    * @return the type represented by the type name
    */
-  Type2 getType(TypeName typeName) {
+  Type2 _getType(TypeName typeName) {
     Type2 type = typeName.type;
     if (type == null) {
       return _dynamicType;
     }
     return type;
   }
 
   /**
    * Return the type arguments associated with the given type.
    *
    * @param type the type whole type arguments are to be returned
    * @return the type arguments associated with the given type
    */
-  List<Type2> getTypeArguments(Type2 type) {
+  List<Type2> _getTypeArguments(Type2 type) {
     if (type is InterfaceType) {
       return type.typeArguments;
     } else if (type is FunctionType) {
       return type.typeArguments;
     }
     return TypeImpl.EMPTY_ARRAY;
   }
 
   /**
    * Returns the simple identifier of the given (may be qualified) type name.
    *
    * @param typeName the (may be qualified) qualified type name
    * @return the simple identifier of the given (may be qualified) type name.
    */
-  SimpleIdentifier getTypeSimpleIdentifier(Identifier typeName) {
+  SimpleIdentifier _getTypeSimpleIdentifier(Identifier typeName) {
     if (typeName is SimpleIdentifier) {
       return typeName;
     } else {
       return (typeName as PrefixedIdentifier).identifier;
     }
   }
 
   /**
    * Given the multiple elements to which a single name could potentially be resolved, return the
    * single interface type that should be used, or `null` if there is no clear choice.
    *
    * @param elements the elements to which a single name could potentially be resolved
    * @return the single interface type that should be used for the type name
    */
-  InterfaceType getTypeWhenMultiplyDefined(List<Element> elements) {
+  InterfaceType _getTypeWhenMultiplyDefined(List<Element> elements) {
     InterfaceType type = null;
     for (Element element in elements) {
       if (element is ClassElement) {
         if (type != null) {
           return null;
         }
         type = element.type;
       }
     }
     return type;
   }
 
   /**
    * Checks if the given type name is used as the type in an as expression.
    *
    * @param typeName the type name to analyzer
    * @return `true` if the given type name is used as the type in an as expression
    */
-  bool isTypeNameInAsExpression(TypeName typeName) {
+  bool _isTypeNameInAsExpression(TypeName typeName) {
     AstNode parent = typeName.parent;
     if (parent is AsExpression) {
       AsExpression asExpression = parent;
       return identical(asExpression.type, typeName);
     }
     return false;
   }
 
   /**
    * Checks if the given type name is used as the exception type in a catch clause.
    *
    * @param typeName the type name to analyzer
    * @return `true` if the given type name is used as the exception type in a catch clause
    */
-  bool isTypeNameInCatchClause(TypeName typeName) {
+  bool _isTypeNameInCatchClause(TypeName typeName) {
     AstNode parent = typeName.parent;
     if (parent is CatchClause) {
       CatchClause catchClause = parent;
       return identical(catchClause.exceptionType, typeName);
     }
     return false;
   }
 
   /**
    * Checks if the given type name is used as the type in an instance creation expression.
    *
    * @param typeName the type name to analyzer
    * @return `true` if the given type name is used as the type in an instance creation
    *         expression
    */
-  bool isTypeNameInInstanceCreationExpression(TypeName typeName) {
+  bool _isTypeNameInInstanceCreationExpression(TypeName typeName) {
     AstNode parent = typeName.parent;
     if (parent is ConstructorName && parent.parent is InstanceCreationExpression) {
       ConstructorName constructorName = parent;
       return constructorName != null && identical(constructorName.type, typeName);
     }
     return false;
   }
 
   /**
    * Checks if the given type name is used as the type in an is expression.
    *
    * @param typeName the type name to analyzer
    * @return `true` if the given type name is used as the type in an is expression
    */
-  bool isTypeNameInIsExpression(TypeName typeName) {
+  bool _isTypeNameInIsExpression(TypeName typeName) {
     AstNode parent = typeName.parent;
     if (parent is IsExpression) {
       IsExpression isExpression = parent;
       return identical(isExpression.type, typeName);
     }
     return false;
   }
 
   /**
    * Checks if the given type name used in a type argument list.
    *
    * @param typeName the type name to analyzer
    * @return `true` if the given type name is in a type argument list
    */
-  bool isTypeNameInTypeArgumentList(TypeName typeName) => typeName.parent is TypeArgumentList;
+  bool _isTypeNameInTypeArgumentList(TypeName typeName) => typeName.parent is TypeArgumentList;
 
   /**
    * Record that the static type of the given node is the given type.
    *
    * @param expression the node whose type is to be recorded
    * @param type the static type of the node
    */
-  Object recordType(Expression expression, Type2 type) {
+  Object _recordType(Expression expression, Type2 type) {
     if (type == null) {
       expression.staticType = _dynamicType;
     } else {
       expression.staticType = type;
     }
     return null;
   }
 
   /**
    * Resolve the types in the given with and implements clauses and associate those types with the
    * given class element.
    *
    * @param classElement the class element with which the mixin and interface types are to be
    *          associated
    * @param withClause the with clause to be resolved
    * @param implementsClause the implements clause to be resolved
    */
-  void resolve(ClassElementImpl classElement, WithClause withClause, ImplementsClause implementsClause) {
+  void _resolve(ClassElementImpl classElement, WithClause withClause, ImplementsClause implementsClause) {
     if (withClause != null) {
-      List<InterfaceType> mixinTypes = resolveTypes(withClause.mixinTypes, CompileTimeErrorCode.MIXIN_OF_NON_CLASS, CompileTimeErrorCode.MIXIN_OF_NON_CLASS);
+      List<InterfaceType> mixinTypes = _resolveTypes(withClause.mixinTypes, CompileTimeErrorCode.MIXIN_OF_NON_CLASS, CompileTimeErrorCode.MIXIN_OF_NON_CLASS);
       if (classElement != null) {
         classElement.mixins = mixinTypes;
       }
     }
     if (implementsClause != null) {
       NodeList<TypeName> interfaces = implementsClause.interfaces;
-      List<InterfaceType> interfaceTypes = resolveTypes(interfaces, CompileTimeErrorCode.IMPLEMENTS_NON_CLASS, CompileTimeErrorCode.IMPLEMENTS_DYNAMIC);
+      List<InterfaceType> interfaceTypes = _resolveTypes(interfaces, CompileTimeErrorCode.IMPLEMENTS_NON_CLASS, CompileTimeErrorCode.IMPLEMENTS_DYNAMIC);
       if (classElement != null) {
         classElement.interfaces = interfaceTypes;
       }
       // TODO(brianwilkerson) Move the following checks to ErrorVerifier.
       List<TypeName> typeNames = new List.from(interfaces);
       List<bool> detectedRepeatOnIndex = new List<bool>.filled(typeNames.length, false);
       for (int i = 0; i < detectedRepeatOnIndex.length; i++) {
         detectedRepeatOnIndex[i] = false;
       }
       for (int i = 0; i < typeNames.length; i++) {
@@ skipping 17 matching lines @@
 
   /**
    * Return the type specified by the given name.
    *
    * @param typeName the type name specifying the type to be returned
    * @param nonTypeError the error to produce if the type name is defined to be something other than
    *          a type
    * @param dynamicTypeError the error to produce if the type name is "dynamic"
    * @return the type specified by the type name
    */
-  InterfaceType resolveType(TypeName typeName, ErrorCode nonTypeError, ErrorCode dynamicTypeError) {
+  InterfaceType _resolveType(TypeName typeName, ErrorCode nonTypeError, ErrorCode dynamicTypeError) {
     Type2 type = typeName.type;
     if (type is InterfaceType) {
       return type;
     }
     // If the type is not an InterfaceType, then visitTypeName() sets the type to be a DynamicTypeImpl
     Identifier name = typeName.name;
     if (name.name == sc.Keyword.DYNAMIC.syntax) {
       reportErrorForNode(dynamicTypeError, name, [name.name]);
     } else {
       reportErrorForNode(nonTypeError, name, [name.name]);
     }
     return null;
   }
 
   /**
    * Resolve the types in the given list of type names.
    *
    * @param typeNames the type names to be resolved
    * @param nonTypeError the error to produce if the type name is defined to be something other than
    *          a type
    * @param dynamicTypeError the error to produce if the type name is "dynamic"
    * @return an array containing all of the types that were resolved.
    */
-  List<InterfaceType> resolveTypes(NodeList<TypeName> typeNames, ErrorCode nonTypeError, ErrorCode dynamicTypeError) {
+  List<InterfaceType> _resolveTypes(NodeList<TypeName> typeNames, ErrorCode nonTypeError, ErrorCode dynamicTypeError) {
     List<InterfaceType> types = new List<InterfaceType>();
     for (TypeName typeName in typeNames) {
-      InterfaceType type = resolveType(typeName, nonTypeError, dynamicTypeError);
+      InterfaceType type = _resolveType(typeName, nonTypeError, dynamicTypeError);
       if (type != null) {
         types.add(type);
       }
     }
     return new List.from(types);
   }
 
-  void setElement(Identifier typeName, Element element) {
+  void _setElement(Identifier typeName, Element element) {
     if (element != null) {
       if (typeName is SimpleIdentifier) {
         typeName.staticElement = element;
       } else if (typeName is PrefixedIdentifier) {
         PrefixedIdentifier identifier = typeName;
         identifier.identifier.staticElement = element;
         SimpleIdentifier prefix = identifier.prefix;
         Element prefixElement = nameScope.lookup(prefix, definingLibrary);
         if (prefixElement != null) {
           prefix.staticElement = prefixElement;
         }
       }
     }
   }
 
   /**
    * Given a parameter element, create a function type based on the given return type and parameter
    * list and associate the created type with the element.
    *
    * @param element the parameter element whose type is to be set
    * @param returnType the (possibly `null`) return type of the function
    * @param parameterList the list of parameters to the function
    */
-  void setFunctionTypedParameterType(ParameterElementImpl element, TypeName returnType, FormalParameterList parameterList) {
-    List<ParameterElement> parameters = getElements(parameterList);
+  void _setFunctionTypedParameterType(ParameterElementImpl element, TypeName returnType, FormalParameterList parameterList) {
+    List<ParameterElement> parameters = _getElements(parameterList);
     FunctionTypeAliasElementImpl aliasElement = new FunctionTypeAliasElementImpl(null);
     aliasElement.synthetic = true;
     aliasElement.shareParameters(parameters);
-    aliasElement.returnType = computeReturnType(returnType);
+    aliasElement.returnType = _computeReturnType(returnType);
     FunctionTypeImpl type = new FunctionTypeImpl.con2(aliasElement);
     ClassElement definingClass = element.getAncestor((element) => element is ClassElement);
     if (definingClass != null) {
       aliasElement.shareTypeParameters(definingClass.typeParameters);
       type.typeArguments = definingClass.type.typeArguments;
     } else {
       FunctionTypeAliasElement alias = element.getAncestor((element) => element is FunctionTypeAliasElement);
       while (alias != null && alias.isSynthetic) {
         alias = alias.getAncestor((element) => element is FunctionTypeAliasElement);
       }
@@ skipping 154 matching lines @@
  * Instances of the class `ClassScope` implement the scope defined by a class.
  */
 class ClassScope extends EnclosedScope {
   /**
    * Initialize a newly created scope enclosed within another scope.
    *
    * @param enclosingScope the scope in which this scope is lexically enclosed
    * @param typeElement the element representing the type represented by this scope
    */
   ClassScope(Scope enclosingScope, ClassElement typeElement) : super(new EnclosedScope(enclosingScope)) {
-    defineTypeParameters(typeElement);
-    defineMembers(typeElement);
+    _defineTypeParameters(typeElement);
+    _defineMembers(typeElement);
   }
 
   AnalysisError getErrorForDuplicate(Element existing, Element duplicate) {
     if (existing is PropertyAccessorElement && duplicate is MethodElement) {
       if (existing.nameOffset < duplicate.nameOffset) {
         return new AnalysisError.con2(duplicate.source, duplicate.nameOffset, duplicate.displayName.length, CompileTimeErrorCode.METHOD_AND_GETTER_WITH_SAME_NAME, [existing.displayName]);
       } else {
         return new AnalysisError.con2(existing.source, existing.nameOffset, existing.displayName.length, CompileTimeErrorCode.GETTER_AND_METHOD_WITH_SAME_NAME, [existing.displayName]);
       }
     }
     return super.getErrorForDuplicate(existing, duplicate);
   }
 
   /**
    * Define the instance members defined by the class.
    *
    * @param typeElement the element representing the type represented by this scope
    */
-  void defineMembers(ClassElement typeElement) {
+  void _defineMembers(ClassElement typeElement) {
     for (PropertyAccessorElement accessor in typeElement.accessors) {
       define(accessor);
     }
     for (MethodElement method in typeElement.methods) {
       define(method);
     }
   }
 
   /**
    * Define the type parameters for the class.
    *
    * @param typeElement the element representing the type represented by this scope
    */
-  void defineTypeParameters(ClassElement typeElement) {
+  void _defineTypeParameters(ClassElement typeElement) {
     Scope parameterScope = enclosingScope;
     for (TypeParameterElement typeParameter in typeElement.typeParameters) {
       parameterScope.define(typeParameter);
     }
   }
 }
 
 /**
  * Instances of the class `EnclosedScope` implement a scope that is lexically enclosed in
  * another scope.
@@ skipping 111 matching lines @@
   bool _parametersDefined = false;
 
   /**
    * Initialize a newly created scope enclosed within another scope.
    *
    * @param enclosingScope the scope in which this scope is lexically enclosed
    * @param typeElement the element representing the type alias represented by this scope
    */
   FunctionTypeScope(Scope enclosingScope, FunctionTypeAliasElement typeElement) : super(new EnclosedScope(enclosingScope)) {
     this._typeElement = typeElement;
-    defineTypeParameters();
+    _defineTypeParameters();
   }
 
   /**
    * Define the parameters for the function type alias.
    *
    * @param typeElement the element representing the type represented by this scope
    */
   void defineParameters() {
     if (_parametersDefined) {
       return;
     }
     _parametersDefined = true;
     for (ParameterElement parameter in _typeElement.parameters) {
       define(parameter);
     }
   }
 
   /**
    * Define the type parameters for the function type alias.
    *
    * @param typeElement the element representing the type represented by this scope
    */
-  void defineTypeParameters() {
+  void _defineTypeParameters() {
     Scope typeParameterScope = enclosingScope;
     for (TypeParameterElement typeParameter in _typeElement.typeParameters) {
       typeParameterScope.define(typeParameter);
     }
   }
 }
 
 /**
  * Instances of the class `LabelScope` represent a scope in which a single label is defined.
  */
@@ skipping 89 matching lines @@
 
   /**
    * Initialize a newly created scope representing the names imported into the given library.
    *
    * @param definingLibrary the element representing the library that imports the names defined in
    *          this scope
    * @param errorListener the listener that is to be informed when an error is encountered
    */
   LibraryImportScope(LibraryElement definingLibrary, this.errorListener) {
     this._definingLibrary = definingLibrary;
-    createImportedNamespaces(definingLibrary);
+    _createImportedNamespaces(definingLibrary);
   }
 
   void define(Element element) {
     if (!Scope.isPrivateName(element.displayName)) {
       super.define(element);
     }
   }
 
   Element internalLookup(Identifier identifier, String name, LibraryElement referencingLibrary) {
     Element foundElement = localLookup(name, referencingLibrary);
     if (foundElement != null) {
       return foundElement;
     }
     for (Namespace nameSpace in _importedNamespaces) {
       Element element = nameSpace.get(name);
       if (element != null) {
         if (foundElement == null) {
           foundElement = element;
         } else if (foundElement != element) {
           foundElement = MultiplyDefinedElementImpl.fromElements(_definingLibrary.context, foundElement, element);
         }
       }
     }
     if (foundElement is MultiplyDefinedElementImpl) {
-      foundElement = removeSdkElements(identifier, name, foundElement as MultiplyDefinedElementImpl);
+      foundElement = _removeSdkElements(identifier, name, foundElement as MultiplyDefinedElementImpl);
     }
     if (foundElement is MultiplyDefinedElementImpl) {
       String foundEltName = foundElement.displayName;
       List<Element> conflictingMembers = (foundElement as MultiplyDefinedElementImpl).conflictingElements;
-      String libName1 = getLibraryName(conflictingMembers[0], "");
-      String libName2 = getLibraryName(conflictingMembers[1], "");
+      String libName1 = _getLibraryName(conflictingMembers[0], "");
+      String libName2 = _getLibraryName(conflictingMembers[1], "");
       // TODO (jwren) Change the error message to include a list of all library names instead of
       // just the first two
       errorListener.onError(new AnalysisError.con2(getSource(identifier), identifier.offset, identifier.length, StaticWarningCode.AMBIGUOUS_IMPORT, [foundEltName, libName1, libName2]));
       return foundElement;
     }
     if (foundElement != null) {
       defineNameWithoutChecking(name, foundElement);
     }
     return foundElement;
   }
 
   /**
    * Create all of the namespaces associated with the libraries imported into this library. The
    * names are not added to this scope, but are stored for later reference.
    *
    * @param definingLibrary the element representing the library that imports the libraries for
    *          which namespaces will be created
    */
-  void createImportedNamespaces(LibraryElement definingLibrary) {
+  void _createImportedNamespaces(LibraryElement definingLibrary) {
     NamespaceBuilder builder = new NamespaceBuilder();
     List<ImportElement> imports = definingLibrary.imports;
     int count = imports.length;
     _importedNamespaces = new List<Namespace>(count);
     for (int i = 0; i < count; i++) {
       _importedNamespaces[i] = builder.createImportNamespaceForDirective(imports[i]);
     }
   }
 
   /**
    * Returns the name of the library that defines given element.
    *
    * @param element the element to get library name
    * @param def the default name to use
    * @return the name of the library that defines given element
    */
-  String getLibraryName(Element element, String def) {
+  String _getLibraryName(Element element, String def) {
     if (element == null) {
       return def;
     }
     LibraryElement library = element.library;
     if (library == null) {
       return def;
     }
     return library.definingCompilationUnit.displayName;
   }
 
   /**
    * Given a collection of elements that a single name could all be mapped to, remove from the list
    * all of the names defined in the SDK. Return the element(s) that remain.
    *
    * @param identifier the identifier node to lookup element for, used to report correct kind of a
    *          problem and associate problem with
    * @param name the name associated with the element
    * @param foundElement the element encapsulating the collection of elements
    * @return all of the elements that are not defined in the SDK
    */
-  Element removeSdkElements(Identifier identifier, String name, MultiplyDefinedElementImpl foundElement) {
+  Element _removeSdkElements(Identifier identifier, String name, MultiplyDefinedElementImpl foundElement) {
     List<Element> conflictingMembers = foundElement.conflictingElements;
     int length = conflictingMembers.length;
     int to = 0;
     Element sdkElement = null;
     for (Element member in conflictingMembers) {
       if (member.library.isInSdk) {
         sdkElement = member;
       } else {
         conflictingMembers[to++] = member;
       }
     }
     if (sdkElement != null && to > 0) {
-      String sdkLibName = getLibraryName(sdkElement, "");
-      String otherLibName = getLibraryName(conflictingMembers[0], "");
+      String sdkLibName = _getLibraryName(sdkElement, "");
+      String otherLibName = _getLibraryName(conflictingMembers[0], "");
       errorListener.onError(new AnalysisError.con2(getSource(identifier), identifier.offset, identifier.length, StaticWarningCode.CONFLICTING_DART_IMPORT, [name, sdkLibName, otherLibName]));
     }
     if (to == length) {
       // None of the members were removed
       return foundElement;
     } else if (to == 1) {
       // All but one member was removed
       return conflictingMembers[0];
     } else if (to == 0) {
       // All members were removed
@@ skipping 11 matching lines @@
  * in a given library.
  */
 class LibraryScope extends EnclosedScope {
   /**
    * Initialize a newly created scope representing the names defined in the given library.
    *
    * @param definingLibrary the element representing the library represented by this scope
    * @param errorListener the listener that is to be informed when an error is encountered
    */
   LibraryScope(LibraryElement definingLibrary, AnalysisErrorListener errorListener) : super(new LibraryImportScope(definingLibrary, errorListener)) {
-    defineTopLevelNames(definingLibrary);
+    _defineTopLevelNames(definingLibrary);
   }
 
   AnalysisError getErrorForDuplicate(Element existing, Element duplicate) {
     if (existing is PrefixElement) {
       // TODO(scheglov) consider providing actual 'nameOffset' from the synthetic accessor
       int offset = duplicate.nameOffset;
       if (duplicate is PropertyAccessorElement) {
         PropertyAccessorElement accessor = duplicate;
         if (accessor.isSynthetic) {
           offset = accessor.variable.nameOffset;
         }
       }
       return new AnalysisError.con2(duplicate.source, offset, duplicate.displayName.length, CompileTimeErrorCode.PREFIX_COLLIDES_WITH_TOP_LEVEL_MEMBER, [existing.displayName]);
     }
     return super.getErrorForDuplicate(existing, duplicate);
   }
 
   /**
    * Add to this scope all of the public top-level names that are defined in the given compilation
    * unit.
    *
    * @param compilationUnit the compilation unit defining the top-level names to be added to this
    *          scope
    */
-  void defineLocalNames(CompilationUnitElement compilationUnit) {
+  void _defineLocalNames(CompilationUnitElement compilationUnit) {
     for (PropertyAccessorElement element in compilationUnit.accessors) {
       define(element);
     }
     for (FunctionElement element in compilationUnit.functions) {
       define(element);
     }
     for (FunctionTypeAliasElement element in compilationUnit.functionTypeAliases) {
       define(element);
     }
     for (ClassElement element in compilationUnit.types) {
       define(element);
     }
   }
 
   /**
    * Add to this scope all of the names that are explicitly defined in the given library.
    *
    * @param definingLibrary the element representing the library that defines the names in this
    *          scope
    */
-  void defineTopLevelNames(LibraryElement definingLibrary) {
+  void _defineTopLevelNames(LibraryElement definingLibrary) {
     for (PrefixElement prefix in definingLibrary.prefixes) {
       define(prefix);
     }
-    defineLocalNames(definingLibrary.definingCompilationUnit);
+    _defineLocalNames(definingLibrary.definingCompilationUnit);
     for (CompilationUnitElement compilationUnit in definingLibrary.parts) {
-      defineLocalNames(compilationUnit);
+      _defineLocalNames(compilationUnit);
     }
   }
 }
 
 /**
  * Instances of the class `Namespace` implement a mapping of identifiers to the elements
  * represented by those identifiers. Namespaces are the building blocks for scopes.
  */
 class Namespace {
   /**
@@ skipping 46 matching lines @@
    * @return the export namespace that was created
    */
   Namespace createExportNamespaceForDirective(ExportElement element) {
     LibraryElement exportedLibrary = element.exportedLibrary;
     if (exportedLibrary == null) {
       //
       // The exported library will be null if the URI does not reference a valid library.
       //
       return Namespace.EMPTY;
     }
-    Map<String, Element> definedNames = createExportMapping(exportedLibrary, new Set<LibraryElement>());
-    definedNames = applyCombinators(definedNames, element.combinators);
+    Map<String, Element> definedNames = _createExportMapping(exportedLibrary, new Set<LibraryElement>());
+    definedNames = _applyCombinators(definedNames, element.combinators);
     return new Namespace(definedNames);
   }
 
   /**
    * Create a namespace representing the export namespace of the given library.
    *
    * @param library the library whose export namespace is to be created
    * @return the export namespace that was created
    */
-  Namespace createExportNamespaceForLibrary(LibraryElement library) => new Namespace(createExportMapping(library, new Set<LibraryElement>()));
+  Namespace createExportNamespaceForLibrary(LibraryElement library) => new Namespace(_createExportMapping(library, new Set<LibraryElement>()));
 
   /**
    * Create a namespace representing the import namespace of the given library.
    *
    * @param library the library whose import namespace is to be created
    * @return the import namespace that was created
    */
   Namespace createImportNamespaceForDirective(ImportElement element) {
     LibraryElement importedLibrary = element.importedLibrary;
     if (importedLibrary == null) {
       //
       // The imported library will be null if the URI does not reference a valid library.
       //
       return Namespace.EMPTY;
     }
-    Map<String, Element> definedNames = createExportMapping(importedLibrary, new Set<LibraryElement>());
-    definedNames = applyCombinators(definedNames, element.combinators);
-    definedNames = applyPrefix(definedNames, element.prefix);
+    Map<String, Element> definedNames = _createExportMapping(importedLibrary, new Set<LibraryElement>());
+    definedNames = _applyCombinators(definedNames, element.combinators);
+    definedNames = _applyPrefix(definedNames, element.prefix);
     return new Namespace(definedNames);
   }
 
   /**
    * Create a namespace representing the public namespace of the given library.
    *
    * @param library the library whose public namespace is to be created
    * @return the public namespace that was created
    */
   Namespace createPublicNamespaceForLibrary(LibraryElement library) {
     Map<String, Element> definedNames = new Map<String, Element>();
-    addPublicNames(definedNames, library.definingCompilationUnit);
+    _addPublicNames(definedNames, library.definingCompilationUnit);
     for (CompilationUnitElement compilationUnit in library.parts) {
-      addPublicNames(definedNames, compilationUnit);
+      _addPublicNames(definedNames, compilationUnit);
     }
     return new Namespace(definedNames);
   }
 
   /**
    * Add all of the names in the given namespace to the given mapping table.
    *
    * @param definedNames the mapping table to which the names in the given namespace are to be added
    * @param namespace the namespace containing the names to be added to this namespace
    */
-  void addAllFromMap(Map<String, Element> definedNames, Map<String, Element> newNames) {
+  void _addAllFromMap(Map<String, Element> definedNames, Map<String, Element> newNames) {
     for (MapEntry<String, Element> entry in getMapEntrySet(newNames)) {
       definedNames[entry.getKey()] = entry.getValue();
     }
   }
 
   /**
    * Add all of the names in the given namespace to the given mapping table.
    *
    * @param definedNames the mapping table to which the names in the given namespace are to be added
    * @param namespace the namespace containing the names to be added to this namespace
    */
-  void addAllFromNamespace(Map<String, Element> definedNames, Namespace namespace) {
+  void _addAllFromNamespace(Map<String, Element> definedNames, Namespace namespace) {
     if (namespace != null) {
-      addAllFromMap(definedNames, namespace.definedNames);
+      _addAllFromMap(definedNames, namespace.definedNames);
     }
   }
 
   /**
    * Add the given element to the given mapping table if it has a publicly visible name.
    *
    * @param definedNames the mapping table to which the public name is to be added
    * @param element the element to be added
    */
-  void addIfPublic(Map<String, Element> definedNames, Element element) {
+  void _addIfPublic(Map<String, Element> definedNames, Element element) {
     String name = element.name;
     if (name != null && !Scope.isPrivateName(name)) {
       definedNames[name] = element;
     }
   }
 
   /**
    * Add to the given mapping table all of the public top-level names that are defined in the given
    * compilation unit.
    *
    * @param definedNames the mapping table to which the public names are to be added
    * @param compilationUnit the compilation unit defining the top-level names to be added to this
    *          namespace
    */
-  void addPublicNames(Map<String, Element> definedNames, CompilationUnitElement compilationUnit) {
+  void _addPublicNames(Map<String, Element> definedNames, CompilationUnitElement compilationUnit) {
     for (PropertyAccessorElement element in compilationUnit.accessors) {
-      addIfPublic(definedNames, element);
+      _addIfPublic(definedNames, element);
     }
     for (FunctionElement element in compilationUnit.functions) {
-      addIfPublic(definedNames, element);
+      _addIfPublic(definedNames, element);
     }
     for (FunctionTypeAliasElement element in compilationUnit.functionTypeAliases) {
-      addIfPublic(definedNames, element);
+      _addIfPublic(definedNames, element);
     }
     for (ClassElement element in compilationUnit.types) {
-      addIfPublic(definedNames, element);
+      _addIfPublic(definedNames, element);
     }
   }
 
   /**
    * Apply the given combinators to all of the names in the given mapping table.
    *
    * @param definedNames the mapping table to which the namespace operations are to be applied
    * @param combinators the combinators to be applied
    */
-  Map<String, Element> applyCombinators(Map<String, Element> definedNames, List<NamespaceCombinator> combinators) {
+  Map<String, Element> _applyCombinators(Map<String, Element> definedNames, List<NamespaceCombinator> combinators) {
     for (NamespaceCombinator combinator in combinators) {
       if (combinator is HideElementCombinator) {
-        hide(definedNames, combinator.hiddenNames);
+        _hide(definedNames, combinator.hiddenNames);
       } else if (combinator is ShowElementCombinator) {
-        definedNames = show(definedNames, combinator.shownNames);
+        definedNames = _show(definedNames, combinator.shownNames);
       } else {
         // Internal error.
         AnalysisEngine.instance.logger.logError("Unknown type of combinator: ${combinator.runtimeType.toString()}");
       }
     }
     return definedNames;
   }
 
   /**
    * Apply the given prefix to all of the names in the table of defined names.
    *
    * @param definedNames the names that were defined before this operation
    * @param prefixElement the element defining the prefix to be added to the names
    */
-  Map<String, Element> applyPrefix(Map<String, Element> definedNames, PrefixElement prefixElement) {
+  Map<String, Element> _applyPrefix(Map<String, Element> definedNames, PrefixElement prefixElement) {
     if (prefixElement != null) {
       String prefix = prefixElement.name;
       Map<String, Element> newNames = new Map<String, Element>();
       for (MapEntry<String, Element> entry in getMapEntrySet(definedNames)) {
         newNames["${prefix}.${entry.getKey()}"] = entry.getValue();
       }
       return newNames;
     } else {
       return definedNames;
     }
   }
 
   /**
    * Create a mapping table representing the export namespace of the given library.
    *
    * @param library the library whose public namespace is to be created
    * @param visitedElements a set of libraries that do not need to be visited when processing the
    *          export directives of the given library because all of the names defined by them will
    *          be added by another library
    * @return the mapping table that was created
    */
-  Map<String, Element> createExportMapping(LibraryElement library, Set<LibraryElement> visitedElements) {
+  Map<String, Element> _createExportMapping(LibraryElement library, Set<LibraryElement> visitedElements) {
     visitedElements.add(library);
     try {
       Map<String, Element> definedNames = new Map<String, Element>();
       for (ExportElement element in library.exports) {
         LibraryElement exportedLibrary = element.exportedLibrary;
         if (exportedLibrary != null && !visitedElements.contains(exportedLibrary)) {
           //
           // The exported library will be null if the URI does not reference a valid library.
           //
-          Map<String, Element> exportedNames = createExportMapping(exportedLibrary, visitedElements);
-          exportedNames = applyCombinators(exportedNames, element.combinators);
-          addAllFromMap(definedNames, exportedNames);
+          Map<String, Element> exportedNames = _createExportMapping(exportedLibrary, visitedElements);
+          exportedNames = _applyCombinators(exportedNames, element.combinators);
+          _addAllFromMap(definedNames, exportedNames);
         }
       }
-      addAllFromNamespace(definedNames, (library.context as InternalAnalysisContext).getPublicNamespace(library));
+      _addAllFromNamespace(definedNames, (library.context as InternalAnalysisContext).getPublicNamespace(library));
       return definedNames;
     } finally {
       visitedElements.remove(library);
     }
   }
 
   /**
    * Hide all of the given names by removing them from the given collection of defined names.
    *
    * @param definedNames the names that were defined before this operation
    * @param hiddenNames the names to be hidden
    */
-  void hide(Map<String, Element> definedNames, List<String> hiddenNames) {
+  void _hide(Map<String, Element> definedNames, List<String> hiddenNames) {
     for (String name in hiddenNames) {
       definedNames.remove(name);
       definedNames.remove("${name}=");
     }
   }
 
   /**
    * Show only the given names by removing all other names from the given collection of defined
    * names.
    *
    * @param definedNames the names that were defined before this operation
    * @param shownNames the names to be shown
    */
-  Map<String, Element> show(Map<String, Element> definedNames, List<String> shownNames) {
+  Map<String, Element> _show(Map<String, Element> definedNames, List<String> shownNames) {
     Map<String, Element> newNames = new Map<String, Element>();
     for (String name in shownNames) {
       Element element = definedNames[name];
       if (element != null) {
         newNames[name] = element;
       }
       String setterName = "${name}=";
       element = definedNames[setterName];
       if (element != null) {
         newNames[setterName] = element;
@@ skipping 46 matching lines @@
 
   /**
    * Add the given element to this scope. If there is already an element with the given name defined
    * in this scope, then an error will be generated and the original element will continue to be
    * mapped to the name. If there is an element with the given name in an enclosing scope, then a
    * warning will be generated but the given element will hide the inherited element.
    *
    * @param element the element to be added to this scope
    */
   void define(Element element) {
-    String name = getName(element);
+    String name = _getName(element);
     if (name != null && !name.isEmpty) {
       if (_definedNames.containsKey(name)) {
         errorListener.onError(getErrorForDuplicate(_definedNames[name], element));
       } else {
         _definedNames[name] = element;
         _hasName = true;
       }
     }
   }
 
@@ skipping 25 matching lines @@
     _definedNames[name] = element;
     _hasName = true;
   }
 
   /**
    * Add the given element to this scope without checking for duplication or hiding.
    *
    * @param element the element to be added to this scope
    */
   void defineWithoutChecking(Element element) {
-    _definedNames[getName(element)] = element;
+    _definedNames[_getName(element)] = element;
     _hasName = true;
   }
 
   /**
    * Return the error code to be used when reporting that a name being defined locally conflicts
    * with another element of the same name in the local scope.
    *
    * @param existing the first element to be declared with the conflicting name
    * @param duplicate another element declared with the conflicting name
    * @return the error code used to report duplicate names within a scope
@@ skipping 60 matching lines @@
     }
     return null;
   }
 
   /**
    * Return the name that will be used to look up the given element.
    *
    * @param element the element whose look-up name is to be returned
    * @return the name that will be used to look up the given element
    */
-  String getName(Element element) {
+  String _getName(Element element) {
     if (element is MethodElement) {
       MethodElement method = element;
       if (method.name == "-" && method.parameters.length == 0) {
         return UNARY_MINUS;
       }
     }
     return element.name;
   }
 }
 
 /**
  * Instances of the class `ScopeBuilder` build the scope for a given node in an AST structure.
  * At the moment, this class only handles top-level and class-level declarations.
  */
 class ScopeBuilder {
   /**
    * Return the scope in which the given AST structure should be resolved.
    *
    * @param node the root of the AST structure to be resolved
    * @param errorListener the listener to which analysis errors will be reported
    * @return the scope in which the given AST structure should be resolved
    * @throws AnalysisException if the AST structure has not been resolved or is not part of a
    *           [CompilationUnit]
    */
   static Scope scopeFor(AstNode node, AnalysisErrorListener errorListener) {
     if (node == null) {
       throw new AnalysisException.con1("Cannot create scope: node is null");
     } else if (node is CompilationUnit) {
       ScopeBuilder builder = new ScopeBuilder(errorListener);
-      return builder.scopeForAstNode(node);
+      return builder._scopeForAstNode(node);
     }
     AstNode parent = node.parent;
     if (parent == null) {
       throw new AnalysisException.con1("Cannot create scope: node is not part of a CompilationUnit");
     }
     ScopeBuilder builder = new ScopeBuilder(errorListener);
-    return builder.scopeForAstNode(parent);
+    return builder._scopeForAstNode(parent);
   }
 
   /**
    * The listener to which analysis errors will be reported.
    */
   AnalysisErrorListener _errorListener;
 
   /**
    * Initialize a newly created scope builder to generate a scope that will report errors to the
    * given listener.
    *
    * @param errorListener the listener to which analysis errors will be reported
    */
   ScopeBuilder(AnalysisErrorListener errorListener) {
     this._errorListener = errorListener;
   }
 
   /**
    * Return the scope in which the given AST structure should be resolved.
    *
    * <b>Note:</b> This method needs to be kept in sync with
    * [IncrementalResolver#canBeResolved].
    *
    * @param node the root of the AST structure to be resolved
    * @return the scope in which the given AST structure should be resolved
    * @throws AnalysisException if the AST structure has not been resolved or is not part of a
    *           [CompilationUnit]
    */
-  Scope scopeForAstNode(AstNode node) {
+  Scope _scopeForAstNode(AstNode node) {
     if (node is CompilationUnit) {
-      return scopeForCompilationUnit(node);
+      return _scopeForCompilationUnit(node);
     }
     AstNode parent = node.parent;
     if (parent == null) {
       throw new AnalysisException.con1("Cannot create scope: node is not part of a CompilationUnit");
     }
-    Scope scope = scopeForAstNode(parent);
+    Scope scope = _scopeForAstNode(parent);
     if (node is ClassDeclaration) {
       scope = new ClassScope(scope, node.element);
     } else if (node is ClassTypeAlias) {
       scope = new ClassScope(scope, node.element);
     } else if (node is ConstructorDeclaration) {
       FunctionScope functionScope = new FunctionScope(scope, node.element);
       functionScope.defineParameters();
       scope = functionScope;
     } else if (node is FunctionDeclaration) {
       FunctionScope functionScope = new FunctionScope(scope, node.element);
       functionScope.defineParameters();
       scope = functionScope;
     } else if (node is FunctionTypeAlias) {
       scope = new FunctionTypeScope(scope, node.element);
     } else if (node is MethodDeclaration) {
       FunctionScope functionScope = new FunctionScope(scope, node.element);
       functionScope.defineParameters();
       scope = functionScope;
     }
     return scope;
   }
 
-  Scope scopeForCompilationUnit(CompilationUnit node) {
+  Scope _scopeForCompilationUnit(CompilationUnit node) {
     CompilationUnitElement unitElement = node.element;
     if (unitElement == null) {
       throw new AnalysisException.con1("Cannot create scope: compilation unit is not resolved");
     }
     LibraryElement libraryElement = unitElement.library;
     if (libraryElement == null) {
       throw new AnalysisException.con1("Cannot create scope: compilation unit is not part of a library");
     }
     return new LibraryScope(libraryElement, _errorListener);
   }
@@ skipping 60 matching lines @@
         _errorReporter.reportErrorForNode(CompileTimeErrorCode.NON_CONSTANT_ANNOTATION_CONSTRUCTOR, node, []);
         return null;
       }
       // should have arguments
       ArgumentList argumentList = node.arguments;
       if (argumentList == null) {
         _errorReporter.reportErrorForNode(CompileTimeErrorCode.NO_ANNOTATION_CONSTRUCTOR_ARGUMENTS, node, []);
         return null;
       }
       // arguments should be constants
-      validateConstantArguments(argumentList);
+      _validateConstantArguments(argumentList);
     }
     return null;
   }
 
   Object visitConstructorDeclaration(ConstructorDeclaration node) {
     if (node.constKeyword != null) {
-      validateInitializers(node);
+      _validateInitializers(node);
     }
-    validateDefaultValues(node.parameters);
+    _validateDefaultValues(node.parameters);
     return super.visitConstructorDeclaration(node);
   }
 
   Object visitFunctionExpression(FunctionExpression node) {
     super.visitFunctionExpression(node);
-    validateDefaultValues(node.parameters);
+    _validateDefaultValues(node.parameters);
     return null;
   }
 
   Object visitInstanceCreationExpression(InstanceCreationExpression node) {
-    validateInstanceCreationArguments(node);
+    _validateInstanceCreationArguments(node);
     return super.visitInstanceCreationExpression(node);
   }
 
   Object visitListLiteral(ListLiteral node) {
     super.visitListLiteral(node);
     if (node.constKeyword != null) {
       for (Expression element in node.elements) {
-        validate(element, CompileTimeErrorCode.NON_CONSTANT_LIST_ELEMENT);
+        _validate(element, CompileTimeErrorCode.NON_CONSTANT_LIST_ELEMENT);
       }
     }
     return null;
   }
 
   Object visitMapLiteral(MapLiteral node) {
     super.visitMapLiteral(node);
     bool isConst = node.constKeyword != null;
     bool reportEqualKeys = true;
     Set<DartObject> keys = new Set<DartObject>();
     List<Expression> invalidKeys = new List<Expression>();
     for (MapLiteralEntry entry in node.entries) {
       Expression key = entry.key;
       if (isConst) {
-        EvaluationResultImpl result = validate(key, CompileTimeErrorCode.NON_CONSTANT_MAP_KEY);
-        validate(entry.value, CompileTimeErrorCode.NON_CONSTANT_MAP_VALUE);
+        EvaluationResultImpl result = _validate(key, CompileTimeErrorCode.NON_CONSTANT_MAP_KEY);
+        _validate(entry.value, CompileTimeErrorCode.NON_CONSTANT_MAP_VALUE);
         if (result is ValidResult) {
           DartObject value = result.value;
           if (keys.contains(value)) {
             invalidKeys.add(key);
           } else {
             keys.add(value);
           }
         }
       } else {
         EvaluationResultImpl result = key.accept(new ConstantVisitor(_typeProvider));
@@ skipping 12 matching lines @@
     if (reportEqualKeys) {
       for (Expression key in invalidKeys) {
         _errorReporter.reportErrorForNode(StaticWarningCode.EQUAL_KEYS_IN_MAP, key, []);
       }
     }
     return null;
   }
 
   Object visitMethodDeclaration(MethodDeclaration node) {
     super.visitMethodDeclaration(node);
-    validateDefaultValues(node.parameters);
+    _validateDefaultValues(node.parameters);
     return null;
   }
 
   Object visitSwitchCase(SwitchCase node) {
     super.visitSwitchCase(node);
-    validate(node.expression, CompileTimeErrorCode.NON_CONSTANT_CASE_EXPRESSION);
+    _validate(node.expression, CompileTimeErrorCode.NON_CONSTANT_CASE_EXPRESSION);
     return null;
   }
 
   Object visitVariableDeclaration(VariableDeclaration node) {
     super.visitVariableDeclaration(node);
     Expression initializer = node.initializer;
     if (initializer != null && node.isConst) {
       VariableElementImpl element = node.element as VariableElementImpl;
       EvaluationResultImpl result = element.evaluationResult;
       if (result == null) {
         //
         // Normally we don't need to visit const variable declarations because we have already
         // computed their values. But if we missed it for some reason, this gives us a second
         // chance.
         //
-        result = validate(initializer, CompileTimeErrorCode.CONST_INITIALIZED_WITH_NON_CONSTANT_VALUE);
+        result = _validate(initializer, CompileTimeErrorCode.CONST_INITIALIZED_WITH_NON_CONSTANT_VALUE);
         element.evaluationResult = result;
       } else if (result is ErrorResult) {
-        reportErrors(result, CompileTimeErrorCode.CONST_INITIALIZED_WITH_NON_CONSTANT_VALUE);
+        _reportErrors(result, CompileTimeErrorCode.CONST_INITIALIZED_WITH_NON_CONSTANT_VALUE);
       }
     }
     return null;
   }
 
   /**
    * If the given result represents one or more errors, report those errors. Except for special
    * cases, use the given error code rather than the one reported in the error.
    *
    * @param result the result containing any errors that need to be reported
    * @param errorCode the error code to be used if the result represents an error
    */
-  void reportErrors(EvaluationResultImpl result, ErrorCode errorCode) {
+  void _reportErrors(EvaluationResultImpl result, ErrorCode errorCode) {
     if (result is ErrorResult) {
       for (ErrorResult_ErrorData data in result.errorData) {
         ErrorCode dataErrorCode = data.errorCode;
         if (identical(dataErrorCode, CompileTimeErrorCode.CONST_EVAL_THROWS_EXCEPTION) || identical(dataErrorCode, CompileTimeErrorCode.CONST_EVAL_THROWS_IDBZE) || identical(dataErrorCode, CompileTimeErrorCode.CONST_EVAL_TYPE_BOOL_NUM_STRING) || identical(dataErrorCode, CompileTimeErrorCode.CONST_EVAL_TYPE_BOOL) || identical(dataErrorCode, CompileTimeErrorCode.CONST_EVAL_TYPE_INT) || identical(dataErrorCode, CompileTimeErrorCode.CONST_EVAL_TYPE_NUM)) {
           _errorReporter.reportErrorForNode(dataErrorCode, data.node, []);
         } else {
           _errorReporter.reportErrorForNode(errorCode, data.node, []);
         }
       }
     }
   }
 
-  ValidResult valid(InterfaceType type, InstanceState state) => new ValidResult(new DartObjectImpl(type, state));
+  ValidResult _valid(InterfaceType type, InstanceState state) => new ValidResult(new DartObjectImpl(type, state));
 
   /**
    * Validate that the given expression is a compile time constant. Return the value of the compile
    * time constant, or `null` if the expression is not a compile time constant.
    *
    * @param expression the expression to be validated
    * @param errorCode the error code to be used if the expression is not a compile time constant
    * @return the value of the compile time constant
    */
-  EvaluationResultImpl validate(Expression expression, ErrorCode errorCode) {
+  EvaluationResultImpl _validate(Expression expression, ErrorCode errorCode) {
     EvaluationResultImpl result = expression.accept(new ConstantVisitor(_typeProvider));
-    reportErrors(result, errorCode);
+    _reportErrors(result, errorCode);
     return result;
   }
 
   /**
    * Validate that if the passed arguments are constant expressions.
    *
    * @param argumentList the argument list to evaluate
    */
-  void validateConstantArguments(ArgumentList argumentList) {
+  void _validateConstantArguments(ArgumentList argumentList) {
     for (Expression argument in argumentList.arguments) {
       if (argument is NamedExpression) {
         argument = (argument as NamedExpression).expression;
       }
-      validate(argument, CompileTimeErrorCode.CONST_WITH_NON_CONSTANT_ARGUMENT);
+      _validate(argument, CompileTimeErrorCode.CONST_WITH_NON_CONSTANT_ARGUMENT);
     }
   }
 
   /**
    * Validate that the default value associated with each of the parameters in the given list is a
    * compile time constant.
    *
    * @param parameters the list of parameters to be validated
    */
-  void validateDefaultValues(FormalParameterList parameters) {
+  void _validateDefaultValues(FormalParameterList parameters) {
     if (parameters == null) {
       return;
     }
     for (FormalParameter parameter in parameters.parameters) {
       if (parameter is DefaultFormalParameter) {
         DefaultFormalParameter defaultParameter = parameter;
         Expression defaultValue = defaultParameter.defaultValue;
         if (defaultValue != null) {
-          EvaluationResultImpl result = validate(defaultValue, CompileTimeErrorCode.NON_CONSTANT_DEFAULT_VALUE);
+          EvaluationResultImpl result = _validate(defaultValue, CompileTimeErrorCode.NON_CONSTANT_DEFAULT_VALUE);
           VariableElementImpl element = parameter.element as VariableElementImpl;
           element.evaluationResult = result;
         }
       }
     }
   }
 
   /**
    * Validates that the given expression is a compile time constant.
    *
    * @param parameterElements the elements of parameters of constant constructor, they are
    *          considered as a valid potentially constant expressions
    * @param expression the expression to validate
    */
-  void validateInitializerExpression(List<ParameterElement> parameterElements, Expression expression) {
+  void _validateInitializerExpression(List<ParameterElement> parameterElements, Expression expression) {
     EvaluationResultImpl result = expression.accept(new ConstantVisitor_ConstantVerifier_validateInitializerExpression(_typeProvider, this, parameterElements));
-    reportErrors(result, CompileTimeErrorCode.NON_CONSTANT_VALUE_IN_INITIALIZER);
+    _reportErrors(result, CompileTimeErrorCode.NON_CONSTANT_VALUE_IN_INITIALIZER);
   }
 
   /**
    * Validates that all of the arguments of a constructor initializer are compile time constants.
    *
    * @param parameterElements the elements of parameters of constant constructor, they are
    *          considered as a valid potentially constant expressions
    * @param argumentList the argument list to validate
    */
-  void validateInitializerInvocationArguments(List<ParameterElement> parameterElements, ArgumentList argumentList) {
+  void _validateInitializerInvocationArguments(List<ParameterElement> parameterElements, ArgumentList argumentList) {
     if (argumentList == null) {
       return;
     }
     for (Expression argument in argumentList.arguments) {
-      validateInitializerExpression(parameterElements, argument);
+      _validateInitializerExpression(parameterElements, argument);
     }
   }
 
   /**
    * Validates that the expressions of the given initializers (of a constant constructor) are all
    * compile time constants.
    *
    * @param constructor the constant constructor declaration to validate
    */
-  void validateInitializers(ConstructorDeclaration constructor) {
+  void _validateInitializers(ConstructorDeclaration constructor) {
     List<ParameterElement> parameterElements = constructor.parameters.parameterElements;
     NodeList<ConstructorInitializer> initializers = constructor.initializers;
     for (ConstructorInitializer initializer in initializers) {
       if (initializer is ConstructorFieldInitializer) {
         ConstructorFieldInitializer fieldInitializer = initializer;
-        validateInitializerExpression(parameterElements, fieldInitializer.expression);
+        _validateInitializerExpression(parameterElements, fieldInitializer.expression);
       }
       if (initializer is RedirectingConstructorInvocation) {
         RedirectingConstructorInvocation invocation = initializer;
-        validateInitializerInvocationArguments(parameterElements, invocation.argumentList);
+        _validateInitializerInvocationArguments(parameterElements, invocation.argumentList);
       }
       if (initializer is SuperConstructorInvocation) {
         SuperConstructorInvocation invocation = initializer;
-        validateInitializerInvocationArguments(parameterElements, invocation.argumentList);
+        _validateInitializerInvocationArguments(parameterElements, invocation.argumentList);
       }
     }
   }
 
   /**
    * Validate that if the passed instance creation is 'const' then all its arguments are constant
    * expressions.
    *
    * @param node the instance creation evaluate
    */
-  void validateInstanceCreationArguments(InstanceCreationExpression node) {
+  void _validateInstanceCreationArguments(InstanceCreationExpression node) {
     if (!node.isConst) {
       return;
     }
     ArgumentList argumentList = node.argumentList;
     if (argumentList == null) {
       return;
     }
-    validateConstantArguments(argumentList);
+    _validateConstantArguments(argumentList);
   }
 }
 
 class ConstantVisitor_ConstantVerifier_validateInitializerExpression extends ConstantVisitor {
   final ConstantVerifier ConstantVerifier_this;
 
   List<ParameterElement> parameterElements;
 
   ConstantVisitor_ConstantVerifier_validateInitializerExpression(TypeProvider arg0, this.ConstantVerifier_this, this.parameterElements) : super(arg0);
 
   EvaluationResultImpl visitSimpleIdentifier(SimpleIdentifier node) {
     Element element = node.staticElement;
     for (ParameterElement parameterElement in parameterElements) {
       if (identical(parameterElement, element) && parameterElement != null) {
         Type2 type = parameterElement.type;
         if (type != null) {
           if (type.isDynamic) {
-            return ConstantVerifier_this.valid(ConstantVerifier_this._typeProvider.objectType, DynamicState.DYNAMIC_STATE);
+            return ConstantVerifier_this._valid(ConstantVerifier_this._typeProvider.objectType, DynamicState.DYNAMIC_STATE);
           } else if (type.isSubtypeOf(ConstantVerifier_this._boolType)) {
-            return ConstantVerifier_this.valid(ConstantVerifier_this._typeProvider.boolType, BoolState.UNKNOWN_VALUE);
+            return ConstantVerifier_this._valid(ConstantVerifier_this._typeProvider.boolType, BoolState.UNKNOWN_VALUE);
           } else if (type.isSubtypeOf(ConstantVerifier_this._typeProvider.doubleType)) {
-            return ConstantVerifier_this.valid(ConstantVerifier_this._typeProvider.doubleType, DoubleState.UNKNOWN_VALUE);
+            return ConstantVerifier_this._valid(ConstantVerifier_this._typeProvider.doubleType, DoubleState.UNKNOWN_VALUE);
           } else if (type.isSubtypeOf(ConstantVerifier_this._intType)) {
-            return ConstantVerifier_this.valid(ConstantVerifier_this._typeProvider.intType, IntState.UNKNOWN_VALUE);
+            return ConstantVerifier_this._valid(ConstantVerifier_this._typeProvider.intType, IntState.UNKNOWN_VALUE);
           } else if (type.isSubtypeOf(ConstantVerifier_this._numType)) {
-            return ConstantVerifier_this.valid(ConstantVerifier_this._typeProvider.numType, NumState.UNKNOWN_VALUE);
+            return ConstantVerifier_this._valid(ConstantVerifier_this._typeProvider.numType, NumState.UNKNOWN_VALUE);
           } else if (type.isSubtypeOf(ConstantVerifier_this._stringType)) {
-            return ConstantVerifier_this.valid(ConstantVerifier_this._typeProvider.stringType, StringState.UNKNOWN_VALUE);
+            return ConstantVerifier_this._valid(ConstantVerifier_this._typeProvider.stringType, StringState.UNKNOWN_VALUE);
           }
         }
-        return ConstantVerifier_this.valid(type is InterfaceType ? type : ConstantVerifier_this._typeProvider.objectType, GenericState.UNKNOWN_VALUE);
+        return ConstantVerifier_this._valid(type is InterfaceType ? type : ConstantVerifier_this._typeProvider.objectType, GenericState.UNKNOWN_VALUE);
       }
     }
     return super.visitSimpleIdentifier(node);
   }
 }
 
 /**
  * Instances of the class `ErrorVerifier` traverse an AST structure looking for additional
  * errors and warnings not covered by the parser and resolver.
  */
@@ skipping 201 matching lines @@
     _DISALLOWED_TYPES_TO_EXTEND_OR_IMPLEMENT = <InterfaceType> [
         typeProvider.nullType,
         typeProvider.numType,
         _intType,
         typeProvider.doubleType,
         _boolType,
         typeProvider.stringType];
   }
 
   Object visitArgumentList(ArgumentList node) {
-    checkForArgumentTypesNotAssignableInList(node);
+    _checkForArgumentTypesNotAssignableInList(node);
     return super.visitArgumentList(node);
   }
 
   Object visitAssertStatement(AssertStatement node) {
-    checkForNonBoolExpression(node);
+    _checkForNonBoolExpression(node);
     return super.visitAssertStatement(node);
   }
 
   Object visitAssignmentExpression(AssignmentExpression node) {
     sc.Token operator = node.operator;
     sc.TokenType operatorType = operator.type;
     if (identical(operatorType, sc.TokenType.EQ)) {
-      checkForInvalidAssignment(node.leftHandSide, node.rightHandSide);
+      _checkForInvalidAssignment(node.leftHandSide, node.rightHandSide);
     } else {
-      checkForInvalidCompoundAssignment(node);
+      _checkForInvalidCompoundAssignment(node);
     }
-    checkForAssignmentToFinal(node.leftHandSide);
-    checkForArgumentTypeNotAssignableForArgument(node.rightHandSide);
+    _checkForAssignmentToFinal(node.leftHandSide);
+    _checkForArgumentTypeNotAssignableForArgument(node.rightHandSide);
     return super.visitAssignmentExpression(node);
   }
 
   Object visitBinaryExpression(BinaryExpression node) {
-    checkForArgumentTypeNotAssignableForArgument(node.rightOperand);
+    _checkForArgumentTypeNotAssignableForArgument(node.rightOperand);
     return super.visitBinaryExpression(node);
   }
 
   Object visitBlockFunctionBody(BlockFunctionBody node) {
     List<ReturnStatement> previousReturnsWith = _returnsWith;
     List<ReturnStatement> previousReturnsWithout = _returnsWithout;
     try {
       _returnsWith = new List<ReturnStatement>();
       _returnsWithout = new List<ReturnStatement>();
       super.visitBlockFunctionBody(node);
-      checkForMixedReturns(node);
+      _checkForMixedReturns(node);
     } finally {
       _returnsWith = previousReturnsWith;
       _returnsWithout = previousReturnsWithout;
     }
     return null;
   }
 
   Object visitBreakStatement(BreakStatement node) {
     SimpleIdentifier labelNode = node.label;
     if (labelNode != null) {
@@ skipping 16 matching lines @@
   }
 
   Object visitClassDeclaration(ClassDeclaration node) {
     ClassElement outerClass = _enclosingClass;
     try {
       _isInNativeClass = node.nativeClause != null;
       _enclosingClass = node.element;
       WithClause withClause = node.withClause;
       ImplementsClause implementsClause = node.implementsClause;
       ExtendsClause extendsClause = node.extendsClause;
-      checkForBuiltInIdentifierAsName(node.name, CompileTimeErrorCode.BUILT_IN_IDENTIFIER_AS_TYPE_NAME);
-      checkForMemberWithClassName();
-      checkForNoDefaultSuperConstructorImplicit(node);
-      checkForConflictingTypeVariableErrorCodes(node);
+      _checkForBuiltInIdentifierAsName(node.name, CompileTimeErrorCode.BUILT_IN_IDENTIFIER_AS_TYPE_NAME);
+      _checkForMemberWithClassName();
+      _checkForNoDefaultSuperConstructorImplicit(node);
+      _checkForConflictingTypeVariableErrorCodes(node);
       // Only do error checks on the clause nodes if there is a non-null clause
       if (implementsClause != null || extendsClause != null || withClause != null) {
         // Only check for all of the inheritance logic around clauses if there isn't an error code
         // such as "Cannot extend double" already on the class.
-        if (!checkForImplementsDisallowedClass(implementsClause) && !checkForExtendsDisallowedClass(extendsClause) && !checkForAllMixinErrorCodes(withClause)) {
-          checkForNonAbstractClassInheritsAbstractMember(node);
-          checkForInconsistentMethodInheritance();
-          checkForRecursiveInterfaceInheritance(_enclosingClass);
-          checkForConflictingGetterAndMethod();
-          checkForConflictingInstanceGetterAndSuperclassMember();
-          checkImplementsSuperClass(node);
-          checkImplementsFunctionWithoutCall(node);
+        if (!_checkForImplementsDisallowedClass(implementsClause) && !_checkForExtendsDisallowedClass(extendsClause) && !_checkForAllMixinErrorCodes(withClause)) {
+          _checkForNonAbstractClassInheritsAbstractMember(node);
+          _checkForInconsistentMethodInheritance();
+          _checkForRecursiveInterfaceInheritance(_enclosingClass);
+          _checkForConflictingGetterAndMethod();
+          _checkForConflictingInstanceGetterAndSuperclassMember();
+          _checkImplementsSuperClass(node);
+          _checkImplementsFunctionWithoutCall(node);
         }
       }
       // initialize initialFieldElementsMap
       ClassElement classElement = node.element;
       if (classElement != null) {
         List<FieldElement> fieldElements = classElement.fields;
         _initialFieldElementsMap = new Map<FieldElement, INIT_STATE>();
         for (FieldElement fieldElement in fieldElements) {
           if (!fieldElement.isSynthetic) {
             _initialFieldElementsMap[fieldElement] = fieldElement.initializer == null ? INIT_STATE.NOT_INIT : INIT_STATE.INIT_IN_DECLARATION;
           }
         }
       }
-      checkForFinalNotInitializedInClass(node);
-      checkForDuplicateDefinitionInheritance();
-      checkForConflictingInstanceMethodSetter(node);
+      _checkForFinalNotInitializedInClass(node);
+      _checkForDuplicateDefinitionInheritance();
+      _checkForConflictingInstanceMethodSetter(node);
       return super.visitClassDeclaration(node);
     } finally {
       _isInNativeClass = false;
       _initialFieldElementsMap = null;
       _enclosingClass = outerClass;
     }
   }
 
   Object visitClassTypeAlias(ClassTypeAlias node) {
-    checkForBuiltInIdentifierAsName(node.name, CompileTimeErrorCode.BUILT_IN_IDENTIFIER_AS_TYPEDEF_NAME);
-    checkForAllMixinErrorCodes(node.withClause);
+    _checkForBuiltInIdentifierAsName(node.name, CompileTimeErrorCode.BUILT_IN_IDENTIFIER_AS_TYPEDEF_NAME);
+    _checkForAllMixinErrorCodes(node.withClause);
     ClassElement outerClassElement = _enclosingClass;
     try {
       _enclosingClass = node.element;
-      checkForRecursiveInterfaceInheritance(node.element);
-      checkForTypeAliasCannotReferenceItself_mixin(node);
+      _checkForRecursiveInterfaceInheritance(node.element);
+      _checkForTypeAliasCannotReferenceItself_mixin(node);
     } finally {
       _enclosingClass = outerClassElement;
     }
     return super.visitClassTypeAlias(node);
   }
 
   Object visitComment(Comment node) {
     _isInComment = true;
     try {
       return super.visitComment(node);
     } finally {
       _isInComment = false;
     }
   }
 
   Object visitConditionalExpression(ConditionalExpression node) {
-    checkForNonBoolCondition(node.condition);
+    _checkForNonBoolCondition(node.condition);
     return super.visitConditionalExpression(node);
   }
 
   Object visitConstructorDeclaration(ConstructorDeclaration node) {
     ExecutableElement outerFunction = _enclosingFunction;
     try {
       _enclosingFunction = node.element;
       _isEnclosingConstructorConst = node.constKeyword != null;
-      checkForConstConstructorWithNonFinalField(node);
-      checkForConstConstructorWithNonConstSuper(node);
-      checkForConflictingConstructorNameAndMember(node);
-      checkForAllFinalInitializedErrorCodes(node);
-      checkForRedirectingConstructorErrorCodes(node);
-      checkForMultipleSuperInitializers(node);
-      checkForRecursiveConstructorRedirect(node);
-      if (!checkForRecursiveFactoryRedirect(node)) {
-        checkForAllRedirectConstructorErrorCodes(node);
+      _checkForConstConstructorWithNonFinalField(node);
+      _checkForConstConstructorWithNonConstSuper(node);
+      _checkForConflictingConstructorNameAndMember(node);
+      _checkForAllFinalInitializedErrorCodes(node);
+      _checkForRedirectingConstructorErrorCodes(node);
+      _checkForMultipleSuperInitializers(node);
+      _checkForRecursiveConstructorRedirect(node);
+      if (!_checkForRecursiveFactoryRedirect(node)) {
+        _checkForAllRedirectConstructorErrorCodes(node);
       }
-      checkForUndefinedConstructorInInitializerImplicit(node);
-      checkForRedirectToNonConstConstructor(node);
-      checkForReturnInGenerativeConstructor(node);
+      _checkForUndefinedConstructorInInitializerImplicit(node);
+      _checkForRedirectToNonConstConstructor(node);
+      _checkForReturnInGenerativeConstructor(node);
       return super.visitConstructorDeclaration(node);
     } finally {
       _isEnclosingConstructorConst = false;
       _enclosingFunction = outerFunction;
     }
   }
 
   Object visitConstructorFieldInitializer(ConstructorFieldInitializer node) {
     _isInConstructorInitializer = true;
     try {
-      checkForInvalidField(node);
-      checkForFieldInitializerNotAssignable(node);
+      _checkForInvalidField(node);
+      _checkForFieldInitializerNotAssignable(node);
       return super.visitConstructorFieldInitializer(node);
     } finally {
       _isInConstructorInitializer = false;
     }
   }
 
   Object visitContinueStatement(ContinueStatement node) {
     SimpleIdentifier labelNode = node.label;
     if (labelNode != null) {
       Element labelElement = labelNode.staticElement;
       if (labelElement is LabelElementImpl && labelElement.isOnSwitchStatement) {
         _errorReporter.reportErrorForNode(ResolverErrorCode.CONTINUE_LABEL_ON_SWITCH, labelNode, []);
       }
     }
     return null;
   }
 
   Object visitDefaultFormalParameter(DefaultFormalParameter node) {
-    checkForInvalidAssignment(node.identifier, node.defaultValue);
-    checkForDefaultValueInFunctionTypedParameter(node);
+    _checkForInvalidAssignment(node.identifier, node.defaultValue);
+    _checkForDefaultValueInFunctionTypedParameter(node);
     return super.visitDefaultFormalParameter(node);
   }
 
   Object visitDoStatement(DoStatement node) {
-    checkForNonBoolCondition(node.condition);
+    _checkForNonBoolCondition(node.condition);
     return super.visitDoStatement(node);
   }
 
   Object visitExportDirective(ExportDirective node) {
     ExportElement exportElement = node.element;
     if (exportElement != null) {
-      checkForAmbiguousExport(node, exportElement);
-      checkForExportDuplicateLibraryName(node, exportElement);
-      checkForExportInternalLibrary(node, exportElement);
+      _checkForAmbiguousExport(node, exportElement);
+      _checkForExportDuplicateLibraryName(node, exportElement);
+      _checkForExportInternalLibrary(node, exportElement);
     }
     return super.visitExportDirective(node);
   }
 
   Object visitExpressionFunctionBody(ExpressionFunctionBody node) {
     FunctionType functionType = _enclosingFunction == null ? null : _enclosingFunction.type;
     Type2 expectedReturnType = functionType == null ? DynamicTypeImpl.instance : functionType.returnType;
-    checkForReturnOfInvalidType(node.expression, expectedReturnType);
+    _checkForReturnOfInvalidType(node.expression, expectedReturnType);
     return super.visitExpressionFunctionBody(node);
   }
 
   Object visitFieldDeclaration(FieldDeclaration node) {
     _isInStaticVariableDeclaration = node.isStatic;
     _isInInstanceVariableDeclaration = !_isInStaticVariableDeclaration;
     if (_isInInstanceVariableDeclaration) {
       VariableDeclarationList variables = node.fields;
       if (variables.isConst) {
         _errorReporter.reportErrorForToken(CompileTimeErrorCode.CONST_INSTANCE_FIELD, variables.keyword, []);
       }
     }
     try {
-      checkForAllInvalidOverrideErrorCodesForField(node);
+      _checkForAllInvalidOverrideErrorCodesForField(node);
       return super.visitFieldDeclaration(node);
     } finally {
       _isInStaticVariableDeclaration = false;
       _isInInstanceVariableDeclaration = false;
     }
   }
 
   Object visitFieldFormalParameter(FieldFormalParameter node) {
-    checkForValidField(node);
-    checkForConstFormalParameter(node);
-    checkForPrivateOptionalParameter(node);
-    checkForFieldInitializingFormalRedirectingConstructor(node);
+    _checkForValidField(node);
+    _checkForConstFormalParameter(node);
+    _checkForPrivateOptionalParameter(node);
+    _checkForFieldInitializingFormalRedirectingConstructor(node);
     return super.visitFieldFormalParameter(node);
   }
 
   Object visitFunctionDeclaration(FunctionDeclaration node) {
     ExecutableElement outerFunction = _enclosingFunction;
     try {
       SimpleIdentifier identifier = node.name;
       String methodName = "";
       if (identifier != null) {
         methodName = identifier.name;
       }
       _enclosingFunction = node.element;
       if (node.isSetter || node.isGetter) {
-        checkForMismatchedAccessorTypes(node, methodName);
+        _checkForMismatchedAccessorTypes(node, methodName);
         if (node.isSetter) {
           FunctionExpression functionExpression = node.functionExpression;
           if (functionExpression != null) {
-            checkForWrongNumberOfParametersForSetter(node.name, functionExpression.parameters);
+            _checkForWrongNumberOfParametersForSetter(node.name, functionExpression.parameters);
           }
           TypeName returnType = node.returnType;
-          checkForNonVoidReturnTypeForSetter(returnType);
+          _checkForNonVoidReturnTypeForSetter(returnType);
         }
       }
       return super.visitFunctionDeclaration(node);
     } finally {
       _enclosingFunction = outerFunction;
     }
   }
 
   Object visitFunctionExpression(FunctionExpression node) {
     // If this function expression is wrapped in a function declaration, don't change the
     // enclosingFunction field.
     if (node.parent is! FunctionDeclaration) {
       ExecutableElement outerFunction = _enclosingFunction;
       try {
         _enclosingFunction = node.element;
         return super.visitFunctionExpression(node);
       } finally {
         _enclosingFunction = outerFunction;
       }
     } else {
       return super.visitFunctionExpression(node);
     }
   }
 
   Object visitFunctionExpressionInvocation(FunctionExpressionInvocation node) {
     Expression functionExpression = node.function;
     Type2 expressionType = functionExpression.staticType;
-    if (!isFunctionType(expressionType)) {
+    if (!_isFunctionType(expressionType)) {
       _errorReporter.reportErrorForNode(StaticTypeWarningCode.INVOCATION_OF_NON_FUNCTION_EXPRESSION, functionExpression, []);
     }
     return super.visitFunctionExpressionInvocation(node);
   }
 
   Object visitFunctionTypeAlias(FunctionTypeAlias node) {
-    checkForBuiltInIdentifierAsName(node.name, CompileTimeErrorCode.BUILT_IN_IDENTIFIER_AS_TYPEDEF_NAME);
-    checkForDefaultValueInFunctionTypeAlias(node);
-    checkForTypeAliasCannotReferenceItself_function(node);
+    _checkForBuiltInIdentifierAsName(node.name, CompileTimeErrorCode.BUILT_IN_IDENTIFIER_AS_TYPEDEF_NAME);
+    _checkForDefaultValueInFunctionTypeAlias(node);
+    _checkForTypeAliasCannotReferenceItself_function(node);
     return super.visitFunctionTypeAlias(node);
   }
 
   Object visitFunctionTypedFormalParameter(FunctionTypedFormalParameter node) {
     bool old = _isInFunctionTypedFormalParameter;
     _isInFunctionTypedFormalParameter = true;
     try {
       return super.visitFunctionTypedFormalParameter(node);
     } finally {
       _isInFunctionTypedFormalParameter = old;
     }
   }
 
   Object visitIfStatement(IfStatement node) {
-    checkForNonBoolCondition(node.condition);
+    _checkForNonBoolCondition(node.condition);
     return super.visitIfStatement(node);
   }
 
   Object visitImportDirective(ImportDirective node) {
     ImportElement importElement = node.element;
     if (importElement != null) {
-      checkForImportDuplicateLibraryName(node, importElement);
-      checkForImportInternalLibrary(node, importElement);
+      _checkForImportDuplicateLibraryName(node, importElement);
+      _checkForImportInternalLibrary(node, importElement);
     }
     return super.visitImportDirective(node);
   }
 
   Object visitIndexExpression(IndexExpression node) {
-    checkForArgumentTypeNotAssignableForArgument(node.index);
+    _checkForArgumentTypeNotAssignableForArgument(node.index);
     return super.visitIndexExpression(node);
   }
 
   Object visitInstanceCreationExpression(InstanceCreationExpression node) {
     _isInConstInstanceCreation = node.isConst;
     try {
       ConstructorName constructorName = node.constructorName;
       TypeName typeName = constructorName.type;
       Type2 type = typeName.type;
       if (type is InterfaceType) {
         InterfaceType interfaceType = type;
-        checkForConstOrNewWithAbstractClass(node, typeName, interfaceType);
+        _checkForConstOrNewWithAbstractClass(node, typeName, interfaceType);
         if (_isInConstInstanceCreation) {
-          checkForConstWithNonConst(node);
-          checkForConstWithUndefinedConstructor(node);
-          checkForConstWithTypeParametersInCreation(node);
+          _checkForConstWithNonConst(node);
+          _checkForConstWithUndefinedConstructor(node);
+          _checkForConstWithTypeParametersInCreation(node);
         } else {
-          checkForNewWithUndefinedConstructor(node);
+          _checkForNewWithUndefinedConstructor(node);
         }
       }
       return super.visitInstanceCreationExpression(node);
     } finally {
       _isInConstInstanceCreation = false;
     }
   }
 
   Object visitListLiteral(ListLiteral node) {
     if (node.constKeyword != null) {
       TypeArgumentList typeArguments = node.typeArguments;
       if (typeArguments != null) {
         NodeList<TypeName> arguments = typeArguments.arguments;
         if (arguments.length != 0) {
-          checkForInvalidTypeArgumentInConstTypedLiteral(arguments, CompileTimeErrorCode.INVALID_TYPE_ARGUMENT_IN_CONST_LIST);
+          _checkForInvalidTypeArgumentInConstTypedLiteral(arguments, CompileTimeErrorCode.INVALID_TYPE_ARGUMENT_IN_CONST_LIST);
         }
       }
     }
-    checkForExpectedOneListTypeArgument(node);
-    checkForListElementTypeNotAssignable(node);
+    _checkForExpectedOneListTypeArgument(node);
+    _checkForListElementTypeNotAssignable(node);
     return super.visitListLiteral(node);
   }
 
   Object visitMapLiteral(MapLiteral node) {
     TypeArgumentList typeArguments = node.typeArguments;
     if (typeArguments != null) {
       NodeList<TypeName> arguments = typeArguments.arguments;
       if (arguments.length != 0) {
         if (node.constKeyword != null) {
-          checkForInvalidTypeArgumentInConstTypedLiteral(arguments, CompileTimeErrorCode.INVALID_TYPE_ARGUMENT_IN_CONST_MAP);
+          _checkForInvalidTypeArgumentInConstTypedLiteral(arguments, CompileTimeErrorCode.INVALID_TYPE_ARGUMENT_IN_CONST_MAP);
         }
       }
     }
-    checkExpectedTwoMapTypeArguments(typeArguments);
-    checkForNonConstMapAsExpressionStatement(node);
-    checkForMapTypeNotAssignable(node);
-    checkForConstMapKeyExpressionTypeImplementsEquals(node);
+    _checkExpectedTwoMapTypeArguments(typeArguments);
+    _checkForNonConstMapAsExpressionStatement(node);
+    _checkForMapTypeNotAssignable(node);
+    _checkForConstMapKeyExpressionTypeImplementsEquals(node);
     return super.visitMapLiteral(node);
   }
 
   Object visitMethodDeclaration(MethodDeclaration node) {
     ExecutableElement previousFunction = _enclosingFunction;
     try {
       _isInStaticMethod = node.isStatic;
       _enclosingFunction = node.element;
       SimpleIdentifier identifier = node.name;
       String methodName = "";
       if (identifier != null) {
         methodName = identifier.name;
       }
       if (node.isSetter || node.isGetter) {
-        checkForMismatchedAccessorTypes(node, methodName);
+        _checkForMismatchedAccessorTypes(node, methodName);
       }
       if (node.isGetter) {
-        checkForConflictingStaticGetterAndInstanceSetter(node);
+        _checkForConflictingStaticGetterAndInstanceSetter(node);
       } else if (node.isSetter) {
-        checkForWrongNumberOfParametersForSetter(node.name, node.parameters);
-        checkForNonVoidReturnTypeForSetter(node.returnType);
-        checkForConflictingStaticSetterAndInstanceMember(node);
+        _checkForWrongNumberOfParametersForSetter(node.name, node.parameters);
+        _checkForNonVoidReturnTypeForSetter(node.returnType);
+        _checkForConflictingStaticSetterAndInstanceMember(node);
       } else if (node.isOperator) {
-        checkForOptionalParameterInOperator(node);
-        checkForWrongNumberOfParametersForOperator(node);
-        checkForNonVoidReturnTypeForOperator(node);
+        _checkForOptionalParameterInOperator(node);
+        _checkForWrongNumberOfParametersForOperator(node);
+        _checkForNonVoidReturnTypeForOperator(node);
       }
-      checkForConcreteClassWithAbstractMember(node);
-      checkForAllInvalidOverrideErrorCodesForMethod(node);
+      _checkForConcreteClassWithAbstractMember(node);
+      _checkForAllInvalidOverrideErrorCodesForMethod(node);
       return super.visitMethodDeclaration(node);
     } finally {
       _enclosingFunction = previousFunction;
       _isInStaticMethod = false;
     }
   }
 
   Object visitMethodInvocation(MethodInvocation node) {
     Expression target = node.realTarget;
     SimpleIdentifier methodName = node.methodName;
     if (target != null) {
       ClassElement typeReference = ElementResolver.getTypeReference(target);
-      checkForStaticAccessToInstanceMember(typeReference, methodName);
-      checkForInstanceAccessToStaticMember(typeReference, methodName);
+      _checkForStaticAccessToInstanceMember(typeReference, methodName);
+      _checkForInstanceAccessToStaticMember(typeReference, methodName);
     } else {
-      checkForUnqualifiedReferenceToNonLocalStaticMember(methodName);
+      _checkForUnqualifiedReferenceToNonLocalStaticMember(methodName);
     }
     return super.visitMethodInvocation(node);
   }
 
   Object visitNativeClause(NativeClause node) {
     // TODO(brianwilkerson) Figure out the right rule for when 'native' is allowed.
     if (!_isInSystemLibrary) {
       _errorReporter.reportErrorForNode(ParserErrorCode.NATIVE_CLAUSE_IN_NON_SDK_CODE, node, []);
     }
     return super.visitNativeClause(node);
   }
 
   Object visitNativeFunctionBody(NativeFunctionBody node) {
-    checkForNativeFunctionBodyInNonSDKCode(node);
+    _checkForNativeFunctionBodyInNonSDKCode(node);
     return super.visitNativeFunctionBody(node);
   }
 
   Object visitPostfixExpression(PostfixExpression node) {
-    checkForAssignmentToFinal(node.operand);
-    checkForIntNotAssignable(node.operand);
+    _checkForAssignmentToFinal(node.operand);
+    _checkForIntNotAssignable(node.operand);
     return super.visitPostfixExpression(node);
   }
 
   Object visitPrefixedIdentifier(PrefixedIdentifier node) {
     if (node.parent is! Annotation) {
       ClassElement typeReference = ElementResolver.getTypeReference(node.prefix);
       SimpleIdentifier name = node.identifier;
-      checkForStaticAccessToInstanceMember(typeReference, name);
-      checkForInstanceAccessToStaticMember(typeReference, name);
+      _checkForStaticAccessToInstanceMember(typeReference, name);
+      _checkForInstanceAccessToStaticMember(typeReference, name);
     }
     return super.visitPrefixedIdentifier(node);
   }
 
   Object visitPrefixExpression(PrefixExpression node) {
     sc.TokenType operatorType = node.operator.type;
     Expression operand = node.operand;
     if (identical(operatorType, sc.TokenType.BANG)) {
-      checkForNonBoolNegationExpression(operand);
+      _checkForNonBoolNegationExpression(operand);
     } else if (operatorType.isIncrementOperator) {
-      checkForAssignmentToFinal(operand);
+      _checkForAssignmentToFinal(operand);
     }
-    checkForIntNotAssignable(operand);
+    _checkForIntNotAssignable(operand);
     return super.visitPrefixExpression(node);
   }
 
   Object visitPropertyAccess(PropertyAccess node) {
     ClassElement typeReference = ElementResolver.getTypeReference(node.realTarget);
     SimpleIdentifier propertyName = node.propertyName;
-    checkForStaticAccessToInstanceMember(typeReference, propertyName);
-    checkForInstanceAccessToStaticMember(typeReference, propertyName);
+    _checkForStaticAccessToInstanceMember(typeReference, propertyName);
+    _checkForInstanceAccessToStaticMember(typeReference, propertyName);
     return super.visitPropertyAccess(node);
   }
 
   Object visitRedirectingConstructorInvocation(RedirectingConstructorInvocation node) {
     _isInConstructorInitializer = true;
     try {
       return super.visitRedirectingConstructorInvocation(node);
     } finally {
       _isInConstructorInitializer = false;
     }
   }
 
   Object visitRethrowExpression(RethrowExpression node) {
-    checkForRethrowOutsideCatch(node);
+    _checkForRethrowOutsideCatch(node);
     return super.visitRethrowExpression(node);
   }
 
   Object visitReturnStatement(ReturnStatement node) {
     if (node.expression == null) {
       _returnsWithout.add(node);
     } else {
       _returnsWith.add(node);
     }
-    checkForAllReturnStatementErrorCodes(node);
+    _checkForAllReturnStatementErrorCodes(node);
     return super.visitReturnStatement(node);
   }
 
   Object visitSimpleFormalParameter(SimpleFormalParameter node) {
-    checkForConstFormalParameter(node);
-    checkForPrivateOptionalParameter(node);
+    _checkForConstFormalParameter(node);
+    _checkForPrivateOptionalParameter(node);
     return super.visitSimpleFormalParameter(node);
   }
 
   Object visitSimpleIdentifier(SimpleIdentifier node) {
-    checkForImplicitThisReferenceInInitializer(node);
-    if (!isUnqualifiedReferenceToNonLocalStaticMemberAllowed(node)) {
-      checkForUnqualifiedReferenceToNonLocalStaticMember(node);
+    _checkForImplicitThisReferenceInInitializer(node);
+    if (!_isUnqualifiedReferenceToNonLocalStaticMemberAllowed(node)) {
+      _checkForUnqualifiedReferenceToNonLocalStaticMember(node);
     }
     return super.visitSimpleIdentifier(node);
   }
 
   Object visitSuperConstructorInvocation(SuperConstructorInvocation node) {
     _isInConstructorInitializer = true;
     try {
       return super.visitSuperConstructorInvocation(node);
     } finally {
       _isInConstructorInitializer = false;
     }
   }
 
   Object visitSwitchStatement(SwitchStatement node) {
-    checkForInconsistentCaseExpressionTypes(node);
-    checkForSwitchExpressionNotAssignable(node);
-    checkForCaseBlocksNotTerminated(node);
+    _checkForInconsistentCaseExpressionTypes(node);
+    _checkForSwitchExpressionNotAssignable(node);
+    _checkForCaseBlocksNotTerminated(node);
     return super.visitSwitchStatement(node);
   }
 
   Object visitThisExpression(ThisExpression node) {
-    checkForInvalidReferenceToThis(node);
+    _checkForInvalidReferenceToThis(node);
     return super.visitThisExpression(node);
   }
 
   Object visitThrowExpression(ThrowExpression node) {
-    checkForConstEvalThrowsException(node);
+    _checkForConstEvalThrowsException(node);
     return super.visitThrowExpression(node);
   }
 
   Object visitTopLevelVariableDeclaration(TopLevelVariableDeclaration node) {
-    checkForFinalNotInitialized(node.variables);
+    _checkForFinalNotInitialized(node.variables);
     return super.visitTopLevelVariableDeclaration(node);
   }
 
   Object visitTypeName(TypeName node) {
-    checkForTypeArgumentNotMatchingBounds(node);
-    checkForTypeParameterReferencedByStatic(node);
+    _checkForTypeArgumentNotMatchingBounds(node);
+    _checkForTypeParameterReferencedByStatic(node);
     return super.visitTypeName(node);
   }
 
   Object visitTypeParameter(TypeParameter node) {
-    checkForBuiltInIdentifierAsName(node.name, CompileTimeErrorCode.BUILT_IN_IDENTIFIER_AS_TYPE_PARAMETER_NAME);
-    checkForTypeParameterSupertypeOfItsBound(node);
+    _checkForBuiltInIdentifierAsName(node.name, CompileTimeErrorCode.BUILT_IN_IDENTIFIER_AS_TYPE_PARAMETER_NAME);
+    _checkForTypeParameterSupertypeOfItsBound(node);
     return super.visitTypeParameter(node);
   }
 
   Object visitVariableDeclaration(VariableDeclaration node) {
     SimpleIdentifier nameNode = node.name;
     Expression initializerNode = node.initializer;
     // do checks
-    checkForInvalidAssignment(nameNode, initializerNode);
+    _checkForInvalidAssignment(nameNode, initializerNode);
     // visit name
     nameNode.accept(this);
     // visit initializer
     String name = nameNode.name;
     _namesForReferenceToDeclaredVariableInInitializer.add(name);
     _isInInstanceVariableInitializer = _isInInstanceVariableDeclaration;
     try {
       if (initializerNode != null) {
         initializerNode.accept(this);
       }
     } finally {
       _isInInstanceVariableInitializer = false;
       _namesForReferenceToDeclaredVariableInInitializer.remove(name);
     }
     // done
     return null;
   }
 
   Object visitVariableDeclarationList(VariableDeclarationList node) => super.visitVariableDeclarationList(node);
 
   Object visitVariableDeclarationStatement(VariableDeclarationStatement node) {
-    checkForFinalNotInitialized(node.variables);
+    _checkForFinalNotInitialized(node.variables);
     return super.visitVariableDeclarationStatement(node);
   }
 
   Object visitWhileStatement(WhileStatement node) {
-    checkForNonBoolCondition(node.condition);
+    _checkForNonBoolCondition(node.condition);
     return super.visitWhileStatement(node);
   }
 
   /**
    * This verifies if the passed map literal has type arguments then there is exactly two.
    *
    * @param node the map literal to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * @see StaticTypeWarningCode#EXPECTED_TWO_MAP_TYPE_ARGUMENTS
    */
-  bool checkExpectedTwoMapTypeArguments(TypeArgumentList typeArguments) {
+  bool _checkExpectedTwoMapTypeArguments(TypeArgumentList typeArguments) {
     // has type arguments
     if (typeArguments == null) {
       return false;
     }
     // check number of type arguments
     int num = typeArguments.arguments.length;
     if (num == 2) {
       return false;
     }
     // report problem
     _errorReporter.reportErrorForNode(StaticTypeWarningCode.EXPECTED_TWO_MAP_TYPE_ARGUMENTS, typeArguments, [num]);
     return true;
   }
 
   /**
    * This verifies that the passed constructor declaration does not violate any of the error codes
    * relating to the initialization of fields in the enclosing class.
    *
    * @param node the [ConstructorDeclaration] to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * @see #initialFieldElementsMap
    * @see CompileTimeErrorCode#FINAL_INITIALIZED_IN_DECLARATION_AND_CONSTRUCTOR
    * @see CompileTimeErrorCode#FINAL_INITIALIZED_MULTIPLE_TIMES
    */
-  bool checkForAllFinalInitializedErrorCodes(ConstructorDeclaration node) {
+  bool _checkForAllFinalInitializedErrorCodes(ConstructorDeclaration node) {
     if (node.factoryKeyword != null || node.redirectedConstructor != null || node.externalKeyword != null) {
       return false;
     }
     // Ignore if native class.
     if (_isInNativeClass) {
       return false;
     }
     bool foundError = false;
     Map<FieldElement, INIT_STATE> fieldElementsMap = new Map<FieldElement, INIT_STATE>.from(_initialFieldElementsMap);
     // Visit all of the field formal parameters
@@ skipping 80 matching lines @@
    * @see CompileTimeErrorCode#INVALID_OVERRIDE_POSITIONAL
    * @see CompileTimeErrorCode#INVALID_OVERRIDE_NAMED
    * @see StaticWarningCode#INVALID_GETTER_OVERRIDE_RETURN_TYPE
    * @see StaticWarningCode#INVALID_METHOD_OVERRIDE_RETURN_TYPE
    * @see StaticWarningCode#INVALID_METHOD_OVERRIDE_NORMAL_PARAM_TYPE
    * @see StaticWarningCode#INVALID_SETTER_OVERRIDE_NORMAL_PARAM_TYPE
    * @see StaticWarningCode#INVALID_METHOD_OVERRIDE_OPTIONAL_PARAM_TYPE
    * @see StaticWarningCode#INVALID_METHOD_OVERRIDE_NAMED_PARAM_TYPE
    * @see StaticWarningCode#INVALID_OVERRIDE_DIFFERENT_DEFAULT_VALUES
    */
-  bool checkForAllInvalidOverrideErrorCodes(ExecutableElement executableElement, ExecutableElement overriddenExecutable, List<ParameterElement> parameters, List<AstNode> parameterLocations, SimpleIdentifier errorNameTarget) {
+  bool _checkForAllInvalidOverrideErrorCodes(ExecutableElement executableElement, ExecutableElement overriddenExecutable, List<ParameterElement> parameters, List<AstNode> parameterLocations, SimpleIdentifier errorNameTarget) {
     bool isGetter = false;
     bool isSetter = false;
     if (executableElement is PropertyAccessorElement) {
       PropertyAccessorElement accessorElement = executableElement;
       isGetter = accessorElement.isGetter;
       isSetter = accessorElement.isSetter;
     }
     String executableElementName = executableElement.name;
     // SWC.INSTANCE_METHOD_NAME_COLLIDES_WITH_SUPERCLASS_STATIC
     if (overriddenExecutable == null) {
@@ skipping 186 matching lines @@
     // Next compare the list of optional parameter elements to the list of overridden optional
     // parameter elements.
     //
     if (parameterElts.length > 0) {
       if (identical(parameterElts[0].parameterKind, ParameterKind.NAMED)) {
         // Named parameters, consider the names when matching the parameterElts to the overriddenParameterElts
         for (int i = 0; i < parameterElts.length; i++) {
           ParameterElementImpl parameterElt = parameterElts[i];
           EvaluationResultImpl result = parameterElt.evaluationResult;
           // TODO (jwren) Ignore Object types, see Dart bug 11287
-          if (isUserDefinedObject(result)) {
+          if (_isUserDefinedObject(result)) {
             continue;
           }
           String parameterName = parameterElt.name;
           for (int j = 0; j < overriddenParameterElts.length; j++) {
             ParameterElementImpl overriddenParameterElt = overriddenParameterElts[j];
             String overriddenParameterName = overriddenParameterElt.name;
             if (parameterName != null && parameterName == overriddenParameterName) {
               EvaluationResultImpl overriddenResult = overriddenParameterElt.evaluationResult;
-              if (isUserDefinedObject(overriddenResult)) {
+              if (_isUserDefinedObject(overriddenResult)) {
                 break;
               }
               if (!result.equalValues(_typeProvider, overriddenResult)) {
                 _errorReporter.reportErrorForNode(StaticWarningCode.INVALID_OVERRIDE_DIFFERENT_DEFAULT_VALUES_NAMED, formalParameters[i], [
                     overriddenExecutable.enclosingElement.displayName,
                     overriddenExecutable.displayName,
                     parameterName]);
                 foundError = true;
               }
             }
           }
         }
       } else {
         // Positional parameters, consider the positions when matching the parameterElts to the overriddenParameterElts
         for (int i = 0; i < parameterElts.length && i < overriddenParameterElts.length; i++) {
           ParameterElementImpl parameterElt = parameterElts[i];
           EvaluationResultImpl result = parameterElt.evaluationResult;
           // TODO (jwren) Ignore Object types, see Dart bug 11287
-          if (isUserDefinedObject(result)) {
+          if (_isUserDefinedObject(result)) {
             continue;
           }
           ParameterElementImpl overriddenParameterElt = overriddenParameterElts[i];
           EvaluationResultImpl overriddenResult = overriddenParameterElt.evaluationResult;
-          if (isUserDefinedObject(overriddenResult)) {
+          if (_isUserDefinedObject(overriddenResult)) {
             continue;
           }
           if (!result.equalValues(_typeProvider, overriddenResult)) {
             _errorReporter.reportErrorForNode(StaticWarningCode.INVALID_OVERRIDE_DIFFERENT_DEFAULT_VALUES_POSITIONAL, formalParameters[i], [
                 overriddenExecutable.enclosingElement.displayName,
                 overriddenExecutable.displayName]);
             foundError = true;
           }
         }
       }
     }
     return foundError;
   }
 
   /**
    * This checks the passed executable element against override-error codes. This method computes
    * the passed executableElement is overriding and calls
    * [checkForAllInvalidOverrideErrorCodes]
    * when the [InheritanceManager] returns a [MultiplyInheritedExecutableElement], this
    * method loops through the array in the [MultiplyInheritedExecutableElement].
    *
    * @param executableElement a non-null [ExecutableElement] to evaluate
    * @param parameters the parameters of the executable element
    * @param errorNameTarget the node to report problems on
    * @return `true` if and only if an error code is generated on the passed node
    */
-  bool checkForAllInvalidOverrideErrorCodesForExecutable(ExecutableElement executableElement, List<ParameterElement> parameters, List<AstNode> parameterLocations, SimpleIdentifier errorNameTarget) {
+  bool _checkForAllInvalidOverrideErrorCodesForExecutable(ExecutableElement executableElement, List<ParameterElement> parameters, List<AstNode> parameterLocations, SimpleIdentifier errorNameTarget) {
     //
     // Compute the overridden executable from the InheritanceManager
     //
     ExecutableElement overriddenExecutable = _inheritanceManager.lookupInheritance(_enclosingClass, executableElement.name);
     //
     // If the result is a MultiplyInheritedExecutableElement call
     // checkForAllInvalidOverrideErrorCodes on all of the elements, until an error is found.
     //
     if (overriddenExecutable is MultiplyInheritedExecutableElement) {
       MultiplyInheritedExecutableElement multiplyInheritedElement = overriddenExecutable;
       List<ExecutableElement> overriddenElement = multiplyInheritedElement.inheritedElements;
       for (int i = 0; i < overriddenElement.length; i++) {
-        if (checkForAllInvalidOverrideErrorCodes(executableElement, overriddenElement[i], parameters, parameterLocations, errorNameTarget)) {
+        if (_checkForAllInvalidOverrideErrorCodes(executableElement, overriddenElement[i], parameters, parameterLocations, errorNameTarget)) {
           return true;
         }
       }
       return false;
     }
     //
     // Otherwise, just call checkForAllInvalidOverrideErrorCodes.
     //
-    return checkForAllInvalidOverrideErrorCodes(executableElement, overriddenExecutable, parameters, parameterLocations, errorNameTarget);
+    return _checkForAllInvalidOverrideErrorCodes(executableElement, overriddenExecutable, parameters, parameterLocations, errorNameTarget);
   }
 
   /**
    * This checks the passed field declaration against override-error codes.
    *
    * @param node the [MethodDeclaration] to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * @see #checkForAllInvalidOverrideErrorCodes(ExecutableElement)
    */
-  bool checkForAllInvalidOverrideErrorCodesForField(FieldDeclaration node) {
+  bool _checkForAllInvalidOverrideErrorCodesForField(FieldDeclaration node) {
     if (_enclosingClass == null || node.isStatic) {
       return false;
     }
     bool hasProblems = false;
     VariableDeclarationList fields = node.fields;
     for (VariableDeclaration field in fields.variables) {
       FieldElement element = field.element as FieldElement;
       if (element == null) {
         continue;
       }
       PropertyAccessorElement getter = element.getter;
       PropertyAccessorElement setter = element.setter;
       SimpleIdentifier fieldName = field.name;
       if (getter != null) {
-        hasProblems = javaBooleanOr(hasProblems, checkForAllInvalidOverrideErrorCodesForExecutable(getter, ParameterElementImpl.EMPTY_ARRAY, AstNode.EMPTY_ARRAY, fieldName));
+        hasProblems = javaBooleanOr(hasProblems, _checkForAllInvalidOverrideErrorCodesForExecutable(getter, ParameterElementImpl.EMPTY_ARRAY, AstNode.EMPTY_ARRAY, fieldName));
       }
       if (setter != null) {
-        hasProblems = javaBooleanOr(hasProblems, checkForAllInvalidOverrideErrorCodesForExecutable(setter, setter.parameters, <AstNode> [fieldName], fieldName));
+        hasProblems = javaBooleanOr(hasProblems, _checkForAllInvalidOverrideErrorCodesForExecutable(setter, setter.parameters, <AstNode> [fieldName], fieldName));
       }
     }
     return hasProblems;
   }
 
   /**
    * This checks the passed method declaration against override-error codes.
    *
    * @param node the [MethodDeclaration] to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * @see #checkForAllInvalidOverrideErrorCodes(ExecutableElement)
    */
-  bool checkForAllInvalidOverrideErrorCodesForMethod(MethodDeclaration node) {
+  bool _checkForAllInvalidOverrideErrorCodesForMethod(MethodDeclaration node) {
     if (_enclosingClass == null || node.isStatic || node.body is NativeFunctionBody) {
       return false;
     }
     ExecutableElement executableElement = node.element;
     if (executableElement == null) {
       return false;
     }
     SimpleIdentifier methodName = node.name;
     if (methodName.isSynthetic) {
       return false;
     }
     FormalParameterList formalParameterList = node.parameters;
     NodeList<FormalParameter> parameterList = formalParameterList != null ? formalParameterList.parameters : null;
     List<AstNode> parameters = parameterList != null ? new List.from(parameterList) : null;
-    return checkForAllInvalidOverrideErrorCodesForExecutable(executableElement, executableElement.parameters, parameters, methodName);
+    return _checkForAllInvalidOverrideErrorCodesForExecutable(executableElement, executableElement.parameters, parameters, methodName);
   }
 
   /**
    * This verifies that all classes of the passed 'with' clause are valid.
    *
    * @param node the 'with' clause to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#MIXIN_DECLARES_CONSTRUCTOR
    * @see CompileTimeErrorCode#MIXIN_INHERITS_FROM_NOT_OBJECT
    * @see CompileTimeErrorCode#MIXIN_REFERENCES_SUPER
    */
-  bool checkForAllMixinErrorCodes(WithClause withClause) {
+  bool _checkForAllMixinErrorCodes(WithClause withClause) {
     if (withClause == null) {
       return false;
     }
     bool problemReported = false;
     for (TypeName mixinName in withClause.mixinTypes) {
       Type2 mixinType = mixinName.type;
       if (mixinType is! InterfaceType) {
         continue;
       }
-      if (checkForExtendsOrImplementsDisallowedClass(mixinName, CompileTimeErrorCode.MIXIN_OF_DISALLOWED_CLASS)) {
+      if (_checkForExtendsOrImplementsDisallowedClass(mixinName, CompileTimeErrorCode.MIXIN_OF_DISALLOWED_CLASS)) {
         problemReported = true;
       } else {
         ClassElement mixinElement = (mixinType as InterfaceType).element;
-        problemReported = javaBooleanOr(problemReported, checkForMixinDeclaresConstructor(mixinName, mixinElement));
-        problemReported = javaBooleanOr(problemReported, checkForMixinInheritsNotFromObject(mixinName, mixinElement));
-        problemReported = javaBooleanOr(problemReported, checkForMixinReferencesSuper(mixinName, mixinElement));
+        problemReported = javaBooleanOr(problemReported, _checkForMixinDeclaresConstructor(mixinName, mixinElement));
+        problemReported = javaBooleanOr(problemReported, _checkForMixinInheritsNotFromObject(mixinName, mixinElement));
+        problemReported = javaBooleanOr(problemReported, _checkForMixinReferencesSuper(mixinName, mixinElement));
       }
     }
     return problemReported;
   }
 
   /**
    * This checks error related to the redirected constructors.
    *
    * @param node the constructor declaration to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * @see StaticWarningCode#REDIRECT_TO_INVALID_RETURN_TYPE
    * @see StaticWarningCode#REDIRECT_TO_INVALID_FUNCTION_TYPE
    * @see StaticWarningCode#REDIRECT_TO_MISSING_CONSTRUCTOR
    */
-  bool checkForAllRedirectConstructorErrorCodes(ConstructorDeclaration node) {
+  bool _checkForAllRedirectConstructorErrorCodes(ConstructorDeclaration node) {
     //
     // Prepare redirected constructor node
     //
     ConstructorName redirectedConstructor = node.redirectedConstructor;
     if (redirectedConstructor == null) {
       return false;
     }
     //
     // Prepare redirected constructor type
     //
@@ skipping 49 matching lines @@
    *
    * This checks that the return type matches the type of the declared return type in the enclosing
    * method or function.
    *
    * @param node the return statement to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#RETURN_IN_GENERATIVE_CONSTRUCTOR
    * @see StaticWarningCode#RETURN_WITHOUT_VALUE
    * @see StaticTypeWarningCode#RETURN_OF_INVALID_TYPE
    */
-  bool checkForAllReturnStatementErrorCodes(ReturnStatement node) {
+  bool _checkForAllReturnStatementErrorCodes(ReturnStatement node) {
     FunctionType functionType = _enclosingFunction == null ? null : _enclosingFunction.type;
     Type2 expectedReturnType = functionType == null ? DynamicTypeImpl.instance : functionType.returnType;
     Expression returnExpression = node.expression;
     // RETURN_IN_GENERATIVE_CONSTRUCTOR
     bool isGenerativeConstructor = _enclosingFunction is ConstructorElement && !(_enclosingFunction as ConstructorElement).isFactory;
     if (isGenerativeConstructor) {
       if (returnExpression == null) {
         return false;
       }
       _errorReporter.reportErrorForNode(CompileTimeErrorCode.RETURN_IN_GENERATIVE_CONSTRUCTOR, returnExpression, []);
       return true;
     }
     // RETURN_WITHOUT_VALUE
     if (returnExpression == null) {
       if (VoidTypeImpl.instance.isAssignableTo(expectedReturnType)) {
         return false;
       }
       _errorReporter.reportErrorForNode(StaticWarningCode.RETURN_WITHOUT_VALUE, node, []);
       return true;
     }
     // RETURN_OF_INVALID_TYPE
-    return checkForReturnOfInvalidType(returnExpression, expectedReturnType);
+    return _checkForReturnOfInvalidType(returnExpression, expectedReturnType);
   }
 
   /**
    * This verifies that the export namespace of the passed export directive does not export any name
    * already exported by other export directive.
    *
    * @param node the export directive node to report problem on
    * @param exportElement the [ExportElement] retrieved from the node, if the element in the
    *          node was `null`, then this method is not called
    * @return `true` if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#AMBIGUOUS_EXPORT
    */
-  bool checkForAmbiguousExport(ExportDirective node, ExportElement exportElement) {
+  bool _checkForAmbiguousExport(ExportDirective node, ExportElement exportElement) {
     // prepare exported library
     LibraryElement exportedLibrary = exportElement.exportedLibrary;
     if (exportedLibrary == null) {
       return false;
     }
     // check exported names
     Namespace namespace = new NamespaceBuilder().createExportNamespaceForDirective(exportElement);
     Map<String, Element> definedNames = namespace.definedNames;
     for (MapEntry<String, Element> definedEntry in getMapEntrySet(definedNames)) {
       String name = definedEntry.getKey();
@@ skipping 17 matching lines @@
    *
    * @param expression the expression to evaluate
    * @param expectedStaticType the expected static type of the parameter
    * @param actualStaticType the actual static type of the argument
    * @param expectedPropagatedType the expected propagated type of the parameter, may be
    *          `null`
    * @param actualPropagatedType the expected propagated type of the parameter, may be `null`
    * @return `true` if and only if an error code is generated on the passed node
    * @see StaticWarningCode#ARGUMENT_TYPE_NOT_ASSIGNABLE
    */
-  bool checkForArgumentTypeNotAssignable(Expression expression, Type2 expectedStaticType, Type2 actualStaticType, Type2 expectedPropagatedType, Type2 actualPropagatedType, ErrorCode errorCode) {
+  bool _checkForArgumentTypeNotAssignable(Expression expression, Type2 expectedStaticType, Type2 actualStaticType, Type2 expectedPropagatedType, Type2 actualPropagatedType, ErrorCode errorCode) {
     //
     // Test static type information
     //
     if (actualStaticType == null || expectedStaticType == null) {
       return false;
     }
     if (actualStaticType.isAssignableTo(expectedStaticType)) {
       return false;
     }
     _errorReporter.reportErrorForNode(errorCode, expression, [
         actualStaticType.displayName,
         expectedStaticType.displayName]);
     return true;
   }
 
   /**
    * This verifies that the passed argument can be assigned to its corresponding parameter.
    *
    * @param argument the argument to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * @see StaticWarningCode#ARGUMENT_TYPE_NOT_ASSIGNABLE
    */
-  bool checkForArgumentTypeNotAssignableForArgument(Expression argument) {
+  bool _checkForArgumentTypeNotAssignableForArgument(Expression argument) {
     if (argument == null) {
       return false;
     }
     ParameterElement staticParameterElement = argument.staticParameterElement;
     Type2 staticParameterType = staticParameterElement == null ? null : staticParameterElement.type;
     ParameterElement propagatedParameterElement = argument.propagatedParameterElement;
     Type2 propagatedParameterType = propagatedParameterElement == null ? null : propagatedParameterElement.type;
-    return checkForArgumentTypeNotAssignableWithExpectedTypes(argument, staticParameterType, propagatedParameterType, StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE);
+    return _checkForArgumentTypeNotAssignableWithExpectedTypes(argument, staticParameterType, propagatedParameterType, StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE);
   }
 
   /**
    * This verifies that the passed expression can be assigned to its corresponding parameters.
    *
    * @param expression the expression to evaluate
    * @param expectedStaticType the expected static type
    * @param expectedPropagatedType the expected propagated type, may be `null`
    * @return `true` if and only if an error code is generated on the passed node
    * @see StaticWarningCode#ARGUMENT_TYPE_NOT_ASSIGNABLE
    */
-  bool checkForArgumentTypeNotAssignableWithExpectedTypes(Expression expression, Type2 expectedStaticType, Type2 expectedPropagatedType, ErrorCode errorCode) => checkForArgumentTypeNotAssignable(expression, expectedStaticType, getStaticType(expression), expectedPropagatedType, expression.propagatedType, errorCode);
+  bool _checkForArgumentTypeNotAssignableWithExpectedTypes(Expression expression, Type2 expectedStaticType, Type2 expectedPropagatedType, ErrorCode errorCode) => _checkForArgumentTypeNotAssignable(expression, expectedStaticType, _getStaticType(expression), expectedPropagatedType, expression.propagatedType, errorCode);
 
   /**
    * This verifies that the passed arguments can be assigned to their corresponding parameters.
    *
    * @param node the arguments to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * @see StaticWarningCode#ARGUMENT_TYPE_NOT_ASSIGNABLE
    */
-  bool checkForArgumentTypesNotAssignableInList(ArgumentList argumentList) {
+  bool _checkForArgumentTypesNotAssignableInList(ArgumentList argumentList) {
     if (argumentList == null) {
       return false;
     }
     bool problemReported = false;
     for (Expression argument in argumentList.arguments) {
-      problemReported = javaBooleanOr(problemReported, checkForArgumentTypeNotAssignableForArgument(argument));
+      problemReported = javaBooleanOr(problemReported, _checkForArgumentTypeNotAssignableForArgument(argument));
     }
     // done
     return problemReported;
   }
 
   /**
    * This verifies that the passed expression is not final.
    *
    * @param node the expression to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * @see StaticWarningCode#ASSIGNMENT_TO_CONST
    * @see StaticWarningCode#ASSIGNMENT_TO_FINAL
    * @see StaticWarningCode#ASSIGNMENT_TO_METHOD
    */
-  bool checkForAssignmentToFinal(Expression expression) {
+  bool _checkForAssignmentToFinal(Expression expression) {
     // prepare element
     Element element = null;
     if (expression is Identifier) {
       element = expression.staticElement;
     }
     if (expression is PropertyAccess) {
       element = expression.propertyName.staticElement;
     }
     // check if element is assignable
     if (element is PropertyAccessorElement) {
@@ skipping 27 matching lines @@
    * @param errorCode if the passed identifier is a keyword then this error code is created on the
    *          identifier, the error code will be one of
    *          [CompileTimeErrorCode#BUILT_IN_IDENTIFIER_AS_TYPE_NAME],
    *          [CompileTimeErrorCode#BUILT_IN_IDENTIFIER_AS_TYPE_PARAMETER_NAME] or
    *          [CompileTimeErrorCode#BUILT_IN_IDENTIFIER_AS_TYPEDEF_NAME]
    * @return `true` if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#BUILT_IN_IDENTIFIER_AS_TYPE_NAME
    * @see CompileTimeErrorCode#BUILT_IN_IDENTIFIER_AS_TYPE_PARAMETER_NAME
    * @see CompileTimeErrorCode#BUILT_IN_IDENTIFIER_AS_TYPEDEF_NAME
    */
-  bool checkForBuiltInIdentifierAsName(SimpleIdentifier identifier, ErrorCode errorCode) {
+  bool _checkForBuiltInIdentifierAsName(SimpleIdentifier identifier, ErrorCode errorCode) {
     sc.Token token = identifier.token;
     if (identical(token.type, sc.TokenType.KEYWORD)) {
       _errorReporter.reportErrorForNode(errorCode, identifier, [identifier.name]);
       return true;
     }
     return false;
   }
 
   /**
    * This verifies that the given switch case is terminated with 'break', 'continue', 'return' or
    * 'throw'.
    *
    * @param node the switch case to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * @see StaticWarningCode#CASE_BLOCK_NOT_TERMINATED
    */
-  bool checkForCaseBlockNotTerminated(SwitchCase node) {
+  bool _checkForCaseBlockNotTerminated(SwitchCase node) {
     NodeList<Statement> statements = node.statements;
     if (statements.isEmpty) {
       // fall-through without statements at all
       AstNode parent = node.parent;
       if (parent is SwitchStatement) {
         SwitchStatement switchStatement = parent;
         NodeList<SwitchMember> members = switchStatement.members;
         int index = members.indexOf(node);
         if (index != -1 && index < members.length - 1) {
           return false;
@@ skipping 19 matching lines @@
   }
 
   /**
    * This verifies that the switch cases in the given switch statement is terminated with 'break',
    * 'continue', 'return' or 'throw'.
    *
    * @param node the switch statement containing the cases to be checked
    * @return `true` if and only if an error code is generated on the passed node
    * @see StaticWarningCode#CASE_BLOCK_NOT_TERMINATED
    */
-  bool checkForCaseBlocksNotTerminated(SwitchStatement node) {
+  bool _checkForCaseBlocksNotTerminated(SwitchStatement node) {
     bool foundError = false;
     NodeList<SwitchMember> members = node.members;
     int lastMember = members.length - 1;
     for (int i = 0; i < lastMember; i++) {
       SwitchMember member = members[i];
       if (member is SwitchCase) {
-        foundError = javaBooleanOr(foundError, checkForCaseBlockNotTerminated(member));
+        foundError = javaBooleanOr(foundError, _checkForCaseBlockNotTerminated(member));
       }
     }
     return foundError;
   }
 
   /**
    * This verifies that the passed switch statement does not have a case expression with the
    * operator '==' overridden.
    *
    * @param node the switch statement to evaluate
    * @param type the common type of all 'case' expressions
    * @return `true` if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#CASE_EXPRESSION_TYPE_IMPLEMENTS_EQUALS
    */
-  bool checkForCaseExpressionTypeImplementsEquals(SwitchStatement node, Type2 type) {
-    if (!implementsEqualsWhenNotAllowed(type)) {
+  bool _checkForCaseExpressionTypeImplementsEquals(SwitchStatement node, Type2 type) {
+    if (!_implementsEqualsWhenNotAllowed(type)) {
       return false;
     }
     // report error
     _errorReporter.reportErrorForToken(CompileTimeErrorCode.CASE_EXPRESSION_TYPE_IMPLEMENTS_EQUALS, node.keyword, [type.displayName]);
     return true;
   }
 
   /**
    * This verifies that the passed method declaration is abstract only if the enclosing class is
    * also abstract.
    *
    * @param node the method declaration to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * @see StaticWarningCode#CONCRETE_CLASS_WITH_ABSTRACT_MEMBER
    */
-  bool checkForConcreteClassWithAbstractMember(MethodDeclaration node) {
+  bool _checkForConcreteClassWithAbstractMember(MethodDeclaration node) {
     if (node.isAbstract && _enclosingClass != null && !_enclosingClass.isAbstract) {
       SimpleIdentifier methodName = node.name;
       _errorReporter.reportErrorForNode(StaticWarningCode.CONCRETE_CLASS_WITH_ABSTRACT_MEMBER, methodName, [methodName.name, _enclosingClass.displayName]);
       return true;
     }
     return false;
   }
 
   /**
    * This verifies all possible conflicts of the constructor name with other constructors and
    * members of the same class.
    *
    * @param node the constructor declaration to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#DUPLICATE_CONSTRUCTOR_DEFAULT
    * @see CompileTimeErrorCode#DUPLICATE_CONSTRUCTOR_NAME
    * @see CompileTimeErrorCode#CONFLICTING_CONSTRUCTOR_NAME_AND_FIELD
    * @see CompileTimeErrorCode#CONFLICTING_CONSTRUCTOR_NAME_AND_METHOD
    */
-  bool checkForConflictingConstructorNameAndMember(ConstructorDeclaration node) {
+  bool _checkForConflictingConstructorNameAndMember(ConstructorDeclaration node) {
     ConstructorElement constructorElement = node.element;
     SimpleIdentifier constructorName = node.name;
     String name = constructorElement.name;
     ClassElement classElement = constructorElement.enclosingElement;
     // constructors
     List<ConstructorElement> constructors = classElement.constructors;
     for (ConstructorElement otherConstructor in constructors) {
       if (identical(otherConstructor, constructorElement)) {
         continue;
       }
@@ skipping 25 matching lines @@
   }
 
   /**
    * This verifies that the [enclosingClass] does not have a method and getter pair with the
    * same name on, via inheritance.
    *
    * @return `true` if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#CONFLICTING_GETTER_AND_METHOD
    * @see CompileTimeErrorCode#CONFLICTING_METHOD_AND_GETTER
    */
-  bool checkForConflictingGetterAndMethod() {
+  bool _checkForConflictingGetterAndMethod() {
     if (_enclosingClass == null) {
       return false;
     }
     bool hasProblem = false;
     // method declared in the enclosing class vs. inherited getter
     for (MethodElement method in _enclosingClass.methods) {
       String name = method.name;
       // find inherited property accessor (and can be only getter)
       ExecutableElement inherited = _inheritanceManager.lookupInheritance(_enclosingClass, name);
       if (inherited is! PropertyAccessorElement) {
@@ skipping 31 matching lines @@
   /**
    * This verifies that the superclass of the [enclosingClass] does not declare accessible
    * static members with the same name as the instance getters/setters declared in
    * [enclosingClass].
    *
    * @param node the method declaration to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * @see StaticWarningCode#CONFLICTING_INSTANCE_GETTER_AND_SUPERCLASS_MEMBER
    * @see StaticWarningCode#CONFLICTING_INSTANCE_SETTER_AND_SUPERCLASS_MEMBER
    */
-  bool checkForConflictingInstanceGetterAndSuperclassMember() {
+  bool _checkForConflictingInstanceGetterAndSuperclassMember() {
     if (_enclosingClass == null) {
       return false;
     }
     InterfaceType enclosingType = _enclosingClass.type;
     // check every accessor
     bool hasProblem = false;
     for (PropertyAccessorElement accessor in _enclosingClass.accessors) {
       // we analyze instance accessors here
       if (accessor.isStatic) {
         continue;
@@ skipping 39 matching lines @@
   /**
    * This verifies that the enclosing class does not have a setter with the same name as the passed
    * instance method declaration.
    *
    * TODO(jwren) add other "conflicting" error codes into algorithm/ data structure
    *
    * @param node the method declaration to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * @see StaticWarningCode#CONFLICTING_INSTANCE_METHOD_SETTER
    */
-  bool checkForConflictingInstanceMethodSetter(ClassDeclaration node) {
+  bool _checkForConflictingInstanceMethodSetter(ClassDeclaration node) {
     // Reference all of the class members in this class.
     NodeList<ClassMember> classMembers = node.members;
     if (classMembers.isEmpty) {
       return false;
     }
     // Create a HashMap to track conflicting members, and then loop through members in the class to
     // construct the HashMap, at the same time, look for violations.  Don't add members if they are
     // part of a conflict, this prevents multiple warnings for one issue.
     bool foundError = false;
     Map<String, ClassMember> memberHashMap = new Map<String, ClassMember>();
@@ skipping 60 matching lines @@
   }
 
   /**
    * This verifies that the enclosing class does not have an instance member with the same name as
    * the passed static getter method declaration.
    *
    * @param node the method declaration to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * @see StaticWarningCode#CONFLICTING_STATIC_GETTER_AND_INSTANCE_SETTER
    */
-  bool checkForConflictingStaticGetterAndInstanceSetter(MethodDeclaration node) {
+  bool _checkForConflictingStaticGetterAndInstanceSetter(MethodDeclaration node) {
     if (!node.isStatic) {
       return false;
     }
     // prepare name
     SimpleIdentifier nameNode = node.name;
     if (nameNode == null) {
       return false;
     }
     String name = nameNode.name;
     // prepare enclosing type
@@ skipping 19 matching lines @@
   }
 
   /**
    * This verifies that the enclosing class does not have an instance member with the same name as
    * the passed static getter method declaration.
    *
    * @param node the method declaration to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * @see StaticWarningCode#CONFLICTING_STATIC_SETTER_AND_INSTANCE_MEMBER
    */
-  bool checkForConflictingStaticSetterAndInstanceMember(MethodDeclaration node) {
+  bool _checkForConflictingStaticSetterAndInstanceMember(MethodDeclaration node) {
     if (!node.isStatic) {
       return false;
     }
     // prepare name
     SimpleIdentifier nameNode = node.name;
     if (nameNode == null) {
       return false;
     }
     String name = nameNode.name;
     // prepare enclosing type
@@ skipping 26 matching lines @@
   }
 
   /**
    * This verifies all conflicts between type variable and enclosing class. TODO(scheglov)
    *
    * @param node the class declaration to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#CONFLICTING_TYPE_VARIABLE_AND_CLASS
    * @see CompileTimeErrorCode#CONFLICTING_TYPE_VARIABLE_AND_MEMBER
    */
-  bool checkForConflictingTypeVariableErrorCodes(ClassDeclaration node) {
+  bool _checkForConflictingTypeVariableErrorCodes(ClassDeclaration node) {
     bool problemReported = false;
     for (TypeParameterElement typeParameter in _enclosingClass.typeParameters) {
       String name = typeParameter.name;
       // name is same as the name of the enclosing class
       if (_enclosingClass.name == name) {
         _errorReporter.reportErrorForOffset(CompileTimeErrorCode.CONFLICTING_TYPE_VARIABLE_AND_CLASS, typeParameter.nameOffset, name.length, [name]);
         problemReported = true;
       }
       // check members
       if (_enclosingClass.getMethod(name) != null || _enclosingClass.getGetter(name) != null || _enclosingClass.getSetter(name) != null) {
         _errorReporter.reportErrorForOffset(CompileTimeErrorCode.CONFLICTING_TYPE_VARIABLE_AND_MEMBER, typeParameter.nameOffset, name.length, [name]);
         problemReported = true;
       }
     }
     return problemReported;
   }
 
   /**
    * This verifies that if the passed constructor declaration is 'const' then there are no
    * invocations of non-'const' super constructors.
    *
    * @param node the constructor declaration to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#CONST_CONSTRUCTOR_WITH_NON_CONST_SUPER
    */
-  bool checkForConstConstructorWithNonConstSuper(ConstructorDeclaration node) {
+  bool _checkForConstConstructorWithNonConstSuper(ConstructorDeclaration node) {
     if (!_isEnclosingConstructorConst) {
       return false;
     }
     // OK, const factory, checked elsewhere
     if (node.factoryKeyword != null) {
       return false;
     }
     // try to find and check super constructor invocation
     for (ConstructorInitializer initializer in node.initializers) {
       if (initializer is SuperConstructorInvocation) {
@@ skipping 27 matching lines @@
   }
 
   /**
    * This verifies that if the passed constructor declaration is 'const' then there are no non-final
    * instance variable.
    *
    * @param node the constructor declaration to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#CONST_CONSTRUCTOR_WITH_NON_FINAL_FIELD
    */
-  bool checkForConstConstructorWithNonFinalField(ConstructorDeclaration node) {
+  bool _checkForConstConstructorWithNonFinalField(ConstructorDeclaration node) {
     if (!_isEnclosingConstructorConst) {
       return false;
     }
     // check if there is non-final field
     ConstructorElement constructorElement = node.element;
     ClassElement classElement = constructorElement.enclosingElement;
     if (!classElement.hasNonFinalField) {
       return false;
     }
     // report problem
     _errorReporter.reportErrorForNode(CompileTimeErrorCode.CONST_CONSTRUCTOR_WITH_NON_FINAL_FIELD, node, []);
     return true;
   }
 
   /**
    * This verifies that the passed throw expression is not enclosed in a 'const' constructor
    * declaration.
    *
    * @param node the throw expression expression to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#CONST_CONSTRUCTOR_THROWS_EXCEPTION
    */
-  bool checkForConstEvalThrowsException(ThrowExpression node) {
+  bool _checkForConstEvalThrowsException(ThrowExpression node) {
     if (_isEnclosingConstructorConst) {
       _errorReporter.reportErrorForNode(CompileTimeErrorCode.CONST_CONSTRUCTOR_THROWS_EXCEPTION, node, []);
       return true;
     }
     return false;
   }
 
   /**
    * This verifies that the passed normal formal parameter is not 'const'.
    *
    * @param node the normal formal parameter to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#CONST_FORMAL_PARAMETER
    */
-  bool checkForConstFormalParameter(NormalFormalParameter node) {
+  bool _checkForConstFormalParameter(NormalFormalParameter node) {
     if (node.isConst) {
       _errorReporter.reportErrorForNode(CompileTimeErrorCode.CONST_FORMAL_PARAMETER, node, []);
       return true;
     }
     return false;
   }
 
   /**
    * This verifies that the all keys of the passed map literal have class type that does not declare
    * operator <i>==<i>.
    *
    * @param key the map literal to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#CONST_MAP_KEY_EXPRESSION_TYPE_IMPLEMENTS_EQUALS
    */
-  bool checkForConstMapKeyExpressionTypeImplementsEquals(MapLiteral node) {
+  bool _checkForConstMapKeyExpressionTypeImplementsEquals(MapLiteral node) {
     // OK, not const.
     if (node.constKeyword == null) {
       return false;
     }
     // Check every map entry.
     bool hasProblems = false;
     for (MapLiteralEntry entry in node.entries) {
       Expression key = entry.key;
       Type2 type = key.staticType;
-      if (implementsEqualsWhenNotAllowed(type)) {
+      if (_implementsEqualsWhenNotAllowed(type)) {
         _errorReporter.reportErrorForNode(CompileTimeErrorCode.CONST_MAP_KEY_EXPRESSION_TYPE_IMPLEMENTS_EQUALS, key, [type.displayName]);
         hasProblems = true;
       }
     }
     return hasProblems;
   }
 
   /**
    * This verifies that the passed instance creation expression is not being invoked on an abstract
    * class.
    *
    * @param node the instance creation expression to evaluate
    * @param typeName the [TypeName] of the [ConstructorName] from the
    *          [InstanceCreationExpression], this is the AST node that the error is attached to
    * @param type the type being constructed with this [InstanceCreationExpression]
    * @return `true` if and only if an error code is generated on the passed node
    * @see StaticWarningCode#CONST_WITH_ABSTRACT_CLASS
    * @see StaticWarningCode#NEW_WITH_ABSTRACT_CLASS
    */
-  bool checkForConstOrNewWithAbstractClass(InstanceCreationExpression node, TypeName typeName, InterfaceType type) {
+  bool _checkForConstOrNewWithAbstractClass(InstanceCreationExpression node, TypeName typeName, InterfaceType type) {
     if (type.element.isAbstract) {
       ConstructorElement element = node.staticElement;
       if (element != null && !element.isFactory) {
         if (identical((node.keyword as sc.KeywordToken).keyword, sc.Keyword.CONST)) {
           _errorReporter.reportErrorForNode(StaticWarningCode.CONST_WITH_ABSTRACT_CLASS, typeName, []);
         } else {
           _errorReporter.reportErrorForNode(StaticWarningCode.NEW_WITH_ABSTRACT_CLASS, typeName, []);
         }
         return true;
       }
     }
     return false;
   }
 
   /**
    * This verifies that the passed 'const' instance creation expression is not being invoked on a
    * constructor that is not 'const'.
    *
    * This method assumes that the instance creation was tested to be 'const' before being called.
    *
    * @param node the instance creation expression to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#CONST_WITH_NON_CONST
    */
-  bool checkForConstWithNonConst(InstanceCreationExpression node) {
+  bool _checkForConstWithNonConst(InstanceCreationExpression node) {
     ConstructorElement constructorElement = node.staticElement;
     if (constructorElement != null && !constructorElement.isConst) {
       _errorReporter.reportErrorForNode(CompileTimeErrorCode.CONST_WITH_NON_CONST, node, []);
       return true;
     }
     return false;
   }
 
   /**
    * This verifies that the passed type name does not reference any type parameters.
    *
    * @param typeName the type name to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#CONST_WITH_TYPE_PARAMETERS
    */
-  bool checkForConstWithTypeParameters(TypeName typeName) {
+  bool _checkForConstWithTypeParameters(TypeName typeName) {
     // something wrong with AST
     if (typeName == null) {
       return false;
     }
     Identifier name = typeName.name;
     if (name == null) {
       return false;
     }
     // should not be a type parameter
     if (name.staticElement is TypeParameterElement) {
       _errorReporter.reportErrorForNode(CompileTimeErrorCode.CONST_WITH_TYPE_PARAMETERS, name, []);
     }
     // check type arguments
     TypeArgumentList typeArguments = typeName.typeArguments;
     if (typeArguments != null) {
       bool hasError = false;
       for (TypeName argument in typeArguments.arguments) {
-        hasError = javaBooleanOr(hasError, checkForConstWithTypeParameters(argument));
+        hasError = javaBooleanOr(hasError, _checkForConstWithTypeParameters(argument));
       }
       return hasError;
     }
     // OK
     return false;
   }
 
   /**
    * This verifies that the passed 'const' instance creation expression does not reference any type
    * parameters.
    *
    * This method assumes that the instance creation was tested to be 'const' before being called.
    *
    * @param node the instance creation expression to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#CONST_WITH_TYPE_PARAMETERS
    */
-  bool checkForConstWithTypeParametersInCreation(InstanceCreationExpression node) {
+  bool _checkForConstWithTypeParametersInCreation(InstanceCreationExpression node) {
     ConstructorName constructorName = node.constructorName;
     if (constructorName == null) {
       return false;
     }
     TypeName typeName = constructorName.type;
-    return checkForConstWithTypeParameters(typeName);
+    return _checkForConstWithTypeParameters(typeName);
   }
 
   /**
    * This verifies that if the passed 'const' instance creation expression is being invoked on the
    * resolved constructor.
    *
    * This method assumes that the instance creation was tested to be 'const' before being called.
    *
    * @param node the instance creation expression to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#CONST_WITH_UNDEFINED_CONSTRUCTOR
    * @see CompileTimeErrorCode#CONST_WITH_UNDEFINED_CONSTRUCTOR_DEFAULT
    */
-  bool checkForConstWithUndefinedConstructor(InstanceCreationExpression node) {
+  bool _checkForConstWithUndefinedConstructor(InstanceCreationExpression node) {
     // OK if resolved
     if (node.staticElement != null) {
       return false;
     }
     // prepare constructor name
     ConstructorName constructorName = node.constructorName;
     if (constructorName == null) {
       return false;
     }
     // prepare class name
@@ skipping 12 matching lines @@
     return true;
   }
 
   /**
    * This verifies that there are no default parameters in the passed function type alias.
    *
    * @param node the function type alias to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#DEFAULT_VALUE_IN_FUNCTION_TYPE_ALIAS
    */
-  bool checkForDefaultValueInFunctionTypeAlias(FunctionTypeAlias node) {
+  bool _checkForDefaultValueInFunctionTypeAlias(FunctionTypeAlias node) {
     bool result = false;
     FormalParameterList formalParameterList = node.parameters;
     NodeList<FormalParameter> parameters = formalParameterList.parameters;
     for (FormalParameter formalParameter in parameters) {
       if (formalParameter is DefaultFormalParameter) {
         DefaultFormalParameter defaultFormalParameter = formalParameter;
         if (defaultFormalParameter.defaultValue != null) {
           _errorReporter.reportErrorForNode(CompileTimeErrorCode.DEFAULT_VALUE_IN_FUNCTION_TYPE_ALIAS, node, []);
           result = true;
         }
       }
     }
     return result;
   }
 
   /**
    * This verifies that the given default formal parameter is not part of a function typed
    * parameter.
    *
    * @param node the default formal parameter to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#DEFAULT_VALUE_IN_FUNCTION_TYPED_PARAMETER
    */
-  bool checkForDefaultValueInFunctionTypedParameter(DefaultFormalParameter node) {
+  bool _checkForDefaultValueInFunctionTypedParameter(DefaultFormalParameter node) {
     // OK, not in a function typed parameter.
     if (!_isInFunctionTypedFormalParameter) {
       return false;
     }
     // OK, no default value.
     if (node.defaultValue == null) {
       return false;
     }
     // Report problem.
     _errorReporter.reportErrorForNode(CompileTimeErrorCode.DEFAULT_VALUE_IN_FUNCTION_TYPED_PARAMETER, node, []);
     return true;
   }
 
   /**
    * This verifies that the enclosing class does not have an instance member with the given name of
    * the static member.
    *
    * @return `true` if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#DUPLICATE_DEFINITION_INHERITANCE
    */
-  bool checkForDuplicateDefinitionInheritance() {
+  bool _checkForDuplicateDefinitionInheritance() {
     if (_enclosingClass == null) {
       return false;
     }
     bool hasProblem = false;
     for (ExecutableElement member in _enclosingClass.methods) {
       if (!member.isStatic) {
         continue;
       }
-      hasProblem = javaBooleanOr(hasProblem, checkForDuplicateDefinitionOfMember(member));
+      hasProblem = javaBooleanOr(hasProblem, _checkForDuplicateDefinitionOfMember(member));
     }
     for (ExecutableElement member in _enclosingClass.accessors) {
       if (!member.isStatic) {
         continue;
       }
-      hasProblem = javaBooleanOr(hasProblem, checkForDuplicateDefinitionOfMember(member));
+      hasProblem = javaBooleanOr(hasProblem, _checkForDuplicateDefinitionOfMember(member));
     }
     return hasProblem;
   }
 
   /**
    * This verifies that the enclosing class does not have an instance member with the given name of
    * the static member.
    *
    * @param staticMember the static member to check conflict for
    * @return `true` if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#DUPLICATE_DEFINITION_INHERITANCE
    */
-  bool checkForDuplicateDefinitionOfMember(ExecutableElement staticMember) {
+  bool _checkForDuplicateDefinitionOfMember(ExecutableElement staticMember) {
     // prepare name
     String name = staticMember.name;
     if (name == null) {
       return false;
     }
     // try to find member
     ExecutableElement inheritedMember = _inheritanceManager.lookupInheritance(_enclosingClass, name);
     if (inheritedMember == null) {
       return false;
     }
     // OK, also static
     if (inheritedMember.isStatic) {
       return false;
     }
     // report problem
     _errorReporter.reportErrorForOffset(CompileTimeErrorCode.DUPLICATE_DEFINITION_INHERITANCE, staticMember.nameOffset, name.length, [name, inheritedMember.enclosingElement.displayName]);
     return true;
   }
 
   /**
    * This verifies if the passed list literal has type arguments then there is exactly one.
    *
    * @param node the list literal to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * @see StaticTypeWarningCode#EXPECTED_ONE_LIST_TYPE_ARGUMENTS
    */
-  bool checkForExpectedOneListTypeArgument(ListLiteral node) {
+  bool _checkForExpectedOneListTypeArgument(ListLiteral node) {
     // prepare type arguments
     TypeArgumentList typeArguments = node.typeArguments;
     if (typeArguments == null) {
       return false;
     }
     // check number of type arguments
     int num = typeArguments.arguments.length;
     if (num == 1) {
       return false;
     }
     // report problem
     _errorReporter.reportErrorForNode(StaticTypeWarningCode.EXPECTED_ONE_LIST_TYPE_ARGUMENTS, typeArguments, [num]);
     return true;
   }
 
   /**
    * This verifies the passed import has unique name among other exported libraries.
    *
    * @param node the export directive to evaluate
    * @param exportElement the [ExportElement] retrieved from the node, if the element in the
    *          node was `null`, then this method is not called
    * @return `true` if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#EXPORT_DUPLICATED_LIBRARY_NAME
    */
-  bool checkForExportDuplicateLibraryName(ExportDirective node, ExportElement exportElement) {
+  bool _checkForExportDuplicateLibraryName(ExportDirective node, ExportElement exportElement) {
     // prepare exported library
     LibraryElement nodeLibrary = exportElement.exportedLibrary;
     if (nodeLibrary == null) {
       return false;
     }
     String name = nodeLibrary.name;
     // check if there is other exported library with the same name
     LibraryElement prevLibrary = _nameToExportElement[name];
     if (prevLibrary != null) {
       if (prevLibrary != nodeLibrary) {
@@ skipping 13 matching lines @@
   /**
    * Check that if the visiting library is not system, then any passed library should not be SDK
    * internal library.
    *
    * @param node the export directive to evaluate
    * @param exportElement the [ExportElement] retrieved from the node, if the element in the
    *          node was `null`, then this method is not called
    * @return `true` if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#EXPORT_INTERNAL_LIBRARY
    */
-  bool checkForExportInternalLibrary(ExportDirective node, ExportElement exportElement) {
+  bool _checkForExportInternalLibrary(ExportDirective node, ExportElement exportElement) {
     if (_isInSystemLibrary) {
       return false;
     }
     // should be private
     DartSdk sdk = _currentLibrary.context.sourceFactory.dartSdk;
     String uri = exportElement.uri;
     SdkLibrary sdkLibrary = sdk.getSdkLibrary(uri);
     if (sdkLibrary == null) {
       return false;
     }
     if (!sdkLibrary.isInternal) {
       return false;
     }
     // report problem
     _errorReporter.reportErrorForNode(CompileTimeErrorCode.EXPORT_INTERNAL_LIBRARY, node, [node.uri]);
     return true;
   }
 
   /**
    * This verifies that the passed extends clause does not extend classes such as num or String.
    *
    * @param node the extends clause to test
    * @return `true` if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#EXTENDS_DISALLOWED_CLASS
    */
-  bool checkForExtendsDisallowedClass(ExtendsClause node) {
+  bool _checkForExtendsDisallowedClass(ExtendsClause node) {
     if (node == null) {
       return false;
     }
-    return checkForExtendsOrImplementsDisallowedClass(node.superclass, CompileTimeErrorCode.EXTENDS_DISALLOWED_CLASS);
+    return _checkForExtendsOrImplementsDisallowedClass(node.superclass, CompileTimeErrorCode.EXTENDS_DISALLOWED_CLASS);
   }
 
   /**
    * This verifies that the passed type name does not extend or implement classes such as 'num' or
    * 'String'.
    *
    * @param node the type name to test
    * @return `true` if and only if an error code is generated on the passed node
    * @see #checkForExtendsDisallowedClass(ExtendsClause)
    * @see #checkForImplementsDisallowedClass(ImplementsClause)
    * @see CompileTimeErrorCode#EXTENDS_DISALLOWED_CLASS
    * @see CompileTimeErrorCode#IMPLEMENTS_DISALLOWED_CLASS
    */
-  bool checkForExtendsOrImplementsDisallowedClass(TypeName typeName, ErrorCode errorCode) {
+  bool _checkForExtendsOrImplementsDisallowedClass(TypeName typeName, ErrorCode errorCode) {
     if (typeName.isSynthetic) {
       return false;
     }
     Type2 superType = typeName.type;
     for (InterfaceType disallowedType in _DISALLOWED_TYPES_TO_EXTEND_OR_IMPLEMENT) {
       if (superType != null && superType == disallowedType) {
         // if the violating type happens to be 'num', we need to rule out the case where the
         // enclosing class is 'int' or 'double'
         if (superType == _typeProvider.numType) {
           AstNode grandParent = typeName.parent.parent;
@@ skipping 19 matching lines @@
 
   /**
    * This verifies that the passed constructor field initializer has compatible field and
    * initializer expression types.
    *
    * @param node the constructor field initializer to test
    * @return `true` if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#CONST_FIELD_INITIALIZER_NOT_ASSIGNABLE
    * @see StaticWarningCode#FIELD_INITIALIZER_NOT_ASSIGNABLE
    */
-  bool checkForFieldInitializerNotAssignable(ConstructorFieldInitializer node) {
+  bool _checkForFieldInitializerNotAssignable(ConstructorFieldInitializer node) {
     // prepare field element
     Element staticElement = node.fieldName.staticElement;
     if (staticElement is! FieldElement) {
       return false;
     }
     FieldElement fieldElement = staticElement as FieldElement;
     // prepare field type
     Type2 fieldType = fieldElement.type;
     // prepare expression type
     Expression expression = node.expression;
     if (expression == null) {
       return false;
     }
     // test the static type of the expression
-    Type2 staticType = getStaticType(expression);
+    Type2 staticType = _getStaticType(expression);
     if (staticType == null) {
       return false;
     }
     if (staticType.isAssignableTo(fieldType)) {
       return false;
     }
     // report problem
     if (_isEnclosingConstructorConst) {
       _errorReporter.reportErrorForNode(CompileTimeErrorCode.CONST_FIELD_INITIALIZER_NOT_ASSIGNABLE, expression, [staticType.displayName, fieldType.displayName]);
     } else {
       _errorReporter.reportErrorForNode(StaticWarningCode.FIELD_INITIALIZER_NOT_ASSIGNABLE, expression, [staticType.displayName, fieldType.displayName]);
     }
     return true;
   }
 
   /**
    * This verifies that the passed field formal parameter is in a constructor declaration.
    *
    * @param node the field formal parameter to test
    * @return `true` if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#FIELD_INITIALIZER_OUTSIDE_CONSTRUCTOR
    */
-  bool checkForFieldInitializingFormalRedirectingConstructor(FieldFormalParameter node) {
+  bool _checkForFieldInitializingFormalRedirectingConstructor(FieldFormalParameter node) {
     ConstructorDeclaration constructor = node.getAncestor((node) => node is ConstructorDeclaration);
     if (constructor == null) {
       _errorReporter.reportErrorForNode(CompileTimeErrorCode.FIELD_INITIALIZER_OUTSIDE_CONSTRUCTOR, node, []);
       return true;
     }
     // constructor cannot be a factory
     if (constructor.factoryKeyword != null) {
       _errorReporter.reportErrorForNode(CompileTimeErrorCode.FIELD_INITIALIZER_FACTORY_CONSTRUCTOR, node, []);
       return true;
     }
@@ skipping 13 matching lines @@
    * list is final or const. This method is called by
    * [checkForFinalNotInitializedInClass],
    * [visitTopLevelVariableDeclaration] and
    * [visitVariableDeclarationStatement].
    *
    * @param node the class declaration to test
    * @return `true` if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#CONST_NOT_INITIALIZED
    * @see StaticWarningCode#FINAL_NOT_INITIALIZED
    */
-  bool checkForFinalNotInitialized(VariableDeclarationList node) {
+  bool _checkForFinalNotInitialized(VariableDeclarationList node) {
     if (_isInNativeClass) {
       return false;
     }
     bool foundError = false;
     if (!node.isSynthetic) {
       NodeList<VariableDeclaration> variables = node.variables;
       for (VariableDeclaration variable in variables) {
         if (variable.initializer == null) {
           if (node.isConst) {
             _errorReporter.reportErrorForNode(CompileTimeErrorCode.CONST_NOT_INITIALIZED, variable.name, [variable.name.name]);
@@ skipping 10 matching lines @@
   /**
    * This verifies that final fields that are declared, without any constructors in the enclosing
    * class, are initialized. Cases in which there is at least one constructor are handled at the end
    * of [checkForAllFinalInitializedErrorCodes].
    *
    * @param node the class declaration to test
    * @return `true` if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#CONST_NOT_INITIALIZED
    * @see StaticWarningCode#FINAL_NOT_INITIALIZED
    */
-  bool checkForFinalNotInitializedInClass(ClassDeclaration node) {
+  bool _checkForFinalNotInitializedInClass(ClassDeclaration node) {
     NodeList<ClassMember> classMembers = node.members;
     for (ClassMember classMember in classMembers) {
       if (classMember is ConstructorDeclaration) {
         return false;
       }
     }
     bool foundError = false;
     for (ClassMember classMember in classMembers) {
       if (classMember is FieldDeclaration) {
         FieldDeclaration field = classMember;
-        foundError = javaBooleanOr(foundError, checkForFinalNotInitialized(field.fields));
+        foundError = javaBooleanOr(foundError, _checkForFinalNotInitialized(field.fields));
       }
     }
     return foundError;
   }
 
   /**
    * This verifies that the passed implements clause does not implement classes such as 'num' or
    * 'String'.
    *
    * @param node the implements clause to test
    * @return `true` if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#IMPLEMENTS_DISALLOWED_CLASS
    */
-  bool checkForImplementsDisallowedClass(ImplementsClause node) {
+  bool _checkForImplementsDisallowedClass(ImplementsClause node) {
     if (node == null) {
       return false;
     }
     bool foundError = false;
     for (TypeName type in node.interfaces) {
-      foundError = javaBooleanOr(foundError, checkForExtendsOrImplementsDisallowedClass(type, CompileTimeErrorCode.IMPLEMENTS_DISALLOWED_CLASS));
+      foundError = javaBooleanOr(foundError, _checkForExtendsOrImplementsDisallowedClass(type, CompileTimeErrorCode.IMPLEMENTS_DISALLOWED_CLASS));
     }
     return foundError;
   }
 
   /**
    * This verifies that if the passed identifier is part of constructor initializer, then it does
    * not reference implicitly 'this' expression.
    *
    * @param node the simple identifier to test
    * @return `true` if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#IMPLICIT_THIS_REFERENCE_IN_INITIALIZER
    * @see CompileTimeErrorCode#INSTANCE_MEMBER_ACCESS_FROM_STATIC TODO(scheglov) rename thid method
    */
-  bool checkForImplicitThisReferenceInInitializer(SimpleIdentifier node) {
+  bool _checkForImplicitThisReferenceInInitializer(SimpleIdentifier node) {
     if (!_isInConstructorInitializer && !_isInStaticMethod && !_isInInstanceVariableInitializer && !_isInStaticVariableDeclaration) {
       return false;
     }
     // prepare element
     Element element = node.staticElement;
     if (!(element is MethodElement || element is PropertyAccessorElement)) {
       return false;
     }
     // static element
     ExecutableElement executableElement = element as ExecutableElement;
@@ skipping 41 matching lines @@
 
   /**
    * This verifies the passed import has unique name among other imported libraries.
    *
    * @param node the import directive to evaluate
    * @param importElement the [ImportElement] retrieved from the node, if the element in the
    *          node was `null`, then this method is not called
    * @return `true` if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#IMPORT_DUPLICATED_LIBRARY_NAME
    */
-  bool checkForImportDuplicateLibraryName(ImportDirective node, ImportElement importElement) {
+  bool _checkForImportDuplicateLibraryName(ImportDirective node, ImportElement importElement) {
     // prepare imported library
     LibraryElement nodeLibrary = importElement.importedLibrary;
     if (nodeLibrary == null) {
       return false;
     }
     String name = nodeLibrary.name;
     // check if there is other imported library with the same name
     LibraryElement prevLibrary = _nameToImportElement[name];
     if (prevLibrary != null) {
       if (prevLibrary != nodeLibrary) {
@@ skipping 13 matching lines @@
   /**
    * Check that if the visiting library is not system, then any passed library should not be SDK
    * internal library.
    *
    * @param node the import directive to evaluate
    * @param importElement the [ImportElement] retrieved from the node, if the element in the
    *          node was `null`, then this method is not called
    * @return `true` if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#IMPORT_INTERNAL_LIBRARY
    */
-  bool checkForImportInternalLibrary(ImportDirective node, ImportElement importElement) {
+  bool _checkForImportInternalLibrary(ImportDirective node, ImportElement importElement) {
     if (_isInSystemLibrary) {
       return false;
     }
     // should be private
     DartSdk sdk = _currentLibrary.context.sourceFactory.dartSdk;
     String uri = importElement.uri;
     SdkLibrary sdkLibrary = sdk.getSdkLibrary(uri);
     if (sdkLibrary == null) {
       return false;
     }
     if (!sdkLibrary.isInternal) {
       return false;
     }
     // report problem
     _errorReporter.reportErrorForNode(CompileTimeErrorCode.IMPORT_INTERNAL_LIBRARY, node, [node.uri]);
     return true;
   }
 
   /**
    * This verifies that the passed switch statement case expressions all have the same type.
    *
    * @param node the switch statement to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#INCONSISTENT_CASE_EXPRESSION_TYPES
    */
-  bool checkForInconsistentCaseExpressionTypes(SwitchStatement node) {
+  bool _checkForInconsistentCaseExpressionTypes(SwitchStatement node) {
     // TODO(jwren) Revisit this algorithm, should there up to n-1 errors?
     NodeList<SwitchMember> switchMembers = node.members;
     bool foundError = false;
     Type2 firstType = null;
     for (SwitchMember switchMember in switchMembers) {
       if (switchMember is SwitchCase) {
         SwitchCase switchCase = switchMember;
         Expression expression = switchCase.expression;
         if (firstType == null) {
           // TODO(brianwilkerson) This is failing with const variables whose declared type is
           // dynamic. The problem is that we don't have any way to propagate type information for
           // the variable.
           firstType = expression.bestType;
         } else {
           Type2 nType = expression.bestType;
           if (firstType != nType) {
             _errorReporter.reportErrorForNode(CompileTimeErrorCode.INCONSISTENT_CASE_EXPRESSION_TYPES, expression, [expression.toSource(), firstType.displayName]);
             foundError = true;
           }
         }
       }
     }
     if (!foundError) {
-      checkForCaseExpressionTypeImplementsEquals(node, firstType);
+      _checkForCaseExpressionTypeImplementsEquals(node, firstType);
     }
     return foundError;
   }
 
   /**
    * For each class declaration, this method is called which verifies that all inherited members are
    * inherited consistently.
    *
    * @return `true` if and only if an error code is generated on the passed node
    * @see StaticTypeWarningCode#INCONSISTENT_METHOD_INHERITANCE
    */
-  bool checkForInconsistentMethodInheritance() {
+  bool _checkForInconsistentMethodInheritance() {
     // Ensure that the inheritance manager has a chance to generate all errors we may care about,
     // note that we ensure that the interfaces data since there are no errors.
     _inheritanceManager.getMapOfMembersInheritedFromInterfaces(_enclosingClass);
     Set<AnalysisError> errors = _inheritanceManager.getErrors(_enclosingClass);
     if (errors == null || errors.isEmpty) {
       return false;
     }
     for (AnalysisError error in errors) {
       _errorReporter.reportError(error);
     }
     return true;
   }
 
   /**
    * This checks the given "typeReference" is not a type reference and that then the "name" is
    * reference to an instance member.
    *
    * @param typeReference the resolved [ClassElement] of the left hand side of the expression,
    *          or `null`, aka, the class element of 'C' in 'C.x', see
    *          [getTypeReference]
    * @param name the accessed name to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * @see StaticTypeWarningCode#INSTANCE_ACCESS_TO_STATIC_MEMBER
    */
-  bool checkForInstanceAccessToStaticMember(ClassElement typeReference, SimpleIdentifier name) {
+  bool _checkForInstanceAccessToStaticMember(ClassElement typeReference, SimpleIdentifier name) {
     // OK, in comment
     if (_isInComment) {
       return false;
     }
     // OK, target is a type
     if (typeReference != null) {
       return false;
     }
     // prepare member Element
     Element element = name.staticElement;
@@ skipping 16 matching lines @@
 
   /**
    * This verifies that an 'int' can be assigned to the parameter corresponding to the given
    * expression. This is used for prefix and postfix expressions where the argument value is
    * implicit.
    *
    * @param argument the expression to which the operator is being applied
    * @return `true` if and only if an error code is generated on the passed node
    * @see StaticWarningCode#ARGUMENT_TYPE_NOT_ASSIGNABLE
    */
-  bool checkForIntNotAssignable(Expression argument) {
+  bool _checkForIntNotAssignable(Expression argument) {
     if (argument == null) {
       return false;
     }
     ParameterElement staticParameterElement = argument.staticParameterElement;
     Type2 staticParameterType = staticParameterElement == null ? null : staticParameterElement.type;
     ParameterElement propagatedParameterElement = argument.propagatedParameterElement;
     Type2 propagatedParameterType = propagatedParameterElement == null ? null : propagatedParameterElement.type;
-    return checkForArgumentTypeNotAssignable(argument, staticParameterType, _intType, propagatedParameterType, _intType, StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE);
+    return _checkForArgumentTypeNotAssignable(argument, staticParameterType, _intType, propagatedParameterType, _intType, StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE);
   }
 
   /**
    * This verifies that the passed left hand side and right hand side represent a valid assignment.
    *
    * @param lhs the left hand side expression
    * @param rhs the right hand side expression
    * @return `true` if and only if an error code is generated on the passed node
    * @see StaticTypeWarningCode#INVALID_ASSIGNMENT
    */
-  bool checkForInvalidAssignment(Expression lhs, Expression rhs) {
+  bool _checkForInvalidAssignment(Expression lhs, Expression rhs) {
     if (lhs == null || rhs == null) {
       return false;
     }
-    VariableElement leftElement = getVariableElement(lhs);
-    Type2 leftType = (leftElement == null) ? getStaticType(lhs) : leftElement.type;
-    Type2 staticRightType = getStaticType(rhs);
+    VariableElement leftElement = _getVariableElement(lhs);
+    Type2 leftType = (leftElement == null) ? _getStaticType(lhs) : leftElement.type;
+    Type2 staticRightType = _getStaticType(rhs);
     bool isStaticAssignable = staticRightType.isAssignableTo(leftType);
     if (!isStaticAssignable) {
       String leftName = leftType.displayName;
       String rightName = staticRightType.displayName;
       if (leftName == rightName) {
-        leftName = getExtendedDisplayName(leftType);
-        rightName = getExtendedDisplayName(staticRightType);
+        leftName = _getExtendedDisplayName(leftType);
+        rightName = _getExtendedDisplayName(staticRightType);
       }
       _errorReporter.reportErrorForNode(StaticTypeWarningCode.INVALID_ASSIGNMENT, rhs, [rightName, leftName]);
       return true;
     }
     // TODO(brianwilkerson) Define a hint corresponding to the warning and report it if appropriate.
     //    Type propagatedRightType = rhs.getPropagatedType();
     //    boolean isPropagatedAssignable = propagatedRightType.isAssignableTo(leftType);
     //    if (!isStaticAssignable && !isPropagatedAssignable) {
     //      errorReporter.reportError(
     //          StaticTypeWarningCode.INVALID_ASSIGNMENT,
     //          rhs,
     //          staticRightType.getDisplayName(),
     //          leftType.getDisplayName());
     //      return true;
     //    }
     return false;
   }
 
   /**
    * Given an assignment using a compound assignment operator, this verifies that the given
    * assignment is valid.
    *
    * @param node the assignment expression being tested
    * @return `true` if and only if an error code is generated on the passed node
    * @see StaticTypeWarningCode#INVALID_ASSIGNMENT
    */
-  bool checkForInvalidCompoundAssignment(AssignmentExpression node) {
+  bool _checkForInvalidCompoundAssignment(AssignmentExpression node) {
     Expression lhs = node.leftHandSide;
     if (lhs == null) {
       return false;
     }
-    VariableElement leftElement = getVariableElement(lhs);
-    Type2 leftType = (leftElement == null) ? getStaticType(lhs) : leftElement.type;
+    VariableElement leftElement = _getVariableElement(lhs);
+    Type2 leftType = (leftElement == null) ? _getStaticType(lhs) : leftElement.type;
     MethodElement invokedMethod = node.staticElement;
     if (invokedMethod == null) {
       return false;
     }
     Type2 rightType = invokedMethod.type.returnType;
     if (leftType == null || rightType == null) {
       return false;
     }
     if (!rightType.isAssignableTo(leftType)) {
       String leftName = leftType.displayName;
       String rightName = rightType.displayName;
       if (leftName == rightName) {
-        leftName = getExtendedDisplayName(leftType);
-        rightName = getExtendedDisplayName(rightType);
+        leftName = _getExtendedDisplayName(leftType);
+        rightName = _getExtendedDisplayName(rightType);
       }
       _errorReporter.reportErrorForNode(StaticTypeWarningCode.INVALID_ASSIGNMENT, node.rightHandSide, [rightName, leftName]);
       return true;
     }
     return false;
   }
 
   /**
    * Check the given initializer to ensure that the field being initialized is a valid field.
    *
    * @param node the field initializer being checked
    */
-  void checkForInvalidField(ConstructorFieldInitializer node) {
+  void _checkForInvalidField(ConstructorFieldInitializer node) {
     SimpleIdentifier fieldName = node.fieldName;
     Element staticElement = fieldName.staticElement;
     if (staticElement is FieldElement) {
       FieldElement fieldElement = staticElement;
       if (fieldElement.isSynthetic) {
         _errorReporter.reportErrorForNode(CompileTimeErrorCode.INITIALIZER_FOR_NON_EXISTANT_FIELD, node, [fieldName]);
       } else if (fieldElement.isStatic) {
         _errorReporter.reportErrorForNode(CompileTimeErrorCode.INITIALIZER_FOR_STATIC_FIELD, node, [fieldName]);
       }
     } else {
       _errorReporter.reportErrorForNode(CompileTimeErrorCode.INITIALIZER_FOR_NON_EXISTANT_FIELD, node, [fieldName]);
       return;
     }
   }
 
   /**
    * This verifies that the usage of the passed 'this' is valid.
    *
    * @param node the 'this' expression to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#INVALID_REFERENCE_TO_THIS
    */
-  bool checkForInvalidReferenceToThis(ThisExpression node) {
-    if (!isThisInValidContext(node)) {
+  bool _checkForInvalidReferenceToThis(ThisExpression node) {
+    if (!_isThisInValidContext(node)) {
       _errorReporter.reportErrorForNode(CompileTimeErrorCode.INVALID_REFERENCE_TO_THIS, node, []);
       return true;
     }
     return false;
   }
 
   /**
    * Checks to ensure that the passed [ListLiteral] or [MapLiteral] does not have a type
    * parameter as a type argument.
    *
    * @param arguments a non-`null`, non-empty [TypeName] node list from the respective
    *          [ListLiteral] or [MapLiteral]
    * @param errorCode either [CompileTimeErrorCode#INVALID_TYPE_ARGUMENT_IN_CONST_LIST] or
    *          [CompileTimeErrorCode#INVALID_TYPE_ARGUMENT_IN_CONST_MAP]
    * @return `true` if and only if an error code is generated on the passed node
    */
-  bool checkForInvalidTypeArgumentInConstTypedLiteral(NodeList<TypeName> arguments, ErrorCode errorCode) {
+  bool _checkForInvalidTypeArgumentInConstTypedLiteral(NodeList<TypeName> arguments, ErrorCode errorCode) {
     bool foundError = false;
     for (TypeName typeName in arguments) {
       if (typeName.type is TypeParameterType) {
         _errorReporter.reportErrorForNode(errorCode, typeName, [typeName.name]);
         foundError = true;
       }
     }
     return foundError;
   }
 
   /**
    * This verifies that the elements given [ListLiteral] are subtypes of the specified element
    * type.
    *
    * @param node the list literal to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#LIST_ELEMENT_TYPE_NOT_ASSIGNABLE
    * @see StaticWarningCode#LIST_ELEMENT_TYPE_NOT_ASSIGNABLE
    */
-  bool checkForListElementTypeNotAssignable(ListLiteral node) {
+  bool _checkForListElementTypeNotAssignable(ListLiteral node) {
     // Prepare list element type.
     TypeArgumentList typeArgumentList = node.typeArguments;
     if (typeArgumentList == null) {
       return false;
     }
     NodeList<TypeName> typeArguments = typeArgumentList.arguments;
     if (typeArguments.length < 1) {
       return false;
     }
     Type2 listElementType = typeArguments[0].type;
     // Prepare problem to report.
     ErrorCode errorCode;
     if (node.constKeyword != null) {
       errorCode = CompileTimeErrorCode.LIST_ELEMENT_TYPE_NOT_ASSIGNABLE;
     } else {
       errorCode = StaticWarningCode.LIST_ELEMENT_TYPE_NOT_ASSIGNABLE;
     }
     // Check every list element.
     bool hasProblems = false;
     for (Expression element in node.elements) {
-      hasProblems = javaBooleanOr(hasProblems, checkForArgumentTypeNotAssignableWithExpectedTypes(element, listElementType, null, errorCode));
+      hasProblems = javaBooleanOr(hasProblems, _checkForArgumentTypeNotAssignableWithExpectedTypes(element, listElementType, null, errorCode));
     }
     return hasProblems;
   }
 
   /**
    * This verifies that the key/value of entries of the given [MapLiteral] are subtypes of the
    * key/value types specified in the type arguments.
    *
    * @param node the map literal to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#MAP_KEY_TYPE_NOT_ASSIGNABLE
    * @see CompileTimeErrorCode#MAP_VALUE_TYPE_NOT_ASSIGNABLE
    * @see StaticWarningCode#MAP_KEY_TYPE_NOT_ASSIGNABLE
    * @see StaticWarningCode#MAP_VALUE_TYPE_NOT_ASSIGNABLE
    */
-  bool checkForMapTypeNotAssignable(MapLiteral node) {
+  bool _checkForMapTypeNotAssignable(MapLiteral node) {
     // Prepare maps key/value types.
     TypeArgumentList typeArgumentList = node.typeArguments;
     if (typeArgumentList == null) {
       return false;
     }
     NodeList<TypeName> typeArguments = typeArgumentList.arguments;
     if (typeArguments.length < 2) {
       return false;
     }
     Type2 keyType = typeArguments[0].type;
     Type2 valueType = typeArguments[1].type;
     // Prepare problem to report.
     ErrorCode keyErrorCode;
     ErrorCode valueErrorCode;
     if (node.constKeyword != null) {
       keyErrorCode = CompileTimeErrorCode.MAP_KEY_TYPE_NOT_ASSIGNABLE;
       valueErrorCode = CompileTimeErrorCode.MAP_VALUE_TYPE_NOT_ASSIGNABLE;
     } else {
       keyErrorCode = StaticWarningCode.MAP_KEY_TYPE_NOT_ASSIGNABLE;
       valueErrorCode = StaticWarningCode.MAP_VALUE_TYPE_NOT_ASSIGNABLE;
     }
     // Check every map entry.
     bool hasProblems = false;
     NodeList<MapLiteralEntry> entries = node.entries;
     for (MapLiteralEntry entry in entries) {
       Expression key = entry.key;
       Expression value = entry.value;
-      hasProblems = javaBooleanOr(hasProblems, checkForArgumentTypeNotAssignableWithExpectedTypes(key, keyType, null, keyErrorCode));
-      hasProblems = javaBooleanOr(hasProblems, checkForArgumentTypeNotAssignableWithExpectedTypes(value, valueType, null, valueErrorCode));
+      hasProblems = javaBooleanOr(hasProblems, _checkForArgumentTypeNotAssignableWithExpectedTypes(key, keyType, null, keyErrorCode));
+      hasProblems = javaBooleanOr(hasProblems, _checkForArgumentTypeNotAssignableWithExpectedTypes(value, valueType, null, valueErrorCode));
     }
     return hasProblems;
   }
 
   /**
    * This verifies that the [enclosingClass] does not define members with the same name as
    * the enclosing class.
    *
    * @return `true` if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#MEMBER_WITH_CLASS_NAME
    */
-  bool checkForMemberWithClassName() {
+  bool _checkForMemberWithClassName() {
     if (_enclosingClass == null) {
       return false;
     }
     String className = _enclosingClass.name;
     if (className == null) {
       return false;
     }
     bool problemReported = false;
     // check accessors
     for (PropertyAccessorElement accessor in _enclosingClass.accessors) {
       if (className == accessor.name) {
         _errorReporter.reportErrorForOffset(CompileTimeErrorCode.MEMBER_WITH_CLASS_NAME, accessor.nameOffset, className.length, []);
         problemReported = true;
       }
     }
     // don't check methods, they would be constructors
     // done
     return problemReported;
   }
 
   /**
    * Check to make sure that all similarly typed accessors are of the same type (including inherited
    * accessors).
    *
    * @param node the accessor currently being visited
    * @return `true` if and only if an error code is generated on the passed node
    * @see StaticWarningCode.MISMATCHED_GETTER_AND_SETTER_TYPES
    * @see StaticWarningCode.MISMATCHED_GETTER_AND_SETTER_TYPES_FROM_SUPERTYPE
    */
-  bool checkForMismatchedAccessorTypes(Declaration accessorDeclaration, String accessorTextName) {
+  bool _checkForMismatchedAccessorTypes(Declaration accessorDeclaration, String accessorTextName) {
     ExecutableElement accessorElement = accessorDeclaration.element as ExecutableElement;
     if (accessorElement is! PropertyAccessorElement) {
       return false;
     }
     PropertyAccessorElement propertyAccessorElement = accessorElement as PropertyAccessorElement;
     PropertyAccessorElement counterpartAccessor = null;
     ClassElement enclosingClassForCounterpart = null;
     if (propertyAccessorElement.isGetter) {
       counterpartAccessor = propertyAccessorElement.correspondingSetter;
     } else {
@@ skipping 25 matching lines @@
       }
       if (counterpartAccessor == null) {
         return false;
       }
     }
     // Default of null == no accessor or no type (dynamic)
     Type2 getterType = null;
     Type2 setterType = null;
     // Get an existing counterpart accessor if any.
     if (propertyAccessorElement.isGetter) {
-      getterType = getGetterType(propertyAccessorElement);
-      setterType = getSetterType(counterpartAccessor);
+      getterType = _getGetterType(propertyAccessorElement);
+      setterType = _getSetterType(counterpartAccessor);
     } else if (propertyAccessorElement.isSetter) {
-      setterType = getSetterType(propertyAccessorElement);
-      getterType = getGetterType(counterpartAccessor);
+      setterType = _getSetterType(propertyAccessorElement);
+      getterType = _getGetterType(counterpartAccessor);
     }
     // If either types are not assignable to each other, report an error (if the getter is null,
     // it is dynamic which is assignable to everything).
     if (setterType != null && getterType != null && !getterType.isAssignableTo(setterType)) {
       if (enclosingClassForCounterpart == null) {
         _errorReporter.reportErrorForNode(StaticWarningCode.MISMATCHED_GETTER_AND_SETTER_TYPES, accessorDeclaration, [
             accessorTextName,
             setterType.displayName,
             getterType.displayName]);
         return true;
       } else {
         _errorReporter.reportErrorForNode(StaticWarningCode.MISMATCHED_GETTER_AND_SETTER_TYPES_FROM_SUPERTYPE, accessorDeclaration, [
             accessorTextName,
             setterType.displayName,
             getterType.displayName,
             enclosingClassForCounterpart.displayName]);
       }
     }
     return false;
   }
 
   /**
    * This verifies that the given function body does not contain return statements that both have
    * and do not have return values.
    *
    * @param node the function body being tested
    * @return `true` if and only if an error code is generated on the passed node
    * @see StaticWarningCode#MIXED_RETURN_TYPES
    */
-  bool checkForMixedReturns(BlockFunctionBody node) {
+  bool _checkForMixedReturns(BlockFunctionBody node) {
     int withCount = _returnsWith.length;
     int withoutCount = _returnsWithout.length;
     if (withCount > 0 && withoutCount > 0) {
       for (int i = 0; i < withCount; i++) {
         _errorReporter.reportErrorForToken(StaticWarningCode.MIXED_RETURN_TYPES, _returnsWith[i].keyword, []);
       }
       for (int i = 0; i < withoutCount; i++) {
         _errorReporter.reportErrorForToken(StaticWarningCode.MIXED_RETURN_TYPES, _returnsWithout[i].keyword, []);
       }
       return true;
     }
     return false;
   }
 
   /**
    * This verifies that the passed mixin does not have an explicitly declared constructor.
    *
    * @param mixinName the node to report problem on
    * @param mixinElement the mixing to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#MIXIN_DECLARES_CONSTRUCTOR
    */
-  bool checkForMixinDeclaresConstructor(TypeName mixinName, ClassElement mixinElement) {
+  bool _checkForMixinDeclaresConstructor(TypeName mixinName, ClassElement mixinElement) {
     for (ConstructorElement constructor in mixinElement.constructors) {
       if (!constructor.isSynthetic && !constructor.isFactory) {
         _errorReporter.reportErrorForNode(CompileTimeErrorCode.MIXIN_DECLARES_CONSTRUCTOR, mixinName, [mixinElement.name]);
         return true;
       }
     }
     return false;
   }
 
   /**
    * This verifies that the passed mixin has the 'Object' superclass.
    *
    * @param mixinName the node to report problem on
    * @param mixinElement the mixing to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#MIXIN_INHERITS_FROM_NOT_OBJECT
    */
-  bool checkForMixinInheritsNotFromObject(TypeName mixinName, ClassElement mixinElement) {
+  bool _checkForMixinInheritsNotFromObject(TypeName mixinName, ClassElement mixinElement) {
     InterfaceType mixinSupertype = mixinElement.supertype;
     if (mixinSupertype != null) {
       if (!mixinSupertype.isObject || !mixinElement.isTypedef && mixinElement.mixins.length != 0) {
         _errorReporter.reportErrorForNode(CompileTimeErrorCode.MIXIN_INHERITS_FROM_NOT_OBJECT, mixinName, [mixinElement.name]);
         return true;
       }
     }
     return false;
   }
 
   /**
    * This verifies that the passed mixin does not reference 'super'.
    *
    * @param mixinName the node to report problem on
    * @param mixinElement the mixing to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#MIXIN_REFERENCES_SUPER
    */
-  bool checkForMixinReferencesSuper(TypeName mixinName, ClassElement mixinElement) {
+  bool _checkForMixinReferencesSuper(TypeName mixinName, ClassElement mixinElement) {
     if (mixinElement.hasReferenceToSuper) {
       _errorReporter.reportErrorForNode(CompileTimeErrorCode.MIXIN_REFERENCES_SUPER, mixinName, [mixinElement.name]);
     }
     return false;
   }
 
   /**
    * This verifies that the passed constructor has at most one 'super' initializer.
    *
    * @param node the constructor declaration to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#MULTIPLE_SUPER_INITIALIZERS
    */
-  bool checkForMultipleSuperInitializers(ConstructorDeclaration node) {
+  bool _checkForMultipleSuperInitializers(ConstructorDeclaration node) {
     int numSuperInitializers = 0;
     for (ConstructorInitializer initializer in node.initializers) {
       if (initializer is SuperConstructorInvocation) {
         numSuperInitializers++;
         if (numSuperInitializers > 1) {
           _errorReporter.reportErrorForNode(CompileTimeErrorCode.MULTIPLE_SUPER_INITIALIZERS, initializer, []);
         }
       }
     }
     return numSuperInitializers > 0;
   }
 
   /**
    * Checks to ensure that native function bodies can only in SDK code.
    *
    * @param node the native function body to test
    * @return `true` if and only if an error code is generated on the passed node
    * @see ParserErrorCode#NATIVE_FUNCTION_BODY_IN_NON_SDK_CODE
    */
-  bool checkForNativeFunctionBodyInNonSDKCode(NativeFunctionBody node) {
+  bool _checkForNativeFunctionBodyInNonSDKCode(NativeFunctionBody node) {
     if (!_isInSystemLibrary && !_hasExtUri) {
       _errorReporter.reportErrorForNode(ParserErrorCode.NATIVE_FUNCTION_BODY_IN_NON_SDK_CODE, node, []);
       return true;
     }
     return false;
   }
 
   /**
    * This verifies that the passed 'new' instance creation expression invokes existing constructor.
    *
    * This method assumes that the instance creation was tested to be 'new' before being called.
    *
    * @param node the instance creation expression to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * @see StaticWarningCode#NEW_WITH_UNDEFINED_CONSTRUCTOR
    */
-  bool checkForNewWithUndefinedConstructor(InstanceCreationExpression node) {
+  bool _checkForNewWithUndefinedConstructor(InstanceCreationExpression node) {
     // OK if resolved
     if (node.staticElement != null) {
       return false;
     }
     // prepare constructor name
     ConstructorName constructorName = node.constructorName;
     if (constructorName == null) {
       return false;
     }
     // prepare class name
@@ skipping 13 matching lines @@
   }
 
   /**
    * This checks that if the passed class declaration implicitly calls default constructor of its
    * superclass, there should be such default constructor - implicit or explicit.
    *
    * @param node the [ClassDeclaration] to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#NO_DEFAULT_SUPER_CONSTRUCTOR_IMPLICIT
    */
-  bool checkForNoDefaultSuperConstructorImplicit(ClassDeclaration node) {
+  bool _checkForNoDefaultSuperConstructorImplicit(ClassDeclaration node) {
     // do nothing if there is explicit constructor
     List<ConstructorElement> constructors = _enclosingClass.constructors;
     if (!constructors[0].isSynthetic) {
       return false;
     }
     // prepare super
     InterfaceType superType = _enclosingClass.supertype;
     if (superType == null) {
       return false;
     }
@@ skipping 19 matching lines @@
    * and interfaces.
    *
    * @param node the [ClassDeclaration] to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * @see StaticWarningCode#NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE
    * @see StaticWarningCode#NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_TWO
    * @see StaticWarningCode#NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_THREE
    * @see StaticWarningCode#NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_FOUR
    * @see StaticWarningCode#NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_FIVE_PLUS
    */
-  bool checkForNonAbstractClassInheritsAbstractMember(ClassDeclaration node) {
+  bool _checkForNonAbstractClassInheritsAbstractMember(ClassDeclaration node) {
     if (_enclosingClass.isAbstract) {
       return false;
     }
     //
     // Store in local sets the set of all method and accessor names
     //
     List<MethodElement> methods = _enclosingClass.methods;
     List<PropertyAccessorElement> accessors = _enclosingClass.accessors;
     Set<String> methodsInEnclosingClass = new Set<String>();
     for (MethodElement method in methods) {
@@ skipping 24 matching lines @@
         break;
       }
       // If the element is not synthetic and can be determined to be defined in Object, skip it.
       if (executableElt.enclosingElement != null && (executableElt.enclosingElement as ClassElement).type.isObject) {
         continue;
       }
       // Reference the type of the enclosing class
       InterfaceType enclosingType = _enclosingClass.type;
       // Check to see if some element is in local enclosing class that matches the name of the
       // required member.
-      if (isMemberInClassOrMixin(executableElt, _enclosingClass)) {
+      if (_isMemberInClassOrMixin(executableElt, _enclosingClass)) {
         // We do not have to verify that this implementation of the found method matches the
         // required function type: the set of StaticWarningCode.INVALID_METHOD_OVERRIDE_* warnings
         // break out the different specific situations.
         continue;
       }
       // First check to see if this element was declared in the superclass chain, in which case
       // there is already a concrete implementation.
       ExecutableElement elt = membersInheritedFromSuperclasses.get(executableElt.name);
       // Check to see if an element was found in the superclass chain with the correct name.
       if (elt != null) {
@@ skipping 64 matching lines @@
   }
 
   /**
    * Checks to ensure that the expressions that need to be of type bool, are. Otherwise an error is
    * reported on the expression.
    *
    * @param condition the conditional expression to test
    * @return `true` if and only if an error code is generated on the passed node
    * @see StaticTypeWarningCode#NON_BOOL_CONDITION
    */
-  bool checkForNonBoolCondition(Expression condition) {
-    Type2 conditionType = getStaticType(condition);
+  bool _checkForNonBoolCondition(Expression condition) {
+    Type2 conditionType = _getStaticType(condition);
     if (conditionType != null && !conditionType.isAssignableTo(_boolType)) {
       _errorReporter.reportErrorForNode(StaticTypeWarningCode.NON_BOOL_CONDITION, condition, []);
       return true;
     }
     return false;
   }
 
   /**
    * This verifies that the passed assert statement has either a 'bool' or '() -> bool' input.
    *
    * @param node the assert statement to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * @see StaticTypeWarningCode#NON_BOOL_EXPRESSION
    */
-  bool checkForNonBoolExpression(AssertStatement node) {
+  bool _checkForNonBoolExpression(AssertStatement node) {
     Expression expression = node.condition;
-    Type2 type = getStaticType(expression);
+    Type2 type = _getStaticType(expression);
     if (type is InterfaceType) {
       if (!type.isAssignableTo(_boolType)) {
         _errorReporter.reportErrorForNode(StaticTypeWarningCode.NON_BOOL_EXPRESSION, expression, []);
         return true;
       }
     } else if (type is FunctionType) {
       FunctionType functionType = type;
       if (functionType.typeArguments.length == 0 && !functionType.returnType.isAssignableTo(_boolType)) {
         _errorReporter.reportErrorForNode(StaticTypeWarningCode.NON_BOOL_EXPRESSION, expression, []);
         return true;
       }
     }
     return false;
   }
 
   /**
    * Checks to ensure that the given expression is assignable to bool.
    *
    * @param expression the expression expression to test
    * @return `true` if and only if an error code is generated on the passed node
    * @see StaticTypeWarningCode#NON_BOOL_NEGATION_EXPRESSION
    */
-  bool checkForNonBoolNegationExpression(Expression expression) {
-    Type2 conditionType = getStaticType(expression);
+  bool _checkForNonBoolNegationExpression(Expression expression) {
+    Type2 conditionType = _getStaticType(expression);
     if (conditionType != null && !conditionType.isAssignableTo(_boolType)) {
       _errorReporter.reportErrorForNode(StaticTypeWarningCode.NON_BOOL_NEGATION_EXPRESSION, expression, []);
       return true;
     }
     return false;
   }
 
   /**
    * This verifies the passed map literal either:
    * * has `const modifier`
    * * has explicit type arguments
    * * is not start of the statement
    *
    * @param node the map literal to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#NON_CONST_MAP_AS_EXPRESSION_STATEMENT
    */
-  bool checkForNonConstMapAsExpressionStatement(MapLiteral node) {
+  bool _checkForNonConstMapAsExpressionStatement(MapLiteral node) {
     // "const"
     if (node.constKeyword != null) {
       return false;
     }
     // has type arguments
     if (node.typeArguments != null) {
       return false;
     }
     // prepare statement
     Statement statement = node.getAncestor((node) => node is ExpressionStatement);
@@ skipping 10 matching lines @@
   }
 
   /**
    * This verifies the passed method declaration of operator `[]=`, has `void` return
    * type.
    *
    * @param node the method declaration to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * @see StaticWarningCode#NON_VOID_RETURN_FOR_OPERATOR
    */
-  bool checkForNonVoidReturnTypeForOperator(MethodDeclaration node) {
+  bool _checkForNonVoidReturnTypeForOperator(MethodDeclaration node) {
     // check that []= operator
     SimpleIdentifier name = node.name;
     if (name.name != "[]=") {
       return false;
     }
     // check return type
     TypeName typeName = node.returnType;
     if (typeName != null) {
       Type2 type = typeName.type;
       if (type != null && !type.isVoid) {
         _errorReporter.reportErrorForNode(StaticWarningCode.NON_VOID_RETURN_FOR_OPERATOR, typeName, []);
       }
     }
     // no warning
     return false;
   }
 
   /**
    * This verifies the passed setter has no return type or the `void` return type.
    *
    * @param typeName the type name to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * @see StaticWarningCode#NON_VOID_RETURN_FOR_SETTER
    */
-  bool checkForNonVoidReturnTypeForSetter(TypeName typeName) {
+  bool _checkForNonVoidReturnTypeForSetter(TypeName typeName) {
     if (typeName != null) {
       Type2 type = typeName.type;
       if (type != null && !type.isVoid) {
         _errorReporter.reportErrorForNode(StaticWarningCode.NON_VOID_RETURN_FOR_SETTER, typeName, []);
       }
     }
     return false;
   }
 
   /**
    * This verifies the passed operator-method declaration, does not have an optional parameter.
    *
    * This method assumes that the method declaration was tested to be an operator declaration before
    * being called.
    *
    * @param node the method declaration to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#OPTIONAL_PARAMETER_IN_OPERATOR
    */
-  bool checkForOptionalParameterInOperator(MethodDeclaration node) {
+  bool _checkForOptionalParameterInOperator(MethodDeclaration node) {
     FormalParameterList parameterList = node.parameters;
     if (parameterList == null) {
       return false;
     }
     bool foundError = false;
     NodeList<FormalParameter> formalParameters = parameterList.parameters;
     for (FormalParameter formalParameter in formalParameters) {
       if (formalParameter.kind.isOptional) {
         _errorReporter.reportErrorForNode(CompileTimeErrorCode.OPTIONAL_PARAMETER_IN_OPERATOR, formalParameter, []);
         foundError = true;
       }
     }
     return foundError;
   }
 
   /**
    * This checks for named optional parameters that begin with '_'.
    *
    * @param node the default formal parameter to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#PRIVATE_OPTIONAL_PARAMETER
    */
-  bool checkForPrivateOptionalParameter(FormalParameter node) {
+  bool _checkForPrivateOptionalParameter(FormalParameter node) {
     // should be named parameter
     if (node.kind != ParameterKind.NAMED) {
       return false;
     }
     // name should start with '_'
     SimpleIdentifier name = node.identifier;
     if (name.isSynthetic || !StringUtilities.startsWithChar(name.name, 0x5F)) {
       return false;
     }
     // report problem
     _errorReporter.reportErrorForNode(CompileTimeErrorCode.PRIVATE_OPTIONAL_PARAMETER, node, []);
     return true;
   }
 
   /**
    * This checks if the passed constructor declaration is the redirecting generative constructor and
    * references itself directly or indirectly.
    *
    * @param node the constructor declaration to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#RECURSIVE_CONSTRUCTOR_REDIRECT
    */
-  bool checkForRecursiveConstructorRedirect(ConstructorDeclaration node) {
+  bool _checkForRecursiveConstructorRedirect(ConstructorDeclaration node) {
     // we check generative constructor here
     if (node.factoryKeyword != null) {
       return false;
     }
     // try to find redirecting constructor invocation and analyzer it for recursion
     for (ConstructorInitializer initializer in node.initializers) {
       if (initializer is RedirectingConstructorInvocation) {
         // OK if no cycle
         ConstructorElement element = node.element;
-        if (!hasRedirectingFactoryConstructorCycle(element)) {
+        if (!_hasRedirectingFactoryConstructorCycle(element)) {
           return false;
         }
         // report error
         _errorReporter.reportErrorForNode(CompileTimeErrorCode.RECURSIVE_CONSTRUCTOR_REDIRECT, initializer, []);
         return true;
       }
     }
     // OK, no redirecting constructor invocation
     return false;
   }
 
   /**
    * This checks if the passed constructor declaration has redirected constructor and references
    * itself directly or indirectly.
    *
    * @param node the constructor declaration to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#RECURSIVE_FACTORY_REDIRECT
    */
-  bool checkForRecursiveFactoryRedirect(ConstructorDeclaration node) {
+  bool _checkForRecursiveFactoryRedirect(ConstructorDeclaration node) {
     // prepare redirected constructor
     ConstructorName redirectedConstructorNode = node.redirectedConstructor;
     if (redirectedConstructorNode == null) {
       return false;
     }
     // OK if no cycle
     ConstructorElement element = node.element;
-    if (!hasRedirectingFactoryConstructorCycle(element)) {
+    if (!_hasRedirectingFactoryConstructorCycle(element)) {
       return false;
     }
     // report error
     _errorReporter.reportErrorForNode(CompileTimeErrorCode.RECURSIVE_FACTORY_REDIRECT, redirectedConstructorNode, []);
     return true;
   }
 
   /**
    * This checks the class declaration is not a superinterface to itself.
    *
    * @param classElt the class element to test
    * @return `true` if and only if an error code is generated on the passed element
    * @see CompileTimeErrorCode#RECURSIVE_INTERFACE_INHERITANCE
    * @see CompileTimeErrorCode#RECURSIVE_INTERFACE_INHERITANCE_BASE_CASE_EXTENDS
    * @see CompileTimeErrorCode#RECURSIVE_INTERFACE_INHERITANCE_BASE_CASE_IMPLEMENTS
    */
-  bool checkForRecursiveInterfaceInheritance(ClassElement classElt) {
+  bool _checkForRecursiveInterfaceInheritance(ClassElement classElt) {
     if (classElt == null) {
       return false;
     }
-    return safeCheckForRecursiveInterfaceInheritance(classElt, new List<ClassElement>());
+    return _safeCheckForRecursiveInterfaceInheritance(classElt, new List<ClassElement>());
   }
 
   /**
    * This checks the passed constructor declaration has a valid combination of redirected
    * constructor invocation(s), super constructor invocations and field initializers.
    *
    * @param node the constructor declaration to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#DEFAULT_VALUE_IN_REDIRECTING_FACTORY_CONSTRUCTOR
    * @see CompileTimeErrorCode#FIELD_INITIALIZER_REDIRECTING_CONSTRUCTOR
    * @see CompileTimeErrorCode#MULTIPLE_REDIRECTING_CONSTRUCTOR_INVOCATIONS
    * @see CompileTimeErrorCode#SUPER_IN_REDIRECTING_CONSTRUCTOR
    */
-  bool checkForRedirectingConstructorErrorCodes(ConstructorDeclaration node) {
+  bool _checkForRedirectingConstructorErrorCodes(ConstructorDeclaration node) {
     bool errorReported = false;
     //
     // Check for default values in the parameters
     //
     ConstructorName redirectedConstructor = node.redirectedConstructor;
     if (redirectedConstructor != null) {
       for (FormalParameter parameter in node.parameters.parameters) {
         if (parameter is DefaultFormalParameter && parameter.defaultValue != null) {
           _errorReporter.reportErrorForNode(CompileTimeErrorCode.DEFAULT_VALUE_IN_REDIRECTING_FACTORY_CONSTRUCTOR, parameter.identifier, []);
           errorReported = true;
@@ skipping 29 matching lines @@
   }
 
   /**
    * This checks if the passed constructor declaration has redirected constructor and references
    * itself directly or indirectly.
    *
    * @param node the constructor declaration to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#REDIRECT_TO_NON_CONST_CONSTRUCTOR
    */
-  bool checkForRedirectToNonConstConstructor(ConstructorDeclaration node) {
+  bool _checkForRedirectToNonConstConstructor(ConstructorDeclaration node) {
     // prepare redirected constructor
     ConstructorName redirectedConstructorNode = node.redirectedConstructor;
     if (redirectedConstructorNode == null) {
       return false;
     }
     // prepare element
     ConstructorElement element = node.element;
     if (element == null) {
       return false;
     }
@@ skipping 15 matching lines @@
     return true;
   }
 
   /**
    * This checks that the rethrow is inside of a catch clause.
    *
    * @param node the rethrow expression to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#RETHROW_OUTSIDE_CATCH
    */
-  bool checkForRethrowOutsideCatch(RethrowExpression node) {
+  bool _checkForRethrowOutsideCatch(RethrowExpression node) {
     if (!_isInCatchClause) {
       _errorReporter.reportErrorForNode(CompileTimeErrorCode.RETHROW_OUTSIDE_CATCH, node, []);
       return true;
     }
     return false;
   }
 
   /**
    * This checks that if the the given constructor declaration is generative, then it does not have
    * an expression function body.
    *
    * @param node the constructor to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#RETURN_IN_GENERATIVE_CONSTRUCTOR
    */
-  bool checkForReturnInGenerativeConstructor(ConstructorDeclaration node) {
+  bool _checkForReturnInGenerativeConstructor(ConstructorDeclaration node) {
     // ignore factory
     if (node.factoryKeyword != null) {
       return false;
     }
     // block body (with possible return statement) is checked elsewhere
     FunctionBody body = node.body;
     if (body is! ExpressionFunctionBody) {
       return false;
     }
     // report error
     _errorReporter.reportErrorForNode(CompileTimeErrorCode.RETURN_IN_GENERATIVE_CONSTRUCTOR, body, []);
     return true;
   }
 
   /**
    * This checks that a type mis-match between the return type and the expressed return type by the
    * enclosing method or function.
    *
    * This method is called both by [checkForAllReturnStatementErrorCodes]
    * and [visitExpressionFunctionBody].
    *
    * @param returnExpression the returned expression to evaluate
    * @param expectedReturnType the expressed return type by the enclosing method or function
    * @return `true` if and only if an error code is generated on the passed node
    * @see StaticTypeWarningCode#RETURN_OF_INVALID_TYPE
    */
-  bool checkForReturnOfInvalidType(Expression returnExpression, Type2 expectedReturnType) {
-    Type2 staticReturnType = getStaticType(returnExpression);
+  bool _checkForReturnOfInvalidType(Expression returnExpression, Type2 expectedReturnType) {
+    Type2 staticReturnType = _getStaticType(returnExpression);
     if (expectedReturnType.isVoid) {
       if (staticReturnType.isVoid || staticReturnType.isDynamic || staticReturnType.isBottom) {
         return false;
       }
       _errorReporter.reportErrorForNode(StaticTypeWarningCode.RETURN_OF_INVALID_TYPE, returnExpression, [
           staticReturnType.displayName,
           expectedReturnType.displayName,
           _enclosingFunction.displayName]);
       return true;
     }
@@ skipping 12 matching lines @@
    * This checks the given "typeReference" and that the "name" is not the reference to an instance
    * member.
    *
    * @param typeReference the resolved [ClassElement] of the left hand side of the expression,
    *          or `null`, aka, the class element of 'C' in 'C.x', see
    *          [getTypeReference]
    * @param name the accessed name to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * @see StaticWarningCode#STATIC_ACCESS_TO_INSTANCE_MEMBER
    */
-  bool checkForStaticAccessToInstanceMember(ClassElement typeReference, SimpleIdentifier name) {
+  bool _checkForStaticAccessToInstanceMember(ClassElement typeReference, SimpleIdentifier name) {
     // OK, target is not a type
     if (typeReference == null) {
       return false;
     }
     // prepare member Element
     Element element = name.staticElement;
     if (element is! ExecutableElement) {
       return false;
     }
     ExecutableElement memberElement = element as ExecutableElement;
     // OK, static
     if (memberElement.isStatic) {
       return false;
     }
     // report problem
     _errorReporter.reportErrorForNode(StaticWarningCode.STATIC_ACCESS_TO_INSTANCE_MEMBER, name, [name.name]);
     return true;
   }
 
   /**
    * This checks that the type of the passed 'switch' expression is assignable to the type of the
    * 'case' members.
    *
    * @param node the 'switch' statement to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * @see StaticWarningCode#SWITCH_EXPRESSION_NOT_ASSIGNABLE
    */
-  bool checkForSwitchExpressionNotAssignable(SwitchStatement node) {
+  bool _checkForSwitchExpressionNotAssignable(SwitchStatement node) {
     // prepare 'switch' expression type
     Expression expression = node.expression;
-    Type2 expressionType = getStaticType(expression);
+    Type2 expressionType = _getStaticType(expression);
     if (expressionType == null) {
       return false;
     }
     // compare with type of the first 'case'
     NodeList<SwitchMember> members = node.members;
     for (SwitchMember switchMember in members) {
       if (switchMember is! SwitchCase) {
         continue;
       }
       SwitchCase switchCase = switchMember as SwitchCase;
       // prepare 'case' type
       Expression caseExpression = switchCase.expression;
-      Type2 caseType = getStaticType(caseExpression);
+      Type2 caseType = _getStaticType(caseExpression);
       // check types
       if (expressionType.isAssignableTo(caseType)) {
         return false;
       }
       // report problem
       _errorReporter.reportErrorForNode(StaticWarningCode.SWITCH_EXPRESSION_NOT_ASSIGNABLE, expression, [expressionType, caseType]);
       return true;
     }
     return false;
   }
 
   /**
    * This verifies that the passed function type alias does not reference itself directly.
    *
    * @param node the function type alias to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#TYPE_ALIAS_CANNOT_REFERENCE_ITSELF
    */
-  bool checkForTypeAliasCannotReferenceItself_function(FunctionTypeAlias node) {
+  bool _checkForTypeAliasCannotReferenceItself_function(FunctionTypeAlias node) {
     FunctionTypeAliasElement element = node.element;
-    if (!hasTypedefSelfReference(element)) {
+    if (!_hasTypedefSelfReference(element)) {
       return false;
     }
     _errorReporter.reportErrorForNode(CompileTimeErrorCode.TYPE_ALIAS_CANNOT_REFERENCE_ITSELF, node, []);
     return true;
   }
 
   /**
    * This verifies that the given class type alias does not reference itself.
    *
    * @return `true` if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#TYPE_ALIAS_CANNOT_REFERENCE_ITSELF
    */
-  bool checkForTypeAliasCannotReferenceItself_mixin(ClassTypeAlias node) {
+  bool _checkForTypeAliasCannotReferenceItself_mixin(ClassTypeAlias node) {
     ClassElement element = node.element;
-    if (!hasTypedefSelfReference(element)) {
+    if (!_hasTypedefSelfReference(element)) {
       return false;
     }
     _errorReporter.reportErrorForNode(CompileTimeErrorCode.TYPE_ALIAS_CANNOT_REFERENCE_ITSELF, node, []);
     return true;
   }
 
   /**
    * This verifies that the type arguments in the passed type name are all within their bounds.
    *
    * @param node the [TypeName] to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * @see StaticTypeWarningCode#TYPE_ARGUMENT_NOT_MATCHING_BOUNDS
    */
-  bool checkForTypeArgumentNotMatchingBounds(TypeName node) {
+  bool _checkForTypeArgumentNotMatchingBounds(TypeName node) {
     if (node.typeArguments == null) {
       return false;
     }
     // prepare Type
     Type2 type = node.type;
     if (type == null) {
       return false;
     }
     // prepare ClassElement
     Element element = type.element;
@@ skipping 31 matching lines @@
   }
 
   /**
    * This checks that if the passed type name is a type parameter being used to define a static
    * member.
    *
    * @param node the type name to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * @see StaticWarningCode#TYPE_PARAMETER_REFERENCED_BY_STATIC
    */
-  bool checkForTypeParameterReferencedByStatic(TypeName node) {
+  bool _checkForTypeParameterReferencedByStatic(TypeName node) {
     if (_isInStaticMethod || _isInStaticVariableDeclaration) {
       Type2 type = node.type;
       if (type is TypeParameterType) {
         _errorReporter.reportErrorForNode(StaticWarningCode.TYPE_PARAMETER_REFERENCED_BY_STATIC, node, []);
         return true;
       }
     }
     return false;
   }
 
   /**
    * This checks that if the passed type parameter is a supertype of its bound.
    *
    * @param node the type parameter to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * @see StaticTypeWarningCode#TYPE_PARAMETER_SUPERTYPE_OF_ITS_BOUND
    */
-  bool checkForTypeParameterSupertypeOfItsBound(TypeParameter node) {
+  bool _checkForTypeParameterSupertypeOfItsBound(TypeParameter node) {
     TypeParameterElement element = node.element;
     // prepare bound
     Type2 bound = element.bound;
     if (bound == null) {
       return false;
     }
     // OK, type parameter is not supertype of its bound
     if (!bound.isMoreSpecificThan(element.type)) {
       return false;
     }
     // report problem
     _errorReporter.reportErrorForNode(StaticTypeWarningCode.TYPE_PARAMETER_SUPERTYPE_OF_ITS_BOUND, node, [element.displayName]);
     return true;
   }
 
   /**
    * This checks that if the passed generative constructor has neither an explicit super constructor
    * invocation nor a redirecting constructor invocation, that the superclass has a default
    * generative constructor.
    *
    * @param node the constructor declaration to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#UNDEFINED_CONSTRUCTOR_IN_INITIALIZER_DEFAULT
    * @see CompileTimeErrorCode#NON_GENERATIVE_CONSTRUCTOR
    * @see StaticWarningCode#NO_DEFAULT_SUPER_CONSTRUCTOR_EXPLICIT
    */
-  bool checkForUndefinedConstructorInInitializerImplicit(ConstructorDeclaration node) {
+  bool _checkForUndefinedConstructorInInitializerImplicit(ConstructorDeclaration node) {
     //
     // Ignore if the constructor is not generative.
     //
     if (node.factoryKeyword != null) {
       return false;
     }
     //
     // Ignore if the constructor has either an implicit super constructor invocation or a
     // redirecting constructor invocation.
     //
@@ skipping 37 matching lines @@
   }
 
   /**
    * This checks that if the given name is a reference to a static member it is defined in the
    * enclosing class rather than in a superclass.
    *
    * @param name the name to be evaluated
    * @return `true` if and only if an error code is generated on the passed node
    * @see StaticTypeWarningCode#UNQUALIFIED_REFERENCE_TO_NON_LOCAL_STATIC_MEMBER
    */
-  bool checkForUnqualifiedReferenceToNonLocalStaticMember(SimpleIdentifier name) {
+  bool _checkForUnqualifiedReferenceToNonLocalStaticMember(SimpleIdentifier name) {
     Element element = name.staticElement;
     if (element == null || element is TypeParameterElement) {
       return false;
     }
     Element enclosingElement = element.enclosingElement;
     if (enclosingElement is! ClassElement) {
       return false;
     }
     if ((element is MethodElement && !element.isStatic) || (element is PropertyAccessorElement && !element.isStatic)) {
       return false;
     }
     if (identical(enclosingElement, _enclosingClass)) {
       return false;
     }
     _errorReporter.reportErrorForNode(StaticTypeWarningCode.UNQUALIFIED_REFERENCE_TO_NON_LOCAL_STATIC_MEMBER, name, [name.name]);
     return true;
   }
 
-  void checkForValidField(FieldFormalParameter node) {
+  void _checkForValidField(FieldFormalParameter node) {
     ParameterElement element = node.element;
     if (element is FieldFormalParameterElement) {
       FieldElement fieldElement = element.field;
       if (fieldElement == null || fieldElement.isSynthetic) {
         _errorReporter.reportErrorForNode(CompileTimeErrorCode.INITIALIZING_FORMAL_FOR_NON_EXISTANT_FIELD, node, [node.identifier.name]);
       } else {
         ParameterElement parameterElement = node.element;
         if (parameterElement is FieldFormalParameterElementImpl) {
           FieldFormalParameterElementImpl fieldFormal = parameterElement;
           Type2 declaredType = fieldFormal.type;
@@ skipping 19 matching lines @@
   /**
    * This verifies the passed operator-method declaration, has correct number of parameters.
    *
    * This method assumes that the method declaration was tested to be an operator declaration before
    * being called.
    *
    * @param node the method declaration to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#WRONG_NUMBER_OF_PARAMETERS_FOR_OPERATOR
    */
-  bool checkForWrongNumberOfParametersForOperator(MethodDeclaration node) {
+  bool _checkForWrongNumberOfParametersForOperator(MethodDeclaration node) {
     // prepare number of parameters
     FormalParameterList parameterList = node.parameters;
     if (parameterList == null) {
       return false;
     }
     int numParameters = parameterList.parameters.length;
     // prepare operator name
     SimpleIdentifier nameNode = node.name;
     if (nameNode == null) {
       return false;
@@ skipping 24 matching lines @@
   /**
    * This verifies if the passed setter parameter list have only one required parameter.
    *
    * This method assumes that the method declaration was tested to be a setter before being called.
    *
    * @param setterName the name of the setter to report problems on
    * @param parameterList the parameter list to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#WRONG_NUMBER_OF_PARAMETERS_FOR_SETTER
    */
-  bool checkForWrongNumberOfParametersForSetter(SimpleIdentifier setterName, FormalParameterList parameterList) {
+  bool _checkForWrongNumberOfParametersForSetter(SimpleIdentifier setterName, FormalParameterList parameterList) {
     if (setterName == null) {
       return false;
     }
     if (parameterList == null) {
       return false;
     }
     NodeList<FormalParameter> parameters = parameterList.parameters;
     if (parameters.length != 1 || parameters[0].kind != ParameterKind.REQUIRED) {
       _errorReporter.reportErrorForNode(CompileTimeErrorCode.WRONG_NUMBER_OF_PARAMETERS_FOR_SETTER, setterName, []);
       return true;
     }
     return false;
   }
 
   /**
    * This verifies that if the given class declaration implements the class Function that it has a
    * concrete implementation of the call method.
    *
    * @return `true` if and only if an error code is generated on the passed node
    * @see StaticWarningCode#FUNCTION_WITHOUT_CALL
    */
-  bool checkImplementsFunctionWithoutCall(ClassDeclaration node) {
+  bool _checkImplementsFunctionWithoutCall(ClassDeclaration node) {
     if (node.abstractKeyword != null) {
       return false;
     }
     ClassElement classElement = node.element;
     if (classElement == null) {
       return false;
     }
     if (!classElement.type.isSubtypeOf(_typeProvider.functionType)) {
       return false;
     }
     ExecutableElement callMethod = _inheritanceManager.lookupMember(classElement, "call");
     if (callMethod == null || callMethod is! MethodElement || (callMethod as MethodElement).isAbstract) {
       _errorReporter.reportErrorForNode(StaticWarningCode.FUNCTION_WITHOUT_CALL, node.name, []);
       return true;
     }
     return false;
   }
 
   /**
    * This verifies that the given class declaration does not have the same class in the 'extends'
    * and 'implements' clauses.
    *
    * @return `true` if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#IMPLEMENTS_SUPER_CLASS
    */
-  bool checkImplementsSuperClass(ClassDeclaration node) {
+  bool _checkImplementsSuperClass(ClassDeclaration node) {
     // prepare super type
     InterfaceType superType = _enclosingClass.supertype;
     if (superType == null) {
       return false;
     }
     // prepare interfaces
     ImplementsClause implementsClause = node.implementsClause;
     if (implementsClause == null) {
       return false;
     }
     // check interfaces
     bool hasProblem = false;
     for (TypeName interfaceNode in implementsClause.interfaces) {
       if (interfaceNode.type == superType) {
         hasProblem = true;
         _errorReporter.reportErrorForNode(CompileTimeErrorCode.IMPLEMENTS_SUPER_CLASS, interfaceNode, [superType.displayName]);
       }
     }
     // done
     return hasProblem;
   }
 
   /**
    * Return a display name for the given type that includes the path to the compilation unit in
    * which the type is defined.
    *
    * @param type the type for which an extended display name is to be returned
    * @return a display name that can help distiguish between two types with the same name
    */
-  String getExtendedDisplayName(Type2 type) {
+  String _getExtendedDisplayName(Type2 type) {
     Element element = type.element;
     if (element != null) {
       Source source = element.source;
       if (source != null) {
         return "${type.displayName} (${source.fullName})";
       }
     }
     return type.displayName;
   }
 
   /**
    * Returns the Type (return type) for a given getter.
    *
    * @param propertyAccessorElement
    * @return The type of the given getter.
    */
-  Type2 getGetterType(PropertyAccessorElement propertyAccessorElement) {
+  Type2 _getGetterType(PropertyAccessorElement propertyAccessorElement) {
     FunctionType functionType = propertyAccessorElement.type;
     if (functionType != null) {
       return functionType.returnType;
     } else {
       return null;
     }
   }
 
   /**
    * Returns the Type (first and only parameter) for a given setter.
    *
    * @param propertyAccessorElement
    * @return The type of the given setter.
    */
-  Type2 getSetterType(PropertyAccessorElement propertyAccessorElement) {
+  Type2 _getSetterType(PropertyAccessorElement propertyAccessorElement) {
     // Get the parameters for MethodDeclaration or FunctionDeclaration
     List<ParameterElement> setterParameters = propertyAccessorElement.parameters;
     // If there are no setter parameters, return no type.
     if (setterParameters.length == 0) {
       return null;
     }
     return setterParameters[0].type;
   }
 
   /**
    * Return the static type of the given expression that is to be used for type analysis.
    *
    * @param expression the expression whose type is to be returned
    * @return the static type of the given expression
    */
-  Type2 getStaticType(Expression expression) {
+  Type2 _getStaticType(Expression expression) {
     Type2 type = expression.staticType;
     if (type == null) {
       // TODO(brianwilkerson) This should never happen.
       return _dynamicType;
     }
     return type;
   }
 
   /**
    * Return the variable element represented by the given expression, or `null` if there is no
    * such element.
    *
    * @param expression the expression whose element is to be returned
    * @return the variable element represented by the expression
    */
-  VariableElement getVariableElement(Expression expression) {
+  VariableElement _getVariableElement(Expression expression) {
     if (expression is Identifier) {
       Element element = expression.staticElement;
       if (element is VariableElement) {
         return element;
       }
     }
     return null;
   }
 
   /**
    * @return `true` if the given constructor redirects to itself, directly or indirectly
    */
-  bool hasRedirectingFactoryConstructorCycle(ConstructorElement element) {
+  bool _hasRedirectingFactoryConstructorCycle(ConstructorElement element) {
     Set<ConstructorElement> constructors = new Set<ConstructorElement>();
     ConstructorElement current = element;
     while (current != null) {
       if (constructors.contains(current)) {
         return identical(current, element);
       }
       constructors.add(current);
       current = current.redirectedConstructor;
       if (current is ConstructorMember) {
         current = (current as ConstructorMember).baseElement;
       }
     }
     return false;
   }
 
   /**
    * @return <code>true</code> if given [Element] has direct or indirect reference to itself
    *         from anywhere except [ClassElement] or type parameter bounds.
    */
-  bool hasTypedefSelfReference(Element target) {
+  bool _hasTypedefSelfReference(Element target) {
     Set<Element> checked = new Set<Element>();
     List<Element> toCheck = new List<Element>();
     toCheck.add(target);
     bool firstIteration = true;
     while (true) {
       Element current;
       // get next element
       while (true) {
         // may be no more elements to check
         if (toCheck.isEmpty) {
@@ skipping 16 matching lines @@
       // check current element
       current.accept(new GeneralizingElementVisitor_ErrorVerifier_hasTypedefSelfReference(target, toCheck));
       checked.add(current);
     }
   }
 
   /**
    * @return `true` if given [Type] implements operator <i>==</i>, and it is not
    *         <i>int</i> or <i>String</i>.
    */
-  bool implementsEqualsWhenNotAllowed(Type2 type) {
+  bool _implementsEqualsWhenNotAllowed(Type2 type) {
     // ignore int or String
     if (type == null || type == _intType || type == _typeProvider.stringType) {
       return false;
     }
     // prepare ClassElement
     Element element = type.element;
     if (element is! ClassElement) {
       return false;
     }
     ClassElement classElement = element as ClassElement;
     // lookup for ==
     MethodElement method = classElement.lookUpMethod("==", _currentLibrary);
     if (method == null || method.enclosingElement.type.isObject) {
       return false;
     }
     // there is == that we don't like
     return true;
   }
 
-  bool isFunctionType(Type2 type) {
+  bool _isFunctionType(Type2 type) {
     if (type.isDynamic || type.isBottom) {
       return true;
     } else if (type is FunctionType || type.isDartCoreFunction) {
       return true;
     } else if (type is InterfaceType) {
       MethodElement callMethod = type.lookUpMethod(ElementResolver.CALL_METHOD_NAME, _currentLibrary);
       return callMethod != null;
     }
     return false;
   }
 
   /**
    * Return `true` iff the passed [ClassElement] has a method, getter or setter that
    * matches the name of the passed [ExecutableElement] in either the class itself, or one of
    * its' mixins.
    *
    * By "match", only the name of the member is tested to match, it does not have to equal or be a
    * subtype of the passed executable element, this is due to the specific use where this method is
    * used in [checkForNonAbstractClassInheritsAbstractMember].
    *
    * @param executableElt the executable to search for in the passed class element
    * @param classElt the class method to search through the members of
    * @return `true` iff the passed member is found in the passed class element
    */
-  bool isMemberInClassOrMixin(ExecutableElement executableElt, ClassElement classElt) {
+  bool _isMemberInClassOrMixin(ExecutableElement executableElt, ClassElement classElt) {
     ExecutableElement foundElt;
     String executableName = executableElt.name;
     if (executableElt is MethodElement) {
       foundElt = classElt.getMethod(executableName);
       if (foundElt != null) {
         return true;
       }
       List<InterfaceType> mixins = classElt.mixins;
       for (int i = 0; i < mixins.length && foundElt == null; i++) {
         foundElt = mixins[i].getMethod(executableName);
@@ skipping 20 matching lines @@
         return true;
       }
     }
     return false;
   }
 
   /**
    * @param node the 'this' expression to analyze
    * @return `true` if the given 'this' expression is in the valid context
    */
-  bool isThisInValidContext(ThisExpression node) {
+  bool _isThisInValidContext(ThisExpression node) {
     for (AstNode n = node; n != null; n = n.parent) {
       if (n is CompilationUnit) {
         return false;
       }
       if (n is ConstructorDeclaration) {
         ConstructorDeclaration constructor = n as ConstructorDeclaration;
         return constructor.factoryKeyword == null;
       }
       if (n is ConstructorInitializer) {
         return false;
       }
       if (n is MethodDeclaration) {
         MethodDeclaration method = n as MethodDeclaration;
         return !method.isStatic;
       }
     }
     return false;
   }
 
   /**
    * Return `true` if the given identifier is in a location where it is allowed to resolve to
    * a static member of a supertype.
    *
    * @param node the node being tested
    * @return `true` if the given identifier is in a location where it is allowed to resolve to
    *         a static member of a supertype
    */
-  bool isUnqualifiedReferenceToNonLocalStaticMemberAllowed(SimpleIdentifier node) {
+  bool _isUnqualifiedReferenceToNonLocalStaticMemberAllowed(SimpleIdentifier node) {
     if (node.inDeclarationContext()) {
       return true;
     }
     AstNode parent = node.parent;
     if (parent is ConstructorName || parent is MethodInvocation || parent is PropertyAccess || parent is SuperConstructorInvocation) {
       return true;
     }
     if (parent is PrefixedIdentifier && identical(parent.identifier, node)) {
       return true;
     }
     if (parent is Annotation && identical(parent.constructorName, node)) {
       return true;
     }
     if (parent is CommentReference) {
       CommentReference commentReference = parent;
       if (commentReference.newKeyword != null) {
         return true;
       }
     }
     return false;
   }
 
-  bool isUserDefinedObject(EvaluationResultImpl result) => result == null || (result is ValidResult && result.isUserDefinedObject);
+  bool _isUserDefinedObject(EvaluationResultImpl result) => result == null || (result is ValidResult && result.isUserDefinedObject);
 
   /**
    * This checks the class declaration is not a superinterface to itself.
    *
    * @param classElt the class element to test
    * @param path a list containing the potentially cyclic implements path
    * @return `true` if and only if an error code is generated on the passed element
    * @see CompileTimeErrorCode#RECURSIVE_INTERFACE_INHERITANCE
    * @see CompileTimeErrorCode#RECURSIVE_INTERFACE_INHERITANCE_BASE_CASE_EXTENDS
    * @see CompileTimeErrorCode#RECURSIVE_INTERFACE_INHERITANCE_BASE_CASE_IMPLEMENTS
    */
-  bool safeCheckForRecursiveInterfaceInheritance(ClassElement classElt, List<ClassElement> path) {
+  bool _safeCheckForRecursiveInterfaceInheritance(ClassElement classElt, List<ClassElement> path) {
     // Detect error condition.
     int size = path.length;
     // If this is not the base case (size > 0), and the enclosing class is the passed class
     // element then an error an error.
     if (size > 0 && _enclosingClass == classElt) {
       String enclosingClassName = _enclosingClass.displayName;
       if (size > 1) {
         // Construct a string showing the cyclic implements path: "A, B, C, D, A"
         String separator = ", ";
         JavaStringBuilder builder = new JavaStringBuilder();
@@ skipping 11 matching lines @@
         _errorReporter.reportErrorForOffset(errorCode, _enclosingClass.nameOffset, enclosingClassName.length, [enclosingClassName]);
         return true;
       }
     }
     if (path.indexOf(classElt) > 0) {
       return false;
     }
     path.add(classElt);
     // n-case
     InterfaceType supertype = classElt.supertype;
-    if (supertype != null && safeCheckForRecursiveInterfaceInheritance(supertype.element, path)) {
+    if (supertype != null && _safeCheckForRecursiveInterfaceInheritance(supertype.element, path)) {
       return true;
     }
     List<InterfaceType> interfaceTypes = classElt.interfaces;
     for (InterfaceType interfaceType in interfaceTypes) {
-      if (safeCheckForRecursiveInterfaceInheritance(interfaceType.element, path)) {
+      if (_safeCheckForRecursiveInterfaceInheritance(interfaceType.element, path)) {
         return true;
       }
     }
     path.removeAt(path.length - 1);
     return false;
   }
 }
 
 /**
  * This enum holds one of four states of a field initialization state through a constructor
@@ skipping 21 matching lines @@
 class GeneralizingElementVisitor_ErrorVerifier_hasTypedefSelfReference extends GeneralizingElementVisitor<Object> {
   Element target;
 
   List<Element> toCheck;
 
   GeneralizingElementVisitor_ErrorVerifier_hasTypedefSelfReference(this.target, this.toCheck) : super();
 
   bool _inClass = false;
 
   Object visitClassElement(ClassElement element) {
-    addTypeToCheck(element.supertype);
+    _addTypeToCheck(element.supertype);
     for (InterfaceType mixin in element.mixins) {
-      addTypeToCheck(mixin);
+      _addTypeToCheck(mixin);
     }
     _inClass = !element.isTypedef;
     try {
       return super.visitClassElement(element);
     } finally {
       _inClass = false;
     }
   }
 
   Object visitExecutableElement(ExecutableElement element) {
     if (element.isSynthetic) {
       return null;
     }
-    addTypeToCheck(element.returnType);
+    _addTypeToCheck(element.returnType);
     return super.visitExecutableElement(element);
   }
 
   Object visitFunctionTypeAliasElement(FunctionTypeAliasElement element) {
-    addTypeToCheck(element.returnType);
+    _addTypeToCheck(element.returnType);
     return super.visitFunctionTypeAliasElement(element);
   }
 
   Object visitParameterElement(ParameterElement element) {
-    addTypeToCheck(element.type);
+    _addTypeToCheck(element.type);
     return super.visitParameterElement(element);
   }
 
   Object visitTypeParameterElement(TypeParameterElement element) {
-    addTypeToCheck(element.bound);
+    _addTypeToCheck(element.bound);
     return super.visitTypeParameterElement(element);
   }
 
   Object visitVariableElement(VariableElement element) {
-    addTypeToCheck(element.type);
+    _addTypeToCheck(element.type);
     return super.visitVariableElement(element);
   }
 
-  void addTypeToCheck(Type2 type) {
+  void _addTypeToCheck(Type2 type) {
     if (type == null) {
       return;
     }
     Element element = type.element;
     // it is OK to reference target from class
     if (_inClass && target == element) {
       return;
     }
     // schedule for checking
     toCheck.add(element);
     // type arguments
     if (type is InterfaceType) {
       InterfaceType interfaceType = type;
       for (Type2 typeArgument in interfaceType.typeArguments) {
-        addTypeToCheck(typeArgument);
+        _addTypeToCheck(typeArgument);
       }
     }
   }
 }
 
 /**
  * The enumeration `ResolverErrorCode` defines the error codes used for errors detected by the
  * resolver. The convention for this class is for the name of the error code to indicate the problem
  * that caused the error to be generated and for the error message to explain what is wrong and,
  * when appropriate, how the problem can be corrected.
@@ skipping 42 matching lines @@
    * @param correction the template used to create the correction to be displayed for the error
    */
   ResolverErrorCode.con2(String name, int ordinal, this.type, this.message, String correction) : super(name, ordinal) {
     this.correction9 = correction;
   }
 
   String get correction => correction9;
 
   ErrorSeverity get errorSeverity => type.severity;
 }