First steps toward AST-based type inference involving closures.

pkg/analyzer/test/src/summary/summary_common.dart

 // Copyright (c) 2015, 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 analyzer.test.src.summary.summary_common;
 
 import 'package:analyzer/analyzer.dart';
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/src/dart/scanner/reader.dart';
@@ skipping 1754 matching lines @@
 class C<T> {
   final x;
   const C(T) : x = T;
 }
 ''');
     _assertUnlinkedConst(cls.executables[0].constantInitializers[0].expression,
         operators: [UnlinkedConstOperation.pushConstructorParameter],
         strings: ['T']);
   }
 
+  test_constExpr_functionExpression_asArgument() {
+    // Even though function expressions are not allowed in constant
+    // declarations, they might occur due to erroneous code, so make sure they
+    // function correctly.
+    UnlinkedVariable variable = serializeVariableText('''
+const v = foo(5, () => 42);
+foo(a, b) {}
+''');
+    _assertUnlinkedConst(variable.constExpr, isValidConst: false, operators: [
+      UnlinkedConstOperation.pushInt,
+      UnlinkedConstOperation.pushLocalFunctionReference,
+      UnlinkedConstOperation.invokeMethodRef
+    ], ints: [
+      5,
+      0,
+      0,
+      0,
+      2
+    ], referenceValidators: [
+      (EntityRef r) => checkTypeRef(r, null, null, 'foo',
+          expectedKind: ReferenceKind.topLevelFunction)
+    ]);
+  }
+
+  test_constExpr_functionExpression_asArgument_multiple() {
+    // Even though function expressions are not allowed in constant
+    // declarations, they might occur due to erroneous code, so make sure they
+    // function correctly.
+    UnlinkedVariable variable = serializeVariableText('''
+const v = foo(5, () => 42, () => 43);
+foo(a, b, c) {}
+''');
+    _assertUnlinkedConst(variable.constExpr, isValidConst: false, operators: [
+      UnlinkedConstOperation.pushInt,
+      UnlinkedConstOperation.pushLocalFunctionReference,
+      UnlinkedConstOperation.pushLocalFunctionReference,
+      UnlinkedConstOperation.invokeMethodRef
+    ], ints: [
+      5,
+      0,
+      0,
+      0,
+      1,
+      0,
+      3
+    ], referenceValidators: [
+      (EntityRef r) => checkTypeRef(r, null, null, 'foo',
+          expectedKind: ReferenceKind.topLevelFunction)
+    ]);
+  }
+
   test_constExpr_invokeConstructor_generic_named() {
     UnlinkedVariable variable = serializeVariableText('''
 class C<K, V> {
   const C.named();
 }
 const v = const C<int, String>.named();
 ''');
     _assertUnlinkedConst(variable.constExpr, operators: [
       UnlinkedConstOperation.invokeConstructor,
     ], ints: [
@@ skipping 5012 matching lines @@
   test_expr_functionExpression_asArgument() {
     if (skipNonConstInitializers) {
       return;
     }
     UnlinkedVariable variable = serializeVariableText('''
 final v = foo(5, () => 42);
 foo(a, b) {}
 ''');
     _assertUnlinkedConst(variable.constExpr, isValidConst: false, operators: [
       UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.pushNull,
+      UnlinkedConstOperation.pushLocalFunctionReference,
       UnlinkedConstOperation.invokeMethodRef
     ], ints: [
       5,
       0,
+      0,
+      0,
       2
     ], referenceValidators: [
       (EntityRef r) => checkTypeRef(r, null, null, 'foo',
           expectedKind: ReferenceKind.topLevelFunction)
     ]);
   }
 
+  test_expr_functionExpression_asArgument_multiple() {
+    if (skipNonConstInitializers) {
+      return;
+    }
+    UnlinkedVariable variable = serializeVariableText('''
+final v = foo(5, () => 42, () => 43);
+foo(a, b, c) {}
+''');
+    _assertUnlinkedConst(variable.constExpr, isValidConst: false, operators: [
+      UnlinkedConstOperation.pushInt,
+      UnlinkedConstOperation.pushLocalFunctionReference,
+      UnlinkedConstOperation.pushLocalFunctionReference,
+      UnlinkedConstOperation.invokeMethodRef
+    ], ints: [
+      5,
+      0,
+      0,
+      0,
+      1,
+      0,
+      3
+    ], referenceValidators: [
+      (EntityRef r) => checkTypeRef(r, null, null, 'foo',
+          expectedKind: ReferenceKind.topLevelFunction)
+    ]);
+  }
+
   test_expr_functionExpression_withBlockBody() {
     if (skipNonConstInitializers) {
       return;
     }
     UnlinkedVariable variable = serializeVariableText('''
 final v = () { return 42; };
 ''');
     _assertUnlinkedConst(variable.constExpr,
-        isValidConst: false, operators: [UnlinkedConstOperation.pushNull]);
+        isValidConst: false,
+        operators: [UnlinkedConstOperation.pushLocalFunctionReference],
+        ints: [0, 0]);
   }
 
   test_expr_functionExpression_withExpressionBody() {
     if (skipNonConstInitializers) {
       return;
     }
     UnlinkedVariable variable = serializeVariableText('''
 final v = () => 42;
 ''');
     _assertUnlinkedConst(variable.constExpr,
-        isValidConst: false, operators: [UnlinkedConstOperation.pushNull]);
+        isValidConst: false,
+        operators: [UnlinkedConstOperation.pushLocalFunctionReference],
+        ints: [0, 0]);
   }
 
   test_expr_functionExpressionInvocation_withBlockBody() {
     if (skipNonConstInitializers) {
       return;
     }
     UnlinkedVariable variable = serializeVariableText('''
 final v = ((a, b) {return 42;})(1, 2);
 ''');
     _assertUnlinkedConst(variable.constExpr,
@@ skipping 2092 matching lines @@
     UnlinkedExecutable f =
         serializeExecutableText('set f(int value) {}', executableName: 'f=');
     expect(f.inferredReturnTypeSlot, 0);
   }
 
   test_slot_reuse() {
     // Different compilation units have independent notions of slot id, so slot
     // ids should be reused.
     addNamedSource('/a.dart', 'part of foo; final v = 0;');
     serializeLibraryText('library foo; part "a.dart"; final w = 0;');
-    expect(unlinkedUnits[0].variables[0].propagatedTypeSlot, 1);
-    expect(unlinkedUnits[1].variables[0].propagatedTypeSlot, 1);
+    expect(unlinkedUnits[1].variables[0].propagatedTypeSlot,
+        unlinkedUnits[0].variables[0].propagatedTypeSlot);
   }
 
   test_syntheticFunctionType_genericClosure() {
     if (skipFullyLinkedData) {
       return;
     }
     if (!strongMode) {
       // The test below uses generic comment syntax because proper generic
       // method syntax doesn't support generic closures.  So it can only run in
       // strong mode.
@@ skipping 1051 matching lines @@
 class _PrefixExpectation {
   final ReferenceKind kind;
   final String name;
   final String absoluteUri;
   final String relativeUri;
   final int numTypeParameters;
 
   _PrefixExpectation(this.kind, this.name,
       {this.absoluteUri, this.relativeUri, this.numTypeParameters: 0});
 }