Run closed_world2_test using the normal compiler pipeline.

pkg/compiler/lib/src/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 dart2js.compiler_base;
 
 import 'dart:async' show Future;
 
 import '../compiler_new.dart' as api;
 import 'closure.dart' as closureMapping show ClosureTask;
 import 'common/names.dart' show Selectors;
-import 'common/names.dart' show Identifiers, Uris;
+import 'common/names.dart' show Uris;
 import 'common/resolution.dart'
     show
         ParsingContext,
         Resolution,
         ResolutionWorkItem,
         ResolutionImpact,
         Target;
 import 'common/tasks.dart' show CompilerTask, GenericTask, Measurer;
 import 'common/work.dart' show WorkItem;
 import 'common.dart';
 import 'compile_time_constants.dart';
 import 'constants/values.dart';
 import 'common_elements.dart' show CommonElements, ElementEnvironment;
 import 'deferred_load.dart' show DeferredLoadTask;
 import 'diagnostics/code_location.dart';
 import 'diagnostics/diagnostic_listener.dart' show DiagnosticReporter;
 import 'diagnostics/invariant.dart' show REPORT_EXCESS_RESOLUTION;
 import 'diagnostics/messages.dart' show Message, MessageTemplate;
 import 'dump_info.dart' show DumpInfoTask;
 import 'elements/elements.dart';
 import 'elements/entities.dart';
-import 'elements/modelx.dart' show ErroneousElementX;
 import 'elements/resolution_types.dart' show ResolutionDartType, Types;
 import 'elements/types.dart' show DartTypes;
 import 'enqueue.dart' show Enqueuer, EnqueueTask, ResolutionEnqueuer;
 import 'environment.dart';
 import 'frontend_strategy.dart';
 import 'id_generator.dart';
 import 'io/source_information.dart' show SourceInformation;
 import 'js_backend/backend.dart' show JavaScriptBackend;
 import 'kernel/kernel_strategy.dart';
 import 'library_loader.dart'
@@ skipping 14 matching lines @@
 import 'resolved_uri_translator.dart';
 import 'scanner/scanner_task.dart' show ScannerTask;
 import 'script.dart' show Script;
 import 'serialization/task.dart' show SerializationTask;
 import 'ssa/nodes.dart' show HInstruction;
 import 'package:front_end/src/fasta/scanner.dart' show StringToken, Token;
 import 'tokens/token_map.dart' show TokenMap;
 import 'tree/tree.dart' show Node, TypeAnnotation;
 import 'typechecker.dart' show TypeCheckerTask;
 import 'types/types.dart' show GlobalTypeInferenceTask;
