Implement parsing and resolving of type-variables.

frog/leg/resolver.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.
 
 interface TreeElements {
   Element operator[](Node node);
   Selector getSelector(Send send);
 }
 
 class TreeElementMapping implements TreeElements {
@@ skipping 392 matching lines @@
     compiler.internalError(message, node: node);
   }
 
   void unimplemented(Node node, String message) {
     compiler.unimplemented(message, node: node);
   }
 }
 
 interface LabelScope {
   LabelScope get outer();
-  LabelElement lookup(String label);
+  LabelElement lookup(String label, [bool inStaticContext]);

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

Why would labels care about a static context?

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

Done, removed all the static context booleans.

 }
 
 class LabeledStatementLabelScope implements LabelScope {
   final LabelScope outer;
   final LabelElement label;
   LabeledStatementLabelScope(this.outer, this.label);
-  LabelElement lookup(String labelName) {
+  LabelElement lookup(String labelName, [bool inStaticContext = false]) {
     if (this.label.labelName == labelName) return label;
-    return outer.lookup(labelName);
+    return outer.lookup(labelName, inStaticContext);
   }
 }
 
 class SwitchLabelScope implements LabelScope {
   final LabelScope outer;
   final Map<String, LabelElement> caseLabels;
 
   SwitchLabelScope(this.outer, this.caseLabels);
 
-  LabelElement lookup(String labelName) {
+  LabelElement lookup(String labelName, [bool inStaticContext = false]) {
     LabelElement result = caseLabels[labelName];
     if (result !== null) return result;
-    return outer.lookup(labelName);
+    return outer.lookup(labelName, inStaticContext);
   }
 }
 
 class EmptyLabelScope implements LabelScope {
   const EmptyLabelScope();
-  LabelElement lookup(String label) => null;
+  LabelElement lookup(String label, [bool inStaticContext = false]) => null;
   LabelScope get outer() {
     throw 'internal error: empty label scope has no outer';
   }
 }
 
 class StatementScope {
   LabelScope labels;
   Link<TargetElement> breakTargetStack;
   Link<TargetElement> continueTargetStack;
   // Used to provide different numbers to statements if one is inside the other.
   // Can be used to make otherwise duplicate labels unique.
   int nestingLevel = 0;
 
   StatementScope()
       : labels = const EmptyLabelScope(),
         breakTargetStack = const EmptyLink<TargetElement>(),
         continueTargetStack = const EmptyLink<TargetElement>();
 
-  LabelElement lookupLabel(String label) =>
-      labels.lookup(label);
-
+  LabelElement lookupLabel(String label, [bool inStaticContext = false]) {
+    return labels.lookup(label, inStaticContext);
+  }
   TargetElement currentBreakTarget() =>
     breakTargetStack.isEmpty() ? null : breakTargetStack.head;
 
   TargetElement currentContinueTarget() =>
     continueTargetStack.isEmpty() ? null : continueTargetStack.head;
 
   void enterLabelScope(LabelElement element) {
     labels = new LabeledStatementLabelScope(labels, element);
     nestingLevel++;
   }
@@ skipping 45 matching lines @@
       inInstanceContext = element.isInstanceMember()
           || element.isGenerativeConstructor(),
       this.context  = element.isMember()
         ? new ClassScope(element.enclosingElement, element.getLibrary())
         : new TopScope(element.getLibrary()),
       this.currentClass = element.isMember() ? element.enclosingElement : null,
       this.statementScope = new StatementScope(),
       super(compiler);
 
   Element lookup(Node node, SourceString name) {
-    Element result = context.lookup(name);
+    Element result = context.lookup(name, !inInstanceContext);
     if (!inInstanceContext && result != null && result.isInstanceMember()) {
       error(node, MessageKind.NO_INSTANCE_AVAILABLE, [node]);
     }
     return result;
   }
 
   // Create, or reuse an already created, statement element for a statement.
   TargetElement getOrCreateTargetElement(Node statement) {
     TargetElement element = mapping[statement];
     if (element === null) {
       element = new TargetElement(statement,
                                      statementScope.nestingLevel,
                                      enclosingElement);
       mapping[statement] = element;
     }
     return element;
   }
 
   inStaticContext(action()) {
     bool wasInstanceContext = inInstanceContext;
     inInstanceContext = false;
-    action();
+    var result = action();
     inInstanceContext = wasInstanceContext;
+    return result;
   }
 
   visitInStaticContext(Node node) {
     inStaticContext(() => visit(node));
   }
 
   Element visitIdentifier(Identifier node) {
     if (node.isThis()) {
       if (!inInstanceContext) {
         error(node, MessageKind.NO_INSTANCE_AVAILABLE, [node]);
@@ skipping 24 matching lines @@
     if (node.typeName.asSend() !== null) {
       // In new and const expressions, the type name can be a Send to
       // denote named constructors or library prefixes.
       Send send = node.typeName.asSend();
       className = send.receiver.asIdentifier().source;
     } else {
       className = node.typeName.asIdentifier().source;
     }
     if (className == const SourceString('var')) return null;
     if (className == const SourceString('void')) return null;
-    Element element = context.lookup(className);
+    Element element = context.lookup(className, !inInstanceContext);
     if (element === null) {
       if (typeRequired) {
         error(node, MessageKind.CANNOT_RESOLVE_TYPE, [className]);
       } else {
         warning(node, MessageKind.CANNOT_RESOLVE_TYPE, [className]);
       }
     } else if (!element.impliesType()) {
       if (typeRequired) {
         error(node, MessageKind.NOT_A_TYPE, [className]);
       } else {
@@ skipping 342 matching lines @@
       // TODO(ngeoffray): resolution error with wrong number of
       // parameters. We cannot do this rigth now because of the
       // List constructor.
     }
     useElement(node.send, constructor);
     return null;
   }
 
   FunctionElement resolveConstructor(NewExpression node) {
     FunctionElement constructor =
-      node.accept(new ConstructorResolver(compiler, this));
+        node.accept(new ConstructorResolver(compiler, this));
     if (constructor === null) {
-      error(node.send, MessageKind.CANNOT_FIND_CONSTRUCTOR, [node.send]);
+      Element resolved = resolveTypeRequired(node.send.selector);
+      if (resolved !== null && resolved.kind === ElementKind.TYPE_VARIABLE) {
+        error(node, WarningKind.TYPE_VARIABLE_AS_CONSTRUCTOR);
+        return null;
+      } else {
+        error(node.send, MessageKind.CANNOT_FIND_CONSTRUCTOR, [node.send]);
+      }
     }
     return constructor;
   }
 
   Element resolveTypeRequired(Node node) {
     bool old = typeRequired;
     typeRequired = true;
     Element element = visit(node);
     typeRequired = old;
     return element;
@@ skipping 217 matching lines @@
     visitIn(node.block, scope);
   }
 
   visitTypedef(Typedef node) {
     unimplemented(node, 'typedef');
   }
 }
 
 class ClassResolverVisitor extends CommonResolverVisitor<Type> {
   Scope context;
+  ClassElement classElement;
 
   ClassResolverVisitor(Compiler compiler, LibraryElement library)
     : context = new TopScope(library),
       super(compiler);
 
   Type visitClassNode(ClassNode node) {
-    ClassElement element = context.lookup(node.name.source);
-    compiler.ensure(element !== null);
-    compiler.ensure(!element.isResolved);
-    element.supertype = visit(node.superclass);
-    if (element.name != Types.OBJECT && element.supertype === null) {
+    classElement = context.lookup(node.name.source);
+    compiler.ensure(classElement !== null);
+    compiler.ensure(!classElement.isResolved);
+    final Link<TypeVariable> parameters =
+        node.typeParameters !== null ? node.typeParameters.nodes
+                                     : const EmptyLink<TypeVariable>();
+    // Create types and elements for type variable.
+    for (Link<TypeVariable> link = parameters;
+         !link.isEmpty();
+         link = link.tail) {
+      TypeVariable typeNode = link.head;
+      SourceString variableName = typeNode.name.source;
+      TypeVariableType variableType = new TypeVariableType(variableName);
+      TypeVariableElement variableElement =
+          new TypeVariableElement(variableName, classElement, node,
+                                  variableType);
+      variableType.element = variableElement;
+      classElement.typeParameters[variableName] = variableElement;
+      context = new TypeVariableScope(context, variableElement);
+    }
+    // Resolve the bounds of type variables.
+    for (Link<TypeVariable> link = parameters;
+         !link.isEmpty();
+         link = link.tail) {
+      TypeVariable typeNode = link.head;
+      SourceString variableName = typeNode.name.source;
+      TypeVariableElement variableElement =
+          classElement.typeParameters[variableName];
+      if (typeNode.bound !== null) {
+        Type boundType = visit(typeNode.bound);
+        if (boundType !== null && boundType.element == variableElement) {
+          warning(node, MessageKind.CYCLIC_TYPE_VARIABLE,
+                  [variableElement.name]);
+        } else if (boundType !== null) {
+          variableElement.bound = boundType;
+        } else {
+          variableElement.bound = compiler.objectClass.computeType(compiler);
+        }
+      }
+    }
+    // Find super type.
+    Type supertype = visit(node.superclass);
+    if (supertype !== null && supertype.element.impliesType()) {
+      classElement.supertype = supertype;
+    } else if (supertype !== null) {
+      error(node.superclass, MessageKind.TYPE_NAME_EXPECTED);
+    }
+    if (classElement.name != Types.OBJECT && classElement.supertype === null) {
       ClassElement objectElement = context.lookup(Types.OBJECT);
       if (objectElement !== null && !objectElement.isResolved) {
         compiler.resolver.toResolve.add(objectElement);
       } else if (objectElement === null){
         error(node, MessageKind.CANNOT_RESOLVE_TYPE, [Types.OBJECT]);
       }
-      element.supertype = new SimpleType(Types.OBJECT, objectElement);
+      classElement.supertype = new SimpleType(Types.OBJECT, objectElement);
     }
     if (node.defaultClause !== null) {
-      element.defaultClass = visit(node.defaultClause.nodes.head);
+      classElement.defaultClass = visit(node.defaultClause);
     }
     for (Link<Node> link = node.interfaces.nodes;
          !link.isEmpty();
          link = link.tail) {
-      element.interfaces = element.interfaces.prepend(visit(link.head));
+      Type interfaceType = visit(link.head);
+      if (interfaceType !== null && interfaceType.element.impliesType()) {

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

IMO interfaceType.element.impliesType should always return true. Which situation
is that?

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

It could be a type variable, which is illegal.

+        classElement.interfaces =
+            classElement.interfaces.prepend(interfaceType);
+      } else {
+        error(link.head, MessageKind.TYPE_NAME_EXPECTED);
+      }
     }
-    calculateAllSupertypes(element, new Set<ClassElement>());
-    addDefaultConstructorIfNeeded(element);
-    return element.computeType(compiler);
+    calculateAllSupertypes(classElement, new Set<ClassElement>());
+    addDefaultConstructorIfNeeded(classElement);
+    return classElement.computeType(compiler);
   }
 
   Type visitTypeAnnotation(TypeAnnotation node) {
     return visit(node.typeName);
   }
 
+  Type visitTypeVariable(TypeVariable node) {

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

Is that really necessary? And it's not obvious that it should return the bound
of the type variable. Why is it not the type of the variable?

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

Done, removed.

+    if (node.bound === null) {
+      return compiler.objectClass;
+    }
+    return visit(node.bound);
+  }
+
   Type visitIdentifier(Identifier node) {
     Element element = context.lookup(node.source);
     if (element === null) {
       error(node, MessageKind.CANNOT_RESOLVE_TYPE, [node]);
-    } else if (!element.impliesType()) {
+      return null;
+    } else if (!element.impliesType() && !element.isTypeVariable()) {
       error(node, MessageKind.NOT_A_TYPE, [node]);
+      return null;
     } else {
       if (element.isClass()) {
         compiler.resolver.toResolve.add(element);
       }
-      // TODO(ngeoffray): Use type variables.
-      return element.computeType(compiler);
+      if (element.isTypeVariable()) {
+        TypeVariableElement variableElement = element;
+        return variableElement.type;
+      } else if (element.isTypedef()) {
+        compiler.unimplemented('visitIdentifier for typedefs');
+      } else {
+        // TODO(ngeoffray): Use type variables.

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

I believe you can remove this TODO now.

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

Done.

+        return element.computeType(compiler);
+      }
     }
     return null;
   }
 
   Type visitSend(Send node) {
     Identifier prefix = node.receiver.asIdentifier();
     if (prefix === null) {
       error(node.receiver, MessageKind.NOT_A_PREFIX, [node.receiver]);
       return null;
     }
@@ skipping 348 matching lines @@
 
 class Scope {
   final Element element;
   final Scope parent;
 
   Scope(this.parent, this.element);
   abstract Element add(Element element);
   abstract Element lookup(SourceString name);
 }
 
+class TypeVariableScope extends Scope {
+  TypeVariableScope(parent, element) : super(parent, element);
+  Element add(Element element) {
+    throw "Cannot add element to TypeVariableScope";
+  }
+  Element lookup(SourceString name, [bool inStaticContext = false]) {
+    if (!inStaticContext && name == element.name) {

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

I don't believe this is correct. The scope should not change based on whether or
not something is static.

For example, this should be a compile-time error because the type variable hides
the top-level field T:

var T;

class Foo<T> {
  static method() => T;
}

Also, why do you need a TypeVariableScope? Are you trying to reject this:

class Foo<T extends List<S>, S> {
}

I don't think this is supposed to be rejected.

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

Done, removed.

+      return element;
+    }
+    if (parent !== null) return parent.lookup(name);
+  }
+}
+
 class MethodScope extends Scope {
   final Map<SourceString, Element> elements;
 
   MethodScope(Scope parent, Element element)
     : super(parent, element), this.elements = new Map<SourceString, Element>();
 
-  Element lookup(SourceString name) {
+  Element lookup(SourceString name, [bool inStaticContext = false]) {
     Element element = elements[name];
     if (element !== null) return element;
-    return parent.lookup(name);
+    return parent.lookup(name, inStaticContext);
   }
 
   Element add(Element element) {
     if (elements.containsKey(element.name)) return elements[element.name];
     elements[element.name] = element;
     return element;
   }
 }
 
 class BlockScope extends MethodScope {
   BlockScope(Scope parent) : super(parent, parent.element);
 }
 
 class ClassScope extends Scope {
   ClassScope(ClassElement element, LibraryElement library)
     : super(new TopScope(library), element);
 
-  Element lookup(SourceString name) {
+  Element lookup(SourceString name, [bool inStaticContext = false]) {
     ClassElement cls = element;
-    Element memberElement = cls.lookupLocalMember(name);
-    if (memberElement != null) return memberElement;
-    memberElement = parent.lookup(name);
-    if (memberElement != null) return memberElement;
+    Element result = cls.lookupLocalMember(name);
+    if (result !== null) return result;
+    if (!inStaticContext) {
+      result = cls.lookupTypeParameter(name);
+    }
+    result = parent.lookup(name);
+    if (result != null) return result;
     return cls.lookupSuperMember(name);
   }
 
   Element add(Element element) {
     throw "Cannot add an element in a class scope";
   }
 }
 
 class TopScope extends Scope {
   LibraryElement get library() => element;
 
   TopScope(LibraryElement library) : super(null, library);
-  Element lookup(SourceString name) => library.find(name);
+  Element lookup(SourceString name, [bool inStaticContext = false]) {
+    return library.find(name);
+  }
 
   Element add(Element element) {
     throw "Cannot add an element in the top scope";
   }
 }