let tips = [
  "Click on any AST node with a '+' to expand it",

  "Hovering over a node highlights something",

  "Shift click on an AST node to expand the whole subtree"
];

function printTips() {
  tips.forEach((tip, i) => console.log(`Tip ${i}:` + tip));
}

 
const Visitor = {
  Identifier() {
    console.log("Called!");
  }
};
// Identifier() { ... } 是 Identifier: { enter() { ... } } 的简写形式。.
// 也可以先创建一个访问者对象，并在稍后给它添加方法。
let visitor = {};
visitor.MemberExpression = function() {};
visitor.FunctionDeclaration = function() {}

const Visitor = {
  Identifier: {
    enter() {
      console.log("Entered!");
    },
    exit() {
      console.log("Exited!");
    }
  }
};

const visitor = {
    "Idenfifier |MemberExpression"(path){}
}

//Function is an alias for FunctionDeclaration, FunctionExpression, 
//ArrowFunctionExpression, ObjectMethod and ClassMethod.
 
const Visitor = {
  Function(path) {}
}

// 对表达式：a+b+c
const visitor = {
    Identifier(path){
        console.log("now: " + path.node.name);
    }
}
 
// 使用path.traverse(visitor)进行转换
path.traverse(visitor);
 
//以下是输出结果：
now: a
now: b
now: c

const parser = require("@babel/parser");  // 解析，js转AST
const traverse = require("@babel/traverse").default;  // 转换
const t = require("@babel/types");
const generator = require("@babel/generator").default;  // 生成
 
const fs = require('fs');  // 文件读写
 
target_js = "function square(n) {  return n * n;}"
 
 
// 尝试将该代码中的n都变为x
const visitor = {
    FunctionDeclaration(path){
        const param = path.node.params[0]
        if (param.name === 'n'){
            paramName = param.name;
            param.name = 'x'
        }
    },
 
    Identifier(path){
        if (path.node.name === paramName){
            path.node.name = "x"
        }
    }
}
 
let ast = parser.parse(target_js);
 
traverse(ast, visitor);
 
let {code} = generator(ast);
 
// 输出：
function square(x) {
  return x * x;
}

function square(n){
    return n * n;
}
 
function add(n, m){
    return n + m
}

function square(x) {
  return x * x;
}
 
function add(x, m) {
  return x + m;
}

const parser = require("@babel/parser");  // 解析，js转AST
const traverse = require("@babel/traverse").default;  // 转换
const t = require("@babel/types");
const generator = require("@babel/generator").default;  // 生成
 
const fs = require('fs');  // 文件读写


var target_js = "function square(n){\n" +
    "    return n * n;\n" +
    "}\n" +
    "\n" +
    "function add(n, m){\n" +
    "    return n + m\n" +
    "}"
 
 
// 尝试将该代码中的n都变为x
const updateParamName = {
    "Identifier"(path){
        if (path.node.name === this.paramName){
            path.node.name = "x"
        }
    }
}
 
 
const visitor = {
    "FunctionDeclaration"(path){
        if (path.node.params.length > 1){
            return;
        }
        const param = path.node.params[0]
        if (param.name === 'n'){
            paramName = param.name;
            param.name = 'x'
            path.traverse(updateParamName, { paramName });
        }
    }
}
 
let ast = parser.parse(target_js);
 
traverse(ast, visitor);
 
let {code} = generator(ast);
 
console.log(code)
 
 
//输出结果
function square(x) {
  return x * x;
}
 
function add(n, m) {
  return n + m;
}

const scope = {
    path: path,
    block: path.node,
    parentBlock: path.parent,
    parent: parentScope,
    bindings: [/** ... */]
}

const binding = {
    identifier: node,
    scope: scope,
    path: path,
    kind: 'var',
 
    referenced: true,
    references: 3,
    referencePaths: [path, path, path],
 
    constant: false,
    constantViolations: [path]
}

defineType("BinaryExpression", {
    builder: ["operator", "left", "right"],
    fields: {
        operator: {
            validate: assertValueType("string")
        },
        left:{
            validate: assertNodeType("Expression")
        },
        right:{
            validate: assertNodeType("Expression")
        }
    },
    visitor: ["left", "right"],
    aliases: ["Binary", "Expression"]
});

type.binaryExpression("*", type.identifier("a"), type.identifiier("b"));

