anchor.diff:            node, inferrer.typeSchemaEnvironment,
             inferred: true);
       }
  -    return null;
     }
   
     void visitMethodInvocationJudgment(
  
positive.code:     assert((node.keyType is ImplicitTypeArgument) ==
          (node.valueType is ImplicitTypeArgument));
      bool inferenceNeeded = node.keyType is ImplicitTypeArgument;
      bool typeChecksNeeded = !inferrer.isTopLevel;
      if (inferenceNeeded || typeChecksNeeded) {
        formalTypes = [];
  
negative.code:   }
  
    void visitSetLiteralJudgment(SetLiteralJudgment node, DartType typeContext) {
      var setClass = inferrer.coreTypes.setClass;
      var setType = setClass.thisType;
      List<DartType> inferredTypes;
      DartType inferredTypeArgument;
      List<DartType> formalTypes;
      List<DartType> actualTypes;
      bool inferenceNeeded = node.typeArgument is ImplicitTypeArgument;
      bool typeChecksNeeded = !inferrer.isTopLevel;
      if (inferenceNeeded || typeChecksNeeded) {
        formalTypes = [];
        actualTypes = [];
      }
      if (inferenceNeeded) {
        inferredTypes = [const UnknownType()];
        inferrer.typeSchemaEnvironment.inferGenericFunctionOrType(setType,
            setClass.typeParameters, null, null, typeContext, inferredTypes,
            isConst: node.isConst);
        inferredTypeArgument = inferredTypes[0];
      } else {
        inferredTypeArgument = node.typeArgument;
      }
      if (inferenceNeeded || typeChecksNeeded) {
        for (int i = 0; i < node.expressions.length; ++i) {
          Expression judgment = node.expressions[i];
          inferrer.inferExpression(
              judgment, inferredTypeArgument, inferenceNeeded || typeChecksNeeded,
              isVoidAllowed: true);
          if (inferenceNeeded) {
            formalTypes.add(setType.typeArguments[0]);
          }
          actualTypes.add(getInferredType(judgment, inferrer));
        }
      }
      if (inferenceNeeded) {
        inferrer.typeSchemaEnvironment.inferGenericFunctionOrType(
            setType,
            setClass.typeParameters,
            formalTypes,
            actualTypes,
            typeContext,
            inferredTypes);
        inferredTypeArgument = inferredTypes[0];
        inferrer.instrumentation?.record(
            inferrer.uri,
            node.fileOffset,
            'typeArgs',
            new InstrumentationValueForTypeArgs([inferredTypeArgument]));
        node.typeArgument = inferredTypeArgument;
      }
      if (typeChecksNeeded) {
        for (int i = 0; i < node.expressions.length; i++) {
          inferrer.ensureAssignable(node.typeArgument, actualTypes[i],
              node.expressions[i], node.expressions[i].fileOffset,
              isVoidAllowed: node.typeArgument is VoidType);
        }
      }
      node.inferredType = new InterfaceType(setClass, [inferredTypeArgument]);
      KernelLibraryBuilder inferrerLibrary = inferrer.library;
      if (inferenceNeeded && inferrerLibrary is KernelLibraryBuilder) {
        inferrerLibrary.checkBoundsInSetLiteral(
            node, inferrer.typeSchemaEnvironment,
            inferred: true);
      }
    }
  
    void visitStaticAssignmentJudgment(
  