Delay disambiguating maps and sets until we know whether there are any conflicts

Change-Id: If55d8ab011047107f34a05a08e60ee54eabc0b44
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/95668
Reviewed-by: Paul Berry <[email protected]>

Author: bwilkerson

pkg/analyzer/lib/src/dart/ast/ast.dart

@@ -8995,7 +8995,7 @@ class SetOrMapLiteralImpl extends TypedLiteralImpl implements SetOrMapLiteral {
       this.leftBracket, List<CollectionElement> elements, this.rightBracket)
       : super(constKeyword, typeArguments) {
     _elements = new NodeListImpl<CollectionElement>(this, elements);
-    _resolvedKind = _computeResolvedKind(typeArguments, _elements);
+    _resolvedKind = _SetOrMapKind.unresolved;
   }
 
   /// Temporary constructor to support MapLiteral2Impl.
@@ -9073,49 +9073,6 @@ class SetOrMapLiteralImpl extends TypedLiteralImpl implements SetOrMapLiteral {
     super.visitChildren(visitor);
     _elements.accept(visitor);
   }
-
-  _SetOrMapKind _computeResolvedKind(TypeArgumentListImpl typeArguments,
-      NodeList<CollectionElement> elements) {
-    int argCount = typeArguments?.arguments?.length ?? 0;
-    if (argCount == 1) {
-      return _SetOrMapKind.set;
-    } else if (argCount == 2) {
-      return _SetOrMapKind.map;
-    }
-    _SetOrMapKind kind = _SetOrMapKind.unresolved;
-    for (var element in elements) {
-      _SetOrMapKind elementKind = _kindOf(element);
-      if (kind == _SetOrMapKind.unresolved) {
-        kind = elementKind;
-      } else if (elementKind != _SetOrMapKind.unresolved &&
-          elementKind != kind) {
-        return _SetOrMapKind.unresolved;
-      }
-    }
-    return kind;
-  }
-
-  _SetOrMapKind _kindOf(CollectionElement element) {
-    if (element is ForElement) {
-      return _kindOf(element.body);
-    } else if (element is IfElement) {
-      if (element.elseElement == null) {
-        return _kindOf(element.thenElement);
-      }
-      _SetOrMapKind thenKind = _kindOf(element.thenElement);
-      _SetOrMapKind elseKind = _kindOf(element.elseElement);
-      if (thenKind == _SetOrMapKind.unresolved || thenKind == elseKind) {
-        return elseKind;
-      } else if (elseKind == _SetOrMapKind.unresolved) {
-        return thenKind;
-      }
-    } else if (element is Expression) {
-      return _SetOrMapKind.set;
-    } else if (element is MapLiteralEntry) {
-      return _SetOrMapKind.map;
-    }
-    return _SetOrMapKind.unresolved;
-  }
 }
 
 /// A combinator that restricts the names being imported to those in a given

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

