Support for "a is Function".

frog/leg/emitter.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.
 
 /**
  * A function element that represents a closure call. The signature is copied
  * from the given element.
  */
 class ClosureInvocationElement extends FunctionElement {
   ClosureInvocationElement(SourceString name,
@@ skipping 18 matching lines @@
     function tmp() {};
     tmp.prototype = parent.prototype;
     child.prototype = new tmp();
     child.prototype.constructor = child;
   }
 }''';
 
   bool addedInheritFunction = false;
   final Namer namer;
   final NativeEmitter nativeEmitter;
+  Set<ClassElement> generatedClasses;
 
   CodeEmitterTask(Compiler compiler)
       : namer = compiler.namer,
         nativeEmitter = new NativeEmitter(compiler),
+        generatedClasses = new Set<ClassElement>(),
         super(compiler);
 
   String get name() => 'CodeEmitter';
 
   String get inheritsName() => '${namer.ISOLATE}.\$inherits';
 
   String get objectClassName() {
     ClassElement objectClass =
         compiler.coreLibrary.find(const SourceString('Object'));
     return namer.isolatePropertyAccess(objectClass);
@@ skipping 194 matching lines @@
         generateFieldInit(element);
       }
       for (Element element in classElement.backendMembers) {
         generateFieldInit(element);
       }
 
       classElement = classElement.superclass;
     } while(classElement !== null);
   }
 
-  void generateClass(ClassElement classElement,
-                     StringBuffer buffer,
-                     Set<ClassElement> seenClasses) {
-    if (seenClasses.contains(classElement)) return;
-    seenClasses.add(classElement);
-    ClassElement superclass = classElement.superclass;
+  void emitInherits(ClassElement cls, StringBuffer buffer) {
+    ClassElement superclass = cls.superclass;
     if (superclass !== null) {
-      generateClass(classElement.superclass, buffer, seenClasses);
+      addInheritFunctionIfNecessary(buffer);
+      String className = namer.isolatePropertyAccess(cls);
+      String superName = namer.isolatePropertyAccess(superclass);
+      buffer.add('${inheritsName}($className, $superName);\n');
     }
+  }
+
+  void ensureGenerated(ClassElement classElement, StringBuffer buffer) {
+    if (classElement == null) return;
+    if (generatedClasses.contains(classElement)) return;
+    generatedClasses.add(classElement);
+    generateClass(classElement, buffer);
+  }
+
+  void generateClass(ClassElement classElement, StringBuffer buffer) {
+    ensureGenerated(classElement.superclass, buffer);
 
     if (classElement.isNative()) {
       nativeEmitter.generateNativeClass(classElement, buffer);
       return;
     }
 
     String className = namer.isolatePropertyAccess(classElement);
     buffer.add('$className = function ${classElement.name.slowToString()}(');
     StringBuffer bodyBuffer = new StringBuffer();
     // If the class is never instantiated we still need to set it up for
     // inheritance purposes, but we can leave its JavaScript constructor empty.
     if (compiler.universe.instantiatedClasses.contains(classElement)) {
       generateFieldInits(classElement, buffer, bodyBuffer);
     }
     buffer.add(') {\n');
     buffer.add(bodyBuffer);
     buffer.add('};\n');
-    if (superclass !== null) {
-      addInheritFunctionIfNecessary(buffer);
-      String superName = namer.isolatePropertyAccess(superclass);
-      buffer.add('${inheritsName}($className, $superName);\n');
-    }
+
+    emitInherits(classElement, buffer);
 
     String attachTo(String name) => '$className.prototype.$name';
     for (Element member in classElement.members) {
       if (member.isInstanceMember()) {
         addInstanceMember(member, attachTo, buffer);
       }
     }
     for (Element member in classElement.backendMembers) {
       if (member.isInstanceMember()) {
         addInstanceMember(member, attachTo, buffer);
       }
     }
     generateTypeTests(classElement, (Element other) {
       buffer.add('${attachTo(namer.operatorIs(other))} = true;\n');
     });
 
-    if (superclass === null && compiler.enabledNoSuchMethod) {
+    if (classElement === compiler.objectClass && compiler.enabledNoSuchMethod) {
       // Emit the noSuchMethods on the Object prototype now, so that
       // the code in the dynamicMethod can find them. Note that the
       // code in dynamicMethod is invoked before analyzing the full JS
       // script.
       emitNoSuchMethodCalls(buffer);
     }
   }
 
   void generateTypeTests(ClassElement cls,
                          void generateTypeTest(ClassElement element)) {
     if (compiler.universe.isChecks.contains(cls)) {
       generateTypeTest(cls);
     }
     generateInterfacesIsTests(cls, generateTypeTest);
   }
 
   void generateInterfacesIsTests(ClassElement cls,
                                  void generateTypeTest(ClassElement element)) {
     for (Type interfaceType in cls.interfaces) {
       Element element = interfaceType.element;
       if (compiler.universe.isChecks.contains(element)) {
         generateTypeTest(element);
       }
       generateInterfacesIsTests(element, generateTypeTest);
     }
   }
 
   void emitClasses(StringBuffer buffer) {
-    Set seenClasses = new Set<ClassElement>();
     for (ClassElement element in compiler.universe.instantiatedClasses) {
-      generateClass(element, buffer, seenClasses);
+      ensureGenerated(element, buffer);
     }
   }
 
   void emitStaticFunctionsWithNamer(StringBuffer buffer,
                                     Map<Element, String> generatedCode,
                                     String functionNamer(Element element)) {
     generatedCode.forEach((Element element, String codeBlock) {
       if (!element.isInstanceMember()) {
         buffer.add('${functionNamer(element)} = ');
         buffer.add(codeBlock);
@@ skipping 35 matching lines @@
                                  FunctionElement member) {
     // For every method that has the same name as a property-get we create a
     // getter that returns a bound closure. Say we have a class 'A' with method
     // 'foo' and somewhere in the code there is a dynamic property get of
     // 'foo'. Then we generate the following code (in pseudo Dart):
     //
     // class A {
     //    foo(x, y, z) { ... } // Original function.
     //    get foo() { return new BoundClosure499(this); }
     // }
-    // class BoundClosure499 {
+    // class BoundClosure499 extends Closure {
     //   var self;
     //   BoundClosure499(this.self);
     //   $call3(x, y, z) { return self.foo(x, y, z); }
     // }
 
     // TODO(floitsch): share the closure classes with other classes
     // if they share methods with the same signature.
 
     // The closure class.
     SourceString name = const SourceString("BoundClosure");
-    CompilationUnitElement compilationUnit = member.getCompilationUnit();
-    ClassElement closureClassElement = new ClassElement(name, compilationUnit);
+    ClassElement closureClassElement =
+        new ClosureClassElement(compiler, member.getCompilationUnit());
     String isolateAccess = namer.isolatePropertyAccess(closureClassElement);
+    ensureGenerated(closureClassElement.superclass, buffer);
 
     // Define the constructor with a name so that Object.toString can
     // find the class name of the closure class.
     buffer.add("$isolateAccess = function $name(self) ");
     buffer.add("{ this.self = self; };\n");
-
-    // Make the closure class extend Object.
-    addInheritFunctionIfNecessary(buffer);
-    ClassElement objectClass =
-        compiler.coreLibrary.find(const SourceString('Object'));
-    String superName = namer.isolatePropertyAccess(objectClass);
-    buffer.add('${inheritsName}($isolateAccess, $superName);\n');
+    emitInherits(closureClassElement, buffer);
 
     String prototype = "$isolateAccess.prototype";
 
     // Now add the methods on the closure class. The instance method does not
     // have the correct name. Since [addParameterStubs] use the name to create
     // its stubs we simply create a fake element with the correct name.
     // Note: the callElement will not have any enclosingElement.
     FunctionElement callElement =
         new ClosureInvocationElement(Namer.CLOSURE_INVOCATION_NAME, member);
 
@@ skipping 187 matching lines @@
       emitStaticFinalFieldInitializations(buffer);
       nativeEmitter.emitDynamicDispatchMetadata(buffer);
       buffer.add('var ${namer.CURRENT_ISOLATE} = new ${namer.ISOLATE}();\n');
       Element main = compiler.mainApp.find(Compiler.MAIN);
       buffer.add('${namer.isolateAccess(main)}();\n');
       compiler.assembledCode = buffer.toString();
     });
     return compiler.assembledCode;
   }
 }