Support proper unparse of is and is!.

lib/compiler/implementation/tree/unparser.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.
 
 class Unparser implements Visitor {
   StringBuffer sb;
   final bool printDebugInfo;
 
   Unparser([this.printDebugInfo = false]);
 
@@ skipping 166 matching lines @@
       visit(node.expression);
     }
     if (node.endToken !== null) add(node.endToken.value);
   }
 
 
   unparseSendPart(Send node) {
     if (node.isPrefix) {
       visit(node.selector);
     }
     if (node.receiver !== null) {

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

How about this:

    Operator op = node.selector.asOperator();
    bool isCheck = op !== null && op.source.stringValue === 'is';
    if (node.receiver !== null) {
      visit(node.receiver);
      if (op === null) {
        sb.add('.');
      } else if (isCheck) {
        sb.add(' ');
      }
    }
    if (!node.isPrefix) {
      visit(node.selector);
    }
    if (isCheck) sb.add(' ');

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

Done with following changes:

1) == 'is' instead of === 'is' (does language guarantees that === will wok
here?)

2) I need slightly more involved logic: I don't emit trailing space for is! form
and hence I get 'expr is!Type' which is apparently correct Dart;
3) I didn't use if (isCheck) sb.add(' ') to follow the style of the function.  I
can turn all ifs into single-lines if you prefer that.

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

       visit(node.receiver);
       if (node.selector is !Operator) sb.add('.');
     }
     if (!node.isPrefix) {
       visit(node.selector);
     }
   }
 
   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);
   }
 
   visitSendSet(SendSet node) {
     unparseSendPart(node);
     add(node.assignmentOperator.token.value);
     visit(node.argumentsNode);
   }
 
@@ skipping 196 matching lines @@
       sb.add(' ');
     }
     visit(node.name);
     if (node.typeParameters !== null) {
       visit(node.typeParameters);
     }
     visit(node.formals);
     add(node.endToken.value);
   }
 }