Summarize constructor initializers.

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/visitor.dart';
 import 'package:analyzer/src/generated/scanner.dart';
 import 'package:analyzer/src/generated/utilities_dart.dart';
 import 'package:analyzer/src/summary/format.dart';
 import 'package:analyzer/src/summary/idl.dart';
 import 'package:analyzer/src/summary/public_namespace_computer.dart';
 import 'package:analyzer/src/summary/summarize_const_expr.dart';
 
 /**
  * Serialize all the declarations in [compilationUnit] to an unlinked summary.
  */
 UnlinkedUnitBuilder serializeAstUnlinked(CompilationUnit compilationUnit) {
   return new _SummarizeAstVisitor().serializeCompilationUnit(compilationUnit);
 }
 
 /**
  * Instances of this class keep track of intermediate state during
  * serialization of a single constant [Expression].
  */
 class _ConstExprSerializer extends AbstractConstExprSerializer {
   final _SummarizeAstVisitor visitor;
 
-  _ConstExprSerializer(this.visitor);
+  /**
+   * If a constructor initializer expression is being serialized, the names of
+   * the constructor parameters.  Otherwise `null`.
+   */
+  final Set<String> constructorParameterNames;
+
+  _ConstExprSerializer(this.visitor, this.constructorParameterNames);
+
+  @override
+  bool isConstructorParameterName(String name) {
+    return constructorParameterNames?.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;
       if (name is PrefixedIdentifier && annotation.constructorName == null) {
@@ skipping 274 matching lines @@
   /**
    * Serialize the given list of [annotations].  If there are no annotations,
    * the empty list is returned.
    */
   List<UnlinkedConstBuilder> serializeAnnotations(
       NodeList<Annotation> annotations) {
     if (annotations.isEmpty) {
       return const <UnlinkedConstBuilder>[];
     }
     return annotations.map((Annotation a) {
-      _ConstExprSerializer serializer = new _ConstExprSerializer(this);
+      _ConstExprSerializer serializer = new _ConstExprSerializer(this, null);
       serializer.serializeAnnotation(a);
       return serializer.toBuilder();
     }).toList();
   }
 
   /**
    * Serialize a [ClassDeclaration] or [ClassTypeAlias] into an [UnlinkedClass]
    * and store the result in [classes].
    */
   void serializeClass(
@@ skipping 93 matching lines @@
     b.references = unlinkedReferences;
     b.typedefs = typedefs;
     b.variables = variables;
     b.publicNamespace = computePublicNamespace(compilationUnit);
     return b;
   }
 
   /**
    * Serialize the given [expression], creating an [UnlinkedConstBuilder].
    */
-  UnlinkedConstBuilder serializeConstExpr(Expression expression) {
-    _ConstExprSerializer serializer = new _ConstExprSerializer(this);
+  UnlinkedConstBuilder serializeConstExpr(Expression expression,
+      [Set<String> constructorParameterNames]) {
+    _ConstExprSerializer serializer =
+        new _ConstExprSerializer(this, constructorParameterNames);
     serializer.serialize(expression);
     return serializer.toBuilder();
   }
 
   /**
    * Serialize a [Comment] node into an [UnlinkedDocumentationComment] object.
    */
   UnlinkedDocumentationCommentBuilder serializeDocumentation(
       Comment documentationComment) {
     if (documentationComment == null) {
@@ skipping 294 matching lines @@
     }
     b.parameters = node.parameters.parameters
         .map((FormalParameter p) => p.accept(this))
         .toList();
     b.kind = UnlinkedExecutableKind.constructor;
     b.isFactory = node.factoryKeyword != null;
     b.isConst = node.constKeyword != null;
     b.isExternal = node.externalKeyword != null;
     b.documentationComment = serializeDocumentation(node.documentationComment);
     b.annotations = serializeAnnotations(node.metadata);
+    if (node.constKeyword != null) {
+      Set<String> constructorParameterNames =
+          node.parameters.parameters.map((p) => p.identifier.name).toSet();
+      b.constantInitializers = node.initializers
+          .map((ConstructorInitializer initializer) =>
+              serializeConstructorInitializer(initializer, (Expression expr) {
+                return serializeConstExpr(expr, constructorParameterNames);
+              }))
+          .toList();
+    }
     executables.add(b);
   }
 
   @override
   UnlinkedParamBuilder visitDefaultFormalParameter(
       DefaultFormalParameter node) {
     UnlinkedParamBuilder b = node.parameter.accept(this);
     if (node.defaultValue != null) {
       b.defaultValue = serializeConstExpr(node.defaultValue);
     }
@@ skipping 194 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;
 }