Separate prelinked and unlinked parts of 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 'dart:convert';
@@ skipping 177 matching lines @@
 
 PrelinkedReferenceBuilder encodePrelinkedReference(builder.BuilderContext builderContext, {int dependency, PrelinkedReferenceKind kind, int unit}) {
   PrelinkedReferenceBuilder builder = new PrelinkedReferenceBuilder(builderContext);
   builder.dependency = dependency;
   builder.kind = kind;
   builder.unit = unit;
   return builder;
 }
 
 class PrelinkedUnit {
-  UnlinkedUnit _unlinked;
   List<PrelinkedReference> _references;
 
   PrelinkedUnit.fromJson(Map json)
-    : _unlinked = json["unlinked"] == null ? null : new UnlinkedUnit.fromJson(json["unlinked"]),
-      _references = json["references"]?.map((x) => new PrelinkedReference.fromJson(x))?.toList();
+    : _references = json["references"]?.map((x) => new PrelinkedReference.fromJson(x))?.toList();
 
-  UnlinkedUnit get unlinked => _unlinked;
   List<PrelinkedReference> get references => _references ?? const <PrelinkedReference>[];
 }
 
 class PrelinkedUnitBuilder {
   final Map _json = {};
 
   bool _finished = false;
 
   PrelinkedUnitBuilder(builder.BuilderContext context);
 
-  void set unlinked(UnlinkedUnitBuilder _value) {
-    assert(!_finished);
-    assert(!_json.containsKey("unlinked"));
-    if (_value != null) {
-      _json["unlinked"] = _value.finish();
-    }
-  }
-
   void set references(List<PrelinkedReferenceBuilder> _value) {
     assert(!_finished);
     assert(!_json.containsKey("references"));
     if (_value != null || _value.isEmpty) {
       _json["references"] = _value.map((b) => b.finish()).toList();
     }
   }
 
   Map finish() {
     assert(!_finished);
     _finished = true;
     return _json;
   }
 }
 
-PrelinkedUnitBuilder encodePrelinkedUnit(builder.BuilderContext builderContext, {UnlinkedUnitBuilder unlinked, List<PrelinkedReferenceBuilder> references}) {
+PrelinkedUnitBuilder encodePrelinkedUnit(builder.BuilderContext builderContext, {List<PrelinkedReferenceBuilder> references}) {
   PrelinkedUnitBuilder builder = new PrelinkedUnitBuilder(builderContext);
-  builder.unlinked = unlinked;
   builder.references = references;
   return builder;
 }
 
 class UnlinkedClass {
   String _name;
   List<UnlinkedTypeParam> _typeParameters;
   UnlinkedTypeRef _supertype;
   List<UnlinkedTypeRef> _mixins;
   List<UnlinkedTypeRef> _interfaces;
@@ skipping 1006 matching lines @@
       _references = json["references"]?.map((x) => new UnlinkedReference.fromJson(x))?.toList(),
       _classes = json["classes"]?.map((x) => new UnlinkedClass.fromJson(x))?.toList(),
       _enums = json["enums"]?.map((x) => new UnlinkedEnum.fromJson(x))?.toList(),
       _executables = json["executables"]?.map((x) => new UnlinkedExecutable.fromJson(x))?.toList(),
       _exports = json["exports"]?.map((x) => new UnlinkedExport.fromJson(x))?.toList(),
       _imports = json["imports"]?.map((x) => new UnlinkedImport.fromJson(x))?.toList(),
       _parts = json["parts"]?.map((x) => new UnlinkedPart.fromJson(x))?.toList(),
       _typedefs = json["typedefs"]?.map((x) => new UnlinkedTypedef.fromJson(x))?.toList(),
       _variables = json["variables"]?.map((x) => new UnlinkedVariable.fromJson(x))?.toList();
 
+  UnlinkedUnit.fromBuffer(List<int> buffer) : this.fromJson(JSON.decode(UTF8.decode(buffer)));
+
   String get libraryName => _libraryName ?? '';
   List<UnlinkedReference> get references => _references ?? const <UnlinkedReference>[];
   List<UnlinkedClass> get classes => _classes ?? const <UnlinkedClass>[];
   List<UnlinkedEnum> get enums => _enums ?? const <UnlinkedEnum>[];
   List<UnlinkedExecutable> get executables => _executables ?? const <UnlinkedExecutable>[];
   List<UnlinkedExport> get exports => _exports ?? const <UnlinkedExport>[];
   List<UnlinkedImport> get imports => _imports ?? const <UnlinkedImport>[];
   List<UnlinkedPart> get parts => _parts ?? const <UnlinkedPart>[];
   List<UnlinkedTypedef> get typedefs => _typedefs ?? const <UnlinkedTypedef>[];
   List<UnlinkedVariable> get variables => _variables ?? const <UnlinkedVariable>[];
@@ skipping 79 matching lines @@
   }
 
   void set variables(List<UnlinkedVariableBuilder> _value) {
     assert(!_finished);
     assert(!_json.containsKey("variables"));
     if (_value != null || _value.isEmpty) {
       _json["variables"] = _value.map((b) => b.finish()).toList();
     }
   }
 
+  List<int> toBuffer() => UTF8.encode(JSON.encode(finish()));
+
   Map finish() {
     assert(!_finished);
     _finished = true;
     return _json;
   }
 }
 
 UnlinkedUnitBuilder encodeUnlinkedUnit(builder.BuilderContext builderContext, {String libraryName, List<UnlinkedReferenceBuilder> references, List<UnlinkedClassBuilder> classes, List<UnlinkedEnumBuilder> enums, List<UnlinkedExecutableBuilder> executables, List<UnlinkedExportBuilder> exports, List<UnlinkedImportBuilder> imports, List<UnlinkedPartBuilder> parts, List<UnlinkedTypedefBuilder> typedefs, List<UnlinkedVariableBuilder> variables}) {
   UnlinkedUnitBuilder builder = new UnlinkedUnitBuilder(builderContext);
   builder.libraryName = libraryName;
@@ skipping 99 matching lines @@
   UnlinkedVariableBuilder builder = new UnlinkedVariableBuilder(builderContext);
   builder.name = name;
   builder.type = type;
   builder.isStatic = isStatic;
   builder.isFinal = isFinal;
   builder.isConst = isConst;
   builder.hasImplicitType = hasImplicitType;
   return builder;
 }