Support for native in leg, and start moving native tests to a specific test suite.

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:].
  */
 class CodeEmitterTask extends CompilerTask {
   static final String INHERIT_FUNCTION = '''
 function(child, parent) {
   if (child.prototype.__proto__) {
     child.prototype.__proto__ = parent.prototype;
   } else {
     function tmp() {};
     tmp.prototype = parent.prototype;
     child.prototype = new tmp();
     child.prototype.constructor = child;
   }
 }''';
 
+  /**
+   * Code for finding the type name of a JavaScript object.
+   */
+  static final String TYPE_NAME_OF_FUNCTION = '''
+function(obj) {
+  var constructor = obj.constructor;
+  if (typeof(constructor) == 'function') {
+    // The constructor isn't null or undefined at this point. Try
+    // to grab hold of its name.
+    var name = constructor.name;
+    // If the name is a non-empty string, we use that as the type
+    // name of this object. On Firefox, we often get 'Object' as
+    // the constructor name even for more specialized objects so
+    // we have to fall through to the toString() based implementation
+    // below in that case.
+    if (name && typeof(name) == 'string' && name != 'Object') return name;
+  }
+  var string = Object.prototype.toString.call(obj);
+  var name = string.substring(8, string.length - 1);
+  if (name == 'Window') {
+    name = 'DOMWindow';
+  } else if (name == 'Document') {
+    name = 'HTMLDocument';
+  }
+  return name;
+}
+''';
+
+  /**
+   * Code for defining a property in a JavaScript object that will not
+   * be visible through for-in (aka enumerable is false).
+   */
+  static final String DEF_PROP_FUNCTION = '''
+function(obj, prop, value) {
+  Object.defineProperty(obj, prop,
+      {value: value, enumerable: false, writable: true, configurable: true});
+}''';
+
+  /**
+   * Code for doing the dynamic dispatch on JavaScript prototypes that are not
+   * available at compile-time. Each property of a native Dart class
+   * is registered through this function, which is called with the
+   * following pattern:
+   *
+   * $dynamic('propertyName').prototypeName = // JS code
+   *
+   * What this function does is:
+   * - Creates a map of { prototypeName: JS code }.
+   * - Attaches 'propertyName' to the JS Object prototype that will
+   *   intercept at runtime all calls to propertyName.
+   * - Sets the value of 'propertyName' to a function that queries the
+   *   map with the prototype of 'this', patches the prototype of
+   *   'this' with the found JS code, and invokes the JS code.
+   *
+   */
+  String buildDynamicFunctionCode() => '''
+function(name) {
+  var f = Object.prototype[name];
+  if (f && f.methods) return f.methods;
+
+  var methods = {};
+  if (f) methods.Object = f;
+  function dynamicBind() {
+    // Find the target method
+    var obj = this;
+    var tag = $typeNameOfName(obj);
+    var method = methods[tag];
+    if (!method) {
+      var table = $dynamicMetadataName;
+      for (var i = 0; i < table.length; i++) {
+        var entry = table[i];
+        if (entry.map.hasOwnProperty(tag)) {
+          method = methods[entry.tag];
+          if (method) break;
+        }
+      }
+    }
+    method = method || methods.Object;
+    var proto = Object.getPrototypeOf(obj);
+    if (!proto.hasOwnProperty(name)) {
+      $defPropName(proto, name, method);
+    }
+
+    return method.apply(this, Array.prototype.slice.call(arguments));
+  };
+  dynamicBind.methods = methods;
+  $defPropName(Object.prototype, name, dynamicBind);
+  return methods;
+}
+''';
+
+  String buildDynamicMetadataCode() => '''
+if (typeof $dynamicMetadataName == 'undefined') $dynamicMetadataName = [];
+''';
+
   bool addedInheritFunction = false;
+  bool addedDynamicFunction = false;
   final Namer namer;
 
   CodeEmitterTask(Compiler compiler) : namer = compiler.namer, super(compiler);
   String get name() => 'CodeEmitter';
 
   String get inheritsName() => '${compiler.namer.ISOLATE}.\$inherits';
+  String get dynamicName() => '${compiler.namer.ISOLATE}.\$dynamic';
+  String get defPropName() => '${compiler.namer.ISOLATE}.\$defProp';
+  String get typeNameOfName() => '${compiler.namer.ISOLATE}.\$typeNameOf';
+  String get dynamicMetadataName() =>
+      '${compiler.namer.ISOLATE}.\$dynamicMetatada';
 
   void addInheritFunctionIfNecessary(StringBuffer buffer) {
     if (addedInheritFunction) return;
     addedInheritFunction = true;
     buffer.add('$inheritsName = ');
     buffer.add(INHERIT_FUNCTION);
     buffer.add(';\n');
   }
 
+  void addDynamicFunctionIfNecessary(StringBuffer buffer) {
+    if (addedDynamicFunction) return;
+    addedDynamicFunction = true;
+    buffer.add('$defPropName = ');
+    buffer.add(DEF_PROP_FUNCTION);
+    buffer.add('\n');
+    buffer.add('$typeNameOfName = ');
+    buffer.add(TYPE_NAME_OF_FUNCTION);
+    buffer.add('\n');
+    buffer.add('$dynamicName = ');
+    buffer.add(buildDynamicFunctionCode());
+    buffer.add('\n');
+    buffer.add(buildDynamicMetadataCode());
+    buffer.add('\n');
+  }
+
   void addParameterStub(FunctionElement member,
-                        String prototype,
+                        String attachTo(String invocationName),
                         StringBuffer buffer,
                         Selector selector) {
     FunctionParameters parameters = member.computeParameters(compiler);
     int positionalArgumentCount = selector.positionalArgumentCount;
     if (positionalArgumentCount == parameters.parameterCount) {
       assert(selector.namedArgumentCount == 0);
       return;
     }
     CompileTimeConstantHandler constants = compiler.compileTimeConstantHandler;
     List<SourceString> names = selector.getOrderedNamedArguments();
 
     String invocationName =
         namer.instanceMethodInvocationName(member.name, selector);
-    buffer.add('$prototype.$invocationName = function(');
+    buffer.add('${attachTo(invocationName)} = function(');
 
     // The parameters that this stub takes.
     List<String> parametersBuffer = new List<String>(selector.argumentCount);
     // The arguments that will be passed to the real method.
     List<String> argumentsBuffer = new List<String>(parameters.parameterCount);
 
     // We fill the lists depending on the selector. For example,
     // take method foo:
     //    foo(a, b, [c, d]);
     //
@@ skipping 48 matching lines @@
       }
       count++;
     });
 
     buffer.add('${Strings.join(parametersBuffer, ",")}) {\n');
     buffer.add('  return this.${namer.getName(member)}');
     buffer.add('(${Strings.join(argumentsBuffer, ",")})\n}\n');
   }
 
   void addParameterStubs(FunctionElement member,
-                         String prototype,
+                         String attachTo(String invocationName),
                          StringBuffer buffer) {
     Set<Selector> selectors = compiler.universe.invokedNames[member.name];
     if (selectors == null) return;
     for (Selector selector in selectors) {
       if (!selector.applies(compiler, member)) continue;
-      addParameterStub(member, prototype, buffer, selector);
+      addParameterStub(member, attachTo, buffer, selector);
     }
   }
 
   void addInstanceMember(Element member,
                          String prototype,
                          StringBuffer buffer) {
     assert(member.isInstanceMember());
     if (member.kind === ElementKind.FUNCTION
         || member.kind === ElementKind.GENERATIVE_CONSTRUCTOR_BODY
         || member.kind === ElementKind.GETTER
         || member.kind === ElementKind.SETTER) {
       String codeBlock = compiler.universe.generatedCode[member];
-      if (codeBlock !== null) {
-        buffer.add('$prototype.${namer.getName(member)} = $codeBlock;\n');
-      }
+      if (codeBlock == null) return;
+      buffer.add('$prototype.${namer.getName(member)} = $codeBlock;\n');
       codeBlock = compiler.universe.generatedBailoutCode[member];
       if (codeBlock !== null) {
         String name = namer.getBailoutName(member);
         buffer.add('$prototype.$name = $codeBlock;\n');
       }
       FunctionElement function = member;
       if (!function.computeParameters(compiler).optionalParameters.isEmpty()) {
-        addParameterStubs(member, prototype, buffer);
+        addParameterStubs(member, (name) => '$prototype.$name', buffer);
       }
     } else if (member.kind === ElementKind.FIELD) {
       // TODO(ngeoffray): Have another class generate the code for the
       // fields.
       if (compiler.universe.invokedSetters.contains(member.name)) {
         String setterName = namer.setterName(member.name);
         buffer.add('$prototype.$setterName = function(v){\n' +
           '  this.${namer.getName(member)} = v;\n};\n');
       }
       if (compiler.universe.invokedGetters.contains(member.name)) {
@@ skipping 15 matching lines @@
       // TODO(floitsch): make sure there are no name clashes.
       String className = namer.getName(classElement);
 
       void generateFieldInit(Element member) {
         if (member.isInstanceMember() && member.kind == ElementKind.FIELD) {
           if (!isFirst) argumentsBuffer.add(', ');
           isFirst = false;
           String memberName = namer.instanceFieldName(member.name);
           argumentsBuffer.add('${className}_$memberName');
           bodyBuffer.add('  this.$memberName = ${className}_$memberName;\n');
-        }        
+        }
       }
 
       for (Element element in classElement.members) {
         generateFieldInit(element);
       }
       for (Element element in classElement.backendMembers) {
         generateFieldInit(element);
       }
 
       classElement = classElement.superclass;
     } while(classElement !== null);
   }
 
