Add a fallback mode for building 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 'flat_buffers.dart' as fb;
@@ skipping 957 matching lines @@
 
   @override
   String toString() => convert.JSON.encode(toJson());
 }
 
 class LinkedLibraryBuilder extends Object with _LinkedLibraryMixin implements idl.LinkedLibrary {
   bool _finished = false;
 
   List<LinkedDependencyBuilder> _dependencies;
   List<LinkedExportNameBuilder> _exportNames;
+  bool _fallbackMode;
   List<int> _importDependencies;
   int _numPrelinkedDependencies;
   List<LinkedUnitBuilder> _units;
 
   @override
   List<LinkedDependencyBuilder> get dependencies => _dependencies ??= <LinkedDependencyBuilder>[];
 
   /**
    * The libraries that this library depends on (either via an explicit import
    * statement or via the implicit dependencies on `dart:core` and
@@ skipping 24 matching lines @@
    * brought into the namespace via `export` directives).
    *
    * Sorted by name.
    */
   void set exportNames(List<LinkedExportNameBuilder> _value) {
     assert(!_finished);
     _exportNames = _value;
   }
 
   @override
+  bool get fallbackMode => _fallbackMode ??= false;
+
+  /**
+   * Indicates whether this library was summarized in "fallback mode".  If
+   * true, all other fields in the data structure have their default values.
+   */
+  void set fallbackMode(bool _value) {
+    assert(!_finished);
+    _fallbackMode = _value;
+  }
+
+  @override
   List<int> get importDependencies => _importDependencies ??= <int>[];
 
   /**
    * For each import in [UnlinkedUnit.imports], an index into [dependencies]
    * of the library being imported.
    */
   void set importDependencies(List<int> _value) {
     assert(!_finished);
     assert(_value == null || _value.every((e) => e >= 0));
     _importDependencies = _value;
@@ skipping 20 matching lines @@
    * The linked summary of all the compilation units constituting the
    * library.  The summary of the defining compilation unit is listed first,
    * followed by the summary of each part, in the order of the `part`
    * declarations in the defining compilation unit.
    */
   void set units(List<LinkedUnitBuilder> _value) {
     assert(!_finished);
     _units = _value;
   }
 
-  LinkedLibraryBuilder({List<LinkedDependencyBuilder> dependencies, List<LinkedExportNameBuilder> exportNames, List<int> importDependencies, int numPrelinkedDependencies, List<LinkedUnitBuilder> units})
+  LinkedLibraryBuilder({List<LinkedDependencyBuilder> dependencies, List<LinkedExportNameBuilder> exportNames, bool fallbackMode, List<int> importDependencies, int numPrelinkedDependencies, List<LinkedUnitBuilder> units})
     : _dependencies = dependencies,
       _exportNames = exportNames,
+      _fallbackMode = fallbackMode,
       _importDependencies = importDependencies,
       _numPrelinkedDependencies = numPrelinkedDependencies,
       _units = units;
 
   /**
    * Flush [informative] data recursively.
    */
   void flushInformative() {
     _dependencies?.forEach((b) => b.flushInformative());
     _exportNames?.forEach((b) => b.flushInformative());
@@ skipping 24 matching lines @@
     if (!(_units == null || _units.isEmpty)) {
       offset_units = fbBuilder.writeList(_units.map((b) => b.finish(fbBuilder)).toList());
     }
     fbBuilder.startTable();
     if (offset_dependencies != null) {
       fbBuilder.addOffset(0, offset_dependencies);
     }
     if (offset_exportNames != null) {
       fbBuilder.addOffset(4, offset_exportNames);
     }
+    if (_fallbackMode == true) {
+      fbBuilder.addBool(5, true);
+    }
     if (offset_importDependencies != null) {
       fbBuilder.addOffset(1, offset_importDependencies);
     }
     if (_numPrelinkedDependencies != null && _numPrelinkedDependencies != 0) {
       fbBuilder.addUint32(2, _numPrelinkedDependencies);
     }
     if (offset_units != null) {
       fbBuilder.addOffset(3, offset_units);
     }
     return fbBuilder.endTable();
@@ skipping 12 matching lines @@
   _LinkedLibraryImpl createObject(fb.BufferPointer bp) => new _LinkedLibraryImpl(bp);
 }
 
 class _LinkedLibraryImpl extends Object with _LinkedLibraryMixin implements idl.LinkedLibrary {
   final fb.BufferPointer _bp;
 
   _LinkedLibraryImpl(this._bp);
 
   List<idl.LinkedDependency> _dependencies;
   List<idl.LinkedExportName> _exportNames;
+  bool _fallbackMode;
   List<int> _importDependencies;
   int _numPrelinkedDependencies;
   List<idl.LinkedUnit> _units;
 
   @override
   List<idl.LinkedDependency> get dependencies {
     _dependencies ??= const fb.ListReader<idl.LinkedDependency>(const _LinkedDependencyReader()).vTableGet(_bp, 0, const <idl.LinkedDependency>[]);
     return _dependencies;
   }
 
   @override
   List<idl.LinkedExportName> get exportNames {
     _exportNames ??= const fb.ListReader<idl.LinkedExportName>(const _LinkedExportNameReader()).vTableGet(_bp, 4, const <idl.LinkedExportName>[]);
     return _exportNames;
   }
 
   @override
+  bool get fallbackMode {
+    _fallbackMode ??= const fb.BoolReader().vTableGet(_bp, 5, false);
+    return _fallbackMode;
+  }
+
+  @override
   List<int> get importDependencies {
     _importDependencies ??= const fb.Uint32ListReader().vTableGet(_bp, 1, const <int>[]);
     return _importDependencies;
   }
 
   @override
   int get numPrelinkedDependencies {
     _numPrelinkedDependencies ??= const fb.Uint32Reader().vTableGet(_bp, 2, 0);
     return _numPrelinkedDependencies;
   }
 
   @override
   List<idl.LinkedUnit> get units {
     _units ??= const fb.ListReader<idl.LinkedUnit>(const _LinkedUnitReader()).vTableGet(_bp, 3, const <idl.LinkedUnit>[]);
     return _units;
   }
 }
 
 abstract class _LinkedLibraryMixin implements idl.LinkedLibrary {
   @override
   Map<String, Object> toJson() {
     Map<String, Object> _result = <String, Object>{};
     if (dependencies.isNotEmpty) _result["dependencies"] = dependencies.map((_value) => _value.toJson()).toList();
     if (exportNames.isNotEmpty) _result["exportNames"] = exportNames.map((_value) => _value.toJson()).toList();
+    if (fallbackMode != false) _result["fallbackMode"] = fallbackMode;
     if (importDependencies.isNotEmpty) _result["importDependencies"] = importDependencies;
     if (numPrelinkedDependencies != 0) _result["numPrelinkedDependencies"] = numPrelinkedDependencies;
     if (units.isNotEmpty) _result["units"] = units.map((_value) => _value.toJson()).toList();
     return _result;
   }
 
   @override
   Map<String, Object> toMap() => {
     "dependencies": dependencies,
     "exportNames": exportNames,
+    "fallbackMode": fallbackMode,
     "importDependencies": importDependencies,
     "numPrelinkedDependencies": numPrelinkedDependencies,
     "units": units,
   };
 
   @override
   String toString() => convert.JSON.encode(toJson());
 }
 
 class LinkedReferenceBuilder extends Object with _LinkedReferenceMixin implements idl.LinkedReference {
@@ skipping 6004 matching lines @@
     "nameOffset": nameOffset,
   };
 
   @override
   String toString() => convert.JSON.encode(toJson());
 }
 
 class UnlinkedUnitBuilder extends Object with _UnlinkedUnitMixin implements idl.UnlinkedUnit {
   bool _finished = false;
 
+  String _fallbackModePath;
   List<UnlinkedClassBuilder> _classes;
   CodeRangeBuilder _codeRange;
   List<UnlinkedEnumBuilder> _enums;
   List<UnlinkedExecutableBuilder> _executables;
   List<UnlinkedExportNonPublicBuilder> _exports;
   List<UnlinkedImportBuilder> _imports;
   List<UnlinkedConstBuilder> _libraryAnnotations;
   UnlinkedDocumentationCommentBuilder _libraryDocumentationComment;
   String _libraryName;
   int _libraryNameLength;
   int _libraryNameOffset;
   List<UnlinkedPartBuilder> _parts;
   UnlinkedPublicNamespaceBuilder _publicNamespace;
   List<UnlinkedReferenceBuilder> _references;
   List<UnlinkedTypedefBuilder> _typedefs;
   List<UnlinkedVariableBuilder> _variables;
 
   @override
+  String get fallbackModePath => _fallbackModePath ??= '';
+
+  /**
+   * If this compilation unit was summarized in fallback mode, the path where
+   * the compilation unit may be found on disk.  Otherwise empty.
+   *
+   * When this field is non-empty, all other fields in the data structure have
+   * their default values.
+   */
+  void set fallbackModePath(String _value) {
+    assert(!_finished);
+    _fallbackModePath = _value;
+  }
+
+  @override
   List<UnlinkedClassBuilder> get classes => _classes ??= <UnlinkedClassBuilder>[];
 
   /**
    * Classes declared in the compilation unit.
    */
   void set classes(List<UnlinkedClassBuilder> _value) {
     assert(!_finished);
     _classes = _value;
   }
 
@@ skipping 166 matching lines @@
   List<UnlinkedVariableBuilder> get variables => _variables ??= <UnlinkedVariableBuilder>[];
 
   /**
    * Top level variables declared in the compilation unit.
    */
   void set variables(List<UnlinkedVariableBuilder> _value) {
     assert(!_finished);
     _variables = _value;
   }
 
-  UnlinkedUnitBuilder({List<UnlinkedClassBuilder> classes, CodeRangeBuilder codeRange, List<UnlinkedEnumBuilder> enums, List<UnlinkedExecutableBuilder> executables, List<UnlinkedExportNonPublicBuilder> exports, List<UnlinkedImportBuilder> imports, List<UnlinkedConstBuilder> libraryAnnotations, UnlinkedDocumentationCommentBuilder libraryDocumentationComment, String libraryName, int libraryNameLength, int libraryNameOffset, List<UnlinkedPartBuilder> parts, UnlinkedPublicNamespaceBuilder publicNamespace, List<UnlinkedReferenceBuilder> references, List<UnlinkedTypedefBuilder> typedefs, List<UnlinkedVariableBuilder> variables})
-    : _classes = classes,
+  UnlinkedUnitBuilder({String fallbackModePath, List<UnlinkedClassBuilder> classes, CodeRangeBuilder codeRange, List<UnlinkedEnumBuilder> enums, List<UnlinkedExecutableBuilder> executables, List<UnlinkedExportNonPublicBuilder> exports, List<UnlinkedImportBuilder> imports, List<UnlinkedConstBuilder> libraryAnnotations, UnlinkedDocumentationCommentBuilder libraryDocumentationComment, String libraryName, int libraryNameLength, int libraryNameOffset, List<UnlinkedPartBuilder> parts, UnlinkedPublicNamespaceBuilder publicNamespace, List<UnlinkedReferenceBuilder> references, List<UnlinkedTypedefBuilder> typedefs, List<UnlinkedVariableBuilder> variables})
+    : _fallbackModePath = fallbackModePath,
+      _classes = classes,
       _codeRange = codeRange,
       _enums = enums,
       _executables = executables,
       _exports = exports,
       _imports = imports,
       _libraryAnnotations = libraryAnnotations,
       _libraryDocumentationComment = libraryDocumentationComment,
       _libraryName = libraryName,
       _libraryNameLength = libraryNameLength,
       _libraryNameOffset = libraryNameOffset,
@@ skipping 25 matching lines @@
   }
 
   List<int> toBuffer() {
     fb.Builder fbBuilder = new fb.Builder();
     return fbBuilder.finish(finish(fbBuilder), "UUnt");
   }
 
   fb.Offset finish(fb.Builder fbBuilder) {
     assert(!_finished);
     _finished = true;
+    fb.Offset offset_fallbackModePath;
     fb.Offset offset_classes;
     fb.Offset offset_codeRange;
     fb.Offset offset_enums;
     fb.Offset offset_executables;
     fb.Offset offset_exports;
     fb.Offset offset_imports;
     fb.Offset offset_libraryAnnotations;
     fb.Offset offset_libraryDocumentationComment;
     fb.Offset offset_libraryName;
     fb.Offset offset_parts;
     fb.Offset offset_publicNamespace;
     fb.Offset offset_references;
     fb.Offset offset_typedefs;
     fb.Offset offset_variables;
+    if (_fallbackModePath != null) {
+      offset_fallbackModePath = fbBuilder.writeString(_fallbackModePath);
+    }
     if (!(_classes == null || _classes.isEmpty)) {
       offset_classes = fbBuilder.writeList(_classes.map((b) => b.finish(fbBuilder)).toList());
     }
     if (_codeRange != null) {
       offset_codeRange = _codeRange.finish(fbBuilder);
     }
     if (!(_enums == null || _enums.isEmpty)) {
       offset_enums = fbBuilder.writeList(_enums.map((b) => b.finish(fbBuilder)).toList());
     }
     if (!(_executables == null || _executables.isEmpty)) {
@@ skipping 23 matching lines @@
     if (!(_references == null || _references.isEmpty)) {
       offset_references = fbBuilder.writeList(_references.map((b) => b.finish(fbBuilder)).toList());
     }
     if (!(_typedefs == null || _typedefs.isEmpty)) {
       offset_typedefs = fbBuilder.writeList(_typedefs.map((b) => b.finish(fbBuilder)).toList());
     }
     if (!(_variables == null || _variables.isEmpty)) {
       offset_variables = fbBuilder.writeList(_variables.map((b) => b.finish(fbBuilder)).toList());
     }
     fbBuilder.startTable();
+    if (offset_fallbackModePath != null) {
+      fbBuilder.addOffset(16, offset_fallbackModePath);
+    }
     if (offset_classes != null) {
       fbBuilder.addOffset(2, offset_classes);
     }
     if (offset_codeRange != null) {
       fbBuilder.addOffset(15, offset_codeRange);
     }
     if (offset_enums != null) {
       fbBuilder.addOffset(12, offset_enums);
     }
     if (offset_executables != null) {
@@ skipping 49 matching lines @@
 
   @override
   _UnlinkedUnitImpl createObject(fb.BufferPointer bp) => new _UnlinkedUnitImpl(bp);
 }
 
 class _UnlinkedUnitImpl extends Object with _UnlinkedUnitMixin implements idl.UnlinkedUnit {
   final fb.BufferPointer _bp;
 
   _UnlinkedUnitImpl(this._bp);
 
+  String _fallbackModePath;
   List<idl.UnlinkedClass> _classes;
   idl.CodeRange _codeRange;
   List<idl.UnlinkedEnum> _enums;
   List<idl.UnlinkedExecutable> _executables;
   List<idl.UnlinkedExportNonPublic> _exports;
   List<idl.UnlinkedImport> _imports;
   List<idl.UnlinkedConst> _libraryAnnotations;
   idl.UnlinkedDocumentationComment _libraryDocumentationComment;
   String _libraryName;
   int _libraryNameLength;
   int _libraryNameOffset;
   List<idl.UnlinkedPart> _parts;
   idl.UnlinkedPublicNamespace _publicNamespace;
   List<idl.UnlinkedReference> _references;
   List<idl.UnlinkedTypedef> _typedefs;
   List<idl.UnlinkedVariable> _variables;
 
   @override
+  String get fallbackModePath {
+    _fallbackModePath ??= const fb.StringReader().vTableGet(_bp, 16, '');
+    return _fallbackModePath;
+  }
+
+  @override
   List<idl.UnlinkedClass> get classes {
     _classes ??= const fb.ListReader<idl.UnlinkedClass>(const _UnlinkedClassReader()).vTableGet(_bp, 2, const <idl.UnlinkedClass>[]);
     return _classes;
   }
 
   @override
   idl.CodeRange get codeRange {
     _codeRange ??= const _CodeRangeReader().vTableGet(_bp, 15, null);
     return _codeRange;
   }
@@ skipping 80 matching lines @@
   List<idl.UnlinkedVariable> get variables {
     _variables ??= const fb.ListReader<idl.UnlinkedVariable>(const _UnlinkedVariableReader()).vTableGet(_bp, 3, const <idl.UnlinkedVariable>[]);
     return _variables;
   }
 }
 
 abstract class _UnlinkedUnitMixin implements idl.UnlinkedUnit {
   @override
   Map<String, Object> toJson() {
     Map<String, Object> _result = <String, Object>{};
+    if (fallbackModePath != '') _result["fallbackModePath"] = fallbackModePath;
     if (classes.isNotEmpty) _result["classes"] = classes.map((_value) => _value.toJson()).toList();
     if (codeRange != null) _result["codeRange"] = codeRange.toJson();
     if (enums.isNotEmpty) _result["enums"] = enums.map((_value) => _value.toJson()).toList();
     if (executables.isNotEmpty) _result["executables"] = executables.map((_value) => _value.toJson()).toList();
     if (exports.isNotEmpty) _result["exports"] = exports.map((_value) => _value.toJson()).toList();
     if (imports.isNotEmpty) _result["imports"] = imports.map((_value) => _value.toJson()).toList();
     if (libraryAnnotations.isNotEmpty) _result["libraryAnnotations"] = libraryAnnotations.map((_value) => _value.toJson()).toList();
     if (libraryDocumentationComment != null) _result["libraryDocumentationComment"] = libraryDocumentationComment.toJson();
     if (libraryName != '') _result["libraryName"] = libraryName;
     if (libraryNameLength != 0) _result["libraryNameLength"] = libraryNameLength;
     if (libraryNameOffset != 0) _result["libraryNameOffset"] = libraryNameOffset;
     if (parts.isNotEmpty) _result["parts"] = parts.map((_value) => _value.toJson()).toList();
     if (publicNamespace != null) _result["publicNamespace"] = publicNamespace.toJson();
     if (references.isNotEmpty) _result["references"] = references.map((_value) => _value.toJson()).toList();
     if (typedefs.isNotEmpty) _result["typedefs"] = typedefs.map((_value) => _value.toJson()).toList();
     if (variables.isNotEmpty) _result["variables"] = variables.map((_value) => _value.toJson()).toList();
     return _result;
   }
 
   @override
   Map<String, Object> toMap() => {
+    "fallbackModePath": fallbackModePath,
     "classes": classes,
     "codeRange": codeRange,
     "enums": enums,
     "executables": executables,
     "exports": exports,
     "imports": imports,
     "libraryAnnotations": libraryAnnotations,
     "libraryDocumentationComment": libraryDocumentationComment,
     "libraryName": libraryName,
     "libraryNameLength": libraryNameLength,
@@ skipping 482 matching lines @@
     "propagatedTypeSlot": propagatedTypeSlot,
     "type": type,
     "visibleLength": visibleLength,
     "visibleOffset": visibleOffset,
   };
 
   @override
   String toString() => convert.JSON.encode(toJson());
 }