using Map instead

Author: Janther

src/slang-nodes/ArgumentsDeclaration.ts

@@ -8,17 +8,25 @@ import type { ParserOptions } from 'prettier';
 import type { CollectedMetadata } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
-const variantConstructors = {
-  [ast.PositionalArgumentsDeclaration.name]: PositionalArgumentsDeclaration,
-  [ast.NamedArgumentsDeclaration.name]: NamedArgumentsDeclaration
-};
+const keys = [
+  ast.PositionalArgumentsDeclaration,
+  ast.NamedArgumentsDeclaration
+];
+const constructors = [
+  PositionalArgumentsDeclaration,
+  NamedArgumentsDeclaration
+];
+
+const variantConstructors = new Map<string, (typeof constructors)[number]>(
+  keys.map((key, index) => [key.name, constructors[index]])
+);
 
 function createNonterminalVariant(
   variant: ast.ArgumentsDeclaration['variant'],
   collected: CollectedMetadata,
   options: ParserOptions<AstNode>
 ): ArgumentsDeclaration['variant'] {
-  const variantConstructor = variantConstructors[variant.constructor.name];
+  const variantConstructor = variantConstructors.get(variant.constructor.name);
   if (variantConstructor !== undefined)
     return new variantConstructor(variant as never, collected, options);
 

src/slang-nodes/ContractMember.ts

@@ -19,28 +19,47 @@ import type { ParserOptions } from 'prettier';
 import type { CollectedMetadata } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
-const variantConstructors = {
-  [ast.UsingDirective.name]: UsingDirective,
-  [ast.FunctionDefinition.name]: FunctionDefinition,
-  [ast.ConstructorDefinition.name]: ConstructorDefinition,
-  [ast.ReceiveFunctionDefinition.name]: ReceiveFunctionDefinition,
-  [ast.FallbackFunctionDefinition.name]: FallbackFunctionDefinition,
-  [ast.UnnamedFunctionDefinition.name]: UnnamedFunctionDefinition,
-  [ast.ModifierDefinition.name]: ModifierDefinition,
-  [ast.StructDefinition.name]: StructDefinition,
-  [ast.EnumDefinition.name]: EnumDefinition,
-  [ast.EventDefinition.name]: EventDefinition,
-  [ast.StateVariableDefinition.name]: StateVariableDefinition,
-  [ast.ErrorDefinition.name]: ErrorDefinition,
-  [ast.UserDefinedValueTypeDefinition.name]: UserDefinedValueTypeDefinition
-};
+const keys = [
+  ast.UsingDirective,
+  ast.FunctionDefinition,
+  ast.ConstructorDefinition,
+  ast.ReceiveFunctionDefinition,
+  ast.FallbackFunctionDefinition,
+  ast.UnnamedFunctionDefinition,
+  ast.ModifierDefinition,
+  ast.StructDefinition,
+  ast.EnumDefinition,
+  ast.EventDefinition,
+  ast.StateVariableDefinition,
+  ast.ErrorDefinition,
+  ast.UserDefinedValueTypeDefinition
+];
+const constructors = [
+  UsingDirective,
+  FunctionDefinition,
+  ConstructorDefinition,
+  ReceiveFunctionDefinition,
+  FallbackFunctionDefinition,
+  UnnamedFunctionDefinition,
+  ModifierDefinition,
+  StructDefinition,
+  EnumDefinition,
+  EventDefinition,
+  StateVariableDefinition,
+  ErrorDefinition,
+  UserDefinedValueTypeDefinition
+];
+
+const variantConstructors = new Map<string, (typeof constructors)[number]>(
+  keys.map((key, index) => [key.name, constructors[index]])
+);
 
 function createNonterminalVariant(
   variant: ast.ContractMember['variant'],
   collected: CollectedMetadata,
   options: ParserOptions<AstNode>
 ): ContractMember['variant'] {
-  const variantConstructor = variantConstructors[variant.constructor.name];
+  const variantConstructor = variantConstructors.get(variant.constructor.name);
   if (variantConstructor !== undefined)
     return new variantConstructor(variant as never, collected, options);
 

src/slang-nodes/ContractSpecifier.ts

@@ -8,17 +8,19 @@ import type { ParserOptions } from 'prettier';
 import type { CollectedMetadata } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
-const variantConstructors = {
-  [ast.InheritanceSpecifier.name]: InheritanceSpecifier,
-  [ast.StorageLayoutSpecifier.name]: StorageLayoutSpecifier
-};
+const keys = [ast.InheritanceSpecifier, ast.StorageLayoutSpecifier];
+const constructors = [InheritanceSpecifier, StorageLayoutSpecifier];
+
+const variantConstructors = new Map<string, (typeof constructors)[number]>(
+  keys.map((key, index) => [key.name, constructors[index]])
+);
 
 function createNonterminalVariant(
   variant: ast.ContractSpecifier['variant'],
   collected: CollectedMetadata,
   options: ParserOptions<AstNode>
 ): ContractSpecifier['variant'] {
-  const variantConstructor = variantConstructors[variant.constructor.name];
+  const variantConstructor = variantConstructors.get(variant.constructor.name);
   if (variantConstructor !== undefined)
     return new variantConstructor(variant as never, collected, options);
 

src/slang-nodes/Expression.ts

@@ -38,50 +38,90 @@ import type { ParserOptions } from 'prettier';
 import type { CollectedMetadata } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
-const variantConstructors = {
-  [ast.AssignmentExpression.name]: AssignmentExpression,
-  [ast.ConditionalExpression.name]: ConditionalExpression,
-  [ast.OrExpression.name]: OrExpression,
-  [ast.AndExpression.name]: AndExpression,
-  [ast.EqualityExpression.name]: EqualityExpression,
-  [ast.InequalityExpression.name]: InequalityExpression,
-  [ast.BitwiseOrExpression.name]: BitwiseOrExpression,
-  [ast.BitwiseXorExpression.name]: BitwiseXorExpression,
-  [ast.BitwiseAndExpression.name]: BitwiseAndExpression,
-  [ast.ShiftExpression.name]: ShiftExpression,
-  [ast.AdditiveExpression.name]: AdditiveExpression,
-  [ast.MultiplicativeExpression.name]: MultiplicativeExpression,
-  [ast.ExponentiationExpression.name]: ExponentiationExpression,
-  [ast.PostfixExpression.name]: PostfixExpression,
-  [ast.PrefixExpression.name]: PrefixExpression,
-  [ast.FunctionCallExpression.name]: FunctionCallExpression,
-  [ast.CallOptionsExpression.name]: CallOptionsExpression,
-  [ast.MemberAccessExpression.name]: MemberAccessExpression,
-  [ast.IndexAccessExpression.name]: IndexAccessExpression,
-  [ast.NewExpression.name]: NewExpression,
-  [ast.TupleExpression.name]: TupleExpression,
-  [ast.TypeExpression.name]: TypeExpression,
-  [ast.ArrayExpression.name]: ArrayExpression,
-  [ast.HexNumberExpression.name]: HexNumberExpression,
-  [ast.DecimalNumberExpression.name]: DecimalNumberExpression
-};
+const keys = [
+  ast.AssignmentExpression,
+  ast.ConditionalExpression,
+  ast.OrExpression,
+  ast.AndExpression,
+  ast.EqualityExpression,
+  ast.InequalityExpression,
+  ast.BitwiseOrExpression,
+  ast.BitwiseXorExpression,
+  ast.BitwiseAndExpression,
+  ast.ShiftExpression,
+  ast.AdditiveExpression,
+  ast.MultiplicativeExpression,
+  ast.ExponentiationExpression,
+  ast.PostfixExpression,
+  ast.PrefixExpression,
+  ast.FunctionCallExpression,
+  ast.CallOptionsExpression,
+  ast.MemberAccessExpression,
+  ast.IndexAccessExpression,
+  ast.NewExpression,
+  ast.TupleExpression,
+  ast.TypeExpression,
+  ast.ArrayExpression,
+  ast.HexNumberExpression,
+  ast.DecimalNumberExpression
+];
+const constructors = [
+  AssignmentExpression,
+  ConditionalExpression,
+  OrExpression,
+  AndExpression,
+  EqualityExpression,
+  InequalityExpression,
+  BitwiseOrExpression,
+  BitwiseXorExpression,
+  BitwiseAndExpression,
+  ShiftExpression,
+  AdditiveExpression,
+  MultiplicativeExpression,
+  ExponentiationExpression,
+  PostfixExpression,
+  PrefixExpression,
+  FunctionCallExpression,
+  CallOptionsExpression,
+  MemberAccessExpression,
+  IndexAccessExpression,
+  NewExpression,
+  TupleExpression,
+  TypeExpression,
+  ArrayExpression,
+  HexNumberExpression,
+  DecimalNumberExpression
+];
 
-const variantWithVariantsConstructors = {
-  [ast.StringExpression.name]: StringExpression,
-  [ast.ElementaryType.name]: ElementaryType
-};
+const variantConstructors = new Map<string, (typeof constructors)[number]>(
+  keys.map((key, index) => [key.name, constructors[index]])
+);
+
+const keysWithVariants = [ast.StringExpression, ast.ElementaryType];
+const constructorsWithVariants = [StringExpression, ElementaryType];
+
+const variantWithVariantsConstructors = new Map<
+  string,
+  (typeof constructorsWithVariants)[number]
+>(
+  keysWithVariants.map((key, index) => [
+    key.name,
+    constructorsWithVariants[index]
+  ])
+);
 
 function createNonterminalVariant(
   variant: Exclude<ast.Expression['variant'], SlangTerminalNode>,
   collected: CollectedMetadata,
   options: ParserOptions<AstNode>
 ): Expression['variant'] {
-  const variantConstructor = variantConstructors[variant.constructor.name];
+  const variantConstructor = variantConstructors.get(variant.constructor.name);
   if (variantConstructor !== undefined)
     return new variantConstructor(variant as never, collected, options);
 
-  const variantWithVariantsConstructor =
-    variantWithVariantsConstructors[variant.constructor.name];
+  const variantWithVariantsConstructor = variantWithVariantsConstructors.get(
+    variant.constructor.name
+  );
   if (variantWithVariantsConstructor !== undefined)
     return extractVariant(
       new variantWithVariantsConstructor(variant as never, collected, options)

src/slang-nodes/FallbackFunctionAttribute.ts

@@ -12,17 +12,19 @@ import type { ParserOptions } from 'prettier';
 import type { CollectedMetadata } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
-const variantConstructors = {
-  [ast.ModifierInvocation.name]: ModifierInvocation,
-  [ast.OverrideSpecifier.name]: OverrideSpecifier
-};
+const keys = [ast.ModifierInvocation, ast.OverrideSpecifier];
+const constructors = [ModifierInvocation, OverrideSpecifier];
+
+const variantConstructors = new Map<string, (typeof constructors)[number]>(
+  keys.map((key, index) => [key.name, constructors[index]])
+);
 
 function createNonterminalVariant(
   variant: Exclude<ast.FallbackFunctionAttribute['variant'], SlangTerminalNode>,
   collected: CollectedMetadata,
   options: ParserOptions<AstNode>
 ): Exclude<FallbackFunctionAttribute['variant'], TerminalNode> {
-  const variantConstructor = variantConstructors[variant.constructor.name];
+  const variantConstructor = variantConstructors.get(variant.constructor.name);
   if (variantConstructor !== undefined)
     return new variantConstructor(variant as never, collected, options);
 

src/slang-nodes/ForStatementInitialization.ts

@@ -13,11 +13,20 @@ import type { ParserOptions } from 'prettier';
 import type { CollectedMetadata } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
-const variantConstructors = {
-  [ast.ExpressionStatement.name]: ExpressionStatement,
-  [ast.VariableDeclarationStatement.name]: VariableDeclarationStatement,
-  [ast.TupleDeconstructionStatement.name]: TupleDeconstructionStatement
-};
+const keys = [
+  ast.ExpressionStatement,
+  ast.VariableDeclarationStatement,
+  ast.TupleDeconstructionStatement
+];
+const constructors = [
+  ExpressionStatement,
+  VariableDeclarationStatement,
+  TupleDeconstructionStatement
+];
+
+const variantConstructors = new Map<string, (typeof constructors)[number]>(
+  keys.map((key, index) => [key.name, constructors[index]])
+);
 
 function createNonterminalVariant(
   variant: Exclude<
@@ -27,7 +36,7 @@ function createNonterminalVariant(
   collected: CollectedMetadata,
   options: ParserOptions<AstNode>
 ): Exclude<ForStatementInitialization['variant'], TerminalNode> {
-  const variantConstructor = variantConstructors[variant.constructor.name];
+  const variantConstructor = variantConstructors.get(variant.constructor.name);
   if (variantConstructor !== undefined)
     return new variantConstructor(variant as never, collected, options);
 

src/slang-nodes/FunctionAttribute.ts

@@ -12,17 +12,19 @@ import type { ParserOptions } from 'prettier';
 import type { CollectedMetadata } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
-const variantConstructors = {
-  [ast.ModifierInvocation.name]: ModifierInvocation,
-  [ast.OverrideSpecifier.name]: OverrideSpecifier
-};
+const keys = [ast.ModifierInvocation, ast.OverrideSpecifier];
+const constructors = [ModifierInvocation, OverrideSpecifier];
+
+const variantConstructors = new Map<string, (typeof constructors)[number]>(
+  keys.map((key, index) => [key.name, constructors[index]])
+);
 
 function createNonterminalVariant(
   variant: Exclude<ast.FunctionAttribute['variant'], SlangTerminalNode>,
   collected: CollectedMetadata,
   options: ParserOptions<AstNode>
 ): Exclude<FunctionAttribute['variant'], TerminalNode> {
-  const variantConstructor = variantConstructors[variant.constructor.name];
+  const variantConstructor = variantConstructors.get(variant.constructor.name);
   if (variantConstructor !== undefined)
     return new variantConstructor(variant as never, collected, options);
 

src/slang-nodes/ImportClause.ts

@@ -9,18 +9,19 @@ import type { ParserOptions } from 'prettier';
 import type { CollectedMetadata } from '../types.d.ts';
 import type { AstNode } from './types.d.ts';
 
-const variantConstructors = {
-  [ast.PathImport.name]: PathImport,
-  [ast.NamedImport.name]: NamedImport,
-  [ast.ImportDeconstruction.name]: ImportDeconstruction
-};
+const keys = [ast.PathImport, ast.NamedImport, ast.ImportDeconstruction];
+const constructors = [PathImport, NamedImport, ImportDeconstruction];
+
+const variantConstructors = new Map<string, (typeof constructors)[number]>(
+  keys.map((key, index) => [key.name, constructors[index]])
+);
 
 function createNonterminalVariant(
   variant: ast.ImportClause['variant'],
   collected: CollectedMetadata,
   options: ParserOptions<AstNode>
 ): ImportClause['variant'] {
-  const variantConstructor = variantConstructors[variant.constructor.name];
+  const variantConstructor = variantConstructors.get(variant.constructor.name);
   if (variantConstructor !== undefined)
     return new variantConstructor(variant as never, collected, options);