// Function return values are all the terminator operands + pass through
  // extern values (if enabled).
  auto return_values = llvm::to_vector<4>(terminator->getOperands());
  if (only_one_return_value) {
    return_values.resize(1);
  }
  if (extern_values_passthrough)
    return_values.insert(return_values.end(),
                         first_block.args_begin() + num_region_arguments,

  llvm::SetVector<Value> return_values;
  llvm::SmallVector<Type> return_types;

  for (Operation *op : cluster.operations)
    for (OpOperand &use : op->getUses()) {
      // User is inside the cluster.
      if (in_cluster.contains(use.getOwner())) continue;
      // Do not return the same value multiple times.
      if (return_values.contains(use.get())) continue;

  }
  for (Operation* op : cloning_ops) {
    builder.clone(*op, mapping);
  }

  SmallVector<Value> return_values;
  for (Value result : results) {
    return_values.push_back(mapping.lookupOrNull(result));
  }
  builder.create<func::ReturnOp>(location, return_values);

  // Create a function call to the newly created function.
  StringAttr new_func_name =

        tensorflow::XlaExpression::CastExpressionFromTensor(*output);
    output_values.push_back(expr->AsXlaOp(&xla_builder_));
  }

  absl::Span<const xla::XlaOp> return_values(output_values);
  xla::XlaOp root_value = xla::Tuple(&xla_builder_, return_values);

  TF_ASSIGN_OR_RETURN(XlaComputation computation,
                      xla_builder_.Build(root_value,

                                    custom_legalization_passes));

  xla::XlaOp return_value;
  if (returns.size() == 1)
    return_value = returns[0];
  else
    return_value = xla::Tuple(&builder, returns);

  TF_ASSIGN_OR_RETURN(
      xla::XlaComputation computation,
      return_value.valid() ? builder.Build(return_value) : builder.Build());
  auto hlo_module = computation.proto();
  xla::HloProto hlo_proto;

                useMapping = false;
            }
            if (useMapping) {
                returnValue = Cast.uncheckedNonnullCast(_mappings.get(propertyName).getValue(_convention, _source));
            }
        }
        return returnValue;
    }

    @Deprecated
    @Override
    public org.gradle.api.plugins.Convention getConvention() {

        "binaryTypeBuilder" | "A method annotated with @ComponentType must have a single parameter of type ${TypeBuilder.name}."                      | "wrong builder type"
        "returnValue"       | "A method annotated with @ComponentType must have void return type."                                                    | "method with return type"

        private T returnValue;

        @Override
        public void execute(CallableBuildOperation<T> buildOperation, BuildOperationContext context) throws Exception {
            returnValue = buildOperation.call(context);
        }

        public T getReturnValue() {
            return returnValue;
        }
    }

      throws InvocationTargetException, IllegalAccessException {
    T returnValue = factory.invoke(null, args.toArray());
    if (returnValue == null) {
      Assert.assertTrue(
          factory + " returns null but it's not annotated with @Nullable", isNullable(factory));
    }
    return returnValue;
  }

  /**

      throws InvocationTargetException, IllegalAccessException {
    T returnValue = factory.invoke(null, args.toArray());
    if (returnValue == null) {
      Assert.assertTrue(
          factory + " returns null but it's not annotated with @Nullable", isNullable(factory));
    }
    return returnValue;
  }

  /**