Support user generated custom native JS classes.

pkg/compiler/lib/src/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;
 
 const VERBOSE_OPTIMIZER_HINTS = false;
 
 class JavaScriptItemCompilationContext extends ItemCompilationContext {
   final Set<HInstruction> boundsChecked = new Set<HInstruction>();
@@ skipping 215 matching lines @@
   static final Uri DART_FOREIGN_HELPER =
       new Uri(scheme: 'dart', path: '_foreign_helper');
   static final Uri DART_JS_MIRRORS =
       new Uri(scheme: 'dart', path: '_js_mirrors');
   static final Uri DART_JS_NAMES =
       new Uri(scheme: 'dart', path: '_js_names');
   static final Uri DART_EMBEDDED_NAMES =
       new Uri(scheme: 'dart', path: '_js_embedded_names');
   static final Uri DART_ISOLATE_HELPER =
       new Uri(scheme: 'dart', path: '_isolate_helper');
+  static final Uri PACKAGE_JS =
+         new Uri(scheme: 'package', path: 'js/js.dart');
 
   static const String INVOKE_ON = '_getCachedInvocation';
   static const String START_ROOT_ISOLATE = 'startRootIsolate';
 
 
   String get patchVersion => emitter.patchVersion;
 
   bool get supportsReflection => emitter.emitter.supportsReflection;
 
   final Annotations annotations;
@@ skipping 36 matching lines @@
   ClassElement jsInterceptorClass;
   ClassElement jsStringClass;
   ClassElement jsArrayClass;
   ClassElement jsNumberClass;
   ClassElement jsIntClass;
   ClassElement jsDoubleClass;
   ClassElement jsNullClass;
   ClassElement jsBoolClass;
   ClassElement jsPlainJavaScriptObjectClass;
   ClassElement jsUnknownJavaScriptObjectClass;
+  ClassElement jsJavaScriptFunctionClass;
 
   ClassElement jsIndexableClass;
   ClassElement jsMutableIndexableClass;
 
   ClassElement jsMutableArrayClass;
   ClassElement jsFixedArrayClass;
   ClassElement jsExtendableArrayClass;
   ClassElement jsUnmodifiableArrayClass;
   ClassElement jsPositiveIntClass;
   ClassElement jsUInt32Class;
@@ skipping 17 matching lines @@
   ConstructorElement mapLiteralConstructorEmpty;
   Element mapLiteralUntypedMaker;
   Element mapLiteralUntypedEmptyMaker;
 
   ClassElement noSideEffectsClass;
   ClassElement noThrowsClass;
   ClassElement noInlineClass;
   ClassElement forceInlineClass;
   ClassElement irRepresentationClass;
 
+  ClassElement jsAnnotationClass;
+
   Element getInterceptorMethod;
 
   ClassElement jsInvocationMirrorClass;
 
   /// If [true], the compiler will emit code that logs whenever a method is
   /// called. When TRACE_METHOD is 'console' this will be logged
   /// directly in the JavaScript console. When TRACE_METHOD is 'post' the
   /// information will be sent to a server via a POST request.
   static const String TRACE_METHOD = const String.fromEnvironment('traceCalls');
   static const bool TRACE_CALLS =
@@ skipping 314 matching lines @@
 
   ConstantSystem get constantSystem => constants.constantSystem;
 
   /// Returns constant environment for the JavaScript interpretation of the
   /// constants.
   JavaScriptConstantCompiler get constants {
     return constantCompilerTask.jsConstantCompiler;
   }
 
   FunctionElement resolveExternalFunction(FunctionElement element) {
-    if (isForeign(element)) return element;
+    if (isForeign(element) || element.isJsInterop) return element;
     return patchResolverTask.measure(() {
       return patchResolverTask.resolveExternalFunction(element);
     });
   }
 
   // TODO(karlklose): Split into findHelperFunction and findHelperClass and
   // add a check that the element has the expected kind.
   Element findHelper(String name) => find(jsHelperLibrary, name);
   Element findAsyncHelper(String name) => find(asyncLibrary, name);
   Element findInterceptor(String name) => find(interceptorsLibrary, name);
@@ skipping 358 matching lines @@
         // For map literals, the dependency between the implementation class
         // and [Map] is not visible, so we have to add it manually.
         rti.registerRtiDependency(mapLiteralClass, cls);
       } else if (cls == boundClosureClass) {
         // TODO(johnniwinther): Is this a noop?
         enqueueClass(enqueuer, boundClosureClass, registry);
       } else if (Elements.isNativeOrExtendsNative(cls)) {
         enqueue(enqueuer, getNativeInterceptorMethod, registry);
         enqueueClass(enqueuer, jsInterceptorClass, compiler.globalDependencies);
         enqueueClass(enqueuer, jsPlainJavaScriptObjectClass, registry);
+        enqueueClass(enqueuer, jsJavaScriptFunctionClass, registry);
       } else if (cls == mapLiteralClass) {
         // For map literals, the dependency between the implementation class
         // and [Map] is not visible, so we have to add it manually.
         Element getFactory(String name, int arity) {
           // The constructor is on the patch class, but dart2js unit tests don't
           // have a patch class.
           ClassElement implementation = cls.patch != null ? cls.patch : cls;
           ConstructorElement ctor = implementation.lookupConstructor(name);
           if (ctor == null
               || (Name.isPrivateName(name)
@@ skipping 60 matching lines @@
       addInterceptors(jsIntClass, enqueuer, registry);
       addInterceptors(jsPositiveIntClass, enqueuer, registry);
       addInterceptors(jsUInt32Class, enqueuer, registry);
       addInterceptors(jsUInt31Class, enqueuer, registry);
       addInterceptors(jsDoubleClass, enqueuer, registry);
       addInterceptors(jsNumberClass, enqueuer, registry);
     } else if (cls == jsPlainJavaScriptObjectClass) {
       addInterceptors(jsPlainJavaScriptObjectClass, enqueuer, registry);
     } else if (cls == jsUnknownJavaScriptObjectClass) {
       addInterceptors(jsUnknownJavaScriptObjectClass, enqueuer, registry);
+    } else if (cls == jsJavaScriptFunctionClass) {
+      addInterceptors(jsJavaScriptFunctionClass, enqueuer, registry);
     } else if (Elements.isNativeOrExtendsNative(cls)) {
       addInterceptorsForNativeClassMembers(cls, enqueuer);
     } else if (cls == jsIndexingBehaviorInterface) {
       // These two helpers are used by the emitter and the codegen.
       // Because we cannot enqueue elements at the time of emission,
       // we make sure they are always generated.
       enqueue(enqueuer, findHelper('isJsIndexable'), registry);
     }
 
     customElementsAnalysis.registerInstantiatedClass(cls, enqueuer);
   }
 
   void registerUseInterceptor(Enqueuer enqueuer) {
     assert(!enqueuer.isResolutionQueue);
     if (!enqueuer.nativeEnqueuer.hasInstantiatedNativeClasses()) return;
     Registry registry = compiler.globalDependencies;
     enqueue(enqueuer, getNativeInterceptorMethod, registry);
     enqueueClass(enqueuer, jsPlainJavaScriptObjectClass, registry);
+    enqueueClass(enqueuer, jsJavaScriptFunctionClass, registry);
     needToInitializeIsolateAffinityTag = true;
     needToInitializeDispatchProperty = true;
   }
 
   JavaScriptItemCompilationContext createItemCompilationContext() {
     return new JavaScriptItemCompilationContext();
   }
 
   void enqueueHelpers(ResolutionEnqueuer world, Registry registry) {
     assert(interceptorsLibrary != null);
@@ skipping 310 matching lines @@
 
   native.NativeEnqueuer nativeResolutionEnqueuer(Enqueuer world) {
     return new native.NativeResolutionEnqueuer(world, compiler);
   }
 
   native.NativeEnqueuer nativeCodegenEnqueuer(Enqueuer world) {
     return new native.NativeCodegenEnqueuer(world, compiler, emitter);
   }
 
   ClassElement defaultSuperclass(ClassElement element) {
+    if (element.isJsInterop) return jsPlainJavaScriptObjectClass;

[sra1, 2015/10/01 20:55:28]

jsJavaScriptObjectClass

[Jacob, 2015/10/02 20:08:15]

Done.

     // Native classes inherit from Interceptor.
     return element.isNative ? jsInterceptorClass : compiler.objectClass;
   }
 
   /**
    * Unit test hook that returns code of an element as a String.
    *
    * Invariant: [element] must be a declaration element.
    */
   String assembleCode(Element element) {
@@ skipping 612 matching lines @@
         jsUInt31Class = findClass('JSUInt31');
         jsDoubleClass = findClass('JSDouble');
         jsNumberClass = findClass('JSNumber');
         jsNullClass = findClass('JSNull');
         jsBoolClass = findClass('JSBool');
         jsMutableArrayClass = findClass('JSMutableArray');
         jsFixedArrayClass = findClass('JSFixedArray');
         jsExtendableArrayClass = findClass('JSExtendableArray');
         jsUnmodifiableArrayClass = findClass('JSUnmodifiableArray');
         jsPlainJavaScriptObjectClass = findClass('PlainJavaScriptObject');
+        jsJavaScriptFunctionClass = findClass('JavaScriptFunction');
         jsUnknownJavaScriptObjectClass = findClass('UnknownJavaScriptObject');
         jsIndexableClass = findClass('JSIndexable');
         jsMutableIndexableClass = findClass('JSMutableIndexable');
       } else if (uri == DART_JS_HELPER) {
         initializeHelperClasses();
         assertMethod = findHelper('assertHelper');
 
         typeLiteralClass = findClass('TypeImpl');
         constMapLiteralClass = findClass('ConstantMap');
         typeVariableClass = findClass('TypeVariable');
@@ skipping 14 matching lines @@
         preserveMetadataMarker = find(library, 'preserveMetadata');
         preserveUrisMarker = find(library, 'preserveUris');
         preserveLibraryNamesMarker = find(library, 'preserveLibraryNames');
       } else if (uri == DART_JS_NAMES) {
         preserveNamesMarker = find(library, 'preserveNames');
       } else if (uri == DART_EMBEDDED_NAMES) {
         jsGetNameEnum = find(library, 'JsGetName');
         jsBuiltinEnum = find(library, 'JsBuiltin');
       } else if (uri == Uris.dart_html) {
         htmlLibraryIsLoaded = true;
+      } else if (uri == PACKAGE_JS) {
+        jsAnnotationClass = find(library, 'Js');
       }
       annotations.onLibraryScanned(library);
     });
   }
 
   Future onLibrariesLoaded(LoadedLibraries loadedLibraries) {
     if (!loadedLibraries.containsLibrary(Uris.dart_core)) {
       return new Future.value();
     }
 
@@ skipping 952 matching lines @@
   }
 }
 
 /// Records that [constant] is used by the element behind [registry].
 class Dependency {
   final ConstantValue constant;
   final Element annotatedElement;
 
   const Dependency(this.constant, this.annotatedElement);
 }