Use a poor man's incremental parser to perform incremental resolution.

pkg/analyzer/test/generated/incremental_resolver_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 engine.incremental_resolver_test;
 
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/element.dart';
 import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/generated/error.dart';
@@ skipping 10 matching lines @@
 import '../reflective_tests.dart';
 import 'parser_test.dart';
 import 'resolver_test.dart';
 import 'test_support.dart';
 
 
 main() {
   groupSep = ' | ';
   runReflectiveTests(DeclarationMatcherTest);
   runReflectiveTests(IncrementalResolverTest);
+  runReflectiveTests(PoorMansIncrementalResolutionTest);
   runReflectiveTests(ScopeBuilderTest);
 }
 
 
 class DeclarationMatcherTest extends ResolverTestCase {
   void fail_test_methodDeclarationMatches_false_localVariable() {
     // TODO(scheglov) as I understand DeclarationMatcher, we care only
     // about externally visible model changes. So, because we analyze (at least
     // right now) incremental changes on method level, local variable can be
     // ignored.
@@ skipping 1314 matching lines @@
     var errorListener = new BooleanErrorListener();
     var reader = new CharSequenceReader(code);
     var scanner = new Scanner(null, reader, errorListener);
     var token = scanner.tokenize();
     var parser = new Parser(null, errorListener);
     return parser.parseCompilationUnit(token);
   }
 }
 
 
+/**
+ * The test for [poorMansIncrementalResolution] function and its integration
+ * into [AnalysisContext].
+ */
+class PoorMansIncrementalResolutionTest extends ResolverTestCase {

[Brian Wilkerson, 2014/11/24 15:09:14]

It would be good to test some cases where incremental resolution isn't expected
to work, such as changing the parameters to a function, adding a new top-level
function/variable, new directives, etc.

[scheglov, 2014/11/24 18:59:06]

Agree, but not in this CL.

+  Source source;
+  String code;
+  LibraryElement oldLibrary;
+  CompilationUnit oldUnit;
+  CompilationUnitElement oldUnitElement;
+
+  void setUp() {
+    super.setUp();
+    _resetWithIncremental(true);
+  }
+
+  void test_inBody_expression() {
+    _resolveUnit(r'''
+class A {
+  m() {
+    print(1);
+  }
+}
+''');
+    _updateAndValidate(r'''
+class A {
+  m() {
+    print(2 + 3);
+  }
+}
+''');
+  }
+
+  void test_inBody_insertStatement() {
+    _resolveUnit(r'''
+main() {
+  print(1);
+}
+''');
+    _updateAndValidate(r'''
+main() {
+  print(0);
+  print(1);
+}
+''');
+  }
+
+  void test_inBody_tokenToNode() {
+    _resolveUnit(r'''
+main() {
+  var v = 42;
+}
+''');
+    _updateAndValidate(r'''
+main() {
+  int v = 42;
+}
+''');
+  }
+
+  void test_twice() {
+    _resolveUnit(r'''
+main() {
+  print(1);
+}''');
+    _updateAndValidate(r'''
+main() {
+  print(12);
+}''', false);
+    _updateAndValidate(r'''
+main() {
+  print(1);
+}''', false);
+  }
+
+  void test_twice2() {
+    _resolveUnit(r'''
+class A {
+  m() {
+    int vvvvvvvv = 42;
+    print(vvvvvvvv);
+  }
+}''');
+    _updateAndValidate(r'''
+class A {
+  m() {
+    int vvvvvvvv2 = 42;
+    print(vvvvvvvv2);
+  }
+}''', false);
+    _updateAndValidate(r'''
+class A {
+  m() {
+    int vvvvvvvv = 42;
+    print(vvvvvvvv);
+  }
+}''', false);
+  }
+
+  void test_withImport() {
+    _resolveUnit(r'''
+import 'dart:async';
+import 'dart:io';
+main() {
+  print(1);
+}
+''');
+    _updateAndValidate(r'''
+import 'dart:async';
+import 'dart:io';
+main() {
+  print(2 + 3);
+}
+''');
+  }
+
+  /**
+   * Reset the analysis context to have the 'incremental' option set to the
+   * given value.
+   */
+  void _resetWithIncremental(bool enable) {
+    AnalysisOptionsImpl analysisOptions = new AnalysisOptionsImpl();
+    analysisOptions.incremental = enable;
+    analysisContext2.analysisOptions = analysisOptions;
+  }
+
+  void _resolveUnit(String code) {
+    this.code = code;
+    source = addSource(code);
+    oldLibrary = resolve(source);
+    oldUnit = resolveCompilationUnit(source, oldLibrary);
+    oldUnitElement = oldUnit.element;
+  }
+
+  void _runTasks() {
+    AnalysisResult result = analysisContext.performAnalysisTask();
+    while (result.changeNotices != null) {
+      result = analysisContext.performAnalysisTask();
+    }
+  }
+
+  void _updateAndValidate(String newCode, [bool compareWithFull = true]) {
+    // Run any pending tasks tasks.
+    _runTasks();
+    // Update the source - currently this may cause incremental resolution.
+    // Then request the updated resolved unit.
+    _resetWithIncremental(true);
+    analysisContext2.setContents(source, newCode);
+    CompilationUnit newUnit = resolveCompilationUnit(source, oldLibrary);
+    // The existing CompilationUnitElement should be updated.
+    expect(newUnit.element, same(oldUnitElement));
+    // The only expected pending task should return the same resolved
+    // "newUnit", so all clients will get it using the usual way.
+    AnalysisResult analysisResult = analysisContext.performAnalysisTask();
+    ChangeNotice notice = analysisResult.changeNotices[0];
+    expect(notice.compilationUnit, same(newUnit));
+    // Resolve "newCode" from scratch.
+    if (compareWithFull) {
+      _resetWithIncremental(false);
+      source = addSource(newCode);
+      LibraryElement library = resolve(source);
+      CompilationUnit fullNewUnit = resolveCompilationUnit(source, library);
+      // Validate that "incremental" and "full" units have the same resolution.
+      _SameResolutionValidator.assertSameResolution(newUnit, fullNewUnit);
+    }
+  }
+}
+
+
 class ScopeBuilderTest extends EngineTestCase {
   void test_scopeFor_ClassDeclaration() {
     GatheringErrorListener listener = new GatheringErrorListener();
     Scope scope =
         ScopeBuilder.scopeFor(_createResolvedClassDeclaration(), listener);
     EngineTestCase.assertInstanceOf(
         (obj) => obj is LibraryScope,
         LibraryScope,
         scope);
   }
@@ skipping 1064 matching lines @@
     _visitList(node.metadata, other.metadata);
     _visitNode(node.identifier, other.identifier);
   }
 
   static void assertSameResolution(CompilationUnit actual,
       CompilationUnit expected) {
     _SameResolutionValidator validator = new _SameResolutionValidator(expected);
     actual.accept(validator);
   }
 }