Clean up many generated constructors

pkg/analyzer/test/generated/engine_test.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.engine_test;
 
 import 'dart:async';
@@ skipping 89 matching lines @@
 
   /**
    * Verify that if multiple Source objects refer to the same file via
    * different URIs, they are treated as separate entries in the cache.
    */
   void test_lookup_distinguishes_uris() {
     CachePartition partition =
         new UniversalCachePartition(null, 8, new DefaultRetentionPolicy());
     AnalysisCache cache = new AnalysisCache(<CachePartition>[partition]);
     JavaFile file = new JavaFile('baz.dart');
-    Source source1 = new FileBasedSource.con1(file);
+    Source source1 = new FileBasedSource(file);
     Source source2 =
-        new FileBasedSource.con2(Uri.parse('package:foo/baz.dart'), file);
+        new FileBasedSource(file, Uri.parse('package:foo/baz.dart'));
     Source source3 =
-        new FileBasedSource.con2(Uri.parse('package:bar/baz.dart'), file);
+        new FileBasedSource(file, Uri.parse('package:bar/baz.dart'));
     DartEntry entry1 = new DartEntry();
     DartEntry entry2 = new DartEntry();
     DartEntry entry3 = new DartEntry();
     cache.put(source1, entry1);
     cache.put(source2, entry2);
     cache.put(source3, entry3);
     expect(cache.get(source1), same(entry1));
     expect(cache.get(source2), same(entry2));
     expect(cache.get(source3), same(entry3));
   }
@@ skipping 103 matching lines @@
 
   @override
   void setUp() {
     _context = new AnalysisContextImpl();
     _sourceFactory = new SourceFactory([
       new DartUriResolver(DirectoryBasedDartSdk.defaultSdk),
       new FileUriResolver()
     ]);
     _context.sourceFactory = _sourceFactory;
     AnalysisOptionsImpl options =
-        new AnalysisOptionsImpl.con1(_context.analysisOptions);
+        new AnalysisOptionsImpl.from(_context.analysisOptions);
     options.cacheSize = 256;
     _context.analysisOptions = options;
   }
 
   @override
   void tearDown() {
     _context = null;
     _sourceFactory = null;
     super.tearDown();
   }
 
   Future test_applyChanges_add() {
     SourcesChangedListener listener = new SourcesChangedListener();
     _context.onSourcesChanged.listen(listener.onData);
     expect(_context.sourcesNeedingProcessing.isEmpty, isTrue);
     Source source =
-        new FileBasedSource.con1(FileUtilities2.createFile("/test.dart"));
+        new FileBasedSource(FileUtilities2.createFile("/test.dart"));
     ChangeSet changeSet = new ChangeSet();
     changeSet.addedSource(source);
     _context.applyChanges(changeSet);
     expect(_context.sourcesNeedingProcessing.contains(source), isTrue);
     return pumpEventQueue().then((_) {
       listener.assertEvent(wereSourcesAdded: true);
       listener.assertNoMoreEvents();
     });
   }
 
   Future test_applyChanges_change() {
     SourcesChangedListener listener = new SourcesChangedListener();
     _context.onSourcesChanged.listen(listener.onData);
     expect(_context.sourcesNeedingProcessing.isEmpty, isTrue);
     Source source =
-        new FileBasedSource.con1(FileUtilities2.createFile("/test.dart"));
+        new FileBasedSource(FileUtilities2.createFile("/test.dart"));
     ChangeSet changeSet1 = new ChangeSet();
     changeSet1.addedSource(source);
     _context.applyChanges(changeSet1);
     expect(_context.sourcesNeedingProcessing.contains(source), isTrue);
     Source source2 =
-        new FileBasedSource.con1(FileUtilities2.createFile("/test2.dart"));
+        new FileBasedSource(FileUtilities2.createFile("/test2.dart"));
     ChangeSet changeSet2 = new ChangeSet();
     changeSet2.addedSource(source2);
     changeSet2.changedSource(source);
     _context.applyChanges(changeSet2);
     return pumpEventQueue().then((_) {
       listener.assertEvent(wereSourcesAdded: true);
       listener.assertEvent(wereSourcesAdded: true, changedSources: [source]);
       listener.assertNoMoreEvents();
     });
   }
 
   Future test_applyChanges_change_content() {
     SourcesChangedListener listener = new SourcesChangedListener();
     _context.onSourcesChanged.listen(listener.onData);
     expect(_context.sourcesNeedingProcessing.isEmpty, isTrue);
     Source source =
-        new FileBasedSource.con1(FileUtilities2.createFile("/test.dart"));
+        new FileBasedSource(FileUtilities2.createFile("/test.dart"));
     ChangeSet changeSet1 = new ChangeSet();
     changeSet1.addedSource(source);
     _context.applyChanges(changeSet1);
     expect(_context.sourcesNeedingProcessing.contains(source), isTrue);
     Source source2 =
-        new FileBasedSource.con1(FileUtilities2.createFile("/test2.dart"));
+        new FileBasedSource(FileUtilities2.createFile("/test2.dart"));
     ChangeSet changeSet2 = new ChangeSet();
     changeSet2.addedSource(source2);
     changeSet2.changedContent(source, 'library test;');
     _context.applyChanges(changeSet2);
     return pumpEventQueue().then((_) {
       listener.assertEvent(wereSourcesAdded: true);
       listener.assertEvent(wereSourcesAdded: true, changedSources: [source]);
       listener.assertNoMoreEvents();
     });
   }
