Add the arity to calls, and support noSuchMethodException.

frog/leg/emitter.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.
 
 /**
  * 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 38 matching lines @@
       }
       codeBlock = compiler.universe.generatedBailoutCode[member];
       if (codeBlock !== null) {
         String name = namer.getBailoutName(member);
         buffer.add('$prototype.$name = $codeBlock;\n');
       }
     } else {
       // TODO(ngeoffray): Have another class generate the code for the
       // fields.
       assert(member.kind === ElementKind.FIELD);
-      if (compiler.universe.invokedSetters.contains(member.name.stringValue)) {
+      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.stringValue)) {
+      if (compiler.universe.invokedGetters.contains(member.name)) {
         String getterName = namer.getterName(member.name);
         buffer.add('$prototype.$getterName = function(){\n' +
           '  return this.${namer.getName(member)};\n}\n');
       }
     }
   }
 
   bool generateFieldInits(ClassElement classElement,
                           StringBuffer argumentsBuffer,
                           StringBuffer bodyBuffer) {
     bool isFirst = true;
     do {
       // TODO(floitsch): make sure there are no name clashes.
       String className = namer.getName(classElement);
       for (Element member in classElement.members) {
         if (member.isInstanceMember() && member.kind == ElementKind.FIELD) {
           if (!isFirst) argumentsBuffer.add(', ');
           isFirst = false;
-          String memberName = namer.instanceName(member.name);
+          String memberName = namer.instanceFieldName(member.name);
           argumentsBuffer.add('${className}_$memberName');
           bodyBuffer.add('  this.$memberName = ${className}_$memberName;\n');
         }
       }
       classElement = classElement.superClass;
     } while(classElement !== null);
   }
 
   void generateClass(ClassElement classElement,
                      StringBuffer buffer,
@@ skipping 82 matching lines @@
     CompileTimeConstantHandler constants = compiler.compileTimeConstantHandler;
     List<VariableElement> staticFinalFields =
         constants.getStaticFinalFieldsForEmission();
     for (VariableElement element in staticFinalFields) {
       buffer.add('${namer.isolatePropertyAccess(element)} = ');
       constants.emitJsCodeForField(element, buffer);
       buffer.add(';\n');
     }
   }
 
+  void emitNoSuchMethodCalls(StringBuffer buffer) {
+    // Do not generate no such method calls if there is no class.
+    if (!addedInheritFunction) return;

[floitsch, 2012/01/24 11:46:03]

I assume you don't want to use instantiatedClasses because it contains native
classes?
Otherwise the following would be cleaner:
if (!compiler.universe.instantiatedClasses.isEmpty()) ...

[floitsch, 2012/01/24 11:46:03]

Add TODO that we don't need to generate these methods if nobody overwrites
noSuchMethod ?

[ngeoffray, 2012/01/24 12:09:39]

Done.

[ngeoffray, 2012/01/24 12:09:39]

No, I just didn't think of using it (addedInheritFunction was local to this
class, so simpler to use).
I agree. Changed to use instantiatedClasses.

+
+    ClassElement objectClass =
+        compiler.universe.find(const SourceString('Object'));
+    String className = namer.isolatePropertyAccess(objectClass);
+    String prototype = '$className.prototype';
+    String noSuchMethodName =
+        namer.instanceMethodName(Compiler.NO_SUCH_METHOD, 2);
+
+    void generateMethod(String methodName, String jsName, int arity) {
+      buffer.add('$prototype.$jsName = function');
+      StringBuffer args = new StringBuffer();
+      for (int i = 0; i < arity; i++) {
+        if (i != 0) args.add(', ');
+        args.add('arg$i');
+      }
+      buffer.add(' ($args) {\n');
+      buffer.add("  return this.$noSuchMethodName('$methodName', [$args]);\n");
+      buffer.add('}\n');
+    }
+
+    compiler.universe.invokedNames.forEach((SourceString methodName,
+                                            Set<int> arities) {
+      if (objectClass.lookupLocalMember(methodName) === null) {
+        for (int arity in arities) {
+          String jsName = namer.instanceMethodName(methodName, arity);
+          generateMethod(methodName.stringValue, jsName, arity);
+        }
+      }
+    });
+
+    compiler.universe.invokedGetters.forEach((SourceString getterName) {
+      String jsName = namer.getterName(getterName);
+      generateMethod('get $getterName', jsName, 0);
+    });
+
+    compiler.universe.invokedSetters.forEach((SourceString setterName) {
+      String jsName = namer.setterName(setterName);
+      generateMethod('set $setterName', jsName, 1);
+    });
+  }
+
   String assembleProgram() {
     measure(() {
       StringBuffer buffer = new StringBuffer();
       buffer.add('function ${namer.ISOLATE}() {');
       emitStaticNonFinalFieldInitializations(buffer);
       buffer.add('}\n\n');
       emitClasses(buffer);
+      emitNoSuchMethodCalls(buffer);
       emitStaticFunctions(buffer);
       emitStaticFinalFieldInitializations(buffer);
       buffer.add('var ${namer.CURRENT_ISOLATE} = new ${namer.ISOLATE}();\n');
-      buffer.add('${namer.CURRENT_ISOLATE}.main();\n');
+      Element main = compiler.universe.find(Compiler.MAIN);
+      buffer.add('${namer.isolateAccess(main)}();\n');
       compiler.assembledCode = buffer.toString();
     });
     return compiler.assembledCode;
   }
 }