Add test structure to the outline from 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.
 
 import 'package:analysis_server/src/collections.dart';
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/visitor.dart';
 import 'package:analyzer/dart/element/element.dart' as engine;
 import 'package:analyzer/dart/element/type.dart' as engine;
 import 'package:analyzer/src/generated/source.dart';
@@ skipping 72 matching lines @@
       }
       if (unitMember is FunctionTypeAlias) {
         FunctionTypeAlias alias = unitMember;
         unitContents.add(_newFunctionTypeAliasOutline(alias));
       }
     }
     Outline unitOutline = _newUnitOutline(unitContents);
     return unitOutline;
   }
 
-  List<Outline> _addLocalFunctionOutlines(FunctionBody body) {
+  List<Outline> _addFunctionBodyOutlines(FunctionBody body) {
     List<Outline> contents = <Outline>[];
-    body.accept(new _LocalFunctionOutlinesVisitor(this, contents));
+    body.accept(new _FunctionBodyOutlinesVisitor(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) {
@@ skipping 99 matching lines @@
     SourceRange range = _getSourceRange(constructor);
     FormalParameterList parameters = constructor.parameters;
     String parametersStr = _safeToSource(parameters);
     Element element = new Element(
         ElementKind.CONSTRUCTOR,
         name,
         Element.makeFlags(
             isPrivate: isPrivate, isDeprecated: _isDeprecated(constructor)),
         location: _getLocationOffsetLength(offset, length),
         parameters: parametersStr);
-    List<Outline> contents = _addLocalFunctionOutlines(constructor.body);
+    List<Outline> contents = _addFunctionBodyOutlines(constructor.body);
     Outline outline = new Outline(element, range.offset, range.length,
         children: nullIfEmpty(contents));
     return outline;
   }
 
   Outline _newEnumConstant(EnumConstantDeclaration node) {
     SimpleIdentifier nameNode = node.name;
     String name = nameNode.name;
     SourceRange range = _getSourceRange(node);
     Element element = new Element(
@@ skipping 41 matching lines @@
     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);
+    List<Outline> contents = _addFunctionBodyOutlines(functionExpression.body);
     Outline outline = new Outline(element, range.offset, range.length,
         children: nullIfEmpty(contents));
     return outline;
   }
 
   Outline _newFunctionTypeAliasOutline(FunctionTypeAlias node) {
     TypeAnnotation returnType = node.returnType;
     SimpleIdentifier nameNode = node.name;
     String name = nameNode.name;
     SourceRange range = _getSourceRange(node);
@@ skipping 33 matching lines @@
         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);
+    List<Outline> contents = _addFunctionBodyOutlines(method.body);
     Outline outline = new Outline(element, range.offset, range.length,
         children: nullIfEmpty(contents));
     return outline;
   }
 
   Outline _newUnitOutline(List<Outline> unitContents) {
     Element element = new Element(
         ElementKind.COMPILATION_UNIT, '<unit>', Element.makeFlags(),
         location: _getLocationNode(unit));
     return new Outline(element, unit.offset, unit.length,
@@ skipping 35 matching lines @@
     return element != null && element.isDeprecated;
   }
 
   static String _safeToSource(AstNode node) =>
       node == null ? '' : node.toSource();
 }
 
 /**
  * A visitor for building local function outlines.
  */
-class _LocalFunctionOutlinesVisitor extends RecursiveAstVisitor {
+class _FunctionBodyOutlinesVisitor extends RecursiveAstVisitor {
   final DartUnitOutlineComputer outlineComputer;
   final List<Outline> contents;
 
-  _LocalFunctionOutlinesVisitor(this.outlineComputer, this.contents);
+  _FunctionBodyOutlinesVisitor(this.outlineComputer, this.contents);
+
+  bool isGroup(engine.ExecutableElement element) {
+    if (element is engine.FunctionElement && element.name == 'group') {
+      engine.Element parent = element.enclosingElement;
+      return parent is engine.CompilationUnitElement &&
+          parent.source.fullName.endsWith('test.dart');
+    }
+    return false;
+  }
+
+  bool isTest(engine.ExecutableElement element) {
+    if (element is engine.FunctionElement && element.name == 'test') {
+      engine.Element parent = element.enclosingElement;
+      return parent is engine.CompilationUnitElement &&
+          parent.source.fullName.endsWith('test.dart');
+    }
+    return false;
+  }
 
   @override
   visitFunctionDeclaration(FunctionDeclaration node) {
     contents.add(outlineComputer._newFunctionOutline(node, false));
   }
+
+  @override
+  visitMethodInvocation(MethodInvocation node) {
+    SimpleIdentifier nameNode = node.methodName;
+    engine.ExecutableElement executableElement = nameNode.bestElement;
+
+    String extractString(NodeList<Expression> arguments) {
+      if (arguments != null && arguments.length > 0) {
+        Expression argument = arguments[0];
+        if (argument is StringLiteral) {
+          String value = argument.stringValue;
+          if (value != null) {
+            return value;
+          }
+        }
+        return argument.toSource();
+      }
+      return 'unnamed';
+    }
+
+    void addOutline(String kind, [List<Outline> children]) {
+      SourceRange range = outlineComputer._getSourceRange(node);
+      String name = kind + ' ' + extractString(node.argumentList?.arguments);
+      Element element = new Element(ElementKind.UNKNOWN, name, 0,
+          location: outlineComputer._getLocationNode(nameNode));
+      contents.add(new Outline(element, range.offset, range.length,
+          children: nullIfEmpty(children)));
+    }
+
+    if (isGroup(executableElement)) {
+      List<Outline> groupContents = <Outline>[];
+      node.argumentList.accept(
+          new _FunctionBodyOutlinesVisitor(outlineComputer, groupContents));
+      addOutline('group', groupContents);
+    } else if (isTest(executableElement)) {
+      addOutline('test');
+    } else {
+      super.visitMethodInvocation(node);
+    }
+  }
 }