Clean up many generated constructors

pkg/analyzer/lib/src/generated/engine.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;
 
 import "dart:math" as math;
@@ skipping 1517 matching lines @@
       return null;
     }
     Source source = element.source;
     if (source == null) {
       return null;
     }
     CompilationUnit unit = parseCompilationUnit(source);
     if (unit == null) {
       return null;
     }
-    NodeLocator locator = new NodeLocator.con1(element.nameOffset);
+    NodeLocator locator = new NodeLocator(element.nameOffset);
     AstNode nameNode = locator.searchWithin(unit);
     while (nameNode != null) {
       if (nameNode is AnnotatedNode) {
         Comment comment = nameNode.documentationComment;
         if (comment == null) {
           return null;
         }
         StringBuffer buffer = new StringBuffer();
         List<Token> tokens = comment.tokens;
         for (int i = 0; i < tokens.length; i++) {
@@ skipping 4529 matching lines @@
   /**
    * The default value for enabling deferred loading.
    */
   @deprecated
   static bool DEFAULT_ENABLE_DEFERRED_LOADING = true;
 
   /**
    * The default value for enabling enum support.
    */
   @deprecated
-  static bool DEFAULT_ENABLE_ENUM = false;
+  static bool DEFAULT_ENABLE_ENUM = true;
 
   /**
    * A predicate indicating whether analysis is to parse and analyze function
    * bodies.
    */
   AnalyzeFunctionBodiesPredicate _analyzeFunctionBodiesPredicate =
       _analyzeAllFunctionBodies;
 
   /**
    * The maximum number of sources for which AST structures should be kept in
@@ skipping 66 matching lines @@
   /**
    * Initialize a newly created set of analysis options to have their default
    * values.
    */
   AnalysisOptionsImpl();
 
   /**
    * Initialize a newly created set of analysis options to have the same values
    * as those in the given set of analysis [options].
    */
+  @deprecated // Use new AnalysisOptionsImpl.from(options)
   AnalysisOptionsImpl.con1(AnalysisOptions options) {
     analyzeFunctionBodiesPredicate = options.analyzeFunctionBodiesPredicate;
     cacheSize = options.cacheSize;
     dart2jsHint = options.dart2jsHint;
     enableNullAwareOperators = options.enableNullAwareOperators;
     enableStrictCallChecks = options.enableStrictCallChecks;
     generateImplicitErrors = options.generateImplicitErrors;
     generateSdkErrors = options.generateSdkErrors;
     hint = options.hint;
     incremental = options.incremental;
     incrementalApi = options.incrementalApi;
     incrementalValidation = options.incrementalValidation;
     lint = options.lint;
     preserveComments = options.preserveComments;
   }
 
+  /**
+   * Initialize a newly created set of analysis options to have the same values
+   * as those in the given set of analysis [options].
+   */
+  AnalysisOptionsImpl.from(AnalysisOptions options) {
+    analyzeFunctionBodiesPredicate = options.analyzeFunctionBodiesPredicate;
+    cacheSize = options.cacheSize;
+    dart2jsHint = options.dart2jsHint;
+    enableNullAwareOperators = options.enableNullAwareOperators;
+    enableStrictCallChecks = options.enableStrictCallChecks;
+    generateImplicitErrors = options.generateImplicitErrors;
+    generateSdkErrors = options.generateSdkErrors;
+    hint = options.hint;
+    incremental = options.incremental;
+    incrementalApi = options.incrementalApi;
+    incrementalValidation = options.incrementalValidation;
+    lint = options.lint;
+    preserveComments = options.preserveComments;
+  }
+
   bool get analyzeFunctionBodies {
     if (identical(analyzeFunctionBodiesPredicate, _analyzeAllFunctionBodies)) {
       return true;
     } else if (identical(
         analyzeFunctionBodiesPredicate, _analyzeNoFunctionBodies)) {
       return false;
     } else {
       throw new StateError('analyzeFunctionBodiesPredicate in use');
     }
   }
@@ skipping 2041 matching lines @@
       if (context.exists(source)) {
         return;
       }
     } else {
       // Don't report errors already reported by ParseDartTask.resolveDirective
       if (directive.validate() != null) {
         return;
       }
     }
     StringLiteral uriLiteral = directive.uri;
-    errorListener.onError(new AnalysisError.con2(librarySource,
-        uriLiteral.offset, uriLiteral.length,
-        CompileTimeErrorCode.URI_DOES_NOT_EXIST, [directive.uriContent]));
+    errorListener.onError(new AnalysisError(librarySource, uriLiteral.offset,
+        uriLiteral.length, CompileTimeErrorCode.URI_DOES_NOT_EXIST,
+        [directive.uriContent]));
   }
 }
 
 /**
  * Instances of the class `GenerateDartHintsTask` generate hints for a single Dart library.
  */
 class GenerateDartHintsTask extends AnalysisTask {
   /**
    * The compilation units that comprise the library, with the defining compilation unit appearing
    * first in the list.
@@ skipping 203 matching lines @@
   @override
   void internalPerform() {
     _complete = true;
     try {
       TimestampedData<String> data = context.getContents(source);
       _content = data.data;
       _modificationTime = data.modificationTime;
       AnalysisEngine.instance.instrumentationService.logFileRead(
           source.fullName, _modificationTime, _content);
     } catch (exception, stackTrace) {
-      errors.add(new AnalysisError.con1(
-          source, ScannerErrorCode.UNABLE_GET_CONTENT, [exception]));
+      errors.add(new AnalysisError(
+          source, 0, 0, ScannerErrorCode.UNABLE_GET_CONTENT, [exception]));
       throw new AnalysisException("Could not get contents of $source",
           new CaughtException(exception, stackTrace));
     }
   }
 }
 
 /**
  * The information cached by an analysis context about an individual HTML file.
  */
 class HtmlEntry extends SourceEntry {
@@ skipping 669 matching lines @@
    * explanation of why the error occurred or what it means. The [exception] is
    * expected to be the reason for the error. At least one argument must be
    * provided.
    */
   void logError(String message, [CaughtException exception]);
 
   /**
    * Log the given [exception] as one representing an error. The [message] is an
    * explanation of why the error occurred or what it means.
    */
-  @deprecated
+  @deprecated // Use logError(message, exception)
   void logError2(String message, Object exception);
 
   /**
    * Log the given informational message. The [message] is expected to be an
    * explanation of why the error occurred or what it means. The [exception] is
    * expected to be the reason for the error.
    */
   void logInformation(String message, [CaughtException exception]);
 
   /**
    * Log the given [exception] as one representing an informational message. The
    * [message] is an explanation of why the error occurred or what it means.
    */
-  @deprecated
+  @deprecated // Use logInformation(message, exception)
   void logInformation2(String message, Object exception);
 }
 
 /**
  * An implementation of [Logger] that does nothing.
  */
 class NullLogger implements Logger {
   @override
   void logError(String message, [CaughtException exception]) {}
 
@@ skipping 247 matching lines @@
         directive.source = source;
         return source;
       } on JavaIOException {
         code = UriValidationCode.INVALID_URI;
       }
     }
     if (code == UriValidationCode.URI_WITH_DART_EXT_SCHEME) {
       return null;
     }
     if (code == UriValidationCode.URI_WITH_INTERPOLATION) {
-      errorListener.onError(new AnalysisError.con2(librarySource,
-          uriLiteral.offset, uriLiteral.length,
-          CompileTimeErrorCode.URI_WITH_INTERPOLATION));
+      errorListener.onError(new AnalysisError(librarySource, uriLiteral.offset,
+          uriLiteral.length, CompileTimeErrorCode.URI_WITH_INTERPOLATION));
       return null;
     }
     if (code == UriValidationCode.INVALID_URI) {
-      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;
     }
     throw new RuntimeException(
         message: "Failed to handle validation code: $code");
   }
 }
 
 /**
  * Instances of the class `ParseHtmlTask` parse a specific source as an HTML file.
  */
@@ skipping 2194 matching lines @@
     PendingFuture pendingFuture =
         new PendingFuture<T>(_context, source, computeValue);
     if (!pendingFuture.evaluate(sourceEntry)) {
       _context._pendingFutureSources
           .putIfAbsent(source, () => <PendingFuture>[])
           .add(pendingFuture);
     }
     return pendingFuture.future;
   }
 }