Introduce "platform configurations" to replace categories and libraries.dart.

pkg/compiler/lib/src/apiimpl.dart

 // Copyright (c) 2012, 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 leg_apiimpl;
 
 import 'dart:async';
 import 'dart:convert';
 
 import 'package:package_config/packages.dart';
 import 'package:package_config/packages_file.dart' as pkgs;
 import 'package:package_config/src/packages_impl.dart' show
     MapPackages,
     NonFilePackagesDirectoryPackages;
 import 'package:package_config/src/util.dart' show
     checkValidPackageUri;
-import 'package:sdk_library_metadata/libraries.dart' as library_info;
 
 import '../compiler_new.dart' as api;
 import 'commandline_options.dart';
 import 'common.dart';
 import 'common/tasks.dart' show
     GenericTask;
 import 'compiler.dart';
 import 'diagnostics/diagnostic_listener.dart' show
     DiagnosticOptions;
 import 'diagnostics/messages.dart' show
     Message;
 import 'elements/elements.dart' as elements;
 import 'io/source_file.dart';
+import 'platform_configuration.dart' as platform_configuration;
 import 'script.dart';
 
 const bool forceIncrementalSupport =
     const bool.fromEnvironment('DART2JS_EXPERIMENTAL_INCREMENTAL_SUPPORT');
 
