dart2js: Add test to compile empty main without any libraries.

tests/compiler/dart2js/mock_compiler.dart

 // Copyright (c) 2012, 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 mock_compiler;
 
 import "package:expect/expect.dart";
 import 'dart:async';
 import 'dart:collection';
 
@@ skipping 32 matching lines @@
 class WarningMessage {
   Spannable node;
   Message message;
   WarningMessage(this.node, this.message);
 
   toString() => message.kind.toString();
 }
 
 final Uri PATCH_CORE = new Uri(scheme: 'patch', path: 'core');
 
+typedef String LibrarySourceProvider(Uri uri);
+
 class MockCompiler extends Compiler {
   api.DiagnosticHandler diagnosticHandler;
   List<WarningMessage> warnings;
   List<WarningMessage> errors;
   List<WarningMessage> hints;
   List<WarningMessage> infos;
   List<WarningMessage> crashes;
   /// Expected number of warnings. If `null`, the number of warnings is
   /// not checked.
   final int expectedWarnings;
   /// Expected number of errors. If `null`, the number of errors is not checked.
   final int expectedErrors;
   final Map<String, SourceFile> sourceFiles;
   Node parsedTree;
   final String testedPatchVersion;
+  final LibrarySourceProvider librariesOverride;
 
   MockCompiler.internal(
       {Map<String, String> coreSource,
        bool enableTypeAssertions: false,
        bool enableMinification: false,
        bool enableConcreteTypeInference: false,
        int maxConcreteTypeSize: 5,
        bool disableTypeInference: false,
        bool analyzeAll: false,
        bool analyzeOnly: false,
        bool emitJavaScript: true,
        bool preserveComments: false,
        // Our unit tests check code generation output that is
        // affected by inlining support.
        bool disableInlining: true,
        bool trustTypeAnnotations: false,
        bool enableAsyncAwait: false,
        int this.expectedWarnings,
        int this.expectedErrors,
        api.CompilerOutputProvider outputProvider,
-       String patchVersion})
+       String patchVersion,
+       LibrarySourceProvider this.librariesOverride})
       : sourceFiles = new Map<String, SourceFile>(),
         testedPatchVersion = patchVersion,
         super(enableTypeAssertions: enableTypeAssertions,
               enableMinification: enableMinification,
               enableConcreteTypeInference: enableConcreteTypeInference,
               maxConcreteTypeSize: maxConcreteTypeSize,
               disableTypeInferenceFlag: disableTypeInference,
               analyzeAllFlag: analyzeAll,
               analyzeOnly: analyzeOnly,
               emitJavaScript: emitJavaScript,
@@ skipping 61 matching lines @@
                  expectedWarnings != warnings.length) {
         throw "unexpected warnings during compilation ${warnings}";
       } else {
         return result;
       }
     });
   }
 
   /**
    * Registers the [source] with [uri] making it possible load [source] as a
-   * library.
+   * library.  If an override has been provided in [librariesOverride], that
+   * is used instead.
    */
   void registerSource(Uri uri, String source) {
+    if (librariesOverride != null) {
+      String override = librariesOverride(uri);
+      if (override != null) {
+        source = override;
+      }
+    }
     sourceFiles[uri.toString()] = new MockFile(source);
   }
 
   // TODO(johnniwinther): Remove this when we don't filter certain type checker
   // warnings.
   void reportWarning(Spannable node, MessageKind messageKind,
                      [Map arguments = const {}]) {
     MessageTemplate template = MessageTemplate.TEMPLATES[messageKind];
     reportDiagnostic(node,
                      template.message(arguments, terseDiagnostics),
@@ skipping 230 matching lines @@
   MockElement(Element enclosingElement)
       : super('', ElementKind.FUNCTION, Modifiers.EMPTY,
               enclosingElement);
 
   get node => null;
 
   parseNode(_) => null;
 
   bool get hasNode => false;
 }