Issue 991: Missing compiler errors for uninitialized final fields

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();
 
     @VisibleForTesting
     public ResolveElementsVisitor(ResolutionContext context,
                                   EnclosingElement currentHolder,
                                   MethodElement currentMethod) {
       super(typeProvider);
       this.context = context;
       this.currentMethod = currentMethod;
       this.innermostFunction = currentMethod;
       this.currentHolder = currentHolder;
@@ skipping 43 matching lines @@
       }
 
       checkClassTypeVariables(classElement);
 
       // Push new resolution context.
       ResolutionContext previousContext = context;
       EnclosingElement previousHolder = currentHolder;
       currentHolder = classElement;
       context = topLevelContext.extend(classElement);
 
+      this.finalsNeedingInitializing.clear();
       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)) {
@@ skipping 264 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();
 
       // 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 ((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);
+        resolveInitializers(node, initalizedFinals);
+        // 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 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;
         try {
           for (InterfaceType supertype : classElement.getAllSupertypes()) {
             Member superMember = supertype.lookupMember(member.getName());
@@ skipping 70 matching lines @@
         modifiers.makeStatic();
       }
 
       if (expression != null) {
         resolve(expression);
         // Now, this constant has a type. Save it for future reference.
         Element element = node.getSymbol();
         if (expression.getType() != null) {
           Elements.setType(element, expression.getType());
         }
-      } else if (isStatic && isFinal) {
-        onError(node, ResolverErrorCode.STATIC_FINAL_REQUIRES_VALUE);
+      } 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());
+        }
       }
 
       // 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 1014 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) {
+    private void resolveInitializers(DartMethodDefinition node, Set<String> 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());
         }
       }
 
       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;
   }
 }