addressing 3 previous review comments

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 409 matching lines @@
           // TODO: Could warn at parse time.
           world.error('static field of hidden native type is inaccessible',
               node.span);
         }
         return new Value(type, '${declaringType.jsname}.$jsname', node.span);
       } else {
         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);
-      }
-    }*/
     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, isDynamic);
     return new Value(type, '${lhs.code} = ${value.code}', node.span);
   }
 }
@@ skipping 601 matching lines @@
 
     final span = node != null ? node.span : target.span;
     if (!target.isType) {
       // initializer call to another constructor
       var code = '${declaringType.nativeName}${ctor}.call($argsString)';
       return new Value(target.type, code, span);
     } else {
       // Start of abstract interpretation to replace const hacks goes here
       // TODO(jmesserly): using the "node" here feels really hacky
       if (isConst && node is NewExpression && node.dynamic.isConst) {
-        // !!!!!! Egregious hack !!!!!!!
+        // TODO(jimhug): Embedding JSSyntaxRegExp works around an annoying
+        //   issue with tracking native constructors for const objects.
         if (isNative || declaringType.name == 'JSSyntaxRegExp') {
           // check that all args are const?
           var code = 'new ${declaringType.nativeName}${ctor}($argsString)';
           return world.gen.globalForConst(new Value(target.type, code, span),
             [args.values]);
         }
         var newType = declaringType;
         var newObject = new ObjectValue(true, newType, span);
         newObject.initFields();
         _evalConstConstructor(newObject, args);
-        // ??? Does args.values include named args???
         return world.gen.globalForConst(newObject, [args.values]);
       } else {
         var code = 'new ${declaringType.nativeName}${ctor}($argsString)';
         return new Value(target.type, code, span);
       }
     }
   }
 
   _evalConstConstructor(Value newObject, Arguments args) {
     declaringType.markUsed();
@@ skipping 508 matching lines @@
   }
 
   void forEach(void f(Member member)) {
     factories.forEach((_, Map constructors) {
       constructors.forEach((_, Member member) {
         f(member);
       });
     });
   }
 }