So after thinking about it a bit more, if the value of x, a, and b are hardcoded in each of the functions, then the only thing that could be returned is either the greatest value like below:

```
function r1(){
var x = 2;
var a = 2;
var b = 1;
return x+a+b // 5
}
function r2(){
var x = 3;
var a = 1;
var b = 5;
return x+a+b // 9
}
function r3(){
var x = 3;
var a = 2;
var b = 0
return x+a //5
}
function findGreater(...functions) {
return functions.reduce((calc, func) => {
const result = func();
return calc === null ? result : Math.max(result, calc);
}, null);
}
console.log(findGreater(r1, r2, r3)); // 9
```

Or if you also want to know the function name that produces the greater value, then you could return an object like:

```
function r1(){
var x = 2;
var a = 2;
var b = 1;
return x+a+b // 5
}
function r2(){
var x = 3;
var a = 1;
var b = 5;
return x+a+b // 9
}
function r3(){
var x = 3;
var a = 2;
var b = 0
return x+a //5
}
function findGreater(...functions) {
return functions.reduce((resultObj, func) => {
const greater = func();
const functionName = func.name;
return resultObj === null
? { greater, functionName }
: greater > resultObj.greater
? { greater, functionName }
: resultObj;
}, null);
}
console.log(findGreater(r1, r2, r3)); // { greater: 9, functionName: 'r2' }
```

One way to return the greater value along with corresponding values of x, a, and b would be to pass them along with the function but the functions would need to just return the calculated results of the values of x, a, and b passed to them. The result of the function is an array containing the greater value, the values of x, a, and b (in order), and also the function name that calculated the greater value.

```
function r1(x, a, b){
return x+a+b
}
function r2(x, a, b){
return x+a+b
}
function r3(x, a, b){
return x+a
}
function findGreater(...functions) {
const greaterResult = functions.reduce((resultObj, [ func, ...args ]) => {
const greater = func(...args);
const functionName = func.name;
return resultObj === null
? { greater, args, functionName }
: greater > resultObj.greater
? { greater, args, functionName }
: resultObj;
}, null);
const { greater, args, functionName } = greaterResult;
return [ greater, ...args, functionName ];
}
console.log(findGreater([r1,2,2,1], [r2,3,1,5], [r3, 3, 2, 0])); // [ 9, 3, 1, 5, 'r2' ]
```