Lots of frog cleanup

frog/gen.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.
 
 /**
  * Top level generator object for writing code and keeping track of
  * dependencies.
  *
  * Should have two compilation models, but only one implemented so far.
  *
  * 1. Do a top-level resolution of all types and their members.
  * 2. Start from main and walk the call-graph compiling members as needed.
  * 2a. That includes compiling overriding methods and calling methods by
  *     selector when invoked on var.
  * 3. Spit out all required code.
  */
 class WorldGenerator {
   MethodMember main;
   CodeWriter writer;
   CodeWriter _mixins;
 
+  CallingContext mainContext;
+
   /**
    * Whether the app has any static fields used. Note this could still be true
    * and [globals] be empty if no static field has a default initialization.
    */
   bool hasStatics = false;
 
   /** Global const and static field initializations. */
   Map<String, GlobalValue> globals;
   CoreJs corejs;
 
   /** */
   Set<Type> typesWithDynamicDispatch;
 
   WorldGenerator(this.main, this.writer)
     : globals = {}, corejs = new CoreJs();
 
+  analyze() {
+    // Walk all code and find all NewExpressions - to determine possible types
+    int nlibs=0, ntypes=0, nmems=0, nnews=0;
+    //Set<Type> newedTypes = new Set<Type>();
+    for (var lib in world.libraries.getValues()) {
+      nlibs += 1;
+      for (var type in lib.types.getValues()) {
+        ntypes += 1;
+        var allMembers = [];
+        allMembers.addAll(type.constructors.getValues());
+        allMembers.addAll(type.members.getValues());
+        type.factories.forEach((f) => allMembers.add(f));
+        for (var m in allMembers) {
+          if (m.isAbstract || !m.isMethod) continue;
+
+          m.methodData.analyze();
+        }
+      }
+    }
+  }
+
   run() {
-    var metaGen = new MethodGenerator(main, null);
+    mainContext = new MethodGenerator(main, null);
     var mainTarget = new TypeValue(main.declaringType, main.span);
-    var mainCall = main.invoke(metaGen, null, mainTarget, Arguments.EMPTY);
+    var mainCall = main.invoke(mainContext, null, mainTarget, Arguments.EMPTY);
     main.declaringType.markUsed();
 
     if (options.compileAll) {
       markLibrariesUsed(
           [world.coreimpl, world.corelib, main.declaringType.library]);
     }
 
     // These are essentially always used through literals - just include them
     world.numImplType.markUsed();
     world.stringImplType.markUsed();
 
     // Only include isolate-specific code if isolates are used.
     if (world.corelib.types['Isolate'].isUsed
         || world.coreimpl.types['ReceivePortImpl'].isUsed) {
 
       // Generate callbacks from JS to isolate code if needed
       if (corejs.useWrap0 || corejs.useWrap1) {
         genMethod(world.coreimpl.types['IsolateContext'].getMember('eval'));
         genMethod(world.coreimpl.types['EventLoop'].getMember('run'));
       }
 
       corejs.useIsolates = true;
       MethodMember isolateMain =
         world.coreimpl.lookup('startRootIsolate', main.span);
       var isolateMainTarget = new TypeValue(world.coreimpl.topType, main.span);
-      mainCall = isolateMain.invoke(metaGen, null, isolateMainTarget,
-          new Arguments(null, [main._get(metaGen, main.definition, null)]));
+      mainCall = isolateMain.invoke(mainContext, null, isolateMainTarget,
+          new Arguments(null, [main._get(mainContext, main.definition, null)]));
     }
 
     writeTypes(world.coreimpl);
     writeTypes(world.corelib);
 
     // Write the main library. This will cause all libraries to be written in
     // the topographic sort order.
     writeTypes(main.declaringType.library);
 
     // Write out any inherited concrete members.
@@ skipping 122 matching lines @@
     for (var type in orderedTypes) {
       if ((type.library.isDom || type.isHiddenNativeType) &&
           type.isClass) {
         type.markUsed();
       }
     }
 
     for (var type in orderedTypes) {
       if (type.isUsed && type.isClass) {
         writeType(type);
-
-        if (type.isGeneric) {
+        // TODO(jimhug): Performance is terrible if we use current
+        // reified generics approach for reified generic Arrays.
+        if (type.isGeneric && type !== world.listFactoryType) {
           for (var ct in _orderValues(type._concreteTypes)) {
-            writeType(ct);
+            if (ct.isUsed) writeType(ct);
           }
         }
       } else if (type.isFunction && type.varStubs.length > 0) {
         // Emit stubs on "Function" or hidden types if needed
         writer.comment('// ********** Code for ${type.jsname} **************');
         _writeDynamicStubs(type);
       }
       // Type check functions for builtin JS types
       if (type.typeCheckCode != null) {
         writer.writeln(type.typeCheckCode);
       }
     }
   }
 
-  genMethod(Member meth, [MethodGenerator enclosingMethod=null]) {
-    if (!meth.isGenerated && !meth.isAbstract && meth.definition != null) {
-      new MethodGenerator(meth, enclosingMethod).run();
-    }
+  genMethod(MethodMember meth) {
+    meth.methodData.run(meth);
   }
 
   String _prototypeOf(Type type, String name) {
     if (type.isSingletonNative) {
       // e.g. window.console.log$1
       return '${type.jsname}.$name';
     } else if (type.isHiddenNativeType) {
       corejs.ensureDynamicProto();
       _usedDynamicDispatchOnType(type);
       return '\$dynamic("$name").${type.definition.nativeType.name}';
@@ skipping 63 matching lines @@
   writeType(Type type) {
     if (type.isWritten) return;
 
     type.isWritten = true;
     // Ensure parent has been written before the child. Important ordering for
     // IE when we're using $inherits, since we don't have __proto__ available.
     if (type.parent !=  null && !type.isNative) {
       writeType(type.parent);
     }
 
-    // TODO(jimhug): Workaround for problems with reified generic Array.
-    if (type.name != null && type is ConcreteType &&
-        type.library == world.coreimpl &&
-        type.name.startsWith('ListFactory')) {
-      writer.writeln('${type.jsname} = ${type.genericType.jsname};');
-      return;
-    }
-
     var typeName = type.jsname != null ? type.jsname : 'top level';
     writer.comment('// ********** Code for ${typeName} **************');
-    if (type.isNative && !type.isTop) {
+    if (type.isNative && !type.isTop && !type.isConcreteGeneric) {
       var nativeName = type.definition.nativeType.name;
       if (nativeName == '') {
         writer.writeln('function ${type.jsname}() {}');
       } else if (type.jsname != nativeName) {
         if (type.isHiddenNativeType) {
           if (_typeNeedsHolderForStaticMethods(type)) {
             // This is a holder for static methods.
             writer.writeln('var ${type.jsname} = {};');

[sra1, 2012/01/23 20:40:30]

This code is being emitted unnecessarily for all 500 DOM types - see
_typeNeedsHolderForStaticMethods.

           }
         } else {
           writer.writeln('${type.jsname} = ${nativeName};');
         }
       }
     }
 
+    // TODO(jimhug): This comment below seems out-of-order now?
     // We need the $inherits function to be declared before factory constructors
     // so that inheritance ($inherits) will work correctly in IE.
     if (!type.isTop) {
-      if (type is ConcreteType) {
+      if (type.genericType !== type) {
+        corejs.ensureInheritsHelper();
+        writer.writeln('\$inherits(${type.jsname}, ${type.genericType.jsname});');
+      }
+
+      // TODO(jimhug): Do we still need this code below?
+      /*if (type is ConcreteType) {
         ConcreteType c = type;
         corejs.ensureInheritsHelper();
         writer.writeln('\$inherits(${c.jsname}, ${c.genericType.jsname});');
 
         // Mixin members from concrete specializations of base types too.
         // TODO(jmesserly): emit this sooner instead of at the end.
         // But it needs to come after we've emitted both types.
         // TODO(jmesserly): HACK: using _parent instead of parent so we don't
         // try to inherit things that we didn't actually use.
         for (var p = c._parent; p is ConcreteType; p = p._parent) {
           _ensureInheritMembersHelper();
           _mixins.writeln('\$inheritsMembers(${c.jsname}, ${p.jsname});');
         }
-      } else if (!type.isNative) {
+      } else*/
+      else if (!type.isNative) {
         if (type.parent != null && !type.parent.isObject) {
           corejs.ensureInheritsHelper();
           writer.writeln('\$inherits(${type.jsname}, ${type.parent.jsname});');
         }
       }
     }
 
     if (type.isTop) {
       // no preludes for top type
     } else if (type.constructors.length == 0) {
-      if (!type.isNative) {
+      if (!type.isNative || type.isConcreteGeneric) {
         // TODO(jimhug): More guards to guarantee staticness
         writer.writeln('function ${type.jsname}() {}');
       }
     } else {
-      Member standardConstructor = type.constructors[''];
-      if (standardConstructor == null ||
-          standardConstructor.generator == null) {
-        if (!type.isNative) {
-          writer.writeln('function ${type.jsname}() {}');
+      bool wroteStandard = false;
+      for (var c in type.constructors.getValues()) {
+        if (c.methodData.writeDefinition(c, writer)) {
+          if (c.isConstructor && c.constructorName == '') wroteStandard = true;
         }
-      } else {
-        standardConstructor.generator.writeDefinition(writer, null);
       }
 
-      for (var c in type.constructors.getValues()) {
-        if (c.generator != null && c != standardConstructor) {
-          c.generator.writeDefinition(writer, null);
-        }
+      if (!wroteStandard && (!type.isNative || type.genericType !== type)) {
+        writer.writeln('function ${type.jsname}() {}');
       }
     }
 
     // Concrete types (like List<String>) will have this already defined on
     // their prototype from the generic type (like List)
-    if (type is! ConcreteType) {
+    if (!type.isConcreteGeneric) {
       _maybeIsTest(type, type);
     }
     if (type.genericType._concreteTypes != null) {
       for (var ct in _orderValues(type.genericType._concreteTypes)) {
         _maybeIsTest(type, ct);
       }
     }
 
     if (type.interfaces != null) {
       final seen = new Set();
@@ skipping 47 matching lines @@
    *  }
    *
    * The factory method and static member are generated something like this:
    *    var lib_Float32Array = {};
    *    lib_Float32Array.Float32Array$factory = ... ;
    *    lib_Float32Array._construct = ... ;
    *
    * This predicate determines when we need to define lib_Float32Array.
    */
   _typeNeedsHolderForStaticMethods(Type type) {
-    for (var member in type.members.getValues()) {
-      if (member.isMethod) {
-        if (member.isConstructor || member.isStatic) {
-          if (member.isGenerated) {
-            return true;
-          }
-        }
-      }
-    }
-    return false;
+    return type.isUsed;

[sra1, 2012/01/23 20:40:30]

This new code causes 500 useless dummy declarations for DOM hidden native
classes with no static methods, i.e. 20k bloat.

   }
 
   /**
    * Generates the $inheritsMembers function when it's first used.
    * This is used to mix in specialized generic members from the base class.
    */
   _ensureInheritMembersHelper() {
     if (_mixins != null) return;
     _mixins = new CodeWriter();
     _mixins.comment('// ********** Generic Type Inheritance **************');
@@ skipping 31 matching lines @@
     // No need to write code for a static class field with no initial value.
   }
 
   _writeField(FieldMember field) {
     // Generate declarations for static top-level fields with no value.
     if (field.declaringType.isTop && !field.isNative && field.value == null) {
       writer.writeln('var ${field.jsname};');
     }
 
     // generate code for instance fields
-    if (field._providePropertySyntax) {
+    if (field._providePropertySyntax &&
+        !field.declaringType.isConcreteGeneric) {
       _writePrototypePatch(field.declaringType, 'get\$${field.jsname}',
           'function() { return this.${field.jsname}; }', writer);
       if (!field.isFinal) {
         _writePrototypePatch(field.declaringType, 'set\$${field.jsname}',
           'function(value) { return this.${field.jsname} = value; }', writer);
       }
     }
 
     // TODO(jimhug): Currently choose not to initialize fields on objects, but
     //    instead to rely on uninitialized === null in our generated code.
     //    Investigate the perf pros and cons of this.
   }
 
   _writeProperty(PropertyMember property) {
     if (property.getter != null) _writeMethod(property.getter);
     if (property.setter != null) _writeMethod(property.setter);
 
     // TODO(jmesserly): make sure we don't do this on hidden native types!
-    if (property._provideFieldSyntax) {
+    if (property.needsFieldSyntax) {
       writer.enterBlock('Object.defineProperty(' +
         '${property.declaringType.jsname}.prototype, "${property.jsname}", {');
       if (property.getter != null) {
         writer.write(
           'get: ${property.declaringType.jsname}.prototype.${property.getter.jsname}');
         // The shenanigan below is to make IE happy -- IE 9 doesn't like a
         // trailing comma on the last element in a list.
         writer.writeln(property.setter == null ? '' : ',');
       }
       if (property.setter != null) {
         writer.writeln(
           'set: ${property.declaringType.jsname}.prototype.${property.setter.jsname}');
       }
       writer.exitBlock('});');
     }
   }
 
-  _writeMethod(Member m) {
-    if (m.generator != null) {
-      m.generator.writeDefinition(writer, null);
-    } else if (m is MethodMember && m.isNative
-        && m._providePropertySyntax && !m._provideFieldSyntax) {
+  _writeMethod(MethodMember m) {
+    m.methodData.writeDefinition(m, writer);
+
+    if (m.isNative && m._providePropertySyntax) {
       MethodGenerator._maybeGenerateBoundGetter(m, writer);
     }
   }
 
   writeGlobals() {
     if (globals.length > 0) {
       writer.comment('//  ********** Globals **************');
       var list = globals.getValues();
       list.sort((a, b) => a.compareTo(b));
 
@@ skipping 165 matching lines @@
 
     // If that fails, compare by name.
     return x.name.compareTo(y.name);
   }
 }
 
 
 /**
  * A naive code generator for Dart.
  */
-class MethodGenerator implements TreeVisitor {
+class MethodGenerator implements TreeVisitor, CallingContext {
   Member method;
   CodeWriter writer;
   BlockScope _scope;
   MethodGenerator enclosingMethod;
   bool needsThis;
   List<String> _paramCode;
 
   // TODO(jmesserly): if we knew temps were always used like a stack, we could
   // reduce the overhead here.
   List<String> _freeTemps;
@@ skipping 23 matching lines @@
     counters = world.counters;
   }
 
   Library get library() => method.library;
 
   // TODO(jimhug): Where does this really belong?
   MemberSet findMembers(String name) {
     return library._findMembers(name);
   }
 
+  bool get needsCode() => true;
+  bool get showWarnings() => false;
+
   bool get isClosure() => (enclosingMethod != null);
 
   bool get isStatic() => method.isStatic;
 
   Value getTemp(Value value) {
     return value.needsTemp ? forceTemp(value) : value;
   }
 
   VariableValue forceTemp(Value value) {
     String name;
@@ skipping 23 matching lines @@
     if (_usedTemps.remove(value.code)) {
       _freeTemps.add(value.code);
     } else {
       world.internalError(
         'tried to free unused value or non-temp "${value.code}"');
     }
     */
   }
 
   run() {
-    if (method.isGenerated) return;
-
-    // This avoids any attempts to infer across recursion.
-    method.isGenerated = true;
-    method.generator = this;
-
     // Create most generic possible call for this method.
     var thisObject;
     if (method.isConstructor) {
       thisObject = new ObjectValue(false, method.declaringType, method.span);
       thisObject.initFields();
     } else {
       thisObject = new Value(method.declaringType, 'this', null);
     }
     var values = [];
     for (var p in method.parameters) {
       values.add(new Value(p.type, p.name, null));
     }
     var args = new Arguments(null, values);
 
     evalBody(thisObject, args);
-
-    if (method.definition.nativeBody != null) {
-      // Throw away the code--it was just used for tree shaking purposes.
-      writer = new CodeWriter();
-      if (method.definition.nativeBody == '') {
-        method.generator = null;
-      } else {
-        _paramCode = map(method.parameters, (p) => p.name);
-        writer.write(method.definition.nativeBody);
-      }
-    }
   }
 
 
   writeDefinition(CodeWriter defWriter, LambdaExpression lambda/*=null*/) {
     // To implement block scope: capture any variables we need to.
     var paramCode = _paramCode;
     var names = null;
     if (captures != null && captures.length > 0) {
       names = new List.from(captures);
       names.sort((x, y) => x.compareTo(y));
@@ skipping 70 matching lines @@
     }
   }
 
   static _maybeGenerateBoundGetter(MethodMember m, CodeWriter defWriter) {
     if (m._providePropertySyntax) {
       String suffix = world.gen._writePrototypePatch(m.declaringType,
           'get\$' + m.jsname, 'function() {', defWriter, false);
       // TODO(jimhug): Bind not available in older Safari, need fallback?
       defWriter.writeln('return this.${m.jsname}.bind(this);');
       defWriter.exitBlock(suffix);
-
-      if (m._provideFieldSyntax) {
-        world.internalError('bound "${m.name}" accessed with field syntax',
-            m.definition.span);
-      }
     }
   }
 
   /**
    * Generates information about the default/named arguments into the JS code.
    * Only methods that are passed as bound methods to "var" need this. It is
    * generated to support run time stub creation.
    */
   _provideOptionalParamInfo(CodeWriter defWriter) {
     if (method is MethodMember) {
       MethodMember meth = method;
       if (meth._provideOptionalParamInfo) {
         var optNames = [];
         var optValues = [];
-        meth.genParameterValues();
+        meth.genParameterValues(this);
         for (var param in meth.parameters) {
           if (param.isOptional) {
             optNames.add(param.name);
             // TODO(jimhug): Remove this last usage of escapeString.
             optValues.add(_escapeString(param.value.code));
           }
         }
         if (optNames.length > 0) {
           // TODO(jmesserly): the logic for how to refer to
           // static/instance/top-level members is duplicated all over the place.
@@ skipping 37 matching lines @@
       var p = method.parameters[i];
       Value currentArg = null;
       // TODO(jimhug): bareCount is O(N)
       if (i < args.bareCount) {
         currentArg = args.values[i];
       } else {
         // Handle named or missing arguments
         currentArg = args.getValue(p.name);
         if (currentArg === null) {
           // Ensure default value for param has been generated
-          p.genValue(method, method.generator);
+          p.genValue(method, this);
           currentArg = p.value;
         }
       }
 
       if (p.isInitializer) {
         _paramCode.add(p.name);
         fieldsSet = true;
         _initField(newObject, p.name, currentArg, p.definition.span);
       } else {
         var paramValue = _scope.declareParameter(p);
         _paramCode.add(paramValue.code);
         if (newObject != null && newObject.isConst) {
           _scope.assign(p.name, currentArg.convertTo(this, p.type));
         }
       }
     }
 
     var initializerCall = null;
-    final declaredInitializers = method.definition.initializers;
+    final declaredInitializers = method.definition.dynamic.initializers;
     if (declaredInitializers != null) {
       for (var init in declaredInitializers) {
         if (init is CallExpression) {
           if (initializerCall != null) {
             world.error('only one initializer redirecting call is allowed',
                 init.span);
           }
           initializerCall = init;
         } else if (init is BinaryExpression
             && TokenKind.kindFromAssign(init.op.kind) == 0) {
@@ skipping 47 matching lines @@
         var value = fields[field];
         if (value === null && field.isFinal &&
             field.declaringType == method.declaringType &&
             !newObject.dynamic.seenNativeInitializer) {
           world.error('uninitialized final field "${field.name}"',
             field.span, method.span);
         }
       }
     }
 
-    var body = method.definition.body;
+    var body = method.definition.dynamic.body;
 
     if (body === null) {
       // TODO(jimhug): Move check into resolve on method.
       if (!method.isConstructor && !method.isNative) {
         world.error('unexpected empty body for ${method.name}',
           method.definition.span);
       }
     } else {
       visitStatementsInBlock(body);
     }
@@ skipping 175 matching lines @@
     savedWriter.write(writer.text);
     writer = savedWriter;
     savedCounters.add(counters);
     counters = savedCounters;
   }
 
   MethodMember _makeLambdaMethod(String name, FunctionDefinition func) {
     var meth = new MethodMember(name, method.declaringType, func);
     meth.isLambda = true;
     meth.enclosingElement = method;
+    meth._methodData = new MethodData(meth, this);
     meth.resolve();
     return meth;
   }
 
   visitBool(Expression node) {
     // Boolean conversions in if/while/do/for/conditions require non-null bool.
 
     // TODO(jmesserly): why do we have this rule? It seems inconsistent with
     // the rest of the type system, and just causes bogus asserts unless all
     // bools are initialized to false.
@@ skipping 40 matching lines @@
     return false;
   }
 
   bool visitVariableDefinition(VariableDefinition node) {
     var isFinal = false;
     // TODO(jimhug): Clean this up and share modifier parsing somewhere.
     if (node.modifiers != null && node.modifiers[0].kind == TokenKind.FINAL) {
       isFinal = true;
     }
     writer.write('var ');
-    var type = method.resolveType(node.type, false);
+    var type = method.resolveType(node.type, false, true);
     for (int i=0; i < node.names.length; i++) {
       if (i > 0) {
         writer.write(', ');
       }
       final name = node.names[i].name;
       var value = visitValue(node.values[i]);
       if (isFinal && value == null) {
         world.error('no value specified for final variable', node.span);
       }
 
@@ skipping 16 matching lines @@
     writer.writeln(';');
     return false;
 
   }
 
   bool visitFunctionDefinition(FunctionDefinition node) {
     var meth = _makeLambdaMethod(node.name.name, node);
     var funcValue = _scope.create(meth.name, meth.functionType,
         method.definition.span, isFinal:true);
 
-    world.gen.genMethod(meth, this);
-    meth.generator.writeDefinition(writer, null);
+    meth.methodData.createFunction(writer);
     return false;
   }
 
   /**
    * Returns true indicating that normal control-flow is interrupted by
    * this statement. (This could be a return, break, throw, or continue.)
    */
   bool visitReturnStatement(ReturnStatement node) {
     if (node.value == null) {
       // This is essentially "return null".
@@ skipping 139 matching lines @@
       node.body.visit(this);
       _popBlock(node.body);
     });
     _popBlock(node);
     return false;
   }
 
   bool _isFinal(typeRef) {
     if (typeRef is GenericTypeReference) {
       typeRef = typeRef.baseType;
+    } else if (typeRef is SimpleTypeReference) {
+      return false;
     }
     return typeRef != null && typeRef.isFinal;
   }
 
   bool visitForInStatement(ForInStatement node) {
     // TODO(jimhug): visitValue and other cleanups here.
-    var itemType = method.resolveType(node.item.type, false);
+    var itemType = method.resolveType(node.item.type, false, true);
     var list = node.list.visit(this);
     _visitLoop(node, () {
       _visitForInBody(node, itemType, list);
     });
     return false;
   }
 
   void _visitForInBody(ForInStatement node, Type itemType, Value list) {
     // TODO(jimhug): Check that itemType matches list members...
     bool isFinal = _isFinal(node.item.type);
     var itemName = node.item.name.name;
     var item = _scope.create(itemName, itemType, node.item.name.span, isFinal);
     if (list.needsTemp) {
       var listVar = _scope.create('\$list', list.type, null);
       writer.writeln('var ${listVar.code} = ${list.code};');
       list = listVar;
     }
 
-    // Special path for list for readability and perf optimization.
-    if (list.type.isList) {
+    // Special path for concrete Arrays for readability and perf optimization.
+    if (list.type.genericType == world.listFactoryType) {
       var tmpi = _scope.create('\$i', world.numType, null);
       var listLength = list.get_(this, 'length', node.list);
       writer.enterBlock('for (var ${tmpi.code} = 0;' +
           '${tmpi.code} < ${listLength.code}; ${tmpi.code}++) {');
       var value = list.invoke(this, ':index', node.list,
           new Arguments(null, [tmpi]));
       writer.writeln('var ${item.code} = ${value.code};');
     } else {
       var iterator = list.invoke(this, 'iterator', node.list, Arguments.EMPTY);
       var tmpi = _scope.create('\$i', iterator.type, null);
@@ skipping 24 matching lines @@
     writer.enterBlock('try {');
     _pushBlock(node.body);
     visitStatementsInBlock(node.body);
     _popBlock(node.body);
 
     if (node.catches.length == 1) {
       // Handle a single catch. We can generate simple code here compared to the
       // multiple catch, such as no extra temp or if-else-if chain.
       var catch_ = node.catches[0];
       _pushBlock(catch_);
-      var exType = method.resolveType(catch_.exception.type, false);
+      var exType = method.resolveType(catch_.exception.type, false, true);
       var ex = _scope.declare(catch_.exception);
       _scope.rethrow = ex.code;
       writer.nextBlock('} catch (${ex.code}) {');
       if (catch_.trace != null) {
         var trace = _scope.declare(catch_.trace);
         _genStackTraceOf(trace, ex);
       }
       _genToDartException(ex);
 
       if (!exType.isVarOrObject) {
@@ skipping 16 matching lines @@
       }
       _genToDartException(ex);
 
       // We need a rethrow unless we encounter a "var" or "Object" catch
       bool needsRethrow = true;
 
       for (int i = 0; i < node.catches.length; i++) {
         var catch_ = node.catches[i];
 
         _pushBlock(catch_);
-        var tmpType = method.resolveType(catch_.exception.type, false);
+        var tmpType = method.resolveType(catch_.exception.type, false, true);
         var tmp = _scope.declare(catch_.exception);
         if (!tmpType.isVarOrObject) {
           var test = ex.instanceOf(this, tmpType, catch_.exception.span,
               isTrue:true, forceCheck:true);
           if (i == 0) {
             writer.enterBlock('if (${test.code}) {');
           } else {
             writer.nextBlock('} else if (${test.code}) {');
           }
         } else if (i > 0) {
@@ skipping 184 matching lines @@
       return new ThisValue(method.declaringType, 'this',
           node != null ? node.span : null);
     }
   }
 
   // ******************* Expressions *******************
   visitLambdaExpression(LambdaExpression node) {
     var name = (node.func.name != null) ? node.func.name.name : '';
 
     MethodMember meth = _makeLambdaMethod(name, node.func);
-    final lambdaGen = new MethodGenerator(meth, this);
-    if (name != '') {
-      // Note: we don't want to put this in our enclosing scope because the
-      // name shouldn't be visible except inside the lambda. We also don't want
-      // to put the name directly in the lambda's scope because parameters are
-      // allowed to shadow it. So we create an extra scope for it to go into.
-      lambdaGen._scope.create(name, meth.functionType, meth.definition.span,
-          isFinal:true);
-      lambdaGen._pushBlock(node);
-    }
-    lambdaGen.run();
-
-    var w = new CodeWriter();
-    meth.generator.writeDefinition(w, node);
-    return new Value(meth.functionType, w.text, node.span);
+    return meth.methodData.createLambda(node, this);
   }
 
   visitCallExpression(CallExpression node) {
     var target;
     var position = node.target;
     var name = ':call';
     if (node.target is DotExpression) {
       DotExpression dot = node.target;
       target = dot.self.visit(this);
       name = dot.name.name;
@@ skipping 145 matching lines @@
 
     return target.set_(this, xn.name.name, xn.name, y, kind: kind,
       returnKind: returnKind);
   }
 
   visitUnaryExpression(UnaryExpression node) {
     var value = visitValue(node.self);
     switch (node.op.kind) {
       case TokenKind.INCR:
       case TokenKind.DECR:
-        // TODO(jimhug): Requires non-null num to be correct.
-        if (value.type.isNum) {
+        // TODO(jimhug): Hackish optimization not always correct
+        if (value.type.isNum && !value.isFinal && node.self is VarExpression) {
           return new Value(value.type, '${node.op}${value.code}', node.span);
         } else {
           // ++x becomes x += 1
           // --x becomes x -= 1
-          // TODO(jimhug): Confirm that --x becomes x -= 1 as it is in VM.
           var kind = (TokenKind.INCR == node.op.kind ?
               TokenKind.ADD : TokenKind.SUB);
           // TODO(jimhug): Shouldn't need a full-expression here.
           var operand = new LiteralExpression(Value.fromInt(1, node.span),
             node.span);
 
           var assignValue = _visitAssign(kind, node.self, operand, node,
               ReturnKind.POST);
           return new Value(assignValue.type, '(${assignValue.code})',
               node.span);
         }
     }
     return value.unop(node.op.kind, this, node);
   }
 
   visitDeclaredIdentifier(DeclaredIdentifier node) {
     world.error('Expected expression', node.span);
   }
 
   visitAwaitExpression(AwaitExpression node) {
     world.internalError(
         'Await expressions should have been eliminated before code generation',
         node.span);
   }
 
   visitPostfixExpression(PostfixExpression node, [bool isVoid = false]) {
+    // TODO(jimhug): Hackish optimization here to revisit in many ways...
     var value = visitValue(node.body);
-    // TODO(jimhug): Move and validate this code with nullable ints.
-    if (value.type.isNum && !value.isFinal) {
+    if (value.type.isNum && !value.isFinal && node.body is VarExpression) {
+      // Would like to also do on "pure" fields - check to see if possible...
       return new Value(value.type, '${value.code}${node.op}', node.span);
     }
 
     // x++ is equivalent to (t = x, x = t + 1, t), where we capture all temps
     // needed to evaluate x so we're not evaluating multiple times. Likewise,
     // x-- is equivalent to (t = x, x = t - 1, t).
     var kind = (TokenKind.INCR == node.op.kind) ?
       TokenKind.ADD : TokenKind.SUB;
     // TODO(jimhug): Shouldn't need a full-expression here.
     var operand = new LiteralExpression(Value.fromInt(1, node.span),
       node.span);
     var ret = _visitAssign(kind, node.body, operand, node,
       isVoid ? ReturnKind.IGNORE : ReturnKind.PRE);
     return ret;
   }
 
   visitNewExpression(NewExpression node) {
     var typeRef = node.type;
 
     var constructorName = '';
     if (node.name != null) {
       constructorName = node.name.name;
     }
 
     // Named constructors and library prefixes, oh my!
     // At last, we can collapse the ambiguous wave function...
-    if (constructorName == '' && typeRef is !GenericTypeReference &&
+    if (constructorName == '' && typeRef is NameTypeReference &&
         typeRef.names != null) {
 
       // Pull off the last name from the type, guess it's the constructor name.
       var names = new List.from(typeRef.names);
       constructorName = names.removeLast().name;
       if (names.length == 0) names = null;
 
       typeRef = new NameTypeReference(
           typeRef.isFinal, typeRef.name, names, typeRef.span);
     }
 
-    var type = method.resolveType(typeRef, true);
+    var type = method.resolveType(typeRef, true, true);
     if (type.isTop) {
       type = type.library.findTypeByName(constructorName);
       constructorName = '';
     }
 
     if (type is ParameterType) {
       world.error('cannot instantiate a type parameter', node.span);
       return _makeMissingValue(constructorName);
     }
 
@@ skipping 24 matching lines @@
     // interface, not the class.
     var target = new TypeValue(type, typeRef.span);
     return m.invoke(this, node, target, _makeArgs(node.arguments));
   }
 
   visitListExpression(ListExpression node) {
     var argValues = [];
     var listType = world.listType;
     var type = world.varType;
     if (node.itemType != null) {
-      type = method.resolveType(node.itemType, true);
+      type = method.resolveType(node.itemType, true, !node.isConst);
       if (node.isConst && (type is ParameterType || type.hasTypeParams)) {
         world.error('type parameter cannot be used in const list literals');
       }
       listType = listType.getOrMakeConcreteType([type]);
     }
     for (var item in node.values) {
       var arg = visitTypedValue(item, type);
       argValues.add(arg);
       if (node.isConst && !arg.isConst) {
         world.error('const list can only contain const values', arg.span);
@@ skipping 13 matching lines @@
     if (node.items.length == 0 && !node.isConst) {
       return world.mapType.getConstructor('').invoke(this, node,
         new TypeValue(world.mapType, node.span), Arguments.EMPTY);
     }
 
     var values = <Value>[];
     var valueType = world.varType, keyType = world.stringType;
     var mapType = world.mapType; // TODO(jimhug): immutable type?
     if (node.valueType !== null) {
       if (node.keyType !== null) {
-        keyType = method.resolveType(node.keyType, true);
+        keyType = method.resolveType(node.keyType, true, !node.isConst);
         // TODO(jimhug): Would be nice to allow arbitrary keys here (this is
         // currently not allowed by the spec).
         if (!keyType.isString) {
           world.error('the key type of a map literal must be "String"',
               keyType.span);
         }
         if (node.isConst &&
             (keyType is ParameterType || keyType.hasTypeParams)) {
           world.error('type parameter cannot be used in const map literals');
         }
       }
 
-      valueType = method.resolveType(node.valueType, true);
+      valueType = method.resolveType(node.valueType, true, !node.isConst);
       if (node.isConst &&
           (valueType is ParameterType || valueType.hasTypeParams)) {
         world.error('type parameter cannot be used in const map literals');
       }
 
       mapType = mapType.getOrMakeConcreteType([keyType, valueType]);
     }
 
     for (int i = 0; i < node.items.length; i += 2) {
       var key = visitTypedValue(node.items[i], keyType);
@@ skipping 20 matching lines @@
     var falseBranch = visitValue(node.falseBranch);
 
     // TODO(jmesserly): is there a way to use Value.union here, even though
     // we need different code?
     return new Value(Type.union(trueBranch.type, falseBranch.type),
         '${test.code} ? ${trueBranch.code} : ${falseBranch.code}', node.span);
   }
 
   visitIsExpression(IsExpression node) {
     var value = visitValue(node.x);
-    var type = method.resolveType(node.type, false);
+    var type = method.resolveType(node.type, true, true);
+    if (type.isVar) {
+      return Value.comma(value, Value.fromBool(true, node.span));
+    }
+
     return value.instanceOf(this, type, node.span, node.isTrue);
   }
 
   visitParenExpression(ParenExpression node) {
     var body = visitValue(node.body);
     // Assumption implicit here that const values never need parens...
     if (body.isConst) return body;
     return new Value(body.type, '(${body.code})', node.span);
   }
 
@@ skipping 177 matching lines @@
     for (int i = 0; i < bareCount; i++) {
       result.add(new VariableValue(world.varType, '\$$i', null));
     }
     for (int i = bareCount; i < length; i++) {
       var name = getName(i);
       if (name == null) name = '\$$i';
       result.add(new VariableValue(world.varType, name, null));
     }
     return new Arguments(nodes, result);
   }
+
+  bool matches(Arguments other) {
+    if (length != other.length) return false;
+    if (bareCount != other.bareCount) return false;
+
+    for (int i = 0; i < bareCount; i++) {
+      if (values[i].type != other.values[i].type) return false;
+    }
+    // TODO(jimhug): Needs to check that named args also match!
+    return true;
+  }
+
 }
 
 class ReturnKind {
   static final int IGNORE = 1;
   static final int POST = 2;
   static final int PRE = 3;
 }