Add Element.nameOffset and LibraryElement.nameLength to 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 492 matching lines @@
   builder.unlinkedUnitUris = unlinkedUnitUris;
   builder.unlinkedUnits = unlinkedUnits;
   return builder;
 }
 
 /**
  * Unlinked summary information about a class declaration.
  */
 class UnlinkedClass extends base.SummaryClass {
   String _name;
+  int _nameOffset;
   List<UnlinkedTypeParam> _typeParameters;
   UnlinkedTypeRef _supertype;
   List<UnlinkedTypeRef> _mixins;
   List<UnlinkedTypeRef> _interfaces;
   List<UnlinkedVariable> _fields;
   List<UnlinkedExecutable> _executables;
   bool _isAbstract;
   bool _isMixinApplication;
   bool _hasNoSupertype;
 
   UnlinkedClass.fromJson(Map json)
     : _name = json["name"],
+      _nameOffset = json["nameOffset"],
       _typeParameters = json["typeParameters"]?.map((x) => new UnlinkedTypeParam.fromJson(x))?.toList(),
       _supertype = json["supertype"] == null ? null : new UnlinkedTypeRef.fromJson(json["supertype"]),
       _mixins = json["mixins"]?.map((x) => new UnlinkedTypeRef.fromJson(x))?.toList(),
       _interfaces = json["interfaces"]?.map((x) => new UnlinkedTypeRef.fromJson(x))?.toList(),
       _fields = json["fields"]?.map((x) => new UnlinkedVariable.fromJson(x))?.toList(),
       _executables = json["executables"]?.map((x) => new UnlinkedExecutable.fromJson(x))?.toList(),
       _isAbstract = json["isAbstract"],
       _isMixinApplication = json["isMixinApplication"],
       _hasNoSupertype = json["hasNoSupertype"];
 
   @override
   Map<String, Object> toMap() => {
     "name": name,
+    "nameOffset": nameOffset,
     "typeParameters": typeParameters,
     "supertype": supertype,
     "mixins": mixins,
     "interfaces": interfaces,
     "fields": fields,
     "executables": executables,
     "isAbstract": isAbstract,
     "isMixinApplication": isMixinApplication,
     "hasNoSupertype": hasNoSupertype,
   };
 
   /**
    * Name of the class.
    */
   String get name => _name ?? '';
 
   /**
+   * Offset of the class name relative to the beginning of the file.
+   */
+  int get nameOffset => _nameOffset ?? 0;
+
+  /**
    * Type parameters of the class, if any.
    */
   List<UnlinkedTypeParam> get typeParameters => _typeParameters ?? const <UnlinkedTypeParam>[];
 
   /**
    * Supertype of the class, or `null` if either (a) the class doesn't
    * explicitly declare a supertype (and hence has supertype `Object`), or (b)
    * the class *is* `Object` (and hence has no supertype).
    */
   UnlinkedTypeRef get supertype => _supertype;
@@ skipping 47 matching lines @@
    */
   void set name(String _value) {
     assert(!_finished);
     assert(!_json.containsKey("name"));
     if (_value != null) {
       _json["name"] = _value;
     }
   }
 
   /**
+   * Offset of the class name relative to the beginning of the file.
+   */
+  void set nameOffset(int _value) {
+    assert(!_finished);
+    assert(!_json.containsKey("nameOffset"));
+    if (_value != null) {
+      _json["nameOffset"] = _value;
+    }
+  }
+
+  /**
    * Type parameters of the class, if any.
    */
   void set typeParameters(List<UnlinkedTypeParamBuilder> _value) {
     assert(!_finished);
     assert(!_json.containsKey("typeParameters"));
     if (!(_value == null || _value.isEmpty)) {
       _json["typeParameters"] = _value.map((b) => b.finish()).toList();
     }
   }
 
@@ skipping 88 matching lines @@
     }
   }
 
   Map finish() {
     assert(!_finished);
     _finished = true;
     return _json;
   }
 }
 
