anchor.diff:                .instantiate(<DartType>[staticKeyType, staticValueType]));
         return;
       }
  +
  +    DartType mapDynamicType = _typeProvider.mapType
  +        .instantiate(<DartType>[_dynamicType, _dynamicType]);
   
       // If we have no explicit type arguments, try to infer type arguments.
       ParameterizedType inferred = inferMapType(node);
  
positive.code:   @override
    void visitRethrowExpression(RethrowExpression node) {
      _recordStaticType(node, _typeProvider.bottomType);
    }
  
    /**
  
negative.code:     var ts = _typeSystem as StrongTypeSystemImpl;
      ParameterizedType inferred = ts.inferGenericFunctionOrType(
          _typeProvider.mapType, parameters, elementTypes, contextType,
          downwards: downwards,
          errorReporter: _resolver.errorReporter,
          errorNode: node);
      return inferred;
    }
  
    DartType inferSetType(SetLiteral node, {bool downwards: false}) {
      DartType contextType = InferenceContext.getContext(node);
  
      var ts = _typeSystem as StrongTypeSystemImpl;
      List<DartType> elementTypes;
      List<ParameterElement> parameters;
  
      if (downwards) {
        if (contextType == null) {
          return null;
        }
  
        elementTypes = [];
        parameters = [];
      } else {
        // Also use upwards information to infer the type.
        elementTypes = node.elements
            .map((e) => e.staticType)
            .where((t) => t != null)
            .toList();
        var setTypeParam = _typeProvider.setType.typeParameters[0].type;
        var syntheticParamElement = new ParameterElementImpl.synthetic(
            'element', setTypeParam, ParameterKind.POSITIONAL);
        parameters = new List.filled(elementTypes.length, syntheticParamElement);
      }
      DartType inferred = ts.inferGenericFunctionOrType<InterfaceType>(
          _typeProvider.setType, parameters, elementTypes, contextType,
          downwards: downwards,
          errorReporter: _resolver.errorReporter,
          errorNode: node);
  