Use configurations and declared variables to select import/export URIs during prelinking.

pkg/analyzer/lib/src/summary/prelink.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 'package:analyzer/src/generated/utilities_dart.dart';
 import 'package:analyzer/src/summary/format.dart';
 import 'package:analyzer/src/summary/idl.dart';
 import 'package:analyzer/src/summary/name_filter.dart';
 
 /**
  * Create a [LinkedLibraryBuilder] corresponding to the given
  * [definingUnit], which should be the defining compilation unit for a library.
  * Compilation units referenced by the defining compilation unit via `part`
  * declarations will be retrieved using [getPart].  Public namespaces for
  * libraries referenced by the defining compilation unit via `import`
  * declarations (and files reachable from them via `part` and `export`
  * declarations) will be retrieved using [getImport].
  */
 LinkedLibraryBuilder prelink(UnlinkedUnit definingUnit, GetPartCallback getPart,
-    GetImportCallback getImport) {
-  return new _Prelinker(definingUnit, getPart, getImport).prelink();
+    GetImportCallback getImport, GetDeclaredVariable getDeclaredVariable) {
+  return new _Prelinker(definingUnit, getPart, getImport, getDeclaredVariable)
+      .prelink();
 }
 
 /**
+ * Return the raw string value of the variable with the given [name],
+ * or `null` of the variable is not defined.
+ */
+typedef String GetDeclaredVariable(String name);
+
+/**
  * Type of the callback used by the prelinker to obtain public namespace
  * information about libraries imported by the library to be prelinked (and
  * the transitive closure of parts and exports reachable from those libraries).
  * [relativeUri] should be interpreted relative to the defining compilation
  * unit of the library being prelinked.
  *
  * If no file exists at the given uri, `null` should be returned.
  */
 typedef UnlinkedPublicNamespace GetImportCallback(String relativeUri);
 
