Make more use of generated code in analysis server.

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:analysis_server/src/protocol2.dart' show ElementKind;
-import 'package:analysis_server/src/services/json.dart';
+import 'package:analysis_server/src/protocol2.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(AnalysisContext context, Source source, this._unit) {
     file = source.fullName;
     lineInfo = context.getLineInfo(source);
   }
 
   /**
    * Returns the computed outline, not `null`.
    */
   Outline compute() {
-    Outline unitOutline = _newUnitOutline();
+    List<Outline> unitContents = <Outline>[];
     for (CompilationUnitMember unitMember in _unit.declarations) {
       if (unitMember is ClassDeclaration) {
         ClassDeclaration classDeclaration = unitMember;
-        Outline classOutline = _newClassOutline(unitOutline, classDeclaration);
+        List<Outline> classContents = <Outline>[];
         for (ClassMember classMember in classDeclaration.members) {
           if (classMember is ConstructorDeclaration) {
             ConstructorDeclaration constructorDeclaration = classMember;
-            _newConstructorOutline(classOutline, constructorDeclaration);
+            classContents.add(_newConstructorOutline(constructorDeclaration));
           }
           if (classMember is FieldDeclaration) {
             FieldDeclaration fieldDeclaration = classMember;
             VariableDeclarationList fields = fieldDeclaration.fields;
             if (fields != null) {
               TypeName fieldType = fields.type;
               String fieldTypeName = fieldType != null ? fieldType.toSource() :
                   '';
               for (VariableDeclaration field in fields.variables) {
-                _newVariableOutline(classOutline, fieldTypeName,
-                    ElementKind.FIELD, field, fieldDeclaration.isStatic);
+                classContents.add(_newVariableOutline(fieldTypeName,
+                    ElementKind.FIELD, field, fieldDeclaration.isStatic));
               }
             }
           }
           if (classMember is MethodDeclaration) {
             MethodDeclaration methodDeclaration = classMember;
-            _newMethodOutline(classOutline, methodDeclaration);
+            classContents.add(_newMethodOutline(methodDeclaration));
           }
         }
+        unitContents.add(_newClassOutline(classDeclaration, classContents));
       }
       if (unitMember is TopLevelVariableDeclaration) {
         TopLevelVariableDeclaration fieldDeclaration = unitMember;
         VariableDeclarationList fields = fieldDeclaration.variables;
         if (fields != null) {
           TypeName fieldType = fields.type;
           String fieldTypeName = fieldType != null ? fieldType.toSource() : '';
           for (VariableDeclaration field in fields.variables) {
-            _newVariableOutline(unitOutline, fieldTypeName,
-                ElementKind.TOP_LEVEL_VARIABLE, field, false);
+            unitContents.add(_newVariableOutline(fieldTypeName,
+                ElementKind.TOP_LEVEL_VARIABLE, field, false));
           }
         }
       }
       if (unitMember is FunctionDeclaration) {
         FunctionDeclaration functionDeclaration = unitMember;
-        _newFunctionOutline(unitOutline, functionDeclaration, true);
+        unitContents.add(_newFunctionOutline(functionDeclaration, true));
       }
       if (unitMember is ClassTypeAlias) {
         ClassTypeAlias alias = unitMember;
-        _newClassTypeAlias(unitOutline, alias);
+        unitContents.add(_newClassTypeAlias(alias));
       }
       if (unitMember is FunctionTypeAlias) {
         FunctionTypeAlias alias = unitMember;
-        _newFunctionTypeAliasOutline(unitOutline, alias);
+        unitContents.add(_newFunctionTypeAliasOutline(alias));
       }
     }
+    Outline unitOutline = _newUnitOutline(unitContents);
     return unitOutline;
   }
 
-  void _addLocalFunctionOutlines(Outline parent, FunctionBody body) {
-    body.accept(new _LocalFunctionOutlinesVisitor(this, parent));
+  List<Outline> _addLocalFunctionOutlines(FunctionBody body) {
+    List<Outline> contents = <Outline>[];
+    body.accept(new _LocalFunctionOutlinesVisitor(this, contents));
+    return contents;
   }
 
   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);
@@ skipping 42 matching lines @@
     // first child: [endOfParent, endOfNode]
     int index = siblings.indexOf(node);
     if (index == 0) {
       return new _SourceRegion(firstOffset, endOffset - firstOffset);
     }
     // not first child: [endOfPreviousSibling, endOfNode]
     int prevSiblingEnd = siblings[index - 1].end;
     return new _SourceRegion(prevSiblingEnd, endOffset - prevSiblingEnd);
   }
 
