anchor.diff:    void 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;
  
positive.code:               .instantiate(<DartType>[staticKeyType, staticValueType]));
        return;
      }
  
      // If we have no explicit type arguments, try to infer type arguments.
      ParameterizedType inferred = inferMapType(node);
  
negative.code:   @override
    void visitRethrowExpression(RethrowExpression node) {
      _recordStaticType(node, _typeProvider.bottomType);
    }
  
    @override
    void visitSetLiteral(SetLiteral node) {
      TypeArgumentList typeArguments = node.typeArguments;
  
      // If we have type arguments, use them
      if (typeArguments != null) {
        DartType elementType = _dynamicType;
        NodeList<TypeAnnotation> arguments = typeArguments.arguments;
        if (arguments != null && arguments.length == 1) {
          DartType type = _getType(arguments[0]);
          if (type != null) {
            elementType = type;
          }
        }
        _recordStaticType(
            node, _typeProvider.setType.instantiate(<DartType>[elementType]));
        return;
      }
  
      DartType setDynamicType =
          _typeProvider.setType.instantiate(<DartType>[_dynamicType]);
  
      // If we have no explicit type arguments, try to infer type arguments.
      ParameterizedType inferred = inferSetType(node);
  
      if (inferred != setDynamicType) {
        // 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;
      }
  
      // If no type arguments and no inference, use dynamic
      _recordStaticType(node, setDynamicType);
    }
  
    /**
  