Typescript: Exclamation mark next to operator does not produce compilation error.

[nenadvicentic]

TypeScript Version: 2.7.2

Search Terms:
is:issue label:Bug exclamation
Code

// actually any combination compiles !+, !<, !-
if (5 !> 2) {
    // Something
}
const result = 5 !+ 2;

Expected behavior:
Should be compilation error, same as it would be for 5 ~+ 2, 5 ?+ 2 or something similar.
Actual behavior:
Strips off "!" and compiles operator behind it.

[ajafff]

The exclamation mark here is actually part of a non-null assertion. You basically assert that 5 is not null or undefined.
Consider the following:

declare let foo: number | undefined;
if (foo! > 2) { } // assertion is actually needed here, otherwise the compiler complains about possibly undefined value

If you want a warning when an assertion is unnecessary, you could use a lint rule:
TSLint has no-unnecessary-type-assertion (use with caution, sometimes the assertion is necessary but the linter still complains)
My linter project wotan has a rule no-useless-assertion that does a bit more than TSLint's rule and should also get the edge cases right.

[andy-ms]

Reminds me of the --> operator.

[nenadvicentic]

@ajafff: Example you have gave is OK foo! > 2, but having extra space in between like foo !> 2 or
foo ! > 2 being valid, does not seem right to me.

[RyanCavanaugh]

but having extra space in between like foo !> 2 or foo ! > 2 being valid, does not seem right to me.

This consistent with other post-expression notation; x .y or x [0] or x () or function f(x ?: string) { } are all valid.

[nenadvicentic]

@RyanCavanaugh Yes, I see your point. Unfortunately, some of those post-expression cases are more confusing then the others.

@andy-ms Am I wrong, or is this only case where a !== b and a ! == b compile in two different things?

This also compiles a!!!!!==b. I don't know. It feels odd.

[typescript-bot]

Automatically closing this issue for housekeeping purposes. The issue labels indicate that it is unactionable at the moment or has already been addressed.

[andy-ms]

@nenadvicentic a ! == b isn't valid JS -- you can't insert spaces in the middle of an operator.

[nenadvicentic]

@andy-ms Both expression are valid in Typescript. Now extra space char can produce different valid expression. Also, only operator you can chain on itself a!!!!!.

[weswigham]

@nenadvicentic you forget ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~1

[andy-ms]

JS also has expressions whose meaning varies based on spacing:

let a = 1;
let b = 1;
console.log(a++ +b); // 2, but `a+ ++b` is 3

[nenadvicentic]

@weswigham, @andy-ms Good point, I did not know about ~~ thing. 😳 Both examples are correct. I guess I'll switch back to C#.

P.S. Damn, I hope nobody plans to port some this stuff from Typescript to C#. 😯

[andy-ms]

I hope nobody plans to port some this stuff from Typescript to C#

I think you mean, from C to C#...

using System;

public namespace App
{
    public class Program
    {
        public static void Main(string[] args)
        {
            Console.WriteLine(~~~~~~~~~~~~~1); // -2
            var a = 1;
            var b = 1;
            Console.WriteLine(a++ +b); // 2
            a = 1;
            b = 1;
            Console.WriteLine(a + ++b); // 3
        }
    }
}

[RyanCavanaugh]

Are there any languages that disallow repeated applications of the same prefix unary operator?

[nenadvicentic]

@andy-ms No, I was aiming at non-nullable classes.
@RyanCavanaugh : ++++a does not seem to work. Only postfix operator that can be chained seems to be !.