Translate private Java members to private Dart members.

pkg/analyzer/lib/src/generated/element.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.element;
 
 import 'dart:collection';
@@ skipping 2518 matching lines @@
    * @param name the name of this element
    */
   ClassElementImpl(Identifier name) : super.con1(name);
 
   accept(ElementVisitor visitor) => visitor.visitClassElement(this);
 
   List<PropertyAccessorElement> get accessors => _accessors;
 
   List<InterfaceType> get allSupertypes {
     List<InterfaceType> list = new List<InterfaceType>();
-    collectAllSupertypes(list);
+    _collectAllSupertypes(list);
     return new List.from(list);
   }
 
   ElementImpl getChild(String identifier) {
     //
     // The casts in this method are safe because the set methods would have thrown a CCE if any of
     // the elements in the arrays were not of the expected types.
     //
     for (PropertyAccessorElement accessor in _accessors) {
       if ((accessor as PropertyAccessorElementImpl).identifier == identifier) {
@@ skipping 127 matching lines @@
       }
     }
     // not found
     return false;
   }
 
   bool get hasReferenceToSuper => hasModifier(Modifier.REFERENCES_SUPER);
 
   bool get isAbstract => hasModifier(Modifier.ABSTRACT);
 
-  bool get isOrInheritsProxy => safeIsOrInheritsProxy(this, new Set<ClassElement>());
+  bool get isOrInheritsProxy => _safeIsOrInheritsProxy(this, new Set<ClassElement>());
 
   bool get isProxy {
     for (ElementAnnotation annotation in metadata) {
       if (annotation.isProxy) {
         return true;
       }
     }
     return false;
   }
 
@@ skipping 213 matching lines @@
       for (int i = 0; i < variableCount; i++) {
         if (i > 0) {
           builder.append(", ");
         }
         (_typeParameters[i] as TypeParameterElementImpl).appendTo(builder);
       }
       builder.append(">");
     }
   }
 
