Implement operator-is for interfaces' supertypes and String's supertypes. Also, improve stack trace…

dart/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.
 
 /**
  * Generates the code for all used classes in the program. Static fields (even
  * in classes) are ignored, since they can be treated as non-class elements.
  *
  * The code for the containing (used) methods must exist in the [:universe:].
  */
@@ skipping 116 matching lines @@
       count++;
     });
     buffer.add('${Strings.join(parametersBuffer, ",")}) {\n');
     String arguments = Strings.join(argumentsBuffer, ",");
 
     if (isNative) {
       nativeEmitter.emitParameterStub(
           member, invocationName, arguments, buffer);
     } else {
       buffer.add('  return this.${namer.getName(member)}($arguments)');
-    }
+  }
     buffer.add('\n}\n');
   }
 
   void addParameterStubs(FunctionElement member,
                          String attachTo(String invocationName),
                          StringBuffer buffer,
                          [bool isNative = false]) {
     Set<Selector> selectors = compiler.universe.invokedNames[member.name];
     if (selectors == null) return;
     for (Selector selector in selectors) {
@@ skipping 107 matching lines @@
       if (member.isInstanceMember()) {
         addInstanceMember(member, prototype, buffer);
       }
     }
     for (Element member in classElement.backendMembers) {
       if (member.isInstanceMember()) {
         addInstanceMember(member, prototype, buffer);
       }
     }
     buffer.add('$prototype.${namer.operatorIs(classElement)} = true;\n');
-    for (Type ifc in classElement.interfaces) {
-      buffer.add('$prototype.${namer.operatorIs(ifc.element)} = true;\n');
+    generateInterfacesIsTests(buffer, prototype, classElement);
+    if (superclass === null) {
+      // JS "toString" wrapper. This gives better exceptions. The
+      // function must handle the situation where builtin$toString$0
+      // is not generated.
+      buffer.add('''
+$prototype.toString = function() {
+  try {
+    if (typeof ${namer.CURRENT_ISOLATE}.builtin\$toString\$0\$1 == 'function') {
+      return ${namer.CURRENT_ISOLATE}.builtin\$toString\$0\$1(this);
+    } else {
+      var name = this.constructor.name;
+      if (typeof name != 'string') {
+        name = this.constructor.toString();
+        name = name.match(/^\s*function\s*(\S*)\s*\(/)[1];
+      }
+      return "Instance of '" + name +"'";
     }
-    if (superclass === null) {
-      // JS "toString" wrapper. This gives better exceptions.
-      buffer.add('$prototype.toString = function() {\n');
-      buffer.add('  try {');
-      buffer.add('    return ${namer.CURRENT_ISOLATE}');
-      buffer.add('.builtin\$toString\$0\$1(this);');
-      buffer.add('  } catch (ex) {');
-      buffer.add('     return "uncaught exception in toString";');
-      buffer.add('  }');
-      buffer.add('};\n');
+  } catch (ex) {
+     return "uncaught exception in toString";
+  }
+};
+''');
 
       // 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 generateInterfacesIsTests(StringBuffer buffer, String prototype,
+                                 ClassElement cls) {
+    for (Type ifc in cls.interfaces) {
+      buffer.add('$prototype.${namer.operatorIs(ifc.element)} = true;\n');
+      generateInterfacesIsTests(buffer, prototype, ifc.element);
+    }
+  }
+
   void emitClasses(StringBuffer buffer) {
     Set seenClasses = new Set<ClassElement>();
     for (ClassElement element in compiler.universe.instantiatedClasses) {
       generateClass(element, buffer, seenClasses);
     }
   }
 
   void emitStaticFunctionsWithNamer(StringBuffer buffer,
                                     Map<Element, String> generatedCode,
                                     String functionNamer(Element element)) {
@@ skipping 169 matching lines @@
           if (!member.isInstanceMember()) continue;
           if (member.kind == ElementKind.GETTER ||
               member.kind == ElementKind.FIELD) {
             Set<Selector> selectors =
                 compiler.universe.invokedNames[member.name];
             if (selectors == null || selectors.isEmpty()) continue;
             emitCallStubForGetter(buffer, currentClass, member, selectors);
           }
         }
       }
-    }
+    }    
   }
 
   void emitStaticNonFinalFieldInitializations(StringBuffer buffer) {
     // Adds initializations inside the Isolate constructor.
     // Example:
     //    function Isolate() {
     //       this.staticNonFinal = Isolate.prototype.someVal;
     //       ...
     //    }
     CompileTimeConstantHandler handler = compiler.compileTimeConstantHandler;
@@ skipping 104 matching lines @@
       emitCompileTimeConstants(buffer);
       emitStaticFinalFieldInitializations(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;
   }
 }