simplify and remove unnecessary checks in kernel service

utils/kernel-service/kernel-service.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.
 
 /// This is an interface to the Dart Kernel parser and Kernel binary generator.
 ///
 /// It is used by the kernel-isolate to load Dart source code and generate
 /// Kernel binary format.
 ///
 /// This is either invoked as the root script of the Kernel isolate when used
@@ skipping 18 matching lines @@
 import 'package:front_end/front_end.dart';
 import 'package:front_end/memory_file_system.dart';
 import 'package:front_end/physical_file_system.dart';
 import 'package:front_end/src/fasta/kernel/utils.dart';
 import 'package:front_end/src/testing/hybrid_file_system.dart';
 import 'package:kernel/kernel.dart' show Program;
 import 'package:kernel/target/targets.dart' show TargetFlags;
 import 'package:kernel/target/vm_fasta.dart' show VmFastaTarget;
 
 const bool verbose = const bool.fromEnvironment('DFE_VERBOSE');
-
 const bool strongMode = const bool.fromEnvironment('DFE_STRONG_MODE');
 
-Future<CompilationResult> _parseScriptInFileSystem(
-    Uri script, FileSystem fileSystem,
-    {bool verbose: false, bool strongMode: false}) async {
-  final Uri packagesUri = (Platform.packageConfig != null)
-      ? Uri.parse(Platform.packageConfig)
-      : null;
-
-  final Uri patchedSdk = Uri.base
-      .resolveUri(new Uri.file(Platform.resolvedExecutable))
-      .resolveUri(new Uri.directory("patched_sdk"));
-
-  if (verbose) {
-    print("""DFE: Requesting compilation {
-  scriptUri: ${script}
-  packagesUri: ${packagesUri}
-  patchedSdk: ${patchedSdk}
-}""");
-  }
-
-  try {
-    var errors = <String>[];
-    var options = new CompilerOptions()
-      ..strongMode = strongMode
-      ..fileSystem = fileSystem
-      ..target = new VmFastaTarget(new TargetFlags(strongMode: strongMode))
-      ..packagesFileUri = packagesUri
-      // TODO(sigmund): use outline.dill when the mixin transformer is modular.
-      ..sdkSummary = patchedSdk.resolve('platform.dill')
-      ..verbose = verbose
-      ..onError = (CompilationError e) => errors.add(e.message);
-
-    Program program = await kernelForProgram(script, options);
-    if (errors.isNotEmpty) return new CompilationResult.errors(errors);
-
-    // We serialize the program excluding platform.dill because the VM has these
-    // sources built-in. Everything loaded as a summary in [kernelForProgram] is
-    // marked `external`, so we can use that bit to decide what to excluce.
-    // TODO(sigmund): remove the following line (Issue #30111)
-    program.libraries.forEach((e) => e.isExternal = false);
-    return new CompilationResult.ok(
-        serializeProgram(program, filter: (lib) => !lib.isExternal));
-  } catch (err, stack) {
-    return new CompilationResult.crash(err, stack);
-  }
-}
-
-Future<CompilationResult> _processLoadRequestImpl(
-    String inputFilePathOrUri, FileSystem fileSystem) {
-  Uri scriptUri = Uri.parse(inputFilePathOrUri);
-
-  // Because we serve both Loader and bootstrapping requests we need to
-  // duplicate the logic from _resolveScriptUri(...) here and attempt to
-  // resolve schemaless uris using current working directory.
-  if (!scriptUri.hasScheme) {
-    // Script does not have a scheme, assume that it is a path,
-    // resolve it against the working directory.
-    scriptUri = Uri.base.resolveUri(new Uri.file(inputFilePathOrUri));
-  }
-
-  if (!scriptUri.isScheme('file')) {
-    // TODO(vegorov): Reuse loader code to support other schemes.
-    return new Future<CompilationResult>.value(new CompilationResult.errors(
-        ["Expected 'file' scheme for a script uri: got ${scriptUri.scheme}"]));
-  }
-  return _parseScriptInFileSystem(scriptUri, fileSystem,
-      verbose: verbose, strongMode: strongMode);
-}
-
 // Process a request from the runtime. See KernelIsolate::CompileToKernel in
 // kernel_isolate.cc and Loader::SendKernelRequest in loader.cc.
 Future _processLoadRequest(request) async {
-  if (verbose) {
-    print("DFE: request: $request");
-    print("DFE: Platform.packageConfig: ${Platform.packageConfig}");
-    print("DFE: Platform.resolvedExecutable: ${Platform.resolvedExecutable}");
-  }
+  if (verbose) print("DFE: request: $request");
 
   int tag = request[0];
   final SendPort port = request[1];
-  final String inputFileUrl = request[2];
+  final String inputFileUri = request[2];
+  final Uri script = Uri.base.resolve(inputFileUri);
+
   FileSystem fileSystem = request.length > 3
       ? _buildFileSystem(request[3])
       : PhysicalFileSystem.instance;
 
+  Uri packagesUri = (Platform.packageConfig != null)
+      ? Uri.parse(Platform.packageConfig)
+      : null;
+
+  Uri sdkSummary = Uri.base
+      .resolveUri(new Uri.file(Platform.resolvedExecutable))
+      .resolveUri(new Uri.directory("patched_sdk"))
+      // TODO(sigmund): use outline.dill when the mixin transformer is modular.
+      .resolve('platform.dill');
+
+  if (verbose) {
+    print("DFE: scriptUri: ${script}");
+    print("DFE: Platform.packageConfig: ${Platform.packageConfig}");
+    print("DFE: packagesUri: ${packagesUri}");
+    print("DFE: Platform.resolvedExecutable: ${Platform.resolvedExecutable}");
+    print("DFE: sdkSummary: ${sdkSummary}");
+  }
+
+  var errors = <String>[];
+  var options = new CompilerOptions()
+    ..strongMode = strongMode
+    ..fileSystem = fileSystem
+    ..target = new VmFastaTarget(new TargetFlags(strongMode: strongMode))
+    ..packagesFileUri = packagesUri
+    ..sdkSummary = sdkSummary
+    ..verbose = verbose
+    ..onError = (CompilationError e) => errors.add(e.message);
+
   CompilationResult result;
   try {
-    result = await _processLoadRequestImpl(inputFileUrl, fileSystem);
+    Program program = await kernelForProgram(script, options);
+    if (errors.isNotEmpty) {
+      result = new CompilationResult.errors(errors);
+    } else {
+      // We serialize the program excluding platform.dill because the VM has
+      // these sources built-in. Everything loaded as a summary in
+      // [kernelForProgram] is marked `external`, so we can use that bit to
+      // decide what to excluce.
+      // TODO(sigmund): remove the following line (Issue #30111)
+      program.libraries.forEach((e) => e.isExternal = false);
+      result = new CompilationResult.ok(
+          serializeProgram(program, filter: (lib) => !lib.isExternal));
+    }
   } catch (error, stack) {
     result = new CompilationResult.crash(error, stack);
   }
 
-  if (verbose) {
-    print("DFE:> ${result}");
-  }
+  if (verbose) print("DFE:> ${result}");
 
   // Check whether this is a Loader request or a bootstrapping request from
   // KernelIsolate::CompileToKernel.
   final isBootstrapRequest = tag == null;
   if (isBootstrapRequest) {
     port.send(result.toResponse());
   } else {
     // See loader.cc for the code that handles these replies.
     if (result.status != Status.ok) {
       tag = -tag;
     }
-    port.send([tag, inputFileUrl, inputFileUrl, null, result.payload]);
+    port.send([tag, inputFileUri, inputFileUri, null, result.payload]);
   }
 }
 
 /// Creates a file system containing the files specified in [namedSources] and
 /// that delegates to the underlying file system for any other file request.
 /// The [namedSources] list interleaves file name string and
 /// raw file content Uint8List.
 ///
 /// The result can be used instead of PhysicalFileSystem.instance by the
 /// frontend.
@@ skipping 116 matching lines @@
   _CompilationCrash(this.exception, this.stack);
 
   @override
   Status get status => Status.crash;
 
   @override
   String get errorString => "${exception}\n${stack}";
 
   String toString() => "_CompilationCrash(${errorString})";
 }