How to fix Parameter must have a unique name in TypeScript

// WRONG - duplicate parameter 'x'
function calculate(x: number, x: number): number {
  return x + x; // Which 'x' is being referenced?
}

// CORRECT - unique parameter names
function calculate(x: number, y: number): number {
  return x + y;
}

// WRONG - duplicate in arrow function
const process = (data: string, data: string) => {
  console.log(data); // Ambiguous
};

// CORRECT - unique names
const process = (input1: string, input2: string) => {
  console.log(input1, input2);
};

// WRONG - duplicate in method
class Calculator {
  add(a: number, a: number): number { // Error
    return a + a;
  }
}

// CORRECT
class Calculator {
  add(a: number, b: number): number {
    return a + b;
  }
}

// WRONG - duplicate 'value' parameter in overloads
interface Parser {
  parse(value: string): Document;
  parse(value: number): Document; // Error: duplicate 'value'
}

// CORRECT - different parameter names or restructure
interface Parser {
  parse(strValue: string): Document;
  parse(numValue: number): Document; // OK - unique name

  // Alternative: single method with union type
  parse(input: string | number): Document;
}

// WRONG - overloads with same parameter names
function format(data: string): string;
function format(data: number): string; // Error
function format(data: string | number): string {
  return String(data);
}

// CORRECT - unique names or union type approach
function format(text: string): string;
function format(value: number): string; // OK - 'value' vs 'text'
function format(input: string | number): string {
  return String(input);
}

// Better: Single signature with union type
function format(input: string | number): string {
  return String(input);
}

// WRONG - duplicate 'id' property
interface User {
  id: string;
  name: string;
  id: number; // Error: duplicate 'id'
}

// CORRECT - unique property names
interface User {
  id: string;
  name: string;
  userId: number; // Different name
}

// WRONG - type alias with duplicate
type Config = {
  path: string;
  path: string; // Error
};

// CORRECT
type Config = {
  sourcePath: string;
  destPath: string;
};

// WRONG - intersection types creating duplicates
type A = { x: string };
type B = { x: number };
type C = A & B; // Creates 'x: string & number', not duplicate

// For extending interfaces, use 'extends' properly
interface Base {
  id: string;
}

interface Extended extends Base {
  id: number; // Error: conflicts with Base.id
  // CORRECT: use a different name or omit
  numericId: number;
}

// WRONG - destructuring creates duplicate 'id'
function processUser(
  { id, name }: { id: string, name: string },
  id: number // Error: duplicate 'id'
) {
  console.log(id); // Which id? string or number?
}

// CORRECT - rename destructured parameter
function processUser(
  user: { id: string, name: string },
  userId: number // Unique name
) {
  console.log(user.id, userId);
}

// Alternative: rename during destructuring
function processUser(
  { id: userId, name }: { id: string, name: string },
  id: number
) {
  console.log(userId, id); // Clear distinction
}

// WRONG - nested destructuring conflicts
function updateConfig(
  { db: { host } }: { db: { host: string } },
  host: string // Error: duplicate 'host'
) {
  // ...
}

// CORRECT
function updateConfig(
  config: { db: { host: string } },
  serverHost: string
) {
  console.log(config.db.host, serverHost);
}

// WRONG - generic 'T' conflicts with parameter 'T'
function identity<T>(T: T): T { // Error: duplicate 'T'
  return T;
}

// CORRECT - different names
function identity<T>(value: T): T {
  return value;
}

// WRONG - multiple generics with same name
function merge<T, T>(a: T, b: T): T[] { // Error
  return [a, b];
}

// CORRECT
function merge<T, U>(a: T, b: U): (T | U)[] {
  return [a, b];
}

// WRONG - generic in class conflicts with method parameter
class Container<T> {
  set(value: T, T: string): void { // Error
    // ...
  }
}

// CORRECT
class Container<T> {
  set(value: T, tag: string): void {
    // ...
  }
}

// tsconfig.json - recommended settings
{
  "compilerOptions": {
    "strict": true,
    "noImplicitAny": true,
    "strictNullChecks": true,
    "noUnusedParameters": true,

    // These help catch duplicate parameter issues
    "noImplicitReturns": true,
    "noFallthroughCasesInSwitch": true,

    // For better error messages
    "pretty": true,
    "diagnostics": true
  }
}