anchor.diff:      assert((node.keyType is ImplicitTypeArgument) ==
           (node.valueType is ImplicitTypeArgument));
       bool inferenceNeeded = node.keyType is ImplicitTypeArgument;
  +    KernelLibraryBuilder library = inferrer.library;
  +    if (library != null &&
  +        library.loader.target.enableSetLiterals &&
  +        inferenceNeeded &&
  +        node.entries.isEmpty) {
  +      // Ambiguous set/map literal
  +      DartType context =
  +          inferrer.typeSchemaEnvironment.unfutureType(typeContext);
  +      if (context is InterfaceType) {
  +        if (inferrer.classHierarchy
  +                .isSubclassOf(inferrer.coreTypes.setClass, context.classNode) &&
  +            !inferrer.classHierarchy
  +                .isSubclassOf(inferrer.coreTypes.mapClass, context.classNode)) {
  +          // Set literal
  +          SetLiteralJudgment setLiteral = new SetLiteralJudgment([],
  +              typeArgument: const ImplicitTypeArgument(),
  +              isConst: node.isConst);
  +          node.replaceWith(setLiteral);
  +          visitSetLiteralJudgment(setLiteral, typeContext);
  +          node.inferredType = setLiteral.inferredType;
  +          return;
  +        }
  +      }
  +    }
       bool typeChecksNeeded = !inferrer.isTopLevel;
       if (inferenceNeeded || typeChecksNeeded) {
         formalTypes = [];
  
positive.code:   }
  
    void visitSetLiteralJudgment(SetLiteralJudgment node, DartType typeContext) {
      // Not implemented
      defaultExpression(node, typeContext);
    }
  
    void visitStaticAssignmentJudgment(
  
negative.code:           node, inferrer.typeSchemaEnvironment,
            inferred: true);
      }
    }
  
    void visitMethodInvocationJudgment(
  