Clean up computed properties classes

Author: gitKrystan

package.json

@@ -43,7 +43,6 @@
     "lint:prettier:fix": "prettier --write .",
     "lint:ts": "tsc --noEmit",
     "test": "yarn build && codemod-cli test && node ./test/run-test.js && yarn clean",
-    "fixme": "rm codemods.log; yarn build && codemod-cli test; yarn clean",
     "update-docs": "codemod-cli update-docs"
   },
   "dependencies": {

transforms/helpers/eo-prop/index.ts

@@ -3,11 +3,12 @@ import type { DecoratorImportInfoMap } from '../decorator-info';
 import type { Options } from '../options';
 import { assert } from '../util/types';
 import EOActionsProp from './private/actions';
-import type EOComputedFunctionExpressionProp from './private/computed/function-expression';
+import EOClassDecorator from './private/class-decorator';
+import type EOComputedFunctionExpressionGetter from './private/computed/function-expression-getter';
+import type EOComputedFunctionExpressionMethod from './private/computed/function-expression-method';
 import { makeEOComputedProp } from './private/computed/index';
 import type EOComputedObjectExpressionProp from './private/computed/object-expression';
 import type EOComputedProp from './private/computed/property';
-import EOClassDecorator from './private/class-decorator';
 import EOFunctionExpressionProp from './private/function-expression';
 import EOMethod from './private/method';
 import EOSimpleProp from './private/simple';
@@ -18,7 +19,8 @@ export type { default as EOClassDecorator } from './private/class-decorator';
 export type EOProp =
   | EOActionsProp
   | EOSimpleProp
-  | EOComputedFunctionExpressionProp
+  | EOComputedFunctionExpressionGetter
+  | EOComputedFunctionExpressionMethod
   | EOComputedObjectExpressionProp
   | EOComputedProp
   | EOFunctionExpressionProp

…/private/computed/function-expression.ts …e/computed/function-expression-getter.tstransforms/helpers/eo-prop/private/computed/function-expression.ts renamed to transforms/helpers/eo-prop/private/computed/function-expression-getter.ts transforms/helpers/eo-prop/private/computed/function-expression.ts renamed to transforms/helpers/eo-prop/private/computed/function-expression-getter.ts

@@ -1,10 +1,7 @@
 import { default as j } from 'jscodeshift';
 import type * as AST from '../../../ast';
-import {
-  replaceGetterSetterSuperExpressions,
-  replaceMethodSuperExpressions,
-} from '../../../transform-helper';
-import { assert, defined } from '../../../util/types';
+import { replaceGetterSetterSuperExpressions } from '../../../transform-helper';
+import { assert } from '../../../util/types';
 import AbstractEOComputedProp from './abstract';
 
 /**
@@ -64,17 +61,17 @@ import AbstractEOComputedProp from './abstract';
  * Notably, if the modifiers `volatile` and `readOnly` are used in conjunction,
  * a non-computed getter will be returned.
  */
-export default class EOComputedFunctionExpressionProp extends AbstractEOComputedProp<AST.ClassMethod> {
+export default class EOComputedFunctionExpressionGetter extends AbstractEOComputedProp<AST.ClassMethod> {
   build(): AST.ClassMethod {
     const args = this.arguments;
     const lastArg = args[args.length - 1];
     assert(
       lastArg && lastArg.type === 'FunctionExpression',
       'expected lastArg to be a FunctionExpression'
     );
-    return this.replaceSuperExpression(
+    return replaceGetterSetterSuperExpressions(
       j.classMethod.from({
-        kind: defined(this.kind),
+        kind: 'get',
         key: this.key,
         params: lastArg.params,
         body: lastArg.body,
@@ -85,14 +82,4 @@ export default class EOComputedFunctionExpressionProp extends AbstractEOComputed
       this.key
     );
   }
-
-  private get replaceSuperExpression(): (
-    classMethod: AST.ClassMethod,
-    replaceWithUndefined: boolean,
-    identifier: AST.Identifier
-  ) => AST.ClassMethod {
-    return this.kind === 'method'
-      ? replaceMethodSuperExpressions
-      : replaceGetterSetterSuperExpressions;
-  }
 }

transforms/helpers/eo-prop/private/computed/function-expression-method.ts

@@ -0,0 +1,65 @@
+import { default as j } from 'jscodeshift';
+import type * as AST from '../../../ast';
+import { replaceMethodSuperExpressions } from '../../../transform-helper';
+import { assert } from '../../../util/types';
+import AbstractEOComputedProp from './abstract';
+
+/**
+ * Ember Object Computed Function Expression Property
+ *
+ * A wrapper object for Ember Object properties where the value is a
+ * `CallExpression` with a `FunctionExpression` as its last argument.
+ *
+ * These represent computed properties (including computed macros) to be
+ * transformed into `ClassMethod`s with their appropriate decorators (and any
+ * modifiers).
+ *
+ * @example
+ *
+ * ```
+ * import { observer as watcher } from '@ember/object';
+ *
+ * const MyObject = EmberObject.extend({
+ *   observedProp: watcher('xyz', function() {
+ *     return 'observed';
+ *   }),
+ * });
+ * ```
+ *
+ * transforms into:
+ *
+ * ```
+ * import { observes as watcher } from '@ember-decorators/object';
+ *
+ * class MyObject extends EmberObject {
+ *   @watcher('xyz')
+ *   observedProp() {
+ *     return 'observed';
+ *   }
+ * }
+ * ```
+ *
+ * Notably, if the modifiers `volatile` and `readOnly` are used in conjunction,
+ * a non-computed getter will be returned.
+ */
+export default class EOComputedFunctionExpressionMethod extends AbstractEOComputedProp<AST.ClassMethod> {
+  build(): AST.ClassMethod {
+    const args = this.arguments;
+    const lastArg = args[args.length - 1];
+    assert(
+      lastArg && lastArg.type === 'FunctionExpression',
+      'expected lastArg to be a FunctionExpression'
+    );
+    return replaceMethodSuperExpressions(
+      j.classMethod.from({
+        kind: 'method',
+        key: this.key,
+        params: lastArg.params,
+        body: lastArg.body,
+        comments: this.comments,
+        decorators: this.buildDecorators(),
+      }),
+      this.replaceSuperWithUndefined
+    );
+  }
+}

transforms/helpers/eo-prop/private/computed/index.ts

@@ -5,7 +5,8 @@ import type {
 } from '../../../decorator-info';
 import type { Options } from '../../../options';
 import { assert } from '../../../util/types';
-import EOComputedFunctionExpressionProp from './function-expression';
+import EOComputedFunctionExpressionGetter from './function-expression-getter';
+import EOComputedFunctionExpressionMethod from './function-expression-method';
 import { getModifier } from './modifier-helper';
 import EOComputedObjectExpressionProp from './object-expression';
 import EOComputedProp from './property';
@@ -18,7 +19,8 @@ export function makeEOComputedProp(
   existingDecoratorImportInfos: DecoratorImportInfoMap,
   options: Options
 ):
-  | EOComputedFunctionExpressionProp
+  | EOComputedFunctionExpressionGetter
+  | EOComputedFunctionExpressionMethod
   | EOComputedObjectExpressionProp
   | EOComputedProp {
   let calleeObject = raw.value;
@@ -48,30 +50,33 @@ export function makeEOComputedProp(
 
   const args = calleeObject.arguments;
   const lastArg = args[args.length - 1];
-  if ((kind === 'method' || kind === 'get') && lastArg) {
-    if (lastArg.type === 'FunctionExpression') {
-      return new EOComputedFunctionExpressionProp(
-        raw,
-        calleeObject,
-        modifiers,
-        kind,
-        decorators,
-        options
-      );
-    } else if (lastArg.type === 'ObjectExpression') {
-      return new EOComputedObjectExpressionProp(
-        raw,
-        calleeObject,
-        modifiers,
-        kind,
-        decorators,
-        options
-      );
-    } else {
-      throw new Error(
-        'Expected last argument in call expression to be a FunctionExpression or ObjectExpression'
-      );
-    }
+  if (kind === 'method' && lastArg?.type === 'FunctionExpression') {
+    return new EOComputedFunctionExpressionMethod(
+      raw,
+      calleeObject,
+      modifiers,
+      kind,
+      decorators,
+      options
+    );
+  } else if (kind === 'get' && lastArg?.type === 'FunctionExpression') {
+    return new EOComputedFunctionExpressionGetter(
+      raw,
+      calleeObject,
+      modifiers,
+      kind,
+      decorators,
+      options
+    );
+  } else if (kind === 'get' && lastArg?.type === 'ObjectExpression') {
+    return new EOComputedObjectExpressionProp(
+      raw,
+      calleeObject,
+      modifiers,
+      kind,
+      decorators,
+      options
+    );
   }
 
   return new EOComputedProp(