Remove ReferencedNames(Builder).

pkg/analysis_server/lib/src/status/validator.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 analysis_server.src.status.validator;
 
 import 'dart:collection';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart';
@@ skipping 1491 matching lines @@
     } else if (actual is DartScript) {
       return _compareDartScripts(expected, actual, buffer);
     } else if (actual is html.Document) {
       return _compareDocuments(expected, actual, buffer);
     } else if (actual is Element) {
       return _compareElements(expected, actual, buffer);
     } else if (actual is LibrarySpecificUnit) {
       return _compareLibrarySpecificUnits(expected, actual, buffer);
     } else if (actual is LineInfo) {
       return _compareLineInfos(expected, actual, buffer);
-    } else if (actual is ReferencedNames) {
-      return _compareReferencedNames(expected, actual, buffer);
     } else if (actual is Source) {
       return _compareSources(expected, actual, buffer);
     } else if (actual is SourceKind) {
       return _comparePrimitives(expected, actual, buffer);
     } else if (actual is Token) {
       return _compareTokenStreams(expected, actual, buffer);
     } else if (actual is TypeProvider) {
       return true;
     } else if (actual is UsedLocalElements) {
       return _compareUsedLocalElements(expected, actual, buffer);
@@ skipping 15 matching lines @@
     }
     if (buffer != null) {
       buffer.write('Expected ');
       buffer.write(expected);
       buffer.write('; found ');
       buffer.write(actual);
     }
     return false;
   }
 
-  bool _compareReferencedNames(
-      ReferencedNames expected, ReferencedNames actual, StringBuffer buffer) {
-    Set<String> expectedNames = expected.names;
-    Map<String, Set<String>> expectedUserToDependsOn = expected.userToDependsOn;
-    Set<String> expectedKeys = expectedUserToDependsOn.keys.toSet();
-
-    Set<String> actualNames = actual.names;
-    Map<String, Set<String>> actualUserToDependsOn = actual.userToDependsOn;
-    Set<String> actualKeys = actualUserToDependsOn.keys.toSet();
-
-    Set<String> missingNames = expectedNames.difference(actualNames);
-    Set<String> extraNames = actualNames.difference(expectedNames);
-    Set<String> missingKeys = expectedKeys.difference(actualKeys);
-    Set<String> extraKeys = actualKeys.difference(expectedKeys);
-    Map<String, List<Set<String>>> mismatchedDependencies =
-        new HashMap<String, List<Set<String>>>();
-    Set<String> commonKeys = expectedKeys.intersection(actualKeys);
-    for (String key in commonKeys) {
-      Set<String> expectedDependencies = expectedUserToDependsOn[key];
-      Set<String> actualDependencies = actualUserToDependsOn[key];
-      Set<String> missingDependencies =
-          expectedDependencies.difference(actualDependencies);
-      Set<String> extraDependencies =
-          actualDependencies.difference(expectedDependencies);
-      if (missingDependencies.isNotEmpty || extraDependencies.isNotEmpty) {
-        mismatchedDependencies[key] = [missingDependencies, extraDependencies];
-      }
-    }
-
-    if (missingNames.isEmpty &&
-        extraNames.isEmpty &&
-        missingKeys.isEmpty &&
-        extraKeys.isEmpty &&
-        mismatchedDependencies.isEmpty) {
-      return true;
-    }
-    if (buffer != null) {
-      void write(String title, Set<String> names) {
-        buffer.write(names.length);
-        buffer.write(' ');
-        buffer.write(title);
-        buffer.write(': {');
-        bool first = true;
-        for (String name in names) {
-          if (first) {
-            first = false;
-          } else {
-            buffer.write(', ');
-          }
-          buffer.write(name);
-        }
-        buffer.write('}');
-      }
-
-      bool needsNewline = false;
-      if (missingNames.isNotEmpty) {
-        buffer.write('Has ');
-        write('missing names', missingNames);
-        needsNewline = true;
-      }
-      if (extraNames.isNotEmpty) {
-        if (needsNewline) {
-          buffer.write('</p><p>');
-        }
-        buffer.write('Has ');
-        write('extra names', extraNames);
-        needsNewline = true;
-      }
-      if (missingKeys.isNotEmpty) {
-        if (needsNewline) {
-          buffer.write('</p><p>');
-        }
-        buffer.write('Has ');
-        write('missing keys', missingKeys);
-        needsNewline = true;
-      }
-      if (extraKeys.isNotEmpty) {
-        if (needsNewline) {
-          buffer.write('</p><p>');
-        }
-        buffer.write('Has ');
-        write('extra keys', extraKeys);
-        needsNewline = true;
-      }
-      mismatchedDependencies.forEach((String key, List<Set<String>> value) {
-        Set<String> missingDependencies = value[0];
-        Set<String> extraDependencies = value[1];
-        if (needsNewline) {
-          buffer.write('</p><p>');
-        }
-        buffer.write('The key ');
-        buffer.write(key);
-        buffer.write(' has ');
-        bool needsConjunction = false;
-        if (missingNames.isNotEmpty) {
-          write('missing dependencies', missingDependencies);
-          needsConjunction = true;
-        }
-        if (extraNames.isNotEmpty) {
-          if (needsConjunction) {
-            buffer.write(' and ');
-          }
-          write('extra dependencies', extraDependencies);
-        }
-        needsNewline = true;
-      });
-    }
-    return true;
-  }
-
   bool _compareSources(Source expected, Source actual, StringBuffer buffer) {
     if (actual.fullName == expected.fullName) {
       return true;
     }
     if (buffer != null) {
       buffer.write('Expected a source for ');
       buffer.write(expected.fullName);
       buffer.write('; found a source for ');
       buffer.write(actual.fullName);
     }
@@ skipping 107 matching lines @@
    * Determine whether or not there is any interesting difference between the
    * original and cloned values.
    */
   void _performComparison() {
     StringBuffer buffer = new StringBuffer();
     if (!_compareObjects(cloneValue, originalValue, buffer)) {
       description = buffer.toString();
     }
   }
 }