The rule just doesn't support these operators yet.

Just to be clear for posterity's sake - the assignment operators are equivalent to the expression variable operator (variable = value) eg:

const result: { [key: number]: number } = {};
result[1] ??= 1;
result[1] ?? (result[1] = 1);

declare let foo: null;
foo ||= null;
foo || (foo = null);

declare let bar: {};
bar &&= 1;
bar && (bar = 1);

But all of those cases are supported - so it's a no brainer to add this
playground

I think I found a bug when tsconfig’s exactOptionalPropertyTypes is on. With this setting, optional properties are treated as nullish when accessed but as non-nullish when assigned.

// tsconfig:compilerOptions.exactOptionalPropertyTypes = true

const obj: { prop?: [number] } = {};

obj.prop;
//  ^? (property) prop?: [number] | undefined

obj.prop = [42];
//  ^? (property) prop?: [number]

I have a function that sets the property once and returns it on the first call, but subsequent calls only return it without setting it:

function setOnce(value: number): [number] {
    return obj.prop ??= [value]; // ! @typescript-eslint/no-unnecessary-condition: "Unnecessary conditional, expected left-hand side of `??` operator to be possibly null or undefined."
}

setOnce(1); //=> [1]
setOnce(2); //=> [1]
obj.prop.push(3);
setOnce(1);  //=> [1, 3]

The problem here is that typescript-eslint thinks obj.prop is non-nullish and reports an error, even though it is nullish before being assigned.

I’m not sure what the right solution is. We want to keep --exactOptionalPropertyTypes on to avoid statements like obj.prop = undefined;, but we still want to allow the ??= assignment operator.

@chharvey Thanks for the report. This seems related to #5344 (an optional property is different from a property with undefined). Could you send a new issue?