Add an incremental reloader example and a utility tool to trigger a reload by

pkg/front_end/test/incremental_kernel_generator_test.dart

 // Copyright (c) 2017, 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.
 
 import 'dart:async';
 
 import 'package:front_end/compiler_options.dart';
 import 'package:front_end/incremental_kernel_generator.dart';
 import 'package:front_end/memory_file_system.dart';
 import 'package:front_end/src/incremental/byte_store.dart';
@@ skipping 645 matching lines @@
 
 static field core::String a = "aaa";
 static field core::double c = self::b;
 static field core::double b = 2.3 /* from file:///test/lib/bar.dart */;
 static field core::String d = self::a /* from file:///test/lib/bar.dart */;
 static method main() → void {}
 ''');
     }
   }
 
+  test_invalidateAll() async {
+    writeFile('/test/.packages', '');
+    Uri aUri = writeFile('/test/a.dart', "import 'b.dart';\nint a = b;");
+    Uri bUri = writeFile('/test/b.dart', 'var b = 1;');
+
+    Program program = await getInitialState(aUri);
+    expect(_getLibraryText(_getLibrary(program, aUri)), contains("int a ="));

[Siggi Cherem (dart-lang), 2017/06/07 20:17:11]

Let me know if you prefer that I check the full text of the library. I felt that
this was the main relevant subset to compare before and after.

Aside -- I find it a bit hard to navigate code when we have multiline strings
inlined, especially when those strings start from the margin and are not
indented. Would you be OK if we indent them? It is easy to do for the input
programs, but we'd need to trim the whitespace to do it also for the output
expectations. Another alternative would be to move code snippets to the bottom
of the file and add a bunch of top-level variables/getters for those.

[scheglov, 2017/06/07 20:26:32]

Verifying only relevant parts is perfectly fine.

Multiline strings work fine when you use IDEA with its semantic highlighting.
All tests in Analyzer and Analysis Server are written in this style.

I would prefer to keep our test methods self contained, without external
variables.

[Siggi Cherem (dart-lang), 2017/06/07 20:51:09]

I have highlighting too :) - the problem is that I do like scanning code
visually and indentation helps with that. The multi-line strings break that flow
for me.
I can relate to that. The other idea of indenting is a small change. Basically
instead of:

  test_compile_export_cycle() async {
    Uri cUri = writeFile(
        cPath,
        r'''
import 'b.dart';
A a;
B b;
''');

    expect(
        _getLibraryText(library),
        r'''
library;
import self as self;
import "./a.dart" as a;
import "./b.dart" as b;

static field a::A a;
static field b::B b;
''');
  }


We would write it as:

  test_compile_export_cycle() async {
    Uri cUri = writeFile(
        cPath,
        r'''
        import 'b.dart';
        A a;
        B b;
        ''');

    expect(
        _getLibraryText(library),
        r'''
        library;
        import self as self;
        import "./a.dart" as a;
        import "./b.dart" as b;

        static field a::A a;
        static field b::B b;
        '''.replaceAll('\n          ','\n'));
  }



(or we could compare ignoring whitespace, or automate the process of trimming
indentation based on the whitespace on the first line)

Thoughts?

+    expect(_getLibraryText(_getLibrary(program, bUri)), contains("b = 1"));
+
+    writeFile('/test/a.dart', "import 'b.dart';\ndouble a = b;");
+    writeFile('/test/b.dart', 'var b = 2;');
+    incrementalKernelGenerator.invalidateAll();
+
+    DeltaProgram delta = await incrementalKernelGenerator.computeDelta();
+    program = delta.newProgram;
+    _assertLibraryUris(program, includes: [aUri, bUri]);
+    expect(_getLibraryText(_getLibrary(program, aUri)), contains("double a ="));
+    expect(_getLibraryText(_getLibrary(program, bUri)), contains("b = 2"));
+  }
+
   /// Write the given [text] of the file with the given [path] into the
   /// virtual filesystem.  Return the URI of the file.
   Uri writeFile(String path, String text) {
     Uri uri = Uri.parse('file://$path');
     fileSystem.entityForUri(uri).writeAsStringSync(text);
     return uri;
   }
 
   /// Write the given file contents to the virtual filesystem.
   void writeFiles(Map<String, String> contents) {
@@ skipping 19 matching lines @@
     throw fail('No library found with URI "$uri"');
   }
 
   String _getLibraryText(Library library) {
     StringBuffer buffer = new StringBuffer();
     new Printer(buffer, syntheticNames: new NameSystem())
         .writeLibraryFile(library);
     return buffer.toString();
   }
 }