Move Location factories and RefactoringProblemSeverity.max into the generated classes.

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/ast.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 [sourceEdits] to the list in [sourceFileEdit].
+ */
+void _addAllEditsForSource(SourceFileEdit sourceFileEdit,
+    Iterable<SourceEdit> edits) {
+  edits.forEach(sourceFileEdit.add);
+}
+
+/**
  * 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) {
+AnalysisError _analysisErrorFromEngine(engine.LineInfo lineInfo,
+    engine.AnalysisError error) {
   engine.ErrorCode errorCode = error.errorCode;
   // prepare location
   Location location;
   {
     String file = error.source.fullName;
     int offset = error.offset;
     int length = error.length;
     int startLine = -1;
     int startColumn = -1;
     if (lineInfo != null) {
       engine.LineInfo_Location lineLocation = lineInfo.getLocation(offset);
       if (lineLocation != null) {
         startLine = lineLocation.lineNumber;
         startColumn = lineLocation.columnNumber;
       }
     }
     location = new Location(file, offset, length, startLine, startColumn);
   }
   // done
   var severity = new ErrorSeverity(errorCode.errorSeverity.name);
   var type = new ErrorType(errorCode.type.name);
   String message = error.message;
   String correction = error.correction;
-  return new AnalysisError(severity, type, location, message, correction:
-      correction);
+  return new AnalysisError(
+      severity,
+      type,
+      location,
+      message,
+      correction: correction);
 }
 
 /**
  * Get the result of applying the edit to the given [code].  Access via
  * SourceEdit.apply().
  */
 String _applyEdit(String code, SourceEdit edit) {
-  return code.substring(0, edit.offset) + edit.replacement + code.substring(
-      edit.end);
+  return code.substring(0, edit.offset) +
+      edit.replacement +
+      code.substring(edit.end);
 }
 
 /**
  * Get the result of applying a set of [edits] to the given [code].  Edits
  * are applied in the order they appear in [edits].  Access via
  * SourceEdit.applySequence().
  */
 String _applySequence(String code, Iterable<SourceEdit> edits) {
   edits.forEach((SourceEdit edit) {
     code = edit.apply(code);
@@ skipping 61 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.
+ * Creates a new [Location].
  */
-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;
+Location _locationForArgs(engine.AnalysisContext context, engine.Source source,
+    engine.SourceRange range) {
+  int startLine = 0;
+  int startColumn = 0;
+  {
+    engine.LineInfo lineInfo = context.getLineInfo(source);
+    if (lineInfo != null) {
+      engine.LineInfo_Location offsetLocation =
+          lineInfo.getLocation(range.offset);
+      startLine = offsetLocation.lineNumber;
+      startColumn = offsetLocation.columnNumber;
+    }
   }
-  // done
   return new Location(
       source.fullName,
-      offset,
-      length,
+      range.offset,
+      range.length,
       startLine,
       startColumn);
 }
 
 /**
- * Create a Location based on an element and offset from the analyzer engine.
+ * Creates a new [Location] for the given [engine.Element].
  */
-Location _locationFromOffset(engine.Element element, int offset, int length) {
+Location _locationFromElement(engine.Element element) {
+  engine.AnalysisContext context = element.context;
   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);
+  String name = element.displayName;
+  int offset = element.nameOffset;
+  int length = name != null ? name.length : 0;
+  if (element is engine.CompilationUnitElement) {
+    offset = 0;
+    length = 0;
+  }
+  engine.SourceRange range = new engine.SourceRange(offset, length);
+  return _locationForArgs(context, source, range);
 }
 
+
+/**
+ * Creates a new [Location] for the given [engine.SearchMatch].
+ */
+Location _locationFromMatch(engine.SearchMatch match) {
+  engine.Element enclosingElement = match.element;
+  return _locationForArgs(
+      enclosingElement.context,
+      enclosingElement.source,
+      match.sourceRange);
+}
+
+
+/**
+ * Creates a new [Location] for the given [engine.AstNode].
+ */
+Location _locationFromNode(engine.AstNode node) {
+  engine.CompilationUnit unit =
+      node.getAncestor((node) => node is engine.CompilationUnit);
+  engine.CompilationUnitElement unitElement = unit.element;
+  engine.AnalysisContext context = unitElement.context;
+  engine.Source source = unitElement.source;
+  engine.SourceRange range = new engine.SourceRange(node.offset, node.length);
+  return _locationForArgs(context, source, range);
+}
+
+/**
+ * Creates a new [Location] for the given [engine.CompilationUnit].
+ */
+Location _locationFromUnit(engine.CompilationUnit unit,
+    engine.SourceRange range) {
+  engine.CompilationUnitElement unitElement = unit.element;
+  engine.AnalysisContext context = unitElement.context;
+  engine.Source source = unitElement.source;
+  return _locationForArgs(context, source, range);
+}
+
+
 /**
  * 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;
 }
 
+
+RefactoringProblemSeverity
+    _maxRefactoringProblemSeverity(RefactoringProblemSeverity a,
+    RefactoringProblemSeverity b) {
+  if (b == null) {
+    return a;
+  }
+  if (a == null) {
+    return b;
+  } else if (a == RefactoringProblemSeverity.INFO) {
+    return b;
+  } else if (a == RefactoringProblemSeverity.WARNING) {
+    if (b == RefactoringProblemSeverity.ERROR ||
+        b == RefactoringProblemSeverity.FATAL) {
+      return b;
+    }
+  } else if (a == RefactoringProblemSeverity.ERROR) {
+    if (b == RefactoringProblemSeverity.FATAL) {
+      return b;
+    }
+  }
+  return a;
+}
+
 /**
  * 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);
 }
 
 /**
@@ skipping 73 matching lines @@
         throw mismatch(jsonPath, 'int');
       });
     }
     throw mismatch(jsonPath, 'int');
   }
 
   /**
    * Decode a JSON object that is expected to be a List.  [decoder] is used to
    * decode the items in the list.
    */
-  List _decodeList(String jsonPath, Object json, [JsonDecoderCallback decoder])
-      {
+  List _decodeList(String jsonPath, Object json,
+      [JsonDecoderCallback decoder]) {
     if (json == null) {
       return [];
     } else if (json is List) {
       List result = [];
       for (int i = 0; i < json.length; i++) {
         result.add(decoder('$jsonPath[$i]', json[i]));
       }
       return result;
     } else {
       throw mismatch(jsonPath, 'List');
     }
   }
 
   /**
    * Decode a JSON object that is expected to be a Map.  [keyDecoder] is used
    * to decode the keys, and [valueDecoder] is used to decode the values.
    */
-  Map _decodeMap(String jsonPath, Object json, {JsonDecoderCallback
-      keyDecoder, JsonDecoderCallback valueDecoder}) {
+  Map _decodeMap(String jsonPath, Object json, {JsonDecoderCallback keyDecoder,
+      JsonDecoderCallback valueDecoder}) {
     if (json == null) {
       return {};
     } else if (json is Map) {
       Map result = {};
       json.forEach((String key, value) {
         Object decodedKey;
         if (keyDecoder != null) {
           decodedKey = keyDecoder('$jsonPath.key', key);
         } else {
           decodedKey = key;
@@ skipping 51 matching lines @@
 class RequestDecoder extends JsonDecoder {
   /**
    * The request being deserialized.
    */
   final Request _request;
 
   RequestDecoder(this._request);
 
   @override
   dynamic mismatch(String jsonPath, String expected) {
-    return new RequestFailure(new Response.invalidParameter(_request, jsonPath,
-        'be $expected'));
+    return new RequestFailure(
+        new Response.invalidParameter(_request, jsonPath, 'be $expected'));
   }
 
   @override
   dynamic missingKey(String jsonPath, String key) {
-    return new RequestFailure(new Response.invalidParameter(_request, jsonPath,
-        'contain key ${JSON.encode(key)}'));
+    return new RequestFailure(
+        new Response.invalidParameter(
+            _request,
+            jsonPath,
+            'contain key ${JSON.encode(key)}'));
   }
 }
 
 /**
  * JsonDecoder for decoding responses from the server.  This is intended to be
  * used only for testing.  Errors are reported using bare [Exception] objects.
  */
 class ResponseDecoder extends JsonDecoder {
   @override
   dynamic mismatch(String jsonPath, String expected) {
@@ skipping 20 matching lines @@
   }
 
   static int finish(int hash) {
     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));
+  static int hash4(a, b, c, d) =>
+      finish(combine(combine(combine(combine(0, a), b), c), d));
 }