Make more use of generated code in analysis server.

pkg/analysis_server/lib/src/protocol2.dart

 // Copyright (c) 2014, 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 protocol2;
 
 import 'dart:convert';
 
+import 'package:analysis_server/src/computer/element.dart' show
+    elementFromEngine;
+import 'package:analysis_server/src/search/search_result.dart' show
+    searchResultFromMatch;
 import 'package:analysis_server/src/services/json.dart';
+import 'package:analysis_server/src/services/search/search_engine.dart' as
+    engine;
 import 'package:analyzer/src/generated/element.dart' as engine;
 import 'package:analyzer/src/generated/engine.dart' as engine;
 import 'package:analyzer/src/generated/error.dart' as engine;
 import 'package:analyzer/src/generated/source.dart' as engine;
 
 import 'protocol.dart';
 
 part 'generated_protocol.dart';
 
 /**
  * Translate the input [map], applying [keyCallback] to all its keys, and
  * [valueCallback] to all its values.
  */
 mapMap(Map map, {dynamic keyCallback(key), dynamic valueCallback(value)}) {
   Map result = {};
   map.forEach((key, value) {
     if (keyCallback != null) {
       key = keyCallback(key);
     }
     if (valueCallback != null) {
       value = valueCallback(value);
     }
     result[key] = value;
   });
   return result;
 }
 
 /**
+ * Adds the given [sourceEdit] to the list in [sourceFileEdit].
+ */
+void _addEditForSource(SourceFileEdit sourceFileEdit, SourceEdit sourceEdit) {
+  List<SourceEdit> edits = sourceFileEdit.edits;
+  int index = 0;
+  while (index < edits.length && edits[index].offset > sourceEdit.offset) {
+    index++;
+  }
+  edits.insert(index, sourceEdit);
+}
+
+/**
+ * Adds the given [sourceEdits] to the list in [sourceFileEdit].
+ */
+void _addAllEditsForSource(SourceFileEdit sourceFileEdit,
+                          Iterable<SourceEdit> edits) {
+  edits.forEach(sourceFileEdit.add);
+}
+
+/**
  * Create an AnalysisError based on error information from the analyzer
  * engine.  Access via AnalysisError.fromEngine().
  */
 AnalysisError _analysisErrorFromEngine(engine.LineInfo
     lineInfo, engine.AnalysisError error) {
   engine.ErrorCode errorCode = error.errorCode;
   // prepare location
   Location location;
   {
     String file = error.source.fullName;
@@ skipping 100 matching lines @@
   }
   for (int i = 0; i < listA.length; i++) {
     if (!itemEqual(listA[i], listB[i])) {
       return false;
     }
   }
   return true;
 }
 
 /**
+ * Create a Location based on an element from the analyzer engine.
+ */
+Location _locationFromElement(engine.Element element) {
+  engine.Source source = element.source;
+  engine.LineInfo lineInfo = element.context.getLineInfo(source);
+  String name = element.displayName;
+  // prepare location
+  int offset = element.nameOffset;
+  int length = name != null ? name.length : 0;
+  engine.LineInfo_Location lineLocation = lineInfo.getLocation(offset);
+  int startLine = lineLocation.lineNumber;
+  int startColumn = lineLocation.columnNumber;
+  if (element is engine.CompilationUnitElement) {
+    offset = 0;
+    length = 0;
+    startLine = 1;
+    startColumn = 1;
+  }
+  // done
+  return new Location(
+      source.fullName,
+      offset,
+      length,
+      startLine,
+      startColumn);
+}
+
+/**
+ * Create a Location based on an element and offset from the analyzer engine.
+ */
+Location _locationFromOffset(engine.Element element, int offset, int length) {
+  engine.Source source = element.source;
+  engine.LineInfo lineInfo = element.context.getLineInfo(source);
+  // prepare location
+  engine.LineInfo_Location lineLocation = lineInfo.getLocation(offset);
+  int startLine = lineLocation.lineNumber;
+  int startColumn = lineLocation.columnNumber;
+  // done
+  return new Location(
+      source.fullName,
+      offset,
+      length,
+      startLine,
+      startColumn);
+}
+
+/**
  * Compare the maps [mapA] and [mapB], using [valueEqual] to compare map
  * values.
  */
 bool _mapEqual(Map mapA, Map mapB, bool valueEqual(a, b)) {
   if (mapA.length != mapB.length) {
     return false;
   }
   for (var key in mapA.keys) {
     if (!mapB.containsKey(key)) {
       return false;
     }
     if (!valueEqual(mapA[key], mapB[key])) {
       return false;
     }
   }
   return true;
 }
 
+/**
+ * Create an OverriddenMember based on an element from the analyzer engine.
+ */
+OverriddenMember _overriddenMemberFromEngine(engine.Element member) {
+  Element element = elementFromEngine(member);
+  String className = member.enclosingElement.displayName;
+  return new OverriddenMember(element, className);
+}
+
+/**
+ * Create a SearchResultKind based on a value from the search engine.
+ */
+SearchResultKind _searchResultKindFromEngine(engine.MatchKind kind) {
+  if (kind == engine.MatchKind.DECLARATION) {
+    return SearchResultKind.DECLARATION;
+  }
+  if (kind == engine.MatchKind.READ) {
+    return SearchResultKind.READ;
+  }
+  if (kind == engine.MatchKind.READ_WRITE) {
+    return SearchResultKind.READ_WRITE;
+  }
+  if (kind == engine.MatchKind.WRITE) {
+    return SearchResultKind.WRITE;
+  }
+  if (kind == engine.MatchKind.INVOCATION) {
+    return SearchResultKind.INVOCATION;
+  }
+  if (kind == engine.MatchKind.REFERENCE) {
+    return SearchResultKind.REFERENCE;
+  }
+  return SearchResultKind.UNKNOWN;
+}
+
 
 /**
  * Type of callbacks used to decode parts of JSON objects.  [jsonPath] is a
  * string describing the part of the JSON object being decoded, and [value] is
  * the part to decode.
  */
 typedef Object JsonDecoderCallback(String jsonPath, Object value);
 
 /**
  * Base class for decoding JSON objects.  The derived class must implement
@@ skipping 182 matching lines @@
     hash = 0x1fffffff & (hash + ((0x03ffffff & hash) << 3));
     hash = hash ^ (hash >> 11);
     return 0x1fffffff & (hash + ((0x00003fff & hash) << 15));
   }
 
   static int hash2(a, b) => finish(combine(combine(0, a), b));
 
   static int hash4(a, b, c, d) => finish(combine(combine(combine(combine(0, a),
       b), c), d));
 }