Issue 1105: Duplicate initialization should have a compile error

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 159 matching lines @@
   @VisibleForTesting
   public class ResolveElementsVisitor extends ResolveVisitor {
     private EnclosingElement currentHolder;
     private MethodElement currentMethod;
     private boolean inInitializer;
     private MethodElement innermostFunction;
     private ResolutionContext context;
     private LabelElement currentLabel;
     private Set<LabelElement> referencedLabels = Sets.newHashSet();
     private Set<LabelElement> labelsInScopes = Sets.newHashSet();
-    private Set<String> finalsNeedingInitializing = Sets.newHashSet();
+    private Set<FieldElement> finalsNeedingInitializing = Sets.newHashSet();
 
     @VisibleForTesting
     public ResolveElementsVisitor(ResolutionContext context,
                                   EnclosingElement currentHolder,
                                   MethodElement currentMethod) {
       super(typeProvider);
       this.context = context;
       this.currentMethod = currentMethod;
       this.innermostFunction = currentMethod;
       this.currentHolder = currentHolder;
@@ skipping 361 matching lines @@
     @Override
     public MethodElement visitMethodDefinition(DartMethodDefinition node) {
       MethodElement member = node.getSymbol();
       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();
-      Set<String> initalizedFinals = Sets.newHashSet();
+      Set<FieldElement> initializedFields = Sets.newHashSet();
 
       // 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);
-          if (!initalizedFinals.add(parameter.getParameterName())) {
-            onError(parameter, ResolverErrorCode.DUPLICATE_PARAMETER, parameter.getName());
-          }
         } else {
           getContext().declare(
               parameter.getSymbol(),
               ResolverErrorCode.DUPLICATE_PARAMETER,
               ResolverErrorCode.DUPLICATE_PARAMETER_WARNING);
         }
       }
       for (DartParameter parameter : parameters) {
         // Then resolve the default values.
         resolve(parameter.getDefaultExpr());
+        if (parameter.getQualifier() instanceof DartThisExpression && parameter.getSymbol() != null
+            && !initializedFields.add(parameter.getSymbol().getParameterInitializerElement())) {
+          onError(parameter, ResolverErrorCode.DUPLICATE_INITIALIZATION, parameter.getName());
+        }
       }
 
       if ((functionNode.getBody() == null)
           && !Elements.isNonFactoryConstructor(member)
           && !member.getModifiers().isAbstract()
           && !member.getEnclosingElement().isInterface()) {
         onError(functionNode, ResolverErrorCode.METHOD_MUST_HAVE_BODY);
       }
       resolve(functionNode.getBody());
 
       if (Elements.isNonFactoryConstructor(member)) {
-        resolveInitializers(node, initalizedFinals);
+        resolveInitializers(node, initializedFields);
         // Test for missing final initialized fields
-        if (!this.currentHolder.isInterface() && !member.getModifiers().isRedirectedConstructor()
-            && !finalsNeedingInitializing.equals(initalizedFinals)) {
-          for (String field : this.finalsNeedingInitializing) {
-            if (!initalizedFinals.contains(field)) {
-              onError(node.getName(), ResolverErrorCode.FINAL_FIELD_MUST_BE_INITIALIZED, field);
+        if (!this.currentHolder.isInterface() && !member.getModifiers().isRedirectedConstructor()) {
+          for (FieldElement finalField : this.finalsNeedingInitializing) {
+            if (!initializedFields.contains(finalField)) {
+              onError(node.getName(), ResolverErrorCode.FINAL_FIELD_MUST_BE_INITIALIZED,
+                  finalField.getName());
             }
           }
         }
       }
 
       // If this method is an override, make sure its signature roughly matches any superclass
       // declaration.
       if (ElementKind.of(currentHolder).equals(ElementKind.CLASS)) {
         // Look for this method in super implementations.
         ClassElement classElement = (ClassElement) currentHolder;
@@ skipping 79 matching lines @@
         Element element = node.getSymbol();
         if (expression.getType() != null) {
           Elements.setType(element, expression.getType());
         }
       } else if (isFinal) {
         if (isStatic) {
           onError(node, ResolverErrorCode.STATIC_FINAL_REQUIRES_VALUE);
         } else {
           // If a final instance field wasn't initialized at declaration, we must check
           // at construction time.
-          this.finalsNeedingInitializing.add(node.getName().getTargetName());
+          this.finalsNeedingInitializing.add(node.getSymbol());
         }
       }
 
       // If field is an accessor, both getter and setter need to be visited (if present).
       FieldElement field = node.getSymbol();
       if (field.getGetter() != null) {
         resolve(field.getGetter().getNode());
       }
       if (field.getSetter() != null) {
         resolve(field.getSetter().getNode());
@@ skipping 1015 matching lines @@
         // If no type specified, use type of field.
         if (parameter.getTypeNode() == null && element != null) {
           Elements.setType(parameter.getSymbol(), element.getType());
         }
       } else {
         onError(parameter.getName(),
             ResolverErrorCode.PARAMETER_INIT_OUTSIDE_CONSTRUCTOR);
       }
     }
 
-    private void resolveInitializers(DartMethodDefinition node, Set<String> intializedFields) {
+    private void resolveInitializers(DartMethodDefinition node, Set<FieldElement> intializedFields) {
       Iterator<DartInitializer> initializers = node.getInitializers().iterator();
       ConstructorElement constructorElement = null;
       while (initializers.hasNext()) {
         DartInitializer initializer = initializers.next();
         Element element = resolve(initializer);
         if ((ElementKind.of(element) == ElementKind.CONSTRUCTOR) && initializer.isInvocation()) {
           constructorElement = (ConstructorElement) element;
         } else if (initializer.getName() != null && initializer.getName().getSymbol() != null
             && initializer.getName().getSymbol().getModifiers() != null
-            && initializer.getName().getSymbol().getModifiers().isFinal()
-            && !intializedFields.add(initializer.getName().getTargetName())) {
-          onError(initializer, ResolverErrorCode.DUPLICATE_PARAMETER, initializer.getName());
+            && !intializedFields.add((FieldElement)initializer.getName().getTargetSymbol())) {
+          onError(initializer, ResolverErrorCode.DUPLICATE_INITIALIZATION, initializer.getName());
         }
       }
 
       checkConstructor(node, constructorElement);
     }
 
     private void onError(DartNode node, ErrorCode errorCode, Object... arguments) {
       context.onError(node, errorCode, arguments);
     }
 
@@ skipping 71 matching lines @@
         ClassElement nextClass = (ClassElement) nextConstructorElement.getEnclosingElement();
         ClassElement currentClass = (ClassElement) constructor.getEnclosingElement();
         if (nextClass.getName().equals(currentClass.getName())) {
           return nextConstructorElement;
         }
       }
     }
     return null;
   }
 }