javascript-analyzer/src/analyzers/utils/extract_main_method.ts at 9ff332bb365bdb84c53e7b14064479ae13876fac · exercism/javascript-analyzer · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
import { Program, Node, FunctionDeclaration, ArrowFunctionExpression, MethodDefinition, ClassProperty, FunctionExpression, ObjectExpression, Property } from "@typescript-eslint/typescript-estree/dist/ts-estree/ts-estree"
import { AST_NODE_TYPES } from "@typescript-eslint/typescript-estree"

import traverser from 'eslint/lib/util/traverser'

export type Traverser = traverser.Traverser
export type MainMethod = FunctionDeclaration | ArrowFunctionExpression | FunctionExpression

export function extractMainMethod(program: Program, name: string): MainMethod | undefined {
  let result: MainMethod | undefined = undefined

  traverser.traverse(program, {
    enter(node: Node) {
      switch (node.type) {

        // function name() {}
        case AST_NODE_TYPES.FunctionDeclaration:
          if (node.id && node.id.name === name) {
            result = node
            this.break()
          }
          break;

        case AST_NODE_TYPES.VariableDeclaration:
          this.skip()

          traverser.traverse(node, {
            enter(innerNode: Node) {
              switch(innerNode.type) {

                case AST_NODE_TYPES.VariableDeclarator:
                  if (innerNode.id.type === AST_NODE_TYPES.Identifier) {
                    if (
                         innerNode.id.name === name
                      && innerNode.init
                    ) {
                      // const name = () => {}
                      if (innerNode.init.type === AST_NODE_TYPES.ArrowFunctionExpression) {
                        result = innerNode.init
                        this.break()
                      }
                      // const name = function() {}
                      else if (innerNode.init.type === AST_NODE_TYPES.FunctionExpression) {
                        result = innerNode.init
                        this.break()
                      }
                    }
                  }
              }
            }
          })

          if (result) {
            this.break()
          }
          break;

          // class Foo {
          //   name() {}
          // }
          case AST_NODE_TYPES.MethodDefinition:
            this.skip()
            if (
              node.static
              && node.key.type === AST_NODE_TYPES.Identifier
              && node.key.name === name
            ) {
              switch(node.value.type) {
                case AST_NODE_TYPES.FunctionExpression:
                  result = node.value
                  this.break()
                  break;
              }
            }

          // class Foo {
          //   static name = () => {}
          //   static name = name() {}
          //   static name = function name() {}
          // }
          case AST_NODE_TYPES.ClassProperty:
            this.skip()

            if (
                 node.static
              && node.key.type === AST_NODE_TYPES.Identifier
              && node.key.name === name
            ) {
              switch(node.value.type) {
                case AST_NODE_TYPES.ArrowFunctionExpression:
                case AST_NODE_TYPES.FunctionExpression:
                  result = node.value
                  this.break()
                  break;
              }
            }
            break;

          // export default {
          //   name: () => {}
          // }
          case AST_NODE_TYPES.ExportDefaultDeclaration:
            // This was necessary because type incorrectly did not include this
            if (node.declaration.type as string === AST_NODE_TYPES.ObjectExpression) {
              this.skip()

              const objectNode = node.declaration as unknown as ObjectExpression
              const property = objectNode.properties.find(
                property =>
                   property.type === AST_NODE_TYPES.Property
                && property.key.type === AST_NODE_TYPES.Identifier
                && property.key.name === name
              ) as Property | undefined

              if (property) {
                if (
                     property.value.type === AST_NODE_TYPES.ArrowFunctionExpression
                  || property.value.type === AST_NODE_TYPES.FunctionExpression
                ) {
                  result = property.value
                  this.break()
                }
              }
            }
      }

    },
  })

  return result
}