+  void generateNativeClass(ClassElement classElement, StringBuffer buffer) {
+    addDynamicFunctionIfNecessary(buffer);
+    assert(classElement.backendMembers.isEmpty());
+    String nativeName = classElement.nativeName.stringValue;
+    nativeName = nativeName.substring(2, nativeName.length - 1);
+    for (Element member in classElement.members) {
+      if (member.isInstanceMember()) {
+        String memberName = namer.getName(member);
+        if (member.kind === ElementKind.FUNCTION
+            || member.kind === ElementKind.GENERATIVE_CONSTRUCTOR_BODY
+            || member.kind === ElementKind.GETTER
+            || member.kind === ElementKind.SETTER) {
+          String codeBlock = compiler.universe.generatedCode[member];
+          if (codeBlock == null) continue;
+          buffer.add(
+              "$dynamicName('$memberName').$nativeName = $codeBlock;\n");
+          codeBlock = compiler.universe.generatedBailoutCode[member];
+          if (codeBlock !== null) {
+            String name = namer.getBailoutName(member);
+            buffer.add("$dynamicName('$name').$nativeName = $codeBlock;\n");
+          }
+          FunctionElement function = member;
+          FunctionParameters parameters = function.computeParameters(compiler);
+          if (!parameters.optionalParameters.isEmpty()) {
+            addParameterStubs(
+                member, (name) => "$dynamicName('$name').$nativeName", buffer);
+          }
+        } else if (member.kind === ElementKind.FIELD) {
+          if (compiler.universe.invokedSetters.contains(member.name)) {
+            String setterName = namer.setterName(member.name);
+            buffer.add(
+              "$dynamicName('$setterName').$nativeName = function(v){\n" +
+              '  this.${member.name} = v;\n};\n');
+          }
+          if (compiler.universe.invokedGetters.contains(member.name)) {
+            String getterName = namer.getterName(member.name);
+            buffer.add(
+              "$dynamicName('$getterName').$nativeName = function(){\n" +
+              '  return this.${member.name};\n};\n');
+          }
+        } else {
+          compiler.internalError('unexpected kind: "${member.kind}"',
+                                 element: member);
+        }
+      }
+    }
+  }
+
   void generateClass(ClassElement classElement,
                      StringBuffer buffer,
                      Set<ClassElement> seenClasses) {
     if (seenClasses.contains(classElement)) return;
     seenClasses.add(classElement);
     ClassElement superclass = classElement.superclass;
     if (superclass !== null) {
       generateClass(classElement.superclass, buffer, seenClasses);
     }
 
+    if (classElement.isNative()) {
+      generateNativeClass(classElement, buffer);
+      return;
+    }
+
     String className = namer.isolatePropertyAccess(classElement);
     buffer.add('$className = function ${classElement.name}(');
     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);