@@ -4198,29 +4198,34 @@ class ErrorVerifier extends RecursiveAstVisitor<void> {
     assert(mapType is InterfaceTypeImpl);
 
     List<DartType> typeArguments = (mapType as InterfaceTypeImpl).typeArguments;
-    assert(typeArguments.length == 2);
-    DartType keyType = typeArguments[0];
-    DartType valueType = typeArguments[1];
-
-    bool isConst = literal.isConst;
-    NodeList<CollectionElement> entries = literal.elements2;
-    for (CollectionElement entry in entries) {
-      if (isConst) {
-        // TODO(paulberry): this error should be based on the actual type of the
-        // map entries, not the static type.  See dartbug.com/21119.
-        _checkForMapElementTypeNotAssignableWithKeyOrValueType(
-            entry,
-            keyType,
-            valueType,
-            CheckedModeCompileTimeErrorCode.MAP_KEY_TYPE_NOT_ASSIGNABLE,
-            CheckedModeCompileTimeErrorCode.MAP_VALUE_TYPE_NOT_ASSIGNABLE);
-      } else {
-        _checkForMapElementTypeNotAssignableWithKeyOrValueType(
-            entry,
-            keyType,
-            valueType,
-            StaticWarningCode.MAP_KEY_TYPE_NOT_ASSIGNABLE,
-            StaticWarningCode.MAP_VALUE_TYPE_NOT_ASSIGNABLE);
+    // It is possible for the number of type arguments to be inconsistent when
+    // the literal is ambiguous and a non-map type was selected.
+    // TODO(brianwilkerson) Unify this and _checkForSetElementTypeNotAssignable3
+    //  to better handle recovery situations.
+    if (typeArguments.length == 2) {
+      DartType keyType = typeArguments[0];
+      DartType valueType = typeArguments[1];
+
+      bool isConst = literal.isConst;
+      NodeList<CollectionElement> entries = literal.elements2;
+      for (CollectionElement entry in entries) {
+        if (isConst) {
+          // TODO(paulberry): this error should be based on the actual type of
+          //  the map entries, not the static type.  See dartbug.com/21119.
+          _checkForMapElementTypeNotAssignableWithKeyOrValueType(
+              entry,
+              keyType,
+              valueType,
+              CheckedModeCompileTimeErrorCode.MAP_KEY_TYPE_NOT_ASSIGNABLE,
+              CheckedModeCompileTimeErrorCode.MAP_VALUE_TYPE_NOT_ASSIGNABLE);
+        } else {
+          _checkForMapElementTypeNotAssignableWithKeyOrValueType(
+              entry,
+              keyType,
+              valueType,
+              StaticWarningCode.MAP_KEY_TYPE_NOT_ASSIGNABLE,
+              StaticWarningCode.MAP_VALUE_TYPE_NOT_ASSIGNABLE);
+        }
       }
     }
   }
@@ -5491,23 +5496,29 @@ class ErrorVerifier extends RecursiveAstVisitor<void> {
     assert(setType is InterfaceTypeImpl);
 
     List<DartType> typeArguments = (setType as InterfaceTypeImpl).typeArguments;
-    assert(typeArguments.length == 1);
-
-    DartType setElementType = typeArguments[0];
-
-    // Check every set element.
-    bool isConst = literal.isConst;
-    for (CollectionElement element in literal.elements2) {
-      if (isConst) {
-        // TODO(paulberry): this error should be based on the actual type of the
-        // element, not the static type.  See dartbug.com/21119.
-        _checkForCollectionElementTypeNotAssignableWithElementType(
-            element,
-            setElementType,
-            CheckedModeCompileTimeErrorCode.SET_ELEMENT_TYPE_NOT_ASSIGNABLE);
-      } else {
-        _checkForCollectionElementTypeNotAssignableWithElementType(element,
-            setElementType, StaticWarningCode.SET_ELEMENT_TYPE_NOT_ASSIGNABLE);
+    // It is possible for the number of type arguments to be inconsistent when
+    // the literal is ambiguous and a non-set type was selected.
+    // TODO(brianwilkerson) Unify this and _checkForMapTypeNotAssignable3 to
+    //  better handle recovery situations.
+    if (typeArguments.length == 1) {
+      DartType setElementType = typeArguments[0];
+
+      // Check every set element.
+      bool isConst = literal.isConst;
+      for (CollectionElement element in literal.elements2) {
+        if (isConst) {
+          // TODO(paulberry): this error should be based on the actual type of
+          //  the element, not the static type.  See dartbug.com/21119.
+          _checkForCollectionElementTypeNotAssignableWithElementType(
+              element,
+              setElementType,
+              CheckedModeCompileTimeErrorCode.SET_ELEMENT_TYPE_NOT_ASSIGNABLE);
+        } else {
+          _checkForCollectionElementTypeNotAssignableWithElementType(
+              element,
+              setElementType,
+              StaticWarningCode.SET_ELEMENT_TYPE_NOT_ASSIGNABLE);
+        }
       }
     }
   }

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

@@ -4892,14 +4892,12 @@ class ResolverVisitor extends ScopedVisitor {
     if (literalType != null) {
       List<DartType> typeArguments = literalType.typeArguments;
       if (typeArguments.length == 1) {
-        (node as SetOrMapLiteralImpl).becomeSet();
         DartType elementType = literalType.typeArguments[0];
         DartType iterableType =
             typeProvider.iterableType.instantiate([elementType]);
         _pushCollectionTypesDownToAll(node.elements2,
             elementType: elementType, iterableType: iterableType);
       } else if (typeArguments.length == 2) {
-        (node as SetOrMapLiteralImpl).becomeMap();
         DartType keyType = typeArguments[0];
         DartType valueType = typeArguments[1];
         _pushCollectionTypesDownToAll(node.elements2,

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

@@ -1047,7 +1047,8 @@ class StaticTypeAnalyzer extends SimpleAstVisitor<void> {
 
   @override
   void visitSetOrMapLiteral(SetOrMapLiteral node) {
-    if (node.staticType == null) {
+    DartType staticType = node.staticType;
+    if (staticType == null) {
       DartType literalType = _inferSetOrMapLiteralType(node);
       if (literalType.element == _typeProvider.mapType.element) {
         (node as SetOrMapLiteralImpl).becomeMap();
@@ -1057,6 +1058,13 @@ class StaticTypeAnalyzer extends SimpleAstVisitor<void> {
       }
       _resolver.inferenceContext.recordInference(node, literalType);
       _recordStaticType(node, literalType);
+    } else if (staticType is InterfaceType) {
+      List<DartType> typeArguments = staticType.typeArguments;
+      if (typeArguments.length == 1) {
+        (node as SetOrMapLiteralImpl).becomeSet();
+      } else if (typeArguments.length == 2) {
+        (node as SetOrMapLiteralImpl).becomeMap();
+      }
     }
   }
 
@@ -1948,12 +1956,16 @@ class StaticTypeAnalyzer extends SimpleAstVisitor<void> {
 
   DartType _inferSetOrMapLiteralType(SetOrMapLiteral literal) {
     DartType contextType = InferenceContext.getContext(literal);
+    NodeList<CollectionElement> elements = literal.elements2;
+    if (elements.length < 2 && contextType != null) {
+      return contextType;
+    }
     List<_InferredCollectionElementTypeInformation> inferredTypes = [];
     bool canBeAMap = true;
     bool mustBeAMap = false;
     bool canBeASet = true;
     bool mustBeASet = false;
-    for (CollectionElement element in literal.elements2) {
+    for (CollectionElement element in elements) {
       _InferredCollectionElementTypeInformation inferredType =
           _inferCollectionElementType(element);
       inferredTypes.add(inferredType);

pkg/analyzer/test/src/dart/resolution/type_inference/map_literal_test.dart

@@ -116,6 +116,14 @@ var a = <int, int>{1 : 2};
     assertType(setOrMapLiteral('{'), 'Map<int, int>');
   }
 
+  test_noContext_typeArgs_expression_conflict() async {
+    addTestFile('''
+var a = <int, String>{1};
+''');
+    await resolveTestFile();
+    assertType(setOrMapLiteral('{'), 'Map<int, String>');
+  }
+
   test_noContext_typeArgs_noEntries() async {
     addTestFile('''
 var a = <num, String>{};