Test for duplicate referenced in index and clean up super types.

pkg/analyzer/lib/src/summary/index_unit.dart

 // Copyright (c) 2016, 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.
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart';
 import 'package:analyzer/dart/ast/visitor.dart';
 import 'package:analyzer/dart/element/element.dart';
-import 'package:analyzer/dart/element/type.dart';
 import 'package:analyzer/src/generated/utilities_dart.dart';
 import 'package:analyzer/src/summary/format.dart';
 import 'package:analyzer/src/summary/idl.dart';
 
 /**
  * Object that gathers information about the whole package index and then uses
  * it to assemble a new [PackageIndexBuilder].  Call [index] on each compilation
  * unit to be indexed, then call [assemble] to retrieve the complete index for
  * the package.
  */
@@ skipping 179 matching lines @@
 
 /**
  * Visits a resolved AST and adds relationships into [_UnitIndexAssembler].
  */
 class _IndexContributor extends GeneralizingAstVisitor {
   final _UnitIndexAssembler assembler;
 
   _IndexContributor(this.assembler);
 
   /**
-   * Record information about a [ClassDeclaration] or [ClassTypeAlias] with
-   * the given [nameNode].  Nodes [superNode], [withClause] and
-   * [implementsClause] can be `null`.
-   */
-  void recordClassClauses(SimpleIdentifier nameNode, TypeName superNode,
-      WithClause withClause, ImplementsClause implementsClause) {
-    if (superNode != null) {
-      recordSuperType(superNode, IndexRelationKind.IS_EXTENDED_BY);
-    } else {
-      ClassElement element = nameNode.staticElement;
-      InterfaceType superType = element.supertype;
-      if (superType != null) {
-        ClassElement objectElement = superType.element;
-        recordRelationOffset(objectElement, IndexRelationKind.IS_EXTENDED_BY,
-            nameNode.offset, 0);
-      }
-    }
-    if (withClause != null) {
-      for (TypeName mixinNode in withClause.mixinTypes) {
-        recordSuperType(mixinNode, IndexRelationKind.IS_MIXED_IN_BY);
-      }
-    }
-    if (implementsClause != null) {
-      for (TypeName interfaceNode in implementsClause.interfaces) {
-        recordSuperType(interfaceNode, IndexRelationKind.IS_IMPLEMENTED_BY);
-      }
-    }
-  }
-
-  /**
    * Record reference to the given operator [Element] and name.
    */
   void recordOperatorReference(Token operator, Element element) {
     recordRelationToken(element, IndexRelationKind.IS_INVOKED_BY, operator);
     // TODO(scheglov) do we need this?
 //    // prepare location
 //    LocationImpl location = _createLocationForToken(operator, element != null);
 //    // record name reference
 //    {
 //      String name = operator.lexeme;
@@ skipping 54 matching lines @@
    * of the given [token].
    */
   void recordRelationToken(
       Element element, IndexRelationKind kind, Token token) {
     if (element != null && token != null) {
       recordRelationOffset(element, kind, token.offset, token.length);
     }
   }
 
   /**
-   * Records a relation between [superNode] and its [Element].
+   * Record a relation between a super [typeName] and its [Element].
    */
-  void recordSuperType(TypeName superNode, IndexRelationKind kind) {
-    if (superNode != null) {
-      Identifier superName = superNode.name;
-      if (superName != null) {
-        Element superElement = superName.staticElement;
-        recordRelation(superElement, kind, superName);
-      }
+  void recordSuperType(TypeName typeName, IndexRelationKind kind) {
+    Identifier name = typeName?.name;
+    if (name != null) {
+      recordRelation(name.staticElement, kind, name);
+      typeName.typeArguments?.accept(this);
     }
   }
 
   /**
    * Record the top-level [element] definition.
    */
   void recordTopLevelElementDefinition(Element element) {
     // TODO(scheglov) do we need this?
 //    if (element?.enclosingElement is CompilationUnitElement) {
 //      IndexableElement indexable = new IndexableElement(element);
@@ skipping 19 matching lines @@
   @override
   visitBinaryExpression(BinaryExpression node) {
     recordOperatorReference(node.operator, node.bestElement);
     super.visitBinaryExpression(node);
   }
 
   @override
   visitClassDeclaration(ClassDeclaration node) {
     ClassElement element = node.element;
     recordTopLevelElementDefinition(element);
-    recordClassClauses(node.name, node.extendsClause?.superclass,
-        node.withClause, node.implementsClause);
+    if (node.extendsClause == null) {
+      ClassElement objectElement = element.supertype?.element;
+      recordRelationOffset(
+          objectElement, IndexRelationKind.IS_EXTENDED_BY, node.name.offset, 0);
+    }
     super.visitClassDeclaration(node);
   }
 
   @override
   visitClassTypeAlias(ClassTypeAlias node) {
     ClassElement element = node.element;
     recordTopLevelElementDefinition(element);
-    recordClassClauses(
-        node.name, node.superclass, node.withClause, node.implementsClause);
     super.visitClassTypeAlias(node);
   }
 
   @override
   visitConstructorFieldInitializer(ConstructorFieldInitializer node) {
     SimpleIdentifier fieldName = node.fieldName;
     if (fieldName != null) {
       Element element = fieldName.staticElement;
       recordRelation(element, IndexRelationKind.IS_REFERENCED_BY, fieldName);
     }
@@ skipping 33 matching lines @@
   }
 
   @override
   visitExportDirective(ExportDirective node) {
     ExportElement element = node.element;
     recordUriReference(element?.exportedLibrary, node);
     super.visitExportDirective(node);
   }
 
   @override
+  visitExtendsClause(ExtendsClause node) {
+    recordSuperType(node.superclass, IndexRelationKind.IS_EXTENDED_BY);
+  }
+
+  @override
   visitFunctionDeclaration(FunctionDeclaration node) {
     Element element = node.element;
     recordTopLevelElementDefinition(element);
     super.visitFunctionDeclaration(node);
   }
 
   @override
   visitFunctionTypeAlias(FunctionTypeAlias node) {
     Element element = node.element;
     recordTopLevelElementDefinition(element);
     super.visitFunctionTypeAlias(node);
   }
 
   @override
+  visitImplementsClause(ImplementsClause node) {
+    for (TypeName typeName in node.interfaces) {
+      recordSuperType(typeName, IndexRelationKind.IS_IMPLEMENTED_BY);
+    }
+  }
+
+  @override
   visitImportDirective(ImportDirective node) {
     ImportElement element = node.element;
     recordUriReference(element?.importedLibrary, node);
     super.visitImportDirective(node);
   }
 
   @override
   visitIndexExpression(IndexExpression node) {
     MethodElement element = node.bestElement;
     if (element is MethodElement) {
@@ skipping 68 matching lines @@
 //    if (location == null) {
 //      return;
 //    }
     // name in declaration
     if (node.inDeclarationContext()) {
       // TODO(scheglov) do we need this?
 //      recordRelationshipIndexable(
 //          indexableName, IndexConstants.NAME_IS_DEFINED_BY, location);
       return;
     }
-    // name in an extends/with/implements clause
-    if (_isInExtendsWithImplementsClause(node)) {
-      return;
-    }
     Element element = node.bestElement;
     // this.field parameter
     if (element is FieldFormalParameterElement) {
       recordRelation(element.field, IndexRelationKind.IS_REFERENCED_BY, node);
       return;
     }
     // record specific relations
     // TODO(scheglov) consider removing the conditions
     if (element is ClassElement ||
         element is FunctionElement ||
@@ skipping 19 matching lines @@
           element, IndexRelationKind.IS_REFERENCED_BY, offset, length);
     } else {
       int offset = node.superKeyword.end;
       recordRelationOffset(
           element, IndexRelationKind.IS_REFERENCED_BY, offset, 0);
     }
     super.visitSuperConstructorInvocation(node);
   }
 
   @override
+  visitTypeName(TypeName node) {
+    AstNode parent = node.parent;
+    if (parent is ClassTypeAlias && parent.superclass == node) {
+      recordSuperType(node, IndexRelationKind.IS_EXTENDED_BY);
+    } else {
+      super.visitTypeName(node);
+    }
+  }
+
+  @override
   visitVariableDeclaration(VariableDeclaration node) {
     VariableElement element = node.element;
     recordTopLevelElementDefinition(element);
     // TODO(scheglov) do we need this?
 //    // record declaration
 //    {
 //      SimpleIdentifier name = node.name;
 //      LocationImpl location = _createLocationForNode(name);
 //      location = _getLocationWithExpressionType(location, node.initializer);
 //      recordRelationshipElement(
 //          element, IndexConstants.NAME_IS_DEFINED_BY, location);
 //    }
     super.visitVariableDeclaration(node);
   }
 
-  static bool _isInExtendsWithImplementsClause(SimpleIdentifier node) {
-    TypeName typeName;
-    AstNode parent = node?.parent;
-    AstNode parent2 = parent?.parent;
-    if (parent is TypeName && parent.name == node) {
-      typeName = parent;
-    } else if (parent is PrefixedIdentifier &&
-        parent.identifier == node &&
-        parent2 is TypeName &&
-        parent2.name == node) {
-      typeName = parent2;
-    } else {
-      return false;
+  @override
+  visitWithClause(WithClause node) {
+    for (TypeName typeName in node.mixinTypes) {
+      recordSuperType(typeName, IndexRelationKind.IS_MIXED_IN_BY);
     }
-    AstNode clause = typeName.parent;
-    return clause is ExtendsClause ||
-        clause is WithClause ||
-        clause is ImplementsClause;
   }
 }
 
 /**
  * Information about a single relation.  Any [_RelationInfo] is always part
  * of a [_UnitIndexAssembler], so [offset] and [length] should be understood
  * within the context of the compilation unit pointed to by the
  * [_UnitIndexAssembler].
  */
 class _RelationInfo {
@@ skipping 37 matching lines @@
     });
     return new UnitIndexBuilder(
         elements: relations.map((r) => r.elementInfo.id).toList(),
         kinds: relations.map((r) => r.kind).toList(),
         locationOffsets: relations.map((r) => r.offset).toList(),
         locationLengths: relations.map((r) => r.length).toList(),
         libraryUri: pkg._getUriId(unitElement.library.source.uri),
         unitUri: pkg._getUriId(unitElement.source.uri));
   }
 }