Implement canonical name scheme in kernel.

pkg/kernel/bin/dartk.dart

 #!/usr/bin/env 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 'dart:async';
 import 'dart:io';
 
 import 'batch_util.dart';
 
@@ skipping 44 matching lines @@
   ..addFlag('no-output', negatable: false, help: 'Do not output any files.')
   ..addOption('url-mapping',
       allowMultiple: true,
       help: 'A custom url mapping of the form `<scheme>:<name>::<uri>`.')
   ..addFlag('verbose',
       abbr: 'v',
       negatable: false,
       help: 'Print internal warnings and diagnostics to stderr.')
   ..addFlag('print-metrics',
       negatable: false, help: 'Print performance metrics.')
-  ..addOption('write-dependencies',
-      help: 'Write all the .dart that were loaded to the given file.')
   ..addFlag('verify-ir', help: 'Perform slow internal correctness checks.')
   ..addFlag('tolerant',
       help: 'Generate kernel even if there are compile-time errors.',
       defaultsTo: false)
   ..addOption('D',
       abbr: 'D',
       allowMultiple: true,
       help: 'Define an environment variable.',
       hide: true)
   ..addFlag('show-external',
       help: 'When printing a library as text, also print its dependencies\n'
           'on external libraries.')
   ..addFlag('show-offsets',
-      help: 'When printing a library as text, also print node offsets');
+      help: 'When printing a library as text, also print node offsets')
+  ..addFlag('include-sdk',
+      help: 'Include the SDK in the output. Implied by --link.');
 
 String getUsage() => """
 Usage: dartk [options] FILE
 
 Convert .dart or .dill files to kernel's IR and print out its textual
 or binary form.
 
 Examples:
     dartk foo.dart            # print text IR for foo.dart
     dartk foo.dart -ofoo.dill # write binary IR for foo.dart to foo.dill
@@ skipping 168 matching lines @@
   }
   var applicationRoot = new ApplicationRoot(applicationRootOption);
 
   // Set up logging.
   if (options['verbose']) {
     log.onRecord.listen((LogRecord rec) {
       stderr.writeln(rec.message);
     });
   }
 
-  if (options.rest.length != 1) {
-    return fail('Exactly one FILE should be given.');
+  bool includeSdk = options['include-sdk'];
+
+  List<String> inputFiles = options.rest;
+  if (inputFiles.length < 1 && !includeSdk) {
+    return fail('At least one file should be given.');
   }
 
-  String file = options.rest.single;
-  checkIsFile(file, option: 'Input file');
-  file = new File(file).absolute.path;
-  Uri fileUri = new Uri(scheme: 'file', path: file);
+  bool hasBinaryInput = false;
+  bool hasDartInput = includeSdk;
+  for (String file in inputFiles) {
+    checkIsFile(file, option: 'Input file');
+    if (file.endsWith('.dill')) {
+      hasBinaryInput = true;
+    } else if (file.endsWith('.dart')) {
+      hasDartInput = true;
+    } else {
+      fail('Unrecognized file extension: $file');
+    }
+  }
+
+  if (hasBinaryInput && hasDartInput) {
+    fail('Mixed binary and dart input is not currently supported');
+  }
 
   String format = options['format'] ?? defaultFormat();
   String outputFile = options['out'] ?? defaultOutput();
 
   List<String> urlMapping = options['url-mapping'] as List<String>;
   var customUriMappings = parseCustomUriMappings(urlMapping);
-  var repository = new Repository();
-
-  Program program;
+  var program = new Program();
 
   var watch = new Stopwatch()..start();
-  List<String> loadedFiles;
-  Function getLoadedFiles;
   List errors = const [];
   TargetFlags targetFlags = new TargetFlags(strongMode: options['strong']);
   Target target = getTarget(options['target'], targetFlags);
 
   var declaredVariables = <String, String>{};
   declaredVariables.addAll(target.extraDeclaredVariables);
   for (String define in options['D']) {
     int separator = define.indexOf('=');
     if (separator == -1) {
       fail('Invalid define: -D$define. Format is -D<name>=<value>');
     }
     String name = define.substring(0, separator);
     String value = define.substring(separator + 1);
     declaredVariables[name] = value;
   }
 
-  if (file.endsWith('.dill')) {
-    program = loadProgramFromBinary(file, repository);
-    getLoadedFiles = () => [file];
-  } else {
-    DartOptions dartOptions = new DartOptions(
-        strongMode: target.strongMode,
-        strongModeSdk: target.strongModeSdk,
-        sdk: options['sdk'],
-        packagePath: packagePath,
-        customUriMappings: customUriMappings,
-        declaredVariables: declaredVariables,
-        applicationRoot: applicationRoot);
-    String packageDiscoveryPath = batchModeState.isBatchMode ? null : file;
-    DartLoader loader = await batchModeState.batch.getLoader(
-        repository, dartOptions,
+  DartLoader loader;
+  if (hasDartInput) {
+    String packageDiscoveryPath =
+        batchModeState.isBatchMode || inputFiles.isEmpty
+            ? null
+            : inputFiles.first;
+    loader = await batchModeState.batch.getLoader(
+        program,
+        new DartOptions(
+            strongMode: target.strongMode,
+            strongModeSdk: target.strongModeSdk,
+            sdk: options['sdk'],
+            packagePath: packagePath,
+            customUriMappings: customUriMappings,
+            declaredVariables: declaredVariables,
+            applicationRoot: applicationRoot),
         packageDiscoveryPath: packageDiscoveryPath);
-    if (options['link']) {
-      program = loader.loadProgram(fileUri, target: target);
+  }
+
+  if (includeSdk) {
+    for (var uri in batchModeState.batch.dartSdk.uris) {
+      loader.loadLibrary(Uri.parse(uri));
+    }
+  }
+
+  for (String file in inputFiles) {
+    Uri fileUri = Uri.base.resolve(file);
+
+    if (file.endsWith('.dill')) {
+      loadProgramFromBinary(file, program);
     } else {
-      var library = loader.loadLibrary(fileUri);
-      assert(library ==
-          repository.getLibraryReference(applicationRoot.relativeUri(fileUri)));
-      program = new Program(repository.libraries);
-    }
-    errors = loader.errors;
-    if (errors.isNotEmpty) {
-      const int errorLimit = 100;
-      stderr.writeln(errors.take(errorLimit).join('\n'));
-      if (errors.length > errorLimit) {
-        stderr
-            .writeln('[error] ${errors.length - errorLimit} errors not shown');
+      if (options['link']) {
+        program = loader.loadProgram(fileUri, target: target);
+      } else {
+        var library = loader.loadLibrary(fileUri);
+        assert(library ==
+            program.getLibraryReference(applicationRoot.relativeUri(fileUri)));
+        program.mainMethod ??= library.procedures
+            .firstWhere((p) => p.name.name == 'main', orElse: () => null);
+      }
+      errors = loader.errors;
+      if (errors.isNotEmpty) {
+        const int errorLimit = 100;
+        stderr.writeln(errors.take(errorLimit).join('\n'));
+        if (errors.length > errorLimit) {
+          stderr.writeln(
+              '[error] ${errors.length - errorLimit} errors not shown');
+        }
       }
     }
-    getLoadedFiles = () => loadedFiles ??= loader.getLoadedFileNames();
   }
 
   bool canContinueCompilation = errors.isEmpty || options['tolerant'];
 
   int loadTime = watch.elapsedMilliseconds;
   if (shouldReportMetrics) {
     print('loader.time = $loadTime ms');
   }
 
   void runVerifier() {
     if (options['verify-ir']) {
       verifyProgram(program);
     }
   }
 
   if (canContinueCompilation) {
     runVerifier();
   }
 
-  String outputDependencies = options['write-dependencies'];
-  if (outputDependencies != null) {
-    new File(outputDependencies).writeAsStringSync(getLoadedFiles().join('\n'));
+  if (options['link'] && program.mainMethodName == null) {
+    fail('[error] The program has no main method.');
   }
 
   // Apply target-specific transformations.
   if (target != null && options['link'] && canContinueCompilation) {
     target.transformProgram(program);
     runVerifier();
   }
 
   if (options['no-output']) {
     return CompilerOutcome.Ok;
@@ skipping 23 matching lines @@
 
   await ioFuture;
 
   if (shouldReportMetrics) {
     int flushTime = watch.elapsedMilliseconds - time;
     print('writer.flush_time = $flushTime ms');
   }
 
   return errors.length > 0 ? CompilerOutcome.Fail : CompilerOutcome.Ok;
 }