anchor.diff:    checkSet<int>(iterableContext<int>(const {}), []);
     checkSet<int>(foSetContext<int>(const {}), []);
     checkSet<int>(foIterableContext<int>(const {}), []);
  -  checkSet<num>(sContext(const {}), []);
  -  checkSet<num>(iContext(const {}), []);
   
     // Non-empty set literal, no type argument.
     // No context.
     checkSet<int>(const {1}, [1]);
  -  checkSet<int>(const {3, 1, 2, 4, 1, 4}, [3, 1, 2, 4]);
  +  checkSet<int>(const {3, 1, 2, 4}, [3, 1, 2, 4]);
     // Set context with no inferred type argument.
     checkSet<int>(setContext(const {1}), [1]);
     checkSet<int>(iterableContext(const {1}), [1]);
     checkSet<int>(foSetContext(const {1}), [1]);
     checkSet<int>(foIterableContext(const {1}), [1]);
  -  checkSet<int>(setContext(const {3, 1, 2, 4, 1, 4}), [3, 1, 2, 4]);
  -  checkSet<int>(iterableContext(const {3, 1, 2, 4, 1, 4}), [3, 1, 2, 4]);
  +  checkSet<int>(setContext(const {3, 1, 2, 4}), [3, 1, 2, 4]);
  +  checkSet<int>(iterableContext(const {3, 1, 2, 4}), [3, 1, 2, 4]);
     checkSet<int>(foSetContext(const {1}), [1]);
     checkSet<int>(foIterableContext(const {1}), [1]);
     // Specific set context.
     checkSet<num>(setContext<num>(const {1}), [1]);
  -  checkSet<num>(sContext(const {1}), [1]);
     checkSet<num>(iterableContext<num>(const {1}), [1]);
  -  checkSet<num>(iContext(const {1}), [1]);
     checkSet<num>(foSetContext<num>(const {1}), [1]);
     checkSet<num>(foIterableContext<num>(const {1}), [1]);
  -  checkSet<num>(setContext<num>(const {3, 1, 2, 4, 1, 4}), [3, 1, 2, 4]);
  -  checkSet<num>(sContext(const {3, 1, 2, 4, 1, 4}), [3, 1, 2, 4]);
  -  checkSet<num>(iterableContext<num>(const {3, 1, 2, 4, 1, 4}), [3, 1, 2, 4]);
  -  checkSet<num>(iContext(const {3, 1, 2, 4, 1, 4}), [3, 1, 2, 4]);
  -  checkSet<num>(foSetContext<num>(const {3, 1, 2, 4, 1, 4}), [3, 1, 2, 4]);
  -  checkSet<num>(foIterableContext<num>(const {3, 1, 2, 4, 1, 4}), [3, 1, 2, 4]);
  +  checkSet<num>(setContext<num>(const {3, 1, 2, 4}), [3, 1, 2, 4]);
  +  checkSet<num>(iterableContext<num>(const {3, 1, 2, 4}), [3, 1, 2, 4]);
  +  checkSet<num>(foSetContext<num>(const {3, 1, 2, 4}), [3, 1, 2, 4]);
  +  checkSet<num>(foIterableContext<num>(const {3, 1, 2, 4}), [3, 1, 2, 4]);
   
     // Non-empty set literal with type argument.
     checkSet<num>(const <num>{1}, [1]);
  -  checkSet<num>(const <num>{3, 1, 2, 4, 1, 4}, [3, 1, 2, 4]);
  +  checkSet<num>(const <num>{3, 1, 2, 4}, [3, 1, 2, 4]);
   
     // Integers, String and symbols work, even if they override ==.
  -  checkSet<String>(const {"foo", "bar", "foo"}, ["foo", "bar"]);
  -  checkSet<Symbol>(const {#foo, #bar, #foo}, [#foo, #bar]);
  -  checkSet<Symbol>(const {#_foo, #_bar, #_foo}, [#_foo, #_bar]);
  +  checkSet<String>(const {"foo", "bar"}, ["foo", "bar"]);
  +  checkSet<Symbol>(const {#foo, #bar}, [#foo, #bar]);
  +  checkSet<Symbol>(const {#_foo, #_bar}, [#_foo, #_bar]);
     const object = Object();
     checkSet<Object>(const {#foo, 1, "string", object, true},
         [#foo, 1, "string", object, true]);
  
positive.code:   test();
  }
  
  void test<S extends Set<num>, I extends Iterable<num>>() {
    checkSet<T>(Object o, List elements) {
      Expect.type<Set<T>>(o);
      Set<T> set = o;
  
negative.code:   Object iterableContext<T>(Iterable<T> object) => object;
    Object foSetContext<T>(FutureOr<Set<T>> object) => object;
    Object foIterableContext<T>(FutureOr<Set<T>> object) => object;
  
    // Empty literal, no type arguments.
    // No context.
  