Work in progress: changes to interpretation

frog/member.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.
 
 /** A formal parameter to a [Method]. */
 class Parameter {
   FormalNode definition;
   Member method;
 
   String name;
   Type type;
   bool isInitializer = false;
 
   Value value;
 
   Parameter(this.definition, this.method);
 
+  SourceSpan get span() => definition.span;
+
   resolve() {
     name = definition.name.name;
     if (name.startsWith('this.')) {
       name = name.substring(5);
       isInitializer = true;
     }
 
     type = method.resolveType(definition.type, false);
 
     if (definition.value != null) {
@@ skipping 14 matching lines @@
       } else if (method.isAbstract) {
         world.error('default value not allowed on abstract methods',
             definition.span);
       }
     } else if (isInitializer && !method.isConstructor) {
       world.error('initializer parameters only allowed on constructors',
           definition.span);
     }
   }
 
-  genValue(MethodMember method, MethodGenerator context) {
+  genValue(MethodMember method, [MethodGenerator context]) {
     if (definition.value == null || value != null) return;
 
     if (context == null) { // interface method
-      context = new MethodGenerator(method, null);
+      context = new MethodGenerator(method);
     }
-    value = definition.value.visit(context);
+    value = context.evalExpression(definition.value);
     if (!value.isConst) {
       world.error('default parameter values must be constant', value.span);
     }
     value = value.convertTo(context, type);
   }
 
   Parameter copyWithNewType(Member newMethod, Type newType) {
     var ret = new Parameter(definition, newMethod);
     ret.type = newType;
     ret.name = name;
     ret.isInitializer = isInitializer;
     return ret;
   }
 
   bool get isOptional() => definition != null && definition.value != null;
 
   /**
    * Gets whether this named parameter has an explicit default value or relies
    * on the implicit `null`.
    */
   bool get hasDefaultValue() =>
     definition.value.span.start != definition.span.start;
 }
 
 
 class Member extends Element {
   final Type declaringType;
 
-  bool isGenerated;
-  MethodGenerator generator;
+  bool isUsed;
+
+  // TODO(jmesserly): this only makes sense if we never specialize functions
+  // for their argument types.
+  MethodGenerator get generator() => specializer.generator;
+  MethodSpecializer specializer;
 
   Member(String name, Type declaringType)
-      : isGenerated = false, this.declaringType = declaringType,
+      : isUsed = false, this.declaringType = declaringType,
         super(name, declaringType);
 
   abstract bool get isStatic();
   abstract Type get returnType();
 
   abstract bool get canGet();
   abstract bool get canSet();
 
   Library get library() => declaringType.library;
 
@@ skipping 33 matching lines @@
     world.internalError('cannot have initializers', span);
   }
   void set initDelegate(ctor) {
     world.internalError('cannot have initializers', span);
   }
 
   Value computeValue() {
     world.internalError('cannot have value', span);
   }
 
-  /**
-   * The inferred returnType. Right now this is just used to track
-   * non-nullable bools.
-   */
-  Type get inferredResult() {
-    var t = returnType;
-    if (t.isBool && (library.isCore || library.isCoreImpl)) {
-      // We trust our core libraries not to return null from bools.
-      // I hope this trust is well placed!
-      return world.nonNullBool;
-    }
-    return t;
-  }
-
   Definition get definition() => null;
 
   List<Parameter> get parameters() => [];
 
