Implement redirecting natives.

dart/lib/compiler/implementation/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('../../uri/uri.dart');
 #import('leg.dart');
 #import('elements/elements.dart');
 #import('scanner/scannerlib.dart');
 #import('ssa/ssa.dart');
@@ skipping 160 matching lines @@
                         NativeEmitter nativeEmitter) {
   List<ClassElement> subtypes = nativeEmitter.subtypes[cls];
   if (subtypes == null) return false;
   for (ClassElement subtype in subtypes) {
     if (subtype.lookupLocalMember(element.name) != null) return true;
   }
   return false;
 }
 
 void handleSsaNative(SsaBuilder builder, Send node) {
-  // Register NoSuchMethodException and captureStackTrace in the compiler
-  // because the dynamic dispatch for native classes may use them.
   Compiler compiler = builder.compiler;
-  ClassElement cls = compiler.coreLibrary.find(
-      Compiler.NO_SUCH_METHOD_EXCEPTION);
-  cls.ensureResolved(compiler);
-  compiler.addToWorkList(cls.lookupConstructor(cls.name));
-  compiler.registerStaticUse(
-      compiler.findHelper(new SourceString('captureStackTrace')));
-
   FunctionElement element = builder.work.element;
   element.setNative();
   NativeEmitter nativeEmitter = compiler.emitter.nativeEmitter;
   // If what we're compiling is a getter named 'typeName' and the native
   // class is named 'DOMType', we generate a call to the typeNameOf
   // function attached on the isolate.
   // The DOM classes assume that their 'typeName' property, which is
   // not a JS property on the DOM types, returns the type name.
   if (element.name == const SourceString('typeName')
       && element.isGetter()
       && nativeEmitter.toNativeName(element.enclosingElement) == 'DOMType') {
-    DartString jsCode = new DartString.literal(
-        '${nativeEmitter.typeNameOfName}(#)');
-    List<HInstruction> inputs =
-        <HInstruction>[builder.localsHandler.readThis()];
-    builder.push(new HForeign(
-        jsCode, const LiteralDartString('String'), inputs));
+    Element element = compiler.findHelper(const SourceString('getTypeNameOf'));
+    HStatic method = new HStatic(element);
+    builder.add(method);
+    builder.push(new HInvokeStatic(Selector.INVOCATION_1,
+        <HInstruction>[method, builder.localsHandler.readThis()]));
     return;
   }
 
   HInstruction convertDartClosure(Element parameter) {
     HInstruction local = builder.localsHandler.readLocal(parameter);
     // TODO(ngeoffray): by better analyzing the function type and
-    // its formal parameters, we could just pass, eg closure.$call$0.
+    // its formal parameters, we could pass a method with a defined arity.
     builder.push(new HStatic(builder.interceptors.getClosureConverter()));
     List<HInstruction> callInputs = <HInstruction>[builder.pop(), local];
     HInstruction closure = new HInvokeStatic(Selector.INVOCATION_1, callInputs);
     builder.add(closure);
     return closure;
   }
 
+
+  // Check which pattern this native method follows:
+  // 1) foo() native; hasBody = false, isRedirecting = false
+  // 2) foo() native "bar"; hasBody = false, isRedirecting = true
+  // 3) foo() native "return 42"; hasBody = true, isRedirecting = false
+  bool hasBody = false;
+  bool isRedirecting = false;
+  String nativeMethodName = element.name.slowToString();
+  if (!node.arguments.isEmpty()) {
+    if (!node.arguments.tail.isEmpty()) {
+      builder.compiler.cancel('More than one argument to native');
+    }
+    LiteralString jsCode = node.arguments.head;
+    String str = jsCode.dartString.slowToString();
+    if (const RegExp(@'^[a-zA-Z][a-zA-Z_$0-9]*$').hasMatch(str)) {
+      nativeMethodName = str;
+      isRedirecting = true;
+    } else {
+      hasBody = true;
+    }
+  }
+
   FunctionParameters parameters = element.computeParameters(builder.compiler);
-  if (node.arguments.isEmpty()) {
+  if (!hasBody) {
     List<String> arguments = <String>[];
     List<HInstruction> inputs = <HInstruction>[];
     String receiver = '';
     if (element.isInstanceMember()) {
       receiver = '#.';
       inputs.add(builder.localsHandler.readThis());
     }
     parameters.forEachParameter((Element parameter) {
       Type type = parameter.computeType(compiler);
       HInstruction input = builder.localsHandler.readLocal(parameter);
       if (type is FunctionType) input = convertDartClosure(parameter);
       inputs.add(input);
       arguments.add('#');
     });
     String foreignParameters = Strings.join(arguments, ',');
 
     String dartMethodName;
-    String nativeMethodName = element.name.slowToString();
     String nativeMethodCall;
 
     if (element.kind == ElementKind.FUNCTION) {
       dartMethodName = builder.compiler.namer.instanceMethodName(
           element.getLibrary(), element.name, parameters.parameterCount);
       nativeMethodCall = '$receiver$nativeMethodName($foreignParameters)';
     } else if (element.kind == ElementKind.GETTER) {
       dartMethodName = builder.compiler.namer.getterName(
           element.getLibrary(), element.name);
       nativeMethodCall = '$receiver$nativeMethodName';
@@ skipping 62 matching lines @@
           jsCode, const LiteralDartString('Object'),
           <HInstruction>[builder.localsHandler.readThis(), constant]));
 
       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');
+    if (isRedirecting) {
+      // The parser creates a return node if there is no string literal
+      // after the native keyword. In case of a redirecting method, there
+      // is a string literal, therefore we must emit a return instruction
+      // in the builder.
+      builder.push(new HReturn(builder.pop()));
+    }
   } else {
     // This is JS code written in a Dart file with the construct
     // native """ ... """;. It does not work well with mangling,
     // but there should currently be no clash between leg mangling
     // and the library where this construct is being used. This
     // mangling problem will go away once we switch these libraries
     // to use Leg's 'JS' function.
     parameters.forEachParameter((Element parameter) {
       Type type = parameter.computeType(compiler);
       if (type is FunctionType) {
         HInstruction jsClosure = convertDartClosure(parameter);
         // Because the JS code references the argument name directly,
         // we must keep the name and assign the JS closure to it.
         builder.add(new HForeign(
             new DartString.literal('${parameter.name.slowToString()} = #'),
             const LiteralDartString('void'),
             <HInstruction>[jsClosure]));
       }
     });
     LiteralString jsCode = node.arguments.head;
     builder.push(new HForeign(jsCode.dartString,
                               const LiteralDartString('Object'),
                               <HInstruction>[]));
   }
 }