Add the ability to resynthesize class members from summaries.

pkg/analyzer/test/src/summary/resynthesize_test.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 test.src.serialization.elements_test;
 
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
 import 'package:analyzer/src/dart/element/element.dart';
 import 'package:analyzer/src/dart/element/type.dart';
@@ skipping 29 matching lines @@
     otherLibrarySources.add(analysisContext2.sourceFactory.forUri(uri));
   }
 
   void addLibrarySource(String filePath, String contents) {
     otherLibrarySources.add(addNamedSource(filePath, contents));
   }
 
   void checkLibrary(String text, {bool allowErrors: false}) {
     Source source = addSource(text);
     LibraryElementImpl original = resolve2(source);
-    LibraryElementImpl resynthesized =
-        resynthesizeLibrary(source, original, allowErrors);
+    LibraryElementImpl resynthesized = resynthesizeLibraryElement(
+        encodeLibrary(original, allowErrors: allowErrors),
+        source.uri.toString());
     checkLibraryElements(original, resynthesized);
   }
 
   void checkLibraryElements(
       LibraryElementImpl original, LibraryElementImpl resynthesized) {
     compareElements(resynthesized, original, '(library)');
     expect(resynthesized.displayName, original.displayName);
     expect(original.enclosingElement, isNull);
     expect(resynthesized.enclosingElement, isNull);
     expect(resynthesized.hasExtUri, original.hasExtUri);
@@ skipping 442 matching lines @@
     expect(resynthesized.uriEnd, original.uriEnd, reason: desc);
   }
 
   void compareVariableElements(VariableElementImpl resynthesized,
       VariableElementImpl original, String desc) {
     compareElements(resynthesized, original, desc);
     compareTypes(resynthesized.type, original.type, desc);
     // TODO(paulberry): test initializer
   }
 
