Fix bug 578

frog/gen.dart

 // Copyright (c) 2011, 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.
  *
@@ skipping 185 matching lines @@
     // 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.isNativeType && !type.isTop) {
+    if (type.isNative && !type.isTop) {
       var nativeName = type.definition.nativeType.name;
       if (nativeName == '') {
         writer.writeln('function ${type.jsname}() {}');
       } else if (type.jsname != nativeName) {
         writer.writeln('${type.jsname} = ${nativeName};');
       }
     }
 
     if (type.isTop) {
       // no preludes for top type
     } else if (type.constructors.length == 0) {
-      if (!type.isNativeType) {
+      if (!type.isNative) {
         // 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.isNativeType) {
+        if (!type.isNative) {
           writer.writeln('function ${type.jsname}() {}');
         }
       } 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 (!type.isTop) {
       if (type is ConcreteType) {
         ConcreteType c = type;
         _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.isNativeType) {
+      } else if (!type.isNative) {
         if (type.parent != null && !type.parent.isObject) {
           _ensureInheritsHelper();
           writer.writeln('\$inherits(${type.jsname}, ${type.parent.jsname});');
         }
       }
     }
 
     // Concrete types (like List<String>) will have this already defined on
     // their prototype from the generic type (like List)
     if (type is! ConcreteType) {
@@ skipping 852 matching lines @@
     _scope = new BlockScope(this, _scope, reentrant);
   }
 
   _popBlock() {
     _scope = _scope.parent;
   }
 
   MethodMember _makeLambdaMethod(String name, FunctionDefinition func) {
     var meth = new MethodMember(name, method.declaringType, func);
     meth.isLambda = true;
-    meth.resolve(method.declaringType);
+    meth.enclosingElement = method;
+    meth.resolve();
     world.gen.genMethod(meth, this);
     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 1258 matching lines @@
       result.add(new Value(world.varType, '\$$i', null, /*needsTemp:*/false));
     }
     for (int i = bareCount; i < length; i++) {
       var name = getName(i);
       if (name == null) name = '\$$i';
       result.add(new Value(world.varType, name, null, /*needsTemp:*/false));
     }
     return new Arguments(nodes, result);
   }
 }