Drop return types in DeclarationMatcher visitor.

pkg/analyzer/lib/src/generated/incremental_resolver.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 engine.incremental_resolver;
 
 import 'dart:collection';
 
 import 'ast.dart';
 import 'element.dart';
 import 'error.dart';
 import 'java_engine.dart';
 import 'resolver.dart';
 import 'scanner.dart';
 import 'source.dart';
 
 
 /**
  * Instances of the class [DeclarationMatcher] determine whether the element
  * model defined by a given AST structure matches an existing element model.
  */
-class DeclarationMatcher extends RecursiveAstVisitor<Object> {
+class DeclarationMatcher extends RecursiveAstVisitor {
   /**
    * The compilation unit containing the AST nodes being visited.
    */
   CompilationUnitElement _enclosingUnit;
 
   /**
    * The function type alias containing the AST nodes being visited, or `null` if we are not
    * in the scope of a function type alias.
    */
   FunctionTypeAliasElement _enclosingAlias;
@@ skipping 50 matching lines @@
     _gatherElements(element);
     try {
       node.accept(this);
     } on _DeclarationMismatchException catch (exception) {
       return false;
     }
     return _unmatchedElements.isEmpty;
   }
 
   @override
-  Object visitCatchClause(CatchClause node) {
+  visitCatchClause(CatchClause node) {
     SimpleIdentifier exceptionParameter = node.exceptionParameter;
     if (exceptionParameter != null) {
       List<LocalVariableElement> localVariables =
           _enclosingExecutable.localVariables;
       LocalVariableElement exceptionElement =
           _findIdentifier(localVariables, exceptionParameter);
       _processElement(exceptionElement);
       SimpleIdentifier stackTraceParameter = node.stackTraceParameter;
       if (stackTraceParameter != null) {
         LocalVariableElement stackTraceElement =
             _findIdentifier(localVariables, stackTraceParameter);
         _processElement(stackTraceElement);
       }
     }
-    return super.visitCatchClause(node);
+    super.visitCatchClause(node);
   }
 
   @override
-  Object visitClassDeclaration(ClassDeclaration node) {
+  visitClassDeclaration(ClassDeclaration node) {
     String name = node.name.name;
     ClassElement clazz = _findElement(_enclosingUnit.types, name);
     _enclosingClass = clazz;
     _processElement(clazz);
     // check for missing clauses
     if (node.extendsClause == null) {
       _assertTrue(clazz.supertype.name == 'Object');
     }
     if (node.implementsClause == null) {
       _assertTrue(clazz.interfaces.isEmpty);
     }
     if (node.withClause == null) {
       _assertTrue(clazz.mixins.isEmpty);
     }
     // process clauses and members
     _hasConstructor = false;
     super.visitClassDeclaration(node);
     // process default constructor
     if (!_hasConstructor) {
       ConstructorElement constructor = clazz.unnamedConstructor;
       _processElement(constructor);
       if (!constructor.isSynthetic) {
         _assertEquals(constructor.parameters.length, 0);
       }
     }
     return null;

[Brian Wilkerson, 2014/11/20 15:43:05]

We don't need explicit returns at the end of methods either.

[scheglov, 2014/11/20 15:58:49]

Done.

   }
 
   @override
-  Object visitClassTypeAlias(ClassTypeAlias node) {
+  visitClassTypeAlias(ClassTypeAlias node) {
     ClassElement outerClass = _enclosingClass;
     try {
       SimpleIdentifier className = node.name;
       _enclosingClass = _findIdentifier(_enclosingUnit.types, className);
       _processElement(_enclosingClass);
-      return super.visitClassTypeAlias(node);
+      super.visitClassTypeAlias(node);
     } finally {
       _enclosingClass = outerClass;
     }
   }
 
   @override
-  Object visitCompilationUnit(CompilationUnit node) {
+  visitCompilationUnit(CompilationUnit node) {
     _processElement(_enclosingUnit);
-    return super.visitCompilationUnit(node);
+    super.visitCompilationUnit(node);
   }
 
   @override
-  Object visitConstructorDeclaration(ConstructorDeclaration node) {
+  visitConstructorDeclaration(ConstructorDeclaration node) {
     ExecutableElement outerExecutable = _enclosingExecutable;
     try {
       SimpleIdentifier constructorName = node.name;
       if (constructorName == null) {
         _enclosingExecutable = _enclosingClass.unnamedConstructor;
       } else {
         _enclosingExecutable =
             _enclosingClass.getNamedConstructor(constructorName.name);
       }
       _processElement(_enclosingExecutable);
-      return super.visitConstructorDeclaration(node);
+      super.visitConstructorDeclaration(node);
     } finally {
       _enclosingExecutable = outerExecutable;
     }
   }
 
   @override
-  Object visitDeclaredIdentifier(DeclaredIdentifier node) {
+  visitDeclaredIdentifier(DeclaredIdentifier node) {
     SimpleIdentifier variableName = node.identifier;
     LocalVariableElement element =
         _findIdentifier(_enclosingExecutable.localVariables, variableName);
     _processElement(element);
-    return super.visitDeclaredIdentifier(node);
+    super.visitDeclaredIdentifier(node);
   }
 
   @override
-  Object visitDefaultFormalParameter(DefaultFormalParameter node) {
+  visitDefaultFormalParameter(DefaultFormalParameter node) {
     SimpleIdentifier parameterName = node.parameter.identifier;
     ParameterElement element = _getElementForParameter(node, parameterName);
     Expression defaultValue = node.defaultValue;
     if (defaultValue != null) {
       ExecutableElement outerExecutable = _enclosingExecutable;
       try {
         if (element == null) {
           // TODO(brianwilkerson) Report this internal error.
         } else {
           _enclosingExecutable = element.initializer;
         }
         defaultValue.accept(this);
       } finally {
         _enclosingExecutable = outerExecutable;
       }
       _processElement(_enclosingExecutable);
     }
     ParameterElement outerParameter = _enclosingParameter;
     try {
       _enclosingParameter = element;
       _processElement(_enclosingParameter);
-      return super.visitDefaultFormalParameter(node);
+      super.visitDefaultFormalParameter(node);
     } finally {
       _enclosingParameter = outerParameter;
     }
   }
 
   @override
-  Object visitEnumDeclaration(EnumDeclaration node) {
+  visitEnumDeclaration(EnumDeclaration node) {
     ClassElement enclosingEnum =
         _findIdentifier(_enclosingUnit.enums, node.name);
     _processElement(enclosingEnum);
     List<FieldElement> constants = enclosingEnum.fields;
     for (EnumConstantDeclaration constant in node.constants) {
       FieldElement constantElement = _findIdentifier(constants, constant.name);
       _processElement(constantElement);
     }
-    return super.visitEnumDeclaration(node);
+    super.visitEnumDeclaration(node);
   }
 
   @override
-  Object visitExportDirective(ExportDirective node) {
+  visitExportDirective(ExportDirective node) {
     String uri = _getStringValue(node.uri);
     if (uri != null) {
       LibraryElement library = _enclosingUnit.library;
       ExportElement exportElement = _findExport(
           library.exports,
           _enclosingUnit.context.sourceFactory.resolveUri(_enclosingUnit.source, uri));
       _processElement(exportElement);
     }
-    return super.visitExportDirective(node);
+    super.visitExportDirective(node);
   }
 
   @override
   visitExtendsClause(ExtendsClause node) {
     _assertSameType(node.superclass, _enclosingClass.supertype);
   }
 
   @override
-  Object visitFieldFormalParameter(FieldFormalParameter node) {
+  visitFieldFormalParameter(FieldFormalParameter node) {
     if (node.parent is! DefaultFormalParameter) {
       SimpleIdentifier parameterName = node.identifier;
       ParameterElement element = _getElementForParameter(node, parameterName);
       ParameterElement outerParameter = _enclosingParameter;
       try {
         _enclosingParameter = element;
         _processElement(_enclosingParameter);
-        return super.visitFieldFormalParameter(node);
+        super.visitFieldFormalParameter(node);
       } finally {
         _enclosingParameter = outerParameter;
       }
     } else {
-      return super.visitFieldFormalParameter(node);
+      super.visitFieldFormalParameter(node);
     }
   }
 
   @override
-  Object visitFunctionDeclaration(FunctionDeclaration node) {
+  visitFunctionDeclaration(FunctionDeclaration node) {
     ExecutableElement outerExecutable = _enclosingExecutable;
     try {
       SimpleIdentifier functionName = node.name;
       Token property = node.propertyKeyword;
       if (property == null) {
         if (_enclosingExecutable != null) {
           _enclosingExecutable =
               _findIdentifier(_enclosingExecutable.functions, functionName);
         } else {
           _enclosingExecutable =
               _findIdentifier(_enclosingUnit.functions, functionName);
         }
       } else {
         PropertyAccessorElement accessor =
             _findIdentifier(_enclosingUnit.accessors, functionName);
         if ((property as KeywordToken).keyword == Keyword.SET) {
           accessor = accessor.variable.setter;
         }
         _enclosingExecutable = accessor;
       }
       _processElement(_enclosingExecutable);
-      return super.visitFunctionDeclaration(node);
+      super.visitFunctionDeclaration(node);
     } finally {
       _enclosingExecutable = outerExecutable;
     }
   }
 
   @override
-  Object visitFunctionExpression(FunctionExpression node) {
+  visitFunctionExpression(FunctionExpression node) {
     if (node.parent is! FunctionDeclaration) {
       FunctionElement element =
           _findAtOffset(_enclosingExecutable.functions, node.beginToken.offset);
       _processElement(element);
     }
     ExecutableElement outerExecutable = _enclosingExecutable;
     try {
       _enclosingExecutable = node.element;
       _processElement(_enclosingExecutable);
-      return super.visitFunctionExpression(node);
+      super.visitFunctionExpression(node);
     } finally {
       _enclosingExecutable = outerExecutable;
     }
   }
 
   @override
-  Object visitFunctionTypeAlias(FunctionTypeAlias node) {
+  visitFunctionTypeAlias(FunctionTypeAlias node) {
     FunctionTypeAliasElement outerAlias = _enclosingAlias;
     try {
       SimpleIdentifier aliasName = node.name;
       _enclosingAlias =
           _findIdentifier(_enclosingUnit.functionTypeAliases, aliasName);
       _processElement(_enclosingAlias);
-      return super.visitFunctionTypeAlias(node);
+      super.visitFunctionTypeAlias(node);
     } finally {
       _enclosingAlias = outerAlias;
     }
   }
 
   @override
-  Object visitFunctionTypedFormalParameter(FunctionTypedFormalParameter node) {
+  visitFunctionTypedFormalParameter(FunctionTypedFormalParameter node) {
     if (node.parent is! DefaultFormalParameter) {
       SimpleIdentifier parameterName = node.identifier;
       ParameterElement element = _getElementForParameter(node, parameterName);
       ParameterElement outerParameter = _enclosingParameter;
       try {
         _enclosingParameter = element;
         _processElement(_enclosingParameter);
-        return super.visitFunctionTypedFormalParameter(node);
+        super.visitFunctionTypedFormalParameter(node);
       } finally {
         _enclosingParameter = outerParameter;
       }
     } else {
-      return super.visitFunctionTypedFormalParameter(node);
+      super.visitFunctionTypedFormalParameter(node);
     }
   }
 
   @override
   visitImplementsClause(ImplementsClause node) {
     List<TypeName> nodes = node.interfaces;
     List<InterfaceType> types = _enclosingClass.interfaces;
     _assertSameTypes(nodes, types);
   }
 
   @override
-  Object visitImportDirective(ImportDirective node) {
+  visitImportDirective(ImportDirective node) {
     String uri = _getStringValue(node.uri);
     if (uri != null) {
       LibraryElement library = _enclosingUnit.library;
       ImportElement importElement = _findImport(
           library.imports,
           _enclosingUnit.context.sourceFactory.resolveUri(_enclosingUnit.source, uri),
           node.prefix);
       _processElement(importElement);
     }
-    return super.visitImportDirective(node);
+    super.visitImportDirective(node);
   }
 
   @override
-  Object visitLabeledStatement(LabeledStatement node) {
+  visitLabeledStatement(LabeledStatement node) {
     for (Label label in node.labels) {
       SimpleIdentifier labelName = label.label;
       LabelElement element =
           _findIdentifier(_enclosingExecutable.labels, labelName);
       _processElement(element);
     }
-    return super.visitLabeledStatement(node);
+    super.visitLabeledStatement(node);
   }
 
   @override
-  Object visitMethodDeclaration(MethodDeclaration node) {
+  visitMethodDeclaration(MethodDeclaration node) {
     ExecutableElement outerExecutable = _enclosingExecutable;
     try {
       Token property = node.propertyKeyword;
       SimpleIdentifier methodName = node.name;
       String nameOfMethod = methodName.name;
       if (nameOfMethod == TokenType.MINUS.lexeme &&
           node.parameters.parameters.length == 0) {
         nameOfMethod = "unary-";
       }
       if (property == null) {
         _enclosingExecutable = _findWithNameAndOffset(
             _enclosingClass.methods,
             nameOfMethod,
             methodName.offset);
         methodName.staticElement = _enclosingExecutable;
       } else {
         PropertyAccessorElement accessor =
             _findIdentifier(_enclosingClass.accessors, methodName);
         if ((property as KeywordToken).keyword == Keyword.SET) {
           accessor = accessor.variable.setter;
           methodName.staticElement = accessor;
         }
         _enclosingExecutable = accessor;
       }
       _processElement(_enclosingExecutable);
-      return super.visitMethodDeclaration(node);
+      super.visitMethodDeclaration(node);
     } finally {
       _enclosingExecutable = outerExecutable;
     }
   }
 
   @override
-  Object visitPartDirective(PartDirective node) {
+  visitPartDirective(PartDirective node) {
     String uri = _getStringValue(node.uri);
     if (uri != null) {
       Source partSource =
           _enclosingUnit.context.sourceFactory.resolveUri(_enclosingUnit.source, uri);
       CompilationUnitElement element =
           _findPart(_enclosingUnit.library.parts, partSource);
       _processElement(element);
     }
-    return super.visitPartDirective(node);
+    super.visitPartDirective(node);
   }
 
   @override
-  Object visitSimpleFormalParameter(SimpleFormalParameter node) {
+  visitSimpleFormalParameter(SimpleFormalParameter node) {
     if (node.parent is! DefaultFormalParameter) {
       SimpleIdentifier parameterName = node.identifier;
       ParameterElement element = _getElementForParameter(node, parameterName);
       ParameterElement outerParameter = _enclosingParameter;
       try {
         _enclosingParameter = element;
         _processElement(_enclosingParameter);
-        return super.visitSimpleFormalParameter(node);
+        super.visitSimpleFormalParameter(node);
       } finally {
         _enclosingParameter = outerParameter;
       }
     } else {
     }
-    return super.visitSimpleFormalParameter(node);
+    super.visitSimpleFormalParameter(node);
   }
 
   @override
-  Object visitSwitchCase(SwitchCase node) {
+  visitSwitchCase(SwitchCase node) {
     for (Label label in node.labels) {
       SimpleIdentifier labelName = label.label;
       LabelElement element =
           _findIdentifier(_enclosingExecutable.labels, labelName);
       _processElement(element);
     }
-    return super.visitSwitchCase(node);
+    super.visitSwitchCase(node);
   }
 
   @override
-  Object visitSwitchDefault(SwitchDefault node) {
+  visitSwitchDefault(SwitchDefault node) {
     for (Label label in node.labels) {
       SimpleIdentifier labelName = label.label;
       LabelElement element =
           _findIdentifier(_enclosingExecutable.labels, labelName);
       _processElement(element);
     }
-    return super.visitSwitchDefault(node);
+    super.visitSwitchDefault(node);
   }
 
   @override
-  Object visitTopLevelVariableDeclaration(TopLevelVariableDeclaration node) {
+  visitTopLevelVariableDeclaration(TopLevelVariableDeclaration node) {
     _inTopLevelVariableDeclaration = true;
     try {
-      return super.visitTopLevelVariableDeclaration(node);
+      super.visitTopLevelVariableDeclaration(node);
     } finally {
       _inTopLevelVariableDeclaration = false;
     }
   }
 
   @override
-  Object visitTypeParameter(TypeParameter node) {
+  visitTypeParameter(TypeParameter node) {
     SimpleIdentifier parameterName = node.name;
     TypeParameterElement element = null;
     if (_enclosingClass != null) {
       element = _findIdentifier(_enclosingClass.typeParameters, parameterName);
     } else if (_enclosingAlias != null) {
       element = _findIdentifier(_enclosingAlias.typeParameters, parameterName);
     }
     _processElement(element);
-    return super.visitTypeParameter(node);
+    super.visitTypeParameter(node);
   }
 
   @override
-  Object visitVariableDeclaration(VariableDeclaration node) {
+  visitVariableDeclaration(VariableDeclaration node) {
     String name = node.name.name;
     if (_inTopLevelVariableDeclaration) {
       TopLevelVariableElement variable =
           _findElement(_enclosingUnit.topLevelVariables, name);
       _assertNotNull(variable);
       _assertFalse(variable.isSynthetic);
       _assertEquals(node.isConst, variable.isConst);
       _assertEquals(node.isFinal, variable.isFinal);
       _assertSameType(
           (node.parent as VariableDeclarationList).type,
           variable.type);
       _processElement(variable);
-      return null;
+      return;
     }
     VariableElement element;
     if (_enclosingExecutable != null) {
       element = _findElement(_enclosingExecutable.localVariables, name);
     }
     if (element == null && _enclosingClass != null) {
       element = _findElement(_enclosingClass.fields, name);
     }
-    return super.visitVariableDeclaration(node);
+    super.visitVariableDeclaration(node);
   }
 
   @override
   visitWithClause(WithClause node) {
     List<TypeName> nodes = node.mixinTypes;
     List<InterfaceType> types = _enclosingClass.mixins;
     _assertSameTypes(nodes, types);
   }
 
   void _assertEquals(Object a, Object b) {
@@ skipping 584 matching lines @@
     }
   }
 
   void _addElement(Element element) {
     if (element != null) {
       matcher._allElements.add(element);
       matcher._unmatchedElements.add(element);
     }
   }
 }