-import 'universe/call_structure.dart' show CallStructure;
 import 'universe/selector.dart' show Selector;
 import 'universe/world_builder.dart'
     show ResolutionWorldBuilder, CodegenWorldBuilder;
 import 'universe/use.dart' show StaticUse, TypeUse;
 import 'universe/world_impact.dart'
     show ImpactStrategy, WorldImpact, WorldImpactBuilderImpl;
 import 'util/util.dart' show Link;
 import 'world.dart' show ClosedWorld, ClosedWorldRefiner, ClosedWorldImpl;
 
 typedef CompilerDiagnosticReporter MakeReporterFunction(
@@ skipping 27 matching lines @@
    */
   bool stopAfterTypeInference = false;
 
   /// Output provider from user of Compiler API.
   api.CompilerOutput userOutputProvider;
 
   List<Uri> librariesToAnalyzeWhenRun;
 
   ResolvedUriTranslator get resolvedUriTranslator;
 
-  LibraryElement mainApp;
-  MethodElement mainFunction;
+  LibraryEntity mainApp;
+  FunctionEntity mainFunction;
 
   DiagnosticReporter get reporter => _reporter;
   ElementEnvironment get elementEnvironment => _elementEnvironment;
   CommonElements get commonElements => _commonElements;
   Resolution get resolution => _resolution;
   ParsingContext get parsingContext => _parsingContext;
 
   // TODO(zarah): Remove this map and incorporate compile-time errors
   // in the model.
   /// Tracks elements with compile-time errors.
@@ skipping 330 matching lines @@
     if (uri != null) {
       if (options.analyzeOnly) {
         reporter.log('Analyzing $uri (${options.buildId})');
       } else {
         reporter.log('Compiling $uri (${options.buildId})');
       }
       LoadedLibraries libraries = await libraryLoader.loadLibrary(uri);
       processLoadedLibraries(libraries);
       mainApp = libraries.rootLibrary;
     }
-    compileLoadedLibraries();
-  }
-
-  WorldImpact computeMain() {
-    if (mainApp == null) return const WorldImpact();
-
-    WorldImpactBuilderImpl impactBuilder = new WorldImpactBuilderImpl();
-    Element main = mainApp.findExported(Identifiers.main);
-    ErroneousElement errorElement = null;
-    if (main == null) {
-      if (options.analyzeOnly) {
-        if (!analyzeAll) {
-          errorElement = new ErroneousElementX(MessageKind.CONSIDER_ANALYZE_ALL,
-              {'main': Identifiers.main}, Identifiers.main, mainApp);
-        }
-      } else {
-        // Compilation requires a main method.
-        errorElement = new ErroneousElementX(MessageKind.MISSING_MAIN,
-            {'main': Identifiers.main}, Identifiers.main, mainApp);
-      }
-      mainFunction = backend.helperForMissingMain();
-    } else if (main.isError && main.isSynthesized) {
-      if (main is ErroneousElement) {
-        errorElement = main;
-      } else {
-        reporter.internalError(main, 'Problem with ${Identifiers.main}.');
-      }
-      mainFunction = backend.helperForBadMain();
-    } else if (!main.isFunction) {
-      errorElement = new ErroneousElementX(MessageKind.MAIN_NOT_A_FUNCTION,
-          {'main': Identifiers.main}, Identifiers.main, main);
-      mainFunction = backend.helperForBadMain();
-    } else {
-      mainFunction = main;
-      mainFunction.computeType(resolution);
-      FunctionSignature parameters = mainFunction.functionSignature;
-      if (parameters.requiredParameterCount > 2) {
-        int index = 0;
-        parameters.orderedForEachParameter((Element parameter) {
-          if (index++ < 2) return;
-          errorElement = new ErroneousElementX(
-              MessageKind.MAIN_WITH_EXTRA_PARAMETER,
-              {'main': Identifiers.main},
-              Identifiers.main,
-              parameter);
-          // Don't warn about main not being used:
-          impactBuilder.registerStaticUse(
-              new StaticUse.staticInvoke(mainFunction, CallStructure.NO_ARGS));
-
-          mainFunction = backend.helperForMainArity();
-        });
-      }
-    }
-    if (mainFunction == null) {
-      if (errorElement == null && !options.analyzeOnly && !analyzeAll) {
-        reporter.internalError(mainApp, "Problem with '${Identifiers.main}'.");
-      } else {
-        mainFunction = errorElement;
-      }
-    }
-    if (errorElement != null &&
-        errorElement.isSynthesized &&
-        !mainApp.isSynthesized) {
-      reporter.reportWarningMessage(errorElement, errorElement.messageKind,
-          errorElement.messageArguments);
-    }
-    return impactBuilder;
+    compileLoadedLibraries(mainApp);
   }
 
   /// Analyze all members of the library in [libraryUri].
   ///
   /// If [skipLibraryWithPartOfTag] is `true`, member analysis is skipped if the
   /// library has a `part of` tag, assuming it is a part and not a library.
   ///
   /// This operation assumes an unclosed resolution queue and is only supported
   /// when the '--analyze-main' option is used.
   Future<LibraryElement> analyzeUri(Uri libraryUri,
@@ skipping 23 matching lines @@
       resolutionEnqueuer = enqueuer.resolution;
     } else {
       resolutionEnqueuer = enqueuer.createResolutionEnqueuer();
       backend.onResolutionStart(resolutionEnqueuer);
     }
     resolutionEnqueuer.addDeferredActions(libraryLoader.pullDeferredActions());
     return resolutionEnqueuer;
   }
 
   /// Performs the compilation when all libraries have been loaded.