@@ skipping 71 matching lines @@
       // of static functions) and will not have any enclosingElement.
       FunctionElement callElement =
           new FunctionElement.from(Namer.CLOSURE_INVOCATION_NAME,
                                    element,
                                    null);
       String staticName = namer.isolatePropertyAccess(element);
       int parameterCount = element.parameterCount(compiler);
       String invocationName =
           namer.instanceMethodName(callElement.name, parameterCount);
       buffer.add("$staticName.$invocationName = $staticName;\n");
-      addParameterStubs(callElement, staticName, buffer);
+      addParameterStubs(callElement, (name) => '$staticName.$name', buffer);
     }
   }
 
   void emitDynamicFunctionGetter(StringBuffer buffer,
                                  ClassElement enclosingClass,
                                  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):
@@ skipping 32 matching lines @@
         namer.instanceMethodName(callElement.name, parameterCount);
     String targetName = namer.instanceMethodName(member.name, parameterCount);
     List<String> arguments = new List<String>(parameterCount);
     for (int i = 0; i < parameterCount; i++) {
       arguments[i] = "arg$i";
     }
     String joinedArgs = Strings.join(arguments, ", ");
     buffer.add("$prototype.$invocationName = function($joinedArgs) {\n");
     buffer.add("  return this.self.$targetName($joinedArgs);\n");
     buffer.add("};\n");
-    addParameterStubs(callElement, prototype, buffer);
+    addParameterStubs(callElement, (name) => '$prototype.$name', buffer);
 
     // And finally the getter.
     String enclosingClassAccess = namer.isolatePropertyAccess(enclosingClass);
     String enclosingClassPrototype = "$enclosingClassAccess.prototype";
     String getterName = namer.getterName(member.name);
     String closureClass = namer.isolateAccess(closureClassElement);
     buffer.add("$enclosingClassPrototype.$getterName = function() {\n");
     buffer.add("  return new $closureClass(this);\n");
     buffer.add("};\n");
   }
@@ skipping 163 matching lines @@
       emitCallStubForGetters(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;
   }
 }