Update cross-context options encoding to account for patchPlatform.

pkg/analyzer/lib/src/generated/engine.dart

 // Copyright (c) 2014, 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.
 
 library analyzer.src.generated.engine;
 
 import 'dart:async';
 import 'dart:collection';
 
 import 'package:analyzer/dart/ast/ast.dart';
@@ skipping 1037 matching lines @@
  * of any known library).
  */
 class AnalysisNotScheduledError implements Exception {}
 
 /**
  * A set of analysis options used to control the behavior of an analysis
  * context.
  */
 abstract class AnalysisOptions {
   /**
+   * The length of the list returned by [encodeCrossContextOptions].
+   */
+  static const int crossContextOptionsLength = 2;
+
+  /**
    * Function that returns `true` if analysis is to parse and analyze function
    * bodies for a given source.
    */
   AnalyzeFunctionBodiesPredicate get analyzeFunctionBodiesPredicate;
 
   /**
    * DEPRECATED: Return the maximum number of sources for which AST structures should be
    * kept in the cache.
    *
    * This setting no longer has any effect.
@@ skipping 140 matching lines @@
 
   /**
    * Return `true` if dependencies between computed results should be tracked
    * by analysis cache.  This option should only be set to `false` if analysis
    * is performed in such a way that none of the inputs is ever changed
    * during the life time of the context.
    */
   bool get trackCacheDependencies;
 
   /**
-   * Return an integer encoding of the values of the options that need to be the
-   * same across all of the contexts associated with partitions that are to be
-   * shared by a single analysis context.
+   * Return a list of integers encoding of the values of the options that need
+   * to be the same across all of the contexts associated with partitions that
+   * are to be shared by a single analysis context.
+   *
+   * The length of the list is guaranteed to equal [crossContextOptionsLength].
    */
-  int encodeCrossContextOptions();
+  List<int> encodeCrossContextOptions();
 
   /**
    * Set the values of the cross-context options to match those in the given set
    * of [options].
    */
   void setCrossContextOptionsFrom(AnalysisOptions options);
+
+  /**
+   * Determine whether two lists returned by [encodeCrossContextOptions] are
+   * equal.
+   */
+  static bool crossContextOptionsEqual(List<int> a, List<int> b) {
+    assert(a.length == crossContextOptionsLength);
+    assert(b.length == crossContextOptionsLength);
+    if (a.length != b.length) {
+      return false;
+    }
+    for (int i = 0; i < a.length; i++) {
+      if (a[i] != b[i]) {
+        return false;
+      }
+    }
+    return true;
+  }
 }
 
 /**
  * A set of analysis options used to control the behavior of an analysis
  * context.
  */
 class AnalysisOptionsImpl implements AnalysisOptions {
   /**
    * DEPRECATED: The maximum number of sources for which data should be kept in the cache.
    *
@@ skipping 207 matching lines @@
 
   /**
    * A flag indicating whether interface libraries are to be supported (DEP 40).
    */
   bool get enableConditionalDirectives => true;
 
   @deprecated
   void set enableConditionalDirectives(_) {}
 
   @override
-  int encodeCrossContextOptions() =>
-      (enableAssertMessage ? ENABLE_ASSERT_FLAG : 0) |
-      (enableGenericMethods ? ENABLE_GENERIC_METHODS_FLAG : 0) |
-      (enableLazyAssignmentOperators ? ENABLE_LAZY_ASSIGNMENT_OPERATORS : 0) |
-      (enableStrictCallChecks ? ENABLE_STRICT_CALL_CHECKS_FLAG : 0) |
-      (enableSuperMixins ? ENABLE_SUPER_MIXINS_FLAG : 0) |
-      (strongMode ? ENABLE_STRONG_MODE_FLAG : 0) |
-      (strongModeHints ? ENABLE_STRONG_MODE_HINTS_FLAG : 0);
+  List<int> encodeCrossContextOptions() {
+    int flags = (enableAssertMessage ? ENABLE_ASSERT_FLAG : 0) |
+        (enableGenericMethods ? ENABLE_GENERIC_METHODS_FLAG : 0) |
+        (enableLazyAssignmentOperators ? ENABLE_LAZY_ASSIGNMENT_OPERATORS : 0) |
+        (enableStrictCallChecks ? ENABLE_STRICT_CALL_CHECKS_FLAG : 0) |
+        (enableSuperMixins ? ENABLE_SUPER_MIXINS_FLAG : 0) |
+        (strongMode ? ENABLE_STRONG_MODE_FLAG : 0) |
+        (strongModeHints ? ENABLE_STRONG_MODE_HINTS_FLAG : 0);
+    return <int>[flags, patchPlatform];
+  }
 
   @override
   void setCrossContextOptionsFrom(AnalysisOptions options) {
     enableAssertMessage = options.enableAssertMessage;
     enableGenericMethods = options.enableGenericMethods;
     enableLazyAssignmentOperators = options.enableLazyAssignmentOperators;
     enableStrictCallChecks = options.enableStrictCallChecks;
     enableSuperMixins = options.enableSuperMixins;
     strongMode = options.strongMode;
     if (options is AnalysisOptionsImpl) {
       strongModeHints = options.strongModeHints;
     }
+    patchPlatform = options.patchPlatform;
   }
 
   /**
    * Produce a human readable list of option names corresponding to the options
    * encoded in the given [encoding], presumably from invoking the method
    * [encodeCrossContextOptions].
    */
-  static String decodeCrossContextOptions(int encoding) {
-    if (encoding == 0) {
+  static String decodeCrossContextOptions(List<int> encoding) {
+    List<String> parts = [];
+    int flags = encoding[0];
+    if (flags & ENABLE_ASSERT_FLAG > 0) {
+      parts.add('assert');
+    }
+    if (flags & ENABLE_GENERIC_METHODS_FLAG > 0) {
+      parts.add('genericMethods');
+    }
+    if (flags & ENABLE_LAZY_ASSIGNMENT_OPERATORS > 0) {
+      parts.add('lazyAssignmentOperators');
+    }
+    if (flags & ENABLE_STRICT_CALL_CHECKS_FLAG > 0) {
+      parts.add('strictCallChecks');
+    }
+    if (flags & ENABLE_SUPER_MIXINS_FLAG > 0) {
+      parts.add('superMixins');
+    }
+    if (flags & ENABLE_STRONG_MODE_FLAG > 0) {
+      parts.add('strongMode');
+    }
+    if (flags & ENABLE_STRONG_MODE_HINTS_FLAG > 0) {
+      parts.add('strongModeHints');
+    }
+    int patchPlatform = encoding[1];
+    if (patchPlatform != 0) {
+      parts.add('patchPlatform=$patchPlatform');
+    }
+    if (parts.isEmpty) {
       return 'none';
+    } else {
+      return parts.join(', ');
     }
-    StringBuffer buffer = new StringBuffer();
-    bool needsSeparator = false;
-    void add(String optionName) {
-      if (needsSeparator) {
-        buffer.write(', ');
-      }
-      buffer.write(optionName);
-      needsSeparator = true;
-    }
-
-    if (encoding & ENABLE_ASSERT_FLAG > 0) {
-      add('assert');
-    }
-    if (encoding & ENABLE_GENERIC_METHODS_FLAG > 0) {
-      add('genericMethods');
-    }
-    if (encoding & ENABLE_LAZY_ASSIGNMENT_OPERATORS > 0) {
-      add('lazyAssignmentOperators');
-    }
-    if (encoding & ENABLE_STRICT_CALL_CHECKS_FLAG > 0) {
-      add('strictCallChecks');
-    }
-    if (encoding & ENABLE_SUPER_MIXINS_FLAG > 0) {
-      add('superMixins');
-    }
-    if (encoding & ENABLE_STRONG_MODE_FLAG > 0) {
-      add('strongMode');
-    }
-    if (encoding & ENABLE_STRONG_MODE_HINTS_FLAG > 0) {
-      add('strongModeHints');
-    }
-    return buffer.toString();
   }
 
   /**
    * Predicate used for [analyzeFunctionBodiesPredicate] when
    * [analyzeFunctionBodies] is set to `true`.
    */
   static bool _analyzeAllFunctionBodies(Source _) => true;
 
   /**
    * Predicate used for [analyzeFunctionBodiesPredicate] when
@@ skipping 1180 matching lines @@
    * The data that was created from the source.
    */
   final E data;
 
   /**
    * Initialize a newly created holder to associate the given [data] with the
    * given [modificationTime].
    */
   TimestampedData(this.modificationTime, this.data);
 }