Fix some crashes in dartk.

pkg/kernel/lib/analyzer/loader.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 kernel.analyzer.loader;
 
 import 'dart:async';
 import 'dart:io' as io;
 
 import 'package:analyzer/analyzer.dart';
 import 'package:analyzer/file_system/file_system.dart';
@@ skipping 91 matching lines @@
   /// Classes that have been referenced, and must be promoted to type level
   /// so as not to expose partially initialized classes.
   final List<ast.Class> temporaryClassWorklist = [];
 
   LibraryElement _libraryBeingLoaded = null;
 
   bool get strongMode => context.analysisOptions.strongMode;
 
   DartLoader(this.repository, DartOptions options, Packages packages,
       {DartSdk dartSdk, AnalysisContext context})
-      : this.context = context ?? createContext(options, packages, dartSdk: dartSdk),
+      : this.context =
+            context ?? createContext(options, packages, dartSdk: dartSdk),
         this.applicationRoot = options.applicationRoot;
 
   String getLibraryName(LibraryElement element) {
     return element.name.isEmpty ? null : element.name;
   }
 
   ast.Library getLibraryReference(LibraryElement element) {
     var uri = applicationRoot.relativeUri(element.source.uri);
     return repository.getLibraryReference(uri)
       ..name ??= getLibraryName(element)
@@ skipping 271 matching lines @@
 
   ast.TypeParameter tryGetClassTypeParameter(TypeParameterElement element) {
     return _classTypeParameters[element];
   }
 
   Element getMemberElement(ast.Member node) {
     return _members.inverse[node];
   }
 
   ast.Member getMemberReference(Element element) {
+    assert(element != null);
     assert(element is! Member); // Use the "base element".
     return _members[element] ??= _buildMemberReference(element);
   }
 
   ast.Member _buildMemberReference(Element element) {
+    assert(element != null);
     var node = _buildOrphanedMemberReference(element);
     // Set the parent pointer and store it in the enclosing class or library.
     // If the enclosing library is being built from the AST, do not add the
     // member, since the AST builder will put it in there.
     var parent = element.enclosingElement;
     if (parent is ClassElement) {
       var class_ = getClassReference(parent);
       node.parent = class_;
       if (!isLibraryBeingLoaded(element.library)) {
         class_.addMember(node);
       }
     } else {
       var library = getLibraryReference(element.library);
       node.parent = library;
       if (!isLibraryBeingLoaded(element.library)) {
         library.addMember(node);
       }
     }
     return node;
   }
 
   ast.Member _buildOrphanedMemberReference(Element element) {
+    assert(element != null);
     ClassElement classElement = element.enclosingElement is ClassElement
         ? element.enclosingElement
         : null;
     TypeScope scope = classElement != null
         ? new ClassScope(this, getLibraryReference(element.library))
         : new TypeScope(this);
     if (classElement != null) {
       getClassReference(classElement);
     }
     switch (element.kind) {
@@ skipping 237 matching lines @@
     return list;
   }
 
   void _iterateWorklist() {
     while (temporaryClassWorklist.isNotEmpty) {
       var element = temporaryClassWorklist.removeLast();
       promoteToTypeLevel(element);
     }
   }
 
+  ast.Procedure _getMainMethod(Uri uri) {
+    Source source = context.sourceFactory.forUri2(uri);
+    LibraryElement library = context.computeLibraryElement(source);
+    var mainElement = library.entryPoint;
+    if (mainElement == null) return null;
+    var mainMember = getMemberReference(mainElement);
+    if (mainMember is ast.Procedure && !mainMember.isAccessor) {
+      return mainMember;
+    }
+    // Top-level 'main' getters are not supported at the moment.
+    return null;
+  }
+
+  ast.Procedure _makeMissingMainMethod(ast.Library library) {
+    var main = new ast.Procedure(
+        new ast.Name('main'),
+        ast.ProcedureKind.Method,
+        new ast.FunctionNode(new ast.ExpressionStatement(new ast.Throw(
+            new ast.StringLiteral('Program has no main method')))),
+        isStatic: true)
+      ..fileUri = library.fileUri;
+    library.addMember(main);
+    return main;
+  }
+
   ast.Program loadProgram(Uri mainLibrary, {Target target, bool compileSdk}) {
-    ast.Library library = repository
-        .getLibraryReference(applicationRoot.relativeUri(mainLibrary));
+    Uri uri = applicationRoot.relativeUri(mainLibrary);
+    ast.Library library = repository.getLibraryReference(uri);
     ensureLibraryIsLoaded(library);
+    var mainMethod = _getMainMethod(mainLibrary);
     loadEverything(target: target, compileSdk: compileSdk);
     var program = new ast.Program(repository.libraries);
-    program.mainMethod = library.procedures.firstWhere(
-        (member) => member.name?.name == 'main',
-        orElse: () => null);
+    if (mainMethod == null) {
+      mainMethod = _makeMissingMainMethod(library);
+    }
+    program.mainMethod = mainMethod;
     for (LibraryElement libraryElement in libraryElements) {
       for (CompilationUnitElement compilationUnitElement
           in libraryElement.units) {
         var source = compilationUnitElement.source;
         LineInfo lineInfo = context.computeLineInfo(source);
         String sourceCode;
         try {
           sourceCode = context.getContents(source).data;
         } catch (e) {
           // The source's contents could not be accessed.
@@ skipping 160 matching lines @@
   AnalysisContext context = AnalysisEngine.instance.createAnalysisContext()
     ..sourceFactory = new SourceFactory(resolvers)
     ..analysisOptions = createAnalysisOptions(options.strongMode);
 
   options.declaredVariables.forEach((String name, String value) {
     context.declaredVariables.define(name, value);
   });
 
   return context;
 }