cleaning up Object.create cases

Author: Janther

src/slang-nodes/ModifierDefinition.ts

@@ -12,12 +12,6 @@ import type { AstPath, Doc, ParserOptions } from 'prettier';
 import type { AstNode } from '../slang-nodes';
 import type { PrintFunction, SlangNode } from '../types';
 
-const objectConfig = {
-  writable: true,
-  enumerable: true,
-  configurable: true
-};
-
 export class ModifierDefinition implements SlangNode {
   readonly kind = NonterminalKind.ModifierDefinition;
 
@@ -74,27 +68,24 @@ export class ModifierDefinition implements SlangNode {
         trailingOffset: 0
       };
 
-      this.parameters = Object.create(ParametersDeclaration.prototype, {
-        kind: {
-          value: NonterminalKind.ParametersDeclaration,
-          ...objectConfig
-        },
-        loc: {
-          value: { ...parametersLoc },
-          ...objectConfig
-        },
-        comments: { value: [], ...objectConfig },
-        parameters: {
-          value: Object.create(Parameters.prototype, {
-            kind: { value: NonterminalKind.Parameters, ...objectConfig },
-            loc: { value: { ...parametersLoc }, ...objectConfig },
-            comments: { value: [], ...objectConfig },
-            items: { value: [], ...objectConfig },
-            separators: { value: [], ...objectConfig }
-          }) as Parameters,
-          ...objectConfig
+      this.parameters = Object.assign(
+        Object.create(ParametersDeclaration.prototype) as ParametersDeclaration,
+        {
+          kind: NonterminalKind.ParametersDeclaration,
+          loc: { ...parametersLoc },
+          comments: [],
+          parameters: Object.assign(
+            Object.create(Parameters.prototype) as Parameters,
+            {
+              kind: NonterminalKind.Parameters,
+              loc: { ...parametersLoc },
+              comments: [],
+              items: [],
+              separators: []
+            }
+          )
         }
-      }) as ParametersDeclaration;
+      );
     }
   }
 

src/slang-nodes/ModifierInvocation.ts

@@ -52,7 +52,7 @@ export class ModifierInvocation implements SlangNode {
         this.arguments.variant.arguments.items.length === 0 && // no arguments
         !ast.arguments!.variant.cst.children().some((child) => isComment(child)) // no comments, at this point we need to check the CST
       ) {
-        this.arguments = undefined;
+        delete this.arguments;
       }
     };
   }

src/slang-utils/create-hug-function.ts

@@ -8,12 +8,6 @@ import { TupleExpression } from '../slang-nodes/TupleExpression.js';
 import { TupleValues } from '../slang-nodes/TupleValues.js';
 import { TupleValue } from '../slang-nodes/TupleValue.js';
 
-const objectConfig = {
-  writable: true,
-  enumerable: true,
-  configurable: true
-};
-
 export function createHugFunction(
   huggableOperators: string[]
 ): (node: Expression) => Expression {
@@ -26,42 +20,39 @@ export function createHugFunction(
     ) {
       const { loc } = node;
 
-      return Object.create(Expression.prototype, {
-        kind: { value: NonterminalKind.Expression, ...objectConfig },
-        loc: { value: { ...loc }, ...objectConfig },
-        comments: { value: [], ...objectConfig },
-        variant: {
-          value: Object.create(TupleExpression.prototype, {
-            kind: { value: NonterminalKind.TupleExpression, ...objectConfig },
-            loc: { value: { ...loc }, ...objectConfig },
-            comments: { value: [], ...objectConfig },
-            items: {
-              value: Object.create(TupleValues.prototype, {
-                kind: { value: NonterminalKind.TupleValues, ...objectConfig },
-                loc: { value: { ...loc }, ...objectConfig },
-                comments: { value: [], ...objectConfig },
-                items: {
-                  value: [
-                    Object.create(TupleValue.prototype, {
-                      kind: {
-                        value: NonterminalKind.TupleValue,
-                        ...objectConfig
-                      },
-                      loc: { value: { ...loc }, ...objectConfig },
-                      comments: { value: [], ...objectConfig },
-                      expression: { value: node, ...objectConfig }
-                    }) as TupleValue
-                  ],
-                  ...objectConfig
-                },
-                separators: { value: [], ...objectConfig }
-              }) as TupleValues,
-              ...objectConfig
-            }
-          }) as TupleExpression,
-          ...objectConfig
-        }
-      }) as Expression;
+      return Object.assign(Object.create(Expression.prototype) as Expression, {
+        kind: NonterminalKind.Expression,
+        loc: { ...loc },
+        comments: [],
+        variant: Object.assign(
+          Object.create(TupleExpression.prototype) as TupleExpression,
+          {
+            kind: NonterminalKind.TupleExpression,
+            loc: { ...loc },
+            comments: [],
+            items: Object.assign(
+              Object.create(TupleValues.prototype) as TupleValues,
+              {
+                kind: NonterminalKind.TupleValues,
+                loc: { ...loc },
+                comments: [],
+                items: [
+                  Object.assign(
+                    Object.create(TupleValue.prototype) as TupleValue,
+                    {
+                      kind: NonterminalKind.TupleValue,
+                      loc: { ...loc },
+                      comments: [],
+                      expression: node
+                    }
+                  )
+                ],
+                separators: []
+              }
+            )
+          }
+        )
+      });
     }
 
     return node;

src/slang-utils/create-kind-check-function.ts

@@ -1,8 +1,12 @@
 import type { Node } from '@nomicfoundation/slang/cst';
+import type {
+  NonterminalKind,
+  TerminalKind
+} from '@nomicfoundation/slang/kinds';
 import type { StrictAstNode } from '../slang-nodes';
 
 export function createKindCheckFunction(
-  kindsArray: string[]
+  kindsArray: (keyof typeof TerminalKind | keyof typeof NonterminalKind)[]
 ): (node: StrictAstNode | Node) => boolean {
   const kinds = new Set(kindsArray);
   return (node: StrictAstNode | Node): boolean => kinds.has(node.kind);