Fix incremental parsing of function literals in initializer lists.

pkg/analyzer/test/generated/parser_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.
 
 // This code was auto-generated, is not intended to be edited, and is subject to
 // significant change. Please see the README file for more information.
 
 library engine.parser_test;
 
 import 'package:analyzer/src/generated/ast.dart';
@@ skipping 2503 matching lines @@
 
   void test_wrongTerminatorForParameterGroup_optional() {
     ParserTestCase.parse4(
         "parseFormalParameterList",
         "(a, [b, c})",
         [ParserErrorCode.WRONG_TERMINATOR_FOR_PARAMETER_GROUP]);
   }
 }
 
 class IncrementalParserTest extends EngineTestCase {
-  void fail_replace_identifier_with_functionLiteral_in_initializer() {
-    // Function literals aren't allowed inside initializers; incremental parsing
-    // needs to gather the appropriate context.
+  void fail_replace_identifier_with_functionLiteral_in_initializer_interp() {
+    // TODO(paulberry, brianwilkerson): broken due to incremental scanning bugs
+
+    // Function literals are allowed inside interpolation expressions in
+    // initializers.
     //
-    // "class A { var a; A(b) : a = b ? b : 0 { } }"
-    // "class A { var a; A(b) : a = b ? () {} : 0 { } }"
-    _assertParse(
-        "class A { var a; A(b) : a = b ? ",
-        "b",
-        "() {}",
-        " : 0 { } }");
+    // 'class A { var a; A(b) : a = "${b}";'
+    // 'class A { var a; A(b) : a = "${() {}}";'
+    _assertParse(r'class A { var a; A(b) : a = "${', 'b', '() {}', '}";');
   }
 
   void test_delete_everything() {
     // "f() => a + b;"
     // ""
     _assertParse("", "f() => a + b;", "", "");
   }
 
   void test_delete_identifier_beginning() {
     // "f() => abs + b;"
@@ skipping 170 matching lines @@
     // "f() => belt + b;"
     _assertParse("f() => bel", "l", "t", " + b;");
   }
 
   void test_replace_identifier_middle() {
     // "f() => first + b;"
     // "f() => frost + b;"
     _assertParse("f() => f", "ir", "ro", "st + b;");
   }
 
+  void test_replace_identifier_with_functionLiteral_in_initializer() {
+    // Function literals aren't allowed inside initializers; incremental parsing
+    // needs to gather the appropriate context.
+    //
+    // "class A { var a; A(b) : a = b ? b : 0 { } }"
+    // "class A { var a; A(b) : a = b ? () {} : 0 { } }"
+    _assertParse(
+        "class A { var a; A(b) : a = b ? ",
+        "b",
+        "() {}",
+        " : 0 { } }");
+  }
+
+  void test_replace_identifier_with_functionLiteral_in_initializer_index() {
+    // Function literals are allowed inside index expressions in initializers.
+    //
+    // "class A { var a; A(b) : a = b[b];"
+    // "class A { var a; A(b) : a = b[() {}];"
+    _assertParse('class A { var a; A(b) : a = b[', 'b', '() {}', '];');
+  }
+
+  void test_replace_identifier_with_functionLiteral_in_initializer_list() {
+    // Function literals are allowed inside list literals in initializers.
+    //
+    // "class A { var a; A(b) : a = [b];"
+    // "class A { var a; A(b) : a = [() {}];"
+    _assertParse('class A { var a; A(b) : a = [', 'b', '() {}', '];');
+  }
+
+  void test_replace_identifier_with_functionLiteral_in_initializer_map() {
+    // Function literals are allowed inside map literals in initializers.
+    //
+    // "class A { var a; A(b) : a = {0: b};"
+    // "class A { var a; A(b) : a = {0: () {}};"
+    _assertParse('class A { var a; A(b) : a = {0: ', 'b', '() {}', '};');
+  }
+
+  void test_replace_identifier_with_functionLiteral_in_initializer_parens() {
+    // Function literals are allowed inside parentheses in initializers.
+    //
+    // "class A { var a; A(b) : a = (b);"
+    // "class A { var a; A(b) : a = (() {});"
+    _assertParse('class A { var a; A(b) : a = (', 'b', '() {}', ');');
+  }
+
   void test_replace_multiple_partialFirstAndLast() {
     // "f() => aa + bb;"
     // "f() => ab * ab;"
     _assertParse("f() => a", "a + b", "b * a", "b;");
   }
 
   void test_replace_operator_oneForMany() {
     // "f() => a + b;"
     // "f() => a * c - b;"
     _assertParse("f() => a ", "+", "* c -", " b;");
@@ skipping 8048 matching lines @@
     // Parse the source.
     //
     Parser parser = new Parser(null, listener);
     return invokeParserMethodImpl(
         parser,
         methodName,
         <Object>[tokenStream],
         tokenStream) as Token;
   }
 }