Include default parameter values into summary.

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 2329 matching lines @@
    */
   void set isExternal(bool _value) {
     assert(!_finished);
     _isExternal = _value;
   }
 
   @override
   int get inferredReturnTypeSlot => _inferredReturnTypeSlot ??= 0;
 
   /**
-   * If this executable's return type is inferrable, nonzero slot id
+   * 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
    * no return type was inferred for this variable, so its static type is
    * `dynamic`.
    */
   void set inferredReturnTypeSlot(int _value) {
     assert(!_finished);
     assert(_value == null || _value >= 0);
     _inferredReturnTypeSlot = _value;
   }
@@ skipping 679 matching lines @@
   bool _finished = false;
 
   String _name;
   int _nameOffset;
   EntityRefBuilder _type;
   List<UnlinkedParamBuilder> _parameters;
   idl.UnlinkedParamKind _kind;
   bool _isFunctionTyped;
   bool _isInitializingFormal;
   int _inferredTypeSlot;
+  UnlinkedConstBuilder _defaultValue;
 
   @override
   String get name => _name ??= '';
 
   /**
    * Name of the parameter.
    */
   void set name(String _value) {
     assert(!_finished);
     _name = _value;
@@ skipping 66 matching lines @@
    */
   void set isInitializingFormal(bool _value) {
     assert(!_finished);
     _isInitializingFormal = _value;
   }
 
   @override
   int get inferredTypeSlot => _inferredTypeSlot ??= 0;
 
   /**
-   * If this parameter's type is inferrable, nonzero slot id identifying which
+   * If this parameter's type is inferable, nonzero slot id identifying which
    * entry in [LinkedLibrary.types] contains the inferred type.  If there is no
    * matching entry in [LinkedLibrary.types], then no type was inferred for
    * this variable, so its static type is `dynamic`.
    *
    * Note that although strong mode considers initializing formals to be
-   * inferrable, they are not marked as such in the summary; if their type is
+   * 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.
    */
   void set inferredTypeSlot(int _value) {
     assert(!_finished);
     assert(_value == null || _value >= 0);
     _inferredTypeSlot = _value;
   }
 
-  UnlinkedParamBuilder({String name, int nameOffset, EntityRefBuilder type, List<UnlinkedParamBuilder> parameters, idl.UnlinkedParamKind kind, bool isFunctionTyped, bool isInitializingFormal, int inferredTypeSlot})
+  @override
+  UnlinkedConstBuilder get defaultValue => _defaultValue;
+
+  /**
+   * If the parameter has a default value the constant expression in the
+   * default value.
+   */
+  void set defaultValue(UnlinkedConstBuilder _value) {
+    assert(!_finished);
+    _defaultValue = _value;
+  }
+
+  UnlinkedParamBuilder({String name, int nameOffset, EntityRefBuilder type, List<UnlinkedParamBuilder> parameters, idl.UnlinkedParamKind kind, bool isFunctionTyped, bool isInitializingFormal, int inferredTypeSlot, UnlinkedConstBuilder defaultValue})
     : _name = name,
       _nameOffset = nameOffset,
       _type = type,
       _parameters = parameters,
       _kind = kind,
       _isFunctionTyped = isFunctionTyped,
       _isInitializingFormal = isInitializingFormal,
-      _inferredTypeSlot = inferredTypeSlot;
+      _inferredTypeSlot = inferredTypeSlot,
+      _defaultValue = defaultValue;
 
   fb.Offset finish(fb.Builder fbBuilder) {
     assert(!_finished);
     _finished = true;
     fb.Offset offset_name;
     fb.Offset offset_type;
     fb.Offset offset_parameters;
+    fb.Offset offset_defaultValue;
     if (_name != null) {
       offset_name = fbBuilder.writeString(_name);
     }
     if (_type != null) {
       offset_type = _type.finish(fbBuilder);
     }
     if (!(_parameters == null || _parameters.isEmpty)) {
       offset_parameters = fbBuilder.writeList(_parameters.map((b) => b.finish(fbBuilder)).toList());
     }
+    if (_defaultValue != null) {
+      offset_defaultValue = _defaultValue.finish(fbBuilder);
+    }
     fbBuilder.startTable();
     if (offset_name != null) {
       fbBuilder.addOffset(0, offset_name);
     }
     if (_nameOffset != null && _nameOffset != 0) {
       fbBuilder.addUint32(1, _nameOffset);
     }
     if (offset_type != null) {
       fbBuilder.addOffset(2, offset_type);
     }
     if (offset_parameters != null) {
       fbBuilder.addOffset(3, offset_parameters);
     }
     if (_kind != null && _kind != idl.UnlinkedParamKind.required) {
       fbBuilder.addUint32(4, _kind.index);
     }
     if (_isFunctionTyped == true) {
       fbBuilder.addBool(5, true);
     }
     if (_isInitializingFormal == true) {
       fbBuilder.addBool(6, true);
     }
     if (_inferredTypeSlot != null && _inferredTypeSlot != 0) {
       fbBuilder.addUint32(7, _inferredTypeSlot);
     }
+    if (offset_defaultValue != null) {
+      fbBuilder.addOffset(8, offset_defaultValue);
+    }
     return fbBuilder.endTable();
   }
 }
 
 class _UnlinkedParamReader extends fb.TableReader<_UnlinkedParamImpl> {
   const _UnlinkedParamReader();
 
   @override
   _UnlinkedParamImpl createObject(fb.BufferPointer bp) => new _UnlinkedParamImpl(bp);
 }
 
 class _UnlinkedParamImpl extends Object with _UnlinkedParamMixin implements idl.UnlinkedParam {
   final fb.BufferPointer _bp;
 
   _UnlinkedParamImpl(this._bp);
 
   String _name;
   int _nameOffset;
   idl.EntityRef _type;
   List<idl.UnlinkedParam> _parameters;
   idl.UnlinkedParamKind _kind;
   bool _isFunctionTyped;
   bool _isInitializingFormal;
   int _inferredTypeSlot;
+  idl.UnlinkedConst _defaultValue;
 
   @override
   String get name {
     _name ??= const fb.StringReader().vTableGet(_bp, 0, '');
     return _name;
   }
 
   @override
   int get nameOffset {
     _nameOffset ??= const fb.Uint32Reader().vTableGet(_bp, 1, 0);
@@ skipping 28 matching lines @@
   bool get isInitializingFormal {
     _isInitializingFormal ??= const fb.BoolReader().vTableGet(_bp, 6, false);
     return _isInitializingFormal;
   }
 
   @override
   int get inferredTypeSlot {
     _inferredTypeSlot ??= const fb.Uint32Reader().vTableGet(_bp, 7, 0);
     return _inferredTypeSlot;
   }
+
+  @override
+  idl.UnlinkedConst get defaultValue {
+    _defaultValue ??= const _UnlinkedConstReader().vTableGet(_bp, 8, null);
+    return _defaultValue;
+  }
 }
 
 abstract class _UnlinkedParamMixin implements idl.UnlinkedParam {
   @override
   Map<String, Object> toMap() => {
     "name": name,
     "nameOffset": nameOffset,
     "type": type,
     "parameters": parameters,
     "kind": kind,
     "isFunctionTyped": isFunctionTyped,
     "isInitializingFormal": isInitializingFormal,
     "inferredTypeSlot": inferredTypeSlot,
+    "defaultValue": defaultValue,
   };
 }
 
 class UnlinkedPartBuilder extends Object with _UnlinkedPartMixin implements idl.UnlinkedPart {
   bool _finished = false;
 
   int _uriOffset;
   int _uriEnd;
 
   @override
@@ skipping 1319 matching lines @@
   void set propagatedTypeSlot(int _value) {
     assert(!_finished);
     assert(_value == null || _value >= 0);
     _propagatedTypeSlot = _value;
   }
 
   @override
   int get inferredTypeSlot => _inferredTypeSlot ??= 0;
 
   /**
-   * If this variable is inferrable, nonzero slot id identifying which entry in
+   * 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`.
    */
   void set inferredTypeSlot(int _value) {
     assert(!_finished);
     assert(_value == null || _value >= 0);
     _inferredTypeSlot = _value;
   }
 
@@ skipping 156 matching lines @@
     "type": type,
     "constExpr": constExpr,
     "isStatic": isStatic,
     "isFinal": isFinal,
     "isConst": isConst,
     "propagatedTypeSlot": propagatedTypeSlot,
     "inferredTypeSlot": inferredTypeSlot,
   };
 }