pkg/analyzer/tool/summary/inspect.dart - sdk - Git at Google

 // Copyright (c) 2016, 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.

 import 'dart:convert';
 import 'dart:io';
 import 'dart:mirrors';

 import 'package:analyzer/src/generated/utilities_dart.dart';
 import 'package:analyzer/src/summary/base.dart';
 import 'package:analyzer/src/summary/format.dart';
 import 'package:analyzer/src/summary/idl.dart';
 import 'package:args/args.dart';

 main(List<String> args) {
   ArgParser argParser = new ArgParser()..addFlag('raw');
   ArgResults argResults = argParser.parse(args);
   if (argResults.rest.length != 1) {
     print(argParser.usage);
     exitCode = 1;
     return;
   }
   String path = argResults.rest[0];
   List<int> bytes = new File(path).readAsBytesSync();
   PackageBundle bundle = new PackageBundle.fromBuffer(bytes);
   SummaryInspector inspector = new SummaryInspector(argResults['raw']);
   print(inspector.dumpPackageBundle(bundle).join('\n'));
 }

 const int MAX_LINE_LENGTH = 80;

 /**
  * Cache used to speed up [isEnum].
  */
 Map<Type, bool> _isEnumCache = <Type, bool>{};

 /**
  * Determine if the given [obj] has an enumerated type.
  */
 bool isEnum(Object obj) {
   return _isEnumCache.putIfAbsent(
       obj.runtimeType, () => reflect(obj).type.isEnum);
 }

 /**
  * Decoded reprensentation of a part of a summary that occupies multiple lines
  * of output.
  */
 class BrokenEntity implements DecodedEntity {
   final String opener;
   final Map<String, DecodedEntity> parts;
   final String closer;

   BrokenEntity(this.opener, this.parts, this.closer);

   @override
   List<String> getLines() {
     List<String> result = <String>[opener];
     bool first = true;
     for (String key in parts.keys) {
       if (first) {
         first = false;
       } else {
         result[result.length - 1] += ',';
       }
       List<String> subResult = parts[key].getLines();
       subResult[0] = '$key: ${subResult[0]}';
       result.addAll(subResult.map((String s) => '  $s'));
     }
     result.add(closer);
     return result;
   }
 }

 /**
  * Decoded representation of a part of a summary.
  */
 abstract class DecodedEntity {
   /**
    * Create a representation of a part of the summary that consists of a group
    * of entities (represented by [parts]) contained between [opener] and
    * [closer].
    *
    * If [forceKeys] is `true`, the keys in [parts] will always be shown.  If
    * [forceKeys] is `false`, they keys will only be shown if the output is
    * broken into multiple lines.
    */
   factory DecodedEntity.group(String opener, Map<String, DecodedEntity> parts,
       String closer, bool forceKeys) {
     // Attempt to format the entity in a single line; if not bail out and
     // construct a _BrokenEntity.
     DecodedEntity bailout() => new BrokenEntity(opener, parts, closer);
     String short = opener;
     bool first = true;
     for (String key in parts.keys) {
       if (first) {
         first = false;
       } else {
         short += ', ';
       }
       DecodedEntity value = parts[key];
       if (forceKeys) {
         short += '$key: ';
       }
       if (value is UnbrokenEntity) {
         short += value._s;
       } else {
         return bailout();
       }
       if (short.length > MAX_LINE_LENGTH) {
         return bailout();
       }
     }
     return new DecodedEntity.short(short + closer);
   }

   /**
    * Create a representation of a part of the summary that is represented by a
    * single unbroken string.
    */
   factory DecodedEntity.short(String s) = UnbrokenEntity;

   /**
    * Format this entity into a sequence of strings (one per output line).
    */
   List<String> getLines();
 }

 /**
  * Wrapper around a [LinkedLibrary] and its constituent [UnlinkedUnit]s.
  */
 class LibraryWrapper {
   final LinkedLibrary _linked;
   final List<UnlinkedUnit> _unlinked;

   LibraryWrapper(this._linked, this._unlinked);
 }

 /**
  * Wrapper around a [LinkedReference] and its corresponding [UnlinkedReference].
  */
 class ReferenceWrapper {
   final LinkedReference _linked;
   final UnlinkedReference _unlinked;

   ReferenceWrapper(this._linked, this._unlinked);

   String get name {
     if (_linked != null && _linked.name.isNotEmpty) {
       return _linked.name;
     } else if (_unlinked != null && _unlinked.name.isNotEmpty) {
       return _unlinked.name;
     } else {
       return '???';
     }
   }
 }

 /**
  * Instances of [SummaryInspector] are capable of traversing a summary and
  * converting it to semi-human-readable output.
  */
 class SummaryInspector {
   /**
    * The dependencies of the library currently being visited.
    */
   List<LinkedDependency> _dependencies;

   /**
    * The references of the unit currently being visited.
    */
   List<ReferenceWrapper> _references;

   /**
    * Indicates whether summary inspection should operate in "raw" mode.  In this
    * mode, the structure of the summary file is not altered for easier
    * readability; everything is output in exactly the form in which it appears
    * in the file.
    */
   final bool raw;

   SummaryInspector(this.raw);

   /**
    * Decode the object [obj], which was reached by examining [key] inside
    * another object.
    */
   DecodedEntity decode(Object obj, String key) {
     if (!raw && obj is PackageBundle) {
       return decodePackageBundle(obj);
     }
     if (obj is LibraryWrapper) {
       return decodeLibrary(obj);
     }
     if (obj is UnitWrapper) {
       return decodeUnit(obj);
     }
     if (obj is ReferenceWrapper) {
       return decodeReference(obj);
     }
     if (obj is DecodedEntity) {
       return obj;
     }
     if (obj is SummaryClass) {
       Map<String, Object> map = obj.toMap();
       return decodeMap(map);
     } else if (obj is List) {
       Map<String, DecodedEntity> parts = <String, DecodedEntity>{};
       for (int i = 0; i < obj.length; i++) {
         parts[i.toString()] = decode(obj[i], key);
       }
       return new DecodedEntity.group('[', parts, ']', false);
     } else if (obj is String) {
       return new DecodedEntity.short(json.encode(obj));
     } else if (isEnum(obj)) {
       return new DecodedEntity.short(obj.toString().split('.')[1]);
     } else if (obj is int &&
         key == 'dependency' &&
         _dependencies != null &&
         obj < _dependencies.length) {
       return new DecodedEntity.short('$obj (${_dependencies[obj].uri})');
     } else if (obj is int &&
         key == 'reference' &&
         _references != null &&
         obj < _references.length) {
       return new DecodedEntity.short('$obj (${_references[obj].name})');
     } else {
       return new DecodedEntity.short(obj.toString());
     }
   }

   /**
    * Decode the given [LibraryWrapper].
    */
   DecodedEntity decodeLibrary(LibraryWrapper obj) {
     try {
       LinkedLibrary linked = obj._linked;
       List<UnlinkedUnit> unlinked = obj._unlinked;
       _dependencies = linked.dependencies;
       Map<String, Object> result = linked.toMap();
       result.remove('units');
       result['defining compilation unit'] =
           new UnitWrapper(linked.units[0], unlinked[0]);
       for (int i = 1; i < linked.units.length; i++) {
         String partUri = unlinked[0].publicNamespace.parts[i - 1];
         result['part ${json.encode(partUri)}'] =
             new UnitWrapper(linked.units[i], unlinked[i]);
       }
       return decodeMap(result);
     } finally {
       _dependencies = null;
     }
   }

   /**
    * Decode the given [map].
    */
   DecodedEntity decodeMap(Map<String, Object> map) {
     Map<String, DecodedEntity> parts = <String, DecodedEntity>{};
     map = reorderMap(map);
     map.forEach((String key, Object value) {
       if (value is String && value.isEmpty) {
         return;
       }
       if (isEnum(value) && (value as dynamic).index == 0) {
         return;
       }
       if (value is int && value == 0) {
         return;
       }
       if (value is bool && value == false) {
         return;
       }
       if (value == null) {
         return;
       }
       if (value is List) {
         if (value.isEmpty) {
           return;
         }
         DecodedEntity entity = decode(value, key);
         if (entity is BrokenEntity) {
           for (int i = 0; i < value.length; i++) {
             parts['$key[$i]'] = decode(value[i], key);
           }
           return;
         } else {
           parts[key] = entity;
         }
       }
       parts[key] = decode(value, key);
     });
     return new DecodedEntity.group('{', parts, '}', true);
   }

   /**
    * Decode the given [PackageBundle].
    */
   DecodedEntity decodePackageBundle(PackageBundle bundle) {
     Map<String, UnlinkedUnit> units = <String, UnlinkedUnit>{};
     Set<String> seenUnits = new Set<String>();
     for (int i = 0; i < bundle.unlinkedUnits.length; i++) {
       units[bundle.unlinkedUnitUris[i]] = bundle.unlinkedUnits[i];
     }
     Map<String, Object> restOfMap = bundle.toMap();
     Map<String, Object> result = <String, Object>{};
     result['version'] = new DecodedEntity.short(
         '${bundle.majorVersion}.${bundle.minorVersion}');
     restOfMap.remove('majorVersion');
     restOfMap.remove('minorVersion');
     result['linkedLibraryUris'] = restOfMap['linkedLibraryUris'];
     result['unlinkedUnitUris'] = restOfMap['unlinkedUnitUris'];
     for (int i = 0; i < bundle.linkedLibraries.length; i++) {
       String libraryUriString = bundle.linkedLibraryUris[i];
       Uri libraryUri = Uri.parse(libraryUriString);
       UnlinkedUnit unlinkedDefiningUnit = units[libraryUriString];
       seenUnits.add(libraryUriString);
       List<UnlinkedUnit> libraryUnits = <UnlinkedUnit>[unlinkedDefiningUnit];
       LinkedLibrary linkedLibrary = bundle.linkedLibraries[i];
       for (int j = 1; j < linkedLibrary.units.length; j++) {
         String partUriString = resolveRelativeUri(libraryUri,
                 Uri.parse(unlinkedDefiningUnit.publicNamespace.parts[j - 1]))
             .toString();
         libraryUnits.add(units[partUriString]);
         seenUnits.add(partUriString);
       }
       result['library ${json.encode(libraryUriString)}'] =
           new LibraryWrapper(linkedLibrary, libraryUnits);
     }
     for (String uriString in units.keys) {
       if (seenUnits.contains(uriString)) {
         continue;
       }
       result['orphan unit ${json.encode(uriString)}'] =
           new UnitWrapper(null, units[uriString]);
     }
     restOfMap.remove('linkedLibraries');
     restOfMap.remove('linkedLibraryUris');
     restOfMap.remove('unlinkedUnits');
     restOfMap.remove('unlinkedUnitUris');
     result.addAll(restOfMap);
     return decodeMap(result);
   }

   /**
    * Decode the given [ReferenceWrapper].
    */
   DecodedEntity decodeReference(ReferenceWrapper obj) {
     Map<String, Object> result = obj._unlinked != null
         ? obj._unlinked.toMap()
         : <String, Object>{'linkedOnly': true};
     if (obj._linked != null) {
       mergeMaps(result, obj._linked.toMap());
     }
     return decodeMap(result);
   }

   /**
    * Decode the given [UnitWrapper].
    */
   DecodedEntity decodeUnit(UnitWrapper obj) {
     try {
       LinkedUnit linked = obj._linked;
       UnlinkedUnit unlinked = obj._unlinked ?? new UnlinkedUnitBuilder();
       Map<String, Object> unlinkedMap = unlinked.toMap();
       Map<String, Object> linkedMap =
           linked != null ? linked.toMap() : <String, Object>{};
       Map<String, Object> result = <String, Object>{};
       List<ReferenceWrapper> references = <ReferenceWrapper>[];
       int numReferences = linked != null
           ? linked.references.length
           : unlinked.references.length;
       for (int i = 0; i < numReferences; i++) {
         references.add(new ReferenceWrapper(
             linked != null ? linked.references[i] : null,
             i < unlinked.references.length ? unlinked.references[i] : null));
       }
       result['references'] = references;
       _references = references;
       unlinkedMap.remove('references');
       linkedMap.remove('references');
       linkedMap.forEach((String key, Object value) {
         result['linked $key'] = value;
       });
       unlinkedMap.forEach((String key, Object value) {
         result[key] = value;
       });
       return decodeMap(result);
     } finally {
       _references = null;
     }
   }

   /**
    * Decode the given [PackageBundle] and dump it to a list of strings.
    */
   List<String> dumpPackageBundle(PackageBundle bundle) {
     DecodedEntity decoded = decode(bundle, 'PackageBundle');
     return decoded.getLines();
   }

   /**
    * Merge the contents of [other] into [result], discarding empty entries.
    */
   void mergeMaps(Map<String, Object> result, Map<String, Object> other) {
     other.forEach((String key, Object value) {
       if (value is String && value.isEmpty) {
         return;
       }
       if (result.containsKey(key)) {
         Object oldValue = result[key];
         if (oldValue is String && oldValue.isEmpty) {
           result[key] = value;
         } else {
           throw new Exception(
               'Duplicate values for $key: $oldValue and $value');
         }
       } else {
         result[key] = value;
       }
     });
   }

   /**
    * Reorder [map] for more intuitive display.
    */
   Map<String, Object> reorderMap(Map<String, Object> map) {
     Map<String, Object> result = <String, Object>{};
     if (map.containsKey('name')) {
       result['name'] = map['name'];
     }
     result.addAll(map);
     return result;
   }
 }

 /**
  * Decoded reprensentation of a part of a summary that occupies a single line of
  * output.
  */
 class UnbrokenEntity implements DecodedEntity {
   final String _s;

   UnbrokenEntity(this._s);

   @override
   List<String> getLines() => <String>[_s];
 }

 /**
  * Wrapper around a [LinkedUnit] and its corresponding [UnlinkedUnit].
  */
 class UnitWrapper {
   final LinkedUnit _linked;
   final UnlinkedUnit _unlinked;

   UnitWrapper(this._linked, this._unlinked);
 }
	// Copyright (c) 2016, 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.

	import 'dart:convert';
	import 'dart:io';
	import 'dart:mirrors';

	import 'package:analyzer/src/generated/utilities_dart.dart';
	import 'package:analyzer/src/summary/base.dart';
	import 'package:analyzer/src/summary/format.dart';
	import 'package:analyzer/src/summary/idl.dart';
	import 'package:args/args.dart';

	main(List<String> args) {
	ArgParser argParser = new ArgParser()..addFlag('raw');
	ArgResults argResults = argParser.parse(args);
	if (argResults.rest.length != 1) {
	print(argParser.usage);
	exitCode = 1;
	return;
	}
	String path = argResults.rest[0];
	List<int> bytes = new File(path).readAsBytesSync();
	PackageBundle bundle = new PackageBundle.fromBuffer(bytes);
	SummaryInspector inspector = new SummaryInspector(argResults['raw']);
	print(inspector.dumpPackageBundle(bundle).join('\n'));
	}

	const int MAX_LINE_LENGTH = 80;

	/**
	* Cache used to speed up [isEnum].
	*/
	Map<Type, bool> _isEnumCache = <Type, bool>{};

	/**
	* Determine if the given [obj] has an enumerated type.
	*/
	bool isEnum(Object obj) {
	return _isEnumCache.putIfAbsent(
	obj.runtimeType, () => reflect(obj).type.isEnum);
	}

	/**
	* Decoded reprensentation of a part of a summary that occupies multiple lines
	* of output.
	*/
	class BrokenEntity implements DecodedEntity {
	final String opener;
	final Map<String, DecodedEntity> parts;
	final String closer;

	BrokenEntity(this.opener, this.parts, this.closer);

	@override
	List<String> getLines() {
	List<String> result = <String>[opener];
	bool first = true;
	for (String key in parts.keys) {
	if (first) {
	first = false;
	} else {
	result[result.length - 1] += ',';
	}
	List<String> subResult = parts[key].getLines();
	subResult[0] = '$key: ${subResult[0]}';
	result.addAll(subResult.map((String s) => ' $s'));
	}
	result.add(closer);
	return result;
	}
	}

	/**
	* Decoded representation of a part of a summary.
	*/
	abstract class DecodedEntity {
	/**
	* Create a representation of a part of the summary that consists of a group
	* of entities (represented by [parts]) contained between [opener] and
	* [closer].
	*
	* If [forceKeys] is `true`, the keys in [parts] will always be shown. If
	* [forceKeys] is `false`, they keys will only be shown if the output is
	* broken into multiple lines.
	*/
	factory DecodedEntity.group(String opener, Map<String, DecodedEntity> parts,
	String closer, bool forceKeys) {
	// Attempt to format the entity in a single line; if not bail out and
	// construct a _BrokenEntity.
	DecodedEntity bailout() => new BrokenEntity(opener, parts, closer);
	String short = opener;
	bool first = true;
	for (String key in parts.keys) {
	if (first) {
	first = false;
	} else {
	short += ', ';
	}
	DecodedEntity value = parts[key];
	if (forceKeys) {
	short += '$key: ';
	}
	if (value is UnbrokenEntity) {
	short += value._s;
	} else {
	return bailout();
	}
	if (short.length > MAX_LINE_LENGTH) {
	return bailout();
	}
	}
	return new DecodedEntity.short(short + closer);
	}

	/**
	* Create a representation of a part of the summary that is represented by a
	* single unbroken string.
	*/
	factory DecodedEntity.short(String s) = UnbrokenEntity;

	/**
	* Format this entity into a sequence of strings (one per output line).
	*/
	List<String> getLines();
	}

	/**
	* Wrapper around a [LinkedLibrary] and its constituent [UnlinkedUnit]s.
	*/
	class LibraryWrapper {
	final LinkedLibrary _linked;
	final List<UnlinkedUnit> _unlinked;

	LibraryWrapper(this._linked, this._unlinked);
	}

	/**
	* Wrapper around a [LinkedReference] and its corresponding [UnlinkedReference].
	*/
	class ReferenceWrapper {
	final LinkedReference _linked;
	final UnlinkedReference _unlinked;

	ReferenceWrapper(this._linked, this._unlinked);

	String get name {
	if (_linked != null && _linked.name.isNotEmpty) {
	return _linked.name;
	} else if (_unlinked != null && _unlinked.name.isNotEmpty) {
	return _unlinked.name;
	} else {
	return '???';
	}
	}
	}

	/**
	* Instances of [SummaryInspector] are capable of traversing a summary and
	* converting it to semi-human-readable output.
	*/
	class SummaryInspector {
	/**
	* The dependencies of the library currently being visited.
	*/
	List<LinkedDependency> _dependencies;

	/**
	* The references of the unit currently being visited.
	*/
	List<ReferenceWrapper> _references;

	/**
	* Indicates whether summary inspection should operate in "raw" mode. In this
	* mode, the structure of the summary file is not altered for easier
	* readability; everything is output in exactly the form in which it appears
	* in the file.
	*/
	final bool raw;

	SummaryInspector(this.raw);

	/**
	* Decode the object [obj], which was reached by examining [key] inside
	* another object.
	*/
	DecodedEntity decode(Object obj, String key) {
	if (!raw && obj is PackageBundle) {
	return decodePackageBundle(obj);
	}
	if (obj is LibraryWrapper) {
	return decodeLibrary(obj);
	}
	if (obj is UnitWrapper) {
	return decodeUnit(obj);
	}
	if (obj is ReferenceWrapper) {
	return decodeReference(obj);
	}
	if (obj is DecodedEntity) {
	return obj;
	}
	if (obj is SummaryClass) {
	Map<String, Object> map = obj.toMap();
	return decodeMap(map);
	} else if (obj is List) {
	Map<String, DecodedEntity> parts = <String, DecodedEntity>{};
	for (int i = 0; i < obj.length; i++) {
	parts[i.toString()] = decode(obj[i], key);
	}
	return new DecodedEntity.group('[', parts, ']', false);
	} else if (obj is String) {
	return new DecodedEntity.short(json.encode(obj));
	} else if (isEnum(obj)) {
	return new DecodedEntity.short(obj.toString().split('.')[1]);
	} else if (obj is int &&
	key == 'dependency' &&
	_dependencies != null &&
	obj < _dependencies.length) {
	return new DecodedEntity.short('$obj (${_dependencies[obj].uri})');
	} else if (obj is int &&
	key == 'reference' &&
	_references != null &&
	obj < _references.length) {
	return new DecodedEntity.short('$obj (${_references[obj].name})');
	} else {
	return new DecodedEntity.short(obj.toString());
	}
	}

	/**
	* Decode the given [LibraryWrapper].
	*/
	DecodedEntity decodeLibrary(LibraryWrapper obj) {
	try {
	LinkedLibrary linked = obj._linked;
	List<UnlinkedUnit> unlinked = obj._unlinked;
	_dependencies = linked.dependencies;
	Map<String, Object> result = linked.toMap();
	result.remove('units');
	result['defining compilation unit'] =
	new UnitWrapper(linked.units[0], unlinked[0]);
	for (int i = 1; i < linked.units.length; i++) {
	String partUri = unlinked[0].publicNamespace.parts[i - 1];
	result['part ${json.encode(partUri)}'] =
	new UnitWrapper(linked.units[i], unlinked[i]);
	}
	return decodeMap(result);
	} finally {
	_dependencies = null;
	}
	}

	/**
	* Decode the given [map].
	*/
	DecodedEntity decodeMap(Map<String, Object> map) {
	Map<String, DecodedEntity> parts = <String, DecodedEntity>{};
	map = reorderMap(map);
	map.forEach((String key, Object value) {
	if (value is String && value.isEmpty) {
	return;
	}
	if (isEnum(value) && (value as dynamic).index == 0) {
	return;
	}
	if (value is int && value == 0) {
	return;
	}
	if (value is bool && value == false) {
	return;
	}
	if (value == null) {
	return;
	}
	if (value is List) {
	if (value.isEmpty) {
	return;
	}
	DecodedEntity entity = decode(value, key);
	if (entity is BrokenEntity) {
	for (int i = 0; i < value.length; i++) {
	parts['$key[$i]'] = decode(value[i], key);
	}
	return;
	} else {
	parts[key] = entity;
	}
	}
	parts[key] = decode(value, key);
	});
	return new DecodedEntity.group('{', parts, '}', true);
	}

	/**
	* Decode the given [PackageBundle].
	*/
	DecodedEntity decodePackageBundle(PackageBundle bundle) {
	Map<String, UnlinkedUnit> units = <String, UnlinkedUnit>{};
	Set<String> seenUnits = new Set<String>();
	for (int i = 0; i < bundle.unlinkedUnits.length; i++) {
	units[bundle.unlinkedUnitUris[i]] = bundle.unlinkedUnits[i];
	}
	Map<String, Object> restOfMap = bundle.toMap();
	Map<String, Object> result = <String, Object>{};
	result['version'] = new DecodedEntity.short(
	'${bundle.majorVersion}.${bundle.minorVersion}');
	restOfMap.remove('majorVersion');
	restOfMap.remove('minorVersion');
	result['linkedLibraryUris'] = restOfMap['linkedLibraryUris'];
	result['unlinkedUnitUris'] = restOfMap['unlinkedUnitUris'];
	for (int i = 0; i < bundle.linkedLibraries.length; i++) {
	String libraryUriString = bundle.linkedLibraryUris[i];
	Uri libraryUri = Uri.parse(libraryUriString);
	UnlinkedUnit unlinkedDefiningUnit = units[libraryUriString];
	seenUnits.add(libraryUriString);
	List<UnlinkedUnit> libraryUnits = <UnlinkedUnit>[unlinkedDefiningUnit];
	LinkedLibrary linkedLibrary = bundle.linkedLibraries[i];
	for (int j = 1; j < linkedLibrary.units.length; j++) {
	String partUriString = resolveRelativeUri(libraryUri,
	Uri.parse(unlinkedDefiningUnit.publicNamespace.parts[j - 1]))
	.toString();
	libraryUnits.add(units[partUriString]);
	seenUnits.add(partUriString);
	}
	result['library ${json.encode(libraryUriString)}'] =
	new LibraryWrapper(linkedLibrary, libraryUnits);
	}
	for (String uriString in units.keys) {
	if (seenUnits.contains(uriString)) {
	continue;
	}
	result['orphan unit ${json.encode(uriString)}'] =
	new UnitWrapper(null, units[uriString]);
	}
	restOfMap.remove('linkedLibraries');
	restOfMap.remove('linkedLibraryUris');
	restOfMap.remove('unlinkedUnits');
	restOfMap.remove('unlinkedUnitUris');
	result.addAll(restOfMap);
	return decodeMap(result);
	}

	/**
	* Decode the given [ReferenceWrapper].
	*/
	DecodedEntity decodeReference(ReferenceWrapper obj) {
	Map<String, Object> result = obj._unlinked != null
	? obj._unlinked.toMap()
	: <String, Object>{'linkedOnly': true};
	if (obj._linked != null) {
	mergeMaps(result, obj._linked.toMap());
	}
	return decodeMap(result);
	}

	/**
	* Decode the given [UnitWrapper].
	*/
	DecodedEntity decodeUnit(UnitWrapper obj) {
	try {
	LinkedUnit linked = obj._linked;
	UnlinkedUnit unlinked = obj._unlinked ?? new UnlinkedUnitBuilder();
	Map<String, Object> unlinkedMap = unlinked.toMap();
	Map<String, Object> linkedMap =
	linked != null ? linked.toMap() : <String, Object>{};
	Map<String, Object> result = <String, Object>{};
	List<ReferenceWrapper> references = <ReferenceWrapper>[];
	int numReferences = linked != null
	? linked.references.length
	: unlinked.references.length;
	for (int i = 0; i < numReferences; i++) {
	references.add(new ReferenceWrapper(
	linked != null ? linked.references[i] : null,
	i < unlinked.references.length ? unlinked.references[i] : null));
	}
	result['references'] = references;
	_references = references;
	unlinkedMap.remove('references');
	linkedMap.remove('references');
	linkedMap.forEach((String key, Object value) {
	result['linked $key'] = value;
	});
	unlinkedMap.forEach((String key, Object value) {
	result[key] = value;
	});
	return decodeMap(result);
	} finally {
	_references = null;
	}
	}

	/**
	* Decode the given [PackageBundle] and dump it to a list of strings.
	*/
	List<String> dumpPackageBundle(PackageBundle bundle) {
	DecodedEntity decoded = decode(bundle, 'PackageBundle');
	return decoded.getLines();
	}

	/**
	* Merge the contents of [other] into [result], discarding empty entries.
	*/
	void mergeMaps(Map<String, Object> result, Map<String, Object> other) {
	other.forEach((String key, Object value) {
	if (value is String && value.isEmpty) {
	return;
	}
	if (result.containsKey(key)) {
	Object oldValue = result[key];
	if (oldValue is String && oldValue.isEmpty) {
	result[key] = value;
	} else {
	throw new Exception(
	'Duplicate values for $key: $oldValue and $value');
	}
	} else {
	result[key] = value;
	}
	});
	}

	/**
	* Reorder [map] for more intuitive display.
	*/
	Map<String, Object> reorderMap(Map<String, Object> map) {
	Map<String, Object> result = <String, Object>{};
	if (map.containsKey('name')) {
	result['name'] = map['name'];
	}
	result.addAll(map);
	return result;
	}
	}

	/**
	* Decoded reprensentation of a part of a summary that occupies a single line of
	* output.
	*/
	class UnbrokenEntity implements DecodedEntity {
	final String _s;

	UnbrokenEntity(this._s);

	@override
	List<String> getLines() => <String>[_s];
	}

	/**
	* Wrapper around a [LinkedUnit] and its corresponding [UnlinkedUnit].
	*/
	class UnitWrapper {
	final LinkedUnit _linked;
	final UnlinkedUnit _unlinked;

	UnitWrapper(this._linked, this._unlinked);
	}