Clean up AST types

Author: gitKrystan

transforms/helpers/ast.ts

@@ -1,6 +1,7 @@
-import type { Decorator, JSCodeshift } from 'jscodeshift';
+import type { JSCodeshift } from 'jscodeshift';
+import type { Decorator } from './ast';
+import type { EOClassDecoratorProp, EOSimpleProp } from './eo-prop/index';
 import { EOCallExpressionProp } from './eo-prop/index';
-import type { EOBaseProp, EOClassDecoratorProp } from './eo-prop/index';
 import { assert, defined } from './util/types';
 
 /** Copy decorators `from` => `to` */
@@ -110,7 +111,7 @@ function createBindingDecorators(
 /** Handles decorators for instance properties */
 export function createInstancePropDecorators(
   j: JSCodeshift,
-  instanceProp: EOCallExpressionProp | EOBaseProp
+  instanceProp: EOCallExpressionProp | EOSimpleProp
 ): Decorator[] {
   let decorators: Decorator[] = [];
   for (const decorator of instanceProp.decoratorNames) {

transforms/helpers/decorator-helper.ts

@@ -1,6 +1,6 @@
-import type { ImportSpecifier } from 'jscodeshift';
 import { assert } from './util/types';
 import { METHOD_DECORATORS } from './util/index';
+import type { ImportSpecifier } from './ast';
 
 export interface DecoratorImportInfo {
   name: 'unobserves' | 'off' | 'className' | 'attribute' | string;

transforms/helpers/decorator-info.ts

@@ -1,31 +1,29 @@
-import type { Property } from 'jscodeshift';
+import type { EOProperty } from '../ast';
+import {
+  isEOPropertyForActionsObject,
+  isEOPropertyForClassDecorator,
+  isEOPropertySimple,
+  isEOPropertyWithCallExpression,
+  isEOPropertyWithFunctionExpression,
+} from '../ast';
 import type { DecoratorImportInfoMap } from '../decorator-info';
 import type { RuntimeData } from '../runtime-data';
 import { assert } from '../util/types';
-import EOActionsObjectProp, {
-  isEOActionsPropProperty,
-} from './private/actions-object';
-import EOBaseProp, { isEOProperty } from './private/base';
-import EOCallExpressionProp, {
-  isCallExpressionProperty,
-} from './private/call-expression';
-import EOClassDecoratorProp, {
-  isClassDecoratorProperty,
-} from './private/class-decorator';
-import EOFunctionExpressionProp, {
-  isFunctionExpressionProperty,
-} from './private/function-expression';
+import EOActionsObjectProp from './private/actions-object';
+import EOCallExpressionProp from './private/call-expression';
+import EOClassDecoratorProp from './private/class-decorator';
+import EOFunctionExpressionProp from './private/function-expression';
+import EOSimpleProp from './private/simple';
 
 export { default as EOActionsObjectProp } from './private/actions-object';
-export type { Action } from './private/actions-object';
-export { default as EOBaseProp } from './private/base';
 export { default as EOCallExpressionProp } from './private/call-expression';
 export { default as EOClassDecoratorProp } from './private/class-decorator';
 export { default as EOFunctionExpressionProp } from './private/function-expression';
+export { default as EOSimpleProp } from './private/simple';
 
 export type EOProp =
   | EOActionsObjectProp
-  | EOBaseProp
+  | EOSimpleProp
   | EOCallExpressionProp
   | EOClassDecoratorProp
   | EOFunctionExpressionProp;
@@ -39,24 +37,24 @@ export interface EOProps {
  * Property, RuntimeData, and ImportPropDecoratorMap.
  */
 export default function makeEOProp(
-  eoProp: Property,
+  eoProp: EOProperty,
   runtimeData: RuntimeData | undefined,
   existingDecoratorImportInfos: DecoratorImportInfoMap
 ): EOProp {
-  if (isCallExpressionProperty(eoProp)) {
+  if (isEOPropertyWithCallExpression(eoProp)) {
     return new EOCallExpressionProp(
       eoProp,
       runtimeData,
       existingDecoratorImportInfos
     );
-  } else if (isFunctionExpressionProperty(eoProp)) {
+  } else if (isEOPropertyWithFunctionExpression(eoProp)) {
     return new EOFunctionExpressionProp(eoProp, runtimeData);
-  } else if (isClassDecoratorProperty(eoProp)) {
+  } else if (isEOPropertyForClassDecorator(eoProp)) {
     return new EOClassDecoratorProp(eoProp, runtimeData);
-  } else if (isEOActionsPropProperty(eoProp)) {
+  } else if (isEOPropertyForActionsObject(eoProp)) {
     return new EOActionsObjectProp(eoProp, runtimeData);
   } else {
-    assert(isEOProperty(eoProp));
-    return new EOBaseProp(eoProp, runtimeData);
+    assert(isEOPropertySimple(eoProp));
+    return new EOSimpleProp(eoProp, runtimeData);
   }
 }

transforms/helpers/eo-prop/index.ts

@@ -1,7 +1,6 @@
-import type { Property } from 'jscodeshift';
+import type { EOProperty } from '../../ast';
 import type { DecoratorImportInfo } from '../../decorator-info';
 import type { RuntimeData } from '../../runtime-data';
-import { getPropName } from '../../util/index';
 
 interface EODecoratorArgs {
   unobserves?: Array<string | boolean | number | null> | undefined;
@@ -14,8 +13,7 @@ interface EODecoratorArgs {
  * A wrapper object for ember object properties
  */
 export default abstract class AbstractEOProp<
-  V extends Property['value'] = Property['value'],
-  P extends Property & { value: V } = Property & { value: V }
+  P extends EOProperty = EOProperty
 > {
   readonly _prop: P;
 
@@ -56,7 +54,7 @@ export default abstract class AbstractEOProp<
     }
   }
 
-  get value(): V {
+  get value(): P['value'] {
     return this._prop.value;
   }
 
@@ -65,10 +63,10 @@ export default abstract class AbstractEOProp<
   }
 
   get name(): string {
-    return getPropName(this._prop);
+    return this._prop.key.name;
   }
 
-  get type(): V['type'] {
+  get type(): P['value']['type'] {
     return this._prop.value.type;
   }
 

transforms/helpers/eo-prop/private/abstract.ts

@@ -1,42 +1,12 @@
-import type { Identifier, ObjectExpression, Property } from 'jscodeshift';
+import type { EOAction, EOPropertyWithActionsObject } from '../../ast';
 import type { RuntimeData } from '../../runtime-data';
 import AbstractEOProp from './abstract';
 
-export type Action = Property & {
-  key: Identifier;
-};
-
-type ActionsObjectExpression = ObjectExpression & {
-  properties: Action[];
-};
-
-export type ActionsObjectProperty = Property & {
-  value: ActionsObjectExpression;
-  key: Identifier & { name: 'actions' };
-};
-
-/** Type predicate */
-export function isEOActionsPropProperty(
-  property: Property
-): property is ActionsObjectProperty {
-  return (
-    property.value.type === 'ObjectExpression' &&
-    'name' in property.key &&
-    property.key.name === 'actions' &&
-    property.value.properties.every(
-      (p) => p.type === 'Property' && p.key.type === 'Identifier'
-    )
-  );
-}
-
-export default class EOActionsObjectProp extends AbstractEOProp<
-  ActionsObjectExpression,
-  ActionsObjectProperty
-> {
+export default class EOActionsObjectProp extends AbstractEOProp<EOPropertyWithActionsObject> {
   readonly overriddenActions: string[] = [];
 
   constructor(
-    eoProp: ActionsObjectProperty,
+    eoProp: EOPropertyWithActionsObject,
     runtimeData: RuntimeData | undefined
   ) {
     super(eoProp, runtimeData);
@@ -45,7 +15,7 @@ export default class EOActionsObjectProp extends AbstractEOProp<
     }
   }
 
-  get properties(): Action[] {
+  get properties(): EOAction[] {
     return this._prop.value.properties;
   }
 }

transforms/helpers/eo-prop/private/actions-object.ts

@@ -1,32 +1,24 @@
-import type { CallExpression, Identifier, Property } from 'jscodeshift';
+import type {
+  CallExpression,
+  EOCallExpression,
+  EOPropertyWithCallExpression,
+} from '../../ast';
 import type { DecoratorImportInfoMap } from '../../decorator-info';
 import type { RuntimeData } from '../../runtime-data';
 import { assert, isString, verified } from '../../util/types';
 import AbstractEOProp from './abstract';
 
-type CallExpressionProperty = Property & {
-  value: CallExpression;
-  key: Identifier;
-};
-
-/** Type predicate */
-export function isCallExpressionProperty(
-  property: Property
-): property is CallExpressionProperty {
-  return property.value.type === 'CallExpression';
-}
-
 interface CallExpressionModifier {
   prop:
-    | Extract<CallExpression['callee'], { property: unknown }>['property']
+    | Extract<EOCallExpression['callee'], { property: unknown }>['property']
     | undefined;
-  args: CallExpression['arguments'];
+  args: EOCallExpression['arguments'];
 }
 
 /**
  * Get property modifier from the property callee object
  */
-function getModifier(calleeObject: CallExpression): CallExpressionModifier {
+function getModifier(calleeObject: EOCallExpression): CallExpressionModifier {
   return {
     prop:
       'property' in calleeObject.callee
@@ -36,15 +28,12 @@ function getModifier(calleeObject: CallExpression): CallExpressionModifier {
   };
 }
 
-export default class EOCallExpressionProp extends AbstractEOProp<
-  CallExpression,
-  CallExpressionProperty
-> {
+export default class EOCallExpressionProp extends AbstractEOProp<EOPropertyWithCallExpression> {
   private calleeObject: CallExpression;
   readonly modifiers: CallExpressionModifier[];
 
   constructor(
-    eoProp: CallExpressionProperty,
+    eoProp: EOPropertyWithCallExpression,
     runtimeData: RuntimeData | undefined,
     existingDecoratorImportInfos: DecoratorImportInfoMap
   ) {

transforms/helpers/eo-prop/private/base.ts

@@ -1,46 +1,11 @@
-import type {
-  ArrayExpression,
-  Identifier,
-  Literal,
-  Property,
-} from 'jscodeshift';
+import type { EOPropertyForClassDecorator } from '../../ast';
 import {
   LAYOUT_DECORATOR_LOCAL_NAME,
   LAYOUT_DECORATOR_NAME,
 } from '../../util/index';
 import AbstractEOProp from './abstract';
 
-type ClassDecoratorPropertyValue = (Literal | ArrayExpression | Identifier) & {
-  name: string;
-};
-
-export type ClassDecoratorProperty = Property & {
-  value: ClassDecoratorPropertyValue;
-};
-
-const ClassDecoratorPropNames = new Set([
-  'layout',
-  'tagName',
-  'classNames',
-  'classNameBindings',
-  'attributeBindings',
-]);
-
-/** Type predicate */
-export function isClassDecoratorProperty(
-  property: Property
-): property is ClassDecoratorProperty {
-  return (
-    (property.value.type === 'Literal' ||
-      property.value.type === 'ArrayExpression' ||
-      property.value.type === 'Identifier') &&
-    'name' in property.key &&
-    typeof property.key.name === 'string' &&
-    ClassDecoratorPropNames.has(property.key.name)
-  );
-}
-
-export default class EOClassDecoratorProp extends AbstractEOProp<ClassDecoratorPropertyValue> {
+export default class EOClassDecoratorProp extends AbstractEOProp<EOPropertyForClassDecorator> {
   get classDecoratorName(): string {
     if (
       this.name === LAYOUT_DECORATOR_NAME &&

transforms/helpers/eo-prop/private/call-expression.ts

@@ -1,19 +1,4 @@
-import type { FunctionExpression, Identifier, Property } from 'jscodeshift';
+import type { EOPropertyWithFunctionExpression } from '../../ast';
 import AbstractEOProp from './abstract';
 
-export type FunctionExpressionProperty = Property & {
-  value: FunctionExpression;
-  key: Identifier;
-};
-
-/** Type predicate */
-export function isFunctionExpressionProperty(
-  property: Property
-): property is FunctionExpressionProperty {
-  return property.value.type === 'FunctionExpression';
-}
-
-export default class EOFunctionExpressionProp extends AbstractEOProp<
-  FunctionExpression,
-  FunctionExpressionProperty
-> {}
+export default class EOFunctionExpressionProp extends AbstractEOProp<EOPropertyWithFunctionExpression> {}