webpack/lib/Parser.js

/*
	MIT License http://www.opensource.org/licenses/mit-license.php
	Author Tobias Koppers @sokra
*/
var esprima = require("esprima");
var Tapable = require("tapable");
var BasicEvaluatedExpression = require("./BasicEvaluatedExpression");

function Parser(options) {
	Tapable.call(this);
	this.options = options;
	this.initializeEvaluating();
}
module.exports = Parser;

// Syntax: https://developer.mozilla.org/en/SpiderMonkey/Parser_API



Parser.prototype = Object.create(Tapable.prototype);
Parser.prototype.initializeEvaluating = function() {
	function joinRanges(startRange, endRange) {
		if(!endRange) return startRange;
		if(!startRange) return endRange;
		return [startRange[0], endRange[1]];
	}
	this.plugin("evaluate Literal", function(expr) {
		switch(typeof expr.value) {
		case "number":
			return new BasicEvaluatedExpression().setNumber(expr.value).setRange(expr.range);
		case "string":
			return new BasicEvaluatedExpression().setString(expr.value).setRange(expr.range);
		case "boolean":
			return new BasicEvaluatedExpression().setBoolean(expr.value).setRange(expr.range);
		}
	});
	this.plugin("evaluate BinaryExpression", function(expr) {
		if(expr.operator == "+") {
			var left = this.evaluateExpression(expr.left);
			var right = this.evaluateExpression(expr.right);
			if(!left || !right) return;
			var res = new BasicEvaluatedExpression()
			if(left.isString()) {
				if(right.isString()) {
					res.setString(left.string + right.string);
				} else if(right.isNumber()) {
					res.setString(left.string + right.number);
				} else if(right.isWrapped() && right.prefix.isString()) {
					res.setWrapped(
						new BasicEvaluatedExpression()
							.setString(left.string + right.prefix.string)
							.setRange(joinRanges(left.range, right.prefix.range)),
						right.postfix);
				} else {
					res.setWrapped(left, new BasicEvaluatedExpression().setString(""))
				}
			} else if(left.isNumber()) {
				if(right.isString()) {
					res.setString(left.number + right.string);
				} else if(right.isNumber()) {
					res.setNumber(left.number + right.number);
				}
			} else if(left.isWrapped() && left.postfix.isString()) {
				if(right.isString()) {
					res.setWrapped(left.prefix,
						new BasicEvaluatedExpression()
							.setString(left.postfix.string + right.string)
							.setRange(joinRanges(left.postfix.range, right.range))
					);
				} else if(right.isNumber()) {
					res.setWrapped(left.prefix,
						new BasicEvaluatedExpression()
							.setString(left.postfix.string + right.number)
							.setRange(joinRanges(left.postfix.range, right.range))
					);
				}
			} else {
				if(right.isString()) {
					res.setWrapped(new BasicEvaluatedExpression().setString(""), right);
				}
			}
			res.setRange(expr.range);
			return res;
		} else if(expr.operator == "==" || expr.operator == "===") {
			var left = this.evaluateExpression(expr.left);
			var right = this.evaluateExpression(expr.right);
			if(!left || !right) return;
			var res = new BasicEvaluatedExpression();
			res.setRange(expr.range);
			if(left.isString() && right.isString()) {
				return res.setBoolean(left.string === right.string);
			} else if(left.isNumber() && right.isNumber()) {
				return res.setBoolean(left.number === right.number);
			} else if(left.isBoolean() && right.isBoolean()) {
				return res.setBoolean(left.bool === right.bool);
			}
		} else if(expr.operator == "!=" || expr.operator == "!==") {
			var left = this.evaluateExpression(expr.left);
			var right = this.evaluateExpression(expr.right);
			if(!left || !right) return;
			var res = new BasicEvaluatedExpression();
			res.setRange(expr.range);
			if(left.isString() && right.isString()) {
				return res.setBoolean(left.string !== right.string);
			} else if(left.isNumber() && right.isNumber()) {
				return res.setBoolean(left.number !== right.number);
			} else if(left.isBoolean() && right.isBoolean()) {
				return res.setBoolean(left.bool !== right.bool);
			}
		}
	});
	this.plugin("evaluate UnaryExpression", function(expr) {
		if(expr.operator == "typeof" && expr.argument.type == "Identifier") {
			return this.applyPluginsBailResult("evaluate typeof " + expr.argument.name, expr);
		}
	});
	this.plugin("evaluate Identifier", function(expr) {
		return this.applyPluginsBailResult("evaluate Identifier " + expr.name, expr);
	});
	this.plugin("evaluate ConditionalExpression", function(expr) {
		var consequent = this.evaluateExpression(expr.consequent);
		var alternate = this.evaluateExpression(expr.alternate);
		if(!consequent || !alternate) return;
		var res = new BasicEvaluatedExpression();
		if(consequent.isConditional())
			res.setOptions(consequent.options);
		else
			res.setOptions([consequent]);
		if(alternate.isConditional())
			res.addOptions(alternate.options);
		else
			res.addOptions([alternate]);
		res.setRange(expr.range);
		return res;
	});
	this.plugin("evaluate ArrayExpression", function(expr) {
		var items = expr.elements.map(function(element) {
			return this.evaluateExpression(element);
		}, this);
		if(items.filter(function(i) { return !i; }).length > 0) return;
		return new BasicEvaluatedExpression().setItems(items).setRange(expr.range);
	});
}
Parser.prototype.walkStatements = function walkStatements(statements) {
	statements.forEach(function(statement) {
		this.walkStatement(statement);
	}, this);
}

