Revert "Remove 'Element.docRange'."

pkg/analyzer/test/generated/all_the_rest_test.dart

 // Copyright (c) 2014, 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.generated.all_the_rest_test;
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
@@ skipping 716 matching lines @@
     expect(types, hasLength(1));
     ClassElement type = types[0];
     expect(type, isNotNull);
     expect(type.name, className);
     List<TypeParameterElement> typeParameters = type.typeParameters;
     expect(typeParameters, hasLength(0));
     expect(type.isAbstract, isFalse);
     expect(type.isMixinApplication, isFalse);
     expect(type.isSynthetic, isFalse);
     expect(type.documentationComment, '/// aaa');
+    _assertHasDocRange(type, 50, 7);
     _assertHasCodeRange(type, 50, 31);
   }
 
   void test_visitClassDeclaration_parameterized() {
     ElementHolder holder = new ElementHolder();
     ElementBuilder builder = _makeBuilder(holder);
     String className = "C";
     String firstVariableName = "E";
     String secondVariableName = "F";
     ClassDeclaration classDeclaration = AstFactory.classDeclaration(
@@ skipping 246 matching lines @@
             [TokenFactory.tokenFromString('/// aaa')..offset = 50], []);
     constructorDeclaration.endToken.offset = 80;
     constructorDeclaration.accept(builder);
 
     List<ConstructorElement> constructors = holder.constructors;
     expect(constructors, hasLength(1));
     ConstructorElement constructor = constructors[0];
     expect(constructor, isNotNull);
     _assertHasCodeRange(constructor, 50, 31);
     expect(constructor.documentationComment, '/// aaa');
+    _assertHasDocRange(constructor, 50, 7);
     expect(constructor.isExternal, isFalse);
     expect(constructor.isFactory, isFalse);
     expect(constructor.name, "");
     expect(constructor.functions, hasLength(0));
     expect(constructor.labels, hasLength(0));
     expect(constructor.localVariables, hasLength(0));
     expect(constructor.parameters, hasLength(0));
   }
 
   void test_visitConstructorDeclaration_named() {
@@ skipping 182 matching lines @@
     enumDeclaration.documentationComment = AstFactory.documentationComment(
         [TokenFactory.tokenFromString('/// aaa')..offset = 50], []);
     enumDeclaration.endToken.offset = 80;
     enumDeclaration.accept(builder);
     List<ClassElement> enums = holder.enums;
     expect(enums, hasLength(1));
     ClassElement enumElement = enums[0];
     expect(enumElement, isNotNull);
     _assertHasCodeRange(enumElement, 50, 31);
     expect(enumElement.documentationComment, '/// aaa');
+    _assertHasDocRange(enumElement, 50, 7);
     expect(enumElement.name, enumName);
   }
 
   void test_visitFieldDeclaration() {
     ElementHolder holder = new ElementHolder();
     ElementBuilder builder = _makeBuilder(holder);
     String firstFieldName = "x";
     String secondFieldName = "y";
     FieldDeclaration fieldDeclaration =
         AstFactory.fieldDeclaration2(false, null, [
       AstFactory.variableDeclaration(firstFieldName),
       AstFactory.variableDeclaration(secondFieldName)
     ]);
     fieldDeclaration.documentationComment = AstFactory.documentationComment(
         [TokenFactory.tokenFromString('/// aaa')..offset = 50], []);
     fieldDeclaration.endToken.offset = 110;
     fieldDeclaration.accept(builder);
 
     List<FieldElement> fields = holder.fields;
     expect(fields, hasLength(2));
 
     FieldElement firstField = fields[0];
     expect(firstField, isNotNull);
     _assertHasCodeRange(firstField, 50, 61);
     expect(firstField.documentationComment, '/// aaa');
+    _assertHasDocRange(firstField, 50, 7);
     expect(firstField.name, firstFieldName);
     expect(firstField.initializer, isNull);
     expect(firstField.isConst, isFalse);
     expect(firstField.isFinal, isFalse);
     expect(firstField.isSynthetic, isFalse);
 
     FieldElement secondField = fields[1];
     expect(secondField, isNotNull);
     _assertHasCodeRange(secondField, 50, 61);
     expect(secondField.documentationComment, '/// aaa');
+    _assertHasDocRange(secondField, 50, 7);
     expect(secondField.name, secondFieldName);
     expect(secondField.initializer, isNull);
     expect(secondField.isConst, isFalse);
     expect(secondField.isFinal, isFalse);
     expect(secondField.isSynthetic, isFalse);
   }
 
   void test_visitFieldFormalParameter() {
     ElementHolder holder = new ElementHolder();
     ElementBuilder builder = _makeBuilder(holder);
@@ skipping 100 matching lines @@
         [TokenFactory.tokenFromString('/// aaa')..offset = 50], []);
     declaration.endToken.offset = 80;
     declaration.accept(builder);
 
     List<PropertyAccessorElement> accessors = holder.accessors;
     expect(accessors, hasLength(1));
     PropertyAccessorElement accessor = accessors[0];
     expect(accessor, isNotNull);
     _assertHasCodeRange(accessor, 50, 31);
     expect(accessor.documentationComment, '/// aaa');
