Cache linked bundles for Bazel packages in files..

pkg/analyzer/test/src/summary/bazel_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/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/error/listener.dart';
 import 'package:analyzer/file_system/file_system.dart';
 import 'package:analyzer/src/context/cache.dart';
 import 'package:analyzer/src/dart/scanner/reader.dart';
 import 'package:analyzer/src/dart/scanner/scanner.dart';
 import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/generated/parser.dart';
 import 'package:analyzer/src/generated/source.dart';
 import 'package:analyzer/src/summary/bazel_summary.dart';
 import 'package:analyzer/src/summary/format.dart';
+import 'package:analyzer/src/summary/idl.dart';
 import 'package:analyzer/src/summary/summarize_ast.dart';
 import 'package:analyzer/src/summary/summarize_elements.dart';
 import 'package:analyzer/src/util/fast_uri.dart';
 import 'package:analyzer/task/dart.dart';
 import 'package:path/path.dart' as pathos;
 import 'package:test_reflective_loader/test_reflective_loader.dart';
 import 'package:unittest/unittest.dart';
 
 import '../../utils.dart';
 import '../context/abstract_context.dart';
 
 main() {
   initializeTestEnvironment();
   defineReflectiveTests(BazelResultProviderTest);
   defineReflectiveTests(SummaryProviderTest);
 }
 
 const OUT_ROOT = '$SRC_ROOT/bazel-bin';
 const SRC_ROOT = '/company/src/user/project/root';
 
 @reflectiveTest
 class BazelResultProviderTest extends _BaseTest {
   BazelResultProvider provider;
 
   @override
   void setUp() {
     super.setUp();
-    provider = new BazelResultProvider(
-        new SummaryProvider(resourceProvider, _getOutputFolder, context));
+    provider = new BazelResultProvider(new SummaryProvider(
+        resourceProvider,
+        '_.temp',
+        _getOutputFolder,
+        resourceProvider.getFolder('/tmp/dart/bazel/linked'),
+        context));
   }
 
   test_failure_inconsistent_directDependency() {
     _setComponentFile('aaa', 'a.dart', 'class A {}');
     _setComponentFile(
         'bbb',
         'b.dart',
         r'''
 import 'package:components.aaa/a.dart';
 class B extends A {}
@@ skipping 72 matching lines @@
   }
 }
 
 @reflectiveTest
 class SummaryProviderTest extends _BaseTest {
   SummaryProvider manager;
 
   @override
   void setUp() {
     super.setUp();
-    manager = new SummaryProvider(resourceProvider, _getOutputFolder, context);
+    _createManager();
+  }
+
+  test_getLinkedPackages_cached() {
+    _setComponentFile('aaa', 'a.dart', 'class A {}');
+    _setComponentFile(
+        'bbb',
+        'b.dart',
+        r'''
+import 'package:components.aaa/a.dart';
+class B extends A {}
+''');
+    _writeUnlinkedBundle('components.aaa');
+    _writeUnlinkedBundle('components.bbb');
+    Source source = _resolveUri('package:components.bbb/b.dart');
+
+    // Session 1.
+    // Create linked bundles and store them in files.
+    {
+      List<Package> packages = manager.getLinkedPackages(source);
+      expect(packages, hasLength(2));
+    }
+
+    // Session 2.
+    // Recreate manager (with disabled linking) and ask again.
+    {
+      _createManager(allowLinking: false);
+      List<Package> packages = manager.getLinkedPackages(source);
+      expect(packages, hasLength(2));
+    }
+  }
+
+  test_getLinkedPackages_cached_declaredVariables_export() {
+    _testImpl_getLinkedPackages_cached_declaredVariables('export');
+  }
+
+  test_getLinkedPackages_cached_declaredVariables_import() {
+    _testImpl_getLinkedPackages_cached_declaredVariables('import');
   }
 
   test_getLinkedPackages_null_inconsistent_directDependency() {
     _setComponentFile('aaa', 'a.dart', 'class A {}');
     _setComponentFile(
         'bbb',
         'b.dart',
         r'''
 import 'package:components.aaa/a.dart';
 class B extends A {}
@@ skipping 150 matching lines @@
     _writeUnlinkedBundle('components.aaa');
     // Ask the package for the URI.
     Source source1 = _resolveUri('package:components.aaa/a1.dart');
     Source source2 = _resolveUri('package:components.aaa/a2.dart');
     Package package = manager.getUnlinkedForUri(source1.uri);
     expect(package, isNotNull);
     // The same instance is returned to another URI in the same package.
     expect(manager.getUnlinkedForUri(source2.uri), same(package));
   }
 
-  test_getUnlinkedForUri_inconsistent() {
+  test_getUnlinkedForUri_inconsistent_fileContent() {
     File file1 = _setComponentFile('aaa', 'a1.dart', 'class A1 {}');
     _setComponentFile('aaa', 'a2.dart', 'class A2 {}');
     _writeUnlinkedBundle('components.aaa');
     // Update one of the files, so the bundle is not consistent.
     file1.writeAsStringSync('\nclass A1 {}');
     Source source1 = _resolveUri('package:components.aaa/a1.dart');
     Source source2 = _resolveUri('package:components.aaa/a2.dart');
     expect(manager.getUnlinkedForUri(source1.uri), isNull);
     expect(manager.getUnlinkedForUri(source2.uri), isNull);
   }
+
+  test_getUnlinkedForUri_inconsistent_majorVersion() {
+    _setComponentFile('aaa', 'a.dart', 'class A {}');
+    _writeUnlinkedBundle('components.aaa');
+    Source source = _resolveUri('package:components.aaa/a.dart');
+
+    // Create manager with a different major version.
+    // The unlinked bundle cannot be used.
+    _createManager(majorVersion: 12345);
+    Package package = manager.getUnlinkedForUri(source.uri);
+    expect(package, isNull);
+  }
+
+  void _createManager(
+      {bool allowLinking: true,
+      int majorVersion: PackageBundleAssembler.currentMajorVersion}) {
+    manager = new SummaryProvider(resourceProvider, '_.temp', _getOutputFolder,
+        resourceProvider.getFolder('/tmp/dart/bazel/linked'), context,
+        allowLinking: allowLinking, majorVersion: majorVersion);
+  }
+
+  void _testImpl_getLinkedPackages_cached_declaredVariables(
+      String importOrExport) {
+    _setComponentFile(
+        'aaa',
+        'user.dart',
+        '''
+    $importOrExport 'foo.dart'
+      if (dart.library.io) 'foo_io.dart'
+      if (dart.library.html) 'foo_html.dart';
+    ''');
+    _setComponentFile('aaa', 'foo.dart', 'class B {}');
+    _setComponentFile('aaa', 'foo_io.dart', 'class B {}');
+    _setComponentFile('aaa', 'foo_dart.dart', 'class B {}');
+    _writeUnlinkedBundle('components.aaa');
+    Source source = _resolveUri('package:components.aaa/user.dart');
+
+    void _assertDependencyInUser(PackageBundle bundle, String shortName) {
+      for (var i = 0; i < bundle.linkedLibraryUris.length; i++) {
+        if (bundle.linkedLibraryUris[i].endsWith('user.dart')) {
+          LinkedLibrary library = bundle.linkedLibraries[i];
+          expect(library.dependencies.map((d) => d.uri),
+              unorderedEquals(['', 'dart:core', shortName]));
+          return;
+        }
+      }
+      fail('Not found user.dart in $bundle');
+    }
+
+    // Session 1.
+    // Create linked bundles and store them in files.
+    {
+      List<Package> packages = manager.getLinkedPackages(source);
+      expect(packages, hasLength(1));
+      _assertDependencyInUser(packages.single.linked, 'foo.dart');
+    }
+
+    // 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<Package> packages = manager.getLinkedPackages(source);
+      expect(packages, hasLength(1));
+      _assertDependencyInUser(packages.single.linked, 'foo.dart');
+    }
+
+    // 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<Package> packages = manager.getLinkedPackages(source);
+      expect(packages, isEmpty);
+    }
+
+    // Session 4.
+    // Enable new linking, and configure to use 'foo_html.dart'.
+    {
+      context.declaredVariables.define('dart.library.html', 'true');
+      _createManager(allowLinking: true);
+      List<Package> packages = manager.getLinkedPackages(source);
+      expect(packages, hasLength(1));
+      _assertDependencyInUser(packages.single.linked, 'foo_html.dart');
+    }
+  }
 }
 
 class _BaseTest extends AbstractContextTest {
   @override
   void setUp() {
     super.setUp();
     // Include a 'package' URI resolver.
     sourceFactory = new SourceFactory(<UriResolver>[
       sdkResolver,
       resourceResolver,
@@ skipping 126 matching lines @@
       }
     }
     return null;
   }
 
   @override
   Uri restoreAbsolute(Source source) {
     throw new UnimplementedError();
   }
 }