Some cleanups to Frog to avoid looking up its builtin types too much

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;
   Member method;
 
   String name;
@@ skipping 40 matching lines @@
   genValue(MethodMember method, MethodGenerator context) {
     if (definition.value == null || value != null) return;
 
     if (context == null) { // interface method
       context = new MethodGenerator(method, null);
     }
     value = definition.value.visit(context);
     if (!value.isConst) {
       world.error('default parameter values must be constant', value.span);
     }
-    value = value.convertTo(context, type, definition.value);
+    value = value.convertTo(context, type);
   }
 
   Parameter copyWithNewType(Member newMethod, Type newType) {
     var ret = new Parameter(definition, newMethod);
     ret.type = newType;
     ret.name = name;
     ret.isInitializer = isInitializer;
     return ret;
   }
 
@@ skipping 330 matching lines @@
       declaringType.markUsed();
 
       // 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) {
-        if (declaringType.library == world.dom) {
+        if (declaringType.library.isDom) {
+          // TODO(jmesserly): this check doesn't look right.
           return new Value(type, '$jsname', node.span);
         } else {
           return new Value(type, '\$globals.$jsname', node.span);
         }
       } else if (declaringType.isNative) {
         if (declaringType.isHiddenNativeType) {
           // TODO: Could warn at parse time.
           world.error('static field of hidden native type is inaccessible',
               node.span);
         }
@@ skipping 10 matching lines @@
       } else if (constTarget.type == world.stringType && name == 'length') {
         return new Value(type, '${constTarget.actualValue.length}', node.span);
       }
     }
     return new Value(type, '${target.code}.$jsname', node.span);
   }
 
   Value _set(MethodGenerator context, Node node, Value target, Value value,
       [bool isDynamic=false]) {
     var lhs = _get(context, node, target, isDynamic);
-    value = value.convertTo(context, type, node, isDynamic);
+    value = value.convertTo(context, type, isDynamic);
     return new Value(type, '${lhs.code} = ${value.code}', node.span);
   }
 }
 
 class PropertyMember extends Member {
   MethodMember getter;
   MethodMember setter;
 
   Member _overriddenField;
 
@@ skipping 480 matching lines @@
       argsCode.add('this');
     }
 
     int bareCount = args.bareCount;
     for (int i = 0; i < bareCount; i++) {
       var arg = args.values[i];
       if (i >= parameters.length) {
         var msg = _argCountMsg(args.length, parameters.length);
         return _argError(context, node, target, args, msg, i);
       }
-      arg = arg.convertTo(context, parameters[i].type, node, isDynamic);
+      arg = arg.convertTo(context, parameters[i].type, isDynamic);
       if (isConst && arg.isConst) {
         argsCode.add(arg.canonicalCode);
       } else {
         argsCode.add(arg.code);
       }
     }
 
     int namedArgsUsed = 0;
     if (bareCount < parameters.length) {
       genParameterValues();
 
       for (int i = bareCount; i < parameters.length; i++) {
         var arg = args.getValue(parameters[i].name);
         if (arg == null) {
           arg = parameters[i].value;
         } else {
-          arg = arg.convertTo(context, parameters[i].type, node, isDynamic);
+          arg = arg.convertTo(context, parameters[i].type, isDynamic);
           namedArgsUsed++;
         }
 
         if (arg == null || !parameters[i].isOptional) {
           var msg = _argCountMsg(Math.min(i, args.length), i + 1, atLeast:true);
           return _argError(context, node, target, args, msg, i);
         } else {
           argsCode.add(isConst && arg.isConst
               ? arg.canonicalCode : arg.code);
         }
@@ skipping 69 matching lines @@
           code = '${target.dynamic.values.length}';
         }
       } else if (name == 'isEmpty') {
         if (target is ConstListValue || target is ConstMapValue) {
           code = '${target.dynamic.values.isEmpty()}';
         }
       }
     }
 
     // TODO(jmesserly): factor this better
-    if (name == 'get:typeName' && declaringType.library == world.dom) {
+    if (name == 'get:typeName' && declaringType.library.isDom) {
       world.gen.corejs.ensureTypeNameOf();
     }
 
     return new Value(inferredResult, code, node.span);
   }
 
   Value _invokeConstructor(MethodGenerator context, Node node,
       Value target, Arguments args, argsString) {
     declaringType.markUsed();
 
+    String ctor = constructorName;
+    if (ctor != '') ctor = '.${ctor}\$ctor';
+
     if (!target.isType) {
       // initializer call to another constructor
-      var code = (constructorName != '')
-          ? '${declaringType.jsname}.${constructorName}\$ctor.call($argsString)'
-          : '${declaringType.jsname}.call($argsString)';
+      var code = '${declaringType.nativeName}${ctor}.call($argsString)';
       return new Value(target.type, code, node.span);
     } else {
-      // If a hidden native class has a direct (non-factory) constructor, use
-      // the native name.  This will work if the name is available in the
-      // execution environment, and will fail at run-time if the name is really
-      // hidden.  This lets the generated code run on some browsers before the
-      // browser compat issue is finalized.
-      var typeName = declaringType.isNative
-          ? declaringType.nativeType.name
-          : declaringType.jsname;
-      var code = (constructorName != '')
-          ? 'new ${typeName}.${constructorName}\$ctor($argsString)'
-          : 'new ${typeName}($argsString)';
+
+      var code = 'new ${declaringType.nativeName}${ctor}($argsString)';
+
       // TODO(jmesserly): using the "node" here feels really hacky

[Jennifer Messerly, 2012/01/06 21:36:29]

one cleanup I'd like to do:

if we're in visitNewExpression and we get back the constructor, don't just call
"invoke" on the MethodMember. Instead call invokeConstructor (which should be
called "construct") directly, and add a parameter to it saying whether its a
"const" or "new". 

Most of the reasons that "node" gets passed around instead of "span" is because
of this problem.

[jimhug, 2012/01/11 19:09:53]

Yes!
On 2012/01/06 21:36:29, John Messerly wrote:

       if (isConst && node is NewExpression && node.dynamic.isConst) {
         return _invokeConstConstructor(node, code, target, args);
       } else {
-        return new Value(target.type, code, node.span);
+        final span = node != null ? node.span : target.span;
+        return new Value(target.type, code, span);
       }
     }
   }
 
   /**
    * Special handling for const constructors so that so that:
    * [: const B() === const B.a(0, 1) === const B.b(0) :]
    * where: [:
    *   class A {
    *     final int x;
@@ skipping 687 matching lines @@
   }
 
   void forEach(void f(Member member)) {
     factories.forEach((_, Map constructors) {
       constructors.forEach((_, Member member) {
         f(member);
       });
     });
   }
 }