Fix main handling in dart2js and add tests.

dart/sdk/lib/_internal/compiler/implementation/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.
 
 part of dart2js;
 
 /**
  * If true, print a warning for each method that was resolved, but not
  * compiled.
  */
@@ skipping 436 matching lines @@
     return true;
   }
 
   /// Called after [element] has been resolved.
   // TODO(johnniwinther): Change [TreeElements] to [Registry] or a dependency
   // node. [elements] is currently unused by the implementation.
   void onElementResolved(Element element, TreeElements elements) {}
 
   // Does this element belong in the output
   bool shouldOutput(Element element) => true;
+
+  FunctionElement helperForBadMain() => null;
+
+  FunctionElement helperForMissingMain() => null;
+
+  FunctionElement helperForMainArity() => null;
 }
 
 /// Backend callbacks function specific to the resolution phase.
 class ResolutionCallbacks {
   /// Register that [node] is a call to `assert`.
   void onAssert(Send node, Registry registry) {}
 
   /// Called during resolution to notify to the backend that the
   /// program uses string interpolation.
   void onStringInterpolation(Registry registry) {}
@@ skipping 808 matching lines @@
       }
     }).then((_) {
       if (!compilationFailed) {
         // TODO(johnniwinther): Reenable analysis of programs with load failures
         // when these are handled as erroneous libraries/compilation units.
         compileLoadedLibraries();
       }
     });
   }
 
