Handle cycles when infering static variables

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/src/context/cache.dart';
 import 'package:analyzer/src/generated/ast.dart';
@@ skipping 2543 matching lines @@
     //
     // 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;
     CompilationUnit unit = getRequiredInput(UNIT_INPUT);
     TypeProvider typeProvider = getRequiredInput(TYPE_PROVIDER_INPUT);
-    //
-    // Re-resolve the variable's initializer so that the inferred types of other
-    // variables will be propagated.
-    //
-    NodeLocator locator = new NodeLocator(variable.nameOffset);
-    AstNode node = locator.searchWithin(unit);
-    VariableDeclaration declaration =
-        node.getAncestor((AstNode ancestor) => ancestor is VariableDeclaration);
-    if (declaration == null || declaration.name != node) {
-      throw new AnalysisException(
-          "NodeLocator failed to find a variable's declaration");
-    }
-    RecordingErrorListener errorListener = new RecordingErrorListener();
-    Expression initializer = declaration.initializer;
-    ResolutionContext resolutionContext =
-        ResolutionContextBuilder.contextFor(initializer, errorListener);
-    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);
-    //
-    // Record the type of the variable.
-    //
-    DartType newType = initializer.staticType;
-    variable.type = newType;
-    (variable.initializer as ExecutableElementImpl).returnType = newType;
-    if (variable is PropertyInducingElementImpl) {
-      setReturnType(variable.getter, newType);
-      setParameterType(variable.setter, newType);
+    if (dependencyCycle == null) {
+      //
+      // Re-resolve the variable's initializer so that the inferred types of other
+      // variables will be propagated.
+      //
+      NodeLocator locator = new NodeLocator(variable.nameOffset);
+      AstNode node = locator.searchWithin(unit);
+      VariableDeclaration declaration = node
+          .getAncestor((AstNode ancestor) => ancestor is VariableDeclaration);
+      if (declaration == null || declaration.name != node) {
+        throw new AnalysisException(
+            "NodeLocator failed to find a variable's declaration");
+      }
+      RecordingErrorListener errorListener = new RecordingErrorListener();
+      Expression initializer = declaration.initializer;
+      ResolutionContext resolutionContext =
+          ResolutionContextBuilder.contextFor(initializer, errorListener);
+      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);
+      //
+      // Record the type of the variable.
+      //
+      DartType newType = initializer.staticType;
+      if (newType == null || newType.isBottom) {
+        newType = typeProvider.dynamicType;
+      }
+      variable.type = newType;
+      (variable.initializer as ExecutableElementImpl).returnType = newType;
+      if (variable is PropertyInducingElementImpl) {
+        setReturnType(variable.getter, newType);
+        setParameterType(variable.setter, newType);
+      }
+    } 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
+      // warrent the extra effort.

[Leaf, 2015/08/31 21:07:03]

warrent -> warrant

[Brian Wilkerson, 2015/08/31 21:27:47]

Thanks! I really miss spell checking :-(

     }
     //
     // Record outputs.
     //
     outputs[INFERRED_STATIC_VARIABLE] = variable;
   }
 
   /**
    * Return a map from the names of the inputs of this kind of task to the task
    * input descriptors describing those inputs for a task with the given
@@ skipping 1342 matching lines @@
 
   @override
   bool moveNext() {
     if (_newSources.isEmpty) {
       return false;
     }
     currentTarget = _newSources.removeLast();
     return true;
   }
 }