Implement 'local' mode in TypeResolverVisitor.

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 analyzer.src.generated.resolver;
 
 import 'dart:collection';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart';
@@ skipping 9420 matching lines @@
    */
   TypeSystem _typeSystem;
 
   /**
    * The helper to resolve [TypeName]s.
    */
   TypeNameResolver _typeNameResolver;
 
   final TypeResolverMode mode;
 
+  bool _visitAllInLocalMode = false;
+
   /**
    * Initialize a newly created visitor to resolve the nodes in an AST node.
    *
    * [definingLibrary] is the element for the library containing the node being
    * visited.
    * [source] is the source representing the compilation unit containing the
    * node being visited.
    * [typeProvider] is the object used to access the types from the core
    * library.
    * [errorListener] is the error listener that will be informed of any errors
@@ skipping 38 matching lines @@
           element is PropertyAccessorElement) {
         // This is the @proxy from dart.core
         ElementAnnotationImpl elementAnnotation = node.elementAnnotation;
         elementAnnotation.element = element;
       }
     }
     return null;
   }
 
   @override
-  Object visitBlockFunctionBody(BlockFunctionBody node) {
-    if (mode == TypeResolverMode.api) {
-      return null;
-    }
-    return super.visitBlockFunctionBody(node);
-  }
-
-  @override
   Object visitCatchClause(CatchClause node) {
     super.visitCatchClause(node);
     SimpleIdentifier exception = node.exceptionParameter;
     if (exception != null) {
       // If an 'on' clause is provided the type of the exception parameter is
       // the type in the 'on' clause. Otherwise, the type of the exception
       // parameter is 'Object'.
       TypeName exceptionTypeName = node.exceptionType;
       DartType exceptionType;
       if (exceptionTypeName == null) {
@@ skipping 138 matching lines @@
       declaredType = _dynamicType;
     } else {
       declaredType = _typeNameResolver._getType(typeName);
     }
     LocalVariableElementImpl element = node.element as LocalVariableElementImpl;
     element.type = declaredType;
     return null;
   }
 
   @override
-  Object visitExpressionFunctionBody(ExpressionFunctionBody node) {
-    if (mode == TypeResolverMode.api) {
-      return null;
-    }
-    return super.visitExpressionFunctionBody(node);
-  }
-
-  @override
   Object visitFieldFormalParameter(FieldFormalParameter node) {
     super.visitFieldFormalParameter(node);
     Element element = node.identifier.staticElement;
     if (element is ParameterElementImpl) {
       FormalParameterList parameterList = node.parameters;
       if (parameterList == null) {
         DartType type;
         TypeName typeName = node.type;
         if (typeName == null) {
           element.hasImplicitType = true;
@@ skipping 92 matching lines @@
         if (parameters != null && parameters.length > 0) {
           variable.type = parameters[0].type;
         }
       }
     }
     return null;
   }
 
   @override
   Object visitNode(AstNode node) {
-    // In API mode we need to ignore:
+    // In API mode we need to skip:
+    //   - function bodies;
     //   - default values of parameters;
     //   - initializers of top-level variables.
     if (mode == TypeResolverMode.api) {
+      if (node is FunctionBody) {
+        return null;
+      }
       if (node is DefaultFormalParameter) {
         node.parameter.accept(this);
         return null;
       }
       if (node is VariableDeclaration) {
         return null;
       }
     }
+
+    // In local mode we need to resolve only:
+    //   - function bodies;
+    //   - default values of parameters;
+    //   - initializers of top-level variables.
+    // So, we carefully visit only nodes that are, or contain, these nodes.
+    // The client may choose to start visiting any node, but we still want to
+    // resolve only type names that are local.
+    if (mode == TypeResolverMode.local) {
+      // We are in the state of visiting all nodes.
+      if (_visitAllInLocalMode) {
+        return super.visitNode(node);
+      }
+
+      /**
+       * Visit the given [node] and all its children.
+       */
+      void visitAllNodes(AstNode node) {
+        if (node != null) {
+          bool wasVisitAllInLocalMode = _visitAllInLocalMode;
+          try {
+            _visitAllInLocalMode = true;
+            node.accept(this);
+          } finally {
+            _visitAllInLocalMode = wasVisitAllInLocalMode;
+          }
+        }
+      }
+
+      // Visit only nodes that may contain type names to resolve.
+      if (node is FunctionBody) {

[Brian Wilkerson, 2016/10/19 16:30:18]

This like of is tests is kind of ugly, but if there isn't a better way to
structure the code consider using "else if".

[Paul Berry, 2016/10/19 16:37:49]

Another possibility: create a little visitor which takes the appropriate action,
and use it to do the dispatch.

[scheglov, 2016/10/19 16:47:10]

Done.

+        visitAllNodes(node);
+        return null;
+      }
+      if (node is DefaultFormalParameter) {
+        visitAllNodes(node.defaultValue);
+        return null;
+      }
+      if (node is CompilationUnit) {
+        node.declarations.forEach(visitNode);
+        return null;
+      }
+      if (node is ClassDeclaration) {
+        for (ClassMember member in node.members) {
+          visitNode(member);
+        }
+        return null;
+      }
+      if (node is FieldDeclaration) {
+        visitNode(node.fields);
+        return null;
+      }
+      if (node is FunctionDeclaration) {
+        node.functionExpression.parameters?.accept(this);
+        visitAllNodes(node.functionExpression.body);
+        return null;
+      }
+      if (node is FormalParameterList) {
+        node.parameters.accept(this);
+        return null;
+      }
+      if (node is MethodDeclaration) {
+        visitAllNodes(node.body);
+        return null;
+      }
+      if (node is TopLevelVariableDeclaration) {
+        visitNode(node.variables);
+        return null;
+      }
+      if (node is VariableDeclaration) {
+        visitAllNodes(node.initializer);
+        return null;
+      }
+      if (node is VariableDeclarationList) {
+        node.variables.forEach(visitNode);
+        return null;
+      }
+
+      // Ignore all other nodes.
+      return null;
+    }
+
+    // The mode in which we visit all nodes.
     return super.visitNode(node);
   }
 
   @override
   Object visitSimpleFormalParameter(SimpleFormalParameter node) {
     super.visitSimpleFormalParameter(node);
     DartType declaredType;
     TypeName typeName = node.type;
     if (typeName == null) {
       declaredType = _dynamicType;
@@ skipping 825 matching lines @@
       return null;
     }
     if (identical(node.staticElement, variable)) {
       if (node.inSetterContext()) {
         result = true;
       }
     }
     return null;
   }
 }