More fixes for java2dart and status files.

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

 // 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';
 import 'java_core.dart';
 import 'java_engine.dart';
 import 'instrumentation.dart';
 import 'source.dart';
 import 'error.dart';
 import 'scanner.dart' as sc;
@@ skipping 3505 matching lines @@
    * itself recursively
    * @return a mapping between the set of all string names of the members inherited from the passed{@link ClassElement} interface hierarchy, and the associated {@link ExecutableElement}
    */
   Map<String, ExecutableElement> computeInterfaceLookupMap(ClassElement classElt, Set<ClassElement> visitedInterfaces) {
     Map<String, ExecutableElement> resultMap = _interfaceLookup[classElt];
     if (resultMap != null) {
       return resultMap;
     } else {
       resultMap = new Map<String, ExecutableElement>();
     }
+    InterfaceType supertype2 = classElt.supertype;
+    ClassElement superclassElement = supertype2 != null ? supertype2.element : null;
     List<InterfaceType> interfaces2 = classElt.interfaces;
-    if (interfaces2.length == 0) {
+    if (superclassElement == null || interfaces2.length == 0) {
       _interfaceLookup[classElt] = resultMap;
       return resultMap;
     }
     List<Map<String, ExecutableElement>> lookupMaps = new List<Map<String, ExecutableElement>>();
+    if (superclassElement != null) {
+      if (!visitedInterfaces.contains(superclassElement)) {
+        try {
+          javaSetAdd(visitedInterfaces, superclassElement);
+          lookupMaps.add(computeInterfaceLookupMap(superclassElement, visitedInterfaces));
+        } finally {
+          visitedInterfaces.remove(superclassElement);
+        }
+      } else {
+        Map<String, ExecutableElement> map = _interfaceLookup[classElt];
+        if (map != null) {
+          lookupMaps.add(map);
+        } else {
+          _interfaceLookup[superclassElement] = resultMap;
+          return resultMap;
+        }
+      }
+    }
     for (InterfaceType interfaceType in interfaces2) {
       ClassElement interfaceElement = interfaceType.element;
       if (interfaceElement != null) {
         if (!visitedInterfaces.contains(interfaceElement)) {
-          javaSetAdd(visitedInterfaces, interfaceElement);
-          lookupMaps.add(computeInterfaceLookupMap(interfaceElement, visitedInterfaces));
+          try {
+            javaSetAdd(visitedInterfaces, interfaceElement);
+            lookupMaps.add(computeInterfaceLookupMap(interfaceElement, visitedInterfaces));
+          } finally {
+            visitedInterfaces.remove(interfaceElement);
+          }
         } else {
           Map<String, ExecutableElement> map = _interfaceLookup[classElt];
           if (map != null) {
             lookupMaps.add(map);
           } else {
             _interfaceLookup[interfaceElement] = resultMap;
             return resultMap;
           }
         }
       }
     }
     if (lookupMaps.length == 0) {
       _interfaceLookup[classElt] = resultMap;
       return resultMap;
     }
     Map<String, Set<ExecutableElement>> unionMap = new Map<String, Set<ExecutableElement>>();
     for (Map<String, ExecutableElement> lookupMap in lookupMaps) {
       for (MapEntry<String, ExecutableElement> entry in getMapEntrySet(lookupMap)) {
         String key = entry.getKey();
         if (!unionMap.containsKey(key)) {
           Set<ExecutableElement> set = new Set<ExecutableElement>();
           javaSetAdd(set, entry.getValue());
           unionMap[key] = set;
         } else {
           javaSetAdd(unionMap[key], entry.getValue());
         }
       }
     }
+    if (superclassElement != null) {
+      List<MethodElement> methods2 = superclassElement.methods;
+      for (MethodElement method in methods2) {
+        if (method.isAccessibleIn(_library) && !method.isStatic()) {
+          String key = method.name;
+          if (!unionMap.containsKey(key)) {
+            Set<ExecutableElement> set = new Set<ExecutableElement>();
+            javaSetAdd(set, method);
+            unionMap[key] = set;
+          } else {
+            javaSetAdd(unionMap[key], method);
+          }
+        }
+      }
+      List<PropertyAccessorElement> accessors2 = superclassElement.accessors;
+      for (PropertyAccessorElement accessor in accessors2) {
+        if (accessor.isAccessibleIn(_library) && !accessor.isStatic()) {
+          String key = accessor.name;
+          if (!unionMap.containsKey(key)) {
+            Set<ExecutableElement> set = new Set<ExecutableElement>();
+            javaSetAdd(set, accessor);
+            unionMap[key] = set;
+          } else {
+            javaSetAdd(unionMap[key], accessor);
+          }
+        }
+      }
+    }
     for (InterfaceType interfaceType in interfaces2) {
       ClassElement interfaceElement = interfaceType.element;
       if (interfaceElement != null) {
-        List<MethodElement> methods2 = interfaceElement.methods;
-        for (MethodElement method in methods2) {
+        List<MethodElement> methods3 = interfaceElement.methods;
+        for (MethodElement method in methods3) {
           if (method.isAccessibleIn(_library) && !method.isStatic()) {
             String key = method.name;
             if (!unionMap.containsKey(key)) {
               Set<ExecutableElement> set = new Set<ExecutableElement>();
               javaSetAdd(set, method);
               unionMap[key] = set;
             } else {
               javaSetAdd(unionMap[key], method);
             }
           }
         }
-        List<PropertyAccessorElement> accessors2 = interfaceElement.accessors;
-        for (PropertyAccessorElement accessor in accessors2) {
+        List<PropertyAccessorElement> accessors3 = interfaceElement.accessors;
+        for (PropertyAccessorElement accessor in accessors3) {
           if (accessor.isAccessibleIn(_library) && !accessor.isStatic()) {
             String key = accessor.name;
             if (!unionMap.containsKey(key)) {
               Set<ExecutableElement> set = new Set<ExecutableElement>();
               javaSetAdd(set, accessor);
               unionMap[key] = set;
             } else {
               javaSetAdd(unionMap[key], accessor);
             }
           }
@@ skipping 22 matching lines @@
             allGetters = false;
             allSetters = false;
           }
         }
         if (allMethods || allGetters || allSetters) {
           List<ExecutableElement> elements = new List.from(set);
           List<FunctionType> executableElementTypes = new List<FunctionType>(numOfEltsWithMatchingNames);
           for (int i = 0; i < numOfEltsWithMatchingNames; i++) {
             executableElementTypes[i] = elements[i].type;
           }
-          bool foundSubtypeOfAllTypes = true;
+          bool foundSubtypeOfAllTypes = false;
           for (int i = 0; i < numOfEltsWithMatchingNames; i++) {
             FunctionType subtype = executableElementTypes[i];
             if (subtype == null) {
               continue;
             }
             bool subtypeOfAllTypes = true;
             for (int j = 0; j < numOfEltsWithMatchingNames && subtypeOfAllTypes; j++) {
               if (i != j) {
                 if (!subtype.isSubtypeOf(executableElementTypes[j])) {
                   subtypeOfAllTypes = false;
-                  foundSubtypeOfAllTypes = false;
                   break;
                 }
               }
             }
             if (subtypeOfAllTypes) {
+              foundSubtypeOfAllTypes = true;
               resultMap[key] = elements[i];
               break;
             }
           }
           if (!foundSubtypeOfAllTypes) {
             reportError(classElt, classElt.nameOffset, classElt.displayName.length, StaticTypeWarningCode.INCONSISTENT_METHOD_INHERITANCE, [key]);
           }
         } else {
           if (!allMethods && !allGetters) {
             reportError(classElt, classElt.nameOffset, classElt.displayName.length, StaticWarningCode.INCONSISTENT_METHOD_INHERITANCE_GETTER_AND_METHOD, [key]);
@@ skipping 4309 matching lines @@
           reportError(StaticWarningCode.NEW_WITH_NON_TYPE, typeNameSimple, [typeName]);
           elementValid = false;
         }
       }
     }
     if (elementValid && element == null) {
       SimpleIdentifier typeNameSimple = getTypeSimpleIdentifier(typeName);
       if (typeNameSimple.name == "boolean") {
         reportError(StaticWarningCode.UNDEFINED_CLASS_BOOLEAN, typeNameSimple, []);
       } else if (isTypeNameInCatchClause(node)) {
-        reportError(StaticWarningCode.NON_TYPE_IN_CATCH_CLAUSE, node, [node]);
+        reportError(StaticWarningCode.NON_TYPE_IN_CATCH_CLAUSE, typeName, [typeName.name]);
+      } else if (isTypeNameInAsExpression(node)) {
+        reportError(StaticWarningCode.CAST_TO_NON_TYPE, typeName, [typeName.name]);
+      } else if (isTypeNameInIsExpression(node)) {
+        reportError(StaticWarningCode.TYPE_TEST_NON_TYPE, typeName, [typeName.name]);
       } else {
-        reportError(StaticWarningCode.UNDEFINED_CLASS, typeNameSimple, [typeNameSimple.name]);
+        reportError(StaticWarningCode.UNDEFINED_CLASS, typeName, [typeName.name]);
       }
       elementValid = false;
     }
     if (!elementValid) {
       setElement(typeName, _dynamicType.element);
       typeName.staticType = _dynamicType;
       node.type = _dynamicType;
       return null;
     }
     Type2 type = null;
     if (element is ClassElement) {
       setElement(typeName, element);
       type = ((element as ClassElement)).type;
     } else if (element is FunctionTypeAliasElement) {
       setElement(typeName, element);
       type = ((element as FunctionTypeAliasElement)).type;
     } else if (element is TypeVariableElement) {
       setElement(typeName, element);
       type = ((element as TypeVariableElement)).type;
       if (argumentList != null) {
       }
     } else if (element is MultiplyDefinedElement) {
       List<Element> elements = ((element as MultiplyDefinedElement)).conflictingElements;
       type = getType(elements);
       if (type != null) {
         node.type = type;
       }
     } else {
       if (isTypeNameInCatchClause(node)) {
-        reportError(StaticWarningCode.NON_TYPE_IN_CATCH_CLAUSE, node, [node]);
+        reportError(StaticWarningCode.NON_TYPE_IN_CATCH_CLAUSE, typeName, [typeName.name]);
+      } else if (isTypeNameInAsExpression(node)) {
+        reportError(StaticWarningCode.CAST_TO_NON_TYPE, typeName, [typeName.name]);
+      } else if (isTypeNameInIsExpression(node)) {
+        reportError(StaticWarningCode.TYPE_TEST_NON_TYPE, typeName, [typeName.name]);
       }
       setElement(typeName, _dynamicType.element);
       typeName.staticType = _dynamicType;
       node.type = _dynamicType;
       return null;
     }
     if (argumentList != null) {
       NodeList<TypeName> arguments2 = argumentList.arguments;
       int argumentCount = arguments2.length;
       List<Type2> parameters = getTypeArguments(type);
@@ skipping 179 matching lines @@
    */
   SimpleIdentifier getTypeSimpleIdentifier(Identifier typeName) {
     if (typeName is SimpleIdentifier) {
       return typeName as SimpleIdentifier;
     } else {
       return ((typeName as PrefixedIdentifier)).identifier;
     }
   }
 
   /**
-   * Checks if the given type name is used as the exception type in the catch clause.
+   * Checks if the given type name is used as the type in an as expression.
    * @param typeName the type name to analyzer
-   * @return {@code true} if the given type name is used as the exception type in the catch clause.
+   * @return {@code true} if the given type name is used as the type in an as expression
+   */
+  bool isTypeNameInAsExpression(TypeName typeName) {
+    ASTNode parent2 = typeName.parent;
+    if (parent2 is AsExpression) {
+      AsExpression asExpression = parent2 as AsExpression;
+      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 {@code true} if the given type name is used as the exception type in a catch clause
    */
   bool isTypeNameInCatchClause(TypeName typeName) {
     ASTNode parent2 = typeName.parent;
     if (parent2 is CatchClause) {
       CatchClause catchClause = parent2 as CatchClause;
       return identical(catchClause.exceptionType, typeName);
     }
     return false;
   }
 
   /**
-   * Checks if the given type name is used as the type in the instance creation expression.
+   * Checks if the given type name is used as the type in an instance creation expression.
    * @param typeName the type name to analyzer
-   * @return {@code true} if the given type name is used as the type in the instance creation
+   * @return {@code true} if the given type name is used as the type in an instance creation
    * expression
    */
   bool isTypeNameInInstanceCreationExpression(TypeName typeName) {
     ASTNode parent2 = typeName.parent;
     if (parent2 is ConstructorName && parent2.parent is InstanceCreationExpression) {
       ConstructorName constructorName = parent2 as ConstructorName;
       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 {@code true} if the given type name is used as the type in an is expression
+   */
+  bool isTypeNameInIsExpression(TypeName typeName) {
+    ASTNode parent2 = typeName.parent;
+    if (parent2 is IsExpression) {
+      IsExpression isExpression = parent2 as IsExpression;
+      return identical(isExpression.type, typeName);
+    }
+    return false;
+  }
+
+  /**
    * 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) {
     if (type == null) {
       expression.staticType = _dynamicType;
     } else {
       expression.staticType = type;
     }
@@ skipping 1548 matching lines @@
   Object visitDoStatement(DoStatement node) {
     checkForNonBoolCondition(node.condition);
     return super.visitDoStatement(node);
   }
   Object visitExportDirective(ExportDirective node) {
     checkForAmbiguousExport(node);
     checkForExportDuplicateLibraryName(node);
     checkForExportInternalLibrary(node);
     return super.visitExportDirective(node);
   }
+  Object visitFieldDeclaration(FieldDeclaration node) {
+    if (!node.isStatic()) {
+      VariableDeclarationList variables = node.fields;
+      if (variables.isConst()) {
+        _errorReporter.reportError4(CompileTimeErrorCode.CONST_INSTANCE_FIELD, variables.keyword, []);
+      }
+    }
+    return super.visitFieldDeclaration(node);
+  }
   Object visitFieldFormalParameter(FieldFormalParameter node) {
     checkForConstFormalParameter(node);
     checkForFieldInitializingFormalRedirectingConstructor(node);
     return super.visitFieldFormalParameter(node);
   }
   Object visitFunctionDeclaration(FunctionDeclaration node) {
     ExecutableElement outerFunction = _enclosingFunction;
     try {
       SimpleIdentifier identifier = node.name;
       String methoName = "";
@@ skipping 1382 matching lines @@
    * @param node the class declaration to test
    * @return {@code true} if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#FINAL_NOT_INITIALIZED
    */
   bool checkForFinalNotInitialized2(VariableDeclarationList node) {
     bool foundError = false;
     if (!node.isSynthetic() && (node.isConst() || node.isFinal())) {
       NodeList<VariableDeclaration> variables2 = node.variables;
       for (VariableDeclaration variable in variables2) {
         if (variable.initializer == null) {
-          _errorReporter.reportError2(CompileTimeErrorCode.FINAL_NOT_INITIALIZED, variable, [variable.name.name]);
+          _errorReporter.reportError2(StaticWarningCode.FINAL_NOT_INITIALIZED, variable, [variable.name.name]);
           foundError = true;
         }
       }
     }
     return foundError;
   }
 
   /**
    * This verifies that the passed implements clause does not implement classes such as 'num' or
    * 'String'.
@@ skipping 507 matching lines @@
         if (!accessorsInEnclosingClass.contains(accessorName)) {
           javaSetAdd(missingOverrides, executableElt);
         }
       }
     }
     int missingOverridesSize = missingOverrides.length;
     if (missingOverridesSize == 0) {
       return false;
     }
     List<ExecutableElement> missingOverridesArray = new List.from(missingOverrides);
+    List<String> stringTypeArray = new List<String>(Math.min(missingOverridesSize, 4));
+    String GET = "get ";
+    String SET = "set ";
+    for (int i = 0; i < stringTypeArray.length; i++) {
+      stringTypeArray[i] = StringUtilities.EMPTY;
+      if (missingOverridesArray[i] is PropertyAccessorElement) {
+        stringTypeArray[i] = ((missingOverridesArray[i] as PropertyAccessorElement)).isGetter() ? GET : SET;
+      }
+    }
     if (missingOverridesSize == 1) {
-      _errorReporter.reportError2(StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE, node.name, [missingOverridesArray[0].enclosingElement.displayName, missingOverridesArray[0].displayName]);
+      _errorReporter.reportError2(StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE, node.name, [stringTypeArray[0], missingOverridesArray[0].enclosingElement.displayName, missingOverridesArray[0].displayName]);
     } else if (missingOverridesSize == 2) {
-      _errorReporter.reportError2(StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_TWO, node.name, [missingOverridesArray[0].enclosingElement.displayName, missingOverridesArray[0].displayName, missingOverridesArray[1].enclosingElement.displayName, missingOverridesArray[1].displayName]);
+      _errorReporter.reportError2(StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_TWO, node.name, [stringTypeArray[0], missingOverridesArray[0].enclosingElement.displayName, missingOverridesArray[0].displayName, stringTypeArray[1], missingOverridesArray[1].enclosingElement.displayName, missingOverridesArray[1].displayName]);
     } else if (missingOverridesSize == 3) {
-      _errorReporter.reportError2(StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_THREE, node.name, [missingOverridesArray[0].enclosingElement.displayName, missingOverridesArray[0].displayName, missingOverridesArray[1].enclosingElement.displayName, missingOverridesArray[1].displayName, missingOverridesArray[2].enclosingElement.displayName, missingOverridesArray[2].displayName]);
+      _errorReporter.reportError2(StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_THREE, node.name, [stringTypeArray[0], missingOverridesArray[0].enclosingElement.displayName, missingOverridesArray[0].displayName, stringTypeArray[1], missingOverridesArray[1].enclosingElement.displayName, missingOverridesArray[1].displayName, stringTypeArray[2], missingOverridesArray[2].enclosingElement.displayName, missingOverridesArray[2].displayName]);
     } else if (missingOverridesSize == 4) {
-      _errorReporter.reportError2(StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_FOUR, node.name, [missingOverridesArray[0].enclosingElement.displayName, missingOverridesArray[0].displayName, missingOverridesArray[1].enclosingElement.displayName, missingOverridesArray[1].displayName, missingOverridesArray[2].enclosingElement.displayName, missingOverridesArray[2].displayName, missingOverridesArray[3].enclosingElement.displayName, missingOverridesArray[3].displayName]);
+      _errorReporter.reportError2(StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_FOUR, node.name, [stringTypeArray[0], missingOverridesArray[0].enclosingElement.displayName, missingOverridesArray[0].displayName, stringTypeArray[1], missingOverridesArray[1].enclosingElement.displayName, missingOverridesArray[1].displayName, stringTypeArray[2], missingOverridesArray[2].enclosingElement.displayName, missingOverridesArray[2].displayName, stringTypeArray[3], missingOverridesArray[3].enclosingElement.displayName, missingOverridesArray[3].displayName]);
     } else {
-      _errorReporter.reportError2(StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_FIVE_PLUS, node.name, [missingOverridesArray[0].enclosingElement.displayName, missingOverridesArray[0].displayName, missingOverridesArray[1].enclosingElement.displayName, missingOverridesArray[1].displayName, missingOverridesArray[2].enclosingElement.displayName, missingOverridesArray[2].displayName, missingOverridesArray[3].enclosingElement.displayName, missingOverridesArray[3].displayName, missingOverridesArray.length - 4]);
+      _errorReporter.reportError2(StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_FIVE_PLUS, node.name, [stringTypeArray[0], missingOverridesArray[0].enclosingElement.displayName, missingOverridesArray[0].displayName, stringTypeArray[1], missingOverridesArray[1].enclosingElement.displayName, missingOverridesArray[1].displayName, stringTypeArray[2], missingOverridesArray[2].enclosingElement.displayName, missingOverridesArray[2].displayName, stringTypeArray[3], missingOverridesArray[3].enclosingElement.displayName, missingOverridesArray[3].displayName, missingOverridesArray.length - 4]);
     }
     return true;
   }
 
   /**
    * 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 {@code true} if and only if an error code is generated on the passed node
    * @see StaticTypeWarningCode#NON_BOOL_CONDITION
@@ skipping 487 matching lines @@
             _errorReporter.reportError2(StaticTypeWarningCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS, argTypeName, [argTypeName.name, boundingElts[i].displayName]);
             return true;
           }
         }
       }
     }
     return false;
   }
 
   /**
-   * This checks that if the passed generative constructor has no explicit super constructor
-   * invocation, then super class has the default generative constructor.
+   * 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 {@code 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
    */
   bool checkForUndefinedConstructorInInitializerImplicit(ConstructorDeclaration node) {
     if (node.factoryKeyword != null) {
       return false;
     }
+    for (ConstructorInitializer constructorInitializer in node.initializers) {
+      if (constructorInitializer is SuperConstructorInvocation || constructorInitializer is RedirectingConstructorInvocation) {
+        return false;
+      }
+    }
     if (_enclosingClass == null) {
       return false;
     }
     InterfaceType superType = _enclosingClass.supertype;
     if (superType == null) {
       return false;
     }
     ClassElement superElement = superType.element;
-    for (ConstructorInitializer constructorInitializer in node.initializers) {
-      if (constructorInitializer is SuperConstructorInvocation) {
-        return false;
-      }
-    }
     ConstructorElement superDefaultConstructor = superElement.unnamedConstructor;
     if (superDefaultConstructor != null) {
       if (superDefaultConstructor.isFactory()) {
         _errorReporter.reportError2(CompileTimeErrorCode.NON_GENERATIVE_CONSTRUCTOR, node.returnType, [superDefaultConstructor]);
         return true;
       }
       return false;
     }
     _errorReporter.reportError2(CompileTimeErrorCode.UNDEFINED_CONSTRUCTOR_IN_INITIALIZER_DEFAULT, node.returnType, [superElement.name]);
     return true;
@@ skipping 196 matching lines @@
   static final List<INIT_STATE> values = [NOT_INIT, INIT_IN_DECLARATION, INIT_IN_FIELD_FORMAL, INIT_IN_DEFAULT_VALUE, INIT_IN_INITIALIZERS];
 
   /// The name of this enum constant, as declared in the enum declaration.
   final String name;
 
   /// The position in the enum declaration.
   final int ordinal;
   INIT_STATE(this.name, this.ordinal) {
   }
   int compareTo(INIT_STATE other) => ordinal - other.ordinal;
+  int get hashCode => ordinal;
   String toString() => name;
 }
 /**
  * Instances of the class {@code PubVerifier} traverse an AST structure looking for deviations from
  * pub best practices.
  */
 class PubVerifier extends RecursiveASTVisitor<Object> {
 
   /**
    * The error reporter by which errors will be reported.
@@ skipping 116 matching lines @@
    * @param message the message template used to create the message to be displayed for the error
    */
   ResolverErrorCode(this.name, this.ordinal, ErrorType type, String message) {
     this._type = type;
     this._message = message;
   }
   ErrorSeverity get errorSeverity => _type.severity;
   String get message => _message;
   ErrorType get type => _type;
   int compareTo(ResolverErrorCode other) => ordinal - other.ordinal;
+  int get hashCode => ordinal;
   String toString() => name;
 }