Store type inference errors into EntityRef.

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 1789 matching lines @@
   String toString() => convert.JSON.encode(toJson());
 }
 
 class EntityRefBuilder extends Object with _EntityRefMixin implements idl.EntityRef {
   List<int> _implicitFunctionTypeIndices;
   int _paramReference;
   int _reference;
   int _slot;
   List<UnlinkedParamBuilder> _syntheticParams;
   EntityRefBuilder _syntheticReturnType;
+  List<TopLevelInferenceErrorBuilder> _topLevelInferenceErrors;
   List<EntityRefBuilder> _typeArguments;
   List<UnlinkedTypeParamBuilder> _typeParameters;
 
   @override
   List<int> get implicitFunctionTypeIndices => _implicitFunctionTypeIndices ??= <int>[];
 
   /**
    * If this is a reference to a function type implicitly defined by a
    * function-typed parameter, a list of zero-based indices indicating the path
    * from the entity referred to by [reference] to the appropriate type
@@ skipping 94 matching lines @@
    * If this [EntityRef] is a reference to a function type whose
    * [FunctionElement] is not in any library (e.g. a function type that was
    * synthesized by a LUB computation), the return type of the function.
    * Otherwise `null`.
    */
   void set syntheticReturnType(EntityRefBuilder value) {
     this._syntheticReturnType = value;
   }
 
   @override
+  List<TopLevelInferenceErrorBuilder> get topLevelInferenceErrors => _topLevelInferenceErrors ??= <TopLevelInferenceErrorBuilder>[];
+
+  /**
+   * If this [EntityRef] is a result of type inference, and so contained within
+   * [LinkedUnit.types], and was computed as a result of top-level type
+   * inference, which failed for this target, contains the list of one or more
+   * errors describing the failure.  The [reference] must point at `dynamic` in
+   * this case.
+   */
+  void set topLevelInferenceErrors(List<TopLevelInferenceErrorBuilder> value) {
+    this._topLevelInferenceErrors = value;
+  }
+
+  @override
   List<EntityRefBuilder> get typeArguments => _typeArguments ??= <EntityRefBuilder>[];
 
   /**
    * If this is an instantiation of a generic type or generic executable, the
    * type arguments used to instantiate it (if any).
    */
   void set typeArguments(List<EntityRefBuilder> value) {
     this._typeArguments = value;
   }
 
   @override
   List<UnlinkedTypeParamBuilder> get typeParameters => _typeParameters ??= <UnlinkedTypeParamBuilder>[];
 
   /**
    * If this is a function type, the type parameters defined for the function
    * type (if any).
    */
   void set typeParameters(List<UnlinkedTypeParamBuilder> value) {
     this._typeParameters = value;
   }
 
-  EntityRefBuilder({List<int> implicitFunctionTypeIndices, int paramReference, int reference, int slot, List<UnlinkedParamBuilder> syntheticParams, EntityRefBuilder syntheticReturnType, List<EntityRefBuilder> typeArguments, List<UnlinkedTypeParamBuilder> typeParameters})
+  EntityRefBuilder({List<int> implicitFunctionTypeIndices, int paramReference, int reference, int slot, List<UnlinkedParamBuilder> syntheticParams, EntityRefBuilder syntheticReturnType, List<TopLevelInferenceErrorBuilder> topLevelInferenceErrors, List<EntityRefBuilder> typeArguments, List<UnlinkedTypeParamBuilder> typeParameters})
     : _implicitFunctionTypeIndices = implicitFunctionTypeIndices,
       _paramReference = paramReference,
       _reference = reference,
       _slot = slot,
       _syntheticParams = syntheticParams,
       _syntheticReturnType = syntheticReturnType,
+      _topLevelInferenceErrors = topLevelInferenceErrors,
       _typeArguments = typeArguments,
       _typeParameters = typeParameters;
 
   /**
    * Flush [informative] data recursively.
    */
   void flushInformative() {
     _syntheticParams?.forEach((b) => b.flushInformative());
     _syntheticReturnType?.flushInformative();
+    _topLevelInferenceErrors?.forEach((b) => b.flushInformative());
     _typeArguments?.forEach((b) => b.flushInformative());
     _typeParameters?.forEach((b) => b.flushInformative());
   }
 
   /**
    * Accumulate non-[informative] data into [signature].
    */
   void collectApiSignature(api_sig.ApiSignature signature) {
     signature.addInt(this._reference ?? 0);
     if (this._typeArguments == null) {
@@ skipping 25 matching lines @@
       }
     }
     if (this._typeParameters == null) {
       signature.addInt(0);
     } else {
       signature.addInt(this._typeParameters.length);
       for (var x in this._typeParameters) {
         x?.collectApiSignature(signature);
       }
     }
+    if (this._topLevelInferenceErrors == null) {
+      signature.addInt(0);
+    } else {
+      signature.addInt(this._topLevelInferenceErrors.length);
+      for (var x in this._topLevelInferenceErrors) {
+        x?.collectApiSignature(signature);
+      }
+    }
   }
 
   fb.Offset finish(fb.Builder fbBuilder) {
     fb.Offset offset_implicitFunctionTypeIndices;
     fb.Offset offset_syntheticParams;
     fb.Offset offset_syntheticReturnType;
+    fb.Offset offset_topLevelInferenceErrors;
     fb.Offset offset_typeArguments;
     fb.Offset offset_typeParameters;
     if (!(_implicitFunctionTypeIndices == null || _implicitFunctionTypeIndices.isEmpty)) {
       offset_implicitFunctionTypeIndices = fbBuilder.writeListUint32(_implicitFunctionTypeIndices);
     }
     if (!(_syntheticParams == null || _syntheticParams.isEmpty)) {
       offset_syntheticParams = fbBuilder.writeList(_syntheticParams.map((b) => b.finish(fbBuilder)).toList());
     }
     if (_syntheticReturnType != null) {
       offset_syntheticReturnType = _syntheticReturnType.finish(fbBuilder);
     }
+    if (!(_topLevelInferenceErrors == null || _topLevelInferenceErrors.isEmpty)) {
+      offset_topLevelInferenceErrors = fbBuilder.writeList(_topLevelInferenceErrors.map((b) => b.finish(fbBuilder)).toList());
+    }
     if (!(_typeArguments == null || _typeArguments.isEmpty)) {
       offset_typeArguments = fbBuilder.writeList(_typeArguments.map((b) => b.finish(fbBuilder)).toList());
     }
     if (!(_typeParameters == null || _typeParameters.isEmpty)) {
       offset_typeParameters = fbBuilder.writeList(_typeParameters.map((b) => b.finish(fbBuilder)).toList());
     }
     fbBuilder.startTable();
     if (offset_implicitFunctionTypeIndices != null) {
       fbBuilder.addOffset(4, offset_implicitFunctionTypeIndices);
     }
     if (_paramReference != null && _paramReference != 0) {
       fbBuilder.addUint32(3, _paramReference);
     }
     if (_reference != null && _reference != 0) {
       fbBuilder.addUint32(0, _reference);
     }
     if (_slot != null && _slot != 0) {
       fbBuilder.addUint32(2, _slot);
     }
     if (offset_syntheticParams != null) {
       fbBuilder.addOffset(6, offset_syntheticParams);
     }
     if (offset_syntheticReturnType != null) {
       fbBuilder.addOffset(5, offset_syntheticReturnType);
     }
+    if (offset_topLevelInferenceErrors != null) {
+      fbBuilder.addOffset(8, offset_topLevelInferenceErrors);
+    }
     if (offset_typeArguments != null) {
       fbBuilder.addOffset(1, offset_typeArguments);
     }
     if (offset_typeParameters != null) {
       fbBuilder.addOffset(7, offset_typeParameters);
     }
     return fbBuilder.endTable();
   }
 }
 
 class _EntityRefReader extends fb.TableReader<_EntityRefImpl> {
   const _EntityRefReader();
 
   @override
   _EntityRefImpl createObject(fb.BufferContext bc, int offset) => new _EntityRefImpl(bc, offset);
 }
 
 class _EntityRefImpl extends Object with _EntityRefMixin implements idl.EntityRef {
   final fb.BufferContext _bc;
   final int _bcOffset;
 
   _EntityRefImpl(this._bc, this._bcOffset);
 
   List<int> _implicitFunctionTypeIndices;
   int _paramReference;
   int _reference;
   int _slot;
   List<idl.UnlinkedParam> _syntheticParams;
   idl.EntityRef _syntheticReturnType;
+  List<idl.TopLevelInferenceError> _topLevelInferenceErrors;
   List<idl.EntityRef> _typeArguments;
   List<idl.UnlinkedTypeParam> _typeParameters;
 
   @override
   List<int> get implicitFunctionTypeIndices {
     _implicitFunctionTypeIndices ??= const fb.Uint32ListReader().vTableGet(_bc, _bcOffset, 4, const <int>[]);
     return _implicitFunctionTypeIndices;
   }
 
   @override
@@ skipping 20 matching lines @@
     return _syntheticParams;
   }
 
   @override
   idl.EntityRef get syntheticReturnType {
     _syntheticReturnType ??= const _EntityRefReader().vTableGet(_bc, _bcOffset, 5, null);
     return _syntheticReturnType;
   }
 
   @override