Parser.prototype.walkStatement = function walkStatement(statement) {
	switch(statement.type) {
	// Real Statements
	case "BlockStatement":
		this.walkStatements(statement.body);
		break;
	case "ExpressionStatement":
		this.walkExpression(statement.expression);
		break;
	case "IfStatement":
		var result = this.applyPluginsBailResult("statement if", statement);
		if(result === undefined) {
			this.walkExpression(statement.test);
			this.walkStatement(statement.consequent);
			if(statement.alternate)
				this.walkStatement(statement.alternate);
		} else {
			if(result)
				this.walkStatement(statement.consequent);
			else if(statement.alternate)
				this.walkStatement(statement.alternate);
		}
		break;
	case "LabeledStatement":
		this.walkStatement(statement.body);
		break;
	case "WithStatement":
		this.walkExpression(statement.object);
		this.walkStatement(statement.body);
		break;
	case "SwitchStatement":
		this.walkExpression(statement.discriminant);
		this.walkSwitchCases(statement.cases);
		break;
	case "ReturnStatement":
	case "ThrowStatement":
		if(statement.argument)
			this.walkExpression(statement.argument);
		break;
	case "TryStatement":
		if(this.scope.inTry) {
			this.walkStatement(statement.block);
		} else {
			this.scope.inTry = true;
			this.walkStatement(statement.block);
			this.scope.inTry = false;
		}
		this.walkCatchClauses(statement.handlers);
		if(statement.finalizer)
			this.walkStatement(statement.finalizer);
		break;
	case "WhileStatement":
	case "DoWhileStatement":
		this.walkExpression(statement.test);
		this.walkStatement(statement.body);
		break;
	case "ForStatement":
		if(statement.init) {
			if(statement.init.type === "VariableDeclaration")
				this.walkStatement(statement.init);
			else
				this.walkExpression(statement.init);
		}
		if(statement.test)
			this.walkExpression(statement.test);
		if(statement.update)
			this.walkExpression(statement.update);
		this.walkStatement(statement.body);
		break;
	case "ForInStatement":
		if(statement.left.type === "VariableDeclaration")
			this.walkStatement(statement.left);
		else
			this.walkExpression(statement.left);
		this.walkExpression(statement.right);
		this.walkStatement(statement.body);
		break;

	// Declarations
	case "FunctionDeclaration":
		this.scope.definitions.push(statement.id.name);
		this.inScope(statement.params, function() {
			if(statement.body.type === "BlockStatement")
				this.walkStatement(statement.body);
			else
				this.walkExpression(statement.body);
		}.bind(this));
		break;
	case "VariableDeclaration":
		if(statement.declarations)
			this.walkVariableDeclarators(statement.declarations);
		break;
	}
}

