Fail inference when an instance field is referenced.

pkg/analyzer/lib/src/task/strong_mode.dart

 // Copyright (c) 2015, 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.task.strong_mode;
 
 import 'dart:collection';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/visitor.dart';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
 import 'package:analyzer/src/dart/element/element.dart';
 import 'package:analyzer/src/dart/element/type.dart';
 import 'package:analyzer/src/dart/resolver/inheritance_manager.dart';
 import 'package:analyzer/src/generated/resolver.dart'
     show TypeProvider, InheritanceManager;
 import 'package:analyzer/src/generated/type_system.dart';
 import 'package:analyzer/src/generated/utilities_dart.dart';
 
 /**
+ * Return `true` if the given [expression] is an immediately-evident expression,
+ * so can be used to infer the type for a top-level variable or a class field.
+ */
+bool isValidForTypeInference(Expression expression) {
+  var visitor = new _IsValidForTypeInferenceVisitor();
+  expression.accept(visitor);
+  return visitor.isValid;
+}
+
+/**
  * Sets the type of the field. This is stored in the field itself, and the
  * synthetic getter/setter types.
  */
 void setFieldType(VariableElement field, DartType newType) {
   (field as VariableElementImpl).type = newType;
   if (field.initializer != null) {
     (field.initializer as ExecutableElementImpl).returnType = newType;
   }
 }
 
@@ skipping 31 matching lines @@
    * The type system used to compute the least upper bound of types.
    */
   TypeSystem typeSystem;
 
   /**
    * The inheritance manager used to find overridden method.
    */
   final InheritanceManager inheritanceManager;
 
   /**
+   * The set of fields for which type inference from initializer should be
+   * disabled, because their initializers are not immediately-evident
+   * expressions.
+   */
+  final Set<FieldElement> fieldsWithDisabledInitializerInference;
+
+  /**
    * The classes that have been visited while attempting to infer the types of
    * instance members of some base class.
    */
   HashSet<ClassElementImpl> elementsBeingInferred =
       new HashSet<ClassElementImpl>();
 
   /**
    * Initialize a newly create inferrer.
    */
   InstanceMemberInferrer(TypeProvider typeProvider, this.inheritanceManager,
+      this.fieldsWithDisabledInitializerInference,
       {TypeSystem typeSystem})
       : typeSystem = (typeSystem != null)
             ? typeSystem
             : new TypeSystemImpl(typeProvider),
         this.typeProvider = typeProvider;
 
   /**
    * Infer type information for all of the instance members in the given
    * compilation [unit].
    */
@@ skipping 263 matching lines @@
       //
       // If there is no overridden getter or if the overridden getter's type is
       // dynamic, then we can infer the type from the initialization expression
       // without breaking subtype rules. We could potentially infer a consistent
       // return type even if the overridden getter's type was not dynamic, but
       // choose not to for simplicity. The field is required to be final to
       // prevent choosing a type that is inconsistent with assignments we cannot
       // analyze.
       //
       if (newType == null || newType.isDynamic) {
-        if (fieldElement.initializer != null &&
+        FunctionElement initializer = fieldElement.initializer;
+        if (initializer != null &&
             (fieldElement.isFinal || overriddenGetters.isEmpty)) {
-          newType = fieldElement.initializer.returnType;
+          if (!fieldsWithDisabledInitializerInference.contains(fieldElement)) {
+            newType = initializer.returnType;
+          }
         }
       }
       if (newType == null || newType.isBottom || newType.isDartCoreNull) {
         newType = typeProvider.dynamicType;
       }
       setFieldType(fieldElement, newType);
     }
   }
 
   void _inferFieldFormalParameter(FieldFormalParameterElementImpl element) {
@@ skipping 108 matching lines @@
   void visitSimpleIdentifier(SimpleIdentifier node) {
     if (!node.inDeclarationContext()) {
       Element nonAccessor(Element element) {
         if (element is PropertyAccessorElement && element.isSynthetic) {
           return element.variable;
         }
         return element;
       }
 
       Element element = nonAccessor(node.staticElement);
-      if (element is VariableElement && (filter == null || filter(element))) {
-        results.add(element);
+      if (element is VariableElement) {
+        if (filter == null || filter(element)) {
+          results.add(element);
+        }
       }
     }
   }
 }
 
 /**
  * A class of exception that is not used anywhere else.
  */
 class _CycleException implements Exception {}
+
+/**
+ * The visitor for [isValidForTypeInference].
+ */
+class _IsValidForTypeInferenceVisitor extends RecursiveAstVisitor {
+  bool isValid = true;
+
+  @override
+  void visitAssignmentExpression(AssignmentExpression node) {
+    isValid = false;
+  }
+
+  @override
+  void visitCascadeExpression(CascadeExpression node) {
+    node.target.accept(this);
+  }
+
+  @override
+  void visitSimpleIdentifier(SimpleIdentifier node) {
+    Element element = node.staticElement;
+    if (element == null) {
+      AstNode parent = node.parent;
+      if (parent is PropertyAccess && parent.propertyName == node ||
+          parent is PrefixedIdentifier && parent.identifier == node) {
+        isValid = false;
+      }
+    } else if (element is PropertyAccessorElement && !element.isStatic) {
+      isValid = false;
+    }
+  }
+}