Verify that cache unlinked and linked bundles are majorVersion compatible.

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' hide Resource;
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart';
@@ skipping 62 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';
 
+  /**
+   * See [PackageBundleAssembler.currentMajorVersion].
+   */
+  @visibleForTesting
+  int majorVersion = PackageBundleAssembler.currentMajorVersion;

[Brian Wilkerson, 2016/09/08 16:42:28]

Should this be final?

[scheglov, 2016/09/08 16:44:24]

No.
The only reason it was added is to be able to change it in tests.
In theory it could be final, and passed in the constructor.
But that seems like an overhead for the test-only feature.

[Paul Berry, 2016/09/08 16:45:16]

I was just about to make a similar comment.  I'd prefer if we made this final
and initialized it in the constructor using a named argument whose default value
is PackageBundleAssembler.currentMajorVersion.  That way we can still create a
PubSummaryManager during tests that uses a different major version, but there's
no worry about this field getting modified after the class is created and
causing weird behaviors.

[scheglov, 2016/09/08 17:02:37]

OK, it seems that we have a consensus here :-)
Done.

+
   final ResourceProvider resourceProvider;
 
   /**
    * The name of the temporary file that is used for atomic writes.
    */
   final String tempFileName;
 
   /**
    * The map from [PubPackage]s to their unlinked [PackageBundle]s in the pub
    * cache.
@@ skipping 242 matching lines @@
       }
       for (Resource child in children) {
         if (child is Folder) {
           addDartFiles(child);
         }
       }
     }
 
     try {
       addDartFiles(libFolder);
-      List<int> bytes = assembler.assemble().toBuffer();
+      PackageBundleBuilder bundleWriter = assembler.assemble();
+      bundleWriter.majorVersion = majorVersion;
+      List<int> bytes = bundleWriter.toBuffer();
       String fileName = _getUnlinkedName(strong);
       _writeAtomic(package.folder, fileName, bytes);
     } on FileSystemException {
       // Ignore file system exceptions.
     }
   }
 
   /**
    * Return the name of the file for a linked bundle, in strong or spec mode.
    */
@@ skipping 19 matching lines @@
   /**
    * Return the unlinked [PackageBundle] for the given [package]. If the bundle
    * has not been compute yet, return `null` and schedule its computation.
    */
   PackageBundle _getUnlinkedOrSchedule(PubPackage package, bool strong) {
     // Try to find in the cache.
     PackageBundle bundle = unlinkedBundleMap[package];
     if (bundle != null) {
       return bundle;
     }
+
     // Try to read from the file system.
     String fileName = _getUnlinkedName(strong);
-    File unlinkedFile = package.folder.getChildAssumingFile(fileName);
-    if (unlinkedFile.exists) {
+    File file = package.folder.getChildAssumingFile(fileName);
+    if (file.exists) {
       try {
-        List<int> bytes = unlinkedFile.readAsBytesSync();
+        List<int> bytes = file.readAsBytesSync();
         bundle = new PackageBundle.fromBuffer(bytes);
-        unlinkedBundleMap[package] = bundle;
-        // TODO(scheglov) if not in the pub cache, check for consistency
-        return bundle;
       } on FileSystemException {
         // Ignore file system exceptions.
       }
     }
+
+    bool isInPubCache = isPathInPubCache(pathContext, package.folder.path);
+
+    // Verify compatibility.
+    // TODO(scheglov) if not in the pub cache, check for consistency
+    if (bundle != null && bundle.majorVersion == majorVersion) {
+      unlinkedBundleMap[package] = bundle;
+      return bundle;
+    }
+
     // Schedule computation in the background, if in the pub cache.
-    if (isPathInPubCache(pathContext, package.folder.path)) {
+    if (isInPubCache) {
       if (seenPackages.add(package)) {
         _scheduleUnlinked(package);
       }
     }
-    // The bundle is for available.
+
+    // The bundle is not available.
     return null;
   }
 
   /**
    * Parse the given [source] into AST.
    */
   CompilationUnit _parse(Source source, bool strong) {
     String code = source.contents.data;
     AnalysisErrorListener errorListener = AnalysisErrorListener.NULL_LISTENER;
     CharSequenceReader reader = new CharSequenceReader(code);
@@ skipping 291 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);
   }
 }