Move Engine to Server element / error converters into protocol_server.dart

pkg/analysis_server/lib/src/protocol_server.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 protocol.server;
 
-import 'package:analysis_server/src/computer/element.dart';
 import 'package:analysis_server/src/protocol.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 'package:analyzer/src/generated/utilities_dart.dart' as engine;
 
 export 'package:analysis_server/src/protocol.dart';
 
 
 /**
  * Returns a list of AnalysisErrors correponding to the given list of Engine
  * errors.
  */
 List<AnalysisError> doAnalysisError_listFromEngine(engine.LineInfo lineInfo,
     List<engine.AnalysisError> errors) {
@@ skipping 170 matching lines @@
     return ElementKind.TYPE_PARAMETER;
   }
   return ElementKind.UNKNOWN;
 }
 
 
 /**
  * Construct based on a value from the analyzer engine.
  */
 Element newElement_fromEngine(engine.Element element) {
-  return elementFromEngine(element);
+  String name = element.displayName;
+  String elementParameters = _getParametersString(element);
+  String elementReturnType = _getReturnTypeString(element);
+  return new Element(
+      newElementKind_fromEngine(element.kind),
+      name,
+      Element.makeFlags(
+          isPrivate: element.isPrivate,
+          isDeprecated: element.isDeprecated,
+          isAbstract: _isAbstract(element),
+          isConst: _isConst(element),
+          isFinal: _isFinal(element),
+          isStatic: _isStatic(element)),
+      location: newLocation_fromElement(element),
+      parameters: elementParameters,
+      returnType: elementReturnType);
 }
 
 
 /**
  * Create a Location based on an [engine.Element].
  */
 Location newLocation_fromElement(engine.Element element) {
   engine.AnalysisContext context = element.context;
   engine.Source source = element.source;
   if (context == null || source == null) {
@@ skipping 46 matching lines @@
   engine.AnalysisContext context = unitElement.context;
   engine.Source source = unitElement.source;
   return _locationForArgs(context, source, range);
 }
 
 
 /**
  * Construct based on an element from the analyzer engine.
  */
 OverriddenMember newOverriddenMember_fromEngine(engine.Element member) {
-  Element element = elementFromEngine(member);
+  Element element = newElement_fromEngine(member);
   String className = member.enclosingElement.displayName;
   return new OverriddenMember(element, className);
 }
 
 
 
 /**
  * Construct based on a value from the search engine.
  */
 SearchResultKind newSearchResultKind_fromEngine(engine.MatchKind kind) {
@@ skipping 41 matching lines @@
 List<Element> _computePath(engine.Element element) {
   List<Element> path = <Element>[];
   while (element != null) {
     path.add(newElement_fromEngine(element));
     element = element.enclosingElement;
   }
   return path;
 }
 
 
+String _getParametersString(engine.Element element) {
+  // TODO(scheglov) expose the corresponding feature from ExecutableElement
+  if (element is engine.ExecutableElement) {
+    var sb = new StringBuffer();
+    String closeOptionalString = '';
+    for (var parameter in element.parameters) {
+      if (sb.isNotEmpty) {
+        sb.write(', ');
+      }
+      if (closeOptionalString.isEmpty) {
+        if (parameter.kind == engine.ParameterKind.NAMED) {
+          sb.write('{');
+          closeOptionalString = '}';
+        }
+        if (parameter.kind == engine.ParameterKind.POSITIONAL) {
+          sb.write('[');
+          closeOptionalString = ']';
+        }
+      }
+      sb.write(parameter.toString());
+    }
+    sb.write(closeOptionalString);
+    return '(' + sb.toString() + ')';
+  } else {
+    return null;
+  }
+}
+
+
+String _getReturnTypeString(engine.Element element) {
+  if (element is engine.ExecutableElement) {
+    if (element.kind == engine.ElementKind.SETTER) {
+      return null;
+    } else {
+      return element.returnType.toString();
+    }
+  } else {
+    return null;
+  }
+}
+
+bool _isAbstract(engine.Element element) {
+  // TODO(scheglov) add isAbstract to Element API

[Brian Wilkerson, 2014/10/07 22:21:55]

It doesn't make sense to ask isAbstract, etc. for most elements. Let me think
about this before we add it to the API's.

+  if (element is engine.ClassElement) {
+    return element.isAbstract;
+  }
+  if (element is engine.MethodElement) {
+    return element.isAbstract;
+  }
+  if (element is engine.PropertyAccessorElement) {
+    return element.isAbstract;
+  }
+  return false;
+}
+
+bool _isConst(engine.Element element) {
+  // TODO(scheglov) add isConst to Element API
+  if (element is engine.ConstructorElement) {
+    return element.isConst;
+  }
+  if (element is engine.VariableElement) {
+    return element.isConst;
+  }
+  return false;
+}
+
+bool _isFinal(engine.Element element) {
+  // TODO(scheglov) add isFinal to Element API
+  if (element is engine.VariableElement) {
+    return element.isFinal;
+  }
+  return false;
+}
+
+bool _isStatic(engine.Element element) {
+  // TODO(scheglov) add isStatic to Element API
+  if (element is engine.ExecutableElement) {
+    return element.isStatic;
+  }
+  if (element is engine.PropertyInducingElement) {
+    return element.isStatic;
+  }
+  return false;
+}
+
 /**
  * Creates a new [Location].
  */
 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;
     }
   }
   return new Location(
       source.fullName,
       range.offset,
       range.length,
       startLine,
       startColumn);
 }