fix: resolve property assignments in object literals

.tool-versions

@@ -1,2 +1,3 @@
 nodejs 20.8.1
 pnpm 8.9.2
+yarn 1.22.17

package.json

@@ -46,18 +46,20 @@
     "@types/diff": "5.0.9",
     "@types/google-protobuf": "3.15.12",
     "@types/node": "20.10.5",
-    "ts-node": "^10.7.0",
     "@types/progress": "2.0.7",
     "@typescript-eslint/eslint-plugin": "^7.18.0",
     "@typescript-eslint/parser": "^7.18.0",
     "diff": "^5.1.0",
     "eslint": "^8.57.0",
+    "eslint-plugin-etc": "^2.0.3",
+    "eslint-plugin-rxjs": "^5.0.3",
     "eslint-plugin-unicorn": "^55.0.0",
     "eslint-plugin-unused-imports": "^4.1.3",
     "pnpm": "8.12.1",
     "prettier": "3.3.2",
+    "ts-node": "^10.7.0",
+    "tsm": "^2.3.0",
     "typescript-eslint": "7.18.0",
-    "uvu": "^0.5.6",
-    "tsm": "^2.3.0"
+    "uvu": "^0.5.6"
   }
 }

snapshots/input/pure-js/src/main.js

@@ -47,3 +47,7 @@ function var_function_scope() {
   }
   print_fib(k)
 }
+
+function array_of_objects() {
+  var a = [{ element: 0 }, { element: 1 }]
+}

snapshots/input/syntax/src/decorators.ts

@@ -0,0 +1,12 @@
+import { Configuration } from './reusable-types'
+
+function MyDecorator(value: Configuration) {
+  return function (target: Function) {
+    console.log(`MyDecorator is called with value: ${value}`)
+  }
+}
+
+@MyDecorator({ property: 42, property2: '42' })
+class MyClass {
+  //...
+}

snapshots/input/syntax/src/inheritance.ts

@@ -1,9 +1,6 @@
+import { Superinterface } from './reusable-types'
 import { Overloader } from './overload'
 
-export interface Superinterface {
-  property: string
-  interfaceMethod(): string
-}
 export interface IntermediateSuperinterface extends Superinterface {
   intermediateInterfaceMethod(): string
 }
@@ -43,10 +40,3 @@ export const objectLiteralImplementation: Superinterface = {
     throw new Error('Function not implemented.')
   },
 }
-export function consumesInterface(superInterface: Superinterface): void {}
-export function infersInterface(): void {
-  consumesInterface({
-    interfaceMethod: (): string => 'inferred',
-    property: 'inferred',
-  })
-}

snapshots/input/syntax/src/object-literals-arrow-function.ts

@@ -0,0 +1,35 @@
+import { Option } from './reusable-types'
+
+interface Foobar {
+  foobar: number
+}
+
+export function hasArrowFunctionParameter(
+  something: number,
+  fn: (foobar: Foobar) => Foobar
+): Foobar {
+  return fn({ foobar: 42 + something })
+}
+
+export function consumesArrowFunction(): number {
+  return (
+    hasArrowFunctionParameter(1, ({ foobar }) => ({ foobar: foobar + 1 }))
+      .foobar +
+    hasArrowFunctionParameter(2, foobar => ({ foobar: foobar.foobar + 2 }))
+      .foobar
+  )
+}
+
+export function genericArrow(): Foobar[] {
+  return [1].map<Foobar>(n => ({ foobar: n + 1 }))
+}
+
+export function genericArrowOption(): Option<Foobar>[] {
+  return [1].map<Option<Foobar>>(n => ({ value: { foobar: n + 1 } }))
+}
+
+export function genericArrow2(): Foobar[] {
+  // navigation to `foobar` below does not work with tsserver or scip-java
+  // because `map`  is missing an explicit `map<Foobar>` annotation.
+  return [1].map(n => ({ foobar: n + 1 }))
+}

snapshots/input/syntax/src/object-literals-call-signatures.ts

