Correctly recognize type literals in literal lists and maps in an invocation context.

sdk/lib/_internal/compiler/implementation/resolution/members.dart

 // Copyright (c) 2012, 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.
 
 part of resolution;
 
 abstract class TreeElements {
   Element get currentElement;
   Setlet<Node> get superUses;
 
@@ skipping 3169 matching lines @@
       compiler.backend.registerRequiredType(type, enclosingElement);
     }
     return type;
   }
 
   visitModifiers(Modifiers node) {
     internalError(node, 'modifiers');
   }
 
   visitLiteralList(LiteralList node) {
+    bool oldSendIsMemberAccess = sendIsMemberAccess;
+    sendIsMemberAccess = false;
+
     NodeList arguments = node.typeArguments;
     DartType typeArgument;
     if (arguments != null) {
       Link<Node> nodes = arguments.nodes;
       if (nodes.isEmpty) {
         // The syntax [: <>[] :] is not allowed.
         error(arguments, MessageKind.MISSING_TYPE_ARGUMENT);
       } else {
         typeArgument = resolveTypeAnnotation(nodes.head);
         for (nodes = nodes.tail; !nodes.isEmpty; nodes = nodes.tail) {
@@ skipping 14 matching lines @@
       compiler.listClass.computeType(compiler);
       listType = compiler.listClass.rawType;
     }
     mapping.setType(node, listType);
     world.registerInstantiatedType(listType, mapping);
     compiler.backend.registerRequiredType(listType, enclosingElement);
     visit(node.elements);
     if (node.isConst()) {
       analyzeConstant(node);
     }
+
+    sendIsMemberAccess = false;
   }
 
   visitConditional(Conditional node) {
     doInPromotionScope(node.condition, () => visit(node.condition));
     doInPromotionScope(node.thenExpression, () => visit(node.thenExpression));
     visit(node.elseExpression);
   }
 
   visitStringInterpolation(StringInterpolation node) {
     world.registerInstantiatedClass(compiler.stringClass, mapping);
@@ skipping 160 matching lines @@
       }
     });
     if (!targetElement.isTarget && identical(mapping[body], targetElement)) {
       // If the body is itself a break or continue for another target, it
       // might have updated its mapping to the target it actually does target.
       mapping.remove(body);
     }
   }
 
   visitLiteralMap(LiteralMap node) {
+    bool oldSendIsMemberAccess = sendIsMemberAccess;
+    sendIsMemberAccess = false;
+
     NodeList arguments = node.typeArguments;
     DartType keyTypeArgument;
     DartType valueTypeArgument;
     if (arguments != null) {
       Link<Node> nodes = arguments.nodes;
       if (nodes.isEmpty) {
         // The syntax [: <>{} :] is not allowed.
         error(arguments, MessageKind.MISSING_TYPE_ARGUMENT);
       } else {
         keyTypeArgument = resolveTypeAnnotation(nodes.head);
@@ skipping 24 matching lines @@
     mapping.setType(node, mapType);
     world.registerInstantiatedType(mapType, mapping);
     if (node.isConst()) {
       compiler.backend.registerConstantMap(mapping);
     }
     compiler.backend.registerRequiredType(mapType, enclosingElement);
     node.visitChildren(this);
     if (node.isConst()) {
       analyzeConstant(node);
     }
+
+    sendIsMemberAccess = false;
   }
 
   visitLiteralMapEntry(LiteralMapEntry node) {
     node.visitChildren(this);
   }
 
   visitNamedArgument(NamedArgument node) {
     visit(node.expression);
   }
 
@@ skipping 1190 matching lines @@
   TreeElements _treeElements;
 
   bool get hasTreeElements => _treeElements != null;
 
   TreeElements get treeElements {
     assert(invariant(this, _treeElements !=null,
         message: "TreeElements have not been computed for $this."));
     return _treeElements;
   }
 }