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) {
+          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.
+      // TODO(sigmund): can we avoid generating the entire type, but only what
+      // we need?
+      declaringType.markUsed();
       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 65 matching lines @@
       Arguments args, [bool isDynamic=false]) {
     // TODO(jimhug): Fix this hack for ensuring a method is resolved.
     if (parameters == null) {
       world.info('surprised to need to resolve: ${declaringType.name}.$name');
       this.resolve(declaringType);
     }
 
     declaringType.genMethod(this);
 
     if (isStatic || isFactory) {
+      // TODO(sigmund): can we avoid generating the entire type, but only what
+      // we need?
       declaringType.markUsed();
     }
 
     if (isNative && returnType != null) returnType.markUsed();
 
     if (!namesInOrder(args)) {
       // Names aren't in order. For now, use a var call because it's an
       // easy way to get the right eval order for out of order arguments.
       return context.findMembers(name).invokeOnVar(context, node, target, args);
     }
@@ skipping 824 matching lines @@
   }
 
   void forEach(void f(Member member)) {
     factories.forEach((_, Map constructors) {
       constructors.forEach((_, Member member) {
         f(member);
       });
     });
   }
 }