Add codeOffset/codeLength properties to ElementImpl.

pkg/analyzer/lib/src/dart/element/builder.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.src.dart.element.builder;
 
 import 'dart:collection';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart';
@@ skipping 364 matching lines @@
       if (node.exceptionType == null) {
         exception.hasImplicitType = true;
       }
       _currentHolder.addLocalVariable(exception);
       exceptionParameter.staticElement = exception;
       // stack trace
       SimpleIdentifier stackTraceParameter = node.stackTraceParameter;
       if (stackTraceParameter != null) {
         LocalVariableElementImpl stackTrace =
             new LocalVariableElementImpl.forNode(stackTraceParameter);
+        _setCodeRange(stackTrace, stackTraceParameter);
         _currentHolder.addLocalVariable(stackTrace);
         stackTraceParameter.staticElement = stackTrace;
       }
     }
     return super.visitCatchClause(node);
   }
 
   @override
   Object visitClassDeclaration(ClassDeclaration node) {
     ElementHolder holder = new ElementHolder();
@@ skipping 11 matching lines @@
       _buildFieldMap(holder.fieldsWithoutFlushing);
       int count = nonFields.length;
       for (int i = 0; i < count; i++) {
         nonFields[i].accept(this);
       }
     } finally {
       _currentHolder = previousHolder;
     }
     SimpleIdentifier className = node.name;
     ClassElementImpl element = new ClassElementImpl.forNode(className);
+    _setCodeRange(element, node);
     element.metadata = _createElementAnnotations(node.metadata);
     List<TypeParameterElement> typeParameters = holder.typeParameters;
     List<DartType> typeArguments = _createTypeParameterTypes(typeParameters);
     InterfaceTypeImpl interfaceType = new InterfaceTypeImpl(element);
     interfaceType.typeArguments = typeArguments;
     element.type = interfaceType;
     element.typeParameters = typeParameters;
     setElementDocumentationComment(element, node);
     element.abstract = node.isAbstract;
     element.accessors = holder.accessors;
@@ skipping 29 matching lines @@
     ClassElement classElement = node.element;
     _buildFieldMap(classElement.fields);
   }
 
   @override
   Object visitClassTypeAlias(ClassTypeAlias node) {
     ElementHolder holder = new ElementHolder();
     _visitChildren(holder, node);
     SimpleIdentifier className = node.name;
     ClassElementImpl element = new ClassElementImpl.forNode(className);
+    _setCodeRange(element, node);
     element.metadata = _createElementAnnotations(node.metadata);
     element.abstract = node.abstractKeyword != null;
     element.mixinApplication = true;
     List<TypeParameterElement> typeParameters = holder.typeParameters;
     element.typeParameters = typeParameters;
     List<DartType> typeArguments = _createTypeParameterTypes(typeParameters);
     InterfaceTypeImpl interfaceType = new InterfaceTypeImpl(element);
     interfaceType.typeArguments = typeArguments;
     element.type = interfaceType;
     setElementDocumentationComment(element, node);
     _currentHolder.addType(element);
     className.staticElement = element;
     holder.validate();
     return null;
   }
 
   @override
+  Object visitCompilationUnit(CompilationUnit node) {
+    if (compilationUnitElement is ElementImpl) {
+      _setCodeRange(compilationUnitElement as ElementImpl, node);
+    }
+    return super.visitCompilationUnit(node);
+  }
+
+  @override
   Object visitConstructorDeclaration(ConstructorDeclaration node) {
     ElementHolder holder = new ElementHolder();
     bool wasInFunction = _inFunction;
     _inFunction = true;
     try {
       _visitChildren(holder, node);
     } finally {
       _inFunction = wasInFunction;
     }
     FunctionBody body = node.body;
     SimpleIdentifier constructorName = node.name;
     ConstructorElementImpl element =
         new ConstructorElementImpl.forNode(constructorName);
+    _setCodeRange(element, node);
     element.metadata = _createElementAnnotations(node.metadata);
     setElementDocumentationComment(element, node);
     if (node.externalKeyword != null) {
       element.external = true;
     }
     if (node.factoryKeyword != null) {
       element.factory = true;
     }
     element.functions = holder.functions;
     element.labels = holder.labels;
@@ skipping 21 matching lines @@
     }
     holder.validate();
     return null;
   }
 
   @override
   Object visitDeclaredIdentifier(DeclaredIdentifier node) {
     SimpleIdentifier variableName = node.identifier;
     LocalVariableElementImpl element =
         new LocalVariableElementImpl.forNode(variableName);
+    _setCodeRange(element, node);
     element.metadata = _createElementAnnotations(node.metadata);
     ForEachStatement statement = node.parent as ForEachStatement;
     int declarationEnd = node.offset + node.length;
     int statementEnd = statement.offset + statement.length;
     element.setVisibleRange(declarationEnd, statementEnd - declarationEnd - 1);
     element.const3 = node.isConst;
     element.final2 = node.isFinal;
     if (node.type == null) {
       element.hasImplicitType = true;
     }
@@ skipping 12 matching lines @@
       parameter =
           new DefaultFieldFormalParameterElementImpl.forNode(parameterName);
       FieldElement field =
           _fieldMap == null ? null : _fieldMap[parameterName.name];
       if (field != null) {
         (parameter as DefaultFieldFormalParameterElementImpl).field = field;
       }
     } else {
       parameter = new DefaultParameterElementImpl.forNode(parameterName);
     }
