Tweak public APIs and use them in patch_sdk, dart2js, and kernel-service

pkg/front_end/test/src/base/processed_options_test.dart

 // Copyright (c) 2017, 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 'package:front_end/compiler_options.dart';
 import 'package:front_end/memory_file_system.dart';
 import 'package:front_end/src/base/processed_options.dart';
 import 'package:front_end/src/fasta/fasta.dart' show ByteSink;
 import 'package:kernel/binary/ast_to_binary.dart' show BinaryPrinter;
-import 'package:kernel/kernel.dart' show Program, Library;
+import 'package:kernel/kernel.dart' show Program, Library, CanonicalName;
 
 import 'package:test/test.dart';
 import 'package:test_reflective_loader/test_reflective_loader.dart';

[ahe, 2017/07/06 13:12:22]

Not a big fan of this.

 
 main() {
   defineReflectiveSuite(() {
     defineReflectiveTests(ProcessedOptionsTest);
   });
 }
 
 @reflectiveTest
 class ProcessedOptionsTest {
   final fileSystem = new MemoryFileSystem(Uri.parse('file:///'));
 
   Program _mockOutline;
 
   Program get mockSummary => _mockOutline ??=
       new Program(libraries: [new Library(Uri.parse('file:///a/b.dart'))]);

[ahe, 2017/07/06 13:12:22]

As far as I can tell, this file relies heavily on the assumption that its being
run on a machine that doesn't have a the following directories:

/a
/sdk
etc.

This is super brittle and easily avoided by using custom URI schemes.

[Paul Berry, 2017/07/06 14:20:05]

Actually it doesn't matter what directories exist on the machine, since we're
using a MemoryFileSystem.  The physical file system is never examined.

[Siggi Cherem (dart-lang), 2017/07/06 19:05:28]

exactly.

Note however that new test files I added (for summary_generator and
kernel_generator) do use a hybrid system to read sources from memory, but sdk
and outline.dill files from disk. I still think it is safe due to how ew overlay
them.

[ahe, 2017/07/11 09:34:26]

I think it matters for the same reason as this is problematic:

    const bool isTrue = false;

Using file URIs as fake URIs is brittle, especially since we also have a hybrid
file system.

[Siggi Cherem (dart-lang), 2017/07/11 23:16:32]

Next time we see each other we can discuss more about this. For now I filed
https://github.com/dart-lang/sdk/issues/30141

 
   test_compileSdk_false() {
     for (var value in [false, true]) {
       var raw = new CompilerOptions()..compileSdk = value;
       var processed = new ProcessedOptions(raw);
       expect(processed.compileSdk, value);
     }
   }
 
+  test_sdk_summary_inferred() {
+    // The sdk-summary is inferred by default form sdk-root, when compile-sdk is
+    // false
+    var raw = new CompilerOptions()
+      ..sdkRoot = Uri.parse('file:///sdk/dir/')
+      ..compileSdk = false;
+    expect(new ProcessedOptions(raw).sdkSummary,
+        Uri.parse('file:///sdk/dir/outline.dill'));
+
+    // But it is left null when compile-sdk is true
+    raw = new CompilerOptions()
+      ..sdkRoot = Uri.parse('file:///sdk/dir/')
+      ..compileSdk = true;
+    expect(new ProcessedOptions(raw).sdkSummary, null);
+  }
+
   test_fileSystem_noBazelRoots() {
     // When no bazel roots are specified, the filesystem should be passed
     // through unmodified.
     var raw = new CompilerOptions()..fileSystem = fileSystem;
     var processed = new ProcessedOptions(raw);
     expect(processed.fileSystem, same(fileSystem));
   }
 
   test_getSdkSummary_summaryLocationProvided() async {
     var uri = Uri.parse('file:///sdkSummary');
     writeMockSummaryTo(uri);
     checkMockSummary(new CompilerOptions()
       ..fileSystem = fileSystem
       ..sdkSummary = uri);
   }
 
   void writeMockSummaryTo(Uri uri) {
     var sink = new ByteSink();
     new BinaryPrinter(sink).writeProgramFile(mockSummary);
     fileSystem.entityForUri(uri).writeAsBytesSync(sink.builder.takeBytes());
   }
 
   Future<Null> checkMockSummary(CompilerOptions raw) async {
     var processed = new ProcessedOptions(raw);
-    var sdkSummary = await processed.sdkSummaryProgram;
+    var sdkSummary = await processed.loadSdkSummary(new CanonicalName.root());
     expect(sdkSummary.libraries.single.importUri,
         mockSummary.libraries.single.importUri);
   }
 
   test_getUriTranslator_explicitPackagesFile() async {
     // This .packages file should be ignored.
     fileSystem
         .entityForUri(Uri.parse('file:///.packages'))
         .writeAsStringSync('foo:bar\n');
     // This one should be used.
@@ skipping 31 matching lines @@
     fileSystem
         .entityForUri(Uri.parse('file:///.packages'))
         .writeAsStringSync('foo:bar\n');
     var raw = new CompilerOptions()
       ..fileSystem = fileSystem
       ..packagesFileUri = new Uri();
     var processed = new ProcessedOptions(raw);
     var uriTranslator = await processed.getUriTranslator();
     expect(uriTranslator.packages, isEmpty);
   }
+
+  test_validateOptions_root_exists() async {
+    var sdkRoot = Uri.parse('file:///sdk/root/');
+    fileSystem
+        // Note: this test is a bit hackish because the memory file system
+        // doesn't have the notion of directories.
+        .entityForUri(sdkRoot)
+        .writeAsStringSync('\n');
+    fileSystem
+        .entityForUri(sdkRoot.resolve('outline.dill'))
+        .writeAsStringSync('\n');
+
+    var errors = [];
+    var raw = new CompilerOptions()
+      ..sdkRoot = sdkRoot
+      ..fileSystem = fileSystem
+      ..onError = (e) => errors.add(e);
+    var options = new ProcessedOptions(raw);
+    var result = await options.validateOptions();
+    // Note: we check this first so test failures show the cause directly.
+    expect(errors, isEmpty);
+    expect(result, isTrue);
+  }
+
+  test_validateOptions_root_doesnt_exists() async {
+    var sdkRoot = Uri.parse('file:///sdk/root');
+    var errors = [];
+    var raw = new CompilerOptions()
+      ..sdkRoot = sdkRoot
+      ..fileSystem = fileSystem
+      ..onError = (e) => errors.add(e);
+    var options = new ProcessedOptions(raw);
+    expect(await options.validateOptions(), isFalse);
+    expect('${errors.first}', contains("SDK root directory not found"));
+  }
+
+  test_validateOptions_summary_exists() async {
+    var sdkSummary = Uri.parse('file:///sdk/root/outline.dill');
+    fileSystem.entityForUri(sdkSummary).writeAsStringSync('\n');
+
+    var errors = [];
+    var raw = new CompilerOptions()
+      ..sdkSummary = sdkSummary
+      ..fileSystem = fileSystem
+      ..onError = (e) => errors.add(e);
+    var options = new ProcessedOptions(raw);
+    var result = await options.validateOptions();
+    expect(errors, isEmpty);
+    expect(result, isTrue);
+  }
+
+  test_validateOptions_summary_doesnt_exists() async {
+    var sdkSummary = Uri.parse('file:///sdk/root/outline.dill');
+    var errors = [];
+    var raw = new CompilerOptions()
+      ..sdkSummary = sdkSummary
+      ..fileSystem = fileSystem
+      ..onError = (e) => errors.add(e);
+    var options = new ProcessedOptions(raw);
+    expect(await options.validateOptions(), isFalse);
+    expect('${errors.first}', contains("SDK summary not found"));
+  }
+
+  test_validateOptions_inferred_summary_exists() async {
+    var sdkRoot = Uri.parse('file:///sdk/root/');
+    var sdkSummary = Uri.parse('file:///sdk/root/outline.dill');
+    fileSystem.entityForUri(sdkRoot).writeAsStringSync('\n');
+    fileSystem.entityForUri(sdkSummary).writeAsStringSync('\n');
+
+    var errors = [];
+    var raw = new CompilerOptions()
+      ..sdkRoot = sdkRoot
+      ..fileSystem = fileSystem
+      ..onError = (e) => errors.add(e);
+    var options = new ProcessedOptions(raw);
+    var result = await options.validateOptions();
+    expect(errors, isEmpty);
+    expect(result, isTrue);
+  }
+
+  test_validateOptions_inferred_summary_doesnt_exists() async {
+    var sdkRoot = Uri.parse('file:///sdk/root/');
+    var sdkSummary = Uri.parse('file:///sdk/root/outline.dill');
+    fileSystem.entityForUri(sdkRoot).writeAsStringSync('\n');
+    var errors = [];
+    var raw = new CompilerOptions()
+      ..sdkSummary = sdkSummary
+      ..fileSystem = fileSystem
+      ..onError = (e) => errors.add(e);
+    var options = new ProcessedOptions(raw);
+    expect(await options.validateOptions(), isFalse);
+    expect('${errors.first}', contains("SDK summary not found"));
+  }
 }