Move more error detection out of Scope

pkg/analyzer/lib/src/dart/resolver/scope.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.dart.resolver.scope;
 
 import 'dart:collection';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/src/dart/element/element.dart';
 import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/generated/error.dart';
 import 'package:analyzer/src/generated/java_core.dart';
 import 'package:analyzer/src/generated/java_engine.dart';
 import 'package:analyzer/src/generated/source.dart';
 
 /**
+ * The scope defined by a block.
+ */
+class BlockScope extends EnclosedScope {
+  /**
+   * Initialize a newly created scope, enclosed within the [enclosingScope],
+   * based on the given [classElement].
+   */
+  BlockScope(Scope enclosingScope, Block block) : super(enclosingScope) {
+    if (block == null) {
+      throw new IllegalArgumentException("block cannot be null");
+    }
+    _defineElements(block);
+  }
+
+  void _defineElements(block) {

[scheglov, 2016/09/02 23:46:50]

Type for "block"?

[Brian Wilkerson, 2016/09/03 17:12:37]

Done

+    for (var element in elementsInBlock(block)) {
+      define(element);
+    }

[scheglov, 2016/09/02 23:46:50]

This could be written as:
elementsInBlock(block).forEach(define);

Hm... OTOH, forEach(), if not inlined, will have a megamorphic lookup :-(

[Brian Wilkerson, 2016/09/03 17:12:37]

Leaving it as is.

+  }
+
+  /**
+   * Return the elements that are declared directly in the given [block]. This
+   * does not include elements declared in nested blocks.
+   */
+  static Iterable<Element> elementsInBlock(Block block) sync* {
+    NodeList<Statement> statements = block.statements;
+    int statementCount = statements.length;
+    for (int i = 0; i < statementCount; i++) {
+      Statement statement = statements[i];
+      if (statement is VariableDeclarationStatement) {
+        NodeList<VariableDeclaration> variables = statement.variables.variables;
+        int variableCount = variables.length;
+        for (int j = 0; j < variableCount; j++) {
+          yield variables[j].element;
+        }
+      } else if (statement is FunctionDeclarationStatement) {
+        yield statement.functionDeclaration.element;
+      }
+    }
+  }
+}
+
+/**
  * The scope defined by a class.
  */
 class ClassScope extends EnclosedScope {
   /**
    * Initialize a newly created scope, enclosed within the [enclosingScope],
    * based on the given [classElement].
    */
   ClassScope(Scope enclosingScope, ClassElement classElement)
       : super(enclosingScope) {
     if (classElement == null) {
@@ skipping 45 matching lines @@
  * A scope that is lexically enclosed in another scope.
  */
 class EnclosedScope extends Scope {
   /**
    * The scope in which this scope is lexically enclosed.
    */
   @override
   final Scope enclosingScope;
 
   /**
-   * A table mapping names that will be defined in this scope, but right now are
-   * not initialized. According to the scoping rules these names are hidden,
-   * even if they were defined in an outer scope.
-   */
-  HashMap<String, Element> _hiddenElements = null;
-
-  /**
    * Initialize a newly created scope, enclosed within the [enclosingScope].
    */
   EnclosedScope(this.enclosingScope);
 
   @override
   AnalysisErrorListener get errorListener => enclosingScope.errorListener;
 
-  /**
-   * Record that given [element] is declared in this scope, but hasn't been
-   * initialized yet, so it is error to use. If there is already an element with
-   * the given name defined in an outer scope, then it will become unavailable.
-   */
-  void hide(Element element) {
-    if (element != null) {
-      String name = element.name;
-      if (name != null && !name.isEmpty) {
-        _hiddenElements ??= new HashMap<String, Element>();
-        _hiddenElements[name] = element;
-      }
-    }
-  }
-
   @override
   Element internalLookup(
       Identifier identifier, String name, LibraryElement referencingLibrary) {
     Element element = localLookup(name, referencingLibrary);
     if (element != null) {
       return element;
     }
-    // May be there is a hidden Element.
-    if (_hiddenElements != null) {
-      Element hiddenElement = _hiddenElements[name];
-      if (hiddenElement != null) {
-        errorListener.onError(new AnalysisError(
-            getSource(identifier),
-            identifier.offset,
-            identifier.length,
-            CompileTimeErrorCode.REFERENCED_BEFORE_DECLARATION,
-            [name]));
-        return hiddenElement;
-      }
-    }
     // Check enclosing scope.
     return enclosingScope.internalLookup(identifier, name, referencingLibrary);
   }
 
   @override
   Element _internalLookupPrefixed(Identifier identifier, String prefix,
       String name, LibraryElement referencingLibrary) {
     return enclosingScope._internalLookupPrefixed(
         identifier, prefix, name, referencingLibrary);
   }
@@ skipping 1122 matching lines @@
 
   /**
    * Define the type parameters declared by the [classElement].
    */
   void _defineTypeParameters(ClassElement classElement) {
     for (TypeParameterElement typeParameter in classElement.typeParameters) {
       define(typeParameter);
     }
   }
 }