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

pkg/analyzer/test/src/summary/pub_summary_test.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 'package:analyzer/file_system/file_system.dart';
 import 'package:analyzer/source/package_map_resolver.dart';
 import 'package:analyzer/src/generated/source.dart';
 import 'package:analyzer/src/summary/format.dart';
 import 'package:analyzer/src/summary/idl.dart';
 import 'package:analyzer/src/summary/pub_summary.dart';
@@ skipping 156 matching lines @@
       // Verify that new files with linked bundles were created.
       LinkedPubPackage packageA = _getLinkedPackage(linkedPackages, 'aaa');
       LinkedPubPackage packageB = _getLinkedPackage(linkedPackages, 'bbb');
       expect(packageA.linkedHash, isNot(linkedHashA));
       expect(packageB.linkedHash, isNot(linkedHashB));
       _assertFileExists(folderA2, 'linked_spec_${packageA.linkedHash}.ds');
       _assertFileExists(folderB, 'linked_spec_${packageB.linkedHash}.ds');
     }
   }
 
+  test_getLinkedBundles_cached_declaredVariables_export() async {
+    _testImpl_getLinkedBundles_cached_declaredVariables('export');
+  }
+
+  test_getLinkedBundles_cached_declaredVariables_import() async {
+    _testImpl_getLinkedBundles_cached_declaredVariables('import');
+  }
+
   test_getLinkedBundles_cached_differentSdk() async {
     String pathA = '$CACHE/aaa';
     resourceProvider.newFile(
         '$pathA/lib/a.dart',
         '''
 class A {}
 int a;
 ''');
     resourceProvider.newFile(
         '$CACHE/bbb/lib/b.dart',
@@ skipping 1064 matching lines @@
             }
           }
           fail('Cannot find linked unit for $variableName in $linkedPackage');
         }
       }
     }
     fail('Cannot find variable $variableName in $linkedPackage');
   }
 
   void _createManager(
-      {int majorVersion: PackageBundleAssembler.currentMajorVersion}) {
+      {bool allowLinking: true,
+      int majorVersion: PackageBundleAssembler.currentMajorVersion}) {
     manager = new PubSummaryManager(resourceProvider, '_.temp',
-        majorVersion: majorVersion);
+        allowLinking: allowLinking, majorVersion: majorVersion);
   }
 
   LinkedPubPackage _getLinkedPackage(
       List<LinkedPubPackage> packages, String name) {
     return packages
         .singleWhere((linkedPackage) => linkedPackage.package.name == name);
   }
 
+  _testImpl_getLinkedBundles_cached_declaredVariables(
+      String importOrExport) async {
+    String pathA = '$CACHE/aaa/lib';
+    resourceProvider.newFile('$pathA/foo.dart', 'class A {}');
+    resourceProvider.newFile('$pathA/foo_io.dart', 'class A {}');
+    resourceProvider.newFile('$pathA/foo_html.dart', 'class A {}');
+    resourceProvider.newFile(
+        '$pathA/user.dart',
+        '''
+$importOrExport 'foo.dart'
+  if (dart.library.io) 'foo_io.dart'
+  if (dart.library.html) 'foo_html.dart';
+''');
+    // Configure packages resolution.
+    Folder libFolderA = resourceProvider.newFolder(pathA);
+    context.sourceFactory = new SourceFactory(<UriResolver>[
+      sdkResolver,
+      resourceResolver,
+      new PackageMapUriResolver(resourceProvider, {
+        'aaa': [libFolderA],
+      })
+    ]);
+
+    // Session 1.
+    // Create the linked bundle and cache it in a file.
+    {
+      // Ensure unlinked bundles.
+      manager.getUnlinkedBundles(context);
+      await manager.onUnlinkedComplete;
+
+      // Now we should be able to get the linked bundle.
+      List<LinkedPubPackage> linkedPackages = manager.getLinkedBundles(context);
+      expect(linkedPackages, hasLength(1));
+    }
+
+    // Session 2.
+    // Recreate manager and don't allow it to perform new linking.
+    // Set a declared variable, which is not used in the package.
+    // We still can get the cached linked bundle.
+    {
+      context.declaredVariables.define('not.used.variable', 'baz');
+      _createManager(allowLinking: false);
+      List<LinkedPubPackage> linkedPackages = manager.getLinkedBundles(context);
+      expect(linkedPackages, hasLength(1));
+    }
+
+    // Session 3.
+    // Recreate manager and don't allow it to perform new linking.
+    // Set the value of a referenced declared variable.
+    // So, we cannot use the previously cached linked bundle.
+    {
+      context.declaredVariables.define('dart.library.io', 'does-not-matter');
+      _createManager(allowLinking: false);
+      List<LinkedPubPackage> linkedPackages = manager.getLinkedBundles(context);
+      expect(linkedPackages, isEmpty);
+    }
+  }
+
   static PackageBundle _getBundleByPackageName(
       Map<PubPackage, PackageBundle> bundles, String name) {
     PubPackage package =
         bundles.keys.singleWhere((package) => package.name == name);
     return bundles[package];
   }
 }