Add UnlinkedConst.isValid and set it during summarizing.

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 498 matching lines @@
  * potentially constant expression.
  *
  * Constant expressions are represented using a simple stack-based language
  * where [operations] is a sequence of operations to execute starting with an
  * empty stack.  Once all operations have been executed, the stack should
  * contain a single value which is the value of the constant.  Note that some
  * operations consume additional data from the other fields of this class.
  */
 abstract class UnlinkedConst extends base.SummaryClass {
   /**
+   * Indicates whether the expression is a valid potentially constant
+   * expression.
+   */
+  bool get isValid;

[Paul Berry, 2016/02/08 15:02:23]

Change this to `isInvalid`.  That way in the normal (valid) case it won't
consume any bytes in the summary file.

[scheglov, 2016/02/08 17:01:42]

Done.

+
+  /**
    * Sequence of operations to execute (starting with an empty stack) to form
    * the constant value.
    */
   List<UnlinkedConstOperation> get operations;
 
   /**
    * Sequence of unsigned 32-bit integers consumed by the operations
    * `pushArgument`, `pushInt`, `shiftOr`, `concatenate`, `invokeConstructor`,
    * `makeList`, and `makeMap`.
    */
@@ skipping 649 matching lines @@
    * this variable, so its static type is `dynamic`.
    *
    * Note that although strong mode considers initializing formals to be
    * inferable, they are not marked as such in the summary; if their type is
    * not specified, they always inherit the static type of the corresponding
    * field.
    */
   int get inferredTypeSlot;
 
   /**
-   * If the parameter has a default value the constant expression in the
-   * default value.
+   * If the parameter has a default value, the constant expression in the
+   * default value.  Note that the presence of this expression does not mean
+   * that it is a valid , check [UnlinkedConst.isValid].
    */
   UnlinkedConst get defaultValue;
 }
 
 /**
  * Enum used to indicate the kind of a parameter.
  */
 enum UnlinkedParamKind {
   /**
    * Parameter is required.
@@ skipping 287 matching lines @@
   @informative
   UnlinkedDocumentationComment get documentationComment;
 
   /**
    * Declared type of the variable.  Absent if the type is implicit.
    */
   EntityRef get type;
 
   /**
    * If [isConst] is true, and the variable has an initializer, the constant
-   * expression in the initializer.
+   * expression in the initializer.  Note that the presence of this expression
+   * does not mean that it is a valid, check [UnlinkedConst.isValid].
    */
   UnlinkedConst get constExpr;
 
   /**
    * Indicates whether the variable is declared using the `static` keyword.
    *
    * Note that for top level variables, this flag is false, since they are not
    * declared using the `static` keyword (even though they are considered
    * static for semantic purposes).
    */
@@ skipping 20 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;
 }