-UnlinkedClassBuilder encodeUnlinkedClass(base.BuilderContext builderContext, {String name, List<UnlinkedTypeParamBuilder> typeParameters, UnlinkedTypeRefBuilder supertype, List<UnlinkedTypeRefBuilder> mixins, List<UnlinkedTypeRefBuilder> interfaces, List<UnlinkedVariableBuilder> fields, List<UnlinkedExecutableBuilder> executables, bool isAbstract, bool isMixinApplication, bool hasNoSupertype}) {
+UnlinkedClassBuilder encodeUnlinkedClass(base.BuilderContext builderContext, {String name, int nameOffset, List<UnlinkedTypeParamBuilder> typeParameters, UnlinkedTypeRefBuilder supertype, List<UnlinkedTypeRefBuilder> mixins, List<UnlinkedTypeRefBuilder> interfaces, List<UnlinkedVariableBuilder> fields, List<UnlinkedExecutableBuilder> executables, bool isAbstract, bool isMixinApplication, bool hasNoSupertype}) {
   UnlinkedClassBuilder builder = new UnlinkedClassBuilder(builderContext);
   builder.name = name;
+  builder.nameOffset = nameOffset;
   builder.typeParameters = typeParameters;
   builder.supertype = supertype;
   builder.mixins = mixins;
   builder.interfaces = interfaces;
   builder.fields = fields;
   builder.executables = executables;
   builder.isAbstract = isAbstract;
   builder.isMixinApplication = isMixinApplication;
   builder.hasNoSupertype = hasNoSupertype;
   return builder;
@@ skipping 69 matching lines @@
   builder.shows = shows;
   builder.hides = hides;
   return builder;
 }
 
 /**
  * Unlinked summary information about an enum declaration.
  */
 class UnlinkedEnum extends base.SummaryClass {
   String _name;
+  int _nameOffset;
   List<UnlinkedEnumValue> _values;
 
   UnlinkedEnum.fromJson(Map json)
     : _name = json["name"],
+      _nameOffset = json["nameOffset"],
       _values = json["values"]?.map((x) => new UnlinkedEnumValue.fromJson(x))?.toList();
 
   @override
   Map<String, Object> toMap() => {
     "name": name,
+    "nameOffset": nameOffset,
     "values": values,
   };
 
   /**
    * Name of the enum type.
    */
   String get name => _name ?? '';
 
   /**
+   * Offset of the enum name relative to the beginning of the file.
+   */
+  int get nameOffset => _nameOffset ?? 0;
+
+  /**
    * Values listed in the enum declaration, in declaration order.
    */
   List<UnlinkedEnumValue> get values => _values ?? const <UnlinkedEnumValue>[];
 }
 
 class UnlinkedEnumBuilder {
   final Map _json = {};
 
   bool _finished = false;
 
   UnlinkedEnumBuilder(base.BuilderContext context);
 
   /**
    * Name of the enum type.
    */
   void set name(String _value) {
     assert(!_finished);
     assert(!_json.containsKey("name"));
     if (_value != null) {
       _json["name"] = _value;
     }
   }
 
   /**
+   * Offset of the enum name relative to the beginning of the file.
+   */
+  void set nameOffset(int _value) {
+    assert(!_finished);
+    assert(!_json.containsKey("nameOffset"));
+    if (_value != null) {
+      _json["nameOffset"] = _value;
+    }
+  }
+
+  /**
    * Values listed in the enum declaration, in declaration order.
    */
   void set values(List<UnlinkedEnumValueBuilder> _value) {
     assert(!_finished);
     assert(!_json.containsKey("values"));
     if (!(_value == null || _value.isEmpty)) {
       _json["values"] = _value.map((b) => b.finish()).toList();
     }
   }
 
   Map finish() {
     assert(!_finished);
     _finished = true;
     return _json;
   }
 }
 
-UnlinkedEnumBuilder encodeUnlinkedEnum(base.BuilderContext builderContext, {String name, List<UnlinkedEnumValueBuilder> values}) {
+UnlinkedEnumBuilder encodeUnlinkedEnum(base.BuilderContext builderContext, {String name, int nameOffset, List<UnlinkedEnumValueBuilder> values}) {
   UnlinkedEnumBuilder builder = new UnlinkedEnumBuilder(builderContext);
   builder.name = name;
+  builder.nameOffset = nameOffset;
   builder.values = values;
   return builder;
 }
 
 /**
  * Unlinked summary information about a single enumerated value in an enum
  * declaration.
  */
 class UnlinkedEnumValue extends base.SummaryClass {
   String _name;
+  int _nameOffset;
 
   UnlinkedEnumValue.fromJson(Map json)
-    : _name = json["name"];
+    : _name = json["name"],
+      _nameOffset = json["nameOffset"];
 
   @override
   Map<String, Object> toMap() => {
     "name": name,
+    "nameOffset": nameOffset,
   };
 
   /**
    * Name of the enumerated value.
    */
   String get name => _name ?? '';
+
+  /**
+   * Offset of the enum value name relative to the beginning of the file.
+   */
+  int get nameOffset => _nameOffset ?? 0;
 }
 
 class UnlinkedEnumValueBuilder {
   final Map _json = {};
 
   bool _finished = false;
 
   UnlinkedEnumValueBuilder(base.BuilderContext context);
 
   /**
    * Name of the enumerated value.
    */
   void set name(String _value) {
     assert(!_finished);
     assert(!_json.containsKey("name"));
     if (_value != null) {
       _json["name"] = _value;
     }
   }
 
+  /**
+   * Offset of the enum value name relative to the beginning of the file.
+   */
+  void set nameOffset(int _value) {
+    assert(!_finished);
+    assert(!_json.containsKey("nameOffset"));
+    if (_value != null) {
+      _json["nameOffset"] = _value;
+    }
+  }
+
   Map finish() {
     assert(!_finished);
     _finished = true;
     return _json;
   }
 }
 
-UnlinkedEnumValueBuilder encodeUnlinkedEnumValue(base.BuilderContext builderContext, {String name}) {
+UnlinkedEnumValueBuilder encodeUnlinkedEnumValue(base.BuilderContext builderContext, {String name, int nameOffset}) {
   UnlinkedEnumValueBuilder builder = new UnlinkedEnumValueBuilder(builderContext);
   builder.name = name;
+  builder.nameOffset = nameOffset;
   return builder;
 }
 
 /**
  * Unlinked summary information about a function, method, getter, or setter
  * declaration.
  */
 class UnlinkedExecutable extends base.SummaryClass {
   String _name;
+  int _nameOffset;
   List<UnlinkedTypeParam> _typeParameters;
   UnlinkedTypeRef _returnType;
   List<UnlinkedParam> _parameters;
   UnlinkedExecutableKind _kind;
   bool _isAbstract;
   bool _isStatic;
   bool _isConst;
   bool _isFactory;
   bool _hasImplicitReturnType;
   bool _isExternal;
 
   UnlinkedExecutable.fromJson(Map json)
     : _name = json["name"],
+      _nameOffset = json["nameOffset"],
       _typeParameters = json["typeParameters"]?.map((x) => new UnlinkedTypeParam.fromJson(x))?.toList(),
       _returnType = json["returnType"] == null ? null : new UnlinkedTypeRef.fromJson(json["returnType"]),
       _parameters = json["parameters"]?.map((x) => new UnlinkedParam.fromJson(x))?.toList(),
       _kind = json["kind"] == null ? null : UnlinkedExecutableKind.values[json["kind"]],
       _isAbstract = json["isAbstract"],
       _isStatic = json["isStatic"],
       _isConst = json["isConst"],
       _isFactory = json["isFactory"],
       _hasImplicitReturnType = json["hasImplicitReturnType"],
       _isExternal = json["isExternal"];
 
   @override
   Map<String, Object> toMap() => {
     "name": name,
+    "nameOffset": nameOffset,
     "typeParameters": typeParameters,
     "returnType": returnType,
     "parameters": parameters,
     "kind": kind,
     "isAbstract": isAbstract,
     "isStatic": isStatic,
     "isConst": isConst,
     "isFactory": isFactory,
     "hasImplicitReturnType": hasImplicitReturnType,
     "isExternal": isExternal,
   };
 
   /**
    * 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.
    */
   String get name => _name ?? '';
 
   /**
+   * Offset of the executable name relative to the beginning of the file.  For
+   * named constructors, this excludes the class name and excludes the ".".
+   * For unnamed constructors, this is the offset of the class name (i.e. the
+   * offset of the second "C" in "class C { C(); }").
+   */
+  int get nameOffset => _nameOffset ?? 0;
+
+  /**
    * Type parameters of the executable, if any.  Empty if support for generic
    * method syntax is disabled.
    */
   List<UnlinkedTypeParam> get typeParameters => _typeParameters ?? const <UnlinkedTypeParam>[];
 
   /**
    * Declared return type of the executable.  Absent if the return type is
    * `void` or the executable is a constructor.  Note that when strong mode is
    * enabled, the actual return type may be different due to type inference.
    */
@@ skipping 62 matching lines @@
    */
   void set name(String _value) {
     assert(!_finished);
     assert(!_json.containsKey("name"));
     if (_value != null) {
       _json["name"] = _value;
     }
   }
 
   /**
+   * Offset of the executable name relative to the beginning of the file.  For
+   * named constructors, this excludes the class name and excludes the ".".
+   * For unnamed constructors, this is the offset of the class name (i.e. the
+   * offset of the second "C" in "class C { C(); }").
+   */
+  void set nameOffset(int _value) {
+    assert(!_finished);
+    assert(!_json.containsKey("nameOffset"));
+    if (_value != null) {
+      _json["nameOffset"] = _value;
+    }
+  }
+
+  /**
    * Type parameters of the executable, if any.  Empty if support for generic
    * method syntax is disabled.
    */
   void set typeParameters(List<UnlinkedTypeParamBuilder> _value) {
     assert(!_finished);
     assert(!_json.containsKey("typeParameters"));
     if (!(_value == null || _value.isEmpty)) {
       _json["typeParameters"] = _value.map((b) => b.finish()).toList();
     }
   }
@@ skipping 107 matching lines @@
     }
   }
 
   Map finish() {
     assert(!_finished);
     _finished = true;
     return _json;
   }
 }
 
-UnlinkedExecutableBuilder encodeUnlinkedExecutable(base.BuilderContext builderContext, {String name, List<UnlinkedTypeParamBuilder> typeParameters, UnlinkedTypeRefBuilder returnType, List<UnlinkedParamBuilder> parameters, UnlinkedExecutableKind kind, bool isAbstract, bool isStatic, bool isConst, bool isFactory, bool hasImplicitReturnType, bool isExternal}) {
+UnlinkedExecutableBuilder encodeUnlinkedExecutable(base.BuilderContext builderContext, {String name, int nameOffset, List<UnlinkedTypeParamBuilder> typeParameters, UnlinkedTypeRefBuilder returnType, List<UnlinkedParamBuilder> parameters, UnlinkedExecutableKind kind, bool isAbstract, bool isStatic, bool isConst, bool isFactory, bool hasImplicitReturnType, bool isExternal}) {
   UnlinkedExecutableBuilder builder = new UnlinkedExecutableBuilder(builderContext);
   builder.name = name;
+  builder.nameOffset = nameOffset;
   builder.typeParameters = typeParameters;
   builder.returnType = returnType;
   builder.parameters = parameters;
   builder.kind = kind;
   builder.isAbstract = isAbstract;
   builder.isStatic = isStatic;
   builder.isConst = isConst;
   builder.isFactory = isFactory;
   builder.hasImplicitReturnType = hasImplicitReturnType;
   builder.isExternal = isExternal;
   return builder;
 }
 
 /**
  * Unlinked summary information about an export declaration (stored outside
  * [UnlinkedPublicNamespace]).
  */
 class UnlinkedExportNonPublic extends base.SummaryClass {
+  int _offset;
   int _uriOffset;
   int _uriEnd;
 
   UnlinkedExportNonPublic.fromJson(Map json)
-    : _uriOffset = json["uriOffset"],
+    : _offset = json["offset"],
+      _uriOffset = json["uriOffset"],
       _uriEnd = json["uriEnd"];
 
   @override
   Map<String, Object> toMap() => {
+    "offset": offset,
     "uriOffset": uriOffset,
     "uriEnd": uriEnd,
   };
 
   /**
+   * Offset of the "export" keyword.
+   */
+  int get offset => _offset ?? 0;
+
+  /**
    * Offset of the URI string (including quotes) relative to the beginning of
    * the file.
    */
   int get uriOffset => _uriOffset ?? 0;
 
   /**
    * End of the URI string (including quotes) relative to the beginning of the
    * file.
    */
   int get uriEnd => _uriEnd ?? 0;
 }
 
 class UnlinkedExportNonPublicBuilder {
   final Map _json = {};
 
   bool _finished = false;
 
   UnlinkedExportNonPublicBuilder(base.BuilderContext context);
 
   /**
+   * Offset of the "export" keyword.
+   */
+  void set offset(int _value) {
+    assert(!_finished);
+    assert(!_json.containsKey("offset"));
+    if (_value != null) {
+      _json["offset"] = _value;
+    }
+  }
+
+  /**
    * Offset of the URI string (including quotes) relative to the beginning of
    * the file.
    */
   void set uriOffset(int _value) {
     assert(!_finished);
     assert(!_json.containsKey("uriOffset"));
     if (_value != null) {
       _json["uriOffset"] = _value;
     }
   }
@@ skipping 10 matching lines @@
     }
   }
 
   Map finish() {
     assert(!_finished);
     _finished = true;
     return _json;
   }
 }
 
