incremental progress on Value

frog/gen.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.
 
 /**
  * Top level generator object for writing code and keeping track of
  * dependencies.
  *
  * Should have two compilation models, but only one implemented so far.
  *
@@ skipping 472 matching lines @@
     // (This lookup might report errors, which is a bit strange.
     // But probably harmless since we have to pay for the lookup anyway.)
     final type = enclosingMethod.method.declaringType;
     if (type.library.lookup(name, null) != null) return true;
 
     // Nobody else needs this name. It's safe to reuse.
     return false;
   }
 
 
-  Value create(String name, Type type, Node location,
+  Value create(String name, Type type, SourceSpan span,
       [bool isParameter = false]) {
 
     var jsName = world.toJsIdentifier(name);
     if (_vars.containsKey(name)) {
-      if (location != null) {
-        world.error('duplicate name "$name"', location.span);
-      } else {
-        world.internalError('conflict with temporary name "$name"');
-      }
+      world.error('duplicate name "$name"', span);
     }
 
     // Make sure variables don't shadow any names we might need to access.
     if (!isParameter) {
       int index = 0;
       while (_isDefinedInParent(jsName)) {
         jsName = '$name${index++}';
       }
     }
 
-    var ret = new Value(type, jsName, location != null ? location.span : null,
-      false, false);
+    var ret = new Value(type, jsName, span, false);
     _vars[name] = ret;
     return ret;
   }
 
   Value declareParameter(Parameter p) {
-    return create(p.name, p.type, p.definition, isParameter:true);
+    return create(p.name, p.type, p.definition.span, isParameter:true);
   }
 
   /** Declares a variable in the current scope for this identifier. */
   Value declare(DeclaredIdentifier id) {
     var type = enclosingMethod.method.resolveType(id.type, false);
-    return create(id.name.name, type, id);
+    return create(id.name.name, type, id.span);
   }
 
   /**
    * Finds the first lexically enclosing catch block, if any, and returns its
    * exception variable.
    */
   Value getRethrow() {
     var scope = this;
     while (scope.rethrow == null && scope.parent != null) {
       scope = scope.parent;
@@ skipping 33 matching lines @@
     if (enclosingMethod != null) {
       _scope = new BlockScope(this, enclosingMethod._scope);
       captures = new Set();
     } else {
       _scope = new BlockScope(this, null);
     }
     // For named lambdas, add the name to this scope so we can call it
     // recursively.
     if (enclosingMethod != null && method.name != '') {
       MethodMember m = method; // lambdas must be MethodMembers
-      _scope.create(m.name, m.functionType, m.definition);
+      _scope.create(m.name, m.functionType, m.definition.span);
     }
     _usedTemps = new Set();
     _freeTemps = [];
   }
 
   Library get library() => method.library;
 
   // TODO(jimhug): Where does this really belong?
   MemberSet findMembers(String name) {
     return library._findMembers(name);
   }
 
   bool get isClosure() => (enclosingMethod != null);
 
   bool get isStatic() => method.isStatic;
 
   Value getTemp(Value value) {
     return value.needsTemp ? forceTemp(value) : value;
   }
 
   Value forceTemp(Value value) {
     String name;
     if (_freeTemps.length > 0) {
       name = _freeTemps.removeLast();
     } else {
       name = '\$' + _usedTemps.length;
     }
     _usedTemps.add(name);
-    return new Value(value.type, name, value.span,
-      /*isSuper:*/false, /*needsTemp:*/false);
+    return new Value(value.type, name, value.span, /*needsTemp:*/false);
   }
 
   Value assignTemp(Value tmp, Value v) {
     if (tmp == v) {
       return v;
     } else {
       // TODO(jmesserly): we should mark this returned value with the temp
       // somehow, so getTemp will reuse it instead of allocating a new one.
       return new Value(v.type, '(${tmp.code} = ${v.code})', v.span);
     }
@@ skipping 182 matching lines @@
         var field = method.declaringType.getMember(p.name);
         if (field == null) {
           world.error('bad this parameter - no matching field',
             p.definition.span);
         }
         if (!field.isField) {
           world.error('"this.${p.name}" does not refer to a field',
             p.definition.span);
         }
         var paramValue = new Value(field.returnType, p.name,
-          p.definition.span, false, false);
+          p.definition.span, false);
         _paramCode.add(paramValue.code);
 
         initializers.add('this.${field.jsname} = ${paramValue.code};');
         initializedFields.add(p.name);
       } else {
         var paramValue = _scope.declareParameter(p);
         _paramCode.add(paramValue.code);
       }
     }
 
