Validate local resolution scope, and compute initial name scope.

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 9377 matching lines @@
   everything,
 
   /**
    * Resolve only type names outside of function bodies, variable initializers,
    * and parameter default values.
    */
   api,
 
   /**
    * Resolve only type names that would be skipped during [api].
+   *
+   * Resolution must start from a unit member or a class member. For example
+   * it is not allowed to resolve types in a separate statement, or a function
+   * body.
    */
   local
 }
 
 /**
  * Instances of the class `TypeResolverVisitor` are used to resolve the types associated with
  * the elements in the element model. This includes the types of superclasses, mixins, interfaces,
  * fields, methods, parameters, and local variables. As a side-effect, this also finishes building
  * the type hierarchy.
  */
@@ skipping 23 matching lines @@
    */
   TypeSystem _typeSystem;
 
   /**
    * The helper to resolve [TypeName]s.
    */
   TypeNameResolver _typeNameResolver;
 
   final TypeResolverMode mode;
 
-  bool _visitAllInLocalMode = false;
+  /**
+   * Is `true` when we are visiting all nodes in [TypeResolverMode.local] mode.
+   */
+  bool _localModeVisitAll = false;
+
+  /**
+   * Is `true` is we are in [TypeResolverMode.local] mode, and the initial

[Brian Wilkerson, 2016/10/19 21:00:36]

"is we" --> "if we"

+   * [nameScope] was computed.
+   */
+  bool _localModeScopeReady = 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.
@@ skipping 335 matching lines @@
 
     // 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) {
+      if (_localModeVisitAll) {
         return super.visitNode(node);
       }
 
+      // Ensure that the name scope is ready.
+      if (!_localModeScopeReady) {
+        void fillNameScope(AstNode node) {
+          if (node is FunctionBody ||
+              node is FormalParameterList ||
+              node is VariableDeclaration) {
+            throw new StateError(
+                'Local type resolution must start from a class or unit member.');
+          }
+          // Create enclosing name scopes.
+          AstNode parent = node.parent;
+          if (parent != null) {
+            fillNameScope(parent);
+          }
+          // Create the name scope for the node.
+          if (node is ClassDeclaration) {
+            ClassElement classElement = node.element;
+            nameScope = new TypeParameterScope(nameScope, classElement);
+            nameScope = new ClassScope(nameScope, classElement);
+          }
+        }
+
+        fillNameScope(node);
+        _localModeScopeReady = true;
+      }
+
       /**
        * Visit the given [node] and all its children.
        */
       void visitAllNodes(AstNode node) {
         if (node != null) {
-          bool wasVisitAllInLocalMode = _visitAllInLocalMode;
+          bool wasVisitAllInLocalMode = _localModeVisitAll;
           try {
-            _visitAllInLocalMode = true;
+            _localModeVisitAll = true;
             node.accept(this);
           } finally {
-            _visitAllInLocalMode = wasVisitAllInLocalMode;
+            _localModeVisitAll = wasVisitAllInLocalMode;
           }
         }
       }
 
       // Visit only nodes that may contain type names to resolve.
       if (node is CompilationUnit) {
         node.declarations.forEach(visitNode);
       } else if (node is ClassDeclaration) {
         node.members.forEach(visitNode);
       } else if (node is DefaultFormalParameter) {
@@ skipping 859 matching lines @@
       return null;
     }
     if (identical(node.staticElement, variable)) {
       if (node.inSetterContext()) {
         result = true;
       }
     }
     return null;
   }
 }