Rollback pkg/analyzer that breaks code_transformers

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 201 matching lines @@
    */
   static AngularSelectorElement _parseSelectorFromString(SimpleStringLiteral literal) {
     int offset = literal.valueOffset;
     String text = literal.stringValue;
     return parseSelector(offset, text);
   }
 
   /**
    * The listener to which errors will be reported.
    */
-  final AnalysisErrorListener _errorListener;
+  AnalysisErrorListener _errorListener;
 
   /**
    * The source containing the unit that will be analyzed.
    */
-  final Source _source;
+  Source _source;
 
   /**
    * The compilation unit with built Dart element models.
    */
-  final CompilationUnit _unit;
+  CompilationUnit _unit;
 
   /**
    * The [ClassDeclaration] that is currently being analyzed.
    */
   ClassDeclaration _classDeclaration;
 
   /**
    * The [ClassElementImpl] that is currently being analyzed.
    */
   ClassElementImpl _classElement;
 
   /**
    * The [ToolkitObjectElement]s to set for [classElement].
    */
   List<ToolkitObjectElement> _classToolkitObjects = [];
 
   /**
    * The [Annotation] that is currently being analyzed.
    */
   Annotation _annotation;
 
   /**
    * Initialize a newly created compilation unit element builder.
    *
    * @param errorListener the listener to which errors will be reported.
    * @param source the source containing the unit that will be analyzed
    * @param unit the compilation unit with built Dart element models
    */