+    _setCodeRange(parameter, node);
     parameter.const3 = node.isConst;
     parameter.final2 = node.isFinal;
     parameter.parameterKind = node.kind;
     // set initializer, default value range
     Expression defaultValue = node.defaultValue;
     if (defaultValue != null) {
       _visit(holder, defaultValue);
       FunctionElementImpl initializer =
           new FunctionElementImpl.forOffset(defaultValue.beginToken.offset);
       initializer.hasImplicitReturnType = true;
@@ skipping 16 matching lines @@
     parameterName.staticElement = parameter;
     normalParameter.accept(this);
     holder.validate();
     return null;
   }
 
   @override
   Object visitEnumDeclaration(EnumDeclaration node) {
     SimpleIdentifier enumName = node.name;
     ClassElementImpl enumElement = new ClassElementImpl.forNode(enumName);
+    _setCodeRange(enumElement, node);
     enumElement.metadata = _createElementAnnotations(node.metadata);
     enumElement.enum2 = true;
     setElementDocumentationComment(enumElement, node);
     InterfaceTypeImpl enumType = new InterfaceTypeImpl(enumElement);
     enumElement.type = enumType;
     // The equivalent code for enums in the spec shows a single constructor,
     // but that constructor is not callable (since it is a compile-time error
     // to subclass, mix-in, implement, or explicitly instantiate an enum).  So
     // we represent this as having no constructors.
     enumElement.constructors = ConstructorElement.EMPTY_LIST;
     _currentHolder.addEnum(enumElement);
     enumName.staticElement = enumElement;
     return super.visitEnumDeclaration(node);
   }
 
   @override
   Object visitExportDirective(ExportDirective node) {
     _createElementAnnotations(node.metadata);
     return super.visitExportDirective(node);
   }
 
   @override
   Object visitFieldFormalParameter(FieldFormalParameter node) {
     if (node.parent is! DefaultFormalParameter) {
       SimpleIdentifier parameterName = node.identifier;
       FieldElement field =
           _fieldMap == null ? null : _fieldMap[parameterName.name];
       FieldFormalParameterElementImpl parameter =
           new FieldFormalParameterElementImpl.forNode(parameterName);
+      _setCodeRange(parameter, node);
       parameter.const3 = node.isConst;
       parameter.final2 = node.isFinal;
       parameter.parameterKind = node.kind;
       if (field != null) {
         parameter.field = field;
       }
       _currentHolder.addParameter(parameter);
       parameterName.staticElement = parameter;
     }
     //
@@ skipping 21 matching lines @@
         _visitChildren(holder, node);
       } finally {
         _inFunction = wasInFunction;
       }
       FunctionBody body = expression.body;
       Token property = node.propertyKeyword;
       if (property == null || _inFunction) {
         SimpleIdentifier functionName = node.name;
         FunctionElementImpl element =
             new FunctionElementImpl.forNode(functionName);
+        _setCodeRange(element, node);
         element.metadata = _createElementAnnotations(node.metadata);
         setElementDocumentationComment(element, node);
         if (node.externalKeyword != null) {
           element.external = true;
         }
         element.functions = holder.functions;
         element.labels = holder.labels;
         element.localVariables = holder.localVariables;
         element.parameters = holder.parameters;
         element.typeParameters = holder.typeParameters;
@@ skipping 27 matching lines @@
             .getTopLevelVariable(propertyName) as TopLevelVariableElementImpl;
         if (variable == null) {
           variable = new TopLevelVariableElementImpl(node.name.name, -1);
           variable.final2 = true;
           variable.synthetic = true;
           _currentHolder.addTopLevelVariable(variable);
         }
         if (node.isGetter) {
           PropertyAccessorElementImpl getter =
               new PropertyAccessorElementImpl.forNode(propertyNameNode);
+          _setCodeRange(getter, node);
           getter.metadata = _createElementAnnotations(node.metadata);
           setElementDocumentationComment(getter, node);
           if (node.externalKeyword != null) {
             getter.external = true;
           }
           getter.functions = holder.functions;
           getter.labels = holder.labels;
           getter.localVariables = holder.localVariables;
           if (body.isAsynchronous) {
             getter.asynchronous = true;
           }
           if (body.isGenerator) {
             getter.generator = true;
           }
           getter.variable = variable;
           getter.getter = true;
           getter.static = true;
           variable.getter = getter;
           if (node.returnType == null) {
             getter.hasImplicitReturnType = true;
           }
           _currentHolder.addAccessor(getter);
           expression.element = getter;
           propertyNameNode.staticElement = getter;
         } else {
           PropertyAccessorElementImpl setter =
               new PropertyAccessorElementImpl.forNode(propertyNameNode);
+          _setCodeRange(setter, node);
           setter.metadata = _createElementAnnotations(node.metadata);
           setElementDocumentationComment(setter, node);
           if (node.externalKeyword != null) {
             setter.external = true;
           }
           setter.functions = holder.functions;
           setter.labels = holder.labels;
           setter.localVariables = holder.localVariables;
           setter.parameters = holder.parameters;
           if (body.isAsynchronous) {
@@ skipping 31 matching lines @@
     bool wasInFunction = _inFunction;
     _inFunction = true;
     try {
       _visitChildren(holder, node);
     } finally {
       _inFunction = wasInFunction;
     }
     FunctionBody body = node.body;
     FunctionElementImpl element =
         new FunctionElementImpl.forOffset(node.beginToken.offset);
+    _setCodeRange(element, node);
     element.functions = holder.functions;
     element.labels = holder.labels;
     element.localVariables = holder.localVariables;
     element.parameters = holder.parameters;
     element.typeParameters = holder.typeParameters;
     if (body.isAsynchronous) {
       element.asynchronous = true;
     }
     if (body.isGenerator) {
       element.generator = true;
@@ skipping 18 matching lines @@
 
   @override
   Object visitFunctionTypeAlias(FunctionTypeAlias node) {
     ElementHolder holder = new ElementHolder();
     _visitChildren(holder, node);
     SimpleIdentifier aliasName = node.name;
     List<ParameterElement> parameters = holder.parameters;
     List<TypeParameterElement> typeParameters = holder.typeParameters;
     FunctionTypeAliasElementImpl element =
         new FunctionTypeAliasElementImpl.forNode(aliasName);
+    _setCodeRange(element, node);
     element.metadata = _createElementAnnotations(node.metadata);
     setElementDocumentationComment(element, node);
     element.parameters = parameters;
     element.typeParameters = typeParameters;
     _createTypeParameterTypes(typeParameters);
     element.type = new FunctionTypeImpl.forTypedef(element);
     _currentHolder.addTypeAlias(element);
     aliasName.staticElement = element;
     holder.validate();
     return null;
   }
 
   @override
   Object visitFunctionTypedFormalParameter(FunctionTypedFormalParameter node) {
     if (node.parent is! DefaultFormalParameter) {
       SimpleIdentifier parameterName = node.identifier;
       ParameterElementImpl parameter =
           new ParameterElementImpl.forNode(parameterName);
+      _setCodeRange(parameter, node);
       parameter.parameterKind = node.kind;
       _setParameterVisibleRange(node, parameter);
       _currentHolder.addParameter(parameter);
       parameterName.staticElement = parameter;
     }
     //
     // The children of this parameter include any parameters defined on the type
     //of this parameter.
     //
     ElementHolder holder = new ElementHolder();
@@ skipping 12 matching lines @@
     return super.visitImportDirective(node);
   }
 
   @override
   Object visitLabeledStatement(LabeledStatement node) {
     bool onSwitchStatement = node.statement is SwitchStatement;
     for (Label label in node.labels) {
       SimpleIdentifier labelName = label.label;
       LabelElementImpl element =
           new LabelElementImpl.forNode(labelName, onSwitchStatement, false);
+      _setCodeRange(element, node);
       _currentHolder.addLabel(element);
       labelName.staticElement = element;
     }
     return super.visitLabeledStatement(node);
   }
 
   @override
   Object visitLibraryDirective(LibraryDirective node) {
     _createElementAnnotations(node.metadata);
     return super.visitLibraryDirective(node);
@@ skipping 15 matching lines @@
       FunctionBody body = node.body;
       if (property == null) {
         SimpleIdentifier methodName = node.name;
         String nameOfMethod = methodName.name;
         if (nameOfMethod == TokenType.MINUS.lexeme &&
             node.parameters.parameters.length == 0) {
           nameOfMethod = "unary-";
         }
         MethodElementImpl element =
             new MethodElementImpl(nameOfMethod, methodName.offset);
+        _setCodeRange(element, node);
         element.metadata = _createElementAnnotations(node.metadata);
         setElementDocumentationComment(element, node);
         element.abstract = node.isAbstract;
         if (node.externalKeyword != null) {
           element.external = true;
         }
         element.functions = holder.functions;
         element.labels = holder.labels;
         element.localVariables = holder.localVariables;
         element.parameters = holder.parameters;
@@ skipping 18 matching lines @@
         if (field == null) {
           field = new FieldElementImpl(node.name.name, -1);
           field.final2 = true;
           field.static = isStatic;
           field.synthetic = true;
           _currentHolder.addField(field);
         }
         if (node.isGetter) {
           PropertyAccessorElementImpl getter =
               new PropertyAccessorElementImpl.forNode(propertyNameNode);
+          _setCodeRange(getter, node);
           getter.metadata = _createElementAnnotations(node.metadata);
           setElementDocumentationComment(getter, node);
           if (node.externalKeyword != null) {
             getter.external = true;
           }
           getter.functions = holder.functions;
           getter.labels = holder.labels;
           getter.localVariables = holder.localVariables;
           if (body.isAsynchronous) {
             getter.asynchronous = true;
           }
           if (body.isGenerator) {
             getter.generator = true;
           }
           getter.variable = field;
           getter.abstract = node.isAbstract;
           getter.getter = true;
           getter.static = isStatic;
           field.getter = getter;
           if (node.returnType == null) {
             getter.hasImplicitReturnType = true;
           }
           _currentHolder.addAccessor(getter);
           propertyNameNode.staticElement = getter;
         } else {
           PropertyAccessorElementImpl setter =
               new PropertyAccessorElementImpl.forNode(propertyNameNode);
+          _setCodeRange(setter, node);
           setter.metadata = _createElementAnnotations(node.metadata);
           setElementDocumentationComment(setter, node);
           if (node.externalKeyword != null) {
             setter.external = true;
           }
           setter.functions = holder.functions;
           setter.labels = holder.labels;
           setter.localVariables = holder.localVariables;
           setter.parameters = holder.parameters;
           if (body.isAsynchronous) {
@@ skipping 58 matching lines @@
     _createElementAnnotations(node.metadata);
     return super.visitPartDirective(node);
   }
 
   @override
   Object visitSimpleFormalParameter(SimpleFormalParameter node) {
     if (node.parent is! DefaultFormalParameter) {
       SimpleIdentifier parameterName = node.identifier;
       ParameterElementImpl parameter =
           new ParameterElementImpl.forNode(parameterName);
+      _setCodeRange(parameter, node);
       parameter.const3 = node.isConst;
       parameter.final2 = node.isFinal;
       parameter.parameterKind = node.kind;
       _setParameterVisibleRange(node, parameter);
       if (node.type == null) {
         parameter.hasImplicitType = true;
       }
       _currentHolder.addParameter(parameter);
       parameterName.staticElement = parameter;
     }
@@ skipping 25 matching lines @@
       labelName.staticElement = element;
     }
     return super.visitSwitchDefault(node);
   }
 
   @override
   Object visitTypeParameter(TypeParameter node) {
     SimpleIdentifier parameterName = node.name;
     TypeParameterElementImpl typeParameter =
         new TypeParameterElementImpl.forNode(parameterName);
+    _setCodeRange(typeParameter, node);
     typeParameter.metadata = _createElementAnnotations(node.metadata);
     TypeParameterTypeImpl typeParameterType =
         new TypeParameterTypeImpl(typeParameter);
     typeParameter.type = typeParameterType;
     _currentHolder.addTypeParameter(typeParameter);
     parameterName.staticElement = typeParameter;
     return super.visitTypeParameter(node);
   }
 
   @override
   Object visitVariableDeclaration(VariableDeclaration node) {
     bool isConst = node.isConst;
     bool isFinal = node.isFinal;
     bool hasInitializer = node.initializer != null;
     VariableDeclarationList varList = node.parent;
     FieldDeclaration fieldNode =
         varList.parent is FieldDeclaration ? varList.parent : null;
     VariableElementImpl element;
     if (fieldNode != null) {
       SimpleIdentifier fieldName = node.name;
       FieldElementImpl field;
       if ((isConst || isFinal && !fieldNode.isStatic) && hasInitializer) {
         field = new ConstFieldElementImpl.forNode(fieldName);
       } else {
         field = new FieldElementImpl.forNode(fieldName);
       }
       element = field;
       field.static = fieldNode.isStatic;
+      _setCodeRange(element, node);
       setElementDocumentationComment(element, fieldNode);
       field.hasImplicitType = varList.type == null;
       _currentHolder.addField(field);
       fieldName.staticElement = field;
     } else if (_inFunction) {
       SimpleIdentifier variableName = node.name;
       LocalVariableElementImpl variable;
       if (isConst && hasInitializer) {
         variable = new ConstLocalVariableElementImpl.forNode(variableName);
       } else {
         variable = new LocalVariableElementImpl.forNode(variableName);
       }
       element = variable;
+      _setCodeRange(element, node);
       Block enclosingBlock = node.getAncestor((node) => node is Block);
       // TODO(brianwilkerson) This isn't right for variables declared in a for
       // loop.
       variable.setVisibleRange(enclosingBlock.offset, enclosingBlock.length);
       variable.hasImplicitType = varList.type == null;
       _currentHolder.addLocalVariable(variable);
       variableName.staticElement = element;
     } else {
       SimpleIdentifier variableName = node.name;
       TopLevelVariableElementImpl variable;
       if (isConst && hasInitializer) {
         variable = new ConstTopLevelVariableElementImpl.forNode(variableName);
       } else {
         variable = new TopLevelVariableElementImpl.forNode(variableName);
       }
       element = variable;
+      _setCodeRange(element, node);
       if (varList.parent is TopLevelVariableDeclaration) {
         setElementDocumentationComment(element, varList.parent);
       }
       variable.hasImplicitType = varList.type == null;
       _currentHolder.addTopLevelVariable(variable);
       variableName.staticElement = element;
     }
     element.const3 = isConst;
     element.final2 = isFinal;
     if (hasInitializer) {
@@ skipping 42 matching lines @@
     List<ElementAnnotation> elementAnnotations;
     if (parent is FieldDeclaration) {
       elementAnnotations = _createElementAnnotations(parent.metadata);
     } else if (parent is TopLevelVariableDeclaration) {
       elementAnnotations = _createElementAnnotations(parent.metadata);
     } else {
       // Local variable declaration
       elementAnnotations = _createElementAnnotations(node.metadata);
     }
     for (VariableDeclaration variableDeclaration in node.variables) {
-      (variableDeclaration.element as ElementImpl).metadata =
-          elementAnnotations;
+      ElementImpl element = variableDeclaration.element as ElementImpl;
+      _setCodeRange(element, node.parent);
+      element.metadata = elementAnnotations;
     }
     return null;
   }
 
   /**
    * Build the table mapping field names to field elements for the fields defined in the current
    * class.
    *
    * @param fields the field elements defined in the current class
    */
@@ skipping 71 matching lines @@
     if (parent is ConstructorDeclaration) {
       return parent.body;
     } else if (parent is FunctionExpression) {
       return parent.body;
     } else if (parent is MethodDeclaration) {
       return parent.body;
     }
     return null;
   }
 
+  void _setCodeRange(ElementImpl element, AstNode node) {

[Brian Wilkerson, 2016/03/02 00:08:09]

Should / could this happen automatically in the 'forNode' constructors? If so,
it would prevent us from missing the necessary step. (It might cause a problem,
though, for ElementFactory.)

[scheglov, 2016/03/02 04:57:01]

Unfortunately it does not work well for constructors, where it is normal to have
"null" as a name.
And in general it seems that the idea of using forNode() was not very successful
- it mixes nodes with elements, and in result we get only barely initialized
element - just name and nothing else.

+    element.setCodeRange(node.offset, node.length);
+  }
+
   /**
    * Sets the visible source range for formal parameter.
    */
   void _setParameterVisibleRange(
       FormalParameter node, ParameterElementImpl element) {
     FunctionBody body = _getFunctionBody(node);
     if (body is BlockFunctionBody || body is ExpressionFunctionBody) {
       element.setVisibleRange(body.offset, body.length);
     }
   }
@@ skipping 86 matching lines @@
     return null;
   }
 
   /**
    * Return the lexical identifiers associated with the given [identifiers].
    */
   static List<String> _getIdentifiers(NodeList<SimpleIdentifier> identifiers) {
     return identifiers.map((identifier) => identifier.name).toList();
   }
 }