Resynthesize codeOffset/codeLength properties.

pkg/analyzer/test/src/summary/summary_common.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_common;
 
 import 'package:analyzer/analyzer.dart';
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/src/dart/scanner/reader.dart';
@@ skipping 1058 matching lines @@
         numTypeParameters: 2);
   }
 
   test_class_alias_supertype() {
     UnlinkedClass cls =
         serializeClassText('class C = D with E; class D {} class E {}');
     checkTypeRef(cls.supertype, null, null, 'D');
     expect(cls.hasNoSupertype, isFalse);
   }
 
+  test_class_codeRange() {
+    UnlinkedClass cls = serializeClassText(' class C {}');
+    expect(cls.hasCodeRange, true);

[Paul Berry, 2016/03/04 16:36:07]

When would `hasCodeRange` be false?  We need tests for these cases.

[scheglov, 2016/03/04 17:15:19]

In production - never.
It tests - for every manually created element.

+    expect(cls.codeOffset, 1);
+    expect(cls.codeLength, 10);
+  }
+
   test_class_concrete() {
     UnlinkedClass cls = serializeClassText('class C {}');
     expect(cls.isAbstract, false);
     expect(unlinkedUnits[0].publicNamespace.names, hasLength(1));
     expect(unlinkedUnits[0].publicNamespace.names[0].kind,
         ReferenceKind.classOrEnum);
     expect(unlinkedUnits[0].publicNamespace.names[0].name, 'C');
     expect(unlinkedUnits[0].publicNamespace.names[0].numTypeParameters, 0);
   }
 
