Remove VariableScope, Scope.lexicalLookup and Scope.inStaticContext

lib/compiler/implementation/resolution/members.dart

 // Copyright (c) 2012, 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.
 
 abstract class TreeElements {
   Element operator[](Node node);
   Selector getSelector(Send send);
   DartType getType(TypeAnnotation annotation);
   bool isParameterChecked(Element element);
 }
@@ skipping 1329 matching lines @@
 
   DartType useType(TypeAnnotation annotation, DartType type) {
     if (type != null) {
       mapping.setType(annotation, type);
       useElement(annotation, type.element);
     }
     return type;
   }
 
   void setupFunction(FunctionExpression node, FunctionElement function) {
-    // If [function] is the [enclosingElement], the [scope] has
-    // already been set in the constructor of [ResolverVisitor].
-    if (function != enclosingElement) scope = new MethodScope(scope, function);
+    scope = new MethodScope(scope, function);
 
     // Put the parameters in scope.
     FunctionSignature functionParameters =
         function.computeSignature(compiler);
     Link<Node> parameterNodes = (node.parameters == null)
         ? const Link<Node>() : node.parameters.nodes;
     functionParameters.forEachParameter((Element element) {
       if (element == functionParameters.optionalParameters.head) {
         NodeList nodes = parameterNodes.head;
         parameterNodes = nodes.nodes;
@@ skipping 1582 matching lines @@
       }
     } else {
       internalError(node.receiver, 'unexpected element $e');
     }
     return e;
   }
 
   Element visitIdentifier(Identifier node) {
     SourceString name = node.source;
     Element e = resolver.lookup(node, name);
+    // TODO(johnniwinther): Change errors to warnings, cf. 11.11.1.
     if (e == null) {
       return failOrReturnErroneousElement(resolver.enclosingElement, node, name,
                                           MessageKind.CANNOT_RESOLVE, [name]);
     } else if (identical(e.kind, ElementKind.TYPEDEF)) {
       error(node, MessageKind.CANNOT_INSTANTIATE_TYPEDEF, [name]);
+    } else if (identical(e.kind, ElementKind.TYPE_VARIABLE)) {
+      error(node, MessageKind.CANNOT_INSTANTIATE_TYPE_VARIABLE, [name]);
     } else if (!identical(e.kind, ElementKind.CLASS)
         && !identical(e.kind, ElementKind.PREFIX)) {
       error(node, MessageKind.NOT_A_TYPE, [name]);
     }
     return e;
   }
 }
 
 abstract class Scope {
   final Element element;
   final Scope parent;
 
   Scope(this.parent, this.element);
   abstract Element add(Element element);
 
   Element lookup(SourceString name) {
     Element result = localLookup(name);
     if (result != null) return result;
     return parent.lookup(name);
   }
 
-  Element lexicalLookup(SourceString name) {
-    Element result = localLookup(name);
-    if (result != null) return result;
-    return parent.lexicalLookup(name);
-  }
-
   abstract Element localLookup(SourceString name);
 }
 
-class VariableScope extends Scope {
-  VariableScope(parent, element) : super(parent, element);
-
-  Element add(Element newElement) {
-    throw "Cannot add element to VariableScope";
-  }
-
-  Element localLookup(SourceString name) => null;
-
-  String toString() => '$element > $parent';
-}
-
 /**
  * [TypeDeclarationScope] defines the outer scope of a type declaration in
  * which the declared type variables and the entities in the enclosing scope are
  * available but where declared and inherited members are not available. This
  * scope is only used for class/interface declarations during resolution of the
  * class hierarchy. In all other cases [ClassScope] is used.
  */
 class TypeDeclarationScope extends Scope {
   TypeDeclarationElement get element => super.element;
 
@@ skipping 49 matching lines @@
 
   String toString() => 'block${elements.getKeys()}';
 }
 
 /**
  * [ClassScope] defines the inner scope of a class/interface declaration in
  * which declared members, declared type variables, entities in the enclosing
  * scope and inherited members are available, in the given order.
  */
 class ClassScope extends TypeDeclarationScope {
-  bool inStaticContext = false;
+  ClassElement get element => super.element;
 
   ClassScope(Scope parentScope, ClassElement element)
       : super(parentScope, element)  {
     assert(parent != null);
   }
 
   Element localLookup(SourceString name) {
-    ClassElement cls = element;
-    Element result = cls.lookupLocalMember(name);
+    Element result = element.lookupLocalMember(name);
     if (result != null) return result;
-    if (!inStaticContext) {
-      // If not in a static context, we can lookup in the
-      // TypeDeclaration scope, which contains the type variables of
-      // the class.
-      result = super.localLookup(name);
-    }
-    return result;
+    return super.localLookup(name);
   }
 
   Element lookup(SourceString name) {
     Element result = localLookup(name);
     if (result != null) return result;
     result = parent.lookup(name);
     if (result != null) return result;
-    ClassElement cls = element;
-    return cls.lookupSuperMember(name);
+    return element.lookupSuperMember(name);
   }
 
   Element add(Element newElement) {
     throw "Cannot add an element in a class scope";
   }
 
   String toString() => 'ClassScope($element)';
 }
 
 // TODO(johnniwinther): Refactor scopes to avoid class explosion.
 class PatchClassScope extends TypeDeclarationScope {
-  bool inStaticContext = false;
   ClassElement get origin => element;
   final ClassElement patch;
 
   PatchClassScope(Scope parentScope,
                   ClassElement origin, ClassElement this.patch)
       : super(parentScope, origin) {
     assert(parent != null);
   }
 
   Element localLookup(SourceString name) {
     Element result = patch.lookupLocalMember(name);
     if (result != null) return result;
     result = origin.lookupLocalMember(name);
     if (result != null) return result;
-    if (!inStaticContext) {
-      // If not in a static context, we can lookup in the
-      // TypeDeclaration scope, which contains the type variables of
-      // the class.
-      result = super.localLookup(name);
-      if (result != null) return result;
-    }
+    result = super.localLookup(name);
+    if (result != null) return result;
     result = parent.lookup(name);
     if (result != null) return result;
     return result;
   }
 
   Element lookup(SourceString name) {
     Element result = localLookup(name);
     if (result != null) return result;
     // TODO(johnniwinther): Should we support patch lookup on supertypes?
     return origin.lookupSuperMember(name);
@@ skipping 81 matching lines @@
     return result;
   }
   Element lookup(SourceString name) => localLookup(name);
   Element lexicalLookup(SourceString name) => localLookup(name);
 
   Element add(Element newElement) {
     throw "Cannot add an element in a patch library scope";
   }
   String toString() => 'PatchLibraryScope($origin,$patch)';
 }