// NormalModule.js
build(options, compilation, resolver, fs, callback) {
    //...
    return this.doBuild(options, compilation, resolver, fs, err => {
        const result = this.parser.parse(this._ast || this._source.source(), (err, result) => { /*...*/ })        
    })
}

const acorn = require("acorn");
const acornParser = acorn.Parser;

class Parser extends Tapable {
   constructor(options, sourceType = "auto") {
       this.hooks = {
           // ... 各种hooks
       }
   }
 
   // ... 
   
   parse(source, initialState) {
     ast = Parser.parse(source, {
        sourceType: this.sourceType,
        onComment: comments
     });
        
     // ... 开始解析ast，从ast中解析出其余资源的引用
   }
 
   static parse(code, options) {
       //...
       ast = acornParser.parse(code, parserOptions);
   }
}   

// WebpackOptionsApply
new HarmonyModulesPlugin(options.module).apply(compiler);

// HarmonyModulesPlugin.js 根据配置动态注册下面插件
new HarmonyDetectionParserPlugin().apply(parser);
new HarmonyImportDependencyParserPlugin(this.options).apply(parser);
new HarmonyExportDependencyParserPlugin(this.options).apply(parser);
new HarmonyTopLevelThisParserPlugin().apply(parser);

// HarmonyImportDependencyParserPlugin.js
// 添加各种相关依赖Dependency：HarmonyImportSideEffectDependency、//HarmonyImportSpecifierDependency 等等
parser.hooks.Xxx.tap('', () => {
    //...   
    parser.state.current.addDependency(dep); 
    //...
})

// 构建前
'function' === 'function' ? console.log(1) : console.log(2)
// 构建后
true ? console.log(1) : undefined

ObjectExpression //  { two: 1 * 2 }
ArrayExpression // [{ flag: false }, 'a' + 'b'] // [ObjectExpression, BinaryExpression]
CallExpression // 调用表达式，如fun()
LogicalExpression // 逻辑表达式，如 a && b
AssignmentExpression // 赋值表达式，a = b
ConditionalExpression // 条件表达式， a ? c : d
FunctionExpression // 函数表达式，!function(){}、(function(){})等
// .....

// 声明语句（简称：声明）
var a = ''; // VariableDeclaration 变量声明语句
function log(){}; // FunctionDeclaration 函数声明语句

IfStatement // if(expression) statement
ForInStatement // for(variable in object) statement
WhileStatement // while(expression) statement
//...等等

var foo = true;

if (foo) {
    var bar = foo * 2;
    console.log(bar);
}

// webpack/lib/Parser.js
parse(source, initialState) {
 //...
 this.prewalkStatements(ast.body);
 this.blockPrewalkStatements(ast.body);
 this.walkStatements(ast.body);
 //...
}

var a = 'a'
{ 
    // 当既然怒这个块的时候访问的a，应该是这个块的，因此块级作用域需要区分，不能和外层作用域混在一起了
    let a = 'a';
    
    console.log(a);
}

ClassDeclaration、
ExpressionStatement、
ReturnStatement、
ThrowStatement

ExportAllDeclaration //（export * from 'xxx'）
ImportDeclaration

walkVariableDeclaration(statement) {
   for (const declarator of statement.declarations) {
      switch (declarator.type) {
         case "VariableDeclarator": {
             // case 1 的处理
             // case 2 的处理
            break;
         }
      }
   }
}

// case 2的处理逻辑
this.walkPattern(declarator.id);
if (declarator.init) this.walkExpression(declarator.init);

// case 1的处理逻辑
const renameIdentifier = declarator.init && this.getRenameIdentifier(declarator.init);
if (renameIdentifier && declarator.id.type === "Identifier") {
   const hook = this.hooks.canRename.get(renameIdentifier);
   if (hook !== undefined && hook.call(declarator.init)) {
      // renaming with "var a = b;"
      const hook = this.hooks.rename.get(renameIdentifier);
      if (hook === undefined || !hook.call(declarator.init)) {
         this.scope.renames.set(
            declarator.id.name,
            this.scope.renames.get(renameIdentifier) || renameIdentifier
         );
         this.scope.definitions.delete(declarator.id.name);
      }
      break;
   }
}

// CommonJsPlugin.js

parser.hooks.canRename.for("require").tap("CommonJsPlugin", () => true);
parser.hooks.rename.for("require").tap("CommonJsPlugin", expr => {
   // define the require variable. It's still undefined, but not "not defined".
   const dep = new ConstDependency("var require;", 0);
   dep.loc = expr.loc;
   parser.state.current.addDependency(dep);
   return false;
});

// 表达式类型 -> 子表达式所在属性
ArrayExpression -> elements // 如 walkExpressions(expression.elements);
AwaitExpression -> argument
BinaryExpression -> left & right
ConditionalExpression -> test & consequent
SequenceExpression -> expressions
SpreadElement -> argument 
TaggedTemplateExpression -> tag & quasi.expressions
TemplateLiteral -> expressions
UpdateExpression -> argument
YieldExpression -> argument
LogicalExpression -> left、right
ObjectExpression -> properties

walkCallExpression(expression) {
   if (expression.callee.type === "MemberExpression" && expression.callee.object.type === "FunctionExpression" && !expression.callee.computed &&
      (expression.callee.property.name === "call" || expression.callee.property.name === "bind") && expression.arguments.length > 0
   ) {
      // (function(…) { }.call/bind(?, …))
      this._walkIIFE( expression.callee.object, expression.arguments.slice(1), expression.arguments[0]);
   } else if (expression.callee.type === "FunctionExpression") {
      // (function(…) { }(…))
      this._walkIIFE(expression.callee, expression.arguments, null);
   } else if (expression.callee.type === "Import") {
        // import(...)
   } else {
     // 普通函数调用
   }
}

