Support user generated custom native JS classes.

pkg/compiler/lib/src/patch_parser.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.
 
 /**
  * This library contains the infrastructure to parse and integrate patch files.
  *
  * Three types of elements can be patched: [LibraryElement], [ClassElement],
  * [FunctionElement]. Patches are introduced in patch libraries which are loaded
  * together with the corresponding origin library. Which libraries that are
@@ skipping 286 matching lines @@
 }
 
 void patchElement(Compiler compiler,
                   Element origin,
                   Element patch) {
   if (origin == null) {
     compiler.reportError(
         patch, MessageKind.PATCH_NON_EXISTING, {'name': patch.name});
     return;
   }
+
   if (!(origin.isClass ||
         origin.isConstructor ||
         origin.isFunction ||
         origin.isAbstractField)) {
     // TODO(ahe): Remove this error when the parser rejects all bad modifiers.
     compiler.reportError(origin, MessageKind.PATCH_NONPATCHABLE);
     return;
   }
   if (patch.isClass) {
     tryPatchClass(compiler, origin, patch);
@@ skipping 35 matching lines @@
   checkNativeAnnotation(compiler, patch);
 }
 
 /// Check whether [cls] has a `@Native(...)` annotation, and if so, set its
 /// native name from the annotation.
 checkNativeAnnotation(Compiler compiler, ClassElement cls) {
   EagerAnnotationHandler.checkAnnotation(compiler, 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:
 /// - match the annotation syntactically and assume that the annotation is valid
 ///   if it looks correct,
 /// - setup a deferred action to check that the annotation has a valid constant
 ///   value and report an internal error if not.
 abstract class EagerAnnotationHandler<T> {
   /// Checks that [annotation] looks like a matching annotation and optionally
   /// applies actions on [element]. Returns a non-null annotation marker if the
@@ skipping 15 matching lines @@
                          Element element,
                          EagerAnnotationHandler handler) {
     for (Link<MetadataAnnotation> link = element.metadata;
          !link.isEmpty;
          link = link.tail) {
       MetadataAnnotation annotation = link.head;
       var result = handler.apply(compiler, element, annotation);
       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;
       }
     }
     return null;
   }
 }
 
 /// Annotation handler for pre-resolution detection of `@Native(...)`
 /// annotations.
 class NativeAnnotationHandler implements EagerAnnotationHandler<String> {
@@ skipping 29 matching lines @@
                 Element element,
                 MetadataAnnotation annotation,
                 ConstantValue constant) {
     if (constant.getType(compiler.coreTypes).element !=
             compiler.nativeAnnotationClass) {
       compiler.internalError(annotation, 'Invalid @Native(...) annotation.');
     }
   }
 }
 
+/// 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();
 
   PatchVersion getPatchVersion(MetadataAnnotation annotation) {
     if (annotation.beginToken != null) {
       if (annotation.beginToken.next.value == 'patch') {
         return const PatchVersion(null);
       } else if (annotation.beginToken.next.value == 'patch_full') {
         return const PatchVersion('full');
@@ skipping 129 matching lines @@
 
 class PatchVersion {
   final String tag;
 
   const PatchVersion(this.tag);
 
   bool isActive(String patchTag) => tag == null || tag == patchTag;
 
   String toString() => 'PatchVersion($tag)';
 }