Lots of frog cleanup

frog/library.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.
 
 class LibraryImport {
   final String prefix;
   final Library library;
   final SourceSpan span;
   LibraryImport(this.library, [this.prefix, this.span]);
 }
@@ skipping 100 matching lines @@
       } else {
         mset.members.add(member);
       }
     } else {
       world._addMember(member);
     }
   }
 
   // TODO(jimhug): Cache and share the types as interfaces!
   Type getOrAddFunctionType(Element enclosingElement, String name,
-      FunctionDefinition func) {
+      FunctionDefinition func, MethodData data) {
     // TODO(jimhug): This is redundant now that FunctionDef has type params.
     final def = new FunctionTypeDefinition(func, null, func.span);
     final type = new DefinedType(name, this, def, false);
     type.addMethod(':call', func);
     var m = type.members[':call'];
     m.enclosingElement = enclosingElement;
     m.resolve();
+    m._methodData = data;
     // Function types implement the Function interface.
     type.interfaces = [world.functionType];
     return type;
   }
 
   /** Adds a type to the library. */
   DefinedType addType(String name, Node definition, bool isClass) {
     if (types.containsKey(name)) {
       var existingType = types[name];
       if ((isCore || isCoreImpl) && existingType.definition == null) {
@@ skipping 52 matching lines @@
         if (ret != null  && ret != newRet) {
           world.error('conflicting types for "$name"', ret.span, newRet.span);
         } else {
           ret = newRet;
         }
       }
     }
     return ret;
   }
 
-  Type resolveType(TypeReference node, bool typeErrors) {
+
+  // TODO(jimhug): Why is it okay to assume node is NameTypeReference in here?
+  Type resolveType(TypeReference node, bool typeErrors, bool allowTypeParams) {
     if (node == null) return world.varType;
 
-    if (node.type != null) return node.type;
+    var ret = findType(node);
 
-    node.type = findType(node);
-
-    if (node.type == null) {
+    if (ret == null) {
       var message = 'cannot find type ${_getDottedName(node)}';
       if (typeErrors) {
         world.error(message, node.span);
-        node.type = world.objectType;
+        return world.objectType;
       } else {
         world.warning(message, node.span);
-        node.type = world.varType;
+        return world.varType;
       }
     }
-    return node.type;
+    return ret;
   }
 
   static String _getDottedName(NameTypeReference type) {
     if (type.names != null) {
       var names = map(type.names, (n) => n.name);
       return type.name.name + '.' + Strings.join(names, '.');
     } else {
       return type.name.name;
     }
   }
@@ skipping 125 matching lines @@
     library.sources.add(source);
     final parser = new Parser(source, diet: options.dietParse);
     final unit = parser.compilationUnit();
 
     unit.forEach((def) => def.visit(this));
 
     assert(sources.length == 0 || isTop);
     isTop = false;
     var newSources = sources;
     sources = [];
-    for (var source in newSources) {
-      addSource(source);
+    for (var newSource in newSources) {
+      addSource(newSource);
     }
   }
 
   void visitDirectiveDefinition(DirectiveDefinition node) {
     if (!isTop) {
       world.error('directives not allowed in sourced file', node.span);
       return;
     }
 
     var name;
@@ skipping 134 matching lines @@
 
   void visitFunctionDefinition(FunctionDefinition node) {
     currentType.addMethod(node.name.name, node);
   }
 
   void visitFunctionTypeDefinition(FunctionTypeDefinition node) {
     var type = library.addType(node.func.name.name, node, false);
     type.addMethod(':call', node.func);
   }
 }