Parser.prototype.walkSwitchCases = function walkSwitchCases(switchCases) {
	switchCases.forEach(function(switchCase) {
		if(switchCase.test)
			this.walkExpression(switchCase.test);
		this.walkStatements(switchCase.consequent);
	}, this);
}

Parser.prototype.walkCatchClauses = function walkCatchClauses(catchClauses) {
	catchClauses.forEach(function(catchClause) {
		if(catchClause.guard)
			this.walkExpression(catchClause.guard);
		this.inScope([catchClause.param], function() {
			this.walkStatement(catchClause.body);
		}.bind(this));
	}, this);
}

Parser.prototype.walkVariableDeclarators = function walkVariableDeclarators(declarators) {
	declarators.forEach(function(declarator) {
		switch(declarator.type) {
		case "VariableDeclarator":
			if(declarator.id.type === "Identifier") {
				this.scope.definitions.push(declarator.id.name);
			}
			if(declarator.init)
				this.walkExpression(declarator.init);
			break;
		}
	}, this);
}

Parser.prototype.walkExpressions = function walkExpressions(expressions) {
	expressions.forEach(function(expression) {
		this.walkExpression(expression);
	}, this);
}

Parser.prototype.walkExpression = function walkExpression(expression) {
	switch(expression.type) {
	case "ArrayExpression":
		if(expression.elements)
			this.walkExpressions(expression.elements);
		break;
	case "ObjectExpression":
		expression.properties.forEach(function(prop) {
			this.walkExpression(prop.value);
		}, this);
		break;
	case "FunctionExpression":
		this.inScope(expression.params, function() {
			if(expression.body.type === "BlockStatement")
				this.walkStatement(expression.body);
			else
				this.walkExpression(expression.body);
		}.bind(this));
		break;
	case "SequenceExpression":
		if(expression.expressions)
			this.walkExpressions(expression.expressions);
		break;
	case "UpdateExpression":
		this.walkExpression(expression.argument);
		break;
	case "UnaryExpression":
		if(expression.operator === "typeof") {
			var expr = expression.argument;
			var exprName = [];
			while(expr.type == "MemberExpression" && expr.property.type == "Identifier") {
				exprName.unshift(expr.property.name);
				expr = expr.object;
			}
			if(expr.type == "Identifier" && this.scope.definitions.indexOf(expr.name) == -1) {
				exprName.unshift(expr.name);
				exprName = exprName.join(".");
				var result = this.applyPluginsBailResult("typeof " + exprName, expression);
				if(result === true)
					break;
			}
		}
		this.walkExpression(expression.argument);
		break;
	case "BinaryExpression":
	case "LogicalExpression":
		this.walkExpression(expression.left);
		this.walkExpression(expression.right);
		break;
	case "AssignmentExpression":
		if(expression.left.type !== "Identifier" ||
			expression.left.name !== "require")
			this.walkExpression(expression.left);
		this.walkExpression(expression.right);
		break;
	case "ConditionalExpression":
		this.walkExpression(expression.test);
		this.walkExpression(expression.alternate);
		this.walkExpression(expression.consequent);
		break;
	case "NewExpression":
		this.walkExpression(expression.callee);
		if(expression.arguments)
			this.walkExpressions(expression.arguments);
		break;
	case "CallExpression":
		var callee = expression.callee;
		var calleeName = [];
		while(callee.type == "MemberExpression" && callee.property.type == "Identifier") {
			calleeName.unshift(callee.property.name);
			callee = callee.object;
		}
		if(callee.type == "Identifier" && this.scope.definitions.indexOf(callee.name) == -1) {
			calleeName.unshift(callee.name);
			calleeName = calleeName.join(".");
			var result = this.applyPluginsBailResult("call " + calleeName, expression);
			if(result === true)
				break;
		}

		if(expression.callee)
			this.walkExpression(expression.callee);
		if(expression.arguments)
			this.walkExpressions(expression.arguments);
		break;
	case "MemberExpression":
		var expr = expression;
		var exprName = [];
		while(expr.type == "MemberExpression" && expr.property.type == "Identifier") {
			exprName.unshift(expr.property.name);
			expr = expr.object;
		}
		if(expr.type == "Identifier" && this.scope.definitions.indexOf(expr.name) == -1) {
			exprName.unshift(expr.name);
			exprName = exprName.join(".");
			var result = this.applyPluginsBailResult("expression " + exprName, expression);
			if(result === true)
				break;
		}
		this.walkExpression(expression.object);
		if(expression.property.type !== "Identifier")
			this.walkExpression(expression.property);
		break;
	case "Identifier":
		if(this.scope.definitions.indexOf(expression.name) == -1) {
			var result = this.applyPluginsBailResult("expression " + expression.name, expression);
			if(result === true)
				break;
		}
		break;
	}
}

