Include referenced declared variables and their values into the linked bundle hash.

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

 // Copyright (c) 2016, 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.
 
 import 'dart:async';
 import 'dart:collection';
 import 'dart:core';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart';
@@ skipping 15 matching lines @@
     show serializeAstUnlinked;
 import 'package:analyzer/src/summary/summarize_elements.dart'
     show PackageBundleAssembler;
 import 'package:analyzer/src/util/fast_uri.dart';
 import 'package:convert/convert.dart';
 import 'package:crypto/crypto.dart';
 import 'package:meta/meta.dart';
 import 'package:path/path.dart' as pathos;
 
 /**
+ * Return the raw string value of the variable with the given [name],
+ * or `null` of the variable is not defined.
+ */
+typedef String _GetDeclaredVariable(String name);
+
+/**
  * Unlinked and linked information about a [PubPackage].
  */
 class LinkedPubPackage {
   final PubPackage package;
   final PackageBundle unlinked;
   final PackageBundle linked;
 
   final String linkedHash;
 
   LinkedPubPackage(this.package, this.unlinked, this.linked, this.linkedHash);
@@ skipping 31 matching lines @@
  * The client should call [getLinkedBundles] after creating a new
  * [AnalysisContext] and configuring its source factory, but before computing
  * any analysis results.  The returned linked bundles can be used to create and
  * configure [ResynthesizerResultProvider] for the context.
  */
 class PubSummaryManager {
   static const UNLINKED_NAME = 'unlinked.ds';
   static const UNLINKED_SPEC_NAME = 'unlinked_spec.ds';
 
   /**
+   * If `true` (by default), then linking new bundles is allowed.
+   * Otherwise only using existing cached bundles can be used.
+   */
+  final bool allowLinking;
+
+  /**
    * See [PackageBundleAssembler.currentMajorVersion].
    */
   final int majorVersion;
 
   final ResourceProvider resourceProvider;
 
   /**
    * The name of the temporary file that is used for atomic writes.
    */
   final String tempFileName;
@@ skipping 22 matching lines @@
    */
   final Set<PubPackage> seenPackages = new Set<PubPackage>();
 
   /**
    * The [Completer] that completes when computing of all scheduled unlinked
    * bundles is complete.
    */
   Completer _onUnlinkedCompleteCompleter;
 
   PubSummaryManager(this.resourceProvider, this.tempFileName,
-      {@visibleForTesting this.majorVersion:
+      {@visibleForTesting this.allowLinking: true,
+      @visibleForTesting this.majorVersion:
           PackageBundleAssembler.currentMajorVersion});
 
   /**
    * The [Future] that completes when computing of all scheduled unlinked
    * bundles is complete.
    */
   Future get onUnlinkedComplete {
     if (packagesToComputeUnlinked.isEmpty) {
       return new Future.value();
     }
@@ skipping 49 matching lines @@
     // If no unlinked bundles, there is nothing we can try to link.
     if (unlinkedBundles.isEmpty) {
       return const <LinkedPubPackage>[];
     }
 
     // Create graph nodes for packages.
     List<_LinkedNode> nodes = <_LinkedNode>[];
     Map<String, _LinkedNode> packageToNode = <String, _LinkedNode>{};
     unlinkedBundles.forEach((package, unlinked) {
       _LinkedNode node = new _LinkedNode(
-          sdkBundle, listedPackages, package, unlinked, packageToNode);
+          sdkBundle,
+          context.declaredVariables.get,
+          listedPackages,
+          package,
+          unlinked,
+          packageToNode);
       nodes.add(node);
       packageToNode[package.name] = node;
     });
 
     // Compute transitive dependencies, mark some nodes as failed.
     for (_LinkedNode node in nodes) {
       node.computeTransitiveDependencies();
     }
 
     // Attempt to read existing linked bundles.
     for (_LinkedNode node in nodes) {
       _readLinked(node, strong);
     }
 
-    // Fill the store with bundles.
-    // Append the linked SDK bundle.
-    // Append unlinked and (if read from a cache) linked package bundles.
-    SummaryDataStore store = new SummaryDataStore(const <String>[]);
-    store.addBundle(null, sdkBundle);
-    for (_LinkedNode node in nodes) {
-      store.addBundle(null, node.unlinked);
-      if (node.linked != null) {
-        store.addBundle(null, node.linked);
+    // Link new bundles, if allowed.
+    if (allowLinking) {
+      // Fill the store with bundles.
+      // Append the linked SDK bundle.
+      // Append unlinked and (if read from a cache) linked package bundles.
+      SummaryDataStore store = new SummaryDataStore(const <String>[]);
+      store.addBundle(null, sdkBundle);
+      for (_LinkedNode node in nodes) {
+        store.addBundle(null, node.unlinked);
+        if (node.linked != null) {
+          store.addBundle(null, node.linked);
+        }
+      }
+
+      // Link each package node.
+      for (_LinkedNode node in nodes) {
+        if (!node.isEvaluated) {
+          new _LinkedWalker(listedPackages, store, strong).walk(node);
+        }
+      }
+
+      // Write newly linked bundles.
+      for (_LinkedNode node in nodes) {
+        _writeLinked(node, strong);
       }
     }
 
-    // Link each package node.
-    for (_LinkedNode node in nodes) {
-      if (!node.isEvaluated) {
-        new _LinkedWalker(listedPackages, store, strong).walk(node);
-      }
-    }
-
-    // Write newly linked bundles.
-    for (_LinkedNode node in nodes) {
-      _writeLinked(node, strong);
-    }
-
     // Create successfully linked packages.
     List<LinkedPubPackage> linkedPackages = <LinkedPubPackage>[];
     for (_LinkedNode node in nodes) {
       if (node.linked != null) {
         linkedPackages.add(new LinkedPubPackage(
-            node.package, node.unlinked, node.linked, node._linkedHash));
+            node.package, node.unlinked, node.linked, node.linkedHash));
       }
     }
 
     // TODO(scheglov) remove debug output after optimizing
 //    print('LINKED ${linkedPackages.length} bundles'
 //        ' in ${timer.elapsedMilliseconds} ms');
 
     // Done.
     return linkedPackages;
   }
@@ skipping 343 matching lines @@
     }
     return false;
   }
 }
 
 /**
  * Specialization of [Node] for linking packages in proper dependency order.
  */
 class _LinkedNode extends Node<_LinkedNode> {
   final PackageBundle sdkBundle;
+  final _GetDeclaredVariable getDeclaredVariable;
   final _ListedPackages listedPackages;
   final PubPackage package;
   final PackageBundle unlinked;
   final Map<String, _LinkedNode> packageToNode;
 
   bool failed = false;
   Set<_LinkedNode> transitiveDependencies;
   String _linkedHash;
 
   List<int> linkedNewBytes;
   PackageBundle linked;
 
-  _LinkedNode(this.sdkBundle, this.listedPackages, this.package, this.unlinked,
-      this.packageToNode);
+  _LinkedNode(this.sdkBundle, this.getDeclaredVariable, this.listedPackages,
+      this.package, this.unlinked, this.packageToNode);
 
   @override
   bool get isEvaluated => linked != null || failed;
 
   /**
    * Return the hash string that corresponds to this linked bundle in the
-   * context of its [sdkBundles] and transitive dependencies.  Return `null` if
+   * context of its [sdkBundle] and transitive dependencies.  Return `null` if
    * the hash computation fails, because for example the full transitive
    * dependencies cannot computed.
    */
   String get linkedHash {
     if (_linkedHash == null && transitiveDependencies != null) {
-      // Collect all unlinked API signatures.
+      ApiSignature signature = new ApiSignature();
+      // Add all unlinked API signatures.
       List<String> signatures = <String>[];
       signatures.add(sdkBundle.apiSignature);
       transitiveDependencies
           .map((node) => node.unlinked.apiSignature)
           .forEach(signatures.add);
       signatures.sort();
-      // Combine sorted unlinked API signatures into a single hash.
-      ApiSignature signature = new ApiSignature();
       signatures.forEach(signature.addString);
+      // Combine into a single hash.
+      _appendDeclaredVariables(signature);
       _linkedHash = signature.toHex();
     }
     return _linkedHash;
   }
 
   @override
   List<_LinkedNode> computeDependencies() {
     Set<_LinkedNode> dependencies = new Set<_LinkedNode>();
 
     void appendDependency(String uriStr) {
@@ skipping 49 matching lines @@
 
       appendDependencies(this);
       if (transitiveDependencies.any((node) => node.failed)) {
         failed = true;
       }
     }
   }
 
   @override
   String toString() => package.toString();
+
+  /**
+   * Append names and values of all referenced declared variables (even the
+   * ones without actually declared values) to the given [signature].
+   */
+  void _appendDeclaredVariables(ApiSignature signature) {
+    Set<String> names = new Set<String>();
+    for (_LinkedNode node in transitiveDependencies) {
+      for (UnlinkedUnit unit in node.unlinked.unlinkedUnits) {
+        for (UnlinkedImport import in unit.imports) {
+          for (UnlinkedConfiguration configuration in import.configurations) {
+            names.add(configuration.name);
+          }
+        }
+        for (UnlinkedExportPublic export in unit.publicNamespace.exports) {
+          for (UnlinkedConfiguration configuration in export.configurations) {
+            names.add(configuration.name);
+          }
+        }
+      }
+    }
+    for (String name in names) {

[Paul Berry, 2016/09/21 19:47:22]

Before the for loop, add:

signature.addInt(names.length);

(Otherwise there's a small risk of hash collisions).

Also, can we sort the names before adding them to the signature?  That would
reduce the risk of an unnecessary mismatch if the set iteration order changes.

[scheglov, 2016/09/21 20:34:49]

Done.

+      signature.addString(name);
+      signature.addString(getDeclaredVariable(name) ?? '');
+    }
+  }
 }
 
 /**
  * Specialization of [DependencyWalker] for linking packages.
  */
 class _LinkedWalker extends DependencyWalker<_LinkedNode> {
   final _ListedPackages listedPackages;
   final SummaryDataStore store;
   final bool strong;
 
@@ skipping 56 matching lines @@
   }
 
   /**
    * Check whether the given `package:` [uri] is listed in the package map.
    */
   bool isListed(String uri) {
     String package = PubSummaryManager.getPackageName(uri);
     return names.contains(package);
   }
 }