Add support for requesting units from resynthesizer.

pkg/analyzer/lib/src/summary/resynthesize.dart

 // Copyright (c) 2015, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 library summary_resynthesizer;
 
 import 'dart:collection';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/element/element.dart';
@@ skipping 39 matching lines @@
    */
   final TypeProvider typeProvider;
 
   /**
    * Indicates whether the summary should be resynthesized assuming strong mode
    * semantics.
    */
   final bool strongMode;
 
   /**
+   * Map of top level elements resynthesized from summaries.  The two map

[Paul Berry, 2016/02/12 19:32:03]

s/top level elements/compilation units/

+   * keys are the first two elements of the element's location (the library
+   * URI and the compilation unit URI).
+   */
+  final Map<String, Map<String, CompilationUnitElement>> _resynthesizedUnits =
+      <String, Map<String, CompilationUnitElement>>{};
+
+  /**
    * Map of top level elements resynthesized from summaries.  The three map
    * keys are the first three elements of the element's location (the library
    * URI, the compilation unit URI, and the name of the top level declaration).
    */
   final Map<String, Map<String, Map<String, Element>>> _resynthesizedElements =
       <String, Map<String, Map<String, Element>>>{};
 
   /**
    * Map of libraries which have been resynthesized from summaries.  The map
    * key is the library URI.
@@ skipping 24 matching lines @@
   Element getElement(ElementLocation location) {
     List<String> components = location.components;
     String libraryUri = components[0];
     // Ask the parent resynthesizer.
     if (parent != null && parent._hasLibrarySummary(libraryUri)) {
       return parent.getElement(location);
     }
     // Resynthesize locally.
     if (components.length == 1) {
       return getLibraryElement(libraryUri);
+    } else if (components.length == 2) {
+      Map<String, CompilationUnitElement> libraryMap =
+          _resynthesizedUnits[libraryUri];
+      if (libraryMap == null) {
+        getLibraryElement(libraryUri);
+        libraryMap = _resynthesizedUnits[libraryUri];
+        assert(libraryMap != null);
+      }
+      String unitUri = components[1];
+      CompilationUnitElement element = libraryMap[unitUri];
+      if (element == null) {
+        throw new Exception('Unit element not found in summary: $location');
+      }
+      return element;
     } else if (components.length == 3 || components.length == 4) {
       Map<String, Map<String, Element>> libraryMap =
           _resynthesizedElements[libraryUri];
       if (libraryMap == null) {
         getLibraryElement(libraryUri);
         libraryMap = _resynthesizedElements[libraryUri];
         assert(libraryMap != null);
       }
       Map<String, Element> compilationUnitElements = libraryMap[components[1]];
       Element element;
@@ skipping 48 matching lines @@
       ];
       Source librarySource = _getSource(uri);
       for (String part in serializedUnits[0].publicNamespace.parts) {
         Source partSource = sourceFactory.resolveUri(librarySource, part);
         String partAbsUri = partSource.uri.toString();
         serializedUnits.add(_getUnlinkedSummaryOrThrow(partAbsUri));
       }
       _LibraryResynthesizer libraryResynthesizer = new _LibraryResynthesizer(
           this, serializedLibrary, serializedUnits, librarySource);
       LibraryElement library = libraryResynthesizer.buildLibrary();
-      _resynthesizedElements[uri] = libraryResynthesizer.resummarizedElements;
+      _resynthesizedUnits[uri] = libraryResynthesizer.resynthesizedUnits;
+      _resynthesizedElements[uri] = libraryResynthesizer.resynthesizedElements;
       return library;
     });
   }
 
   /**
    * Return the [LinkedLibrary] for the given [uri] or `null` if it could not
    * be found.  Caller has already checked that `parent.hasLibrarySummary(uri)`
    * returns `false`.
    */
   LinkedLibrary getLinkedSummary(String uri);
@@ skipping 510 matching lines @@
    */
   CompilationUnitElementImpl currentCompilationUnit;
 
   /**
    * The [ConstructorElementImpl] for the constructor currently being
    * resynthesized.
    */
   ConstructorElementImpl currentConstructor;
 
   /**
+   * Map of compilation unit elements that have been resynthesized so far.  The
+   * key is the URI of the compilation unit.
+   */
+  final Map<String, CompilationUnitElement> resynthesizedUnits =
+      <String, CompilationUnitElement>{};
+
+  /**
    * Map of top level elements that have been resynthesized so far.  The first
    * key is the URI of the compilation unit; the second is the name of the top
    * level element.
    */
-  final Map<String, Map<String, Element>> resummarizedElements =
+  final Map<String, Map<String, Element>> resynthesizedElements =
       <String, Map<String, Element>>{};
 
   /**
    * Type parameters for the generic class, typedef, or executable currently
    * being resynthesized, if any.  If multiple entities with type parameters
    * are nested (e.g. a generic executable inside a generic class), this is the
    * concatenation of all type parameters from all declarations currently in
    * force, with the outermost declaration appearing first.  If there are no
    * type parameters, or we are not currently resynthesizing a class, typedef,
    * or executable, then this is an empty list.
@@ skipping 1162 matching lines @@
     }
     for (FunctionTypeAliasElement typeAlias in unit.functionTypeAliases) {
       elementMap[typeAlias.name] = typeAlias;
     }
     for (FunctionElement function in unit.functions) {
       elementMap[function.name] = function;
     }
     for (PropertyAccessorElementImpl accessor in unit.accessors) {
       elementMap[accessor.identifier] = accessor;
     }
-    resummarizedElements[absoluteUri] = elementMap;
+    resynthesizedUnits[absoluteUri] = unit;
+    resynthesizedElements[absoluteUri] = elementMap;
   }
 
   /**
    * Set up data structures for deserializing a compilation unit.
    */
   void prepareUnit(CompilationUnitElementImpl unit, int unitNum) {
     linkedUnit = linkedLibrary.units[unitNum];
     unlinkedUnit = unlinkedUnits[unitNum];
     linkedTypeMap = <int, EntityRef>{};
     currentCompilationUnit = unit;
@@ skipping 216 matching lines @@
                 }
               : () => this.element;
       // TODO(paulberry): Is it a bug that we have to pass `false` for
       // isInstantiated?
       return new DeferredFunctionTypeImpl(computer, null, typeArguments, false);
     } else {
       return null;
     }
   }
 }