Support globals in frog isolates.

frog/member.dart

 // Copyright (c) 2011, 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.
 
 /** A formal parameter to a [Method]. */
 class Parameter {
   FormalNode definition;
 
   String name;
   Type type;
@@ skipping 384 matching lines @@
     if (!isDynamic) {
       declaringType.markUsed();
     }
     if (isStatic) {
       // Make sure to compute the value of all static fields, even if we don't
       // use this value immediately.
       var cv = computeValue();
       if (isFinal) {
         return cv;
       }
+      world.gen.hasStatics = true;
       if (declaringType.isTop) {
-        return new Value(type, '$jsname', node.span);
+        if (declaringType.library == world.dom) {

[Siggi Cherem (dart-lang), 2011/11/18 01:28:10]

I don't like all these subtle cases (here/below), let me know if you think of
something more general here. 

Basically we don't want to move natives into $globals, in the case of the DOM
this is not marked as a native field, maybe it should be?

[Jennifer Messerly, 2011/11/18 01:46:39]

yes, if it can be solved by marking native--that would be ideal.

I think the issue is that there's no way to put "native" on top level variables.
:\

[Siggi Cherem (dart-lang), 2011/11/18 18:33:17]

yeah :(

+          return new Value(type, '$jsname', node.span);
+        } else {
+          return new Value(type, '\$globals.$jsname', node.span);
+        }
+      } else if (declaringType.isNative) {
+        return new Value(type, '${declaringType.jsname}.$jsname', node.span);
       } else {
-        return new Value(type, '${declaringType.jsname}.$jsname', node.span);
+        return new Value(type,
+            '\$globals.${declaringType.jsname}_$jsname', node.span);
       }
     } else if (target.isConst && isFinal) {
       // take advantage of consts and retrieve the value directly if possible
       var constTarget = target is GlobalValue ? target.dynamic.exp : target;
       if (constTarget is ConstObjectValue) {
         return constTarget.fields[name];
       } else if (constTarget.type == world.stringType && name == 'length') {
         return new Value(type, '${constTarget.actualValue.length}', node.span);
       }
     }
@@ skipping 327 matching lines @@
       [bool isDynamic=false]) {
     world.error('can not set method', definition.span);
   }
 
   Value _get(MethodGenerator context, Node node, Value target,
       [bool isDynamic=false]) {
     // TODO(jimhug): Would prefer to invoke!
     declaringType.genMethod(this);
     _provideOptionalParamInfo = true;
     if (isStatic) {
+      // ensure the type is generated:
+      declaringType.markUsed();

[Jennifer Messerly, 2011/11/18 01:46:39]

hmmm, we probably don't want to generate an entire type because one static
method is implicitly closure bound. However, I noticed that "invoke" has the
same issue. Can you add a TODO here and in MethodMember.invoke?

[Siggi Cherem (dart-lang), 2011/11/18 18:33:17]

Sure. Done.

       var type = declaringType.isTop ? '' : '${declaringType.jsname}.';
       return new Value(functionType, '$type$jsname', node.span);
     }
     _providePropertySyntax = true;
     return new Value(functionType, '${target.code}.get\$$jsname()', node.span);
   }
 
   bool namesInOrder(Arguments args) {
     if (!args.hasNames) return true;
 
@@ skipping 858 matching lines @@
   }
 
   void forEach(void f(Member member)) {
     factories.forEach((_, Map constructors) {
       constructors.forEach((_, Member member) {
         f(member);
       });
     });
   }
 }