incremental progress on Value

frog/value.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.
 
 /**
  * Represents a meta-value for code generation.
  */
 class Value {
   /** The [Type] of the [Value]. */
   Type type;
 
-  /** The code to generate this value. */
+  /** The javascript code to generate this value. */
   String code;
 
   /** The source location that created this value for error messages. */
   SourceSpan span;
 
   /** Is this a reference to super? */
-  bool isSuper;
+  bool isSuper = false;
 
   /** Is this a pretend first-class type? */
-  bool isType;
+  bool isType = false;
 
   /** If we reference this value multiple times, do we need a temp? */
   bool needsTemp;
 
   // TODO(jmesserly): until reified generics are fixed, treat ParameterType as
   // "var".
   bool get _typeIsVarOrParameterType() => type.isVar || type is ParameterType;
 
-  Value(this.type, this.code, this.span,
-        // TODO(sigmund): reorder, so that needsTemp comes first.
-        [this.isSuper = false, this.needsTemp = true, this.isType = false]) {
-    if (type == null) type = world.varType;
+  Value(this.type, this.code, this.span, [this.needsTemp = true]) {
+    if (type == null) world.internalError('type passed as null', span);
   }
 
   /** Is this value a constant expression? */
   bool get isConst() => false;
 
   /**
    * A canonicalized form of the code. Two const expressions that result in the
    * same instance should have the same [canonicalCode].
    */
   String get canonicalCode() => null;
@@ skipping 23 matching lines @@
 
 
   Value invoke(MethodGenerator context, String name, Node node, Arguments args,
       [bool isDynamic=false]) {
     // TODO(jimhug): The != method is weird - understand it better.
     if (_typeIsVarOrParameterType && name == '\$ne') {
       if (args.values.length != 1) {
         world.warning('wrong number of arguments for !=', node.span);
       }
       world.gen.corejs.useOperator('\$ne');
-      return new Value(null, '\$ne($code, ${args.values[0].code})', node.span);
+      return new Value(world.varType, '\$ne($code, ${args.values[0].code})',
+        node.span);
     }
 
     // TODO(jmesserly): it'd be nice to remove these special cases
     // We could create a $call (and $ne) in world members, and have
     // those guys handle the canInvoke/Invoke logic.
 
     // Note: this check is a little different than the one in canInvoke, because
     // sometimes we need to call dynamically even if we found the $call method
     // statically.
 
@@ skipping 94 matching lines @@
       world.error('Types are not first class', span);
     }
   }
 
   /** Generate a call to an unknown function type. */
   Value _varCall(MethodGenerator context, Arguments args) {
     // TODO(jmesserly): calls to unknown functions will bypass type checks,
     // which normally happen on the caller side, or in the generated stub for
     // dynamic method calls. What should we do?
     var stub = world.functionType.getCallStub(args);
-    return new Value(null, '$code.${stub.name}(${args.getCode()})', span);
+    return new Value(world.varType, '$code.${stub.name}(${args.getCode()})',
+      span);
   }
 
   /** True if convertTo would generate a conversion. */
   // TODO(jmesserly): I don't like how this is coupled to convertTo.
   bool needsConversion(Type toType) {
     var callMethod = toType.getCallMethod();
     if (callMethod != null) {
       int arity = callMethod.parameters.length;
       var myCall = type.getCallMethod();
       if (myCall == null || myCall.parameters.length != arity) {
@@ skipping 72 matching lines @@
       return _typeAssert(context, toType, node);
     } else {
       return this;
     }
   }
 
   // TODO(jmesserly): this generates an unnecessary check for the 90%
   // case where the thing passed in was a non-overloaded == or != expression
   // We'll want to eliminate these, probably by tracking non-null bools in the
   // type system.
+  // This matches the interesting Boolean Conversion section of the spec.
   Value convertToNonNullBool(MethodGenerator context, Node node) {
     if (!type.isAssignable(world.boolType)) {
       convertWarning(world.boolType, node);
     }
     if (!options.enableTypeChecks) {
+      // TODO(jimhug): If type != world.boolType, this should return
+      //  this.code === true according to the spec.
       return this;
     } else {
       // TODO(jmesserly): this is hacky.
       if (code.startsWith('\$notnull_bool')) {
         return this;
       } else {
         world.gen.corejs.useNotNullBool = true;
         return new Value(world.boolType, '\$notnull_bool($code)', span);
       }
     }
@@ skipping 194 matching lines @@
   String canonicalCode;
 
   factory EvaluatedValue(Type type, actualValue, String canonicalCode,
       SourceSpan span) {
     return new EvaluatedValue._internal(type, actualValue,
         canonicalCode, span, codeWithComments(canonicalCode, span));
   }
 
   EvaluatedValue._internal(Type type, this.actualValue, this.canonicalCode,
       SourceSpan span, String code)
-    : super(type, code, span, false, false, false);
+    : super(type, code, span, false);
 
   static String codeWithComments(String canonicalCode, SourceSpan span) {
     return (span != null && span.text != canonicalCode)
         ? '$canonicalCode/*${span.text}*/' : canonicalCode;
   }
 }
 
 /** An evaluated constant list expression. */
 class ConstListValue extends EvaluatedValue {
   List<EvaluatedValue> values;
@@ skipping 100 matching lines @@
     var codeWithComment = "$name/*${exp.span.text}*/";
     return new GlobalValue(
         exp.type, codeWithComment, true, null, name, exp, name,
         exp.span,
         dependencies.filter((d) => d is GlobalValue));
   }
 
   GlobalValue(Type type, String code, bool isConst,
       this.field, this.name, this.exp, this.canonicalCode,
       SourceSpan span, this.dependencies)
-      : super(type, code, span, false, !isConst, false);
+      : super(type, code, span, !isConst);
 
   int compareTo(GlobalValue other) {
     // order by dependencies, o.w. by name
     if (other == this) {
       return 0;
     } else if (dependencies.indexOf(other, 0) >= 0) {
       return 1;
     } else if (other.dependencies.indexOf(this, 0) >= 0) {
       return -1;
     } else if (dependencies.length > other.dependencies.length) {
@@ skipping 13 matching lines @@
 }
 
 /**
  * Represents the hidden or implicit value in a bare reference like 'a'.
  * This could be this, the current type, or the current library for purposes
  * of resolving members.
  */
 class BareValue extends Value {
   MethodGenerator home;
 
-  BareValue(this.home, MethodGenerator outermost, SourceSpan span):
-    super(outermost.method.declaringType, null, span, false, false,
-      outermost.isStatic);
+  BareValue(this.home, MethodGenerator outermost, SourceSpan span)
+      : super(outermost.method.declaringType, null, span, false) {
+    isType = outermost.isStatic;
+  }
 
   _tryResolveMember(MethodGenerator context, String name) {
     assert(context == home);
 
     // First look for members directly defined on my type.
     var member = type.resolveMember(name);
     if (member != null) {
       assert(code == null);
       // TODO(jimhug): Lazy initialization here is weird!
       if (isType) {
         code = type.jsname;
       } else {
         code = home._makeThisCode();
       }
       return member;
     }
 
     // Then look for members in my library.
     member = home.library.lookup(name, span);
     if (member != null) {
       return member;
     }
 
     return null;
   }
 }