Summarize constructor initializers.

pkg/analyzer/lib/src/summary/idl.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.
 
 /**
  * This file is an "idl" style description of the summary format.  It
  * contains abstract classes which declare the interface for reading data from
  * summaries.  It is parsed and transformed into code that implements the
  * summary format.
  *
@@ skipping 596 matching lines @@
    * and push it onto the stack.
    */
   makeSymbol,
 
   /**
    * Push the constant `null` onto the stack.
    */
   pushNull,
 
   /**
+   * Push the value of the constant constructor parameter with
+   * the name obtained from [UnlinkedConst.strings].
+   */
+  pushConstructorParameter,
+
+  /**
    * Evaluate a (potentially qualified) identifier expression and push the
    * resulting value onto the stack.  The identifier to be evaluated is
    * obtained from [UnlinkedConst.references].
    *
    * This operation is used to represent the following kinds of constants
    * (which are indistinguishable from an unresolved AST alone):
    *
    * - A qualified reference to a static constant variable (e.g. `C.v`, where
    *   C is a class and `v` is a constant static variable in `C`).
    * - An identifier expression referring to a constant variable.
@@ skipping 199 matching lines @@
   conditional,
 
   /**
    * Pop the top value from the stack, evaluate `v.length`, and push the result
    * back onto the stack.
    */
   length,
 }
 
 /**
+ * Unlinked summary information about a constructor initializer.
+ */
+abstract class UnlinkedConstructorInitializer extends base.SummaryClass {
+  /**
+   * The kind of the constructor initializer (field, redirect, super).
+   */
+  UnlinkedConstructorInitializerKind get kind;
+
+  /**
+   * Depending on the [kind] is the name of the field declared in the class,

[Paul Berry, 2016/02/08 14:53:12]

Rather than make the reader figure out which possibility relates to which value
of [kind], let's just be specific and say:

"If [kind] is `field`, the name of the field declared in the class.  If [kind]
is `thisInvocation`, the name of the constructor to redirect to.  ..."

[scheglov, 2016/02/08 16:29:51]

Done.

+   * or the name of the constructor to redirect to (may be `null`), or the name
+   * of the invoked super constructor (may be `null`).
+   */
+  String get name;
+
+  /**
+   * If [UnlinkedConstructorInitializerKind.field], the expression of the

[Paul Berry, 2016/02/08 14:53:12]

Nit: how about saying "If [kind] is `field`"?  It's easier to scan and it's
grammatical.

[scheglov, 2016/02/08 16:29:51]

Done.

+   * field initializer.  Otherwise `null`.
+   */
+  UnlinkedConst get expression;
+
+  /**
+   * If [UnlinkedConstructorInitializerKind.thisInvocation] or
+   * [UnlinkedConstructorInitializerKind.superInvocation], the arguments of
+   * the invocation.  Otherwise empty.
+   */
+  List<UnlinkedConst> get arguments;
+}
+
+/**
+ * Enum used to indicate the kind of an constructor initializer.
+ */
+enum UnlinkedConstructorInitializerKind {
+  /**
+   * Initialization of a field.
+   */
+  field,
+
+  /**
+   * Invocation of a constructor in the same class.
+   */
+  thisInvocation,
+
+  /**
+   * Invocation of a superclass' constructor.
+   */
+  superInvocation
+}
+
+/**
  * Unlinked summary information about a documentation comment.
  */
 abstract class UnlinkedDocumentationComment extends base.SummaryClass {
   /**
    * Text of the documentation comment, with '\r\n' replaced by '\n'.
    *
    * References appearing within the doc comment in square brackets are not
    * specially encoded.
    */
   String get text;
@@ skipping 139 matching lines @@
    */
   bool get isFactory;
 
   /**
    * Indicates whether the executable is declared using the `external` keyword.
    */
   bool get isExternal;
 
   /**
    * If this executable's return type is inferable, nonzero slot id
-   * identifying which entry in [LinkedLibrary.types] contains the inferred
-   * return type.  If there is no matching entry in [LinkedLibrary.types], then
+   * identifying which entry in [LinkedUnit.types] contains the inferred
+   * return type.  If there is no matching entry in [LinkedUnit.types], then
    * no return type was inferred for this variable, so its static type is
    * `dynamic`.
    */
   int get inferredReturnTypeSlot;
+
+  /**
+   * If a constant [UnlinkedExecutableKind.constructor], the constructor
+   * initializers.  Otherwise empty.
+   */
+  List<UnlinkedConstructorInitializer> get constantInitializers;
 }
 
 /**
  * Enum used to indicate the kind of an executable.
  */
 enum UnlinkedExecutableKind {
   /**
    * Executable is a function or method.
    */
   functionOrMethod,
@@ skipping 517 matching lines @@
   int get propagatedTypeSlot;
 
   /**
    * If this variable is inferable, nonzero slot id identifying which entry in
    * [LinkedLibrary.types] contains the inferred type for this variable.  If
    * there is no matching entry in [LinkedLibrary.types], then no type was
    * inferred for this variable, so its static type is `dynamic`.
    */
   int get inferredTypeSlot;
 }