storing variant before switch statement

Author: Janther

src/slang-nodes/ArgumentsDeclaration.ts

@@ -16,21 +16,23 @@ export class ArgumentsDeclaration extends SlangNode {
   constructor(ast: ast.ArgumentsDeclaration, options: ParserOptions<AstNode>) {
     super(ast);
 
-    switch (ast.variant.cst.kind) {
+    const variant = ast.variant;
+    const variantKind = variant.cst.kind;
+    switch (variantKind) {
       case NonterminalKind.PositionalArgumentsDeclaration:
         this.variant = new PositionalArgumentsDeclaration(
-          ast.variant as ast.PositionalArgumentsDeclaration,
+          variant as ast.PositionalArgumentsDeclaration,
           options
         );
         break;
       case NonterminalKind.NamedArgumentsDeclaration:
         this.variant = new NamedArgumentsDeclaration(
-          ast.variant as ast.NamedArgumentsDeclaration,
+          variant as ast.NamedArgumentsDeclaration,
           options
         );
         break;
       default:
-        throw new Error(`Unexpected variant: ${ast.variant.cst.kind}`);
+        throw new Error(`Unexpected variant: ${variantKind}`);
     }
 
     this.updateMetadata(this.variant);

src/slang-nodes/ConstructorAttribute.ts

@@ -16,11 +16,12 @@ export class ConstructorAttribute extends SlangNode {
   constructor(ast: ast.ConstructorAttribute, options: ParserOptions<AstNode>) {
     super(ast);
 
-    if (ast.variant instanceof TerminalNode) {
-      this.variant = ast.variant.unparse();
+    const variant = ast.variant;
+    if (variant instanceof TerminalNode) {
+      this.variant = variant.unparse();
       return;
     }
-    this.variant = new ModifierInvocation(ast.variant, options);
+    this.variant = new ModifierInvocation(variant, options);
 
     this.updateMetadata(this.variant);
   }

src/slang-nodes/ContractMember.ts

@@ -40,83 +40,85 @@ export class ContractMember extends SlangNode {
   constructor(ast: ast.ContractMember, options: ParserOptions<AstNode>) {
     super(ast);
 
-    switch (ast.variant.cst.kind) {
+    const variant = ast.variant;
+    const variantKind = variant.cst.kind;
+    switch (variantKind) {
       case NonterminalKind.UsingDirective:
         this.variant = new UsingDirective(
-          ast.variant as ast.UsingDirective,
+          variant as ast.UsingDirective,
           options
         );
         break;
       case NonterminalKind.FunctionDefinition:
         this.variant = new FunctionDefinition(
-          ast.variant as ast.FunctionDefinition,
+          variant as ast.FunctionDefinition,
           options
         );
         break;
       case NonterminalKind.ConstructorDefinition:
         this.variant = new ConstructorDefinition(
-          ast.variant as ast.ConstructorDefinition,
+          variant as ast.ConstructorDefinition,
           options
         );
         break;
       case NonterminalKind.ReceiveFunctionDefinition:
         this.variant = new ReceiveFunctionDefinition(
-          ast.variant as ast.ReceiveFunctionDefinition,
+          variant as ast.ReceiveFunctionDefinition,
           options
         );
         break;
       case NonterminalKind.FallbackFunctionDefinition:
         this.variant = new FallbackFunctionDefinition(
-          ast.variant as ast.FallbackFunctionDefinition,
+          variant as ast.FallbackFunctionDefinition,
           options
         );
         break;
       case NonterminalKind.UnnamedFunctionDefinition:
         this.variant = new UnnamedFunctionDefinition(
-          ast.variant as ast.UnnamedFunctionDefinition,
+          variant as ast.UnnamedFunctionDefinition,
           options
         );
         break;
       case NonterminalKind.ModifierDefinition:
         this.variant = new ModifierDefinition(
-          ast.variant as ast.ModifierDefinition,
+          variant as ast.ModifierDefinition,
           options
         );
         break;
       case NonterminalKind.StructDefinition:
         this.variant = new StructDefinition(
-          ast.variant as ast.StructDefinition,
+          variant as ast.StructDefinition,
           options
         );
         break;
       case NonterminalKind.EnumDefinition:
-        this.variant = new EnumDefinition(ast.variant as ast.EnumDefinition);
+        this.variant = new EnumDefinition(variant as ast.EnumDefinition);
         break;
       case NonterminalKind.EventDefinition:
         this.variant = new EventDefinition(
-          ast.variant as ast.EventDefinition,
+          variant as ast.EventDefinition,
           options
         );
         break;
       case NonterminalKind.StateVariableDefinition:
         this.variant = new StateVariableDefinition(
-          ast.variant as ast.StateVariableDefinition,
+          variant as ast.StateVariableDefinition,
           options
         );
         break;
       case NonterminalKind.ErrorDefinition:
         this.variant = new ErrorDefinition(
-          ast.variant as ast.ErrorDefinition,
+          variant as ast.ErrorDefinition,
           options
         );
         break;
       case NonterminalKind.UserDefinedValueTypeDefinition:
         this.variant = new UserDefinedValueTypeDefinition(
-          ast.variant as ast.UserDefinedValueTypeDefinition
+          variant as ast.UserDefinedValueTypeDefinition
         );
         break;
       default:
-        throw new Error(`Unexpected variant: ${ast.variant.cst.kind}`);
+        throw new Error(`Unexpected variant: ${variantKind}`);
     }
 
     this.updateMetadata(this.variant);

src/slang-nodes/ContractSpecifier.ts

@@ -16,21 +16,23 @@ export class ContractSpecifier extends SlangNode {
   constructor(ast: ast.ContractSpecifier, options: ParserOptions<AstNode>) {
     super(ast);
 
-    switch (ast.variant.cst.kind) {
+    const variant = ast.variant;
+    const variantKind = variant.cst.kind;
+    switch (variantKind) {
       case NonterminalKind.InheritanceSpecifier:
         this.variant = new InheritanceSpecifier(
-          ast.variant as ast.InheritanceSpecifier,
+          variant as ast.InheritanceSpecifier,
           options
         );
         break;
       case NonterminalKind.StorageLayoutSpecifier:
         this.variant = new StorageLayoutSpecifier(
-          ast.variant as ast.StorageLayoutSpecifier,
+          variant as ast.StorageLayoutSpecifier,
           options
         );
         break;
       default:
-        throw new Error(`Unexpected variant: ${ast.variant.cst.kind}`);
+        throw new Error(`Unexpected variant: ${variantKind}`);
     }
     this.updateMetadata(this.variant);
   }

src/slang-nodes/ElementaryType.ts

@@ -15,11 +15,12 @@ export class ElementaryType extends SlangNode {
   constructor(ast: ast.ElementaryType) {
     super(ast);
 
-    if (ast.variant instanceof TerminalNode) {
-      this.variant = ast.variant.unparse();
+    const variant = ast.variant;
+    if (variant instanceof TerminalNode) {
+      this.variant = variant.unparse();
       return;
     }
-    this.variant = new AddressType(ast.variant);
+    this.variant = new AddressType(variant);
 
     this.updateMetadata(this.variant);
   }

src/slang-nodes/ExperimentalFeature.ts

@@ -16,11 +16,12 @@ export class ExperimentalFeature extends SlangNode {
   constructor(ast: ast.ExperimentalFeature, options: ParserOptions<AstNode>) {
     super(ast);
 
-    if (ast.variant instanceof TerminalNode) {
-      this.variant = new Identifier(ast.variant);
+    const variant = ast.variant;
+    if (variant instanceof TerminalNode) {
+      this.variant = new Identifier(variant);
       return;
     }
-    this.variant = new StringLiteral(ast.variant, options);
+    this.variant = new StringLiteral(variant, options);
 
     this.updateMetadata(this.variant);
   }