Invalid recursive methods or functions

🔍 Search Terms

Invalid recursive methods or functions not detected as error by typescript compiler during compile time

✅ Viability Checklist

• This wouldn't be a breaking change in existing TypeScript/JavaScript code
• This wouldn't change the runtime behavior of existing JavaScript code
• This could be implemented without emitting different JS based on the types of the expressions
• This isn't a runtime feature (e.g. library functionality, non-ECMAScript syntax with JavaScript output, new syntax sugar for JS, etc.)
• This feature would agree with the rest of our Design Goals: https://github.com/Microsoft/TypeScript/wiki/TypeScript-Design-Goals

⭐ Suggestion

// TypeScript compiler should detect invalid recursive functions and methods

// Invalid Recursions should not compile and should be reported as error during compile time

// Examples :
function testFunction(i:number) {
return testFunction(i); // compiler should warn this as invalid recursive function
}

let testFunction2 = function (i:number) {
return testFunction2(i); // compiler should warn this as invalid recursive function
}

let testFunction3 :(i:number)=>number = (i:number)=>{
return testFunction3(i); // compiler should warn this as invalid recursive function
}

testFunction(1); // compiler should warn this as invalid recursive function call
testFunction2(1); // compiler should warn this as invalid recursive function call
testFunction3(1); // compiler should warn this as invalid recursive function call

class Testing {
id:number=0;

test1():number{
return this.test1(); // compiler should warn this as invalid recursive method
}
}

const testing:Testing = new Testing();
console.log(testing.test1());// compiler should warn this as invalid recursive method call

//-----------------------------------------------------------------------------------------

// Correct Recursions should work fine and should not be reported as error by compiler

// Examples :
function factorial(x:number):number {

// if number is 0
if (x == 0) {
return 1;
}

// if number is positive
else {
return x * factorial(x - 1);
}
}

console.log(factorial(5));

📃 Motivating Example

// Invalid Recursions should not compile and should be reported as error during compile time

// Examples :
function testFunction(i:number) {
return testFunction(i); // compiler should warn this as invalid recursive function
}

let testFunction2 = function (i:number) {
return testFunction2(i); // compiler should warn this as invalid recursive function
}

let testFunction3 :(i:number)=>number = (i:number)=>{
return testFunction3(i); // compiler should warn this as invalid recursive function
}

testFunction(1); // compiler should warn this as invalid recursive function call
testFunction2(1); // compiler should warn this as invalid recursive function call
testFunction3(1); // compiler should warn this as invalid recursive function call

class Testing {
id:number=0;

test1():number{
return this.test1(); // compiler should warn this as invalid recursive method
}
}

const testing:Testing = new Testing();
console.log(testing.test1());// compiler should warn this as invalid recursive method call

//-----------------------------------------------------------------------------------------

// Correct Recursions should work fine and should not be reported as error by compiler

// Examples :
function factorial(x:number):number {

// if number is 0
if (x == 0) {
return 1;
}

// if number is positive
else {
return x * factorial(x - 1);
}
}

console.log(factorial(5));

💻 Use Cases

// Invalid Recursions should not compile and should be reported as error during compile time

// Examples :
function testFunction(i:number) {
return testFunction(i); // compiler should warn this as invalid recursive function
}

let testFunction2 = function (i:number) {
return testFunction2(i); // compiler should warn this as invalid recursive function
}

let testFunction3 :(i:number)=>number = (i:number)=>{
return testFunction3(i); // compiler should warn this as invalid recursive function
}

testFunction(1); // compiler should warn this as invalid recursive function call
testFunction2(1); // compiler should warn this as invalid recursive function call
testFunction3(1); // compiler should warn this as invalid recursive function call

class Testing {
id:number=0;

test1():number{
return this.test1(); // compiler should warn this as invalid recursive method
}
}

const testing:Testing = new Testing();
console.log(testing.test1());// compiler should warn this as invalid recursive method call

//-----------------------------------------------------------------------------------------

// Correct Recursions should work fine and should not be reported as error by compiler

// Examples :
function factorial(x:number):number {

// if number is 0
if (x == 0) {
return 1;
}

// if number is positive
else {
return x * factorial(x - 1);
}
}

console.log(factorial(5));

1. What do you want to use this for?
   Java programmers can detect invalid recursive methods and functions in Intellij.
   Swift programmers can detect invalid recursive methods and functions in Xcode.
   But typescript programmers cannot detect invalid recursive methods and functions in VsCode or any other code editor.
   Invalid recursion check should exist in typescript as well which will allow to catch bugs during compile time .

2. What shortcomings exist with current approaches?
   Java programmers can detect invalid recursive methods and functions in Intellij.
   Swift programmers can detect invalid recursive methods and functions in Xcode.
   But typescript programmers cannot detect invalid recursive methods and functions in VsCode or any other code editor.
   Invalid recursion check should exist in typescript as well which will allow to catch bugs during compile time .

3. What workarounds are you using in the meantime?
   No workarounds at the moment for detecting typescript invalid recursive methods or functions during compile time .
   As a result runtime error happens for invalid recursive methods or functions in typescript.

The issue names no files, tests, or compiler entry points. Start by defining what counts as invalid recursion beyond the self-calling examples, then determine how diagnostics can reject those cases while allowing the factorial example; completion would require agreed behavior and compiler tests.