Summarize references to closure parameters properly.

pkg/analyzer/lib/src/summary/summarize_ast.dart

 // Copyright (c) 2016, 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 serialization.summarize_ast;
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart';
 import 'package:analyzer/dart/ast/visitor.dart';
 import 'package:analyzer/dart/element/type.dart' show DartType;
@@ skipping 19 matching lines @@
 
   /**
    * If the expression being serialized can contain closures, map whose
    * keys are the offsets of local function nodes representing those closures,
    * and whose values are indices of those local functions relative to their
    * siblings.
    */
   final Map<int, int> localClosureIndexMap;
 
   /**
-   * If a constructor initializer expression is being serialized, the names of
-   * the constructor parameters.  Otherwise `null`.
+   * If the expression being serialize appears inside a function body, the names

[scheglov, 2016/05/26 16:59:33]

"being serialized"?

[Paul Berry, 2016/05/26 17:04:23]

Fixed, thanks.

+   * of parameters that are in scope.  Otherwise `null`.
    */
-  final Set<String> constructorParameterNames;
+  final Set<String> parameterNames;
 
   _ConstExprSerializer(
-      this.visitor, this.localClosureIndexMap, this.constructorParameterNames);
+      this.visitor, this.localClosureIndexMap, this.parameterNames);
 
   @override
-  bool isConstructorParameterName(String name) {
-    return constructorParameterNames?.contains(name) ?? false;
+  bool isParameterName(String name) {
+    return parameterNames?.contains(name) ?? false;
   }
 
   @override
   void serializeAnnotation(Annotation annotation) {
     if (annotation.arguments == null) {
       assert(annotation.constructorName == null);
       serialize(annotation.name);
     } else {
       Identifier name = annotation.name;
       EntityRefBuilder constructor;
@@ skipping 285 matching lines @@
   Map<int, int> _localClosureIndexMap;
 
   /**
    * Indicates whether closure function bodies should be serialized.  This flag
    * is set while visiting the bodies of initializer expressions that will be
    * needed by type inference.
    */
   bool _serializeClosureBodyExprs = false;
 
   /**
+   * If a closure function body is being serialized, the set of closure
+   * parameter names which are currently in scope.  Otherwise `null`.
+   */
+  Set<String> _parameterNames;
+
+  /**
    * Create a slot id for storing a propagated or inferred type or const cycle
    * info.
    */
   int assignSlot() => ++numSlots;
 
   /**
    * Build a [_Scope] object containing the names defined within the body of a
    * class declaration.
    */
   _Scope buildClassMemberScope(
@@ skipping 156 matching lines @@
     b.variables = variables;
     b.publicNamespace = computePublicNamespace(compilationUnit);
     return b;
   }
 
   /**
    * Serialize the given [expression], creating an [UnlinkedConstBuilder].
    */
   UnlinkedConstBuilder serializeConstExpr(
       Map<int, int> localClosureIndexMap, Expression expression,
-      [Set<String> constructorParameterNames]) {
-    _ConstExprSerializer serializer = new _ConstExprSerializer(
-        this, localClosureIndexMap, constructorParameterNames);
+      [Set<String> parameterNames]) {
+    _ConstExprSerializer serializer =
+        new _ConstExprSerializer(this, localClosureIndexMap, parameterNames);
     serializer.serialize(expression);
     return serializer.toBuilder();
   }
 
   /**
    * Serialize the given [declaredIdentifier] into [UnlinkedVariable], and
    * store it in [variables].
    */
   void serializeDeclaredIdentifier(
       AstNode scopeNode,
@@ skipping 102 matching lines @@
       }
     }
     b.documentationComment = serializeDocumentation(documentationComment);
     b.annotations = serializeAnnotations(annotations);
     b.codeRange = serializeCodeRange(node);
     if (returnType == null && !isSemanticallyStatic) {
       b.inferredReturnTypeSlot = assignSlot();
     }
     b.visibleOffset = enclosingBlock?.offset;
     b.visibleLength = enclosingBlock?.length;
+    Set<String> oldParameterNames = _parameterNames;
+    if (formalParameters != null && formalParameters.parameters.isNotEmpty) {
+      _parameterNames =
+          _parameterNames == null ? new Set<String>() : _parameterNames.toSet();
+      _parameterNames.addAll(formalParameters.parameters
+          .map((FormalParameter p) => p.identifier.name));
+    }
     serializeFunctionBody(b, null, body, serializeBodyExpr);
+    _parameterNames = oldParameterNames;
     scopes.removeLast();
     assert(scopes.length == oldScopesLength);
     return b;
   }
 
   /**
    * Record local functions and variables into the given executable. The given
    * [body] is usually an actual [FunctionBody], but may be an [Expression]
    * when we process a synthetic variable initializer function.
    *
@@ skipping 30 matching lines @@
     _localClosureIndexMap = <int, int>{};
     _serializeClosureBodyExprs = serializeBodyExpr;
     if (initializers != null) {
       for (ConstructorInitializer initializer in initializers) {
         initializer.accept(this);
       }
     }
     body.accept(this);
     if (serializeBodyExpr) {
       if (body is Expression) {
-        b.bodyExpr = serializeConstExpr(_localClosureIndexMap, body);
+        b.bodyExpr =
+            serializeConstExpr(_localClosureIndexMap, body, _parameterNames);
       } else if (body is ExpressionFunctionBody) {
-        b.bodyExpr = serializeConstExpr(_localClosureIndexMap, body.expression);
+        b.bodyExpr = serializeConstExpr(
+            _localClosureIndexMap, body.expression, _parameterNames);
       } else {
         // TODO(paulberry): serialize other types of function bodies.
       }
     }
     b.localFunctions = executables;
     b.localLabels = labels;
     b.localVariables = variables;
     Map<int, int> localClosureIndexMap = _localClosureIndexMap;
     executables = oldExecutables;
     labels = oldLabels;
@@ skipping 639 matching lines @@
 /**
  * A [_TypeParameterScope] is a [_Scope] which defines [_ScopedTypeParameter]s.
  */
 class _TypeParameterScope extends _Scope {
   /**
    * Get the number of [_ScopedTypeParameter]s defined in this
    * [_TypeParameterScope].
    */
   int get length => _definedNames.length;
 }