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].
+   */
+  final int majorVersion;
+
   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 17 matching lines @@
    * for their unlinked bundle existence, or scheduled its computing.
    */
   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);
+  PubSummaryManager(this.resourceProvider, this.tempFileName,
+      {@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();
     }
     _onUnlinkedCompleteCompleter ??= new Completer();
@@ skipping 204 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);
   }
 }