+    _assertHasDocRange(accessor, 50, 7);
     expect(accessor.name, functionName);
     expect(declaration.element, same(accessor));
     expect(declaration.functionExpression.element, same(accessor));
     expect(accessor.hasImplicitReturnType, isTrue);
     expect(accessor.isGetter, isTrue);
     expect(accessor.isExternal, isFalse);
     expect(accessor.isSetter, isFalse);
     expect(accessor.isSynthetic, isFalse);
     expect(accessor.typeParameters, hasLength(0));
     PropertyInducingElement variable = accessor.variable;
@@ skipping 17 matching lines @@
         [TokenFactory.tokenFromString('/// aaa')..offset = 50], []);
     declaration.endToken.offset = 80;
     declaration.accept(builder);
 
     List<FunctionElement> functions = holder.functions;
     expect(functions, hasLength(1));
     FunctionElement function = functions[0];
     expect(function, isNotNull);
     _assertHasCodeRange(function, 50, 31);
     expect(function.documentationComment, '/// aaa');
+    _assertHasDocRange(function, 50, 7);
     expect(function.hasImplicitReturnType, isFalse);
     expect(function.name, functionName);
     expect(declaration.element, same(function));
     expect(declaration.functionExpression.element, same(function));
     expect(function.isExternal, isFalse);
     expect(function.isSynthetic, isFalse);
     expect(function.typeParameters, hasLength(0));
   }
 
   void test_visitFunctionDeclaration_setter() {
@@ skipping 11 matching lines @@
         [TokenFactory.tokenFromString('/// aaa')..offset = 50], []);
     declaration.endToken.offset = 80;
     declaration.accept(builder);
 
     List<PropertyAccessorElement> accessors = holder.accessors;
     expect(accessors, hasLength(1));
     PropertyAccessorElement accessor = accessors[0];
     expect(accessor, isNotNull);
     _assertHasCodeRange(accessor, 50, 31);
     expect(accessor.documentationComment, '/// aaa');
+    _assertHasDocRange(accessor, 50, 7);
     expect(accessor.hasImplicitReturnType, isTrue);
     expect(accessor.name, "$functionName=");
     expect(declaration.element, same(accessor));
     expect(declaration.functionExpression.element, same(accessor));
     expect(accessor.isGetter, isFalse);
     expect(accessor.isExternal, isFalse);
     expect(accessor.isSetter, isTrue);
     expect(accessor.isSynthetic, isFalse);
     expect(accessor.typeParameters, hasLength(0));
     PropertyInducingElement variable = accessor.variable;
