Clean up many generated constructors

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.
 
 library engine.resolver;
 
 import "dart:math" as math;
 import 'dart:collection';
 
 import 'package:analyzer/src/generated/utilities_collection.dart';
@@ skipping 725 matching lines @@
     if (typeElement == null) {
       throw new IllegalArgumentException("class element cannot be null");
     }
     _defineMembers(typeElement);
   }
 
   @override
   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,
+        return new AnalysisError(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,
+        return new AnalysisError(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.
@@ skipping 499 matching lines @@
               new DartObjectImpl(_typeProvider.nullType, NullState.NULL_STATE);
         } else {
           result = _validate(
               defaultValue, CompileTimeErrorCode.NON_CONSTANT_DEFAULT_VALUE);
           if (result != null) {
             _reportErrorIfFromDeferredLibrary(defaultValue,
                 CompileTimeErrorCode.NON_CONSTANT_DEFAULT_VALUE_FROM_DEFERRED_LIBRARY);
           }
         }
         VariableElementImpl element = parameter.element as VariableElementImpl;
-        element.evaluationResult = new EvaluationResultImpl.con1(result);
+        element.evaluationResult = new EvaluationResultImpl(result);
       }
     }
   }
 
   /**
    * Validates that the expressions of any field initializers in the class declaration are all
    * compile time constants. Since this is only required if the class has a constant constructor,
    * the error is reported at the constructor site.
    *
    * @param classDeclaration the class which should be validated
@@ skipping 427 matching lines @@
    * 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
    */
   EvaluationResultImpl _getConstantBooleanValue(Expression expression) {
     if (expression is BooleanLiteral) {
       if (expression.value) {
-        return new EvaluationResultImpl.con1(
+        return new EvaluationResultImpl(
             new DartObjectImpl(null, BoolState.from(true)));
       } else {
-        return new EvaluationResultImpl.con1(
+        return new EvaluationResultImpl(
             new DartObjectImpl(null, BoolState.from(false)));
       }
     }
     // Don't consider situations where we could evaluate to a constant boolean
     // expression with the ConstantVisitor
     // else {
     // EvaluationResultImpl result = expression.accept(new ConstantVisitor());
     // if (result == ValidResult.RESULT_TRUE) {
     // return ValidResult.RESULT_TRUE;
     // } else if (result == ValidResult.RESULT_FALSE) {
@@ skipping 710 matching lines @@
       for (int i = 0; i < count; i++) {
         nonFields[i].accept(this);
       }
     } finally {
       _currentHolder = previousHolder;
     }
     SimpleIdentifier className = node.name;
     ClassElementImpl element = new ClassElementImpl.forNode(className);
     List<TypeParameterElement> typeParameters = holder.typeParameters;
     List<DartType> typeArguments = _createTypeParameterTypes(typeParameters);
-    InterfaceTypeImpl interfaceType = new InterfaceTypeImpl.con1(element);
+    InterfaceTypeImpl interfaceType = new InterfaceTypeImpl(element);
     interfaceType.typeArguments = typeArguments;
     element.type = interfaceType;
     List<ConstructorElement> constructors = holder.constructors;
     if (constructors.length == 0) {
       //
       // Create the default constructor.
       //
       constructors = _createDefaultConstructors(interfaceType);
     }
     element.abstract = node.isAbstract;
@@ skipping 34 matching lines @@
     _functionTypesToFix = new List<FunctionTypeImpl>();
     _visitChildren(holder, node);
     SimpleIdentifier className = node.name;
     ClassElementImpl element = new ClassElementImpl.forNode(className);
     element.abstract = node.abstractKeyword != null;
     element.mixinApplication = true;
     element.typedef = true;
     List<TypeParameterElement> typeParameters = holder.typeParameters;
     element.typeParameters = typeParameters;
     List<DartType> typeArguments = _createTypeParameterTypes(typeParameters);
-    InterfaceTypeImpl interfaceType = new InterfaceTypeImpl.con1(element);
+    InterfaceTypeImpl interfaceType = new InterfaceTypeImpl(element);
     interfaceType.typeArguments = typeArguments;
     element.type = interfaceType;
     // set default constructor
     element.constructors = _createDefaultConstructors(interfaceType);
     for (FunctionTypeImpl functionType in _functionTypesToFix) {
       functionType.typeArguments = typeArguments;
     }
     _functionTypesToFix = null;
     _currentHolder.addType(element);
     className.staticElement = element;
@@ skipping 103 matching lines @@
     normalParameter.accept(this);
     holder.validate();
     return null;
   }
 
   @override
   Object visitEnumDeclaration(EnumDeclaration node) {
     SimpleIdentifier enumName = node.name;
     ClassElementImpl enumElement = new ClassElementImpl.forNode(enumName);
     enumElement.enum2 = true;
-    InterfaceTypeImpl enumType = new InterfaceTypeImpl.con1(enumElement);
+    InterfaceTypeImpl enumType = new InterfaceTypeImpl(enumElement);
     enumElement.type = enumType;
     _currentHolder.addEnum(enumElement);
     enumName.staticElement = enumElement;
     return super.visitEnumDeclaration(node);
   }
 
   @override
   Object visitFieldDeclaration(FieldDeclaration node) {
     bool wasInField = _inFieldContext;
     _inFieldContext = true;
@@ skipping 163 matching lines @@
       element.generator = true;
     }
     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);