@@ -0,0 +1,73 @@
+import {
+  Configuration,
+  GenericClass,
+  GenericInterface,
+  Option,
+  Superinterface,
+} from './reusable-types'
+
+export function consumesInterface(superInterface: Superinterface): void {}
+export function consumesArray(superInterface: Superinterface[]): void {}
+export function consumesGenericInterface<T>(
+  genercInterface: GenericInterface<T>
+): void {}
+
+export function infersInterface(): void {
+  consumesInterface({
+    interfaceMethod: (): string => 'inferred',
+    property: 'inferred',
+  })
+  consumesArray([
+    {
+      interfaceMethod: (): string => 'inferred',
+      property: 'inferred',
+    },
+  ])
+  consumesGenericInterface<number>({
+    interfaceMethod: (): string => 'inferred',
+    property: 123,
+  })
+  consumesGenericInterface<Option<Configuration>[]>({
+    interfaceMethod: (): string => 'inferred',
+    property: [{ value: { property: 42, property2: '42' } }],
+  })
+}
+export function returnStatementInsideArgumentExpression(): Configuration[] {
+  if (1 == 1) {
+    return [1].map<Configuration>((number: number): Configuration => {
+      const incremented = number + 1
+      return {
+        property: incremented,
+        property2: incremented.toString(),
+      }
+    })
+  } else {
+    return [1].map<Configuration>(number => {
+      const incremented = number + 1
+      return {
+        property: incremented,
+        property2: incremented.toString(),
+      }
+    })
+  }
+}
+
+export function createGenericClass(): GenericClass<Configuration> {
+  return new GenericClass<Configuration>([{ property: 1, property2: '2' }])
+}
+
+export function handleGenericClass() {
+  return createGenericClass().map(({ property, property2 }) => ({
+    property: property + 1,
+    property2: property2 + '1',
+  }))
+}
+
+export function handleShorthand() {
+  const property = '42'
+  const interfaceMethod = (): string => 'inferred'
+  consumesInterface({
+    interfaceMethod,
+    property,
+  })
+}

snapshots/input/syntax/src/object-literals-nested.ts

@@ -0,0 +1,40 @@
+import { Option } from './reusable-types'
+
+interface Address {
+  street: string
+  people: Person[]
+}
+interface Person {
+  name: string
+  address?: Address
+}
+
+export function handleNestedObjectLiterals(): Person {
+  return {
+    name: 'John',
+    address: {
+      street: 'Oxford Street',
+      people: [
+        {
+          name: 'Susan',
+        },
+      ],
+    },
+  }
+}
+
+export function handleNestedTypeVariables(): Option<Person> {
+  return {
+    value: {
+      name: 'John',
+      address: {
+        street: 'Oxford Street',
+        people: [
+          {
+            name: 'Susan',
+          },
+        ],
+      },
+    },
+  }
+}

snapshots/input/syntax/src/object-literals.ts

@@ -0,0 +1,91 @@
+import { Configuration } from './reusable-types'
+
+function random(): number {
+  return Math.random()
+}
+
+export function handleArrayLiteral(): Configuration[] {
+  return [
+    {
+      property: 41,
+      property2: '41',
+    },
+  ]
+}
+
+export function returnStatement(): Configuration {
+  if (random() > 0) {
+    return {
+      property: 41,
+      property2: '41',
+    }
+  }
+  for (let i = 0; i < 9; i++) {
+    if (random() > i) {
+      return {
+        property: 41,
+        property2: '41',
+      }
+    }
+  }
+  for (const i of [1, 2, 3]) {
+    if (random() > i) {
+      return {
+        property: 41,
+        property2: '41',
+      }
+    }
+  }
+  for (const i in { '1': 2 }) {
+    if (random() > Number.parseInt(i)) {
+      return {
+        property: 41,
+        property2: '41',
+      }
+    }
+  }
+  while (random() < 0) {
+    return {
+      property: 41,
+      property2: '41',
+    }
+  }
+  do {
+    if (random() > 0) {
+      return {
+        property: 41,
+        property2: '41',
+      }
+    }
+  } while (random() < 0)
+
+  return {
+    property: 42,
+    property2: '41',
+  }
+}
+
+export function constDeclaration(): number[] {
+  var configuration1: Configuration = {
+    property: 1,
+    property2: '1',
+  }
+  configuration1 = {
+    property: 2,
+    property2: '2',
+  }
+  let configuration2: Configuration = {
+    property: 3,
+    property2: '3',
+  }
+  configuration2.property = configuration1.property
+  const configuration3: Configuration = {
+    property: 4,
+    property2: '4',
+  }
+  return [
+    configuration1.property,
+    configuration2.property,
+    configuration3.property,
+  ]
+}

snapshots/input/syntax/src/property-assignment.ts

@@ -5,3 +5,8 @@ export function shorthandPropertyAssignment() {
   const a = 'a'
   return { a }
 }
+type A = { a: string; b: number }
+export function typedPropertyAssignment(): A {
+  // prettier-ignore
+  return { a: 'a', "b": 10 }
+}