Implement super initializers.

frog/leg/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 351 matching lines @@
                   ElementKind kind,
                   Modifiers this.modifiers,
                   Element enclosing)
     : super(name, kind, enclosing);
 
   FunctionElement.node(SourceString name,
                        FunctionExpression node,
                        ElementKind kind,
                        Modifiers this.modifiers,
                        Element enclosing)
-    : super(name, kind, enclosing),
-      cachedNode = node;
+    : super(name, kind, enclosing), cachedNode = node;
 
   FunctionElement.from(SourceString name,
                        FunctionElement other,
                        Element enclosing)
     : super(name, other.kind, enclosing),
       cachedNode = other.cachedNode,
       modifiers = other.modifiers,
       functionParameters = other.functionParameters;
 
   bool isInstanceMember() {
@@ skipping 171 matching lines @@
   }
 
   ClassElement resolve(Compiler compiler) {
     if (!isResolved) {
       compiler.resolveType(this);
       isResolved = true;
     }
     return this;
   }
 
-  Element lookupLocalMember(SourceString name) {
-    return localMembers[name];
+  Element lookupLocalMember(SourceString memberName) {
+    return localMembers[memberName];
   }
 
   Element lookupConstructor(SourceString className,
                             [SourceString constructorName =
                                  const SourceString(''),
                             Element noMatch(Element)]) {
     // TODO(karlklose): have a map from class names to a map of constructors
     //                  instead of creating the name here?
-    SourceString name;
+    SourceString normalizedName;
     if (constructorName !== const SourceString('')) {
-      name = Elements.constructConstructorName(className, constructorName);
+      normalizedName = Elements.constructConstructorName(className,
+                                                         constructorName);
     } else {
-      name = className;
+      normalizedName = className;
     }
-    Element result = constructors[name];
+    Element result = constructors[normalizedName];
     if (result === null && noMatch !== null) {
       result = noMatch(lookupLocalMember(constructorName));
     }
     return result;
   }
 
   bool canHaveDefaultConstructor() => constructors.length == 0;
 
   SynthesizedConstructorElement getSynthesizedConstructor() {
     if (synthesizedConstructor === null && canHaveDefaultConstructor()) {
@@ skipping 89 matching lines @@
     else if (str === '>=') str = 'ge';
     else if (str === '>') str = 'gt';
     else if (str === '<=') str = 'le';
     else if (str === '<') str = 'lt';
     else if (str === '&' || str === '&=') str = 'and';
     else if (str === '^' || str === '^=') str = 'xor';
     else if (str === '|' || str === '|=') str = 'or';
     return new SourceString('$receiver\$$str');
   }
 }