Updates for the Outline API and use it in Editor.

pkg/analysis_server/test/analysis_notification_outline_test.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 test.domain.analysis.notification.outline;
 
 import 'dart:async';
 import 'dart:mirrors';
 
 import 'package:analysis_server/src/analysis_server.dart';
@@ skipping 54 matching lines @@
       _Outline unitOutline = outline;
       List<_Outline> topOutlines = unitOutline.children;
       expect(topOutlines, hasLength(2));
       // A
       {
         _Outline outline_A = topOutlines[0];
         expect(outline_A.kind, _OutlineKind.CLASS);
         expect(outline_A.name, "A");
         expect(outline_A.nameOffset, testCode.indexOf("A {"));
         expect(outline_A.nameLength, 1);
-        expect(outline_A.arguments, null);
+        expect(outline_A.parameters, null);
         expect(outline_A.returnType, null);
         // A children
         List<_Outline> outlines_A = outline_A.children;
         expect(outlines_A, hasLength(10));
         {
           _Outline outline = outlines_A[0];
           expect(outline.kind, _OutlineKind.FIELD);
           expect(outline.name, "fa");
-          expect(outline.arguments, isNull);
+          expect(outline.parameters, isNull);
           expect(outline.returnType, "int");
         }
         {
           _Outline outline = outlines_A[1];
           expect(outline.kind, _OutlineKind.FIELD);
           expect(outline.name, "fb");
-          expect(outline.arguments, isNull);
+          expect(outline.parameters, isNull);
           expect(outline.returnType, "int");
         }
         {
           _Outline outline = outlines_A[2];
           expect(outline.kind, _OutlineKind.FIELD);
           expect(outline.name, "fc");
-          expect(outline.arguments, isNull);
+          expect(outline.parameters, isNull);
           expect(outline.returnType, "String");
         }
         {
           _Outline outline = outlines_A[3];
           expect(outline.kind, _OutlineKind.CONSTRUCTOR);
           expect(outline.name, "A");
           expect(outline.nameOffset, testCode.indexOf("A(int i, String s);"));
           expect(outline.nameLength, "A".length);
-          expect(outline.arguments, "(int i, String s)");
+          expect(outline.parameters, "(int i, String s)");
           expect(outline.returnType, isNull);
           expect(outline.isAbstract, isFalse);
           expect(outline.isStatic, isFalse);
         }
         {
           _Outline outline = outlines_A[4];
           expect(outline.kind, _OutlineKind.CONSTRUCTOR);
           expect(outline.name, "A.name");
           expect(outline.nameOffset, testCode.indexOf("name(num p);"));
           expect(outline.nameLength, "name".length);
-          expect(outline.arguments, "(num p)");
+          expect(outline.parameters, "(num p)");
           expect(outline.returnType, isNull);
           expect(outline.isAbstract, isFalse);
           expect(outline.isStatic, isFalse);
         }
         {
           _Outline outline = outlines_A[5];
           expect(outline.kind, _OutlineKind.CONSTRUCTOR);
           expect(outline.name, "A._privateName");
           expect(outline.nameOffset, testCode.indexOf("_privateName(num p);"));
           expect(outline.nameLength, "_privateName".length);
-          expect(outline.arguments, "(num p)");
+          expect(outline.parameters, "(num p)");
           expect(outline.returnType, isNull);
           expect(outline.isAbstract, isFalse);
           expect(outline.isStatic, isFalse);
         }
         {
           _Outline outline = outlines_A[6];
           expect(outline.kind, _OutlineKind.METHOD);
           expect(outline.name, "ma");
           expect(outline.nameOffset, testCode.indexOf("ma(int pa) => null;"));
           expect(outline.nameLength, "ma".length);
-          expect(outline.arguments, "(int pa)");
+          expect(outline.parameters, "(int pa)");
           expect(outline.returnType, "String");
           expect(outline.isAbstract, isFalse);
           expect(outline.isStatic, isTrue);
         }
         {
           _Outline outline = outlines_A[7];
           expect(outline.kind, _OutlineKind.METHOD);
           expect(outline.name, "_mb");
           expect(outline.nameOffset, testCode.indexOf("_mb(int pb);"));
           expect(outline.nameLength, "_mb".length);
-          expect(outline.arguments, "(int pb)");
+          expect(outline.parameters, "(int pb)");
           expect(outline.returnType, "");
           expect(outline.isAbstract, isTrue);
           expect(outline.isStatic, isFalse);
         }
         {
           _Outline outline = outlines_A[8];
           expect(outline.kind, _OutlineKind.GETTER);
           expect(outline.name, "propA");
           expect(outline.nameOffset, testCode.indexOf("propA => null;"));
           expect(outline.nameLength, "propA".length);
-          expect(outline.arguments, "");
+          expect(outline.parameters, "");
           expect(outline.returnType, "String");
         }
         {
           _Outline outline = outlines_A[9];
           expect(outline.kind, _OutlineKind.SETTER);
           expect(outline.name, "propB");
           expect(outline.nameOffset, testCode.indexOf("propB(int v) {}"));
           expect(outline.nameLength, "propB".length);
-          expect(outline.arguments, "(int v)");
+          expect(outline.parameters, "(int v)");
           expect(outline.returnType, "");
         }
       }
       // B
       {
         _Outline outline_B = topOutlines[1];
         expect(outline_B.kind, _OutlineKind.CLASS);
         expect(outline_B.name, "B");
         expect(outline_B.nameOffset, testCode.indexOf("B {"));
         expect(outline_B.nameLength, 1);
-        expect(outline_B.arguments, null);
+        expect(outline_B.parameters, null);
         expect(outline_B.returnType, null);
         // B children
         List<_Outline> outlines_B = outline_B.children;
         expect(outlines_B, hasLength(1));
         {
           _Outline outline = outlines_B[0];
           expect(outline.kind, _OutlineKind.CONSTRUCTOR);
           expect(outline.name, "B");
           expect(outline.nameOffset, testCode.indexOf("B(int p);"));
           expect(outline.nameLength, "B".length);
-          expect(outline.arguments, "(int p)");
+          expect(outline.parameters, "(int p)");
           expect(outline.returnType, isNull);
         }
       }
     });
   }
 
   test_sourceRange_inClass() {
     addTestFile('''
 class A { // leftA
   int methodA() {} // endA
@@ skipping 212 matching lines @@
       _Outline unitOutline = outline;
       List<_Outline> topOutlines = unitOutline.children;
       expect(topOutlines, hasLength(2));
       // A
       {
         _Outline outline_A = topOutlines[0];
         expect(outline_A.kind, _OutlineKind.CLASS);
         expect(outline_A.name, "A");
         expect(outline_A.nameOffset, testCode.indexOf("A {"));
         expect(outline_A.nameLength, "A".length);
-        expect(outline_A.arguments, null);
+        expect(outline_A.parameters, null);
         expect(outline_A.returnType, null);
         // A children
         List<_Outline> outlines_A = outline_A.children;
         expect(outlines_A, hasLength(2));
         {
           _Outline constructorOutline = outlines_A[0];
           expect(constructorOutline.kind, _OutlineKind.CONSTRUCTOR);
           expect(constructorOutline.name, "A");
           expect(constructorOutline.nameOffset, testCode.indexOf("A() {"));
           expect(constructorOutline.nameLength, "A".length);
-          expect(constructorOutline.arguments, "()");
+          expect(constructorOutline.parameters, "()");
           expect(constructorOutline.returnType, isNull);
           // local function
           List<_Outline> outlines_constructor = constructorOutline.children;
           expect(outlines_constructor, hasLength(1));
           {
             _Outline outline = outlines_constructor[0];
             expect(outline.kind, _OutlineKind.FUNCTION);
             expect(outline.name, "local_A");
             expect(outline.nameOffset, testCode.indexOf("local_A() {}"));
             expect(outline.nameLength, "local_A".length);
-            expect(outline.arguments, "()");
+            expect(outline.parameters, "()");
             expect(outline.returnType, "int");
           }
         }
         {
           _Outline outline_m = outlines_A[1];
           expect(outline_m.kind, _OutlineKind.METHOD);
           expect(outline_m.name, "m");
           expect(outline_m.nameOffset, testCode.indexOf("m() {"));
           expect(outline_m.nameLength, "m".length);
-          expect(outline_m.arguments, "()");
+          expect(outline_m.parameters, "()");
           expect(outline_m.returnType, "");
           // local function
           List<_Outline> methodChildren = outline_m.children;
           expect(methodChildren, hasLength(1));
           {
             _Outline outline = methodChildren[0];
             expect(outline.kind, _OutlineKind.FUNCTION);
             expect(outline.name, "local_m");
             expect(outline.nameOffset, testCode.indexOf("local_m() {}"));
             expect(outline.nameLength, "local_m".length);
-            expect(outline.arguments, "()");
+            expect(outline.parameters, "()");
             expect(outline.returnType, "");
           }
         }
       }
       // f()
       {
         _Outline outline_f = topOutlines[1];
         expect(outline_f.kind, _OutlineKind.FUNCTION);
         expect(outline_f.name, "f");
         expect(outline_f.nameOffset, testCode.indexOf("f() {"));
         expect(outline_f.nameLength, "f".length);
-        expect(outline_f.arguments, "()");
+        expect(outline_f.parameters, "()");
         expect(outline_f.returnType, "");
         // f() children
         List<_Outline> outlines_f = outline_f.children;
         expect(outlines_f, hasLength(2));
         {
           _Outline outline_f1 = outlines_f[0];
           expect(outline_f1.kind, _OutlineKind.FUNCTION);
           expect(outline_f1.name, "local_f1");
           expect(outline_f1.nameOffset, testCode.indexOf("local_f1(int i) {}"));
           expect(outline_f1.nameLength, "local_f1".length);
-          expect(outline_f1.arguments, "(int i)");
+          expect(outline_f1.parameters, "(int i)");
           expect(outline_f1.returnType, "");
         }
         {
           _Outline outline_f2 = outlines_f[1];
           expect(outline_f2.kind, _OutlineKind.FUNCTION);
           expect(outline_f2.name, "local_f2");
           expect(outline_f2.nameOffset, testCode.indexOf("local_f2(String s) {"));
           expect(outline_f2.nameLength, "local_f2".length);
-          expect(outline_f2.arguments, "(String s)");
+          expect(outline_f2.parameters, "(String s)");
           expect(outline_f2.returnType, "");
           // local_f2() local function
           List<_Outline> outlines_f2 = outline_f2.children;
           expect(outlines_f2, hasLength(1));
           {
             _Outline outline_f21 = outlines_f2[0];
             expect(outline_f21.kind, _OutlineKind.FUNCTION);
             expect(outline_f21.name, "local_f21");
             expect(outline_f21.nameOffset, testCode.indexOf("local_f21(int p) {"));
             expect(outline_f21.nameLength, "local_f21".length);
-            expect(outline_f21.arguments, "(int p)");
+            expect(outline_f21.parameters, "(int p)");
             expect(outline_f21.returnType, "");
           }
         }
       }
     });
   }
 
   test_topLevel() {
     addTestFile('''
 typedef String FTA(int i, String s);
@@ skipping 10 matching lines @@
       _Outline unitOutline = outline;
       List<_Outline> topOutlines = unitOutline.children;
       expect(topOutlines, hasLength(9));
       // FTA
       {
         _Outline outline = topOutlines[0];
         expect(outline.kind, _OutlineKind.FUNCTION_TYPE_ALIAS);
         expect(outline.name, "FTA");
         expect(outline.nameOffset, testCode.indexOf("FTA("));
         expect(outline.nameLength, "FTA".length);
-        expect(outline.arguments, "(int i, String s)");
+        expect(outline.parameters, "(int i, String s)");
         expect(outline.returnType, "String");
       }
       // FTB
       {
         _Outline outline = topOutlines[1];
         expect(outline.kind, _OutlineKind.FUNCTION_TYPE_ALIAS);
         expect(outline.name, "FTB");
         expect(outline.nameOffset, testCode.indexOf("FTB("));
         expect(outline.nameLength, "FTB".length);
-        expect(outline.arguments, "(int p)");
+        expect(outline.parameters, "(int p)");
         expect(outline.returnType, "");
       }
       // CTA
       {
         _Outline outline = topOutlines[4];
         expect(outline.kind, _OutlineKind.CLASS_TYPE_ALIAS);
         expect(outline.name, "CTA");
         expect(outline.nameOffset, testCode.indexOf("CTA ="));
         expect(outline.nameLength, "CTA".length);
-        expect(outline.arguments, isNull);
+        expect(outline.parameters, isNull);
         expect(outline.returnType, isNull);
       }
       // fA
       {
         _Outline outline = topOutlines[5];
         expect(outline.kind, _OutlineKind.FUNCTION);
         expect(outline.name, "fA");
         expect(outline.nameOffset, testCode.indexOf("fA("));
         expect(outline.nameLength, "fA".length);
-        expect(outline.arguments, "(int i, String s)");
+        expect(outline.parameters, "(int i, String s)");
         expect(outline.returnType, "String");
       }
       // fB
       {
         _Outline outline = topOutlines[6];
         expect(outline.kind, _OutlineKind.FUNCTION);
         expect(outline.name, "fB");
         expect(outline.nameOffset, testCode.indexOf("fB("));
         expect(outline.nameLength, "fB".length);
-        expect(outline.arguments, "(int p)");
+        expect(outline.parameters, "(int p)");
         expect(outline.returnType, "");
       }
       // propA
       {
         _Outline outline = topOutlines[7];
         expect(outline.kind, _OutlineKind.GETTER);
         expect(outline.name, "propA");
         expect(outline.nameOffset, testCode.indexOf("propA => null;"));
         expect(outline.nameLength, "propA".length);
-        expect(outline.arguments, "");
+        expect(outline.parameters, "");
         expect(outline.returnType, "String");
       }
       // propB
       {
         _Outline outline = topOutlines[8];
         expect(outline.kind, _OutlineKind.SETTER);
         expect(outline.name, "propB");
         expect(outline.nameOffset, testCode.indexOf("propB(int v) {}"));
         expect(outline.nameLength, "propB".length);
-        expect(outline.arguments, "(int v)");
+        expect(outline.parameters, "(int v)");
         expect(outline.returnType, "");
       }
     });
   }
 }
 
 
 /**
  * Element outline kinds.
  */
