true == false - cannot be applied to types 'false' and 'true'.

[cevek]

TypeScript Version: Version 2.1.0-dev.20160927

Code

const a = false;
const b = a === true; //  Operator '===' cannot be applied to types 'false' and 'true'.
const c = true === false; // that is ok

[kitsonk]

Is there a real issue with this? While the error message is potentially confusing, it is valid and TypeScript is identifying a position where you have a logic error, although the third statement also has the same logic error it is because it is comparing a boolean to a boolean instead of two incomparable literal types. The behaviour could be stricter to interpret literal values as literal types for comparison, but I can't see where it is being already more strict is a problem.

const a: boolean = false;
const b = a === true; // no issue

[cevek]

That issue from source code of mobx, it is simplified example
https://github.com/mobxjs/mobx/blob/master/src/api/autorun.ts#L225

[cevek]

Also https://github.com/mobxjs/mobx/blob/master/src/core/derivation.ts#L75
Operator '===' cannot be applied to types 'IDerivationState.POSSIBLY_STALE' and 'IDerivationState.STALE'.

[kitsonk]

@cevek, that is different than the reported issue... there the comparison is between a let, which should not automatically infer a literal type of false. For example, this should work:

let a = false;
const b = a === true; // Operator '===' cannot be applied to types 'false' and 'true'.

But the following works:

let a = false;
a = true;
const b = a === true; // No error

Which means the CFA is tracking the assigned literal type of the code. So I think the example need to be expanded upon, because the error isn't in the example, it is in CFA not properly tracking the type on assignment of a variable.

[cevek]

ahejlsberg
This is working as intended. The compiler performs control flow analysis and knows that p has the actual value Place.Left where you're performing the === operations, and it is calling out that it makes no sense to compare a value that is known to be Place.Left to a value that is known to be Place.Right. It's effectively like writing Place.Left === Place.Right or 1 === 2, both of which would also produce errors.

[RyanCavanaugh]

@cevek Is this a bug in the mobx code, or did derivation.dependenciesState actually change value between lines 63 and 75?

[cevek]

Yeah, obj.get(); can change derivation.dependenciesState

[cevek]

duplicates of #10120 #11134

[jasonswearingen]

@cevek: Please reopen this issue. control flow analysis fails when using closures such as this example:

        var didAFix = false;
        _.forEach(this.invalid, (value:T, key:string) => {
            var fixedValue = func(value, key, this);
            if (fixedValue !== undefined) {
                this._accept(key, fixedValue);
                didAFix = true;
            }
        });
        //fixup state after modifications
        if (didAFix === true) {  //tsc error TS2365
            this._maintainValidState();
        }

I get a tsc compile error on the 3rd to last line (if (didAFix === true)):

src/validation.ts(120,7): error TS2365: Operator '===' cannot be applied to types 'false' and 'true'.

[RyanCavanaugh]

@jasonswearingen see #9998 and the many bugs linked from it

With typescript do this is work for me

let whatToDo: any =  false;

if (whatToDo === true) {
        this.pages.push(this.pageRange);
      }

[gsdnano]

Same error when using simple statements such as

var b:boolean = false;
...
b === true ? 'n_' : ''

[kitsonk]

Code flow analysis is doing a better tracking of code than you might assume... In this case CFA has determined the only value b might have at this point in the code is false.

The problem goes away, when the value cannot be statically determined anymore:

var b: boolean = false;

b = Math.random() % 2 ? true : false;

b === true ? 'n_' : '';

It is the goal of TypeScript to statically identify constructs that are likely to be errors, which a variable, without reassignment, within the same closure cannot be any other value than false so it is invalid to compare it to true.