@@ skipping 60 matching lines @@
         [TokenFactory.tokenFromString('/// aaa')..offset = 50], []);
     aliasNode.endToken.offset = 80;
     aliasNode.accept(builder);
 
     List<FunctionTypeAliasElement> aliases = holder.typeAliases;
     expect(aliases, hasLength(1));
     FunctionTypeAliasElement alias = aliases[0];
     expect(alias, isNotNull);
     _assertHasCodeRange(alias, 50, 31);
     expect(alias.documentationComment, '/// aaa');
+    _assertHasDocRange(alias, 50, 7);
     expect(alias.name, aliasName);
     expect(alias.parameters, hasLength(0));
     List<TypeParameterElement> typeParameters = alias.typeParameters;
     expect(typeParameters, hasLength(1));
     TypeParameterElement typeParameter = typeParameters[0];
     expect(typeParameter, isNotNull);
     expect(typeParameter.name, parameterName);
   }
 
   void test_visitFunctionTypedFormalParameter() {
@@ skipping 180 matching lines @@
     expect(fields, hasLength(1));
     FieldElement field = fields[0];
     expect(field, isNotNull);
     expect(field.name, methodName);
     expect(field.isSynthetic, isTrue);
     expect(field.setter, isNull);
     PropertyAccessorElement getter = field.getter;
     expect(getter, isNotNull);
     _assertHasCodeRange(getter, 50, 31);
     expect(getter.documentationComment, '/// aaa');
+    _assertHasDocRange(getter, 50, 7);
     expect(getter.hasImplicitReturnType, isTrue);
     expect(getter.isAbstract, isFalse);
     expect(getter.isExternal, isFalse);
     expect(getter.isGetter, isTrue);
     expect(getter.isSynthetic, isFalse);
     expect(getter.name, methodName);
     expect(getter.variable, field);
     expect(getter.functions, hasLength(0));
     expect(getter.labels, hasLength(0));
     expect(getter.localVariables, hasLength(0));
@@ skipping 92 matching lines @@
         [TokenFactory.tokenFromString('/// aaa')..offset = 50], []);
     methodDeclaration.endToken.offset = 80;
     methodDeclaration.accept(builder);
 
     List<MethodElement> methods = holder.methods;
     expect(methods, hasLength(1));
     MethodElement method = methods[0];
     expect(method, isNotNull);
     _assertHasCodeRange(method, 50, 31);
     expect(method.documentationComment, '/// aaa');
+    _assertHasDocRange(method, 50, 7);
     expect(method.hasImplicitReturnType, isFalse);
     expect(method.name, methodName);
     expect(method.functions, hasLength(0));
     expect(method.labels, hasLength(0));
     expect(method.localVariables, hasLength(0));
     expect(method.parameters, hasLength(0));
     expect(method.typeParameters, hasLength(0));
     expect(method.isAbstract, isFalse);
     expect(method.isExternal, isFalse);
     expect(method.isStatic, isFalse);
@@ skipping 56 matching lines @@
     FieldElement field = fields[0];
     expect(field, isNotNull);
     expect(field.name, methodName);
     expect(field.isSynthetic, isTrue);
     expect(field.getter, isNull);
 
     PropertyAccessorElement setter = field.setter;
     expect(setter, isNotNull);
     _assertHasCodeRange(setter, 50, 31);
     expect(setter.documentationComment, '/// aaa');
+    _assertHasDocRange(setter, 50, 7);
     expect(setter.hasImplicitReturnType, isTrue);
     expect(setter.isAbstract, isFalse);
     expect(setter.isExternal, isFalse);
     expect(setter.isSetter, isTrue);
     expect(setter.isSynthetic, isFalse);
     expect(setter.name, "$methodName=");
     expect(setter.displayName, methodName);
     expect(setter.variable, field);
     expect(setter.functions, hasLength(0));
     expect(setter.labels, hasLength(0));