+  void computeMain() {
+    if (mainApp == null) return;
+
+    Element main = mainApp.findExported(MAIN);
+    if (main == null) {
+      if (analyzeOnly) {
+        if (!analyzeAll) {
+          reportWarning(
+              mainApp, MessageKind.CONSIDER_ANALYZE_ALL, {'main': MAIN});
+        }
+      } else {
+        // Compilation requires a main method.
+        reportWarning(mainApp, MessageKind.MISSING_MAIN, {'main': MAIN});
+      }
+      mainFunction = backend.helperForMissingMain();
+    } else if (main.isErroneous && main.isSynthesized) {
+      if (main is ErroneousElement) {
+        reportWarning(main, main.messageKind, main.messageArguments);
+      } else {
+        internalError(main, 'Problem with $MAIN.');
+      }
+      mainFunction = backend.helperForBadMain();
+    } else if (!main.isFunction) {
+      reportWarning(main, MessageKind.MAIN_NOT_A_FUNCTION, {'main': MAIN});
+      mainFunction = backend.helperForBadMain();
+    } else {
+      mainFunction = main;
+      FunctionSignature parameters = mainFunction.computeSignature(this);
+      if (parameters.requiredParameterCount > 2) {
+        int index = 0;
+        parameters.orderedForEachParameter((Element parameter) {
+          if (index++ < 2) return;
+          reportWarning(
+              parameter, MessageKind.MAIN_WITH_EXTRA_PARAMETER, {'main': MAIN});
+          mainFunction = backend.helperForMainArity();
+          // Don't warn about main not being used:
+          enqueuer.resolution.registerStaticUse(main);
+        });
+      }
+    }
+    if (mainFunction == null) {
+      internalError(mainApp, 'Unable to find method "$MAIN".');

[Johnni Winther, 2014/07/11 13:19:26]

dart2dart will result in [internalError] instead of [reportFatalError]. Can you
avoid that regression?

[ahe, 2014/07/11 13:24:01]

Yes. I'll call reportFatalError instead. How about this message:

Compilation aborted due to problem with "$MAIN" method.

[Johnni Winther, 2014/07/13 12:31:43]

Sounds good.

+    }
+  }
+
   /// Performs the compilation when all libraries have been loaded.
   void compileLoadedLibraries() {
-    Element main = null;
-    if (mainApp != null) {
-      main = mainApp.findExported(MAIN);
-      if (main == null) {
-        if (!analyzeOnly) {
-          // Allow analyze only of libraries with no main.
-          reportFatalError(
-              mainApp,
-              MessageKind.GENERIC,
-              {'text': "Could not find '$MAIN'."});
-        } else if (!analyzeAll) {
-          reportFatalError(mainApp, MessageKind.GENERIC,
-              {'text': "Could not find '$MAIN'. "
-                       "No source will be analyzed. "
-                       "Use '--analyze-all' to analyze all code in the "
-                       "library."});
-        }
-      } else {
-        if (main.isErroneous && main.isSynthesized) {
-          reportFatalError(main, MessageKind.GENERIC,
-              {'text': "Cannot determine which '$MAIN' to use."});
-        } else if (!main.isFunction) {
-          reportFatalError(main, MessageKind.GENERIC,
-              {'text': "'$MAIN' is not a function."});
-        }
-        mainFunction = main;
-        FunctionSignature parameters = mainFunction.computeSignature(this);
-        if (parameters.parameterCount > 2) {
-          int index = 0;
-          parameters.forEachParameter((Element parameter) {
-            if (index++ < 2) return;
-            reportError(parameter, MessageKind.GENERIC,
-                {'text': "'$MAIN' cannot have more than two parameters."});
-          });
-        }
-      }
+    computeMain();
 
-      mirrorUsageAnalyzerTask.analyzeUsage(mainApp);
+    mirrorUsageAnalyzerTask.analyzeUsage(mainApp);
 
-      // In order to see if a library is deferred, we must compute the
-      // compile-time constants that are metadata.  This means adding
-      // something to the resolution queue.  So we cannot wait with
-      // this until after the resolution queue is processed.
-      deferredLoadTask.ensureMetadataResolved(this);
-    }
+    // In order to see if a library is deferred, we must compute the
+    // compile-time constants that are metadata.  This means adding
+    // something to the resolution queue.  So we cannot wait with
+    // this until after the resolution queue is processed.
+    deferredLoadTask.ensureMetadataResolved(this);
 
     phase = PHASE_RESOLVING;
     if (analyzeAll) {
       libraryLoader.libraries.forEach((LibraryElement library) {
         log('Enqueuing ${library.canonicalUri}');
         fullyEnqueueLibrary(library, enqueuer.resolution);
       });
     } else if (analyzeMain && mainApp != null) {
       fullyEnqueueLibrary(mainApp, enqueuer.resolution);
     }
     // Elements required by enqueueHelpers are global dependencies
     // that are not pulled in by a particular element.
     backend.enqueueHelpers(enqueuer.resolution, globalDependencies);
     resolveLibraryMetadata();
     log('Resolving...');
-    processQueue(enqueuer.resolution, main);
+    processQueue(enqueuer.resolution, mainFunction);
     enqueuer.resolution.logSummary(log);
 
     if (compilationFailed) return;
     if (!showPackageWarnings && !suppressWarnings) {
       suppressedWarnings.forEach((Uri uri, SuppressionInfo info) {
         MessageKind kind = MessageKind.HIDDEN_WARNINGS_HINTS;
         if (info.warnings == 0) {
           kind = MessageKind.HIDDEN_HINTS;
         } else if (info.hints == 0) {
           kind = MessageKind.HIDDEN_WARNINGS;
         }
         reportDiagnostic(null,
             kind.message({'warnings': info.warnings,
                           'hints': info.hints,
                           'uri': uri},
                          terseDiagnostics),
             api.Diagnostic.HINT);
       });
     }
     if (analyzeOnly) {
       if (!analyzeAll) {
         // No point in reporting unused code when [analyzeAll] is true: all
         // code is artificially used.
         reportUnusedCode();
       }
       return;
     }
-    assert(main != null);
+    assert(mainFunction != null);
     phase = PHASE_DONE_RESOLVING;
 
     // TODO(ahe): Remove this line. Eventually, enqueuer.resolution
     // should know this.
     world.populate();
     // Compute whole-program-knowledge that the backend needs. (This might
     // require the information computed in [world.populate].)
     backend.onResolutionComplete();
 
-    deferredLoadTask.onResolutionComplete(main);
+    deferredLoadTask.onResolutionComplete(mainFunction);
 
     log('Building IR...');
     irBuilder.buildNodes();
 
     log('Inferring types...');
-    typesTask.onResolutionComplete(main);
+    typesTask.onResolutionComplete(mainFunction);
 
     if(stopAfterTypeInference) return;
 
     log('Compiling...');
     phase = PHASE_COMPILING;
     // TODO(johnniwinther): Move these to [CodegenEnqueuer].
     if (hasIsolateSupport) {
       backend.enableIsolateSupport(enqueuer.codegen);
-      enqueuer.codegen.registerGetOfStaticFunction(main);
+      enqueuer.codegen.registerGetOfStaticFunction(mainFunction);
     }
     if (enabledNoSuchMethod) {
       backend.enableNoSuchMethod(enqueuer.codegen);
     }
     if (compileAll) {
       libraryLoader.libraries.forEach((LibraryElement library) {
         fullyEnqueueLibrary(library, enqueuer.codegen);
       });
     }
-    processQueue(enqueuer.codegen, main);
+    processQueue(enqueuer.codegen, mainFunction);
     enqueuer.codegen.logSummary(log);
 
     if (compilationFailed) return;
 
     backend.assembleProgram();
 
     if (dumpInfo) {
       dumpInfoTask.dumpInfo();
     }
 
@@ skipping 602 matching lines @@
   static NullSink outputProvider(String name, String extension) {
     return new NullSink('$name.$extension');
   }
 }
 
 /// Information about suppressed warnings and hints for a given library.
 class SuppressionInfo {
   int warnings = 0;
   int hints = 0;
 }