@@ skipping 58 matching lines @@
       listener.assertEvent(changedSources: [partSource]);
       listener.assertNoMoreEvents();
     });
   }
 
   Future test_applyChanges_change_range() {
     SourcesChangedListener listener = new SourcesChangedListener();
     _context.onSourcesChanged.listen(listener.onData);
     expect(_context.sourcesNeedingProcessing.isEmpty, isTrue);
     Source source =
-        new FileBasedSource.con1(FileUtilities2.createFile("/test.dart"));
+        new FileBasedSource(FileUtilities2.createFile("/test.dart"));
     ChangeSet changeSet1 = new ChangeSet();
     changeSet1.addedSource(source);
     _context.applyChanges(changeSet1);
     expect(_context.sourcesNeedingProcessing.contains(source), isTrue);
     Source source2 =
-        new FileBasedSource.con1(FileUtilities2.createFile("/test2.dart"));
+        new FileBasedSource(FileUtilities2.createFile("/test2.dart"));
     ChangeSet changeSet2 = new ChangeSet();
     changeSet2.addedSource(source2);
     changeSet2.changedRange(source, 'library test;', 0, 0, 13);
     _context.applyChanges(changeSet2);
     return pumpEventQueue().then((_) {
       listener.assertEvent(wereSourcesAdded: true);
       listener.assertEvent(wereSourcesAdded: true, changedSources: [source]);
       listener.assertNoMoreEvents();
     });
   }
@@ skipping 967 matching lines @@
 
   void test_parseCompilationUnit_noErrors() {
     Source source = _addSource("/lib.dart", "library lib;");
     CompilationUnit compilationUnit = _context.parseCompilationUnit(source);
     expect(compilationUnit, isNotNull);
     expect(_context.getErrors(source).errors, hasLength(0));
   }
 
   void test_parseCompilationUnit_nonExistentSource() {
     Source source =
-        new FileBasedSource.con1(FileUtilities2.createFile("/test.dart"));
+        new FileBasedSource(FileUtilities2.createFile("/test.dart"));
     try {
       _context.parseCompilationUnit(source);
       fail("Expected AnalysisException because file does not exist");
     } on AnalysisException {
       // Expected result
     }
   }
 
   void test_parseHtmlUnit_noErrors() {
     Source source = _addSource("/lib.html", "<html></html>");
@@ skipping 437 matching lines @@
     options.hint = false;
     _context.analysisOptions = options;
     AnalysisOptions result = _context.analysisOptions;
     expect(result.cacheSize, options.cacheSize);
     expect(result.dart2jsHint, options.dart2jsHint);
     expect(result.hint, options.hint);
   }
 
   void test_setAnalysisOptions_reduceAnalysisPriorityOrder() {
     AnalysisOptionsImpl options =
-        new AnalysisOptionsImpl.con1(_context.analysisOptions);
+        new AnalysisOptionsImpl.from(_context.analysisOptions);
     List<Source> sources = new List<Source>();
     for (int index = 0; index < options.cacheSize; index++) {
       sources.add(_addSource("/lib.dart$index", ""));
     }
     _context.analysisPriorityOrder = sources;
     int oldPriorityOrderSize = _getPriorityOrder(_context).length;
     options.cacheSize = options.cacheSize - 10;
     _context.analysisOptions = options;
     expect(oldPriorityOrderSize > _getPriorityOrder(_context).length, isTrue);
   }