-  fail_library_hasExtUri() {
-    checkLibrary('import "dart-ext:doesNotExist.dart";');
+  /**
+   * Serialize the given [library] into a summary.  Then create a
+   * [_TestSummaryResynthesizer] which can deserialize it, along with any
+   * references it makes to `dart:core`.
+   *
+   * Errors will lead to a test failure unless [allowErrors] is `true`.
+   */
+  _TestSummaryResynthesizer encodeLibrary(LibraryElementImpl library,
+      {bool allowErrors: false}) {
+    if (!allowErrors) {
+      assertNoErrors(library.source);
+    }
+    addLibrary('dart:core');
+    return encodeLibraryElement(library);
   }
 
-  ElementImpl getActualElement(Element element, String desc) {
-    if (element is ElementHandle) {
-      return element.actualElement;
-    } else if (element is ElementImpl) {
-      return element;
-    } else {
-      fail('Unexpected type for resynthesized ($desc):'
-          ' ${element.runtimeType}');
-      return null;
-    }
-  }
-
-  LibraryElementImpl resynthesizeLibrary(
-      Source source, LibraryElementImpl original, bool allowErrors) {
-    if (!allowErrors) {
-      assertNoErrors(source);
-    }
-    String uri = source.uri.toString();
-    addLibrary('dart:core');
-    return resynthesizeLibraryElement(uri, original);
-  }
-
-  LibraryElementImpl resynthesizeLibraryElement(
-      String uri, LibraryElementImpl original) {
+  /**
+   * Convert the library element [library] into a summary, and then create a
+   * [_TestSummaryResynthesizer] which can deserialize it.
+   *
+   * Caller is responsible for checking the library for errors, and adding any
+   * dependent libraries using [addLibrary].
+   */
+  _TestSummaryResynthesizer encodeLibraryElement(LibraryElementImpl library) {
     Map<String, UnlinkedUnit> unlinkedSummaries = <String, UnlinkedUnit>{};
     LinkedLibrary getLinkedSummaryFor(LibraryElement lib) {
       LibrarySerializationResult serialized = serializeLibrary(
           lib, typeProvider, analysisContext.analysisOptions.strongMode);
       for (int i = 0; i < serialized.unlinkedUnits.length; i++) {
         unlinkedSummaries[serialized.unitUris[i]] =
             new UnlinkedUnit.fromBuffer(serialized.unlinkedUnits[i].toBuffer());
       }
       return new LinkedLibrary.fromBuffer(serialized.linked.toBuffer());
     }
     Map<String, LinkedLibrary> linkedSummaries = <String, LinkedLibrary>{
-      uri: getLinkedSummaryFor(original)
+      library.source.uri.toString(): getLinkedSummaryFor(library)
     };
     for (Source source in otherLibrarySources) {
       LibraryElement original = resolve2(source);
       String uri = source.uri.toString();
       linkedSummaries[uri] = getLinkedSummaryFor(original);
     }
-    _TestSummaryResynthesizer resynthesizer = new _TestSummaryResynthesizer(
+    return new _TestSummaryResynthesizer(
         null,
         analysisContext,
         analysisContext.typeProvider,
         analysisContext.sourceFactory,
         unlinkedSummaries,
         linkedSummaries,
         options.strongMode);
+  }
+
+  fail_library_hasExtUri() {
+    checkLibrary('import "dart-ext:doesNotExist.dart";');
+  }
+
+  ElementImpl getActualElement(Element element, String desc) {
+    if (element is ElementHandle) {
+      return element.actualElement;
+    } else if (element is ElementImpl) {
+      return element;
+    } else {
+      fail('Unexpected type for resynthesized ($desc):'
+          ' ${element.runtimeType}');
+      return null;
+    }
+  }
+
+  /**
+   * Resynthesize the library element associated with [uri] using
+   * [resynthesizer], and verify that it only had to consult one summary in
+   * order to do so.
+   */
+  LibraryElementImpl resynthesizeLibraryElement(
+      _TestSummaryResynthesizer resynthesizer, String uri) {
     LibraryElementImpl resynthesized = resynthesizer.getLibraryElement(uri);
     // Check that no other summaries needed to be resynthesized to resynthesize
     // the library element.
     expect(resynthesizer.resynthesisCount, 1);
     return resynthesized;
   }
 
   @override
   void setUp() {
     super.setUp();
@@ skipping 320 matching lines @@
    */
   C();
 }''');
   }
 
   test_core() {
     String uri = 'dart:core';
     LibraryElementImpl original =
         resolve2(analysisContext2.sourceFactory.forUri(uri));
     LibraryElementImpl resynthesized =
-        resynthesizeLibraryElement(uri, original);
+        resynthesizeLibraryElement(encodeLibraryElement(original), uri);
     checkLibraryElements(original, resynthesized);
   }
 
   test_enum_documented() {
     checkLibrary('''
 // Extra comment so doc comment offset != 0
 /**
  * Docs
  */
 enum E { v }''');
@@ skipping 241 matching lines @@
 
   test_function_type_parameter_with_function_typed_parameter() {
     resetWithOptions(new AnalysisOptionsImpl()..enableGenericMethods = true);
     checkLibrary('void f<T, U>(T x(U u)) {}');
   }
 
   test_functions() {
     checkLibrary('f() {} g() {}');
   }
 
+  test_getElement_constructor_named() {
+    ConstructorElement original = resolve2(addSource('class C { C.named(); }'))
+        .getType('C')
+        .getNamedConstructor('named');
+    expect(original, isNotNull);
+    ConstructorElement resynthesized = validateGetElement(original);
+    compareConstructorElements(resynthesized, original, 'C.constructor named');
+  }
+
+  test_getElement_constructor_unnamed() {
+    ConstructorElement original =
+        resolve2(addSource('class C { C(); }')).getType('C').unnamedConstructor;
+    expect(original, isNotNull);
+    ConstructorElement resynthesized = validateGetElement(original);
+    compareConstructorElements(resynthesized, original, 'C.constructor');
+  }
+
+  test_getElement_field() {
+    FieldElement original =
+        resolve2(addSource('class C { var f; }')).getType('C').getField('f');
+    expect(original, isNotNull);
+    FieldElement resynthesized = validateGetElement(original);
+    compareFieldElements(resynthesized, original, 'C.field f');
+  }
+
+  test_getElement_getter() {
+    PropertyAccessorElement original =
+        resolve2(addSource('class C { get f => null; }'))
+            .getType('C')
+            .getGetter('f');
+    expect(original, isNotNull);
+    PropertyAccessorElement resynthesized = validateGetElement(original);
+    comparePropertyAccessorElements(resynthesized, original, 'C.getter f');
+  }
+
+  test_getElement_method() {
+    MethodElement original =
+        resolve2(addSource('class C { f() {} }')).getType('C').getMethod('f');
+    expect(original, isNotNull);
+    MethodElement resynthesized = validateGetElement(original);
+    compareMethodElements(resynthesized, original, 'C.method f');
+  }
+
+  test_getElement_operator() {
+    MethodElement original =
+        resolve2(addSource('class C { operator+(x) => null; }'))
+            .getType('C')
+            .getMethod('+');
+    expect(original, isNotNull);
+    MethodElement resynthesized = validateGetElement(original);
+    compareMethodElements(resynthesized, original, 'C.operator+');
+  }
+
+  test_getElement_setter() {
+    PropertyAccessorElement original =
+        resolve2(addSource('class C { void set f(value) {} }'))
+            .getType('C')
+            .getSetter('f');
+    expect(original, isNotNull);
+    PropertyAccessorElement resynthesized = validateGetElement(original);
+    comparePropertyAccessorElements(resynthesized, original, 'C.setter f');
+  }
+
   test_getter_documented() {
     checkLibrary('''
 // Extra comment so doc comment offset != 0
 /**
  * Docs
  */
 get x => null;''');
   }
 
   test_getter_external() {
@@ skipping 532 matching lines @@
 
   test_variable_setterInPart_getterInPart() {
     addNamedSource('/a.dart', 'part of my.lib; void set x(int _) {}');
     addNamedSource('/b.dart', 'part of my.lib; int get x => 42;');
     checkLibrary('library my.lib; part "a.dart"; part "b.dart";');
   }
 
   test_variables() {
     checkLibrary('int i; int j;');
   }
+
+  /**
+   * Encode the library containing [original] into a summary and then use
+   * [_TestSummaryResynthesizer.getElement] to retrieve just the original
+   * element from the resynthesized summary.
+   */
+  Element validateGetElement(Element original) {
+    _TestSummaryResynthesizer resynthesizer = encodeLibrary(original.library);
+    ElementLocationImpl location = original.location;
+    Element result = resynthesizer.getElement(location);
+    // Check that no other summaries needed to be resynthesized to resynthesize
+    // the library element.
+    expect(resynthesizer.resynthesisCount, 1);
+    expect(result.location, location);
+    return result;
+  }
 }
 
 class _TestSummaryResynthesizer extends SummaryResynthesizer {
   final Map<String, UnlinkedUnit> unlinkedSummaries;
   final Map<String, LinkedLibrary> linkedSummaries;
 
   _TestSummaryResynthesizer(
       SummaryResynthesizer parent,
       AnalysisContext context,
       TypeProvider typeProvider,
@@ skipping 19 matching lines @@
       fail('Unexpectedly tried to get unlinked summary for $uri');
     }
     return serializedUnit;
   }
 
   @override
   bool hasLibrarySummary(String uri) {
     return true;
   }
 }