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;
   }
 }''';
 
+  static final String TYPE_NAME_OF_FUNCTION = '''
+function(obj) {

[ahe, 2012/02/19 14:38:02]

Could you add a documentation comment for this function?

[ngeoffray, 2012/02/20 09:09:37]

Sure. For the reference, this code is a pure copy and paste of frog's code.

+  var constructor = obj.constructor;

[ahe, 2012/02/19 14:38:02]

What happens if obj is undefined?

[ngeoffray, 2012/02/20 09:09:37]

boom? :)

[floitsch, 2012/02/21 13:11:15]

Note that this function is called on the prototype of Object and 'obj' is set to
'this' there.
So null is not possible.

+  if (typeof(constructor) == 'function') {

[floitsch, 2012/02/19 00:59:43]

typeof is not a function:
if (typeof constructor == 'function')

[ngeoffray, 2012/02/20 09:09:37]

Copy/pasted code.

+    // 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;

[floitsch, 2012/02/19 00:59:43]

exchange typeof and name-check.
It probably does not matter, but it feels righter to me :)

(background: typeof check is cheap, and the boolification of the string should
be cheaper then).

[ngeoffray, 2012/02/20 09:09:37]

Copy-pasted code.

+  }
+  var string = Object.prototype.toString.call(obj);
+  var name = string.substring(8, string.length - 1);

[ahe, 2012/02/19 14:38:02]

I'm getting a feeling that this is very similar to Primitives.objectToString in
js_helper. We should consolidate eventually.

[ngeoffray, 2012/02/20 09:09:37]

Not on this code, which is copy-pasted.

+  if (name == 'Window') {
+    name = 'DOMWindow';
+  } else if (name == 'Document') {
+    name = 'HTMLDocument';
+  }
+  return name;
+}
+''';
+
+  static final String DEF_PROP_FUNCTION = '''
+function(obj, prop, value) {
+  Object.defineProperty(obj, prop,
+      {value: value, enumerable: false, writable: true, configurable: true});
+}''';
+
+  String get DYNAMIC_FUNCTION() => '''

[floitsch, 2012/02/19 00:59:43]

this needs comments.

[ahe, 2012/02/19 14:38:02]

Documentation comment, please.

[ngeoffray, 2012/02/20 09:09:37]

As for TYPE_NAME_OF_FUNCTION, this method was taken from frog.

[ahe, 2012/02/20 09:36:10]

Whatever information you have about these functions, please document it. Perhaps
you can ask Stephen for more information.

You must have at least some idea about what is going on here.

+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;
+}
+if (typeof $dynamicMetadataName == 'undefined') $dynamicMetadataName = [];

[ahe, 2012/02/19 14:38:02]

Extra code after function. Shouldn't this be in the isolate?

[ngeoffray, 2012/02/20 09:09:37]

Code also comes from frog.

[ahe, 2012/02/20 09:36:10]

You chose the word "DYNAMIC_FUNCTION". Clearly this is not just a function.

+''';
+
   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';

[ahe, 2012/02/19 14:38:02]

Why aren't these strings final values? Generating them repeatedly seems
wasteful. I guess the idea is that they are only called once, however, the
pattern is confusing.

[ngeoffray, 2012/02/20 09:09:37]

They cannot be final because compiler.namer.ISOLATE is not final.

+  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';

[ahe, 2012/02/19 14:38:02]

How is this related to line 89?

[ngeoffray, 2012/02/20 09:09:37]

Not sure I understand.

[ahe, 2012/02/20 09:36:10]

I overlooked that the code on 89 wasn't in a raw string.

I think this coding style is confusing, and it would be clearer if
DYNAMIC_FUNCTION didn't pretend to be a constant and instead was a real method
with parameters.

 
   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(DYNAMIC_FUNCTION);
+    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(');

[ahe, 2012/02/19 14:38:02]

How about turning this into a streaming API, that is, something like this:

attachNameOn(buffer, invocationName);

 
     // 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');
       }
       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.substring(
+        2, classElement.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) {
+            buffer.add(
+                "$dynamicName('$memberName').$nativeName = $codeBlock;\n");
+          }
+          codeBlock = compiler.universe.generatedBailoutCode[member];
+          if (codeBlock !== null) {

[floitsch, 2012/02/19 00:59:43]

Maybe we should consider making our bailout function static.

+            String name = namer.getBailoutName(member);
+            buffer.add("$dynamicName('$name').$nativeName = $codeBlock;\n");
+          }
+          FunctionElement function = member;
+          FunctionParameters parameters = function.computeParameters(compiler);
+          if (!parameters.optionalParameters.isEmpty()) {

[ahe, 2012/02/19 14:38:02]

Is this necessary if there is no code generated?

[ngeoffray, 2012/02/20 09:09:37]

Very good catch. Will remove it.

+            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()) {
+      return generateNativeClass(classElement, buffer);

[floitsch, 2012/02/19 00:59:43]

don't use 'return val' to leave a void function.

+    }
     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 60 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;
   }
 }