Support user generated custom native JS classes.

pkg/compiler/lib/src/patch_parser.dart

Index: pkg/compiler/lib/src/patch_parser.dart
diff --git a/pkg/compiler/lib/src/patch_parser.dart b/pkg/compiler/lib/src/patch_parser.dart
index 0f3008475c1095209ef5cf8d8f547788361d14dc..1ae480e2ea8242cd49517de0594ed2ac38a94cd2 100644
--- a/pkg/compiler/lib/src/patch_parser.dart
+++ b/pkg/compiler/lib/src/patch_parser.dart
@@ -304,6 +304,7 @@ void patchElement(Compiler compiler,
         patch, MessageKind.PATCH_NON_EXISTING, {'name': patch.name});
     return;
   }
+
   if (!(origin.isClass ||
         origin.isConstructor ||
         origin.isFunction ||
@@ -359,6 +360,12 @@ checkNativeAnnotation(Compiler compiler, ClassElement cls) {
       const NativeAnnotationHandler());
 }
 
+checkJsInteropAnnotation(Compiler compiler, element) {
+  EagerAnnotationHandler.checkAnnotation(compiler, element,
+      const JsInteropAnnotationHandler());
+}
+
+
 /// Abstract interface for pre-resolution detection of metadata.
 ///
 /// The detection is handled in two steps:
@@ -394,12 +401,17 @@ abstract class EagerAnnotationHandler<T> {
       if (result != null) {
         // TODO(johnniwinther): Perform this check in
         // [Compiler.onLibrariesLoaded].
-        compiler.enqueuer.resolution.addDeferredAction(element, () {
+        actionCallback() {
           annotation.ensureResolved(compiler);
           handler.validate(
               compiler, element, annotation,
               compiler.constants.getConstantValue(annotation.constant));
-        });
+        }
+        if (compiler.enqueuer.resolution.queueIsClosed) {

[Siggi Cherem (dart-lang), 2015/09/18 20:34:10]

this is probably breaking the current enqueuer invariant, since calling
ensureResolved may add more work to the queue :-/

In what cases do you hit this?

[Jacob, 2015/10/01 00:47:33]

this is somewhat horrible but somewhat acceptable according to sra.
The reason is calling annotation.ensureResolved(compiler) should essentially act
as an assert if we are calling this too late.

here's the stack trace I get when I tear out hack.
#0      ResolutionEnqueuer.addDeferredAction
(package:compiler/src/enqueue.dart:883:7)
#1      EagerAnnotationHandler.checkAnnotation
(package:compiler/src/patch_parser.dart:406:38)
#2      checkJsInteropAnnotation (package:compiler/src/patch_parser.dart:366:26)
#3      NativeEnqueuerBase.processJsInteropAnnotationsInLibrary
(package:compiler/src/native/enqueue.dart:151:5)
#4      Iterable.forEach (dart:core/iterable.dart:217)
#5      NativeEnqueuerBase.processNativeClasses
(package:compiler/src/native/enqueue.dart:142:15)
#6      NativeCodegenEnqueuer.processNativeClasses
(package:compiler/src/native/enqueue.dart:653:31)
#7      Compiler.processQueue (package:compiler/src/compiler.dart:1221:26)
#8      Compiler.compileLoadedLibraries
(package:compiler/src/compiler.dart:1165:5)
#9      Compiler.runCompiler.<anonymous closure>
(package:compiler/src/compiler.dart:979:7)
#10     _RootZone.runUnary (dart:async/zone.dart:1166)
#11     _Future._propagateToListeners.handleValueCallback
(dart:async/future_impl.dart:494)
#12     _Future._propagateToListeners (dart:async/future_impl.dart:577)
#13     _Future._completeWithValue (dart:async/future_impl.dart:368)
#14     _Future._asyncComplete.<anonymous closure>
(dart:async/future_impl.dart:422)
#15     _microtaskLoop (dart:async/schedule_microtask.dart:43)
#16     _microtaskLoopEntry (dart:async/schedule_microtask.dart:52)
#17     _runPendingImmediateCallback (dart:isolate-patch/isolate_patch.dart:96)
#18     _RawReceivePortImpl._handleMessage
(dart:isolate-patch/isolate_patch.dart:149)


Added a TODO that annotation resolution needs to be refactored.

+          actionCallback();
+        } else {
+          compiler.enqueuer.resolution.addDeferredAction(element, actionCallback);

[Siggi Cherem (dart-lang), 2015/09/18 20:34:10]

nit: long line

[Jacob, 2015/10/01 00:47:33]

Done.

+        }
         return result;
       }
     }
@@ -449,6 +461,52 @@ class NativeAnnotationHandler implements EagerAnnotationHandler<String> {
   }
 }
 
+/// Annotation handler for pre-resolution detection of `@JsName(...)`
+/// annotations.
+class JsInteropAnnotationHandler implements EagerAnnotationHandler<String> {
+  const JsInteropAnnotationHandler();
+
+  // TODO(jacobr): this method is pure technical debt.
+  String dietResolveStringToken(StringToken token) {

[Siggi Cherem (dart-lang), 2015/09/18 20:34:10]

could we switch to use the constant evaluation instead? That way you don't have
to assume that the string token is in the annotation.

For example, this should be OK:

  const _foo = 'my.name';

  @JsName(_foo)
  class MyName extends JavascriptObject {
    get jsName => _foo;
  }

[Jacob, 2015/10/01 00:47:33]

The trouble is getJsNameAnnotation is currently called before const evaluation
is possible unless I'm missing something.
I could modify the ordering so we fill in the value for jsName on the later call
to validate. Let me know if you think that is worth it and you give me a
breadcrumb pointing at the const evaluation code.

+    String value = token.value;
+    if ((value.startsWith('"') && value.endsWith('"')) ||
+        value.startsWith("'") && value.endsWith("'")) {
+      return value.substring(1, value.length - 1);
+    } else {
+      throw 'Invalid @JsName(...) annotation. Unexpected name: $value';
+    }
+  }
+
+  String getJsNameAnnotation(MetadataAnnotation annotation) {
+    if (annotation.beginToken != null &&
+        annotation.beginToken.next.value == 'JsName') {
+      // Skipping '@', 'JsName', and '('.
+      Token argument = annotation.beginToken.next.next.next;
+      return (argument is StringToken) ? dietResolveStringToken(argument) : '';
+    }
+
+    return null;
+  }
+
+  String apply(Compiler compiler,
+             Element element,
+             MetadataAnnotation annotation) {
+    String jsName = getJsNameAnnotation(annotation);
+    if (jsName != null) {
+      element.setJsInterop(jsName);
+      element.declaration.setJsInterop(jsName);
+    }
+    return jsName;
+  }
+
+  @override
+  void validate(Compiler compiler,
+                Element element,
+                MetadataAnnotation annotation,
+                ConstantValue constant) {
+  }
+}
+
 /// Annotation handler for pre-resolution detection of `@patch` annotations.
 class PatchAnnotationHandler implements EagerAnnotationHandler<PatchVersion> {
   const PatchAnnotationHandler();