first stage of Value cleanups

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 122 matching lines @@
 
   Definition get initDelegate() =>
       world.internalError('cannot have initializers', span);
   Definition set initDelegate(ctor) =>
       world.internalError('cannot have initializers', span);
 
   Definition get definition() => null;
 
   List<Parameter> get parameters() => [];
 
-  // TODO(jimhug): Fix these names once get/set are truly pseudo-keywords.
   // TODO(jmesserly): isDynamic isn't a great name for this, something better?
-  abstract Value get_(MethodGenerator context, Node node, Value target,
+  abstract Value _get(MethodGenerator context, Node node, Value target,
       [bool isDynamic]);
 
-  abstract Value set_(MethodGenerator context, Node node, Value target,
+  abstract Value _set(MethodGenerator context, Node node, Value target,
       Value value, [bool isDynamic]);
 
   bool canInvoke(MethodGenerator context, Arguments args) {
-    return canGet && new Value(returnType, null).canInvoke(context, '\$call', args);
+    // TODO(jimhug): Needs better source location?

[Jennifer Messerly, 2011/11/10 22:50:39]

I would hope that "canInvoke" can't emit errors.

+    return canGet &&
+      new Value(returnType, null, null).canInvoke(context, '\$call', args);
   }
 
   Value invoke(MethodGenerator context, Node node, Value target, Arguments args,
       [bool isDynamic=false]) {
-    var newTarget = get_(context, node, target, isDynamic);
+    var newTarget = _get(context, node, target, isDynamic);
     return newTarget.invoke(context, '\$call', node, args, isDynamic);
   }
 
   bool override(Member other) {
     if (isStatic) {
       world.error('static members can not hide parent members',
         span, other.span);
       return false;
     } else if (other.isStatic) {
       world.error('can not override static member', span, other.span);
@@ skipping 42 matching lines @@
 
   // If this really becomes first class, this should return typeof(Type)
   Type get returnType() => world.varType;
 
   bool canInvoke(MethodGenerator context, Arguments args) => false;
   bool get canGet() => true;
   bool get canSet() => false;
 
   void resolve(Type inType) {}
 
-  Value get_(MethodGenerator context, Node node, Value target,
+  Value _get(MethodGenerator context, Node node, Value target,
       [bool isDynamic=false]) {
-    assert(target == null || target.type.isTop);
     // TODO(jmesserly): named args

[Jennifer Messerly, 2011/11/10 22:50:39]

btw, I think the VM is the main blocker here. Maybe we just need to make them
not use "this." for now so we can fix all the callsites.

-    return new Value(type, type.jsname, false, false, true);
+    return new Value(type, type.jsname, node.span, false, false, true);
   }
 
-  Value set_(MethodGenerator context, Node node, Value target, Value value,
+  Value _set(MethodGenerator context, Node node, Value target, Value value,
       [bool isDynamic=false]) {
     world.error('can not set type', type.definition.span);
   }
 
   Value invoke(MethodGenerator context, Node node, Value target, Arguments args,
       [bool isDynamic=false]) {
     world.error('can not invoke type', type.definition.span);
   }
 }
 
@@ skipping 122 matching lines @@
 
       if (isStatic) {
         _computedValue = world.gen.globalForStaticField(
             this, _computedValue, [_computedValue]);
       }
       _computing = false;
     }
     return _computedValue;
   }
 
-  Value get_(MethodGenerator context, Node node, Value target,
+  Value _get(MethodGenerator context, Node node, Value target,
       [bool isDynamic=false]) {
     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;
       }
       if (declaringType.isTop) {
-        return new Value(type, '$jsname');
+        return new Value(type, '$jsname', node.span);
       } else {
-        return new Value(type, '${declaringType.jsname}.$jsname');
+        return new Value(type, '${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}');
+        return new Value(type, '${constTarget.actualValue.length}', node.span);
       }
     }
-    return new Value(type, '${target.code}.$jsname');
+    return new Value(type, '${target.code}.$jsname', node.span);
   }
 
-  Value set_(MethodGenerator context, Node node, Value target, Value value,
+  Value _set(MethodGenerator context, Node node, Value target, Value value,
       [bool isDynamic=false]) {
-    var lhs = get_(context, node, target, isDynamic);
+    var lhs = _get(context, node, target, isDynamic);
     value = value.convertTo(context, type, node, isDynamic);
-    return new Value(type, '${lhs.code} = ${value.code}');
+    return new Value(type, '${lhs.code} = ${value.code}', node.span);
   }
 }
 
 class PropertyMember extends Member {
   MethodMember getter;
   MethodMember setter;
 
   Member _overriddenField;
 
   bool _provideFieldSyntax = false;
@@ skipping 31 matching lines @@
       if (other.isProperty) addFromParent(other);
       else _overriddenField = other;
       return true;
     } else {
       world.error('property can only override field or property',
         span, other.span);
       return false;
     }
   }
 
-  Value get_(MethodGenerator context, Node node, Value target,
+  Value _get(MethodGenerator context, Node node, Value target,
       [bool isDynamic=false]) {
     if (getter == null) {
       if (_overriddenField != null) {
-        return _overriddenField.get_(context, node, target, isDynamic);
+        return _overriddenField._get(context, node, target, isDynamic);
       }
       return target.invokeNoSuchMethod(context, 'get:$name', node);
     }
     return getter.invoke(context, node, target, Arguments.EMPTY);
   }
 
-  Value set_(MethodGenerator context, Node node, Value target, Value value,
+  Value _set(MethodGenerator context, Node node, Value target, Value value,
       [bool isDynamic=false]) {
     if (setter == null) {
       if (_overriddenField != null) {
-        return _overriddenField.set_(context, node, target, value, isDynamic);
+        return _overriddenField._set(context, node, target, value, isDynamic);
       }
       return target.invokeNoSuchMethod(context, 'set:$name', node,
         new Arguments(null, [value]));
     }
     return setter.invoke(context, node, target, new Arguments(null, [value]),
       isDynamic);
   }
 
   addFromParent(Member parentMember) {
     // TODO(jimhug): Egregious Hack!
@@ skipping 76 matching lines @@
   Definition set initDelegate(ctor) { baseMember.initDelegate = ctor; }
 
   Type resolveType(TypeReference node, bool isRequired) {
     var type = baseMember.resolveType(node, isRequired);
     return type.resolveTypeParams(declaringType);
   }
 
   // TODO(jimhug): Add support for type params.
   bool override(Member other) => baseMember.override(other);
 
-  Value get_(MethodGenerator context, Node node, Value target,
+  Value _get(MethodGenerator context, Node node, Value target,
       [bool isDynamic=false]) {
-    Value ret = baseMember.get_(context, node, target, isDynamic);
-    return new Value(returnType, ret.code);
+    Value ret = baseMember._get(context, node, target, isDynamic);
+    return new Value(returnType, ret.code, node.span);
   }
 
-  Value set_(MethodGenerator context, Node node, Value target, Value value,
+  Value _set(MethodGenerator context, Node node, Value target, Value value,
       [bool isDynamic=false]) {
     // TODO(jimhug): Check arg types in context of concrete type.
-    Value ret = baseMember.set_(context, node, target, value, isDynamic);
-    return new Value(returnType, ret.code);
+    Value ret = baseMember._set(context, node, target, value, isDynamic);
+    return new Value(returnType, ret.code, node.span);
   }
 
   Value invoke(MethodGenerator context, Node node, Value target, Arguments args,
       [bool isDynamic=false]) {
     // TODO(jimhug): Check arg types in context of concrete type.
     Value ret = baseMember.invoke(context, node, target, args, isDynamic);
     var code = ret.code;
     if (isConstructor) {
       // TODO(jimhug): Egregious hack - won't live through the weekend.
       code = code.replaceFirst(
           declaringType.genericType.jsname, declaringType.jsname);
     }
     declaringType.genMethod(this);
-    return new Value(returnType, code);
+    return new Value(returnType, code, node.span);
   }
 }
 
 
 /** Represents a Dart method or top-level function. */
 class MethodMember extends Member {
   FunctionDefinition definition;
   Type returnType;
   List<Parameter> parameters;
 
@@ skipping 108 matching lines @@
     }
     return -1;
   }
 
   bool get prefersPropertySyntax() => true;
   bool get requiresFieldSyntax() => false;
 
   void provideFieldSyntax() => _provideFieldSyntax = true;
   void providePropertySyntax() => _providePropertySyntax = true;
 
-  Value set_(MethodGenerator context, Node, Value target, Value value,
+  Value _set(MethodGenerator context, Node, Value target, Value value,
       [bool isDynamic=false]) {
     world.error('can not set method', definition.span);
   }
 
-  Value get_(MethodGenerator context, Node node, Value target,
+  Value _get(MethodGenerator context, Node node, Value target,
       [bool isDynamic=false]) {
     // TODO(jimhug): Would prefer to invoke!
     declaringType.genMethod(this);
     _provideOptionalParamInfo = true;
     if (isStatic) {
       var type = declaringType.isTop ? '' : '${declaringType.jsname}.';
-      return new Value(functionType, '$type$jsname');
+      return new Value(functionType, '$type$jsname', node.span);
     }
     _providePropertySyntax = true;
-    return new Value(functionType, '${target.code}.get\$$jsname()');
+    return new Value(functionType, '${target.code}.get\$$jsname()', node.span);
   }
 
   bool namesInOrder(Arguments args) {
     if (!args.hasNames) return true;
 
     int lastParameter = null;
     for (int i = args.bareCount; i < parameters.length; i++) {
       var p = args.getIndexOfName(parameters[i].name);
       // Only worry about parameters that needTemps. Otherwise it's fine to
       // reorder.
@@ skipping 148 matching lines @@
 
     var argsString = Strings.join(argsCode, ', ');
 
     if (isConstructor) {
       return _invokeConstructor(context, node, target, args, argsString);
     }
 
     // TODO(jimhug): target really shouldn't ever be null...
     if (target != null && target.isSuper) {
       return new Value(returnType,
-          '${declaringType.jsname}.prototype.$jsname.call($argsString)');
+          '${declaringType.jsname}.prototype.$jsname.call($argsString)',
+          node.span);
     }
 
     if (name.startsWith('\$')) {
       return _invokeBuiltin(context, node, target, args, argsCode);
     }
 
     if (isFactory) {
-      return new Value(returnType, '$generatedFactoryName($argsString)');
+      return new Value(returnType, '$generatedFactoryName($argsString)',
+        node.span);
     }
 
     if (isStatic) {
       if (declaringType.isTop) {
         // TODO(jimhug): Explore moving libraries into their own namespaces
-        return new Value(returnType, '$jsname($argsString)');
+        return new Value(returnType, '$jsname($argsString)', node != null ? node.span : node);
       }
       return new Value(returnType,
-        '${declaringType.jsname}.$jsname($argsString)');
+        '${declaringType.jsname}.$jsname($argsString)', node.span);
     }
 
     var code = '${target.code}.$jsname($argsString)';
     // optimize expressions which we know statically their value.
     if (target.isConst) {
       if (target is GlobalValue) {
         target = target.dynamic.exp; // TODO: an inline "cast" would be nice.
       }
       if (name == 'get\$length') {
         if (target is ConstListValue || target is ConstMapValue) {
           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) {
       world.gen.corejs.useTypeNameOf = true;
     }
 
-    return new Value(returnType, code);
+    return new Value(returnType, code, node.span);
   }
 
   Value _invokeConstructor(MethodGenerator context, Node node,
       Value target, Arguments args, argsString) {
     declaringType.markUsed();
 
     if (target != null) {
       // initializer call to another constructor
       var code = (constructorName != '')
           ? '${declaringType.jsname}.${constructorName}\$ctor.call($argsString)'
           : '${declaringType.jsname}.call($argsString)';
-      return new Value(declaringType, code);
+      return new Value(declaringType, code, node.span);
     } else {
       var code = (constructorName != '')
           ? 'new ${declaringType.jsname}.${constructorName}\$ctor($argsString)'
           : 'new ${declaringType.jsname}($argsString)';
       // TODO(jmesserly): using the "node" here feels really hacky
       if (isConst && node is NewExpression && node.dynamic.isConst) {
         return _invokeConstConstructor(node, code, target, args);
       } else {
-        return new Value(declaringType, code);
+        return new Value(declaringType, code, node.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 109 matching lines @@
         } else if (name == '\$bit_not') {
           code = '~${target.code}';
         } else if (name == '\$truncdiv' || name == '\$mod') {
           world.gen.corejs.useOperator(name);
           code = '$name(${target.code}, ${argsCode[0]})';
         } else {
           var op = TokenKind.rawOperatorFromMethod(name);
           code = '${target.code} $op ${argsCode[0]}';
         }
 
-        return new Value(returnType, code);
+        return new Value(returnType, code, node.span);
       } else {
         var value;
         num val0, val1, ival0, ival1;
         val0 = target.dynamic.actualValue;
         ival0 = val0.toInt();
         if (args.values.length > 0) {
           val1 = args.values[0].dynamic.actualValue;
           ival1 = val1.toInt();
         }
         switch (name) {
@@ skipping 19 matching lines @@
           case '\$shl': value = (ival0 << ival1).toDouble(); break;
           case '\$sar': value = (ival0 >> ival1).toDouble(); break;
           case '\$shr': value = (ival0 >>> ival1).toDouble(); break;
         }
         return new EvaluatedValue(returnType, value, "$value", node.span);
       }
     } else if (declaringType.isString) {
       if (name == '\$index') {
         // Note: this could technically propagate constness, but that's not
         // specified explicitly and the VM doesn't do that.
-        return new Value(declaringType, '${target.code}[${argsCode[0]}]');
+        return new Value(declaringType, '${target.code}[${argsCode[0]}]',
+          node.span);
       } else if (name == '\$add') {
         if (allConst) {
           var val0 = target.dynamic.actualValue;
           val0 = val0.substring(1, val0.length - 1);
           var val1 = args.values[0].dynamic.actualValue;
           if (args.values[0].type.isString) {
             val1 = val1.substring(1, val1.length - 1);
           }
           var value = '${val0}${val1}';
           value = '"' + value.replaceAll('"', '\\"') + '"';
           return new EvaluatedValue(world.stringType, value, value, node.span);
         }
 
         // Ensure we generate toString on the right side
         args.values[0].invoke(context, 'toString', node, Arguments.EMPTY);
-        return new Value(declaringType, '${target.code} + ${argsCode[0]}');
+        return new Value(declaringType, '${target.code} + ${argsCode[0]}',
+          node.span);
       }
     } else if (declaringType.isNativeType) {
       if (name == '\$index') {
         // Note: this could technically propagate constness, but that's not
         // specified explicitly and the VM doesn't do that.
         // TODO(jmesserly): why are we using a return type of "var"?
-        return new Value(null, '${target.code}[${argsCode[0]}]');
+        return new Value(null, '${target.code}[${argsCode[0]}]', node.span);
       } else if (name == '\$setindex') {
         return new Value(null,
-          '${target.code}[${argsCode[0]}] = ${argsCode[1]}');
+          '${target.code}[${argsCode[0]}] = ${argsCode[1]}', node.span);
       }
     }
 
     // TODO(jimhug): Optimize null on lhs as well.
     if (name == '\$eq' || name == '\$ne') {
       final op = name == '\$eq' ? '==' : '!=';
       if (allConst) {
         var val0 = target.dynamic.actualValue;
         var val1 = args.values[0].dynamic.actualValue;
         var newVal = name == '\$eq' ? val0 == val1 : val0 != val1;
         return new EvaluatedValue(world.boolType,
             newVal, "$newVal", node.span);
       }
       // Optimize test when null is on the rhs.
       if (argsCode[0] == 'null') {
-        return new Value(returnType, '${target.code} $op null');
+        return new Value(returnType, '${target.code} $op null', node.span);
       } else if (target.type.isNum || target.type.isString) {
         // TODO(jimhug): Maybe check rhs.
-        return new Value(returnType, '${target.code} $op ${argsCode[0]}');
+        return new Value(returnType, '${target.code} $op ${argsCode[0]}',
+          node.span);
       }
       world.gen.corejs.useOperator(name);
-      return new Value(returnType, '$name(${target.code}, ${argsCode[0]})');
+      return new Value(returnType, '$name(${target.code}, ${argsCode[0]})',
+        node.span);
     }
 
     if (name == '\$call') {
       declaringType.markUsed();
       return new Value(returnType,
-        '${target.code}(${Strings.join(argsCode, ", ")})');
+        '${target.code}(${Strings.join(argsCode, ", ")})', node.span);
     }
 
     if (name == '\$index') {
       world.gen.corejs.useIndex = true;
     } else if (name == '\$setindex') {
       world.gen.corejs.useSetIndex = true;
     }
 
     // Fall back to normal method invocation.
     var argsString = Strings.join(argsCode, ', ');
-    return new Value(returnType, '${target.code}.$jsname($argsString)');
+    return new Value(returnType, '${target.code}.$jsname($argsString)',
+      node.span);
   }
 
 
   resolve(Type inType) {
     // TODO(jimhug): cut-and-paste-and-edit from Field.resolve
     isStatic = inType.isTop;
     isConst = false;
     isFactory = false;
     isAbstract = !declaringType.isClass;
     if (definition.modifiers != null) {
@@ skipping 100 matching lines @@
   // TODO(jimhug): Always false, or is this needed?
   bool get isStatic() => members.length == 1 && members[0].isStatic;
 
   bool canInvoke(MethodGenerator context, Arguments args) =>
     members.some((m) => m.canInvoke(context, args));
 
   Value _makeError(Node node, Value target, String action) {
     if (!target.type.isVar) {
       world.warning('could not find applicable $action for "$name"', node.span);
     }
-    return new Value(null, '${target.code}.$jsname() /*no applicable $action*/');
+    return new Value(null, '${target.code}.$jsname() /*no applicable $action*/',
+      node.span);
   }
 
   bool _treatAsField;
   bool get treatAsField() {
     if (_treatAsField == null) {
       _treatAsField = true;
       for (var member in members) {
         if (member.requiresFieldSyntax) {
           _treatAsField = true;
           break;
         }
         if (member.prefersPropertySyntax) {
           _treatAsField = false;
         }
       }
       for (var member in members) {
         if (_treatAsField) {
           member.provideFieldSyntax();
         } else {
           member.providePropertySyntax();
         }
       }
     }
     return _treatAsField;
   }
 
-  Value get_(MethodGenerator context, Node node, Value target,
+  Value _get(MethodGenerator context, Node node, Value target,
       [bool isDynamic=false]) {
     if (members.length == 1) {
-      return members[0].get_(context, node, target, isDynamic);
+      return members[0]._get(context, node, target, isDynamic);
     }
     final targets = members.filter((m) => m.canGet);
     if (targets.length == 1) {
-      return targets[0].get_(context, node, target, isDynamic);
+      return targets[0]._get(context, node, target, isDynamic);
     }
 
     Value returnValue = null;
     for (var member in targets) {
-      final value = member.get_(context, node, target, isDynamic:true);
+      final value = member._get(context, node, target, isDynamic:true);
       returnValue = _tryUnion(returnValue, value, node);
     }
     if (returnValue == null) {
       return _makeError(node, target, 'getter');
     }
     if (returnValue.code == null) {
       if (treatAsField) {
-        return new Value(returnValue.type, '${target.code}.$jsname');
+        return new Value(returnValue.type, '${target.code}.$jsname',
+          node.span);
       } else {
-        return new Value(returnValue.type, '${target.code}.get\$$jsname()');
+        return new Value(returnValue.type, '${target.code}.get\$$jsname()',
+          node.span);
       }
     }
     return returnValue;
   }
 
-  Value set_(MethodGenerator context, Node node, Value target, Value value,
+  Value _set(MethodGenerator context, Node node, Value target, Value value,
       [bool isDynamic=false]) {
     if (members.length == 1) {
-      return members[0].set_(context, node, target, value, isDynamic);
+      return members[0]._set(context, node, target, value, isDynamic);
     }
     final targets = members.filter((m) => m.canSet);
     if (targets.length == 1) {
-      return targets[0].set_(context, node, target, value, isDynamic);
+      return targets[0]._set(context, node, target, value, isDynamic);
     }
 
     Value returnValue = null;
     for (var member in targets) {
-      final res = member.set_(context, node, target, value, isDynamic:true);
+      final res = member._set(context, node, target, value, isDynamic:true);
       returnValue = _tryUnion(returnValue, res, node);
     }
     if (returnValue == null) {
       return _makeError(node, target, 'setter');
     }
     if (returnValue.code == null) {
       if (treatAsField) {
         return new Value(returnValue.type,
-          '${target.code}.$jsname = ${value.code}');
+          '${target.code}.$jsname = ${value.code}', node.span);
       } else {
         return new Value(returnValue.type,
-          '${target.code}.set\$$jsname(${value.code})');
+          '${target.code}.set\$$jsname(${value.code})', node.span);
       }
     }
     return returnValue;
   }
 
   Value invoke(MethodGenerator context, Node node, Value target,
       Arguments args, [bool isDynamic=false]) {
     if (members.length == 1) {
       return members[0].invoke(context, node, target, args, isDynamic);
     }
@@ skipping 40 matching lines @@
 
   Value _tryUnion(Value x, Value y, Node node) {
     if (x == null) return y;
     var type = Type.union(x.type, y.type);
     if (x.code == y.code) {
       if (type == x.type) {
         return x;
       } else if (x.isConst || y.isConst) {
         world.internalError("unexpected: union of const values ");
       } else {
-        return new Value(type, x.code,
+        return new Value(type, x.code, node.span,
             x.isSuper && y.isSuper,
             x.needsTemp || y.needsTemp,
             x.isType && y.isType);
       }
     } else {
-      return new Value(type, null);
+      return new Value(type, null, node.span);
     }
   }
 
   dumpAllMembers() {
     for (var member in members) {
       world.warning('hard-multi $name on ${member.declaringType.name}',
         member.span);
     }
   }
 
@@ skipping 81 matching lines @@
   }
 
   void forEach(void f(Member member)) {
     factories.forEach((_, Map constructors) {
       constructors.forEach((_, Member member) {
         f(member);
       });
     });
   }
 }