Add Element.nameOffset and LibraryElement.nameLength to summaries.

pkg/analyzer/test/src/summary/summary_test.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.
 
 library analyzer.test.src.summary.summary_test;
 
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/generated/error.dart';
@@ skipping 822 matching lines @@
 ''');
     expect(cls.mixins, hasLength(2));
     checkTypeRef(cls.mixins[0], null, null, 'D');
     checkTypeRef(cls.mixins[1], null, null, 'E');
   }
 
   test_class_name() {
     var classText = 'class C {}';
     UnlinkedClass cls = serializeClassText(classText);
     expect(cls.name, 'C');
+    expect(cls.nameOffset, classText.indexOf('C'));
   }
 
   test_class_no_flags() {
     UnlinkedClass cls = serializeClassText('class C {}');
     expect(cls.isAbstract, false);
     expect(cls.isMixinApplication, false);
   }
 
   test_class_no_interface() {
     UnlinkedClass cls = serializeClassText('class C {}');
@@ skipping 62 matching lines @@
     checkParamTypeRef(typeArgument, 2);
   }
 
   test_class_type_param_f_bound_self_ref() {
     UnlinkedClass cls = serializeClassText('class C<T, U extends List<U>> {}');
     UnlinkedTypeRef typeArgument = cls.typeParameters[1].bound.typeArguments[0];
     checkParamTypeRef(typeArgument, 1);
   }
 
   test_class_type_param_no_bound() {
-    UnlinkedClass cls = serializeClassText('class C<T> {}');
+    String text = 'class C<T> {}';
+    UnlinkedClass cls = serializeClassText(text);
     expect(cls.typeParameters, hasLength(1));
     expect(cls.typeParameters[0].name, 'T');
+    expect(cls.typeParameters[0].nameOffset, text.indexOf('T'));
     expect(cls.typeParameters[0].bound, isNull);
     expect(unlinkedUnits[0].publicNamespace.names[0].numTypeParameters, 1);
   }
 
   test_constructor() {
-    UnlinkedExecutable executable = findExecutable('',
-        executables: serializeClassText('class C { C(); }').executables);
+    String text = 'class C { C(); }';
+    UnlinkedExecutable executable =
+        findExecutable('', executables: serializeClassText(text).executables);
     expect(executable.kind, UnlinkedExecutableKind.constructor);
     expect(executable.hasImplicitReturnType, isFalse);
     expect(executable.isExternal, isFalse);
+    expect(executable.nameOffset, text.indexOf('C();'));
   }
 
   test_constructor_anonymous() {
     UnlinkedExecutable executable = findExecutable('',
         executables: serializeClassText('class C { C(); }').executables);
     expect(executable.name, isEmpty);
   }
 
   test_constructor_const() {
     UnlinkedExecutable executable = findExecutable('',
@@ skipping 159 matching lines @@
   test_constructor_initializing_formal_typedef() {
     UnlinkedExecutable executable = findExecutable('',
         executables: serializeClassText(
                 'typedef F<T>(T x); class C<X> { C(this.f); F<X> f; }')
             .executables);
     UnlinkedParam parameter = executable.parameters[0];
     expect(parameter.parameters, hasLength(1));
   }
 
   test_constructor_named() {
+    String text = 'class C { C.foo(); }';
     UnlinkedExecutable executable = findExecutable('foo',
-        executables: serializeClassText('class C { C.foo(); }').executables);
+        executables: serializeClassText(text).executables);
     expect(executable.name, 'foo');
+    expect(executable.nameOffset, text.indexOf('foo'));
   }
 
   test_constructor_non_const() {
     UnlinkedExecutable executable = findExecutable('',
         executables: serializeClassText('class C { C(); }').executables);
     expect(executable.isConst, isFalse);
   }
 
   test_constructor_non_factory() {
     UnlinkedExecutable executable = findExecutable('',
@@ skipping 111 matching lines @@
     serializeLibraryText('library my.lib; part "part1.dart";');
     UnlinkedUnit unit = unlinkedUnits[1];
     expect(findClass('C', unit: unit), isNotNull);
     expect(findEnum('E', unit: unit), isNotNull);
     expect(findVariable('v', variables: unit.variables), isNotNull);
     expect(findExecutable('f', executables: unit.executables), isNotNull);
     expect(findTypedef('F', unit: unit), isNotNull);
   }
 
   test_enum() {
-    UnlinkedEnum e = serializeEnumText('enum E { v1 }');
+    String text = 'enum E { v1 }';
+    UnlinkedEnum e = serializeEnumText(text);
     expect(e.name, 'E');
+    expect(e.nameOffset, text.indexOf('E'));
     expect(e.values, hasLength(1));
     expect(e.values[0].name, 'v1');
+    expect(e.values[0].nameOffset, text.indexOf('v1'));
     expect(unlinkedUnits[0].publicNamespace.names, hasLength(1));
     expect(unlinkedUnits[0].publicNamespace.names[0].kind,
         PrelinkedReferenceKind.classOrEnum);
     expect(unlinkedUnits[0].publicNamespace.names[0].name, 'E');
     expect(unlinkedUnits[0].publicNamespace.names[0].numTypeParameters, 0);
   }
 
   test_enum_order() {
     UnlinkedEnum e = serializeEnumText('enum E { v1, v2 }');
     expect(e.values, hasLength(2));
@@ skipping 12 matching lines @@
     expect(executable.isAbstract, isTrue);
   }
 
   test_executable_concrete() {
     UnlinkedExecutable executable =
         serializeClassText('abstract class C { f() {} }').executables[0];
     expect(executable.isAbstract, isFalse);
   }
 
   test_executable_function() {
-    UnlinkedExecutable executable = serializeExecutableText('f() {}');
+    String text = '  f() {}';
+    UnlinkedExecutable executable = serializeExecutableText(text);
     expect(executable.kind, UnlinkedExecutableKind.functionOrMethod);
     expect(executable.hasImplicitReturnType, isTrue);
     checkDynamicTypeRef(executable.returnType);
     expect(executable.isExternal, isFalse);
+    expect(executable.nameOffset, text.indexOf('f'));
     expect(unlinkedUnits[0].publicNamespace.names, hasLength(1));
     expect(unlinkedUnits[0].publicNamespace.names[0].kind,
         PrelinkedReferenceKind.other);
     expect(unlinkedUnits[0].publicNamespace.names[0].name, 'f');
     expect(unlinkedUnits[0].publicNamespace.names[0].numTypeParameters, 0);
   }
 
   test_executable_function_explicit_return() {
     UnlinkedExecutable executable =
         serializeExecutableText('dynamic f() => null;');
     expect(executable.hasImplicitReturnType, isFalse);
     checkDynamicTypeRef(executable.returnType);
   }
 
   test_executable_function_external() {
     UnlinkedExecutable executable = serializeExecutableText('external f();');
     expect(executable.isExternal, isTrue);
   }
 
   test_executable_function_private() {
     serializeExecutableText('_f() {}', '_f');
     expect(unlinkedUnits[0].publicNamespace.names, isEmpty);
   }
 
   test_executable_getter() {
-    UnlinkedExecutable executable = serializeExecutableText('int get f => 1;');
+    String text = 'int get f => 1;';
+    UnlinkedExecutable executable = serializeExecutableText(text);
     expect(executable.kind, UnlinkedExecutableKind.getter);
     expect(executable.hasImplicitReturnType, isFalse);
     expect(executable.isExternal, isFalse);
+    expect(executable.nameOffset, text.indexOf('f'));
     expect(findVariable('f'), isNull);
     expect(findExecutable('f='), isNull);
     expect(unlinkedUnits[0].publicNamespace.names, hasLength(1));
     expect(unlinkedUnits[0].publicNamespace.names[0].kind,
         PrelinkedReferenceKind.other);
     expect(unlinkedUnits[0].publicNamespace.names[0].name, 'f');
   }
 
   test_executable_getter_external() {
     UnlinkedExecutable executable =
@@ skipping 245 matching lines @@
     UnlinkedExecutable executable = serializeExecutableText('f([x]) {}');
     expect(executable.parameters[0].kind, UnlinkedParamKind.positional);
   }
 
   test_executable_param_kind_required() {
     UnlinkedExecutable executable = serializeExecutableText('f(x) {}');
     expect(executable.parameters[0].kind, UnlinkedParamKind.required);
   }
 
   test_executable_param_name() {
-    UnlinkedExecutable executable = serializeExecutableText('f(x) {}');
+    String text = 'f(x) {}';
+    UnlinkedExecutable executable = serializeExecutableText(text);
     expect(executable.parameters, hasLength(1));
     expect(executable.parameters[0].name, 'x');
+    expect(executable.parameters[0].nameOffset, text.indexOf('x'));
   }
 
   test_executable_param_no_flags() {
     UnlinkedExecutable executable = serializeExecutableText('f(x) {}');
     expect(executable.parameters[0].isFunctionTyped, isFalse);
     expect(executable.parameters[0].isInitializingFormal, isFalse);
   }
 
   test_executable_param_non_function_typed() {
     UnlinkedExecutable executable = serializeExecutableText('f(g) {}');
@@ skipping 35 matching lines @@
     checkDynamicTypeRef(executable.returnType);
     expect(executable.hasImplicitReturnType, isTrue);
   }
 
   test_executable_return_type_void() {
     UnlinkedExecutable executable = serializeExecutableText('void f() {}');
     expect(executable.returnType, isNull);
   }
 
   test_executable_setter() {
-    UnlinkedExecutable executable =
-        serializeExecutableText('void set f(value) {}', 'f=');
+    String text = 'void set f(value) {}';
+    UnlinkedExecutable executable = serializeExecutableText(text, 'f=');
     expect(executable.kind, UnlinkedExecutableKind.setter);
     expect(executable.hasImplicitReturnType, isFalse);
     expect(executable.isExternal, isFalse);
+    expect(executable.nameOffset, text.indexOf('f'));
     expect(findVariable('f'), isNull);
     expect(findExecutable('f'), isNull);
     expect(unlinkedUnits[0].publicNamespace.names, hasLength(1));
     expect(unlinkedUnits[0].publicNamespace.names[0].kind,
         PrelinkedReferenceKind.other);
     expect(unlinkedUnits[0].publicNamespace.names[0].name, 'f=');
   }
 
   test_executable_setter_external() {
     UnlinkedExecutable executable =
@@ skipping 99 matching lines @@
     expect(unlinkedUnits[0].publicNamespace.exports, hasLength(1));
     expect(unlinkedUnits[0].publicNamespace.exports[0].combinators, isEmpty);
   }
 
   test_export_offset() {
     String libraryText = '    export "dart:async";';
     serializeLibraryText(libraryText);
     expect(unlinkedUnits[0].exports[0].uriOffset,
         libraryText.indexOf('"dart:async"'));
     expect(unlinkedUnits[0].exports[0].uriEnd, libraryText.indexOf(';'));
+    expect(unlinkedUnits[0].exports[0].offset, libraryText.indexOf('export'));
   }
 
   test_export_show_order() {
     serializeLibraryText('export "dart:async" show Future, Stream;');
     expect(unlinkedUnits[0].publicNamespace.exports, hasLength(1));
     expect(
         unlinkedUnits[0].publicNamespace.exports[0].combinators, hasLength(1));
     expect(unlinkedUnits[0].publicNamespace.exports[0].combinators[0].shows,
         hasLength(2));
     expect(unlinkedUnits[0].publicNamespace.exports[0].combinators[0].hides,
@@ skipping 140 matching lines @@
         libraryText.indexOf('"dart:async"'));
     expect(unlinkedUnits[0].imports[0].uriEnd, libraryText.indexOf('; Future'));
   }
 
   test_import_prefix_name() {
     String libraryText = 'import "dart:async" as a; a.Future x;';
     serializeLibraryText(libraryText);
     // Second import is the implicit import of dart:core
     expect(unlinkedUnits[0].imports, hasLength(2));
     checkPrefix(unlinkedUnits[0].imports[0].prefixReference, 'a');
+    expect(unlinkedUnits[0].imports[0].prefixOffset, libraryText.indexOf('a;'));
   }
 
   test_import_prefix_none() {
     serializeLibraryText('import "dart:async"; Future x;');
     // Second import is the implicit import of dart:core
     expect(unlinkedUnits[0].imports, hasLength(2));
     expect(unlinkedUnits[0].imports[0].prefixReference, 0);
   }
 
   test_import_prefix_not_in_public_namespace() {
@@ skipping 60 matching lines @@
 
   test_import_uri() {
     String uriString = '"dart:async"';
     String libraryText = 'import $uriString; Future x;';
     serializeLibraryText(libraryText);
     // Second import is the implicit import of dart:core
     expect(unlinkedUnits[0].imports, hasLength(2));
     expect(unlinkedUnits[0].imports[0].uri, 'dart:async');
   }
 
+  test_library_name_with_spaces() {
+    String text = 'library foo . bar ;';
+    serializeLibraryText(text);
+    expect(unlinkedUnits[0].libraryName, 'foo.bar');
+    expect(unlinkedUnits[0].libraryNameOffset, text.indexOf('foo . bar'));
+    expect(unlinkedUnits[0].libraryNameLength, 'foo . bar'.length);
+  }
+
   test_library_named() {
     String text = 'library foo.bar;';
     serializeLibraryText(text);
     expect(unlinkedUnits[0].libraryName, 'foo.bar');
+    expect(unlinkedUnits[0].libraryNameOffset, text.indexOf('foo.bar'));
+    expect(unlinkedUnits[0].libraryNameLength, 'foo.bar'.length);
   }
 
   test_library_unnamed() {
     serializeLibraryText('');
     expect(unlinkedUnits[0].libraryName, isEmpty);
+    expect(unlinkedUnits[0].libraryNameOffset, 0);
+    expect(unlinkedUnits[0].libraryNameLength, 0);
   }
 
   test_part_declaration() {
     addNamedSource('/a.dart', 'part of my.lib;');
     String text = 'library my.lib; part "a.dart"; // <-part';
     serializeLibraryText(text);
     expect(unlinkedUnits[0].publicNamespace.parts, hasLength(1));
     expect(unlinkedUnits[0].publicNamespace.parts[0], 'a.dart');
     expect(unlinkedUnits[0].parts, hasLength(1));
     expect(unlinkedUnits[0].parts[0].uriOffset, text.indexOf('"a.dart"'));
@@ skipping 219 matching lines @@
     checkTypeRef(typeRef, absUri('/a.dart'), 'a.dart', 'C',
         expectedTargetUnit: 2);
   }
 
   test_type_unresolved() {
     UnlinkedTypeRef typeRef = serializeTypeText('Foo', allowErrors: true);
     checkUnresolvedTypeRef(typeRef, null, 'Foo');
   }
 
   test_typedef_name() {
-    UnlinkedTypedef type = serializeTypedefText('typedef F();');
+    String text = 'typedef F();';
+    UnlinkedTypedef type = serializeTypedefText(text);
     expect(type.name, 'F');
+    expect(type.nameOffset, text.indexOf('F'));
     expect(unlinkedUnits[0].publicNamespace.names, hasLength(1));
     expect(unlinkedUnits[0].publicNamespace.names[0].kind,
         PrelinkedReferenceKind.typedef);
     expect(unlinkedUnits[0].publicNamespace.names[0].name, 'F');
     expect(unlinkedUnits[0].publicNamespace.names[0].numTypeParameters, 0);
   }
 
   test_typedef_param_none() {
     UnlinkedTypedef type = serializeTypedefText('typedef F();');
     expect(type.parameters, isEmpty);
@@ skipping 48 matching lines @@
   }
 
   test_typedef_type_param_order() {
     UnlinkedTypedef type = serializeTypedefText('typedef F<T, U>();');
     expect(type.typeParameters, hasLength(2));
     expect(type.typeParameters[0].name, 'T');
     expect(type.typeParameters[1].name, 'U');
   }
 
   test_variable() {
-    serializeVariableText('int i;', variableName: 'i');
+    String text = 'int i;';
+    UnlinkedVariable v = serializeVariableText(text, variableName: 'i');
+    expect(v.nameOffset, text.indexOf('i;'));
     expect(findExecutable('i'), isNull);
     expect(findExecutable('i='), isNull);
     expect(unlinkedUnits[0].publicNamespace.names, hasLength(2));
     expect(unlinkedUnits[0].publicNamespace.names[0].kind,
         PrelinkedReferenceKind.other);
     expect(unlinkedUnits[0].publicNamespace.names[0].name, 'i');
     expect(unlinkedUnits[0].publicNamespace.names[0].numTypeParameters, 0);
     expect(unlinkedUnits[0].publicNamespace.names[1].kind,
         PrelinkedReferenceKind.other);
     expect(unlinkedUnits[0].publicNamespace.names[1].name, 'i=');
@@ skipping 73 matching lines @@
     UnlinkedVariable variable =
         serializeVariableText('int i;', variableName: 'i');
     checkTypeRef(variable.type, 'dart:core', 'dart:core', 'int');
   }
 
   test_varible_private() {
     serializeVariableText('int _i;', variableName: '_i');
     expect(unlinkedUnits[0].publicNamespace.names, isEmpty);
   }
 }