-UnlinkedExportNonPublicBuilder encodeUnlinkedExportNonPublic(base.BuilderContext builderContext, {int uriOffset, int uriEnd}) {
+UnlinkedExportNonPublicBuilder encodeUnlinkedExportNonPublic(base.BuilderContext builderContext, {int offset, int uriOffset, int uriEnd}) {
   UnlinkedExportNonPublicBuilder builder = new UnlinkedExportNonPublicBuilder(builderContext);
+  builder.offset = offset;
   builder.uriOffset = uriOffset;
   builder.uriEnd = uriEnd;
   return builder;
 }
 
 /**
  * Unlinked summary information about an export declaration (stored inside
  * [UnlinkedPublicNamespace]).
  */
 class UnlinkedExportPublic extends base.SummaryClass {
@@ skipping 69 matching lines @@
  */
 class UnlinkedImport extends base.SummaryClass {
   String _uri;
   int _offset;
   int _prefixReference;
   List<UnlinkedCombinator> _combinators;
   bool _isDeferred;
   bool _isImplicit;
   int _uriOffset;
   int _uriEnd;
+  int _prefixOffset;
 
   UnlinkedImport.fromJson(Map json)
     : _uri = json["uri"],
       _offset = json["offset"],
       _prefixReference = json["prefixReference"],
       _combinators = json["combinators"]?.map((x) => new UnlinkedCombinator.fromJson(x))?.toList(),
       _isDeferred = json["isDeferred"],
       _isImplicit = json["isImplicit"],
       _uriOffset = json["uriOffset"],
-      _uriEnd = json["uriEnd"];
+      _uriEnd = json["uriEnd"],
+      _prefixOffset = json["prefixOffset"];
 
   @override
   Map<String, Object> toMap() => {
     "uri": uri,
     "offset": offset,
     "prefixReference": prefixReference,
     "combinators": combinators,
     "isDeferred": isDeferred,
     "isImplicit": isImplicit,
     "uriOffset": uriOffset,
     "uriEnd": uriEnd,
+    "prefixOffset": prefixOffset,
   };
 
   /**
    * URI used in the source code to reference the imported library.
    */
   String get uri => _uri ?? '';
 
   /**
    * If [isImplicit] is false, offset of the "import" keyword.  If [isImplicit]
    * is true, zero.
@@ skipping 27 matching lines @@
    * Offset of the URI string (including quotes) relative to the beginning of
    * the file.  If [isImplicit] is true, zero.
    */
   int get uriOffset => _uriOffset ?? 0;
 
   /**
    * End of the URI string (including quotes) relative to the beginning of the
    * file.  If [isImplicit] is true, zero.
    */
   int get uriEnd => _uriEnd ?? 0;
+
+  /**
+   * Offset of the prefix name relative to the beginning of the file, or zero
+   * if there is no prefix.
+   */
+  int get prefixOffset => _prefixOffset ?? 0;
 }
 
 class UnlinkedImportBuilder {
   final Map _json = {};
 
   bool _finished = false;
 
   UnlinkedImportBuilder(base.BuilderContext context);
 
   /**
@@ skipping 83 matching lines @@
    * file.  If [isImplicit] is true, zero.
    */
   void set uriEnd(int _value) {
     assert(!_finished);
     assert(!_json.containsKey("uriEnd"));
     if (_value != null) {
       _json["uriEnd"] = _value;
     }
   }
 
+  /**
+   * Offset of the prefix name relative to the beginning of the file, or zero
+   * if there is no prefix.
+   */
+  void set prefixOffset(int _value) {
+    assert(!_finished);
+    assert(!_json.containsKey("prefixOffset"));
+    if (_value != null) {
+      _json["prefixOffset"] = _value;
+    }
+  }
+
   Map finish() {
     assert(!_finished);
     _finished = true;
     return _json;
   }
 }
 
-UnlinkedImportBuilder encodeUnlinkedImport(base.BuilderContext builderContext, {String uri, int offset, int prefixReference, List<UnlinkedCombinatorBuilder> combinators, bool isDeferred, bool isImplicit, int uriOffset, int uriEnd}) {
+UnlinkedImportBuilder encodeUnlinkedImport(base.BuilderContext builderContext, {String uri, int offset, int prefixReference, List<UnlinkedCombinatorBuilder> combinators, bool isDeferred, bool isImplicit, int uriOffset, int uriEnd, int prefixOffset}) {
   UnlinkedImportBuilder builder = new UnlinkedImportBuilder(builderContext);
   builder.uri = uri;
   builder.offset = offset;
   builder.prefixReference = prefixReference;
   builder.combinators = combinators;
   builder.isDeferred = isDeferred;
   builder.isImplicit = isImplicit;
   builder.uriOffset = uriOffset;
   builder.uriEnd = uriEnd;
+  builder.prefixOffset = prefixOffset;
   return builder;
 }
 
 /**
  * Unlinked summary information about a function parameter.
  */
 class UnlinkedParam extends base.SummaryClass {
   String _name;
+  int _nameOffset;
   UnlinkedTypeRef _type;
   List<UnlinkedParam> _parameters;
   UnlinkedParamKind _kind;
   bool _isFunctionTyped;
   bool _isInitializingFormal;
   bool _hasImplicitType;
 
   UnlinkedParam.fromJson(Map json)
     : _name = json["name"],
+      _nameOffset = json["nameOffset"],
       _type = json["type"] == null ? null : new UnlinkedTypeRef.fromJson(json["type"]),
       _parameters = json["parameters"]?.map((x) => new UnlinkedParam.fromJson(x))?.toList(),
       _kind = json["kind"] == null ? null : UnlinkedParamKind.values[json["kind"]],
       _isFunctionTyped = json["isFunctionTyped"],
       _isInitializingFormal = json["isInitializingFormal"],
       _hasImplicitType = json["hasImplicitType"];
 
   @override
   Map<String, Object> toMap() => {
     "name": name,
+    "nameOffset": nameOffset,
     "type": type,
     "parameters": parameters,
     "kind": kind,
     "isFunctionTyped": isFunctionTyped,
     "isInitializingFormal": isInitializingFormal,
     "hasImplicitType": hasImplicitType,
   };
 
   /**
    * Name of the parameter.
    */
   String get name => _name ?? '';
 
   /**
+   * Offset of the parameter name relative to the beginning of the file.
+   */
+  int get nameOffset => _nameOffset ?? 0;
+
+  /**
    * If [isFunctionTyped] is `true`, the declared return type.  If
    * [isFunctionTyped] is `false`, the declared type.  Absent if
    * [isFunctionTyped] is `true` and the declared return type is `void`.  Note
    * that when strong mode is enabled, the actual type may be different due to
    * type inference.
    */
   UnlinkedTypeRef get type => _type;
 
   /**
    * If [isFunctionTyped] is `true`, the parameters of the function type.
@@ skipping 35 matching lines @@
    */
   void set name(String _value) {
     assert(!_finished);
     assert(!_json.containsKey("name"));
     if (_value != null) {
       _json["name"] = _value;
     }
   }
 
   /**
+   * Offset of the parameter name relative to the beginning of the file.
+   */
+  void set nameOffset(int _value) {
+    assert(!_finished);
+    assert(!_json.containsKey("nameOffset"));
+    if (_value != null) {
+      _json["nameOffset"] = _value;
+    }
+  }
+
+  /**
    * If [isFunctionTyped] is `true`, the declared return type.  If
    * [isFunctionTyped] is `false`, the declared type.  Absent if
    * [isFunctionTyped] is `true` and the declared return type is `void`.  Note
    * that when strong mode is enabled, the actual type may be different due to
    * type inference.
    */
   void set type(UnlinkedTypeRefBuilder _value) {
     assert(!_finished);
     assert(!_json.containsKey("type"));
     if (_value != null) {
@@ skipping 58 matching lines @@
     }
   }
 
   Map finish() {
     assert(!_finished);
     _finished = true;
     return _json;
   }
 }
 
-UnlinkedParamBuilder encodeUnlinkedParam(base.BuilderContext builderContext, {String name, UnlinkedTypeRefBuilder type, List<UnlinkedParamBuilder> parameters, UnlinkedParamKind kind, bool isFunctionTyped, bool isInitializingFormal, bool hasImplicitType}) {
+UnlinkedParamBuilder encodeUnlinkedParam(base.BuilderContext builderContext, {String name, int nameOffset, UnlinkedTypeRefBuilder type, List<UnlinkedParamBuilder> parameters, UnlinkedParamKind kind, bool isFunctionTyped, bool isInitializingFormal, bool hasImplicitType}) {
   UnlinkedParamBuilder builder = new UnlinkedParamBuilder(builderContext);
   builder.name = name;
+  builder.nameOffset = nameOffset;
   builder.type = type;
   builder.parameters = parameters;
   builder.kind = kind;
   builder.isFunctionTyped = isFunctionTyped;
   builder.isInitializingFormal = isInitializingFormal;
   builder.hasImplicitType = hasImplicitType;
   return builder;
 }
 
 /**
@@ skipping 352 matching lines @@
   builder.name = name;
   builder.prefixReference = prefixReference;
   return builder;
 }
 
 /**
  * Unlinked summary information about a typedef declaration.
  */
 class UnlinkedTypedef extends base.SummaryClass {
   String _name;
+  int _nameOffset;
   List<UnlinkedTypeParam> _typeParameters;
   UnlinkedTypeRef _returnType;
   List<UnlinkedParam> _parameters;
 
   UnlinkedTypedef.fromJson(Map json)
     : _name = json["name"],
+      _nameOffset = json["nameOffset"],
       _typeParameters = json["typeParameters"]?.map((x) => new UnlinkedTypeParam.fromJson(x))?.toList(),
       _returnType = json["returnType"] == null ? null : new UnlinkedTypeRef.fromJson(json["returnType"]),
       _parameters = json["parameters"]?.map((x) => new UnlinkedParam.fromJson(x))?.toList();
 
   @override
   Map<String, Object> toMap() => {
     "name": name,
+    "nameOffset": nameOffset,
     "typeParameters": typeParameters,
     "returnType": returnType,
     "parameters": parameters,
   };
 
   /**
    * Name of the typedef.
    */
   String get name => _name ?? '';
 
   /**
+   * Offset of the typedef name relative to the beginning of the file.
+   */
+  int get nameOffset => _nameOffset ?? 0;
+
+  /**
    * Type parameters of the typedef, if any.
    */
   List<UnlinkedTypeParam> get typeParameters => _typeParameters ?? const <UnlinkedTypeParam>[];
 
   /**
    * Return type of the typedef.  Absent if the return type is `void`.
    */
   UnlinkedTypeRef get returnType => _returnType;
 
   /**
@@ skipping 14 matching lines @@
    */
   void set name(String _value) {
     assert(!_finished);
     assert(!_json.containsKey("name"));
     if (_value != null) {
       _json["name"] = _value;
     }
   }
 
   /**
+   * Offset of the typedef name relative to the beginning of the file.
+   */
+  void set nameOffset(int _value) {
+    assert(!_finished);
+    assert(!_json.containsKey("nameOffset"));
+    if (_value != null) {
+      _json["nameOffset"] = _value;
+    }
+  }
+
+  /**
    * Type parameters of the typedef, if any.
    */
   void set typeParameters(List<UnlinkedTypeParamBuilder> _value) {
     assert(!_finished);
     assert(!_json.containsKey("typeParameters"));
     if (!(_value == null || _value.isEmpty)) {
       _json["typeParameters"] = _value.map((b) => b.finish()).toList();
     }
   }
 
@@ skipping 19 matching lines @@
     }
   }
 
   Map finish() {
     assert(!_finished);
     _finished = true;
     return _json;
   }
 }
 
-UnlinkedTypedefBuilder encodeUnlinkedTypedef(base.BuilderContext builderContext, {String name, List<UnlinkedTypeParamBuilder> typeParameters, UnlinkedTypeRefBuilder returnType, List<UnlinkedParamBuilder> parameters}) {
+UnlinkedTypedefBuilder encodeUnlinkedTypedef(base.BuilderContext builderContext, {String name, int nameOffset, List<UnlinkedTypeParamBuilder> typeParameters, UnlinkedTypeRefBuilder returnType, List<UnlinkedParamBuilder> parameters}) {
   UnlinkedTypedefBuilder builder = new UnlinkedTypedefBuilder(builderContext);
   builder.name = name;
+  builder.nameOffset = nameOffset;
   builder.typeParameters = typeParameters;
   builder.returnType = returnType;
   builder.parameters = parameters;
   return builder;
 }
 
 /**
  * Unlinked summary information about a type parameter declaration.
  */
 class UnlinkedTypeParam extends base.SummaryClass {
   String _name;
+  int _nameOffset;
   UnlinkedTypeRef _bound;
 
   UnlinkedTypeParam.fromJson(Map json)
     : _name = json["name"],
+      _nameOffset = json["nameOffset"],
       _bound = json["bound"] == null ? null : new UnlinkedTypeRef.fromJson(json["bound"]);
 
   @override
   Map<String, Object> toMap() => {
     "name": name,
+    "nameOffset": nameOffset,
     "bound": bound,
   };
 
   /**
    * Name of the type parameter.
    */
   String get name => _name ?? '';
 
   /**
+   * Offset of the type parameter name relative to the beginning of the file.
+   */
+  int get nameOffset => _nameOffset ?? 0;
+
+  /**
    * Bound of the type parameter, if a bound is explicitly declared.  Otherwise
    * null.
    */
   UnlinkedTypeRef get bound => _bound;
 }
 
 class UnlinkedTypeParamBuilder {
   final Map _json = {};
 
   bool _finished = false;
 
   UnlinkedTypeParamBuilder(base.BuilderContext context);
 
   /**
    * Name of the type parameter.
    */
   void set name(String _value) {
     assert(!_finished);
     assert(!_json.containsKey("name"));
     if (_value != null) {
       _json["name"] = _value;
     }
   }
 
   /**
+   * Offset of the type parameter name relative to the beginning of the file.
+   */
+  void set nameOffset(int _value) {
+    assert(!_finished);
+    assert(!_json.containsKey("nameOffset"));
+    if (_value != null) {
+      _json["nameOffset"] = _value;
+    }
+  }
+
+  /**
    * Bound of the type parameter, if a bound is explicitly declared.  Otherwise
    * null.
    */
   void set bound(UnlinkedTypeRefBuilder _value) {
     assert(!_finished);
     assert(!_json.containsKey("bound"));
     if (_value != null) {
       _json["bound"] = _value.finish();
     }
   }
 
   Map finish() {
     assert(!_finished);
     _finished = true;
     return _json;
   }
 }
 
-UnlinkedTypeParamBuilder encodeUnlinkedTypeParam(base.BuilderContext builderContext, {String name, UnlinkedTypeRefBuilder bound}) {
+UnlinkedTypeParamBuilder encodeUnlinkedTypeParam(base.BuilderContext builderContext, {String name, int nameOffset, UnlinkedTypeRefBuilder bound}) {
   UnlinkedTypeParamBuilder builder = new UnlinkedTypeParamBuilder(builderContext);
   builder.name = name;
+  builder.nameOffset = nameOffset;
   builder.bound = bound;
   return builder;
 }
 
 /**
  * Unlinked summary information about a reference to a type.
  */
 class UnlinkedTypeRef extends base.SummaryClass {
   int _reference;
   int _paramReference;
@@ skipping 128 matching lines @@
   builder.paramReference = paramReference;
   builder.typeArguments = typeArguments;
   return builder;
 }
 
 /**
  * Unlinked summary information about a compilation unit ("part file").
  */
 class UnlinkedUnit extends base.SummaryClass {
   String _libraryName;
+  int _libraryNameOffset;
+  int _libraryNameLength;
   UnlinkedPublicNamespace _publicNamespace;
   List<UnlinkedReference> _references;
   List<UnlinkedClass> _classes;
   List<UnlinkedEnum> _enums;
   List<UnlinkedExecutable> _executables;
   List<UnlinkedExportNonPublic> _exports;
   List<UnlinkedImport> _imports;
   List<UnlinkedPart> _parts;
   List<UnlinkedTypedef> _typedefs;
   List<UnlinkedVariable> _variables;
 
   UnlinkedUnit.fromJson(Map json)
     : _libraryName = json["libraryName"],
+      _libraryNameOffset = json["libraryNameOffset"],
+      _libraryNameLength = json["libraryNameLength"],
       _publicNamespace = json["publicNamespace"] == null ? null : new UnlinkedPublicNamespace.fromJson(json["publicNamespace"]),
       _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 UnlinkedExportNonPublic.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();
 
   @override
   Map<String, Object> toMap() => {
     "libraryName": libraryName,
+    "libraryNameOffset": libraryNameOffset,
+    "libraryNameLength": libraryNameLength,
     "publicNamespace": publicNamespace,
     "references": references,
     "classes": classes,
     "enums": enums,
     "executables": executables,
     "exports": exports,
     "imports": imports,
     "parts": parts,
     "typedefs": typedefs,
     "variables": variables,
   };
 
   UnlinkedUnit.fromBuffer(List<int> buffer) : this.fromJson(JSON.decode(UTF8.decode(buffer)));
 
   /**
    * Name of the library (from a "library" declaration, if present).
    */
   String get libraryName => _libraryName ?? '';
 
   /**
+   * Offset of the library name relative to the beginning of the file (or 0 if
+   * the library has no name).
+   */
+  int get libraryNameOffset => _libraryNameOffset ?? 0;
+
+  /**
+   * Length of the library name as it appears in the source code (or 0 if the
+   * library has no name).
+   */
+  int get libraryNameLength => _libraryNameLength ?? 0;
+
+  /**
    * Unlinked public namespace of this compilation unit.
    */
   UnlinkedPublicNamespace get publicNamespace => _publicNamespace;
 
   /**
    * Top level and prefixed names referred to by this compilation unit.  The
    * zeroth element of this array is always populated and always represents a
    * reference to the pseudo-type "dynamic".
    */
   List<UnlinkedReference> get references => _references ?? const <UnlinkedReference>[];
@@ skipping 52 matching lines @@
    */
   void set libraryName(String _value) {
     assert(!_finished);
     assert(!_json.containsKey("libraryName"));
     if (_value != null) {
       _json["libraryName"] = _value;
     }
   }
 
   /**
+   * Offset of the library name relative to the beginning of the file (or 0 if
+   * the library has no name).
+   */
+  void set libraryNameOffset(int _value) {
+    assert(!_finished);
+    assert(!_json.containsKey("libraryNameOffset"));
+    if (_value != null) {
+      _json["libraryNameOffset"] = _value;
+    }
+  }
+
+  /**
+   * Length of the library name as it appears in the source code (or 0 if the
+   * library has no name).
+   */
+  void set libraryNameLength(int _value) {
+    assert(!_finished);
+    assert(!_json.containsKey("libraryNameLength"));
+    if (_value != null) {
+      _json["libraryNameLength"] = _value;
+    }
+  }
+
+  /**
    * Unlinked public namespace of this compilation unit.
    */
   void set publicNamespace(UnlinkedPublicNamespaceBuilder _value) {
     assert(!_finished);
     assert(!_json.containsKey("publicNamespace"));
     if (_value != null) {
       _json["publicNamespace"] = _value.finish();
     }
   }
 
@@ skipping 101 matching lines @@
 
   List<int> toBuffer() => UTF8.encode(JSON.encode(finish()));
 
   Map finish() {
     assert(!_finished);
     _finished = true;
     return _json;
   }
 }
 
-UnlinkedUnitBuilder encodeUnlinkedUnit(base.BuilderContext builderContext, {String libraryName, UnlinkedPublicNamespaceBuilder publicNamespace, List<UnlinkedReferenceBuilder> references, List<UnlinkedClassBuilder> classes, List<UnlinkedEnumBuilder> enums, List<UnlinkedExecutableBuilder> executables, List<UnlinkedExportNonPublicBuilder> exports, List<UnlinkedImportBuilder> imports, List<UnlinkedPartBuilder> parts, List<UnlinkedTypedefBuilder> typedefs, List<UnlinkedVariableBuilder> variables}) {
+UnlinkedUnitBuilder encodeUnlinkedUnit(base.BuilderContext builderContext, {String libraryName, int libraryNameOffset, int libraryNameLength, UnlinkedPublicNamespaceBuilder publicNamespace, List<UnlinkedReferenceBuilder> references, List<UnlinkedClassBuilder> classes, List<UnlinkedEnumBuilder> enums, List<UnlinkedExecutableBuilder> executables, List<UnlinkedExportNonPublicBuilder> exports, List<UnlinkedImportBuilder> imports, List<UnlinkedPartBuilder> parts, List<UnlinkedTypedefBuilder> typedefs, List<UnlinkedVariableBuilder> variables}) {
   UnlinkedUnitBuilder builder = new UnlinkedUnitBuilder(builderContext);
   builder.libraryName = libraryName;
+  builder.libraryNameOffset = libraryNameOffset;
+  builder.libraryNameLength = libraryNameLength;
   builder.publicNamespace = publicNamespace;
   builder.references = references;
   builder.classes = classes;
   builder.enums = enums;
   builder.executables = executables;
   builder.exports = exports;
   builder.imports = imports;
   builder.parts = parts;
   builder.typedefs = typedefs;
   builder.variables = variables;
   return builder;
 }
 
 /**
  * Unlinked summary information about a top level variable, local variable, or
  * a field.
  */
 class UnlinkedVariable extends base.SummaryClass {
   String _name;
+  int _nameOffset;
   UnlinkedTypeRef _type;
   bool _isStatic;
   bool _isFinal;
   bool _isConst;
   bool _hasImplicitType;
 
   UnlinkedVariable.fromJson(Map json)
     : _name = json["name"],
+      _nameOffset = json["nameOffset"],
       _type = json["type"] == null ? null : new UnlinkedTypeRef.fromJson(json["type"]),
       _isStatic = json["isStatic"],
       _isFinal = json["isFinal"],
       _isConst = json["isConst"],
       _hasImplicitType = json["hasImplicitType"];
 
   @override
   Map<String, Object> toMap() => {
     "name": name,
+    "nameOffset": nameOffset,
     "type": type,
     "isStatic": isStatic,
     "isFinal": isFinal,
     "isConst": isConst,
     "hasImplicitType": hasImplicitType,
   };
 
   /**
    * Name of the variable.
    */
   String get name => _name ?? '';
 
   /**
+   * Offset of the variable name relative to the beginning of the file.
+   */
+  int get nameOffset => _nameOffset ?? 0;
+
+  /**
    * Declared type of the variable.  Note that when strong mode is enabled, the
    * actual type of the variable may be different due to type inference.
    */
   UnlinkedTypeRef get type => _type;
 
   /**
    * Indicates whether the variable is declared using the `static` keyword.
    *
    * Note that for top level variables, this flag is false, since they are not
    * declared using the `static` keyword (even though they are considered
@@ skipping 29 matching lines @@
    */
   void set name(String _value) {
     assert(!_finished);
     assert(!_json.containsKey("name"));
     if (_value != null) {
       _json["name"] = _value;
     }
   }
 
   /**
+   * Offset of the variable name relative to the beginning of the file.
+   */
+  void set nameOffset(int _value) {
+    assert(!_finished);
+    assert(!_json.containsKey("nameOffset"));
+    if (_value != null) {
+      _json["nameOffset"] = _value;
+    }
+  }
+
+  /**
    * Declared type of the variable.  Note that when strong mode is enabled, the
    * actual type of the variable may be different due to type inference.
    */
   void set type(UnlinkedTypeRefBuilder _value) {
     assert(!_finished);
     assert(!_json.containsKey("type"));
     if (_value != null) {
       _json["type"] = _value.finish();
     }
   }
@@ skipping 46 matching lines @@
     }
   }
 
   Map finish() {
     assert(!_finished);
     _finished = true;
     return _json;
   }
 }
 
-UnlinkedVariableBuilder encodeUnlinkedVariable(base.BuilderContext builderContext, {String name, UnlinkedTypeRefBuilder type, bool isStatic, bool isFinal, bool isConst, bool hasImplicitType}) {
+UnlinkedVariableBuilder encodeUnlinkedVariable(base.BuilderContext builderContext, {String name, int nameOffset, UnlinkedTypeRefBuilder type, bool isStatic, bool isFinal, bool isConst, bool hasImplicitType}) {
   UnlinkedVariableBuilder builder = new UnlinkedVariableBuilder(builderContext);
   builder.name = name;
+  builder.nameOffset = nameOffset;
   builder.type = type;
   builder.isStatic = isStatic;
   builder.isFinal = isFinal;
   builder.isConst = isConst;
   builder.hasImplicitType = hasImplicitType;
   return builder;
 }