more negative test fixes

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;
@@ skipping 14 matching lines @@
       // 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) {
@@ skipping 1104 matching lines @@
 
     return target.invokeSpecial(jsname, args, returnType);
   }
 
 
   resolve(Type inType) {
     // TODO(jimhug): cut-and-paste-and-edit from Field.resolve
     isStatic = inType.isTop;
     isConst = false;
     isFactory = false;
-    isAbstract = false;
+    isAbstract = !declaringType.isClass;
     if (definition.modifiers != null) {
       for (var mod in definition.modifiers) {
         if (mod.kind == TokenKind.STATIC) {
           if (isStatic) {
             world.error('duplicate static modifier', mod.span);
           }
           isStatic = true;
         } else if (isConstructor && mod.kind == TokenKind.CONST) {
           if (isConst) {
             world.error('duplicate const modifier', mod.span);
           }
           isConst = true;
         } else if (mod.kind == TokenKind.FACTORY) {
           if (isFactory) {
             world.error('duplicate factory modifier', mod.span);
           }
           isFactory = true;
         } else if (mod.kind == TokenKind.ABSTRACT) {
           if (isAbstract) {
-           world.error('duplicate abstract modifier', mod.span);
+            if (declaringType.isClass) {
+              world.error('duplicate abstract modifier', mod.span);
+            } else {
+              world.error('abstract modifier not allowed on interface members',
+                mod.span);
+            }
           }
           isAbstract = true;
         } else {
           world.error('${mod} modifier not allowed on method', mod.span);
         }
       }
     }
 
     if (isFactory) {
       isStatic = true;
     }
 
     if (isAbstract) {
-      if (definition.body != null) {
+      if (definition.body != null &&
+          declaringType.definition is! FunctionTypeDefinition) {
+        // TODO(jimhug): Creating function types for concrete methods is
+        //   steadily feeling uglier...
         world.error('abstract method can not have a body',
           definition.body.span);
       }
-      if (isStatic) {
+      if (isStatic &&
+          declaringType.definition is! FunctionTypeDefinition) {
         world.error('static method can not be abstract', definition.span);
       }
     } else {
-      // TODO(jimhug): proper checks for bodies on non-interfaces
+      if (definition.body == null && !isConstructor) {
+        world.error('method needs a body', span);
+      }
     }
 
     if (isConstructor) {
       returnType = declaringType;
     } else {
       // TODO(jimhug): Unify this check and the below with method's
       //   resolveType method - requires cleaning up inType stuff.
       returnType = inType.resolveType(definition.returnType, false);
 
       if (isStatic && returnType.hasTypeParams) {
@@ skipping 282 matching lines @@
   }
 
   void forEach(void f(Member member)) {
     factories.forEach((_, Map constructors) {
       constructors.forEach((_, Member member) {
         f(member);
       });
     });
   }
 }