Add patch file support to the analyzer task model.

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 1173 matching lines @@
    * analysis.
    */
   bool get incrementalValidation;
 
   /**
    * Return `true` if analysis is to generate lint warnings.
    */
   bool get lint;
 
   /**
+   * Return the "platform" bit mask which should be used to apply patch files,
+   * or `0` if no patch files should be applied.
+   */
+  int get patchPlatform;
+
+  /**
    * Return `true` if analysis is to parse comments.
    */
   bool get preserveComments;
 
   /**
    * Return `true` if strong mode analysis should be used.
    */
   bool get strongMode;
 
   /**
@@ skipping 97 matching lines @@
   @override
   bool incrementalApi = false;
 
   @override
   bool incrementalValidation = false;
 
   @override
   bool lint = false;
 
   @override
+  int patchPlatform = 0;
+
+  @override
   bool preserveComments = true;
 
   @override
   bool strongMode = false;
 
   /**
    * A flag indicating whether strong-mode inference hints should be
    * used.  This flag is not exposed in the interface, and should be
    * replaced by something more general.
    */
@@ skipping 67 matching lines @@
     strongMode = options.strongMode;
     if (options is AnalysisOptionsImpl) {
       strongModeHints = options.strongModeHints;
       implicitCasts = options.implicitCasts;
       nonnullableTypes = options.nonnullableTypes;
       implicitDynamic = options.implicitDynamic;
     }
     trackCacheDependencies = options.trackCacheDependencies;
     disableCacheFlushing = options.disableCacheFlushing;
     finerGrainedInvalidation = options.finerGrainedInvalidation;
+    patchPlatform = options.patchPlatform;
   }
 
   bool get analyzeFunctionBodies {
     if (identical(analyzeFunctionBodiesPredicate, _analyzeAllFunctionBodies)) {
       return true;
     } else if (identical(
         analyzeFunctionBodiesPredicate, _analyzeNoFunctionBodies)) {
       return false;
     } else {
       throw new StateError('analyzeFunctionBodiesPredicate in use');
@@ skipping 28 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() =>

[Brian Wilkerson, 2016/11/08 21:24:30]

I think this, setCrossContextOptionsFrom, and decodeCrossContextOptions need to
include a notion of patchPlatform. This is used to determine whether we need a
different context for a set of sources (such as an SDK) because of the way the
code will be analyzed, and I think applying a different patch platform would
qualify.

[Paul Berry, 2016/11/08 21:56:19]

Good catch.  As discussed in person, I will address this in a follow-up CL.

       (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);
 
   @override
   void setCrossContextOptionsFrom(AnalysisOptions options) {
@@ skipping 1242 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);
 }