Drop return type in _IndexContributor.

pkg/analysis_server/lib/src/services/index/index_contributor.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 services.src.index.index_contributor;
 
 import 'dart:collection' show Queue;
 
 import 'package:analysis_server/src/services/correction/namespace.dart';
 import 'package:analysis_server/src/services/index/index.dart';
@@ skipping 52 matching lines @@
     return;
   }
   // do index
   store.doneIndex();
 }
 
 
 /**
  * Visits a resolved AST and adds relationships into [IndexStore].
  */
-class _IndexContributor extends GeneralizingAstVisitor<Object> {
+class _IndexContributor extends GeneralizingAstVisitor {
   final IndexStore _store;
 
   LibraryElement _libraryElement;
 
   Map<ImportElement, Set<Element>> _importElementsMap = {};
 
   /**
-   * A stack whose top element (the element with the largest index) is an element representing the
-   * inner-most enclosing scope.
+   * A stack whose top element (the element with the largest index) is an
+   * element representing the inner-most enclosing scope.
    */
   Queue<Element> _elementStack = new Queue();
 
   _IndexContributor(this._store);
 
   /**
    * Enter a new scope represented by the given [Element].
    */
   void enterScope(Element element) {
     _elementStack.addFirst(element);
@@ skipping 15 matching lines @@
    * Record the given relationship between the given [Element] and [Location].
    */
   void recordRelationship(Element element, Relationship relationship,
       Location location) {
     if (element != null && location != null) {
       _store.recordRelationship(element, relationship, location);
     }
   }
 
   @override
-  Object visitAssignmentExpression(AssignmentExpression node) {
+  visitAssignmentExpression(AssignmentExpression node) {
     _recordOperatorReference(node.operator, node.bestElement);
-    return super.visitAssignmentExpression(node);
+    super.visitAssignmentExpression(node);
   }
 
   @override
-  Object visitBinaryExpression(BinaryExpression node) {
+  visitBinaryExpression(BinaryExpression node) {
     _recordOperatorReference(node.operator, node.bestElement);
-    return super.visitBinaryExpression(node);
+    super.visitBinaryExpression(node);
   }
 
   @override
-  Object visitClassDeclaration(ClassDeclaration node) {
+  visitClassDeclaration(ClassDeclaration node) {
     ClassElement element = node.element;
     enterScope(element);
     try {
       _recordElementDefinition(element);
       {
         ExtendsClause extendsClause = node.extendsClause;
         if (extendsClause != null) {
           TypeName superclassNode = extendsClause.superclass;
           _recordSuperType(superclassNode, IndexConstants.IS_EXTENDED_BY);
         } else {
@@ skipping 16 matching lines @@
         }
       }
       {
         ImplementsClause implementsClause = node.implementsClause;
         if (implementsClause != null) {
           for (TypeName interfaceNode in implementsClause.interfaces) {
             _recordSuperType(interfaceNode, IndexConstants.IS_IMPLEMENTED_BY);
           }
         }
       }
-      return super.visitClassDeclaration(node);
+      super.visitClassDeclaration(node);
     } finally {
       _exitScope();
     }
   }
 
   @override
-  Object visitClassTypeAlias(ClassTypeAlias node) {
+  visitClassTypeAlias(ClassTypeAlias node) {
     ClassElement element = node.element;
     enterScope(element);
     try {
       _recordElementDefinition(element);
       {
         TypeName superclassNode = node.superclass;
         if (superclassNode != null) {
           _recordSuperType(superclassNode, IndexConstants.IS_EXTENDED_BY);
         }
       }
       {
         WithClause withClause = node.withClause;
         if (withClause != null) {
           for (TypeName mixinNode in withClause.mixinTypes) {
             _recordSuperType(mixinNode, IndexConstants.IS_MIXED_IN_BY);
           }
         }
       }
       {
         ImplementsClause implementsClause = node.implementsClause;
         if (implementsClause != null) {
           for (TypeName interfaceNode in implementsClause.interfaces) {
             _recordSuperType(interfaceNode, IndexConstants.IS_IMPLEMENTED_BY);
           }
         }
       }
-      return super.visitClassTypeAlias(node);
+      super.visitClassTypeAlias(node);
     } finally {
       _exitScope();
     }
   }
 
   @override
-  Object visitCompilationUnit(CompilationUnit node) {
+  visitCompilationUnit(CompilationUnit node) {
     CompilationUnitElement unitElement = node.element;
     if (unitElement != null) {
       _elementStack.add(unitElement);
       _libraryElement = unitElement.enclosingElement;
       if (_libraryElement != null) {
-        return super.visitCompilationUnit(node);
+        super.visitCompilationUnit(node);
       }
     }
-    return null;
   }
 
   @override
-  Object visitConstructorDeclaration(ConstructorDeclaration node) {
+  visitConstructorDeclaration(ConstructorDeclaration node) {
     ConstructorElement element = node.element;
     enterScope(element);
     try {
-      return super.visitConstructorDeclaration(node);
+      super.visitConstructorDeclaration(node);
     } finally {
       _exitScope();
     }
   }
 
   @override
   visitConstructorFieldInitializer(ConstructorFieldInitializer node) {
     SimpleIdentifier fieldName = node.fieldName;
     Expression expression = node.expression;
     // field reference is write here
     if (fieldName != null) {
       Element element = fieldName.staticElement;
       Location location = _createLocationForNode(fieldName);
-      _store.recordRelationship(element, IndexConstants.IS_WRITTEN_BY, location);
+      _store.recordRelationship(
+          element,
+          IndexConstants.IS_WRITTEN_BY,
+          location);
     }
     // index expression
     if (expression != null) {
       expression.accept(this);
     }
   }
 
   @override
-  Object visitConstructorName(ConstructorName node) {
+  visitConstructorName(ConstructorName node) {
     ConstructorElement element = node.staticElement;
     // in 'class B = A;' actually A constructors are invoked
     if (element != null &&
         element.isSynthetic &&
         element.redirectedConstructor != null) {
       element = element.redirectedConstructor;
     }
     // prepare location
     Location location;
     if (node.name != null) {
       int start = node.period.offset;
       int end = node.name.end;
       location = _createLocationForOffset(start, end - start);
     } else {
       int start = node.type.end;
       location = _createLocationForOffset(start, 0);
     }
     // record relationship
     recordRelationship(element, IndexConstants.IS_REFERENCED_BY, location);
-    return super.visitConstructorName(node);
+    super.visitConstructorName(node);
   }
 
   @override
-  Object visitDeclaredIdentifier(DeclaredIdentifier node) {
+  visitDeclaredIdentifier(DeclaredIdentifier node) {
     LocalVariableElement element = node.element;
     enterScope(element);
     try {
-      return super.visitDeclaredIdentifier(node);
+      super.visitDeclaredIdentifier(node);
     } finally {
       _exitScope();
     }
   }
 
   @override
-  Object visitEnumDeclaration(EnumDeclaration node) {
+  visitEnumDeclaration(EnumDeclaration node) {
     ClassElement element = node.element;
     enterScope(element);
     try {
       _recordElementDefinition(element);
-      return super.visitEnumDeclaration(node);
+      super.visitEnumDeclaration(node);
     } finally {
       _exitScope();
     }
   }
 
   @override
-  Object visitExportDirective(ExportDirective node) {
+  visitExportDirective(ExportDirective node) {
     ExportElement element = node.element;
     if (element != null) {
       LibraryElement expLibrary = element.exportedLibrary;
       _recordLibraryReference(node, expLibrary);
     }
-    return super.visitExportDirective(node);
+    super.visitExportDirective(node);
   }
 
   @override
-  Object visitFormalParameter(FormalParameter node) {
+  visitFormalParameter(FormalParameter node) {
     ParameterElement element = node.element;
     enterScope(element);
     try {
-      return super.visitFormalParameter(node);
+      super.visitFormalParameter(node);
     } finally {
       _exitScope();
     }
   }
 
   @override
-  Object visitFunctionDeclaration(FunctionDeclaration node) {
+  visitFunctionDeclaration(FunctionDeclaration node) {
     Element element = node.element;
     _recordElementDefinition(element);
     enterScope(element);
     try {
-      return super.visitFunctionDeclaration(node);
+      super.visitFunctionDeclaration(node);
     } finally {
       _exitScope();
     }
   }
 
   @override
-  Object visitFunctionTypeAlias(FunctionTypeAlias node) {
+  visitFunctionTypeAlias(FunctionTypeAlias node) {
     Element element = node.element;
     _recordElementDefinition(element);
-    return super.visitFunctionTypeAlias(node);
+    super.visitFunctionTypeAlias(node);
   }
 
   @override
-  Object visitImportDirective(ImportDirective node) {
+  visitImportDirective(ImportDirective node) {
     ImportElement element = node.element;
     if (element != null) {
       LibraryElement impLibrary = element.importedLibrary;
       _recordLibraryReference(node, impLibrary);
     }
-    return super.visitImportDirective(node);
+    super.visitImportDirective(node);
   }
 
   @override
-  Object visitIndexExpression(IndexExpression node) {
+  visitIndexExpression(IndexExpression node) {
     MethodElement element = node.bestElement;
     if (element is MethodElement) {
       Token operator = node.leftBracket;
       Location location = _createLocationForToken(operator, element != null);
       recordRelationship(element, IndexConstants.IS_INVOKED_BY, location);
     }
-    return super.visitIndexExpression(node);
+    super.visitIndexExpression(node);
   }
 
   @override
-  Object visitMethodDeclaration(MethodDeclaration node) {
+  visitMethodDeclaration(MethodDeclaration node) {
     ExecutableElement element = node.element;
     enterScope(element);
     try {
-      return super.visitMethodDeclaration(node);
+      super.visitMethodDeclaration(node);
     } finally {
       _exitScope();
     }
   }
 
   @override
-  Object visitMethodInvocation(MethodInvocation node) {
+  visitMethodInvocation(MethodInvocation node) {
     SimpleIdentifier name = node.methodName;
     Location location = _createLocationForNode(name);
     // element invocation
     Element element = name.bestElement;
     if (element is MethodElement ||
         element is PropertyAccessorElement ||
         element is FunctionElement ||
         element is VariableElement) {
       recordRelationship(element, IndexConstants.IS_INVOKED_BY, location);
     }
     // name invocation
     {
       Element nameElement = new NameElement(name.name);
       _store.recordRelationship(
           nameElement,
           IndexConstants.IS_INVOKED_BY,
           location);
     }
     _recordImportElementReferenceWithoutPrefix(name);
-    return super.visitMethodInvocation(node);
+    super.visitMethodInvocation(node);
   }
 
   @override
-  Object visitPartDirective(PartDirective node) {
+  visitPartDirective(PartDirective node) {
     Element element = node.element;
     Location location = _createLocationForNode(node.uri);
     recordRelationship(element, IndexConstants.IS_REFERENCED_BY, location);
-    return super.visitPartDirective(node);
+    super.visitPartDirective(node);
   }
 
   @override
-  Object visitPartOfDirective(PartOfDirective node) {
+  visitPartOfDirective(PartOfDirective node) {
     Location location = _createLocationForNode(node.libraryName);
     recordRelationship(node.element, IndexConstants.IS_REFERENCED_BY, location);
-    return null;
   }
 
   @override
-  Object visitPostfixExpression(PostfixExpression node) {
+  visitPostfixExpression(PostfixExpression node) {
     _recordOperatorReference(node.operator, node.bestElement);
-    return super.visitPostfixExpression(node);
+    super.visitPostfixExpression(node);
   }
 
   @override
-  Object visitPrefixExpression(PrefixExpression node) {
+  visitPrefixExpression(PrefixExpression node) {
     _recordOperatorReference(node.operator, node.bestElement);
-    return super.visitPrefixExpression(node);
+    super.visitPrefixExpression(node);
   }
 
   @override
-  Object
-      visitRedirectingConstructorInvocation(RedirectingConstructorInvocation node) {
+  visitRedirectingConstructorInvocation(RedirectingConstructorInvocation node) {
     ConstructorElement element = node.staticElement;
     Location location;
     if (node.constructorName != null) {
       int start = node.period.offset;
       int end = node.constructorName.end;
       location = _createLocationForOffset(start, end - start);
     } else {
       int start = node.keyword.end;
       location = _createLocationForOffset(start, 0);
     }
     recordRelationship(element, IndexConstants.IS_REFERENCED_BY, location);
-    return super.visitRedirectingConstructorInvocation(node);
+    super.visitRedirectingConstructorInvocation(node);
   }
 
   @override
-  Object visitSimpleIdentifier(SimpleIdentifier node) {
+  visitSimpleIdentifier(SimpleIdentifier node) {
     Element nameElement = new NameElement(node.name);
     Location location = _createLocationForNode(node);
     // name in declaration
     if (node.inDeclarationContext()) {
       recordRelationship(
           nameElement,
           IndexConstants.NAME_IS_DEFINED_BY,
           location);
-      return null;
+      return;
     }
     // prepare information
     Element element = node.bestElement;
     // stop if already handled
     if (_isAlreadyHandledName(node)) {
-      return null;
+      return;
     }
     // record name read/write
     if (element != null && element.enclosingElement is ClassElement ||
         element == null && location.isQualified) {
       bool inGetterContext = node.inGetterContext();
       bool inSetterContext = node.inSetterContext();
       if (inGetterContext && inSetterContext) {
         _store.recordRelationship(
             nameElement,
             IndexConstants.IS_READ_WRITTEN_BY,
             location);
       } else if (inGetterContext) {
         _store.recordRelationship(
             nameElement,
             IndexConstants.IS_READ_BY,
             location);
       } else if (inSetterContext) {
         _store.recordRelationship(
             nameElement,
             IndexConstants.IS_WRITTEN_BY,
             location);
       }
     }
     // this.field parameter
     if (element is FieldFormalParameterElement) {
       Relationship relationship = peekElement() == element ?
           IndexConstants.IS_WRITTEN_BY :
           IndexConstants.IS_REFERENCED_BY;
       _store.recordRelationship(element.field, relationship, location);
-      return null;
+      return;
     }
     // record specific relations
     if (element is ClassElement ||
         element is FunctionElement ||
         element is FunctionTypeAliasElement ||
         element is LabelElement ||
         element is MethodElement ||
         element is PropertyAccessorElement ||
         element is PropertyInducingElement ||
         element is TypeParameterElement) {
@@ skipping 11 matching lines @@
             location);
       } else if (inGetterContext) {
         recordRelationship(element, IndexConstants.IS_READ_BY, location);
       } else if (inSetterContext) {
         recordRelationship(element, IndexConstants.IS_WRITTEN_BY, location);
       } else {
         recordRelationship(element, IndexConstants.IS_REFERENCED_BY, location);
       }
     }
     _recordImportElementReferenceWithoutPrefix(node);
-    return super.visitSimpleIdentifier(node);
+    super.visitSimpleIdentifier(node);
   }
 
   @override
-  Object visitSuperConstructorInvocation(SuperConstructorInvocation node) {
+  visitSuperConstructorInvocation(SuperConstructorInvocation node) {
     ConstructorElement element = node.staticElement;
     Location location;
     if (node.constructorName != null) {
       int start = node.period.offset;
       int end = node.constructorName.end;
       location = _createLocationForOffset(start, end - start);
     } else {
       int start = node.keyword.end;
       location = _createLocationForOffset(start, 0);
     }
     recordRelationship(element, IndexConstants.IS_REFERENCED_BY, location);
-    return super.visitSuperConstructorInvocation(node);
+    super.visitSuperConstructorInvocation(node);
   }
 
   @override
-  Object visitTopLevelVariableDeclaration(TopLevelVariableDeclaration node) {
+  visitTopLevelVariableDeclaration(TopLevelVariableDeclaration node) {
     VariableDeclarationList variables = node.variables;
     for (VariableDeclaration variableDeclaration in variables.variables) {
       Element element = variableDeclaration.element;
       _recordElementDefinition(element);
     }
-    return super.visitTopLevelVariableDeclaration(node);
+    super.visitTopLevelVariableDeclaration(node);
   }
 
   @override
-  Object visitTypeParameter(TypeParameter node) {
+  visitTypeParameter(TypeParameter node) {
     TypeParameterElement element = node.element;
     enterScope(element);
     try {
-      return super.visitTypeParameter(node);
+      super.visitTypeParameter(node);
     } finally {
       _exitScope();
     }
   }
 
   @override
-  Object visitVariableDeclaration(VariableDeclaration node) {
+  visitVariableDeclaration(VariableDeclaration node) {
     VariableElement element = node.element;
     // record declaration
     {
       SimpleIdentifier name = node.name;
       Location location = _createLocationForNode(name);
       location = _getLocationWithExpressionType(location, node.initializer);
       recordRelationship(element, IndexConstants.NAME_IS_DEFINED_BY, location);
     }
     // visit
     enterScope(element);
     try {
-      return super.visitVariableDeclaration(node);
+      super.visitVariableDeclaration(node);
     } finally {
       _exitScope();
     }
   }
 
   @override
-  Object visitVariableDeclarationList(VariableDeclarationList node) {
+  visitVariableDeclarationList(VariableDeclarationList node) {
     NodeList<VariableDeclaration> variables = node.variables;
     if (variables != null) {
       // use first VariableDeclaration as Element for Location(s) in type
       {
         TypeName type = node.type;
         if (type != null) {
           for (VariableDeclaration variableDeclaration in variables) {
             enterScope(variableDeclaration.element);
             try {
               type.accept(this);
             } finally {
               _exitScope();
             }
             // only one iteration
             break;
           }
         }
       }
       // visit variables
       variables.accept(this);
     }
-    return null;
   }
 
   /**
    * @return the [Location] representing location of the [AstNode].
    */
   Location _createLocationForNode(AstNode node) {
     bool isQualified = _isQualifiedClassMemberAccess(node);
     bool isResolved = true;
     if (node is SimpleIdentifier) {
       isResolved = node.bestElement != null;
@@ skipping 214 matching lines @@
   }
 
   /**
    * @return `true` if given "node" is part of [PrefixedIdentifier] "prefix.node".
    */
   static bool _isIdentifierInPrefixedIdentifier(SimpleIdentifier node) {
     AstNode parent = node.parent;
     return parent is PrefixedIdentifier && parent.identifier == node;
   }
 }