Generative constructor factories for native objects

sdk/lib/_internal/compiler/implementation/js_backend/backend.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.
 
 part of js_backend;
 
 class JavaScriptItemCompilationContext extends ItemCompilationContext {
   final Set<HInstruction> boundsChecked;
 
   JavaScriptItemCompilationContext()
@@ skipping 459 matching lines @@
     Set<ClassElement> classes = getInterceptedClassesOn(selector.name);
     String name = namer.getOneShotInterceptorName(selector, classes);
     if (!oneShotInterceptors.containsKey(name)) {
       registerSpecializedGetInterceptor(classes);
       oneShotInterceptors[name] = selector;
     }
     return name;
   }
 
   bool isInterceptedMethod(Element element) {
-    return element.isInstanceMember()
-        && !element.isGenerativeConstructorBody()
-        && interceptedElements[element.name] != null;
+    if (!element.isInstanceMember()) return false;
+    if (element.isGenerativeConstructorBody()) {
+      return Elements.isNativeOrExtendsNative(element.getEnclosingClass());
+    }
+    return interceptedElements[element.name] != null;
   }
 
   bool fieldHasInterceptedGetter(Element element) {
     assert(element.isField());
     return interceptedElements[element.name] != null;
   }
 
   bool fieldHasInterceptedSetter(Element element) {
     assert(element.isField());
     return interceptedElements[element.name] != null;
@@ skipping 452 matching lines @@
                            Enqueuer enqueuer,
                            TreeElements elements) {
     enqueuer.registerInstantiatedClass(typeImplementation, elements);
     enqueueInResolution(getCreateRuntimeType(), elements);
     // TODO(ahe): Might want to register [element] as an instantiated class
     // when reflection is used.  However, as long as we disable tree-shaking
     // eagerly it doesn't matter.
     if (element.isTypedef()) {
       typedefTypeLiterals.add(element);
     }
+    registerEscapingConstructorsOfClass(element, enqueuer);
   }
 
+
+  void registerEscapingConstructorsOfClass(ClassElement classElement,
+                                           Enqueuer enqueuer) {
+    // Web component classes have constructors that are escaped to the host
+    // environment.
+    classElement.ensureResolved(compiler);

[kasperl, 2013/10/04 11:08:43]

You may want to consider if you can avoid the static use registering if
document.register isn't being used.

[sra1, 2013/10/04 20:21:28]

I'll TODO it for now.

It would be nice if there was a single general mechanism for this complex kind
of rule that allowed us to write the rule in one place rather than implement it
as a nest of notifications and state smeared across the enqueuer and backend.

The enqueuer is basically an ad-hoc implementation of the RETE algorithm, which
has a lot in common with semi-naive bottom-up evaluation of datalog programs.

+    if (Elements.isNativeOrExtendsNative(classElement)) {

[kasperl, 2013/10/04 11:08:43]

I guess we are sure that we're only calling Elements.isNativeOrExtendsNative on
resolved class elements. I guess it would be nice if we checked that in the
implementation Elements.isNativeOrExtendsNative because the super class
reference will not be correct if the class hasn't been resolved yet.

Maybe we already have that check indirectly through the ClassElement.superclass
accessor but it might make sense to add it to Elements.isNativeOrExtendsNative
to better document the intent.

[sra1, 2013/10/04 20:21:28]

Added assertion in isNativeOrExtendsNative.

+      classElement.forEachMember(
+          (ClassElement enclosingClass, Element member) {

[kasperl, 2013/10/04 11:08:43]

Maybe this would be more readable if you introduced a local helper function with
a name for it?

[sra1, 2013/10/04 20:21:28]

Done.

+            if (member.isGenerativeConstructor()) {
+              enqueuer.registerStaticUse(member);
+            }
+          },
+          includeBackendMembers: false,
+          includeSuperAndInjectedMembers: false);
+    }
+  }
+
+
+
   void registerStackTraceInCatch(TreeElements elements) {
     enqueueInResolution(getTraceFromException(), elements);
   }
 
   void registerSetRuntimeType(TreeElements elements) {
     enqueueInResolution(getSetRuntimeTypeInfo(), elements);
   }
 
   void registerGetRuntimeTypeArgument(TreeElements elements) {
     enqueueInResolution(getGetRuntimeTypeArgument(), elements);
@@ skipping 891 matching lines @@
     copy(constant.values);
     copy(constant.protoValue);
     copy(constant);
   }
 
   void visitConstructed(ConstructedConstant constant) {
     copy(constant.fields);
     copy(constant);
   }
 }