@@ skipping 30 matching lines @@
 
   _Outline parent;
   final _OutlineKind kind;
   final String name;
   final int nameOffset;
   final int nameLength;
   final int elementOffset;
   final int elementLength;
   final bool isAbstract;
   final bool isStatic;
-  final String arguments;
+  final String parameters;
   final String returnType;
   final List<_Outline> children = <_Outline>[];
 
   _Outline(this.kind, this.name,
            this.nameOffset, this.nameLength,
            this.elementOffset, this.elementLength,
            this.isAbstract, this.isStatic,
-           this.arguments, this.returnType);
+           this.parameters, this.returnType);
 
   factory _Outline.fromJson(Map<String, Object> map) {
     _Outline outline = new _Outline(
         _OutlineKind.valueOf(map[KIND]), map[NAME],
         map[NAME_OFFSET], map[NAME_LENGTH],
         map[ELEMENT_OFFSET], map[ELEMENT_LENGTH],
         map[IS_ABSTRACT], map[IS_STATIC],
-        map[ARGUMENTS], map[RETURN_TYPE]);
+        map[PARAMETERS], map[RETURN_TYPE]);
     List<Map<String, Object>> childrenMaps = map[CHILDREN];
     if (childrenMaps != null) {
       childrenMaps.forEach((childMap) {
         outline.children.add(new _Outline.fromJson(childMap));
       });
     }
     return outline;
   }
 }