Optimizations for hashCode.

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 15927 matching lines @@
       _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<DartType> parameters = _getTypeArguments(type);
       int parameterCount = parameters.length;
-      int count = Math.min(argumentCount, parameterCount);
-      List<DartType> typeArguments = new List<DartType>();
-      for (int i = 0; i < count; i++) {
-        DartType argumentType = _getType(arguments[i]);
-        if (argumentType != null) {
-          typeArguments.add(argumentType);
+      List<DartType> typeArguments = new List<DartType>(parameterCount);
+      if (argumentCount == parameterCount) {
+        for (int i = 0; i < parameterCount; i++) {
+          TypeName argumentTypeName = arguments[i];
+          DartType argumentType = _getType(argumentTypeName);
+          if (argumentType == null) {
+            argumentType = _dynamicType;
+          }
+          typeArguments[i] = argumentType;
         }
-      }
-      if (argumentCount != parameterCount) {
+      } else {
         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(_dynamicType);
+        for (int i = 0; i < parameterCount; i++) {
+          typeArguments[i] = _dynamicType;
         }
       }
       if (type is InterfaceTypeImpl) {
         InterfaceTypeImpl interfaceType = type as InterfaceTypeImpl;
-        type = interfaceType.substitute4(new List.from(typeArguments));
+        type = interfaceType.substitute4(typeArguments);
       } else if (type is FunctionTypeImpl) {
         FunctionTypeImpl functionType = type as FunctionTypeImpl;
-        type = functionType.substitute3(new List.from(typeArguments));
+        type = functionType.substitute3(typeArguments);
       } else {
       }
     } else {
       //
       // Check for the case where there are no type arguments given for a parameterized type.
       //
       List<DartType> parameters = _getTypeArguments(type);
       int parameterCount = parameters.length;
       if (parameterCount > 0) {
         DynamicTypeImpl dynamicType = DynamicTypeImpl.instance;
@@ skipping 7176 matching lines @@
     this.message = message;
     this.correction9 = correction;
   }
 
   @override
   String get correction => correction9;
 
   @override
   ErrorSeverity get errorSeverity => type.severity;
 }