-  void compileLoadedLibraries() =>
+  void compileLoadedLibraries(LibraryEntity rootLibrary) =>
       selfTask.measureSubtask("Compiler.compileLoadedLibraries", () {
         ResolutionEnqueuer resolutionEnqueuer = startResolution();
-        WorldImpact mainImpact = computeMain();
+        WorldImpactBuilderImpl mainImpact = new WorldImpactBuilderImpl();
+        mainFunction = frontEndStrategy.computeMain(rootLibrary, mainImpact);
 
-        mirrorUsageAnalyzerTask.analyzeUsage(mainApp);
+        mirrorUsageAnalyzerTask.analyzeUsage(rootLibrary);
 
         // 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.beforeResolution(this);
         impactStrategy = backend.createImpactStrategy(
             supportDeferredLoad: deferredLoadTask.isProgramSplit,
             supportDumpInfo: options.dumpInfo,
             supportSerialization: serialization.supportSerialization);
 
         phase = PHASE_RESOLVING;
         resolutionEnqueuer.applyImpact(mainImpact);
         if (options.resolveOnly) {
           libraryLoader.libraries.where((LibraryEntity library) {
             return !serialization.isDeserialized(library);
           }).forEach((LibraryEntity library) {
             reporter.log('Enqueuing ${library.canonicalUri}');
             resolutionEnqueuer.applyImpact(computeImpactForLibrary(library));
           });
         } else if (analyzeAll) {
           libraryLoader.libraries.forEach((LibraryEntity library) {
             reporter.log('Enqueuing ${library.canonicalUri}');
             resolutionEnqueuer.applyImpact(computeImpactForLibrary(library));
           });
         } else if (options.analyzeMain) {
-          if (mainApp != null) {
-            resolutionEnqueuer.applyImpact(computeImpactForLibrary(mainApp));
+          if (rootLibrary != null) {
+            resolutionEnqueuer
+                .applyImpact(computeImpactForLibrary(rootLibrary));
           }
           if (librariesToAnalyzeWhenRun != null) {
             for (Uri libraryUri in librariesToAnalyzeWhenRun) {
               resolutionEnqueuer.applyImpact(computeImpactForLibrary(
                   libraryLoader.lookupLibrary(libraryUri)));
             }
           }
         }
         resolveLibraryMetadata();
         reporter.log('Resolving...');
-        MethodElement mainMethod;
-        if (mainFunction != null && !mainFunction.isMalformed) {
-          mainFunction.computeType(resolution);
-          mainMethod = mainFunction;
-        }
 
-        processQueue(resolutionEnqueuer, mainMethod, libraryLoader.libraries,
+        processQueue(resolutionEnqueuer, mainFunction, libraryLoader.libraries,
             onProgress: showResolutionProgress);
         backend.onResolutionEnd();
         resolutionEnqueuer.logSummary(reporter.log);
 
         _reporter.reportSuppressedMessagesSummary();
 
         if (compilationFailed) {
           if (!options.generateCodeWithCompileTimeErrors) return;
+          if (mainFunction == null) return;
           if (!backend
               .enableCodegenWithErrorsIfSupported(NO_LOCATION_SPANNABLE)) {
             return;
           }
         }
 
         if (options.resolveOnly && !compilationFailed) {
           reporter.log('Serializing to ${options.resolutionOutput}');
           serialization.serializeToSink(
               userOutputProvider.createOutputSink(
@@ skipping 21 matching lines @@
 
         Enqueuer codegenEnqueuer = enqueuer.createCodegenEnqueuer(closedWorld);
         _codegenWorldBuilder = codegenEnqueuer.worldBuilder;
         codegenEnqueuer.applyImpact(
             backend.onCodegenStart(closedWorld, _codegenWorldBuilder));
         if (compileAll) {
           libraryLoader.libraries.forEach((LibraryEntity library) {
             codegenEnqueuer.applyImpact(computeImpactForLibrary(library));
           });
         }
-        processQueue(codegenEnqueuer, mainMethod, libraryLoader.libraries,
+        processQueue(codegenEnqueuer, mainFunction, libraryLoader.libraries,
             onProgress: showCodegenProgress);
         codegenEnqueuer.logSummary(reporter.log);
 
         int programSize = backend.assembleProgram(closedWorld);
 
         if (options.dumpInfo) {
           dumpInfoTask.reportSize(programSize);
           dumpInfoTask.dumpInfo(closedWorld);
         }
 
@@ skipping 70 matching lines @@
         }
       });
     }
     return impactBuilder;
   }
 
   // Resolves metadata on library elements.  This is necessary in order to
   // resolve metadata classes referenced only from metadata on library tags.
   // TODO(ahe): Figure out how to do this lazily.
   void resolveLibraryMetadata() {
+    if (commonElements.mirrorsLibrary == null) return;
     for (LibraryElement library in libraryLoader.libraries) {
       if (library.metadata != null) {
         for (MetadataAnnotation metadata in library.metadata) {
           metadata.ensureResolved(resolution);
         }
       }
     }
   }
 
   /**
    * Empty the [enqueuer] queue.
    */
   void emptyQueue(Enqueuer enqueuer, {void onProgress(Enqueuer enqueuer)}) {
     selfTask.measureSubtask("Compiler.emptyQueue", () {
       enqueuer.forEach((WorkItem work) {
         if (onProgress != null) {
           onProgress(enqueuer);
         }
         reporter.withCurrentElement(
             work.element,
             () => selfTask.measureSubtask("world.applyImpact", () {
                   enqueuer.applyImpact(
                       selfTask.measureSubtask("work.run", () => work.run()),
                       impactSource: work.element);
                 }));
       });
     });
   }
 
-  void processQueue(Enqueuer enqueuer, MethodElement mainMethod,
+  void processQueue(Enqueuer enqueuer, FunctionEntity mainMethod,
       Iterable<LibraryEntity> libraries,
       {void onProgress(Enqueuer enqueuer)}) {
     selfTask.measureSubtask("Compiler.processQueue", () {
       enqueuer.open(impactStrategy, mainMethod, libraries);
       if (options.verbose) {
         progress.reset();
       }
       emptyQueue(enqueuer, onProgress: onProgress);
       enqueuer.queueIsClosed = true;
       enqueuer.close();
       // Notify the impact strategy impacts are no longer needed for this
       // enqueuer.
       impactStrategy.onImpactUsed(enqueuer.impactUse);
       backend.onQueueClosed();
       assert(compilationFailed ||
-          enqueuer.checkNoEnqueuedInvokedInstanceMethods());
+          enqueuer.checkNoEnqueuedInvokedInstanceMethods(elementEnvironment));
     });
   }
 
   /**
    * Perform various checks of the queues. This includes checking that
    * the queues are empty (nothing was added after we stopped
    * processing the queues). Also compute the number of methods that
    * were resolved, but not compiled (aka excess resolution).
    */
   checkQueues(Enqueuer resolutionEnqueuer, Enqueuer codegenEnqueuer) {
@@ skipping 171 matching lines @@
   }
 
   /// Associate [element] with a compile-time error [message].
   void registerCompileTimeError(Element element, DiagnosticMessage message) {
     // The information is only needed if [generateCodeWithCompileTimeErrors].
     if (options.generateCodeWithCompileTimeErrors) {
       if (element == null) {
         // Record as global error.
         // TODO(zarah): Extend element model to represent compile-time
         // errors instead of using a map.
-        element = mainFunction;
+        element = mainFunction as MethodElement;
       }
       elementsWithCompileTimeErrors
           .putIfAbsent(element, () => <DiagnosticMessage>[])
           .add(message);
     }
   }
 
   api.OutputSink outputProvider(
       String name, String extension, api.OutputType type) {
     if (compilationFailed) {
@@ skipping 11 matching lines @@
 /// Information about suppressed warnings and hints for a given library.
 class SuppressionInfo {
   int warnings = 0;
   int hints = 0;
 }
 
 class CompilerDiagnosticReporter extends DiagnosticReporter {
   final Compiler compiler;
   final DiagnosticOptions options;
 
-  Element _currentElement;
+  Entity _currentElement;
   bool hasCrashed = false;
 
   /// `true` if the last diagnostic was filtered, in which case the
   /// accompanying info message should be filtered as well.
   bool lastDiagnosticWasFiltered = false;
 
   /// Map containing information about the warnings and hints that have been
   /// suppressed for each library.
   Map<Uri, SuppressionInfo> suppressedWarnings = <Uri, SuppressionInfo>{};
 
   CompilerDiagnosticReporter(this.compiler, this.options);
 
-  Element get currentElement => _currentElement;
+  Entity get currentElement => _currentElement;
 
   DiagnosticMessage createMessage(Spannable spannable, MessageKind messageKind,
       [Map arguments = const {}]) {
     SourceSpan span = spanFromSpannable(spannable);
     MessageTemplate template = MessageTemplate.TEMPLATES[messageKind];
     Message message = template.message(arguments, options.terseDiagnostics);
     return new DiagnosticMessage(span, spannable, message);
   }
 
   void reportError(DiagnosticMessage message,
@@ skipping 72 matching lines @@
   }
 
   @override
   bool get hasReportedError => compiler.compilationFailed;
 
   /**
    * Perform an operation, [f], returning the return value from [f].  If an
    * error occurs then report it as having occurred during compilation of
    * [element].  Can be nested.
    */
-  withCurrentElement(Element element, f()) {
-    Element old = currentElement;
+  withCurrentElement(Entity element, f()) {
+    Entity old = currentElement;
     _currentElement = element;
     try {
       return f();
     } on SpannableAssertionFailure catch (ex) {
       if (!hasCrashed) {
         reportAssertionFailure(ex);
         pleaseReportCrash();
       }
       hasCrashed = true;
       rethrow;
@@ skipping 27 matching lines @@
   SourceSpan spanFromToken(Token token) => spanFromTokens(token, token);
 
   SourceSpan spanFromTokens(Token begin, Token end, [Uri uri]) {
     if (begin == null || end == null) {
       // TODO(ahe): We can almost always do better. Often it is only
       // end that is null. Otherwise, we probably know the current
       // URI.
       throw 'Cannot find tokens to produce error message.';
     }
     if (uri == null && currentElement != null) {
-      uri = currentElement.compilationUnit.script.resourceUri;
+      if (currentElement is! Element) {
+        throw 'Can only find tokens from an Element.';
+      }
+      Element element = currentElement;
+      uri = element.compilationUnit.script.resourceUri;
       assert(invariant(currentElement, () {
         bool sameToken(Token token, Token sought) {
           if (token == sought) return true;
           if (token.stringValue == '>>') {
             // `>>` is converted to `>` in the parser when needed.
             return sought.stringValue == '>' &&
                 token.charOffset <= sought.charOffset &&
                 sought.charOffset < token.charEnd;
           }
           return false;
@@ skipping 16 matching lines @@
               return true;
             }
             if (token == to || token == token.next || token.next == null) {
               break;
             }
             token = token.next;
           }
 
           // Create a good message for when the tokens were not found.
           StringBuffer sb = new StringBuffer();
-          sb.write('Invalid current element: $currentElement. ');
+          sb.write('Invalid current element: $element. ');
           sb.write('Looking for ');
           sb.write('[${begin} (${begin.hashCode}),');
           sb.write('${end} (${end.hashCode})] in');
 
           token = from;
           while (true) {
             sb.write('\n ${token} (${token.hashCode})');
             if (token == to || token == token.next || token.next == null) {
               break;
             }
             token = token.next;
           }
           return sb.toString();
         }
 
-        if (currentElement.enclosingClass != null &&
-            currentElement.enclosingClass.isEnumClass) {
+        if (element.enclosingClass != null &&
+            element.enclosingClass.isEnumClass) {
           // Enums ASTs are synthesized (and give messed up messages).
           return true;
         }
 
-        if (currentElement is AstElement) {
-          AstElement astElement = currentElement;
+        if (element is AstElement) {
+          AstElement astElement = element;
           if (astElement.hasNode) {
             Token from = astElement.node.getBeginToken();
             Token to = astElement.node.getEndToken();
             if (astElement.metadata.isNotEmpty) {
               if (!astElement.metadata.first.hasNode) {
                 // We might try to report an error while parsing the metadata
                 // itself.
                 return true;
               }
               from = astElement.metadata.first.node.getBeginToken();
             }
             return validateToken(from, to);
           }
         }
         return true;
-      }, message: "Invalid current element: $currentElement [$begin,$end]."));
+      }, message: "Invalid current element: $element [$begin,$end]."));
     }
     return new SourceSpan.fromTokens(uri, begin, end);
   }
 
   SourceSpan spanFromNode(Node node) {
     return spanFromTokens(node.getBeginToken(), node.getPrefixEndToken());
   }
 
   SourceSpan spanFromElement(Element element) {
     if (element != null && element.sourcePosition != null) {
@@ skipping 74 matching lines @@
 
   internalError(Spannable node, reason) {
     String message = tryToString(reason);
     reportDiagnosticInternal(
         createMessage(node, MessageKind.GENERIC, {'text': message}),
         const <DiagnosticMessage>[],
         api.Diagnostic.CRASH);
     throw 'Internal Error: $message';
   }
 
-  void unhandledExceptionOnElement(Element element) {
+  void unhandledExceptionOnElement(Entity element) {
     if (hasCrashed) return;
     hasCrashed = true;
     reportDiagnostic(createMessage(element, MessageKind.COMPILER_CRASHED),
         const <DiagnosticMessage>[], api.Diagnostic.CRASH);
     pleaseReportCrash();
   }
 
   void pleaseReportCrash() {
     print(MessageTemplate.TEMPLATES[MessageKind.PLEASE_REPORT_THE_CRASH]
         .message({'buildId': compiler.options.buildId}));
@@ skipping 366 matching lines @@
   _ElementScanner(this.scanner);
   void scanLibrary(LibraryElement library) => scanner.scanLibrary(library);
   void scanUnit(CompilationUnitElement unit) => scanner.scan(unit);
 }
 
 class _EmptyEnvironment implements Environment {
   const _EmptyEnvironment();
 
   String valueOf(String key) => null;
 }