Create `loadLibrary` function element eagerly.

pkg/analyzer/lib/src/context/context.dart

 // Copyright (c) 2015, 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 analyzer.src.context.context;
 
 import 'dart:async';
 import 'dart:collection';
 
 import 'package:analyzer/instrumentation/instrumentation.dart';
@@ skipping 613 matching lines @@
     if (AnalysisEngine.isDartFileName(name)) {
       return computeResult(source, SOURCE_KIND);
     } else if (AnalysisEngine.isHtmlFileName(name)) {
       return SourceKind.HTML;
     }
     return SourceKind.UNKNOWN;
   }
 
   @override
   LibraryElement computeLibraryElement(Source source) {
+    assert(!driver.isTaskRunning);

[Brian Wilkerson, 2015/10/19 20:15:19]

Do we want to add this, or was this left over from debugging?

If we want to add it, consider putting it in computeResult just before asking
the driver to do some work.

[Paul Berry, 2015/10/19 20:31:29]

This was added on purpose--in the absence of the bug fix, it changes the bug
from non-deterministic to deterministic by doing the reentrancy check prior to
checking whether the result has already been computed.  That should help us
catch the problem more quickly in the event of a regression.
Seems reasonable--that has the potential to catch more bugs.  I've moved it to
the top of computeResult, though (rather than just before asking the driver to
do some work) to preserve the determinism.

I've also added a comment to clarify what the check is for so that it doesn't
look like it was included by accident.

     //_computeResult(source, HtmlEntry.ELEMENT);
     return computeResult(source, LIBRARY_ELEMENT);
   }
 
   @override
   LineInfo computeLineInfo(Source source) => computeResult(source, LINE_INFO);
 
   @override
   @deprecated
   CompilationUnit computeResolvableCompilationUnit(Source source) {
@@ skipping 1466 matching lines @@
         new PendingFuture<T>(_context, target, computeValue);
     if (!pendingFuture.evaluate(entry)) {
       _context._pendingFutureTargets
           .putIfAbsent(target, () => <PendingFuture>[])
           .add(pendingFuture);
       scheduleComputation();
     }
     return pendingFuture.future;
   }
 }