Update Element/navigation/outline to use Location.

pkg/analysis_server/lib/src/computer/computer_outline.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 computer.outline;
 
 import 'package:analysis_server/src/computer/element.dart';
 import 'package:analysis_server/src/constants.dart';
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/element.dart' as engine;
+import 'package:analyzer/src/generated/engine.dart';
+import 'package:analyzer/src/generated/source.dart';
 
 
 /**
  * A computer for [CompilationUnit] outline.
  */
 class DartUnitOutlineComputer {
   final CompilationUnit _unit;
+  String file;
+  LineInfo lineInfo;
 
-  DartUnitOutlineComputer(this._unit);
+  DartUnitOutlineComputer(AnalysisContext context, Source source, this._unit) {
+    file = source.fullName;
+    lineInfo = context.getLineInfo(source);
+  }
 
   /**
    * Returns the computed outline, not `null`.
    */
   Map<String, Object> compute() {
     Outline unitOutline = _newUnitOutline();
     for (CompilationUnitMember unitMember in _unit.declarations) {
       if (unitMember is ClassDeclaration) {
         ClassDeclaration classDeclaration = unitMember;
         Outline classOutline = _newClassOutline(unitOutline, classDeclaration);
@@ skipping 46 matching lines @@
         _newFunctionTypeAliasOutline(unitOutline, alias);
       }
     }
     return unitOutline.toJson();
   }
 
   void _addLocalFunctionOutlines(Outline parent, FunctionBody body) {
     body.accept(new _LocalFunctionOutlinesVisitor(this, parent));
   }
 
+  Location _getLocationNode(AstNode node) {
+    int offset = node.offset;
+    int length = node.length;
+    return _getLocationOffsetLength(offset, length);
+  }
+
+  Location _getLocationOffsetLength(int offset, int length) {
+    LineInfo_Location lineLocation = lineInfo.getLocation(offset);
+    int startLine = lineLocation.lineNumber;
+    int startColumn = lineLocation.columnNumber;
+    return new Location(file, offset, length, startLine, startColumn);
+  }
+
   /**
    * Returns the [AstNode]'s source region.
    */
   _SourceRegion _getSourceRegion(AstNode node) {
     int endOffset = node.end;
     // prepare position of the node among its siblings
     int firstOffset;
     List<AstNode> siblings;
     AstNode parent = node.parent;
     // field
@@ skipping 31 matching lines @@
     }
     // not first child: [endOfPreviousSibling, endOfNode]
     int prevSiblingEnd = siblings[index - 1].end;
     return new _SourceRegion(prevSiblingEnd, endOffset - prevSiblingEnd);
   }
 
   Outline _newClassOutline(Outline parent, ClassDeclaration classDeclaration) {
     SimpleIdentifier nameNode = classDeclaration.name;
     String name = nameNode.name;
     _SourceRegion sourceRegion = _getSourceRegion(classDeclaration);
-    Element element = new Element(ElementKind.CLASS, name, nameNode.offset,
-        nameNode.length, Identifier.isPrivateName(name), _isDeprecated(
-        classDeclaration), isAbstract: classDeclaration.isAbstract);
+    Element element = new Element(ElementKind.CLASS, name, _getLocationNode(
+        nameNode), Identifier.isPrivateName(name), _isDeprecated(classDeclaration),
+        isAbstract: classDeclaration.isAbstract);
     Outline outline = new Outline(element, sourceRegion.offset,
         sourceRegion.length);
     parent.children.add(outline);
     return outline;
   }
 
   void _newClassTypeAlias(Outline parent, ClassTypeAlias alias) {
     SimpleIdentifier nameNode = alias.name;
     String name = nameNode.name;
     _SourceRegion sourceRegion = _getSourceRegion(alias);
     Element element = new Element(ElementKind.CLASS_TYPE_ALIAS, name,
-        nameNode.offset, nameNode.length, Identifier.isPrivateName(name), _isDeprecated(
+        _getLocationNode(nameNode), Identifier.isPrivateName(name), _isDeprecated(
         alias), isAbstract: alias.isAbstract);
     Outline outline = new Outline(element, sourceRegion.offset,
         sourceRegion.length);
     parent.children.add(outline);
   }
 
   void _newConstructorOutline(Outline parent,
       ConstructorDeclaration constructor) {
     Identifier returnType = constructor.returnType;
     String name = returnType.name;
     int offset = returnType.offset;
     int length = returnType.length;
     SimpleIdentifier constructorNameNode = constructor.name;
     bool isPrivate = false;
     if (constructorNameNode != null) {
       String constructorName = constructorNameNode.name;
       isPrivate = Identifier.isPrivateName(constructorName);
       name += '.${constructorName}';
       offset = constructorNameNode.offset;
       length = constructorNameNode.length;
     }
     _SourceRegion sourceRegion = _getSourceRegion(constructor);
     FormalParameterList parameters = constructor.parameters;
     String parametersStr = parameters != null ? parameters.toSource() : '';
-    Element element = new Element(ElementKind.CONSTRUCTOR, name, offset, length,
-        isPrivate, _isDeprecated(constructor), parameters: parametersStr);
+    Element element = new Element(ElementKind.CONSTRUCTOR, name,
+        _getLocationOffsetLength(offset, length), isPrivate, _isDeprecated(constructor),
+        parameters: parametersStr);
     Outline outline = new Outline(element, sourceRegion.offset,
         sourceRegion.length);
     parent.children.add(outline);
     _addLocalFunctionOutlines(outline, constructor.body);
   }
 
   void _newFunctionOutline(Outline parent, FunctionDeclaration function,
       bool isStatic) {
     TypeName returnType = function.returnType;
     SimpleIdentifier nameNode = function.name;
     String name = nameNode.name;
     FunctionExpression functionExpression = function.functionExpression;
     FormalParameterList parameters = functionExpression.parameters;
     ElementKind kind;
     if (function.isGetter) {
       kind = ElementKind.GETTER;
     } else if (function.isSetter) {
       kind = ElementKind.SETTER;
     } else {
       kind = ElementKind.FUNCTION;
     }
     _SourceRegion sourceRegion = _getSourceRegion(function);
     String parametersStr = parameters != null ? parameters.toSource() : '';
     String returnTypeStr = returnType != null ? returnType.toSource() : '';
-    Element element = new Element(kind, name, nameNode.offset, nameNode.length,
+    Element element = new Element(kind, name, _getLocationNode(nameNode),
         Identifier.isPrivateName(name), _isDeprecated(function), parameters:
         parametersStr, returnType: returnTypeStr, isStatic: isStatic);
     Outline outline = new Outline(element, sourceRegion.offset,
         sourceRegion.length);
     parent.children.add(outline);
     _addLocalFunctionOutlines(outline, functionExpression.body);
   }
 
   void _newFunctionTypeAliasOutline(Outline parent, FunctionTypeAlias alias) {
     TypeName returnType = alias.returnType;
     SimpleIdentifier nameNode = alias.name;
     String name = nameNode.name;
     _SourceRegion sourceRegion = _getSourceRegion(alias);
     FormalParameterList parameters = alias.parameters;
     String parametersStr = parameters != null ? parameters.toSource() : '';
     String returnTypeStr = returnType != null ? returnType.toSource() : '';
     Element element = new Element(ElementKind.FUNCTION_TYPE_ALIAS, name,
-        nameNode.offset, nameNode.length, Identifier.isPrivateName(name), _isDeprecated(
+        _getLocationNode(nameNode), Identifier.isPrivateName(name), _isDeprecated(
         alias), parameters: parametersStr, returnType: returnTypeStr);
     Outline outline = new Outline(element, sourceRegion.offset,
         sourceRegion.length);
     parent.children.add(outline);
   }
 
   void _newMethodOutline(Outline parent, MethodDeclaration method) {
     TypeName returnType = method.returnType;
     SimpleIdentifier nameNode = method.name;
     String name = nameNode.name;
     FormalParameterList parameters = method.parameters;
     ElementKind kind;
     if (method.isGetter) {
       kind = ElementKind.GETTER;
     } else if (method.isSetter) {
       kind = ElementKind.SETTER;
     } else {
       kind = ElementKind.METHOD;
     }
     _SourceRegion sourceRegion = _getSourceRegion(method);
     String parametersStr = parameters != null ? parameters.toSource() : '';
     String returnTypeStr = returnType != null ? returnType.toSource() : '';
-    Element element = new Element(kind, name, nameNode.offset, nameNode.length,
+    Element element = new Element(kind, name, _getLocationNode(nameNode),
         Identifier.isPrivateName(name), _isDeprecated(method), parameters:
         parametersStr, returnType: returnTypeStr, isAbstract: method.isAbstract,
         isStatic: method.isStatic);
     Outline outline = new Outline(element, sourceRegion.offset,
         sourceRegion.length);
     parent.children.add(outline);
     _addLocalFunctionOutlines(outline, method.body);
   }
 
   Outline _newUnitOutline() {
     Element element = new Element(ElementKind.COMPILATION_UNIT, '<unit>',
-        _unit.offset, _unit.length, false, false);
+        _getLocationNode(_unit), false, false);
     return new Outline(element, _unit.offset, _unit.length);
   }
 
   void _newVariableOutline(Outline parent, String typeName, ElementKind kind,
       VariableDeclaration variable, bool isStatic) {
     SimpleIdentifier nameNode = variable.name;
     String name = nameNode.name;
     _SourceRegion sourceRegion = _getSourceRegion(variable);
-    Element element = new Element(kind, name, nameNode.offset, nameNode.length,
+    Element element = new Element(kind, name, _getLocationNode(nameNode),
         Identifier.isPrivateName(name), _isDeprecated(variable), returnType: typeName,
         isStatic: isStatic, isConst: variable.isConst, isFinal: variable.isFinal);
     Outline outline = new Outline(element, sourceRegion.offset,
         sourceRegion.length);
     parent.children.add(outline);
   }
 
   /**
    * Returns `true` if the given [element] is not `null` and deprecated.
    */
@@ skipping 78 matching lines @@
 
 
 /**
  * A range of characters.
  */
 class _SourceRegion {
   final int length;
   final int offset;
   _SourceRegion(this.offset, this.length);
 }