/*

  This file is part of solidity.

  solidity is free software: you can redistribute it and/or modify

  it under the terms of the GNU General Public License as published by

  the Free Software Foundation, either version 3 of the License, or

  (at your option) any later version.

  solidity is distributed in the hope that it will be useful,

  but WITHOUT ANY WARRANTY; without even the implied warranty of

  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  GNU General Public License for more details.

  You should have received a copy of the GNU General Public License

  along with solidity.  If not, see <http://www.gnu.org/licenses/>.

*/

// SPDX-License-Identifier: GPL-3.0

/**

 * @author julius <djudju@protonmail.com>

 * @date 2019

 * Converts an inlineAssembly AST from JSON format to AsmData

 */

#include <libyul/AsmJsonImporter.h>

#include <libyul/AST.h>

#include <libyul/Dialect.h>

#include <libyul/Exceptions.h>

#include <libyul/Utilities.h>

#include <liblangutil/Exceptions.h>

#include <liblangutil/Scanner.h>

#include <boost/algorithm/string/split.hpp>

#include <boost/algorithm/string.hpp>

#include <vector>

using namespace solidity::langutil;

namespace solidity::yul

{

using SourceLocation = langutil::SourceLocation;

SourceLocation const AsmJsonImporter::createSourceLocation(Json const& _node)

{

  yulAssert(member(_node, "src").is_string(), "'src' must be a string");

  return solidity::langutil::parseSourceLocation(_node["src"].get<std::string>(), m_sourceNames);

}

AST AsmJsonImporter::createAST(solidity::Json const& _node)

{

  return {m_dialect, createBlock(_node)};

}

template <class T>

T AsmJsonImporter::createAsmNode(Json const& _node)

{

  T r;

  SourceLocation nativeLocation = createSourceLocation(_node);

  yulAssert(nativeLocation.hasText(), "Invalid source location in Asm AST");

  // TODO: We should add originLocation to the AST.

  // While it's not included, we'll use nativeLocation for it because we only support importing

  // inline assembly as a part of a Solidity AST and there these locations are always the same.

  r.debugData = DebugData::create(nativeLocation, nativeLocation);

  return r;

}

Unexecuted instantiation: solidity::yul::NameWithDebugData solidity::yul::AsmJsonImporter::createAsmNode<solidity::yul::NameWithDebugData>(nlohmann::json_abi_v3_12_0::basic_json<std::__1::map, std::__1::vector, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, bool, long, unsigned long, double, std::__1::allocator, nlohmann::json_abi_v3_12_0::adl_serializer, std::__1::vector<unsigned char, std::__1::allocator<unsigned char> >, void> const&)

Unexecuted instantiation: solidity::yul::Block solidity::yul::AsmJsonImporter::createAsmNode<solidity::yul::Block>(nlohmann::json_abi_v3_12_0::basic_json<std::__1::map, std::__1::vector, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, bool, long, unsigned long, double, std::__1::allocator, nlohmann::json_abi_v3_12_0::adl_serializer, std::__1::vector<unsigned char, std::__1::allocator<unsigned char> >, void> const&)

Unexecuted instantiation: solidity::yul::Literal solidity::yul::AsmJsonImporter::createAsmNode<solidity::yul::Literal>(nlohmann::json_abi_v3_12_0::basic_json<std::__1::map, std::__1::vector, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, bool, long, unsigned long, double, std::__1::allocator, nlohmann::json_abi_v3_12_0::adl_serializer, std::__1::vector<unsigned char, std::__1::allocator<unsigned char> >, void> const&)

Unexecuted instantiation: solidity::yul::Leave solidity::yul::AsmJsonImporter::createAsmNode<solidity::yul::Leave>(nlohmann::json_abi_v3_12_0::basic_json<std::__1::map, std::__1::vector, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, bool, long, unsigned long, double, std::__1::allocator, nlohmann::json_abi_v3_12_0::adl_serializer, std::__1::vector<unsigned char, std::__1::allocator<unsigned char> >, void> const&)

Unexecuted instantiation: solidity::yul::Identifier solidity::yul::AsmJsonImporter::createAsmNode<solidity::yul::Identifier>(nlohmann::json_abi_v3_12_0::basic_json<std::__1::map, std::__1::vector, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, bool, long, unsigned long, double, std::__1::allocator, nlohmann::json_abi_v3_12_0::adl_serializer, std::__1::vector<unsigned char, std::__1::allocator<unsigned char> >, void> const&)

Unexecuted instantiation: solidity::yul::Assignment solidity::yul::AsmJsonImporter::createAsmNode<solidity::yul::Assignment>(nlohmann::json_abi_v3_12_0::basic_json<std::__1::map, std::__1::vector, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, bool, long, unsigned long, double, std::__1::allocator, nlohmann::json_abi_v3_12_0::adl_serializer, std::__1::vector<unsigned char, std::__1::allocator<unsigned char> >, void> const&)

Unexecuted instantiation: solidity::yul::FunctionCall solidity::yul::AsmJsonImporter::createAsmNode<solidity::yul::FunctionCall>(nlohmann::json_abi_v3_12_0::basic_json<std::__1::map, std::__1::vector, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, bool, long, unsigned long, double, std::__1::allocator, nlohmann::json_abi_v3_12_0::adl_serializer, std::__1::vector<unsigned char, std::__1::allocator<unsigned char> >, void> const&)

Unexecuted instantiation: solidity::yul::BuiltinName solidity::yul::AsmJsonImporter::createAsmNode<solidity::yul::BuiltinName>(nlohmann::json_abi_v3_12_0::basic_json<std::__1::map, std::__1::vector, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, bool, long, unsigned long, double, std::__1::allocator, nlohmann::json_abi_v3_12_0::adl_serializer, std::__1::vector<unsigned char, std::__1::allocator<unsigned char> >, void> const&)

Unexecuted instantiation: solidity::yul::ExpressionStatement solidity::yul::AsmJsonImporter::createAsmNode<solidity::yul::ExpressionStatement>(nlohmann::json_abi_v3_12_0::basic_json<std::__1::map, std::__1::vector, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, bool, long, unsigned long, double, std::__1::allocator, nlohmann::json_abi_v3_12_0::adl_serializer, std::__1::vector<unsigned char, std::__1::allocator<unsigned char> >, void> const&)

Unexecuted instantiation: solidity::yul::VariableDeclaration solidity::yul::AsmJsonImporter::createAsmNode<solidity::yul::VariableDeclaration>(nlohmann::json_abi_v3_12_0::basic_json<std::__1::map, std::__1::vector, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, bool, long, unsigned long, double, std::__1::allocator, nlohmann::json_abi_v3_12_0::adl_serializer, std::__1::vector<unsigned char, std::__1::allocator<unsigned char> >, void> const&)

Unexecuted instantiation: solidity::yul::FunctionDefinition solidity::yul::AsmJsonImporter::createAsmNode<solidity::yul::FunctionDefinition>(nlohmann::json_abi_v3_12_0::basic_json<std::__1::map, std::__1::vector, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, bool, long, unsigned long, double, std::__1::allocator, nlohmann::json_abi_v3_12_0::adl_serializer, std::__1::vector<unsigned char, std::__1::allocator<unsigned char> >, void> const&)

Unexecuted instantiation: solidity::yul::If solidity::yul::AsmJsonImporter::createAsmNode<solidity::yul::If>(nlohmann::json_abi_v3_12_0::basic_json<std::__1::map, std::__1::vector, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, bool, long, unsigned long, double, std::__1::allocator, nlohmann::json_abi_v3_12_0::adl_serializer, std::__1::vector<unsigned char, std::__1::allocator<unsigned char> >, void> const&)

Unexecuted instantiation: solidity::yul::Case solidity::yul::AsmJsonImporter::createAsmNode<solidity::yul::Case>(nlohmann::json_abi_v3_12_0::basic_json<std::__1::map, std::__1::vector, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, bool, long, unsigned long, double, std::__1::allocator, nlohmann::json_abi_v3_12_0::adl_serializer, std::__1::vector<unsigned char, std::__1::allocator<unsigned char> >, void> const&)

Unexecuted instantiation: solidity::yul::Switch solidity::yul::AsmJsonImporter::createAsmNode<solidity::yul::Switch>(nlohmann::json_abi_v3_12_0::basic_json<std::__1::map, std::__1::vector, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, bool, long, unsigned long, double, std::__1::allocator, nlohmann::json_abi_v3_12_0::adl_serializer, std::__1::vector<unsigned char, std::__1::allocator<unsigned char> >, void> const&)

Unexecuted instantiation: solidity::yul::ForLoop solidity::yul::AsmJsonImporter::createAsmNode<solidity::yul::ForLoop>(nlohmann::json_abi_v3_12_0::basic_json<std::__1::map, std::__1::vector, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, bool, long, unsigned long, double, std::__1::allocator, nlohmann::json_abi_v3_12_0::adl_serializer, std::__1::vector<unsigned char, std::__1::allocator<unsigned char> >, void> const&)

Unexecuted instantiation: solidity::yul::Break solidity::yul::AsmJsonImporter::createAsmNode<solidity::yul::Break>(nlohmann::json_abi_v3_12_0::basic_json<std::__1::map, std::__1::vector, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, bool, long, unsigned long, double, std::__1::allocator, nlohmann::json_abi_v3_12_0::adl_serializer, std::__1::vector<unsigned char, std::__1::allocator<unsigned char> >, void> const&)

Unexecuted instantiation: solidity::yul::Continue solidity::yul::AsmJsonImporter::createAsmNode<solidity::yul::Continue>(nlohmann::json_abi_v3_12_0::basic_json<std::__1::map, std::__1::vector, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, bool, long, unsigned long, double, std::__1::allocator, nlohmann::json_abi_v3_12_0::adl_serializer, std::__1::vector<unsigned char, std::__1::allocator<unsigned char> >, void> const&)

Json AsmJsonImporter::member(Json const& _node, std::string const& _name)

{

  if (!_node.contains(_name))

    return Json();

  return _node[_name];

}

NameWithDebugData AsmJsonImporter::createNameWithDebugData(Json const& _node)

{

  auto nameWithDebugData = createAsmNode<NameWithDebugData>(_node);

  nameWithDebugData.name = YulName{member(_node, "name").get<std::string>()};

  return nameWithDebugData;

}

Statement AsmJsonImporter::createStatement(Json const& _node)

{

  Json jsonNodeType = member(_node, "nodeType");

  yulAssert(jsonNodeType.is_string(), "Expected \"nodeType\" to be of type string!");

  std::string nodeType = jsonNodeType.get<std::string>();

  yulAssert(nodeType.substr(0, 3) == "Yul", "Invalid nodeType prefix");

  nodeType = nodeType.substr(3);

  if (nodeType == "ExpressionStatement")

    return createExpressionStatement(_node);

  else if (nodeType == "Assignment")

    return createAssignment(_node);

  else if (nodeType == "VariableDeclaration")

    return createVariableDeclaration(_node);

  else if (nodeType == "FunctionDefinition")

    return createFunctionDefinition(_node);

  else if (nodeType == "If")

    return createIf(_node);

  else if (nodeType == "Switch")

    return createSwitch(_node);

  else if (nodeType == "ForLoop")

    return createForLoop(_node);

  else if (nodeType == "Break")

    return createBreak(_node);

  else if (nodeType == "Continue")

    return createContinue(_node);

  else if (nodeType == "Leave")

    return createLeave(_node);

  else if (nodeType == "Block")

    return createBlock(_node);

  else

    yulAssert(false, "Invalid nodeType as statement");

  // FIXME: Workaround for spurious GCC 12.1 warning (https://gcc.gnu.org/bugzilla/show_bug.cgi?id=105794)

  util::unreachable();

}

Expression AsmJsonImporter::createExpression(Json const& _node)

{

  Json jsonNodeType = member(_node, "nodeType");

  yulAssert(jsonNodeType.is_string(), "Expected \"nodeType\" to be of type string!");

  std::string nodeType = jsonNodeType.get<std::string>();

  yulAssert(nodeType.substr(0, 3) == "Yul", "Invalid nodeType prefix");

  nodeType = nodeType.substr(3);

  if (nodeType == "FunctionCall")

    return createFunctionCall(_node);

  else if (nodeType == "Identifier")

    return createIdentifier(_node);

  else if (nodeType == "Literal")

    return createLiteral(_node);

  else

    yulAssert(false, "Invalid nodeType as expression");

  // FIXME: Workaround for spurious GCC 12.1 warning (https://gcc.gnu.org/bugzilla/show_bug.cgi?id=105794)

  util::unreachable();

}

std::vector<Expression> AsmJsonImporter::createExpressionVector(Json const& _array)

{

  std::vector<Expression> ret;

  for (auto& var: _array)

    ret.emplace_back(createExpression(var));

  return ret;

}

std::vector<Statement> AsmJsonImporter::createStatementVector(Json const& _array)

{

  std::vector<Statement> ret;

  for (auto& var: _array)

    ret.emplace_back(createStatement(var));

  return ret;

}

Block AsmJsonImporter::createBlock(Json const& _node)

{

  auto block = createAsmNode<Block>(_node);

  block.statements = createStatementVector(_node["statements"]);

  return block;

}

Literal AsmJsonImporter::createLiteral(Json const& _node)

{

  auto lit = createAsmNode<Literal>(_node);

  std::string kind = member(_node, "kind").get<std::string>();

  solAssert(member(_node, "hexValue").is_string() || member(_node, "value").is_string(), "");

  std::string value;

  if (_node.contains("hexValue"))

    value = util::asString(util::fromHex(member(_node, "hexValue").get<std::string>()));

  else

    value = member(_node, "value").get<std::string>();

  {

    auto const typeNode = member(_node, "type");

    yulAssert(

      typeNode.empty() || typeNode.get<std::string>().empty(),

      fmt::format(

        "Expected literal types to be either empty or absent in the JSON. Got \"{}\".",

        typeNode.get<std::string>()

      )

    );

  }

  if (kind == "number")

  {

    langutil::CharStream charStream(value, "");

    langutil::Scanner scanner{charStream};

    lit.kind = LiteralKind::Number;

    yulAssert(

      scanner.currentToken() == Token::Number,

      "Expected number but got " + langutil::TokenTraits::friendlyName(scanner.currentToken()) + std::string(" while scanning ") + value

    );

  }

  else if (kind == "bool")

  {

    langutil::CharStream charStream(value, "");

    langutil::Scanner scanner{charStream};

    lit.kind = LiteralKind::Boolean;

    yulAssert(

      scanner.currentToken() == Token::TrueLiteral ||

      scanner.currentToken() == Token::FalseLiteral,

      "Expected true/false literal!"

    );

  }

  else if (kind == "string")

  {

    lit.kind = LiteralKind::String;

    yulAssert(

      value.size() <= 32,

      "String literal too long (" + std::to_string(value.size()) + " > 32)"

    );

  }

  else

    yulAssert(false, "unknown type of literal");

  // import only for inline assembly, no unlimited string literals there

  lit.value = valueOfLiteral(value, lit.kind, false /* _unlimitedLiteralArgument */);

  yulAssert(validLiteral(lit));

  return lit;

}

Leave AsmJsonImporter::createLeave(Json const& _node)

{

  return createAsmNode<Leave>(_node);

}

Identifier AsmJsonImporter::createIdentifier(Json const& _node)

{

  auto identifier = createAsmNode<Identifier>(_node);

  identifier.name = YulName(member(_node, "name").get<std::string>());

  return identifier;

}

Assignment AsmJsonImporter::createAssignment(Json const& _node)

{

  auto assignment = createAsmNode<Assignment>(_node);

  if (_node.contains("variableNames"))

    for (auto const& var: member(_node, "variableNames"))

      assignment.variableNames.emplace_back(createIdentifier(var));

  assignment.value = std::make_unique<Expression>(createExpression(member(_node, "value")));

  return assignment;

}

FunctionCall AsmJsonImporter::createFunctionCall(Json const& _node)

{

  auto functionCall = createAsmNode<FunctionCall>(_node);

  for (auto const& var: member(_node, "arguments"))

    functionCall.arguments.emplace_back(createExpression(var));

  auto const functionNameNode = member(_node, "functionName");

  auto const name = member(functionNameNode, "name").get<std::string>();

  if (std::optional<BuiltinHandle> builtinHandle = m_dialect.findBuiltin(name))

  {

    auto builtin = createAsmNode<BuiltinName>(functionNameNode);

    builtin.handle = *builtinHandle;

    functionCall.functionName = builtin;

  }

  else

    functionCall.functionName = createIdentifier(functionNameNode);

  return functionCall;

}

ExpressionStatement AsmJsonImporter::createExpressionStatement(Json const& _node)

{

  auto statement = createAsmNode<ExpressionStatement>(_node);

  statement.expression = createExpression(member(_node, "expression"));

  return statement;

}

VariableDeclaration AsmJsonImporter::createVariableDeclaration(Json const& _node)

{

  auto varDec = createAsmNode<VariableDeclaration>(_node);

  for (auto const& var: member(_node, "variables"))

    varDec.variables.emplace_back(createNameWithDebugData(var));

  if (_node.contains("value"))

    varDec.value = std::make_unique<Expression>(createExpression(member(_node, "value")));

  return varDec;

}

FunctionDefinition AsmJsonImporter::createFunctionDefinition(Json const& _node)

{

  auto funcDef = createAsmNode<FunctionDefinition>(_node);

  funcDef.name = YulName{member(_node, "name").get<std::string>()};

  if (_node.contains("parameters"))

    for (auto const& var: member(_node, "parameters"))

      funcDef.parameters.emplace_back(createNameWithDebugData(var));

  if (_node.contains("returnVariables"))

    for (auto const& var: member(_node, "returnVariables"))

      funcDef.returnVariables.emplace_back(createNameWithDebugData(var));

  funcDef.body = createBlock(member(_node, "body"));

  return funcDef;

}

If AsmJsonImporter::createIf(Json const& _node)

{

  auto ifStatement = createAsmNode<If>(_node);

  ifStatement.condition = std::make_unique<Expression>(createExpression(member(_node, "condition")));

  ifStatement.body = createBlock(member(_node, "body"));

  return ifStatement;

}

Case AsmJsonImporter::createCase(Json const& _node)

{

  auto caseStatement = createAsmNode<Case>(_node);

  auto const& value = member(_node, "value");

  if (value.is_string())

    yulAssert(value.get<std::string>() == "default", "Expected default case");

  else

    caseStatement.value = std::make_unique<Literal>(createLiteral(value));

  caseStatement.body = createBlock(member(_node, "body"));

  return caseStatement;

}

Switch AsmJsonImporter::createSwitch(Json const& _node)

{

  auto switchStatement = createAsmNode<Switch>(_node);

  switchStatement.expression = std::make_unique<Expression>(createExpression(member(_node, "expression")));

  for (auto const& var: member(_node, "cases"))

    switchStatement.cases.emplace_back(createCase(var));

  return switchStatement;

}

ForLoop AsmJsonImporter::createForLoop(Json const& _node)

{

  auto forLoop = createAsmNode<ForLoop>(_node);

  forLoop.pre = createBlock(member(_node, "pre"));

  forLoop.condition = std::make_unique<Expression>(createExpression(member(_node, "condition")));

  forLoop.post = createBlock(member(_node, "post"));

  forLoop.body = createBlock(member(_node, "body"));

  return forLoop;

}

Break AsmJsonImporter::createBreak(Json const& _node)

{

  return createAsmNode<Break>(_node);

}

Continue AsmJsonImporter::createContinue(Json const& _node)

{

  return createAsmNode<Continue>(_node);

}

}