Make API signature based only on unlinked data.

pkg/analyzer/lib/src/summary/summarize_elements.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 serialization.elements;
 
 import 'dart:convert';
 
 import 'package:analyzer/dart/ast/ast.dart';
 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/member.dart';
 import 'package:analyzer/src/dart/element/type.dart';
-import 'package:analyzer/src/generated/java_engine.dart';
 import 'package:analyzer/src/generated/resolver.dart';
 import 'package:analyzer/src/generated/source.dart';
 import 'package:analyzer/src/generated/utilities_dart.dart';
 import 'package:analyzer/src/summary/api_signature.dart';
 import 'package:analyzer/src/summary/format.dart';
 import 'package:analyzer/src/summary/idl.dart';
 import 'package:analyzer/src/summary/name_filter.dart';
+import 'package:analyzer/src/summary/package_bundle_reader.dart';
 import 'package:analyzer/src/summary/summarize_const_expr.dart';
 import 'package:convert/convert.dart';
 import 'package:crypto/crypto.dart';
 import 'package:path/path.dart' as path;
-import 'package:analyzer/src/summary/package_bundle_reader.dart';
 
 /**
  * Serialize all the elements in [lib] to a summary using [ctx] as the context
  * for building the summary, and using [typeProvider] to find built-in types.
  */
 LibrarySerializationResult serializeLibrary(
     LibraryElement lib, TypeProvider typeProvider, bool strongMode) {
   _LibrarySerializer serializer =
       new _LibrarySerializer(lib, typeProvider, strongMode);
   LinkedLibraryBuilder linked = serializer.serializeLibrary();
@@ skipping 95 matching lines @@
    * format that clients might need to be aware of (such as adding a kind of
    * data that was previously not summarized), this value should be incremented
    * by 1.
    */
   static const int currentMinorVersion = 0;
 
   final List<String> _linkedLibraryUris = <String>[];
   final List<LinkedLibraryBuilder> _linkedLibraries = <LinkedLibraryBuilder>[];
   final List<String> _unlinkedUnitUris = <String>[];
   final List<UnlinkedUnitBuilder> _unlinkedUnits = <UnlinkedUnitBuilder>[];
+  final Map<String, UnlinkedUnitBuilder> _unlinkedUnitMap =
+      <String, UnlinkedUnitBuilder>{};
   final List<String> _unlinkedUnitHashes;
   final List<PackageDependencyInfoBuilder> _dependencies =
       <PackageDependencyInfoBuilder>[];
   final bool _excludeHashes;
 
   /**
    * Create a [PackageBundleAssembler].  If [excludeHashes] is `true`, hash
    * computation will be skipped.
    */
   PackageBundleAssembler({bool excludeHashes: false})
       : _excludeHashes = excludeHashes,
         _unlinkedUnitHashes = excludeHashes ? null : <String>[];
 
   /**
    * Add a fallback library to the package bundle, corresponding to the library
    * whose defining compilation unit is located at [source].  Caller must also
    * call [addFallbackUnit] for all compilation units contained in the library
    * (including the defining compilation unit).
    */
   void addFallbackLibrary(Source source) {
     String uri = source.uri.toString();
     _linkedLibraryUris.add(uri);
     _linkedLibraries.add(new LinkedLibraryBuilder(fallbackMode: true));
   }
 
   /**
-   * Use the dependency information in [summaryDataStore] to populate the
-   * dependencies in the package bundle being assembled.
-   */
-  void recordDependencies(SummaryDataStore summaryDataStore) {
-    _dependencies.addAll(summaryDataStore.dependencies);
-  }
-
-  /**
    * Add a fallback compilation unit to the package bundle, corresponding to
    * the compilation unit located at [source].
    */
   void addFallbackUnit(Source source) {
     String uri = source.uri.toString();
+    UnlinkedUnitBuilder unit = new UnlinkedUnitBuilder(
+        fallbackModePath: path.relative(source.fullName));
     _unlinkedUnitUris.add(uri);
-    _unlinkedUnits.add(new UnlinkedUnitBuilder(
-        fallbackModePath: path.relative(source.fullName)));
+    _unlinkedUnits.add(unit);
+    _unlinkedUnitMap[uri] = unit;
   }
 
   void addLinkedLibrary(String uri, LinkedLibraryBuilder library) {
     _linkedLibraries.add(library);
     _linkedLibraryUris.add(uri);
   }
 
   void addUnlinkedUnit(Source source, UnlinkedUnitBuilder unit) {
     addUnlinkedUnitWithHash(source.uri.toString(), unit,
         _excludeHashes ? null : _hash(source.contents.data));
   }
 
   void addUnlinkedUnitWithHash(
       String uri, UnlinkedUnitBuilder unit, String hash) {
     _unlinkedUnitUris.add(uri);
     _unlinkedUnits.add(unit);
+    _unlinkedUnitMap[uri] = unit;
     _unlinkedUnitHashes?.add(hash);
   }
 
   /**
    * Assemble a new [PackageBundleBuilder] using the gathered information.
    */
   PackageBundleBuilder assemble() {
-    PackageBundleBuilder packageBundle = new PackageBundleBuilder(
+    return new PackageBundleBuilder(
         linkedLibraryUris: _linkedLibraryUris,
         linkedLibraries: _linkedLibraries,
         unlinkedUnitUris: _unlinkedUnitUris,
         unlinkedUnits: _unlinkedUnits,
         unlinkedUnitHashes: _unlinkedUnitHashes,
         majorVersion: currentMajorVersion,
         minorVersion: currentMinorVersion,
-        dependencies: _dependencies);
-    ApiSignature apiSignature = new ApiSignature();
-    packageBundle.collectApiSignature(apiSignature);
-    packageBundle.apiSignature = apiSignature.toHex();
-    return packageBundle;
+        dependencies: _dependencies,
+        apiSignature: _computeApiSignature());
   }
 
   /**
+   * Use the dependency information in [summaryDataStore] to populate the
+   * dependencies in the package bundle being assembled.
+   */
+  void recordDependencies(SummaryDataStore summaryDataStore) {
+    _dependencies.addAll(summaryDataStore.dependencies);
+  }
+
+  /**
    * Serialize the library with the given [element].
    */
   void serializeLibraryElement(LibraryElement element) {
     String uri = element.source.uri.toString();
     LibrarySerializationResult libraryResult = serializeLibrary(
         element,
         element.context.typeProvider,
         element.context.analysisOptions.strongMode);
     _linkedLibraryUris.add(uri);
     _linkedLibraries.add(libraryResult.linked);
     _unlinkedUnitUris.addAll(libraryResult.unitUris);
     _unlinkedUnits.addAll(libraryResult.unlinkedUnits);
+    for (int i = 0; i < libraryResult.unitUris.length; i++) {
+      _unlinkedUnitMap[libraryResult.unitUris[i]] =
+          libraryResult.unlinkedUnits[i];
+    }
     for (Source source in libraryResult.unitSources) {
       _unlinkedUnitHashes?.add(_hash(source.contents.data));
     }
   }
 
   /**
+   * Compute the API signature for this package bundle.
+   */
+  String _computeApiSignature() {
+    ApiSignature apiSignature = new ApiSignature();
+    for (String unitUri in _unlinkedUnitUris.toList()..sort()) {

[scheglov, 2016/08/09 17:12:36]

It's probably equivalent, but if we ask values from _unlinkedUnitMap, maybe we
should get keys also from it.

[Paul Berry, 2016/08/09 17:18:02]

Done.

+      apiSignature.addString(unitUri);
+      _unlinkedUnitMap[unitUri].collectApiSignature(apiSignature);
+    }
+    return apiSignature.toHex();
+  }
+
+  /**
    * Compute a hash of the given file contents.
    */
   String _hash(String contents) {
     return hex.encode(md5.convert(UTF8.encode(contents)).bytes);
   }
 }
 
 /**
  * Instances of this class keep track of intermediate state during
  * serialization of a single compilation unit.
@@ skipping 1443 matching lines @@
       exportNames.add(new LinkedExportNameBuilder(
           name: name,
           dependency: serializeDependency(dependentLibrary),
           unit: unit,
           kind: kind));
     }
     pb.exportNames = exportNames;
     return pb;
   }
 }