Refactor scope handling.

lib/compiler/implementation/elements/elements.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.
 
 #library('elements');
 
 #import('../tree/tree.dart');
 #import('../scanner/scannerlib.dart');
 #import('../leg.dart');  // TODO(karlklose): we only need type.
 #import('../util/util.dart');
@@ skipping 196 matching lines @@
 
   Element getOutermostEnclosingMemberOrTopLevel() {
     for (Element e = this; e !== null; e = e.enclosingElement) {
       if (e.isMember() || e.isTopLevel()) {
         return e;
       }
     }
     return null;
   }
 
+  /**
+   * Creates the scope for this element. The scope of the
+   * enclosing element will be the parent scope.
+   */
+  Scope buildScope() => buildEnclosingScope();
+
+  /**
+   * Creates the scope for the enclosing element.
+   */
+  Scope buildEnclosingScope() => enclosingElement.buildScope();
+
   String toString() {
     // TODO(johnniwinther): Test for nullness of name, or make non-nullness an
     // invariant for all element types?
     var nameText = name !== null ? name.slowToString() : '?';
     if (enclosingElement !== null && !isTopLevel()) {
       String holderName = enclosingElement.name !== null
           ? enclosingElement.name.slowToString()
           : '${enclosingElement.kind}?';
       return '$kind($holderName#${nameText})';
     } else {
@@ skipping 160 matching lines @@
    */
   String getLibraryOrScriptName() {
     if (libraryTag !== null) {
       return libraryTag.argument.dartString.slowToString();
     } else {
       // Use the file name as script name.
       var path = script.uri.path;
       return path.substring(path.lastIndexOf('/') + 1);
     }
   }
+
+  Scope buildEnclosingScope() => new TopScope(this);
 }
 
 class PrefixElement extends Element {
   Map<SourceString, Element> imported;
   Token firstPosition;
   final CompilationUnitElement patchSource;
 
   PrefixElement(SourceString prefix, Element enclosing, this.firstPosition,
                 [this.patchSource])
     : imported = new Map<SourceString, Element>(),
@@ skipping 91 matching lines @@
 // It contains the node, and the type. A [VariableElement] always
 // references its [VariableListElement]. It forwards its
 // [computeType] and [parseNode] methods to this element.
 class VariableListElement extends Element {
   VariableDefinitions cachedNode;
   Type type;
   final Modifiers modifiers;
 
   /**
    * Function signature for a variable with a function type. The signature is
-   * kept to provide full information about parameter names through the the
-   * mirror system.
+   * kept to provide full information about parameter names through the mirror
+   * system.
    */
   FunctionSignature functionSignature;
 
   VariableListElement(ElementKind kind,
                       Modifiers this.modifiers,
                       Element enclosing)
     : super(null, kind, enclosing);
 
   VariableListElement.node(VariableDefinitions node,
                            ElementKind kind,
@@ skipping 86 matching lines @@
           getter.modifiers.nodes,
           getter.modifiers.flags | Modifiers.FLAG_ABSTRACT);
     } else {
       return new Modifiers.withFlags(
           setter.modifiers.nodes,
           setter.modifiers.flags | Modifiers.FLAG_ABSTRACT);
     }
   }
 }
 
+// TODO(johnniwinther): [FunctionSignature] should be merged with
+// [FunctionType].
 class FunctionSignature {
   Link<Element> requiredParameters;
   Link<Element> optionalParameters;
   Type returnType;
   int requiredParameterCount;
   int optionalParameterCount;
   FunctionSignature(this.requiredParameters,
                     this.optionalParameters,
                     this.requiredParameterCount,
                     this.optionalParameterCount,
@@ skipping 368 matching lines @@
     for (ClassElement s = this; s != null; s = s.superclass) {
       if (s === cls) return true;
     }
     return false;
   }
 
   bool isInterface() => false;
   bool isNative() => nativeName != null;
   SourceString nativeName;
   int hashCode() => id;
+
+  Scope buildScope() =>
+      new ClassScope(enclosingElement.buildScope(), this);
 }
 
 class Elements {
   static bool isLocal(Element element) {
     return ((element !== null)
             && !element.isInstanceMember()
             && !isStaticOrTopLevelField(element)
             && !isStaticOrTopLevelFunction(element)
             && (element.kind === ElementKind.VARIABLE ||
                 element.kind === ElementKind.PARAMETER ||
@@ skipping 168 matching lines @@
   final Node node;
   Type bound;
   Type type;
   TypeVariableElement(name, Element enclosing, this.node, this.type,
                       [this.bound])
     : super(name, ElementKind.TYPE_VARIABLE, enclosing);
   Type computeType(compiler) => type;
   Node parseNode(compiler) => node;
   toString() => "${enclosingElement.toString()}.${name.slowToString()}";
 }