+  List<idl.TopLevelInferenceError> get topLevelInferenceErrors {
+    _topLevelInferenceErrors ??= const fb.ListReader<idl.TopLevelInferenceError>(const _TopLevelInferenceErrorReader()).vTableGet(_bc, _bcOffset, 8, const <idl.TopLevelInferenceError>[]);
+    return _topLevelInferenceErrors;
+  }
+
+  @override
   List<idl.EntityRef> get typeArguments {
     _typeArguments ??= const fb.ListReader<idl.EntityRef>(const _EntityRefReader()).vTableGet(_bc, _bcOffset, 1, const <idl.EntityRef>[]);
     return _typeArguments;
   }
 
   @override
   List<idl.UnlinkedTypeParam> get typeParameters {
     _typeParameters ??= const fb.ListReader<idl.UnlinkedTypeParam>(const _UnlinkedTypeParamReader()).vTableGet(_bc, _bcOffset, 7, const <idl.UnlinkedTypeParam>[]);
     return _typeParameters;
   }
 }
 
 abstract class _EntityRefMixin implements idl.EntityRef {
   @override
   Map<String, Object> toJson() {
     Map<String, Object> _result = <String, Object>{};
     if (implicitFunctionTypeIndices.isNotEmpty) _result["implicitFunctionTypeIndices"] = implicitFunctionTypeIndices;
     if (paramReference != 0) _result["paramReference"] = paramReference;
     if (reference != 0) _result["reference"] = reference;
     if (slot != 0) _result["slot"] = slot;
     if (syntheticParams.isNotEmpty) _result["syntheticParams"] = syntheticParams.map((_value) => _value.toJson()).toList();
     if (syntheticReturnType != null) _result["syntheticReturnType"] = syntheticReturnType.toJson();
+    if (topLevelInferenceErrors.isNotEmpty) _result["topLevelInferenceErrors"] = topLevelInferenceErrors.map((_value) => _value.toJson()).toList();
     if (typeArguments.isNotEmpty) _result["typeArguments"] = typeArguments.map((_value) => _value.toJson()).toList();
     if (typeParameters.isNotEmpty) _result["typeParameters"] = typeParameters.map((_value) => _value.toJson()).toList();
     return _result;
   }
 
   @override
   Map<String, Object> toMap() => {
     "implicitFunctionTypeIndices": implicitFunctionTypeIndices,
     "paramReference": paramReference,
     "reference": reference,
     "slot": slot,
     "syntheticParams": syntheticParams,
     "syntheticReturnType": syntheticReturnType,
+    "topLevelInferenceErrors": topLevelInferenceErrors,
     "typeArguments": typeArguments,
     "typeParameters": typeParameters,
   };
 
   @override
   String toString() => convert.JSON.encode(toJson());
 }
 
 class LinkedDependencyBuilder extends Object with _LinkedDependencyMixin implements idl.LinkedDependency {
   List<String> _parts;
@@ skipping 2016 matching lines @@
     "strings": strings,
     "unitLibraryUris": unitLibraryUris,
     "units": units,
     "unitUnitUris": unitUnitUris,
   };
 
   @override
   String toString() => convert.JSON.encode(toJson());
 }
 
