Start working on unparse validation.

lib/compiler/implementation/compiler.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 WorkItem {
   final Element element;
   TreeElements resolutionTree;
   bool allowSpeculativeOptimization = true;
   List<HTypeGuard> guards = const <HTypeGuard>[];
 
@@ skipping 63 matching lines @@
 }
 
 class Compiler implements DiagnosticListener {
   Queue<WorkItem> codegenQueue;
   Universe universe;
   World world;
   String assembledCode;
   Namer namer;
   Types types;
   bool enableTypeAssertions = false;
+  bool unparseValidation = false;
 
   final Tracer tracer;
 
   CompilerTask measuredTask;
   Element _currentElement;
   LibraryElement coreLibrary;
   LibraryElement coreImplLibrary;
   LibraryElement isolateLibrary;
   LibraryElement jsHelperLibrary;
   LibraryElement interceptorsLibrary;
@@ skipping 263 matching lines @@
     if (!codegenQueue.isEmpty()) {
       internalErrorOnElement(codegenQueue.first().element,
                              "work list is not empty");
     }
   }
 
   TreeElements analyzeElement(Element element) {
     assert(parser !== null);
     Node tree = parser.parse(element);
     validator.validate(tree);
+    if (unparseValidation) {
+      checkUnparse(element, this);

[Anton Muhin, 2012/05/16 16:00:58]

I considered several other options, but found this one most straightforward.

Other options:

a) add another compiler task;
b) add this functionality into validator (and pass element too)

+    }
     TreeElements elements = resolver.resolve(element);
     checker.check(tree, elements);
     return elements;
   }
 
   TreeElements analyze(WorkItem work) {
     work.resolutionTree = analyzeElement(work.element);
     return work.resolutionTree;
   }
 
@@ skipping 210 matching lines @@
   }
 }
 
 class SourceSpan {
   final Uri uri;
   final int begin;
   final int end;
 
   const SourceSpan(this.uri, this.begin, this.end);
 }
+
+void checkUnparse(Element element, Compiler compiler) {

[ahe, 2012/05/21 16:53:29]

I don't like having this method here :-)

A task as you suggest above would be nice. Perhaps in a new file.

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

Done.

+  if (element is! PartialFunctionElement) {
+    // TODO(antonm): consider supporting other kinds of elements.
+    return;
+  }
+
+  PartialFunctionElement originalFunction = element;
+  String unparsed = compiler.parser.parse(originalFunction).unparse(false);

[ahe, 2012/05/21 16:53:29]

I think this should be originalFunction.parseNode(compiler);

And perhaps you should store this result in originalNode as you use below.

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

Done.

+  Token newTokens = new StringScanner(unparsed).tokenize();
+  Token lastToken = newTokens;
+  while (lastToken.info !== EOF_INFO) {
+    lastToken = lastToken.next;
+  }
+
+  PartialFunctionElement newFunction = new PartialFunctionElement(
+      originalFunction.name,
+      newTokens,
+      originalFunction.getOrSet,

[ahe, 2012/05/21 16:53:29]

Unfortunately, this will not work.

Everything after line 610 should be replaced with something like:


// Find the getOrSet token.
// TODO(ahe): This is to frigging complicated. Simplify it.
var dummy = new Listener();
Parser parser = new Parser(dummy);
Token token = parser.parseModifiers(newTokens);
Token getOrSet = parser.findGetOrSet(token);

// TODO(ahe): This is also too frigging complicated.
var script = element.getCompilationUnit().script;
var lib = new LibraryElement(script);
NodeListener listener = new NodeListener(compiler, lib);
parser = new Parser(listener);
compiler.withCurrentElement(lib, () {
  parser.parseFunction(newTokens, getOrSet);
});

FunctionExpression newNode = listener.popNode();

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

Done.

+      lastToken,
+      originalFunction.kind,
+      originalFunction.modifiers,
+      originalFunction.enclosingElement);
+
+  Node originalNode = originalFunction.parseNode(compiler);
+  Node newNode = newFunction.parseNode(compiler);

[Anton Muhin, 2012/05/16 16:00:58]

as of now in some cases we cannot even parse unparsed code (is! provides
something like varis!Type).

Alas, for now error location reporting is off, I need to work some more to amend
it.

+  // TODO(antonm): add Node comparison.
+}