partial fix for #25220, handles inference for list/map literals

[email protected]

Review URL: https://codereview.chromium.org/1717803003 .

Author: John Messerly

pkg/analyzer/lib/src/generated/static_type_analyzer.dart

@@ -626,14 +626,18 @@ class StaticTypeAnalyzer extends SimpleAstVisitor<Object> {
           staticType = argumentType;
         }
       }
-    } else {
+    } else if (_strongMode) {
       DartType contextType = InferenceContext.getType(node);
-      if (_strongMode &&
-          contextType is InterfaceType &&
+      if (contextType is InterfaceType &&
           contextType.typeArguments.length == 1 &&
           contextType.element == _typeProvider.listType.element) {
         staticType = contextType.typeArguments[0];
         _resolver.inferenceContext.recordInference(node, contextType);
+      } else if (node.elements.isNotEmpty) {
+        // Infer the list type from the arguments.
+        staticType =
+            node.elements.map((e) => e.staticType).reduce(_leastUpperBound);
+        // TODO(jmesserly): record inference here?
       }
     }
     _recordStaticType(
@@ -672,15 +676,22 @@ class StaticTypeAnalyzer extends SimpleAstVisitor<Object> {
           staticValueType = entryValueType;
         }
       }
-    } else {
+    } else if (_strongMode) {
       DartType contextType = InferenceContext.getType(node);
-      if (_strongMode &&
-          contextType is InterfaceType &&
+      if (contextType is InterfaceType &&
           contextType.typeArguments.length == 2 &&
           contextType.element == _typeProvider.mapType.element) {
         staticKeyType = contextType.typeArguments[0] ?? staticKeyType;
         staticValueType = contextType.typeArguments[1] ?? staticValueType;
         _resolver.inferenceContext.recordInference(node, contextType);
+      } else if (node.entries.isNotEmpty) {
+        // Infer the list type from the arguments.
+        staticKeyType =
+            node.entries.map((e) => e.key.staticType).reduce(_leastUpperBound);
+        staticValueType = node.entries
+            .map((e) => e.value.staticType)
+            .reduce(_leastUpperBound);
+        // TODO(jmesserly): record inference here?
       }
     }
     _recordStaticType(
@@ -1535,8 +1546,8 @@ class StaticTypeAnalyzer extends SimpleAstVisitor<Object> {
     }
   }
 
-  // TODO(vsm): Use leafp's matchType here?
   DartType _findIteratedType(DartType type, DartType targetType) {
+    // TODO(vsm): Use leafp's matchType here?
     // Set by _find if match is found
     DartType result;
     // Elements we've already visited on a given inheritance path.
@@ -2061,6 +2072,14 @@ class StaticTypeAnalyzer extends SimpleAstVisitor<Object> {
             parent.operator.type == TokenType.PERIOD);
   }
 
+  /**
+   * Computes the least upper bound between two types.
+   *
+   * See [TypeSystem.getLeastUpperBound].
+   */
+  DartType _leastUpperBound(DartType s, DartType t) =>
+      _typeSystem.getLeastUpperBound(_typeProvider, s, t);
+
   /**
    * Record that the propagated type of the given node is the given type.
    *

pkg/analyzer/test/src/context/mock_sdk.dart

@@ -97,6 +97,9 @@ abstract class String implements Comparable<String>, Pattern {
   String toUpperCase();
   List<int> get codeUnits;
 }
+abstract class RegExp implements Pattern {
+  external factory RegExp(String source);
+}
 
 class bool extends Object {}
 abstract class num implements Comparable<num> {
@@ -154,6 +157,8 @@ abstract class List<E> implements Iterable<E> {
 
 abstract class Map<K, V> extends Object {
   Iterable<K> get keys;
+  V operator [](K key);
+  void operator []=(K key, V value);
 }
 
 external bool identical(Object a, Object b);

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

@@ -7077,11 +7077,12 @@ var v;''';
 
   test_variable_initializer_withLocals() {
     String text =
-        'var v = {"1": () { f1() {} var v1; }, "2": () { f2() {} var v2; }};';
+        'var v = <dynamic, dynamic>{"1": () { f1() {} var v1; }, '
+        '"2": () { f2() {} var v2; }};';
     UnlinkedVariable variable = serializeVariableText(text);
     UnlinkedExecutable initializer = variable.initializer;
     expect(initializer, isNotNull);
-    expect(initializer.nameOffset, text.indexOf('{"1'));
+    expect(initializer.nameOffset, text.indexOf('<dynamic, dynamic>{"1'));
     expect(initializer.name, isEmpty);
     expect(initializer.localFunctions, hasLength(2));
     // closure: () { f1() {} var v1; }

pkg/analyzer/test/src/task/strong/inferred_type_test.dart

@@ -339,7 +339,7 @@ void main() {
         var b = new B(/*warning:UNDEFINED_IDENTIFIER*/x);  // allocations
         var c1 = [/*warning:UNDEFINED_IDENTIFIER*/x];      // list literals
         var c2 = const [];
