anchor.diff:      if (const bool.fromEnvironment("reflectable.pause.at.exit")) {
         _processedEntryPointCount++;
       }
  -    if (const bool.fromEnvironment("reflectable.print.resolved.libraries")) {
  -      print("Resolved libraries for $currentEntryPoint: "
  -          "${_resolvedLibraries.length}/${_resolver.libraries.length}");
  -    }
       _resolver.release();
   
       if (const bool.fromEnvironment("reflectable.pause.at.exit")) {
  
positive.code: /// will remain unresolved if they were unresolved when they were obtained.
  EvaluationResultImpl _constTopLevelVariableEvaluationResult(
      ConstTopLevelVariableElementImpl constTopLevelVariable) {
    // This is safe: The result returned from `library` will not be used again.
    _resolvedLibraryOf(constTopLevelVariable.library);
    return constTopLevelVariable.evaluationResult;
  }
  
  /// Requests resolution of constants in [libraryElement] and returns a
  /// [LibraryElement] wherein they have been resolved. If the library has
  /// been obtained by evaluating `library` on an `Element` and all further
  /// usage of that library will happen by invoking `library` again then it is
  /// safe to ignore the returned value (because the future invocations of
  /// `library` will return the resolved library).
  LibraryElement _resolvedLibraryOf(LibraryElement libraryElement) {
    LibraryElement resolvedLibrary = _resolvedLibraries[libraryElement];
    if (resolvedLibrary == null) {
      resolvedLibrary = libraryElement.context
          .computeLibraryElement(libraryElement.definingCompilationUnit.source);
      _resolvedLibraries[libraryElement] = resolvedLibrary;
    }
    return resolvedLibrary;
  }
  
  Map<LibraryElement, LibraryElement> _resolvedLibraries =
      <LibraryElement, LibraryElement>{};
  
negative.code: /// will remain unresolved if they were unresolved when they were obtained.
  EvaluationResultImpl _annotationEvaluationResult(
      ElementAnnotationImpl annotation) {
    EvaluationResultImpl result = annotation.evaluationResult;
    if (result == null) {
      // This is safe: The `library` will not be used again.
      _resolvedLibraryOf(annotation.compilationUnit.library);
      result = annotation.evaluationResult;
    }
    return result;
  }
  
  /// Returns `evaluationResult` for the given [constFieldElement].
  ///
  /// Returns the `evaluationResult` for [constFieldElement], after having
  /// forced constant resolution to take place in `constFieldElement.library`.
  /// Note that future invocations of `constFieldElement.library` will return
  /// a resolved library, but previously obtained results from that method
  /// will remain unresolved if they were unresolved when they were obtained.
  EvaluationResultImpl _constFieldEvaluationResult(
      ConstFieldElementImpl constFieldElement) {
    EvaluationResultImpl result = constFieldElement.evaluationResult;
    if (result == null) {
      // This is safe: The `library` will not be used again.
      _resolvedLibraryOf(constFieldElement.library);
      result = constFieldElement.evaluationResult;
    }
    return result;
  }
  
  /// Returns `evaluationResult` for the given [constTopLevelVariable].
  ///
  /// Returns the `evaluationResult` for [constTopLevelVariable], after having
  /// forced constant resolution to take place in `constTopLevelvariable.library`.
  /// Note that future invocations of `constTopLevelVariable.library` will
  