Only units with 'part of' and no other directives are parts.

pkg/analyzer/lib/src/task/dart_work_manager.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.task.dart_work_manager;
 
 import 'dart:collection';
 
 import 'package:analyzer/src/context/cache.dart';
 import 'package:analyzer/src/generated/engine.dart'
@@ skipping 245 matching lines @@
           librarySourceQueue.add(target);
         }
       }
     }
     // Update parts in libraries.
     if (_isDartSource(target)) {
       Source library = target;
       List<Source> includedParts = outputs[INCLUDED_PARTS];
       if (includedParts != null) {
         libraryPartsMap[library] = includedParts;
-        // update contanining libraries
         for (Source part in includedParts) {
           List<Source> libraries =
               partLibrariesMap.putIfAbsent(part, () => <Source>[]);
           if (!libraries.contains(library)) {
             libraries.add(library);
-          }
-        }
-        // all of the "includedParts" are not libraries anymore
-        for (Source part in includedParts) {
-          unknownSourceQueue.remove(part);
-          librarySourceQueue.remove(part);
-          analysisCache.remove(new LibrarySpecificUnit(part, part));
-          CacheEntry partEntry = analysisCache.get(part);
-          if (partEntry != null) {
-            partEntry.setValue(SOURCE_KIND, SourceKind.PART, <TargetedResult>[
-              new TargetedResult(part, CONTENT),
-              new TargetedResult(target, CONTENT)
-            ]);
+            _invalidateContainingLibraries(part);
           }
         }
       }
     }
     // Update notice.
     if (_isDartSource(target)) {
       bool shouldSetErrors = false;
       outputs.forEach((ResultDescriptor descriptor, value) {
         if (descriptor == PARSED_UNIT && value != null) {
           context.getNotice(target).parsedDartUnit = value;
@@ skipping 22 matching lines @@
         context.getNotice(source).setErrors(info.errors, info.lineInfo);
       }
     }
   }
 
   void unitIncrementallyResolved(Source librarySource, Source unitSource) {
     librarySourceQueue.add(librarySource);
   }
 
   /**
+   * Invalidate  [CONTAINING_LIBRARIES] for the given [source].
+   * [CONTAINING_LIBRARIES] does not have dependencies, so we manage it here.
+   * The [source] may be a part, or a library whose contents is updated so
+   * will be a part.
+   */
+  void _invalidateContainingLibraries(Source source) {
+    CacheEntry entry = analysisCache.get(source);
+    if (entry != null) {
+      entry.setState(CONTAINING_LIBRARIES, CacheState.INVALID);
+    }
+  }
+
+  /**
    * Returns `true` if the given [result] of the given [target] needs
    * computing, i.e. it is not in the valid and not in the error state.
    */
   bool _needsComputing(AnalysisTarget target, ResultDescriptor result) {
     CacheState state = analysisCache.getState(target, result);
     return state != CacheState.VALID && state != CacheState.ERROR;
   }
 
   /**
    * The given [library] source was changed or removed.
    * Update [libraryPartsMap] and [partLibrariesMap].
    */
   void _onLibrarySourceChangedOrRemoved(Source library) {
     List<Source> parts = libraryPartsMap.remove(library);
     if (parts != null) {
       for (Source part in parts) {
         List<Source> libraries = partLibrariesMap[part];
         if (libraries != null) {
           libraries.remove(library);
+          _invalidateContainingLibraries(part);

[Brian Wilkerson, 2015/06/04 20:45:56]

I think this does too much. If a file 'part.dart' is included (via part
directive) in both 'libA.dart' and 'libB.dart', and 'libA.dart' is modified,
won't we loose the fact that 'part.dart' is in 'libB.dart'?

[scheglov, 2015/06/04 20:50:27]

Yes, we will lose it in the cache.
So, ContainingLibrariesTask will be run, call context.getLibrariesContaining()
and get this information again into cache by asking DartWorkManager.

We don't nuke this information in DartWorkManager, so "part.dart" will remember
that it is a part of "libB.dart".

         }
       }
     }
+    _invalidateContainingLibraries(library);
   }
 
   static bool _isDartSource(AnalysisTarget target) {
     return target is Source && AnalysisEngine.isDartFileName(target.fullName);
   }
 }