-        var d = {'a': 'b'};     // map literals
+        var d = <dynamic, dynamic>{'a': 'b'};     // map literals
         var e = new A()..x = 3; // cascades
         var f = 2 + 3;          // binary expressions are OK if the left operand
                                 // is from a library in a different strongest
@@ -1580,8 +1580,9 @@ main() {
     checkFile('''
       import 'dart:async';
       Future<int> test() async {
-        List<int> l0 = /*warning:DOWN_CAST_COMPOSITE should be pass*/await /*pass should be info:INFERRED_TYPE_LITERAL*/[3];
-        List<int> l1 = await /*info:INFERRED_TYPE_ALLOCATION*/new Future.value(/*info:INFERRED_TYPE_LITERAL*/[3]);
+        dynamic d;
+        List<int> l0 = /*warning:DOWN_CAST_COMPOSITE should be pass*/await /*pass should be info:INFERRED_TYPE_LITERAL*/[d];
+        List<int> l1 = await /*info:INFERRED_TYPE_ALLOCATION*/new Future.value(/*info:INFERRED_TYPE_LITERAL*/[/*info:DYNAMIC_CAST*/d]);
       }
     ''');
   });
@@ -1877,4 +1878,45 @@ main() {
   ''');
   });
 
+  test('list literals', () {
+    checkFile(r'''
+test1() {
+  var x = [1, 2, 3];
+  x.add(/*severe:STATIC_TYPE_ERROR*/'hi');
+  x.add(/*severe:STATIC_TYPE_ERROR*/4.0);
+  x.add(4);
+  List<num> y = x;
+}
+test2() {
+  var x = [1, 2.0, 3];
+  x.add(/*severe:STATIC_TYPE_ERROR*/'hi');
+  x.add(4.0);
+  List<int> y = /*info:ASSIGNMENT_CAST*/x;
+}
+    ''');
+  });
+
+  test('map literals', () {
+    checkFile(r'''
+test1() {
+  var x = { 1: 'x', 2: 'y' };
+  x[3] = 'z';
+  x[/*severe:STATIC_TYPE_ERROR*/'hi'] = 'w';
+  x[/*severe:STATIC_TYPE_ERROR*/4.0] = 'u';
+  x[3] = /*severe:STATIC_TYPE_ERROR*/42;
+  Map<num, String> y = x;
+}
+
+test2() {
+  var x = { 1: 'x', 2: 'y', 3.0: new RegExp('.') };
+  x[3] = 'z';
+  x[/*severe:STATIC_TYPE_ERROR*/'hi'] = 'w';
+  x[4.0] = 'u';
+  x[3] = /*severe:STATIC_TYPE_ERROR*/42;
+  Pattern p = null;
+  x[2] = p;
+  Map<int, String> y = /*info:ASSIGNMENT_CAST*/x;
+}
+    ''');
+  });
 }