Check for non-final field in the face of const constructors.

sdk/lib/_internal/compiler/implementation/resolution/members.dart

 // Copyright (c) 2012, 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.
 
 part of resolution;
 
 abstract class TreeElements {
   Element get currentElement;
   Set<Node> get superUses;
 
@@ skipping 318 matching lines @@
   }
 
   TreeElements resolveMethodElement(FunctionElement element) {
     assert(invariant(element, element.isDeclaration));
     return compiler.withCurrentElement(element, () {
       bool isConstructor =
           identical(element.kind, ElementKind.GENERATIVE_CONSTRUCTOR);
       TreeElements elements =
           compiler.enqueuer.resolution.getCachedElements(element);
       if (elements != null) {
-        assert(isConstructor);
+        assert(isConstructor || element.isFactoryConstructor());

[karlklose, 2013/09/05 12:43:42]

Remember to remove this when rebasing with my change.

[Johnni Winther, 2013/09/06 06:22:41]

Done.

         return elements;
       }
       if (element.isSynthesized) {
         Element target = element.targetConstructor;
         // Ensure the signature of the synthesized element is
         // resolved. This is the only place where the resolver is
         // seeing this element.
         element.computeSignature(compiler);
         if (!target.isErroneous()) {
           compiler.enqueuer.resolution.registerStaticUse(
@@ skipping 305 matching lines @@
           use,
           MessageKind.ILLEGAL_MIXIN_SUPER_USE);
     }
   }
 
   void checkClassMembers(ClassElement cls) {
     assert(invariant(cls, cls.isDeclaration));
     if (cls.isObject(compiler)) return;
     // TODO(johnniwinther): Should this be done on the implementation element as
     // well?
+    List<Element> constConstructors = <Element>[];
+    List<Element> nonFinalInstanceFields = <Element>[];
     cls.forEachMember((holder, member) {
       compiler.withCurrentElement(member, () {
         // Perform various checks as side effect of "computing" the type.
         member.computeType(compiler);
 
         // Check modifiers.
         if (member.isFunction() && member.modifiers.isFinal()) {
           compiler.reportError(
               member, MessageKind.ILLEGAL_FINAL_METHOD_MODIFIER);
         }
         if (member.isConstructor()) {
           final mismatchedFlagsBits =
               member.modifiers.flags &
               (Modifiers.FLAG_STATIC | Modifiers.FLAG_ABSTRACT);
           if (mismatchedFlagsBits != 0) {
             final mismatchedFlags =
                 new Modifiers.withFlags(null, mismatchedFlagsBits);
             compiler.reportError(
                 member,
                 MessageKind.ILLEGAL_CONSTRUCTOR_MODIFIERS,
                 {'modifiers': mismatchedFlags});
           }
+          if (member.modifiers.isConst()) {
+            constConstructors.add(member);
+          }
+        }
+        if (member.isField()) {
+          if (!member.modifiers.isStatic() &&
+              !member.modifiers.isFinal()) {
+            nonFinalInstanceFields.add(member);
+          }
         }
         checkAbstractField(member);
         checkValidOverride(member, cls.lookupSuperMember(member.name));
         checkUserDefinableOperator(member);
       });
     });
+    if (!constConstructors.isEmpty && !nonFinalInstanceFields.isEmpty) {
+      if (constConstructors.length == 1) {
+        compiler.reportError(constConstructors[0],
+            MessageKind.CONST_CONSTRUCTOR_WITH_NONFINAL_FIELDS,
+            {'className': cls.name});
+      } else {
+        compiler.reportError(cls,

[karlklose, 2013/09/05 12:43:42]

Move the call out of the if and compute the Spannable as:
  Spannable span = constConstructors.length > 1
      ? cls : constConstructors[0];

[Johnni Winther, 2013/09/06 06:22:41]

Done.

+            MessageKind.CONST_CONSTRUCTOR_WITH_NONFINAL_FIELDS,
+            {'className': cls.name});
+        for (Element constructor in constConstructors) {
+          compiler.reportInfo(constructor,
+              MessageKind.CONST_CONSTRUCTOR_WITH_NONFINAL_FIELDS_CONSTRUCTOR);
+        }
+      }
+      for (Element field in nonFinalInstanceFields) {
+        compiler.reportInfo(field,
+            MessageKind.CONST_CONSTRUCTOR_WITH_NONFINAL_FIELDS_FIELD);
+      }
+    }
   }
 
   void checkAbstractField(Element member) {
     // Only check for getters. The test can only fail if there is both a setter
     // and a getter with the same name, and we only need to check each abstract
     // field once, so we just ignore setters.
     if (!member.isGetter()) return;
 
     // Find the associated abstract field.
     ClassElement classElement = member.getEnclosingClass();
@@ skipping 2005 matching lines @@
     if (!symbolValidationPattern.hasMatch(name)) {
       if (reportError) {
         compiler.reportError(node, MessageKind.INVALID_SYMBOL,
                              {'value': name});
       }
       return false;
     }
     return true;
   }
 
-
   /**
    * Try to resolve the constructor that is referred to by [node].
    * Note: this function may return an ErroneousFunctionElement instead of
    * [null], if there is no corresponding constructor, class or library.
    */
   FunctionElement resolveConstructor(NewExpression node) {
     return node.accept(new ConstructorResolver(compiler, this));
   }
 
   FunctionElement resolveRedirectingFactory(Return node) {
@@ skipping 1385 matching lines @@
     return e;
   }
 
   /// Assumed to be called by [resolveRedirectingFactory].
   Element visitReturn(Return node) {
     Node expression = node.expression;
     return finishConstructorReference(visit(expression),
                                       expression, expression);
   }
 }