import * as ethUtil from 'ethereumjs-util';
import * as _ from 'lodash';
import * as Parser from 'solidity-parser-antlr';
import { SingleFileSourceRange, SourceRange, SourceSnippet } from './types';
import { utils } from './utils';
interface ASTInfo {
type: string;
node: Parser.ASTNode;
name: string | null;
range?: SingleFileSourceRange;
}
// Parsing source code for each transaction/code is slow and therefore we cache it
const parsedSourceByHash: { [sourceHash: string]: Parser.ASTNode } = {};
export function getSourceRangeSnippet(sourceRange: SourceRange, sourceCode: string): SourceSnippet | null {
const sourceHash = ethUtil.sha3(sourceCode).toString('hex');
if (_.isUndefined(parsedSourceByHash[sourceHash])) {
parsedSourceByHash[sourceHash] = Parser.parse(sourceCode, { loc: true });
}
const astNode = parsedSourceByHash[sourceHash];
const visitor = new ASTInfoVisitor();
Parser.visit(astNode, visitor);
const astInfo = visitor.getASTInfoForRange(sourceRange);
if (astInfo === null) {
return null;
}
const sourceCodeInRange = utils.getRange(sourceCode, sourceRange.location);
return {
...astInfo,
range: astInfo.range as SingleFileSourceRange,
source: sourceCodeInRange,
fileName: sourceRange.fileName,
};
}
// A visitor which collects ASTInfo for most nodes in the AST.
class ASTInfoVisitor {
private readonly _astInfos: ASTInfo[] = [];
public getASTInfoForRange(sourceRange: SourceRange): ASTInfo | null {
// HACK(albrow): Sometimes the source range doesn't exactly match that
// of astInfo. To work around that we try with a +/-1 offset on
// end.column. If nothing matches even with the offset, we return null.
const offset = {
start: {
line: 0,
column: 0,
},
end: {
line: 0,
column: 0,
},
};
let astInfo = this._getASTInfoForRange(sourceRange, offset);
if (astInfo !== null) {
return astInfo;
}
offset.end.column += 1;
astInfo = this._getASTInfoForRange(sourceRange, offset);
if (astInfo !== null) {
return astInfo;
}
offset.end.column -= 2;
astInfo = this._getASTInfoForRange(sourceRange, offset);
if (astInfo !== null) {
return astInfo;
}
return null;
}
public ContractDefinition(ast: Parser.ContractDefinition): void {
this._visitContractDefinition(ast);
}
public IfStatement(ast: Parser.IfStatement): void {
this._visitStatement(ast);
}
public FunctionDefinition(ast: Parser.FunctionDefinition): void {
this._visitFunctionLikeDefinition(ast);
}
public ModifierDefinition(ast: Parser.ModifierDefinition): void {
this._visitFunctionLikeDefinition(ast);
}
public ForStatement(ast: Parser.ForStatement): void {
this._visitStatement(ast);
}
public ReturnStatement(ast: Parser.ReturnStatement): void {
this._visitStatement(ast);
}
public BreakStatement(ast: Parser.BreakStatement): void {
this._visitStatement(ast);
}
public ContinueStatement(ast: Parser.ContinueStatement): void {
this._visitStatement(ast);
}
public EmitStatement(ast: any /* TODO: Parser.EmitStatement */): void {
this._visitStatement(ast);
}
public VariableDeclarationStatement(ast: Parser.VariableDeclarationStatement): void {
this._visitStatement(ast);
}
public Statement(ast: Parser.Statement): void {
this._visitStatement(ast);
}
public WhileStatement(ast: Parser.WhileStatement): void {
this._visitStatement(ast);
}
public SimpleStatement(ast: Parser.SimpleStatement): void {
this._visitStatement(ast);
}
public ThrowStatement(ast: Parser.ThrowStatement): void {
this._visitStatement(ast);
}
public DoWhileStatement(ast: Parser.DoWhileStatement): void {
this._visitStatement(ast);
}
public ExpressionStatement(ast: Parser.ExpressionStatement): void {
this._visitStatement(ast.expression);
}
public InlineAssemblyStatement(ast: Parser.InlineAssemblyStatement): void {
this._visitStatement(ast);
}
public ModifierInvocation(ast: Parser.ModifierInvocation): void {
const BUILTIN_MODIFIERS = ['public', 'view', 'payable', 'external', 'internal', 'pure', 'constant'];
if (!_.includes(BUILTIN_MODIFIERS, ast.name)) {
this._visitStatement(ast);
}
}
private _visitStatement(ast: Parser.ASTNode): void {
this._astInfos.push({
type: ast.type,
node: ast,
name: null,
range: ast.loc,
});
}
private _visitFunctionLikeDefinition(ast: Parser.ModifierDefinition | Parser.FunctionDefinition): void {
this._astInfos.push({
type: ast.type,
node: ast,
name: ast.name,
range: ast.loc,
});
}
private _visitContractDefinition(ast: Parser.ContractDefinition): void {
this._astInfos.push({
type: ast.type,
node: ast,
name: ast.name,
range: ast.loc,
});
}
private _getASTInfoForRange(sourceRange: SourceRange, offset: SingleFileSourceRange): ASTInfo | null {
const offsetSourceRange = {
...sourceRange,
location: {
start: {
line: sourceRange.location.start.line + offset.start.line,
column: sourceRange.location.start.column + offset.start.column,
},
end: {
line: sourceRange.location.end.line + offset.end.line,
column: sourceRange.location.end.column + offset.end.column,
},
},
};
for (const astInfo of this._astInfos) {
const astInfoRange = astInfo.range as SingleFileSourceRange;
if (
astInfoRange.start.column === offsetSourceRange.location.start.column &&
astInfoRange.start.line === offsetSourceRange.location.start.line &&
astInfoRange.end.column === offsetSourceRange.location.end.column &&
astInfoRange.end.line === offsetSourceRange.location.end.line
) {
return astInfo;
}
}
return null;
}
}
