Fail inference when an instance field is referenced.

pkg/analyzer/lib/src/task/dart.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.dart;
 
 import 'dart:collection';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/standard_resolution_map.dart';
@@ skipping 369 matching lines @@
     new ListResultDescriptor<AnalysisError>(
         'HINT_ERRORS', AnalysisError.NO_ERRORS);
 
 /**
  * The ignore information for a [Source].
  */
 final ResultDescriptor<IgnoreInfo> IGNORE_INFO =
     new ResultDescriptor<IgnoreInfo>('IGNORE_INFO', null);
 
 /**
+ * This result is `true` if the variable references an instance field or
+ * an instance getter.
+ *
+ * The result is only available for [VariableElement]s, and only when strong
+ * mode is enabled.
+ */
+final ResultDescriptor<bool> INFERABLE_VARIABLE_REFERENCES_INSTANCE_FIELD =
+    new ResultDescriptor<bool>(
+        'INFERABLE_VARIABLE_REFERENCES_INSTANCE_FIELD', false);
+
+/**
  * A list of the [VariableElement]s whose type should be inferred that another
  * inferable static variable (the target) depends on.
  *
  * The result is only available for [VariableElement]s, and only when strong
  * mode is enabled.
  */
 final ListResultDescriptor<VariableElement>
     INFERABLE_STATIC_VARIABLE_DEPENDENCIES =
     new ListResultDescriptor<VariableElement>(
         'INFERABLE_STATIC_VARIABLE_DEPENDENCIES', null);
@@ skipping 1731 matching lines @@
 class ComputeInferableStaticVariableDependenciesTask
     extends InferStaticVariableTask {
   /**
    * The name of the [RESOLVED_UNIT7] input.
    */
   static const String UNIT_INPUT = 'UNIT_INPUT';
 
   static final TaskDescriptor DESCRIPTOR = new TaskDescriptor(
       'ComputeInferableStaticVariableDependenciesTask',
       createTask,
-      buildInputs,
-      <ResultDescriptor>[INFERABLE_STATIC_VARIABLE_DEPENDENCIES]);
+      buildInputs, <ResultDescriptor>[
+    INFERABLE_STATIC_VARIABLE_DEPENDENCIES,
+    INFERABLE_VARIABLE_REFERENCES_INSTANCE_FIELD
+  ]);
 
   ComputeInferableStaticVariableDependenciesTask(
       InternalAnalysisContext context, VariableElement variable)
       : super(context, variable);
 
   @override
   TaskDescriptor get descriptor => DESCRIPTOR;
 
   @override
   void internalPerform() {
     //
     // Prepare inputs.
     //
     CompilationUnit unit = getRequiredInput(UNIT_INPUT);
     //
     // Compute dependencies.
     //
     VariableDeclaration declaration = getDeclaration(unit);
     VariableGatherer gatherer = new VariableGatherer(_isInferableStatic);
     declaration.initializer.accept(gatherer);
+//    print('[INFERABLE_STATIC_VARIABLE_DEPENDENCIES][$declaration] ${gatherer.hasInstanceFieldOrGetterReference}');
     //
     // Record outputs.
     //
     outputs[INFERABLE_STATIC_VARIABLE_DEPENDENCIES] = gatherer.results.toList();
+    outputs[INFERABLE_VARIABLE_REFERENCES_INSTANCE_FIELD] =
+        gatherer.hasInstanceFieldOrGetterReference;
   }
 
   /**
    * Return `true` if the given [variable] is a static variable whose type
    * should be inferred.
    */
   bool _isInferableStatic(VariableElement variable) =>
       variable.isStatic &&
       variable.hasImplicitType &&
       variable.initializer != null;
