cerc-io/solidity
16
0
Fork 0
mirror of https://github.com/ethereum/solidity synced 2023-10-03 13:03:40 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Stop after parsing.

Browse Source
This commit is contained in:
chriseth 2020-07-08 22:08:50 +02:00 committed by Mathias Baumann
parent 4c02cd2310
commit fda8bde2d7
70 changed files with 5440 additions and 105 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
Changelog.md
View File

@ -4,6 +4,7 @@ Compiler Features:
* SMTChecker: Support ``addmod`` and ``mulmod``. * SMTChecker: Support ``addmod`` and ``mulmod``.
* Optimizer: Optimize ``exp`` when base is -1. * Optimizer: Optimize ``exp`` when base is -1.
* Code generator: Implemented events with function type as one of its indexed parameters. * Code generator: Implemented events with function type as one of its indexed parameters.
* General: Option to stop compilation after parsing stage. Can be used with ``solc --stop-after parsing``
### 0.7.2 (2020-09-28) ### 0.7.2 (2020-09-28)

2
docs/using-the-compiler.rst
View File

@ -200,6 +200,8 @@ Input Description
// Optional // Optional
"settings": "settings":
{ {
// Optional: Stop compilation after the given stage. Currently only "parsing" is valid here
"stopAfter": "parsing",
// Optional: Sorted list of remappings // Optional: Sorted list of remappings
"remappings": [ ":g=/dir" ], "remappings": [ ":g=/dir" ],
// Optional: Optimizer settings // Optional: Optimizer settings

54
libsolidity/ast/ASTJsonConverter.cpp
View File

@ -23,6 +23,7 @@
#include <libsolidity/ast/ASTJsonConverter.h> #include <libsolidity/ast/ASTJsonConverter.h>
#include <libsolidity/ast/AST.h> #include <libsolidity/ast/AST.h>
#include <libsolidity/ast/TypeProvider.h>
#include <libyul/AsmJsonConverter.h> #include <libyul/AsmJsonConverter.h>
#include <libyul/AsmData.h> #include <libyul/AsmData.h>
@ -69,8 +70,9 @@ void addIfSet(std::vector<pair<string, Json::Value>>& _attributes, string const&
namespace solidity::frontend namespace solidity::frontend
{ {
ASTJsonConverter::ASTJsonConverter(bool _legacy, map<string, unsigned> _sourceIndices): ASTJsonConverter::ASTJsonConverter(bool _legacy, CompilerStack::State _stackState, map<string, unsigned> _sourceIndices):
m_legacy(_legacy), m_legacy(_legacy),
m_stackState(_stackState),
m_sourceIndices(std::move(_sourceIndices)) m_sourceIndices(std::move(_sourceIndices))
{ {
} }
@ -204,7 +206,6 @@ void ASTJsonConverter::appendExpressionAttributes(
{ {
std::vector<pair<string, Json::Value>> exprAttributes = { std::vector<pair<string, Json::Value>> exprAttributes = {
make_pair("typeDescriptions", typePointerToJson(_annotation.type)), make_pair("typeDescriptions", typePointerToJson(_annotation.type)),
make_pair("lValueRequested", _annotation.willBeWrittenTo),
make_pair("argumentTypes", typePointerToJson(_annotation.arguments)) make_pair("argumentTypes", typePointerToJson(_annotation.arguments))
}; };
@ -212,6 +213,9 @@ void ASTJsonConverter::appendExpressionAttributes(
addIfSet(exprAttributes, "isPure", _annotation.isPure); addIfSet(exprAttributes, "isPure", _annotation.isPure);
addIfSet(exprAttributes, "isConstant", _annotation.isConstant); addIfSet(exprAttributes, "isConstant", _annotation.isConstant);
if (m_stackState > CompilerStack::State::ParsedAndImported)
exprAttributes.emplace_back("lValueRequested", _annotation.willBeWrittenTo);
_attributes += exprAttributes; _attributes += exprAttributes;
} }
@ -260,6 +264,7 @@ bool ASTJsonConverter::visit(SourceUnit const& _node)
addIfSet(attributes, "absolutePath", _node.annotation().path); addIfSet(attributes, "absolutePath", _node.annotation().path);
setJsonNode(_node, "SourceUnit", std::move(attributes)); setJsonNode(_node, "SourceUnit", std::move(attributes));
return false; return false;
} }
@ -268,7 +273,7 @@ bool ASTJsonConverter::visit(PragmaDirective const& _node)
Json::Value literals(Json::arrayValue); Json::Value literals(Json::arrayValue);
for (auto const& literal: _node.literals()) for (auto const& literal: _node.literals())
literals.append(literal); literals.append(literal);
setJsonNode( _node, "PragmaDirective", { setJsonNode(_node, "PragmaDirective", {
make_pair("literals", std::move(literals)) make_pair("literals", std::move(literals))
}); });
return false; return false;
@ -278,7 +283,7 @@ bool ASTJsonConverter::visit(ImportDirective const& _node)
{ {
std::vector<pair<string, Json::Value>> attributes = { std::vector<pair<string, Json::Value>> attributes = {
make_pair("file", _node.path()), make_pair("file", _node.path()),
make_pair(m_legacy ? "SourceUnit" : "sourceUnit", nodeId(*_node.annotation().sourceUnit)), make_pair(m_legacy ? "SourceUnit" : "sourceUnit", idOrNull(_node.annotation().sourceUnit)),
make_pair("scope", idOrNull(_node.scope())) make_pair("scope", idOrNull(_node.scope()))
}; };
@ -395,18 +400,11 @@ bool ASTJsonConverter::visit(OverrideSpecifier const& _node)
bool ASTJsonConverter::visit(FunctionDefinition const& _node) bool ASTJsonConverter::visit(FunctionDefinition const& _node)
{ {
Visibility visibility;
if (_node.isConstructor())
visibility = _node.annotation().contract->abstract() ? Visibility::Internal : Visibility::Public;
else
visibility = _node.visibility();
std::vector<pair<string, Json::Value>> attributes = { std::vector<pair<string, Json::Value>> attributes = {
make_pair("name", _node.name()), make_pair("name", _node.name()),
make_pair("documentation", _node.documentation() ? toJson(*_node.documentation()) : Json::nullValue), make_pair("documentation", _node.documentation() ? toJson(*_node.documentation()) : Json::nullValue),
make_pair("kind", _node.isFree() ? "freeFunction" : TokenTraits::toString(_node.kind())), make_pair("kind", _node.isFree() ? "freeFunction" : TokenTraits::toString(_node.kind())),
make_pair("stateMutability", stateMutabilityToString(_node.stateMutability())), make_pair("stateMutability", stateMutabilityToString(_node.stateMutability())),
make_pair("visibility", Declaration::visibilityToString(visibility)),
make_pair("virtual", _node.markedVirtual()), make_pair("virtual", _node.markedVirtual()),
make_pair("overrides", _node.overrides() ? toJson(*_node.overrides()) : Json::nullValue), make_pair("overrides", _node.overrides() ? toJson(*_node.overrides()) : Json::nullValue),
make_pair("parameters", toJson(_node.parameterList())), make_pair("parameters", toJson(_node.parameterList())),
@ -417,7 +415,19 @@ bool ASTJsonConverter::visit(FunctionDefinition const& _node)
make_pair("scope", idOrNull(_node.scope())) make_pair("scope", idOrNull(_node.scope()))
}; };
if (_node.isPartOfExternalInterface()) optional<Visibility> visibility;
if (_node.isConstructor())
{
if (_node.annotation().contract)
visibility = _node.annotation().contract->abstract() ? Visibility::Internal : Visibility::Public;
}
else
visibility = _node.visibility();
if (visibility)
attributes.emplace_back("visibility", Declaration::visibilityToString(*visibility));
if (_node.isPartOfExternalInterface() && m_stackState > CompilerStack::State::ParsedAndImported)
attributes.emplace_back("functionSelector", _node.externalIdentifierHex()); attributes.emplace_back("functionSelector", _node.externalIdentifierHex());
if (!_node.annotation().baseFunctions.empty()) if (!_node.annotation().baseFunctions.empty())
attributes.emplace_back(make_pair("baseFunctions", getContainerIds(_node.annotation().baseFunctions, true))); attributes.emplace_back(make_pair("baseFunctions", getContainerIds(_node.annotation().baseFunctions, true)));
@ -718,7 +728,7 @@ bool ASTJsonConverter::visit(Assignment const& _node)
make_pair("rightHandSide", toJson(_node.rightHandSide())) make_pair("rightHandSide", toJson(_node.rightHandSide()))
}; };
appendExpressionAttributes(attributes, _node.annotation()); appendExpressionAttributes(attributes, _node.annotation());
setJsonNode( _node, "Assignment", std::move(attributes)); setJsonNode(_node, "Assignment", std::move(attributes));
return false; return false;
} }
@ -770,15 +780,19 @@ bool ASTJsonConverter::visit(FunctionCall const& _node)
make_pair("tryCall", _node.annotation().tryCall) make_pair("tryCall", _node.annotation().tryCall)
}; };
FunctionCallKind nodeKind = *_node.annotation().kind; if (_node.annotation().kind.set())
if (m_legacy)
{ {
attributes.emplace_back("isStructConstructorCall", nodeKind == FunctionCallKind::StructConstructorCall); FunctionCallKind nodeKind = *_node.annotation().kind;
attributes.emplace_back("type_conversion", nodeKind == FunctionCallKind::TypeConversion);
if (m_legacy)
{
attributes.emplace_back("isStructConstructorCall", nodeKind == FunctionCallKind::StructConstructorCall);
attributes.emplace_back("type_conversion", nodeKind == FunctionCallKind::TypeConversion);
}
else
attributes.emplace_back("kind", functionCallKind(nodeKind));
} }
else
attributes.emplace_back("kind", functionCallKind(nodeKind));
appendExpressionAttributes(attributes, _node.annotation()); appendExpressionAttributes(attributes, _node.annotation());
setJsonNode(_node, "FunctionCall", std::move(attributes)); setJsonNode(_node, "FunctionCall", std::move(attributes));
return false; return false;

4
libsolidity/ast/ASTJsonConverter.h
View File

@ -25,6 +25,7 @@
#include <libsolidity/ast/ASTAnnotations.h> #include <libsolidity/ast/ASTAnnotations.h>
#include <libsolidity/ast/ASTVisitor.h> #include <libsolidity/ast/ASTVisitor.h>
#include <libsolidity/interface/CompilerStack.h>
#include <liblangutil/Exceptions.h> #include <liblangutil/Exceptions.h>
#include <json/json.h> #include <json/json.h>
@ -51,9 +52,11 @@ class ASTJsonConverter: public ASTConstVisitor
public: public:
/// Create a converter to JSON for the given abstract syntax tree. /// Create a converter to JSON for the given abstract syntax tree.
/// @a _legacy if true, use legacy format /// @a _legacy if true, use legacy format
/// @a _stackState state of the compiler stack to avoid outputting incomplete data
/// @a _sourceIndices is used to abbreviate source names in source locations. /// @a _sourceIndices is used to abbreviate source names in source locations.
explicit ASTJsonConverter( explicit ASTJsonConverter(
bool _legacy, bool _legacy,
CompilerStack::State _stackState,
std::map<std::string, unsigned> _sourceIndices = std::map<std::string, unsigned>() std::map<std::string, unsigned> _sourceIndices = std::map<std::string, unsigned>()
); );
/// Output the json representation of the AST to _stream. /// Output the json representation of the AST to _stream.
@ -189,6 +192,7 @@ private:
} }
bool m_legacy = false; ///< if true, use legacy format bool m_legacy = false; ///< if true, use legacy format
CompilerStack::State m_stackState = CompilerStack::State::Empty; ///< Used to only access information that already exists
bool m_inEvent = false; ///< whether we are currently inside an event or not bool m_inEvent = false; ///< whether we are currently inside an event or not
Json::Value m_currentValue; Json::Value m_currentValue;
std::map<std::string, unsigned> m_sourceIndices; std::map<std::string, unsigned> m_sourceIndices;

4
libsolidity/ast/Types.cpp
View File

@ -140,7 +140,9 @@ util::Result<TypePointers> transformParametersToExternal(TypePointers const& _pa
for (auto const& type: _parameters) for (auto const& type: _parameters)
{ {
if (TypePointer ext = type->interfaceType(_inLibrary).get()) if (!type)
return util::Result<TypePointers>::err("Type information not present.");
else if (TypePointer ext = type->interfaceType(_inLibrary).get())
transformed.push_back(ext); transformed.push_back(ext);
else else
return util::Result<TypePointers>::err("Parameter should have external type."); return util::Result<TypePointers>::err("Parameter should have external type.");

116
libsolidity/interface/CompilerStack.cpp
View File

@ -124,7 +124,7 @@ std::optional<CompilerStack::Remapping> CompilerStack::parseRemapping(string con
void CompilerStack::setRemappings(vector<Remapping> const& _remappings) void CompilerStack::setRemappings(vector<Remapping> const& _remappings)
{ {
if (m_stackState >= ParsingPerformed) if (m_stackState >= ParsedAndImported)
BOOST_THROW_EXCEPTION(CompilerError() << errinfo_comment("Must set remappings before parsing.")); BOOST_THROW_EXCEPTION(CompilerError() << errinfo_comment("Must set remappings before parsing."));
for (auto const& remapping: _remappings) for (auto const& remapping: _remappings)
solAssert(!remapping.prefix.empty(), ""); solAssert(!remapping.prefix.empty(), "");
@ -133,21 +133,21 @@ void CompilerStack::setRemappings(vector<Remapping> const& _remappings)
void CompilerStack::setEVMVersion(langutil::EVMVersion _version) void CompilerStack::setEVMVersion(langutil::EVMVersion _version)
{ {
if (m_stackState >= ParsingPerformed) if (m_stackState >= ParsedAndImported)
BOOST_THROW_EXCEPTION(CompilerError() << errinfo_comment("Must set EVM version before parsing.")); BOOST_THROW_EXCEPTION(CompilerError() << errinfo_comment("Must set EVM version before parsing."));
m_evmVersion = _version; m_evmVersion = _version;
} }
void CompilerStack::setSMTSolverChoice(smtutil::SMTSolverChoice _enabledSMTSolvers) void CompilerStack::setSMTSolverChoice(smtutil::SMTSolverChoice _enabledSMTSolvers)
{ {
if (m_stackState >= ParsingPerformed) if (m_stackState >= ParsedAndImported)
BOOST_THROW_EXCEPTION(CompilerError() << errinfo_comment("Must set enabled SMT solvers before parsing.")); BOOST_THROW_EXCEPTION(CompilerError() << errinfo_comment("Must set enabled SMT solvers before parsing."));
m_enabledSMTSolvers = _enabledSMTSolvers; m_enabledSMTSolvers = _enabledSMTSolvers;
} }
void CompilerStack::setLibraries(std::map<std::string, util::h160> const& _libraries) void CompilerStack::setLibraries(std::map<std::string, util::h160> const& _libraries)
{ {
if (m_stackState >= ParsingPerformed) if (m_stackState >= ParsedAndImported)
BOOST_THROW_EXCEPTION(CompilerError() << errinfo_comment("Must set libraries before parsing.")); BOOST_THROW_EXCEPTION(CompilerError() << errinfo_comment("Must set libraries before parsing."));
m_libraries = _libraries; m_libraries = _libraries;
} }
@ -161,14 +161,14 @@ void CompilerStack::setOptimiserSettings(bool _optimize, unsigned _runs)
void CompilerStack::setOptimiserSettings(OptimiserSettings _settings) void CompilerStack::setOptimiserSettings(OptimiserSettings _settings)
{ {
if (m_stackState >= ParsingPerformed) if (m_stackState >= ParsedAndImported)
BOOST_THROW_EXCEPTION(CompilerError() << errinfo_comment("Must set optimiser settings before parsing.")); BOOST_THROW_EXCEPTION(CompilerError() << errinfo_comment("Must set optimiser settings before parsing."));
m_optimiserSettings = std::move(_settings); m_optimiserSettings = std::move(_settings);
} }
void CompilerStack::setRevertStringBehaviour(RevertStrings _revertStrings) void CompilerStack::setRevertStringBehaviour(RevertStrings _revertStrings)
{ {
if (m_stackState >= ParsingPerformed) if (m_stackState >= ParsedAndImported)
BOOST_THROW_EXCEPTION(CompilerError() << errinfo_comment("Must set revert string settings before parsing.")); BOOST_THROW_EXCEPTION(CompilerError() << errinfo_comment("Must set revert string settings before parsing."));
solUnimplementedAssert(_revertStrings != RevertStrings::VerboseDebug, ""); solUnimplementedAssert(_revertStrings != RevertStrings::VerboseDebug, "");
m_revertStrings = _revertStrings; m_revertStrings = _revertStrings;
@ -176,21 +176,21 @@ void CompilerStack::setRevertStringBehaviour(RevertStrings _revertStrings)
void CompilerStack::useMetadataLiteralSources(bool _metadataLiteralSources) void CompilerStack::useMetadataLiteralSources(bool _metadataLiteralSources)
{ {
if (m_stackState >= ParsingPerformed) if (m_stackState >= ParsedAndImported)
BOOST_THROW_EXCEPTION(CompilerError() << errinfo_comment("Must set use literal sources before parsing.")); BOOST_THROW_EXCEPTION(CompilerError() << errinfo_comment("Must set use literal sources before parsing."));
m_metadataLiteralSources = _metadataLiteralSources; m_metadataLiteralSources = _metadataLiteralSources;
} }
void CompilerStack::setMetadataHash(MetadataHash _metadataHash) void CompilerStack::setMetadataHash(MetadataHash _metadataHash)
{ {
if (m_stackState >= ParsingPerformed) if (m_stackState >= ParsedAndImported)
BOOST_THROW_EXCEPTION(CompilerError() << errinfo_comment("Must set metadata hash before parsing.")); BOOST_THROW_EXCEPTION(CompilerError() << errinfo_comment("Must set metadata hash before parsing."));
m_metadataHash = _metadataHash; m_metadataHash = _metadataHash;
} }
void CompilerStack::addSMTLib2Response(h256 const& _hash, string const& _response) void CompilerStack::addSMTLib2Response(h256 const& _hash, string const& _response)
{ {
if (m_stackState >= ParsingPerformed) if (m_stackState >= ParsedAndImported)
BOOST_THROW_EXCEPTION(CompilerError() << errinfo_comment("Must add SMTLib2 responses before parsing.")); BOOST_THROW_EXCEPTION(CompilerError() << errinfo_comment("Must add SMTLib2 responses before parsing."));
m_smtlib2Responses[_hash] = _response; m_smtlib2Responses[_hash] = _response;
} }
@ -214,6 +214,7 @@ void CompilerStack::reset(bool _keepSettings)
m_optimiserSettings = OptimiserSettings::minimal(); m_optimiserSettings = OptimiserSettings::minimal();
m_metadataLiteralSources = false; m_metadataLiteralSources = false;
m_metadataHash = MetadataHash::IPFS; m_metadataHash = MetadataHash::IPFS;
m_stopAfter = State::CompilationSuccessful;
} }
m_globalContext.reset(); m_globalContext.reset();
m_sourceOrder.clear(); m_sourceOrder.clear();
@ -247,6 +248,7 @@ bool CompilerStack::parse()
vector<string> sourcesToParse; vector<string> sourcesToParse;
for (auto const& s: m_sources) for (auto const& s: m_sources)
sourcesToParse.push_back(s.first); sourcesToParse.push_back(s.first);
for (size_t i = 0; i < sourcesToParse.size(); ++i) for (size_t i = 0; i < sourcesToParse.size(); ++i)
{ {
string const& path = sourcesToParse[i]; string const& path = sourcesToParse[i];
@ -258,19 +260,26 @@ bool CompilerStack::parse()
else else
{ {
source.ast->annotation().path = path; source.ast->annotation().path = path;
for (auto const& newSource: loadMissingSources(*source.ast, path)) if (m_stopAfter >= ParsedAndImported)
{ for (auto const& newSource: loadMissingSources(*source.ast, path))
string const& newPath = newSource.first; {
string const& newContents = newSource.second; string const& newPath = newSource.first;
m_sources[newPath].scanner = make_shared<Scanner>(CharStream(newContents, newPath)); string const& newContents = newSource.second;
sourcesToParse.push_back(newPath); m_sources[newPath].scanner = make_shared<Scanner>(CharStream(newContents, newPath));
} sourcesToParse.push_back(newPath);
}
} }
} }
m_stackState = ParsingPerformed; if (m_stopAfter <= Parsed)
m_stackState = Parsed;
else
m_stackState = ParsedAndImported;
if (!Error::containsOnlyWarnings(m_errorReporter.errors())) if (!Error::containsOnlyWarnings(m_errorReporter.errors()))
m_hasError = true; m_hasError = true;
storeContractDefinitions();
return !m_hasError; return !m_hasError;
} }
@ -290,13 +299,15 @@ void CompilerStack::importASTs(map<string, Json::Value> const& _sources)
source.scanner = scanner; source.scanner = scanner;
m_sources[path] = source; m_sources[path] = source;
} }
m_stackState = ParsingPerformed; m_stackState = ParsedAndImported;
m_importedSources = true; m_importedSources = true;
storeContractDefinitions();
} }
bool CompilerStack::analyze() bool CompilerStack::analyze()
{ {
if (m_stackState != ParsingPerformed || m_stackState >= AnalysisPerformed) if (m_stackState != ParsedAndImported || m_stackState >= AnalysisPerformed)
BOOST_THROW_EXCEPTION(CompilerError() << errinfo_comment("Must call analyze only after parsing was performed.")); BOOST_THROW_EXCEPTION(CompilerError() << errinfo_comment("Must call analyze only after parsing was performed."));
resolveImports(); resolveImports();
@ -336,26 +347,6 @@ bool CompilerStack::analyze()
if (source->ast && !resolver.resolveNamesAndTypes(*source->ast)) if (source->ast && !resolver.resolveNamesAndTypes(*source->ast))
return false; return false;
// Store contract definitions.
for (Source const* source: m_sourceOrder)
if (source->ast)
for (
ContractDefinition const* contract:
ASTNode::filteredNodes<ContractDefinition>(source->ast->nodes())
)
{
// Note that we now reference contracts by their fully qualified names, and
// thus contracts can only conflict if declared in the same source file. This
// should already cause a double-declaration error elsewhere.
if (!m_contracts.count(contract->fullyQualifiedName()))
m_contracts[contract->fullyQualifiedName()].contract = contract;
else
solAssert(
m_errorReporter.hasErrors(),
"Contract already present (name clash?), but no error was reported."
);
}
DeclarationTypeChecker declarationTypeChecker(m_errorReporter, m_evmVersion); DeclarationTypeChecker declarationTypeChecker(m_errorReporter, m_evmVersion);
for (Source const* source: m_sourceOrder) for (Source const* source: m_sourceOrder)
if (source->ast && !declarationTypeChecker.check(*source->ast)) if (source->ast && !declarationTypeChecker.check(*source->ast))
@ -469,9 +460,13 @@ bool CompilerStack::analyze()
return !m_hasError; return !m_hasError;
} }
bool CompilerStack::parseAndAnalyze() bool CompilerStack::parseAndAnalyze(State _stopAfter)
{ {
m_stopAfter = _stopAfter;
bool success = parse(); bool success = parse();
if (m_stackState >= m_stopAfter)
return success;
if (success || m_parserErrorRecovery) if (success || m_parserErrorRecovery)
success = analyze(); success = analyze();
return success; return success;
@ -502,12 +497,16 @@ bool CompilerStack::isRequestedContract(ContractDefinition const& _contract) con
return false; return false;
} }
bool CompilerStack::compile() bool CompilerStack::compile(State _stopAfter)
{ {
m_stopAfter = _stopAfter;
if (m_stackState < AnalysisPerformed) if (m_stackState < AnalysisPerformed)
if (!parseAndAnalyze()) if (!parseAndAnalyze(_stopAfter))
return false; return false;
if (m_stackState >= m_stopAfter)
return true;
if (m_hasError) if (m_hasError)
BOOST_THROW_EXCEPTION(CompilerError() << errinfo_comment("Called compile with errors.")); BOOST_THROW_EXCEPTION(CompilerError() << errinfo_comment("Called compile with errors."));
@ -574,7 +573,7 @@ void CompilerStack::link()
vector<string> CompilerStack::contractNames() const vector<string> CompilerStack::contractNames() const
{ {
if (m_stackState < AnalysisPerformed) if (m_stackState < Parsed)
BOOST_THROW_EXCEPTION(CompilerError() << errinfo_comment("Parsing was not successful.")); BOOST_THROW_EXCEPTION(CompilerError() << errinfo_comment("Parsing was not successful."));
vector<string> contractNames; vector<string> contractNames;
for (auto const& contract: m_contracts) for (auto const& contract: m_contracts)
@ -921,7 +920,7 @@ Scanner const& CompilerStack::scanner(string const& _sourceName) const
SourceUnit const& CompilerStack::ast(string const& _sourceName) const SourceUnit const& CompilerStack::ast(string const& _sourceName) const
{ {
if (m_stackState < ParsingPerformed) if (m_stackState < Parsed)
BOOST_THROW_EXCEPTION(CompilerError() << errinfo_comment("Parsing not yet performed.")); BOOST_THROW_EXCEPTION(CompilerError() << errinfo_comment("Parsing not yet performed."));
if (!source(_sourceName).ast && !m_parserErrorRecovery) if (!source(_sourceName).ast && !m_parserErrorRecovery)
BOOST_THROW_EXCEPTION(CompilerError() << errinfo_comment("Parsing was not successful.")); BOOST_THROW_EXCEPTION(CompilerError() << errinfo_comment("Parsing was not successful."));
@ -994,7 +993,7 @@ string const& CompilerStack::Source::ipfsUrl() const
StringMap CompilerStack::loadMissingSources(SourceUnit const& _ast, std::string const& _sourcePath) StringMap CompilerStack::loadMissingSources(SourceUnit const& _ast, std::string const& _sourcePath)
{ {
solAssert(m_stackState < ParsingPerformed, ""); solAssert(m_stackState < ParsedAndImported, "");
StringMap newSources; StringMap newSources;
try try
{ {
@ -1038,7 +1037,7 @@ StringMap CompilerStack::loadMissingSources(SourceUnit const& _ast, std::string
string CompilerStack::applyRemapping(string const& _path, string const& _context) string CompilerStack::applyRemapping(string const& _path, string const& _context)
{ {
solAssert(m_stackState < ParsingPerformed, ""); solAssert(m_stackState < ParsedAndImported, "");
// Try to find the longest prefix match in all remappings that are active in the current context. // Try to find the longest prefix match in all remappings that are active in the current context.
auto isPrefixOf = [](string const& _a, string const& _b) auto isPrefixOf = [](string const& _a, string const& _b)
{ {
@ -1080,7 +1079,7 @@ string CompilerStack::applyRemapping(string const& _path, string const& _context
void CompilerStack::resolveImports() void CompilerStack::resolveImports()
{ {
solAssert(m_stackState == ParsingPerformed, ""); solAssert(m_stackState == ParsedAndImported, "");
// topological sorting (depth first search) of the import graph, cutting potential cycles // topological sorting (depth first search) of the import graph, cutting potential cycles
vector<Source const*> sourceOrder; vector<Source const*> sourceOrder;
@ -1110,6 +1109,29 @@ void CompilerStack::resolveImports()
swap(m_sourceOrder, sourceOrder); swap(m_sourceOrder, sourceOrder);
} }
void CompilerStack::storeContractDefinitions()
{
for (auto const& pair: m_sources)
if (pair.second.ast)
for (
ContractDefinition const* contract:
ASTNode::filteredNodes<ContractDefinition>(pair.second.ast->nodes())
)
{
string fullyQualifiedName = *pair.second.ast->annotation().path + ":" + contract->name();
// Note that we now reference contracts by their fully qualified names, and
// thus contracts can only conflict if declared in the same source file. This
// should already cause a double-declaration error elsewhere.
if (!m_contracts.count(fullyQualifiedName))
m_contracts[fullyQualifiedName].contract = contract;
else
solAssert(
m_errorReporter.hasErrors(),
"Contract already present (name clash?), but no error was reported."
);
}
}
namespace namespace
{ {
bool onlySafeExperimentalFeaturesActivated(set<ExperimentalFeature> const& features) bool onlySafeExperimentalFeaturesActivated(set<ExperimentalFeature> const& features)

11
libsolidity/interface/CompilerStack.h
View File

@ -90,7 +90,8 @@ public:
enum State { enum State {
Empty, Empty,
SourcesSet, SourcesSet,
ParsingPerformed, Parsed,
ParsedAndImported,
AnalysisPerformed, AnalysisPerformed,
CompilationSuccessful CompilationSuccessful
}; };
@ -216,11 +217,11 @@ public:
/// Parses and analyzes all source units that were added /// Parses and analyzes all source units that were added
/// @returns false on error. /// @returns false on error.
bool parseAndAnalyze(); bool parseAndAnalyze(State _stopAfter = State::CompilationSuccessful);
/// Compiles the source units that were previously added and parsed. /// Compiles the source units that were previously added and parsed.
/// @returns false on error. /// @returns false on error.
bool compile(); bool compile(State _stopAfter = State::CompilationSuccessful);
/// @returns the list of sources (paths) used /// @returns the list of sources (paths) used
std::vector<std::string> sourceNames() const; std::vector<std::string> sourceNames() const;
@ -373,6 +374,9 @@ private:
std::string applyRemapping(std::string const& _path, std::string const& _context); std::string applyRemapping(std::string const& _path, std::string const& _context);
void resolveImports(); void resolveImports();
/// Store the contract definitions in m_contracts.
void storeContractDefinitions();
/// @returns true if the source is requested to be compiled. /// @returns true if the source is requested to be compiled.
bool isRequestedSource(std::string const& _sourceName) const; bool isRequestedSource(std::string const& _sourceName) const;
@ -446,6 +450,7 @@ private:
ReadCallback::Callback m_readFile; ReadCallback::Callback m_readFile;
OptimiserSettings m_optimiserSettings; OptimiserSettings m_optimiserSettings;
RevertStrings m_revertStrings = RevertStrings::Default; RevertStrings m_revertStrings = RevertStrings::Default;
State m_stopAfter = State::CompilationSuccessful;
langutil::EVMVersion m_evmVersion; langutil::EVMVersion m_evmVersion;
smtutil::SMTSolverChoice m_enabledSMTSolvers; smtutil::SMTSolverChoice m_enabledSMTSolvers;
std::map<std::string, std::set<std::string>> m_requestedContractNames; std::map<std::string, std::set<std::string>> m_requestedContractNames;

47
libsolidity/interface/StandardCompiler.cpp
View File

@ -414,7 +414,7 @@ std::optional<Json::Value> checkAuxiliaryInputKeys(Json::Value const& _input)
std::optional<Json::Value> checkSettingsKeys(Json::Value const& _input) std::optional<Json::Value> checkSettingsKeys(Json::Value const& _input)
{ {
static set<string> keys{"parserErrorRecovery", "debug", "evmVersion", "libraries", "metadata", "optimizer", "outputSelection", "remappings"}; static set<string> keys{"parserErrorRecovery", "debug", "evmVersion", "libraries", "metadata", "optimizer", "outputSelection", "remappings", "stopAfter"};
return checkKeys(_input, keys, "settings"); return checkKeys(_input, keys, "settings");
} }
@ -724,6 +724,17 @@ std::variant<StandardCompiler::InputsAndSettings, Json::Value> StandardCompiler:
if (auto result = checkSettingsKeys(settings)) if (auto result = checkSettingsKeys(settings))
return *result; return *result;
if (settings.isMember("stopAfter"))
{
if (!settings["stopAfter"].isString())
return formatFatalError("JSONError", "\"settings.stopAfter\" must be a string.");
if (settings["stopAfter"].asString() != "parsing")
return formatFatalError("JSONError", "Invalid value for \"settings.stopAfter\". Only valid value is \"parsing\".");
ret.stopAfter = CompilerStack::State::Parsed;
}
if (settings.isMember("parserErrorRecovery")) if (settings.isMember("parserErrorRecovery"))
{ {
if (!settings["parserErrorRecovery"].isBool()) if (!settings["parserErrorRecovery"].isBool())
@ -849,6 +860,12 @@ std::variant<StandardCompiler::InputsAndSettings, Json::Value> StandardCompiler:
ret.outputSelection = std::move(outputSelection); ret.outputSelection = std::move(outputSelection);
if (ret.stopAfter != CompilerStack::State::CompilationSuccessful && isBinaryRequested(ret.outputSelection))
return formatFatalError(
"JSONError",
"Requested output selection conflicts with \"settings.stopAfter\"."
);
return { std::move(ret) }; return { std::move(ret) };
} }
@ -883,7 +900,7 @@ Json::Value StandardCompiler::compileSolidity(StandardCompiler::InputsAndSetting
if (binariesRequested) if (binariesRequested)
compilerStack.compile(); compilerStack.compile();
else else
compilerStack.parseAndAnalyze(); compilerStack.parseAndAnalyze(_inputsAndSettings.stopAfter);
for (auto const& error: compilerStack.errors()) for (auto const& error: compilerStack.errors())
{ {
@ -1005,7 +1022,10 @@ Json::Value StandardCompiler::compileSolidity(StandardCompiler::InputsAndSetting
analysisPerformed = false; analysisPerformed = false;
/// Inconsistent state - stop here to receive error reports from users /// Inconsistent state - stop here to receive error reports from users
if (((binariesRequested && !compilationSuccess) || !analysisPerformed) && errors.empty()) if (
((binariesRequested && !compilationSuccess) || !analysisPerformed) &&
(errors.empty() && _inputsAndSettings.stopAfter >= CompilerStack::State::AnalysisPerformed)
)
return formatFatalError("InternalCompilerError", "No error reported, but compilation failed."); return formatFatalError("InternalCompilerError", "No error reported, but compilation failed.");
Json::Value output = Json::objectValue; Json::Value output = Json::objectValue;
@ -1021,16 +1041,17 @@ Json::Value StandardCompiler::compileSolidity(StandardCompiler::InputsAndSetting
output["sources"] = Json::objectValue; output["sources"] = Json::objectValue;
unsigned sourceIndex = 0; unsigned sourceIndex = 0;
for (string const& sourceName: analysisPerformed ? compilerStack.sourceNames() : vector<string>()) if (compilerStack.state() >= CompilerStack::State::Parsed && (!compilerStack.hasError() || _inputsAndSettings.parserErrorRecovery))
{ for (string const& sourceName: compilerStack.sourceNames())
Json::Value sourceResult = Json::objectValue; {
sourceResult["id"] = sourceIndex++; Json::Value sourceResult = Json::objectValue;
if (isArtifactRequested(_inputsAndSettings.outputSelection, sourceName, "", "ast", wildcardMatchesExperimental)) sourceResult["id"] = sourceIndex++;
sourceResult["ast"] = ASTJsonConverter(false, compilerStack.sourceIndices()).toJson(compilerStack.ast(sourceName)); if (isArtifactRequested(_inputsAndSettings.outputSelection, sourceName, "", "ast", wildcardMatchesExperimental))
if (isArtifactRequested(_inputsAndSettings.outputSelection, sourceName, "", "legacyAST", wildcardMatchesExperimental)) sourceResult["ast"] = ASTJsonConverter(false, compilerStack.state(), compilerStack.sourceIndices()).toJson(compilerStack.ast(sourceName));
sourceResult["legacyAST"] = ASTJsonConverter(true, compilerStack.sourceIndices()).toJson(compilerStack.ast(sourceName)); if (isArtifactRequested(_inputsAndSettings.outputSelection, sourceName, "", "legacyAST", wildcardMatchesExperimental))
output["sources"][sourceName] = sourceResult; sourceResult["legacyAST"] = ASTJsonConverter(true, compilerStack.state(), compilerStack.sourceIndices()).toJson(compilerStack.ast(sourceName));
} output["sources"][sourceName] = sourceResult;
}
Json::Value contractsOutput = Json::objectValue; Json::Value contractsOutput = Json::objectValue;
for (string const& contractName: analysisPerformed ? compilerStack.contractNames() : vector<string>()) for (string const& contractName: analysisPerformed ? compilerStack.contractNames() : vector<string>())

1
libsolidity/interface/StandardCompiler.h
View File

@ -60,6 +60,7 @@ private:
std::string language; std::string language;
Json::Value errors; Json::Value errors;
bool parserErrorRecovery = false; bool parserErrorRecovery = false;
CompilerStack::State stopAfter = CompilerStack::State::CompilationSuccessful;
std::map<std::string, std::string> sources; std::map<std::string, std::string> sources;
std::map<util::h256, std::string> smtLib2Responses; std::map<util::h256, std::string> smtLib2Responses;
langutil::EVMVersion evmVersion; langutil::EVMVersion evmVersion;

62
solc/CommandLineInterface.cpp
View File

@ -159,6 +159,8 @@ static string const g_strOutputDir = "output-dir";
static string const g_strOverwrite = "overwrite"; static string const g_strOverwrite = "overwrite";
static string const g_strRevertStrings = "revert-strings"; static string const g_strRevertStrings = "revert-strings";
static string const g_strStorageLayout = "storage-layout"; static string const g_strStorageLayout = "storage-layout";
static string const g_strStopAfter = "stop-after";
static string const g_strParsing = "parsing";
/// Possible arguments to for --revert-strings /// Possible arguments to for --revert-strings
static set<string> const g_revertStringsArgs static set<string> const g_revertStringsArgs
@ -320,6 +322,17 @@ static bool needsHumanTargetedStdout(po::variables_map const& _args)
return false; return false;
} }
bool checkMutuallyExclusive(boost::program_options::variables_map const& args, std::string const& _optionA, std::string const& _optionB)
{
if (args.count(_optionA) && args.count(_optionB))
{
serr() << "Option " << _optionA << " and " << _optionB << " are mutually exclusive." << endl;
return false;
}
return true;
}
void CommandLineInterface::handleBinary(string const& _contract) void CommandLineInterface::handleBinary(string const& _contract)
{ {
if (m_args.count(g_argBinary)) if (m_args.count(g_argBinary))
@ -804,6 +817,11 @@ General Information)").c_str(),
po::value<string>()->value_name(boost::join(g_revertStringsArgs, ",")), po::value<string>()->value_name(boost::join(g_revertStringsArgs, ",")),
"Strip revert (and require) reason strings or add additional debugging information." "Strip revert (and require) reason strings or add additional debugging information."
) )
(
g_strStopAfter.c_str(),
po::value<string>()->value_name("stage"),
"Stop execution after the given compiler stage. Valid options: \"parsing\"."
)
; ;
desc.add(outputOptions); desc.add(outputOptions);
@ -996,11 +1014,23 @@ General Information)").c_str(),
return false; return false;
} }
if (m_args.count(g_argColor) && m_args.count(g_argNoColor)) if (!checkMutuallyExclusive(m_args, g_argColor, g_argNoColor))
{
serr() << "Option " << g_argColor << " and " << g_argNoColor << " are mutualy exclusive." << endl;
return false; return false;
}
static vector<string> const conflictingWithStopAfter{
g_argBinary,
g_argIR,
g_argIROptimized,
g_argEwasm,
g_argGas,
g_argAsm,
g_argAsmJson,
g_argOpcodes
};
for (auto& option: conflictingWithStopAfter)
if (!checkMutuallyExclusive(m_args, g_strStopAfter, option))
return false;
m_coloredOutput = !m_args.count(g_argNoColor) && (isatty(STDERR_FILENO) || m_args.count(g_argColor)); m_coloredOutput = !m_args.count(g_argNoColor) && (isatty(STDERR_FILENO) || m_args.count(g_argColor));
@ -1138,6 +1168,17 @@ bool CommandLineInterface::processInput()
} }
} }
if (m_args.count(g_strStopAfter))
{
if (m_args[g_strStopAfter].as<string>() != "parsing")
{
serr() << "Valid options for --" << g_strStopAfter << " are: \"parsing\".\n";
return false;
}
else
m_stopAfter = CompilerStack::State::Parsed;
}
vector<string> const exclusiveModes = { vector<string> const exclusiveModes = {
g_argStandardJSON, g_argStandardJSON,
g_argLink, g_argLink,
@ -1417,7 +1458,7 @@ bool CommandLineInterface::processInput()
m_compiler->setParserErrorRecovery(true); m_compiler->setParserErrorRecovery(true);
} }
bool successful = m_compiler->compile(); bool successful = m_compiler->compile(m_stopAfter);
for (auto const& error: m_compiler->errors()) for (auto const& error: m_compiler->errors())
{ {
@ -1565,7 +1606,7 @@ void CommandLineInterface::handleCombinedJSON()
output[g_strSources] = Json::Value(Json::objectValue); output[g_strSources] = Json::Value(Json::objectValue);
for (auto const& sourceCode: m_sourceCodes) for (auto const& sourceCode: m_sourceCodes)
{ {
ASTJsonConverter converter(legacyFormat, m_compiler->sourceIndices()); ASTJsonConverter converter(legacyFormat, m_compiler->state(), m_compiler->sourceIndices());
output[g_strSources][sourceCode.first] = Json::Value(Json::objectValue); output[g_strSources][sourceCode.first] = Json::Value(Json::objectValue);
output[g_strSources][sourceCode.first]["AST"] = converter.toJson(m_compiler->ast(sourceCode.first)); output[g_strSources][sourceCode.first]["AST"] = converter.toJson(m_compiler->ast(sourceCode.first));
} }
@ -1617,7 +1658,7 @@ void CommandLineInterface::handleAst(string const& _argStr)
{ {
stringstream data; stringstream data;
string postfix = ""; string postfix = "";
ASTJsonConverter(legacyFormat, m_compiler->sourceIndices()).print(data, m_compiler->ast(sourceCode.first)); ASTJsonConverter(legacyFormat, m_compiler->state(), m_compiler->sourceIndices()).print(data, m_compiler->ast(sourceCode.first));
postfix += "_json"; postfix += "_json";
boost::filesystem::path path(sourceCode.first); boost::filesystem::path path(sourceCode.first);
createFile(path.filename().string() + postfix + ".ast", data.str()); createFile(path.filename().string() + postfix + ".ast", data.str());
@ -1629,7 +1670,7 @@ void CommandLineInterface::handleAst(string const& _argStr)
for (auto const& sourceCode: m_sourceCodes) for (auto const& sourceCode: m_sourceCodes)
{ {
sout() << endl << "======= " << sourceCode.first << " =======" << endl; sout() << endl << "======= " << sourceCode.first << " =======" << endl;
ASTJsonConverter(legacyFormat, m_compiler->sourceIndices()).print(sout(), m_compiler->ast(sourceCode.first)); ASTJsonConverter(legacyFormat, m_compiler->state(), m_compiler->sourceIndices()).print(sout(), m_compiler->ast(sourceCode.first));
} }
} }
} }
@ -1871,7 +1912,10 @@ void CommandLineInterface::outputCompilationResults()
handleAst(g_argAstJson); handleAst(g_argAstJson);
handleAst(g_argAstCompactJson); handleAst(g_argAstCompactJson);
if (!m_compiler->compilationSuccessful()) if (
!m_compiler->compilationSuccessful() &&
m_stopAfter == CompilerStack::State::CompilationSuccessful
)
{ {
serr() << endl << "Compilation halted after AST generation due to errors." << endl; serr() << endl << "Compilation halted after AST generation due to errors." << endl;
return; return;

1
solc/CommandLineInterface.h
View File

@ -127,6 +127,7 @@ private:
std::map<std::string, util::h160> m_libraries; std::map<std::string, util::h160> m_libraries;
/// Solidity compiler stack /// Solidity compiler stack
std::unique_ptr<frontend::CompilerStack> m_compiler; std::unique_ptr<frontend::CompilerStack> m_compiler;
CompilerStack::State m_stopAfter = CompilerStack::State::CompilationSuccessful;
/// EVM version to use /// EVM version to use
langutil::EVMVersion m_evmVersion; langutil::EVMVersion m_evmVersion;
/// How to handle revert strings /// How to handle revert strings

3
test/cmdlineTests.sh
View File

@ -439,6 +439,9 @@ SOLTMPDIR=$(mktemp -d)
) )
rm -rf "$SOLTMPDIR" rm -rf "$SOLTMPDIR"
printTask "Testing AST export with stop-after=parsing..."
"$REPO_ROOT/test/stopAfterParseTests.sh"
printTask "Testing soljson via the fuzzer..." printTask "Testing soljson via the fuzzer..."
SOLTMPDIR=$(mktemp -d) SOLTMPDIR=$(mktemp -d)
( (

2
test/cmdlineTests/standard_empty_file_name/output.json
View File

@ -1,4 +1,4 @@
{"errors":[{"component":"general","errorCode":"2904","formattedMessage":":2:24: DeclarationError: Declaration \"A\" not found in \"\" (referenced as \".\"). {"errors":[{"component":"general","errorCode":"2904","formattedMessage":":2:24: DeclarationError: Declaration \"A\" not found in \"\" (referenced as \".\").
pragma solidity >=0.0; import {A} from \".\"; pragma solidity >=0.0; import {A} from \".\";
^------------------^ ^------------------^
","message":"Declaration \"A\" not found in \"\" (referenced as \".\").","severity":"error","type":"DeclarationError"}],"sources":{}} ","message":"Declaration \"A\" not found in \"\" (referenced as \".\").","severity":"error","type":"DeclarationError"}],"sources":{"":{"id":0}}}

54
test/libsolidity/ASTJSON/abstract_contract_parseOnly.json Normal file
View File

@ -0,0 +1,54 @@
{
"absolutePath": "a",
"id": 6,
"nodeType": "SourceUnit",
"nodes":
[
{
"abstract": true,
"baseContracts": [],
"contractDependencies": [],
"contractKind": "contract",
"id": 5,
"name": "C",
"nodeType": "ContractDefinition",
"nodes":
[
{
"body":
{
"id": 3,
"nodeType": "Block",
"src": "37:4:1",
"statements": []
},
"id": 4,
"implemented": true,
"kind": "constructor",
"modifiers": [],
"name": "",
"nodeType": "FunctionDefinition",
"parameters":
{
"id": 1,
"nodeType": "ParameterList",
"parameters": [],
"src": "34:2:1"
},
"returnParameters":
{
"id": 2,
"nodeType": "ParameterList",
"parameters": [],
"src": "37:0:1"
},
"src": "23:18:1",
"stateMutability": "nonpayable",
"virtual": false
}
],
"src": "0:43:1"
}
],
"src": "0:44:1"
}

370
test/libsolidity/ASTJSON/address_payable_parseOnly.json Normal file
View File

@ -0,0 +1,370 @@
{
"absolutePath": "a",
"id": 40,
"nodeType": "SourceUnit",
"nodes":
[
{
"abstract": false,
"baseContracts": [],
"contractDependencies": [],
"contractKind": "contract",
"id": 39,
"name": "C",
"nodeType": "ContractDefinition",
"nodes":
[
{
"constant": false,
"id": 4,
"mutability": "mutable",
"name": "m",
"nodeType": "VariableDeclaration",
"src": "17:44:1",
"stateVariable": false,
"storageLocation": "default",
"typeDescriptions": {},
"typeName":
{
"id": 3,
"keyType":
{
"id": 1,
"name": "address",
"nodeType": "ElementaryTypeName",
"src": "25:7:1",
"typeDescriptions": {}
},
"nodeType": "Mapping",
"src": "17:35:1",
"typeDescriptions": {},
"valueType":
{
"id": 2,
"name": "address",
"nodeType": "ElementaryTypeName",
"src": "36:15:1",
"stateMutability": "payable",
"typeDescriptions": {}
}
},
"visibility": "public"
},
{
"body":
{
"id": 37,
"nodeType": "Block",
"src": "134:122:1",
"statements":
[
{
"assignments":
[
12
],
"declarations":
[
{
"constant": false,
"id": 12,
"mutability": "mutable",
"name": "a",
"nodeType": "VariableDeclaration",
"src": "144:17:1",
"stateVariable": false,
"storageLocation": "default",
"typeDescriptions": {},
"typeName":
{
"id": 11,
"name": "address",
"nodeType": "ElementaryTypeName",
"src": "144:15:1",
"stateMutability": "payable",
"typeDescriptions": {}
},
"visibility": "internal"
}
],
"id": 16,
"initialValue":
{
"baseExpression":
{
"id": 13,
"name": "m",
"nodeType": "Identifier",
"overloadedDeclarations": [],
"src": "164:1:1",
"typeDescriptions": {}
},
"id": 15,
"indexExpression":
{
"id": 14,
"name": "arg",
"nodeType": "Identifier",
"overloadedDeclarations": [],
"src": "166:3:1",
"typeDescriptions": {}
},
"nodeType": "IndexAccess",
"src": "164:6:1",
"typeDescriptions": {}
},
"nodeType": "VariableDeclarationStatement",
"src": "144:26:1"
},
{
"expression":
{
"id": 19,
"leftHandSide":
{
"id": 17,
"name": "r",
"nodeType": "Identifier",
"overloadedDeclarations": [],
"src": "180:1:1",
"typeDescriptions": {}
},
"nodeType": "Assignment",
"operator": "=",
"rightHandSide":
{
"id": 18,
"name": "arg",
"nodeType": "Identifier",
"overloadedDeclarations": [],
"src": "184:3:1",
"typeDescriptions": {}
},
"src": "180:7:1",
"typeDescriptions": {}
},
"id": 20,
"nodeType": "ExpressionStatement",
"src": "180:7:1"
},
{
"assignments":
[
22
],
"declarations":
[
{
"constant": false,
"id": 22,
"mutability": "mutable",
"name": "c",
"nodeType": "VariableDeclaration",
"src": "197:9:1",
"stateVariable": false,
"storageLocation": "default",
"typeDescriptions": {},
"typeName":
{
"id": 21,
"name": "address",
"nodeType": "ElementaryTypeName",
"src": "197:7:1",
"stateMutability": "nonpayable",
"typeDescriptions": {}
},
"visibility": "internal"
}
],
"id": 27,
"initialValue":
{
"arguments":
[
{
"id": 25,
"name": "this",
"nodeType": "Identifier",
"overloadedDeclarations": [],
"src": "217:4:1",
"typeDescriptions": {}
}
],
"expression":
{
"id": 24,
"nodeType": "ElementaryTypeNameExpression",
"src": "209:7:1",
"typeDescriptions": {},
"typeName":
{
"id": 23,
"name": "address",
"nodeType": "ElementaryTypeName",
"src": "209:7:1",
"typeDescriptions": {}
}
},
"id": 26,
"names": [],
"nodeType": "FunctionCall",
"src": "209:13:1",
"tryCall": false,
"typeDescriptions": {}
},
"nodeType": "VariableDeclarationStatement",
"src": "197:25:1"
},
{
"expression":
{
"id": 35,
"leftHandSide":
{
"baseExpression":
{
"id": 28,
"name": "m",
"nodeType": "Identifier",
"overloadedDeclarations": [],
"src": "232:1:1",
"typeDescriptions": {}
},
"id": 30,
"indexExpression":
{
"id": 29,
"name": "c",
"nodeType": "Identifier",
"overloadedDeclarations": [],
"src": "234:1:1",
"typeDescriptions": {}
},
"nodeType": "IndexAccess",
"src": "232:4:1",
"typeDescriptions": {}
},
"nodeType": "Assignment",
"operator": "=",
"rightHandSide":
{
"arguments":
[
{
"hexValue": "30",
"id": 33,
"kind": "number",
"nodeType": "Literal",
"src": "247:1:1",
"typeDescriptions": {},
"value": "0"
}
],
"expression":
{
"id": 32,
"nodeType": "ElementaryTypeNameExpression",
"src": "239:7:1",
"typeDescriptions": {},
"typeName":
{
"id": 31,
"name": "address",
"nodeType": "ElementaryTypeName",
"src": "239:7:1",
"typeDescriptions": {}
}
},
"id": 34,
"names": [],
"nodeType": "FunctionCall",
"src": "239:10:1",
"tryCall": false,
"typeDescriptions": {}
},
"src": "232:17:1",
"typeDescriptions": {}
},
"id": 36,
"nodeType": "ExpressionStatement",
"src": "232:17:1"
}
]
},
"id": 38,
"implemented": true,
"kind": "function",
"modifiers": [],
"name": "f",
"nodeType": "FunctionDefinition",
"parameters":
{
"id": 7,
"nodeType": "ParameterList",
"parameters":
[
{
"constant": false,
"id": 6,
"mutability": "mutable",
"name": "arg",
"nodeType": "VariableDeclaration",
"src": "78:19:1",
"stateVariable": false,
"storageLocation": "default",
"typeDescriptions": {},
"typeName":
{
"id": 5,
"name": "address",
"nodeType": "ElementaryTypeName",
"src": "78:15:1",
"stateMutability": "payable",
"typeDescriptions": {}
},
"visibility": "internal"
}
],
"src": "77:21:1"
},
"returnParameters":
{
"id": 10,
"nodeType": "ParameterList",
"parameters":
[
{
"constant": false,
"id": 9,
"mutability": "mutable",
"name": "r",
"nodeType": "VariableDeclaration",
"src": "115:17:1",
"stateVariable": false,
"storageLocation": "default",
"typeDescriptions": {},
"typeName":
{
"id": 8,
"name": "address",
"nodeType": "ElementaryTypeName",
"src": "115:15:1",
"stateMutability": "payable",
"typeDescriptions": {}
},
"visibility": "internal"
}
],
"src": "114:19:1"
},
"src": "67:189:1",
"stateMutability": "nonpayable",
"virtual": false,
"visibility": "public"
}
],
"src": "0:258:1"
}
],
"src": "0:259:1"
}

49
test/libsolidity/ASTJSON/array_type_name_parseOnly.json Normal file
View File

@ -0,0 +1,49 @@
{
"absolutePath": "a",
"id": 5,
"nodeType": "SourceUnit",
"nodes":
[
{
"abstract": false,
"baseContracts": [],
"contractDependencies": [],
"contractKind": "contract",
"id": 4,
"name": "C",
"nodeType": "ContractDefinition",
"nodes":
[
{
"constant": false,
"id": 3,
"mutability": "mutable",
"name": "i",
"nodeType": "VariableDeclaration",
"src": "13:8:1",
"stateVariable": false,
"storageLocation": "default",
"typeDescriptions": {},
"typeName":
{
"baseType":
{
"id": 1,
"name": "uint",
"nodeType": "ElementaryTypeName",
"src": "13:4:1",
"typeDescriptions": {}
},
"id": 2,
"nodeType": "ArrayTypeName",
"src": "13:6:1",
"typeDescriptions": {}
},
"visibility": "internal"
}
],
"src": "0:24:1"
}
],
"src": "0:25:1"
}

152
test/libsolidity/ASTJSON/assembly/call_parseOnly.json Normal file
View File

@ -0,0 +1,152 @@
{
"absolutePath": "a",
"id": 7,
"nodeType": "SourceUnit",
"nodes":
[
{
"abstract": false,
"baseContracts": [],
"contractDependencies": [],
"contractKind": "contract",
"id": 6,
"name": "C",
"nodeType": "ContractDefinition",
"nodes":
[
{
"body":
{
"id": 4,
"nodeType": "Block",
"src": "37:59:1",
"statements":
[
{
"AST":
{
"nodeType": "YulBlock",
"src": "56:34:1",
"statements":
[
{
"expression":
{
"arguments":
[
{
"arguments":
[
{
"kind": "number",
"nodeType": "YulLiteral",
"src": "67:1:1",
"type": "",
"value": "0"
},
{
"kind": "number",
"nodeType": "YulLiteral",
"src": "70:1:1",
"type": "",
"value": "1"
},
{
"kind": "number",
"nodeType": "YulLiteral",
"src": "73:1:1",
"type": "",
"value": "2"
},
{
"kind": "number",
"nodeType": "YulLiteral",
"src": "76:1:1",
"type": "",
"value": "3"
},
{
"kind": "number",
"nodeType": "YulLiteral",
"src": "79:1:1",
"type": "",
"value": "4"
},
{
"kind": "number",
"nodeType": "YulLiteral",
"src": "82:1:1",
"type": "",
"value": "5"
},
{
"kind": "number",
"nodeType": "YulLiteral",
"src": "85:1:1",
"type": "",
"value": "6"
}
],
"functionName":
{
"name": "call",
"nodeType": "YulIdentifier",
"src": "62:4:1"
},
"nodeType": "YulFunctionCall",
"src": "62:25:1"
}
],
"functionName":
{
"name": "pop",
"nodeType": "YulIdentifier",
"src": "58:3:1"
},
"nodeType": "YulFunctionCall",
"src": "58:30:1"
},
"nodeType": "YulExpressionStatement",
"src": "58:30:1"
}
]
},
"evmVersion": %EVMVERSION%,
"externalReferences": [],
"id": 3,
"nodeType": "InlineAssembly",
"src": "47:43:1"
}
]
},
"id": 5,
"implemented": true,
"kind": "function",
"modifiers": [],
"name": "j",
"nodeType": "FunctionDefinition",
"parameters":
{
"id": 1,
"nodeType": "ParameterList",
"parameters": [],
"src": "27:2:1"
},
"returnParameters":
{
"id": 2,
"nodeType": "ParameterList",
"parameters": [],
"src": "37:0:1"
},
"src": "17:79:1",
"stateMutability": "nonpayable",
"virtual": false,
"visibility": "public"
}
],
"src": "0:98:1"
}
],
"src": "0:99:1"
}

77
test/libsolidity/ASTJSON/assembly/empty_block_parseOnly.json Normal file
View File

@ -0,0 +1,77 @@
{
"absolutePath": "a",
"id": 7,
"nodeType": "SourceUnit",
"nodes":
[
{
"abstract": false,
"baseContracts": [],
"contractDependencies": [],
"contractKind": "contract",
"id": 6,
"name": "C",
"nodeType": "ContractDefinition",
"nodes":
[
{
"body":
{
"id": 4,
"nodeType": "Block",
"src": "42:31:1",
"statements":
[
{
"AST":
{
"nodeType": "YulBlock",
"src": "61:6:1",
"statements":
[
{
"nodeType": "YulBlock",
"src": "63:2:1",
"statements": []
}
]
},
"evmVersion": %EVMVERSION%,
"externalReferences": [],
"id": 3,
"nodeType": "InlineAssembly",
"src": "52:15:1"
}
]
},
"id": 5,
"implemented": true,
"kind": "function",
"modifiers": [],
"name": "g",
"nodeType": "FunctionDefinition",
"parameters":
{
"id": 1,
"nodeType": "ParameterList",
"parameters": [],
"src": "27:2:1"
},
"returnParameters":
{
"id": 2,
"nodeType": "ParameterList",
"parameters": [],
"src": "42:0:1"
},
"src": "17:56:1",
"stateMutability": "view",
"virtual": false,
"visibility": "public"
}
],
"src": "0:75:1"
}
],
"src": "0:76:1"
}

139
test/libsolidity/ASTJSON/assembly/function_parseOnly.json Normal file
View File

@ -0,0 +1,139 @@
{
"absolutePath": "a",
"id": 7,
"nodeType": "SourceUnit",
"nodes":
[
{
"abstract": false,
"baseContracts": [],
"contractDependencies": [],
"contractKind": "contract",
"id": 6,
"name": "C",
"nodeType": "ContractDefinition",
"nodes":
[
{
"body":
{
"id": 4,
"nodeType": "Block",
"src": "42:68:1",
"statements":
[
{
"AST":
{
"nodeType": "YulBlock",
"src": "61:43:1",
"statements":
[
{
"body":
{
"nodeType": "YulBlock",
"src": "76:22:1",
"statements":
[
{
"expression":
{
"arguments":
[
{
"arguments":
[
{
"kind": "number",
"nodeType": "YulLiteral",
"src": "92:2:1",
"type": "",
"value": "20"
}
],
"functionName":
{
"name": "blockhash",
"nodeType": "YulIdentifier",
"src": "82:9:1"
},
"nodeType": "YulFunctionCall",
"src": "82:13:1"
}
],
"functionName":
{
"name": "pop",
"nodeType": "YulIdentifier",
"src": "78:3:1"
},
"nodeType": "YulFunctionCall",
"src": "78:18:1"
},
"nodeType": "YulExpressionStatement",
"src": "78:18:1"
}
]
},
"name": "g",
"nodeType": "YulFunctionDefinition",
"src": "63:35:1"
},
{
"expression":
{
"arguments": [],
"functionName":
{
"name": "g",
"nodeType": "YulIdentifier",
"src": "99:1:1"
},
"nodeType": "YulFunctionCall",
"src": "99:3:1"
},
"nodeType": "YulExpressionStatement",
"src": "99:3:1"
}
]
},
"evmVersion": %EVMVERSION%,
"externalReferences": [],
"id": 3,
"nodeType": "InlineAssembly",
"src": "52:52:1"
}
]
},
"id": 5,
"implemented": true,
"kind": "function",
"modifiers": [],
"name": "h",
"nodeType": "FunctionDefinition",
"parameters":
{
"id": 1,
"nodeType": "ParameterList",
"parameters": [],
"src": "27:2:1"
},
"returnParameters":
{
"id": 2,
"nodeType": "ParameterList",
"parameters": [],
"src": "42:0:1"
},
"src": "17:93:1",
"stateMutability": "view",
"virtual": false,
"visibility": "public"
}
],
"src": "0:112:1"
}
],
"src": "0:113:1"
}

89
test/libsolidity/ASTJSON/assembly/leave_parseOnly.json Normal file
View File

@ -0,0 +1,89 @@
{
"absolutePath": "a",
"id": 7,
"nodeType": "SourceUnit",
"nodes":
[
{
"abstract": false,
"baseContracts": [],
"contractDependencies": [],
"contractKind": "contract",
"id": 6,
"name": "C",
"nodeType": "ContractDefinition",
"nodes":
[
{
"body":
{
"id": 4,
"nodeType": "Block",
"src": "37:51:1",
"statements":
[
{
"AST":
{
"nodeType": "YulBlock",
"src": "56:26:1",
"statements":
[
{
"body":
{
"nodeType": "YulBlock",
"src": "71:9:1",
"statements":
[
{
"nodeType": "YulLeave",
"src": "73:5:1"
}
]
},
"name": "f",
"nodeType": "YulFunctionDefinition",
"src": "58:22:1"
}
]
},
"evmVersion": %EVMVERSION%,
"externalReferences": [],
"id": 3,
"nodeType": "InlineAssembly",
"src": "47:35:1"
}
]
},
"id": 5,
"implemented": true,
"kind": "function",
"modifiers": [],
"name": "l",
"nodeType": "FunctionDefinition",
"parameters":
{
"id": 1,
"nodeType": "ParameterList",
"parameters": [],
"src": "27:2:1"
},
"returnParameters":
{
"id": 2,
"nodeType": "ParameterList",
"parameters": [],
"src": "37:0:1"
},
"src": "17:71:1",
"stateMutability": "nonpayable",
"virtual": false,
"visibility": "public"
}
],
"src": "0:90:1"
}
],
"src": "0:91:1"
}

152
test/libsolidity/ASTJSON/assembly/loop_parseOnly.json Normal file
View File

@ -0,0 +1,152 @@
{
"absolutePath": "a",
"id": 7,
"nodeType": "SourceUnit",
"nodes":
[
{
"abstract": false,
"baseContracts": [],
"contractDependencies": [],
"contractKind": "contract",
"id": 6,
"name": "C",
"nodeType": "ContractDefinition",
"nodes":
[
{
"body":
{
"id": 4,
"nodeType": "Block",
"src": "42:74:1",
"statements":
[
{
"AST":
{
"nodeType": "YulBlock",
"src": "61:49:1",
"statements":
[
{
"body":
{
"nodeType": "YulBlock",
"src": "90:18:1",
"statements":
[
{
"nodeType": "YulBreak",
"src": "92:5:1"
},
{
"nodeType": "YulContinue",
"src": "98:8:1"
}
]
},
"condition":
{
"kind": "number",
"nodeType": "YulLiteral",
"src": "70:1:1",
"type": "",
"value": "1"
},
"nodeType": "YulForLoop",
"post":
{
"nodeType": "YulBlock",
"src": "72:17:1",
"statements":
[
{
"expression":
{
"arguments":
[
{
"arguments":
[
{
"kind": "number",
"nodeType": "YulLiteral",
"src": "84:1:1",
"type": "",
"value": "0"
}
],
"functionName":
{
"name": "sload",
"nodeType": "YulIdentifier",
"src": "78:5:1"
},
"nodeType": "YulFunctionCall",
"src": "78:8:1"
}
],
"functionName":
{
"name": "pop",
"nodeType": "YulIdentifier",
"src": "74:3:1"
},
"nodeType": "YulFunctionCall",
"src": "74:13:1"
},
"nodeType": "YulExpressionStatement",
"src": "74:13:1"
}
]
},
"pre":
{
"nodeType": "YulBlock",
"src": "67:2:1",
"statements": []
},
"src": "63:45:1"
}
]
},
"evmVersion": %EVMVERSION%,
"externalReferences": [],
"id": 3,
"nodeType": "InlineAssembly",
"src": "52:58:1"
}
]
},
"id": 5,
"implemented": true,
"kind": "function",
"modifiers": [],
"name": "g",
"nodeType": "FunctionDefinition",
"parameters":
{
"id": 1,
"nodeType": "ParameterList",
"parameters": [],
"src": "27:2:1"
},
"returnParameters":
{
"id": 2,
"nodeType": "ParameterList",
"parameters": [],
"src": "42:0:1"
},
"src": "17:99:1",
"stateMutability": "view",
"virtual": false,
"visibility": "public"
}
],
"src": "0:118:1"
}
],
"src": "0:119:1"
}

1
test/libsolidity/ASTJSON/assembly/nested_functions.json
View File

@ -94,7 +94,6 @@
} }
] ]
}, },
"functionSelector": "26121ff0",
"id": 7, "id": 7,
"implemented": true, "implemented": true,
"kind": "function", "kind": "function",

1
test/libsolidity/ASTJSON/assembly/nested_functions_legacy.json
View File

@ -37,7 +37,6 @@
{ {
"attributes": "attributes":
{ {
"functionSelector": "26121ff0",
"implemented": true, "implemented": true,
"isConstructor": false, "isConstructor": false,
"kind": "function", "kind": "function",

138
test/libsolidity/ASTJSON/assembly/nested_functions_parseOnly.json Normal file
View File

@ -0,0 +1,138 @@
{
"absolutePath": "a",
"id": 9,
"nodeType": "SourceUnit",
"nodes":
[
{
"abstract": false,
"baseContracts": [],
"contractDependencies": [],
"contractKind": "contract",
"id": 8,
"name": "C",
"nodeType": "ContractDefinition",
"nodes":
[
{
"body":
{
"id": 6,
"nodeType": "Block",
"src": "57:97:1",
"statements":
[
{
"AST":
{
"nodeType": "YulBlock",
"src": "72:78:1",
"statements":
[
{
"body":
{
"nodeType": "YulBlock",
"src": "94:50:1",
"statements":
[
{
"body":
{
"nodeType": "YulBlock",
"src": "118:3:1",
"statements": []
},
"name": "f2",
"nodeType": "YulFunctionDefinition",
"src": "104:17:1"
},
{
"nodeType": "YulAssignment",
"src": "130:6:1",
"value":
{
"kind": "number",
"nodeType": "YulLiteral",
"src": "135:1:1",
"type": "",
"value": "2"
},
"variableNames":
[
{
"name": "x",
"nodeType": "YulIdentifier",
"src": "130:1:1"
}
]
}
]
},
"name": "f1",
"nodeType": "YulFunctionDefinition",
"src": "80:64:1"
}
]
},
"evmVersion": %EVMVERSION%,
"externalReferences": [],
"id": 5,
"nodeType": "InlineAssembly",
"src": "63:87:1"
}
]
},
"id": 7,
"implemented": true,
"kind": "function",
"modifiers": [],
"name": "f",
"nodeType": "FunctionDefinition",
"parameters":
{
"id": 1,
"nodeType": "ParameterList",
"parameters": [],
"src": "25:2:1"
},
"returnParameters":
{
"id": 4,
"nodeType": "ParameterList",
"parameters":
[
{
"constant": false,
"id": 3,
"mutability": "mutable",
"name": "x",
"nodeType": "VariableDeclaration",
"src": "49:6:1",
"stateVariable": false,
"storageLocation": "default",
"typeDescriptions": {},
"typeName":
{
"id": 2,
"name": "uint",
"nodeType": "ElementaryTypeName",
"src": "49:4:1",
"typeDescriptions": {}
},
"visibility": "internal"
}
],
"src": "48:8:1"
},
"src": "15:139:1",
"stateMutability": "pure",
"virtual": false,
"visibility": "public"
}
],
"src": "0:156:1"
}
],
"src": "0:157:1"
}

180
test/libsolidity/ASTJSON/assembly/slot_offset_parseOnly.json Normal file
View File

@ -0,0 +1,180 @@
{
"absolutePath": "a",
"id": 12,
"nodeType": "SourceUnit",
"nodes":
[
{
"abstract": false,
"baseContracts": [],
"contractDependencies": [],
"contractKind": "contract",
"id": 11,
"name": "C",
"nodeType": "ContractDefinition",
"nodes":
[
{
"id": 3,
"members":
[
{
"constant": false,
"id": 2,
"mutability": "mutable",
"name": "x",
"nodeType": "VariableDeclaration",
"src": "28:6:1",
"stateVariable": false,
"storageLocation": "default",
"typeDescriptions": {},
"typeName":
{
"id": 1,
"name": "uint",
"nodeType": "ElementaryTypeName",
"src": "28:4:1",
"typeDescriptions": {}
},
"visibility": "internal"
}
],
"name": "S",
"nodeType": "StructDefinition",
"src": "17:20:1",
"visibility": "public"
},
{
"constant": false,
"id": 5,
"mutability": "mutable",
"name": "s",
"nodeType": "VariableDeclaration",
"src": "42:3:1",
"stateVariable": false,
"storageLocation": "default",
"typeDescriptions": {},
"typeName":
{
"id": 4,
"name": "S",
"nodeType": "UserDefinedTypeName",
"src": "42:1:1",
"typeDescriptions": {}
},
"visibility": "internal"
},
{
"body":
{
"id": 9,
"nodeType": "Block",
"src": "76:70:1",
"statements":
[
{
"AST":
{
"nodeType": "YulBlock",
"src": "95:45:1",
"statements":
[
{
"nodeType": "YulVariableDeclaration",
"src": "97:17:1",
"value":
{
"name": "s.offset",
"nodeType": "YulIdentifier",
"src": "106:8:1"
},
"variables":
[
{
"name": "x",
"nodeType": "YulTypedName",
"src": "101:1:1",
"type": ""
}
]
},
{
"nodeType": "YulVariableDeclaration",
"src": "115:23:1",
"value":
{
"arguments":
[
{
"name": "s.slot",
"nodeType": "YulIdentifier",
"src": "128:6:1"
},
{
"kind": "number",
"nodeType": "YulLiteral",
"src": "136:1:1",
"type": "",
"value": "2"
}
],
"functionName":
{
"name": "mul",
"nodeType": "YulIdentifier",
"src": "124:3:1"
},
"nodeType": "YulFunctionCall",
"src": "124:14:1"
},
"variables":
[
{
"name": "y",
"nodeType": "YulTypedName",
"src": "119:1:1",
"type": ""
}
]
}
]
},
"evmVersion": %EVMVERSION%,
"externalReferences": [],
"id": 8,
"nodeType": "InlineAssembly",
"src": "86:54:1"
}
]
},
"id": 10,
"implemented": true,
"kind": "function",
"modifiers": [],
"name": "e",
"nodeType": "FunctionDefinition",
"parameters":
{
"id": 6,
"nodeType": "ParameterList",
"parameters": [],
"src": "61:2:1"
},
"returnParameters":
{
"id": 7,
"nodeType": "ParameterList",
"parameters": [],
"src": "76:0:1"
},
"src": "51:95:1",
"stateMutability": "pure",
"virtual": false,
"visibility": "public"
}
],
"src": "0:148:1"
}
],
"src": "0:149:1"
}

93
test/libsolidity/ASTJSON/assembly/stringlit_parseOnly.json Normal file
View File

@ -0,0 +1,93 @@
{
"absolutePath": "a",
"id": 7,
"nodeType": "SourceUnit",
"nodes":
[
{
"abstract": false,
"baseContracts": [],
"contractDependencies": [],
"contractKind": "contract",
"id": 6,
"name": "C",
"nodeType": "ContractDefinition",
"nodes":
[
{
"body":
{
"id": 4,
"nodeType": "Block",
"src": "37:43:1",
"statements":
[
{
"AST":
{
"nodeType": "YulBlock",
"src": "56:18:1",
"statements":
[
{
"nodeType": "YulVariableDeclaration",
"src": "58:14:1",
"value":
{
"kind": "string",
"nodeType": "YulLiteral",
"src": "67:5:1",
"type": "",
"value": "abc"
},
"variables":
[
{
"name": "x",
"nodeType": "YulTypedName",
"src": "62:1:1",
"type": ""
}
]
}
]
},
"evmVersion": %EVMVERSION%,
"externalReferences": [],
"id": 3,
"nodeType": "InlineAssembly",
"src": "47:27:1"
}
]
},
"id": 5,
"implemented": true,
"kind": "function",
"modifiers": [],
"name": "m",
"nodeType": "FunctionDefinition",
"parameters":
{
"id": 1,
"nodeType": "ParameterList",
"parameters": [],
"src": "27:2:1"
},
"returnParameters":
{
"id": 2,
"nodeType": "ParameterList",
"parameters": [],
"src": "37:0:1"
},
"src": "17:63:1",
"stateMutability": "nonpayable",
"virtual": false,
"visibility": "public"
}
],
"src": "0:82:1"
}
],
"src": "0:83:1"
}

1
test/libsolidity/ASTJSON/assembly/switch.json
View File

@ -179,7 +179,6 @@
} }
] ]
}, },
"functionSelector": "26121ff0",
"id": 5, "id": 5,
"implemented": true, "implemented": true,
"kind": "function", "kind": "function",

116
test/libsolidity/ASTJSON/assembly/switch_default_parseOnly.json Normal file
View File

@ -0,0 +1,116 @@
{
"absolutePath": "a",
"id": 7,
"nodeType": "SourceUnit",
"nodes":
[
{
"abstract": false,
"baseContracts": [],
"contractDependencies": [],
"contractKind": "contract",
"id": 6,
"name": "C",
"nodeType": "ContractDefinition",
"nodes":
[
{
"body":
{
"id": 4,
"nodeType": "Block",
"src": "42:58:1",
"statements":
[
{
"AST":
{
"nodeType": "YulBlock",
"src": "61:33:1",
"statements":
[
{
"cases":
[
{
"body":
{
"nodeType": "YulBlock",
"src": "79:2:1",
"statements": []
},
"nodeType": "YulCase",
"src": "72:9:1",
"value":
{
"kind": "number",
"nodeType": "YulLiteral",
"src": "77:1:1",
"type": "",
"value": "0"
}
},
{
"body":
{
"nodeType": "YulBlock",
"src": "90:2:1",
"statements": []
},
"nodeType": "YulCase",
"src": "82:10:1",
"value": "default"
}
],
"expression":
{
"kind": "number",
"nodeType": "YulLiteral",
"src": "70:1:1",
"type": "",
"value": "0"
},
"nodeType": "YulSwitch",
"src": "63:29:1"
}
]
},
"evmVersion": %EVMVERSION%,
"externalReferences": [],
"id": 3,
"nodeType": "InlineAssembly",
"src": "52:42:1"
}
]
},
"id": 5,
"implemented": true,
"kind": "function",
"modifiers": [],
"name": "g",
"nodeType": "FunctionDefinition",
"parameters":
{
"id": 1,
"nodeType": "ParameterList",
"parameters": [],
"src": "27:2:1"
},
"returnParameters":
{
"id": 2,
"nodeType": "ParameterList",
"parameters": [],
"src": "42:0:1"
},
"src": "17:83:1",
"stateMutability": "view",
"virtual": false,
"visibility": "public"
}
],
"src": "0:102:1"
}
],
"src": "0:103:1"
}

1
test/libsolidity/ASTJSON/assembly/switch_legacy.json
View File

@ -37,7 +37,6 @@
{ {
"attributes": "attributes":
{ {
"functionSelector": "26121ff0",
"implemented": true, "implemented": true,
"isConstructor": false, "isConstructor": false,
"kind": "function", "kind": "function",

185
test/libsolidity/ASTJSON/assembly/switch_parseOnly.json Normal file
View File

@ -0,0 +1,185 @@
{
"absolutePath": "a",
"id": 7,
"nodeType": "SourceUnit",
"nodes":
[
{
"abstract": false,
"baseContracts": [],
"contractDependencies": [],
"contractKind": "contract",
"id": 6,
"name": "C",
"nodeType": "ContractDefinition",
"nodes":
[
{
"body":
{
"id": 4,
"nodeType": "Block",
"src": "42:154:1",
"statements":
[
{
"AST":
{
"nodeType": "YulBlock",
"src": "61:129:1",
"statements":
[
{
"nodeType": "YulVariableDeclaration",
"src": "75:10:1",
"value":
{
"kind": "number",
"nodeType": "YulLiteral",
"src": "84:1:1",
"type": "",
"value": "0"
},
"variables":
[
{
"name": "f",
"nodeType": "YulTypedName",
"src": "79:1:1",
"type": ""
}
]
},
{
"cases":
[
{
"body":
{
"nodeType": "YulBlock",
"src": "139:10:1",
"statements":
[
{
"nodeType": "YulAssignment",
"src": "141:6:1",
"value":
{
"kind": "number",
"nodeType": "YulLiteral",
"src": "146:1:1",
"type": "",
"value": "1"
},
"variableNames":
[
{
"name": "f",
"nodeType": "YulIdentifier",
"src": "141:1:1"
}
]
}
]
},
"nodeType": "YulCase",
"src": "132:17:1",
"value":
{
"kind": "number",
"nodeType": "YulLiteral",
"src": "137:1:1",
"type": "",
"value": "0"
}
},
{
"body":
{
"nodeType": "YulBlock",
"src": "170:10:1",
"statements":
[
{
"nodeType": "YulAssignment",
"src": "172:6:1",
"value":
{
"kind": "number",
"nodeType": "YulLiteral",
"src": "177:1:1",
"type": "",
"value": "2"
},
"variableNames":
[
{
"name": "f",
"nodeType": "YulIdentifier",
"src": "172:1:1"
}
]
}
]
},
"nodeType": "YulCase",
"src": "162:18:1",
"value": "default"
}
],
"expression":
{
"arguments": [],
"functionName":
{
"name": "calldatasize",
"nodeType": "YulIdentifier",
"src": "105:12:1"
},
"nodeType": "YulFunctionCall",
"src": "105:14:1"
},
"nodeType": "YulSwitch",
"src": "98:82:1"
}
]
},
"evmVersion": %EVMVERSION%,
"externalReferences": [],
"id": 3,
"nodeType": "InlineAssembly",
"src": "52:138:1"
}
]
},
"id": 5,
"implemented": true,
"kind": "function",
"modifiers": [],
"name": "f",
"nodeType": "FunctionDefinition",
"parameters":
{
"id": 1,
"nodeType": "ParameterList",
"parameters": [],
"src": "27:2:1"
},
"returnParameters":
{
"id": 2,
"nodeType": "ParameterList",
"parameters": [],
"src": "42:0:1"
},
"src": "17:179:1",
"stateMutability": "pure",
"virtual": false,
"visibility": "public"
}
],
"src": "0:198:1"
}
],
"src": "0:199:1"
}

124
test/libsolidity/ASTJSON/assembly/var_access_parseOnly.json Normal file
View File

@ -0,0 +1,124 @@
{
"absolutePath": "a",
"id": 10,
"nodeType": "SourceUnit",
"nodes":
[
{
"abstract": false,
"baseContracts": [],
"contractDependencies": [],
"contractKind": "contract",
"id": 9,
"name": "C",
"nodeType": "ContractDefinition",
"nodes":
[
{
"body":
{
"id": 7,
"nodeType": "Block",
"src": "42:51:1",
"statements":
[
{
"assignments":
[
4
],
"declarations":
[
{
"constant": false,
"id": 4,
"mutability": "mutable",
"name": "x",
"nodeType": "VariableDeclaration",
"src": "52:6:1",
"stateVariable": false,
"storageLocation": "default",
"typeDescriptions": {},
"typeName":
{
"id": 3,
"name": "uint",
"nodeType": "ElementaryTypeName",
"src": "52:4:1",
"typeDescriptions": {}
},
"visibility": "internal"
}
],
"id": 5,
"nodeType": "VariableDeclarationStatement",
"src": "52:6:1"
},
{
"AST":
{
"nodeType": "YulBlock",
"src": "77:10:1",
"statements":
[
{
"nodeType": "YulAssignment",
"src": "79:6:1",
"value":
{
"kind": "number",
"nodeType": "YulLiteral",
"src": "84:1:1",
"type": "",
"value": "7"
},
"variableNames":
[
{
"name": "x",
"nodeType": "YulIdentifier",
"src": "79:1:1"
}
]
}
]
},
"evmVersion": %EVMVERSION%,
"externalReferences": [],
"id": 6,
"nodeType": "InlineAssembly",
"src": "68:19:1"
}
]
},
"id": 8,
"implemented": true,
"kind": "function",
"modifiers": [],
"name": "f",
"nodeType": "FunctionDefinition",
"parameters":
{
"id": 1,
"nodeType": "ParameterList",
"parameters": [],
"src": "27:2:1"
},
"returnParameters":
{
"id": 2,
"nodeType": "ParameterList",
"parameters": [],
"src": "42:0:1"
},
"src": "17:76:1",
"stateMutability": "pure",
"virtual": false,
"visibility": "public"
}
],
"src": "0:95:1"
}
],
"src": "0:96:1"
}

54
test/libsolidity/ASTJSON/constructor_parseOnly.json Normal file
View File

@ -0,0 +1,54 @@
{
"absolutePath": "a",
"id": 6,
"nodeType": "SourceUnit",
"nodes":
[
{
"abstract": false,
"baseContracts": [],
"contractDependencies": [],
"contractKind": "contract",
"id": 5,
"name": "C",
"nodeType": "ContractDefinition",
"nodes":
[
{
"body":
{
"id": 3,
"nodeType": "Block",
"src": "28:4:1",
"statements": []
},
"id": 4,
"implemented": true,
"kind": "constructor",
"modifiers": [],
"name": "",
"nodeType": "FunctionDefinition",
"parameters":
{
"id": 1,
"nodeType": "ParameterList",
"parameters": [],
"src": "25:2:1"
},
"returnParameters":
{
"id": 2,
"nodeType": "ParameterList",
"parameters": [],
"src": "28:0:1"
},
"src": "14:18:1",
"stateMutability": "nonpayable",
"virtual": false
}
],
"src": "0:34:1"
}
],
"src": "0:35:1"
}

124
test/libsolidity/ASTJSON/contract_dep_order_parseOnly.json Normal file
View File

@ -0,0 +1,124 @@
{
"absolutePath": "a",
"id": 14,
"nodeType": "SourceUnit",
"nodes":
[
{
"abstract": false,
"baseContracts": [],
"contractDependencies": [],
"contractKind": "contract",
"id": 1,
"name": "A",
"nodeType": "ContractDefinition",
"nodes": [],
"src": "0:14:1"
},
{
"abstract": false,
"baseContracts":
[
{
"baseName":
{
"id": 2,
"name": "A",
"nodeType": "UserDefinedTypeName",
"src": "29:1:1",
"typeDescriptions": {}
},
"id": 3,
"nodeType": "InheritanceSpecifier",
"src": "29:1:1"
}
],
"contractDependencies": [],
"contractKind": "contract",
"id": 4,
"name": "B",
"nodeType": "ContractDefinition",
"nodes": [],
"src": "15:19:1"
},
{
"abstract": false,
"baseContracts":
[
{
"baseName":
{
"id": 5,
"name": "B",
"nodeType": "UserDefinedTypeName",
"src": "49:1:1",
"typeDescriptions": {}
},
"id": 6,
"nodeType": "InheritanceSpecifier",
"src": "49:1:1"
}
],
"contractDependencies": [],
"contractKind": "contract",
"id": 7,
"name": "C",
"nodeType": "ContractDefinition",
"nodes": [],
"src": "35:19:1"
},
{
"abstract": false,
"baseContracts":
[
{
"baseName":
{
"id": 8,
"name": "C",
"nodeType": "UserDefinedTypeName",
"src": "69:1:1",
"typeDescriptions": {}
},
"id": 9,
"nodeType": "InheritanceSpecifier",
"src": "69:1:1"
}
],
"contractDependencies": [],
"contractKind": "contract",
"id": 10,
"name": "D",
"nodeType": "ContractDefinition",
"nodes": [],
"src": "55:19:1"
},
{
"abstract": false,
"baseContracts":
[
{
"baseName":
{
"id": 11,
"name": "D",
"nodeType": "UserDefinedTypeName",
"src": "89:1:1",
"typeDescriptions": {}
},
"id": 12,
"nodeType": "InheritanceSpecifier",
"src": "89:1:1"
}
],
"contractDependencies": [],
"contractKind": "contract",
"id": 13,
"name": "E",
"nodeType": "ContractDefinition",
"nodes": [],
"src": "75:19:1"
}
],
"src": "0:95:1"
}

195
test/libsolidity/ASTJSON/documentation_parseOnly.json Normal file
View File

@ -0,0 +1,195 @@
[
{
"absolutePath": "a",
"id": 3,
"nodeType": "SourceUnit",
"nodes":
[
{
"abstract": false,
"baseContracts": [],
"contractDependencies": [],
"contractKind": "contract",
"documentation":
{
"id": 1,
"nodeType": "StructuredDocumentation",
"src": "0:27:1",
"text": "This contract is empty"
},
"id": 2,
"name": "C",
"nodeType": "ContractDefinition",
"nodes": [],
"src": "28:13:1"
}
],
"src": "28:14:1"
},
{
"absolutePath": "b",
"id": 6,
"nodeType": "SourceUnit",
"nodes":
[
{
"abstract": false,
"baseContracts": [],
"contractDependencies": [],
"contractKind": "contract",
"documentation":
{
"id": 4,
"nodeType": "StructuredDocumentation",
"src": "0:61:2",
"text": "This contract is empty\nand has a line-breaking comment."
},
"id": 5,
"name": "C",
"nodeType": "ContractDefinition",
"nodes": [],
"src": "62:13:2"
}
],
"src": "62:14:2"
},
{
"absolutePath": "c",
"id": 24,
"nodeType": "SourceUnit",
"nodes":
[
{
"abstract": false,
"baseContracts": [],
"contractDependencies": [],
"contractKind": "contract",
"id": 23,
"name": "C",
"nodeType": "ContractDefinition",
"nodes":
[
{
"constant": false,
"id": 9,
"mutability": "mutable",
"name": "state",
"nodeType": "VariableDeclaration",
"src": "48:17:3",
"stateVariable": false,
"storageLocation": "default",
"typeDescriptions": {},
"typeName":
{
"id": 8,
"name": "uint",
"nodeType": "ElementaryTypeName",
"src": "48:4:3",
"typeDescriptions": {}
},
"visibility": "public"
},
{
"anonymous": false,
"documentation":
{
"id": 10,
"nodeType": "StructuredDocumentation",
"src": "69:26:3",
"text": "Some comment on Evt."
},
"id": 12,
"name": "Evt",
"nodeType": "EventDefinition",
"parameters":
{
"id": 11,
"nodeType": "ParameterList",
"parameters": [],
"src": "105:2:3"
},
"src": "96:12:3"
},
{
"body":
{
"id": 16,
"nodeType": "Block",
"src": "153:6:3",
"statements":
[
{
"id": 15,
"nodeType": "PlaceholderStatement",
"src": "155:1:3"
}
]
},
"documentation":
{
"id": 13,
"nodeType": "StructuredDocumentation",
"src": "111:26:3",
"text": "Some comment on mod."
},
"id": 17,
"name": "mod",
"nodeType": "ModifierDefinition",
"parameters":
{
"id": 14,
"nodeType": "ParameterList",
"parameters": [],
"src": "150:2:3"
},
"src": "138:21:3",
"virtual": false,
"visibility": "internal"
},
{
"body":
{
"id": 21,
"nodeType": "Block",
"src": "209:2:3",
"statements": []
},
"documentation":
{
"id": 18,
"nodeType": "StructuredDocumentation",
"src": "162:25:3",
"text": "Some comment on fn."
},
"id": 22,
"implemented": true,
"kind": "function",
"modifiers": [],
"name": "fn",
"nodeType": "FunctionDefinition",
"parameters":
{
"id": 19,
"nodeType": "ParameterList",
"parameters": [],
"src": "199:2:3"
},
"returnParameters":
{
"id": 20,
"nodeType": "ParameterList",
"parameters": [],
"src": "209:0:3"
},
"src": "188:23:3",
"stateMutability": "nonpayable",
"virtual": false,
"visibility": "public"
}
],
"src": "0:213:3"
}
],
"src": "0:214:3"
}
]

43
test/libsolidity/ASTJSON/enum_value_parseOnly.json Normal file
View File

@ -0,0 +1,43 @@
{
"absolutePath": "a",
"id": 5,
"nodeType": "SourceUnit",
"nodes":
[
{
"abstract": false,
"baseContracts": [],
"contractDependencies": [],
"contractKind": "contract",
"id": 4,
"name": "C",
"nodeType": "ContractDefinition",
"nodes":
[
{
"id": 3,
"members":
[
{
"id": 1,
"name": "A",
"nodeType": "EnumValue",
"src": "22:1:1"
},
{
"id": 2,
"name": "B",
"nodeType": "EnumValue",
"src": "25:1:1"
}
],
"name": "E",
"nodeType": "EnumDefinition",
"src": "13:15:1"
}
],
"src": "0:30:1"
}
],
"src": "0:31:1"
}

36
test/libsolidity/ASTJSON/event_definition_parseOnly.json Normal file
View File

@ -0,0 +1,36 @@
{
"absolutePath": "a",
"id": 4,
"nodeType": "SourceUnit",
"nodes":
[
{
"abstract": false,
"baseContracts": [],
"contractDependencies": [],
"contractKind": "contract",
"id": 3,
"name": "C",
"nodeType": "ContractDefinition",
"nodes":
[
{
"anonymous": false,
"id": 2,
"name": "E",
"nodeType": "EventDefinition",
"parameters":
{
"id": 1,
"nodeType": "ParameterList",
"parameters": [],
"src": "20:2:1"
},
"src": "13:10:1"
}
],
"src": "0:25:1"
}
],
"src": "0:26:1"
}

88
test/libsolidity/ASTJSON/fallback_and_reveice_ether_parseOnly.json Normal file
View File

@ -0,0 +1,88 @@
{
"absolutePath": "a",
"id": 10,
"nodeType": "SourceUnit",
"nodes":
[
{
"abstract": false,
"baseContracts": [],
"contractDependencies": [],
"contractKind": "contract",
"id": 9,
"name": "C",
"nodeType": "ContractDefinition",
"nodes":
[
{
"body":
{
"id": 3,
"nodeType": "Block",
"src": "42:5:1",
"statements": []
},
"id": 4,
"implemented": true,
"kind": "receive",
"modifiers": [],
"name": "",
"nodeType": "FunctionDefinition",
"parameters":
{
"id": 1,
"nodeType": "ParameterList",
"parameters": [],
"src": "22:2:1"
},
"returnParameters":
{
"id": 2,
"nodeType": "ParameterList",
"parameters": [],
"src": "42:0:1"
},
"src": "15:32:1",
"stateMutability": "payable",
"virtual": false,
"visibility": "external"
},
{
"body":
{
"id": 7,
"nodeType": "Block",
"src": "78:5:1",
"statements": []
},
"id": 8,
"implemented": true,
"kind": "fallback",
"modifiers": [],
"name": "",
"nodeType": "FunctionDefinition",
"parameters":
{
"id": 5,
"nodeType": "ParameterList",
"parameters": [],
"src": "58:2:1"
},
"returnParameters":
{
"id": 6,
"nodeType": "ParameterList",
"parameters": [],
"src": "78:0:1"
},
"src": "50:33:1",
"stateMutability": "payable",
"virtual": false,
"visibility": "external"
}
],
"src": "0:85:1"
}
],
"src": "0:86:1"
}

55
test/libsolidity/ASTJSON/fallback_parseOnly.json Normal file
View File

@ -0,0 +1,55 @@
{
"absolutePath": "a",
"id": 6,
"nodeType": "SourceUnit",
"nodes":
[
{
"abstract": false,
"baseContracts": [],
"contractDependencies": [],
"contractKind": "contract",
"id": 5,
"name": "C",
"nodeType": "ContractDefinition",
"nodes":
[
{
"body":
{
"id": 3,
"nodeType": "Block",
"src": "43:5:1",
"statements": []
},
"id": 4,
"implemented": true,
"kind": "fallback",
"modifiers": [],
"name": "",
"nodeType": "FunctionDefinition",
"parameters":
{
"id": 1,
"nodeType": "ParameterList",
"parameters": [],
"src": "23:2:1"
},
"returnParameters":
{
"id": 2,
"nodeType": "ParameterList",
"parameters": [],
"src": "43:0:1"
},
"src": "15:33:1",
"stateMutability": "payable",
"virtual": false,
"visibility": "external"
}
],
"src": "0:50:1"
}
],
"src": "0:51:1"
}

55
test/libsolidity/ASTJSON/fallback_payable_parseOnly.json Normal file
View File

@ -0,0 +1,55 @@
{
"absolutePath": "a",
"id": 6,
"nodeType": "SourceUnit",
"nodes":
[
{
"abstract": false,
"baseContracts": [],
"contractDependencies": [],
"contractKind": "contract",
"id": 5,
"name": "C",
"nodeType": "ContractDefinition",
"nodes":
[
{
"body":
{
"id": 3,
"nodeType": "Block",
"src": "34:2:1",
"statements": []
},
"id": 4,
"implemented": true,
"kind": "fallback",
"modifiers": [],
"name": "",
"nodeType": "FunctionDefinition",
"parameters":
{
"id": 1,
"nodeType": "ParameterList",
"parameters": [],
"src": "22:2:1"
},
"returnParameters":
{
"id": 2,
"nodeType": "ParameterList",
"parameters": [],
"src": "34:0:1"
},
"src": "14:22:1",
"stateMutability": "nonpayable",
"virtual": false,
"visibility": "external"
}
],
"src": "0:38:1"
}
],
"src": "0:39:1"
}

173
test/libsolidity/ASTJSON/function_type_parseOnly.json Normal file
View File

@ -0,0 +1,173 @@
{
"absolutePath": "a",
"id": 18,
"nodeType": "SourceUnit",
"nodes":
[
{
"abstract": false,
"baseContracts": [],
"contractDependencies": [],
"contractKind": "contract",
"id": 17,
"name": "C",
"nodeType": "ContractDefinition",
"nodes":
[
{
"body":
{
"id": 15,
"nodeType": "Block",
"src": "120:2:1",
"statements": []
},
"id": 16,
"implemented": true,
"kind": "function",
"modifiers": [],
"name": "f",
"nodeType": "FunctionDefinition",
"parameters":
{
"id": 7,
"nodeType": "ParameterList",
"parameters":
[
{
"constant": false,
"id": 6,
"mutability": "mutable",
"name": "x",
"nodeType": "VariableDeclaration",
"src": "24:44:1",
"stateVariable": false,
"storageLocation": "default",
"typeDescriptions": {},
"typeName":
{
"id": 5,
"nodeType": "FunctionTypeName",
"parameterTypes":
{
"id": 1,
"nodeType": "ParameterList",
"parameters": [],
"src": "32:2:1"
},
"returnParameterTypes":
{
"id": 4,
"nodeType": "ParameterList",
"parameters":
[
{
"constant": false,
"id": 3,
"mutability": "mutable",
"name": "",
"nodeType": "VariableDeclaration",
"src": "61:4:1",
"stateVariable": false,
"storageLocation": "default",
"typeDescriptions": {},
"typeName":
{
"id": 2,
"name": "uint",
"nodeType": "ElementaryTypeName",
"src": "61:4:1",
"typeDescriptions": {}
},
"visibility": "internal"
}
],
"src": "60:6:1"
},
"src": "24:44:1",
"stateMutability": "payable",
"typeDescriptions": {},
"visibility": "external"
},
"visibility": "internal"
}
],
"src": "23:46:1"
},
"returnParameters":
{
"id": 14,
"nodeType": "ParameterList",
"parameters":
[
{
"constant": false,
"id": 13,
"mutability": "mutable",
"name": "",
"nodeType": "VariableDeclaration",
"src": "79:40:1",
"stateVariable": false,
"storageLocation": "default",
"typeDescriptions": {},
"typeName":
{
"id": 12,
"nodeType": "FunctionTypeName",
"parameterTypes":
{
"id": 8,
"nodeType": "ParameterList",
"parameters": [],
"src": "87:2:1"
},
"returnParameterTypes":
{
"id": 11,
"nodeType": "ParameterList",
"parameters":
[
{
"constant": false,
"id": 10,
"mutability": "mutable",
"name": "",
"nodeType": "VariableDeclaration",
"src": "113:4:1",
"stateVariable": false,
"storageLocation": "default",
"typeDescriptions": {},
"typeName":
{
"id": 9,
"name": "uint",
"nodeType": "ElementaryTypeName",
"src": "113:4:1",
"typeDescriptions": {}
},
"visibility": "internal"
}
],
"src": "112:6:1"
},
"src": "79:40:1",
"stateMutability": "view",
"typeDescriptions": {},
"visibility": "external"
},
"visibility": "internal"
}
],
"src": "78:41:1"
},
"src": "13:109:1",
"stateMutability": "nonpayable",
"virtual": false,
"visibility": "public"
}
],
"src": "0:124:1"
}
],
"src": "0:125:1"
}

24
test/libsolidity/ASTJSON/global_enum_parseOnly.json Normal file
View File

@ -0,0 +1,24 @@
{
"absolutePath": "a",
"id": 3,
"nodeType": "SourceUnit",
"nodes":
[
{
"id": 2,
"members":
[
{
"id": 1,
"name": "A",
"nodeType": "EnumValue",
"src": "9:1:1"
}
],
"name": "E",
"nodeType": "EnumDefinition",
"src": "0:12:1"
}
],
"src": "0:13:1"
}

39
test/libsolidity/ASTJSON/global_struct_parseOnly.json Normal file
View File

@ -0,0 +1,39 @@
{
"absolutePath": "a",
"id": 4,
"nodeType": "SourceUnit",
"nodes":
[
{
"id": 3,
"members":
[
{
"constant": false,
"id": 2,
"mutability": "mutable",
"name": "a",
"nodeType": "VariableDeclaration",
"src": "11:9:1",
"stateVariable": false,
"storageLocation": "default",
"typeDescriptions": {},
"typeName":
{
"id": 1,
"name": "uint256",
"nodeType": "ElementaryTypeName",
"src": "11:7:1",
"typeDescriptions": {}
},
"visibility": "internal"
}
],
"name": "S",
"nodeType": "StructDefinition",
"src": "0:23:1",
"visibility": "public"
}
],
"src": "0:24:1"
}

46
test/libsolidity/ASTJSON/inheritance_specifier_parseOnly.json Normal file
View File

@ -0,0 +1,46 @@
{
"absolutePath": "a",
"id": 5,
"nodeType": "SourceUnit",
"nodes":
[
{
"abstract": false,
"baseContracts": [],
"contractDependencies": [],
"contractKind": "contract",
"id": 1,
"name": "C1",
"nodeType": "ContractDefinition",
"nodes": [],
"src": "0:14:1"
},
{
"abstract": false,
"baseContracts":
[
{
"baseName":
{
"id": 2,
"name": "C1",
"nodeType": "UserDefinedTypeName",
"src": "30:2:1",
"typeDescriptions": {}
},
"id": 3,
"nodeType": "InheritanceSpecifier",
"src": "30:2:1"
}
],
"contractDependencies": [],
"contractKind": "contract",
"id": 4,
"name": "C2",
"nodeType": "ContractDefinition",
"nodes": [],
"src": "15:20:1"
}
],
"src": "0:36:1"
}

21
test/libsolidity/ASTJSON/license_parseOnly.json Normal file
View File

@ -0,0 +1,21 @@
{
"absolutePath": "a",
"id": 2,
"license": "GPL-3.0",
"nodeType": "SourceUnit",
"nodes":
[
{
"abstract": false,
"baseContracts": [],
"contractDependencies": [],
"contractKind": "contract",
"id": 1,
"name": "C",
"nodeType": "ContractDefinition",
"nodes": [],
"src": "36:13:1"
}
],
"src": "36:14:1"
}

118
test/libsolidity/ASTJSON/long_type_name_binary_operation_parseOnly.json Normal file
View File

@ -0,0 +1,118 @@
{
"absolutePath": "a",
"id": 12,
"nodeType": "SourceUnit",
"nodes":
[
{
"abstract": false,
"baseContracts": [],
"contractDependencies": [],
"contractKind": "contract",
"id": 11,
"name": "c",
"nodeType": "ContractDefinition",
"nodes":
[
{
"body":
{
"id": 9,
"nodeType": "Block",
"src": "33:19:1",
"statements":
[
{
"assignments":
[
4
],
"declarations":
[
{
"constant": false,
"id": 4,
"mutability": "mutable",
"name": "a",
"nodeType": "VariableDeclaration",
"src": "35:6:1",
"stateVariable": false,
"storageLocation": "default",
"typeDescriptions": {},
"typeName":
{
"id": 3,
"name": "uint",
"nodeType": "ElementaryTypeName",
"src": "35:4:1",
"typeDescriptions": {}
},
"visibility": "internal"
}
],
"id": 8,
"initialValue":
{
"commonType": {},
"id": 7,
"leftExpression":
{
"hexValue": "32",
"id": 5,
"kind": "number",
"nodeType": "Literal",
"src": "44:1:1",
"typeDescriptions": {},
"value": "2"
},
"nodeType": "BinaryOperation",
"operator": "+",
"rightExpression":
{
"hexValue": "33",
"id": 6,
"kind": "number",
"nodeType": "Literal",
"src": "48:1:1",
"typeDescriptions": {},
"value": "3"
},
"src": "44:5:1",
"typeDescriptions": {}
},
"nodeType": "VariableDeclarationStatement",
"src": "35:14:1"
}
]
},
"id": 10,
"implemented": true,
"kind": "function",
"modifiers": [],
"name": "f",
"nodeType": "FunctionDefinition",
"parameters":
{
"id": 1,
"nodeType": "ParameterList",
"parameters": [],
"src": "23:2:1"
},
"returnParameters":
{
"id": 2,
"nodeType": "ParameterList",
"parameters": [],
"src": "33:0:1"
},
"src": "13:39:1",
"stateMutability": "nonpayable",
"virtual": false,
"visibility": "public"
}
],
"src": "0:54:1"
}
],
"src": "0:55:1"
}

132
test/libsolidity/ASTJSON/long_type_name_identifier_parseOnly.json Normal file
View File

@ -0,0 +1,132 @@
{
"absolutePath": "a",
"id": 16,
"nodeType": "SourceUnit",
"nodes":
[
{
"abstract": false,
"baseContracts": [],
"contractDependencies": [],
"contractKind": "contract",
"id": 15,
"name": "c",
"nodeType": "ContractDefinition",
"nodes":
[
{
"constant": false,
"id": 3,
"mutability": "mutable",
"name": "a",
"nodeType": "VariableDeclaration",
"src": "13:8:1",
"stateVariable": false,
"storageLocation": "default",
"typeDescriptions": {},
"typeName":
{
"baseType":
{
"id": 1,
"name": "uint",
"nodeType": "ElementaryTypeName",
"src": "13:4:1",
"typeDescriptions": {}
},
"id": 2,
"nodeType": "ArrayTypeName",
"src": "13:6:1",
"typeDescriptions": {}
},
"visibility": "internal"
},
{
"body":
{
"id": 13,
"nodeType": "Block",
"src": "43:25:1",
"statements":
[
{
"assignments":
[
10
],
"declarations":
[
{
"constant": false,
"id": 10,
"mutability": "mutable",
"name": "b",
"nodeType": "VariableDeclaration",
"src": "45:16:1",
"stateVariable": false,
"storageLocation": "storage",
"typeDescriptions": {},
"typeName":
{
"baseType":
{
"id": 8,
"name": "uint",
"nodeType": "ElementaryTypeName",
"src": "45:4:1",
"typeDescriptions": {}
},
"id": 9,
"nodeType": "ArrayTypeName",
"src": "45:6:1",
"typeDescriptions": {}
},
"visibility": "internal"
}
],
"id": 12,
"initialValue":
{
"id": 11,
"name": "a",
"nodeType": "Identifier",
"overloadedDeclarations": [],
"src": "64:1:1",
"typeDescriptions": {}
},
"nodeType": "VariableDeclarationStatement",
"src": "45:20:1"
}
]
},
"id": 14,
"implemented": true,
"kind": "function",
"modifiers": [],
"name": "f",
"nodeType": "FunctionDefinition",
"parameters":
{
"id": 4,
"nodeType": "ParameterList",
"parameters": [],
"src": "33:2:1"
},
"returnParameters":
{
"id": 5,
"nodeType": "ParameterList",
"parameters": [],
"src": "43:0:1"
},
"src": "23:45:1",
"stateMutability": "nonpayable",
"virtual": false,
"visibility": "public"
}
],
"src": "0:70:1"
}
],
"src": "0:71:1"
}

154
test/libsolidity/ASTJSON/mappings_parseOnly.json Normal file
View File

@ -0,0 +1,154 @@
{
"absolutePath": "a",
"id": 18,
"nodeType": "SourceUnit",
"nodes":
[
{
"abstract": false,
"baseContracts": [],
"contractDependencies": [],
"contractKind": "contract",
"id": 17,
"name": "C",
"nodeType": "ContractDefinition",
"nodes":
[
{
"id": 4,
"members":
[
{
"id": 1,
"name": "A",
"nodeType": "EnumValue",
"src": "26:1:1"
},
{
"id": 2,
"name": "B",
"nodeType": "EnumValue",
"src": "29:1:1"
},
{
"id": 3,
"name": "C",
"nodeType": "EnumValue",
"src": "32:1:1"
}
],
"name": "E",
"nodeType": "EnumDefinition",
"src": "17:18:1"
},
{
"constant": false,
"id": 8,
"mutability": "mutable",
"name": "a",
"nodeType": "VariableDeclaration",
"src": "40:20:1",
"stateVariable": false,
"storageLocation": "default",
"typeDescriptions": {},
"typeName":
{
"id": 7,
"keyType":
{
"id": 5,
"name": "C",
"nodeType": "UserDefinedTypeName",
"src": "48:1:1",
"typeDescriptions": {}
},
"nodeType": "Mapping",
"src": "40:18:1",
"typeDescriptions": {},
"valueType":
{
"id": 6,
"name": "bool",
"nodeType": "ElementaryTypeName",
"src": "53:4:1",
"typeDescriptions": {}
}
},
"visibility": "internal"
},
{
"constant": false,
"id": 12,
"mutability": "mutable",
"name": "b",
"nodeType": "VariableDeclaration",
"src": "66:26:1",
"stateVariable": false,
"storageLocation": "default",
"typeDescriptions": {},
"typeName":
{
"id": 11,
"keyType":
{
"id": 9,
"name": "address",
"nodeType": "ElementaryTypeName",
"src": "74:7:1",
"typeDescriptions": {}
},
"nodeType": "Mapping",
"src": "66:24:1",
"typeDescriptions": {},
"valueType":
{
"id": 10,
"name": "bool",
"nodeType": "ElementaryTypeName",
"src": "85:4:1",
"typeDescriptions": {}
}
},
"visibility": "internal"
},
{
"constant": false,
"id": 16,
"mutability": "mutable",
"name": "c",
"nodeType": "VariableDeclaration",
"src": "98:20:1",
"stateVariable": false,
"storageLocation": "default",
"typeDescriptions": {},
"typeName":
{
"id": 15,
"keyType":
{
"id": 13,
"name": "E",
"nodeType": "UserDefinedTypeName",
"src": "106:1:1",
"typeDescriptions": {}
},
"nodeType": "Mapping",
"src": "98:18:1",
"typeDescriptions": {},
"valueType":
{
"id": 14,
"name": "bool",
"nodeType": "ElementaryTypeName",
"src": "111:4:1",
"typeDescriptions": {}
}
},
"visibility": "internal"
}
],
"src": "0:121:1"
}
],
"src": "0:122:1"
}

134
test/libsolidity/ASTJSON/modifier_definition_parseOnly.json Normal file
View File

@ -0,0 +1,134 @@
{
"absolutePath": "a",
"id": 15,
"nodeType": "SourceUnit",
"nodes":
[
{
"abstract": false,
"baseContracts": [],
"contractDependencies": [],
"contractKind": "contract",
"id": 14,
"name": "C",
"nodeType": "ContractDefinition",
"nodes":
[
{
"body":
{
"id": 5,
"nodeType": "Block",
"src": "32:6:1",
"statements":
[
{
"id": 4,
"nodeType": "PlaceholderStatement",
"src": "34:1:1"
}
]
},
"id": 6,
"name": "M",
"nodeType": "ModifierDefinition",
"parameters":
{
"id": 3,
"nodeType": "ParameterList",
"parameters":
[
{
"constant": false,
"id": 2,
"mutability": "mutable",
"name": "i",
"nodeType": "VariableDeclaration",
"src": "24:6:1",
"stateVariable": false,
"storageLocation": "default",
"typeDescriptions": {},
"typeName":
{
"id": 1,
"name": "uint",
"nodeType": "ElementaryTypeName",
"src": "24:4:1",
"typeDescriptions": {}
},
"visibility": "internal"
}
],
"src": "23:8:1"
},
"src": "13:25:1",
"virtual": false,
"visibility": "internal"
},
{
"body":
{
"id": 12,
"nodeType": "Block",
"src": "64:2:1",
"statements": []
},
"id": 13,
"implemented": true,
"kind": "function",
"modifiers":
[
{
"arguments":
[
{
"hexValue": "31",
"id": 9,
"kind": "number",
"nodeType": "Literal",
"src": "54:1:1",
"typeDescriptions": {},
"value": "1"
}
],
"id": 10,
"modifierName":
{
"id": 8,
"name": "M",
"nodeType": "Identifier",
"overloadedDeclarations": [],
"src": "52:1:1",
"typeDescriptions": {}
},
"nodeType": "ModifierInvocation",
"src": "52:4:1"
}
],
"name": "F",
"nodeType": "FunctionDefinition",
"parameters":
{
"id": 7,
"nodeType": "ParameterList",
"parameters": [],
"src": "49:2:1"
},
"returnParameters":
{
"id": 11,
"nodeType": "ParameterList",
"parameters": [],
"src": "64:0:1"
},
"src": "39:27:1",
"stateMutability": "nonpayable",
"virtual": false,
"visibility": "public"
}
],
"src": "0:68:1"
}
],
"src": "0:69:1"
}

134
test/libsolidity/ASTJSON/modifier_invocation_parseOnly.json Normal file
View File

@ -0,0 +1,134 @@
{
"absolutePath": "a",
"id": 15,
"nodeType": "SourceUnit",
"nodes":
[
{
"abstract": false,
"baseContracts": [],
"contractDependencies": [],
"contractKind": "contract",
"id": 14,
"name": "C",
"nodeType": "ContractDefinition",
"nodes":
[
{
"body":
{
"id": 5,
"nodeType": "Block",
"src": "32:6:1",
"statements":
[
{
"id": 4,
"nodeType": "PlaceholderStatement",
"src": "34:1:1"
}
]
},
"id": 6,
"name": "M",
"nodeType": "ModifierDefinition",
"parameters":
{
"id": 3,
"nodeType": "ParameterList",
"parameters":
[
{
"constant": false,
"id": 2,
"mutability": "mutable",
"name": "i",
"nodeType": "VariableDeclaration",
"src": "24:6:1",
"stateVariable": false,
"storageLocation": "default",
"typeDescriptions": {},
"typeName":
{
"id": 1,
"name": "uint",
"nodeType": "ElementaryTypeName",
"src": "24:4:1",
"typeDescriptions": {}
},
"visibility": "internal"
}
],
"src": "23:8:1"
},
"src": "13:25:1",
"virtual": false,
"visibility": "internal"
},
{
"body":
{
"id": 12,
"nodeType": "Block",
"src": "64:2:1",
"statements": []
},
"id": 13,
"implemented": true,
"kind": "function",
"modifiers":
[
{
"arguments":
[
{
"hexValue": "31",
"id": 9,
"kind": "number",
"nodeType": "Literal",
"src": "54:1:1",
"typeDescriptions": {},
"value": "1"
}
],
"id": 10,
"modifierName":
{
"id": 8,
"name": "M",
"nodeType": "Identifier",
"overloadedDeclarations": [],
"src": "52:1:1",
"typeDescriptions": {}
},
"nodeType": "ModifierInvocation",
"src": "52:4:1"
}
],
"name": "F",
"nodeType": "FunctionDefinition",
"parameters":
{
"id": 7,
"nodeType": "ParameterList",
"parameters": [],
"src": "49:2:1"
},
"returnParameters":
{
"id": 11,
"nodeType": "ParameterList",
"parameters": [],
"src": "64:0:1"
},
"src": "39:27:1",
"stateMutability": "nonpayable",
"virtual": false,
"visibility": "public"
}
],
"src": "0:68:1"
}
],
"src": "0:69:1"
}

112
test/libsolidity/ASTJSON/mutability_parseOnly.json Normal file
View File

@ -0,0 +1,112 @@
{
"absolutePath": "a",
"id": 11,
"nodeType": "SourceUnit",
"nodes":
[
{
"abstract": false,
"baseContracts": [],
"contractDependencies": [],
"contractKind": "contract",
"id": 10,
"name": "C",
"nodeType": "ContractDefinition",
"nodes":
[
{
"constant": false,
"id": 3,
"mutability": "immutable",
"name": "a",
"nodeType": "VariableDeclaration",
"src": "17:27:1",
"stateVariable": false,
"storageLocation": "default",
"typeDescriptions": {},
"typeName":
{
"id": 1,
"name": "uint",
"nodeType": "ElementaryTypeName",
"src": "17:4:1",
"typeDescriptions": {}
},
"value":
{
"hexValue": "34",
"id": 2,
"kind": "number",
"nodeType": "Literal",
"src": "43:1:1",
"typeDescriptions": {},
"value": "4"
},
"visibility": "public"
},
{
"constant": true,
"id": 6,
"mutability": "constant",
"name": "b",
"nodeType": "VariableDeclaration",
"src": "50:26:1",
"stateVariable": false,
"storageLocation": "default",
"typeDescriptions": {},
"typeName":
{
"id": 4,
"name": "uint",
"nodeType": "ElementaryTypeName",
"src": "50:4:1",
"typeDescriptions": {}
},
"value":
{
"hexValue": "32",
"id": 5,
"kind": "number",
"nodeType": "Literal",
"src": "75:1:1",
"typeDescriptions": {},
"value": "2"
},
"visibility": "public"
},
{
"constant": false,
"id": 9,
"mutability": "mutable",
"name": "c",
"nodeType": "VariableDeclaration",
"src": "82:17:1",
"stateVariable": false,
"storageLocation": "default",
"typeDescriptions": {},
"typeName":
{
"id": 7,
"name": "uint",
"nodeType": "ElementaryTypeName",
"src": "82:4:1",
"typeDescriptions": {}
},
"value":
{
"hexValue": "33",
"id": 8,
"kind": "number",
"nodeType": "Literal",
"src": "98:1:1",
"typeDescriptions": {},
"value": "3"
},
"visibility": "public"
}
],
"src": "0:102:1"
}
],
"src": "0:103:1"
}

98
test/libsolidity/ASTJSON/non_utf8_parseOnly.json Normal file
View File

@ -0,0 +1,98 @@
{
"absolutePath": "a",
"id": 10,
"nodeType": "SourceUnit",
"nodes":
[
{
"abstract": false,
"baseContracts": [],
"contractDependencies": [],
"contractKind": "contract",
"id": 9,
"name": "C",
"nodeType": "ContractDefinition",
"nodes":
[
{
"body":
{
"id": 7,
"nodeType": "Block",
"src": "33:30:1",
"statements":
[
{
"assignments":
[
4
],
"declarations":
[
{
"constant": false,
"id": 4,
"mutability": "mutable",
"name": "x",
"nodeType": "VariableDeclaration",
"src": "35:15:1",
"stateVariable": false,
"storageLocation": "memory",
"typeDescriptions": {},
"typeName":
{
"id": 3,
"name": "string",
"nodeType": "ElementaryTypeName",
"src": "35:6:1",
"typeDescriptions": {}
},
"visibility": "internal"
}
],
"id": 6,
"initialValue":
{
"hexValue": "ff",
"id": 5,
"kind": "hexString",
"nodeType": "Literal",
"src": "53:7:1",
"typeDescriptions": {}
},
"nodeType": "VariableDeclarationStatement",
"src": "35:25:1"
}
]
},
"id": 8,
"implemented": true,
"kind": "function",
"modifiers": [],
"name": "f",
"nodeType": "FunctionDefinition",
"parameters":
{
"id": 1,
"nodeType": "ParameterList",
"parameters": [],
"src": "23:2:1"
},
"returnParameters":
{
"id": 2,
"nodeType": "ParameterList",
"parameters": [],
"src": "33:0:1"
},
"src": "13:50:1",
"stateMutability": "nonpayable",
"virtual": false,
"visibility": "public"
}
],
"src": "0:65:1"
}
],
"src": "0:66:1"
}

0
test/libsolidity/ASTJSON/not_existing_import.json Normal file
View File

8
test/libsolidity/ASTJSON/not_existing_import.sol Normal file
View File

@ -0,0 +1,8 @@
import "notexisting.sol" as NotExisting;
contract C is NotExisting.X
{
NotExisting.SomeStruct public myStruct;
constructor() {}
}
// ----

0
test/libsolidity/ASTJSON/not_existing_import_legacy.json Normal file
View File

97
test/libsolidity/ASTJSON/not_existing_import_parseOnly.json Normal file
View File

@ -0,0 +1,97 @@
{
"absolutePath": "a",
"id": 11,
"nodeType": "SourceUnit",
"nodes":
[
{
"file": "notexisting.sol",
"id": 1,
"nodeType": "ImportDirective",
"src": "0:40:1",
"symbolAliases": [],
"unitAlias": "NotExisting"
},
{
"abstract": false,
"baseContracts":
[
{
"baseName":
{
"id": 2,
"name": "NotExisting.X",
"nodeType": "UserDefinedTypeName",
"src": "55:13:1",
"typeDescriptions": {}
},
"id": 3,
"nodeType": "InheritanceSpecifier",
"src": "55:13:1"
}
],
"contractDependencies": [],
"contractKind": "contract",
"id": 10,
"name": "C",
"nodeType": "ContractDefinition",
"nodes":
[
{
"constant": false,
"id": 5,
"mutability": "mutable",
"name": "myStruct",
"nodeType": "VariableDeclaration",
"src": "72:38:1",
"stateVariable": false,
"storageLocation": "default",
"typeDescriptions": {},
"typeName":
{
"id": 4,
"name": "NotExisting.SomeStruct",
"nodeType": "UserDefinedTypeName",
"src": "72:22:1",
"typeDescriptions": {}
},
"visibility": "public"
},
{
"body":
{
"id": 8,
"nodeType": "Block",
"src": "127:2:1",
"statements": []
},
"id": 9,
"implemented": true,
"kind": "constructor",
"modifiers": [],
"name": "",
"nodeType": "FunctionDefinition",
"parameters":
{
"id": 6,
"nodeType": "ParameterList",
"parameters": [],
"src": "124:2:1"
},
"returnParameters":
{
"id": 7,
"nodeType": "ParameterList",
"parameters": [],
"src": "127:0:1"
},
"src": "113:16:1",
"stateMutability": "nonpayable",
"virtual": false
}
],
"src": "41:90:1"
}
],
"src": "0:132:1"
}

273
test/libsolidity/ASTJSON/override_parseOnly.json Normal file
View File

@ -0,0 +1,273 @@
{
"absolutePath": "a",
"id": 32,
"nodeType": "SourceUnit",
"nodes":
[
{
"abstract": false,
"baseContracts": [],
"contractDependencies": [],
"contractKind": "contract",
"id": 5,
"name": "A",
"nodeType": "ContractDefinition",
"nodes":
[
{
"body":
{
"id": 3,
"nodeType": "Block",
"src": "36:2:1",
"statements": []
},
"id": 4,
"implemented": true,
"kind": "function",
"modifiers": [],
"name": "faa",
"nodeType": "FunctionDefinition",
"parameters":
{
"id": 1,
"nodeType": "ParameterList",
"parameters": [],
"src": "26:2:1"
},
"returnParameters":
{
"id": 2,
"nodeType": "ParameterList",
"parameters": [],
"src": "36:0:1"
},
"src": "14:24:1",
"stateMutability": "nonpayable",
"virtual": false,
"visibility": "public"
}
],
"src": "0:40:1"
},
{
"abstract": false,
"baseContracts":
[
{
"baseName":
{
"id": 6,
"name": "A",
"nodeType": "UserDefinedTypeName",
"src": "55:1:1",
"typeDescriptions": {}
},
"id": 7,
"nodeType": "InheritanceSpecifier",
"src": "55:1:1"
}
],
"contractDependencies": [],
"contractKind": "contract",
"id": 16,
"name": "B",
"nodeType": "ContractDefinition",
"nodes":
[
{
"id": 10,
"implemented": false,
"kind": "function",
"modifiers": [],
"name": "foo",
"nodeType": "FunctionDefinition",
"parameters":
{
"id": 8,
"nodeType": "ParameterList",
"parameters": [],
"src": "72:2:1"
},
"returnParameters":
{
"id": 9,
"nodeType": "ParameterList",
"parameters": [],
"src": "81:0:1"
},
"src": "60:22:1",
"stateMutability": "nonpayable",
"virtual": false,
"visibility": "public"
},
{
"body":
{
"id": 14,
"nodeType": "Block",
"src": "115:2:1",
"statements": []
},
"id": 15,
"implemented": true,
"kind": "function",
"modifiers": [],
"name": "faa",
"nodeType": "FunctionDefinition",
"overrides":
{
"id": 12,
"nodeType": "OverrideSpecifier",
"overrides": [],
"src": "106:8:1"
},
"parameters":
{
"id": 11,
"nodeType": "ParameterList",
"parameters": [],
"src": "96:2:1"
},
"returnParameters":
{
"id": 13,
"nodeType": "ParameterList",
"parameters": [],
"src": "115:0:1"
},
"src": "84:33:1",
"stateMutability": "nonpayable",
"virtual": false,
"visibility": "public"
}
],
"src": "41:78:1"
},
{
"abstract": false,
"baseContracts":
[
{
"baseName":
{
"id": 17,
"name": "B",
"nodeType": "UserDefinedTypeName",
"src": "134:1:1",
"typeDescriptions": {}
},
"id": 18,
"nodeType": "InheritanceSpecifier",
"src": "134:1:1"
}
],
"contractDependencies": [],
"contractKind": "contract",
"id": 31,
"name": "C",
"nodeType": "ContractDefinition",
"nodes":
[
{
"body":
{
"id": 22,
"nodeType": "Block",
"src": "170:3:1",
"statements": []
},
"id": 23,
"implemented": true,
"kind": "function",
"modifiers": [],
"name": "foo",
"nodeType": "FunctionDefinition",
"overrides":
{
"id": 20,
"nodeType": "OverrideSpecifier",
"overrides": [],
"src": "161:8:1"
},
"parameters":
{
"id": 19,
"nodeType": "ParameterList",
"parameters": [],
"src": "151:2:1"
},
"returnParameters":
{
"id": 21,
"nodeType": "ParameterList",
"parameters": [],
"src": "170:0:1"
},
"src": "139:34:1",
"stateMutability": "nonpayable",
"virtual": false,
"visibility": "public"
},
{
"body":
{
"id": 29,
"nodeType": "Block",
"src": "212:2:1",
"statements": []
},
"id": 30,
"implemented": true,
"kind": "function",
"modifiers": [],
"name": "faa",
"nodeType": "FunctionDefinition",
"overrides":
{
"id": 27,
"nodeType": "OverrideSpecifier",
"overrides":
[
{
"id": 25,
"name": "A",
"nodeType": "UserDefinedTypeName",
"src": "206:1:1",
"typeDescriptions": {}
},
{
"id": 26,
"name": "B",
"nodeType": "UserDefinedTypeName",
"src": "209:1:1",
"typeDescriptions": {}
}
],
"src": "197:14:1"
},
"parameters":
{
"id": 24,
"nodeType": "ParameterList",
"parameters": [],
"src": "187:2:1"
},
"returnParameters":
{
"id": 28,
"nodeType": "ParameterList",
"parameters": [],
"src": "212:0:1"
},
"src": "175:39:1",
"stateMutability": "nonpayable",
"virtual": false,
"visibility": "public"
}
],
"src": "120:96:1"
}
],
"src": "0:217:1"
}

51
test/libsolidity/ASTJSON/placeholder_statement_parseOnly.json Normal file
View File

@ -0,0 +1,51 @@
{
"absolutePath": "a",
"id": 6,
"nodeType": "SourceUnit",
"nodes":
[
{
"abstract": false,
"baseContracts": [],
"contractDependencies": [],
"contractKind": "contract",
"id": 5,
"name": "C",
"nodeType": "ContractDefinition",
"nodes":
[
{
"body":
{
"id": 3,
"nodeType": "Block",
"src": "24:6:1",
"statements":
[
{
"id": 2,
"nodeType": "PlaceholderStatement",
"src": "26:1:1"
}
]
},
"id": 4,
"name": "M",
"nodeType": "ModifierDefinition",
"parameters":
{
"id": 1,
"nodeType": "ParameterList",
"parameters": [],
"src": "24:0:1"
},
"src": "13:17:1",
"virtual": false,
"visibility": "internal"
}
],
"src": "0:32:1"
}
],
"src": "0:33:1"
}

55
test/libsolidity/ASTJSON/receive_ether_parseOnly.json Normal file
View File

@ -0,0 +1,55 @@
{
"absolutePath": "a",
"id": 6,
"nodeType": "SourceUnit",
"nodes":
[
{
"abstract": false,
"baseContracts": [],
"contractDependencies": [],
"contractKind": "contract",
"id": 5,
"name": "C",
"nodeType": "ContractDefinition",
"nodes":
[
{
"body":
{
"id": 3,
"nodeType": "Block",
"src": "42:5:1",
"statements": []
},
"id": 4,
"implemented": true,
"kind": "receive",
"modifiers": [],
"name": "",
"nodeType": "FunctionDefinition",
"parameters":
{
"id": 1,
"nodeType": "ParameterList",
"parameters": [],
"src": "22:2:1"
},
"returnParameters":
{
"id": 2,
"nodeType": "ParameterList",
"parameters": [],
"src": "42:0:1"
},
"src": "15:32:1",
"stateMutability": "payable",
"virtual": false,
"visibility": "external"
}
],
"src": "0:49:1"
}
],
"src": "0:50:1"
}

96
test/libsolidity/ASTJSON/short_type_name_parseOnly.json Normal file
View File

@ -0,0 +1,96 @@
{
"absolutePath": "a",
"id": 12,
"nodeType": "SourceUnit",
"nodes":
[
{
"abstract": false,
"baseContracts": [],
"contractDependencies": [],
"contractKind": "contract",
"id": 11,
"name": "c",
"nodeType": "ContractDefinition",
"nodes":
[
{
"body":
{
"id": 9,
"nodeType": "Block",
"src": "33:20:1",
"statements":
[
{
"assignments":
[
7
],
"declarations":
[
{
"constant": false,
"id": 7,
"mutability": "mutable",
"name": "x",
"nodeType": "VariableDeclaration",
"src": "35:15:1",
"stateVariable": false,
"storageLocation": "memory",
"typeDescriptions": {},
"typeName":
{
"baseType":
{
"id": 5,
"name": "uint",
"nodeType": "ElementaryTypeName",
"src": "35:4:1",
"typeDescriptions": {}
},
"id": 6,
"nodeType": "ArrayTypeName",
"src": "35:6:1",
"typeDescriptions": {}
},
"visibility": "internal"
}
],
"id": 8,
"nodeType": "VariableDeclarationStatement",
"src": "35:15:1"
}
]
},
"id": 10,
"implemented": true,
"kind": "function",
"modifiers": [],
"name": "f",
"nodeType": "FunctionDefinition",
"parameters":
{
"id": 1,
"nodeType": "ParameterList",
"parameters": [],
"src": "23:2:1"
},
"returnParameters":
{
"id": 2,
"nodeType": "ParameterList",
"parameters": [],
"src": "33:0:1"
},
"src": "13:40:1",
"stateMutability": "nonpayable",
"virtual": false,
"visibility": "public"
}
],
"src": "0:55:1"
}
],
"src": "0:56:1"
}

103
test/libsolidity/ASTJSON/short_type_name_ref_parseOnly.json Normal file
View File

@ -0,0 +1,103 @@
{
"absolutePath": "a",
"id": 13,
"nodeType": "SourceUnit",
"nodes":
[
{
"abstract": false,
"baseContracts": [],
"contractDependencies": [],
"contractKind": "contract",
"id": 12,
"name": "c",
"nodeType": "ContractDefinition",
"nodes":
[
{
"body":
{
"id": 10,
"nodeType": "Block",
"src": "33:25:1",
"statements":
[
{
"assignments":
[
8
],
"declarations":
[
{
"constant": false,
"id": 8,
"mutability": "mutable",
"name": "rows",
"nodeType": "VariableDeclaration",
"src": "35:20:1",
"stateVariable": false,
"storageLocation": "memory",
"typeDescriptions": {},
"typeName":
{
"baseType":
{
"baseType":
{
"id": 5,
"name": "uint",
"nodeType": "ElementaryTypeName",
"src": "35:4:1",
"typeDescriptions": {}
},
"id": 6,
"nodeType": "ArrayTypeName",
"src": "35:6:1",
"typeDescriptions": {}
},
"id": 7,
"nodeType": "ArrayTypeName",
"src": "35:8:1",
"typeDescriptions": {}
},
"visibility": "internal"
}
],
"id": 9,
"nodeType": "VariableDeclarationStatement",
"src": "35:20:1"
}
]
},
"id": 11,
"implemented": true,
"kind": "function",
"modifiers": [],
"name": "f",
"nodeType": "FunctionDefinition",
"parameters":
{
"id": 1,
"nodeType": "ParameterList",
"parameters": [],
"src": "23:2:1"
},
"returnParameters":
{
"id": 2,
"nodeType": "ParameterList",
"parameters": [],
"src": "33:0:1"
},
"src": "13:45:1",
"stateMutability": "nonpayable",
"virtual": false,
"visibility": "public"
}
],
"src": "0:60:1"
}
],
"src": "0:61:1"
}

20
test/libsolidity/ASTJSON/smoke_parseOnly.json Normal file
View File

@ -0,0 +1,20 @@
{
"absolutePath": "a",
"id": 2,
"nodeType": "SourceUnit",
"nodes":
[
{
"abstract": false,
"baseContracts": [],
"contractDependencies": [],
"contractKind": "contract",
"id": 1,
"name": "C",
"nodeType": "ContractDefinition",
"nodes": [],
"src": "0:13:1"
}
],
"src": "0:14:1"
}

122
test/libsolidity/ASTJSON/source_location_parseOnly.json Normal file
View File

@ -0,0 +1,122 @@
{
"absolutePath": "a",
"id": 13,
"nodeType": "SourceUnit",
"nodes":
[
{
"abstract": false,
"baseContracts": [],
"contractDependencies": [],
"contractKind": "contract",
"id": 12,
"name": "C",
"nodeType": "ContractDefinition",
"nodes":
[
{
"body":
{
"id": 10,
"nodeType": "Block",
"src": "26:20:1",
"statements":
[
{
"assignments":
[
4
],
"declarations":
[
{
"constant": false,
"id": 4,
"mutability": "mutable",
"name": "x",
"nodeType": "VariableDeclaration",
"src": "28:6:1",
"stateVariable": false,
"storageLocation": "default",
"typeDescriptions": {},
"typeName":
{
"id": 3,
"name": "uint",
"nodeType": "ElementaryTypeName",
"src": "28:4:1",
"typeDescriptions": {}
},
"visibility": "internal"
}
],
"id": 6,
"initialValue":
{
"hexValue": "32",
"id": 5,
"kind": "number",
"nodeType": "Literal",
"src": "37:1:1",
"typeDescriptions": {},
"value": "2"
},
"nodeType": "VariableDeclarationStatement",
"src": "28:10:1"
},
{
"expression":
{
"id": 8,
"nodeType": "UnaryOperation",
"operator": "++",
"prefix": false,
"src": "40:3:1",
"subExpression":
{
"id": 7,
"name": "x",
"nodeType": "Identifier",
"overloadedDeclarations": [],
"src": "40:1:1",
"typeDescriptions": {}
},
"typeDescriptions": {}
},
"id": 9,
"nodeType": "ExpressionStatement",
"src": "40:3:1"
}
]
},
"id": 11,
"implemented": true,
"kind": "function",
"modifiers": [],
"name": "f",
"nodeType": "FunctionDefinition",
"parameters":
{
"id": 1,
"nodeType": "ParameterList",
"parameters": [],
"src": "23:2:1"
},
"returnParameters":
{
"id": 2,
"nodeType": "ParameterList",
"parameters": [],
"src": "26:0:1"
},
"src": "13:33:1",
"stateMutability": "nonpayable",
"virtual": false,
"visibility": "public"
}
],
"src": "0:48:1"
}
],
"src": "0:49:1"
}

99
test/libsolidity/ASTJSON/string_parseOnly.json Normal file
View File

@ -0,0 +1,99 @@
{
"absolutePath": "a",
"id": 10,
"nodeType": "SourceUnit",
"nodes":
[
{
"abstract": false,
"baseContracts": [],
"contractDependencies": [],
"contractKind": "contract",
"id": 9,
"name": "C",
"nodeType": "ContractDefinition",
"nodes":
[
{
"body":
{
"id": 7,
"nodeType": "Block",
"src": "33:36:1",
"statements":
[
{
"assignments":
[
4
],
"declarations":
[
{
"constant": false,
"id": 4,
"mutability": "mutable",
"name": "x",
"nodeType": "VariableDeclaration",
"src": "35:15:1",
"stateVariable": false,
"storageLocation": "memory",
"typeDescriptions": {},
"typeName":
{
"id": 3,
"name": "string",
"nodeType": "ElementaryTypeName",
"src": "35:6:1",
"typeDescriptions": {}
},
"visibility": "internal"
}
],
"id": 6,
"initialValue":
{
"hexValue": "48656c6c6f20576f726c64",
"id": 5,
"kind": "string",
"nodeType": "Literal",
"src": "53:13:1",
"typeDescriptions": {},
"value": "Hello World"
},
"nodeType": "VariableDeclarationStatement",
"src": "35:31:1"
}
]
},
"id": 8,
"implemented": true,
"kind": "function",
"modifiers": [],
"name": "f",
"nodeType": "FunctionDefinition",
"parameters":
{
"id": 1,
"nodeType": "ParameterList",
"parameters": [],
"src": "23:2:1"
},
"returnParameters":
{
"id": 2,
"nodeType": "ParameterList",
"parameters": [],
"src": "33:0:1"
},
"src": "13:56:1",
"stateMutability": "nonpayable",
"virtual": false,
"visibility": "public"
}
],
"src": "0:71:1"
}
],
"src": "0:72:1"
}

198
test/libsolidity/ASTJSON/two_base_functions_parseOnly.json Normal file
View File

@ -0,0 +1,198 @@
{
"absolutePath": "a",
"id": 23,
"nodeType": "SourceUnit",
"nodes":
[
{
"abstract": false,
"baseContracts": [],
"contractDependencies": [],
"contractKind": "contract",
"id": 5,
"name": "A",
"nodeType": "ContractDefinition",
"nodes":
[
{
"body":
{
"id": 3,
"nodeType": "Block",
"src": "45:2:1",
"statements": []
},
"id": 4,
"implemented": true,
"kind": "function",
"modifiers": [],
"name": "f",
"nodeType": "FunctionDefinition",
"parameters":
{
"id": 1,
"nodeType": "ParameterList",
"parameters": [],
"src": "27:2:1"
},
"returnParameters":
{
"id": 2,
"nodeType": "ParameterList",
"parameters": [],
"src": "45:0:1"
},
"src": "17:30:1",
"stateMutability": "nonpayable",
"virtual": true,
"visibility": "public"
}
],
"src": "0:49:1"
},
{
"abstract": false,
"baseContracts": [],
"contractDependencies": [],
"contractKind": "contract",
"id": 10,
"name": "B",
"nodeType": "ContractDefinition",
"nodes":
[
{
"body":
{
"id": 8,
"nodeType": "Block",
"src": "95:2:1",
"statements": []
},
"id": 9,
"implemented": true,
"kind": "function",
"modifiers": [],
"name": "f",
"nodeType": "FunctionDefinition",
"parameters":
{
"id": 6,
"nodeType": "ParameterList",
"parameters": [],
"src": "77:2:1"
},
"returnParameters":
{
"id": 7,
"nodeType": "ParameterList",
"parameters": [],
"src": "95:0:1"
},
"src": "67:30:1",
"stateMutability": "nonpayable",
"virtual": true,
"visibility": "public"
}
],
"src": "50:49:1"
},
{
"abstract": false,
"baseContracts":
[
{
"baseName":
{
"id": 11,
"name": "A",
"nodeType": "UserDefinedTypeName",
"src": "114:1:1",
"typeDescriptions": {}
},
"id": 12,
"nodeType": "InheritanceSpecifier",
"src": "114:1:1"
},
{
"baseName":
{
"id": 13,
"name": "B",
"nodeType": "UserDefinedTypeName",
"src": "117:1:1",
"typeDescriptions": {}
},
"id": 14,
"nodeType": "InheritanceSpecifier",
"src": "117:1:1"
}
],
"contractDependencies": [],
"contractKind": "contract",
"id": 22,
"name": "C",
"nodeType": "ContractDefinition",
"nodes":
[
{
"body":
{
"id": 20,
"nodeType": "Block",
"src": "160:2:1",
"statements": []
},
"id": 21,
"implemented": true,
"kind": "function",
"modifiers": [],
"name": "f",
"nodeType": "FunctionDefinition",
"overrides":
{
"id": 18,
"nodeType": "OverrideSpecifier",
"overrides":
[
{
"id": 16,
"name": "A",
"nodeType": "UserDefinedTypeName",
"src": "154:1:1",
"typeDescriptions": {}
},
{
"id": 17,
"name": "B",
"nodeType": "UserDefinedTypeName",
"src": "157:1:1",
"typeDescriptions": {}
}
],
"src": "145:14:1"
},
"parameters":
{
"id": 15,
"nodeType": "ParameterList",
"parameters": [],
"src": "135:2:1"
},
"returnParameters":
{
"id": 19,
"nodeType": "ParameterList",
"parameters": [],
"src": "160:0:1"
},
"src": "125:37:1",
"stateMutability": "nonpayable",
"virtual": false,
"visibility": "public"
}
],
"src": "100:64:1"
}
],
"src": "0:165:1"
}

99
test/libsolidity/ASTJSON/unicode_parseOnly.json Normal file
View File

@ -0,0 +1,99 @@
{
"absolutePath": "a",
"id": 10,
"nodeType": "SourceUnit",
"nodes":
[
{
"abstract": false,
"baseContracts": [],
"contractDependencies": [],
"contractKind": "contract",
"id": 9,
"name": "C",
"nodeType": "ContractDefinition",
"nodes":
[
{
"body":
{
"id": 7,
"nodeType": "Block",
"src": "33:42:1",
"statements":
[
{
"assignments":
[
4
],
"declarations":
[
{
"constant": false,
"id": 4,
"mutability": "mutable",
"name": "x",
"nodeType": "VariableDeclaration",
"src": "35:15:1",
"stateVariable": false,
"storageLocation": "memory",
"typeDescriptions": {},
"typeName":
{
"id": 3,
"name": "string",
"nodeType": "ElementaryTypeName",
"src": "35:6:1",
"typeDescriptions": {}
},
"visibility": "internal"
}
],
"id": 6,
"initialValue":
{
"hexValue": "48656c6c6f20f09f9883",
"id": 5,
"kind": "unicodeString",
"nodeType": "Literal",
"src": "53:19:1",
"typeDescriptions": {},
"value": "Hello \ud83d\ude03"
},
"nodeType": "VariableDeclarationStatement",
"src": "35:37:1"
}
]
},
"id": 8,
"implemented": true,
"kind": "function",
"modifiers": [],
"name": "f",
"nodeType": "FunctionDefinition",
"parameters":
{
"id": 1,
"nodeType": "ParameterList",
"parameters": [],
"src": "23:2:1"
},
"returnParameters":
{
"id": 2,
"nodeType": "ParameterList",
"parameters": [],
"src": "33:0:1"
},
"src": "13:62:1",
"stateMutability": "nonpayable",
"virtual": false,
"visibility": "public"
}
],
"src": "0:77:1"
}
],
"src": "0:78:1"
}

54
test/libsolidity/ASTJSON/using_for_directive_parseOnly.json Normal file
View File

@ -0,0 +1,54 @@
{
"absolutePath": "a",
"id": 6,
"nodeType": "SourceUnit",
"nodes":
[
{
"abstract": false,
"baseContracts": [],
"contractDependencies": [],
"contractKind": "library",
"id": 1,
"name": "L",
"nodeType": "ContractDefinition",
"nodes": [],
"src": "0:12:1"
},
{
"abstract": false,
"baseContracts": [],
"contractDependencies": [],
"contractKind": "contract",
"id": 5,
"name": "C",
"nodeType": "ContractDefinition",
"nodes":
[
{
"id": 4,
"libraryName":
{
"id": 2,
"name": "L",
"nodeType": "UserDefinedTypeName",
"src": "32:1:1",
"typeDescriptions": {}
},
"nodeType": "UsingForDirective",
"src": "26:17:1",
"typeName":
{
"id": 3,
"name": "uint",
"nodeType": "ElementaryTypeName",
"src": "38:4:1",
"typeDescriptions": {}
}
}
],
"src": "13:32:1"
}
],
"src": "0:46:1"
}

48
test/libsolidity/ASTJSONTest.cpp
View File

@ -73,6 +73,7 @@ ASTJSONTest::ASTJSONTest(string const& _filename)
BOOST_THROW_EXCEPTION(runtime_error("Invalid test contract file name: \"" + _filename + "\".")); BOOST_THROW_EXCEPTION(runtime_error("Invalid test contract file name: \"" + _filename + "\"."));
m_astFilename = _filename.substr(0, _filename.size() - 4) + ".json"; m_astFilename = _filename.substr(0, _filename.size() - 4) + ".json";
m_astParseOnlyFilename = _filename.substr(0, _filename.size() - 4) + "_parseOnly.json";
m_legacyAstFilename = _filename.substr(0, _filename.size() - 4) + "_legacy.json"; m_legacyAstFilename = _filename.substr(0, _filename.size() - 4) + "_legacy.json";
ifstream file(_filename); ifstream file(_filename);
@ -112,6 +113,15 @@ ASTJSONTest::ASTJSONTest(string const& _filename)
m_expectation += line + "\n"; m_expectation += line + "\n";
} }
file.close();
file.open(m_astParseOnlyFilename);
if (file)
{
string line;
while (getline(file, line))
m_expectationParseOnly += line + "\n";
}
file.close(); file.close();
file.open(m_legacyAstFilename); file.open(m_legacyAstFilename);
if (file) if (file)
@ -120,6 +130,7 @@ ASTJSONTest::ASTJSONTest(string const& _filename)
while (getline(file, line)) while (getline(file, line))
m_expectationLegacy += line + "\n"; m_expectationLegacy += line + "\n";
} }
file.close();
} }
TestCase::TestResult ASTJSONTest::run(ostream& _stream, string const& _linePrefix, bool const _formatted) TestCase::TestResult ASTJSONTest::run(ostream& _stream, string const& _linePrefix, bool const _formatted)
@ -136,8 +147,36 @@ TestCase::TestResult ASTJSONTest::run(ostream& _stream, string const& _linePrefi
c.setSources(sources); c.setSources(sources);
c.setEVMVersion(solidity::test::CommonOptions::get().evmVersion()); c.setEVMVersion(solidity::test::CommonOptions::get().evmVersion());
if (!c.compile(CompilerStack::State::Parsed))
{
SourceReferenceFormatterHuman formatter(_stream, _formatted, false);
for (auto const& error: c.errors())
formatter.printErrorInformation(*error);
return TestResult::FatalError;
}
bool resultsMatch = runTest(
m_expectationParseOnly,
m_resultParseOnly,
sourceIndices,
c,
false,
"parseOnly",
_stream,
_linePrefix,
_formatted
);
c.reset();
c.setSources(sources);
c.setEVMVersion(solidity::test::CommonOptions::get().evmVersion());
if (!c.parse()) if (!c.parse())
{ {
// Empty Expectations means we expect failure
if (m_expectation.empty() && m_expectationLegacy.empty())
return resultsMatch ? TestResult::Success : TestResult::Failure;
SourceReferenceFormatterHuman formatter(_stream, _formatted, false); SourceReferenceFormatterHuman formatter(_stream, _formatted, false);
for (auto const& error: c.errors()) for (auto const& error: c.errors())
formatter.printErrorInformation(*error); formatter.printErrorInformation(*error);
@ -146,7 +185,7 @@ TestCase::TestResult ASTJSONTest::run(ostream& _stream, string const& _linePrefi
c.analyze(); c.analyze();
bool resultsMatch = runTest( resultsMatch = runTest(
m_expectation, m_expectation,
m_result, m_result,
sourceIndices, sourceIndices,
@ -156,7 +195,7 @@ TestCase::TestResult ASTJSONTest::run(ostream& _stream, string const& _linePrefi
_stream, _stream,
_linePrefix, _linePrefix,
_formatted _formatted
); ) && resultsMatch;
resultsMatch = runTest( resultsMatch = runTest(
m_expectationLegacy, m_expectationLegacy,
@ -191,7 +230,7 @@ bool ASTJSONTest::runTest(
for (size_t i = 0; i < m_sources.size(); i++) for (size_t i = 0; i < m_sources.size(); i++)
{ {
ostringstream result; ostringstream result;
ASTJsonConverter(_legacy, _sourceIndices).print(result, _compiler.ast(m_sources[i].first)); ASTJsonConverter(_legacy, _compiler.state(), _sourceIndices).print(result, _compiler.ast(m_sources[i].first));
_result += result.str(); _result += result.str();
if (i != m_sources.size() - 1) if (i != m_sources.size() - 1)
_result += ","; _result += ",";
@ -234,7 +273,7 @@ bool ASTJSONTest::runTest(
return false; return false;
} }
return true;; return true;
} }
void ASTJSONTest::printSource(ostream& _stream, string const& _linePrefix, bool const) const void ASTJSONTest::printSource(ostream& _stream, string const& _linePrefix, bool const) const
@ -255,6 +294,7 @@ void ASTJSONTest::printUpdatedExpectations(std::ostream&, std::string const&) co
{ {
updateExpectation(m_astFilename, m_result, ""); updateExpectation(m_astFilename, m_result, "");
updateExpectation(m_legacyAstFilename, m_resultLegacy, "legacy "); updateExpectation(m_legacyAstFilename, m_resultLegacy, "legacy ");
updateExpectation(m_astParseOnlyFilename, m_resultParseOnly, "parseOnly ");
} }
void ASTJSONTest::updateExpectation(string const& _filename, string const& _expectation, string const& _variation) const void ASTJSONTest::updateExpectation(string const& _filename, string const& _expectation, string const& _variation) const

8
test/libsolidity/ASTJSONTest.h
View File

@ -34,7 +34,6 @@ class CompilerStack;
namespace solidity::frontend::test namespace solidity::frontend::test
{ {
class ASTJSONTest: public TestCase class ASTJSONTest: public TestCase
{ {
public: public:
@ -50,9 +49,9 @@ private:
bool runTest( bool runTest(
std::string& _expectation, std::string& _expectation,
std::string& _result, std::string& _result,
std::map<std::string, unsigned> const& _sourceIndicies, std::map<std::string, unsigned> const& _sourceIndices,
CompilerStack& _compiler, CompilerStack& _compiler,
bool _legacy, bool _parseOnly,
std::string const& _variation, std::string const& _variation,
std::ostream& _stream, std::ostream& _stream,
std::string const& _linePrefix = "", std::string const& _linePrefix = "",
@ -66,10 +65,13 @@ private:
std::vector<std::pair<std::string, std::string>> m_sources; std::vector<std::pair<std::string, std::string>> m_sources;
std::string m_expectationLegacy; std::string m_expectationLegacy;
std::string m_expectationParseOnly;
std::string m_astFilename; std::string m_astFilename;
std::string m_astParseOnlyFilename;
std::string m_legacyAstFilename; std::string m_legacyAstFilename;
std::string m_result; std::string m_result;
std::string m_resultLegacy; std::string m_resultLegacy;
std::string m_resultParseOnly;
}; };
} }

85
test/libsolidity/StandardCompiler.cpp
View File

@ -1420,6 +1420,91 @@ BOOST_AUTO_TEST_CASE(standard_output_selection_wildcard_multiple_sources)
BOOST_REQUIRE(result["sources"]["B"].isObject()); BOOST_REQUIRE(result["sources"]["B"].isObject());
} }
BOOST_AUTO_TEST_CASE(stopAfter_invalid_value)
{
char const* input = R"(
{
"language": "Solidity",
"sources":
{ "": { "content": "pragma solidity >=0.0; contract C { function f() public pure {} }" } },
"settings":
{
"stopAfter": "rrr",
"outputSelection":
{
"*": { "C": ["evm.bytecode"] }
}
}
}
)";
Json::Value result = compile(input);
BOOST_CHECK(containsError(result, "JSONError", "Invalid value for \"settings.stopAfter\". Only valid value is \"parsing\"."));
}
BOOST_AUTO_TEST_CASE(stopAfter_invalid_type)
{
char const* input = R"(
{
"language": "Solidity",
"sources":
{ "": { "content": "pragma solidity >=0.0; contract C { function f() public pure {} }" } },
"settings":
{
"stopAfter": 3,
"outputSelection":
{
"*": { "C": ["evm.bytecode"] }
}
}
}
)";
Json::Value result = compile(input);
BOOST_CHECK(containsError(result, "JSONError", "\"settings.stopAfter\" must be a string."));
}
BOOST_AUTO_TEST_CASE(stopAfter_bin_conflict)
{
char const* input = R"(
{
"language": "Solidity",
"sources":
{ "": { "content": "pragma solidity >=0.0; contract C { function f() public pure {} }" } },
"settings":
{
"stopAfter": "parsing",
"outputSelection":
{
"*": { "C": ["evm.bytecode"] }
}
}
}
)";
Json::Value result = compile(input);
BOOST_CHECK(containsError(result, "JSONError", "Requested output selection conflicts with \"settings.stopAfter\"."));
}
BOOST_AUTO_TEST_CASE(stopAfter_ast_output)
{
char const* input = R"(
{
"language": "Solidity",
"sources": {
"a.sol": {
"content": "// SPDX-License-Identifier: GPL-3.0\nimport \"tes32.sol\";\n contract C is X { constructor() {} }"
}
},
"settings": {
"stopAfter": "parsing",
"outputSelection": { "*": { "": [ "ast" ] } }
}
}
)";
Json::Value result = compile(input);
BOOST_CHECK(result["sources"].isObject());
BOOST_CHECK(result["sources"]["a.sol"].isObject());
BOOST_CHECK(result["sources"]["a.sol"]["ast"].isObject());
}
BOOST_AUTO_TEST_SUITE_END() BOOST_AUTO_TEST_SUITE_END()
} // end namespaces } // end namespaces

64
test/stopAfterParseTests.sh Executable file
View File

@ -0,0 +1,64 @@
#! /usr/bin/env bash
REPO_ROOT=$(readlink -f "$(dirname "$0")"/..)
SOLIDITY_BUILD_DIR=${SOLIDITY_BUILD_DIR:-${REPO_ROOT}/build}
SOLC=${SOLIDITY_BUILD_DIR}/solc/solc
SPLITSOURCES=${REPO_ROOT}/scripts/splitSources.py
FILETMP=$(mktemp -d)
cd "$FILETMP" || exit 1
function testFile()
{
ALLOUTPUT=$($SOLC --combined-json ast,compact-format --pretty-json "$@" --stop-after parsing 2>&1)
if test $? -ne 0; then
# solc returned failure. Compilation errors and unimplemented features
# are okay, everything else is a failed test (segfault)
if ! echo "$ALLOUTPUT" | grep -e "Unimplemented feature:" -e "Error:" -q; then
echo -n "Test failed on ";
echo "$@"
echo "$ALLOUTPUT"
return 1;
fi
else
echo -n .
fi
return 0;
}
while read -r file; do
OUTPUT=$($SPLITSOURCES "$file")
RETURN_CODE=$?
FAILED=0
if [ $RETURN_CODE -eq 0 ]
then
# shellcheck disable=SC2086
testFile $OUTPUT
FAILED=$?
rm "${FILETMP:?}/"* -r
elif [ $RETURN_CODE -eq 1 ]
then
testFile "$file"
FAILED=$?
elif [ $RETURN_CODE -eq 2 ]
then
echo -n "<skipping utf8 error>"
else
echo "Received unexpected return code $RETURN_CODE while processing $file: "
echo "-----"
echo "$OUTPUT"
exit 3
fi
if [ $FAILED -eq 1 ]
then
echo -n "Failure on "
echo "$file"
exit 1
fi
done < <(find "${REPO_ROOT}/test" -iname "*.sol" -and -not -name "documentation.sol")
echo