+  void markUsed() => declaringType.markUsedMethod(this);
+
   MemberSet _preciseMemberSet, _potentialMemberSet;
 
   MemberSet get preciseMemberSet() {
     if (_preciseMemberSet === null) {
       _preciseMemberSet = new MemberSet(this);
     }
     return _preciseMemberSet;
   }
 
   MemberSet get potentialMemberSet() {
@@ skipping 255 matching lines @@
     if (value == null) return null;
 
     if (_computedValue == null) {
       if (_computing) {
         world.error('circular reference', value.span);
         return null;
       }
       _computing = true;
       var finalMethod = new MethodMember('final_context', declaringType, null);
       finalMethod.isStatic = true;
-      var finalGen = new MethodGenerator(finalMethod, null);
-      _computedValue = value.visit(finalGen);
+      _computedValue = new MethodGenerator(finalMethod).evalExpression(value);
       if (!_computedValue.isConst) {
         if (isStatic) {
           world.error(
             'non constant static field must be initialized in functions',
             value.span);
         } else {
           world.error(
               'non constant field must be initialized in constructor',
               value.span);
         }
@@ skipping 254 matching lines @@
   Type resolveType(TypeReference node, bool isRequired) {
     var type = baseMember.resolveType(node, isRequired);
     return type.resolveTypeParams(declaringType);
   }
 
   Value computeValue() => baseMember.computeValue();
 
   // TODO(jimhug): Add support for type params.
   bool override(Member other) => baseMember.override(other);
 
+  // TODO(jmesserly): this hack is needed because ConcreteMember is using
+  // baseMember to do the operation, then replacing the type on the Value.
+  // Something else needs to happen.
+  Type get inferredResult() => returnType;
+
   Value _get(MethodGenerator context, Node node, Value target,
       [bool isDynamic=false]) {
     Value ret = baseMember._get(context, node, target, isDynamic);
     return new Value(inferredResult, ret.code, node.span);
   }
 
   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, node.span);
+    return new Value(inferredResult, ret.code, node.span);
   }
 
   _evalConstConstructor(ObjectValue newObject, Arguments args) {
     // TODO(jimhug): Concrete type probably matters somehow here
     return baseMember.dynamic._evalConstConstructor(newObject, args);
   }
 
 
   Value invoke(MethodGenerator context, Node node, Value target, Arguments args,
       [bool isDynamic=false]) {
     // TODO(jimhug): Check arg types in context of concrete type.
     // TODO(jmesserly): I think what needs to happen is to move MethodMember's
     // invoke so that it's run against the "parameters" and "returnType" of the
     // ConcreteMember instead.
     Value ret = baseMember.invoke(context, node, target, args, isDynamic);
     var code = ret.code;
     if (isConstructor) {
       // TODO(jimhug): Egregious hack - won't live through the year.
       code = code.replaceFirst(
           declaringType.genericType.jsname, declaringType.jsname);
     }
     if (baseMember is MethodMember) {
-      declaringType.genMethod(this);
+      // TODO(jmesserly): we should be filling in the right args here and
+      // using the result type. But the args need to be reordered to match the
+      // call site, like baseMember.invoke does.
+      world.gen.invokeMethod(this, target, null);
     }
     return new Value(inferredResult, code, node.span);
   }
 }
 
 
 /** Represents a Dart method or top-level function. */
 class MethodMember extends Member {
   FunctionDefinition definition;
   Type returnType;
@@ skipping 115 matching lines @@
   void provideFieldSyntax() { _provideFieldSyntax = true; }
   void providePropertySyntax() { _providePropertySyntax = true; }
 
   Value _set(MethodGenerator context, Node node, Value target, Value value,
       [bool isDynamic=false]) {
     world.error('cannot set method', node.span);
   }
 
   Value _get(MethodGenerator context, Node node, Value target,
       [bool isDynamic=false]) {
-    // TODO(jimhug): Would prefer to invoke!
-    declaringType.genMethod(this);
+
+    // TODO(jmesserly): if we tracked functions as values, this would be the
+    // place to do it.
+    world.gen.invokeMethod(this);
+
     _provideOptionalParamInfo = true;
     if (isStatic) {
       // ensure the type is generated.
       // TODO(sigmund): can we avoid generating the entire type, but only what
       // we need?
       declaringType.markUsed();
       var type = declaringType.isTop ? '' : '${declaringType.jsname}.';
       return new Value(functionType, '$type$jsname', node.span);
     }
     _providePropertySyntax = true;
@@ skipping 77 matching lines @@
     if (isStatic || isConstructor) {
       world.error(msg, span);
     } else {
       world.warning(msg, span);
     }
     return target.invokeNoSuchMethod(context, name, node, args);
   }
 
   genParameterValues() {
     // Pure lazy?
-    for (var p in parameters) p.genValue(this, generator);
+    for (var p in parameters) p.genValue(this);
   }
 
   /**
    * Invokes this method on the given [target] with the given [args].
    * [node] provides a [SourceSpan] for any error messages.
    */
   Value invoke(MethodGenerator context, Node node, Value target,
       Arguments args, [bool isDynamic=false]) {
     // TODO(jimhug): Fix this hack for ensuring a method is resolved.
     if (parameters == null) {
       world.info('surprised to need to resolve: ${declaringType.name}.$name');
       resolve();
     }
 
-    declaringType.genMethod(this);
-
     if (isStatic || isFactory) {
       // TODO(sigmund): can we avoid generating the entire type, but only what
       // we need?
       declaringType.markUsed();
     }
 
     // TODO(jmesserly): get rid of this in favor of using the native method
     // "bodies" to tell the compiler about valid return types.
     if (isNative && returnType != null) returnType.markUsed();
 
     if (!namesInOrder(args)) {
       // Names aren't in order. For now, use a var call because it's an
       // easy way to get the right eval order for out of order arguments.
       // TODO(jmesserly): temps would be better.
       return context.findMembers(name).invokeOnVar(context, node, target, args);
     }
 
-    var argsCode = [];
-    if (!target.isType && (isConstructor || target.isSuper)) {
-      argsCode.add('this');
-    }
-
+    final argValues = <Value>[];
     int bareCount = args.bareCount;
     for (int i = 0; i < bareCount; i++) {
       var arg = args.values[i];
       if (i >= parameters.length) {
         var msg = _argCountMsg(args.length, parameters.length);
         return _argError(context, node, target, args, msg, i);
       }
       arg = arg.convertTo(context, parameters[i].type, isDynamic);
-      argsCode.add(arg.code);
+      argValues.add(arg);
     }
 
     int namedArgsUsed = 0;
     if (bareCount < parameters.length) {
       genParameterValues();
 
       for (int i = bareCount; i < parameters.length; i++) {
         var arg = args.getValue(parameters[i].name);
         if (arg == null) {
           arg = parameters[i].value;
         } else {
           arg = arg.convertTo(context, parameters[i].type, isDynamic);
           namedArgsUsed++;
         }
 
         if (arg == null || !parameters[i].isOptional) {
           var msg = _argCountMsg(Math.min(i, args.length), i + 1, atLeast:true);
           return _argError(context, node, target, args, msg, i);
         } else {
-          argsCode.add(arg.code);
+          argValues.add(arg);
         }
       }
-      Arguments.removeTrailingNulls(argsCode);
     }
 
     if (namedArgsUsed < args.nameCount) {
       // Find the unused argument name
       var seen = new Set<String>();
       for (int i = bareCount; i < args.length; i++) {
         var name = args.getName(i);
         if (seen.contains(name)) {
           return _argError(context, node, target, args,
               'duplicate argument "$name"', i);
         }
         seen.add(name);
         int p = indexOfParameter(name);
         if (p < 0) {
           return _argError(context, node, target, args,
               'method does not have optional parameter "$name"', i);
         } else if (p < bareCount) {
           return _argError(context, node, target, args,
               'argument "$name" passed as positional and named',
               // Given that the named was mentioned explicitly, highlight the
               // positional location instead:
               p);
         }
       }
       world.internalError('wrong named arguments calling $name', node.span);
     }
 
-    var argsString = Strings.join(argsCode, ', ');
+    // TODO(jmesserly): maybe this should be producing the result Value, and we
+    // just return on this line.
+    Type inferredResult = world.gen.invokeMethod(this, target,
+        new Arguments(null, argValues));
+
+    final argsCode = map(argValues, (v) => v.code);
+    if (!target.isType && (isConstructor || target.isSuper)) {
+      argsCode.insertRange(0, 1, 'this');
+    }
+    if (namedArgsUsed < args.nameCount) {
+      Arguments.removeTrailingNulls(argsCode);
+    }
+    final argsString = Strings.join(argsCode, ', ');
 
     if (isConstructor) {
       return _invokeConstructor(context, node, target, args, argsString);
     }
 
     if (target.isSuper) {
       return new Value(inferredResult,
           '${declaringType.jsname}.prototype.$jsname.call($argsString)',
           node.span);
     }
 
     if (isOperator) {
-      return _invokeBuiltin(context, node, target, args, argsCode, isDynamic);
+      return _invokeBuiltin(context, node, target, args, argsCode, isDynamic,
+          inferredResult);
     }
 
     if (isFactory) {
       assert(target.isType);
       return new Value(target.type, '$generatedFactoryName($argsString)',
           node !== null ? node.span : null);
     }
 
     if (isStatic) {
       if (declaringType.isTop) {
@@ skipping 44 matching lines @@
         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();
-    var generator = new MethodGenerator(this, null);
-    generator.evalBody(newObject, args);
+    new MethodGenerator(this).evalBody(newObject, args);
   }
 
   Value _invokeBuiltin(MethodGenerator context, Node node, Value target,
-      Arguments args, argsCode, bool isDynamic) {
+      Arguments args, argsCode, bool isDynamic, Type inferredResult) {
     // Handle some fast paths for Number, String, List and DOM.
     if (declaringType.isNum) {
       // TODO(jimhug): This fails in bad ways when argsCode[1] is not num.
       // TODO(jimhug): What about null?
       var code;
       if (name == ':negate') {
         code = '-${target.code}';
       } else if (name == ':bit_not') {
         code = '~${target.code}';
       } else if (name == ':truncdiv' || name == ':mod') {
@@ skipping 514 matching lines @@
   }
 
   void forEach(void f(Member member)) {
     factories.forEach((_, Map constructors) {
       constructors.forEach((_, Member member) {
         f(member);
       });
     });
   }
 }