+    FunctionTypeImpl type = new FunctionTypeImpl(element);
     if (_functionTypesToFix != null) {
       _functionTypesToFix.add(type);
     }
     element.type = type;
     _currentHolder.addFunction(element);
     node.element = element;
     holder.validate();
     return null;
   }
 
   @override
   Object visitFunctionTypeAlias(FunctionTypeAlias node) {
     ElementHolder holder = new ElementHolder();
     _visitChildren(holder, node);
     SimpleIdentifier aliasName = node.name;
     List<ParameterElement> parameters = holder.parameters;
     List<TypeParameterElement> typeParameters = holder.typeParameters;
     FunctionTypeAliasElementImpl element =
         new FunctionTypeAliasElementImpl.forNode(aliasName);
     element.parameters = parameters;
     element.typeParameters = typeParameters;
-    FunctionTypeImpl type = new FunctionTypeImpl.con2(element);
+    FunctionTypeImpl type = new FunctionTypeImpl.forTypedef(element);
     type.typeArguments = _createTypeParameterTypes(typeParameters);
     element.type = type;
     _currentHolder.addTypeAlias(element);
     aliasName.staticElement = element;
     holder.validate();
     return null;
   }
 
   @override
   Object visitFunctionTypedFormalParameter(FunctionTypedFormalParameter node) {
@@ skipping 218 matching lines @@
   @override
   Object visitVariableDeclaration(VariableDeclaration node) {
     bool isConst = node.isConst;
     bool isFinal = node.isFinal;
     bool hasInitializer = node.initializer != null;
     VariableElementImpl element;
     if (_inFieldContext) {
       SimpleIdentifier fieldName = node.name;
       FieldElementImpl field;
       if ((isConst || isFinal) && hasInitializer) {
-        field = new ConstFieldElementImpl.con1(fieldName);
+        field = new ConstFieldElementImpl.forNode(fieldName);
       } else {
         field = new FieldElementImpl.forNode(fieldName);
       }
       element = field;
       _currentHolder.addField(field);
       fieldName.staticElement = field;
     } else if (_inFunction) {
       SimpleIdentifier variableName = node.name;
       LocalVariableElementImpl variable;
       if (isConst && hasInitializer) {
@@ skipping 86 matching lines @@
    *
    * @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) {
     ConstructorElementImpl constructor =
         new ConstructorElementImpl.forNode(null);
     constructor.synthetic = true;
     constructor.returnType = interfaceType;
-    FunctionTypeImpl type = new FunctionTypeImpl.con1(constructor);
+    FunctionTypeImpl type = new FunctionTypeImpl(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
@@ skipping 548 matching lines @@
     List<FieldElement> fields = new List<FieldElement>();
     List<PropertyAccessorElement> getters = new List<PropertyAccessorElement>();
     InterfaceType intType = _typeProvider.intType;
     String indexFieldName = "index";
     FieldElementImpl indexField = new FieldElementImpl(indexFieldName, -1);
     indexField.final2 = true;
     indexField.synthetic = true;
     indexField.type = intType;
     fields.add(indexField);
     getters.add(_createGetter(indexField));
-    ConstFieldElementImpl valuesField =
-        new ConstFieldElementImpl.con2("values", -1);
+    ConstFieldElementImpl valuesField = new ConstFieldElementImpl("values", -1);
     valuesField.static = true;
     valuesField.const3 = true;
     valuesField.synthetic = true;
     valuesField.type = _typeProvider.listType.substitute4(<DartType>[enumType]);
     fields.add(valuesField);
     getters.add(_createGetter(valuesField));
     //
     // Build the enum constants.
     //
     NodeList<EnumConstantDeclaration> constants = node.constants;
     List<DartObjectImpl> constantValues = new List<DartObjectImpl>();
     int constantCount = constants.length;
     for (int i = 0; i < constantCount; i++) {
       SimpleIdentifier constantName = constants[i].name;
       FieldElementImpl constantField =
-          new ConstFieldElementImpl.con1(constantName);
+          new ConstFieldElementImpl.forNode(constantName);
       constantField.static = true;
       constantField.const3 = true;
       constantField.type = enumType;
       //
       // Create a value for the constant.
       //
       HashMap<String, DartObjectImpl> fieldMap =
           new HashMap<String, DartObjectImpl>();
       fieldMap[indexFieldName] = new DartObjectImpl(intType, new IntState(i));
       DartObjectImpl value =
           new DartObjectImpl(enumType, new GenericState(fieldMap));
       constantValues.add(value);
-      constantField.evaluationResult = new EvaluationResultImpl.con1(value);
+      constantField.evaluationResult = new EvaluationResultImpl(value);
       fields.add(constantField);
       getters.add(_createGetter(constantField));
       constantName.staticElement = constantField;
     }
     //
     // Build the value of the 'values' field.
     //
-    valuesField.evaluationResult = new EvaluationResultImpl.con1(
+    valuesField.evaluationResult = new EvaluationResultImpl(
         new DartObjectImpl(valuesField.type, new ListState(constantValues)));
     //
     // Finish building the enum.
     //
     enumElement.fields = fields;
     enumElement.accessors = getters;
     // Client code isn't allowed to invoke the constructor, so we do not model
     // it.
     return super.visitEnumDeclaration(node);
   }
 
   /**
    * Create a getter that corresponds to the given field.
    *
    * @param field the field for which a getter is to be created
    * @return the getter that was created
    */
   PropertyAccessorElement _createGetter(FieldElementImpl field) {
     PropertyAccessorElementImpl getter =
         new PropertyAccessorElementImpl.forVariable(field);
     getter.getter = true;
     getter.returnType = field.type;
-    getter.type = new FunctionTypeImpl.con1(getter);
+    getter.type = new FunctionTypeImpl(getter);
     field.getter = getter;
     return getter;
   }
 }
 
 /**
  * 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)`.
  */
@@ skipping 1380 matching lines @@
         implicitParameter.const3 = explicitParameter.isConst;
         implicitParameter.final2 = explicitParameter.isFinal;
         implicitParameter.parameterKind = explicitParameter.parameterKind;
         implicitParameter.synthetic = true;
         implicitParameter.type =
             explicitParameter.type.substitute2(argumentTypes, parameterTypes);
         implicitParameters[i] = implicitParameter;
       }
       implicitConstructor.parameters = implicitParameters;
     }
-    FunctionTypeImpl type = new FunctionTypeImpl.con1(implicitConstructor);
+    FunctionTypeImpl type = new FunctionTypeImpl(implicitConstructor);
     type.typeArguments = classType.typeArguments;
     implicitConstructor.type = type;
     return implicitConstructor;
   }
 
   /**
    * Find all the constructors that should be forwarded from the given
    * [superType], to the class or mixin application [classElement],
    * and pass information about them to [callback].
    *
@@ skipping 62 matching lines @@
       if (superElement != null) {
         _callback(classElement, superElement, () {
           bool constructorFound = false;
           void callback(ConstructorElement explicitConstructor,
               List<DartType> parameterTypes, List<DartType> argumentTypes) {
             constructorFound = true;
           }
           if (_findForwardedConstructors(classElement, superType, callback) &&
               !constructorFound) {
             SourceRange withRange = classElement.withClauseRange;
-            errorListener.onError(new AnalysisError.con2(classElement.source,
+            errorListener.onError(new AnalysisError(classElement.source,
                 withRange.offset, withRange.length,
                 CompileTimeErrorCode.MIXIN_HAS_NO_CONSTRUCTORS,
                 [superElement.name]));
             classElement.mixinErrorsReported = true;
           }
         });
       }
     }
   }
 
@@ skipping 654 matching lines @@
       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(
+          resultMap = new MemberMap.from(
               _computeClassChainLookupMap(superclassElt, visitedClasses));
           //
           // Substitute the super types down the hierarchy.
           //
           _substituteTypeParametersDownHierarchy(supertype, resultMap);
           //
           // Include the members from the superclass in the resultMap.
           //
           _recordMapWithClassMembers(resultMap, supertype, false);
         } finally {
@@ skipping 12 matching lines @@
     // multiple mixins, visit them in the order listed so that methods in later
     // mixins will overwrite identically-named methods in earlier mixins.
     //
     List<InterfaceType> mixins = classElt.mixins;
     for (InterfaceType mixin in mixins) {
       ClassElement mixinElement = mixin.element;
       if (mixinElement != null) {
         if (!visitedClasses.contains(mixinElement)) {
           visitedClasses.add(mixinElement);
           try {
-            MemberMap map = new MemberMap.con2(
+            MemberMap map = new MemberMap.from(
                 _computeClassChainLookupMap(mixinElement, visitedClasses));
             //
             // Substitute the super types down the hierarchy.
             //
             _substituteTypeParametersDownHierarchy(mixin, map);
             //
             // Include the members from the superclass in the resultMap.
             //
             _recordMapWithClassMembers(map, mixin, false);
             //
@@ skipping 147 matching lines @@
     //
     if (superclassElement != null) {
       if (!visitedInterfaces.contains(superclassElement)) {
         try {
           visitedInterfaces.add(superclassElement);
           //
           // Recursively compute the map for the super type.
           //
           MemberMap map =
               _computeInterfaceLookupMap(superclassElement, visitedInterfaces);
-          map = new MemberMap.con2(map);
+          map = new MemberMap.from(map);
           //
           // Substitute the super type down the hierarchy.
           //
           _substituteTypeParametersDownHierarchy(supertype, map);
           //
           // Add any members from the super type into the map as well.
           //
           _recordMapWithClassMembers(map, supertype, true);
           lookupMaps.add(map);
         } finally {
@@ skipping 11 matching lines @@
       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);
-            map = new MemberMap.con2(map);
+            map = new MemberMap.from(map);
             //
             // Substitute the mixin type down the hierarchy.
             //
             _substituteTypeParametersDownHierarchy(mixinType, map);
             //
             // Add any members from the mixin type into the map as well.
             //
             _recordMapWithClassMembers(map, mixinType, true);
             lookupMaps.add(map);
           } finally {
@@ skipping 11 matching lines @@
       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);
-            map = new MemberMap.con2(map);
+            map = new MemberMap.from(map);
             //
             // Substitute the supertypes down the hierarchy
             //
             _substituteTypeParametersDownHierarchy(interfaceType, map);
             //
             // And add any members from the interface into the map as well.
             //
             _recordMapWithClassMembers(map, interfaceType, true);
             lookupMaps.add(map);
           } finally {
@@ skipping 80 matching lines @@
    * @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) {
     HashSet<AnalysisError> errorSet = _errorsInClassElement[classElt];
     if (errorSet == null) {
       errorSet = new HashSet<AnalysisError>();
       _errorsInClassElement[classElt] = errorSet;
     }
-    errorSet.add(new AnalysisError.con2(
+    errorSet.add(new AnalysisError(
         classElt.source, offset, length, errorCode, arguments));
   }
 
   /**
    * Given the set of methods defined by classes above [classElt] in the class hierarchy,
    * apply the appropriate inheritance rules to determine those methods inherited by or overridden
    * by [classElt]. Also report static warnings
    * [StaticTypeWarningCode.INCONSISTENT_METHOD_INHERITANCE] and
    * [StaticWarningCode.INCONSISTENT_METHOD_INHERITANCE_GETTER_AND_METHOD] if appropriate.
    *
@@ skipping 325 matching lines @@
     }
     for (int m = 0; m < namedParameters.length; m++, i++) {
       ParameterElementImpl parameter =
           new ParameterElementImpl(namedParameters[m], 0);
       parameter.type = dynamicType;
       parameter.parameterKind = ParameterKind.NAMED;
       parameters[i] = parameter;
     }
     executable.returnType = dynamicType;
     executable.parameters = parameters;
-    FunctionTypeImpl methodType = new FunctionTypeImpl.con1(executable);
+    FunctionTypeImpl methodType = new FunctionTypeImpl(executable);
     executable.type = methodType;
     return executable;
   }
 
   /**
    * Given some [ExecutableElement], return the list of named parameters.
    */
   static List<String> _getNamedParameterNames(
       ExecutableElement executableElement) {
     List<String> namedParameterNames = new List<String>();
@@ skipping 392 matching lines @@
     if (directive is ImportDirective &&
         uriContent.startsWith(_DART_EXT_SCHEME)) {
       _libraryElement.hasExtUri = true;
       return null;
     }
     try {
       parseUriWithException(uriContent);
       Source source =
           _analysisContext.sourceFactory.resolveUri(librarySource, uriContent);
       if (!_analysisContext.exists(source)) {
-        _errorListener.onError(new AnalysisError.con2(librarySource,
+        _errorListener.onError(new AnalysisError(librarySource,
             uriLiteral.offset, uriLiteral.length,
             CompileTimeErrorCode.URI_DOES_NOT_EXIST, [uriContent]));
       }
       return source;
     } on URISyntaxException {
-      _errorListener.onError(new AnalysisError.con2(librarySource,
-          uriLiteral.offset, uriLiteral.length,
-          CompileTimeErrorCode.INVALID_URI, [uriContent]));
+      _errorListener.onError(new AnalysisError(librarySource, uriLiteral.offset,
+          uriLiteral.length, CompileTimeErrorCode.INVALID_URI, [uriContent]));
     }
     return null;
   }
 
   /**
    * Returns the URI value of the given directive.
    */
   String getUri(UriBasedDirective directive) => _directiveUris[directive];
 
   /**
@@ skipping 78 matching lines @@
           part.uriOffset = partUri.offset;
           part.uriEnd = partUri.end;
           part.uri = partDirective.uriContent;
           //
           // Validate that the part contains a part-of directive with the same
           // name as the library.
           //
           String partLibraryName =
               _getPartLibraryName(partSource, partUnit, directivesToResolve);
           if (partLibraryName == null) {
-            _errorListener.onError(new AnalysisError.con2(librarySource,
+            _errorListener.onError(new AnalysisError(librarySource,
                 partUri.offset, partUri.length,
                 CompileTimeErrorCode.PART_OF_NON_PART, [partUri.toSource()]));
           } else if (libraryNameNode == null) {
             // TODO(brianwilkerson) Collect the names declared by the part.
             // If they are all the same then we can use that name as the
             // inferred name of the library and present it in a quick-fix.
             // partLibraryNames.add(partLibraryName);
           } else if (libraryNameNode.name != partLibraryName) {
-            _errorListener.onError(new AnalysisError.con2(librarySource,
+            _errorListener.onError(new AnalysisError(librarySource,
                 partUri.offset, partUri.length,
                 StaticWarningCode.PART_OF_DIFFERENT_LIBRARY, [
               libraryNameNode.name,
               partLibraryName
             ]));
           }
           if (entryPoint == null) {
             entryPoint = _findEntryPoint(part);
           }
           directive.element = part;
           sourcedCompilationUnits.add(part);
         }
       }
     }
     if (hasPartDirective && libraryNameNode == null) {
-      _errorListener.onError(new AnalysisError.con1(librarySource,
+      _errorListener.onError(new AnalysisError(librarySource, 0, 0,
           ResolverErrorCode.MISSING_LIBRARY_DIRECTIVE_WITH_PART));
     }
     //
     // Create and populate the library element.
     //
     LibraryElementImpl libraryElement = new LibraryElementImpl.forNode(
         _analysisContext.getContextFor(librarySource), libraryNameNode);
     libraryElement.definingCompilationUnit = definingCompilationUnitElement;
     if (entryPoint != null) {
       libraryElement.entryPoint = entryPoint;
@@ skipping 57 matching lines @@
             part.uriOffset = partUri.offset;
             part.uriEnd = partUri.end;
             part.uri = partDirective.uriContent;
             //
             // Validate that the part contains a part-of directive with the same
             // name as the library.
             //
             String partLibraryName =
                 _getPartLibraryName(partSource, partUnit, directivesToResolve);
             if (partLibraryName == null) {
-              _errorListener.onError(new AnalysisError.con2(librarySource,
+              _errorListener.onError(new AnalysisError(librarySource,
                   partUri.offset, partUri.length,
                   CompileTimeErrorCode.PART_OF_NON_PART, [partUri.toSource()]));
             } else if (libraryNameNode == null) {
               // TODO(brianwilkerson) Collect the names declared by the part.
               // If they are all the same then we can use that name as the
               // inferred name of the library and present it in a quick-fix.
               // partLibraryNames.add(partLibraryName);
             } else if (libraryNameNode.name != partLibraryName) {
-              _errorListener.onError(new AnalysisError.con2(librarySource,
+              _errorListener.onError(new AnalysisError(librarySource,
                   partUri.offset, partUri.length,
                   StaticWarningCode.PART_OF_DIFFERENT_LIBRARY, [
                 libraryNameNode.name,
                 partLibraryName
               ]));
             }
             if (entryPoint == null) {
               entryPoint = _findEntryPoint(part);
             }
             directive.element = part;
             sourcedCompilationUnits.add(part);
           }
         }
       }
     }
     if (hasPartDirective && libraryNameNode == null) {
-      _errorListener.onError(new AnalysisError.con1(librarySource,
+      _errorListener.onError(new AnalysisError(librarySource, 0, 0,
           ResolverErrorCode.MISSING_LIBRARY_DIRECTIVE_WITH_PART));
     }
     //
     // Create and populate the library element.
     //
     LibraryElementImpl libraryElement = new LibraryElementImpl.forNode(
         _analysisContext.getContextFor(librarySource), libraryNameNode);
     libraryElement.definingCompilationUnit = definingCompilationUnitElement;
     if (entryPoint != null) {
       libraryElement.entryPoint = entryPoint;
@@ skipping 172 matching lines @@
     }
     if (foundElement is MultiplyDefinedElementImpl) {
       String foundEltName = foundElement.displayName;
       List<Element> conflictingMembers = foundElement.conflictingElements;
       int count = conflictingMembers.length;
       List<String> libraryNames = new List<String>(count);
       for (int i = 0; i < count; i++) {
         libraryNames[i] = _getLibraryName(conflictingMembers[i]);
       }
       libraryNames.sort();
-      errorListener.onError(new AnalysisError.con2(getSource(identifier),
+      errorListener.onError(new AnalysisError(getSource(identifier),
           identifier.offset, identifier.length,
           StaticWarningCode.AMBIGUOUS_IMPORT, [
         foundEltName,
         StringUtilities.printListOfQuotedNames(libraryNames)
       ]));
       return foundElement;
     }
     if (foundElement != null) {
       defineNameWithoutChecking(name, foundElement);
     }
@@ skipping 81 matching lines @@
     for (Element member in conflictingElements) {
       if (member.library.isInSdk) {
         sdkElement = member;
       } else {
         nonSdkElements.add(member);
       }
     }
     if (sdkElement != null && nonSdkElements.length > 0) {
       String sdkLibName = _getLibraryName(sdkElement);
       String otherLibName = _getLibraryName(nonSdkElements[0]);
-      errorListener.onError(new AnalysisError.con2(getSource(identifier),
+      errorListener.onError(new AnalysisError(getSource(identifier),
           identifier.offset, identifier.length,
           StaticWarningCode.CONFLICTING_DART_IMPORT, [
         name,
         sdkLibName,
         otherLibName
       ]));
     }
     if (nonSdkElements.length == conflictingElements.length) {
       // None of the members were removed
       return foundElement;
@@ skipping 442 matching lines @@
                 importElement.prefix = prefix;
                 prefixNode.staticElement = prefix;
               }
               directive.element = importElement;
               imports.add(importElement);
               if (analysisContext.computeKindOf(importedSource) !=
                   SourceKind.LIBRARY) {
                 ErrorCode errorCode = (importElement.isDeferred
                     ? StaticWarningCode.IMPORT_OF_NON_LIBRARY
                     : CompileTimeErrorCode.IMPORT_OF_NON_LIBRARY);
-                _errorListener.onError(new AnalysisError.con2(
-                    library.librarySource, uriLiteral.offset, uriLiteral.length,
-                    errorCode, [uriLiteral.toSource()]));
+                _errorListener.onError(new AnalysisError(library.librarySource,
+                    uriLiteral.offset, uriLiteral.length, errorCode,
+                    [uriLiteral.toSource()]));
               }
             }
           }
         } else if (directive is ExportDirective) {
           ExportDirective exportDirective = directive;
           Source exportedSource = exportDirective.source;
           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(directive.offset);
               StringLiteral uriLiteral = exportDirective.uri;
               exportElement.uriOffset = uriLiteral.offset;
               exportElement.uriEnd = uriLiteral.end;
               exportElement.uri = exportDirective.uriContent;
               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) {
-                _errorListener.onError(new AnalysisError.con2(
-                    library.librarySource, uriLiteral.offset, uriLiteral.length,
+                _errorListener.onError(new AnalysisError(library.librarySource,
+                    uriLiteral.offset, uriLiteral.length,
                     CompileTimeErrorCode.EXPORT_OF_NON_LIBRARY,
                     [uriLiteral.toSource()]));
               }
             }
           }
         }
       }
       Source librarySource = library.librarySource;
       if (!library.explicitlyImportsCore &&
           _coreLibrarySource != librarySource) {
@@ skipping 636 matching lines @@
                 importElement.prefix = prefix;
                 prefixNode.staticElement = prefix;
               }
               directive.element = importElement;
               imports.add(importElement);
               if (analysisContext.computeKindOf(importedSource) !=
                   SourceKind.LIBRARY) {
                 ErrorCode errorCode = (importElement.isDeferred
                     ? StaticWarningCode.IMPORT_OF_NON_LIBRARY
                     : CompileTimeErrorCode.IMPORT_OF_NON_LIBRARY);
-                _errorListener.onError(new AnalysisError.con2(
-                    library.librarySource, uriLiteral.offset, uriLiteral.length,
-                    errorCode, [uriLiteral.toSource()]));
+                _errorListener.onError(new AnalysisError(library.librarySource,
+                    uriLiteral.offset, uriLiteral.length, errorCode,
+                    [uriLiteral.toSource()]));
               }
             }
           }
         } else if (directive is ExportDirective) {
           ExportDirective exportDirective = directive;
           Source exportedSource = exportDirective.source;
           if (exportedSource != null &&
               analysisContext.exists(exportedSource)) {
             // The exported source will be null if the URI in the export
             // directive was invalid.
@@ skipping 10 matching lines @@
               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) {
-                _errorListener.onError(new AnalysisError.con2(
-                    library.librarySource, uriLiteral.offset, uriLiteral.length,
+                _errorListener.onError(new AnalysisError(library.librarySource,
+                    uriLiteral.offset, uriLiteral.length,
                     CompileTimeErrorCode.EXPORT_OF_NON_LIBRARY,
                     [uriLiteral.toSource()]));
               }
             }
           }
         }
       }
       Source librarySource = library.librarySource;
       if (!library.explicitlyImportsCore &&
           _coreLibrarySource != librarySource) {
@@ skipping 304 matching lines @@
     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,
+      return new AnalysisError(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.
@@ skipping 31 matching lines @@
       define(prefix);
     }
     _defineLocalNames(definingLibrary.definingCompilationUnit);
     for (CompilationUnitElement compilationUnit in definingLibrary.parts) {
       _defineLocalNames(compilationUnit);
     }
   }
 }
 
 /**
- * This class is used to replace uses of `HashMap<String, ExecutableElement>` which are not as
- * performant as this class.
+ * This class is used to replace uses of `HashMap<String, ExecutableElement>`
+ * which are not as performant as this class.
  */
 class MemberMap {
   /**
    * The current size of this map.
    */
   int _size = 0;
 
   /**
    * The array of keys.
    */
   List<String> _keys;
 
   /**
    * The array of ExecutableElement values.
    */
   List<ExecutableElement> _values;
 
   /**
-   * Default constructor.
+   * Initialize a newly created member map to have the given [initialCapacity].
+   * The map will grow if needed.
    */
-  MemberMap() : this.con1(10);
+  MemberMap([int initialCapacity = 10]) {
+    _initArrays(initialCapacity);
+  }
 
   /**
    * This constructor takes an initial capacity of the map.
    *
    * @param initialCapacity the initial capacity
    */
+  @deprecated // Use new MemberMap(initialCapacity)
   MemberMap.con1(int initialCapacity) {
     _initArrays(initialCapacity);
   }
 
   /**
    * Copy constructor.
    */
+  @deprecated // Use new MemberMap.from(memberMap)
   MemberMap.con2(MemberMap memberMap) {
     _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;
   }
 
   /**
+   * Initialize a newly created member map to contain the same members as the
+   * given [memberMap].
+   */
+  MemberMap.from(MemberMap memberMap) {
+    _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;
+  }
+
+  /**
    * The size of the map.
    *
    * @return the size of the map.
    */
   int get size => _size;
 
   /**
    * Given some key, return the ExecutableElement value from the map, if the key does not exist in
    * the map, `null` is returned.
    *
@@ skipping 2599 matching lines @@
    * @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
    */
   AnalysisError getErrorForDuplicate(Element existing, Element duplicate) {
     // TODO(brianwilkerson) Customize the error message based on the types of
     // elements that share the same name.
     // TODO(jwren) There are 4 error codes for duplicate, but only 1 is being
     // generated.
     Source source = duplicate.source;
-    return new AnalysisError.con2(source, duplicate.nameOffset,
+    return new AnalysisError(source, duplicate.nameOffset,
         duplicate.displayName.length, CompileTimeErrorCode.DUPLICATE_DEFINITION,
         [existing.displayName]);
   }
 
   /**
    * Return the source that contains the given identifier, or the source associated with this scope
    * if the source containing the identifier could not be determined.
    *
    * @param identifier the identifier whose source is to be returned
    * @return the source that contains the given identifier
@@ skipping 225 matching lines @@
 
   /**
    * Report an error with the given error code and arguments.
    *
    * @param errorCode the error code of the error to be reported
    * @param node the node specifying the location of the error
    * @param arguments the arguments to the error, used to compose the error message
    */
   void reportErrorForNode(ErrorCode errorCode, AstNode node,
       [List<Object> arguments]) {
-    _errorListener.onError(new AnalysisError.con2(
+    _errorListener.onError(new AnalysisError(
         source, node.offset, node.length, errorCode, arguments));
   }
 
   /**
    * Report an error with the given error code and arguments.
    *
    * @param errorCode the error code of the error to be reported
    * @param offset the offset of the location of the error
    * @param length the length of the location of the error
    * @param arguments the arguments to the error, used to compose the error message
    */
   void reportErrorForOffset(ErrorCode errorCode, int offset, int length,
       [List<Object> arguments]) {
     _errorListener.onError(
-        new AnalysisError.con2(source, offset, length, errorCode, arguments));
+        new AnalysisError(source, offset, length, errorCode, arguments));
   }
 
   /**
    * Report an error with the given error code and arguments.
    *
    * @param errorCode the error code of the error to be reported
    * @param token the token specifying the location of the error
    * @param arguments the arguments to the error, used to compose the error message
    */
   void reportErrorForToken(ErrorCode errorCode, sc.Token token,
       [List<Object> arguments]) {
-    _errorListener.onError(new AnalysisError.con2(
+    _errorListener.onError(new AnalysisError(
         source, token.offset, token.length, errorCode, arguments));
   }
 
   /**
    * Visit the given AST node if it is not null.
    *
    * @param node the node to be visited
    */
   void safelyVisit(AstNode node) {
     if (node != null) {
@@ skipping 1773 matching lines @@
         buffer.write(classNode.name.name);
       }
       buffer.write(" in ");
       buffer.write(source.fullName);
       buffer.write(" was not set while trying to resolve types.");
       AnalysisEngine.instance.logger.logError(buffer.toString(),
           new CaughtException(new AnalysisException(), null));
     } else {
       ClassElement definingClass = element.enclosingElement as ClassElement;
       element.returnType = definingClass.type;
-      FunctionTypeImpl type = new FunctionTypeImpl.con1(element);
+      FunctionTypeImpl type = new FunctionTypeImpl(element);
       type.typeArguments = definingClass.type.typeArguments;
       element.type = type;
     }
     return null;
   }
 
   @override
   Object visitDeclaredIdentifier(DeclaredIdentifier node) {
     super.visitDeclaredIdentifier(node);
     DartType declaredType;
@@ skipping 48 matching lines @@
       StringBuffer buffer = new StringBuffer();
       buffer.write("The element for the top-level function ");
       buffer.write(node.name);
       buffer.write(" in ");
       buffer.write(source.fullName);
       buffer.write(" was not set while trying to resolve types.");
       AnalysisEngine.instance.logger.logError(buffer.toString(),
           new CaughtException(new AnalysisException(), null));
     }
     element.returnType = _computeReturnType(node.returnType);
-    FunctionTypeImpl type = new FunctionTypeImpl.con1(element);
+    FunctionTypeImpl type = new FunctionTypeImpl(element);
     ClassElement definingClass =
         element.getAncestor((element) => element is ClassElement);
     if (definingClass != null) {
       type.typeArguments = definingClass.type.typeArguments;
     }
     element.type = type;
     return null;
   }
 
   @override
@@ skipping 36 matching lines @@
       } else {
         buffer.write(classNode.name.name);
       }
       buffer.write(" in ");
       buffer.write(source.fullName);
       buffer.write(" was not set while trying to resolve types.");
       AnalysisEngine.instance.logger.logError(buffer.toString(),
           new CaughtException(new AnalysisException(), null));
     }
     element.returnType = _computeReturnType(node.returnType);
-    FunctionTypeImpl type = new FunctionTypeImpl.con1(element);
+    FunctionTypeImpl type = new FunctionTypeImpl(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;
@@ skipping 335 matching lines @@
       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);
+        FunctionTypeImpl getterType = new FunctionTypeImpl(getter);
         ClassElement definingClass =
             element.getAncestor((element) => element is ClassElement);
         if (definingClass != null) {
           getterType.typeArguments = definingClass.type.typeArguments;
         }
         getter.type = getterType;
         PropertyAccessorElementImpl setter =
             variableElement.setter as PropertyAccessorElementImpl;
         if (setter != null) {
           List<ParameterElement> parameters = setter.parameters;
           if (parameters.length > 0) {
             (parameters[0] as ParameterElementImpl).type = declaredType;
           }
           setter.returnType = VoidTypeImpl.instance;
-          FunctionTypeImpl setterType = new FunctionTypeImpl.con1(setter);
+          FunctionTypeImpl setterType = new FunctionTypeImpl(setter);
           if (definingClass != null) {
             setterType.typeArguments = definingClass.type.typeArguments;
           }
           setter.type = setterType;
         }
       }
     } else {
       // TODO(brianwilkerson) Report the internal error.
     }
     return null;
@@ skipping 400 matching lines @@
         new FunctionTypeAliasElementImpl.forNode(null);
     aliasElement.synthetic = true;
     aliasElement.shareParameters(parameters);
     aliasElement.returnType = _computeReturnType(returnType);
     // FunctionTypeAliasElementImpl assumes the enclosing element is a
     // CompilationUnitElement (because non-synthetic function types can only be
     // declared at top level), so to avoid breaking things, go find the
     // compilation unit element.
     aliasElement.enclosingElement =
         element.getAncestor((element) => element is CompilationUnitElement);
-    FunctionTypeImpl type = new FunctionTypeImpl.con2(aliasElement);
+    FunctionTypeImpl type = new FunctionTypeImpl.forTypedef(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 =
@@ skipping 183 matching lines @@
     }
     if (_usedElements.members.contains(element.displayName)) {
       return true;
     }
     return _usedElements.elements.contains(element);
   }
 
   void _reportErrorForElement(
       ErrorCode errorCode, Element element, List<Object> arguments) {
     if (element != null) {
-      _errorListener.onError(new AnalysisError.con2(element.source,
+      _errorListener.onError(new AnalysisError(element.source,
           element.nameOffset, element.displayName.length, errorCode,
           arguments));
     }
   }
 }
 
 /**
  * A container with information about used imports prefixes and used imported
  * elements.
  */
@@ skipping 395 matching lines @@
     nonFields.add(node);
     return null;
   }
 
   @override
   Object visitNode(AstNode node) => node.accept(TypeResolverVisitor_this);
 
   @override
   Object visitWithClause(WithClause node) => null;
 }