Implement parsing and resolving of type-variables.

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 15 matching lines @@
 
   static final int PREFIX = 8;
 
   /** Constructor or factory. */
   static final int FACTORY = 16;
 
   static final int ALIAS = 32;
 
   static final int SUPER = 64;
 
+  /** Type variable */
+  static final int TYPE_VARIABLE = 128;
+
   static final int IMPLIES_TYPE = CLASS | ALIAS;
 }
 
 class ElementKind {
   final String id;
   final int category;
 
   const ElementKind(String this.id, this.category);
 
   static final ElementKind VARIABLE =
@@ skipping 15 matching lines @@
   static final ElementKind FIELD_LIST =
     const ElementKind('field_list', ElementCategory.NONE);
   static final ElementKind GENERATIVE_CONSTRUCTOR_BODY =
       const ElementKind('generative_constructor_body', ElementCategory.NONE);
   static final ElementKind COMPILATION_UNIT =
       const ElementKind('compilation_unit', ElementCategory.NONE);
   static final ElementKind GETTER =
     const ElementKind('getter', ElementCategory.NONE);
   static final ElementKind SETTER =
     const ElementKind('setter', ElementCategory.NONE);
+  static final ElementKind TYPE_VARIABLE =
+    const ElementKind('type_variable', ElementCategory.TYPE_VARIABLE);
   static final ElementKind ABSTRACT_FIELD =
     const ElementKind('abstract_field', ElementCategory.VARIABLE);
   static final ElementKind LIBRARY =
     const ElementKind('library', ElementCategory.NONE);
   static final ElementKind PREFIX =
     const ElementKind('prefix', ElementCategory.PREFIX);
   static final ElementKind TYPEDEF =
     const ElementKind('typedef', ElementCategory.ALIAS);
 
   static final ElementKind STATEMENT =
@@ skipping 26 matching lines @@
   bool isGenerativeConstructor() => kind === ElementKind.GENERATIVE_CONSTRUCTOR;
   bool isCompilationUnit() {
     return kind === ElementKind.COMPILATION_UNIT ||
            kind === ElementKind.LIBRARY;
   }
   bool isClass() => kind === ElementKind.CLASS;
   bool isVariable() => kind === ElementKind.VARIABLE;
   bool isParameter() => kind === ElementKind.PARAMETER;
   bool isStatement() => kind === ElementKind.STATEMENT;
   bool isTypedef() => kind === ElementKind.TYPEDEF;
+  bool isTypeVariable() => kind === ElementKind.TYPE_VARIABLE;
   bool isGetter() => kind === ElementKind.GETTER;
   bool impliesType() => (kind.category & ElementCategory.IMPLIES_TYPE) != 0;
 
   bool isAssignable() {
     if (modifiers != null && modifiers.isFinal()) return false;
     if (isFunction() || isGenerativeConstructor()) return false;
     return true;
   }
 
   Token position() => null;
@@ skipping 499 matching lines @@
 }
 
 class ClassElement extends ContainerElement {
   Type type;
   Type supertype;
   Type defaultClass;
   Link<Element> members = const EmptyLink<Element>();
   Map<SourceString, Element> localMembers;
   Map<SourceString, Element> constructors;
   Link<Type> interfaces = const EmptyLink<Type>();
+  Map<SourceString, TypeVariableElement> typeParameters;
   bool isResolved = false;
   bool isBeingResolved = false;
   // backendMembers are members that have been added by the backend to simplify
   // compilation. They don't have any user-side counter-part.
   Link<Element> backendMembers = const EmptyLink<Element>();
 
   Link<Type> allSupertypes;
 
   ClassElement(SourceString name, CompilationUnitElement enclosing)
     : localMembers = new Map<SourceString, Element>(),
       constructors = new Map<SourceString, Element>(),
+      typeParameters = new Map<SourceString, TypeVariableElement>(),
       super(name, ElementKind.CLASS, enclosing);
 
   void addMember(Element element, DiagnosticListener listener) {
     members = members.prepend(element);
     if (element.kind == ElementKind.GENERATIVE_CONSTRUCTOR ||
         element.modifiers.isFactory()) {
       constructors[element.name] = element;
     } else if (element.kind == ElementKind.GETTER
                || element.kind == ElementKind.SETTER) {
       addGetterOrSetter(element, localMembers[element.name], listener);
@@ skipping 12 matching lines @@
   ClassElement ensureResolved(Compiler compiler) {
     if (!isResolved && !isBeingResolved) {
       isBeingResolved = true;
       compiler.resolveType(this);
       isBeingResolved = false;
       isResolved = true;
     }
     return this;
   }
 
+  Element lookupTypeParameter(SourceString parameterName) {

[ahe, 2012/03/15 11:17:33]

As far as I can tell, this creates a separate scope for type variables.

[karlklose, 2012/03/16 14:58:47]

Yes, but the resolver will try to look names up using this method, too. 

+    Element result = typeParameters[parameterName];
+    return result;
+  }
+
   Element lookupLocalMember(SourceString memberName) {
     return localMembers[memberName];
   }
 
   Element lookupSuperMember(SourceString memberName) {
     for (ClassElement s = superclass; s != null; s = s.superclass) {
       Element e = s.lookupLocalMember(memberName);
       if (e !== null) return e;
     }
     return null;
@@ skipping 185 matching lines @@
     return result;
   }
 
   Node parseNode(DiagnosticListener l) => statement;
 
   bool get isSwitch() => statement is SwitchStatement;
 
   Token position() => statement.getBeginToken();
   String toString() => statement.toString();
 }
+
+class TypeVariableElement extends Element {

[ahe, 2012/03/15 11:17:33]

Please override toString to include the name of the class (enclosingElement, I
presume).

[karlklose, 2012/03/16 14:58:47]

Done.

+  final Node node;
+  Type bound;
+  Type type;
+  TypeVariableElement(name, Element enclosing, this.node, this.type,

[ngeoffray, 2012/03/15 11:47:40]

I prefer having enclosing at the end.

+                      [this.bound])

[ngeoffray, 2012/03/15 11:47:40]

should that default to Object to avoid null checks?

[karlklose, 2012/03/16 14:58:47]

The bound is set when resolving the class containing this element. After
resolver, having null is an error.

+    : super(name, ElementKind.TYPE_VARIABLE, enclosing);
+  Type computeType(compiler) => type;
+  Node parseNode(compiler) => node;
+}