@@ skipping 241 matching lines @@
       var value = visitValue(node.values[i]);
       if (isFinal) {
         if (value == null) {
           world.error('no value specified for final variable', node.span);
         } else {
           // TODO(jimhug): Mark inferred types as special for correct errors.
           if (thisType.isVar) thisType = value.type;
         }
       }
 
-      var val = _scope.create(name, thisType, node.names[i]);
+      var val = _scope.create(name, thisType, node.names[i].span);
 
       if (value == null) {
         writer.write('${val.code}');
       } else {
         value = value.convertTo(this, type, node.values[i]);
         writer.write('${val.code} = ${value.code}');
       }
     }
     writer.writeln(';');
     return false;
 
   }
 
   bool visitFunctionDefinition(FunctionDefinition node) {
     var name = world.toJsIdentifier(node.name.name);
 
     var meth = _makeLambdaMethod(name, node);
 
     // TODO(jimhug): Pass js name into writeDefinition?
-    var funcValue = _scope.create(name, meth.functionType, method.definition);
+    var funcValue =
+      _scope.create(name, meth.functionType, method.definition.span);
     meth.generator.writeDefinition(writer, null);
     return false;
   }
 
   /**
    * Returns true indicating that normal control-flow is interrupted by
    * this statement. (This could be a return, break, throw, or continue.)
    */
   bool visitReturnStatement(ReturnStatement node) {
     if (node.value == null) {
@@ skipping 128 matching lines @@
     return false;
   }
 
   bool visitForInStatement(ForInStatement node) {
     // TODO(jimhug): visitValue and other cleanups here.
     var itemType = method.resolveType(node.item.type, false);
     var itemName = node.item.name.name;
     var list = node.list.visit(this);
     _pushBlock(/*reentrant:*/true);
     // TODO(jimhug): Check that itemType matches list members...
-    var item = _scope.create(itemName, itemType, node.item.name);
+    var item = _scope.create(itemName, itemType, node.item.name.span);
     Value listVar = list;
     if (list.needsTemp) {
       listVar = _scope.create('\$list', list.type, null);
       writer.writeln('var ${listVar.code} = ${list.code};');
     }
 
     // Special path for list for readability and perf optimization.
     if (list.type.isList) {
       var tmpi = _scope.create('\$i', world.numType, null);
       writer.enterBlock('for (var ${tmpi.code} = 0;' +
           '${tmpi.code} < ${listVar.code}.length; ${tmpi.code}++) {');
       var value = listVar.invoke(this, '\$index', node.list,
           new Arguments(null, [tmpi]));
       writer.writeln('var ${item.code} = ${value.code};');
     } else {
       _pushBlock();
-      // Needed to tell the runtime that we're doing this behind its back.
-      var c = world.coreimpl.types['ListIterator'].getConstructor('');
-      c.invoke(this, node, null,
-        new Arguments(null, [new Value(null, 'l', node.list.span)]));
-
-      var iterator = list.invoke(this, 'iterator', node.list,
-        Arguments.EMPTY);
+      var iterator = list.invoke(this, 'iterator', node.list, Arguments.EMPTY);
       var tmpi = _scope.create('\$i', iterator.type, null);
 
       var hasNext = tmpi.invoke(this, 'hasNext', node.list, Arguments.EMPTY);
       var next = tmpi.invoke(this, 'next', node.list, Arguments.EMPTY);
 
       writer.enterBlock(
         'for (var ${tmpi.code} = ${iterator.code}; ${hasNext.code}; ) {');
       writer.writeln('var ${item.code} = ${next.code};');
     }
 
     visitStatementsInBlock(node.body);
     writer.exitBlock('}');
     _popBlock();
     return false;
   }
 
   void _genToDartException(String ex, Node node) {
     var types = const [
       'NullPointerException', 'ObjectNotClosureException',
       'NoSuchMethodException', 'StackOverflowException'];
-    var target = new Value(null, 'this', node.span);
+    // TODO(jimhug): This is an egregious hack to get some toStrings called.

[Jennifer Messerly, 2011/11/12 00:39:58]

Yeah, we probably just want to invoke all toStrings for live types.

+    var target = new Value(world.varType, 'this', node.span);
     for (var name in types) {
       world.corelib.types[name].markUsed();
       world.corelib.types[name].members['toString'].invoke(
           this, node, target, Arguments.EMPTY);
     }
     writer.writeln('$ex = \$toDartException($ex);');
     world.gen.corejs.useToDartException = true;
   }
 
   bool visitTryStatement(TryStatement node) {
@@ skipping 197 matching lines @@
       world.warning('not allowed in static method', node.span);
     }
   }
 
   _makeSuperValue(Node node) {
     var parentType = method.declaringType.parent;
     _checkNonStatic(node);
     if (parentType == null) {
       world.error('no super class', node.span);
     }
-    return new Value(parentType, 'this', node.span,
-      /*isSuper:*/true, /*needsTemp:*/false);
+    // TODO(jimhug): Replace with SuperValue.

[Jennifer Messerly, 2011/11/12 00:39:58]

+1

+    var ret = new Value(parentType, 'this', node.span, false);
+    ret.isSuper = true;
+    return ret;
   }
 
   _getOutermostMethod() {
     var result = this;
     while (result.enclosingMethod != null) {
       result = result.enclosingMethod;
     }
     return result;
   }
 
