Add getTarget method to CompilerCommandLine

pkg/front_end/lib/src/fasta/compiler_command_line.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.
 
 library fasta.compiler_command_line;
 
 import 'dart:io' show exit;
 
 import 'command_line.dart' show CommandLine, argumentError;
 
 import 'compiler_context.dart' show CompilerContext;
 
+import 'package:kernel/target/targets.dart' as backend_targets
+    show Target, getTarget, TargetFlags;
+
 const Map<String, dynamic> optionSpecification = const <String, dynamic>{
   "--compile-sdk": Uri,
   "--fatal": ",",
   "--output": Uri,
   "--packages": Uri,
   "--platform": Uri,
   "-o": Uri,
   "--target": String,
   "-t": String,
 };
 
 class CompilerCommandLine extends CommandLine {
   final String programName;
+  backend_targets.Target cachedTarget;
 
   CompilerCommandLine(String programName, List<String> arguments)
       : programName = programName,
         super(arguments,
             specification: optionSpecification,
             usage: computeUsage(programName, false));
 
   bool get verify => options.containsKey("--verify");
 
   bool get dumpIr => options.containsKey("--dump-ir");
@@ skipping 16 matching lines @@
     if (options.containsKey("-o") && options.containsKey("--output")) {
       return argumentError(usage, "Can't specify both '-o' and '--output'.");
     }
     if (options.containsKey("-t") && options.containsKey("--target")) {
       return argumentError(usage, "Can't specify both '-t' and '--target'.");
     }
     if (programName == "compile_platform" && arguments.length != 3) {
       return argumentError(usage, "Expected three arguments.");
     } else if (arguments.isEmpty) {
       return argumentError(usage, "No Dart file specified.");
     }

[ahe, 2017/06/08 14:49:37]

Suggestion:

backend_targets.Target target = backend_targets.getTarget(
    targetName, new backend_targets.TargetFlags(strongMode: strongMode));
if (target == null) {
  return argumentError(usage, "Target '${targetName} not recognized. Valid
targets are:\n  ${backend_targets.targets.join("\n  ")}");
}
options["target"] = target;

And then below:

backend_targets.Target get target => options["target"];

[Dmitry Stefantsov, 2017/06/09 08:24:40]

Thanks for the suggestion! I agree. This way we may show the error message at
the appropriate time. Done.

   }
 
   Uri get output {
     return options["-o"] ?? options["--output"] ?? defaultOutput;
   }
 
   Uri get defaultOutput => Uri.base.resolve("${arguments.first}.dill");
 
   Uri get platform {
     return options.containsKey("--compile-sdk")
@@ skipping 10 matching lines @@
   }
 
   bool get errorsAreFatal => fatal.contains("errors");
 
   bool get warningsAreFatal => fatal.contains("warnings");
 
   bool get nitsAreFatal => fatal.contains("nits");
 
   bool get strongMode => options.containsKey("--strong-mode");
 
   String get target {

[ahe, 2017/06/08 14:49:37]

Rename this to targetName.

[Dmitry Stefantsov, 2017/06/09 08:24:40]

Done.

     return options["-t"] ?? options["--target"] ?? "vm_fasta";
   }
 
+  backend_targets.Target getTarget() {

[ahe, 2017/06/08 14:49:37]

Change this to:

backend_targets.Target get target {

[Dmitry Stefantsov, 2017/06/09 08:24:40]

Done.

+    if (cachedTarget != null) {
+      return cachedTarget;
+    }
+    return cachedTarget = backend_targets.getTarget(

[ahe, 2017/06/08 14:49:37]

Use ??=

[Dmitry Stefantsov, 2017/06/09 08:24:40]

Thanks for the suggestion! It looks way better than if-return-than-return.

Also, now that we use eager caching during parameters validation, we don't need
this method body. But I'll keep the trick for when I need to lazily cache
things.

+        target, new backend_targets.TargetFlags(strongMode: strongMode));
+  }
+
   static dynamic withGlobalOptions(String programName, List<String> arguments,
       dynamic f(CompilerContext context)) {
     return CompilerContext.withGlobalOptions(
         new CompilerCommandLine(programName, arguments), f);
   }
 
   static CompilerCommandLine forRootContext() {
     return new CompilerCommandLine("", [""]);
   }
 }
@@ skipping 84 matching lines @@
     Compile the SDK from scratch instead of reading it from 'platform.dill'.
 
   --fatal=errors
   --fatal=warnings
   --fatal=nits
     Makes messages of the given kinds fatal, that is, immediately stop the
     compiler with a non-zero exit-code. In --verbose mode, also display an
     internal stack trace from the compiler. Multiple kinds can be separated by
     commas, for example, --fatal=errors,warnings.
 """;