You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
445 lines
15 KiB
445 lines
15 KiB
// var SolidityParser = require("solidity-parser");
|
|
var solparse = require("solparse");
|
|
var fs = require('fs');
|
|
|
|
var path = require("path");
|
|
module.exports = function(pathToFile, instrumentingActive){
|
|
|
|
// var result = SolidityParser.parseFile("./" + pathToFile);
|
|
var contract = fs.readFileSync("./" + pathToFile).toString();
|
|
var result = solparse.parse(contract);
|
|
var instrumented = "";
|
|
const __INDENTATION__ = " ";
|
|
var parse = {};
|
|
var runnableLines=[];
|
|
var fnMap = {};
|
|
var fnId = 0;
|
|
var linecount = 1;
|
|
var fileName = path.basename(pathToFile);
|
|
var injectionPoints = {};
|
|
function addInstrumentationEvent(charcount){
|
|
injectionPoints[charcount] = {type:"callEvent"};
|
|
return "Coverage('" + fileName + "'," + linecount + ");\n";
|
|
}
|
|
|
|
parse["AssignmentExpression"] = function (expression, instrument){
|
|
if (instrument){ retval += addInstrumentationEvent(expression.start); }
|
|
var retval = "";
|
|
retval += parse[expression.left.type](expression.left, instrument);
|
|
retval += expression.operator;
|
|
retval += parse[expression.right.type](expression.right, instrument) + ';';
|
|
return retval;
|
|
}
|
|
|
|
parse["ConditionalExpression"] = function(expression, instrument){
|
|
return parse[expression.test.left.type](expression.test.left) + expression.test.operator + parse[expression.test.right.type](expression.test.right) + '?' + parse[expression.consequent.type](expression.consequent) + ":" + parse[expression.alternate.type](expression.alternate);
|
|
}
|
|
|
|
parse["Identifier"] = function(expression, instrument){
|
|
return expression.name;
|
|
}
|
|
|
|
parse["InformalParameter"] = function(expression, instrument){
|
|
return expression.literal.literal;
|
|
}
|
|
|
|
parse["Literal"] = function(expression, instrument){
|
|
if (typeof expression.value==='string' && expression.value.slice(0,2)!=="0x"){
|
|
return '"' + expression.value + '"';
|
|
}else{
|
|
return expression.value;
|
|
}
|
|
}
|
|
|
|
parse["ModifierName"] = function(expression, instrument){
|
|
var retvalue = expression.name
|
|
if (expression.params && expression.params.length>0){
|
|
retvalue += '(';
|
|
for (x in expression.params){
|
|
var param = expression.params[x];
|
|
retvalue += param.literal.literal + ', ';
|
|
}
|
|
retvalue = retvalue.slice(0,-2);
|
|
retvalue += ')';
|
|
}
|
|
return retvalue;
|
|
};
|
|
|
|
parse["Modifiers"] = function(modifiers){
|
|
retvalue = "";
|
|
var retModifier = null;
|
|
var constModifier = null;
|
|
for (x in modifiers){
|
|
if (modifiers[x].name==='returns'){
|
|
retModifier = x;
|
|
continue;
|
|
}else if (modifiers[x].name==='constant'){
|
|
constModifier = x;
|
|
}else{
|
|
retvalue+=parse[modifiers[x].type](modifiers[x]);
|
|
retvalue += ' ';
|
|
}
|
|
}
|
|
if (constModifier) {retvalue += 'constant '};
|
|
if (retModifier){
|
|
retvalue += ' returns ';
|
|
retvalue += ' (';
|
|
for (p in modifiers[retModifier].params){
|
|
param = modifiers[retModifier].params[p];
|
|
retvalue+= parse[param.type](param);
|
|
retvalue += ', ';
|
|
}
|
|
retvalue = retvalue.slice(0,-2);
|
|
retvalue +=')';
|
|
}
|
|
return retvalue;
|
|
|
|
}
|
|
|
|
parse["ThisExpression"] = function(expression, instrument){
|
|
return 'this'
|
|
}
|
|
|
|
parse["ReturnStatement"] = function(expression, instrument){
|
|
var retval = "";
|
|
if (instrument){ retval += addInstrumentationEvent(expression.start); }
|
|
|
|
return retval + 'return ' + parse[expression.argument.type](expression.argument, instrument) + ';';
|
|
}
|
|
|
|
parse["NewExpression"] = function(expression, instrument){
|
|
var retval = 'new ' + parse[expression.callee.type](expression.callee);
|
|
retval += '(';
|
|
for (x in expression.arguments){
|
|
retval += parse[expression.arguments[x].type](expression.arguments[x]) + ", "
|
|
}
|
|
if (expression.arguments && expression.arguments.length){
|
|
retval = retval.slice(0,-2);
|
|
}
|
|
retval+=")"
|
|
|
|
return retval
|
|
}
|
|
|
|
parse["MemberExpression"] = function (expression){
|
|
if (!expression.computed){
|
|
return parse[expression.object.type](expression.object) + "." + parse[expression.property.type](expression.property);
|
|
}else{
|
|
return parse[expression.object.type](expression.object) + "[" + parse[expression.property.type](expression.property) + "]";
|
|
}
|
|
}
|
|
|
|
parse["CallExpression"] = function (expression){
|
|
var retval = parse[expression.callee.type](expression.callee) + "(";
|
|
for (x in expression.arguments){
|
|
retval += parse[expression.arguments[x].type](expression.arguments[x]) + ", "
|
|
}
|
|
if (expression.arguments && expression.arguments.length){
|
|
retval = retval.slice(0,-2);
|
|
}
|
|
retval+=")"
|
|
|
|
return retval
|
|
}
|
|
|
|
parse["UnaryExpression"] = function(expression, instrument){
|
|
if (expression.operator==='delete'){
|
|
return expression.operator + ' ' + parse[expression.argument.type](expression.argument);
|
|
|
|
}
|
|
return expression.operator + parse[expression.argument.type](expression.argument);
|
|
}
|
|
|
|
parse["ThrowStatement"] = function(expression, instrument){
|
|
var retval = "";
|
|
if (instrument){ retval += addInstrumentationEvent(expression.start); }
|
|
return retval + 'throw'
|
|
}
|
|
|
|
parse["BinaryExpression"] = function(expression, instrument){
|
|
return '(' + parse[expression.left.type](expression.left) + expression.operator + parse[expression.right.type](expression.right) + ')';
|
|
}
|
|
|
|
parse["IfStatement"] = function(expression, instrument){
|
|
var retval = "";
|
|
if (instrument){ retval += addInstrumentationEvent(expression.start); }
|
|
retval += "if (";
|
|
retval += parse[expression.test.type](expression.test, instrument) + "){"
|
|
retval += newLine('{');
|
|
retval += parse[expression.consequent.type](expression.consequent, instrument)
|
|
retval += newLine(retval.slice(-1));
|
|
retval += "}";
|
|
if (expression.alternate){
|
|
retval += 'else ';
|
|
if (expression.alternate.type!=="IfStatement"){
|
|
retval += '{';
|
|
retval += newLine('{');
|
|
}
|
|
retval += parse[expression.alternate.type](expression.alternate, instrument)
|
|
if (expression.alternate.type!=="IfStatement"){
|
|
retval += '}';
|
|
retval += newLine('}');
|
|
}
|
|
}
|
|
return retval;
|
|
}
|
|
|
|
parse["SequenceExpression"] = function(expression, instrument){
|
|
retval = "(";
|
|
for (x in expression.expressions){
|
|
retval += parse[expression.expressions[x].type](expression.expressions[x]) + ', ';
|
|
}
|
|
if (expression.expressions && expression.expressions.length>0){
|
|
//remove trailing comma and space if needed
|
|
retval = retval.slice(0,-2);
|
|
}
|
|
retval += ')';
|
|
return retval;
|
|
}
|
|
|
|
parse["ImportStatement"] = function(expression, instrument){
|
|
return 'import "' + expression.from + '"';
|
|
}
|
|
|
|
parse["DeclarativeExpression"] = function(expression, instrument){
|
|
return expression.literal.literal + ' ' + (expression.is_public ? "public " : "") + (expression.is_constant ? "constant " : "") + expression.name;
|
|
}
|
|
|
|
parse["ExpressionStatement"] = function(content, instrument){
|
|
var retval = "";
|
|
if (instrument){ retval += addInstrumentationEvent(content.start); }
|
|
if (content.expression.literal && content.expression.literal.literal && content.expression.literal.literal.type==="MappingExpression"){
|
|
return retval + 'mapping (' + content.expression.literal.literal.from.literal + ' => ' + content.expression.literal.literal.to.literal + ') '+ content.expression.name;
|
|
}else {
|
|
return retval + parse[content.expression.type](content.expression);
|
|
}
|
|
}
|
|
|
|
parse["EnumDeclaration"] = function(expression, instrument){
|
|
var retvalue = 'enum ' + expression.name + ' {';
|
|
for (x in expression.members){
|
|
retvalue += expression.members[x] + ', ';
|
|
}
|
|
retvalue = retvalue.slice(0,-2);
|
|
retvalue += '}';
|
|
return retvalue;
|
|
}
|
|
|
|
parse["EventDeclaration"]=function(expression, instrument){
|
|
var retval = 'event ' + expression.name + '(';
|
|
for (x in expression.params){
|
|
var param = expression.params[x];
|
|
retval += param.literal.literal + ' ' + (param.isIndexed ? 'true' : '') + param.id + ', ';
|
|
}
|
|
if (expression.params && expression.params.length>0){
|
|
//remove trailing comma and space if needed
|
|
retval = retval.slice(0,-2);
|
|
}
|
|
retval += ')';
|
|
return retval
|
|
}
|
|
|
|
parse["VariableDeclarationTuple"] = function(expression, instrument){
|
|
var retval = "";
|
|
if (instrument){ retval += addInstrumentationEvent(expression.start); }
|
|
|
|
retval += "var (";
|
|
for (x in expression.declarations){
|
|
retval += expression.declarations[x].id.name + ', ';
|
|
}
|
|
retval = retval.slice(0,-2);
|
|
retval += ") = ";
|
|
retval+=parse[expression.init.type](expression.init)
|
|
return retval;
|
|
}
|
|
|
|
parse["BlockStatement"] = function(expression, instrument){
|
|
var retval = "";
|
|
for (var x=0; x < expression.body.length; x++){
|
|
retval += parse[expression.body[x].type](expression.body[x], instrument);
|
|
retval += newLine(retval.slice(-1));
|
|
}
|
|
return retval;
|
|
}
|
|
|
|
parse["VariableDeclaration"] = function(expression, instrument){
|
|
if (expression.declarations.length>1){
|
|
console.log('more than one declaration')
|
|
}
|
|
retval = "";
|
|
if (instrument){ retval += addInstrumentationEvent(expression.start); }
|
|
return retval + "var " + parse[expression.declarations[0].id.type](expression.declarations[0].id) + " = " + parse[expression.declarations[0].init.type](expression.declarations[0].init);
|
|
}
|
|
|
|
parse["Type"] = function(expression, instrument){
|
|
return expression.literal;
|
|
}
|
|
|
|
parse["UsingStatement"] = function(expression, instrument){
|
|
return "using " + expression.library + " for " + parse[expression.for.type](expression.for) + ";";
|
|
}
|
|
|
|
parse["FunctionDeclaration"] = function(expression, instrument){
|
|
|
|
retval = 'function ' + (expression.name ? expression.name : "") + '('
|
|
for (x in expression.params){
|
|
var param = expression.params[x];
|
|
retval += param.literal.literal + ' ' + (param.isIndexed ? 'true' : '') + param.id + ', ';
|
|
}
|
|
if (expression.params && expression.params.length>0){
|
|
retval = retval.slice(0,-2);
|
|
}
|
|
retval += ')';
|
|
retval += parse["Modifiers"](expression.modifiers);
|
|
if (expression.body){
|
|
|
|
fnId+=1;
|
|
linecount = (contract.slice(0,expression.start).match(/\n/g)||[]).length + 1;
|
|
//We need to work out the lines and columns the function declaration starts and ends
|
|
var startline = linecount;
|
|
var startcol = expression.start - contract.slice(0,expression.start).lastIndexOf('\n');
|
|
var endlineDelta = contract.slice(expression.start).indexOf('{')+1;
|
|
var functionDefinition = contract.slice(expression.start, expression.start + endlineDelta);
|
|
var endline = startline + (functionDefinition.match(/\n/g)||[]).length;
|
|
var endcol = functionDefinition.length - functionDefinition.lastIndexOf('\n')
|
|
fnMap[fnId] = {name: expression.name, line: linecount, loc:{start:{line: startline, col:startcol},end:{line:endline, col:endcol}}}
|
|
injectionPoints[expression.start + endlineDelta +1] = {type: "callFunctionEvent", fnId: fnId};
|
|
|
|
|
|
retval+='{' + newLine('{');
|
|
retval += parse[expression.body.type](expression.body, instrumentingActive);
|
|
retval+='}' + newLine('}');
|
|
}
|
|
return retval;
|
|
}
|
|
|
|
parse["ContractStatement"] = function(expression, instrument){
|
|
var retval = "";
|
|
retval += 'contract ' + expression.name
|
|
|
|
if (expression.is.length>0){
|
|
retval += ' is '
|
|
for (x in expression.is){
|
|
retval += expression.is[x].name + ', '
|
|
}
|
|
retval = retval.slice(0,-2);
|
|
}
|
|
|
|
retval += ' {' + newLine('{');
|
|
//Inject our coverage event if we're covering
|
|
if (instrumentingActive){
|
|
//This is harder because of where .start and .end represent, and how documented comments are validated
|
|
//by solc upon compilation. From the start of this contract statement, find the first '{', and inject
|
|
//there.
|
|
injectionPoints[expression.start + contract.slice(expression.start).indexOf('{')+2] = {type:"eventDefinition"};
|
|
retval += "event Coverage(string fileName, uint256 lineNumber);\n"; //We're injecting this, so don't count the newline
|
|
}
|
|
|
|
for (x in expression.body){
|
|
retval+=parse[expression.body[x].type](expression.body[x], instrument);
|
|
retval += newLine(retval.slice(-1));
|
|
}
|
|
retval += '}' + newLine('}');
|
|
return retval;
|
|
}
|
|
|
|
parse["LibraryStatement"] = function(expression, instrument){
|
|
var retval = "";
|
|
retval += 'library ' + expression.name + ' {' + newLine('{');
|
|
//Inject our coverage event;
|
|
if(instrumentingActive){
|
|
|
|
//This is harder because of where .start and .end represent, and how documented comments are validated
|
|
//by solc upon compilation. From the start of this contract statement, find the first '{', and inject
|
|
//there.
|
|
injectionPoints[expression.start + contract.slice(expression.start).indexOf('{')+2] = {type:"eventDefinition"};
|
|
|
|
retval += "event Coverage(string fileName, uint256 lineNumber);\n"; //We're injecting this, so don't count the newline
|
|
}
|
|
|
|
for (x in expression.body){
|
|
retval+=parse[expression.body[x].type](expression.body[x], instrument);
|
|
retval += newLine(retval.slice(-1));
|
|
}
|
|
retval += '}' + newLine('}');
|
|
|
|
return retval;
|
|
}
|
|
|
|
parse["ModifierDeclaration"] = function(expression, instrument){
|
|
var retval = "";
|
|
retval += 'modifier ' + expression.name + '(';
|
|
for (x in expression.params){
|
|
var param = expression.params[x];
|
|
retval += param.literal.literal + ' ' + (param.isIndexed ? 'true' : '') + param.id + ', ';
|
|
}
|
|
if (expression.params && expression.params.length>0){
|
|
retval = retval.slice(0,-2);
|
|
}
|
|
retval += '){';
|
|
retval += newLine(retval.slice(-1));
|
|
retval += parse[expression.body.type](expression.body, instrumentingActive);
|
|
retval += newLine(retval.slice(-1));
|
|
retval +='}';
|
|
retval += newLine(retval.slice(-1));
|
|
return retval;
|
|
}
|
|
|
|
parse["Program"] = function(expression, instrument){
|
|
retval = "";
|
|
for (x in expression.body){
|
|
retval+=parse[expression.body[x].type](expression.body[x], instrument);
|
|
retval += newLine(retval.slice(-1));
|
|
}
|
|
return retval;
|
|
}
|
|
|
|
function newLine(lastchar){
|
|
linecount+=1;
|
|
if (['}','{',';','_','\n'].indexOf(lastchar)>-1){
|
|
return '\n';
|
|
}else{
|
|
return ';\n';
|
|
}
|
|
|
|
}
|
|
|
|
var instrumented = parse[result.type](result);
|
|
//We have to iterate through these injection points in descending order to not mess up
|
|
//the injection process.
|
|
var sortedPoints = Object.keys(injectionPoints).sort(function(a,b){return a-b});
|
|
for (x = sortedPoints.length-1; x>=0; x--){
|
|
injectionPoint = sortedPoints[x];
|
|
if (injectionPoints[injectionPoint].type==='callEvent'){
|
|
linecount = (contract.slice(0, injectionPoint).match(/\n/g)||[]).length + 1;
|
|
runnableLines.push(linecount);
|
|
contract = contract.slice(0, injectionPoint) + "Coverage('" + fileName + "'," + linecount + ");\n" + contract.slice(injectionPoint);
|
|
}else if (injectionPoints[injectionPoint].type==='callFunctionEvent'){
|
|
contract = contract.slice(0, injectionPoint) + "FunctionCoverage('" + fileName + "'," + injectionPoints[injectionPoint].fnId + ");\n" + contract.slice(injectionPoint);
|
|
}else{
|
|
contract = contract.slice(0, injectionPoint) + "event Coverage(string fileName, uint256 lineNumber);\nevent FunctionCoverage(string fileName, uint256 fnId);\n" + contract.slice(injectionPoint);
|
|
}
|
|
}
|
|
|
|
return {contract: contract, runnableLines: runnableLines, fnMap: fnMap};
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|