How to fix The left-hand side of an assignment expression must be a variable or a property access in TypeScript

// ❌ Function call result
const result = getUser() = newValue;

// ❌ Literal value
5 = x;
'name' = value;

// ❌ Optional property access
user?.name = 'John';

// ❌ Expression result
(a + b) = value;

// ❌ Const reassignment
const name = 'John';
name = 'Jane'; // Cannot reassign const

// ❌ Assignment in non-declaration context
[a, b] = [1, 2]; // Works in declaration, not as separate statement

npx tsc --noEmit

// ❌ Invalid: attempting to assign to function result
getUser() = { name: 'John' };

// ✓ Correct: assign function result to a variable
const user = getUser();
user.name = 'John';

// Or modify in one step if the function returns an object
const user = { ...getUser(), name: 'John' };

// ❌ This looks like assignment but isn't valid
setValue(10) = 20;

// ✓ Just call the function
setValue(20);

// Or if you need to pass a different value
const newValue = 20;
setValue(newValue);

// ❌ Invalid: optional chaining in assignment
employee?.country = 'Germany';

// ✓ Correct: guard with if statement
if (employee) {
  employee.country = 'Germany';
}

// Or use nullish coalescing for default values
if (employee != null) {
  employee.country = 'Germany';
}

// For simpler cases, use logical AND
employee && (employee.country = 'Germany');

// ❌ Invalid
user?.profile?.name = 'John';

// ✓ Correct
if (user?.profile) {
  user.profile.name = 'John';
}

// ❌ This assigns instead of comparing, and = is invalid in if condition
if (method = 'GET') {
  // ...
}

// ✓ Use === for comparison
if (method === 'GET') {
  // ...
}

// ✓ Use == for loose comparison (generally not recommended)
if (method == 'GET') {
  // ...
}

// This is valid but confusing
if ((user = getUser())) {
  // user is now assigned and truthy
}

// Better: separate concerns
const user = getUser();
if (user) {
  // ...
}

// ❌ Invalid: destructuring outside of declaration
[a, b] = [1, 2];
({ x, y } = point);

// ✓ Correct: use 'const', 'let', or 'var' with destructuring
const [a, b] = [1, 2];
let { x, y } = point;

// If you need to reassign existing variables with destructuring:
// Use parentheses to disambiguate from block syntax
({ x, y } = point);  // ✓ Valid at statement level with parens

// Or assign to new variables
const { x: newX, y: newY } = point;

// ❌ Invalid: cannot reassign const
const name = 'John';
name = 'Jane';

// ✓ Declare a new variable
const name = 'John';
const updatedName = 'Jane';

// Or use let if reassignment is intentional
let name = 'John';
name = 'Jane'; // ✓ Valid

// For readonly properties:
interface User {
  readonly id: number;
  name: string;
}

const user: User = { id: 1, name: 'John' };
user.id = 2; // ❌ Error: readonly property
user.name = 'Jane'; // ✓ Valid

// Create new object with updated values
const updatedUser = { ...user, name: 'Jane' };

# Check for TypeScript errors without emitting
npx tsc --noEmit

# Or run your build command
npm run build

# In VS Code, the IDE should clear the error immediately

npx tsc --noEmit 2>&1 | grep TS2364