Serialize parameters visible ranges.

pkg/analyzer/lib/src/dart/element/builder.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 analyzer.src.dart.element.builder;
 
 import 'dart:collection';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/visitor.dart';
@@ skipping 677 matching lines @@
         element.typeParameters = holder.typeParameters;
         if (body.isAsynchronous) {
           element.asynchronous = true;
         }
         if (body.isGenerator) {
           element.generator = true;
         }
         if (_inFunction) {
           Block enclosingBlock = node.getAncestor((node) => node is Block);
           if (enclosingBlock != null) {
-            element.setVisibleRange(enclosingBlock.offset, enclosingBlock.length);
+            element.setVisibleRange(
+                enclosingBlock.offset, enclosingBlock.length);
           }
         }
         if (node.returnType == null) {
           element.hasImplicitReturnType = true;
         }
         _currentHolder.addFunction(element);
         expression.element = element;
         functionName.staticElement = element;
       } else {
         SimpleIdentifier propertyNameNode = node.name;
@@ skipping 602 matching lines @@
           typeParameters[i] as TypeParameterElementImpl;
       TypeParameterTypeImpl typeParameterType =
           new TypeParameterTypeImpl(typeParameter);
       typeParameter.type = typeParameterType;
       typeArguments[i] = typeParameterType;
     }
     return typeArguments;
   }
 
   /**
-   * Return the body of the function that contains the given parameter, or `null` if no
-   * function body could be found.
-   *
-   * @param node the parameter contained in the function whose body is to be returned
-   * @return the body of the function that contains the given parameter
+   * Return the body of the function that contains the given [parameter], or
+   * `null` if no function body could be found.
    */
-  FunctionBody _getFunctionBody(FormalParameter node) {
-    AstNode parent = node.parent;
-    while (parent != null) {
-      if (parent is ConstructorDeclaration) {
-        return parent.body;
-      } else if (parent is FunctionExpression) {
-        return parent.body;
-      } else if (parent is MethodDeclaration) {
-        return parent.body;
-      }
-      parent = parent.parent;
+  FunctionBody _getFunctionBody(FormalParameter parameter) {
+    AstNode parent = parameter?.parent?.parent;
+    if (parent is ConstructorDeclaration) {
+      return parent.body;
+    } else if (parent is FunctionExpression) {
+      return parent.body;
+    } else if (parent is MethodDeclaration) {
+      return parent.body;
     }
     return null;
   }
 
   /**
    * If the given [node] has a documentation comment, remember its content
    * and range into the given [element].
    */
   void _setDoc(ElementImpl element, AnnotatedNode node) {
     Comment comment = node.documentationComment;
     if (comment != null && comment.isDocumentation) {
       element.documentationComment =
           comment.tokens.map((Token t) => t.lexeme).join('\n');
       element.setDocRange(comment.offset, comment.length);
     }
   }
 
   /**
    * Sets the visible source range for formal parameter.
    */
   void _setParameterVisibleRange(
       FormalParameter node, ParameterElementImpl element) {
     FunctionBody body = _getFunctionBody(node);
-    if (body != null) {
+    if (body is BlockFunctionBody || body is ExpressionFunctionBody) {
       element.setVisibleRange(body.offset, body.length);
     }
   }
 
   /**
    * Make the given holder be the current holder while visiting the given node.
    *
    * @param holder the holder that will gather elements that are built while visiting the children
    * @param node the node to be visited
    */
@@ skipping 79 matching lines @@
     return null;
   }
 
   /**
    * Return the lexical identifiers associated with the given [identifiers].
    */
   static List<String> _getIdentifiers(NodeList<SimpleIdentifier> identifiers) {
     return identifiers.map((identifier) => identifier.name).toList();
   }
 }