@@ skipping 11 matching lines @@
   /**
    * Creates a reference to the enclosing type ('this') that can be used within
    * closures.
    */
   Value _makeThisValue(Node node) {
     if (enclosingMethod != null) {
       var outermostMethod = _getOutermostMethod();
       outermostMethod._checkNonStatic(node);
       outermostMethod.needsThis = true;
       return new Value(outermostMethod.method.declaringType, '\$this',
-        node != null ? node.span : null, /*isSuper:*/false, /*needsTemp:*/false);
+        node != null ? node.span : null, /*needsTemp:*/false);
     } else {
       _checkNonStatic(node);
       return new Value(method.declaringType, 'this', node != null ? node.span : null,
-        /*isSuper:*/false, /*needsTemp:*/false);
+        /*needsTemp:*/false);
     }
   }
 
   // ******************* Expressions *******************
   visitLambdaExpression(LambdaExpression node) {
     var name = '';
     if (node.func.name != null) {
       name = world.toJsIdentifier(node.func.name.name);
     }
 
@@ skipping 43 matching lines @@
     // TODO(jimhug): Ensure these have same semantics as JS!
     if (kind == TokenKind.AND || kind == TokenKind.OR) {
       var x = visitValue(node.x);
       var y = visitValue(node.y);
       final code = '${x.code} ${node.op} ${y.code}';
       if (x.isConst && y.isConst) {
         var value = (kind == TokenKind.AND)
             ? x.actualValue && y.actualValue : x.actualValue || y.actualValue;
         return new EvaluatedValue(x.type, value, '$value', node.span);
       }
-      return new Value(null, code, node.span);
+      var ret = new Value(Type.union(x.type, y.type), code, node.span);
+      return ret.convertToNonNullBool(this, node);
     } else if (kind == TokenKind.EQ_STRICT || kind == TokenKind.NE_STRICT) {
       var x = visitValue(node.x);
       var y = visitValue(node.y);
       if (x.isConst && y.isConst) {
         var value = kind == TokenKind.EQ_STRICT
             // Note: it is ok to use == and not === here since all of these
             // constant comparisons are applied to doubles, bool, or strings.
             // We need it for the compile-time evaluator because
             // (9).toDouble() === 9.0 is false in dartvm.
             ? x.actualValue == y.actualValue : x.actualValue != y.actualValue;
         return new EvaluatedValue(world.boolType, value, "$value", node.span);
       }
       if (x.code == 'null' || y.code == 'null') {
         // Switching to == ensures that null and undefined are interchangable.
         final op = node.op.toString().substring(0,2);
-        return new Value(null, '${x.code} $op ${y.code}', node.span);
+        return new Value(world.boolType, '${x.code} $op ${y.code}', node.span);

[Jennifer Messerly, 2011/11/12 00:39:58]

it's funny, I caught this one too. But it's now it's world.nonNullBool :)

       } else {
         // TODO(jimhug): Resolve issue with undefined and null here.
-        return new Value(null, '${x.code} ${node.op} ${y.code}', node.span);
+        return new Value(world.boolType, '${x.code} ${node.op} ${y.code}',
+          node.span);
       }
     }
 
     final assignKind = TokenKind.kindFromAssign(node.op.kind);
     if (assignKind == -1) {
       final x = visitValue(node.x);
       final y = visitValue(node.y);
       var name = TokenKind.binaryMethodName(node.op.kind);
       if (node.op.kind == TokenKind.NE) {
         name = '\$ne';
@@ skipping 45 matching lines @@
 
     if (x == null) {
       // Look for a setter in the class
       var members = method.declaringType.resolveMember(name);
       if (members != null) {
         x = _makeThisOrType(position.span);
         if (kind == 0) {
           return x.set_(this, name, position, y);
         } else if (!members.treatAsField || members.containsMethods) {
           var right = x.get_(this, name, position);
-          //var right = members._get(this, position, x);
           right = captureOriginal(right);
           y = right.invoke(this, TokenKind.binaryMethodName(kind),
               position, new Arguments(null, [y]));
           return x.set_(this, name, position, y);
         } else {
           x = x.get_(this, name, position);
         }
       } else {
         // Look for a top-level setter
         final member = library.lookup(name, xn.name.span);
@@ skipping 342 matching lines @@
     final name = node.name.name;
 
     // First check in block scopes.
     var ret = _scope.lookup(name);
     if (ret != null) return ret;
 
     return _makeThisOrType(node.span).get_(this, name, node);
   }
 
   _makeMissingValue(String name) {
-    // TODO(jimhug): Probably goes away to be fully replaced by doesNotUnder
-    return new Value(null, '$name()/*NotFound*/', null);
+    // TODO(jimhug): Probably goes away to be fully replaced by noSuchMethod
+    return new Value(world.varType, '$name()/*NotFound*/', null);
   }
 
   _makeThisOrType(SourceSpan span) {
     return new BareValue(this, _getOutermostMethod(), span);
   }
 
   visitThisExpression(ThisExpression node) {
     return _makeThisValue(node);
   }
 
   visitSuperExpression(SuperExpression node) {
     return _makeSuperValue(node);
   }
 
   visitNullExpression(NullExpression node) {
-    return new EvaluatedValue(null, null, 'null', null);
+    // TODO(jimhug): should be passing node.span
+    // TODO(jimhug): Can we do better than var for the type?
+    return new EvaluatedValue(world.varType, null, 'null', null);
   }
 
   visitLiteralExpression(LiteralExpression node) {
     // All Literal types are filled in at parse time, so no need to resolve.
     var type = node.type.type;
     assert(type != null);
 
     if (node.value is List) {
       var items = [];
       for (var item in node.value) {
@@ skipping 49 matching lines @@
   List<Value> values;
   List<ArgumentNode> nodes;
   int _bareCount;
 
   Arguments(this.nodes, this.values);
 
   /** Constructs a bare list of arguments. */
   factory Arguments.bare(int arity) {
     var values = [];
     for (int i = 0; i < arity; i++) {
-      // TODO(jimhug): Need source locations.
-      values.add(new Value(world.varType, '\$$i', null, false, /*needsTemp:*/false));
+      // TODO(jimhug): Need a firm rule about null SourceSpans are allowed.
+      values.add(new Value(world.varType, '\$$i', null, /*needsTemp:*/false));
     }
     return new Arguments(null, values);
   }
 
   int get nameCount() => length - bareCount;
   bool get hasNames() => bareCount < length;
 
   int get length() => values.length;
 
   String getName(int i) => nodes[i].label.name;
@@ skipping 67 matching lines @@
     for (int i = bareCount; i < length; i++) {
       names.add(getName(i));
     }
     return names;
   }
 
   /** Gets the argument names used in a call stub; uses $0 $1 for bare args. */
   Arguments toCallStubArgs() {
     var result = [];
     for (int i = 0; i < bareCount; i++) {
-      // TODO(jimhug): Need source locations.
-      result.add(new Value(world.varType, '\$$i', null, false, /*needsTemp:*/false));
+      result.add(new Value(world.varType, '\$$i', null, /*needsTemp:*/false));
     }
     for (int i = bareCount; i < length; i++) {
       var name = getName(i);
       if (name == null) name = '\$$i';
-      // TODO(jimhug): Need source locations.
-      result.add(new Value(world.varType, name, null, false, /*needsTemp:*/false));
+      result.add(new Value(world.varType, name, null, /*needsTemp:*/false));
     }
     return new Arguments(nodes, result);
   }
 }