*/
    void setExtension(String extension);

    /**
     * Sets the type of this artifact.
     *
     * @param type The type. Should not be null.
     */
    void setType(String type);

    /**
     * Sets the classifier of this artifact.
     *
     * @param classifier The classifier. May be null.
     */
    void setClassifier(@Nullable String classifier);

    /**

	}
	if version != testVersion {
		t.Errorf("Unexpected version mismatch, expected: %s, got: %s", testVersion, version)
	}
	// create a set
	set := &ipset.IPSet{
		Name:       "foo",
		SetType:    ipset.HashIPPort,
		HashFamily: ipset.ProtocolFamilyIPV4,
	}
	if err := fake.CreateSet(set, true); err != nil {
		t.Errorf("Unexpected error: %v", err)
	}

	// add two entries

      auto resultType =
          RankedTensorType::get(shape, inputType.getElementType(), extensions);
      arg.setType(resultType);
    }
    llvm::SmallVector<Type, 8> arg_types;
    for (auto arg : func.getArguments()) arg_types.push_back(arg.getType());
    func.setType(
        FunctionType::get(func.getContext(), arg_types,
                          func.front().getTerminator()->getOperandTypes()));

        this.name = name;
    }

    public String getName() {
        return name;
    }

    public TypeMetaData getType() {
        return type;
    }

    public void setType(TypeMetaData type) {
        this.type = type;
    }

    public String getSignature() {
        StringBuilder builder = new StringBuilder();
        builder.append(type.getSignature());
        builder.append(" ");

    //    public void init( ArtifactMetadata af )
    //    {
    //        setGroupId( af.getGroupId() );
    //        setArtifactId( af.getArtifactId() );
    //        setVersion( af.getVersion() );
    //        setType( af.getType() );
    //        setScope( af.getScope() );
    //        setClassifier( af.getClassifier() );
    //        //setUri( af.getDownloadUrl() );
    //
    //        this.resolved = af.isResolved();

  // tensor<x!tf_type.string>.
  auto tensor_string_type =
      RankedTensorType::get({}, TF::StringType::get(builder.getContext()));
  main_func.getArguments().front().setType(tensor_string_type);
  main_func.setType(
      FunctionType::get(builder.getContext(), {tensor_string_type},
                        main_func.getFunctionType().getResults()));

    private final String name;

    NonIncrementalProcessingStrategy(String name, AnnotationProcessorResult result) {
        super(result);
        this.name = name;
        result.setType(UNKNOWN);
    }

    @Override
    public void recordProcessingInputs(Set<String> supportedAnnotationTypes, Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {

        conv_result_shape, getElementTypeOrSelf(stb_op.getInput()));
    op.getResult().setType(conv_result_type);

    squeeze_op.getResult().setType(bts_op.getOutput().getType());

    // Connect `biasadd_op` with the output of `squeeze_op`.
    if (biasadd_op) {
      biasadd_op.setOperand(0, squeeze_op.getOutput());
      biasadd_op.getOutput().setType(squeeze_op.getOutput().getType());
    }
  } else {

    new_dequantize_op->setOperand(0, user_op->getResult(0));
    new_dequantize_op->getResult(0).setType(user_op->getResult(0).getType());
    user_op->getResult(0).replaceAllUsesExcept(new_dequantize_op->getResult(0),
                                               new_dequantize_op);
    user_op->getResult(0).setType(new_user_op_type);
  }

  LogicalResult matchAndRewrite(TF::PartitionedCallOp op,

    }

    public String getClassName() {
        return className;
    }

    public IncrementalAnnotationProcessorType getType() {
        return type;
    }

    public void setType(IncrementalAnnotationProcessorType type) {
        this.type = type;
    }

    public long getExecutionTimeInMillis() {
        return executionTimeInMillis;
    }