Work in progress: changes to interpretation

frog/type.dart

-// Copyright (c) 2011, the Dart project authors.  Please see the AUTHORS file
+// 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 Type extends Element {
   bool isTested = false;
   bool isChecked = false;
   bool isWritten = false;
 
   /**
    * For core types (int, String, etc) this is the generated type assertion
    * function (uses JS "typeof"). This field is null for all other types.
    */
   String typeCheckCode;
 
   Member _typeMember;
 
   /** Stubs used to call into this method dynamically. */
   Map<String, VarMember> varStubs;
 
   /** Cache of [Member]s that have been found. */
   Map<String, Member> _foundMembers;
 
   Type(String name): _foundMembers = {}, varStubs = {}, super(name, null);
 
   void markUsed() {}
-  abstract void genMethod(Member method);
+  abstract void markUsedMethod(Member method);
 
   TypeMember get typeMember() {
     if (_typeMember == null) {
       _typeMember = new TypeMember(this);
     }
     return _typeMember;
   }
 
   abstract Type resolveTypeParams(ConcreteType inType);
 
@@ skipping 126 matching lines @@
     assert(isObject);
     // Add a != method just like the == one.
     MethodMember eq = members[':eq'];
     if (eq == null) {
       // TODO(jmesserly): should this be an error?
       // Frog is being hosted by "utils/css" such that it doesn't have its
       // standard lib initialized properly.
       return;
     }
     final ne = new MethodMember(':ne', this, eq.definition);
-    ne.isGenerated = true;
     ne.returnType = eq.returnType;
     ne.parameters = eq.parameters;
     ne.isStatic = eq.isStatic;
     ne.isAbstract = eq.isAbstract;
     // TODO - What else to fill in?
     members[':ne'] = ne;
   }
 
   Member _getMemberInParents(String memberName) {
     // print('getting $memberName in parents of $name, $isClass');
@@ skipping 48 matching lines @@
       // similar enough, which is probably true quite often in practice.
       if (args.length != call.parameters.length || !call.namesInOrder(args)) {
         return true;
       }
     }
 
     // Use a normal JS call, or not a function type.
     return false;
   }
 
+  // TODO(jmesserly): does this function stick around once we have UnionValue?
   static Type union(Type x, Type y) {
     if (x == y) return x;
+
     if (x.isNum && y.isNum) return world.numType;
     if (x.isString && y.isString) return world.stringType;
 
     // TODO(jmesserly): make this more precise when we can. Or add UnionValue
     // and have Value do the heavy lifting of tracking sets of types.
     return world.varType;
   }
 
   // This is from the "Interface Types" section of the language spec:
 
@@ skipping 12 matching lines @@
    * if I is listed in the extends clause of J.
    */
   bool _isDirectSupertypeOf(Type other) {
     if (other.isClass) {
       return other.parent == this || isObject && other.parent == null;
     } else {
       if (other.interfaces == null || other.interfaces.isEmpty()) {
         return isObject;
       } else {
         return other.interfaces.some((i) => i == this);