cleanup test status

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;
 
   Value value;
 
   Parameter(this.definition);
 
-  resolve(Type inType) {
+  resolve(Member method, Type inType) {
     name = definition.name.name;
     type = inType.resolveType(definition.type, false);
+
+    if (method.isStatic && type.hasTypeParams) {
+      world.error('using type parameter in static context', definition.span);
+    }
+
+    if (definition.value != null) {
+      // To match VM, detect cases where value was not actually specified in
+      // code and don't signal errors.
+      // TODO(jimhug): Clean up after issue #352 is resolved.
+      if (definition.value is NullExpression &&
+          definition.value.span.start == definition.span.start) {
+        return;
+      }
+      if (method.isAbstract) {
+        world.error('default value not allowed on abstract methods',
+          definition.span);
+      } else if (!inType.isClass) {
+          world.error('default value not allowed on interface methods',
+            definition.span);
+      } else if (method.name == '\$call' && method.definition.body == null) {
+        // TODO(jimhug): Need simpler way to detect "true" function types vs.
+        //   regular methods being used as function types for closures.
+        world.error('default value not allowed on function type',
+          definition.span);
+      }
+    }
   }
 
   genValue(MethodMember method, MethodGenerator context) {
     if (definition.value == null || value != null) return;
 
     if (context == null) { // interface method
       context = new MethodGenerator(method, null);
     }
     value = definition.value.visit(context);
     value = value.convertTo(context, type, definition.value);
   }
 
   Parameter copyWithNewType(Type newType) {
     var ret = new Parameter(definition);
     ret.type = newType;
     ret.name = name;
     return ret;
-    //ret.value = value; // TODO(jimhug): Any interaction with generics?
   }
 
   bool get isOptional() => definition != null && definition.value != null;
 }
 
 
 interface Named {
   String get name();
   Library get library();
   bool get isNative();
@@ skipping 526 matching lines @@
     if (definition.returnType.names != null) {
       return definition.returnType.names[0].name;
     } else if (definition.returnType.name != null) {
       return definition.returnType.name.name;
     }
     world.internalError('no valid constructor name', definition.span);
   }
 
   Type get functionType() {
     if (_functionType == null) {
-      _functionType = declaringType.library.getOrAddFunctionType(name,
+      _functionType = library.getOrAddFunctionType(name,
         definition, declaringType);
       // TODO(jimhug): Better resolution checks.
       if (parameters == null) {
         resolve(declaringType);
       }
     }
     return _functionType;
   }
 
   bool override(Member other) {
@@ skipping 589 matching lines @@
       returnType = inType.resolveType(definition.returnType, false);
 
       if (isStatic && returnType.hasTypeParams) {
         world.error('using type parameter in static context',
           definition.returnType.span);
       }
     }
     parameters = [];
     for (var formal in definition.formals) {
       var param = new Parameter(formal);
-      param.resolve(inType);
+      param.resolve(this, inType);
       parameters.add(param);
-      if (isStatic && param.type.hasTypeParams) {
-        world.error('using type parameter in static context',
-          formal.span);
-      }
     }
 
     if (!isLambda) {
       library._addMember(this);
     }
   }
 }
 
 
 class MemberSet {
   final String name;
   final List<Member> members;
   final String jsname;
 
   MemberSet(Member member):
     name = member.name, members = [member], jsname = member.jsname;
 
   toString() => '$name:${members.length}';
 
   // TODO(jimhug): Still working towards the right logic for conflicts...
   bool get containsProperties() => members.some((m) => m is PropertyMember);
   bool get containsMethods() => members.some((m) => m is MethodMember);
 
   void add(Member member) => members.add(member);
 
   bool canInvoke(MethodGenerator context, Arguments args) =>
     members.some((m) => m.canInvoke(context, args));
 
-  Library get library() {
-    var ret = members[0].declaringType.library;
-    for (var m in members) {
-      if (m.declaringType.library != ret) return null;
-    }
-    return ret;
-  }
-
   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*/');
   }
 
   bool _treatAsField;
   bool get treatAsField() {
     if (_treatAsField == null) {
@@ skipping 232 matching lines @@
   }
 
   void forEach(void f(Member member)) {
     factories.forEach((_, Map constructors) {
       constructors.forEach((_, Member member) {
         f(member);
       });
     });
   }
 }