const ast = {
    type: "BinaryExpression",
    operator: "*",
    left: {
        type: "Identifier",
        name: "a"
    },
    right: {
        type: "Identifier",
        name: "b"
    }
}

a * b

const validator = {
  fields: {
    operator: {
      validate: assertValueType("string")
    },
    left: {
      validate: assertNodeType("Expression")
    },
    right: {
      validate: assertNodeType("Expression")
    }

  }
}

type.isBinaryExpression(maybeBinaryExpressionNode)

type.isBinaryExpression(maybeBinaryExpressionNode, { operator: "*" });

type.assertBinaryExpressiion(maybeBinaryExpressionNode);
type.assertBiinaryExpression(maybeBinaryExpressionNode, { operator: "*" });
// Error: Expected type "BinaryExpression" with option { "operator": "*" }

const code = '......'
 
const ast = babylon.parse(code);
generate(ast, {}, code);
// 结果
// {
//   code: "...",
//   map: "..."
// }
 
// 也可以传递选项
generate(ast, {
    retainLines: false,
    compact: "auto",
    concise: false,
    quotes: "double",
}, code);

import template from "babel-template";
import generate from "babel-generator";
import * as type from "babel-types";
 
const buildRequire = template(' var IMPORT_NAME = require(SOURCE); ');
 
const ast = buildRequire({
    IMPORT_NAME: type.identifier("myModule"),
    SOURCE: type.stringLiteral("my-module")
});
 
console.log(generate(ast).code);
 
// 结果：
var myModule = require("my-module");

/**
 * 对于每一个父路径调用callback并将其NodePath当作参数，
 * 当callback返回真值时，则将其NodePath返回。
 */
path.findParent((path) => path.isObjcetExpression());
 
// 如果也需要遍历当前节点：
path.find((path) => path.isObjectExpression());
 
// 查找最接近的父函数或程序：
path.getFunctionParent();
 
// 向上遍历语法树，直到找到在列表中的父节点路径
path.getStatementParent();

target_js = `
var a = 1; // pathA, path.key = 0
var b = 2; // pathB, path.key = 1
var c = 3; // pathC, path.key = 2
`

export default function({ types: t }) {
    return {
        visitor: {
            VariableDeclaration(path) {
                // if the current path is pathA
                path.inList // true
                path.listKey // "body"
                paht.key // 0
                path.getSibling(0) // pathA
                path.getSibling(path.key + 1) //pathB
                path.container // [pathA, pathB, pathC]
            }
        }
    };
}

ReturnStatement(path) {
    path.replaceWithMultiple([
        t.expressionStatement(t.stringLiteral("Is this the real life?")),
        t.expressionStatement(t.stringLiteral("Is this just fantasy?")),
        t.expressionStatement(
            t.stringLiteral(
                "(Enjoy singing the rest of the song in you head)"
            )
        ),
    ]);
}

FunctionDeclaration(path) {
    path.insertBefore(
        t.expressionStatement(
            t.stringLiteral("Because I'm easy come, easy go.")
        )
    );
    path.insertAfter(
        t.expressionStatement(
            t.stringLiteral("A little high, little low.")
        )
    );
}
 
 
// 结果
+     "Because I'm easy come, easy go.";
    function square(n) {
        return n * n;
    }
+     "A little high, little low.";

// 源代码：
target_js = 'foo === bar'
 
// AST：
//{
//  type: "BinaryExpression",
//  operator: "===",
//  left: {
//    type: "Identifier",
//    name: "foo"
//  },
//  right: {
//    type: "Identifier",
//    name: "bar"
//  }
//}
 
// 目标是将 === 运算符左右变量名替换
export default function({ types: t}) {
    return {
        visitor: {
            BinaryExpression(path){
                if (path.node.operator !== "==="){
                    return;
                }
                path.node.left = t.identifier("x");
                path.node.rigth = t.identifier("y");
            }
        }
    }
}
 
 
// 运行结果：
x === y

let value = 'a'
// babel编译后：
var value = 'a'

if (false) {
    let value = 'a';
}
console.log(value); // value is not defined

if (false) {
    var _value = 'a';
}
console.log(value);

var functions = [];
for (let i = 0; i < 3; i++) {
    functions[i] = function () {
        console.log(i);
    };
}
functions[0](); // 0

var functions = [];
var _loop = function _loop(i) {
    functions[i] = function () {
        console.log(i);
    };
};
for (var i = 0; i < 3; i++) {
    _loop(i);
}
functions[0](); // 0