Move TypeDefinitionVisitor.

lib/compiler/implementation/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);
   Type getType(TypeAnnotation annotation);
 }
 
@@ skipping 1639 matching lines @@
     }
     visitIn(node.formals, blockScope);
     visitIn(node.block, blockScope);
   }
 
   visitTypedef(Typedef node) {
     unimplemented(node, 'typedef');
   }
 }
 
+class TypeDefinitionVisitor extends CommonResolverVisitor<Type> {
+  Scope scope;
+  TypeDeclarationElement element;
+  TypeResolver typeResolver;
+
+  TypeDefinitionVisitor(Compiler compiler, TypeDeclarationElement element)
+      : this.element = element,
+        scope = element.enclosingElement.buildScope(),
+        typeResolver = new TypeResolver(compiler),
+        super(compiler);
+
+  void resolveTypeVariableBounds(NodeList node) {
+    if (node === null) return;
+
+    var nameSet = new Set<SourceString>();
+    // Resolve the bounds of type variables.
+    Link<Type> typeLink = element.typeVariables;
+    Link<Node> nodeLink = node.nodes;
+    while (!nodeLink.isEmpty()) {
+      TypeVariableType typeVariable = typeLink.head;
+      SourceString typeName = typeVariable.name;
+      TypeVariable typeNode = nodeLink.head;
+      if (nameSet.contains(typeName)) {
+        error(typeNode, MessageKind.DUPLICATE_TYPE_VARIABLE_NAME, [typeName]);
+      }
+      nameSet.add(typeName);
+
+      TypeVariableElement variableElement = typeVariable.element;
+      if (typeNode.bound !== null) {
+        Type boundType = typeResolver.resolveTypeAnnotation(
+            typeNode.bound, inScope: scope, onFailure: warning);
+        if (boundType !== null && boundType.element == variableElement) {
+          // TODO(johnniwinther): Check for more general cycles, like
+          // [: <A extends B, B extends C, C extends B> :].
+          warning(node, MessageKind.CYCLIC_TYPE_VARIABLE,
+                  [variableElement.name]);
+        } else if (boundType !== null) {
+          variableElement.bound = boundType;
+        } else {
+          // TODO(johnniwinther): Should be an erroneous type.
+          variableElement.bound = compiler.objectClass.computeType(compiler);
+        }
+      } else {
+        variableElement.bound = compiler.objectClass.computeType(compiler);
+      }
+      nodeLink = nodeLink.tail;
+      typeLink = typeLink.tail;
+    }
+    assert(typeLink.isEmpty());
+  }
+}
+
 class ClassResolverVisitor extends TypeDefinitionVisitor {
   ClassElement get element() => super.element;
 
   ClassResolverVisitor(Compiler compiler, ClassElement classElement)
     : super(compiler, classElement);
 
   Type visitClassNode(ClassNode node) {
     compiler.ensure(element !== null);
     compiler.ensure(!element.isResolved);
 
@@ skipping 177 matching lines @@
        type.element === compiler.boolClass ||
        type.element === compiler.numClass ||
        type.element === compiler.intClass ||
        type.element === compiler.doubleClass ||
        type.element === compiler.stringClass ||
        type.element === compiler.nullClass ||
        type.element === compiler.functionClass);
   }
 }
 
-class TypeDefinitionVisitor extends CommonResolverVisitor<Type> {
-  Scope scope;
-  TypeDeclarationElement element;
-  TypeResolver typeResolver;
-
-  TypeDefinitionVisitor(Compiler compiler, TypeDeclarationElement element)
-      : this.element = element,
-        scope = element.enclosingElement.buildScope(),
-        typeResolver = new TypeResolver(compiler),
-        super(compiler);
-
-  void resolveTypeVariableBounds(NodeList node) {
-    if (node === null) return;
-
-    var nameSet = new Set<SourceString>();
-    // Resolve the bounds of type variables.
-    Link<Type> typeLink = element.typeVariables;
-    Link<Node> nodeLink = node.nodes;
-    while (!nodeLink.isEmpty()) {
-      TypeVariableType typeVariable = typeLink.head;
-      SourceString typeName = typeVariable.name;
-      TypeVariable typeNode = nodeLink.head;
-      if (nameSet.contains(typeName)) {
-        error(typeNode, MessageKind.DUPLICATE_TYPE_VARIABLE_NAME, [typeName]);
-      }
-      nameSet.add(typeName);
-
-      TypeVariableElement variableElement = typeVariable.element;
-      if (typeNode.bound !== null) {
-        Type boundType = typeResolver.resolveTypeAnnotation(
-            typeNode.bound, inScope: scope, onFailure: warning);
-        if (boundType !== null && boundType.element == variableElement) {
-          // TODO(johnniwinther): Check for more general cycles, like
-          // [: <A extends B, B extends C, C extends B> :].
-          warning(node, MessageKind.CYCLIC_TYPE_VARIABLE,
-                  [variableElement.name]);
-        } else if (boundType !== null) {
-          variableElement.bound = boundType;
-        } else {
-          // TODO(johnniwinther): Should be an erroneous type.
-          variableElement.bound = compiler.objectClass.computeType(compiler);
-        }
-      } else {
-        variableElement.bound = compiler.objectClass.computeType(compiler);
-      }
-      nodeLink = nodeLink.tail;
-      typeLink = typeLink.tail;
-    }
-    assert(typeLink.isEmpty());
-  }
-}
-
 class VariableDefinitionsVisitor extends CommonResolverVisitor<SourceString> {
   VariableDefinitions definitions;
   ResolverVisitor resolver;
   ElementKind kind;
   VariableListElement variables;
 
   VariableDefinitionsVisitor(Compiler compiler,
                              this.definitions, this.resolver, this.kind)
     : super(compiler)
   {
@@ skipping 382 matching lines @@
   TopScope(LibraryElement library) : super(null, library);
   Element lookup(SourceString name) {
     return library.find(name);
   }
 
   Element add(Element newElement) {
     throw "Cannot add an element in the top scope";
   }
   String toString() => '$element';
 }