cleanup resolveMember and get/set

frog/value.dart

 // Copyright (c) 2012, 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.
 
 
 /**
  * Represents a meta-value for code generation.
  */
 class Value {
   /** The inferred (i.e. most precise) [Type] of the [Value]. */
@@ skipping 29 matching lines @@
    * The statically declared [Type] of the [Value]. This type determines which
    * kind of static type warnings are issued. It's also the type that is used
    * for generating type assertions (i.e. given `Foo x; ...; x = expr;`,
    * expr will be checked against "Foo" regardless of the inferred type of `x`).
    */
   Type get staticType() => type;
 
   /** If [isConst], the [EvaluatedValue] that defines this value. */
   EvaluatedValue get constValue() => null;
 
+  static Value comma(Value x, Value y) {
+    return new Value(y.type, '(${x.code}, ${y.code})', null);
+  }
+
   // TODO(jmesserly): more work is needed to make unifying all kinds of Values
   // work properly.
   static Value union(Value x, Value y) {
     if (y === null || x == y) return x;
     if (x === null) return y;
 
     var ret = x._tryUnion(y);
     if (ret != null) return ret;
 
     // TODO(jmesserly): might want to call a _tryUnionReversed here.
@@ skipping 22 matching lines @@
   Value get_(MethodGenerator context, String name, Node node) {
     final member = _resolveMember(context, name, node);
     if (member != null) {
       return member._get(context, node, this);
     } else {
       return invokeNoSuchMethod(context, 'get:$name', node);
     }
   }
 
   Value set_(MethodGenerator context, String name, Node node, Value value,
-      [bool isDynamic=false]) {
-
+      [bool isDynamic=false, int kind=0, int returnKind=ReturnKind.IGNORE]) {
     final member = _resolveMember(context, name, node, isDynamic);
     if (member != null) {
-      return member._set(context, node, this, value, isDynamic);
+      var thisValue = this;
+      var thisTmp = null;
+      var retTmp = null;
+      if (kind != 0) {
+        // TODO(jimhug): Very special number optimizations will go here...
+        thisTmp = context.getTemp(thisValue);
+        thisValue = context.assignTemp(thisTmp, thisValue);
+        var lhs = member._get(context, node, thisTmp);
+        if (returnKind == ReturnKind.PRE) {
+          retTmp = context.forceTemp(lhs);
+          lhs = context.assignTemp(retTmp, lhs);
+        }
+        value = lhs.binop(kind, value, context, node);
+      }
+
+      if (returnKind == ReturnKind.POST) {
+        // TODO(jimhug): Optimize this away when native JS is detected.
+        retTmp = context.forceTemp(value);
+        value = context.assignTemp(retTmp, value);
+      }
+
+      var ret = member._set(context, node, thisValue, value, isDynamic);
+      if (thisTmp != null && thisTmp != this) context.freeTemp(thisTmp);
+      if (retTmp != null) {
+        context.freeTemp(retTmp);
+        return Value.comma(ret, retTmp);
+      } else {
+        return ret;
+      }
     } else {
+      // TODO(jimhug): Need to support += and noSuchMethod better.
       return invokeNoSuchMethod(context, 'set:$name', node,
           new Arguments(null, [value]));
     }
   }
 
+  // TODO(jimhug): This method body has too much in common with set_ above.
+  Value setIndex(MethodGenerator context, Value index, Node node, Value value,
+      [bool isDynamic=false, int kind=0, int returnKind=ReturnKind.IGNORE]) {
+    final member = _resolveMember(context, ':setindex', node, isDynamic);
+    if (member != null) {
+      var thisValue = this;
+      var indexValue = index;
+      var thisTmp = null;
+      var indexTmp = null;
+      var retTmp = null;
+      if (returnKind == ReturnKind.POST) {
+        // TODO(jimhug): Optimize this away when native JS works.
+        retTmp = context.forceTemp(value);
+      }
+      if (kind != 0) {
+        // TODO(jimhug): Very special number optimizations will go here...
+        thisTmp = context.getTemp(this);
+        indexTmp = context.getTemp(index);
+        thisValue = context.assignTemp(thisTmp, thisValue);
+        indexValue = context.assignTemp(indexTmp, indexValue);
+
+        if (returnKind == ReturnKind.PRE) {
+          retTmp = context.forceTemp(value);
+        }
+
+        var lhs = thisTmp.invoke(context, ':index', node,
+          new Arguments(null, [indexTmp]));
+        if (returnKind == ReturnKind.PRE) {
+          lhs = context.assignTemp(retTmp, lhs);
+        }
+        value = lhs.binop(kind, value, context, node);
+      }
+      if (returnKind == ReturnKind.POST) {
+        value = context.assignTemp(retTmp, value);
+      }
+
+      var ret = member.invoke(context, node, thisValue,
+        new Arguments(null, [indexValue, value]), isDynamic);
+      if (thisTmp != null && thisTmp != this) context.freeTemp(thisTmp);
+      if (indexTmp != null && indexTmp != index) context.freeTemp(indexTmp);
+      if (retTmp != null) {
+        context.freeTemp(retTmp);
+        return Value.comma(ret, retTmp);
+      } else {
+        return ret;
+      }
+    } else {
+      // TODO(jimhug): Need to support += and noSuchMethod better.
+      return invokeNoSuchMethod(context, ':index', node,
+          new Arguments(null, [index, value]));
+    }
+  }
+
+  //Value getIndex(MethodGenerator context, Value index, var node) {
+  //}
+
   Value unop(int kind, MethodGenerator context, var node) {
     switch (kind) {
       case TokenKind.NOT:
         // TODO(jimhug): Issue #359 seeks to clarify this behavior.
         var newVal = convertTo(context, world.nonNullBool);
         return new Value(newVal.type, '!${newVal.code}', node.span);
       case TokenKind.ADD:
         world.error('no unary add operator in dart', node.span);
         break;
       case TokenKind.SUB:
@@ skipping 61 matching lines @@
     var member = _resolveMember(context, name, null, isDynamic:true);
     return member != null && member.canInvoke(context, args);
   }
 
   /**
    * True if this class (or some related class that is not Object) overrides
    * noSuchMethod. If it does we suppress warnings about unknown members.
    */
   // TODO(jmesserly): should we be doing this?
   bool _hasOverriddenNoSuchMethod() {
-    if (isSuper) {
-      var m = staticType.getMember('noSuchMethod');
-      return m != null && !m.declaringType.isObject;
-    } else {
-      var m = staticType.resolveMember('noSuchMethod');
-      return m != null && m.members.length > 1;
+    var m = type.getMember('noSuchMethod');
+    return m != null && !m.declaringType.isObject;
+  }
+
+  // TODO(jimhug): Handle more precise types here, i.e. consts or closed...
+  bool get isPreciseType() => isSuper || isType;
+
+  void _missingMemberError(MethodGenerator context, String name, bool isDynamic, Node node) {
+    bool onStaticType = false;
+    if (type != staticType) {
+      onStaticType = staticType.getMember(name) !== null;
+    }
+
+    if (!onStaticType && !isDynamic &&
+      !_isVarOrParameterType(staticType) && !_hasOverriddenNoSuchMethod()) {
+      // warn if the member was not found, or error if it is a static lookup.
+      var typeName = staticType.name;
+      if (typeName == null) typeName = staticType.library.name;
+      var message = 'can not resolve "$name" on "${typeName}"';
+      if (isType) {
+        world.error(message, node.span);
+      } else {
+        world.warning(message, node.span);
+      }
     }
   }
 
-  _tryResolveMember(MethodGenerator context, Type resolvetype, String name) {
-    if (isSuper) {
-      return resolvetype.getMember(name);
+
+
+  MemberSet _tryResolveMember(MethodGenerator context, String name, bool isDynamic, Node node) {
+    var member = type.getMember(name);
+    if (member == null) {
+      _missingMemberError(context, name, isDynamic, node);
+      return null;
     } else {
-      return resolvetype.resolveMember(name);
+      if (isType && !member.isStatic) {
+        if (!isDynamic) {
+          world.error('can not refer to instance member as static', node.span);
+        }
+        return null;
+      }
+    }
+
+    if (isPreciseType || member.isStatic) {
+      return member.preciseMemberSet;
+    } else {
+      return member.potentialMemberSet;
     }
   }
 
   // TODO(jmesserly): until reified generics are fixed, treat ParameterType as
   // "var".
   bool _isVarOrParameterType(Type t) => t.isVar || t is ParameterType;
 
   bool _shouldBindDynamically() {
     return _isVarOrParameterType(type) || options.forceDynamic && !isConst;
   }
 
   // TODO(jimhug): Better type here - currently is union(Member, MemberSet)
-  _resolveMember(MethodGenerator context, String name, Node node,
+  MemberSet _resolveMember(MethodGenerator context, String name, Node node,
         [bool isDynamic=false]) {
-
-    // TODO(jmesserly): this has gotten ugly again.
-    var member;
+    var member = null;
     if (!_shouldBindDynamically()) {
-      member = _tryResolveMember(context, type, name);
-
-      if (member == null && type != staticType) {
-        member = _tryResolveMember(context, staticType, name);
-      }
-
-      if (member != null && isType && !member.isStatic) {
-        if (!isDynamic) {
-          world.error('can not refer to instance member as static', node.span);
-        }
-        return null;
-      }
-
-      if (member == null && !isDynamic &&
-         !_isVarOrParameterType(staticType) && !_hasOverriddenNoSuchMethod()) {
-        // warn if the member was not found, or error if it is a static lookup.
-        var typeName = staticType.name;
-        if (typeName == null) typeName = staticType.library.name;
-        var message = 'can not resolve "$name" on "${typeName}"';
-        if (isType) {
-          world.error(message, node.span);
-        } else {
-          world.warning(message, node.span);
-        }
-      }
+      member = _tryResolveMember(context, name, isDynamic, node);
     }
 
     // Fall back to a dynamic operation for instance members
     if (member == null && !isSuper && !isType) {
       member = context.findMembers(name);
       if (member == null && !isDynamic) {
         var where = 'the world';
         if (name.startsWith('_')) {
           where = 'library "${context.library.name}"';
         }
@@ skipping 292 matching lines @@
   }
 
   void convertWarning(Type toType) {
     // TODO(jmesserly): better error messages for type conversion failures
     world.warning('type "${type.name}" is not assignable to "${toType.name}"',
         span);
   }
 
   Value invokeNoSuchMethod(MethodGenerator context, String name, Node node,
       [Arguments args]) {
+    if (isType) {
+      world.error('member lookup failed for "$name"', node.span);
+    }
+
     var pos = '';
     if (args != null) {
       var argsCode = [];
       for (int i = 0; i < args.length; i++) {
         argsCode.add(args.values[i].code);
       }
       pos = Strings.join(argsCode, ", "); // don't remove trailing nulls
     }
     final noSuchArgs = [
         new Value(world.stringType, '"$name"', node.span),
@@ skipping 666 matching lines @@
   bool get needsTemp() => false;
   bool _shouldBindDynamically() => false;
 
   String get code() => _code;
 
   // TODO(jimhug): Lazy initialization here is weird!
   void _ensureCode() {
     if (_code === null) _code = isType ? type.jsname : home._makeThisCode();
   }
 
-  _tryResolveMember(MethodGenerator context, Type resolveType, String name) {
+  MemberSet _tryResolveMember(MethodGenerator context, String name, bool isDynamic, Node node) {
     assert(context == home);
 
-    // First look for members directly defined on my resolveType.
-    var member = resolveType.resolveMember(name);
-    if (member != null) {
-      if (options.forceDynamic && !member.isStatic) {
-        member = context.findMembers(name);
+    // TODO(jimhug): Confirm this matches final resolution of issue 641.
+    var member = type.getMember(name);
+    if (member == null || member.declaringType != type) {
+      var libMember = home.library.lookup(name, span);
+      if (libMember !== null) {
+        return libMember.preciseMemberSet;
       }
-      _ensureCode();
-      return member;
-    }
-
-    // Then look for members in my library.
-    member = home.library.lookup(name, span);
-    if (member != null) {
-      return member;
     }
 
     _ensureCode();
-    return null;
+    return super._tryResolveMember(context, name, isDynamic, node);
   }
 }
 
 /** A reference to 'super'. */
 // TODO(jmesserly): override resolveMember to clean up the one on Value
 class SuperValue extends Value {
   SuperValue(Type parentType, SourceSpan span):
     super(parentType, 'this', span);
 
   bool get needsTemp() => false;
@@ skipping 104 matching lines @@
     }
     return super.unop(kind, context, node);
   }
   Value binop(int kind, var other, MethodGenerator context, var node) {
     if (value != null) {
       return replaceValue(value.binop(kind, _unwrap(other), context, node));
     }
     return super.binop(kind, other, context, node);
   }
 }