function square(n) {
  return n * n
}

Program
└── FunctionDeclaration (name: "square")
    ├── params
    │   └── Identifier (name: "n")
    └── body (BlockStatement)
        └── ReturnStatement
            └── BinaryExpression (operator: "*")
                ├── left: Identifier (name: "n")
                └── right: Identifier (name: "n")

{
  "type": "Program",
  "body": [
    {
      "type": "FunctionDeclaration",
      "id": { "type": "Identifier", "name": "square" },
      "params": [{ "type": "Identifier", "name": "n" }],
      "body": {
        "type": "BlockStatement",
        "body": [
          {
            "type": "ReturnStatement",
            "argument": {
              "type": "BinaryExpression",
              "operator": "*",
              "left": { "type": "Identifier", "name": "n" },
              "right": { "type": "Identifier", "name": "n" }
            }
          }
        ]
      }
    }
  ]
}

function square(n) {
  return n * n
}

[
  { type: 'keyword',    value: 'function' },
  { type: 'identifier', value: 'square' },
  { type: 'punctuator', value: '(' },
  { type: 'identifier', value: 'n' },
  { type: 'punctuator', value: ')' },
  { type: 'punctuator', value: '{' },
  { type: 'keyword',    value: 'return' },
  { type: 'identifier', value: 'n' },
  { type: 'punctuator', value: '*' },
  { type: 'identifier', value: 'n' },
  { type: 'punctuator', value: '}' },
]

function tokenize(code) {
  const tokens = []
  let i = 0

  while (i < code.length) {
    const char = code[i]

    // 공백은 건너뛴다
    if (/\s/.test(char)) {
      i++
      continue
    }

    // 숫자: 연속된 숫자를 하나의 토큰으로
    if (/[0-9]/.test(char)) {
      let value = ''
      while (i < code.length && /[0-9]/.test(code[i])) {
        value += code[i++]
      }
      tokens.push({ type: 'number', value })
      continue
    }

    // 연산자
    if ('+-*/'.includes(char)) {
      tokens.push({ type: 'operator', value: char })
      i++
      continue
    }

    throw new Error(`알 수 없는 문자: ${char}`)
  }

  return tokens
}

tokenize('12 + 3 * 45')
// [
//   { type: 'number', value: '12' },
//   { type: 'operator', value: '+' },
//   { type: 'number', value: '3' },
//   { type: 'operator', value: '*' },
//   { type: 'number', value: '45' },
// ]

// 1 + 2 * 3 의 AST
// 곱셈이 더 깊은 위치에 있으므로 먼저 계산된다

BinaryExpression (+)
├── left: NumericLiteral (1)
└── right: BinaryExpression (*)
    ├── left: NumericLiteral (2)
    └── right: NumericLiteral (3)

// Statement: 값을 만들지 않는다 (변수에 담을 수 없다)
if (true) { }
for (let i = 0; i < 10; i++) { }

// Expression: 값을 만든다 (변수에 담을 수 있다)
const x = 1 + 2
const y = condition ? 'a' : 'b'
const z = foo()

// VariableDeclaration + VariableDeclarator
const x = 1
// { type: "VariableDeclaration", kind: "const",
//   declarations: [{ type: "VariableDeclarator",
//     id: Identifier("x"), init: NumericLiteral(1) }] }

// FunctionDeclaration
function foo(a, b) { return a + b }
// { type: "FunctionDeclaration", id: Identifier("foo"),
//   params: [Identifier("a"), Identifier("b")],
//   body: BlockStatement }

// ArrowFunctionExpression
const add = (a, b) => a + b
// { type: "ArrowFunctionExpression",
//   params: [Identifier("a"), Identifier("b")],
//   body: BinaryExpression("+") }

// CallExpression
console.log('hello')
// { type: "CallExpression",
//   callee: MemberExpression(console, log),
//   arguments: [StringLiteral("hello")] }

// MemberExpression
obj.prop
obj['prop']
// { type: "MemberExpression", object: Identifier("obj"),
//   property: Identifier("prop"), computed: false | true }

// ConditionalExpression (삼항 연산자)
a ? b : c
// { type: "ConditionalExpression",
//   test: Identifier("a"),
//   consequent: Identifier("b"),
//   alternate: Identifier("c") }

// IfStatement
if (condition) { doA() } else { doB() }
// { type: "IfStatement",
//   test: Identifier("condition"),
//   consequent: BlockStatement,
//   alternate: BlockStatement }

