Serialize parameters visible ranges.

pkg/analyzer/test/src/summary/summary_common.dart

 // Copyright (c) 2015, 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 analyzer.test.src.summary.summary_common;
 
 import 'package:analyzer/analyzer.dart';
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/src/generated/engine.dart';
@@ skipping 4261 matching lines @@
   }
 
   test_executable_param_name() {
     String text = 'f(x) {}';
     UnlinkedExecutable executable = serializeExecutableText(text);
     expect(executable.parameters, hasLength(1));
     expect(executable.parameters[0].name, 'x');
     expect(executable.parameters[0].nameOffset, text.indexOf('x'));
   }
 
+  test_executable_param_visibleRange() {

[Paul Berry, 2016/02/11 21:10:39]

Add tests to verify that visibleLength and visibleOffset are zero in the
following circumstances:
- Parameters of a typedef
- Parameters of a function-typed parameter
- Parameters of a top level function that lacks a body (e.g. because it is
marked "extern")
- Parameters of a method that lacks a body because it is abstract

Also test that visibleLength and visibleOffset are correct if the method body
uses "=>" syntax.

[scheglov, 2016/02/11 22:26:20]

Done.

+    String text = r'''
+f(x) { // 1
+  f2(y) { // 2
+  } // 3
+} // 4
+''';
+    UnlinkedExecutable f = serializeExecutableText(text);
+    UnlinkedExecutable f2 = f.localFunctions[0];
+    _assertParameterVisible(text, f.parameters[0], '{ // 1', '} // 4');
+    _assertParameterVisible(text, f2.parameters[0], '{ // 2', '} // 3');
+  }
+
   test_executable_param_no_flags() {
     UnlinkedExecutable executable = serializeExecutableText('f(x) {}');
     expect(executable.parameters[0].isFunctionTyped, isFalse);
     expect(executable.parameters[0].isInitializingFormal, isFalse);
   }
 
   test_executable_param_non_function_typed() {
     UnlinkedExecutable executable = serializeExecutableText('f(g) {}');
     expect(executable.parameters[0].isFunctionTyped, isFalse);
   }
@@ skipping 2253 matching lines @@
   }
 
   void _assertVariableVisible(
       String code, UnlinkedVariable v, String visibleBegin, String visibleEnd) {
     int expectedVisibleOffset = code.indexOf(visibleBegin);
     int expectedVisibleLength =
         code.indexOf(visibleEnd) - expectedVisibleOffset + 1;
     expect(v.visibleOffset, expectedVisibleOffset);
     expect(v.visibleLength, expectedVisibleLength);
   }
+
+  void _assertParameterVisible(
+      String code, UnlinkedParam p, String visibleBegin, String visibleEnd) {
+    int expectedVisibleOffset = code.indexOf(visibleBegin);
+    int expectedVisibleLength =
+        code.indexOf(visibleEnd) - expectedVisibleOffset + 1;
+    expect(p.visibleOffset, expectedVisibleOffset);
+    expect(p.visibleLength, expectedVisibleLength);
+  }
 }
 
 /**
  * Description of expectations for a prelinked prefix reference.
  */
 class _PrefixExpectation {
   final ReferenceKind kind;
   final String name;
   final bool inLibraryDefiningUnit;
   final String absoluteUri;
   final String relativeUri;
   final int numTypeParameters;
 
   _PrefixExpectation(this.kind, this.name,
       {this.inLibraryDefiningUnit: false,
       this.absoluteUri,
       this.relativeUri,
       this.numTypeParameters: 0});
 }