-  Outline _newClassOutline(Outline parent, ClassDeclaration classDeclaration) {
+  Outline _newClassOutline(ClassDeclaration classDeclaration,
+      List<Outline> classContents) {
     SimpleIdentifier nameNode = classDeclaration.name;
     String name = nameNode.name;
     _SourceRegion sourceRegion = _getSourceRegion(classDeclaration);
-    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;
+    Element element = new Element(ElementKind.CLASS, name,
+        Element.makeFlags(isPrivate: Identifier.isPrivateName(name),
+            isDeprecated: _isDeprecated(classDeclaration),
+            isAbstract: classDeclaration.isAbstract),
+        location: _getLocationNode(nameNode));
+    return new Outline(element, sourceRegion.offset,
+        sourceRegion.length,
+        children: classContents.isNotEmpty ? classContents : null);

[scheglov, 2014/08/21 18:03:22]

Do we already use null instead of empty lists?
Should we do this check in toJson() instead?
This code is duplicated many times here and in other computers.

[Paul Berry, 2014/08/21 20:00:44]

Ok, I'll look into this in a future CL.

   }
 
-  void _newClassTypeAlias(Outline parent, ClassTypeAlias alias) {
+  Outline _newClassTypeAlias(ClassTypeAlias alias) {
     SimpleIdentifier nameNode = alias.name;
     String name = nameNode.name;
     _SourceRegion sourceRegion = _getSourceRegion(alias);
     Element element = new Element(ElementKind.CLASS_TYPE_ALIAS, name,
-        _getLocationNode(nameNode), Identifier.isPrivateName(name), _isDeprecated(
-        alias), isAbstract: alias.isAbstract);
-    Outline outline = new Outline(element, sourceRegion.offset,
+        Element.makeFlags(isPrivate: Identifier.isPrivateName(name),
+            isDeprecated: _isDeprecated(alias), isAbstract: alias.isAbstract),
+        location: _getLocationNode(nameNode));
+    return new Outline(element, sourceRegion.offset,
         sourceRegion.length);
-    parent.children.add(outline);
   }
 
-  void _newConstructorOutline(Outline parent,
-      ConstructorDeclaration constructor) {
+  Outline _newConstructorOutline(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,
-        _getLocationOffsetLength(offset, length), isPrivate, _isDeprecated(constructor),
+        Element.makeFlags(isPrivate: isPrivate,
+            isDeprecated: _isDeprecated(constructor)),
+        location: _getLocationOffsetLength(offset, length),
         parameters: parametersStr);
+    List<Outline> contents = _addLocalFunctionOutlines(constructor.body);
     Outline outline = new Outline(element, sourceRegion.offset,
-        sourceRegion.length);
-    parent.children.add(outline);
-    _addLocalFunctionOutlines(outline, constructor.body);
+        sourceRegion.length, children: contents.isNotEmpty ? contents : null);
+    return outline;
   }
 
-  void _newFunctionOutline(Outline parent, FunctionDeclaration function,
-      bool isStatic) {
+  Outline _newFunctionOutline(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, _getLocationNode(nameNode),
-        Identifier.isPrivateName(name), _isDeprecated(function), parameters:
-        parametersStr, returnType: returnTypeStr, isStatic: isStatic);
+    Element element = new Element(kind, name,
+        Element.makeFlags(isPrivate: Identifier.isPrivateName(name),
+            isDeprecated: _isDeprecated(function), isStatic: isStatic),
+        location: _getLocationNode(nameNode), parameters: parametersStr,
+        returnType: returnTypeStr);
+    List<Outline> contents = _addLocalFunctionOutlines(functionExpression.body);
     Outline outline = new Outline(element, sourceRegion.offset,
-        sourceRegion.length);
-    parent.children.add(outline);
-    _addLocalFunctionOutlines(outline, functionExpression.body);
+        sourceRegion.length, children: contents.isNotEmpty ? contents : null);
+    return outline;
   }
 
-  void _newFunctionTypeAliasOutline(Outline parent, FunctionTypeAlias alias) {
+  Outline _newFunctionTypeAliasOutline(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,
-        _getLocationNode(nameNode), Identifier.isPrivateName(name), _isDeprecated(
-        alias), parameters: parametersStr, returnType: returnTypeStr);
-    Outline outline = new Outline(element, sourceRegion.offset,
+        Element.makeFlags(isPrivate: Identifier.isPrivateName(name),
+            isDeprecated: _isDeprecated(alias)),
+        location: _getLocationNode(nameNode), parameters: parametersStr,
+        returnType: returnTypeStr);
+    return new Outline(element, sourceRegion.offset,
         sourceRegion.length);
-    parent.children.add(outline);
   }
 