import * as parser from '@babel/parser'
import generate from '@babel/generator'

const code = `const welcome = 'hello world'`

// 1. 코드 → AST
const ast = parser.parse(code)

// 2. AST → 코드
const output = generate(ast)
console.log(output.code) // const welcome = 'hello world'

import * as parser from '@babel/parser'
import _traverse from '@babel/traverse'
import _generate from '@babel/generator'

const traverse = _traverse.default
const generate = _generate.default

const code = `
  const a = 1
  const b = 2
`

const ast = parser.parse(code)

// AST를 순회하면서 const → let으로 변환
traverse(ast, {
  VariableDeclaration(path) {
    if (path.node.kind === 'const') {
      path.node.kind = 'let'
    }
  },
})

const output = generate(ast)
console.log(output.code)
// let a = 1;
// let b = 2;

traverse(ast, {
  Identifier(path) {
    path.node             // 현재 AST 노드 자체
    path.parent           // 부모 노드
    path.parentPath       // 부모의 path 객체
    path.scope            // 현재 스코프 정보

    // 조작 메서드
    path.replaceWith(newNode)    // 현재 노드를 다른 노드로 교체
    path.remove()                // 현재 노드 삭제
    path.insertBefore(newNode)   // 현재 노드 앞에 새 노드 삽입
    path.insertAfter(newNode)    // 현재 노드 뒤에 새 노드 삽입

    // 탐색 메서드
    path.findParent(p => p.isFunction())  // 조건에 맞는 부모 찾기
    path.getSibling(0)                     // 형제 노드 접근
  }
})

traverse(ast, {
  Identifier(path) {
    const binding = path.scope.getBinding(path.node.name)
    if (binding) {
      console.log(binding.kind)           // 'const', 'let', 'var', 'param' 등
      console.log(binding.referenced)     // 참조되고 있는지
      console.log(binding.references)     // 참조 횟수
      console.log(binding.referencePaths) // 참조 위치들
    }
  }
})

// babel-plugin-remove-console.js
export default function () {
  return {
    visitor: {
      CallExpression(path) {
        const { callee } = path.node
        if (
          callee.type === 'MemberExpression' &&
          callee.object.name === 'console' &&
          callee.property.name === 'log'
        ) {
          path.remove()
        }
      },
    },
  }
}

// before
load().then(function (response) {
  return response.data
})

// after
load().then((response) => response.data)

// function-to-arrow.js
export default function transformer(file, api) {
  const j = api.jscodeshift

  return j(file.source)
    .find(j.FunctionExpression)
    .replaceWith((path) => {
      const { params, body } = path.node

      // body가 return 문 하나뿐이면 간결한 arrow function으로
      if (
        body.body.length === 1 &&
        body.body[0].type === 'ReturnStatement'
      ) {
        return j.arrowFunctionExpression(params, body.body[0].argument)
      }

      return j.arrowFunctionExpression(params, body)
    })
    .toSource()
}

npx jscodeshift -t function-to-arrow.js src/

// no-var.js
module.exports = {
  meta: {
    type: 'suggestion',
    fixable: 'code',
  },
  create(context) {
    return {
      VariableDeclaration(node) {
        if (node.kind === 'var') {
          context.report({
            node,
            message: 'var 대신 let 또는 const를 사용하세요.',
            fix(fixer) {
              return fixer.replaceTextRange(
                [node.range[0], node.range[0] + 3],
                'let',
              )
            },
          })
        }
      },
    }
  },
}

group([
  "foo(",
  indent([
    softline,
    "arg1,",
    line,
    "arg2,",
    line,
    "arg3",
  ]),
  softline,
  ")"
])

// printWidth 안에 들어갈 때 → 한 줄
foo(arg1, arg2, arg3)

// printWidth를 초과할 때 → 여러 줄
foo(
  arg1,
  arg2,
  arg3,
)

코드 (문자열)
  ↓ Lexical Analysis (토큰화)
토큰 목록
  ↓ Syntax Analysis (구문 분석)
AST
  ↓ 변환/분석/출력
결과물 (새로운 코드, 에러 리포트, SVG 등)

// Babel 플러그인
{ visitor: { CallExpression(path) { ... } } }

// ESLint 룰
{ create() { return { CallExpression(node) { ... } } } }

// jscodeshift
j(source).find(j.CallExpression).forEach(path => { ... })