@@ skipping 59 matching lines @@
       listener.assertEvent(wereSourcesAdded: true);
       listener.assertEvent(changedSources: [partSource]);
       listener.assertEvent(changedSources: [librarySource]);
       listener.assertNoMoreEvents();
     });
   }
 
   void test_setChangedContents_notResolved() {
     _context = AnalysisContextFactory.contextWithCore();
     AnalysisOptionsImpl options =
-        new AnalysisOptionsImpl.con1(_context.analysisOptions);
+        new AnalysisOptionsImpl.from(_context.analysisOptions);
     options.incremental = true;
     _context.analysisOptions = options;
     _sourceFactory = _context.sourceFactory;
     String oldCode = r'''
 library lib;
 int a = 0;''';
     Source librarySource = _addSource("/lib.dart", oldCode);
     int offset = oldCode.indexOf("int a") + 4;
     String newCode = r'''
 library lib;
@@ skipping 96 matching lines @@
     // test1 and test2 should have been successfully analyzed
     // despite the fact that test3 couldn't be read.
     expect(_context.computeLibraryElement(test1), isNotNull);
     expect(_context.computeLibraryElement(test2), isNotNull);
     expect(_context.computeLibraryElement(test3), isNull);
   }
 
   void test_updateAnalysis() {
     expect(_context.sourcesNeedingProcessing.isEmpty, isTrue);
     Source source =
-        new FileBasedSource.con1(FileUtilities2.createFile("/test.dart"));
+        new FileBasedSource(FileUtilities2.createFile("/test.dart"));
     AnalysisDelta delta = new AnalysisDelta();
     delta.setAnalysisLevel(source, AnalysisLevel.ALL);
     _context.applyAnalysisDelta(delta);
     expect(_context.sourcesNeedingProcessing.contains(source), isTrue);
     delta = new AnalysisDelta();
     delta.setAnalysisLevel(source, AnalysisLevel.NONE);
     _context.applyAnalysisDelta(delta);
     expect(_context.sourcesNeedingProcessing.contains(source), isFalse);
   }
 
   void xtest_performAnalysisTask_stress() {
     int maxCacheSize = 4;
     AnalysisOptionsImpl options =
-        new AnalysisOptionsImpl.con1(_context.analysisOptions);
+        new AnalysisOptionsImpl.from(_context.analysisOptions);
     options.cacheSize = maxCacheSize;
     _context.analysisOptions = options;
     int sourceCount = maxCacheSize + 2;
     List<Source> sources = new List<Source>();
     ChangeSet changeSet = new ChangeSet();
     for (int i = 0; i < sourceCount; i++) {
       Source source = _addSource("/lib$i.dart", "library lib$i;");
       sources.add(source);
       changeSet.addedSource(source);
     }
     _context.applyChanges(changeSet);
     _context.analysisPriorityOrder = sources;
     for (int i = 0; i < 1000; i++) {
       List<ChangeNotice> notice = _context.performAnalysisTask().changeNotices;
       if (notice == null) {
         //System.out.println("test_performAnalysisTask_stress: " + i);
         break;
       }
     }
     List<ChangeNotice> notice = _context.performAnalysisTask().changeNotices;
     if (notice != null) {
       fail(
           "performAnalysisTask failed to terminate after analyzing all sources");
     }
   }
 
   Source _addSource(String fileName, String contents) {
-    Source source =
-        new FileBasedSource.con1(FileUtilities2.createFile(fileName));
+    Source source = new FileBasedSource(FileUtilities2.createFile(fileName));
     ChangeSet changeSet = new ChangeSet();
     changeSet.addedSource(source);
     _context.applyChanges(changeSet);
     _context.setContents(source, contents);
     return source;
   }
 
   TestSource _addSourceWithException(String fileName) {
     return _addSourceWithException2(fileName, "");
   }
@@ skipping 126 matching lines @@
       options.analyzeFunctionBodies = booleanValue;
       options.cacheSize = i;
       options.dart2jsHint = booleanValue;
       options.enableNullAwareOperators = booleanValue;
       options.enableStrictCallChecks = booleanValue;
       options.generateImplicitErrors = booleanValue;
       options.generateSdkErrors = booleanValue;
       options.hint = booleanValue;
       options.incremental = booleanValue;
       options.preserveComments = booleanValue;
-      AnalysisOptionsImpl copy = new AnalysisOptionsImpl.con1(options);
+      AnalysisOptionsImpl copy = new AnalysisOptionsImpl.from(options);
       expect(copy.analyzeFunctionBodies, options.analyzeFunctionBodies);
       expect(copy.cacheSize, options.cacheSize);
       expect(copy.dart2jsHint, options.dart2jsHint);
       expect(copy.enableNullAwareOperators, options.enableNullAwareOperators);
       expect(copy.enableStrictCallChecks, options.enableStrictCallChecks);
       expect(copy.generateImplicitErrors, options.generateImplicitErrors);
       expect(copy.generateSdkErrors, options.generateSdkErrors);
       expect(copy.hint, options.hint);
       expect(copy.incremental, options.incremental);
       expect(copy.preserveComments, options.preserveComments);
@@ skipping 88 matching lines @@
   noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
 }
 
 @reflectiveTest
 class DartEntryTest extends EngineTestCase {
   void test_allErrors() {
     Source source = new TestSource();
     DartEntry entry = new DartEntry();
     expect(entry.allErrors, hasLength(0));
     entry.setValue(SourceEntry.CONTENT_ERRORS, <AnalysisError>[
-      new AnalysisError.con1(
-          source, ScannerErrorCode.UNABLE_GET_CONTENT, ['exception details'])
+      new AnalysisError(source, 0, 0, ScannerErrorCode.UNABLE_GET_CONTENT,
+          ['exception details'])
     ]);
     entry.setValue(DartEntry.SCAN_ERRORS, <AnalysisError>[
-      new AnalysisError.con1(
-          source, ScannerErrorCode.UNTERMINATED_STRING_LITERAL)
+      new AnalysisError(
+          source, 0, 0, ScannerErrorCode.UNTERMINATED_STRING_LITERAL)
     ]);
     entry.setValue(DartEntry.PARSE_ERRORS, <AnalysisError>[
-      new AnalysisError.con1(source, ParserErrorCode.ABSTRACT_CLASS_MEMBER)
+      new AnalysisError(source, 0, 0, ParserErrorCode.ABSTRACT_CLASS_MEMBER)
     ]);
     entry.setValueInLibrary(DartEntry.RESOLUTION_ERRORS, source,
         <AnalysisError>[
-      new AnalysisError.con1(
-          source, CompileTimeErrorCode.CONST_CONSTRUCTOR_THROWS_EXCEPTION)
+      new AnalysisError(
+          source, 0, 0, CompileTimeErrorCode.CONST_CONSTRUCTOR_THROWS_EXCEPTION)
     ]);
     entry.setValueInLibrary(DartEntry.VERIFICATION_ERRORS, source,
         <AnalysisError>[
-      new AnalysisError.con1(
-          source, StaticWarningCode.CASE_BLOCK_NOT_TERMINATED)
+      new AnalysisError(
+          source, 0, 0, StaticWarningCode.CASE_BLOCK_NOT_TERMINATED)
     ]);
     entry.setValueInLibrary(DartEntry.HINTS, source,
-        <AnalysisError>[new AnalysisError.con1(source, HintCode.DEAD_CODE)]);
+        <AnalysisError>[new AnalysisError(source, 0, 0, HintCode.DEAD_CODE)]);
     expect(entry.allErrors, hasLength(6));
   }
 
   void test_creation() {
     Source librarySource = new TestSource();
     DartEntry entry = new DartEntry();
     expect(entry.getState(SourceEntry.CONTENT), same(CacheState.INVALID));
     expect(entry.getState(SourceEntry.LINE_INFO), same(CacheState.INVALID));
     expect(entry.getState(DartEntry.CONTAINING_LIBRARIES),
         same(CacheState.INVALID));
@@ skipping 1020 matching lines @@
     _setValue(DartEntry.ELEMENT, new LibraryElementImpl.forNode(
         null, AstFactory.libraryIdentifier2(["lib"])));
   }
 
   void test_setValue_exportedLibraries() {
     _setValue(DartEntry.EXPORTED_LIBRARIES, <Source>[new TestSource()]);
   }
 
   void test_setValue_hints() {
     _setValueInLibrary(DartEntry.HINTS,
-        <AnalysisError>[new AnalysisError.con1(null, HintCode.DEAD_CODE)]);
+        <AnalysisError>[new AnalysisError(null, 0, 0, HintCode.DEAD_CODE)]);
   }
 
   void test_setValue_importedLibraries() {
     _setValue(DartEntry.IMPORTED_LIBRARIES, <Source>[new TestSource()]);
   }
 
   void test_setValue_includedParts() {
     _setValue(DartEntry.INCLUDED_PARTS, <Source>[new TestSource()]);
   }
 
   void test_setValue_isClient() {
     _setValue(DartEntry.IS_CLIENT, true);
   }
 
   void test_setValue_isLaunchable() {
     _setValue(DartEntry.IS_LAUNCHABLE, true);
   }
 
   void test_setValue_lineInfo() {
     _setValue(SourceEntry.LINE_INFO, new LineInfo(<int>[0]));
   }
 
   void test_setValue_parsedUnit() {
     _setValue(DartEntry.PARSED_UNIT, AstFactory.compilationUnit());
   }
 
   void test_setValue_parseErrors() {
     _setValue(DartEntry.PARSE_ERRORS, <AnalysisError>[
-      new AnalysisError.con1(null, ParserErrorCode.ABSTRACT_CLASS_MEMBER)
+      new AnalysisError(null, 0, 0, ParserErrorCode.ABSTRACT_CLASS_MEMBER)
     ]);
   }
 
   void test_setValue_publicNamespace() {
     _setValue(DartEntry.PUBLIC_NAMESPACE,
         new Namespace(new HashMap<String, Element>()));
   }
 
   void test_setValue_resolutionErrors() {
     _setValueInLibrary(DartEntry.RESOLUTION_ERRORS, <AnalysisError>[
-      new AnalysisError.con1(
-          null, CompileTimeErrorCode.CONST_CONSTRUCTOR_THROWS_EXCEPTION)
+      new AnalysisError(
+          null, 0, 0, CompileTimeErrorCode.CONST_CONSTRUCTOR_THROWS_EXCEPTION)
     ]);
   }
 
   void test_setValue_resolvedUnit() {
     _setValueInLibrary(DartEntry.RESOLVED_UNIT, AstFactory.compilationUnit());
   }
 
   void test_setValue_scanErrors() {
     _setValue(DartEntry.SCAN_ERRORS, <AnalysisError>[
-      new AnalysisError.con1(
-          null, ScannerErrorCode.UNTERMINATED_MULTI_LINE_COMMENT)
+      new AnalysisError(
+          null, 0, 0, ScannerErrorCode.UNTERMINATED_MULTI_LINE_COMMENT)
     ]);
   }
 
   void test_setValue_sourceKind() {
     _setValue(DartEntry.SOURCE_KIND, SourceKind.LIBRARY);
   }
 
   void test_setValue_tokenStream() {
     _setValue(DartEntry.TOKEN_STREAM, new Token(TokenType.LT, 5));
   }
 
   void test_setValue_verificationErrors() {
     _setValueInLibrary(DartEntry.VERIFICATION_ERRORS, <AnalysisError>[
-      new AnalysisError.con1(null, StaticWarningCode.CASE_BLOCK_NOT_TERMINATED)
+      new AnalysisError(null, 0, 0, StaticWarningCode.CASE_BLOCK_NOT_TERMINATED)
     ]);
   }
 
   DartEntry _entryWithValidState([Source firstLibrary, Source secondLibrary]) {
     DartEntry entry = new DartEntry();
     entry.setValue(SourceEntry.CONTENT, null);
     entry.setValue(SourceEntry.CONTENT_ERRORS, null);
     entry.setValue(SourceEntry.LINE_INFO, null);
     entry.setValue(DartEntry.CONTAINING_LIBRARIES, null);
     entry.setValue(DartEntry.ELEMENT, null);
@@ skipping 136 matching lines @@
   void test_getLibraryElement() {
     InternalAnalysisContext context = AnalysisContextFactory.contextWithCore();
     LibraryElement element = ElementFactory.library(context, "lib");
     GenerateDartErrorsTask task =
         new GenerateDartErrorsTask(context, null, null, element);
     expect(task.libraryElement, same(element));
   }
 
   void test_getSource() {
     Source source =
-        new FileBasedSource.con1(FileUtilities2.createFile("/test.dart"));
+        new FileBasedSource(FileUtilities2.createFile("/test.dart"));
     GenerateDartErrorsTask task =
         new GenerateDartErrorsTask(null, source, null, null);
     expect(task.source, same(source));
   }
 
   void test_perform() {
     InternalAnalysisContext context = AnalysisContextFactory.contextWithCore();
     Source source =
-        new FileBasedSource.con1(FileUtilities2.createFile("/test.dart"));
+        new FileBasedSource(FileUtilities2.createFile("/test.dart"));
     ChangeSet changeSet = new ChangeSet();
     changeSet.addedSource(source);
     context.applyChanges(changeSet);
     context.setContents(source, r'''
 library lib;
 class A {
   int f = new A();
 }''');
     LibraryElement libraryElement = context.computeLibraryElement(source);
     CompilationUnit unit =
         context.getResolvedCompilationUnit(source, libraryElement);
     GenerateDartErrorsTask task =
         new GenerateDartErrorsTask(context, source, unit, libraryElement);
     task.perform(
         new GenerateDartErrorsTaskTestTV_perform(libraryElement, source));
   }
 
   void test_perform_validateDirectives() {
     InternalAnalysisContext context = AnalysisContextFactory.contextWithCore();
     Source source =
-        new FileBasedSource.con1(FileUtilities2.createFile("/test.dart"));
+        new FileBasedSource(FileUtilities2.createFile("/test.dart"));
     ChangeSet changeSet = new ChangeSet();
     changeSet.addedSource(source);
     context.applyChanges(changeSet);
     // TODO(scheglov) "import" causes second error reported
 //    context.setContents(source, EngineTestCase.createSource([
 //        "library lib;",
 //        "import 'invaliduri^.dart';",
 //        "export '\${a}lib3.dart';",
 //        "part '/does/not/exist.dart';",
 //        "class A {}"]));
@@ skipping 73 matching lines @@
     InternalAnalysisContext context = AnalysisContextFactory.contextWithCore();
     LibraryElement element = ElementFactory.library(context, "lib");
     GenerateDartHintsTask task =
         new GenerateDartHintsTask(context, null, element);
     expect(task.libraryElement, same(element));
   }
   void test_perform() {
     InternalAnalysisContext context = AnalysisContextFactory.contextWithCore();
     ChangeSet changeSet = new ChangeSet();
     Source librarySource =
-        new FileBasedSource.con1(FileUtilities2.createFile("/test.dart"));
+        new FileBasedSource(FileUtilities2.createFile("/test.dart"));
     changeSet.addedSource(librarySource);
     Source unusedSource =
-        new FileBasedSource.con1(FileUtilities2.createFile("/unused.dart"));
+        new FileBasedSource(FileUtilities2.createFile("/unused.dart"));
     changeSet.addedSource(unusedSource);
     Source partSource =
-        new FileBasedSource.con1(FileUtilities2.createFile("/part.dart"));
+        new FileBasedSource(FileUtilities2.createFile("/part.dart"));
     changeSet.addedSource(partSource);
     context.applyChanges(changeSet);
     context.setContents(librarySource, r'''
 library lib;
 import 'unused.dart';
 part 'part.dart';''');
     context.setContents(unusedSource, "library unused;");
     context.setContents(partSource, "part of lib;");
     List<TimestampedData<CompilationUnit>> units = new List<TimestampedData>(2);
     units[0] = new TimestampedData<CompilationUnit>(
@@ skipping 52 matching lines @@
   }
   void test_lintMap() {
     GenerateDartLintsTask task = new GenerateDartLintsTask(null, null, null);
     expect(task.lintMap, isNull);
   }
 
   void test_perform() {
     InternalAnalysisContext context = AnalysisContextFactory.contextWithCore();
     ChangeSet changeSet = new ChangeSet();
     Source librarySource =
-        new FileBasedSource.con1(FileUtilities2.createFile("/test.dart"));
+        new FileBasedSource(FileUtilities2.createFile("/test.dart"));
     changeSet.addedSource(librarySource);
     context.applyChanges(changeSet);
     context.setContents(librarySource, r'''
 library lib;
 ''');
     List<TimestampedData<CompilationUnit>> units = new List<TimestampedData>(1);
     units[0] = new TimestampedData<CompilationUnit>(
         context.getModificationStamp(librarySource),
         context.resolveCompilationUnit2(librarySource, librarySource));
     GenerateDartLintsTask task = new GenerateDartLintsTask(
@@ skipping 106 matching lines @@
   void test_creation() {
     HtmlEntry entry = new HtmlEntry();
     expect(entry, isNotNull);
   }
 
   void test_getAllErrors() {
     Source source = new TestSource();
     HtmlEntry entry = new HtmlEntry();
     expect(entry.allErrors, hasLength(0));
     entry.setValue(HtmlEntry.PARSE_ERRORS, <AnalysisError>[
-      new AnalysisError.con1(source, ParserErrorCode.EXPECTED_TOKEN, [";"])
+      new AnalysisError(source, 0, 0, ParserErrorCode.EXPECTED_TOKEN, [";"])
     ]);
     entry.setValue(HtmlEntry.RESOLUTION_ERRORS, <AnalysisError>[
-      new AnalysisError.con1(source, HtmlWarningCode.INVALID_URI, ["-"])
+      new AnalysisError(source, 0, 0, HtmlWarningCode.INVALID_URI, ["-"])
     ]);
     entry.setValue(HtmlEntry.HINTS,
-        <AnalysisError>[new AnalysisError.con1(source, HintCode.DEAD_CODE)]);
+        <AnalysisError>[new AnalysisError(source, 0, 0, HintCode.DEAD_CODE)]);
     expect(entry.allErrors, hasLength(3));
   }
 
   void test_invalidateAllResolutionInformation() {
     HtmlEntry entry = _entryWithValidState();
     entry.invalidateAllResolutionInformation(false);
     expect(entry.getState(HtmlEntry.ELEMENT), same(CacheState.INVALID));
     expect(entry.getState(HtmlEntry.HINTS), same(CacheState.INVALID));
     expect(entry.getState(SourceEntry.LINE_INFO), same(CacheState.VALID));
     expect(entry.getState(HtmlEntry.PARSE_ERRORS), same(CacheState.VALID));
@@ skipping 45 matching lines @@
   void test_setState_resolutionErrors() {
     state = HtmlEntry.RESOLUTION_ERRORS;
   }
 
   void test_setValue_element() {
     _setValue(HtmlEntry.ELEMENT, new HtmlElementImpl(null, "test.html"));
   }
 
   void test_setValue_hints() {
     _setValue(HtmlEntry.HINTS,
-        <AnalysisError>[new AnalysisError.con1(null, HintCode.DEAD_CODE)]);
+        <AnalysisError>[new AnalysisError(null, 0, 0, HintCode.DEAD_CODE)]);
   }
 
   void test_setValue_illegal() {
     HtmlEntry entry = new HtmlEntry();
     try {
       entry.setValue(DartEntry.ELEMENT, null);
       fail("Expected ArgumentError for DartEntry.ELEMENT");
     } on ArgumentError {}
   }
 
   void test_setValue_lineInfo() {
     _setValue(SourceEntry.LINE_INFO, new LineInfo(<int>[0]));
   }
 
   void test_setValue_parsedUnit() {
     _setValue(HtmlEntry.PARSED_UNIT, new ht.HtmlUnit(null, null, null));
   }
 
   void test_setValue_parseErrors() {
     _setValue(HtmlEntry.PARSE_ERRORS, <AnalysisError>[
-      new AnalysisError.con1(null, HtmlWarningCode.INVALID_URI, ["-"])
+      new AnalysisError(null, 0, 0, HtmlWarningCode.INVALID_URI, ["-"])
     ]);
   }
 
   void test_setValue_referencedLibraries() {
     _setValue(HtmlEntry.REFERENCED_LIBRARIES, <Source>[new TestSource()]);
   }
 
   void test_setValue_resolutionErrors() {
     _setValue(HtmlEntry.RESOLUTION_ERRORS, <AnalysisError>[
-      new AnalysisError.con1(null, HtmlWarningCode.INVALID_URI, ["-"])
+      new AnalysisError(null, 0, 0, HtmlWarningCode.INVALID_URI, ["-"])
     ]);
   }
 
   HtmlEntry _entryWithValidState() {
     HtmlEntry entry = new HtmlEntry();
     entry.setValue(HtmlEntry.ELEMENT, null);
     entry.setValue(HtmlEntry.HINTS, null);
     entry.setValue(SourceEntry.LINE_INFO, null);
     entry.setValue(HtmlEntry.PARSE_ERRORS, null);
     entry.setValue(HtmlEntry.PARSED_UNIT, null);
@@ skipping 390 matching lines @@
   CompilationUnit visitIncrementalAnalysisTask(
       IncrementalAnalysisTask incrementalAnalysisTask) => task.compilationUnit;
 }
 
 @reflectiveTest
 class LintGeneratorTest extends EngineTestCase {
   void test_generate() {
     InternalAnalysisContext context = AnalysisContextFactory.contextWithCore();
     ChangeSet changeSet = new ChangeSet();
     Source librarySource =
-        new FileBasedSource.con1(FileUtilities2.createFile("/test.dart"));
+        new FileBasedSource(FileUtilities2.createFile("/test.dart"));
     changeSet.addedSource(librarySource);
     context.applyChanges(changeSet);
     context.setContents(librarySource, r'''
 library lib;
 ''');
 
     CompilationUnit unit =
         context.resolveCompilationUnit2(librarySource, librarySource);
     List<CompilationUnit> units = <CompilationUnit>[];
     units.add(unit);
 
     RecordingErrorListener errorListener = new RecordingErrorListener();
 
     LintGeneratorTest_Linter linter = new LintGeneratorTest_Linter();
 
     LintGenerator lintGenerator =
         new LintGenerator(units, errorListener, [linter]);
     lintGenerator.generate();
 
     linter.testExpectations();
   }
 
   void test_generate_null_visitor() {
     InternalAnalysisContext context = AnalysisContextFactory.contextWithCore();
     ChangeSet changeSet = new ChangeSet();
     Source librarySource =
-        new FileBasedSource.con1(FileUtilities2.createFile("/test.dart"));
+        new FileBasedSource(FileUtilities2.createFile("/test.dart"));
     changeSet.addedSource(librarySource);
     context.applyChanges(changeSet);
     context.setContents(librarySource, r'''
 library lib;
 ''');
 
     CompilationUnit unit =
         context.resolveCompilationUnit2(librarySource, librarySource);
     List<CompilationUnit> units = <CompilationUnit>[];
     units.add(unit);
@@ skipping 2099 matching lines @@
   @override
   bool exists() => true;
 }
 
 class _UniversalCachePartitionTest_test_setMaxCacheSize
     implements CacheRetentionPolicy {
   @override
   RetentionPriority getAstPriority(Source source, SourceEntry sourceEntry) =>
       RetentionPriority.LOW;
 }