Implement native getters and setters and move supported tests to 'native'.

frog/leg/native_handler.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.
 
 #library('native');
 #import('leg.dart');
 #import('elements/elements.dart');
 #import('scanner/scannerlib.dart');
 #import('ssa/ssa.dart');
 #import('tree/tree.dart');
@@ skipping 110 matching lines @@
       i++;
       inputs.add(builder.localsHandler.readThis());
     }
     parameters.forEachParameter((Element parameter) {
       arguments.add('\$$i');
       inputs.add(builder.localsHandler.readLocal(parameter));
       i++;
     });
     String foreignParameters = Strings.join(arguments, ',');
 
-    String methodName = builder.compiler.namer.instanceMethodName(
-        element.name, parameters.parameterCount);
+    String dartMethodName;

[kasperl, 2012/02/29 10:16:38]

I guess this almost calls for an abstraction with these three fields.

[ngeoffray, 2012/02/29 10:19:19]

We have the element, but I'm not sure I want to pollute the Element classes with
these native considerations. 

+    String nativeMethodName = element.name.slowToString();
+    String nativeMethodCall;
+
+    if (element.kind == ElementKind.FUNCTION) {
+      dartMethodName = builder.compiler.namer.instanceMethodName(
+          element.name, parameters.parameterCount);
+      nativeMethodCall = '$receiver$nativeMethodName($foreignParameters)';
+    } else if (element.kind == ElementKind.GETTER) {
+      dartMethodName = builder.compiler.namer.getterName(element.name);
+      nativeMethodCall = '$receiver$nativeMethodName';
+    } else if (element.kind == ElementKind.SETTER) {
+      dartMethodName = builder.compiler.namer.setterName(element.name);
+      nativeMethodCall = '$receiver$nativeMethodName = $foreignParameters';
+    } else {
+      builder.compiler.internalError('unexpected kind: "${element.kind}"',
+                                     element: element);
+    }
 
     HInstruction thenInstruction;
     void visitThen() {
-      SourceString jsCode = new SourceString(
-          '$receiver${element.name.slowToString()}($foreignParameters)');
+      SourceString jsCode = new SourceString(nativeMethodCall);
       thenInstruction =
           new HForeign(jsCode, const SourceString('Object'), inputs);
       builder.add(thenInstruction);
     }
 
     if (!element.isInstanceMember()) {
       // If the method is a non-instance method, we just generate a direct
       // call to the native method.
       visitThen();
       builder.stack.add(thenInstruction);
     } else {
       // If the method is an instance method, we generate the following code:
       // function(params) {
-      //   return Object.getPrototypeOf(this).hasOwnProperty(methodName))
+      //   return Object.getPrototypeOf(this).hasOwnProperty(dartMethodName))
       //      ? this.methodName(params)
       //      : Object.prototype.methodName.call(this, params);
       // }
       //
       // The property check at the beginning is to make sure we won't
       // call the method from the super class, in case the prototype of
       // 'this' does not have the method yet.
       //
       // TODO(ngeoffray): We can avoid this if we know the class of this
       // method does not have subclasses.
       HInstruction elseInstruction;
       void visitElse() {
-        SourceString jsCode = new SourceString('Object.prototype.$methodName');
+        SourceString jsCode =
+            new SourceString('Object.prototype.$dartMethodName');
         HInstruction instruction =
             new HForeign(jsCode, const SourceString('Object'), []);
         builder.add(instruction);
         List<HInstruction> elseInputs = new List<HInstruction>.from(inputs);
         elseInputs.add(instruction);
         String params = arguments.isEmpty() ? '' : ', $foreignParameters';
         jsCode = new SourceString('\$${i}.call(\$0$params)');
         elseInstruction =
             new HForeign(jsCode, const SourceString('Object'), elseInputs);
         builder.add(elseInstruction);
       }
 
       HLiteral literal = builder.graph.addNewLiteralString(
-          new DartString.literal('$methodName'));
+          new DartString.literal('$dartMethodName'));
       SourceString jsCode = new SourceString(
           'Object.getPrototypeOf(\$0).hasOwnProperty(\$1)');
       builder.push(new HForeign(
           jsCode, const SourceString('Object'),
           <HInstruction>[builder.localsHandler.readThis(), literal]));
 
       builder.handleIf(visitThen, visitElse);
 
       HPhi phi = new HPhi.manyInputs(
           null, <HInstruction>[thenInstruction, elseInstruction]);
       builder.current.addPhi(phi);
       builder.stack.add(phi);
     }
 
   } else if (!node.arguments.tail.isEmpty()) {
     builder.compiler.cancel('More than one argument to native');
   } else {
     LiteralString jsCode = node.arguments.head;
     int start = jsCode.value.slowToString()[0] === '@' ? 1 : 0;
     builder.push(new HForeign(builder.unquote(jsCode, start),
                               const SourceString('Object'),
                               <HInstruction>[]));
   }
 }