Add type inference logic for map literals

pkg/front_end/testcases/inference/downwards_inference_yield_yield_star.dart.strong.expect

+library test;
+import self as self;
+import "dart:core" as core;
+import "dart:async" as asy;
+
+abstract class MyStream<T extends core::Object> extends asy::Stream<self::MyStream::T> {
+  static factory •<T extends core::Object>() → dynamic
+    return null;
+}
+static method foo() → asy::Stream<core::List<core::int>> /* originally async* */ {
+  dynamic :controller;
+  dynamic :async_op_then;
+  dynamic :async_op_error;
+  dynamic :await_jump_var = 0;
+  dynamic :await_ctx_var;
+  dynamic :saved_try_context_var0;
+  dynamic :saved_try_context_var1;
+  function :async_op([dynamic :result, dynamic :exception, dynamic :stack_trace]) → dynamic yielding 
+    try
+      try {
+        #L1:
+        {
+          if(:controller.add(<core::int>[]))
+            return null;
+          else
+            [yield] null;
+          if(:controller.add(self::MyStream::•<dynamic>()))
+            return null;
+          else
+            [yield] null;
+          if(:controller.addStream(<dynamic>[]))
+            return null;
+          else
+            [yield] null;
+          if(:controller.addStream(self::MyStream::•<core::List<core::int>>()))
+            return null;
+          else
+            [yield] null;
+        }
+        return;
+      }
+      on dynamic catch(dynamic :exception, dynamic :stack_trace) {
+        :controller.addError(:exception, :stack_trace);
+      }
+    finally {
+      :controller.close();
+    }
+  :async_op_then = asy::_asyncThenWrapperHelper(:async_op);
+  :async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
+  :controller = new asy::_AsyncStarStreamController::•(:async_op);
+  return :controller.stream;
+}
+static method bar() → core::Iterable<core::Map<core::int, core::int>> /* originally sync* */ {
+  dynamic :await_jump_var = 0;
+  dynamic :await_ctx_var;
+  function :sync_op(core::Iterator<dynamic> :iterator) → core::bool yielding {
+    {
+      {
+        :iterator._current = <core::int, core::int>{};
+        [yield] true;
+      }
+      {
+        :iterator._current = core::List::_internal<dynamic>();
+        [yield] true;
+      }
+      {
+        :iterator.isYieldEach = true;
+        :iterator._current = <dynamic, dynamic>{};
+        [yield] true;
+      }
+      {
+        :iterator.isYieldEach = true;
+        :iterator._current = core::List::_internal<core::Map<core::int, core::int>>();
+        [yield] true;
+      }
+    }
+    return false;
+  }
+  return new core::_SyncIterable::•(:sync_op);
+}
+static method main() → dynamic {}