Parse the 'patches' argument in SDK libraries declarations.

pkg/analyzer/lib/src/generated/sdk.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.sdk;
 
 import 'dart:collection';
 
 import 'package:analyzer/dart/ast/ast.dart';
+import 'package:analyzer/dart/ast/token.dart';
 import 'package:analyzer/dart/ast/visitor.dart';
 import 'package:analyzer/src/generated/engine.dart'
     show AnalysisContext, AnalysisOptions, AnalysisOptionsImpl;
 import 'package:analyzer/src/generated/source.dart' show Source;
 import 'package:analyzer/src/generated/utilities_general.dart';
 import 'package:analyzer/src/summary/idl.dart' show PackageBundle;
 
 /**
  * A function used to create a new DartSdk with the given [options]. If the
  * passed [options] are `null`, then default options are used.
@@ skipping 247 matching lines @@
   String toString() {
     StringBuffer buffer = new StringBuffer();
     bool needsSeparator = false;
     void add(String optionName) {
       if (needsSeparator) {
         buffer.write(', ');
       }
       buffer.write(optionName);
       needsSeparator = true;
     }
+
     for (String path in paths) {
       add(path);
     }
     if (needsSeparator) {
       buffer.write(' ');
     }
     buffer.write('(');
     buffer.write(AnalysisOptionsImpl
         .decodeCrossContextOptions(options.encodeCrossContextOptions()));
     buffer.write(')');
@@ skipping 14 matching lines @@
    */
   static String _IMPLEMENTATION = "implementation";
 
   /**
    * The name of the optional parameter used to specify the path used when
    * compiling for dart2js.
    */
   static String _DART2JS_PATH = "dart2jsPath";
 
   /**
+   * The name of the `dart2js` platform.
+   */
+  static String _DART2JS_PLATFORM = 'DART2JS_PLATFORM';
+
+  /**
    * The name of the optional parameter used to indicate whether the library is
    * documented.
    */
   static String _DOCUMENTED = "documented";
 
   /**
    * The name of the optional parameter used to specify the category of the
    * library.
    */
   static String _CATEGORIES = "categories";
 
   /**
+   * The name of the optional parameter used to specify the patches for
+   * the library.
+   */
+  static String _PATCHES = "patches";
+
+  /**
    * The name of the optional parameter used to specify the platforms on which
    * the library can be used.
    */
   static String _PLATFORMS = "platforms";
 
   /**
    * The value of the [PLATFORMS] parameter used to specify that the library can
    * be used on the VM.
    */
   static String _VM_PLATFORM = "VM_PLATFORM";
@@ skipping 57 matching lines @@
         } else if (argument is NamedExpression) {
           String name = argument.name.label.name;
           Expression expression = argument.expression;
           if (name == _CATEGORIES) {
             library.category =
                 convertCategories((expression as StringLiteral).stringValue);
           } else if (name == _IMPLEMENTATION) {
             library._implementation = (expression as BooleanLiteral).value;
           } else if (name == _DOCUMENTED) {
             library.documented = (expression as BooleanLiteral).value;
+          } else if (name == _PATCHES) {
+            if (expression is MapLiteral) {
+              expression.entries.forEach((MapLiteralEntry entry) {
+                int platforms = _convertPlatforms(entry.key);
+                Expression pathsListLiteral = entry.value;
+                if (pathsListLiteral is ListLiteral) {
+                  List<String> paths = <String>[];
+                  pathsListLiteral.elements.forEach((Expression pathExpr) {
+                    if (pathExpr is SimpleStringLiteral) {
+                      paths.add(pathExpr.value);
+                    } else {
+                      throw new ArgumentError(
+                          'The "patch" argument items must be simple strings.');
+                    }
+                  });
+                  library.setPatchPaths(platforms, paths);
+                } else {
+                  throw new ArgumentError(
+                      'The "patch" argument values must be list literals.');
+                }
+              });
+            }
           } else if (name == _PLATFORMS) {
             if (expression is SimpleIdentifier) {
               String identifier = expression.name;
               if (identifier == _VM_PLATFORM) {
                 library.setVmLibrary();
               } else {
                 library.setDart2JsLibrary();
               }
             }
           } else if (_useDart2jsPaths && name == _DART2JS_PATH) {
             if (expression is SimpleStringLiteral) {
               library.path = expression.value;
             }
           }
         }
       }
       _librariesMap.setLibrary(libraryName, library);
     }
     return null;
   }
