Remove IMPORT_EXPORT_SOURCE_CLOSURE and IS_CLIENT results.

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 397 matching lines @@
       _sourceFactory.context = null;
     }
     factory.context = this;
     _sourceFactory = factory;
     _cache = createCacheFromSourceFactory(factory);
     for (WorkManager workManager in workManagers) {
       workManager.onSourceFactoryChanged();
     }
   }
 
-  /**
-   * Invalidate analysis cache.
-   */
-  void invalidateCachedResults() {
-    _cache = createCacheFromSourceFactory(_sourceFactory);
-  }
-
   @override
   List<Source> get sources {
     return _cache.sources.toList();
   }
 
   /**
    * Return a list of the sources that would be processed by
    * [performAnalysisTask]. This method duplicates, and must therefore be kept
    * in sync with, [getNextAnalysisTask]. This method is intended to be used for
    * testing purposes only.
@@ skipping 587 matching lines @@
         }
       }
     }
     if (notify && changed) {
       _onSourcesChangedController
           .add(new SourcesChangedEvent.changedContent(source, newContents));
     }
     return changed;
   }
 
+  /**
+   * Invalidate analysis cache.
+   */
+  void invalidateCachedResults() {
+    _cache = createCacheFromSourceFactory(_sourceFactory);
+  }
+
   @override
   void invalidateLibraryHints(Source librarySource) {
     List<Source> sources = getResult(librarySource, UNITS);
     if (sources != null) {
       for (Source source in sources) {
         getCacheEntry(source).setState(HINTS, CacheState.INVALID);
       }
     }
   }
 
   @override
   bool isClientLibrary(Source librarySource) {
     CacheEntry entry = _cache.get(librarySource);
-    return entry.getValue(IS_CLIENT) && entry.getValue(IS_LAUNCHABLE);
+    return _referencesDartHtml(librarySource) && entry.getValue(IS_LAUNCHABLE);
   }
 
   @override
   bool isServerLibrary(Source librarySource) {
     CacheEntry entry = _cache.get(librarySource);
-    return !entry.getValue(IS_CLIENT) && entry.getValue(IS_LAUNCHABLE);
+    return !_referencesDartHtml(librarySource) && entry.getValue(IS_LAUNCHABLE);
   }
 
   @override
   Stream<ComputedResult> onResultComputed(ResultDescriptor descriptor) {
     return driver.onResultComputed(descriptor);
   }
 
   @override
   CompilationUnit parseCompilationUnit(Source source) {
     if (!AnalysisEngine.isDartFileName(source.shortName)) {
@@ skipping 56 matching lines @@
       // CLASS_ELEMENTS
       setValue(COMPILATION_UNIT_ELEMENT, library.definingCompilationUnit);
       // CONSTRUCTORS
       // CONSTRUCTORS_ERRORS
       entry.setState(CONTENT, CacheState.FLUSHED);
       setValue(EXPORTED_LIBRARIES, Source.EMPTY_LIST);
       // EXPORT_SOURCE_CLOSURE
       setValue(IMPORTED_LIBRARIES, Source.EMPTY_LIST);
       // IMPORT_SOURCE_CLOSURE
       setValue(INCLUDED_PARTS, Source.EMPTY_LIST);
-      setValue(IS_CLIENT, true);
       setValue(IS_LAUNCHABLE, false);
       setValue(LIBRARY_ELEMENT, library);
       setValue(LIBRARY_ELEMENT1, library);
       setValue(LIBRARY_ELEMENT2, library);
       setValue(LIBRARY_ELEMENT3, library);
       setValue(LIBRARY_ELEMENT4, library);
       setValue(LIBRARY_ELEMENT5, library);
       setValue(LINE_INFO, new LineInfo(<int>[0]));
       setValue(PARSE_ERRORS, AnalysisError.NO_ERRORS);
       entry.setState(PARSED_UNIT, CacheState.FLUSHED);
@@ skipping 556 matching lines @@
    * given [source] has been updated to the given [errors].
    */
   void _notifyErrors(
       Source source, List<AnalysisError> errors, LineInfo lineInfo) {
     int count = _listeners.length;
     for (int i = 0; i < count; i++) {
       _listeners[i].computedErrors(this, source, errors, lineInfo);
     }
   }
 
+  bool _referencesDartHtml(Source librarySource) {
+    Source htmlSource = sourceFactory.forUri(DartSdk.DART_HTML);
+    Set<Source> checkedSources = new Set<Source>();
+    bool _refHtml(Source source) {
+      if (!checkedSources.add(source)) {
+        return false;
+      }
+      if (source == htmlSource) {
+        return true;
+      }
+      LibraryElement library = _cache.getValue(source, LIBRARY_ELEMENT);
+      if (library != null) {
+        return library.importedLibraries.any((x) => _refHtml(x.source)) ||
+            library.exportedLibraries.any((x) => _refHtml(x.source));
+      }
+      return false;
+    }
+    return _refHtml(librarySource);
+  }
+
   void _removeFromCache(Source source) {
     CacheEntry entry = _cache.remove(source);
     if (entry != null && !entry.explicitlyAdded) {
       _implicitAnalysisEventsController
           .add(new ImplicitAnalysisEvent(source, false));
     }
   }
 
   /**
    * Remove the given [source] from the priority order if it is in the list.
@@ skipping 210 matching lines @@
       }
       // schedule
       dartWorkManager.unitIncrementallyResolved(librarySource, unitSource);
       // OK
       return true;
     });
   }
 }
 
 /**
+ * A helper class used to create futures for [AnalysisContextImpl].
+ * Using a helper class allows us to preserve the generic parameter T.
+ */
+class AnalysisFutureHelper<T> {
+  final AnalysisContextImpl _context;
+  final AnalysisTarget _target;
+  final ResultDescriptor<T> _descriptor;
+
+  AnalysisFutureHelper(this._context, this._target, this._descriptor);
+
+  /**
+   * Return a future that will be completed with the result specified
+   * in the constructor. If the result is cached, the future will be
+   * completed immediately with the resulting value. If not, then
+   * analysis is scheduled that will produce the required result.
+   * If the result cannot be generated, then the future will be completed with
+   * the error AnalysisNotScheduledError.
+   */
+  CancelableFuture<T> computeAsync() {
+    if (_context.isDisposed) {
+      // No further analysis is expected, so return a future that completes
+      // immediately with AnalysisNotScheduledError.
+      return new CancelableFuture.error(new AnalysisNotScheduledError());
+    }
+    CacheEntry entry = _context.getCacheEntry(_target);
+    PendingFuture pendingFuture =
+        new PendingFuture<T>(_context, _target, (CacheEntry entry) {
+      CacheState state = entry.getState(_descriptor);
+      if (state == CacheState.ERROR) {
+        throw entry.exception;
+      } else if (state == CacheState.INVALID) {
+        return null;
+      }
+      return entry.getValue(_descriptor);
+    });
+    if (!pendingFuture.evaluate(entry)) {
+      _context._pendingFutureTargets
+          .putIfAbsent(_target, () => <PendingFuture>[])
+          .add(pendingFuture);
+      _context.dartWorkManager.addPriorityResult(_target, _descriptor);
+    }
+    return pendingFuture.future;
+  }
+}
+
+/**
  * An object that manages the partitions that can be shared between analysis
  * contexts.
  */
 class PartitionManager {
   /**
    * A table mapping SDK's to the partitions used for those SDK's.
    */
   HashMap<DartSdk, SdkCachePartition> _sdkPartitions =
       new HashMap<DartSdk, SdkCachePartition>();
 
@@ skipping 118 matching lines @@
     DartSdk sdk = factory.dartSdk;
     if (sdk == null) {
       throw new IllegalArgumentException(
           "The source factory for an SDK analysis context must have a DartUriResolver");
     }
     return new AnalysisCache(<CachePartition>[
       AnalysisEngine.instance.partitionManager_new.forSdk(sdk)
     ]);
   }
 }
-
-/**
- * A helper class used to create futures for [AnalysisContextImpl].
- * Using a helper class allows us to preserve the generic parameter T.
- */
-class AnalysisFutureHelper<T> {
-  final AnalysisContextImpl _context;
-  final AnalysisTarget _target;
-  final ResultDescriptor<T> _descriptor;
-
-  AnalysisFutureHelper(this._context, this._target, this._descriptor);
-
-  /**
-   * Return a future that will be completed with the result specified
-   * in the constructor. If the result is cached, the future will be
-   * completed immediately with the resulting value. If not, then
-   * analysis is scheduled that will produce the required result.
-   * If the result cannot be generated, then the future will be completed with
-   * the error AnalysisNotScheduledError.
-   */
-  CancelableFuture<T> computeAsync() {
-    if (_context.isDisposed) {
-      // No further analysis is expected, so return a future that completes
-      // immediately with AnalysisNotScheduledError.
-      return new CancelableFuture.error(new AnalysisNotScheduledError());
-    }
-    CacheEntry entry = _context.getCacheEntry(_target);
-    PendingFuture pendingFuture =
-        new PendingFuture<T>(_context, _target, (CacheEntry entry) {
-      CacheState state = entry.getState(_descriptor);
-      if (state == CacheState.ERROR) {
-        throw entry.exception;
-      } else if (state == CacheState.INVALID) {
-        return null;
-      }
-      return entry.getValue(_descriptor);
-    });
-    if (!pendingFuture.evaluate(entry)) {
-      _context._pendingFutureTargets
-          .putIfAbsent(_target, () => <PendingFuture>[])
-          .add(pendingFuture);
-      _context.dartWorkManager.addPriorityResult(_target, _descriptor);
-    }
-    return pendingFuture.future;
-  }
-}