Parser.prototype.inScope = function inScope(params, fn) {
	var oldScope = this.scope;
	this.scope = {
		inTry: false,
		definitions: oldScope.definitions.slice()
	};
	params.forEach(function(param) {
		if(typeof param !== "string") {
			if(param.type !== "Identifier")
				return;
			param = param.name;
		}
		this.scope.definitions.push(param);
	}, this);
	fn();
	this.scope = oldScope;
}

Parser.prototype.evaluateExpression = function evaluateExpression(expression) {
	var result = this.applyPluginsBailResult("evaluate " + expression.type, expression);
	if(result !== undefined)
		return result;
	return new BasicEvaluatedExpression().setRange(expression.range);
}

Parser.prototype.parseString = function parseString(expression) {
	switch(expression.type) {
	case "BinaryExpression":
		if(expression.operator == "+")
			return this.parseString(expression.left) + this.parseString(expression.right);
		break;
	case "Literal":
		return expression.value+"";
	}
	throw new Error(expression.type + " is not supported as parameter for require");
}

Parser.prototype.parseCalculatedString = function parseCalculatedString(expression) {
	switch(expression.type) {
	case "BinaryExpression":
		if(expression.operator == "+") {
			var left = this.parseCalculatedString(expression.left);
			var right = this.parseCalculatedString(expression.right);
			if(left.code) {
				return {range: left.range, value: left.value, code: true};
			} else if(right.code) {
				return {range: [left.range[0], right.range ? right.range[1] : left.range[1]], value: left.value + right.value, code: true};
			} else {
				return {range: [left.range[0], right.range[1]], value: left.value + right.value};
			}
		}
		break;
	case "ConditionalExpression":
		var consequent = this.parseCalculatedString(expression.consequent);
		var alternate = this.parseCalculatedString(expression.alternate);
		var items = [];
		if(consequent.conditional)
			Array.prototype.push.apply(items, consequent.conditional);
		else if(!consequent.code)
			items.push(consequent);
		else break;
		if(alternate.conditional)
			Array.prototype.push.apply(items, alternate.conditional);
		else if(!alternate.code)
			items.push(alternate);
		else break;
		return {value: "", code: true, conditional: items};
	case "Literal":
		return {range: expression.range, value: expression.value+""};
		break;
	}
	return {value: "", code: true};
}

Parser.prototype.parseStringArray = function parseStringArray(expression) {
	switch(expression.type) {
	case "ArrayExpression":
		var arr = [];
		if(expression.elements)
			expression.elements.forEach(function(expr) {
				arr.push(this.parseString(expr));
			}, this);
		return arr;
	}
	return [this.parseString(expression)];
}

Parser.prototype.parseCalculatedStringArray = function parseCalculatedStringArray(expression) {
	switch(expression.type) {
	case "ArrayExpression":
		var arr = [];
		if(expression.elements)
			expression.elements.forEach(function(expr) {
				arr.push(this.parseCalculatedString(expr));
			}, this);
		return arr;
	}
	return [this.parseCalculatedString(expression)];
}

Parser.prototype.parse = function parse(source, initialState) {
	var ast = esprima.parse(source, {range: true, loc: true, raw: true});
	if(!ast || typeof ast != "object")
		throw new Error("Source couldn't be parsed");
	var oldScope = this.scope;
	var oldState = this.state;
	this.scope = {
		inTry: false,
		definitions: []
	};
	var state = this.state = initialState || {};
	this.walkStatements(ast.body);
	this.scope = oldScope;
	this.state = oldState;
	return state;
}