Tests for matching classes.

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';
@@ skipping 34 matching lines @@
 
   /**
    * The parameter containing the AST nodes being visited, or `null` if we are not in the
    * scope of a parameter.
    */
   ParameterElement _enclosingParameter;
 
   bool _inTopLevelVariableDeclaration = false;
 
   /**
+   * Is `true` if the current class declaration has a constructor.
+   */
+  bool _hasConstructor = false;
+
+  /**
    * A set containing all of the elements in the element model that were defined by the old AST node
    * corresponding to the AST node being visited.
    */
   HashSet<Element> _allElements = new HashSet<Element>();
 
   /**
    * A set containing all of the elements in the element model that were defined by the old AST node
    * corresponding to the AST node being visited that have not already been matched to nodes in the
    * AST structure being visited.
    */
   HashSet<Element> _unmatchedElements = new HashSet<Element>();
 
   /**
    * Return `true` if the declarations within the given AST structure define an element model
    * that is equivalent to the corresponding elements rooted at the given element.
    *
    * @param node the AST structure being compared to the element model
    * @param element the root of the element model being compared to the AST structure
    * @return `true` if the AST structure defines the same elements as those in the given
    *         element model
    */
   bool matches(AstNode node, Element element) {
     _captureEnclosingElements(element);
     _gatherElements(element);
     try {
       node.accept(this);
-    } on _DeclarationMismatchException catch (exception) {
+    } on _DeclarationMismatchException catch (exception, st) {

[Brian Wilkerson, 2014/11/19 23:07:22]

Not sure why you added a parameter if we're not using it (or why the dead code
hint didn't catch it :-).

[scheglov, 2014/11/20 05:27:30]

Actually the hint _is_ reported here.
So, it is my failure, not the dead code verifier's :-)

Fixed.

       return false;
     }
-    print(_unmatchedElements.join('\n'));
     return _unmatchedElements.isEmpty;
   }
 
   @override
   Object 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);
   }
 
   @override
   Object visitClassDeclaration(ClassDeclaration node) {
-    ClassElement outerClass = _enclosingClass;
-    try {
-      SimpleIdentifier className = node.name;
-      _enclosingClass = _findIdentifier(_enclosingUnit.types, className);
-      _processElement(_enclosingClass);
-      if (!_hasConstructor(node)) {
-        ConstructorElement constructor = _enclosingClass.unnamedConstructor;
-        if (constructor.isSynthetic) {
-          _processElement(constructor);
-        }
+    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 super.visitClassDeclaration(node);
-    } finally {
-      _enclosingClass = outerClass;
     }
+    return null;
   }
 
   @override
   Object visitClassTypeAlias(ClassTypeAlias node) {
     ClassElement outerClass = _enclosingClass;
     try {
       SimpleIdentifier className = node.name;
       _enclosingClass = _findIdentifier(_enclosingUnit.types, className);
       _processElement(_enclosingClass);
       return super.visitClassTypeAlias(node);
@@ skipping 84 matching lines @@
       LibraryElement library = _enclosingUnit.library;
       ExportElement exportElement = _findExport(
           library.exports,
           _enclosingUnit.context.sourceFactory.resolveUri(_enclosingUnit.source, uri));
       _processElement(exportElement);
     }
     return super.visitExportDirective(node);
   }
 
   @override
+  visitExtendsClause(ExtendsClause node) {
+    _assertSameType(node.superclass, _enclosingClass.supertype);
+  }
+
+  @override
   Object 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);
       } finally {
@@ skipping 76 matching lines @@
         return super.visitFunctionTypedFormalParameter(node);
       } finally {
         _enclosingParameter = outerParameter;
       }
     } else {
       return 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) {
     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);
     }
@@ skipping 139 matching lines @@
     VariableElement element;
     if (_enclosingExecutable != null) {
       element = _findElement(_enclosingExecutable.localVariables, name);
     }
     if (element == null && _enclosingClass != null) {
       element = _findElement(_enclosingClass.fields, name);
     }
     return 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) {
+    if (a != b) {
+      throw new _DeclarationMismatchException();
+    }
+  }
+
+  void _assertFalse(bool condition) {
+    if (condition) {
+      throw new _DeclarationMismatchException();
+    }
+  }
+
+  void _assertNotNull(Element element) {
+    if (element == null) {
+      throw new _DeclarationMismatchException();
+    }
+  }
+
   void _assertSameType(TypeName node, DartType type) {
     String nodeName = node.name.name;
     if (type is InterfaceType) {
       _assertEquals(nodeName, type.name);
+      // check arguments
       TypeArgumentList nodeArgumentList = node.typeArguments;
       List<DartType> typeArguments = type.typeArguments;
       if (nodeArgumentList == null) {
         _assertTrue(typeArguments.isEmpty);
       } else {
         List<TypeName> nodeArguments = nodeArgumentList.arguments;
-        int numArguments = nodeArguments.length;
-        _assertEquals(numArguments, typeArguments.length);
-        for (int i = 0; i < numArguments; i++) {
-          _assertSameType(nodeArguments[i], typeArguments[i]);
-        }
+        _assertSameTypes(nodeArguments, typeArguments);
       }
     } else {
       // TODO(scheglov) support other types
       _assertTrue(false);
     }
   }
 
-  void _assertFalse(bool condition) {
-    if (condition) {
-      throw new _DeclarationMismatchException();
+  void _assertSameTypes(List<TypeName> nodes, List<DartType> type) {
+    int length = nodes.length;
+    _assertEquals(length, type.length);
+    for (int i = 0; i < length; i++) {
+      _assertSameType(nodes[i], type[i]);
     }
   }
 
-  void _assertNotNull(Element element) {
-    if (element == null) {
-      throw new _DeclarationMismatchException();
-    }
-  }
-
-  void _assertEquals(Object a, Object b) {
-    if (a != b) {
-      throw new _DeclarationMismatchException();
-    }
-  }
-
   void _assertTrue(bool condition) {
     if (!condition) {
       throw new _DeclarationMismatchException();
     }
   }
 
   /**
    * Given that the comparison is to begin with the given element, capture the enclosing elements
    * that might be used while performing the comparison.
    *
@@ skipping 181 matching lines @@
    * @param literal the string literal whose value is to be returned
    * @return the value of the given string literal
    */
   String _getStringValue(StringLiteral literal) {
     if (literal is StringInterpolation) {
       return null;
     }
     return literal.stringValue;
   }
 
-  /**
-   * Return `true` if the given class defines at least one constructor.
-   *
-   * @param node the class being tested
-   * @return `true` if the class defines at least one constructor
-   */
-  bool _hasConstructor(ClassDeclaration node) {
-    for (ClassMember member in node.members) {
-      if (member is ConstructorDeclaration) {
-        return true;
-      }
-    }
-    return false;
-  }
-
   void _processElement(Element element) {
     _assertNotNull(element);
     if (!_allElements.contains(element)) {
       throw new _DeclarationMismatchException();
     }
-    bool did = _unmatchedElements.remove(element);
-    print('remove: $element | $did');
+    _unmatchedElements.remove(element);
   }
 }
 
 
 /**
  * Instances of the class [IncrementalResolver] resolve the smallest portion of
  * an AST structure that we currently know how to resolve.
  */
 class IncrementalResolver {
   /**
@@ skipping 323 matching lines @@
     }
   }
 
   void _addElement(Element element) {
     if (element != null) {
       matcher._allElements.add(element);
       matcher._unmatchedElements.add(element);
     }
   }
 }