Build / resynthesize final fields as ConstFieldElementImpl only if the enclosing class has a consta…

pkg/analyzer/lib/src/dart/element/builder.dart

 // Copyright (c) 2014, 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.
 
 library analyzer.src.dart.element.builder;
 
 import 'dart:collection';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart';
@@ skipping 17 matching lines @@
  * build elements outside of function bodies and initializers.
  */
 class ApiElementBuilder extends _BaseElementBuilder {
   /**
    * A table mapping field names to field elements for the fields defined in the current class, or
    * `null` if we are not in the scope of a class.
    */
   HashMap<String, FieldElement> _fieldMap;
 
   /**
+   * Whether the class being built has a constant constructor.
+   */
+  bool _enclosingClassHasConstConstructor = false;
+
+  /**
    * Initialize a newly created element builder to build the elements for a
    * compilation unit. The [initialHolder] is the element holder to which the
    * children of the visited compilation unit node will be added.
    */
   ApiElementBuilder(ElementHolder initialHolder,
       CompilationUnitElementImpl compilationUnitElement)
       : super(initialHolder, compilationUnitElement);
 
   @override
   Object visitAnnotation(Annotation node) {
@@ skipping 13 matching lines @@
     return null;
   }
 
   @override
   Object visitBlockFunctionBody(BlockFunctionBody node) {
     return null;
   }
 
   @override
   Object visitClassDeclaration(ClassDeclaration node) {
+    _enclosingClassHasConstConstructor = false;
+    for (var constructor in node.members) {
+      if (constructor is ConstructorDeclaration &&
+          constructor.constKeyword != null) {
+        _enclosingClassHasConstConstructor = true;
+        break;
+      }
+    }
+
     ElementHolder holder = new ElementHolder();
     //
     // Process field declarations before constructors and methods so that field
     // formal parameters can be correctly resolved to their fields.
     //
     ElementHolder previousHolder = _currentHolder;
     _currentHolder = holder;
     try {
       List<ClassMember> nonFields = new List<ClassMember>();
       node.visitChildren(
@@ skipping 518 matching lines @@
     bool isFinal = node.isFinal;
     Expression initializerNode = node.initializer;
     bool hasInitializer = initializerNode != null;
     VariableDeclarationList varList = node.parent;
     FieldDeclaration fieldNode =
         varList.parent is FieldDeclaration ? varList.parent : null;
     VariableElementImpl element;
     if (fieldNode != null) {
       SimpleIdentifier fieldName = node.name;
       FieldElementImpl field;
-      if ((isConst || isFinal && !fieldNode.isStatic) && hasInitializer) {
+      if ((isConst ||
+              isFinal &&
+                  !fieldNode.isStatic &&
+                  _enclosingClassHasConstConstructor) &&
+          hasInitializer) {
         field = new ConstFieldElementImpl.forNode(fieldName);
       } else {
         field = new FieldElementImpl.forNode(fieldName);
       }
       element = field;
       field.isCovariant = fieldNode.covariantKeyword != null;
       field.isStatic = fieldNode.isStatic;
       _setCodeRange(element, node);
       setElementDocumentationComment(element, fieldNode);
       field.hasImplicitType = varList.type == null;
@@ skipping 1048 matching lines @@
     return null;
   }
 
   /**
    * Return the lexical identifiers associated with the given [identifiers].
    */
   static List<String> _getIdentifiers(NodeList<SimpleIdentifier> identifiers) {
     return identifiers.map((identifier) => identifier.name).toList();
   }
 }