-  void _newMethodOutline(Outline parent, MethodDeclaration method) {
+  Outline _newMethodOutline(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, _getLocationNode(nameNode),
-        Identifier.isPrivateName(name), _isDeprecated(method), parameters:
-        parametersStr, returnType: returnTypeStr, isAbstract: method.isAbstract,
-        isStatic: method.isStatic);
+    Element element = new Element(kind, name,
+        Element.makeFlags(isPrivate: Identifier.isPrivateName(name),
+            isDeprecated: _isDeprecated(method), isAbstract: method.isAbstract,
+            isStatic: method.isStatic), location: _getLocationNode(nameNode),
+        parameters: parametersStr, returnType: returnTypeStr);
+    List<Outline> contents = _addLocalFunctionOutlines(method.body);
     Outline outline = new Outline(element, sourceRegion.offset,
-        sourceRegion.length);
-    parent.children.add(outline);
-    _addLocalFunctionOutlines(outline, method.body);
+        sourceRegion.length, children: contents.isNotEmpty ? contents : null);
+    return outline;
   }
 
-  Outline _newUnitOutline() {
+  Outline _newUnitOutline(List<Outline> unitContents) {
     Element element = new Element(ElementKind.COMPILATION_UNIT, '<unit>',
-        _getLocationNode(_unit), false, false);
-    return new Outline(element, _unit.offset, _unit.length);
+        Element.makeFlags(), location: _getLocationNode(_unit));
+    return new Outline(element, _unit.offset, _unit.length,
+        children: unitContents.isNotEmpty ? unitContents : null);
   }
 
-  void _newVariableOutline(Outline parent, String typeName, ElementKind kind,
+  Outline _newVariableOutline(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, _getLocationNode(nameNode),
-        Identifier.isPrivateName(name), _isDeprecated(variable), returnType: typeName,
-        isStatic: isStatic, isConst: variable.isConst, isFinal: variable.isFinal);
+    Element element = new Element(kind, name,
+        Element.makeFlags(isPrivate: Identifier.isPrivateName(name),
+            isDeprecated: _isDeprecated(variable),
+            isStatic: isStatic, isConst: variable.isConst,
+            isFinal: variable.isFinal), location: _getLocationNode(nameNode),
+        returnType: typeName);
     Outline outline = new Outline(element, sourceRegion.offset,
         sourceRegion.length);
-    parent.children.add(outline);
+    return outline;
   }
 
   /**
    * Returns `true` if the given [element] is not `null` and deprecated.
    */
   static bool _isDeprecated(Declaration declaration) {
     engine.Element element = declaration.element;
     return element != null && element.isDeprecated;
   }
 }
 
 
 /**
- * An element outline.
- */
-class Outline implements HasToJson {
-  static const List<Outline> EMPTY_ARRAY = const <Outline>[];
-
-  /**
-   * The children of the node.
-   * The field will be omitted in JSON if the node has no children.
-   */
-  final List<Outline> children = <Outline>[];
-
-  /**
-   * A description of the element represented by this node.
-   */
-  final Element element;
-
-  /**
-   * The length of the element.
-   */
-  final int length;
-
-  /**
-   * The offset of the first character of the element.
-   */
-  final int offset;
-
-  Outline(this.element, this.offset, this.length);
-
-  factory Outline.fromJson(Map<String, Object> map) {
-    Element element = new Element.fromJson(map[ELEMENT]);
-    Outline outline = new Outline(element, map[OFFSET], map[LENGTH]);
-    // add children
-    List<Map<String, Object>> childrenMaps = map[CHILDREN];
-    if (childrenMaps != null) {
-      childrenMaps.forEach((childMap) {
-        outline.children.add(new Outline.fromJson(childMap));
-      });
-    }
-    // done
-    return outline;
-  }
-
-  Map<String, Object> toJson() {
-    Map<String, Object> json = {
-      ELEMENT: element.toJson(),
-      OFFSET: offset,
-      LENGTH: length
-    };
-    if (children.isNotEmpty) {
-      json[CHILDREN] = children.map((child) => child.toJson()).toList();
-    }
-    return json;
-  }
-}
-
-
-/**
  * A visitor for building local function outlines.
  */
 class _LocalFunctionOutlinesVisitor extends RecursiveAstVisitor {
   final DartUnitOutlineComputer outlineComputer;
-  final Outline parent;
+  final List<Outline> contents;
 
-  _LocalFunctionOutlinesVisitor(this.outlineComputer, this.parent);
+  _LocalFunctionOutlinesVisitor(this.outlineComputer, this.contents);
 
   @override
   visitFunctionDeclaration(FunctionDeclaration node) {
-    outlineComputer._newFunctionOutline(parent, node, false);
+    contents.add(outlineComputer._newFunctionOutline(node, false));
   }
 }
 
 
 /**
  * A range of characters.
  */
 class _SourceRegion {
   final int length;
   final int offset;
   _SourceRegion(this.offset, this.length);
 }