Start working on unparse validation.

lib/compiler/implementation/unparse_validator.dart

Index: lib/compiler/implementation/unparse_validator.dart
diff --git a/lib/compiler/implementation/unparse_validator.dart b/lib/compiler/implementation/unparse_validator.dart
new file mode 100644
index 0000000000000000000000000000000000000000..9b2f8f0b4d6ca1eff877728699b0180d4d6c5b5c
--- /dev/null
+++ b/lib/compiler/implementation/unparse_validator.dart
@@ -0,0 +1,60 @@
+// 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.
+
+/**
+ * Checks result's of [Node] unparse.
+ */
+class UnparseValidator extends CompilerTask {
+  final bool validateUnparse;
+
+  UnparseValidator(Compiler compiler, this.validateUnparse) : super(compiler);
+
+  void check(Element element) {
+    if (!validateUnparse) {

[ahe, 2012/05/22 08:49:04]

Just one line:

if (!validateUnparse) return;

[Anton Muhin, 2012/05/22 15:34:32]

Done.

+      return;
+    }
+
+    if (element is! PartialFunctionElement) {

[ahe, 2012/05/22 08:49:04]

Ditto.

[Anton Muhin, 2012/05/22 15:34:32]

Done.

+      // TODO(antonm): consider supporting other kinds of elements.
+      return;
+    }
+
+    PartialFunctionElement originalFunction = element;
+    FunctionExpression originalNode = originalFunction.parseNode(compiler);
+    String unparsed = originalNode.unparse(false);
+
+    Token newTokens = new StringScanner(unparsed).tokenize();
+
+    // Find the getOrSet token.
+    // TODO(ahe): This is to frigging complicated. Simplify it.

[ahe, 2012/05/22 08:49:04]

It's great that you copied this verbatim :-)

[Anton Muhin, 2012/05/22 15:34:32]

:)

+    Parser parser = new Parser(new Listener());
+    Token getOrSet =
+        parser.findGetOrSet(parser.parseModifiers(newTokens));
+
+    // TODO(ahe): This is also too frigging complicated.
+    Script originalScript = element.getCompilationUnit().script;
+    SourceFile synthesizedSourceFile =
+        new SourceFile(originalScript.name, unparsed);
+    Script synthesizedScript =
+        new Script(originalScript.uri, synthesizedSourceFile);
+    LibraryElement lib = new LibraryElement(synthesizedScript);
+    NodeListener listener = new NodeListener(compiler, lib);
+    parser = new Parser(listener);
+    final oldHandler = compiler.handler;

[Anton Muhin, 2012/05/21 19:14:39]

this trick is sketchy, but allows nice diagnostics.

I can probably make it less sketchy with proper tweaking of reportDiagnostics if
you prefer it this way.

[ahe, 2012/05/22 08:49:04]

I don't understand why you have to do this. How is your new handler different?

[Anton Muhin, 2012/05/22 08:56:32]

The old handler will lookup SourceFile via uri and will find the full version of
the file.  Therefore span would be incorrect.  Example, js_helper has
stringToString function with wrongly unparsed construct (is!)  When we parse
unparsed code, span woud point into copyright header of js_helper.dart :)

With overridden handler:

file:///usr/local/google/home/antonm/dart-all/dart/lib/compiler/implementation/lib/js_helper.dart:1:68:
unexpected token '!'                                                            
                      
String stringToString(var value){var res=value.toString(); if(resis!String)throw
new IllegalArgumentException(value); return res;}                               
                                             
                                                                   ^            
                                                                                
                                             
info: compiler cancelled: unexpected token '!'                                  
                                                                                
                                             

w/o it:

lib/compiler/implementation/lib/js_helper.dart:1:68: unexpected token '!'       
                                                                                
                                             
// Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file   
                                                                                
                                             
                                                                   ^            
                                                                                
                                             
info: compiler cancelled: unexpected token '!'                                  
                                                                                
                                             
info: compilation failed                                                        
                                                                                
                                             

On 2012/05/22 08:49:04, ahe wrote:

[ahe, 2012/05/22 09:04:45]

The source file should be found in the "currentElement" of the compiler. So it
should be possible to remove your custom handler.

If that still doesn't work, the element stored in lib is not setup correctly and
we should figure out what is wrong.

[Anton Muhin, 2012/05/22 15:34:32]

As far as I understand it goes like this:

we get into Compiler.cancel with null for a node and proper token.  Therefore we
construct SourceSpan with offsets of synthesized tokens, but with URI of
original file (because we use it for synthesizedLib).  Now SourceSpan has no
notion of original SourceFile and hence error handler refetches it from a
sourceFile map in dart2js.

If I make a fake URI, error handler will just choke as there will be no
corresponding entry.

I would fix it by passing SourceFile instead of uri into error handler.

However, I suspect it was done differently as that minimized compiler API---in
compiler API there is no notion of SourceFile, but ironically dart2js imports
it.

Another option would be to pass fully formatted message into error handler.

What will be your preferences?

And in any event, I'll land this change w/ error handling overrides and defer it
to future CL (with corresponding TODO).

On 2012/05/22 09:04:45, ahe wrote:

[ahe, 2012/05/22 15:50:56]

Shoot. I forgot about the compiler API. It would be cleaner with a compiler
subclass for the validation, but your hack works for now. So please keep it. I
think it is important that the error message is correct in this case. Otherwise
it will be pretty hard to figure out what went wrong.

On 2012/05/22 15:34:32, antonmuhin wrote:

[Anton Muhin, 2012/05/22 19:16:57]

I am sorry, I've already submitted w/o it.  Sending you hopefully better
variant.

On 2012/05/22 15:50:56, ahe wrote:

+    compiler.handler = (uri, begin, end, message, fatal) {
+      final errorMessage =
+          synthesizedSourceFile.getLocationMessage(message, begin, end, true);
+      print('$errorMessage');
+    };
+    try {
+      compiler.withCurrentElement(lib, () {
+        parser.parseFunction(newTokens, getOrSet);
+      });
+    } finally {
+      compiler.handler = oldHandler;
+    }
+    FunctionExpression newNode = listener.popNode();
+    // TODO(antonm): add Node comparison.
+  }
+}