Use serialized scope info to test incremental compiler.

dart/tests/try/web/incremental_compilation_update_test.dart

 // Copyright (c) 2014, 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.
 
 library trydart.incremental_compilation_update_test;
 
-import 'dart:html';
+import 'dart:html' hide
+    Element;
 
 import 'dart:async' show
     Future;
 
 import 'package:async_helper/async_helper.dart' show
     asyncTest;
 
+import 'package:expect/expect.dart' show
+    Expect;
+
 import 'package:try/src/interaction_manager.dart' show
     splitLines;
 
+import 'package:try/poi/scope_information_visitor.dart' show
+    ScopeInformationVisitor;
+
 import 'sandbox.dart' show
     appendIFrame,
     listener;
 
 import 'web_compiler_test_case.dart' show
     WebCompilerTestCase,
     WebInputProvider;
 
+import '../poi/compiler_test_case.dart' show
+    CompilerTestCase;
+
+import 'package:compiler/src/elements/elements.dart' show
+    Element,
+    LibraryElement;
+
+import 'package:compiler/src/dart2jslib.dart' show
+    Compiler;
+
 import 'program_result.dart';
 
 const int TIMEOUT = 100;
 
 const List<List<ProgramResult>> tests = const <List<ProgramResult>>[
     // Basic hello-world test.
     const <ProgramResult>[
         const ProgramResult(
             "main() { print('Hello, World!'); }",
             const <String> ['Hello, World!']),
@@ skipping 1067 matching lines @@
               test.incrementalCompiler.inputProvider;
           Uri uri = test.scriptUri.resolve('?v${version++}');
           inputProvider.cachedSources[uri] = new Future.value(program.code);
           Future future = test.incrementalCompiler.compileUpdates(
               {test.scriptUri: uri}, logVerbose: logger, logTime: logger);
           return future.then((String update) {
             print({'update': update});
             iframe.contentWindow.postMessage(['apply-update', update], '*');
 
             return listener.expect(
-                program.messagesWith('iframe-dart-updated-main-done'));
+                program.messagesWith('iframe-dart-updated-main-done'))
+                .then((_) {
+                  return new SerializeScopeTestCase(
+                      program.code, test.incrementalCompiler.mainApp,
+                      test.incrementalCompiler.compiler).run();
+                });
           });
         });
       });
     });
   }).then((_) {
     status.style.color = 'limegreen';
 
     // Remove the iframe to work around a bug in test.dart.
     iframe.remove();
   });
 }
 
+class SerializeScopeTestCase extends CompilerTestCase {
+  final String scopeInfo;
+
+  SerializeScopeTestCase(
+      String source,
+      LibraryElement library,
+      Compiler compiler)
+      : scopeInfo = computeScopeInfo(compiler, library),
+        super(source, '${library.canonicalUri}');
+
+  Future run() => mainApp.then(checkScopes);

[Johnni Winther, 2014/11/24 10:30:46]

Maybe `mainApp` should be a function `compileMainApp()` so that this would read
`compileMainApp().then(checkScopes)`.

[ahe, 2014/11/25 14:19:22]

Then it should be something like "loadMainApp", as it doesn't actually compile
the code. I don't see this as a major improvement, and since it would mean
changing existing tests I hesitate to make such a change, unless you feel it
would be a great improvement.

[Johnni Winther, 2014/11/25 14:22:21]

I found it difficult to reason about the control flow since `mainApp` does not
indicate that its an invocation that has side-effects. The renaming can be done
in a separate CL.

[ahe, 2014/11/25 14:30:55]

Since you found it difficult to reason about the code, I'll follow up with a CL
where I rename it.

[ahe, 2014/11/25 15:15:36]

Follow up in https://codereview.chromium.org/757043002.

+
+  void checkScopes(LibraryElement library) {
+    Expect.stringEquals(computeScopeInfo(compiler, library), scopeInfo);
+  }
+
+  static String computeScopeInfo(Compiler compiler, LibraryElement library) {
+    ScopeInformationVisitor visitor =
+        new ScopeInformationVisitor(compiler, library, 0);
+
+    visitor.ignoreImports = true;
+    visitor.indented.write('[\n');
+    visitor.indentationLevel++;
+    visitor.indented;
+    library.accept(visitor);
+    library.forEachLocalMember((Element member) {
+      if (member.isClass) {
+        visitor.buffer.write(',\n');
+        visitor.indented;
+        member.accept(visitor);
+      }
+    });
+    visitor.buffer.write('\n');
+    visitor.indentationLevel--;
+    visitor.indented.write(']');
+    return '${visitor.buffer}';
+  }
+}
+
 void logger(x) {
   print(x);
   bool isCheckedMode = false;
   assert(isCheckedMode = true);
   int timeout = isCheckedMode ? TIMEOUT * 2 : TIMEOUT;
   if (listener.elapsed > timeout) {
     throw 'Test timed out.';
   }
 }
 
-Element numberedLines(String code) {
+DivElement numberedLines(String code) {
   DivElement result = new DivElement();
   result.classes.add("output");
 
   for (String text in splitLines(code)) {
-    Element line = new PreElement()
+    PreElement line = new PreElement()
         ..appendText(text.trimRight())
         ..classes.add("line");
     result.append(line);
   }
 
   return result;
 }
 
 
 StyleElement lineNumberStyle() {
@@ skipping 21 matching lines @@
   position: absolute;
   left: 0px;
   width: 3em;
   text-align: right;
   background-color: lightgoldenrodyellow;
 }
 ''');
   style.type = 'text/css';
   return style;
 }