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);

[Anton Muhin, 2012/06/18 10:04:52]

now we treat all natives as returns, even though there are cases like native
'this.x = 42' which formally has no returns.  That leads to returning a bool if
we need to wrap HForeign into HReturn.

[sra1, 2012/06/20 18:29:05]

I'm not sure that makes sense; some of the native strings are statements, not
expressions.

[Anton Muhin, 2012/06/20 18:51:49]

Stephen, both Peter and me are well aware of this problem---see the discussion. 
Still we think it's the best approach.  But if you have any over proposals,
that'd be really great.

Plus there are plans to rework native system completely which will probably
render this CL fully obsolete, so I'd rather not spend too much time theorizing
about ideal approach but rather keep things as simple as possible.

That's my stance, Peter may very well have completely different view of the
story.

On 2012/06/20 18:29:05, sra1 wrote:

-    }
-  } else {
-    listener.pushNode(new NodeList.empty());
-    listener.endSend(token);
-    listener.endReturnStatement(true, begin, token);
   }
-  listener.endFunctionBody(1, begin, token);
-  // TODO(ngeoffray): expect a ';'.
+  listener.endReturnStatement(hasExpression, begin, token);
+  /* Fails thanks to lib/isolate/frog/isolateimpl.dart:143 --- native method w/ Dart body.

[Anton Muhin, 2012/06/18 10:04:52]

is it valid Dart?  I mean code in isolateimpl.dart.

[ahe, 2012/06/18 10:37:39]

No. Nothing about "native" is valid Dart.
Whatever is used to implement that stuff is needed. If you think it is easier,
convert the code to use the JS function instead. Let me know if you need to some
pointers.

[sra1, 2012/06/20 18:29:05]

Native methods with both a string JavaScript body and a Dart body was a trick
used by Frog to mark the dependencies of the native code.  For example, if the
native code throws a FooException, the Dart code would contain a call to the
constructor of FooException to ensure that the compiler knew it was used,
otherwise no code for FooException might be emitted.

We should rewrite all code using this trick as Dart code with embedded JS()
elements.

[Anton Muhin, 2012/06/20 18:51:49]

Thanks a lot for clarifications.  I wonder if it works now at all, but it might.

On 2012/06/20 18:29:05, sra1 wrote:

+  if (';' !== token.stringValue) {
+    return listener.expected(';', token);
+  }
+  */
   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;
+    return true;
   }
 
   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));
+    return true;
   } 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>[]));
+    return false;
   }
 }
 
 void generateMethodWithPrototypeCheckForElement(Compiler compiler,
                                                 StringBuffer buffer,
                                                 FunctionElement element,
                                                 String code,
                                                 String parameters) {
   String methodName;
   Namer namer = compiler.namer;
@@ skipping 27 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");
 }