-  AngularCompilationUnitBuilder(this._errorListener, this._source, this._unit);
+  AngularCompilationUnitBuilder(AnalysisErrorListener errorListener, Source source, CompilationUnit unit) {
+    this._errorListener = errorListener;
+    this._source = source;
+    this._unit = unit;
+  }
 
   /**
    * Builds Angular specific element models and adds them to the existing Dart elements.
    */
   void build() {
     _parseViews();
     // process classes
     for (CompilationUnitMember unitMember in _unit.declarations) {
       if (unitMember is ClassDeclaration) {
         this._classDeclaration = unitMember;
@@ skipping 1698 matching lines @@
 
 /**
  * Instances of the class `HtmlUnitBuilder` build an element model for a single HTML unit.
  */
 class HtmlUnitBuilder implements ht.XmlVisitor<Object> {
   static String _SRC = "src";
 
   /**
    * The analysis context in which the element model will be built.
    */
-  final InternalAnalysisContext _context;
+  InternalAnalysisContext _context;
 
   /**
    * The error listener to which errors will be reported.
    */
   RecordingErrorListener _errorListener;
 
   /**
    * The modification time of the source for which an element is being built.
    */
   int _modificationStamp = 0;
@@ skipping 16 matching lines @@
   /**
    * A set of the libraries that were resolved while resolving the HTML unit.
    */
   Set<Library> _resolvedLibraries = new Set<Library>();
 
   /**
    * Initialize a newly created HTML unit builder.
    *
    * @param context the analysis context in which the element model will be built
    */
-  HtmlUnitBuilder(this._context) {
+  HtmlUnitBuilder(InternalAnalysisContext context) {
+    this._context = context;
     this._errorListener = new RecordingErrorListener();
   }
 
   /**
    * Build the HTML element for the given source.
    *
    * @param source the source describing the compilation unit
    * @param modificationStamp the modification time of the source for which an element is being
    *          built
    * @param unit the AST structure representing the HTML
@@ skipping 214 matching lines @@
 
   /**
    * The class containing the AST nodes being visited, or `null` if we are not in the scope of
    * a class.
    */
   ClassElement _enclosingClass;
 
   /**
    * The error reporter by which errors will be reported.
    */
-  final ErrorReporter _errorReporter;
+  ErrorReporter _errorReporter;
 
   /**
    * Create a new instance of the [BestPracticesVerifier].
    *
    * @param errorReporter the error reporter
    */
-  BestPracticesVerifier(this._errorReporter);
+  BestPracticesVerifier(ErrorReporter errorReporter) {
+    this._errorReporter = errorReporter;
+  }
 
   @override
   Object visitArgumentList(ArgumentList node) {
     _checkForArgumentTypesNotAssignableInList(node);
     return super.visitArgumentList(node);
   }
 
   @override
   Object visitAsExpression(AsExpression node) {
     _checkForUnnecessaryCast(node);
@@ skipping 525 matching lines @@
 }
 
 /**
  * Instances of the class `Dart2JSVerifier` traverse an AST structure looking for hints for
  * code that will be compiled to JS, such as [HintCode#IS_DOUBLE].
  */
 class Dart2JSVerifier extends RecursiveAstVisitor<Object> {
   /**
    * The error reporter by which errors will be reported.
    */
-  final ErrorReporter _errorReporter;
+  ErrorReporter _errorReporter;
 
   /**
    * The name of the `double` type.
    */
   static String _DOUBLE_TYPE_NAME = "double";
 
   /**
    * Create a new instance of the [Dart2JSVerifier].
    *
    * @param errorReporter the error reporter
    */
-  Dart2JSVerifier(this._errorReporter);
+  Dart2JSVerifier(ErrorReporter errorReporter) {
+    this._errorReporter = errorReporter;
+  }
 
   @override
   Object visitIsExpression(IsExpression node) {
     _checkForIsDoubleHints(node);
     return super.visitIsExpression(node);
   }
 
   /**
    * Check for instances of `x is double`, `x is int`, `x is! double` and
    * `x is! int`.
@@ skipping 35 matching lines @@
 }
 
 /**
  * Instances of the class `DeadCodeVerifier` traverse an AST structure looking for cases of
  * [HintCode#DEAD_CODE].
  */
 class DeadCodeVerifier extends RecursiveAstVisitor<Object> {
   /**
    * The error reporter by which errors will be reported.
    */
-  final ErrorReporter _errorReporter;
+  ErrorReporter _errorReporter;
 
   /**
    * Create a new instance of the [DeadCodeVerifier].
    *
    * @param errorReporter the error reporter
    */
-  DeadCodeVerifier(this._errorReporter);
+  DeadCodeVerifier(ErrorReporter errorReporter) {
+    this._errorReporter = errorReporter;
+  }
 
   @override
   Object visitBinaryExpression(BinaryExpression node) {
     sc.Token operator = node.operator;
     bool isAmpAmp = identical(operator.type, sc.TokenType.AMPERSAND_AMPERSAND);
     bool isBarBar = identical(operator.type, sc.TokenType.BAR_BAR);
     if (isAmpAmp || isBarBar) {
       Expression lhsCondition = node.leftOperand;
       if (!_isDebugConstant(lhsCondition)) {
         ValidResult lhsResult = _getConstantBooleanValue(lhsCondition);
@@ skipping 288 matching lines @@
     // If the operator is && and the left hand side is true literal, don't consider the RHS of the
     // binary expression.
     if (identical(operatorType, sc.TokenType.AMPERSAND_AMPERSAND)) {
       if (lhsExpression is BooleanLiteral) {
         BooleanLiteral booleanLiteral = lhsExpression;
         if (booleanLiteral.value) {
           return false;
         }
       }
     }
-    Expression rhsExpression = node.rightOperand;
-    return (lhsExpression != null && lhsExpression.accept(this)) || (rhsExpression != null && rhsExpression.accept(this));
+    return lhsExpression.accept(this) || node.rightOperand.accept(this);
   }
 
   @override
   bool visitBlock(Block node) => _visitStatements(node.statements);
 
   @override
   bool visitBlockFunctionBody(BlockFunctionBody node) => node.block.accept(this);
 
   @override
   bool visitBreakStatement(BreakStatement node) {
@@ skipping 345 matching lines @@
   }
 }
 
 /**
  * Instances of the class `HintGenerator` traverse a library's worth of dart code at a time to
  * generate hints over the set of sources.
  *
  * @see HintCode
  */
 class HintGenerator {
-  final List<CompilationUnit> _compilationUnits;
+  List<CompilationUnit> _compilationUnits;
 
-  final AnalysisContext _context;
+  AnalysisContext _context;
 
-  final AnalysisErrorListener _errorListener;
+  AnalysisErrorListener _errorListener;
 
   ImportsVerifier _importsVerifier;
 
   bool _enableDart2JSHints = false;
 
   /**
    * The inheritance manager used to find overridden methods.
    */
   InheritanceManager _manager;
 
-  HintGenerator(this._compilationUnits, this._context, this._errorListener) {
-    LibraryElement library = _compilationUnits[0].element.library;
+  HintGenerator(List<CompilationUnit> compilationUnits, AnalysisContext context, AnalysisErrorListener errorListener) {
+    this._compilationUnits = compilationUnits;
+    this._context = context;
+    this._errorListener = errorListener;
+    LibraryElement library = compilationUnits[0].element.library;
     _importsVerifier = new ImportsVerifier(library);
-    _enableDart2JSHints = _context.analysisOptions.dart2jsHint;
-    _manager = new InheritanceManager(_compilationUnits[0].element.library);
+    _enableDart2JSHints = context.analysisOptions.dart2jsHint;
+    _manager = new InheritanceManager(compilationUnits[0].element.library);
   }
 
   void generateForLibrary() {
     TimeCounter_TimeCounterHandle timeCounter = PerformanceStatistics.hints.start();
     try {
       for (int i = 0; i < _compilationUnits.length; i++) {
         CompilationUnitElement element = _compilationUnits[i].element;
         if (element != null) {
           if (i == 0) {
             _importsVerifier.inDefiningCompilationUnit = true;
@@ skipping 374 matching lines @@
 }
 
 /**
  * Instances of the class `OverrideVerifier` visit all of the declarations in a compilation
  * unit to verify that if they have an override annotation it is being used correctly.
  */
 class OverrideVerifier extends RecursiveAstVisitor<Object> {
   /**
    * The inheritance manager used to find overridden methods.
    */
-  final InheritanceManager _manager;
+  InheritanceManager _manager;
 
   /**
    * The error reporter used to report errors.
    */
-  final ErrorReporter _errorReporter;
+  ErrorReporter _errorReporter;
 
   /**
    * Initialize a newly created verifier to look for inappropriate uses of the override annotation.
    *
    * @param manager the inheritance manager used to find overridden methods
    * @param errorReporter the error reporter used to report errors
    */
-  OverrideVerifier(this._manager, this._errorReporter);
+  OverrideVerifier(InheritanceManager manager, ErrorReporter errorReporter) {
+    this._manager = manager;
+    this._errorReporter = errorReporter;
+  }
 
   @override
   Object visitMethodDeclaration(MethodDeclaration node) {
     ExecutableElement element = node.element;
     if (_isOverride(element)) {
       if (_getOverriddenMember(element) == null) {
         if (element is MethodElement) {
           _errorReporter.reportErrorForNode(HintCode.OVERRIDE_ON_NON_OVERRIDING_METHOD, node.name, []);
         } else if (element is PropertyAccessorElement) {
           if (element.isGetter) {
@@ skipping 37 matching lines @@
 /**
  * Instances of the class `PubVerifier` traverse an AST structure looking for deviations from
  * pub best practices.
  */
 class PubVerifier extends RecursiveAstVisitor<Object> {
   static String _PUBSPEC_YAML = "pubspec.yaml";
 
   /**
    * The analysis context containing the sources to be analyzed
    */
-  final AnalysisContext _context;
+  AnalysisContext _context;
 
   /**
    * The error reporter by which errors will be reported.
    */
-  final ErrorReporter _errorReporter;
+  ErrorReporter _errorReporter;
 
-  PubVerifier(this._context, this._errorReporter);
+  PubVerifier(AnalysisContext context, ErrorReporter errorReporter) {
+    this._context = context;
+    this._errorReporter = errorReporter;
+  }
 
   @override
   Object visitImportDirective(ImportDirective directive) {
     return null;
   }
 
   /**
    * This verifies that the passed file import directive is not contained in a source inside a
    * package "lib" directory hierarchy referencing a source outside that package "lib" directory
    * hierarchy.
@@ skipping 128 matching lines @@
   }
 }
 
 /**
  * Instances of the class `ToDoFinder` find to-do comments in Dart code.
  */
 class ToDoFinder {
   /**
    * The error reporter by which to-do comments will be reported.
    */
-  final ErrorReporter _errorReporter;
+  ErrorReporter _errorReporter;
 
   /**
    * Initialize a newly created to-do finder to report to-do comments to the given reporter.
    *
    * @param errorReporter the error reporter by which to-do comments will be reported
    */
-  ToDoFinder(this._errorReporter);
+  ToDoFinder(ErrorReporter errorReporter) {
+    this._errorReporter = errorReporter;
+  }
 
   /**
    * Search the comments in the given compilation unit for to-do comments and report an error for
    * each.
    *
    * @param unit the compilation unit containing the to-do comments
    */
   void findIn(CompilationUnit unit) {
     _gatherTodoComments(unit.beginToken);
   }
@@ skipping 1322 matching lines @@
         MethodDeclaration method = n as MethodDeclaration;
         return !method.isStatic;
       }
     }
     return false;
   }
 
   /**
    * The resolver driving this participant.
    */
-  final ResolverVisitor _resolver;
+  ResolverVisitor _resolver;
 
   /**
    * The element for the library containing the compilation unit being visited.
    */
   LibraryElement _definingLibrary;
 
   /**
    * A flag indicating whether we should generate hints.
    */
   bool _enableHints = false;
@@ skipping 28 matching lines @@
    * The name of the method that will be invoked if an attempt is made to invoke an undefined method
    * on an object.
    */
   static String NO_SUCH_METHOD_METHOD_NAME = "noSuchMethod";
 
   /**
    * Initialize a newly created visitor to resolve the nodes in a compilation unit.
    *
    * @param resolver the resolver driving this participant
    */
-  ElementResolver(this._resolver) {
-    this._definingLibrary = _resolver.definingLibrary;
+  ElementResolver(ResolverVisitor resolver) {
+    this._resolver = resolver;
+    this._definingLibrary = resolver.definingLibrary;
     AnalysisOptions options = _definingLibrary.context.analysisOptions;
     _enableHints = options.hint;
-    _dynamicType = _resolver.typeProvider.dynamicType;
-    _typeType = _resolver.typeProvider.typeType;
+    _dynamicType = resolver.typeProvider.dynamicType;
+    _typeType = resolver.typeProvider.typeType;
     _subtypeManager = new SubtypeManager();
-    _promoteManager = _resolver.promoteManager;
+    _promoteManager = resolver.promoteManager;
   }
 
   @override
   Object visitAssignmentExpression(AssignmentExpression node) {
     sc.Token operator = node.operator;
     sc.TokenType operatorType = operator.type;
     if (operatorType != sc.TokenType.EQ) {
       operatorType = _operatorFromCompoundAssignment(operatorType);
       Expression leftHandSide = node.leftHandSide;
       if (leftHandSide != null) {
@@ skipping 2130 matching lines @@
 /**
  * Instances of the class `SyntheticIdentifier` implement an identifier that can be used to
  * look up names in the lexical scope when there is no identifier in the AST structure. There is
  * no identifier in the AST when the parser could not distinguish between a method invocation and
  * an invocation of a top-level function imported with a prefix.
  */
 class ElementResolver_SyntheticIdentifier extends Identifier {
   /**
    * The name of the synthetic identifier.
    */
-  final String name;
+  String name;
 
   /**
    * Initialize a newly created synthetic identifier to have the given name.
    *
    * @param name the name of the synthetic identifier
    */
-  ElementResolver_SyntheticIdentifier(this.name);
+  ElementResolver_SyntheticIdentifier(String name) {
+    this.name = name;
+  }
 
   @override
   accept(AstVisitor visitor) => null;
 
   @override
   sc.Token get beginToken => null;
 
   @override
   Element get bestElement => null;
 
@@ skipping 15 matching lines @@
 }
 
 /**
  * Instances of the class `IncrementalResolver` resolve the smallest portion of an AST
  * structure that we currently know how to resolve.
  */
 class IncrementalResolver {
   /**
    * The element for the library containing the compilation unit being visited.
    */
-  final LibraryElement _definingLibrary;
+  LibraryElement _definingLibrary;
 
   /**
    * The source representing the compilation unit being visited.
    */
-  final Source _source;
+  Source _source;
 
   /**
    * The object used to access the types from the core library.
    */
-  final TypeProvider _typeProvider;
+  TypeProvider _typeProvider;
 
   /**
    * The error listener that will be informed of any errors that are found during resolution.
    */
-  final AnalysisErrorListener _errorListener;
+  AnalysisErrorListener _errorListener;
 
   /**
    * Initialize a newly created incremental resolver to resolve a node in the given source in the
    * given library, reporting errors to the given error listener.
    *
    * @param definingLibrary the element for the library containing the compilation unit being
    *          visited
    * @param source the source representing the compilation unit being visited
    * @param typeProvider the object used to access the types from the core library
    * @param errorListener the error listener that will be informed of any errors that are found
    *          during resolution
    */
-  IncrementalResolver(this._definingLibrary, this._source, this._typeProvider, this._errorListener);
+  IncrementalResolver(LibraryElement definingLibrary, Source source, TypeProvider typeProvider, AnalysisErrorListener errorListener) {
+    this._definingLibrary = definingLibrary;
+    this._source = source;
+    this._typeProvider = typeProvider;
+    this._errorListener = errorListener;
+  }
 
   /**
    * Resolve the given node, reporting any errors or warnings to the given listener.
    *
    * @param node the root of the AST structure to be resolved
    * @throws AnalysisException if the node could not be resolved
    */
   void resolve(AstNode node) {
     AstNode rootNode = _findResolutionRoot(node);
     Scope scope = ScopeBuilder.scopeFor(rootNode, _errorListener);
@@ skipping 948 matching lines @@
 
 /**
  * Instances of the class `Library` represent the data about a single library during the
  * resolution of some (possibly different) library. They are not intended to be used except during
  * the resolution process.
  */
 class Library {
   /**
    * The analysis context in which this library is being analyzed.
    */
-  final InternalAnalysisContext _analysisContext;
+  InternalAnalysisContext _analysisContext;
 
   /**
    * The inheritance manager which is used for this member lookups in this library.
    */
   InheritanceManager _inheritanceManager;
 
   /**
    * The listener to which analysis errors will be reported.
    */
-  final AnalysisErrorListener _errorListener;
+  AnalysisErrorListener _errorListener;
 
   /**
    * The source specifying the defining compilation unit of this library.
    */
-  final Source librarySource;
+  Source librarySource;
 
   /**
    * The library element representing this library.
    */
   LibraryElementImpl _libraryElement;
 
   /**
    * A list containing all of the libraries that are imported into this library.
    */
   List<Library> _importedLibraries = _EMPTY_ARRAY;
@@ skipping 34 matching lines @@
    */
   static String _DART_EXT_SCHEME = "dart-ext:";
 
   /**
    * Initialize a newly created data holder that can maintain the data associated with a library.
    *
    * @param analysisContext the analysis context in which this library is being analyzed
    * @param errorListener the listener to which analysis errors will be reported
    * @param librarySource the source specifying the defining compilation unit of this library
    */
-  Library(this._analysisContext, this._errorListener, this.librarySource) {
-    this._libraryElement = _analysisContext.getLibraryElement(librarySource) as LibraryElementImpl;
+  Library(InternalAnalysisContext analysisContext, AnalysisErrorListener errorListener, Source librarySource) {
+    this._analysisContext = analysisContext;
+    this._errorListener = errorListener;
+    this.librarySource = librarySource;
+    this._libraryElement = analysisContext.getLibraryElement(librarySource) as LibraryElementImpl;
   }
 
   /**
    * Return the AST structure associated with the given source.
    *
    * @param source the source representing the compilation unit whose AST is to be returned
    * @return the AST structure associated with the given source
    * @throws AnalysisException if an AST structure could not be created for the compilation unit
    */
   CompilationUnit getAST(Source source) {
@@ skipping 212 matching lines @@
   String toString() => librarySource.shortName;
 }
 
 /**
  * Instances of the class `LibraryElementBuilder` build an element model for a single library.
  */
 class LibraryElementBuilder {
   /**
    * The analysis context in which the element model will be built.
    */
-  final InternalAnalysisContext _analysisContext;
+  InternalAnalysisContext _analysisContext;
 
   /**
    * The listener to which errors will be reported.
    */
-  final AnalysisErrorListener _errorListener;
+  AnalysisErrorListener _errorListener;
 
   /**
    * The name of the function used as an entry point.
    */
   static String ENTRY_POINT_NAME = "main";
 
   /**
    * Initialize a newly created library element builder.
    *
    * @param analysisContext the analysis context in which the element model will be built
    * @param errorListener the listener to which errors will be reported
    */
-  LibraryElementBuilder(this._analysisContext, this._errorListener);
+  LibraryElementBuilder(InternalAnalysisContext analysisContext, AnalysisErrorListener errorListener) {
+    this._analysisContext = analysisContext;
+    this._errorListener = errorListener;
+  }
 
   /**
    * Build the library element for the given library.
    *
    * @param library the library for which an element model is to be built
    * @return the library element that was built
    * @throws AnalysisException if the analysis could not be performed
    */
   LibraryElementImpl buildLibrary(Library library) {
     CompilationUnitBuilder builder = new CompilationUnitBuilder();
@@ skipping 14 matching lines @@
       // the possibility of circular references).
       //
       if (directive is LibraryDirective) {
         if (libraryNameNode == null) {
           libraryNameNode = directive.name;
           directivesToResolve.add(directive);
         }
       } else if (directive is PartDirective) {
         PartDirective partDirective = directive;
         StringLiteral partUri = partDirective.uri;
-        Source partSource = partDirective.source;
+        Source partSource = library.getSource(partDirective);
         if (_analysisContext.exists(partSource)) {
           hasPartDirective = true;
           CompilationUnit partUnit = library.getAST(partSource);
           CompilationUnitElementImpl part = builder.buildCompilationUnit(partSource, partUnit);
           part.uriOffset = partUri.offset;
           part.uriEnd = partUri.end;
           part.uri = library.getUri(partDirective);
           //
           // Validate that the part contains a part-of directive with the same name as the library.
           //
@@ skipping 204 matching lines @@
 }
 
 /**
  * Instances of the class `LibraryResolver` are used to resolve one or more mutually dependent
  * libraries within a single context.
  */
 class LibraryResolver {
   /**
    * The analysis context in which the libraries are being analyzed.
    */
-  final InternalAnalysisContext analysisContext;
+  InternalAnalysisContext analysisContext;
 
   /**
    * The listener to which analysis errors will be reported, this error listener is either
    * references [recordingErrorListener], or it unions the passed
    * [AnalysisErrorListener] with the [recordingErrorListener].
    */
   RecordingErrorListener _errorListener;
 
   /**
    * A source object representing the core library (dart:core).
@@ skipping 18 matching lines @@
   /**
    * A collection containing the libraries that are being resolved together.
    */
   Set<Library> _librariesInCycles;
 
   /**
    * Initialize a newly created library resolver to resolve libraries within the given context.
    *
    * @param analysisContext the analysis context in which the library is being analyzed
    */
-  LibraryResolver(this.analysisContext) {
+  LibraryResolver(InternalAnalysisContext analysisContext) {
+    this.analysisContext = analysisContext;
     this._errorListener = new RecordingErrorListener();
     _coreLibrarySource = analysisContext.sourceFactory.forUri(DartSdk.DART_CORE);
   }
 
   /**
    * Return the listener to which analysis errors will be reported.
    *
    * @return the listener to which analysis errors will be reported
    */
   RecordingErrorListener get errorListener => _errorListener;
@@ skipping 278 matching lines @@
    *           be accessed
    */
   void _buildDirectiveModels() {
     for (Library library in _librariesInCycles) {
       Map<String, PrefixElementImpl> nameToPrefixMap = new Map<String, PrefixElementImpl>();
       List<ImportElement> imports = new List<ImportElement>();
       List<ExportElement> exports = new List<ExportElement>();
       for (Directive directive in library.definingCompilationUnit.directives) {
         if (directive is ImportDirective) {
           ImportDirective importDirective = directive;
-          String uriContent = importDirective.uriContent;
-          if (DartUriResolver.isDartExtUri(uriContent)) {
-            library.libraryElement.hasExtUri = true;
-          }
-          Source importedSource = importDirective.source;
+          Source importedSource = library.getSource(importDirective);
           if (importedSource != null) {
             // The imported source will be null if the URI in the import directive was invalid.
             Library importedLibrary = _libraryMap[importedSource];
             if (importedLibrary != null) {
               ImportElementImpl importElement = new ImportElementImpl(directive.offset);
               StringLiteral uriLiteral = importDirective.uri;
               importElement.uriOffset = uriLiteral.offset;
               importElement.uriEnd = uriLiteral.end;
-              importElement.uri = uriContent;
+              importElement.uri = library.getUri(importDirective);
               importElement.combinators = _buildCombinators(importDirective);
               LibraryElement importedLibraryElement = importedLibrary.libraryElement;
               if (importedLibraryElement != null) {
                 importElement.importedLibrary = importedLibraryElement;
               }
               SimpleIdentifier prefixNode = directive.prefix;
               if (prefixNode != null) {
                 importElement.prefixOffset = prefixNode.offset;
                 String prefixName = prefixNode.name;
                 PrefixElementImpl prefix = nameToPrefixMap[prefixName];
                 if (prefix == null) {
                   prefix = new PrefixElementImpl(prefixNode);
                   nameToPrefixMap[prefixName] = prefix;
                 }
                 importElement.prefix = prefix;
                 prefixNode.staticElement = prefix;
               }
               directive.element = importElement;
               imports.add(importElement);
               if (analysisContext.computeKindOf(importedSource) != SourceKind.LIBRARY) {
                 _errorListener.onError(new AnalysisError.con2(library.librarySource, uriLiteral.offset, uriLiteral.length, CompileTimeErrorCode.IMPORT_OF_NON_LIBRARY, [uriLiteral.toSource()]));
               }
             }
           }
         } else if (directive is ExportDirective) {
           ExportDirective exportDirective = directive;
-          Source exportedSource = exportDirective.source;
+          Source exportedSource = library.getSource(exportDirective);
           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();
               StringLiteral uriLiteral = exportDirective.uri;
               exportElement.uriOffset = uriLiteral.offset;
               exportElement.uriEnd = uriLiteral.end;
-              exportElement.uri = exportDirective.uriContent;
+              exportElement.uri = library.getUri(exportDirective);
               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, CompileTimeErrorCode.EXPORT_OF_NON_LIBRARY, [uriLiteral.toSource()]));
               }
@@ skipping 325 matching lines @@
 }
 
 /**
  * Instances of the class `LibraryResolver` are used to resolve one or more mutually dependent
  * libraries within a single context.
  */
 class LibraryResolver2 {
   /**
    * The analysis context in which the libraries are being analyzed.
    */
-  final InternalAnalysisContext analysisContext;
+  InternalAnalysisContext analysisContext;
 
   /**
    * The listener to which analysis errors will be reported, this error listener is either
    * references [recordingErrorListener], or it unions the passed
    * [AnalysisErrorListener] with the [recordingErrorListener].
    */
   RecordingErrorListener _errorListener;
 
   /**
    * A source object representing the core library (dart:core).
@@ skipping 18 matching lines @@
   /**
    * A collection containing the libraries that are being resolved together.
    */
   List<ResolvableLibrary> _librariesInCycle;
 
   /**
    * Initialize a newly created library resolver to resolve libraries within the given context.
    *
    * @param analysisContext the analysis context in which the library is being analyzed
    */
-  LibraryResolver2(this.analysisContext) {
+  LibraryResolver2(InternalAnalysisContext analysisContext) {
+    this.analysisContext = analysisContext;
     this._errorListener = new RecordingErrorListener();
     _coreLibrarySource = analysisContext.sourceFactory.forUri(DartSdk.DART_CORE);
   }
 
   /**
    * Return the listener to which analysis errors will be reported.
    *
    * @return the listener to which analysis errors will be reported
    */
   RecordingErrorListener get errorListener => _errorListener;
@@ skipping 114 matching lines @@
    *           be accessed
    */
   void _buildDirectiveModels() {
     for (ResolvableLibrary library in _librariesInCycle) {
       Map<String, PrefixElementImpl> nameToPrefixMap = new Map<String, PrefixElementImpl>();
       List<ImportElement> imports = new List<ImportElement>();
       List<ExportElement> exports = new List<ExportElement>();
       for (Directive directive in library.definingCompilationUnit.directives) {
         if (directive is ImportDirective) {
           ImportDirective importDirective = directive;
-          String uriContent = importDirective.uriContent;
-          if (DartUriResolver.isDartExtUri(uriContent)) {
-            library.libraryElement.hasExtUri = true;
-          }
           Source importedSource = importDirective.source;
           if (importedSource != null && analysisContext.exists(importedSource)) {
             // The imported source will be null if the URI in the import directive was invalid.
             ResolvableLibrary importedLibrary = _libraryMap[importedSource];
             if (importedLibrary != null) {
               ImportElementImpl importElement = new ImportElementImpl(directive.offset);
               StringLiteral uriLiteral = importDirective.uri;
               if (uriLiteral != null) {
                 importElement.uriOffset = uriLiteral.offset;
                 importElement.uriEnd = uriLiteral.end;
               }
-              importElement.uri = uriContent;
+              importElement.uri = importDirective.uriContent;
               importElement.combinators = _buildCombinators(importDirective);
               LibraryElement importedLibraryElement = importedLibrary.libraryElement;
               if (importedLibraryElement != null) {
                 importElement.importedLibrary = importedLibraryElement;
               }
               SimpleIdentifier prefixNode = directive.prefix;
               if (prefixNode != null) {
                 importElement.prefixOffset = prefixNode.offset;
                 String prefixName = prefixNode.name;
                 PrefixElementImpl prefix = nameToPrefixMap[prefixName];
@@ skipping 369 matching lines @@
  *
  * If we have other conditional error codes in the future, we should have this class implement some
  * ConditionalErrorCode so that after resolution, a list of ConditionalErrorCode can be visited
  * instead of multiple lists of *ConditionalErrorCodes.
  */
 class ProxyConditionalAnalysisError {
   /**
    * The enclosing [ClassElement], this is what will determine if the error code should, or
    * should not, be generated on the source.
    */
-  final Element _enclosingElement;
+  Element _enclosingElement;
 
   /**
    * The conditional analysis error.
    */
-  final AnalysisError analysisError;
+  AnalysisError analysisError;
 
   /**
    * Instantiate a new [ProxyConditionalAnalysisError] with some enclosing element and the
    * conditional analysis error.
    *
    * @param enclosingElement the enclosing element
    * @param analysisError the conditional analysis error
    */
-  ProxyConditionalAnalysisError(this._enclosingElement, this.analysisError);
+  ProxyConditionalAnalysisError(Element enclosingElement, AnalysisError analysisError) {
+    this._enclosingElement = enclosingElement;
+    this.analysisError = analysisError;
+  }
 
   /**
    * Return `true` iff the enclosing class has the proxy annotation.
    *
    * @return `true` iff the enclosing class has the proxy annotation
    */
   bool shouldIncludeErrorCode() {
     if (_enclosingElement is ClassElement) {
       return !(_enclosingElement as ClassElement).isOrInheritsProxy;
     }
     return true;
   }
 }
 
 /**
  * Instances of the class `Library` represent the data about a single library during the
  * resolution of some (possibly different) library. They are not intended to be used except during
  * the resolution process.
  */
 class ResolvableLibrary {
   /**
    * The source specifying the defining compilation unit of this library.
    */
-  final Source librarySource;
+  Source librarySource;
 
   /**
    * A list containing all of the libraries that are imported into this library.
    */
   List<ResolvableLibrary> _importedLibraries = _EMPTY_ARRAY;
 
   /**
    * A flag indicating whether this library explicitly imports core.
    */
   bool explicitlyImportsCore = false;
@@ skipping 33 matching lines @@
    * The library scope used when resolving elements within this library's compilation units.
    */
   LibraryScope _libraryScope;
 
   /**
    * Initialize a newly created data holder that can maintain the data associated with a library.
    *
    * @param librarySource the source specifying the defining compilation unit of this library
    * @param errorListener the listener to which analysis errors will be reported
    */
-  ResolvableLibrary(this.librarySource);
+  ResolvableLibrary(Source librarySource) {
+    this.librarySource = librarySource;
+  }
 
   /**
    * Return the AST structure associated with the given source, or `null` if the source does
    * not represent a compilation unit that is included in this library.
    *
    * @param source the source representing the compilation unit whose AST is to be returned
    * @return the AST structure associated with the given source
    * @throws AnalysisException if an AST structure could not be created for the compilation unit
    */
   CompilationUnit getAST(Source source) {
@@ skipping 1517 matching lines @@
  */
 abstract class ScopedVisitor extends UnifyingAstVisitor<Object> {
   /**
    * The element for the library containing the compilation unit being visited.
    */
   LibraryElement _definingLibrary;
 
   /**
    * The source representing the compilation unit being visited.
    */
-  final Source source;
+  Source source;
 
   /**
    * The error listener that will be informed of any errors that are found during resolution.
    */
   AnalysisErrorListener _errorListener;
 
   /**
    * The scope used to resolve identifiers.
    */
   Scope _nameScope;
 
   /**
    * The object used to access the types from the core library.
    */
-  final TypeProvider typeProvider;
+  TypeProvider typeProvider;
 
   /**
    * The scope used to resolve labels for `break` and `continue` statements, or
    * `null` if no labels have been defined in the current context.
    */
   LabelScope _labelScope;
 
   /**
    * Initialize a newly created visitor to resolve the nodes in a compilation unit.
    *
    * @param library the library containing the compilation unit being resolved
    * @param source the source representing the compilation unit being visited
    * @param typeProvider the object used to access the types from the core library
    */
-  ScopedVisitor.con1(Library library, this.source, this.typeProvider) {
+  ScopedVisitor.con1(Library library, Source source, TypeProvider typeProvider) {
     this._definingLibrary = library.libraryElement;
+    this.source = source;
     LibraryScope libraryScope = library.libraryScope;
     this._errorListener = libraryScope.errorListener;
     this._nameScope = libraryScope;
+    this.typeProvider = typeProvider;
   }
 
   /**
    * Initialize a newly created visitor to resolve the nodes in a compilation unit.
    *
    * @param definingLibrary the element for the library containing the compilation unit being
    *          visited
    * @param source the source representing the compilation unit being visited
    * @param typeProvider the object used to access the types from the core library
    * @param errorListener the error listener that will be informed of any errors that are found
    *          during resolution
    */
-  ScopedVisitor.con2(LibraryElement definingLibrary, this.source, this.typeProvider, AnalysisErrorListener errorListener) {
+  ScopedVisitor.con2(LibraryElement definingLibrary, Source source, TypeProvider typeProvider, AnalysisErrorListener errorListener) {
     this._definingLibrary = definingLibrary;
+    this.source = source;
     this._errorListener = errorListener;
     this._nameScope = new LibraryScope(definingLibrary, errorListener);
+    this.typeProvider = typeProvider;
   }
 
   /**
    * Initialize a newly created visitor to resolve the nodes in a compilation unit.
    *
    * @param definingLibrary the element for the library containing the compilation unit being
    *          visited
    * @param source the source representing the compilation unit being visited
    * @param typeProvider the object used to access the types from the core library
    * @param nameScope the scope used to resolve identifiers in the node that will first be visited
    * @param errorListener the error listener that will be informed of any errors that are found
    *          during resolution
    */
-  ScopedVisitor.con3(LibraryElement definingLibrary, this.source, this.typeProvider, Scope nameScope, AnalysisErrorListener errorListener) {
+  ScopedVisitor.con3(LibraryElement definingLibrary, Source source, TypeProvider typeProvider, Scope nameScope, AnalysisErrorListener errorListener) {
     this._definingLibrary = definingLibrary;
+    this.source = source;
     this._errorListener = errorListener;
     this._nameScope = nameScope;
+    this.typeProvider = typeProvider;
   }
 
   /**
    * Initialize a newly created visitor to resolve the nodes in a compilation unit.
    *
    * @param library the library containing the compilation unit being resolved
    * @param source the source representing the compilation unit being visited
    * @param typeProvider the object used to access the types from the core library
    */
-  ScopedVisitor.con4(ResolvableLibrary library, this.source, this.typeProvider) {
+  ScopedVisitor.con4(ResolvableLibrary library, Source source, TypeProvider typeProvider) {
     this._definingLibrary = library.libraryElement;
+    this.source = source;
     LibraryScope libraryScope = library.libraryScope;
     this._errorListener = libraryScope.errorListener;
     this._nameScope = libraryScope;
+    this.typeProvider = typeProvider;
   }
 
   /**
    * Return the library element for the library containing the compilation unit being resolved.
    *
    * @return the library element for the library containing the compilation unit being resolved
    */
   LibraryElement get definingLibrary => _definingLibrary;
 
   /**
@@ skipping 588 matching lines @@
     map["title"] = "TitleElement";
     map["track"] = "TrackElement";
     map["ul"] = "UListElement";
     map["video"] = "VideoElement";
     return map;
   }
 
   /**
    * The resolver driving the resolution and type analysis.
    */
-  final ResolverVisitor _resolver;
+  ResolverVisitor _resolver;
 
   /**
    * The object providing access to the types defined by the language.
    */
   TypeProvider _typeProvider;
 
   /**
    * The type representing the type 'dynamic'.
    */
   DartType _dynamicType;
@@ skipping 23 matching lines @@
    * A table mapping HTML tag names to the names of the classes (in 'dart:html') that implement
    * those tags.
    */
   static Map<String, String> _HTML_ELEMENT_TO_CLASS_MAP = _createHtmlTagToClassMap();
 
   /**
    * Initialize a newly created type analyzer.
    *
    * @param resolver the resolver driving this participant
    */
-  StaticTypeAnalyzer(this._resolver) {
-    _typeProvider = _resolver.typeProvider;
+  StaticTypeAnalyzer(ResolverVisitor resolver) {
+    this._resolver = resolver;
+    _typeProvider = resolver.typeProvider;
     _dynamicType = _typeProvider.dynamicType;
-    _overrideManager = _resolver.overrideManager;
-    _promoteManager = _resolver.promoteManager;
+    _overrideManager = resolver.overrideManager;
+    _promoteManager = resolver.promoteManager;
   }
 
   /**
    * Set the type of the class being analyzed to the given type.
    *
    * @param thisType the type representing the class containing the nodes being analyzed
    */
   void set thisType(InterfaceType thisType) {
     this._thisType = thisType;
   }
@@ skipping 1808 matching lines @@
 }
 
 /**
  * Instances of the class `TypeOverrideScope` represent a scope in which the types of
  * elements can be overridden.
  */
 class TypeOverrideManager_TypeOverrideScope {
   /**
    * The outer scope in which types might be overridden.
    */
-  final TypeOverrideManager_TypeOverrideScope _outerScope;
+  TypeOverrideManager_TypeOverrideScope _outerScope;
 
   /**
    * A table mapping elements to the overridden type of that element.
    */
   Map<Element, DartType> _overridenTypes = new Map<Element, DartType>();
 
   /**
    * Initialize a newly created scope to be an empty child of the given scope.
    *
    * @param outerScope the outer scope in which types might be overridden
    */
-  TypeOverrideManager_TypeOverrideScope(this._outerScope);
+  TypeOverrideManager_TypeOverrideScope(TypeOverrideManager_TypeOverrideScope outerScope) {
+    this._outerScope = outerScope;
+  }
 
   /**
    * Apply a set of overrides that were previously captured.
    *
    * @param overrides the overrides to be applied
    */
   void applyOverrides(Map<Element, DartType> overrides) {
     for (MapEntry<Element, DartType> entry in getMapEntrySet(overrides)) {
       _overridenTypes[entry.getKey()] = entry.getValue();
     }
@@ skipping 135 matching lines @@
 }
 
 /**
  * Instances of the class `TypePromoteScope` represent a scope in which the types of
  * elements can be promoted.
  */
 class TypePromotionManager_TypePromoteScope {
   /**
    * The outer scope in which types might be promoter.
    */
-  final TypePromotionManager_TypePromoteScope _outerScope;
+  TypePromotionManager_TypePromoteScope _outerScope;
 
   /**
    * A table mapping elements to the promoted type of that element.
    */
   Map<Element, DartType> _promotedTypes = new Map<Element, DartType>();
 
   /**
    * Initialize a newly created scope to be an empty child of the given scope.
    *
    * @param outerScope the outer scope in which types might be promoted
    */
-  TypePromotionManager_TypePromoteScope(this._outerScope);
+  TypePromotionManager_TypePromoteScope(TypePromotionManager_TypePromoteScope outerScope) {
+    this._outerScope = outerScope;
+  }
 
   /**
    * Returns the elements with promoted types.
    */
   Iterable<Element> get promotedElements => _promotedTypes.keys.toSet();
 
   /**
    * Return the promoted type of the given element, or `null` if the type of the element has
    * not been promoted.
    *
@@ skipping 506 matching lines @@
       }
     }
     _resolve(classElement, node.withClause, node.implementsClause);
     return null;
   }
 
   @override
   Object visitConstructorDeclaration(ConstructorDeclaration node) {
     super.visitConstructorDeclaration(node);
     ExecutableElementImpl element = node.element as ExecutableElementImpl;
-    if (element != null) {
-      // TODO(brianwilkerson) Figure out how the element could ever be null.
-      ClassElement definingClass = element.enclosingElement as ClassElement;
-      element.returnType = definingClass.type;
-      FunctionTypeImpl type = new FunctionTypeImpl.con1(element);
-      type.typeArguments = definingClass.type.typeArguments;
-      element.type = type;
-    }
+    ClassElement definingClass = element.enclosingElement as ClassElement;
+    element.returnType = definingClass.type;
+    FunctionTypeImpl type = new FunctionTypeImpl.con1(element);
+    type.typeArguments = definingClass.type.typeArguments;
+    element.type = type;
     return null;
   }
 
   @override
   Object visitDeclaredIdentifier(DeclaredIdentifier node) {
     super.visitDeclaredIdentifier(node);
     DartType declaredType;
     TypeName typeName = node.type;
     if (typeName == null) {
       declaredType = _dynamicType;
@@ skipping 862 matching lines @@
       }
     }
     element.type = type;
   }
 }
 
 /**
  * Kind of the redirecting constructor.
  */
 class RedirectingConstructorKind extends Enum<RedirectingConstructorKind> {
-  static const RedirectingConstructorKind CONST = const RedirectingConstructorKind('CONST', 0);
+  static final RedirectingConstructorKind CONST = new RedirectingConstructorKind('CONST', 0);
 
-  static const RedirectingConstructorKind NORMAL = const RedirectingConstructorKind('NORMAL', 1);
+  static final RedirectingConstructorKind NORMAL = new RedirectingConstructorKind('NORMAL', 1);
 
-  static const List<RedirectingConstructorKind> values = const [CONST, NORMAL];
+  static final List<RedirectingConstructorKind> values = [CONST, NORMAL];
 
-  const RedirectingConstructorKind(String name, int ordinal) : super(name, ordinal);
+  RedirectingConstructorKind(String name, int ordinal) : super(name, ordinal);
 }
 
 class UnifyingAstVisitor_TypeResolverVisitor_visitClassDeclarationInScope extends UnifyingAstVisitor<Object> {
   final TypeResolverVisitor TypeResolverVisitor_this;
 
   List<ClassMember> nonFields;
 
   UnifyingAstVisitor_TypeResolverVisitor_visitClassDeclarationInScope(this.TypeResolverVisitor_this, this.nonFields) : super();
 
   @override
@@ skipping 191 matching lines @@
 }
 
 /**
  * Instances of the class `EnclosedScope` implement a scope that is lexically enclosed in
  * another scope.
  */
 class EnclosedScope extends Scope {
   /**
    * The scope in which this scope is lexically enclosed.
    */
-  final Scope enclosingScope;
+  Scope enclosingScope;
 
   /**
    * A table mapping names that will be defined in this scope, but right now are not initialized.
    * According to the scoping rules these names are hidden, even if they were defined in an outer
    * scope.
    */
   Map<String, Element> _hiddenElements = new Map<String, Element>();
 
   /**
    * A flag indicating whether there are any names defined in this scope.
    */
   bool _hasHiddenName = false;
 
   /**
    * Initialize a newly created scope enclosed within another scope.
    *
    * @param enclosingScope the scope in which this scope is lexically enclosed
    */
-  EnclosedScope(this.enclosingScope);
+  EnclosedScope(Scope enclosingScope) {
+    this.enclosingScope = enclosingScope;
+  }
 
   @override
   AnalysisErrorListener get errorListener => enclosingScope.errorListener;
 
   /**
    * Record that given element is declared in this scope, but hasn't been initialized yet, so it is
    * error to use. If there is already an element with the given name defined in an outer scope,
    * then it will become unavailable.
    *
    * @param element the element declared, but not initialized in this scope
@@ skipping 24 matching lines @@
     }
     // Check enclosing scope.
     return enclosingScope.internalLookup(identifier, name, referencingLibrary);
   }
 }
 
 /**
  * Instances of the class `FunctionScope` implement the scope defined by a function.
  */
 class FunctionScope extends EnclosedScope {
-  final ExecutableElement _functionElement;
+  ExecutableElement _functionElement;
 
   bool _parametersDefined = false;
 
   /**
    * Initialize a newly created scope enclosed within another scope.
    *
    * @param enclosingScope the scope in which this scope is lexically enclosed
    * @param functionElement the element representing the type represented by this scope
    */
-  FunctionScope(Scope enclosingScope, this._functionElement) : super(new EnclosedScope(enclosingScope)) {
-    if (_functionElement == null) {
+  FunctionScope(Scope enclosingScope, ExecutableElement functionElement) : super(new EnclosedScope(enclosingScope)) {
+    if (functionElement == null) {
       throw new IllegalArgumentException("function element cannot be null");
     }
+    this._functionElement = functionElement;
   }
 
   /**
    * Define the parameters for the given function in the scope that encloses this function.
    */
   void defineParameters() {
     if (_parametersDefined) {
       return;
     }
     _parametersDefined = true;
@@ skipping 10 matching lines @@
       }
     }
   }
 }
 
 /**
  * Instances of the class `FunctionTypeScope` implement the scope defined by a function type
  * alias.
  */
 class FunctionTypeScope extends EnclosedScope {
-  final FunctionTypeAliasElement _typeElement;
+  FunctionTypeAliasElement _typeElement;
 
   bool _parametersDefined = false;
 
   /**
    * Initialize a newly created scope enclosed within another scope.
    *
    * @param enclosingScope the scope in which this scope is lexically enclosed
    * @param typeElement the element representing the type alias represented by this scope
    */
-  FunctionTypeScope(Scope enclosingScope, this._typeElement) : super(new EnclosedScope(enclosingScope)) {
+  FunctionTypeScope(Scope enclosingScope, FunctionTypeAliasElement typeElement) : super(new EnclosedScope(enclosingScope)) {
+    this._typeElement = typeElement;
     _defineTypeParameters();
   }
 
   /**
    * Define the parameters for the function type alias.
    *
    * @param typeElement the element representing the type represented by this scope
    */
   void defineParameters() {
     if (_parametersDefined) {
@@ skipping 18 matching lines @@
   }
 }
 
 /**
  * Instances of the class `LabelScope` represent a scope in which a single label is defined.
  */
 class LabelScope {
   /**
    * The label scope enclosing this label scope.
    */
-  final LabelScope _outerScope;
+  LabelScope _outerScope;
 
   /**
    * The label defined in this scope.
    */
-  final String _label;
+  String _label;
 
   /**
    * The element to which the label resolves.
    */
-  final LabelElement _element;
+  LabelElement _element;
 
   /**
    * The marker used to look up a label element for an unlabeled `break` or `continue`.
    */
   static String EMPTY_LABEL = "";
 
   /**
    * The label element returned for scopes that can be the target of an unlabeled `break` or
    * `continue`.
    */
@@ skipping 10 matching lines @@
    */
   LabelScope.con1(LabelScope outerScope, bool onSwitchStatement, bool onSwitchMember) : this.con2(outerScope, EMPTY_LABEL, new LabelElementImpl(_EMPTY_LABEL_IDENTIFIER, onSwitchStatement, onSwitchMember));
 
   /**
    * Initialize a newly created scope to represent the given label.
    *
    * @param outerScope the label scope enclosing the new label scope
    * @param label the label defined in this scope
    * @param element the element to which the label resolves
    */
-  LabelScope.con2(this._outerScope, this._label, this._element);
+  LabelScope.con2(LabelScope outerScope, String label, LabelElement element) {
+    this._outerScope = outerScope;
+    this._label = label;
+    this._element = element;
+  }
 
   /**
    * Return the label element corresponding to the given label, or `null` if the given label
    * is not defined in this scope.
    *
    * @param targetLabel the label being looked up
    * @return the label element corresponding to the given label
    */
   LabelElement lookup(String targetLabel) {
     if (_label == targetLabel) {
       return _element;
     } else if (_outerScope != null) {
       return _outerScope.lookup(targetLabel);
     } else {
       return null;
     }
   }
 }
 
 /**
  * Instances of the class `LibraryImportScope` represent the scope containing all of the names
  * available from imported libraries.
  */
 class LibraryImportScope extends Scope {
   /**
    * The element representing the library in which this scope is enclosed.
    */
-  final LibraryElement _definingLibrary;
+  LibraryElement _definingLibrary;
 
   /**
    * The listener that is to be informed when an error is encountered.
    */
-  final AnalysisErrorListener errorListener;
+  AnalysisErrorListener errorListener;
 
   /**
    * A list of the namespaces representing the names that are available in this scope from imported
    * libraries.
    */
   List<Namespace> _importedNamespaces;
 
   /**
    * Initialize a newly created scope representing the names imported into the given library.
    *
    * @param definingLibrary the element representing the library that imports the names defined in
    *          this scope
    * @param errorListener the listener that is to be informed when an error is encountered
    */
-  LibraryImportScope(this._definingLibrary, this.errorListener) {
-    _createImportedNamespaces(_definingLibrary);
+  LibraryImportScope(LibraryElement definingLibrary, AnalysisErrorListener errorListener) {
+    this._definingLibrary = definingLibrary;
+    this.errorListener = errorListener;
+    _createImportedNamespaces(definingLibrary);
   }
 
   @override
   void define(Element element) {
     if (!Scope.isPrivateName(element.displayName)) {
       super.define(element);
     }
   }
 
   @override
@@ skipping 182 matching lines @@
 
 /**
  * Instances of the class `Namespace` implement a mapping of identifiers to the elements
  * represented by those identifiers. Namespaces are the building blocks for scopes.
  */
 class Namespace {
   /**
    * A table mapping names that are defined in this namespace to the element representing the thing
    * declared with that name.
    */
-  final Map<String, Element> _definedNames;
+  Map<String, Element> _definedNames;
 
   /**
    * An empty namespace.
    */
   static Namespace EMPTY = new Namespace(new Map<String, Element>());
 
   /**
    * Initialize a newly created namespace to have the given defined names.
    *
    * @param definedNames the mapping from names that are defined in this namespace to the
    *          corresponding elements
    */
-  Namespace(this._definedNames);
+  Namespace(Map<String, Element> definedNames) {
+    this._definedNames = definedNames;
+  }
 
   /**
    * Return the element in this namespace that is available to the containing scope using the given
    * name.
    *
    * @param name the name used to reference the
    * @return the element represented by the given identifier
    */
   Element get(String name) => _definedNames[name];
 
@@ skipping 452 matching lines @@
     if (parent == null) {
       throw new AnalysisException.con1("Cannot create scope: node is not part of a CompilationUnit");
     }
     ScopeBuilder builder = new ScopeBuilder(errorListener);
     return builder._scopeForAstNode(parent);
   }
 
   /**
    * The listener to which analysis errors will be reported.
    */
-  final AnalysisErrorListener _errorListener;
+  AnalysisErrorListener _errorListener;
 
   /**
    * Initialize a newly created scope builder to generate a scope that will report errors to the
    * given listener.
    *
    * @param errorListener the listener to which analysis errors will be reported
    */
-  ScopeBuilder(this._errorListener);
+  ScopeBuilder(AnalysisErrorListener errorListener) {
+    this._errorListener = errorListener;
+  }
 
   /**
    * Return the scope in which the given AST structure should be resolved.
    *
    * <b>Note:</b> This method needs to be kept in sync with
    * [IncrementalResolver#canBeResolved].
    *
    * @param node the root of the AST structure to be resolved
    * @return the scope in which the given AST structure should be resolved
    * @throws AnalysisException if the AST structure has not been resolved or is not part of a
@@ skipping 65 matching lines @@
 
 /**
  * Instances of the class `ConstantVerifier` traverse an AST structure looking for additional
  * errors and warnings not covered by the parser and resolver. In particular, it looks for errors
  * and warnings related to constant expressions.
  */
 class ConstantVerifier extends RecursiveAstVisitor<Object> {
   /**
    * The error reporter by which errors will be reported.
    */
-  final ErrorReporter _errorReporter;
+  ErrorReporter _errorReporter;
 
   /**
    * The type provider used to access the known types.
    */
-  final TypeProvider _typeProvider;
+  TypeProvider _typeProvider;
 
   /**
    * The type representing the type 'bool'.
    */
   InterfaceType _boolType;
 
   /**
    * The type representing the type 'int'.
    */
   InterfaceType _intType;
 
   /**
    * The type representing the type 'num'.
    */
   InterfaceType _numType;
 
   /**
    * The type representing the type 'string'.
    */
   InterfaceType _stringType;
 
   /**
    * Initialize a newly created constant verifier.
    *
    * @param errorReporter the error reporter by which errors will be reported
    */
-  ConstantVerifier(this._errorReporter, this._typeProvider) {
-    this._boolType = _typeProvider.boolType;
-    this._intType = _typeProvider.intType;
-    this._numType = _typeProvider.numType;
-    this._stringType = _typeProvider.stringType;
+  ConstantVerifier(ErrorReporter errorReporter, TypeProvider typeProvider) {
+    this._errorReporter = errorReporter;
+    this._typeProvider = typeProvider;
+    this._boolType = typeProvider.boolType;
+    this._intType = typeProvider.intType;
+    this._numType = typeProvider.numType;
+    this._stringType = typeProvider.stringType;
   }
 
   @override
   Object visitAnnotation(Annotation node) {
     super.visitAnnotation(node);
     // check annotation creation
     Element element = node.element;
     if (element is ConstructorElement) {
       ConstructorElement constructorElement = element;
       // should 'const' constructor
@@ skipping 304 matching lines @@
 }
 
 /**
  * Instances of the class `ErrorVerifier` traverse an AST structure looking for additional
  * errors and warnings not covered by the parser and resolver.
  */
 class ErrorVerifier extends RecursiveAstVisitor<Object> {
   /**
    * The error reporter by which errors will be reported.
    */
-  final ErrorReporter _errorReporter;
+  ErrorReporter _errorReporter;
 
   /**
    * The current library that is being analyzed.
    */
-  final LibraryElement _currentLibrary;
+  LibraryElement _currentLibrary;
 
   /**
    * The type representing the type 'dynamic'.
    */
   DartType _dynamicType;
 
   /**
    * The type representing the type 'bool'.
    */
   InterfaceType _boolType;
 
   /**
    * The type representing the type 'int'.
    */
   InterfaceType _intType;
 
   /**
    * The object providing access to the types defined by the language.
    */
-  final TypeProvider _typeProvider;
+  TypeProvider _typeProvider;
 
   /**
    * The manager for the inheritance mappings.
    */
-  final InheritanceManager _inheritanceManager;
+  InheritanceManager _inheritanceManager;
 
   /**
    * This is set to `true` iff the visitor is currently visiting children nodes of a
    * [ConstructorDeclaration] and the constructor is 'const'.
    *
    * @see #visitConstructorDeclaration(ConstructorDeclaration)
    */
   bool _isEnclosingConstructorConst = false;
 
   /**
@@ skipping 129 matching lines @@
    * A set of the names of the variable initializers we are visiting now.
    */
   Set<String> _namesForReferenceToDeclaredVariableInInitializer = new Set<String>();
 
   /**
    * A list of types used by the [CompileTimeErrorCode#EXTENDS_DISALLOWED_CLASS] and
    * [CompileTimeErrorCode#IMPLEMENTS_DISALLOWED_CLASS] error codes.
    */
   List<InterfaceType> _DISALLOWED_TYPES_TO_EXTEND_OR_IMPLEMENT;
 
-  ErrorVerifier(this._errorReporter, this._currentLibrary, this._typeProvider, this._inheritanceManager) {
-    this._isInSystemLibrary = _currentLibrary.source.isInSystemLibrary;
-    this._hasExtUri = _currentLibrary.hasExtUri;
+  ErrorVerifier(ErrorReporter errorReporter, LibraryElement currentLibrary, TypeProvider typeProvider, InheritanceManager inheritanceManager) {
+    this._errorReporter = errorReporter;
+    this._currentLibrary = currentLibrary;
+    this._isInSystemLibrary = currentLibrary.source.isInSystemLibrary;
+    this._hasExtUri = currentLibrary.hasExtUri;
+    this._typeProvider = typeProvider;
+    this._inheritanceManager = inheritanceManager;
     _isEnclosingConstructorConst = false;
     _isInCatchClause = false;
     _isInStaticVariableDeclaration = false;
     _isInInstanceVariableDeclaration = false;
     _isInInstanceVariableInitializer = false;
     _isInConstructorInitializer = false;
     _isInStaticMethod = false;
-    _boolType = _typeProvider.boolType;
-    _intType = _typeProvider.intType;
-    _dynamicType = _typeProvider.dynamicType;
+    _boolType = typeProvider.boolType;
+    _intType = typeProvider.intType;
+    _dynamicType = typeProvider.dynamicType;
     _DISALLOWED_TYPES_TO_EXTEND_OR_IMPLEMENT = <InterfaceType> [
-        _typeProvider.nullType,
-        _typeProvider.numType,
+        typeProvider.nullType,
+        typeProvider.numType,
         _intType,
-        _typeProvider.doubleType,
+        typeProvider.doubleType,
         _boolType,
-        _typeProvider.stringType];
+        typeProvider.stringType];
   }
 
   @override
   Object visitArgumentList(ArgumentList node) {
     _checkForArgumentTypesNotAssignableInList(node);
     return super.visitArgumentList(node);
   }
 
   @override
   Object visitAssertStatement(AssertStatement node) {
@@ skipping 413 matching lines @@
       _enclosingFunction = node.element;
       SimpleIdentifier identifier = node.name;
       String methodName = "";
       if (identifier != null) {
         methodName = identifier.name;
       }
       if (node.isSetter || node.isGetter) {
         _checkForMismatchedAccessorTypes(node, methodName);
       }
       if (node.isGetter) {
-        _checkForVoidReturnType(node);
         _checkForConflictingStaticGetterAndInstanceSetter(node);
       } else if (node.isSetter) {
         _checkForWrongNumberOfParametersForSetter(node.name, node.parameters);
         _checkForNonVoidReturnTypeForSetter(node.returnType);
         _checkForConflictingStaticSetterAndInstanceMember(node);
       } else if (node.isOperator) {
         _checkForOptionalParameterInOperator(node);
         _checkForWrongNumberOfParametersForOperator(node);
         _checkForNonVoidReturnTypeForOperator(node);
       }
@@ skipping 1506 matching lines @@
       return false;
     }
     ConstructorElement unnamedConstructor = supertype.element.unnamedConstructor;
     if (unnamedConstructor == null) {
       return false;
     }
     if (unnamedConstructor.isConst) {
       return false;
     }
     // default constructor is not 'const', report problem
-    _errorReporter.reportErrorForNode(CompileTimeErrorCode.CONST_CONSTRUCTOR_WITH_NON_CONST_SUPER, node.returnType, []);
+    _errorReporter.reportErrorForNode(CompileTimeErrorCode.CONST_CONSTRUCTOR_WITH_NON_CONST_SUPER, node, []);
     return true;
   }
 
   /**
    * This verifies that if the passed constructor declaration is 'const' then there are no non-final
    * instance variable.
    *
    * @param node the constructor declaration to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#CONST_CONSTRUCTOR_WITH_NON_FINAL_FIELD
@@ skipping 2206 matching lines @@
             _errorReporter.reportErrorForNode(CompileTimeErrorCode.INITIALIZING_FORMAL_FOR_NON_EXISTANT_FIELD, node, [node.identifier.name]);
           } else if (fieldElement.isStatic) {
             _errorReporter.reportErrorForNode(CompileTimeErrorCode.INITIALIZING_FORMAL_FOR_STATIC_FIELD, node, [node.identifier.name]);
           }
         }
       }
     }
   }
 
   /**
-   * This verifies that the given getter does not have a return type of 'void'.
-   *
-   * @param node the method declaration to evaluate
-   * @return `true` if and only if an error code is generated on the passed node
-   * @see StaticWarningCode#VOID_RETURN_FOR_GETTER
-   */
-  bool _checkForVoidReturnType(MethodDeclaration node) {
-    TypeName returnType = node.returnType;
-    if (returnType == null || returnType.name.name != "void") {
-      return false;
-    }
-    _errorReporter.reportErrorForNode(StaticWarningCode.VOID_RETURN_FOR_GETTER, returnType, []);
-    return true;
-  }
-
-  /**
    * This verifies the passed operator-method declaration, has correct number of parameters.
    *
    * This method assumes that the method declaration was tested to be an operator declaration before
    * being called.
    *
    * @param node the method declaration to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#WRONG_NUMBER_OF_PARAMETERS_FOR_OPERATOR
    */
   bool _checkForWrongNumberOfParametersForOperator(MethodDeclaration node) {
@@ skipping 447 matching lines @@
     return false;
   }
 }
 
 /**
  * This enum holds one of four states of a field initialization state through a constructor
  * signature, not initialized, initialized in the field declaration, initialized in the field
  * formal, and finally, initialized in the initializers list.
  */
 class INIT_STATE extends Enum<INIT_STATE> {
-  static const INIT_STATE NOT_INIT = const INIT_STATE('NOT_INIT', 0);
+  static final INIT_STATE NOT_INIT = new INIT_STATE('NOT_INIT', 0);
 
-  static const INIT_STATE INIT_IN_DECLARATION = const INIT_STATE('INIT_IN_DECLARATION', 1);
+  static final INIT_STATE INIT_IN_DECLARATION = new INIT_STATE('INIT_IN_DECLARATION', 1);
 
-  static const INIT_STATE INIT_IN_FIELD_FORMAL = const INIT_STATE('INIT_IN_FIELD_FORMAL', 2);
+  static final INIT_STATE INIT_IN_FIELD_FORMAL = new INIT_STATE('INIT_IN_FIELD_FORMAL', 2);
 
-  static const INIT_STATE INIT_IN_INITIALIZERS = const INIT_STATE('INIT_IN_INITIALIZERS', 3);
+  static final INIT_STATE INIT_IN_INITIALIZERS = new INIT_STATE('INIT_IN_INITIALIZERS', 3);
 
-  static const List<INIT_STATE> values = const [
+  static final List<INIT_STATE> values = [
       NOT_INIT,
       INIT_IN_DECLARATION,
       INIT_IN_FIELD_FORMAL,
       INIT_IN_INITIALIZERS];
 
-  const INIT_STATE(String name, int ordinal) : super(name, ordinal);
+  INIT_STATE(String name, int ordinal) : super(name, ordinal);
 }
 
 class GeneralizingElementVisitor_ErrorVerifier_hasTypedefSelfReference extends GeneralizingElementVisitor<Object> {
   Element target;
 
   List<Element> toCheck;
 
   GeneralizingElementVisitor_ErrorVerifier_hasTypedefSelfReference(this.target, this.toCheck) : super();
 
   bool _inClass = false;
@@ skipping 66 matching lines @@
   }
 }
 
 /**
  * The enumeration `ResolverErrorCode` defines the error codes used for errors detected by the
  * resolver. The convention for this class is for the name of the error code to indicate the problem
  * that caused the error to be generated and for the error message to explain what is wrong and,
  * when appropriate, how the problem can be corrected.
  */
 class ResolverErrorCode extends Enum<ResolverErrorCode> implements ErrorCode {
-  static const ResolverErrorCode BREAK_LABEL_ON_SWITCH_MEMBER = const ResolverErrorCode.con1('BREAK_LABEL_ON_SWITCH_MEMBER', 0, ErrorType.COMPILE_TIME_ERROR, "Break label resolves to case or default statement");
+  static final ResolverErrorCode BREAK_LABEL_ON_SWITCH_MEMBER = new ResolverErrorCode.con1('BREAK_LABEL_ON_SWITCH_MEMBER', 0, ErrorType.COMPILE_TIME_ERROR, "Break label resolves to case or default statement");
 
-  static const ResolverErrorCode CONTINUE_LABEL_ON_SWITCH = const ResolverErrorCode.con1('CONTINUE_LABEL_ON_SWITCH', 1, ErrorType.COMPILE_TIME_ERROR, "A continue label resolves to switch, must be loop or switch member");
+  static final ResolverErrorCode CONTINUE_LABEL_ON_SWITCH = new ResolverErrorCode.con1('CONTINUE_LABEL_ON_SWITCH', 1, ErrorType.COMPILE_TIME_ERROR, "A continue label resolves to switch, must be loop or switch member");
 
-  static const ResolverErrorCode MISSING_LIBRARY_DIRECTIVE_WITH_PART = const ResolverErrorCode.con1('MISSING_LIBRARY_DIRECTIVE_WITH_PART', 2, ErrorType.COMPILE_TIME_ERROR, "Libraries that have parts must have a library directive");
+  static final ResolverErrorCode MISSING_LIBRARY_DIRECTIVE_WITH_PART = new ResolverErrorCode.con1('MISSING_LIBRARY_DIRECTIVE_WITH_PART', 2, ErrorType.COMPILE_TIME_ERROR, "Libraries that have parts must have a library directive");
 
-  static const List<ResolverErrorCode> values = const [
+  static final List<ResolverErrorCode> values = [
       BREAK_LABEL_ON_SWITCH_MEMBER,
       CONTINUE_LABEL_ON_SWITCH,
       MISSING_LIBRARY_DIRECTIVE_WITH_PART];
 
   /**
    * The type of this error.
    */
-  final ErrorType type;
+  ErrorType type;
 
   /**
    * The template used to create the message to be displayed for this error.
    */
-  final String message;
+  String message;
 
   /**
    * The template used to create the correction to be displayed for this error, or `null` if
    * there is no correction information for this error.
    */
-  final String correction;
+  String correction9;
 
   /**
    * Initialize a newly created error code to have the given type and message.
    *
    * @param type the type of this error
    * @param message the message template used to create the message to be displayed for the error
    */
-  const ResolverErrorCode.con1(String name, int ordinal, ErrorType type, String message) : this.con2(name, ordinal, type, message, null);
+  ResolverErrorCode.con1(String name, int ordinal, ErrorType type, String message) : super(name, ordinal) {
+    this.type = type;
+    this.message = message;
+  }
 
   /**
    * Initialize a newly created error code to have the given type, message and correction.
    *
    * @param type the type of this error
    * @param message the template used to create the message to be displayed for the error
    * @param correction the template used to create the correction to be displayed for the error
    */
-  const ResolverErrorCode.con2(String name, int ordinal, this.type, this.message, this.correction) : super(name, ordinal);
+  ResolverErrorCode.con2(String name, int ordinal, ErrorType type, String message, String correction) : super(name, ordinal) {
+    this.type = type;
+    this.message = message;
+    this.correction9 = correction;
+  }
+
+  @override
+  String get correction => correction9;
 
   @override
   ErrorSeverity get errorSeverity => type.severity;
 }