New treatment of native methods.

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('dart:uri');
 #import('leg.dart');
 #import('elements/elements.dart');
 #import('scanner/scannerlib.dart');
 #import('ssa/ssa.dart');
@@ skipping 62 matching lines @@
 }
 
 void maybeEnableNative(Compiler compiler,
                        LibraryElement library,
                        Uri uri) {
   String libraryName = uri.toString();
   if (library.script.name.contains('dart/tests/compiler/dart2js_native')
       || libraryName == 'dart:dom_deprecated'
       || libraryName == 'dart:isolate'
       || libraryName == 'dart:html') {
-    library.define(new ForeignElement(
-        const SourceString('native'), library), compiler);
     library.canUseNative = true;
     if (compiler.jsIndexingBehaviorInterface !== null) {
       library.define(compiler.jsIndexingBehaviorInterface, compiler);
     }
   }
 
   // Additionaly, if this is a test, we allow access to foreign functions.
   if (library.script.name.contains('dart/tests/compiler/dart2js_native')) {
     library.define(compiler.findHelper(const SourceString('JS')), compiler);
   }
@@ skipping 39 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);
+  listener.beginReturnStatement(token);
   token = token.next;
+  bool hasExpression = false;
   if (token.kind === STRING_TOKEN) {
+    hasExpression = true;
     listener.beginLiteralString(token);
     listener.endLiteralString(0);
-    LiteralString str = listener.popNode();
-    listener.pushNode(new NodeList.singleton(str));
-    listener.endSend(token);
     token = token.next;
-    // If this native method is just redirecting to another method,
-    // we add a return node to match the SSA builder 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);
+  listener.endReturnStatement(hasExpression, begin, token);
   // TODO(ngeoffray): expect a ';'.
+  // Currently there are method with both native marker and Dart body.
   return token.next;
 }
 
 SourceString checkForNativeClass(ElementListener listener) {
   SourceString nativeName;
   Node node = listener.nodes.head;
   if (node != null
       && node.asIdentifier() != null
       && node.asIdentifier().source.stringValue == 'native') {
     nativeName = node.asIdentifier().token.next.value;
     listener.popNode();
   }
   return nativeName;
 }
 
 bool isOverriddenMethod(FunctionElement element,
                         ClassElement cls,
                         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) {
+void handleSsaNative(SsaBuilder builder, Expression nativeBody) {
   Compiler compiler = builder.compiler;
   FunctionElement element = builder.work.element;
   element.setNative();
   NativeEmitter nativeEmitter = builder.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') {
     Element methodElement =
         compiler.findHelper(const SourceString('getTypeNameOf'));
     HStatic method = new HStatic(methodElement);
     builder.add(method);
     builder.push(new HInvokeStatic(Selector.INVOCATION_1,
         <HInstruction>[method, builder.localsHandler.readThis()]));
-    return;
+    builder.close(new HReturn(builder.pop())).addSuccessor(builder.graph.exit);
   }
 
   HInstruction convertDartClosure(Element parameter, FunctionType type) {
     HInstruction local = builder.localsHandler.readLocal(parameter);
     // TODO(ngeoffray): For static methods, we could pass a method with a
     // defined arity.
     builder.push(new HStatic(builder.interceptors.getClosureConverter()));
     HInstruction arity = builder.graph.addConstantInt(type.computeArity());
     List<HInstruction> callInputs = <HInstruction>[builder.pop(), local, arity];
     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
+  RegExp nativeRedirectionRegExp = const RegExp(@'^[a-zA-Z][a-zA-Z_$0-9]*$');
   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;
+  if (nativeBody !== null) {
+    LiteralString jsCode = nativeBody.asLiteralString();
     String str = jsCode.dartString.slowToString();
     if (nativeRedirectionRegExp.hasMatch(str)) {
       nativeMethodName = str;
       isRedirecting = true;
       nativeEmitter.addRedirectingMethod(element, nativeMethodName);
     } else {
       hasBody = true;
     }
   }
 
@@ skipping 27 matching lines @@
     } else if (element.kind == ElementKind.SETTER) {
       nativeMethodCall = '$receiver$nativeMethodName = $foreignParameters';
     } else {
       builder.compiler.internalError('unexpected kind: "${element.kind}"',
                                      element: element);
     }
 
     DartString jsCode = new DartString.literal(nativeMethodCall);
     builder.push(
         new HForeign(jsCode, const LiteralDartString('Object'), inputs));
+    builder.close(new HReturn(builder.pop())).addSuccessor(builder.graph.exit);
   } 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, type);
         // 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;
+    LiteralString jsCode = nativeBody.asLiteralString();
     builder.push(new HForeign(jsCode.dartString,
                               const LiteralDartString('Object'),
                               <HInstruction>[]));
   }
 }
 
 void generateMethodWithPrototypeCheckForElement(Compiler compiler,
                                                 StringBuffer buffer,
                                                 FunctionElement element,
                                                 String code,
@@ skipping 30 matching lines @@
                                       String parameters) {
   buffer.add("  if (Object.getPrototypeOf(this).hasOwnProperty");
   buffer.add("('$methodName')) {\n");
   buffer.add("  $code");
   buffer.add("  } else {\n");
   buffer.add("    return Object.prototype.$methodName.call(this");
   buffer.add(parameters == '' ? '' : ', $parameters');
   buffer.add(");\n");
   buffer.add("  }\n");
 }