@@ skipping 568 matching lines @@
     expect(variable.hasImplicitType, isTrue);
     expect(variable.initializer, isNull);
     expect(variable.name, variableName);
     expect(variable.isConst, isFalse);
     expect(variable.isFinal, isFalse);
     expect(variable.isSynthetic, isFalse);
     expect(variable.getter, isNotNull);
     expect(variable.setter, isNotNull);
   }
 
-  void test_visitVariableDeclaration_top() {
+  void test_visitVariableDeclaration_top_const_hasInitializer() {
+    // const v = 42;
+    ElementHolder holder = new ElementHolder();
+    ElementBuilder builder = _makeBuilder(holder);
+    String variableName = "v";
+    VariableDeclaration variableDeclaration =
+        AstFactory.variableDeclaration2(variableName, AstFactory.integer(42));
+    AstFactory.variableDeclarationList2(Keyword.CONST, [variableDeclaration]);
+    variableDeclaration.accept(builder);
+
+    List<TopLevelVariableElement> variables = holder.topLevelVariables;
+    expect(variables, hasLength(1));
+    TopLevelVariableElement variable = variables[0];
+    expect(variable, new isInstanceOf<ConstTopLevelVariableElementImpl>());
+    expect(variable.initializer, isNotNull);
+    expect(variable.initializer.type, isNotNull);
+    expect(variable.initializer.hasImplicitReturnType, isTrue);
+    expect(variable.name, variableName);
+    expect(variable.hasImplicitType, isTrue);
+    expect(variable.isConst, isTrue);
+    expect(variable.isFinal, isFalse);
+    expect(variable.isSynthetic, isFalse);
+    expect(variable.getter, isNotNull);
+    expect(variable.setter, isNull);
+  }
+
+  void test_visitVariableDeclaration_top_docRange() {
     // final a, b;
     ElementHolder holder = new ElementHolder();
     ElementBuilder builder = _makeBuilder(holder);
     VariableDeclaration variableDeclaration1 =
         AstFactory.variableDeclaration('a');
     VariableDeclaration variableDeclaration2 =
         AstFactory.variableDeclaration('b');
     TopLevelVariableDeclaration topLevelVariableDeclaration = AstFactory
         .topLevelVariableDeclaration(
             Keyword.FINAL, null, [variableDeclaration1, variableDeclaration2]);
     topLevelVariableDeclaration.documentationComment = AstFactory
         .documentationComment(
             [TokenFactory.tokenFromString('/// aaa')..offset = 50], []);
 
     topLevelVariableDeclaration.accept(builder);
     List<TopLevelVariableElement> variables = holder.topLevelVariables;
     expect(variables, hasLength(2));
 
     TopLevelVariableElement variable1 = variables[0];
     expect(variable1, isNotNull);
     expect(variable1.documentationComment, '/// aaa');
+    _assertHasDocRange(variable1, 50, 7);
 
     TopLevelVariableElement variable2 = variables[1];
     expect(variable2, isNotNull);
     expect(variable2.documentationComment, '/// aaa');
-  }
-
-  void test_visitVariableDeclaration_top_const_hasInitializer() {
-    // const v = 42;
-    ElementHolder holder = new ElementHolder();
-    ElementBuilder builder = _makeBuilder(holder);
-    String variableName = "v";
-    VariableDeclaration variableDeclaration =
-        AstFactory.variableDeclaration2(variableName, AstFactory.integer(42));
-    AstFactory.variableDeclarationList2(Keyword.CONST, [variableDeclaration]);
-    variableDeclaration.accept(builder);
-
-    List<TopLevelVariableElement> variables = holder.topLevelVariables;
-    expect(variables, hasLength(1));
-    TopLevelVariableElement variable = variables[0];
-    expect(variable, new isInstanceOf<ConstTopLevelVariableElementImpl>());
-    expect(variable.initializer, isNotNull);
-    expect(variable.initializer.type, isNotNull);
-    expect(variable.initializer.hasImplicitReturnType, isTrue);
-    expect(variable.name, variableName);
-    expect(variable.hasImplicitType, isTrue);
-    expect(variable.isConst, isTrue);
-    expect(variable.isFinal, isFalse);
-    expect(variable.isSynthetic, isFalse);
-    expect(variable.getter, isNotNull);
-    expect(variable.setter, isNull);
+    _assertHasDocRange(variable2, 50, 7);
   }
 
   void test_visitVariableDeclaration_top_final() {
     // final v;
     ElementHolder holder = new ElementHolder();
     ElementBuilder builder = _makeBuilder(holder);
     String variableName = "v";
     VariableDeclaration variableDeclaration =
         AstFactory.variableDeclaration2(variableName, null);
     AstFactory.variableDeclarationList2(Keyword.FINAL, [variableDeclaration]);
@@ skipping 11 matching lines @@
     expect(variable.getter, isNotNull);
     expect(variable.setter, isNull);
   }
 
   void _assertHasCodeRange(Element element, int offset, int length) {
     ElementImpl elementImpl = element;
     expect(elementImpl.codeOffset, offset);
     expect(elementImpl.codeLength, length);
   }
 
+  void _assertHasDocRange(
+      Element element, int expectedOffset, int expectedLength) {
+    // Cast to dynamic here to avoid a hint about @deprecated docRange.
+    SourceRange docRange = (element as dynamic).docRange;
+    expect(docRange, isNotNull);
+    expect(docRange.offset, expectedOffset);
+    expect(docRange.length, expectedLength);
+  }
+
   void _assertVisibleRange(LocalElement element, int offset, int end) {
     SourceRange visibleRange = element.visibleRange;
     expect(visibleRange.offset, offset);
     expect(visibleRange.end, end);
   }
 
   ElementBuilder _makeBuilder(ElementHolder holder) =>
       new ElementBuilder(holder, new CompilationUnitElementImpl('test.dart'));
 
   void _setBlockBodySourceRange(BlockFunctionBody body, int offset, int end) {
@@ skipping 533 matching lines @@
     expect(field.isSynthetic, isTrue);
     expect((field as FieldElementImpl).evaluationResult, isNotNull);
     _assertGetter(field);
 
     FieldElement constant = fields[2];
     expect(constant, isNotNull);
     expect(constant.name, firstName);
     expect(constant.isStatic, isTrue);
     expect((constant as FieldElementImpl).evaluationResult, isNotNull);
     expect(constant.documentationComment, '/// aaa');
+    expect(constant.docRange.offset, 50);
+    expect(constant.docRange.length, 7);
     _assertGetter(constant);
   }
 
   void _assertGetter(FieldElement field) {
     PropertyAccessorElement getter = field.getter;
     expect(getter, isNotNull);
     expect(getter.variable, same(field));
     expect(getter.type, isNotNull);
   }
 
@@ skipping 988 matching lines @@
     if (1 < 2) {
       break x;
     }
     return;
   }
 }
 ''');
     _assertNthStatementDoesNotExit(source, 0);
   }
 
-  void test_whileStatement_breakWithLabel_afterExiting() {
+  void test_whileStatement_breakWithLabel_afterExting() {
     Source source = addSource(r'''
 void f() {
   x: while (true) {
     return;
     if (1 < 2) {
       break x;
     }
   }
 }
 ''');
@@ skipping 393 matching lines @@
     expect(UriKind.fromEncoding(0x70), same(UriKind.PACKAGE_URI));
     expect(UriKind.fromEncoding(0x58), same(null));
   }
 
   void test_getEncoding() {
     expect(UriKind.DART_URI.encoding, 0x64);
     expect(UriKind.FILE_URI.encoding, 0x66);
     expect(UriKind.PACKAGE_URI.encoding, 0x70);
   }
 }