+class TopLevelInferenceErrorBuilder extends Object with _TopLevelInferenceErrorMixin implements idl.TopLevelInferenceError {
+  String _message;
+
+  @override
+  String get message => _message ??= '';
+
+  /**
+   * The message describing the error.
+   */
+  void set message(String value) {
+    this._message = value;
+  }
+
+  TopLevelInferenceErrorBuilder({String message})
+    : _message = message;
+
+  /**
+   * Flush [informative] data recursively.
+   */
+  void flushInformative() {
+  }
+
+  /**
+   * Accumulate non-[informative] data into [signature].
+   */
+  void collectApiSignature(api_sig.ApiSignature signature) {
+    signature.addString(this._message ?? '');
+  }
+
+  fb.Offset finish(fb.Builder fbBuilder) {
+    fb.Offset offset_message;
+    if (_message != null) {
+      offset_message = fbBuilder.writeString(_message);
+    }
+    fbBuilder.startTable();
+    if (offset_message != null) {
+      fbBuilder.addOffset(0, offset_message);
+    }
+    return fbBuilder.endTable();
+  }
+}
+
+class _TopLevelInferenceErrorReader extends fb.TableReader<_TopLevelInferenceErrorImpl> {
+  const _TopLevelInferenceErrorReader();
+
+  @override
+  _TopLevelInferenceErrorImpl createObject(fb.BufferContext bc, int offset) => new _TopLevelInferenceErrorImpl(bc, offset);
+}
+
+class _TopLevelInferenceErrorImpl extends Object with _TopLevelInferenceErrorMixin implements idl.TopLevelInferenceError {
+  final fb.BufferContext _bc;
+  final int _bcOffset;
+
+  _TopLevelInferenceErrorImpl(this._bc, this._bcOffset);
+
+  String _message;
+
+  @override
+  String get message {
+    _message ??= const fb.StringReader().vTableGet(_bc, _bcOffset, 0, '');
+    return _message;
+  }
+}
+
+abstract class _TopLevelInferenceErrorMixin implements idl.TopLevelInferenceError {
+  @override
+  Map<String, Object> toJson() {
+    Map<String, Object> _result = <String, Object>{};
+    if (message != '') _result["message"] = message;
+    return _result;
+  }
+
+  @override
+  Map<String, Object> toMap() => {
+    "message": message,
+  };
+
+  @override
+  String toString() => convert.JSON.encode(toJson());
+}
+
 class UnitIndexBuilder extends Object with _UnitIndexMixin implements idl.UnitIndex {
   List<idl.IndexNameKind> _definedNameKinds;
   List<int> _definedNameOffsets;
   List<int> _definedNames;
   int _unit;
   List<bool> _usedElementIsQualifiedFlags;
   List<idl.IndexRelationKind> _usedElementKinds;
   List<int> _usedElementLengths;
   List<int> _usedElementOffsets;
   List<int> _usedElements;
@@ skipping 7024 matching lines @@
     "propagatedTypeSlot": propagatedTypeSlot,
     "type": type,
     "visibleLength": visibleLength,
     "visibleOffset": visibleOffset,
   };
 
   @override
   String toString() => convert.JSON.encode(toJson());
 }