Compute propagated type for final instance fields (partially addresses issue 23001)

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:collection';
 
 import 'package:analyzer/src/generated/scanner.dart';
 
@@ skipping 10903 matching lines @@
     //
     // Continue the class resolution.
     //
     enclosingClass = node.element;
     typeAnalyzer.thisType = enclosingClass == null ? null : enclosingClass.type;
     node.accept(elementResolver);
     node.accept(typeAnalyzer);
   }
 
   @override
+  void visitClassMembersInScope(ClassDeclaration node) {
+    safelyVisit(node.documentationComment);
+    node.metadata.accept(this);
+    //
+    // Visit the fields before other members so that instance fields will have
+    // propagated types associated with them before we see their use sites.
+    //
+    List<ClassMember> nonFields = <ClassMember>[];
+    for (ClassMember member in node.members) {
+      if (member is FieldDeclaration) {
+        member.accept(this);
+      } else {
+        nonFields.add(member);
+      }
+    }
+    for (ClassMember member in nonFields) {
+      member.accept(this);
+    }
+  }
+
+  @override
   Object visitComment(Comment node) {
     if (node.parent is FunctionDeclaration ||
         node.parent is ConstructorDeclaration ||
         node.parent is MethodDeclaration) {
       if (!identical(node, _commentBeforeFunction)) {
         _commentBeforeFunction = node;
         return null;
       }
     }
     super.visitComment(node);
@@ skipping 591 matching lines @@
     return null;
   }
 
   @override
   Object visitTypeName(TypeName node) => null;
 
   @override
   Object visitVariableDeclaration(VariableDeclaration node) {
     super.visitVariableDeclaration(node);
     VariableElement element = node.element;
-    if (element.initializer != null && node.initializer != null) {
-      (element.initializer as FunctionElementImpl).returnType =
-          node.initializer.staticType;
+    FunctionElement initializerElement = element.initializer;
+    Expression initializer = node.initializer;
+    if (initializerElement is FunctionElementImpl && initializer != null) {
+      initializerElement.returnType = initializer.staticType;
+    }
+    //
+    // Propagate types for instance fields. Top-level variables and static
+    // fields are handled elsewhere.
+    //
+    if (initializer != null &&
+        element is FieldElementImpl &&
+        !element.isStatic &&
+        (element.isFinal || element.isConst)) {

[Paul Berry, 2015/10/29 17:49:17]

Isn't the test for `element.isConst` redundant?  I thought that all consts had
to be static, and we're already checking for `!element.isStatic`.

[Brian Wilkerson, 2015/10/29 18:31:04]

Actually, no. With illegal code, such as "const int f;" we will put the "const"
flag on the instance field's element. But I'm fine with removing the test; it
just means we won't have a propagated type for the invalid field.

+      DartType staticType = element.type;
+      DartType bestType = initializer.bestType;
+      if (bestType != null &&
+          bestType != staticType &&
+          bestType.isMoreSpecificThan(staticType)) {
+        element.propagatedType = bestType;
+      }
     }
     // 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).
     if ((element.isConst ||
             (element is FieldElement &&
                 element.isFinal &&
                 !element.isStatic)) &&
-        node.initializer != null) {
+        initializer != null) {
       (element as ConstVariableElement).constantInitializer =
-          new ConstantAstCloner().cloneNode(node.initializer);
+          new ConstantAstCloner().cloneNode(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;
     try {
@@ skipping 4535 matching lines @@
     nonFields.add(node);
     return null;
   }
 
   @override
   Object visitNode(AstNode node) => node.accept(TypeResolverVisitor_this);
 
   @override
   Object visitWithClause(WithClause node) => null;
 }