unary operators

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 842 matching lines @@
 
       Arguments.removeTrailingNulls(argsCode);
     }
 
     var argsString = Strings.join(argsCode, ', ');
 
     if (isConstructor) {
       return _invokeConstructor(context, node, target, args, argsString);
     }
 
+    // TODO(jimhug): target really shouldn't ever be null...

[Jennifer Messerly, 2011/11/07 21:29:53]

It's null for constructors, factories, and static (including top-level) methods.
Basically anything that's resolved statically.

I wonder if we should always have a target, but use a Value that represents the
type?

+    if (target != null && target.isSuper) {
+      return new Value(returnType,
+          '${declaringType.jsname}.prototype.$jsname.call($argsString)');
+    }
+
     if (name.startsWith('\$')) {
       return _invokeBuiltin(context, node, target, args, argsCode);
     }
 
-    // TODO(jmesserly): can target ever be null in super call?
-    if (target != null && target.isSuper) {
-      return new Value(returnType,
-          '${declaringType.jsname}.prototype.$jsname.call($argsString)');
-    }
-
     if (isFactory) {
       return new Value(returnType, '$generatedFactoryName($argsString)');
     }
 
     if (isStatic) {
       if (declaringType.isTop) {
         // TODO(jimhug): Explore moving libraries into their own namespaces
         return new Value(returnType, '$jsname($argsString)');
       }
       return new Value(returnType,
@@ skipping 141 matching lines @@
 
     return world.gen.globalForConst(
         new ConstObjectValue(declaringType, fields, code, node.span),
         args.values);
   }
 
 
   Value _invokeBuiltin(MethodGenerator context, Node node, Value target,
       Arguments args, argsCode) {
     var allConst = target.isConst && args.values.every((arg) => arg.isConst);
-    // TODO(jimhug): Handle super calls on special methods.
     // 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?
       if (!allConst) {
         var code;
         if (name == '\$negate') {
           code = '-${target.code}';
         } else if (name == '\$bit_not') {
           code = '~${target.code}';
@@ skipping 85 matching lines @@
         return new EvaluatedValue(world.boolType,
             newVal, "$newVal", node.span);
       }
       // Optimize test when null is on the rhs.
       if (argsCode[0] == 'null') {
         return new Value(returnType, '${target.code} $op null');
       } else if (target.type.isNum || target.type.isString) {
         // TODO(jimhug): Maybe check rhs.
         return new Value(returnType, '${target.code} $op ${argsCode[0]}');
       }
-      return new Value(returnType,
-        '$name(${target.code}, ${argsCode[0]})');
+      return new Value(returnType, '$name(${target.code}, ${argsCode[0]})');
     }
 
     if (name == '\$call') {
       declaringType.markUsed();
       return new Value(returnType,
         '${target.code}(${Strings.join(argsCode, ", ")})');
     }
 
-    return target.invokeSpecial(jsname, args, returnType);
+    // Fall back to normal method invocation.
+    var argsString = Strings.join(argsCode, ', ');
+    return new Value(returnType, '${target.code}.$jsname($argsString)');
   }
 
 
   resolve(Type inType) {
     // TODO(jimhug): cut-and-paste-and-edit from Field.resolve
     isStatic = inType.isTop;
     isConst = false;
     isFactory = false;
     isAbstract = !declaringType.isClass;
     if (definition.modifiers != null) {
@@ skipping 26 matching lines @@
         } else {
           world.error('${mod} modifier not allowed on method', mod.span);
         }
       }
     }
 
     if (isFactory) {
       isStatic = true;
     }
 
+    // TODO(jimhug): need a better annotation for being an operator method

[Jennifer Messerly, 2011/11/07 21:29:53]

+1 :)

+    if (name.startsWith('\$') && !name.startsWith('\$call') && isStatic) {
+      world.error('operator method may not be static "${name}"', span);
+    }
+
     if (isAbstract) {
       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);
+        world.error('abstract method can not have a body', span);
       }
       if (isStatic &&
           declaringType.definition is! FunctionTypeDefinition) {
-        world.error('static method can not be abstract', definition.span);
+        world.error('static method can not be abstract', span);
       }
     } else {
       if (definition.body == null && !isConstructor) {
         world.error('method needs a body', span);
       }
     }
 
     if (isConstructor) {
       returnType = declaringType;
     } else {
@@ skipping 287 matching lines @@
   }
 
   void forEach(void f(Member member)) {
     factories.forEach((_, Map constructors) {
       constructors.forEach((_, Member member) {
         f(member);
       });
     });
   }
 }