@@ skipping 79 matching lines @@
  * Helper class containing temporary data structures needed to prelink a single
  * library.
  *
  * Note: throughout this class, a `null` value for a relative URI represents
  * the defining compilation unit of the library being prelinked.
  */
 class _Prelinker {
   final UnlinkedUnit definingUnit;
   final GetPartCallback getPart;
   final GetImportCallback getImport;
+  final GetDeclaredVariable getDeclaredVariable;
 
   /**
    * Cache of values returned by [getImport].
    */
   final Map<String, UnlinkedPublicNamespace> importCache =
       <String, UnlinkedPublicNamespace>{};
 
   /**
    * Cache of values returned by [getPart].
    */
@@ skipping 20 matching lines @@
    * corresponding entry in [dependencies].
    */
   final Map<String, int> uriToDependency = <String, int>{null: 0};
 
   /**
    * List of public namespaces corresponding to each entry in [dependencies].
    */
   final List<Map<String, _Meaning>> dependencyToPublicNamespace =
       <Map<String, _Meaning>>[null];
 
-  _Prelinker(this.definingUnit, this.getPart, this.getImport) {
+  _Prelinker(this.definingUnit, this.getPart, this.getImport,
+      this.getDeclaredVariable) {
     partCache[null] = definingUnit;
     importCache[null] = definingUnit.publicNamespace;
   }
 
   /**
    * Compute the public namespace for the library whose URI is reachable from
    * [definingUnit] via [relativeUri], by aggregating together public namespace
    * information from all of its parts.
    */
   Map<String, _Meaning> aggregatePublicNamespace(String relativeUri) {
@@ skipping 49 matching lines @@
     Map<String, _Meaning> exportNamespace = relativeUri == null
         ? <String, _Meaning>{}
         : aggregatePublicNamespace(relativeUri);
     void chaseExports(
         NameFilter filter, String relativeUri, Set<String> seenUris) {
       if (seenUris.add(relativeUri)) {
         UnlinkedPublicNamespace exportedNamespace =
             getImportCached(relativeUri);
         if (exportedNamespace != null) {
           for (UnlinkedExportPublic export in exportedNamespace.exports) {
-            String exportUri = resolveUri(relativeUri, export.uri);
+            String relativeExportUri =
+                _selectUri(export.uri, export.configurations);
+            String exportUri = resolveUri(relativeUri, relativeExportUri);
             NameFilter newFilter = filter.merge(
                 new NameFilter.forUnlinkedCombinators(export.combinators));
             aggregatePublicNamespace(exportUri)
                 .forEach((String name, _Meaning meaning) {
               if (newFilter.accepts(name) &&
                   !exportNamespace.containsKey(name)) {
                 exportNamespace[name] = meaning;
               }
             });
             chaseExports(newFilter, exportUri, seenUris);
           }
         }
         seenUris.remove(relativeUri);
       }
     }
+
     chaseExports(NameFilter.identity, relativeUri, new Set<String>());
     return exportNamespace;
   }
 
   /**
    * Extract all the names defined in [unit] (which is the [unitNum]th unit in
    * the library being prelinked) and store them in [privateNamespace].
    * Excludes names introduced by `import` statements.
    */
   void extractPrivateNames(UnlinkedUnit unit, int unitNum) {
@@ skipping 118 matching lines @@
           .map((String uri) => resolveUri(relativeUri, uri)));
     }
     return result;
   }
 
   /**
    * Process a single `import` declaration in the library being prelinked.  The
    * return value is the index of the imported library in [dependencies].
    */
   int handleImport(UnlinkedImport import) {
-    String uri = import.isImplicit ? 'dart:core' : import.uri;
+    String uri = import.isImplicit
+        ? 'dart:core'
+        : _selectUri(import.uri, import.configurations);
     Map<String, _Meaning> targetNamespace = null;
     if (import.prefixReference != 0) {
       // The name introduced by an import declaration can't have a prefix of
       // its own.
       assert(
           definingUnit.references[import.prefixReference].prefixReference == 0);
       String prefix = definingUnit.references[import.prefixReference].name;
       _Meaning prefixMeaning = privateNamespace[prefix];
       if (prefixMeaning is _PrefixMeaning) {
         targetNamespace = prefixMeaning.namespace;
@@ skipping 77 matching lines @@
       if (import.prefixReference != 0) {
         privateNamespace.putIfAbsent(
             units[0].references[import.prefixReference].name,
             () => new _PrefixMeaning());
       }
     }
 
     // Fill in imported and exported names.
     List<int> importDependencies =
         definingUnit.imports.map(handleImport).toList();
-    List<int> exportDependencies = definingUnit.publicNamespace.exports
-        .map((UnlinkedExportPublic exp) => uriToDependency[exp.uri])
-        .toList();
+    List<int> exportDependencies =
+        definingUnit.publicNamespace.exports.map((UnlinkedExportPublic exp) {
+      String uri = _selectUri(exp.uri, exp.configurations);
+      return uriToDependency[uri];
+    }).toList();
 
     // Link each compilation unit.
     List<LinkedUnitBuilder> linkedUnits = units.map(linkUnit).toList();
 
     return new LinkedLibraryBuilder(
         units: linkedUnits,
         dependencies: dependencies,
         importDependencies: importDependencies,
         exportDependencies: exportDependencies,
         exportNames: exportNames,
         numPrelinkedDependencies: dependencies.length);
   }
 
   /**
    * Resolve [relativeUri] relative to [sourceUri].  Works correctly if
    * [sourceUri] is also relative.
    */
   String resolveUri(String sourceUri, String relativeUri) {
     if (sourceUri == null) {
       return relativeUri;
     } else {
       return resolveRelativeUri(Uri.parse(sourceUri), Uri.parse(relativeUri))
           .toString();
     }
   }
+
+  /**
+   * Return the URI of the first configuration from the given [configurations]
+   * which condition is satisfied, or the [defaultUri].
+   */
+  String _selectUri(
+      String defaultUri, List<UnlinkedConfiguration> configurations) {
+    for (UnlinkedConfiguration configuration in configurations) {
+      if (getDeclaredVariable(configuration.name) == configuration.value) {
+        return configuration.uri;
+      }
+    }
+    return defaultUri;
+  }
 }