Louis' answer is great, but I thought I would try to sum it up succinctly:

The bang operator tells the compiler to temporarily relax the "not null" constraint that it might otherwise demand. It says to the compiler: "As the developer, I know better than you that this variable cannot be null right now".

Non-null assertion operator

With the non-null assertion operator we can tell the compiler explicitly that an expression has value other than null or undefined. This is can be useful when the compiler cannot infer the type with certainty but we have more information than the compiler.

Example

TS code

function simpleExample(nullableArg: number | undefined | null) {
   const normal: number = nullableArg; 
    //   Compile err: 
    //   Type 'number | null | undefined' is not assignable to type 'number'.
    //   Type 'undefined' is not assignable to type 'number'.(2322)

   const operatorApplied: number = nullableArg!; 
    // compiles fine because we tell compiler that null | undefined are excluded 
}

Compiled JS code

Note that the JS does not know the concept of the Non-null assertion operator since this is a TS feature

"use strict";
function simpleExample(nullableArg) {
    const normal = nullableArg;
    const operatorApplied = nullableArg;
}

Short Answer

Non-null assertion operator (!) helps the compiler that I'm sure this variable is not a null or undefined variable.

let obj: { field: SampleType } | null | undefined;

... // some code

// the type of sampleVar is SampleType
let sampleVar = obj!.field; // we tell compiler we are sure obj is not null & not undefined so the type of sampleVar is SampleType

My understanding is the ! operator do the same thing like NonNullable.

let ns: string | null = ''
//  ^? let ns: string | null
let s1 = ns!
//  ^? let s1: string
let s2 = ns as NonNullable<typeof ns>
//  ^? let s2: string

Non-Nullable TypeScript performs strict null checks to help catch potential null or undefined errors. When you try to access a member (property or method) on a variable that could be null or undefined, TypeScript raises a compilation error.

let myElement: HTMLElement | null = document.getElementById('myElement');

// Without non-null assertion operator
// Compiler error: Object is possibly 'null'.
myElement.innerHTML = 'Hello, world!';

// With non-null assertion operator
myElement!.innerHTML = 'Hello, world!';

TS's exclamation mark operator: It's used to set the not-nullable references. It tells the typescript compiler that the variable can't be Null or undefined. Please check the following example.

let referenceA: string | null = null
const n = 1
if (n) {
    referenceA= "Hello My World!"    
}
console.log(referenceA.toLowerCase()) // Error: Object is possibly 'null'.ts(2531)

To avoid that error we need to tell the compiler that the variable can't be Null using the "!" operator, which's called non-null assertion operator.

    let referenceA: string | null = null
    const n = 1
    if (n) {
        referenceA= "Hello My World!"    
    }
    console.log(referenceA!.toLowerCase())

The ! you’re seeing after node.parent is not a logical NOT. It is the non-null assertion operator, introduced in TypeScript 2.0.

What it does

The non-null assertion operator tells the TypeScript compiler:

“I know this value is not null or undefined at runtime. trust me.”

node.parent!.kind

is TypeScript’s way of asserting that node.parent is definitely not null or undefined, allowing access to .kind without compiler errors.

Why it compiles away

This operator is purely a compile-time assertion. It does nothing at runtime, so when TypeScript outputs JavaScript, the ! is simply removed:

TypeScript:

if (node.parent!.kind === ts.SyntaxKind.ObjectLiteralExpression) {
    return;
}

JavaScript output:

if (node.parent.kind === ts.SyntaxKind.ObjectLiteralExpression) {
    return;
}

Why your older TypeScript version failed

You mentioned:

TypeScript 1.5.3 → syntax error

TypeScript 2.1.6 → compiles correctly

That’s expected — the non-null assertion operator was introduced in TS 2.0. Versions before that don’t understand the syntax and throw an error.

When to use it

Use ! when TypeScript’s control flow analysis can’t guarantee non-null values, but you know the value won’t be null:

const element = document.getElementById("app")!;
element.innerText = "Hello!";

When not to use it

Don’t use it blindly. It bypasses safety checks, and if you're wrong, you’ll get a runtime exception.

Most answers so far are incomplete, if not slightly incorrect in their generalized tone.

Indeed, it is one use case to flag values as not null and not undefined.

But what the bang operator generally does is, it turns off errors of TypeScript code when compiling it to JavaScript code. It tells TypeScript to leave the expressions result as it is and pass it to JavaScript.

It allows the use of JavaScript semantics in TypeScript, such as using loose equality (with the convenience of omitting all the checks) or using the (loose) inequality comparisons. It can improve the efficiency of the code for people who know how JavaScript works or who want to refactor JavaScript code into TypeScript code without altering behaviour.

backlog.addEventListener('message', (event: BacklogEvent) =>
{
    if (event.target.currentTime! < workday?.endTime!)
    {
        coworker.pushWork(backlog.pop());
    }
});

This "lazy" code snippet will simply only trigger the if-block, if the left side is a valid date that is before the valid date on the right side, even if they can also be undefined in the weekend or after the work day; just in case your coworker crunches extra hours. (Note that nulls are treated as 0 in JavaScript comparisons <, <=, > and >=! You can easily check that yourself.)