_walkIIFE(functionExpression, options, currentThis) {...}
// functionExpression表示函数表达式；
// options是函数表达式的实参；
// currentThis显示指定了函数内部的this指向

this._walkIIFE( expression.callee.object, // 函数表达式，因为是MemberExpression，所以取object
expression.arguments.slice(1), // 参数表示函数表达式的实参
expression.arguments[0]); // 函数表达式内部this的指向

this._walkIIFE(expression.callee, // 函数表达式
expression.arguments, // 参数表示函数表达式的实参
null); // 没有显示指定 this

// 原始代码 ----- 
(function () {
    const aMod = this('./a')
    console.log(aMod)
}).bind(require)

// 构建后的代码 ----- 
var require;

(function () {
    const aMod = __webpack_require__(1) 
    console.log(aMod)
}).bind(require)

let result = this.hooks.importCall.call(expression);
if (result === true) return;

if (expression.arguments) this.walkExpressions(expression.arguments);

// ImportParserPlugin.js
const ImportDependenciesBlock = require("./ImportDependenciesBlock");

parser.hooks.importCall.tap("ImportParserPlugin", expr => {
    //...
    const depBlock = new ImportDependenciesBlock(...);
    parser.state.current.addBlock(depBlock);
    //...
}

// ImportDependenciesBlock.js
class ImportDependenciesBlock extends AsyncDependenciesBlock {
    constructor(request, range, groupOptions, module, loc, originModule) {
        //...
        const dep = new ImportDependency(request, originModule, this);
        this.addDependency(dep);
    }
};

NormalModule extends Module
Module extends DependenciesBlock

class DependenciesBlock {
    //...
    addBlock(block) {  // block: AsyncDependencyBlock类型
       this.blocks.push(block);
       block.parent = this;
    }
    //...
}

// 插件 // 关键字
RequireEnsureDependenciesBlockParserPlugin // require.ensure 
RequireIncludeDependencyParserPlugin // require.include 
RequireContextDependencyParserPlugin // require.context 
RequireResolveDependencyParserPlugin // require.resolve、require.resovleWeak 
RequireJsStuffPlugin // require.config、requirejs.config 
AMDRequireDependenciesBlockParserPlugin // require 
AMDDefineDependencyParserPlugin // define 
CommonJsRequireDependencyParserPlugin // require、module.require 
HarmonyImportDependencyParserPlugin // imported var 
HarmonyDetectionParserPlugin // define、exports 
CompatibilityPlugin // require 
SystemPlugin // System.import 

require.ensure(['./a.js'], function (module) {
    console.log(module)
})

apply(parser) {
   parser.hooks.call.for("require.ensure")
      .tap("RequireEnsureDependenciesBlockParserPlugin", expr => {
            //...
            const dep = new RequireEnsureDependenciesBlock(...);
            const old = parser.state.current;
            parser.state.current = dep; // 为了收集dep的依赖
            //...
            old.addBlock(dep); // 添加 block
            //...
            parser.state.current = old;
       });
}

// 构建前
'function' === 'function' ? console.log(1) : console.log(2)
// 构建后
true ? console.log(1) : undefined

// 复杂一点的例子： if(typeof require === 'function') // => if(true)
// 有兴趣的同学可以debug一下

// parser.hooks.expressionConditionalOperator的回调
expression => {
  const param = parser.evaluateExpression(expression.test);
  const bool = param.asBool();
  if (typeof bool === "boolean") {
     if (expression.test.type !== "Literal") {
        const dep = new ConstDependency(` ${bool}`, param.range);
        //...
     }
     const dep = new ConstDependency("undefined", branchToRemove.range);
    //...
  }
}

// 将 expression.test 部分替换为实际的布尔值（通过ConstDependency依赖实现）
const dep = new ConstDependency(` ${bool}`, param.range); // 注意：设置了替换的范围

// 替换dead branch部分的内容为`undefined`（通过ConstDependency依赖实现）
const dep = new ConstDependency("undefined", branchToRemove.range); 注意：设置了替换的范围

evaluateExpression(expression) {
    //...
    // 这里expression.type是 BinaryExpression (二元表达式）
    const hook = this.hooks.evaluate.get(expression.type);
    const result = hook.call(expression);
    //...
}

this.hooks.evaluate.for("BinaryExpression").tap("Parser", expr => {
  // 枚举了所有的二元运算符，并给出计算结果
})
this.hooks.evaluate.for("LogicalExpression").tap("Parser", expr => {...})
this.hooks.evaluate.for("UnaryExpression").tap("Parser", expr => {...})
// 等等...

this.hooks.evaluate.for("Literal").tap("Parser", expr => {
   switch (typeof expr.value) {
      case "number": //...
      case "string": //...
      case "boolean": //...
   }
    //... null、正则
});

// Literal、Identifier、ThisExpression、MemberExpression、CallExpression、
// TemplateLiteral、ConditionalExpression、ArrayExpression等等

this.hooks.evaluate.for("BinaryExpression").tap("Parser", expr => {
    //...
    } else if (expr.operator === "==" || expr.operator === "===") {
       left = this.evaluateExpression(expr.left);
       right = this.evaluateExpression(expr.right);
       //...
       res = new BasicEvaluatedExpression(); // 构造一个实例
       if (left.isString() && right.isString()) {
          return res.setBoolean(left.string === right.string); // 设置类型及其值
       } else if //...
    } else if (expr.operator === "!=" || expr.operator === "!==") {
    //...
})

// this.hooks.evaluate.for("Literal")回调中的片段
case "string":
   return new BasicEvaluatedExpression()
      .setString(expr.value) // 设置类型和值