Add UnlinkedConst.isValid and set it during summarizing.

pkg/analyzer/lib/src/summary/format.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 has been automatically generated.  Please do not edit it manually.
 // To regenerate the file, use the script "pkg/analyzer/tool/generate_files".
 
 library analyzer.src.summary.format;
 
 import 'flat_buffers.dart' as fb;
@@ skipping 1646 matching lines @@
   @override
   Map<String, Object> toMap() => {
     "shows": shows,
     "hides": hides,
   };
 }
 
 class UnlinkedConstBuilder extends Object with _UnlinkedConstMixin implements idl.UnlinkedConst {
   bool _finished = false;
 
+  bool _isInvalid;
   List<idl.UnlinkedConstOperation> _operations;
   List<int> _ints;
   List<double> _doubles;
   List<String> _strings;
   List<EntityRefBuilder> _references;
 
   @override
+  bool get isInvalid => _isInvalid ??= false;
+
+  /**
+   * Indicates whether the expression is not a valid potentially constant
+   * expression.
+   */
+  void set isInvalid(bool _value) {
+    assert(!_finished);
+    _isInvalid = _value;
+  }
+
+  @override
   List<idl.UnlinkedConstOperation> get operations => _operations ??= <idl.UnlinkedConstOperation>[];
 
   /**
    * Sequence of operations to execute (starting with an empty stack) to form
    * the constant value.
    */
   void set operations(List<idl.UnlinkedConstOperation> _value) {
     assert(!_finished);
     _operations = _value;
   }
@@ skipping 42 matching lines @@
    * Sequence of language constructs consumed by the operations
    * `pushReference`, `invokeConstructor`, `makeList`, and `makeMap`.  Note
    * that in the case of `pushReference` (and sometimes `invokeConstructor` the
    * actual entity being referred to may be something other than a type.
    */
   void set references(List<EntityRefBuilder> _value) {
     assert(!_finished);
     _references = _value;
   }
 
-  UnlinkedConstBuilder({List<idl.UnlinkedConstOperation> operations, List<int> ints, List<double> doubles, List<String> strings, List<EntityRefBuilder> references})
-    : _operations = operations,
+  UnlinkedConstBuilder({bool isInvalid, List<idl.UnlinkedConstOperation> operations, List<int> ints, List<double> doubles, List<String> strings, List<EntityRefBuilder> references})
+    : _isInvalid = isInvalid,
+      _operations = operations,
       _ints = ints,
       _doubles = doubles,
       _strings = strings,
       _references = references;
 
   fb.Offset finish(fb.Builder fbBuilder) {
     assert(!_finished);
     _finished = true;
     fb.Offset offset_operations;
     fb.Offset offset_ints;
     fb.Offset offset_doubles;
     fb.Offset offset_strings;
     fb.Offset offset_references;
     if (!(_operations == null || _operations.isEmpty)) {
       offset_operations = fbBuilder.writeListUint32(_operations.map((b) => b.index).toList());
     }
     if (!(_ints == null || _ints.isEmpty)) {
       offset_ints = fbBuilder.writeListUint32(_ints);
     }
     if (!(_doubles == null || _doubles.isEmpty)) {
       offset_doubles = fbBuilder.writeListFloat64(_doubles);
     }
     if (!(_strings == null || _strings.isEmpty)) {
       offset_strings = fbBuilder.writeList(_strings.map((b) => fbBuilder.writeString(b)).toList());
     }
     if (!(_references == null || _references.isEmpty)) {
       offset_references = fbBuilder.writeList(_references.map((b) => b.finish(fbBuilder)).toList());
     }
     fbBuilder.startTable();
+    if (_isInvalid == true) {
+      fbBuilder.addBool(0, true);
+    }
     if (offset_operations != null) {
-      fbBuilder.addOffset(0, offset_operations);
+      fbBuilder.addOffset(1, offset_operations);
     }
     if (offset_ints != null) {
-      fbBuilder.addOffset(1, offset_ints);
+      fbBuilder.addOffset(2, offset_ints);
     }
     if (offset_doubles != null) {
-      fbBuilder.addOffset(2, offset_doubles);
+      fbBuilder.addOffset(3, offset_doubles);
     }
     if (offset_strings != null) {
-      fbBuilder.addOffset(3, offset_strings);
+      fbBuilder.addOffset(4, offset_strings);
     }
     if (offset_references != null) {
-      fbBuilder.addOffset(4, offset_references);
+      fbBuilder.addOffset(5, offset_references);
     }
     return fbBuilder.endTable();
   }
 }
 
 class _UnlinkedConstReader extends fb.TableReader<_UnlinkedConstImpl> {
   const _UnlinkedConstReader();
 
   @override
   _UnlinkedConstImpl createObject(fb.BufferPointer bp) => new _UnlinkedConstImpl(bp);
 }
 
 class _UnlinkedConstImpl extends Object with _UnlinkedConstMixin implements idl.UnlinkedConst {
   final fb.BufferPointer _bp;
 
   _UnlinkedConstImpl(this._bp);
 
+  bool _isInvalid;
   List<idl.UnlinkedConstOperation> _operations;
   List<int> _ints;
   List<double> _doubles;
   List<String> _strings;
   List<idl.EntityRef> _references;
 
   @override
+  bool get isInvalid {
+    _isInvalid ??= const fb.BoolReader().vTableGet(_bp, 0, false);
+    return _isInvalid;
+  }
+
+  @override
   List<idl.UnlinkedConstOperation> get operations {
-    _operations ??= const fb.ListReader<idl.UnlinkedConstOperation>(const _UnlinkedConstOperationReader()).vTableGet(_bp, 0, const <idl.UnlinkedConstOperation>[]);
+    _operations ??= const fb.ListReader<idl.UnlinkedConstOperation>(const _UnlinkedConstOperationReader()).vTableGet(_bp, 1, const <idl.UnlinkedConstOperation>[]);
     return _operations;
   }
 
   @override
   List<int> get ints {
-    _ints ??= const fb.ListReader<int>(const fb.Uint32Reader()).vTableGet(_bp, 1, const <int>[]);
+    _ints ??= const fb.ListReader<int>(const fb.Uint32Reader()).vTableGet(_bp, 2, const <int>[]);
     return _ints;
   }
 
   @override
   List<double> get doubles {
-    _doubles ??= const fb.Float64ListReader().vTableGet(_bp, 2, const <double>[]);
+    _doubles ??= const fb.Float64ListReader().vTableGet(_bp, 3, const <double>[]);
     return _doubles;
   }
 
   @override
   List<String> get strings {
-    _strings ??= const fb.ListReader<String>(const fb.StringReader()).vTableGet(_bp, 3, const <String>[]);
+    _strings ??= const fb.ListReader<String>(const fb.StringReader()).vTableGet(_bp, 4, const <String>[]);
     return _strings;
   }
 
   @override
   List<idl.EntityRef> get references {
-    _references ??= const fb.ListReader<idl.EntityRef>(const _EntityRefReader()).vTableGet(_bp, 4, const <idl.EntityRef>[]);
+    _references ??= const fb.ListReader<idl.EntityRef>(const _EntityRefReader()).vTableGet(_bp, 5, const <idl.EntityRef>[]);
     return _references;
   }
 }
 
 abstract class _UnlinkedConstMixin implements idl.UnlinkedConst {
   @override
   Map<String, Object> toMap() => {
+    "isInvalid": isInvalid,
     "operations": operations,
     "ints": ints,
     "doubles": doubles,
     "strings": strings,
     "references": references,
   };
 }
 
 class UnlinkedConstructorInitializerBuilder extends Object with _UnlinkedConstructorInitializerMixin implements idl.UnlinkedConstructorInitializer {
   bool _finished = false;
@@ skipping 11 matching lines @@
    */
   void set kind(idl.UnlinkedConstructorInitializerKind _value) {
     assert(!_finished);
     _kind = _value;
   }
 
   @override
   String get name => _name ??= '';
 
   /**
-   * Depending on the [kind] is the name of the field declared in the class,
-   * or the name of the constructor to redirect to (may be `null`), or the name
-   * of the invoked super constructor (may be `null`).
+   * If [kind] is `field`, the name of the field declared in the class.  If
+   * [kind] is `thisInvocation`, the name of the constructor, declared in this
+   * class, to redirect to.  If [kind] is `superInvocation`, the name of the
+   * constructor, declared in the superclass, to invoke.
    */
   void set name(String _value) {
     assert(!_finished);
     _name = _value;
   }
 
   @override
   UnlinkedConstBuilder get expression => _expression;
 
   /**
-   * If [UnlinkedConstructorInitializerKind.field], the expression of the
-   * field initializer.  Otherwise `null`.
+   * If [kind] is `field`, the expression of the field initializer.
+   * Otherwise `null`.
    */
   void set expression(UnlinkedConstBuilder _value) {
     assert(!_finished);
     _expression = _value;
   }
 
   @override
   List<UnlinkedConstBuilder> get arguments => _arguments ??= <UnlinkedConstBuilder>[];
 
   /**
-   * If [UnlinkedConstructorInitializerKind.thisInvocation] or
-   * [UnlinkedConstructorInitializerKind.superInvocation], the arguments of
-   * the invocation.  Otherwise empty.
+   * If [kind] is `thisInvocation` or `superInvocation`, the arguments of the
+   * invocation.  Otherwise empty.
    */
   void set arguments(List<UnlinkedConstBuilder> _value) {
     assert(!_finished);
     _arguments = _value;
   }
 
   UnlinkedConstructorInitializerBuilder({idl.UnlinkedConstructorInitializerKind kind, String name, UnlinkedConstBuilder expression, List<UnlinkedConstBuilder> arguments})
     : _kind = kind,
       _name = name,
       _expression = expression,
@@ skipping 1581 matching lines @@
   void set inferredTypeSlot(int _value) {
     assert(!_finished);
     assert(_value == null || _value >= 0);
     _inferredTypeSlot = _value;
   }
 
   @override
   UnlinkedConstBuilder get defaultValue => _defaultValue;
 
   /**
-   * 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].
    */
   void set defaultValue(UnlinkedConstBuilder _value) {
     assert(!_finished);
     _defaultValue = _value;
   }
 
   UnlinkedParamBuilder({String name, int nameOffset, List<UnlinkedConstBuilder> annotations, EntityRefBuilder type, List<UnlinkedParamBuilder> parameters, idl.UnlinkedParamKind kind, bool isFunctionTyped, bool isInitializingFormal, int inferredTypeSlot, UnlinkedConstBuilder defaultValue})
     : _name = name,
       _nameOffset = nameOffset,
       _annotations = annotations,
@@ skipping 1552 matching lines @@
   void set type(EntityRefBuilder _value) {
     assert(!_finished);
     _type = _value;
   }
 
   @override
   UnlinkedConstBuilder get constExpr => _constExpr;
 
   /**
    * 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].
    */
   void set constExpr(UnlinkedConstBuilder _value) {
     assert(!_finished);
     _constExpr = _value;
   }
 
   @override
   bool get isStatic => _isStatic ??= false;
 
   /**
@@ skipping 237 matching lines @@
     "type": type,
     "constExpr": constExpr,
     "isStatic": isStatic,
     "isFinal": isFinal,
     "isConst": isConst,
     "propagatedTypeSlot": propagatedTypeSlot,
     "inferredTypeSlot": inferredTypeSlot,
   };
 }