Report errors and warnings for hiding elements, issue 572.

compiler/java/com/google/dart/compiler/resolver/Resolver.java

 // Copyright (c) 2011, 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.
 
 package com.google.dart.compiler.resolver;
 
 import com.google.common.annotations.VisibleForTesting;
 import com.google.common.collect.Sets;
 import com.google.dart.compiler.DartCompilationPhase;
 import com.google.dart.compiler.DartCompilerContext;
@@ skipping 209 matching lines @@
       } catch (CyclicDeclarationException e) {
         DartNode node = e.getElement().getNode();
         if (node == null) {
           node = cls;
         }
         onError(node, ResolverErrorCode.CYCLIC_CLASS, e.getElement().getName());
       } catch (DuplicatedInterfaceException e) {
         onError(cls, ResolverErrorCode.DUPLICATED_INTERFACE,
                         e.getFirst(), e.getSecond());
       }
+
+      checkClassTypeVariables(classElement);
+      
+      // Push new resolution context.
       ResolutionContext previousContext = context;
       EnclosingElement previousHolder = currentHolder;
       currentHolder = classElement;
       context = topLevelContext.extend(classElement);
 
       for (Element element : classElement.getMembers()) {
         element.getNode().accept(this);
       }
 
       for (Element element : classElement.getConstructors()) {
         element.getNode().accept(this);
       }
 
       checkRedirectConstructorCycle(classElement.getConstructors(), context);
       if (Elements.needsImplicitDefaultConstructor(classElement)) {
         checkImplicitDefaultDefaultSuperInvocation(cls, classElement);
       }
 
       // Check that interface constructors have corresponding methods in default class.
       if (cls.getDefaultClass() != null) {
         checkInteraceConstructors(classElement);
       }
 
       context = previousContext;
       currentHolder = previousHolder;
       return classElement;
     }
 
     /**
+     * Check that used type variables are unique and don't shadow and existing elements.
+     */
+    private void checkClassTypeVariables(ClassElement classElement) {
+      Scope scope = context.getScope();
+      Set<String> declaredVariableNames = Sets.newHashSet();
+      for (Type type : classElement.getTypeParameters()) {
+        if (type instanceof TypeVariable) {
+          Element typeVariableElement = type.getElement();
+          String name = typeVariableElement.getName();
+          // Check that type variables are unique in this Class  declaration.
+          if (declaredVariableNames.contains(name)) {
+            onError(typeVariableElement.getNode(), ResolverErrorCode.DUPLICATE_TYPE_VARIABLE, name);
+          } else {
+            declaredVariableNames.add(name);
+          }
+          // Check that type variable is not shadowing any element in enclosing context.
+          Element existingElement = scope.findElement(scope.getLibrary(), name);
+          if (existingElement != null) {
+            onError(
+                typeVariableElement.getNode(),
+                ResolverErrorCode.DUPLICATE_TYPE_VARIABLE_WARNING,
+                name,
+                existingElement,
+                Elements.getRelativeElementLocation(typeVariableElement, existingElement));
+          }
+        }
+      }
+    }
+
+    /**
      * Checks that interface constructors have corresponding methods in default class.
      */
     private void checkInteraceConstructors(ClassElement interfaceElement) {
       String interfaceClassName = interfaceElement.getName();
       String defaultClassName = interfaceElement.getDefaultClass().getElement().getName();
       for (ConstructorElement interfaceConstructor : interfaceElement.getConstructors()) {
         ConstructorElement defaultConstructor =
             resolveInterfaceConstructorInDefaultClass(
                 interfaceConstructor.getNode(),
                 interfaceConstructor);
@@ skipping 85 matching lines @@
       ResolutionContext previousContext = context;
       context = context.extend(member.getName());
       assert currentMethod == null : "Nested methods?";
       innermostFunction = currentMethod = member;
 
       DartFunction functionNode = node.getFunction();
       List<DartParameter> parameters = functionNode.getParams();
 
       FunctionType type = (FunctionType) member.getType();
       for (TypeVariable typeVariable : type.getTypeVariables()) {
-        context.declare(typeVariable.getElement());
+        context.declare(
+            typeVariable.getElement(),
+            ResolverErrorCode.DUPLICATE_TYPE_VARIABLE,
+            ResolverErrorCode.DUPLICATE_TYPE_VARIABLE_WARNING);
       }
 
       // First declare all normal parameters in the scope, putting them in the
       // scope of the default expressions so we can report better errors.
       for (DartParameter parameter : parameters) {
         assert parameter.getSymbol() != null;
         if (parameter.getQualifier() instanceof DartThisExpression) {
           checkParameterInitializer(node, parameter);
         } else {
-          getContext().declare(parameter.getSymbol());
+          getContext().declare(
+              parameter.getSymbol(),
+              ResolverErrorCode.DUPLICATE_PARAMETER,
+              ResolverErrorCode.DUPLICATE_PARAMETER_WARNING);
         }
       }
       for (DartParameter parameter : parameters) {
         // Then resolve the default values.
         resolve(parameter.getDefaultExpr());
       }
 
       if ((functionNode.getBody() == null)
           && !Elements.isNonFactoryConstructor(member)
           && !member.getModifiers().isAbstract()
@@ skipping 117 matching lines @@
 
     @Override
     public Element visitFunction(DartFunction node) {
       throw context.internalError(node, "should not be called.");
     }
 
     @Override
     public Element visitParameter(DartParameter x) {
       Element element = super.visitParameter(x);
       resolve(x.getDefaultExpr());
-      getContext().declare(element);
+      getContext().declare(
+          element,
+          ResolverErrorCode.DUPLICATE_PARAMETER,
+          ResolverErrorCode.DUPLICATE_PARAMETER_WARNING);
       return element;
     }
 
     public Element resolveVariable(DartVariable x, Modifiers modifiers) {
       // Visit the initializer first.
       resolve(x.getValue());
       VariableElement element = Elements.variableElement(x, x.getVariableName(), modifiers);
-      getContext().declare(recordElement(x, element));
+      getContext().declare(
+          recordElement(x, element),
+          ResolverErrorCode.DUPLICATE_LOCAL_VARIABLE_ERROR,
+          ResolverErrorCode.DUPLICATE_LOCAL_VARIABLE_WARNING);
       return element;
     }
 
     @Override
     public Element visitVariableStatement(DartVariableStatement node) {
       resolveVariableStatement(node, false);
       return null;
     }
 
     private void resolveVariableStatement(DartVariableStatement node,
@@ skipping 1051 matching lines @@
         ClassElement nextClass = (ClassElement) nextConstructorElement.getEnclosingElement();
         ClassElement currentClass = (ClassElement) constructor.getEnclosingElement();
         if (nextClass.getName().equals(currentClass.getName())) {
           return nextConstructorElement;
         }
       }
     }
     return null;
   }
 }