@@ skipping 1494 matching lines @@
  * stores it in the element model.
  */
 class InferStaticVariableTypeTask extends InferStaticVariableTask {
   /**
    * The name of the input which ensures that dependent values have their type
    * inferred before the target.
    */
   static const String DEPENDENCIES_INPUT = 'DEPENDENCIES_INPUT';
 
   /**
+   * The [INFERABLE_VARIABLE_REFERENCES_INSTANCE_FIELD] input.
+   */
+  static const String REFERENCES_INSTANCE_FIELD_INPUT =
+      'REFERENCES_INSTANCE_FIELD_INPUT';
+
+  /**
    * The name of the [TYPE_PROVIDER] input.
    */
   static const String TYPE_PROVIDER_INPUT = 'TYPE_PROVIDER_INPUT';
 
   /**
    * The name of the [RESOLVED_UNIT8] input.
    */
   static const String UNIT_INPUT = 'UNIT_INPUT';
 
   static final TaskDescriptor DESCRIPTOR = new TaskDescriptor(
@@ skipping 18 matching lines @@
   void internalPerform() {
     //
     // Prepare inputs.
     //
     // Note: DEPENDENCIES_INPUT is not needed.  It is merely a bookkeeping
     // dependency to ensure that the variables that this variable references
     // have types inferred before inferring the type of this variable.
     //
     VariableElementImpl variable = target;
 
+    bool referencesInstanceField =
+        getRequiredInput(REFERENCES_INSTANCE_FIELD_INPUT);
     CompilationUnit unit = getRequiredInput(UNIT_INPUT);
     TypeProvider typeProvider = getRequiredInput(TYPE_PROVIDER_INPUT);
 
     // If we're not in a dependency cycle, and we have no type annotation,
     // re-resolve the right hand side and do inference.
     List<AnalysisError> errors = AnalysisError.NO_ERRORS;
     if (dependencyCycle == null && variable.hasImplicitType) {
       VariableDeclaration declaration = getDeclaration(unit);
+      Expression initializer = declaration.initializer;
       //
       // Re-resolve the variable's initializer so that the inferred types
       // of other variables will be propagated.
       //
       RecordingErrorListener errorListener = new RecordingErrorListener();
-      Expression initializer = declaration.initializer;
       ResolutionContext resolutionContext =
           ResolutionContextBuilder.contextFor(initializer);
       ResolverVisitor visitor = new ResolverVisitor(
           variable.library, variable.source, typeProvider, errorListener,
           nameScope: resolutionContext.scope);
       if (resolutionContext.enclosingClassDeclaration != null) {
         visitor.prepareToResolveMembersInClass(
             resolutionContext.enclosingClassDeclaration);
       }
       visitor.initForIncrementalResolution();
       initializer.accept(visitor);
 
+      DartType newType;
+      if (hasInstanceGetterReference(initializer)) {
+        // Instance getters cannot be used for top-level type inference.
+        newType = typeProvider.dynamicType;
+      } else {
+        newType = initializer.staticType;
+        if (newType == null || newType.isBottom || newType.isDartCoreNull) {
+          newType = typeProvider.dynamicType;
+        }
+      }
+
       //
       // Record the type of the variable.
       //
-      DartType newType = initializer.staticType;
-      if (newType == null || newType.isBottom || newType.isDartCoreNull) {
-        newType = typeProvider.dynamicType;
-      }
       setFieldType(variable, newType);
       errors = getUniqueErrors(errorListener.errors);
     } else {
       // TODO(brianwilkerson) For now we simply don't infer any type for
       // variables or fields involved in a cycle. We could try to be smarter
       // by re-resolving the initializer in a context in which the types of all
       // of the variables in the cycle are assumed to be `null`, but it isn't
       // clear to me that this would produce better results often enough to
       // warrant the extra effort.
     }
@@ skipping 10 matching lines @@
    * [target].
    */
   static Map<String, TaskInput> buildInputs(AnalysisTarget target) {
     VariableElement variable = target;
     LibrarySpecificUnit unit =
         new LibrarySpecificUnit(variable.library.source, variable.source);
     return <String, TaskInput>{
       DEPENDENCIES_INPUT: INFERABLE_STATIC_VARIABLE_DEPENDENCIES
           .of(variable)
           .toListOf(INFERRED_STATIC_VARIABLE),
+      REFERENCES_INSTANCE_FIELD_INPUT:
+          INFERABLE_VARIABLE_REFERENCES_INSTANCE_FIELD.of(variable),
       TYPE_PROVIDER_INPUT: TYPE_PROVIDER.of(AnalysisContextTarget.request),
       UNIT_INPUT: RESOLVED_UNIT7.of(unit),
       // In strong mode, add additional dependencies to enforce inference
       // ordering.
 
       // Require that full inference be complete for all dependencies of the
       // current library cycle.
       'orderLibraryCycles': LIBRARY_CYCLE_DEPENDENCIES
           .of(unit.library)
           .toListOf(CREATED_RESOLVED_UNIT10)
@@ skipping 2764 matching lines @@
 
   @override
   bool moveNext() {
     if (_newSources.isEmpty) {
       return false;
     }
     currentTarget = _newSources.removeLast();
     return true;
   }
 }