@@ skipping 2914 matching lines @@
   }
 
   test_enum() {
     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(e.hasCodeRange, true);
+    expect(e.codeOffset, 0);
+    expect(e.codeLength, 13);
     expect(unlinkedUnits[0].publicNamespace.names, hasLength(1));
     expect(unlinkedUnits[0].publicNamespace.names[0].kind,
         ReferenceKind.classOrEnum);
     expect(unlinkedUnits[0].publicNamespace.names[0].name, 'E');
     expect(unlinkedUnits[0].publicNamespace.names[0].numTypeParameters, 0);
   }
 
   test_enum_documented() {
     String text = '''
 // Extra comment so doc comment offset != 0
@@ skipping 380 matching lines @@
   }
 
   test_executable_member_function() {
     UnlinkedExecutable executable = findExecutable('f',
         executables: serializeClassText('class C { f() {} }').executables);
     expect(executable.kind, UnlinkedExecutableKind.functionOrMethod);
     expect(executable.returnType, isNull);
     expect(executable.isExternal, isFalse);
     expect(executable.visibleOffset, 0);
     expect(executable.visibleLength, 0);
+    expect(executable.hasCodeRange, true);
+    expect(executable.codeOffset, 10);
+    expect(executable.codeLength, 6);
   }
 
   test_executable_member_function_explicit_return() {
     UnlinkedExecutable executable = findExecutable('f',
         executables:
             serializeClassText('class C { dynamic f() => null; }').executables);
     expect(executable.returnType, isNotNull);
   }
 
   test_executable_member_function_external() {
     UnlinkedExecutable executable = findExecutable('f',
         executables:
             serializeClassText('class C { external f(); }').executables);
     expect(executable.isExternal, isTrue);
   }
 
   test_executable_member_getter() {
     UnlinkedClass cls = serializeClassText('class C { int get f => 1; }');
     UnlinkedExecutable executable =
         findExecutable('f', executables: cls.executables, failIfAbsent: true);
     expect(executable.kind, UnlinkedExecutableKind.getter);
     expect(executable.returnType, isNotNull);
     expect(executable.isExternal, isFalse);
+    expect(executable.hasCodeRange, true);
+    expect(executable.codeOffset, 10);
+    expect(executable.codeLength, 15);
     expect(findVariable('f', variables: cls.fields), isNull);
     expect(findExecutable('f=', executables: cls.executables), isNull);
   }
 
   test_executable_member_getter_external() {
     UnlinkedClass cls = serializeClassText('class C { external int get f; }');
     UnlinkedExecutable executable =
         findExecutable('f', executables: cls.executables, failIfAbsent: true);
     expect(executable.isExternal, isTrue);
   }
 
   test_executable_member_setter() {
     UnlinkedClass cls = serializeClassText('class C { void set f(value) {} }');
     UnlinkedExecutable executable =
         findExecutable('f=', executables: cls.executables, failIfAbsent: true);
     expect(executable.kind, UnlinkedExecutableKind.setter);
     expect(executable.returnType, isNotNull);
     expect(executable.isExternal, isFalse);
+    expect(executable.hasCodeRange, true);
+    expect(executable.codeOffset, 10);
+    expect(executable.codeLength, 20);
     expect(findVariable('f', variables: cls.fields), isNull);
     expect(findExecutable('f', executables: cls.executables), isNull);
   }
 
   test_executable_member_setter_external() {
     UnlinkedClass cls =
         serializeClassText('class C { external void set f(value); }');
     UnlinkedExecutable executable =
         findExecutable('f=', executables: cls.executables, failIfAbsent: true);
     expect(executable.isExternal, isTrue);
@@ skipping 101 matching lines @@
     expect(executable.typeParameters, isEmpty);
   }
 
   test_executable_operator_less_equal() {
     UnlinkedExecutable executable =
         serializeClassText('class C { bool operator<=(C other) => false; }')
             .executables[0];
     expect(executable.name, '<=');
   }
 
+  test_executable_param_codeRange() {
+    UnlinkedExecutable executable = serializeExecutableText('f(int x) {}');
+    UnlinkedParam parameter = executable.parameters[0];
+    expect(parameter.hasCodeRange, true);
+    expect(parameter.codeOffset, 2);
+    expect(parameter.codeLength, 5);
+  }
+
   test_executable_param_function_typed() {
     if (!checkAstDerivedData) {
       // TODO(paulberry): this test fails when building the summary from the
       // element model because the elment model doesn't record whether a
       // function-typed parameter's return type is implicit.
       return;
     }
     UnlinkedExecutable executable = serializeExecutableText('f(g()) {}');
     expect(executable.parameters[0].isFunctionTyped, isTrue);
     expect(executable.parameters[0].type, isNull);
@@ skipping 2202 matching lines @@
         allowTypeParameters: true, numTypeParameters: 2);
     expect(typeRef.typeArguments, hasLength(2));
     checkTypeRef(typeRef.typeArguments[0], 'dart:core', 'dart:core', 'int');
     checkTypeRef(typeRef.typeArguments[1], 'dart:core', 'dart:core', 'Object');
   }
 
   test_type_dynamic() {
     checkDynamicTypeRef(serializeTypeText('dynamic'));
   }
 
+  test_type_param_codeRange() {
+    UnlinkedClass cls =
+        serializeClassText('class A {} class C<T extends A> {}');
+    var e = cls.typeParameters[0];
+    expect(e.hasCodeRange, true);
+    expect(e.codeOffset, 19);
+    expect(e.codeLength, 11);
+  }
+
   test_type_param_not_shadowed_by_constructor() {
     UnlinkedClass cls =
         serializeClassText('class C<D> { D x; C.D(); } class D {}');
     checkParamTypeRef(cls.fields[0].type, 1);
   }
 
   test_type_param_not_shadowed_by_field_in_extends() {
     UnlinkedClass cls =
         serializeClassText('class C<T> extends D<T> { T x; } class D<T> {}');
     checkParamTypeRef(cls.supertype.typeArguments[0], 1);
@@ skipping 238 matching lines @@
     // from them.
     checkTypeRef(typeRef, absUri('/a.dart'), 'a.dart', 'C',
         expectedTargetUnit: 2);
   }
 
   test_type_unresolved() {
     EntityRef typeRef = serializeTypeText('Foo', allowErrors: true);
     checkUnresolvedTypeRef(typeRef, null, 'Foo');
   }
 
+  test_typedef_codeRange() {
+    UnlinkedTypedef type = serializeTypedefText('typedef F();');
+    expect(type.hasCodeRange, true);
+    expect(type.codeOffset, 0);
+    expect(type.codeLength, 12);
+  }
+
   test_typedef_documented() {
     String text = '''
 // Extra comment so doc comment offset != 0
 /**
  * Docs
  */
 typedef F();''';
     UnlinkedTypedef typedef = serializeTypedefText(text);
     expect(typedef.documentationComment, isNotNull);
     checkDocumentationComment(typedef.documentationComment, text);
@@ skipping 64 matching lines @@
     expect(type.typeParameters, isEmpty);
   }
 
   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_unit_codeRange() {
+    serializeLibraryText('  int a = 1;  ');
+    UnlinkedUnit unit = unlinkedUnits[0];
+    expect(unit.hasCodeRange, true);
+    expect(unit.codeOffset, 0);
+    expect(unit.codeLength, 14);
+  }
+
   test_unresolved_reference_in_multiple_parts() {
     addNamedSource('/a.dart', 'part of foo; int x; Unresolved y;');
     serializeLibraryText('library foo; part "a.dart"; Unresolved z;',
         allowErrors: true);
     // The unresolved types in the defining compilation unit and the part
     // should both work correctly even though they use different reference
     // indices.
     checkUnresolvedTypeRef(
         unlinkedUnits[0].variables[0].type, null, 'Unresolved');
     checkUnresolvedTypeRef(
@@ skipping 21 matching lines @@
     expect(unlinkedUnits[0].publicNamespace.names[0].kind,
         ReferenceKind.topLevelPropertyAccessor);
     expect(unlinkedUnits[0].publicNamespace.names[0].name, 'i');
     expect(unlinkedUnits[0].publicNamespace.names[0].numTypeParameters, 0);
     expect(unlinkedUnits[0].publicNamespace.names[1].kind,
         ReferenceKind.topLevelPropertyAccessor);
     expect(unlinkedUnits[0].publicNamespace.names[1].name, 'i=');
     expect(unlinkedUnits[0].publicNamespace.names[1].numTypeParameters, 0);
   }
 
+  test_variable_codeRange() {
+    serializeLibraryText(' int a = 1, b = 22;');
+    List<UnlinkedVariable> variables = unlinkedUnits[0].variables;
+    {
+      UnlinkedVariable variable = variables[0];
+      expect(variable.hasCodeRange, true);
+      expect(variable.codeOffset, 1);
+      expect(variable.codeLength, 18);
+    }
+    {
+      UnlinkedVariable variable = variables[1];
+      expect(variable.hasCodeRange, true);
+      expect(variable.codeOffset, 1);
+      expect(variable.codeLength, 18);
+    }
+  }
+
   test_variable_const() {
     UnlinkedVariable variable =
         serializeVariableText('const int i = 0;', variableName: 'i');
     expect(variable.isConst, isTrue);
   }
 
   test_variable_documented() {
     String text = '''
 // Extra comment so doc comment offset != 0
 /**
@@ skipping 295 matching lines @@
 class _PrefixExpectation {
   final ReferenceKind kind;
   final String name;
   final String absoluteUri;
   final String relativeUri;
   final int numTypeParameters;
 
   _PrefixExpectation(this.kind, this.name,
       {this.absoluteUri, this.relativeUri, this.numTypeParameters: 0});
 }