+/// Locations of the platform descriptor files relative to the library root.
+const String _clientPlatform = "lib/dart_client.platform";
+const String _serverPlatform = "lib/dart_server.platform";
+const String _sharedPlatform = "lib/dart_shared.platform";
+const String _dart2dartPlatform = "lib/dart2dart.platform";
+
 /// Implements the [Compiler] using a [api.CompilerInput] for supplying the
 /// sources.
 class CompilerImpl extends Compiler {
   api.CompilerInput provider;
   api.CompilerDiagnostics handler;
-  final Uri libraryRoot;
+  final Uri platformConfigUri;
   final Uri packageConfig;
   final Uri packageRoot;
   final api.PackagesDiscoveryProvider packagesDiscoveryProvider;
   Packages packages;
   List<String> options;
   Map<String, dynamic> environment;
   bool mockableLibraryUsed = false;
-  final Set<library_info.Category> allowedLibraryCategories;
+
+  /// A mapping of the dart: library-names to their location.
+  ///
+  /// Initialized in [setupSdk()].

[Johnni Winther, 2015/10/30 10:38:39]

Remove ()

[sigurdm, 2015/10/30 11:38:27]

Done.

+  Map<String, Uri> sdkLibraries;
 
   GenericTask userHandlerTask;
   GenericTask userProviderTask;
   GenericTask userPackagesDiscoveryTask;
 
+  Uri get libraryRoot => platformConfigUri.resolve(".");
+
   CompilerImpl(this.provider,
            api.CompilerOutput outputProvider,
            this.handler,
-           this.libraryRoot,
+           Uri libraryRoot,
            this.packageRoot,
            List<String> options,
            this.environment,
            [this.packageConfig,
             this.packagesDiscoveryProvider])
       : this.options = options,
-        this.allowedLibraryCategories = getAllowedLibraryCategories(options),
+        this.platformConfigUri = resolvePlatformConfig(libraryRoot, options),
         super(
             outputProvider: outputProvider,
             enableTypeAssertions: hasOption(options, Flags.enableCheckedMode),
             enableUserAssertions: hasOption(options, Flags.enableCheckedMode),
             trustTypeAnnotations:
                 hasOption(options, Flags.trustTypeAnnotations),
             trustPrimitives:
                 hasOption(options, Flags.trustPrimitives),
             enableMinification: hasOption(options, Flags.minify),
             useFrequencyNamer:
@@ skipping 92 matching lines @@
   // CSV: Comma separated values.
   static List<String> extractCsvOption(List<String> options, String prefix) {
     for (String option in options) {
       if (option.startsWith(prefix)) {
         return option.substring(prefix.length).split(',');
       }
     }
     return const <String>[];
   }
 
-  static Set<library_info.Category> getAllowedLibraryCategories(
+  static Uri resolvePlatformConfig(Uri libraryRoot,
       List<String> options) {

[Johnni Winther, 2015/10/30 10:38:39]

Indent to (

[sigurdm, 2015/10/30 11:38:27]

Done.

-    Iterable<library_info.Category> categories =
-      extractCsvOption(options, '--categories=')
-          .map(library_info.parseCategory)
-          .where((x) => x != null);
-    if (categories.isEmpty) {
-      return new Set.from([library_info.Category.client]);
+    String platformConfigPath =
+        extractStringOption(options, "--platform-config=", null);
+    if (platformConfigPath != null) {
+      return libraryRoot.resolve(platformConfigPath);
+    } else if (hasOption(options, '--output-type=dart')) {
+      print("%%% ${libraryRoot.resolve(_dart2dartPlatform)}");

[Johnni Winther, 2015/10/30 10:38:39]

Remove debug code. Maybe add as reporter.log(...) call.

[sigurdm, 2015/10/30 11:38:27]

Removed

+      return libraryRoot.resolve(_dart2dartPlatform);
+    } else {
+      Iterable<String> categories = extractCsvOption(options, '--categories=');
+      if (categories.length == 0) {
+        return libraryRoot.resolve(_clientPlatform);
+      }
+      assert(categories.length <= 2);
+      if (categories.contains("Client")) {
+        if (categories.contains("Server")) {
+          return libraryRoot.resolve(_sharedPlatform);
+        }
+        return libraryRoot.resolve(_clientPlatform);
+      }
+      assert(categories.contains("Server"));
+      return libraryRoot.resolve(_serverPlatform);
     }
-    return new Set.from(categories);
   }
 
   static bool hasOption(List<String> options, String option) {
     return options.indexOf(option) >= 0;
   }
 
-  String lookupPatchPath(String dartLibraryName) {
-    library_info.LibraryInfo info = lookupLibraryInfo(dartLibraryName);
-    if (info == null) return null;
-    if (!info.isDart2jsLibrary) return null;
-    String path = info.dart2jsPatchPath;
-    if (path == null) return null;
-    return "lib/$path";
-  }
-
   void log(message) {
     callUserHandler(
         null, null, null, null, message, api.Diagnostic.VERBOSE_INFO);
   }
 
   /// See [Compiler.translateResolvedUri].
   Uri translateResolvedUri(elements.LibraryElement importingLibrary,
                            Uri resolvedUri, Spannable spannable) {
     if (resolvedUri.scheme == 'dart') {
       return translateDartUri(importingLibrary, resolvedUri, spannable);
@@ skipping 84 matching lines @@
    * See [LibraryLoader] for terminology on URIs.
    */
   Uri translateUri(Spannable node, Uri readableUri) {
     switch (readableUri.scheme) {
       case 'package': return translatePackageUri(node, readableUri);
       default: return readableUri;
     }
   }
 
   /// Translates "resolvedUri" with scheme "dart" to a [uri] resolved relative
-  /// to [libraryRoot] according to the information in [library_info.libraries].
+  /// to [platformConfigUri] according to the information in the file at
+  /// [platformConfigUri].
   ///
   /// Returns null and emits an error if the library could not be found or
   /// imported into [importingLibrary].
   ///
-  /// If [importingLibrary] is a platform or patch library all dart2js libraries
-  /// can be resolved. Otherwise only libraries with categories in
-  /// [allowedLibraryCategories] can be resolved.
+  /// Internal libraries (whose name starts with '_') can be only resolved if
+  /// [importingLibrary] is a platform or patch library.
   Uri translateDartUri(elements.LibraryElement importingLibrary,
                        Uri resolvedUri, Spannable spannable) {
 
-    library_info.LibraryInfo libraryInfo = lookupLibraryInfo(resolvedUri.path);
+    Uri location = lookupLibraryUri(resolvedUri.path);
 
-    bool allowInternalLibraryAccess = false;
-    if (importingLibrary != null) {
-      if (importingLibrary.isPlatformLibrary || importingLibrary.isPatch) {
-        allowInternalLibraryAccess = true;
-      } else if (importingLibrary.canonicalUri.path.contains(
-          'sdk/tests/compiler/dart2js_native')) {
-        allowInternalLibraryAccess = true;
+    if (location == null) {
+      reporter.reportErrorMessage(
+          spannable,
+          MessageKind.LIBRARY_NOT_FOUND,
+          {'resolvedUri': resolvedUri});
+      return null;
+    }
+
+    if (resolvedUri.path.startsWith('_')  ) {
+      bool allowInternalLibraryAccess = false;
+      if (importingLibrary != null) {
+        if (importingLibrary.isPlatformLibrary || importingLibrary.isPatch) {
+          allowInternalLibraryAccess = true;
+        } else if (importingLibrary.canonicalUri.path.contains(
+            'sdk/tests/compiler/dart2js_native')) {
+          allowInternalLibraryAccess = true;
+        }
+      }
+
+      if (!allowInternalLibraryAccess) {
+        if (importingLibrary != null) {
+          reporter.reportErrorMessage(
+              spannable,
+              MessageKind.INTERNAL_LIBRARY_FROM,
+              {'resolvedUri': resolvedUri,
+                'importingUri': importingLibrary.canonicalUri});
+        } else {
+          reporter.reportErrorMessage(
+              spannable,
+              MessageKind.INTERNAL_LIBRARY,
+              {'resolvedUri': resolvedUri});
+          registerDisallowedLibraryUse(resolvedUri);
+        }
+        return null;
       }
     }
 
-    String computePath() {
-      if (libraryInfo == null) {
-        return null;
-      } else if (!libraryInfo.isDart2jsLibrary) {
-        return null;
-      } else {
-        if (libraryInfo.isInternal &&
-            !allowInternalLibraryAccess) {
-          if (importingLibrary != null) {
-            reporter.reportErrorMessage(
-                spannable,
-                MessageKind.INTERNAL_LIBRARY_FROM,
-                {'resolvedUri': resolvedUri,
-                  'importingUri': importingLibrary.canonicalUri});
-          } else {
-            reporter.reportErrorMessage(
-                spannable,
-                MessageKind.INTERNAL_LIBRARY,
-                {'resolvedUri': resolvedUri});
-            registerDisallowedLibraryUse(resolvedUri);
-          }
-          return null;
-        } else if (!allowInternalLibraryAccess &&
-            !allowedLibraryCategories.any(libraryInfo.categories.contains)) {
-          registerDisallowedLibraryUse(resolvedUri);
-          // TODO(sigurdm): Currently we allow the sdk libraries to import
-          // libraries from any category. We might want to revisit this.
-          return null;
-        } else {
-          return (libraryInfo.dart2jsPath != null)
-              ? libraryInfo.dart2jsPath
-              : libraryInfo.path;
-        }
-      }
-    }
-
-    String path = computePath();
-
-    if (path == null) {
-      if (libraryInfo == null) {
-        reporter.reportErrorMessage(
-            spannable,
-            MessageKind.LIBRARY_NOT_FOUND,
-            {'resolvedUri': resolvedUri});
-      } else {
-        reporter.reportErrorMessage(
-            spannable,
-            MessageKind.LIBRARY_NOT_SUPPORTED,
-            {'resolvedUri': resolvedUri});
-      }
-      // TODO(johnniwinther): Support signaling the error through the returned
-      // value.
+    if (location.scheme == "unsupported") {
+      reporter.reportErrorMessage(
+          spannable,
+          MessageKind.LIBRARY_NOT_SUPPORTED,
+          {'resolvedUri': resolvedUri});
+      registerDisallowedLibraryUse(resolvedUri);
       return null;
     }
 
     if (resolvedUri.path == 'html' ||
         resolvedUri.path == 'io') {
       // TODO(ahe): Get rid of mockableLibraryUsed when test.dart
       // supports this use case better.
       mockableLibraryUsed = true;
     }
-    return libraryRoot.resolve("lib/$path");
-  }
-
-  Uri resolvePatchUri(String dartLibraryPath) {
-    String patchPath = lookupPatchPath(dartLibraryPath);
-    if (patchPath == null) return null;
-    return libraryRoot.resolve(patchPath);
+    return location;
   }
 
   Uri translatePackageUri(Spannable node, Uri uri) {
     try {
       checkValidPackageUri(uri);
     } on ArgumentError catch (e) {
       reporter.reportErrorMessage(
           node,
           MessageKind.INVALID_PACKAGE_URI,
           {'uri': uri, 'exception': e.message});
       return null;
     }
     return packages.resolve(uri,
         notFound: (Uri notFound) {
           reporter.reportErrorMessage(
               node,
               MessageKind.LIBRARY_NOT_FOUND,
               {'resolvedUri': uri});
           return null;
         });
   }
 
   Future<elements.LibraryElement> analyzeUri(
       Uri uri,
       {bool skipLibraryWithPartOfTag: true}) {
+    List<Future> setupFunctions = new List<Future>();
+    if (sdkLibraries == null) {
+      setupFunctions.add(setupSdk());
+    }
     if (packages == null) {
-      return setupPackages(uri).then((_) => super.analyzeUri(uri));
+      setupFunctions.add(setupPackages(uri));
     }
-    return super.analyzeUri(
-        uri, skipLibraryWithPartOfTag: skipLibraryWithPartOfTag);
+    return Future.wait(setupFunctions).then((_) => super.analyzeUri(uri));
   }
 
   Future setupPackages(Uri uri) {
     if (packageRoot != null) {
       // Use "non-file" packages because the file version requires a [Directory]
       // and we can't depend on 'dart:io' classes.
       packages = new NonFilePackagesDirectoryPackages(packageRoot);
     } else if (packageConfig != null) {
       return callUserProvider(packageConfig).then((packageConfigContents) {
         if (packageConfigContents is String) {
@@ skipping 20 matching lines @@
         packages = Packages.noPackages;
       } else {
         return callUserPackagesDiscovery(uri).then((p) {
           packages = p;
         });
       }
     }
     return new Future.value();
   }
 
+  Future<Null> setupSdk() {
+    if (sdkLibraries == null) {
+      return platform_configuration.load(platformConfigUri, provider)
+          .then((Map<String, Uri> mapping) {
+        sdkLibraries = mapping;
+      });
+    } else {
+      // The incremental compiler sets up the sdk before run.
+      // Therefore this will be called a second time.
+      return new Future.value(null);
+    }
+  }
+
   Future<bool> run(Uri uri) {
-    log('Allowed library categories: $allowedLibraryCategories');
+    log('Using platform configuration at ${platformConfigUri}');
 
-    return setupPackages(uri).then((_) {
+    return Future.wait([setupSdk(), setupPackages(uri)]).then((_) {
+      assert(sdkLibraries != null);
       assert(packages != null);
 
       return super.run(uri).then((bool success) {
         int cumulated = 0;
         for (final task in tasks) {
           int elapsed = task.timing;
           if (elapsed != 0) {
             cumulated += elapsed;
             log('${task.name} took ${elapsed}msec');
             for (String subtask in task.subtasks) {
@@ skipping 70 matching lines @@
   Future<Packages> callUserPackagesDiscovery(Uri uri) {
     try {
       return userPackagesDiscoveryTask.measure(
                  () => packagesDiscoveryProvider(uri));
     } catch (ex, s) {
       diagnoseCrashInUserCode('Uncaught exception in package discovery', ex, s);
       rethrow;
     }
   }
 
-
   fromEnvironment(String name) => environment[name];
 
-  library_info.LibraryInfo lookupLibraryInfo(String libraryName) {
-    return library_info.libraries[libraryName];
+  Uri lookupLibraryUri(String libraryName) {
+    assert(invariant(NO_LOCATION_SPANNABLE,
+        sdkLibraries != null, message: "setupSdk() has not been run"));
+    return sdkLibraries[libraryName];
+  }
+
+  Uri resolvePatchUri(String libraryName) {
+    return backend.resolvePatchUri(libraryName, platformConfigUri);
   }
 }