Variables referenced indirectly in their initializers are resolved to 'any'

[mhegazy]

The compiler already behaves as per spec, and variables referenced directly or indirectly in their initializers resolve to any. The previous implementation did not just assign them to any, by attempted to go deeper one level, here are some examples;

var a = { f: a };

Now:

a : any

Was:

a: { f: any };

var fibonacci = _.memoize(n =>  n < 2 ? n : fibonacci(n - 1) + fibonacci(n - 2); } );

Now:

fibonacci : any

Was:

fibonacci : (n: any) => any

var n1 = n1++;

Now:

n1 : any

Was:

n1 : number

see tests:

• tests/cases/compiler/recursiveObjectLiteral.ts
• tests/cases/compiler/underscoreTest1_underscoreTests.ts
• tests/cases/conformance/statements/VariableStatements/recursiveInitializer.ts

[ahejlsberg]

The new compiler follows the spec here and I think that makes sense. Also, see my reply to #523. I don't think "going one level deep" is a meaningful (or consistently implementable) rule.

[sophiajt]

Just to be clear, this will differ from the 1.0 behavior, will be a breaking change, and also differs from your recommended "witnesses" proposal. It also doesn't appear to be a valuable improvement over the 1.0 behavior. If anything, we seem to be giving the developer less help rather than more.

That said, I recognize that the old behavior had inconsistencies.

Would it be possible to maintain the old behavior and address the inconsistencies?

[mhegazy]

I agree with Anders that this should not be supported. The previous implementation assigned two types to the same value, which is inconsistent and misleading.. consider this:

var x = ()=> { 
    x.blah; // not error, as x here is any
    return x;
}

x.blah; // Flagged as error as x here is a function ()=>any

I think this is misleading to the user, as they think the compiler understood their intention, where as it did not, and gives the illusion of safety and does not provide it.

A better solution is to make sure that noImplictAny flags theses cases with a message that the variable references itself in its initializer leading to an any type. we have an item for this already #476

[ahejlsberg]

Fixed in #610.