Support proper unparse of is and is!.

lib/compiler/implementation/tree/unparser.dart

Index: lib/compiler/implementation/tree/unparser.dart
diff --git a/lib/compiler/implementation/tree/unparser.dart b/lib/compiler/implementation/tree/unparser.dart
index 05b24260254451bb67f314f740ba13b5e4956b95..e6136f2cade277e7ac5247227fb4a1bc24c5978f 100644
--- a/lib/compiler/implementation/tree/unparser.dart
+++ b/lib/compiler/implementation/tree/unparser.dart
@@ -194,6 +194,23 @@ class Unparser implements Visitor {
   }
 
   visitSend(Send node) {
+    // Special case.  Simple expr is T is represented as Send(expr, 'is', T),

[Anton Muhin, 2012/05/23 19:41:11]

this is rather ugly.

I try to emit expr is! Type exactly like that (we can probably save one space
here).

Peter, why do we have such a representation of is! ?

[ahe, 2012/05/24 09:30:52]

This is the result of an allergic reaction to
http://code.google.com/p/dart/source/browse/branches/bleeding_edge/dart/compi...

Perhaps we went too far in the opposite direction.

However, there are reasons for the madness. The less classes the AST hierarchy
is composed of, the more flexible it is. Flexibility is important for dealing
with syntax errors.

For example, we could have used this AST node to represent an is-check:

class IsCheck extends Node {
  Expression expression;
  TypeAnnotation typeAnnotation;
  bool isNegative;
}

But then we wouldn't be able to represent a parse tree for this bogus code:

if (foo is (1+2)) { ... }

Representing junk like that is important for an editor to be able to do code
completion at any point.

The problem we haven't solved is how to make it convenient to work with the more
flexible AST nodes.

[ahe, 2012/05/24 09:30:52]

Extra space after period.

[ahe, 2012/05/24 09:30:52]

I suggest that you put code snippets in [:...:], for example:

// Special case.  Simple [:expr is T:] is represented as [:Send(expr, 'is',
T):],

[Anton Muhin, 2012/05/24 14:15:12]

I see, still prefixing a type with negation looks like a hack to me, I'd rather
have more something like;

expr is Type = Send(expr, Operator('is'), Type)

and

expr is! Type = Send(expr, Operator('is!'), Type

or something of that kind.

On 2012/05/24 09:30:52, ahe wrote:

[Anton Muhin, 2012/05/24 14:15:12]

Now obsolete.  So you don't use two spaces after period, will mark.

On 2012/05/24 09:30:52, ahe wrote:

[Anton Muhin, 2012/05/24 14:15:12]

Now obsolete, but will do next time.

On 2012/05/24 09:30:52, ahe wrote:

+    // while expr is! T is represented as Send(expr, 'is', Send.prefix('!', T)).
+    if (node.isOperator && node.selector.token.value.stringValue == 'is') {
+      visit(node.receiver);
+      sb.add(' is');
+      bool notForm = node.arguments.head is Send;
+      if (notForm) sb.add('!');
+      sb.add(' ');
+      if (notForm) {
+        visit(node.arguments.head.receiver);
+      } else {
+        visit(node.argumentsNode);
+      }
+
+      return;
+    }
+
     unparseSendPart(node);
     visit(node.argumentsNode);
   }