-  void collectAllSupertypes(List<InterfaceType> supertypes) {
+  void _collectAllSupertypes(List<InterfaceType> supertypes) {
     List<InterfaceType> typesToVisit = new List<InterfaceType>();
     List<ClassElement> visitedClasses = new List<ClassElement>();
     typesToVisit.add(this.type);
     while (!typesToVisit.isEmpty) {
       InterfaceType currentType = typesToVisit.removeAt(0);
       ClassElement currentElement = currentType.element;
       if (!visitedClasses.contains(currentElement)) {
         visitedClasses.add(currentElement);
         if (currentType != this.type) {
           supertypes.add(currentType);
         }
         InterfaceType supertype = currentType.superclass;
         if (supertype != null) {
           typesToVisit.add(supertype);
         }
         for (InterfaceType type in currentElement.interfaces) {
           typesToVisit.add(type);
         }
         for (InterfaceType type in currentElement.mixins) {
           ClassElement element = type.element;
           if (!visitedClasses.contains(element)) {
             supertypes.add(type);
           }
         }
       }
     }
   }
 
-  bool safeIsOrInheritsProxy(ClassElement classElt, Set<ClassElement> visitedClassElts) {
+  bool _safeIsOrInheritsProxy(ClassElement classElt, Set<ClassElement> visitedClassElts) {
     if (visitedClassElts.contains(classElt)) {
       return false;
     }
     visitedClassElts.add(classElt);
     if (classElt.isProxy) {
       return true;
-    } else if (classElt.supertype != null && safeIsOrInheritsProxy(classElt.supertype.element, visitedClassElts)) {
+    } else if (classElt.supertype != null && _safeIsOrInheritsProxy(classElt.supertype.element, visitedClassElts)) {
       return true;
     }
     List<InterfaceType> supertypes = classElt.interfaces;
     for (int i = 0; i < supertypes.length; i++) {
-      if (safeIsOrInheritsProxy(supertypes[i].element, visitedClassElts)) {
+      if (_safeIsOrInheritsProxy(supertypes[i].element, visitedClassElts)) {
         return true;
       }
     }
     supertypes = classElt.mixins;
     for (int i = 0; i < supertypes.length; i++) {
-      if (safeIsOrInheritsProxy(supertypes[i].element, visitedClassElts)) {
+      if (_safeIsOrInheritsProxy(supertypes[i].element, visitedClassElts)) {
         return true;
       }
     }
     return false;
   }
 }
 
 /**
  * Instances of the class `CompilationUnitElementImpl` implement a
  * [CompilationUnitElement].
@@ skipping 216 matching lines @@
   }
 
   String get identifier => source.encoding;
 
   /**
    * Returns the associated toolkit objects.
    *
    * @param element the [Element] to get toolkit objects for
    * @return the associated toolkit objects, may be empty, but not `null`
    */
-  List<ToolkitObjectElement> getToolkitObjects(Element element) {
+  List<ToolkitObjectElement> _getToolkitObjects(Element element) {
     List<ToolkitObjectElement> objects = _toolkitObjects[element];
     if (objects != null) {
       return objects;
     }
     return ToolkitObjectElement.EMPTY_ARRAY;
   }
 
   /**
    * Sets the toolkit objects that are associated with the given [Element].
    *
    * @param element the [Element] to associate toolkit objects with
    * @param objects the toolkit objects to associate
    */
-  void setToolkitObjects(Element element, List<ToolkitObjectElement> objects) {
+  void _setToolkitObjects(Element element, List<ToolkitObjectElement> objects) {
     _toolkitObjects[element] = objects;
   }
 }
 
 /**
  * Instances of the class `ConstFieldElementImpl` implement a `FieldElement` for a
  * 'const' field that has an initializer.
  */
 class ConstFieldElementImpl extends FieldElementImpl {
   /**
@@ skipping 631 matching lines @@
     }
     this._components = new List.from(components);
   }
 
   /**
    * Initialize a newly created location from the given encoded form.
    *
    * @param encoding the encoded form of a location
    */
   ElementLocationImpl.con2(String encoding) {
-    this._components = decode(encoding);
+    this._components = _decode(encoding);
   }
 
   bool operator ==(Object object) {
     if (identical(this, object)) {
       return true;
     }
     if (object is! ElementLocationImpl) {
       return false;
     }
     ElementLocationImpl location = object as ElementLocationImpl;
     List<String> otherComponents = location._components;
     int length = _components.length;
     if (otherComponents.length != length) {
       return false;
     }
     for (int i = length - 1; i >= 2; i--) {
       if (_components[i] != otherComponents[i]) {
         return false;
       }
     }
-    if (length > 1 && !equalSourceComponents(_components[1], otherComponents[1])) {
+    if (length > 1 && !_equalSourceComponents(_components[1], otherComponents[1])) {
       return false;
     }
-    if (length > 0 && !equalSourceComponents(_components[0], otherComponents[0])) {
+    if (length > 0 && !_equalSourceComponents(_components[0], otherComponents[0])) {
       return false;
     }
     return true;
   }
 
   /**
    * Return the path to the element whose location is represented by this object.
    *
    * @return the path to the element whose location is represented by this object
    */
   List<String> get components => _components;
 
   String get encoding {
     JavaStringBuilder builder = new JavaStringBuilder();
     int length = _components.length;
     for (int i = 0; i < length; i++) {
       if (i > 0) {
         builder.appendChar(_SEPARATOR_CHAR);
       }
-      encode(builder, _components[i]);
+      _encode(builder, _components[i]);
     }
     return builder.toString();
   }
 
   int get hashCode {
     int result = 1;
     for (int i = 0; i < _components.length; i++) {
       String component = _components[i];
       int componentHash;
       if (i <= 1) {
-        componentHash = hashSourceComponent(component);
+        componentHash = _hashSourceComponent(component);
       } else {
         componentHash = component.hashCode;
       }
       result = 31 * result + componentHash;
     }
     return result;
   }
 
   String toString() => encoding;
 
   /**
    * Decode the encoded form of a location into an array of components.
    *
    * @param encoding the encoded form of a location
    * @return the components that were encoded
    */
-  List<String> decode(String encoding) {
+  List<String> _decode(String encoding) {
     List<String> components = new List<String>();
     JavaStringBuilder builder = new JavaStringBuilder();
     int index = 0;
     int length = encoding.length;
     while (index < length) {
       int currentChar = encoding.codeUnitAt(index);
       if (currentChar == _SEPARATOR_CHAR) {
         if (index + 1 < length && encoding.codeUnitAt(index + 1) == _SEPARATOR_CHAR) {
           builder.appendChar(_SEPARATOR_CHAR);
           index += 2;
@@ skipping 12 matching lines @@
     }
     return new List.from(components);
   }
 
   /**
    * Append an encoded form of the given component to the given builder.
    *
    * @param builder the builder to which the encoded component is to be appended
    * @param component the component to be appended to the builder
    */
-  void encode(JavaStringBuilder builder, String component) {
+  void _encode(JavaStringBuilder builder, String component) {
     int length = component.length;
     for (int i = 0; i < length; i++) {
       int currentChar = component.codeUnitAt(i);
       if (currentChar == _SEPARATOR_CHAR) {
         builder.appendChar(_SEPARATOR_CHAR);
       }
       builder.appendChar(currentChar);
     }
   }
 
   /**
    * Return `true` if the given components, when interpreted to be encoded sources with a
    * leading source type indicator, are equal when the source type's are ignored.
    *
    * @param left the left component being compared
    * @param right the right component being compared
    * @return `true` if the given components are equal when the source type's are ignored
    */
-  bool equalSourceComponents(String left, String right) {
+  bool _equalSourceComponents(String left, String right) {
     // TODO(brianwilkerson) This method can go away when sources no longer have a URI kind.
     if (left == null) {
       return right == null;
     } else if (right == null) {
       return false;
     }
     int leftLength = left.length;
     int rightLength = right.length;
     if (leftLength != rightLength) {
       return false;
     } else if (leftLength <= 1 || rightLength <= 1) {
       return left == right;
     }
     return javaStringRegionMatches(left, 1, right, 1, leftLength - 1);
   }
 
   /**
    * Return the hash code of the given encoded source component, ignoring the source type indicator.
    *
    * @param sourceComponent the component to compute a hash code
    * @return the hash code of the given encoded source component
    */
-  int hashSourceComponent(String sourceComponent) {
+  int _hashSourceComponent(String sourceComponent) {
     // TODO(brianwilkerson) This method can go away when sources no longer have a URI kind.
     if (sourceComponent.length <= 1) {
       return sourceComponent.hashCode;
     }
     return sourceComponent.substring(1).hashCode;
   }
 }
 
 /**
  * The class `ElementPair` is a pair of [Element]s. [Object#equals] and
@@ skipping 872 matching lines @@
    */
   static List<LibraryElement> EMPTY_ARRAY = new List<LibraryElement>(0);
 
   /**
    * Determine if the given library is up to date with respect to the given time stamp.
    *
    * @param library the library to process
    * @param timeStamp the time stamp to check against
    * @param visitedLibraries the set of visited libraries
    */
-  static bool safeIsUpToDate(LibraryElement library, int timeStamp, Set<LibraryElement> visitedLibraries) {
+  static bool _safeIsUpToDate(LibraryElement library, int timeStamp, Set<LibraryElement> visitedLibraries) {
     if (!visitedLibraries.contains(library)) {
       visitedLibraries.add(library);
       AnalysisContext context = library.context;
       // Check the defining compilation unit.
       if (timeStamp < context.getModificationStamp(library.definingCompilationUnit.source)) {
         return false;
       }
       // Check the parted compilation units.
       for (CompilationUnitElement element in library.parts) {
         if (timeStamp < context.getModificationStamp(element.source)) {
           return false;
         }
       }
       // Check the imported libraries.
       for (LibraryElement importedLibrary in library.importedLibraries) {
-        if (!safeIsUpToDate(importedLibrary, timeStamp, visitedLibraries)) {
+        if (!_safeIsUpToDate(importedLibrary, timeStamp, visitedLibraries)) {
           return false;
         }
       }
       // Check the exported libraries.
       for (LibraryElement exportedLibrary in library.exportedLibraries) {
-        if (!safeIsUpToDate(exportedLibrary, timeStamp, visitedLibraries)) {
+        if (!_safeIsUpToDate(exportedLibrary, timeStamp, visitedLibraries)) {
           return false;
         }
       }
     }
     return true;
   }
 
   /**
    * The analysis context in which this library is defined.
    */
@@ skipping 21 matching lines @@
 
   /**
    * An array containing all of the compilation units that are included in this library using a
    * `part` directive.
    */
   List<CompilationUnitElement> _parts = CompilationUnitElementImpl.EMPTY_ARRAY;
 
   /**
    * Is `true` if this library is created for Angular analysis.
    */
-  bool _isAngularHtml2 = false;
+  bool _isAngularHtml = false;
 
   /**
    * Initialize a newly created library element to have the given name.
    *
    * @param context the analysis context in which the library is defined
    * @param name the name of this element
    */
   LibraryElementImpl(this.context, LibraryIdentifier name) : super.con1(name);
 
   accept(ElementVisitor visitor) => visitor.visitLibraryElement(this);
@@ skipping 90 matching lines @@
 
   List<CompilationUnitElement> get units {
     List<CompilationUnitElement> units = new List<CompilationUnitElement>(1 + _parts.length);
     units[0] = _definingCompilationUnit;
     JavaSystem.arraycopy(_parts, 0, units, 1, _parts.length);
     return units;
   }
 
   List<LibraryElement> get visibleLibraries {
     Set<LibraryElement> visibleLibraries = new Set();
-    addVisibleLibraries(visibleLibraries, false);
+    _addVisibleLibraries(visibleLibraries, false);
     return new List.from(visibleLibraries);
   }
 
   bool get hasExtUri => hasModifier(Modifier.HAS_EXT_URI);
 
   int get hashCode => _definingCompilationUnit.hashCode;
 
-  bool get isAngularHtml => _isAngularHtml2;
+  bool get isAngularHtml => _isAngularHtml;
 
   bool get isBrowserApplication => entryPoint != null && isOrImportsBrowserLibrary;
 
   bool get isDartCore => name == "dart.core";
 
   bool get isInSdk => StringUtilities.startsWith5(name, 0, 0x64, 0x61, 0x72, 0x74, 0x2E);
 
   bool isUpToDate(int timeStamp) {
     Set<LibraryElement> visitedLibraries = new Set();
-    return safeIsUpToDate(this, timeStamp, visitedLibraries);
+    return _safeIsUpToDate(this, timeStamp, visitedLibraries);
   }
 
   /**
    * Specifies if this library is created for Angular analysis.
    */
   void set angularHtml(bool isAngularHtml) {
-    this._isAngularHtml2 = isAngularHtml;
+    this._isAngularHtml = isAngularHtml;
   }
 
   /**
    * Set the compilation unit that defines this library to the given compilation unit.
    *
    * @param definingCompilationUnit the compilation unit that defines this library
    */
   void set definingCompilationUnit(CompilationUnitElement definingCompilationUnit) {
     (definingCompilationUnit as CompilationUnitElementImpl).enclosingElement = this;
     this._definingCompilationUnit = definingCompilationUnit;
@@ skipping 55 matching lines @@
     safelyVisitChildren(_exports, visitor);
     safelyVisitChildren(_imports, visitor);
     safelyVisitChildren(_parts, visitor);
   }
 
   String get identifier => _definingCompilationUnit.source.encoding;
 
   /**
    * Recursively fills set of visible libraries for [getVisibleElementsLibraries].
    */
-  void addVisibleLibraries(Set<LibraryElement> visibleLibraries, bool includeExports) {
+  void _addVisibleLibraries(Set<LibraryElement> visibleLibraries, bool includeExports) {
     // maybe already processed
     if (!visibleLibraries.add(this)) {
       return;
     }
     // add imported libraries
     for (ImportElement importElement in _imports) {
       LibraryElement importedLibrary = importElement.importedLibrary;
       if (importedLibrary != null) {
-        (importedLibrary as LibraryElementImpl).addVisibleLibraries(visibleLibraries, true);
+        (importedLibrary as LibraryElementImpl)._addVisibleLibraries(visibleLibraries, true);
       }
     }
     // add exported libraries
     if (includeExports) {
       for (ExportElement exportElement in _exports) {
         LibraryElement exportedLibrary = exportElement.exportedLibrary;
         if (exportedLibrary != null) {
-          (exportedLibrary as LibraryElementImpl).addVisibleLibraries(visibleLibraries, true);
+          (exportedLibrary as LibraryElementImpl)._addVisibleLibraries(visibleLibraries, true);
         }
       }
     }
   }
 
   /**
    * Answer `true` if the receiver directly or indirectly imports the dart:html libraries.
    *
    * @return `true` if the receiver directly or indirectly imports the dart:html libraries
    */
@@ skipping 61 matching lines @@
 
   accept(ElementVisitor visitor) => visitor.visitLocalVariableElement(this);
 
   ElementKind get kind => ElementKind.LOCAL_VARIABLE;
 
   List<ToolkitObjectElement> get toolkitObjects {
     CompilationUnitElementImpl unit = getAncestor((element) => element is CompilationUnitElementImpl);
     if (unit == null) {
       return ToolkitObjectElement.EMPTY_ARRAY;
     }
-    return unit.getToolkitObjects(this);
+    return unit._getToolkitObjects(this);
   }
 
   SourceRange get visibleRange {
     if (_visibleRangeLength < 0) {
       return null;
     }
     return new SourceRange(_visibleRangeOffset, _visibleRangeLength);
   }
 
   bool get isPotentiallyMutatedInClosure => _potentiallyMutatedInClosure;
@@ skipping 17 matching lines @@
   /**
    * Set the toolkit specific information objects attached to this variable.
    *
    * @param toolkitObjects the toolkit objects attached to this variable
    */
   void set toolkitObjects(List<ToolkitObjectElement> toolkitObjects) {
     CompilationUnitElementImpl unit = getAncestor((element) => element is CompilationUnitElementImpl);
     if (unit == null) {
       return;
     }
-    unit.setToolkitObjects(this, toolkitObjects);
+    unit._setToolkitObjects(this, toolkitObjects);
   }
 
   /**
    * Set the visible range for this element to the range starting at the given offset with the given
    * length.
    *
    * @param offset the offset to the beginning of the visible range for this element
    * @param length the length of the visible range for this element, or `-1` if this element
    *          does not have a visible range
    */
@@ skipping 175 matching lines @@
  */
 class MultiplyDefinedElementImpl implements MultiplyDefinedElement {
   /**
    * Return an element that represents the given conflicting elements.
    *
    * @param context the analysis context in which the multiply defined elements are defined
    * @param firstElement the first element that conflicts
    * @param secondElement the second element that conflicts
    */
   static Element fromElements(AnalysisContext context, Element firstElement, Element secondElement) {
-    List<Element> conflictingElements = computeConflictingElements(firstElement, secondElement);
+    List<Element> conflictingElements = _computeConflictingElements(firstElement, secondElement);
     int length = conflictingElements.length;
     if (length == 0) {
       return null;
     } else if (length == 1) {
       return conflictingElements[0];
     }
     return new MultiplyDefinedElementImpl(context, conflictingElements);
   }
 
   /**
    * Add the given element to the list of elements. If the element is a multiply-defined element,
    * add all of the conflicting elements that it represents.
    *
    * @param elements the list to which the element(s) are to be added
    * @param element the element(s) to be added
    */
-  static void add(Set<Element> elements, Element element) {
+  static void _add(Set<Element> elements, Element element) {
     if (element is MultiplyDefinedElementImpl) {
       for (Element conflictingElement in element.conflictingElements) {
         elements.add(conflictingElement);
       }
     } else {
       elements.add(element);
     }
   }
 
   /**
    * Use the given elements to construct an array of conflicting elements. If either of the given
    * elements are multiply-defined elements then the conflicting elements they represent will be
    * included in the array. Otherwise, the element itself will be included.
    *
    * @param firstElement the first element to be included
    * @param secondElement the second element to be included
    * @return an array containing all of the conflicting elements
    */
-  static List<Element> computeConflictingElements(Element firstElement, Element secondElement) {
+  static List<Element> _computeConflictingElements(Element firstElement, Element secondElement) {
     Set<Element> elements = new Set<Element>();
-    add(elements, firstElement);
-    add(elements, secondElement);
+    _add(elements, firstElement);
+    _add(elements, secondElement);
     return new List.from(elements);
   }
 
   /**
    * The analysis context in which the multiply defined elements are defined.
    */
   final AnalysisContext context;
 
   /**
    * The name of the conflicting elements.
@@ skipping 2027 matching lines @@
    * Return `true` if all of the name/type pairs in the first map are equal to the
    * corresponding name/type pairs in the second map. The maps are expected to iterate over their
    * entries in the same order in which those entries were added to the map.
    *
    * @param firstTypes the first map of name/type pairs being compared
    * @param secondTypes the second map of name/type pairs being compared
    * @param visitedElementPairs a set of visited element pairs
    * @return `true` if all of the name/type pairs in the first map are equal to the
    *         corresponding name/type pairs in the second map
    */
-  static bool equals2(Map<String, Type2> firstTypes, Map<String, Type2> secondTypes, Set<ElementPair> visitedElementPairs) {
+  static bool _equals(Map<String, Type2> firstTypes, Map<String, Type2> secondTypes, Set<ElementPair> visitedElementPairs) {
     if (secondTypes.length != firstTypes.length) {
       return false;
     }
     JavaIterator<MapEntry<String, Type2>> firstIterator = new JavaIterator(getMapEntrySet(firstTypes));
     JavaIterator<MapEntry<String, Type2>> secondIterator = new JavaIterator(getMapEntrySet(secondTypes));
     while (firstIterator.hasNext) {
       MapEntry<String, Type2> firstEntry = firstIterator.next();
       MapEntry<String, Type2> secondEntry = secondIterator.next();
       if (firstEntry.getKey() != secondEntry.getKey() || !(firstEntry.getValue() as TypeImpl).internalEquals(secondEntry.getValue(), visitedElementPairs)) {
         return false;
@@ skipping 220 matching lines @@
       return false;
     }
     // named parameters case
     if (t.namedParameterTypes.length > 0) {
       // check that the number of required parameters are equal, and check that every t_i is
       // more specific than every s_i
       if (t.normalParameterTypes.length != s.normalParameterTypes.length) {
         return false;
       } else if (t.normalParameterTypes.length > 0) {
         for (int i = 0; i < tTypes.length; i++) {
-          if (!(tTypes[i] as TypeImpl).isMoreSpecificThan3(sTypes[i], withDynamic, visitedTypePairs)) {
+          if (!(tTypes[i] as TypeImpl).isMoreSpecificThan2(sTypes[i], withDynamic, visitedTypePairs)) {
             return false;
           }
         }
       }
       Map<String, Type2> namedTypesT = t.namedParameterTypes;
       Map<String, Type2> namedTypesS = s.namedParameterTypes;
       // if k >= m is false, return false: the passed function type has more named parameter types than this
       if (namedTypesT.length < namedTypesS.length) {
         return false;
       }
       // Loop through each element in S verifying that T has a matching parameter name and that the
       // corresponding type is more specific then the type in S.
       JavaIterator<MapEntry<String, Type2>> iteratorS = new JavaIterator(getMapEntrySet(namedTypesS));
       while (iteratorS.hasNext) {
         MapEntry<String, Type2> entryS = iteratorS.next();
         Type2 typeT = namedTypesT[entryS.getKey()];
         if (typeT == null) {
           return false;
         }
-        if (!(typeT as TypeImpl).isMoreSpecificThan3(entryS.getValue(), withDynamic, visitedTypePairs)) {
+        if (!(typeT as TypeImpl).isMoreSpecificThan2(entryS.getValue(), withDynamic, visitedTypePairs)) {
           return false;
         }
       }
     } else if (s.namedParameterTypes.length > 0) {
       return false;
     } else {
       // positional parameter case
       int tArgLength = tTypes.length + tOpTypes.length;
       int sArgLength = sTypes.length + sOpTypes.length;
       // Check that the total number of parameters in t is greater than or equal to the number of
       // parameters in s and that the number of required parameters in s is greater than or equal to
       // the number of required parameters in t.
       if (tArgLength < sArgLength || sTypes.length < tTypes.length) {
         return false;
       }
       if (tOpTypes.length == 0 && sOpTypes.length == 0) {
         // No positional arguments, don't copy contents to new array
         for (int i = 0; i < sTypes.length; i++) {
-          if (!(tTypes[i] as TypeImpl).isMoreSpecificThan3(sTypes[i], withDynamic, visitedTypePairs)) {
+          if (!(tTypes[i] as TypeImpl).isMoreSpecificThan2(sTypes[i], withDynamic, visitedTypePairs)) {
             return false;
           }
         }
       } else {
         // Else, we do have positional parameters, copy required and positional parameter types into
         // arrays to do the compare (for loop below).
         List<Type2> tAllTypes = new List<Type2>(sArgLength);
         for (int i = 0; i < tTypes.length; i++) {
           tAllTypes[i] = tTypes[i];
         }
         for (int i = tTypes.length, j = 0; i < sArgLength; i++, j++) {
           tAllTypes[i] = tOpTypes[j];
         }
         List<Type2> sAllTypes = new List<Type2>(sArgLength);
         for (int i = 0; i < sTypes.length; i++) {
           sAllTypes[i] = sTypes[i];
         }
         for (int i = sTypes.length, j = 0; i < sArgLength; i++, j++) {
           sAllTypes[i] = sOpTypes[j];
         }
         for (int i = 0; i < sAllTypes.length; i++) {
-          if (!(tAllTypes[i] as TypeImpl).isMoreSpecificThan3(sAllTypes[i], withDynamic, visitedTypePairs)) {
+          if (!(tAllTypes[i] as TypeImpl).isMoreSpecificThan2(sAllTypes[i], withDynamic, visitedTypePairs)) {
             return false;
           }
         }
       }
     }
     Type2 tRetType = t.returnType;
     Type2 sRetType = s.returnType;
-    return sRetType.isVoid || (tRetType as TypeImpl).isMoreSpecificThan3(sRetType, withDynamic, visitedTypePairs);
+    return sRetType.isVoid || (tRetType as TypeImpl).isMoreSpecificThan2(sRetType, withDynamic, visitedTypePairs);
   }
 
-  bool isAssignableTo(Type2 type) => isSubtypeOf3(type, new Set<TypeImpl_TypePair>());
+  bool isAssignableTo(Type2 type) => isSubtypeOf2(type, new Set<TypeImpl_TypePair>());
 
   FunctionTypeImpl substitute3(List<Type2> argumentTypes) => substitute2(argumentTypes, typeArguments);
 
   FunctionTypeImpl substitute2(List<Type2> argumentTypes, List<Type2> parameterTypes) {
     if (argumentTypes.length != parameterTypes.length) {
       throw new IllegalArgumentException("argumentTypes.length (${argumentTypes.length}) != parameterTypes.length (${parameterTypes.length})");
     }
     if (argumentTypes.length == 0) {
       return this;
     }
@@ skipping 81 matching lines @@
     if (object is! FunctionTypeImpl) {
       return false;
     }
     FunctionTypeImpl otherType = object as FunctionTypeImpl;
     // If the visitedTypePairs already has the pair (this, type), use the elements to determine equality
     ElementPair elementPair = new ElementPair(element, otherType.element);
     if (!visitedElementPairs.add(elementPair)) {
       return elementPair.firstElt == elementPair.secondElt;
     }
     // Compute the result
-    bool result = TypeImpl.equalArrays(normalParameterTypes, otherType.normalParameterTypes, visitedElementPairs) && TypeImpl.equalArrays(optionalParameterTypes, otherType.optionalParameterTypes, visitedElementPairs) && equals2(namedParameterTypes, otherType.namedParameterTypes, visitedElementPairs) && (returnType as TypeImpl).internalEquals(otherType.returnType, visitedElementPairs);
+    bool result = TypeImpl.equalArrays(normalParameterTypes, otherType.normalParameterTypes, visitedElementPairs) && TypeImpl.equalArrays(optionalParameterTypes, otherType.optionalParameterTypes, visitedElementPairs) && _equals(namedParameterTypes, otherType.namedParameterTypes, visitedElementPairs) && (returnType as TypeImpl).internalEquals(otherType.returnType, visitedElementPairs);
     // Remove the pair from our visited pairs list
     visitedElementPairs.remove(elementPair);
     // Return the result
     return result;
   }
 
   bool internalIsSubtypeOf(Type2 type, Set<TypeImpl_TypePair> visitedTypePairs) {
     // trivial base cases
     if (type == null) {
       return false;
@@ skipping 121 matching lines @@
   static List<InterfaceType> EMPTY_ARRAY = new List<InterfaceType>(0);
 
   /**
    * This method computes the longest inheritance path from some passed [Type] to Object.
    *
    * @param type the [Type] to compute the longest inheritance path of from the passed
    *          [Type] to Object
    * @return the computed longest inheritance path to Object
    * @see InterfaceType#getLeastUpperBound(Type)
    */
-  static int computeLongestInheritancePathToObject(InterfaceType type) => computeLongestInheritancePathToObject2(type, 0, new Set<ClassElement>());
+  static int computeLongestInheritancePathToObject(InterfaceType type) => _computeLongestInheritancePathToObject(type, 0, new Set<ClassElement>());
 
   /**
    * Returns the set of all superinterfaces of the passed [Type].
    *
    * @param type the [Type] to compute the set of superinterfaces of
    * @return the [Set] of superinterfaces of the passed [Type]
    * @see #getLeastUpperBound(Type)
    */
-  static Set<InterfaceType> computeSuperinterfaceSet(InterfaceType type) => computeSuperinterfaceSet2(type, new Set<InterfaceType>());
+  static Set<InterfaceType> computeSuperinterfaceSet(InterfaceType type) => _computeSuperinterfaceSet(type, new Set<InterfaceType>());
 
   /**
    * This method computes the longest inheritance path from some passed [Type] to Object. This
    * method calls itself recursively, callers should use the public method
    * [computeLongestInheritancePathToObject].
    *
    * @param type the [Type] to compute the longest inheritance path of from the passed
    *          [Type] to Object
    * @param depth a field used recursively
    * @param visitedClasses the classes that have already been visited
    * @return the computed longest inheritance path to Object
    * @see #computeLongestInheritancePathToObject(Type)
    * @see #getLeastUpperBound(Type)
    */
-  static int computeLongestInheritancePathToObject2(InterfaceType type, int depth, Set<ClassElement> visitedClasses) {
+  static int _computeLongestInheritancePathToObject(InterfaceType type, int depth, Set<ClassElement> visitedClasses) {
     ClassElement classElement = type.element;
     // Object case
     if (classElement.supertype == null || visitedClasses.contains(classElement)) {
       return depth;
     }
     int longestPath = 1;
     try {
       visitedClasses.add(classElement);
       List<InterfaceType> superinterfaces = classElement.interfaces;
       int pathLength;
       if (superinterfaces.length > 0) {
         // loop through each of the superinterfaces recursively calling this method and keeping track
         // of the longest path to return
         for (InterfaceType superinterface in superinterfaces) {
-          pathLength = computeLongestInheritancePathToObject2(superinterface, depth + 1, visitedClasses);
+          pathLength = _computeLongestInheritancePathToObject(superinterface, depth + 1, visitedClasses);
           if (pathLength > longestPath) {
             longestPath = pathLength;
           }
         }
       }
       // finally, perform this same check on the super type
       // TODO(brianwilkerson) Does this also need to add in the number of mixin classes?
       InterfaceType supertype = classElement.supertype;
-      pathLength = computeLongestInheritancePathToObject2(supertype, depth + 1, visitedClasses);
+      pathLength = _computeLongestInheritancePathToObject(supertype, depth + 1, visitedClasses);
       if (pathLength > longestPath) {
         longestPath = pathLength;
       }
     } finally {
       visitedClasses.remove(classElement);
     }
     return longestPath;
   }
 
   /**
    * Returns the set of all superinterfaces of the passed [Type]. This is a recursive method,
    * callers should call the public [computeSuperinterfaceSet].
    *
    * @param type the [Type] to compute the set of superinterfaces of
    * @param set a [HashSet] used recursively by this method
    * @return the [Set] of superinterfaces of the passed [Type]
    * @see #computeSuperinterfaceSet(Type)
    * @see #getLeastUpperBound(Type)
    */
-  static Set<InterfaceType> computeSuperinterfaceSet2(InterfaceType type, Set<InterfaceType> set) {
+  static Set<InterfaceType> _computeSuperinterfaceSet(InterfaceType type, Set<InterfaceType> set) {
     Element element = type.element;
     if (element != null && element is ClassElement) {
       ClassElement classElement = element;
       List<InterfaceType> superinterfaces = classElement.interfaces;
       for (InterfaceType superinterface in superinterfaces) {
         if (set.add(superinterface)) {
-          computeSuperinterfaceSet2(superinterface, set);
+          _computeSuperinterfaceSet(superinterface, set);
         }
       }
       InterfaceType supertype = classElement.supertype;
       if (supertype != null) {
         if (set.add(supertype)) {
-          computeSuperinterfaceSet2(supertype, set);
+          _computeSuperinterfaceSet(supertype, set);
         }
       }
     }
     return set;
   }
 
   /**
    * Return the intersection of the given sets of types, where intersection is based on the equality
    * of the elements of the types rather than on the equality of the types themselves. In cases
    * where two non-equal types have equal elements, which only happens when the class is
    * parameterized, the type that is added to the intersection is the base type with type arguments
    * that are the least upper bound of the type arguments of the two types.
    *
    * @param first the first set of types to be intersected
    * @param second the second set of types to be intersected
    * @return the intersection of the given sets of types
    */
-  static List<InterfaceType> intersection(Set<InterfaceType> first, Set<InterfaceType> second) {
+  static List<InterfaceType> _intersection(Set<InterfaceType> first, Set<InterfaceType> second) {
     Map<ClassElement, InterfaceType> firstMap = new Map<ClassElement, InterfaceType>();
     for (InterfaceType firstType in first) {
       firstMap[firstType.element] = firstType;
     }
     Set<InterfaceType> result = new Set<InterfaceType>();
     for (InterfaceType secondType in second) {
       InterfaceType firstType = firstMap[secondType.element];
       if (firstType != null) {
-        result.add(leastUpperBound(firstType, secondType));
+        result.add(_leastUpperBound(firstType, secondType));
       }
     }
     return new List.from(result);
   }
 
   /**
    * Return the "least upper bound" of the given types under the assumption that the types have the
    * same element and differ only in terms of the type arguments. The resulting type is composed by
    * comparing the corresponding type arguments, keeping those that are the same, and using
    * 'dynamic' for those that are different.
    *
    * @param firstType the first type
    * @param secondType the second type
    * @return the "least upper bound" of the given types
    */
-  static InterfaceType leastUpperBound(InterfaceType firstType, InterfaceType secondType) {
+  static InterfaceType _leastUpperBound(InterfaceType firstType, InterfaceType secondType) {
     if (firstType == secondType) {
       return firstType;
     }
     List<Type2> firstArguments = firstType.typeArguments;
     List<Type2> secondArguments = secondType.typeArguments;
     int argumentCount = firstArguments.length;
     if (argumentCount == 0) {
       return firstType;
     }
     List<Type2> lubArguments = new List<Type2>(argumentCount);
@@ skipping 110 matching lines @@
     // new names to match up with the spec
     InterfaceType i = this;
     InterfaceType j = type as InterfaceType;
     // compute set of supertypes
     Set<InterfaceType> si = computeSuperinterfaceSet(i);
     Set<InterfaceType> sj = computeSuperinterfaceSet(j);
     // union si with i and sj with j
     si.add(i);
     sj.add(j);
     // compute intersection, reference as set 's'
-    List<InterfaceType> s = intersection(si, sj);
+    List<InterfaceType> s = _intersection(si, sj);
     // for each element in Set s, compute the largest inheritance path to Object
     List<int> depths = new List<int>.filled(s.length, 0);
     int maxDepth = 0;
     for (int n = 0; n < s.length; n++) {
       depths[n] = computeLongestInheritancePathToObject(s[n]);
       if (depths[n] > maxDepth) {
         maxDepth = depths[n];
       }
     }
     // ensure that the currently computed maxDepth is unique,
@@ skipping 290 matching lines @@
     //
     // S is dynamic.
     // The test to determine whether S is dynamic is done here because dynamic is not an instance of
     // InterfaceType.
     //
     if (identical(type, DynamicTypeImpl.instance)) {
       return true;
     } else if (type is! InterfaceType) {
       return false;
     }
-    return isMoreSpecificThan2(type as InterfaceType, new Set<ClassElement>(), withDynamic, visitedTypePairs);
+    return _isMoreSpecificThan(type as InterfaceType, new Set<ClassElement>(), withDynamic, visitedTypePairs);
   }
 
   bool internalIsSubtypeOf(Type2 type, Set<TypeImpl_TypePair> visitedTypePairs) {
     //
     // T is a subtype of S, written T <: S, iff [bottom/dynamic]T << S
     //
     if (identical(type, DynamicTypeImpl.instance)) {
       return true;
     } else if (type is TypeParameterType) {
       return true;
     } else if (type is FunctionType) {
       ClassElement element = this.element;
       MethodElement callMethod = element.lookUpMethod("call", element.library);
       if (callMethod != null) {
         return callMethod.type.isSubtypeOf(type);
       }
       return false;
     } else if (type is! InterfaceType) {
       return false;
     } else if (this == type) {
       return true;
     }
-    return isSubtypeOf2(type as InterfaceType, new Set<ClassElement>(), visitedTypePairs);
+    return _isSubtypeOf(type as InterfaceType, new Set<ClassElement>(), visitedTypePairs);
   }
 
-  bool isMoreSpecificThan2(InterfaceType s, Set<ClassElement> visitedClasses, bool withDynamic, Set<TypeImpl_TypePair> visitedTypePairs) {
+  bool _isMoreSpecificThan(InterfaceType s, Set<ClassElement> visitedClasses, bool withDynamic, Set<TypeImpl_TypePair> visitedTypePairs) {
     //
     // A type T is more specific than a type S, written T << S,  if one of the following conditions
     // is met:
     //
     // Reflexivity: T is S.
     //
     if (this == s) {
       return true;
     }
     //
     // T is bottom. (This case is handled by the class BottomTypeImpl.)
     //
     // Direct supertype: S is a direct supertype of T.
     //
     if (s.isDirectSupertypeOf(this)) {
       return true;
     }
     //
     // Covariance: T is of the form I<T1, ..., Tn> and S is of the form I<S1, ..., Sn> and Ti << Si, 1 <= i <= n.
     //
     ClassElement tElement = this.element;
     ClassElement sElement = s.element;
     if (tElement == sElement) {
       List<Type2> tArguments = typeArguments;
       List<Type2> sArguments = s.typeArguments;
       if (tArguments.length != sArguments.length) {
         return false;
       }
       for (int i = 0; i < tArguments.length; i++) {
-        if (!(tArguments[i] as TypeImpl).isMoreSpecificThan3(sArguments[i], withDynamic, visitedTypePairs)) {
+        if (!(tArguments[i] as TypeImpl).isMoreSpecificThan2(sArguments[i], withDynamic, visitedTypePairs)) {
           return false;
         }
       }
       return true;
     }
     //
     // Transitivity: T << U and U << S.
     //
     // First check for infinite loops
     ClassElement element = this.element;
     if (element == null || visitedClasses.contains(element)) {
       return false;
     }
     visitedClasses.add(element);
     // Iterate over all of the types U that are more specific than T because they are direct
     // supertypes of T and return true if any of them are more specific than S.
     InterfaceType supertype = superclass;
-    if (supertype != null && (supertype as InterfaceTypeImpl).isMoreSpecificThan2(s, visitedClasses, withDynamic, visitedTypePairs)) {
+    if (supertype != null && (supertype as InterfaceTypeImpl)._isMoreSpecificThan(s, visitedClasses, withDynamic, visitedTypePairs)) {
       return true;
     }
     for (InterfaceType interfaceType in interfaces) {
-      if ((interfaceType as InterfaceTypeImpl).isMoreSpecificThan2(s, visitedClasses, withDynamic, visitedTypePairs)) {
+      if ((interfaceType as InterfaceTypeImpl)._isMoreSpecificThan(s, visitedClasses, withDynamic, visitedTypePairs)) {
         return true;
       }
     }
     for (InterfaceType mixinType in mixins) {
-      if ((mixinType as InterfaceTypeImpl).isMoreSpecificThan2(s, visitedClasses, withDynamic, visitedTypePairs)) {
+      if ((mixinType as InterfaceTypeImpl)._isMoreSpecificThan(s, visitedClasses, withDynamic, visitedTypePairs)) {
         return true;
       }
     }
     return false;
   }
 
-  bool isSubtypeOf2(InterfaceType type, Set<ClassElement> visitedClasses, Set<TypeImpl_TypePair> visitedTypePairs) {
+  bool _isSubtypeOf(InterfaceType type, Set<ClassElement> visitedClasses, Set<TypeImpl_TypePair> visitedTypePairs) {
     InterfaceType typeT = this;
     InterfaceType typeS = type;
     ClassElement elementT = element;
     if (elementT == null || visitedClasses.contains(elementT)) {
       return false;
     }
     visitedClasses.add(elementT);
     if (typeT == typeS) {
       return true;
     } else if (elementT == typeS.element) {
       // For each of the type arguments return true if all type args from T is a subtype of all
       // types from S.
       List<Type2> typeTArgs = typeT.typeArguments;
       List<Type2> typeSArgs = typeS.typeArguments;
       if (typeTArgs.length != typeSArgs.length) {
         // This case covers the case where two objects are being compared that have a different
         // number of parameterized types.
         return false;
       }
       for (int i = 0; i < typeTArgs.length; i++) {
         // Recursively call isSubtypeOf the type arguments and return false if the T argument is not
         // a subtype of the S argument.
-        if (!(typeTArgs[i] as TypeImpl).isSubtypeOf3(typeSArgs[i], visitedTypePairs)) {
+        if (!(typeTArgs[i] as TypeImpl).isSubtypeOf2(typeSArgs[i], visitedTypePairs)) {
           return false;
         }
       }
       return true;
     } else if (typeS.isDartCoreFunction && elementT.getMethod("call") != null) {
       return true;
     }
     InterfaceType supertype = superclass;
     // The type is Object, return false.
-    if (supertype != null && (supertype as InterfaceTypeImpl).isSubtypeOf2(typeS, visitedClasses, visitedTypePairs)) {
+    if (supertype != null && (supertype as InterfaceTypeImpl)._isSubtypeOf(typeS, visitedClasses, visitedTypePairs)) {
       return true;
     }
     List<InterfaceType> interfaceTypes = interfaces;
     for (InterfaceType interfaceType in interfaceTypes) {
-      if ((interfaceType as InterfaceTypeImpl).isSubtypeOf2(typeS, visitedClasses, visitedTypePairs)) {
+      if ((interfaceType as InterfaceTypeImpl)._isSubtypeOf(typeS, visitedClasses, visitedTypePairs)) {
         return true;
       }
     }
     List<InterfaceType> mixinTypes = mixins;
     for (InterfaceType mixinType in mixinTypes) {
-      if ((mixinType as InterfaceTypeImpl).isSubtypeOf2(typeS, visitedClasses, visitedTypePairs)) {
+      if ((mixinType as InterfaceTypeImpl)._isSubtypeOf(typeS, visitedClasses, visitedTypePairs)) {
         return true;
       }
     }
     return false;
   }
 }
 
 /**
  * The abstract class `TypeImpl` implements the behavior common to objects representing the
  * declared type of elements in the element model.
@@ skipping 72 matching lines @@
    * or <i>S</i> <: <i>T</i>.
    *
    * The given set of pairs of types (T1, T2), where each pair indicates that we invoked this method
    * because we are in the process of answering the question of whether T1 is a subtype of T2, is
    * used to prevent infinite loops.
    *
    * @param type the type being compared with this type
    * @param visitedPairs the set of pairs of types used to prevent infinite loops
    * @return `true` if this type is assignable to the given type
    */
-  bool isAssignableTo2(Type2 type, Set<TypeImpl_TypePair> visitedTypePairs) => isSubtypeOf3(type, visitedTypePairs) || (type as TypeImpl).isSubtypeOf3(this, visitedTypePairs);
+  bool isAssignableTo2(Type2 type, Set<TypeImpl_TypePair> visitedTypePairs) => isSubtypeOf2(type, visitedTypePairs) || (type as TypeImpl).isSubtypeOf2(this, visitedTypePairs);
 
   bool get isBottom => false;
 
   bool get isDartCoreFunction => false;
 
   bool get isDynamic => false;
 
-  bool isMoreSpecificThan(Type2 type) => isMoreSpecificThan3(type, false, new Set<TypeImpl_TypePair>());
+  bool isMoreSpecificThan(Type2 type) => isMoreSpecificThan2(type, false, new Set<TypeImpl_TypePair>());
 
   /**
    * Return `true` if this type is more specific than the given type.
    *
    * The given set of pairs of types (T1, T2), where each pair indicates that we invoked this method
    * because we are in the process of answering the question of whether T1 is a subtype of T2, is
    * used to prevent infinite loops.
    *
    * @param type the type being compared with this type
    * @param withDynamic `true` if "dynamic" should be considered as a subtype of any type
    * @param visitedPairs the set of pairs of types used to prevent infinite loops
    * @return `true` if this type is more specific than the given type
    */
-  bool isMoreSpecificThan3(Type2 type, bool withDynamic, Set<TypeImpl_TypePair> visitedTypePairs) {
+  bool isMoreSpecificThan2(Type2 type, bool withDynamic, Set<TypeImpl_TypePair> visitedTypePairs) {
     // If the visitedTypePairs already has the pair (this, type), return false
     TypeImpl_TypePair typePair = new TypeImpl_TypePair(this, type);
     if (!visitedTypePairs.add(typePair)) {
       return false;
     }
     bool result = internalIsMoreSpecificThan(type, withDynamic, visitedTypePairs);
     visitedTypePairs.remove(typePair);
     return result;
   }
 
   bool get isObject => false;
 
-  bool isSubtypeOf(Type2 type) => isSubtypeOf3(type, new Set<TypeImpl_TypePair>());
+  bool isSubtypeOf(Type2 type) => isSubtypeOf2(type, new Set<TypeImpl_TypePair>());
 
   /**
    * Return `true` if this type is a subtype of the given type.
    *
    * The given set of pairs of types (T1, T2), where each pair indicates that we invoked this method
    * because we are in the process of answering the question of whether T1 is a subtype of T2, is
    * used to prevent infinite loops.
    *
    * @param type the type being compared with this type
    * @param visitedPairs the set of pairs of types used to prevent infinite loops
    * @return `true` if this type is a subtype of the given type
    */
-  bool isSubtypeOf3(Type2 type, Set<TypeImpl_TypePair> visitedTypePairs) {
+  bool isSubtypeOf2(Type2 type, Set<TypeImpl_TypePair> visitedTypePairs) {
     // If the visitedTypePairs already has the pair (this, type), return false
     TypeImpl_TypePair typePair = new TypeImpl_TypePair(this, type);
     if (!visitedTypePairs.add(typePair)) {
       return false;
     }
     bool result = internalIsSubtypeOf(type, visitedTypePairs);
     visitedTypePairs.remove(typePair);
     return result;
   }
 
@@ skipping 130 matching lines @@
     // S is bottom.
     //
     if (s.isBottom) {
       return true;
     }
     // S is dynamic.
     //
     if (s.isDynamic) {
       return true;
     }
-    return isMoreSpecificThan4(s, new Set<Type2>(), withDynamic, visitedTypePairs);
+    return _isMoreSpecificThan(s, new Set<Type2>(), withDynamic, visitedTypePairs);
   }
 
-  bool internalIsSubtypeOf(Type2 type, Set<TypeImpl_TypePair> visitedTypePairs) => isMoreSpecificThan3(type, true, new Set<TypeImpl_TypePair>());
+  bool internalIsSubtypeOf(Type2 type, Set<TypeImpl_TypePair> visitedTypePairs) => isMoreSpecificThan2(type, true, new Set<TypeImpl_TypePair>());
 
-  bool isMoreSpecificThan4(Type2 s, Set<Type2> visitedTypes, bool withDynamic, Set<TypeImpl_TypePair> visitedTypePairs) {
+  bool _isMoreSpecificThan(Type2 s, Set<Type2> visitedTypes, bool withDynamic, Set<TypeImpl_TypePair> visitedTypePairs) {
     // T is a type parameter and S is the upper bound of T.
     //
     Type2 bound = element.bound;
     if (s == bound) {
       return true;
     }
     // T is a type parameter and S is Object.
     //
     if (s.isObject) {
       return true;
     }
     // We need upper bound to continue.
     if (bound == null) {
       return false;
     }
     //
     // Transitivity: T << U and U << S.
     //
     if (bound is TypeParameterTypeImpl) {
       TypeParameterTypeImpl boundTypeParameter = bound;
       // First check for infinite loops
       if (visitedTypes.contains(bound)) {
         return false;
       }
       visitedTypes.add(bound);
       // Then check upper bound.
-      return boundTypeParameter.isMoreSpecificThan4(s, visitedTypes, withDynamic, visitedTypePairs);
+      return boundTypeParameter._isMoreSpecificThan(s, visitedTypes, withDynamic, visitedTypePairs);
     }
     // Check interface type.
-    return (bound as TypeImpl).isMoreSpecificThan3(s, withDynamic, visitedTypePairs);
+    return (bound as TypeImpl).isMoreSpecificThan2(s, withDynamic, visitedTypePairs);
   }
 }
 
 /**
  * The unique instance of the class `VoidTypeImpl` implements the type `void`.
  */
 class VoidTypeImpl extends TypeImpl implements VoidType {
   /**
    * The unique instance of this class.
    */
@@ skipping 595 matching lines @@
   TypeParameterElement get element;
 }
 
 /**
  * The interface `VoidType` defines the behavior of the unique object representing the type
  * `void`.
  */
 abstract class VoidType implements Type2 {
   VoidType substitute2(List<Type2> argumentTypes, List<Type2> parameterTypes);
 }