+
+  /**
+   * Return the platform constant value for the given [expr].
+   * Throw [ArgumentError] if not a valid platform name given.
+   */
+  static int _convertPlatform(Expression expr) {
+    if (expr is SimpleIdentifier) {
+      String name = expr.name;
+      if (name == _DART2JS_PLATFORM) {
+        return SdkLibraryImpl.DART2JS_PLATFORM;
+      }
+      if (name == _VM_PLATFORM) {
+        return SdkLibraryImpl.VM_PLATFORM;
+      }
+      throw new ArgumentError('Invalid platform name: $name');
+    }
+    throw new ArgumentError('Invalid platform type: ${expr.runtimeType}');
+  }
+
+  /**
+   * Return the platforms combination value for the [expr], which should be
+   * either `name1 | name2` or `name`.  Throw [ArgumentError] if any of the
+   * names is not a valid platform name.
+   */
+  static int _convertPlatforms(Expression expr) {
+    if (expr is BinaryExpression) {
+      TokenType operator = expr.operator?.type;
+      if (operator == TokenType.BAR) {
+        return _convertPlatforms(expr.leftOperand) |
+            _convertPlatforms(expr.rightOperand);
+      } else {
+        throw new ArgumentError('Invalid platforms combination: $operator');
+      }
+    } else {
+      return _convertPlatform(expr);
+    }
+  }
 }
 
 /**
  * Represents a single library in the SDK
  */
 abstract class SdkLibrary {
   /**
    * Return the name of the category containing the library.
    */
   String get category;
@@ skipping 32 matching lines @@
    * Return the path to the file defining the library. The path is relative to
    * the `lib` directory within the SDK.
    */
   String get path;
 
   /**
    * Return the short name of the library. This is the URI of the library,
    * including `dart:`.
    */
   String get shortName;
+
+  /**
+   * Return the list of paths to the patch files that should be applied
+   * to this library for the given [platform], not `null`.
+   */
+  List<String> getPatches(int platform);

[Bill Hesse, 2016/10/11 21:35:59]

This is a breaking change to the interface.  You need to add an implementation
of this to package:linter.  This is showing up as an error in the analyzer bots.

 }
 
 /**
  * The information known about a single library within the SDK.
  */
 class SdkLibraryImpl implements SdkLibrary {
   /**
    * The bit mask used to access the bit representing the flag indicating
    * whether a library is intended to work on the dart2js platform.
    */
@@ skipping 32 matching lines @@
    * A flag indicating whether the library is an implementation library.
    */
   bool _implementation = false;
 
   /**
    * An encoding of which platforms this library is intended to work on.
    */
   int _platforms = 0;
 
   /**
+   * The mapping from the platform combination to the list of paths (relative
+   * to the `sdk/lib` folder) of patches that should be applied to this library
+   * on every platform in the combination.
+   */
+  final Map<int, List<String>> _platformsToPatchPaths =
+      new HashMap<int, List<String>>();
+
+  /**
    * Initialize a newly created library to represent the library with the given
    * [name].
    */
   SdkLibraryImpl(this.shortName);
 
   /**
    * Set whether the library is documented.
    */
   void set documented(bool documented) {
     this._documented = documented;
@@ skipping 10 matching lines @@
 
   @override
   bool get isInternal => category == "Internal";
 
   @override
   bool get isShared => category == "Shared";
 
   @override
   bool get isVmLibrary => (_platforms & VM_PLATFORM) != 0;
 
+  @override
+  List<String> getPatches(int platform) {
+    List<String> paths = <String>[];
+    _platformsToPatchPaths.forEach((int platforms, List<String> value) {
+      if ((platforms & platform) != 0) {
+        paths.addAll(value);
+      }
+    });
+    return paths;
+  }
+
   /**
    * Record that this library can be compiled to JavaScript by dart2js.
    */
   void setDart2JsLibrary() {
     _platforms |= DART2JS_PLATFORM;
   }
 
   /**
+   * Add a new patch with the given [path] that should be applied for the
+   * given [platforms].
+   */
+  void setPatchPaths(int platforms, List<String> paths) {
+    _platformsToPatchPaths[platforms] = paths;
+  }
+
+  /**
    * Record that this library can be run on the VM.
    */
   void setVmLibrary() {
     _platforms |= VM_PLATFORM;
   }
 }