Building the Ssa graph has some sanity checks.

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 113 matching lines @@
   checkAllowedLibrary(listener, token);
   token = token.next;
   if (token.kind !== STRING_TOKEN) {
     listener.unexpected(token);
   } else {
     token = token.next;
   }
   return token;
 }
 
+RegExp nativeRedirectionRegExp = const RegExp(@'^[a-zA-Z][a-zA-Z_$0-9]*$');
+
 Token handleNativeFunctionBody(ElementListener listener, Token token) {
   checkAllowedLibrary(listener, token);
   Token begin = token;
   listener.beginExpressionStatement(token);
   listener.handleIdentifier(token);
   token = token.next;
   if (token.kind === STRING_TOKEN) {
     listener.beginLiteralString(token);
     listener.endLiteralString(0);
-    listener.pushNode(new NodeList.singleton(listener.popNode()));
+    LiteralString str = listener.popNode();
+    listener.pushNode(new NodeList.singleton(str));
     listener.endSend(token);
     token = token.next;
-    listener.endExpressionStatement(token);
+    // If this native method is just redirecting to another method,
+    // we add a return node to match the SSA builder expactations.

[floitsch, 2012/03/30 19:41:26]

expectations

+    if (nativeRedirectionRegExp.hasMatch(str.dartString.slowToString())) {
+      listener.endReturnStatement(true, begin, token);
+    } else {
+      listener.endExpressionStatement(token);
+    }
   } else {
     listener.pushNode(new NodeList.empty());
     listener.endSend(token);
     listener.endReturnStatement(true, begin, token);
   }
   listener.endFunctionBody(1, begin, token);
   // TODO(ngeoffray): expect a ';'.
   return token.next;
 }
 
@@ skipping 59 matching lines @@
   // 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)) {
+    if (nativeRedirectionRegExp.hasMatch(str)) {
       nativeMethodName = str;
       isRedirecting = true;
     } else {
       hasBody = true;
     }
   }
 
   FunctionParameters parameters = element.computeParameters(builder.compiler);
   if (!hasBody) {
     List<String> arguments = <String>[];
@@ skipping 88 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);
     }
-    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>[]));
   }
 }