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';
@@ skipping 11 matching lines @@
  * 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;
   }
 }
 
+bool hasInstanceGetterReference(Expression expression) {
+  var visitor = new _InstanceGetterReferenceVisitor();
+  expression.accept(visitor);
+  return visitor.hasInstanceFieldOrGetterReference;
+}
+
 /**
  * Return the element for the single parameter of the given [setter], or `null`
  * if the executable element is not a setter or does not have a single
  * parameter.
  */
 ParameterElement _getParameter(ExecutableElement setter) {
   if (setter is PropertyAccessorElement && setter.isSetter) {
     List<ParameterElement> parameters = setter.parameters;
     if (parameters.length == 1) {
       return parameters[0];
@@ skipping 314 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;
+          newType = initializer.returnType;
         }
       }
       if (newType == null || newType.isBottom || newType.isDartCoreNull) {
         newType = typeProvider.dynamicType;
       }
       setFieldType(fieldElement, newType);
     }
   }
 
   void _inferFieldFormalParameter(FieldFormalParameterElementImpl element) {
@@ skipping 91 matching lines @@
    * The filter used to limit which variables are gathered, or `null` if no
    * filtering is to be performed.
    */
   final VariableFilter filter;
 
   /**
    * The variables that were found.
    */
   final Set<VariableElement> results = new HashSet<VariableElement>();
 
+  bool hasInstanceFieldOrGetterReference = false;
+
   /**
    * Initialize a newly created gatherer to gather all of the variables that
    * pass the given [filter] (or all variables if no filter is provided).
    */
   VariableGatherer([this.filter = null]);
 
   @override
   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 == null) {
+//        AstNode parent = node.parent;
+//        if (parent is PropertyAccess && parent.propertyName == node ||
+//            parent is PrefixedIdentifier && parent.identifier == node) {
+//          hasInstanceFieldOrGetterReference = true;
+//        }
+//      } else
+      if (element is FieldElement && !element.isStatic ||
+          element is PropertyAccessorElement && !element.isStatic) {
+        hasInstanceFieldOrGetterReference = true;
+      }
+
+      if (element is VariableElement) {
+        if (filter == null || filter(element)) {
+          results.add(element);
+        }
       }
     }
   }
 }
+
+class _InstanceGetterReferenceVisitor extends RecursiveAstVisitor {
+  bool hasInstanceFieldOrGetterReference = false;
+
+  @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) {
+        hasInstanceFieldOrGetterReference = true;
+      }
+    } else if (element is PropertyAccessorElement && !element.isStatic) {
+      hasInstanceFieldOrGetterReference = true;
+    }
+  }
+}
 
 /**
  * A class of exception that is not used anywhere else.
  */
 class _CycleException implements Exception {}