Support user generated custom native JS classes.

pkg/compiler/lib/src/js_backend/js_interop_analysis.dart

+// Copyright (c) 2015, 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.
+
+/// Analysis to determine how to generate code for typed JavaScript interop.
+library compiler.src.js_backend.js_interop_analysis;
+
+import '../common/names.dart' show Identifiers;
+import '../compiler.dart' show Compiler;
+import '../diagnostics/messages.dart' show MessageKind;
+import '../constants/values.dart'
+    show
+        ConstantValue,
+        ConstructedConstantValue,
+        ListConstantValue,
+        NullConstantValue,
+        StringConstantValue,
+        TypeConstantValue;
+import '../elements/elements.dart'
+    show
+        ClassElement,
+        Element,
+        FieldElement,
+        FunctionElement,
+        LibraryElement,
+        MetadataAnnotation;
+
+import '../js/js.dart' as jsAst;
+import '../js/js.dart' show js;
+import '../universe/selector.dart' show Selector;
+import '../universe/universe.dart' show SelectorConstraints;
+
+import 'js_backend.dart' show JavaScriptBackend;
+
+class JsInteropAnalysis {
+  final JavaScriptBackend backend;
+
+  /// The resolved [FieldElement] for `Js.name`.
+  FieldElement nameField;
+  bool enabledJsInterop = false;
+
+  JsInteropAnalysis(this.backend);
+
+  void onQueueClosed() {
+    if (backend.jsAnnotationClass != null) {
+      nameField = backend.jsAnnotationClass.lookupMember('name');
+      backend.compiler.libraryLoader.libraries
+          .forEach(processJsInteropAnnotationsInLibrary);
+    }
+  }
+
+  void processJsInteropAnnotation(Element e) {
+    for (MetadataAnnotation annotation in e.implementation.metadata) {
+      ConstructedConstantValue constant =
+          backend.compiler.constants.getConstantValue(annotation.constant);

[Siggi Cherem (dart-lang), 2015/10/13 02:08:53]

check first for the type of constant since some annotations might be something
other than ConstructedConstantValues, for example:

  const foo = 1;
  @foo
  fElement(){}

[Jacob, 2015/10/13 03:10:42]

Done.

+      if (constant != null &&

[Siggi Cherem (dart-lang), 2015/10/13 02:08:53]

since you'll have more than one check, consider doing:

if (constant == null || constant is! ConstructedConstantValue) continue;

[Jacob, 2015/10/13 03:10:42]

done

+          constant.getType(backend.compiler.coreTypes).element ==

[Siggi Cherem (dart-lang), 2015/10/13 02:08:53]

or simply `constant.type.element` (I believe ConstructedConstantValue has a
.type getter)

[Jacob, 2015/10/13 03:10:43]

Done.

+              backend.jsAnnotationClass) {
+        ConstantValue value = constant.fields[nameField];
+        if (value.isString) {
+          StringConstantValue stringValue = value;
+          e.setJsInteropName(stringValue.primitiveValue.slowToString());
+        } else {
+          assert(value.isNull);
+          e.setJsInteropName('');
+        }
+        enabledJsInterop = true;
+        return;
+      }
+    }
+  }
+
+  void processJsInteropAnnotationsInLibrary(LibraryElement library) {
+    processJsInteropAnnotation(library);
+    library.implementation.forEachLocalMember((Element element) {
+      processJsInteropAnnotation(element);
+      if (element.isClass) {

[Siggi Cherem (dart-lang), 2015/10/13 02:08:53]

nit: to keep the nesting level below smaller, we could here just do:

if (!element.isClass || !element.isJsInterop) return;
...

[Jacob, 2015/10/13 03:10:42]

Done.

+        ClassElement classElement = element;
+        if (classElement.isJsInterop) {
+          classElement.forEachMember((_, memberElement) {
+            processJsInteropAnnotation(memberElement);

[Siggi Cherem (dart-lang), 2015/10/13 02:08:53]

could we move this down and combine with the body of the other forEachMember?

[Jacob, 2015/10/13 03:10:42]

moved it anyway.

i think this is slightly as the rest of the code is error checking while this
code is actually about processing the annotations.
it would be reasonable to move the error checking into its own method, etc.. Not
sure this class is the right place for it. moved it here at the last minute as
the original location was causing errors to be reported multiple times. 

+          });
+
+          if (!classElement
+              .implementsInterface(backend.jsJavaScriptObjectClass)) {
+            backend.compiler.reportErrorMessage(classElement,
+                MessageKind.JS_INTEROP_CLASS_CANNOT_EXTEND_DART_CLASS, {
+              'cls': classElement.name,
+              'superclass': classElement.superclass.name
+            });
+          }
+
+          classElement.forEachMember(
+              (ClassElement classElement, Element member) {
+            if (!member.isSynthesized &&
+                classElement.isJsInterop &&
+                member is FunctionElement) {
+              FunctionElement fn = member;
+              if (!fn.isExternal && !fn.isAbstract) {
+                backend.compiler.reportErrorMessage(
+                    fn,
+                    MessageKind.JS_INTEROP_CLASS_NON_EXTERNAL_MEMBER,
+                    {'cls': classElement.name, 'member': member.name});
+              }
+            }
+          });
+        }
+      }
+    });
+  }
+
+  jsAst.Statement buildJsInteropBootstrap() {
+    if (!enabledJsInterop) return null;
+    List<jsAst.Statement> statements = <jsAst.Statement>[];
+    backend.compiler.codegenWorld.forEachInvokedName(
+        (String name, Map<Selector, SelectorConstraints> selectors) {
+      selectors.forEach((Selector selector, SelectorConstraints constraints) {
+        if (selector.isClosureCall) {
+          // TODO(jacobr): support named arguments.
+          if (selector.namedArgumentCount > 0) return;
+          int argumentCount = selector.argumentCount;
+          var candidateParameterNames =
+              'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLOMOPQRSTUVWXYZ';
+          var parameters = new List<String>.generate(
+              argumentCount, (i) => candidateParameterNames[i]);
+
+          var name = backend.namer.invocationName(selector);
+          statements.add(js.statement(
+              'Function.prototype.# = function(#) { return this(#) }',
+              [name, parameters, parameters]));
+        }
+      });
+    });
+    return new jsAst.Block(statements);
+  }
+}