- Parse the return type of JS during resolution to know what can be instantiated there.

sdk/lib/_internal/compiler/implementation/native_handler.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.
 
 library native;
 
 import 'dart:uri';
 import 'dart2jslib.dart' hide SourceString;
 import 'elements/elements.dart';
 import 'js_backend/js_backend.dart';
@@ skipping 38 matching lines @@
   /**
    * Handles JS-calls, which can be an instantiation point for types.
    *
    * For example, the following code instantiates and returns native classes
    * that are `_DOMWindowImpl` or a subtype.
    *
    *     JS('_DOMWindowImpl', 'window')
    *
    */
   // TODO(sra): The entry from codegen will not have a resolver.
-  void registerJsCall(Send node, ResolverVisitor resolver) {}
+  void registerJsCall(Send node, Enqueuer enqueuer, ResolverVisitor resolver) {}

[sra1, 2012/11/29 16:45:50]

enqueuer already available in implementations as this.world.

 
   /// Emits a summary information using the [log] function.
   void logSummary(log(message)) {}
 }
 
 
 abstract class NativeEnqueuerBase implements NativeEnqueuer {
 
   /**
    * The set of all native classes.  Each native class is in [nativeClasses] and
@@ skipping 141 matching lines @@
     flushQueue();
   }
 
   void registerFieldStore(Element field) {
     processNativeBehavior(
         NativeBehavior.ofFieldStore(field, compiler),
         field);
     flushQueue();
   }
 
-  void registerJsCall(Send node, ResolverVisitor resolver) {
+  void registerJsCall(Send node, Enqueuer enqueuer, ResolverVisitor resolver) {
     processNativeBehavior(
-        NativeBehavior.ofJsCall(node, compiler, resolver),
+        NativeBehavior.ofJsCall(node, compiler, enqueuer, resolver),
         node);
     flushQueue();
   }
 
   processNativeBehavior(NativeBehavior behavior, cause) {
     bool allUsedBefore = unusedClasses.isEmpty;
     for (var type in behavior.typesInstantiated) {
       if (matchedTypeConstraints.contains(type)) continue;
       matchedTypeConstraints.add(type);
       if (type is SpecialType) {
@@ skipping 160 matching lines @@
   /// [DartType]s or [SpecialType]s returned or yielded by the native element.
   final List typesReturned = [];
 
   /// [DartType]s or [SpecialType]s instantiated by the native element.
   final List typesInstantiated = [];
 
   static final NativeBehavior NONE = new NativeBehavior();
 
   //NativeBehavior();
 
-  static NativeBehavior ofJsCall(Send jsCall, Compiler compiler, resolver) {
+  static NativeBehavior ofJsCall(
+      Send jsCall, Compiler compiler, Enqueuer enqueuer, resolver) {
     // The first argument of a JS-call is a string encoding various attributes
     // of the code.
     //
     //  'Type1|Type2'.  A union type.
     //  '=Object'.      A JavaScript Object, no subtype.
     //  '=List'.        A JavaScript Array, no subtype.

[ahe, 2012/11/29 14:48:43]

This has *nothing* to do with legacy support for native frog code.

[ngeoffray, 2012/11/30 11:30:00]

Yes, as discussed, native_handler got mixed into legacy support, and handling of
the html library. I'll clean that up.

 
     var argNodes = jsCall.arguments;
     if (argNodes.isEmpty) {
       compiler.cancel("JS expression has no type", node: jsCall);
     }
 
     var firstArg = argNodes.head;
     LiteralString specLiteral = firstArg.asLiteralString();
     if (specLiteral != null) {
       String specString = specLiteral.dartString.slowToString();
       // Various things that are not in fact types.
       if (specString == 'void') return NativeBehavior.NONE;
       if (specString == '' || specString == 'var') {
         var behavior = new NativeBehavior();
         behavior.typesReturned.add(compiler.objectClass.computeType(compiler));
         return behavior;
       }
       var behavior = new NativeBehavior();
       for (final typeString in specString.split('|')) {
         var type = _parseType(typeString, compiler,
             (name) => resolver.resolveTypeFromString(name),
             jsCall);
+        if (type == SpecialType.JsArray) {
+          enqueuer.registerInstantiatedClass(compiler.listClass); 

[sra1, 2012/11/29 16:45:50]

NativeBehavior is data.  There should be no side effect of creating a
description of something's native behavior.  We could add more information from
annotations, like side-effects.

The registering should be in processNativeBehavior, so that this annotation on a
native class also does the right thing:

class MessageEvent ... native ... {

    @Creates('=List')  @Returns('=List')
    final List ports;
}

NativeEnqueuerBase already had the main enqueuer as this.world.

[ngeoffray, 2012/11/30 11:30:00]

Done.

+        } else if (type == SpecialType.JsObject) {
+          enqueuer.registerInstantiatedClass(compiler.objectClass); 
+        } else if (type is InterfaceType) {
+          enqueuer.registerInstantiatedClass(type.element); 

[sra1, 2012/11/29 16:45:50]

I assume this is how 'int' gets instantiated.

Is there a way to tell if the type is one of the small number (other than native
classes) with hidden calls to the constructors (int, bool, String, ...)

Does JS('List', ...) to instantiate compiler.listClass through this path?

I'm concerned that this path will lead to instantiating all the native types.

[ngeoffray, 2012/11/30 11:30:00]

Yeah, just unconditionally registering will lead to instantiating all the types.
I've changed the code to manually check for these primitive classes. There is no
easy way right now other than if/else, but we can think of creating a set just
for them.

+        }
         behavior.typesInstantiated.add(type);
         behavior.typesReturned.add(type);
       }
       return behavior;
     }
 
     // TODO(sra): We could accept a type identifier? e.g. JS(bool, '1<2').  It
     // is not very satisfactory because it does not work for void, dynamic.
 
     compiler.cancel("Unexpected JS first argument", node: firstArg);
@@ skipping 402 matching lines @@
                                       String parameters) {
   buffer.add("  if (Object.getPrototypeOf(this).hasOwnProperty");
   buffer.add("('$methodName')) {\n");
   buffer.add("  $code");
   buffer.add("  } else {\n");
   buffer.add("    return Object.prototype.$methodName.call(this");
   buffer.add(parameters == '' ? '' : ', $parameters');
   buffer.add(");\n");
   buffer.add("  }\n");
 }