Add option --compile-sdk to fasta compile and run.

pkg/front_end/lib/src/fasta/kernel/kernel_target.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.kernel_target;
 
 import 'dart:async' show
     Future;
 
 import 'dart:io' show
@@ skipping 189 matching lines @@
     builder.interfaces = null;
   }
 
   Future<Program> handleInputError(Uri uri, InputError error,
       {bool isFullProgram}) {
     if (error != null) {
       String message = error.format();
       print(message);
       errors.add(message);
     }
-    program = erroneousProgram();
+    program = erroneousProgram(isFullProgram);
     return uri == null
         ? new Future<Program>.value(program)
         : writeLinkedProgram(uri, program, isFullProgram: isFullProgram);
   }
 
   Future<Program> writeProgram(Uri uri, AstKind astKind) async {
     if (loader.first == null) return null;
     if (errors.isNotEmpty) {
       return handleInputError(uri, null, isFullProgram: true);
     }
@@ skipping 37 matching lines @@
       program = link(new List<Library>.from(loader.libraries));
       if (uri == null) return program;
       return await writeLinkedProgram(uri, program, isFullProgram: false);
     } on InputError catch (e) {
       return handleInputError(uri, e, isFullProgram: false);
     } catch (e, s) {
       return reportCrash(e, s, loader?.currentUriForCrashReporting);
     }
   }
 
-  Program erroneousProgram() {
+  Program erroneousProgram(bool isFullProgram) {
     Uri uri = loader.first?.uri ?? Uri.parse("error:error");
     KernelLibraryBuilder library = new KernelLibraryBuilder(uri, loader);
-    KernelProcedureBuilder mainBuilder = new KernelProcedureBuilder(null, 0,
-        null, "main", null, null, AsyncMarker.Sync, ProcedureKind.Method);
-    library.addBuilder(mainBuilder.name, mainBuilder);
     loader.first = library;
-    mainBuilder.body = new ExpressionStatement(
-        new Throw(new StringLiteral("${errors.join('\n')}")));
+    if (isFullProgram) {

[ahe, 2017/02/03 14:37:12]

If we're generated an outline, we shouldn't add an executable main method.

[Siggi Cherem (dart-lang), 2017/02/03 18:16:57]

makes sense - same thing in the future when generating a single library or a set
of libraries as a separate module.

[ahe, 2017/02/03 19:34:14]

Good point. I should turn this into a comment. Also, another note would be to
say that there should probably be a way to record a compile time error in dill
file.

[ahe, 2017/02/03 20:03:36]

Done.

+      KernelProcedureBuilder mainBuilder = new KernelProcedureBuilder(null, 0,
+          null, "main", null, null, AsyncMarker.Sync, ProcedureKind.Method);
+      library.addBuilder(mainBuilder.name, mainBuilder);
+      mainBuilder.body = new ExpressionStatement(
+          new Throw(new StringLiteral("${errors.join('\n')}")));
+    }
     library.build();
     return link(<Library>[library.library]);
   }
 
   /// Creates a program by combining [libraries] with the libraries of
   /// `dillTarget.loader.program`.
   Program link(List<Library> libraries) {
     Map<String, Source> uriToSource = <String, Source>{};
 
     // for (Library library in libraries) {
@@ skipping 292 matching lines @@
     superclass = superclass.superclass;
   }
   for (Constructor constructor in superclass.constructors) {
     if (constructor.name.name.isEmpty) {
       return constructor.function.requiredParameterCount == 0 ?
           constructor : null;
     }
   }
   return null;
 }