Store the result of type inference in summaries.

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 'base.dart' as base;
@@ skipping 2908 matching lines @@
   UnlinkedDocumentationCommentBuilder _documentationComment;
   List<UnlinkedTypeParamBuilder> _typeParameters;
   EntityRefBuilder _returnType;
   List<UnlinkedParamBuilder> _parameters;
   UnlinkedExecutableKind _kind;
   bool _isAbstract;
   bool _isStatic;
   bool _isConst;
   bool _isFactory;
   bool _isExternal;
+  int _inferredReturnTypeSlot;
 
   @override
   String get name => _name ??= '';
 
   /**
    * Name of the executable.  For setters, this includes the trailing "=".  For
    * named constructors, this excludes the class name and excludes the ".".
    * For unnamed constructors, this is the empty string.
    */
   void set name(String _value) {
@@ skipping 129 matching lines @@
   bool get isExternal => _isExternal ??= false;
 
   /**
    * Indicates whether the executable is declared using the `external` keyword.
    */
   void set isExternal(bool _value) {
     assert(!_finished);
     _isExternal = _value;
   }
 
-  UnlinkedExecutableBuilder({String name, int nameOffset, UnlinkedDocumentationCommentBuilder documentationComment, List<UnlinkedTypeParamBuilder> typeParameters, EntityRefBuilder returnType, List<UnlinkedParamBuilder> parameters, UnlinkedExecutableKind kind, bool isAbstract, bool isStatic, bool isConst, bool isFactory, bool isExternal})
+  @override
+  int get inferredReturnTypeSlot => _inferredReturnTypeSlot ??= 0;
+
+  /**
+   * If this executable's return type is inferrable, 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;
+  }
+
+  UnlinkedExecutableBuilder({String name, int nameOffset, UnlinkedDocumentationCommentBuilder documentationComment, List<UnlinkedTypeParamBuilder> typeParameters, EntityRefBuilder returnType, List<UnlinkedParamBuilder> parameters, UnlinkedExecutableKind kind, bool isAbstract, bool isStatic, bool isConst, bool isFactory, bool isExternal, int inferredReturnTypeSlot})
     : _name = name,
       _nameOffset = nameOffset,
       _documentationComment = documentationComment,
       _typeParameters = typeParameters,
       _returnType = returnType,
       _parameters = parameters,
       _kind = kind,
       _isAbstract = isAbstract,
       _isStatic = isStatic,
       _isConst = isConst,
       _isFactory = isFactory,
-      _isExternal = isExternal;
+      _isExternal = isExternal,
+      _inferredReturnTypeSlot = inferredReturnTypeSlot;
 
   fb.Offset finish(fb.Builder fbBuilder) {
     assert(!_finished);
     _finished = true;
     fb.Offset offset_name;
     fb.Offset offset_documentationComment;
     fb.Offset offset_typeParameters;
     fb.Offset offset_returnType;
     fb.Offset offset_parameters;
     if (_name != null) {
@@ skipping 41 matching lines @@
     }
     if (_isConst == true) {
       fbBuilder.addBool(9, true);
     }
     if (_isFactory == true) {
       fbBuilder.addBool(10, true);
     }
     if (_isExternal == true) {
       fbBuilder.addBool(11, true);
     }
+    if (_inferredReturnTypeSlot != null && _inferredReturnTypeSlot != 0) {
+      fbBuilder.addUint32(12, _inferredReturnTypeSlot);
+    }
     return fbBuilder.endTable();
   }
 }
 
 /**
  * Unlinked summary information about a function, method, getter, or setter
  * declaration.
  */
 abstract class UnlinkedExecutable extends base.SummaryClass {
 
@@ skipping 64 matching lines @@
 
   /**
    * Indicates whether the executable is declared using the `factory` keyword.
    */
   bool get isFactory;
 
   /**
    * Indicates whether the executable is declared using the `external` keyword.
    */
   bool get isExternal;
+
+  /**
+   * If this executable's return type is inferrable, 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`.
+   */
+  int get inferredReturnTypeSlot;
 }
 
 class _UnlinkedExecutableReader extends fb.TableReader<_UnlinkedExecutableImpl> {
   const _UnlinkedExecutableReader();
 
   @override
   _UnlinkedExecutableImpl createObject(fb.BufferPointer bp) => new _UnlinkedExecutableImpl(bp);
 }
 
 class _UnlinkedExecutableImpl extends Object with _UnlinkedExecutableMixin implements UnlinkedExecutable {
   final fb.BufferPointer _bp;
 
   _UnlinkedExecutableImpl(this._bp);
 
   String _name;
   int _nameOffset;
   UnlinkedDocumentationComment _documentationComment;
   List<UnlinkedTypeParam> _typeParameters;
   EntityRef _returnType;
   List<UnlinkedParam> _parameters;
   UnlinkedExecutableKind _kind;
   bool _isAbstract;
   bool _isStatic;
   bool _isConst;
   bool _isFactory;
   bool _isExternal;
+  int _inferredReturnTypeSlot;
 
   @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 52 matching lines @@
   bool get isFactory {
     _isFactory ??= const fb.BoolReader().vTableGet(_bp, 10, false);
     return _isFactory;
   }
 
   @override
   bool get isExternal {
     _isExternal ??= const fb.BoolReader().vTableGet(_bp, 11, false);
     return _isExternal;
   }
+
+  @override
+  int get inferredReturnTypeSlot {
+    _inferredReturnTypeSlot ??= const fb.Uint32Reader().vTableGet(_bp, 12, 0);
+    return _inferredReturnTypeSlot;
+  }
 }
 
 abstract class _UnlinkedExecutableMixin implements UnlinkedExecutable {
   @override
   Map<String, Object> toMap() => {
     "name": name,
     "nameOffset": nameOffset,
     "documentationComment": documentationComment,
     "typeParameters": typeParameters,
     "returnType": returnType,
     "parameters": parameters,
     "kind": kind,
     "isAbstract": isAbstract,
     "isStatic": isStatic,
     "isConst": isConst,
     "isFactory": isFactory,
     "isExternal": isExternal,
+    "inferredReturnTypeSlot": inferredReturnTypeSlot,
   };
 }
 
 class UnlinkedExportNonPublicBuilder extends Object with _UnlinkedExportNonPublicMixin implements UnlinkedExportNonPublic {
   bool _finished = false;
 
   int _offset;
   int _uriOffset;
   int _uriEnd;
 
@@ skipping 563 matching lines @@
 class UnlinkedParamBuilder extends Object with _UnlinkedParamMixin implements UnlinkedParam {
   bool _finished = false;
 
   String _name;
   int _nameOffset;
   EntityRefBuilder _type;
   List<UnlinkedParamBuilder> _parameters;
   UnlinkedParamKind _kind;
   bool _isFunctionTyped;
   bool _isInitializingFormal;
+  int _inferredTypeSlot;
 
   @override
   String get name => _name ??= '';
 
   /**
    * Name of the parameter.
    */
   void set name(String _value) {
     assert(!_finished);
     _name = _value;
@@ skipping 62 matching lines @@
 
   /**
    * Indicates whether this is an initializing formal parameter (i.e. it is
    * declared using `this.` syntax).
    */
   void set isInitializingFormal(bool _value) {
     assert(!_finished);
     _isInitializingFormal = _value;
   }
 
-  UnlinkedParamBuilder({String name, int nameOffset, EntityRefBuilder type, List<UnlinkedParamBuilder> parameters, UnlinkedParamKind kind, bool isFunctionTyped, bool isInitializingFormal})
+  @override
+  int get inferredTypeSlot => _inferredTypeSlot ??= 0;
+
+  /**
+   * If this parameter's type is inferrable, 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
+   * 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, UnlinkedParamKind kind, bool isFunctionTyped, bool isInitializingFormal, int inferredTypeSlot})
     : _name = name,
       _nameOffset = nameOffset,
       _type = type,
       _parameters = parameters,
       _kind = kind,
       _isFunctionTyped = isFunctionTyped,
-      _isInitializingFormal = isInitializingFormal;
+      _isInitializingFormal = isInitializingFormal,
+      _inferredTypeSlot = inferredTypeSlot;
 
   fb.Offset finish(fb.Builder fbBuilder) {
     assert(!_finished);
     _finished = true;
     fb.Offset offset_name;
     fb.Offset offset_type;
     fb.Offset offset_parameters;
     if (_name != null) {
       offset_name = fbBuilder.writeString(_name);
     }
@@ skipping 18 matching lines @@
     }
     if (_kind != null && _kind != 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);
+    }
     return fbBuilder.endTable();
   }
 }
 
 /**
  * Unlinked summary information about a function parameter.
  */
 abstract class UnlinkedParam extends base.SummaryClass {
 
   /**
@@ skipping 26 matching lines @@
   /**
    * Indicates whether this is a function-typed parameter.
    */
   bool get isFunctionTyped;
 
   /**
    * Indicates whether this is an initializing formal parameter (i.e. it is
    * declared using `this.` syntax).
    */
   bool get isInitializingFormal;
+
+  /**
+   * If this parameter's type is inferrable, 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
+   * not specified, they always inherit the static type of the corresponding
+   * field.
+   */
+  int get inferredTypeSlot;
 }
 
 class _UnlinkedParamReader extends fb.TableReader<_UnlinkedParamImpl> {
   const _UnlinkedParamReader();
 
   @override
   _UnlinkedParamImpl createObject(fb.BufferPointer bp) => new _UnlinkedParamImpl(bp);
 }
 
 class _UnlinkedParamImpl extends Object with _UnlinkedParamMixin implements UnlinkedParam {
   final fb.BufferPointer _bp;
 
   _UnlinkedParamImpl(this._bp);
 
   String _name;
   int _nameOffset;
   EntityRef _type;
   List<UnlinkedParam> _parameters;
   UnlinkedParamKind _kind;
   bool _isFunctionTyped;
   bool _isInitializingFormal;
+  int _inferredTypeSlot;
 
   @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 22 matching lines @@
   bool get isFunctionTyped {
     _isFunctionTyped ??= const fb.BoolReader().vTableGet(_bp, 5, false);
     return _isFunctionTyped;
   }
 
   @override
   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;
+  }
 }
 
 abstract class _UnlinkedParamMixin implements UnlinkedParam {
   @override
   Map<String, Object> toMap() => {
     "name": name,
     "nameOffset": nameOffset,
     "type": type,
     "parameters": parameters,
     "kind": kind,
     "isFunctionTyped": isFunctionTyped,
     "isInitializingFormal": isInitializingFormal,
+    "inferredTypeSlot": inferredTypeSlot,
   };
 }
 
 class UnlinkedPartBuilder extends Object with _UnlinkedPartMixin implements UnlinkedPart {
   bool _finished = false;
 
   int _uriOffset;
   int _uriEnd;
 
   @override
@@ skipping 1412 matching lines @@
 
   String _name;
   int _nameOffset;
   UnlinkedDocumentationCommentBuilder _documentationComment;
   EntityRefBuilder _type;
   UnlinkedConstBuilder _constExpr;
   bool _isStatic;
   bool _isFinal;
   bool _isConst;
   int _propagatedTypeSlot;
+  int _inferredTypeSlot;
 
   @override
   String get name => _name ??= '';
 
   /**
    * Name of the variable.
    */
   void set name(String _value) {
     assert(!_finished);
     _name = _value;
@@ skipping 93 matching lines @@
    * propagated type is the same as its declared type.
    *
    * Non-propagable variables have a [propagatedTypeSlot] of zero.
    */
   void set propagatedTypeSlot(int _value) {
     assert(!_finished);
     assert(_value == null || _value >= 0);
     _propagatedTypeSlot = _value;
   }
 
-  UnlinkedVariableBuilder({String name, int nameOffset, UnlinkedDocumentationCommentBuilder documentationComment, EntityRefBuilder type, UnlinkedConstBuilder constExpr, bool isStatic, bool isFinal, bool isConst, int propagatedTypeSlot})
+  @override
+  int get inferredTypeSlot => _inferredTypeSlot ??= 0;
+
+  /**
+   * If this variable is inferrable, 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;
+  }
+
+  UnlinkedVariableBuilder({String name, int nameOffset, UnlinkedDocumentationCommentBuilder documentationComment, EntityRefBuilder type, UnlinkedConstBuilder constExpr, bool isStatic, bool isFinal, bool isConst, int propagatedTypeSlot, int inferredTypeSlot})
     : _name = name,
       _nameOffset = nameOffset,
       _documentationComment = documentationComment,
       _type = type,
       _constExpr = constExpr,
       _isStatic = isStatic,
       _isFinal = isFinal,
       _isConst = isConst,
-      _propagatedTypeSlot = propagatedTypeSlot;
+      _propagatedTypeSlot = propagatedTypeSlot,
+      _inferredTypeSlot = inferredTypeSlot;
 
   fb.Offset finish(fb.Builder fbBuilder) {
     assert(!_finished);
     _finished = true;
     fb.Offset offset_name;
     fb.Offset offset_documentationComment;
     fb.Offset offset_type;
     fb.Offset offset_constExpr;
     if (_name != null) {
       offset_name = fbBuilder.writeString(_name);
@@ skipping 28 matching lines @@
     }
     if (_isFinal == true) {
       fbBuilder.addBool(6, true);
     }
     if (_isConst == true) {
       fbBuilder.addBool(7, true);
     }
     if (_propagatedTypeSlot != null && _propagatedTypeSlot != 0) {
       fbBuilder.addUint32(8, _propagatedTypeSlot);
     }
+    if (_inferredTypeSlot != null && _inferredTypeSlot != 0) {
+      fbBuilder.addUint32(9, _inferredTypeSlot);
+    }
     return fbBuilder.endTable();
   }
 }
 
 /**
  * Unlinked summary information about a top level variable, local variable, or
  * a field.
  */
 abstract class UnlinkedVariable extends base.SummaryClass {
 
@@ skipping 45 matching lines @@
 
   /**
    * If this variable is propagable, nonzero slot id identifying which entry in
    * [LinkedLibrary.types] contains the propagated type for this variable.  If
    * there is no matching entry in [LinkedLibrary.types], then this variable's
    * propagated type is the same as its declared type.
    *
    * Non-propagable variables have a [propagatedTypeSlot] of zero.
    */
   int get propagatedTypeSlot;
+
+  /**
+   * If this variable is inferrable, 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;
 }
 
 class _UnlinkedVariableReader extends fb.TableReader<_UnlinkedVariableImpl> {
   const _UnlinkedVariableReader();
 
   @override
   _UnlinkedVariableImpl createObject(fb.BufferPointer bp) => new _UnlinkedVariableImpl(bp);
 }
 
 class _UnlinkedVariableImpl extends Object with _UnlinkedVariableMixin implements UnlinkedVariable {
   final fb.BufferPointer _bp;
 
   _UnlinkedVariableImpl(this._bp);
 
   String _name;
   int _nameOffset;
   UnlinkedDocumentationComment _documentationComment;
   EntityRef _type;
   UnlinkedConst _constExpr;
   bool _isStatic;
   bool _isFinal;
   bool _isConst;
   int _propagatedTypeSlot;
+  int _inferredTypeSlot;
 
   @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 34 matching lines @@
   bool get isConst {
     _isConst ??= const fb.BoolReader().vTableGet(_bp, 7, false);
     return _isConst;
   }
 
   @override
   int get propagatedTypeSlot {
     _propagatedTypeSlot ??= const fb.Uint32Reader().vTableGet(_bp, 8, 0);
     return _propagatedTypeSlot;
   }
+
+  @override
+  int get inferredTypeSlot {
+    _inferredTypeSlot ??= const fb.Uint32Reader().vTableGet(_bp, 9, 0);
+    return _inferredTypeSlot;
+  }
 }
 
 abstract class _UnlinkedVariableMixin implements UnlinkedVariable {
   @override
   Map<String, Object> toMap() => {
     "name": name,
     "nameOffset": nameOffset,
     "documentationComment": documentationComment,
     "type": type,
     "constExpr": constExpr,
     "isStatic": isStatic,
     "isFinal": isFinal,
     "isConst": isConst,
     "propagatedTypeSlot": propagatedTypeSlot,
+    "inferredTypeSlot": inferredTypeSlot,
   };
 }