In constant evaluation, handle final vars initialized at declaration site.

pkg/analyzer/lib/src/generated/resolver.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 engine.resolver;
 
 import "dart:math" as math;
 import 'dart:collection';
 
 import 'package:analyzer/src/generated/utilities_collection.dart';
@@ skipping 3044 matching lines @@
 
   @override
   Object visitVariableDeclaration(VariableDeclaration node) {
     bool isConst = node.isConst;
     bool isFinal = node.isFinal;
     bool hasInitializer = node.initializer != null;
     VariableElementImpl element;
     if (_inFieldContext) {
       SimpleIdentifier fieldName = node.name;
       FieldElementImpl field;
-      if (isConst && hasInitializer) {
+      if ((isConst || isFinal) && hasInitializer) {
         field = new ConstFieldElementImpl.con1(fieldName);
       } else {
         field = new FieldElementImpl.forNode(fieldName);
       }
       element = field;
       _currentHolder.addField(field);
       fieldName.staticElement = field;
     } else if (_inFunction) {
       SimpleIdentifier variableName = node.name;
       LocalVariableElementImpl variable;
@@ skipping 8222 matching lines @@
     }
     return null;
   }
 
   @override
   Object visitTypeName(TypeName node) => null;
 
   @override
   Object visitVariableDeclaration(VariableDeclaration node) {
     super.visitVariableDeclaration(node);
-    if (node.element.isConst && node.initializer != null) {
-      (node.element as ConstVariableElement).constantInitializer =
+    VariableElement element = node.element;
+    // Note: in addition to cloning the initializers for const variables, we
+    // have to clone the initializers for non-static final fields (because if
+    // they occur in a class with a const constructor, they will be needed to
+    // evaluate the const constructor).

[Brian Wilkerson, 2015/04/22 02:44:00]

Do we really need the AST structure? The initializer for a final field has to be
a constant expression. We should just need the value, not the ability to
evaluate it each time we find an invocation of the constructor.

[Paul Berry, 2015/04/24 18:06:33]

(Capturing the result of an in-person discussion)

Yes, we need it for integration with the new task model.  Otherwise at the time
that we evaluate the constant there is no guarantee that the AST will still be
around (or, if it is still around, that we'll be able to get to it).  And we
can't just carry around a pointer to the original AST, since the targets that
will be used for constant evaluation in the new task model will be long-lived,
and we don't want to prevent the garbage collector from collecting the AST once
analysis of a file is done.

+    if ((element.isConst ||
+            (element is FieldElement &&
+                element.isFinal &&
+                !element.isStatic)) &&
+        node.initializer != null) {
+      (element as ConstVariableElement).constantInitializer =
           new ConstantAstCloner().cloneNode(node.initializer);
     }
     return null;
   }
 
   @override
   Object visitWhileStatement(WhileStatement node) {
     // Note: since we don't call the base class, we have to maintain
     // _implicitLabelScope ourselves.
     ImplicitLabelScope outerImplicitScope = _implicitLabelScope;
@@ skipping 4091 matching lines @@
     nonFields.add(node);
     return null;
   }
 
   @override
   Object visitNode(AstNode node) => node.accept(TypeResolverVisitor_this);
 
   @override
   Object visitWithClause(WithClause node) => null;
 }