fix #27151, list and map literals infer using up and down info

pkg/analyzer/lib/src/generated/static_type_analyzer.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 analyzer.src.generated.static_type_analyzer;
 
 import 'dart:collection';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart';
@@ skipping 605 matching lines @@
         DartType argumentType = _getType(argumentTypeName);
         if (argumentType != null) {
           staticType = argumentType;
         }
       }
       _recordStaticType(
           node, _typeProvider.listType.instantiate(<DartType>[staticType]));
       return null;
     }
 
+    DartType listDynamicType =
+        _typeProvider.listType.instantiate(<DartType>[_dynamicType]);
+
     // If there are no type arguments and we are in strong mode, try to infer
     // some arguments.
     if (_strongMode) {
       DartType contextType = InferenceContext.getType(node);
 
-      // If we have a type from the context, use it.
-      if (contextType is InterfaceType &&
-          contextType.typeArguments.length == 1 &&
-          contextType.element == _typeProvider.listType.element) {
-        _resolver.inferenceContext.recordInference(node, contextType);
-        _recordStaticType(node, contextType);
-        return null;
-      }
+      // Use both downwards and upwards information to infer the type.
+      var ts = _typeSystem as StrongTypeSystemImpl;
+      var elementTypes = node.elements
+          .map((e) => e.staticType)
+          .where((t) => t != null)
+          .toList();
+      var listTypeParam = _typeProvider.listType.typeParameters[0].type;
 
-      // If we don't have a type from the context, try to infer from the
-      // elements
-      if (node.elements.isNotEmpty) {
-        // Infer the list type from the arguments.
-        Iterable<DartType> types =
-            node.elements.map((e) => e.staticType).where((t) => t != null);
-        if (types.isEmpty) {
-          return null;
-        }
-        DartType staticType = types.reduce(_leastUpperBound);
-        if (staticType.isBottom) {
-          staticType = _dynamicType;
-        }
-        DartType listLiteralType =
-            _typeProvider.listType.instantiate(<DartType>[staticType]);
-        if (!staticType.isDynamic) {
-          _resolver.inferenceContext.recordInference(node, listLiteralType);
-        }
-        _recordStaticType(node, listLiteralType);
+      DartType inferred = ts.inferGenericFunctionCall(
+          _typeProvider,
+          _typeProvider.listType,
+          new List.filled(elementTypes.length, listTypeParam),
+          elementTypes,
+          _typeProvider.listType,
+          contextType,
+          errorReporter: _resolver.errorReporter,
+          errorNode: node);
+
+      if (inferred != listDynamicType) {
+        // TODO(jmesserly): this results in an "inferred" message even when we
+        // in fact had an error above, because it will still attempt to return
+        // a type. Perhaps we should record inference from TypeSystem if
+        // everything was successful?
+        _resolver.inferenceContext.recordInference(node, inferred);
+        _recordStaticType(node, inferred);
         return null;
       }
     }
 
     // If we have no type arguments and couldn't infer any, use dynamic.
-    _recordStaticType(
-        node, _typeProvider.listType.instantiate(<DartType>[_dynamicType]));
+    _recordStaticType(node, listDynamicType);
     return null;
   }
 
   /**
    * The Dart Language Specification, 12.7: <blockquote>The static type of a map literal of the form
    * <i><b>const</b> &lt;K, V&gt; {k<sub>1</sub>:e<sub>1</sub>, &hellip;,
    * k<sub>n</sub>:e<sub>n</sub>}</i> or the form <i>&lt;K, V&gt; {k<sub>1</sub>:e<sub>1</sub>,
    * &hellip;, k<sub>n</sub>:e<sub>n</sub>}</i> is `Map&lt;K, V&gt;`. The static type a map
    * literal of the form <i><b>const</b> {k<sub>1</sub>:e<sub>1</sub>, &hellip;,
    * k<sub>n</sub>:e<sub>n</sub>}</i> or the form <i>{k<sub>1</sub>:e<sub>1</sub>, &hellip;,
    * k<sub>n</sub>:e<sub>n</sub>}</i> is `Map&lt;dynamic, dynamic&gt;`.
    *
    * It is a compile-time error if the first type argument to a map literal is not
    * <i>String</i>.</blockquote>
    */
   @override
   Object visitMapLiteral(MapLiteral node) {
     TypeArgumentList typeArguments = node.typeArguments;
 
+    DartType mapDynamicType = _typeProvider.mapType
+        .instantiate(<DartType>[_dynamicType, _dynamicType]);
+
     // If we have type arguments, use them
     if (typeArguments != null) {
       DartType staticKeyType = _dynamicType;
       DartType staticValueType = _dynamicType;
       NodeList<TypeName> arguments = typeArguments.arguments;
       if (arguments != null && arguments.length == 2) {
         TypeName entryKeyTypeName = arguments[0];
         DartType entryKeyType = _getType(entryKeyTypeName);
         if (entryKeyType != null) {
           staticKeyType = entryKeyType;
         }
         TypeName entryValueTypeName = arguments[1];
         DartType entryValueType = _getType(entryValueTypeName);
         if (entryValueType != null) {
           staticValueType = entryValueType;
         }
       }
       _recordStaticType(
           node,
           _typeProvider.mapType
               .instantiate(<DartType>[staticKeyType, staticValueType]));
       return null;
     }
 
     // If we have no explicit type arguments, and we are in strong mode
     // then try to infer type arguments.
     if (_strongMode) {
       DartType contextType = InferenceContext.getType(node);
-      // If we have a context type, use that for inference.
-      if (contextType is InterfaceType &&
-          contextType.typeArguments.length == 2 &&
-          contextType.element == _typeProvider.mapType.element) {
-        _resolver.inferenceContext.recordInference(node, contextType);
-        _recordStaticType(node, contextType);
-        return null;
-      }
 
-      // Otherwise, try to infer a type from the keys and values.
-      if (node.entries.isNotEmpty) {
-        DartType staticKeyType =
-            node.entries.map((e) => e.key.staticType).reduce(_leastUpperBound);
-        DartType staticValueType = node.entries
-            .map((e) => e.value.staticType)
-            .reduce(_leastUpperBound);
-        if (staticKeyType.isBottom) {
-          staticKeyType = _dynamicType;
-        }
-        if (staticValueType.isBottom) {
-          staticValueType = _dynamicType;
-        }
-        DartType mapLiteralType = _typeProvider.mapType
-            .instantiate(<DartType>[staticKeyType, staticValueType]);
-        if (!(staticValueType.isDynamic && staticKeyType.isDynamic)) {
-          _resolver.inferenceContext.recordInference(node, mapLiteralType);
-        }
-        _recordStaticType(node, mapLiteralType);
+      // Use both downwards and upwards information to infer the type.
+      var ts = _typeSystem as StrongTypeSystemImpl;
+      var keyTypes =
+          node.entries.map((e) => e.key.staticType).where((t) => t != null);
+      var valueTypes =
+          node.entries.map((e) => e.value.staticType).where((t) => t != null);
+      var keyTypeParam = _typeProvider.mapType.typeParameters[0].type;
+      var valueTypeParam = _typeProvider.mapType.typeParameters[1].type;
+
+      DartType inferred = ts.inferGenericFunctionCall(
+          _typeProvider,
+          _typeProvider.mapType,
+          new List.filled(keyTypes.length, keyTypeParam, growable: true)
+            ..addAll(new List.filled(valueTypes.length, valueTypeParam)),
+          new List.from(keyTypes)..addAll(valueTypes),
+          _typeProvider.mapType,
+          contextType,
+          errorReporter: _resolver.errorReporter,
+          errorNode: node);
+
+      if (inferred != mapDynamicType) {
+        // TODO(jmesserly): this results in an "inferred" message even when we
+        // in fact had an error above, because it will still attempt to return
+        // a type. Perhaps we should record inference from TypeSystem if
+        // everything was successful?
+        _resolver.inferenceContext.recordInference(node, inferred);
+        _recordStaticType(node, inferred);
         return null;
       }
     }
 
     // If no type arguments and no inference, use dynamic
-    _recordStaticType(
-        node,
-        _typeProvider.mapType
-            .instantiate(<DartType>[_dynamicType, _dynamicType]));
+    _recordStaticType(node, mapDynamicType);
     return null;
   }
 
   /**
    * The Dart Language Specification, 12.15.1: <blockquote>An ordinary method invocation <i>i</i>
    * has the form <i>o.m(a<sub>1</sub>, &hellip;, a<sub>n</sub>, x<sub>n+1</sub>: a<sub>n+1</sub>,
    * &hellip;, x<sub>n+k</sub>: a<sub>n+k</sub>)</i>.
    *
    * Let <i>T</i> be the static type of <i>o</i>. It is a static type warning if <i>T</i> does not
    * have an accessible instance member named <i>m</i>. If <i>T.m</i> exists, it is a static warning
@@ skipping 1219 matching lines @@
               ..synthetic = true
               ..shareParameters(firstParamType.parameters)
               ..returnType = paramReturnType;
             function.type = new FunctionTypeImpl(function);
             // Use this as the expected 1st parameter type.
             paramTypes[0] = function.type;
           }
         }
       }
       return ts.inferGenericFunctionCall(_typeProvider, fnType, paramTypes,
-          argTypes, InferenceContext.getContext(node),
+          argTypes, fnType.returnType, InferenceContext.getContext(node),
           errorReporter: _resolver.errorReporter, errorNode: errorNode);
     }
     return null;
   }
 
   /**
    * Given an instance creation of a possibly generic type, infer the type
    * arguments using the current context type as well as the argument types.
    */
   void _inferInstanceCreationExpression(InstanceCreationExpression node) {
@@ skipping 244 matching lines @@
             (parent.parent is TypeName || identical(parent.prefix, node))) ||
         (parent is PropertyAccess &&
             identical(parent.target, node) &&
             parent.operator.type == TokenType.PERIOD) ||
         (parent is MethodInvocation &&
             identical(node, parent.target) &&
             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.
    *
    * @param expression the node whose type is to be recorded
    * @param type the propagated type of the node
    */
   void _recordPropagatedType(Expression expression, DartType type) {
     if (type != null && !type.isDynamic && !type.isBottom) {
       expression.propagatedType = type;
     }
   }
@@ skipping 135 matching lines @@
     }
     // merge types
     if (result == null) {
       result = type;
     } else {
       result = _typeSystem.getLeastUpperBound(_typeProvider, result, type);
     }
     return null;
   }
 }