New Analysis Engine translation.

pkg/analyzer_experimental/lib/src/generated/resolver.dart

 // 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';
 import 'java_core.dart';
 import 'java_engine.dart';
 import 'source.dart';
 import 'error.dart';
@@ skipping 11 matching lines @@
  * Instances of the class {@code CompilationUnitBuilder} build an element model for a single
  * compilation unit.
  * @coverage dart.engine.resolver
  */
 class CompilationUnitBuilder {
   /**
    * The analysis context in which the element model will be built.
    */
   AnalysisContextImpl _analysisContext;
   /**
-   * The listener to which errors will be reported.
-   */
-  AnalysisErrorListener _errorListener;
-  /**
    * Initialize a newly created compilation unit 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
    */
-  CompilationUnitBuilder(AnalysisContextImpl analysisContext, AnalysisErrorListener errorListener) {
+  CompilationUnitBuilder(AnalysisContextImpl analysisContext) {
     this._analysisContext = analysisContext;
-    this._errorListener = errorListener;
   }
   /**
    * Build the compilation unit element for the given source.
    * @param source the source describing the compilation unit
    * @return the compilation unit element that was built
    * @throws AnalysisException if the analysis could not be performed
    */
-  CompilationUnitElementImpl buildCompilationUnit(Source source) => buildCompilationUnit2(source, _analysisContext.parse3(source, _errorListener));
+  CompilationUnitElementImpl buildCompilationUnit(Source source) => buildCompilationUnit2(source, _analysisContext.parseCompilationUnit(source));
   /**
    * Build the compilation unit element for the given source.
    * @param source the source describing the compilation unit
    * @param unit the AST structure representing the compilation unit
    * @return the compilation unit element that was built
    * @throws AnalysisException if the analysis could not be performed
    */
-  CompilationUnitElementImpl buildCompilationUnit2(Source source15, CompilationUnit unit) {
+  CompilationUnitElementImpl buildCompilationUnit2(Source source13, CompilationUnit unit) {
+    if (unit == null) {
+      return null;
+    }
     ElementHolder holder = new ElementHolder();
     ElementBuilder builder = new ElementBuilder(holder);
     unit.accept(builder);
-    CompilationUnitElementImpl element = new CompilationUnitElementImpl(source15.shortName);
+    CompilationUnitElementImpl element = new CompilationUnitElementImpl(source13.shortName);
     element.accessors = holder.accessors;
     element.functions = holder.functions;
-    element.source = source15;
+    element.source = source13;
     element.typeAliases = holder.typeAliases;
     element.types = holder.types;
     element.topLevelVariables = holder.topLevelVariables;
     unit.element = element;
     return element;
   }
 }
 /**
  * Instances of the class {@code ElementBuilder} traverse an AST structure and build the element
  * model representing the AST structure.
@@ skipping 105 matching lines @@
       if (returnType4 != null) {
         element.nameOffset = returnType4.offset;
       }
     } else {
       constructorName.element = element;
     }
     return null;
   }
   Object visitDeclaredIdentifier(DeclaredIdentifier node) {
     SimpleIdentifier variableName = node.identifier;
-    sc.Token keyword27 = node.keyword;
+    sc.Token keyword28 = node.keyword;
     LocalVariableElementImpl element = new LocalVariableElementImpl(variableName);
     ForEachStatement statement = node.parent as ForEachStatement;
     int declarationEnd = node.offset + node.length;
     int statementEnd = statement.offset + statement.length;
     element.setVisibleRange(declarationEnd, statementEnd - declarationEnd - 1);
-    element.const3 = matches(keyword27, sc.Keyword.CONST);
-    element.final2 = matches(keyword27, sc.Keyword.FINAL);
+    element.const3 = matches(keyword28, sc.Keyword.CONST);
+    element.final2 = matches(keyword28, sc.Keyword.FINAL);
     _currentHolder.addLocalVariable(element);
     variableName.element = element;
     return super.visitDeclaredIdentifier(node);
   }
   Object visitDefaultFormalParameter(DefaultFormalParameter node) {
     ElementHolder holder = new ElementHolder();
     visit(holder, node.defaultValue);
     FunctionElementImpl initializer = new FunctionElementImpl();
     initializer.functions = holder.functions;
     initializer.labels = holder.labels;
@@ skipping 269 matching lines @@
   Object visitTypeParameter(TypeParameter node) {
     SimpleIdentifier parameterName = node.name;
     TypeVariableElementImpl element = new TypeVariableElementImpl(parameterName);
     TypeVariableTypeImpl type = new TypeVariableTypeImpl(element);
     element.type = type;
     _currentHolder.addTypeVariable(element);
     parameterName.element = element;
     return super.visitTypeParameter(node);
   }
   Object visitVariableDeclaration(VariableDeclaration node) {
-    sc.Token keyword28 = ((node.parent as VariableDeclarationList)).keyword;
-    bool isConst = matches(keyword28, sc.Keyword.CONST);
-    bool isFinal = matches(keyword28, sc.Keyword.FINAL);
+    sc.Token keyword29 = ((node.parent as VariableDeclarationList)).keyword;
+    bool isConst = matches(keyword29, sc.Keyword.CONST);
+    bool isFinal = matches(keyword29, sc.Keyword.FINAL);
     bool hasInitializer = node.initializer != null;
     VariableElementImpl element;
     if (_inFieldContext) {
       SimpleIdentifier fieldName = node.name;
       FieldElementImpl field;
       if (isConst && hasInitializer) {
         field = new ConstFieldElementImpl(fieldName);
       } else {
         field = new FieldElementImpl.con1(fieldName);
       }
@@ skipping 91 matching lines @@
       parent13 = parent13.parent;
     }
     return null;
   }
   /**
    * Return {@code true} if the given token is a token for the given keyword.
    * @param token the token being tested
    * @param keyword the keyword being tested for
    * @return {@code true} if the given token is a token for the given keyword
    */
-  bool matches(sc.Token token, sc.Keyword keyword36) => token != null && identical(token.type, sc.TokenType.KEYWORD) && identical(((token as sc.KeywordToken)).keyword, keyword36);
+  bool matches(sc.Token token, sc.Keyword keyword37) => token != null && identical(token.type, sc.TokenType.KEYWORD) && identical(((token as sc.KeywordToken)).keyword, keyword37);
   /**
    * Make the given holder be the current holder while visiting the given node.
    * @param holder the holder that will gather elements that are built while visiting the children
    * @param node the node to be visited
    */
   void visit(ElementHolder holder, ASTNode node) {
     if (node != null) {
       ElementHolder previousHolder = _currentHolder;
       _currentHolder = holder;
       try {
@@ skipping 127 matching lines @@
    */
   HtmlUnitBuilder(AnalysisContextImpl context) {
     this._context = context;
   }
   /**
    * Build the HTML element for the given source.
    * @param source the source describing the compilation unit
    * @return the HTML element that was built
    * @throws AnalysisException if the analysis could not be performed
    */
-  HtmlElementImpl buildHtmlElement(Source source) => buildHtmlElement2(source, _context.parseHtml(source).htmlUnit);
+  HtmlElementImpl buildHtmlElement(Source source) => buildHtmlElement2(source, _context.parseHtmlUnit(source));
   /**
    * Build the HTML element for the given source.
    * @param source the source describing the compilation unit
    * @param unit the AST structure representing the HTML
    * @throws AnalysisException if the analysis could not be performed
    */
-  HtmlElementImpl buildHtmlElement2(Source source16, ht.HtmlUnit unit) {
-    HtmlElementImpl result = new HtmlElementImpl(_context, source16.shortName);
-    result.source = source16;
+  HtmlElementImpl buildHtmlElement2(Source source14, ht.HtmlUnit unit) {
+    HtmlElementImpl result = new HtmlElementImpl(_context, source14.shortName);
+    result.source = source14;
     _htmlElement = result;
     unit.accept(this);
     _htmlElement = null;
     unit.element = result;
     return result;
   }
   Object visitHtmlUnit(ht.HtmlUnit node) {
     _scripts = new List<HtmlScriptElement>();
     node.visitChildren(this);
     _htmlElement.scripts = new List.from(_scripts);
     _scripts = null;
     return null;
   }
   Object visitXmlAttributeNode(ht.XmlAttributeNode node) => null;
   Object visitXmlTagNode(ht.XmlTagNode node) {
     if (isScriptNode(node)) {
       Source htmlSource = _htmlElement.source;
       String scriptSourcePath = getScriptSourcePath(node);
       if (identical(node.attributeEnd.type, ht.TokenType.GT) && scriptSourcePath == null) {
         EmbeddedHtmlScriptElementImpl script = new EmbeddedHtmlScriptElementImpl(node);
         String contents = node.content;
         AnalysisErrorListener errorListener = new AnalysisErrorListener_2();
         sc.StringScanner scanner = new sc.StringScanner(null, contents, errorListener);
         sc.Token firstToken = scanner.tokenize();
         List<int> lineStarts2 = scanner.lineStarts;
         Parser parser = new Parser(null, errorListener);
         CompilationUnit unit = parser.parseCompilationUnit(firstToken);
         try {
-          CompilationUnitBuilder builder = new CompilationUnitBuilder(_context, errorListener);
+          CompilationUnitBuilder builder = new CompilationUnitBuilder(_context);
           CompilationUnitElementImpl elem = builder.buildCompilationUnit2(htmlSource, unit);
           LibraryElementImpl library = new LibraryElementImpl(_context, null);
           library.definingCompilationUnit = elem;
           script.scriptLibrary = library;
         } on AnalysisException catch (e) {
           print(e);
         }
         _scripts.add(script);
       } else {
         ExternalHtmlScriptElementImpl script = new ExternalHtmlScriptElementImpl(node);
@@ skipping 186 matching lines @@
   }
   Object visitContinueStatement(ContinueStatement node) {
     SimpleIdentifier labelNode = node.label;
     LabelElementImpl labelElement = lookupLabel(node, labelNode);
     if (labelElement != null && labelElement.isOnSwitchStatement()) {
       _resolver.reportError(ResolverErrorCode.CONTINUE_LABEL_ON_SWITCH, labelNode, []);
     }
     return null;
   }
   Object visitExportDirective(ExportDirective node) {
-    Element element22 = node.element;
-    if (element22 is ExportElement) {
-      resolveCombinators(((element22 as ExportElement)).exportedLibrary, node.combinators);
+    Element element26 = node.element;
+    if (element26 is ExportElement) {
+      resolveCombinators(((element26 as ExportElement)).exportedLibrary, node.combinators);
     }
     return null;
   }
   Object visitFunctionExpressionInvocation(FunctionExpressionInvocation node) => null;
   Object visitImportDirective(ImportDirective node) {
     SimpleIdentifier prefixNode = node.prefix;
     if (prefixNode != null) {
       String prefixName = prefixNode.name;
       for (PrefixElement prefixElement in _resolver.definingLibrary.prefixes) {
         if (prefixElement.name == prefixName) {
           recordResolution(prefixNode, prefixElement);
           break;
         }
       }
     }
-    Element element23 = node.element;
-    if (element23 is ImportElement) {
-      resolveCombinators(((element23 as ImportElement)).importedLibrary, node.combinators);
+    Element element27 = node.element;
+    if (element27 is ImportElement) {
+      resolveCombinators(((element27 as ImportElement)).importedLibrary, node.combinators);
     }
     return null;
   }
   Object visitIndexExpression(IndexExpression node) {
     Type2 arrayType = getType(node.realTarget);
     if (arrayType == null || arrayType.isDynamic()) {
       return null;
     }
     Element arrayTypeElement = arrayType.element;
     String operator;
@@ skipping 56 matching lines @@
           }
         }
         if (element == null && target is SuperExpression) {
           _resolver.reportError(StaticTypeWarningCode.UNDEFINED_SUPER_METHOD, methodName2, [methodName2.name, targetType.element.name]);
           return null;
         }
       } else if (target is SimpleIdentifier) {
         Element targetElement = ((target as SimpleIdentifier)).element;
         if (targetElement is PrefixElement) {
           String name9 = "${((target as SimpleIdentifier)).name}.${methodName2}";
-          Identifier functionName = new Identifier_4(name9);
+          Identifier functionName = new Identifier_5(name9);
           element = _resolver.nameScope.lookup(functionName, _resolver.definingLibrary);
         } else {
           return null;
         }
       } else {
         return null;
       }
     }
     ExecutableElement invokedMethod = null;
     if (element is ExecutableElement) {
@@ skipping 592 matching lines @@
       break;
     }
     AnalysisEngine.instance.logger.logError("Failed to map ${operator.lexeme} to it's corresponding operator");
     return operator;
   }
   /**
    * Record the fact that the given AST node was resolved to the given element.
    * @param node the AST node that was resolved
    * @param element the element to which the AST node was resolved
    */
-  void recordResolution(SimpleIdentifier node, Element element52) {
-    if (element52 != null) {
-      node.element = element52;
+  void recordResolution(SimpleIdentifier node, Element element58) {
+    if (element58 != null) {
+      node.element = element58;
     }
   }
   /**
    * Report the {@link StaticTypeWarningCode}s <code>UNDEFINED_SETTER</code> and
    * <code>UNDEFINED_GETTER</code>.
    * @param node the prefixed identifier that gives the context to determine if the error on the
    * undefined identifier is a getter or a setter
    * @param identifier the identifier in the passed prefix identifier
    * @param typeName the name of the type of the left hand side of the passed prefixed identifier
    */
@@ skipping 49 matching lines @@
       }
     }
   }
   /**
    * If the given element is a type variable, resolve it to the class that should be used when
    * looking up members. Otherwise, return the original element.
    * @param element the element that is to be resolved if it is a type variable
    * @return the class that should be used in place of the argument if it is a type variable, or the
    * original argument if it isn't a type variable
    */
-  Element resolveTypeVariable(Element element53) {
-    if (element53 is TypeVariableElement) {
-      Type2 bound4 = ((element53 as TypeVariableElement)).bound;
+  Element resolveTypeVariable(Element element59) {
+    if (element59 is TypeVariableElement) {
+      Type2 bound4 = ((element59 as TypeVariableElement)).bound;
       if (bound4 == null) {
         return _resolver.typeProvider.objectType.element;
       }
       return bound4.element;
     }
-    return element53;
+    return element59;
   }
 }
-class Identifier_4 extends Identifier {
+class Identifier_5 extends Identifier {
   String name9;
-  Identifier_4(this.name9) : super();
+  Identifier_5(this.name9) : super();
   accept(ASTVisitor visitor) => null;
   sc.Token get beginToken => null;
   Element get element => null;
   sc.Token get endToken => null;
   String get name => name9;
   void visitChildren(ASTVisitor<Object> visitor) {
   }
 }
 /**
  * Instances of the class {@code Library} represent the data about a single library during the
@@ skipping 42 matching lines @@
   /**
    * 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(AnalysisContextImpl analysisContext, AnalysisErrorListener errorListener, Source librarySource) {
     this._analysisContext = analysisContext;
     this._errorListener = errorListener;
     this._librarySource = librarySource;
-    this._libraryElement = analysisContext.getLibraryElementOrNull(librarySource) as LibraryElementImpl;
+    this._libraryElement = analysisContext.getLibraryElement(librarySource) as LibraryElementImpl;
   }
   /**
    * Record that the given library is exported from this library.
    * @param importLibrary the library that is exported from this library
    */
   void addExport(ExportDirective directive, Library exportLibrary) {
     _exportedLibraries[directive] = exportLibrary;
   }
   /**
    * Record that the given library is imported into this library.
    * @param importLibrary the library that is imported into this library
    */
   void addImport(ImportDirective directive, Library importLibrary) {
     _importedLibraries[directive] = importLibrary;
   }
   /**
    * 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) {
     CompilationUnit unit = _astMap[source];
     if (unit == null) {
-      unit = _analysisContext.parse3(source, _errorListener);
+      unit = _analysisContext.parseCompilationUnit(source);
       _astMap[source] = unit;
     }
     return unit;
   }
   /**
    * Return a collection containing the sources for the compilation units in this library.
    * @return the sources for the compilation units in this library
    */
   Set<Source> get compilationUnitSources => _astMap.keys.toSet();
   /**
@@ skipping 48 matching lines @@
     libraries.addAll(_importedLibraries.values);
     libraries.addAll(_exportedLibraries.values);
     return new List.from(libraries);
   }
   /**
    * Return the library element representing this library, creating it if necessary.
    * @return the library element representing this library
    */
   LibraryElementImpl get libraryElement {
     if (_libraryElement == null) {
-      _libraryElement = _analysisContext.getLibraryElement(_librarySource) as LibraryElementImpl;
+      try {
+        _libraryElement = _analysisContext.computeLibraryElement(_librarySource) as LibraryElementImpl;
+      } on AnalysisException catch (exception) {
+        AnalysisEngine.instance.logger.logError2("Could not compute ilbrary element for ${_librarySource.fullName}", exception);
+      }
     }
     return _libraryElement;
   }
   /**
    * Return the library scope used when resolving elements within this library's compilation units.
    * @return the library scope used when resolving elements within this library's compilation units
    */
   LibraryScope get libraryScope {
     if (_libraryScope == null) {
       _libraryScope = new LibraryScope(_libraryElement, _errorListener);
@@ skipping 108 matching lines @@
     this._analysisContext = resolver.analysisContext;
     this._errorListener = resolver.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(_analysisContext, _errorListener);
+    CompilationUnitBuilder builder = new CompilationUnitBuilder(_analysisContext);
     Source librarySource2 = library.librarySource;
     CompilationUnit definingCompilationUnit3 = library.definingCompilationUnit;
     CompilationUnitElementImpl definingCompilationUnitElement = builder.buildCompilationUnit2(librarySource2, definingCompilationUnit3);
     NodeList<Directive> directives3 = definingCompilationUnit3.directives;
     LibraryIdentifier libraryNameNode = null;
     bool hasPartDirective = false;
     FunctionElement entryPoint = findEntryPoint(definingCompilationUnitElement);
     List<Directive> directivesToResolve = new List<Directive>();
     List<CompilationUnitElementImpl> sourcedCompilationUnits = new List<CompilationUnitElementImpl>();
     for (Directive directive in directives3) {
       if (directive is LibraryDirective) {
         if (libraryNameNode == null) {
           libraryNameNode = ((directive as LibraryDirective)).name;
           directivesToResolve.add(directive);
         }
       } else if (directive is PartDirective) {
         hasPartDirective = true;
         StringLiteral partUri = ((directive as PartDirective)).uri;
         Source partSource = library.getSource(partUri);
-        if (partSource != null) {
+        if (partSource != null && partSource.exists()) {
           CompilationUnitElementImpl part = builder.buildCompilationUnit(partSource);
           String partLibraryName = getPartLibraryName(library, partSource, directivesToResolve);
           if (partLibraryName == null) {
             _errorListener.onError(new AnalysisError.con2(librarySource2, partUri.offset, partUri.length, ResolverErrorCode.MISSING_PART_OF_DIRECTIVE, []));
           } else if (libraryNameNode == null) {
           } else if (libraryNameNode.name != partLibraryName) {
             _errorListener.onError(new AnalysisError.con2(librarySource2, partUri.offset, partUri.length, StaticWarningCode.PART_OF_DIFFERENT_LIBRARY, [libraryNameNode.name, partLibraryName]));
           }
           if (entryPoint == null) {
             entryPoint = findEntryPoint(part);
@@ skipping 68 matching lines @@
    */
   AnalysisContextImpl _analysisContext;
   /**
    * The listener to which analysis errors will be reported, this error listener is either
    * references {@link #recordingErrorListener}, or it unions the passed{@link AnalysisErrorListener} with the {@link #recordingErrorListener}.
    */
   AnalysisErrorListener _errorListener;
   /**
    * This error listener is used by the resolver to be able to call the listener and get back the
    * set of errors for each {@link Source}.
-   * @see #recordErrors()
+   * @see #recordResults()
    */
   RecordingErrorListener _recordingErrorListener;
   /**
    * A source object representing the core library (dart:core).
    */
   Source _coreLibrarySource;
   /**
    * The object representing the core library.
    */
   Library _coreLibrary;
   /**
    * The object used to access the types from the core library.
    */
   TypeProvider _typeProvider;
   /**
    * A table mapping library sources to the information being maintained for those libraries.
    */
   Map<Source, Library> _libraryMap = new Map<Source, Library>();
   /**
    * 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.con1(AnalysisContextImpl analysisContext) {
-    _jtd_constructor_239_impl(analysisContext);
+    _jtd_constructor_243_impl(analysisContext);
   }
-  _jtd_constructor_239_impl(AnalysisContextImpl analysisContext) {
-    _jtd_constructor_240_impl(analysisContext, null);
+  _jtd_constructor_243_impl(AnalysisContextImpl analysisContext) {
+    _jtd_constructor_244_impl(analysisContext, null);
   }
   /**
    * 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
    * @param errorListener the listener to which analysis errors will be reported
    */
   LibraryResolver.con2(AnalysisContextImpl analysisContext2, AnalysisErrorListener additionalAnalysisErrorListener) {
-    _jtd_constructor_240_impl(analysisContext2, additionalAnalysisErrorListener);
+    _jtd_constructor_244_impl(analysisContext2, additionalAnalysisErrorListener);
   }
-  _jtd_constructor_240_impl(AnalysisContextImpl analysisContext2, AnalysisErrorListener additionalAnalysisErrorListener) {
+  _jtd_constructor_244_impl(AnalysisContextImpl analysisContext2, AnalysisErrorListener additionalAnalysisErrorListener) {
     this._analysisContext = analysisContext2;
     this._recordingErrorListener = new RecordingErrorListener();
     if (additionalAnalysisErrorListener == null) {
       this._errorListener = _recordingErrorListener;
     } else {
-      this._errorListener = new AnalysisErrorListener_5(this, additionalAnalysisErrorListener);
+      this._errorListener = new AnalysisErrorListener_6(this, additionalAnalysisErrorListener);
     }
     _coreLibrarySource = analysisContext2.sourceFactory.forUri(LibraryElementBuilder.CORE_LIBRARY_URI);
   }
   /**
    * Return the analysis context in which the libraries are being analyzed.
    * @return the analysis context in which the libraries are being analyzed
    */
   AnalysisContextImpl get analysisContext => _analysisContext;
   /**
    * Return the listener to which analysis errors will be reported.
@@ skipping 21 matching lines @@
     computeLibraryDependencies(targetLibrary);
     _librariesInCycles = computeLibrariesInCycles(targetLibrary);
     buildElementModels();
     buildDirectiveModels();
     _typeProvider = new TypeProviderImpl(_coreLibrary.libraryElement);
     buildTypeHierarchies();
     resolveReferencesAndTypes();
     if (fullAnalysis) {
       runAdditionalAnalyses();
     }
-    recordLibraryElements();
-    recordErrors();
+    recordResults();
     return targetLibrary.libraryElement;
   }
   /**
    * Add a dependency to the given map from the referencing library to the referenced library.
    * @param dependencyMap the map to which the dependency is to be added
    * @param referencingLibrary the library that references the referenced library
    * @param referencedLibrary the library referenced by the referencing library
    */
   void addDependencyToMap(Map<Library, List<Library>> dependencyMap, Library referencingLibrary, Library referencedLibrary) {
     List<Library> dependentLibraries = dependencyMap[referencedLibrary];
@@ skipping 245 matching lines @@
     return library;
   }
   /**
    * Create an object to represent the information about the library defined by the compilation unit
    * with the given source. Return the library object that was created, or {@code null} if the
    * source is not valid.
    * @param librarySource the source of the library's defining compilation unit
    * @return the library object that was created
    */
   Library createLibraryOrNull(Source librarySource) {
+    if (!librarySource.exists()) {
+      return null;
+    }
     Library library = new Library(_analysisContext, _errorListener, librarySource);
     try {
       library.definingCompilationUnit;
     } on AnalysisException catch (exception) {
       return null;
     }
     _libraryMap[librarySource] = library;
     return library;
   }
   /**
    * Return an array containing the lexical identifiers associated with the nodes in the given list.
    * @param names the AST nodes representing the identifiers
    * @return the lexical identifiers associated with the nodes in the list
    */
   List<String> getIdentifiers(NodeList<SimpleIdentifier> names) {
     int count = names.length;
     List<String> identifiers = new List<String>(count);
     for (int i = 0; i < count; i++) {
       identifiers[i] = names[i].name;
     }
     return identifiers;
   }
   /**
-   * For each library, loop through the set of all {@link CompilationUnit}s recording the set of
-   * resolution errors on each unit.
+   * Record the results of resolution with the analysis context. This includes recording
+   * <ul>
+   * <li>the resolved AST associated with each compilation unit,</li>
+   * <li>the set of resolution errors produced for each compilation unit, and</li>
+   * <li>the element models produced for each library.</li>
+   * </ul>
    */
-  void recordErrors() {
-    for (Library library in _librariesInCycles) {
-      try {
-        CompilationUnit definingUnit = library.definingCompilationUnit;
-        definingUnit.resolutionErrors = _recordingErrorListener.getErrors2(library.librarySource);
-      } on AnalysisException catch (e) {
-        throw new AnalysisException();
-      }
-      Set<Source> sources = library.compilationUnitSources;
-      for (Source source in sources) {
-        try {
-          CompilationUnit unit = library.getAST(source);
-          unit.resolutionErrors = _recordingErrorListener.getErrors2(source);
-        } on JavaException catch (e) {
-          throw new AnalysisException();
-        }
-      }
-    }
-  }
-  /**
-   * As the final step in the process, record the resolved element models with the analysis context.
-   */
-  void recordLibraryElements() {
+  void recordResults() {
     Map<Source, LibraryElement> elementMap = new Map<Source, LibraryElement>();
     for (Library library in _librariesInCycles) {
+      recordResults2(library.librarySource, library.definingCompilationUnit);
+      for (Source source in library.compilationUnitSources) {
+        recordResults2(source, library.getAST(source));
+      }
       elementMap[library.librarySource] = library.libraryElement;
     }
     _analysisContext.recordLibraryElements(elementMap);
   }
+  void recordResults2(Source source, CompilationUnit unit) {
+    List<AnalysisError> errors = _recordingErrorListener.getErrors2(source);
+    unit.resolutionErrors = errors;
+    _analysisContext.recordResolvedCompilationUnit(source, unit);
+    _analysisContext.recordResolutionErrors(source, errors, unit.lineInfo);
+  }
   /**
    * Resolve the identifiers and perform type analysis in the libraries in the current cycle.
    * @throws AnalysisException if any of the identifiers could not be resolved or if any of the
    * libraries could not have their types analyzed
    */
   void resolveReferencesAndTypes() {
     for (Library library in _librariesInCycles) {
       resolveReferencesAndTypes2(library);
     }
   }
@@ skipping 29 matching lines @@
     for (Source source in library.compilationUnitSources) {
       ErrorReporter errorReporter = new ErrorReporter(_errorListener, source);
       CompilationUnit unit = library.getAST(source);
       ErrorVerifier errorVerifier = new ErrorVerifier(errorReporter, library.libraryElement, _typeProvider);
       unit.accept(errorVerifier);
       ConstantVerifier constantVerifier = new ConstantVerifier(errorReporter);
       unit.accept(constantVerifier);
     }
   }
 }
-class AnalysisErrorListener_5 implements AnalysisErrorListener {
+class AnalysisErrorListener_6 implements AnalysisErrorListener {
   final LibraryResolver LibraryResolver_this;
   AnalysisErrorListener additionalAnalysisErrorListener;
-  AnalysisErrorListener_5(this.LibraryResolver_this, this.additionalAnalysisErrorListener);
+  AnalysisErrorListener_6(this.LibraryResolver_this, this.additionalAnalysisErrorListener);
   void onError(AnalysisError error) {
     additionalAnalysisErrorListener.onError(error);
     LibraryResolver_this._recordingErrorListener.onError(error);
   }
 }
 /**
  * Instances of the class {@code ResolverVisitor} are used to resolve the nodes within a single
  * compilation unit.
  * @coverage dart.engine.resolver
  */
@@ skipping 361 matching lines @@
     }
     try {
       super.visitSwitchStatement(node);
     } finally {
       _labelScope = outerScope;
     }
     return null;
   }
   Object visitVariableDeclaration(VariableDeclaration node) {
     if (node.parent.parent is! TopLevelVariableDeclaration && node.parent.parent is! FieldDeclaration) {
-      VariableElement element24 = node.element;
-      if (element24 != null) {
-        _nameScope.define(element24);
+      VariableElement element28 = node.element;
+      if (element28 != null) {
+        _nameScope.define(element28);
       }
     }
     super.visitVariableDeclaration(node);
     return null;
   }
   Object visitWhileStatement(WhileStatement node) {
     LabelScope outerScope = _labelScope;
     _labelScope = new LabelScope.con1(outerScope, false, false);
     try {
       super.visitWhileStatement(node);
@@ skipping 435 matching lines @@
    * <p>
    * A postfix expression of the form <i>e1[e2]--</i> is equivalent to <i>(a, i){var r = a[i]; a[i]
    * = r - 1; return r}(e1, e2)</i></blockquote>
    */
   Object visitPostfixExpression(PostfixExpression node) => recordType(node, getType(node.operand));
   /**
    * See {@link #visitSimpleIdentifier(SimpleIdentifier)}.
    */
   Object visitPrefixedIdentifier(PrefixedIdentifier node) {
     SimpleIdentifier prefixedIdentifier = node.identifier;
-    Element element25 = prefixedIdentifier.element;
-    if (element25 is VariableElement) {
-      Type2 variableType = ((element25 as VariableElement)).type;
+    Element element29 = prefixedIdentifier.element;
+    if (element29 is VariableElement) {
+      Type2 variableType = ((element29 as VariableElement)).type;
       recordType(prefixedIdentifier, variableType);
       return recordType(node, variableType);
-    } else if (element25 is PropertyAccessorElement) {
-      Type2 propertyType = getType2((element25 as PropertyAccessorElement));
+    } else if (element29 is PropertyAccessorElement) {
+      Type2 propertyType = getType2((element29 as PropertyAccessorElement));
       recordType(prefixedIdentifier, propertyType);
       return recordType(node, propertyType);
-    } else if (element25 is MethodElement) {
-      Type2 returnType = ((element25 as MethodElement)).type;
+    } else if (element29 is MethodElement) {
+      Type2 returnType = ((element29 as MethodElement)).type;
       recordType(prefixedIdentifier, returnType);
       return recordType(node, returnType);
     } else {
     }
     recordType(prefixedIdentifier, _dynamicType);
     return recordType(node, _dynamicType);
   }
   /**
    * The Dart Language Specification, 12.27: <blockquote>A unary expression <i>u</i> of the form
    * <i>op e</i> is equivalent to a method invocation <i>expression e.op()</i>. An expression of the
@@ skipping 44 matching lines @@
    * The static type of <i>i</i> is the declared return type of <i>C.m</i> if it exists or dynamic
    * otherwise.
    * <p>
    * ... a top-level getter invocation <i>i</i> of the form <i>m</i>, where <i>m</i> is an
    * identifier ...
    * <p>
    * The static type of <i>i</i> is the declared return type of <i>m</i>.</blockquote>
    */
   Object visitPropertyAccess(PropertyAccess node) {
     SimpleIdentifier propertyName2 = node.propertyName;
-    Element element26 = propertyName2.element;
-    if (element26 is MethodElement) {
-      FunctionType type15 = ((element26 as MethodElement)).type;
+    Element element30 = propertyName2.element;
+    if (element30 is MethodElement) {
+      FunctionType type15 = ((element30 as MethodElement)).type;
       recordType(propertyName2, type15);
       return recordType(node, type15);
-    } else if (element26 is PropertyAccessorElement) {
-      Type2 propertyType = getType2((element26 as PropertyAccessorElement));
+    } else if (element30 is PropertyAccessorElement) {
+      Type2 propertyType = getType2((element30 as PropertyAccessorElement));
       recordType(propertyName2, propertyType);
       return recordType(node, propertyType);
     } else {
     }
     recordType(propertyName2, _dynamicType);
     return recordType(node, _dynamicType);
   }
   /**
+   * The Dart Language Specification, 12.9: <blockquote>The static type of a rethrow expression is
+   * bottom.</blockquote>
+   */
+  Object visitRethrowExpression(RethrowExpression node) => recordType(node, _typeProvider.bottomType);
+  /**
    * The Dart Language Specification, 12.30: <blockquote>Evaluation of an identifier expression
    * <i>e</i> of the form <i>id</i> proceeds as follows:
    * <p>
    * Let <i>d</i> be the innermost declaration in the enclosing lexical scope whose name is
    * <i>id</i>. If no such declaration exists in the lexical scope, let <i>d</i> be the declaration
    * of the inherited member named <i>id</i> if it exists.
    * <ul>
    * <li>If <i>d</i> is a class or type alias <i>T</i>, the value of <i>e</i> is the unique instance
    * of class {@code Type} reifying <i>T</i>.
    * <li>If <i>d</i> is a type parameter <i>T</i>, then the value of <i>e</i> is the value of the
@@ skipping 22 matching lines @@
    * <li>If <i>d</i> is the declaration of a top level getter, then <i>e</i> is equivalent to the
    * getter invocation <i>id</i>.
    * <li>Otherwise, if <i>e</i> occurs inside a top level or static function (be it function,
    * method, getter, or setter) or variable initializer, evaluation of e causes a NoSuchMethodError
    * to be thrown.
    * <li>Otherwise <i>e</i> is equivalent to the property extraction <i>this.id</i>.
    * </ul>
    * </blockquote>
    */
   Object visitSimpleIdentifier(SimpleIdentifier node) {
-    Element element27 = node.element;
-    if (element27 == null) {
+    Element element31 = node.element;
+    if (element31 == null) {
       return recordType(node, _dynamicType);
-    } else if (element27 is ClassElement) {
+    } else if (element31 is ClassElement) {
       if (isNotTypeLiteral(node)) {
-        return recordType(node, ((element27 as ClassElement)).type);
+        return recordType(node, ((element31 as ClassElement)).type);
       }
       return recordType(node, _typeProvider.typeType);
-    } else if (element27 is TypeVariableElement) {
-      return recordType(node, ((element27 as TypeVariableElement)).type);
-    } else if (element27 is FunctionTypeAliasElement) {
-      return recordType(node, ((element27 as FunctionTypeAliasElement)).type);
-    } else if (element27 is VariableElement) {
-      return recordType(node, ((element27 as VariableElement)).type);
-    } else if (element27 is MethodElement) {
-      return recordType(node, ((element27 as MethodElement)).type);
-    } else if (element27 is PropertyAccessorElement) {
-      return recordType(node, getType2((element27 as PropertyAccessorElement)));
-    } else if (element27 is ExecutableElement) {
-      return recordType(node, ((element27 as ExecutableElement)).type);
-    } else if (element27 is PrefixElement) {
+    } else if (element31 is TypeVariableElement) {
+      return recordType(node, ((element31 as TypeVariableElement)).type);
+    } else if (element31 is FunctionTypeAliasElement) {
+      return recordType(node, ((element31 as FunctionTypeAliasElement)).type);
+    } else if (element31 is VariableElement) {
+      return recordType(node, ((element31 as VariableElement)).type);
+    } else if (element31 is MethodElement) {
+      return recordType(node, ((element31 as MethodElement)).type);
+    } else if (element31 is PropertyAccessorElement) {
+      return recordType(node, getType2((element31 as PropertyAccessorElement)));
+    } else if (element31 is ExecutableElement) {
+      return recordType(node, ((element31 as ExecutableElement)).type);
+    } else if (element31 is PrefixElement) {
       return null;
     } else {
       return recordType(node, _dynamicType);
     }
   }
   /**
    * The Dart Language Specification, 12.5: <blockquote>The static type of a string literal is{@code String}.</blockquote>
    */
   Object visitSimpleStringLiteral(SimpleStringLiteral node) => recordType(node, _typeProvider.stringType);
   /**
@@ skipping 433 matching lines @@
     SimpleIdentifier exception = node.exceptionParameter;
     if (exception != null) {
       TypeName exceptionTypeName = node.exceptionType;
       Type2 exceptionType;
       if (exceptionTypeName == null) {
         exceptionType = typeProvider.objectType;
       } else {
         exceptionType = getType4(exceptionTypeName);
       }
       recordType(exception, exceptionType);
-      Element element28 = exception.element;
-      if (element28 is VariableElementImpl) {
-        ((element28 as VariableElementImpl)).type = exceptionType;
+      Element element32 = exception.element;
+      if (element32 is VariableElementImpl) {
+        ((element32 as VariableElementImpl)).type = exceptionType;
       } else {
       }
     }
     SimpleIdentifier stackTrace = node.stackTraceParameter;
     if (stackTrace != null) {
       recordType(stackTrace, typeProvider.stackTraceType);
     }
     return null;
   }
   Object visitClassDeclaration(ClassDeclaration node) {
@@ skipping 27 matching lines @@
       superclassType = typeProvider.objectType;
     }
     if (classElement != null && superclassType != null) {
       classElement.supertype = superclassType;
     }
     resolve(classElement, node.withClause, node.implementsClause);
     return null;
   }
   Object visitConstructorDeclaration(ConstructorDeclaration node) {
     super.visitConstructorDeclaration(node);
-    ExecutableElementImpl element29 = node.element as ExecutableElementImpl;
-    FunctionTypeImpl type = new FunctionTypeImpl.con1(element29);
-    setTypeInformation(type, null, element29.parameters);
-    type.returnType = ((element29.enclosingElement as ClassElement)).type;
-    element29.type = type;
+    ExecutableElementImpl element33 = node.element as ExecutableElementImpl;
+    FunctionTypeImpl type = new FunctionTypeImpl.con1(element33);
+    setTypeInformation(type, null, element33.parameters);
+    type.returnType = ((element33.enclosingElement as ClassElement)).type;
+    element33.type = type;
     return null;
   }
   Object visitDeclaredIdentifier(DeclaredIdentifier node) {
     super.visitDeclaredIdentifier(node);
     Type2 declaredType;
     TypeName typeName = node.type;
     if (typeName == null) {
       declaredType = _dynamicType;
     } else {
       declaredType = getType4(typeName);
     }
-    LocalVariableElementImpl element30 = node.element as LocalVariableElementImpl;
-    element30.type = declaredType;
+    LocalVariableElementImpl element34 = node.element as LocalVariableElementImpl;
+    element34.type = declaredType;
     return null;
   }
   Object visitDefaultFormalParameter(DefaultFormalParameter node) {
     super.visitDefaultFormalParameter(node);
     return null;
   }
   Object visitFieldFormalParameter(FieldFormalParameter node) {
     super.visitFieldFormalParameter(node);
-    Element element31 = node.identifier.element;
-    if (element31 is ParameterElementImpl) {
-      ParameterElementImpl parameter = element31 as ParameterElementImpl;
+    Element element35 = node.identifier.element;
+    if (element35 is ParameterElementImpl) {
+      ParameterElementImpl parameter = element35 as ParameterElementImpl;
       Type2 type;
       TypeName typeName = node.type;
       if (typeName == null) {
         type = _dynamicType;
       } else {
         type = getType4(typeName);
       }
       parameter.type = type;
     } else {
     }
     return null;
   }
   Object visitFunctionDeclaration(FunctionDeclaration node) {
     super.visitFunctionDeclaration(node);
-    ExecutableElementImpl element32 = node.element as ExecutableElementImpl;
-    FunctionTypeImpl type = new FunctionTypeImpl.con1(element32);
-    setTypeInformation(type, node.returnType, element32.parameters);
-    element32.type = type;
+    ExecutableElementImpl element36 = node.element as ExecutableElementImpl;
+    FunctionTypeImpl type = new FunctionTypeImpl.con1(element36);
+    setTypeInformation(type, node.returnType, element36.parameters);
+    element36.type = type;
     return null;
   }
   Object visitFunctionTypeAlias(FunctionTypeAlias node) {
     super.visitFunctionTypeAlias(node);
-    FunctionTypeAliasElementImpl element33 = node.element as FunctionTypeAliasElementImpl;
-    FunctionTypeImpl type18 = element33.type as FunctionTypeImpl;
-    setTypeInformation(type18, node.returnType, element33.parameters);
+    FunctionTypeAliasElementImpl element37 = node.element as FunctionTypeAliasElementImpl;
+    FunctionTypeImpl type18 = element37.type as FunctionTypeImpl;
+    setTypeInformation(type18, node.returnType, element37.parameters);
     return null;
   }
   Object visitFunctionTypedFormalParameter(FunctionTypedFormalParameter node) {
     super.visitFunctionTypedFormalParameter(node);
-    ParameterElementImpl element34 = node.identifier.element as ParameterElementImpl;
+    ParameterElementImpl element38 = node.identifier.element as ParameterElementImpl;
     FunctionTypeImpl type = new FunctionTypeImpl.con1((null as ExecutableElement));
     setTypeInformation(type, node.returnType, getElements(node.parameters));
-    element34.type = type;
+    element38.type = type;
     return null;
   }
   Object visitMethodDeclaration(MethodDeclaration node) {
     super.visitMethodDeclaration(node);
-    ExecutableElementImpl element35 = node.element as ExecutableElementImpl;
-    FunctionTypeImpl type = new FunctionTypeImpl.con1(element35);
-    setTypeInformation(type, node.returnType, element35.parameters);
-    element35.type = type;
-    if (element35 is PropertyAccessorElementImpl) {
-      PropertyAccessorElementImpl accessor = element35 as PropertyAccessorElementImpl;
+    ExecutableElementImpl element39 = node.element as ExecutableElementImpl;
+    FunctionTypeImpl type = new FunctionTypeImpl.con1(element39);
+    setTypeInformation(type, node.returnType, element39.parameters);
+    element39.type = type;
+    if (element39 is PropertyAccessorElementImpl) {
+      PropertyAccessorElementImpl accessor = element39 as PropertyAccessorElementImpl;
       PropertyInducingElementImpl variable5 = accessor.variable as PropertyInducingElementImpl;
       if (accessor.isGetter()) {
         variable5.type = type.returnType;
       } else if (variable5.type == null) {
         List<Type2> parameterTypes = type.normalParameterTypes;
         if (parameterTypes != null && parameterTypes.length > 0) {
           variable5.type = parameterTypes[0];
         }
       }
     }
     return null;
   }
   Object visitSimpleFormalParameter(SimpleFormalParameter node) {
     super.visitSimpleFormalParameter(node);
     Type2 declaredType;
     TypeName typeName = node.type;
     if (typeName == null) {
       declaredType = _dynamicType;
     } else {
       declaredType = getType4(typeName);
     }
-    Element element36 = node.identifier.element;
-    if (element36 is ParameterElement) {
-      ((element36 as ParameterElementImpl)).type = declaredType;
+    Element element40 = node.identifier.element;
+    if (element40 is ParameterElement) {
+      ((element40 as ParameterElementImpl)).type = declaredType;
     } else {
     }
     return null;
   }
   Object visitTypeName(TypeName node) {
     super.visitTypeName(node);
     Identifier typeName = node.name;
     TypeArgumentList argumentList = node.typeArguments;
     Element element = nameScope.lookup(typeName, definingLibrary);
     if (element == null) {
@@ skipping 102 matching lines @@
   }
   Object visitVariableDeclaration(VariableDeclaration node) {
     super.visitVariableDeclaration(node);
     Type2 declaredType;
     TypeName typeName = ((node.parent as VariableDeclarationList)).type;
     if (typeName == null) {
       declaredType = _dynamicType;
     } else {
       declaredType = getType4(typeName);
     }
-    Element element37 = node.name.element;
-    if (element37 is VariableElement) {
-      ((element37 as VariableElementImpl)).type = declaredType;
-      if (element37 is FieldElement) {
-        FieldElement field = element37 as FieldElement;
+    Element element41 = node.name.element;
+    if (element41 is VariableElement) {
+      ((element41 as VariableElementImpl)).type = declaredType;
+      if (element41 is FieldElement) {
+        FieldElement field = element41 as FieldElement;
         PropertyAccessorElementImpl getter5 = field.getter as PropertyAccessorElementImpl;
         FunctionTypeImpl getterType = new FunctionTypeImpl.con1(getter5);
         getterType.returnType = declaredType;
         getter5.type = getterType;
         PropertyAccessorElementImpl setter4 = field.setter as PropertyAccessorElementImpl;
         if (setter4 != null) {
           FunctionTypeImpl setterType = new FunctionTypeImpl.con1(setter4);
           setterType.returnType = VoidTypeImpl.instance;
           setterType.normalParameterTypes = <Type2> [declaredType];
           setter4.type = setterType;
         }
       }
     } else {
     }
     return null;
   }
   /**
    * Return the class element that represents the class whose name was provided.
    * @param identifier the name from the declaration of a class
    * @return the class element that represents the class
    */
   ClassElementImpl getClassElement(SimpleIdentifier identifier) {
     if (identifier == null) {
       return null;
     }
-    Element element38 = identifier.element;
-    if (element38 is! ClassElementImpl) {
+    Element element42 = identifier.element;
+    if (element42 is! ClassElementImpl) {
       return null;
     }
-    return element38 as ClassElementImpl;
+    return element42 as ClassElementImpl;
   }
   /**
    * Return an array containing all of the elements associated with the parameters in the given
    * list.
    * @param parameterList the list of parameters whose elements are to be returned
    * @return the elements associated with the parameters
    */
   List<ParameterElement> getElements(FormalParameterList parameterList) {
     List<ParameterElement> elements = new List<ParameterElement>();
     for (FormalParameter parameter in parameterList.parameters) {
-      ParameterElement element39 = parameter.identifier.element as ParameterElement;
-      if (element39 != null) {
-        elements.add(element39);
+      ParameterElement element43 = parameter.identifier.element as ParameterElement;
+      if (element43 != null) {
+        elements.add(element43);
       }
     }
     return new List.from(elements);
   }
   /**
    * The number of type arguments in the given type name does not match the number of parameters in
    * the corresponding class element. Return the error code that should be used to report this
    * error.
    * @param node the type name with the wrong number of type arguments
    * @return the error code that should be used to report that the wrong number of type arguments
@@ skipping 135 matching lines @@
   List<InterfaceType> resolveTypes(NodeList<TypeName> typeNames, ErrorCode undefinedError, ErrorCode nonTypeError, ErrorCode nonInterfaceType) {
     List<InterfaceType> types = new List<InterfaceType>();
     for (TypeName typeName in typeNames) {
       InterfaceType type = resolveType(typeName, undefinedError, nonTypeError, nonInterfaceType);
       if (type != null) {
         types.add(type);
       }
     }
     return new List.from(types);
   }
-  void setElement(Identifier typeName, Element element54) {
-    if (element54 != null) {
+  void setElement(Identifier typeName, Element element60) {
+    if (element60 != null) {
       if (typeName is SimpleIdentifier) {
-        ((typeName as SimpleIdentifier)).element = element54;
+        ((typeName as SimpleIdentifier)).element = element60;
       } else if (typeName is PrefixedIdentifier) {
         PrefixedIdentifier identifier = typeName as PrefixedIdentifier;
-        identifier.identifier.element = element54;
+        identifier.identifier.element = element60;
         SimpleIdentifier prefix9 = identifier.prefix;
         Element prefixElement = nameScope.lookup(prefix9, definingLibrary);
         if (prefixElement != null) {
           prefix9.element = prefixElement;
         }
       }
     }
   }
   /**
    * Set the return type and parameter type information for the given function type based on the
@@ skipping 185 matching lines @@
    * The label element returned for scopes that can be the target of an unlabeled {@code break} or{@code continue}.
    */
   static SimpleIdentifier _EMPTY_LABEL_IDENTIFIER = new SimpleIdentifier.full(new sc.StringToken(sc.TokenType.IDENTIFIER, "", 0));
   /**
    * Initialize a newly created scope to represent the potential target of an unlabeled{@code break} or {@code continue}.
    * @param outerScope the label scope enclosing the new label scope
    * @param onSwitchStatement {@code true} if this label is associated with a {@code switch}statement
    * @param onSwitchMember {@code true} if this label is associated with a {@code switch} member
    */
   LabelScope.con1(LabelScope outerScope, bool onSwitchStatement, bool onSwitchMember) {
-    _jtd_constructor_250_impl(outerScope, onSwitchStatement, onSwitchMember);
+    _jtd_constructor_254_impl(outerScope, onSwitchStatement, onSwitchMember);
   }
-  _jtd_constructor_250_impl(LabelScope outerScope, bool onSwitchStatement, bool onSwitchMember) {
-    _jtd_constructor_251_impl(outerScope, EMPTY_LABEL, new LabelElementImpl(_EMPTY_LABEL_IDENTIFIER, onSwitchStatement, onSwitchMember));
+  _jtd_constructor_254_impl(LabelScope outerScope, bool onSwitchStatement, bool onSwitchMember) {
+    _jtd_constructor_255_impl(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(LabelScope outerScope2, String label4, LabelElement element19) {
-    _jtd_constructor_251_impl(outerScope2, label4, element19);
+  LabelScope.con2(LabelScope outerScope2, String label4, LabelElement element21) {
+    _jtd_constructor_255_impl(outerScope2, label4, element21);
   }
-  _jtd_constructor_251_impl(LabelScope outerScope2, String label4, LabelElement element19) {
+  _jtd_constructor_255_impl(LabelScope outerScope2, String label4, LabelElement element21) {
     this._outerScope = outerScope2;
     this._label = label4;
-    this._element = element19;
+    this._element = element21;
   }
   /**
    * Return the label element corresponding to the given label, or {@code 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(SimpleIdentifier targetLabel) => lookup2(targetLabel.name);
   /**
    * Return the label element corresponding to the given label, or {@code null} if the given label
@@ skipping 225 matching lines @@
     for (MapEntry<String, Element> entry in getMapEntrySet(newNames)) {
       definedNames[entry.getKey()] = entry.getValue();
     }
   }
   /**
    * Add all of the names in the given namespace to the given mapping table.
    * @param definedNames the mapping table to which the names in the given namespace are to be added
    * @param namespace the namespace containing the names to be added to this namespace
    */
   void addAll2(Map<String, Element> definedNames2, Namespace namespace) {
-    addAll(definedNames2, namespace.definedNames);
+    if (namespace != null) {
+      addAll(definedNames2, namespace.definedNames);
+    }
   }
   /**
    * Add the given element to the given mapping table if it has a publicly visible name.
    * @param definedNames the mapping table to which the public name is to be added
    * @param element the element to be added
    */
   void addIfPublic(Map<String, Element> definedNames, Element element) {
     String name19 = element.name;
     if (name19 != null && !Scope.isPrivateName(name19)) {
       definedNames[name19] = element;
@@ skipping 301 matching lines @@
   Object visitSwitchCase(SwitchCase node) {
     super.visitSwitchCase(node);
     validate(node.expression, CompileTimeErrorCode.NON_CONSTANT_CASE_EXPRESSION);
     return null;
   }
   Object visitVariableDeclaration(VariableDeclaration node) {
     super.visitVariableDeclaration(node);
     Expression initializer4 = node.initializer;
     if (initializer4 != null && node.isConst()) {
       EvaluationResultImpl result = validate(initializer4, CompileTimeErrorCode.CONST_INITIALIZED_WITH_NON_CONSTANT_VALUE);
-      VariableElementImpl element45 = node.element as VariableElementImpl;
-      element45.evaluationResult = result;
+      VariableElementImpl element49 = node.element as VariableElementImpl;
+      element49.evaluationResult = result;
     }
     return null;
   }
   /**
    * Validate that the given expression is a compile time constant. Return the value of the compile
    * time constant, or {@code null} if the expression is not a compile time constant.
    * @param expression the expression to be validated
    * @param errorCode the error code to be used if the expression is not a compile time constant
    * @return the value of the compile time constant
    */
@@ skipping 19 matching lines @@
     if (parameters15 == null) {
       return;
     }
     for (FormalParameter parameter in parameters15.parameters) {
       if (parameter is DefaultFormalParameter) {
         DefaultFormalParameter defaultParameter = parameter as DefaultFormalParameter;
         Expression defaultValue2 = defaultParameter.defaultValue;
         if (defaultValue2 != null) {
           EvaluationResultImpl result = validate(defaultValue2, CompileTimeErrorCode.NON_CONSTANT_DEFAULT_VALUE);
           if (defaultParameter.isConst()) {
-            VariableElementImpl element46 = parameter.element as VariableElementImpl;
-            element46.evaluationResult = result;
+            VariableElementImpl element50 = parameter.element as VariableElementImpl;
+            element50.evaluationResult = result;
           }
         }
       }
     }
   }
 }
 /**
  * Instances of the class {@code ErrorVerifier} traverse an AST structure looking for additional
  * errors and warnings not covered by the parser and resolver.
  * @coverage dart.engine.resolver
@@ skipping 14 matching lines @@
   /**
    * The object providing access to the types defined by the language.
    */
   TypeProvider _typeProvider;
   /**
    * This is set to <code>true</code> iff the visitor is currently visiting children nodes of a{@link ConstructorDeclaration} and the constructor is 'const'.
    * @see #visitConstructorDeclaration(ConstructorDeclaration)
    */
   bool _isEnclosingConstructorConst = false;
   /**
-   * The method or function that we are currently visiting, or {@code null} if we are not inside a
-   * method or function.
+   * This is set to <code>true</code> iff the visitor is currently visiting children nodes of a{@link CatchClause}.
+   * @see #visitCatchClause(CatchClause)
+   */
+  bool _isInCatchClause = false;
+  /**
+   * The method or function that we are currently visiting, or <code>null</code> if we are not
+   * inside a method or function.
    */
   ExecutableElement _currentFunction;
   /**
    * A list of types used by the {@link CompileTimeErrorCode#EXTENDS_DISALLOWED_CLASS} and{@link CompileTimeErrorCode#IMPLEMENTS_DISALLOWED_CLASS} error codes.
    */
   List<InterfaceType> _DISALLOWED_TYPES_TO_EXTEND_OR_IMPLEMENT;
   ErrorVerifier(ErrorReporter errorReporter, LibraryElement currentLibrary, TypeProvider typeProvider) {
     this._errorReporter = errorReporter;
     this._currentLibrary = currentLibrary;
     this._typeProvider = typeProvider;
     _isEnclosingConstructorConst = false;
+    _isInCatchClause = false;
     _dynamicType = typeProvider.dynamicType;
     _DISALLOWED_TYPES_TO_EXTEND_OR_IMPLEMENT = <InterfaceType> [typeProvider.numType, typeProvider.intType, typeProvider.doubleType, typeProvider.boolType, typeProvider.stringType];
   }
   Object visitArgumentDefinitionTest(ArgumentDefinitionTest node) {
     checkForArgumentDefinitionTestNonParameter(node);
     return super.visitArgumentDefinitionTest(node);
   }
   Object visitAssertStatement(AssertStatement node) {
     checkForNonBoolExpression(node);
     return super.visitAssertStatement(node);
   }
   Object visitAssignmentExpression(AssignmentExpression node) {
     checkForInvalidAssignment(node);
     return super.visitAssignmentExpression(node);
   }
+  Object visitCatchClause(CatchClause node) {
+    bool previousIsInCatchClause = _isInCatchClause;
+    try {
+      _isInCatchClause = true;
+      return super.visitCatchClause(node);
+    } finally {
+      _isInCatchClause = previousIsInCatchClause;
+    }
+  }
   Object visitClassDeclaration(ClassDeclaration node) {
     checkForBuiltInIdentifierAsName(node.name, CompileTimeErrorCode.BUILT_IN_IDENTIFIER_AS_TYPE_NAME);
     return super.visitClassDeclaration(node);
   }
   Object visitClassTypeAlias(ClassTypeAlias node) {
     checkForBuiltInIdentifierAsName(node.name, CompileTimeErrorCode.BUILT_IN_IDENTIFIER_AS_TYPEDEF_NAME);
     return super.visitClassTypeAlias(node);
   }
   Object visitConditionalExpression(ConditionalExpression node) {
     checkForNonBoolCondition(node.condition);
     return super.visitConditionalExpression(node);
   }
   Object visitConstructorDeclaration(ConstructorDeclaration node) {
     ExecutableElement previousFunction = _currentFunction;
     try {
       _currentFunction = node.element;
       _isEnclosingConstructorConst = node.constKeyword != null;
       checkForConstConstructorWithNonFinalField(node);
       checkForConflictingConstructorNameAndMember(node);
       return super.visitConstructorDeclaration(node);
     } finally {
       _isEnclosingConstructorConst = false;
       _currentFunction = previousFunction;
     }
   }
+  Object visitConstructorFieldInitializer(ConstructorFieldInitializer node) {
+    checkForFieldInitializedInInitializerAndDeclaration(node);
+    checkForFieldInitializedInParameterAndInitializer(node);
+    return super.visitConstructorFieldInitializer(node);
+  }
   Object visitDoStatement(DoStatement node) {
     checkForNonBoolCondition(node.condition);
     return super.visitDoStatement(node);
   }
   Object visitExtendsClause(ExtendsClause node) {
     checkForExtendsDisallowedClass(node);
     return super.visitExtendsClause(node);
   }
   Object visitFieldFormalParameter(FieldFormalParameter node) {
     checkForConstFormalParameter(node);
+    checkForFieldInitializerOutsideConstructor(node);
     return super.visitFieldFormalParameter(node);
   }
   Object visitFunctionDeclaration(FunctionDeclaration node) {
     ExecutableElement previousFunction = _currentFunction;
     try {
       _currentFunction = node.element;
       return super.visitFunctionDeclaration(node);
     } finally {
       _currentFunction = previousFunction;
     }
@@ skipping 34 matching lines @@
   }
   Object visitMethodDeclaration(MethodDeclaration node) {
     ExecutableElement previousFunction = _currentFunction;
     try {
       _currentFunction = node.element;
       return super.visitMethodDeclaration(node);
     } finally {
       _currentFunction = previousFunction;
     }
   }
+  Object visitRethrowExpression(RethrowExpression node) {
+    checkForRethrowOutsideCatch(node);
+    return super.visitRethrowExpression(node);
+  }
   Object visitReturnStatement(ReturnStatement node) {
     checkForReturnOfInvalidType(node);
     return super.visitReturnStatement(node);
   }
   Object visitSimpleFormalParameter(SimpleFormalParameter node) {
     checkForConstFormalParameter(node);
     return super.visitSimpleFormalParameter(node);
   }
   Object visitSwitchStatement(SwitchStatement node) {
     checkForCaseExpressionTypeImplementsEquals(node);
@@ skipping 16 matching lines @@
     return super.visitWhileStatement(node);
   }
   /**
    * This verifies that the passed argument definition test identifier is a parameter.
    * @param node the {@link ArgumentDefinitionTest} to evaluate
    * @return return <code>true</code> if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#ARGUMENT_DEFINITION_TEST_NON_PARAMETER
    */
   bool checkForArgumentDefinitionTestNonParameter(ArgumentDefinitionTest node) {
     SimpleIdentifier identifier14 = node.identifier;
-    Element element47 = identifier14.element;
-    if (element47 != null && element47 is! ParameterElement) {
+    Element element51 = identifier14.element;
+    if (element51 != null && element51 is! ParameterElement) {
       _errorReporter.reportError(CompileTimeErrorCode.ARGUMENT_DEFINITION_TEST_NON_PARAMETER, identifier14, [identifier14.name]);
       return true;
     }
     return false;
   }
   /**
    * This verifies that the passed identifier is not a keyword, and generates the passed error code
    * on the identifier if it is a keyword.
    * @param identifier the identifier to check to ensure that it is not a keyword
    * @param errorCode if the passed identifier is a keyword then this error code is created on the
@@ skipping 38 matching lines @@
    * This verifies that the passed switch statement does not have a case expression with the
    * operator '==' overridden.
    * @param node the switch statement to evaluate
    * @return return <code>true</code> if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#CASE_EXPRESSION_TYPE_IMPLEMENTS_EQUALS
    */
   bool checkForCaseExpressionTypeImplementsEquals(SwitchStatement node) {
     Expression expression16 = node.expression;
     Type2 type = expression16.staticType;
     if (type != null && type != _typeProvider.intType && type != _typeProvider.stringType) {
-      Element element48 = type.element;
-      if (element48 is ClassElement) {
-        ClassElement classElement = element48 as ClassElement;
+      Element element52 = type.element;
+      if (element52 is ClassElement) {
+        ClassElement classElement = element52 as ClassElement;
         MethodElement method = classElement.lookUpMethod("==", _currentLibrary);
         if (method != null && method.enclosingElement.type != _typeProvider.objectType) {
-          _errorReporter.reportError(CompileTimeErrorCode.CASE_EXPRESSION_TYPE_IMPLEMENTS_EQUALS, expression16, [element48.name]);
+          _errorReporter.reportError(CompileTimeErrorCode.CASE_EXPRESSION_TYPE_IMPLEMENTS_EQUALS, expression16, [element52.name]);
           return true;
         }
       }
     }
     return false;
   }
   bool checkForConflictingConstructorNameAndMember(ConstructorDeclaration node) {
     ConstructorElement constructorElement = node.element;
     SimpleIdentifier constructorName = node.name;
     if (constructorName != null && constructorElement != null && !constructorName.isSynthetic()) {
@@ skipping 72 matching lines @@
    * class.
    * @param node the instance creation expression to evaluate
    * @param typeName the {@link TypeName} of the {@link ConstructorName} from the{@link InstanceCreationExpression}, this is the AST node that the error is attached to
    * @param type the type being constructed with this {@link InstanceCreationExpression}
    * @return return <code>true</code> if and only if an error code is generated on the passed node
    * @see StaticWarningCode#CONST_WITH_ABSTRACT_CLASS
    * @see StaticWarningCode#NEW_WITH_ABSTRACT_CLASS
    */
   bool checkForConstOrNewWithAbstractClass(InstanceCreationExpression node, TypeName typeName, InterfaceType type) {
     if (type.element.isAbstract()) {
-      ConstructorElement element49 = node.element;
-      if (element49 != null && !element49.isFactory()) {
+      ConstructorElement element53 = node.element;
+      if (element53 != null && !element53.isFactory()) {
         if (identical(((node.keyword as sc.KeywordToken)).keyword, sc.Keyword.CONST)) {
           _errorReporter.reportError(StaticWarningCode.CONST_WITH_ABSTRACT_CLASS, typeName, []);
         } else {
           _errorReporter.reportError(StaticWarningCode.NEW_WITH_ABSTRACT_CLASS, typeName, []);
         }
         return true;
       }
     }
     return false;
   }
@@ skipping 67 matching lines @@
             }
           }
         }
         _errorReporter.reportError(errorCode, typeName, [disallowedType.name]);
         return true;
       }
     }
     return false;
   }
   /**
+   * This verifies that the passed constructor field initializer is not also a final variable that
+   * already included an initialization.
+   * @param node the constructor field initializer to test
+   * @return return <code>true</code> if and only if an error code is generated on the passed node
+   * @see CompileTimeErrorCode#FIELD_INITIALIZED_IN_INITIALIZER_AND_DECLARATION
+   */
+  bool checkForFieldInitializedInInitializerAndDeclaration(ConstructorFieldInitializer node) {
+    SimpleIdentifier identifier = node.fieldName;
+    Element element54 = identifier.element;
+    if (element54 is PropertyAccessorElement) {
+      PropertyAccessorElement propertyAccessorElement = element54 as PropertyAccessorElement;
+      PropertyInducingElement propertyInducingElement = propertyAccessorElement.variable;
+      if (propertyInducingElement.initializer != null && (propertyInducingElement.isFinal() || propertyInducingElement.isConst())) {
+        _errorReporter.reportError(CompileTimeErrorCode.FIELD_INITIALIZED_IN_INITIALIZER_AND_DECLARATION, node, []);
+        return true;
+      }
+    }
+    return false;
+  }
+  /**
+   * This verifies that the passed constructor field initializer is not also a field formal
+   * parameter in the constructor declaration.
+   * @param node the constructor field initializer to test
+   * @return return <code>true</code> if and only if an error code is generated on the passed node
+   * @see CompileTimeErrorCode#FIELD_INITIALIZED_IN_PARAMETER_AND_INITIALIZER
+   */
+  bool checkForFieldInitializedInParameterAndInitializer(ConstructorFieldInitializer node) {
+    SimpleIdentifier identifier = node.fieldName;
+    Element element55 = identifier.element;
+    ASTNode parent18 = node.parent;
+    if (element55 != null && parent18 is ConstructorDeclaration) {
+      ConstructorDeclaration constructorDeclaration = parent18 as ConstructorDeclaration;
+      NodeList<FormalParameter> formalParameters = constructorDeclaration.parameters.parameters;
+      for (FormalParameter formalParameter in formalParameters) {
+        if (formalParameter is FieldFormalParameter) {
+          FieldFormalParameter fieldFormalParameter = formalParameter as FieldFormalParameter;
+          if (fieldFormalParameter.identifier.name == element55.name) {
+            _errorReporter.reportError(CompileTimeErrorCode.FIELD_INITIALIZED_IN_PARAMETER_AND_INITIALIZER, node, []);
+            return true;
+          }
+        }
+      }
+    }
+    return false;
+  }
+  /**
+   * This verifies that the passed field formal parameter is in a constructor declaration.
+   * @param node the field formal parameter to test
+   * @return return <code>true</code> if and only if an error code is generated on the passed node
+   * @see CompileTimeErrorCode#FIELD_INITIALIZER_OUTSIDE_CONSTRUCTOR
+   */
+  bool checkForFieldInitializerOutsideConstructor(FieldFormalParameter node) {
+    ASTNode parent19 = node.parent;
+    if (parent19 != null) {
+      ASTNode grandparent = parent19.parent;
+      if (grandparent != null && grandparent is! ConstructorDeclaration && grandparent.parent is! ConstructorDeclaration) {
+        _errorReporter.reportError(CompileTimeErrorCode.FIELD_INITIALIZER_OUTSIDE_CONSTRUCTOR, node, []);
+        return true;
+      }
+    }
+    return false;
+  }
+  /**
    * This verifies that the passed implements clause does not implement classes such as 'num' or
    * 'String'.
    * @param node the implements clause to test
    * @return return <code>true</code> if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#IMPLEMENTS_DISALLOWED_CLASS
    */
   bool checkForImplementsDisallowedClass(ImplementsClause implementsClause) {
     bool result = false;
     for (TypeName type in implementsClause.interfaces) {
       result = javaBooleanOr(result, checkForExtendsOrImplementsDisallowedClass(type, CompileTimeErrorCode.IMPLEMENTS_DISALLOWED_CLASS));
@@ skipping 50 matching lines @@
     } else if (type is FunctionType) {
       FunctionType functionType = type as FunctionType;
       if (functionType.typeArguments.length == 0 && !functionType.returnType.isAssignableTo(_typeProvider.boolType)) {
         _errorReporter.reportError(StaticTypeWarningCode.NON_BOOL_EXPRESSION, expression, []);
         return true;
       }
     }
     return false;
   }
   /**
+   * This checks that the rethrow is inside of a catch clause.
+   * @param node the rethrow expression to evaluate
+   * @return <code>true</code> if and only if an error code is generated on the passed node
+   * @see CompileTimeErrorCode#RETHROW_OUTSIDE_CATCH
+   */
+  bool checkForRethrowOutsideCatch(RethrowExpression node) {
+    if (!_isInCatchClause) {
+      _errorReporter.reportError(CompileTimeErrorCode.RETHROW_OUTSIDE_CATCH, node, []);
+      return true;
+    }
+    return false;
+  }
+  /**
    * This checks that the return type matches the type of the declared return type in the enclosing
    * method or function.
    * @param node the return statement to evaluate
    * @return return <code>true</code> if and only if an error code is generated on the passed node
    * @see StaticTypeWarningCode#RETURN_OF_INVALID_TYPE
    */
   bool checkForReturnOfInvalidType(ReturnStatement node) {
     FunctionType functionType = _currentFunction == null ? null : _currentFunction.type;
     Type2 expectedReturnType = functionType == null ? null : functionType.returnType;
     Expression returnExpression = node.expression;
@@ skipping 78 matching lines @@
   ResolverErrorCode(this.__name, this.__ordinal, ErrorType type, String message) {
     this._type = type;
     this._message = message;
   }
   ErrorSeverity get errorSeverity => _type.severity;
   String get message => _message;
   ErrorType get type => _type;
   bool needsRecompilation() => true;
   String toString() => __name;
 }