Yul object node names are std string instead of YulString

libsolidity/interface/StandardCompiler.cpp

@@ -1638,7 +1638,7 @@ Json StandardCompiler::compileYul(InputsAndSettings _inputsAndSettings)
  return output;
  }
 
- std::string contractName = stack.parserResult()->name.str();
+ std::string contractName = stack.parserResult()->name;
 
  bool const wildcardMatchesExperimental = true;
  if (isArtifactRequested(_inputsAndSettings.outputSelection, sourceName, contractName, "ir", wildcardMatchesExperimental))

libyul/AsmAnalysis.cpp

@@ -428,7 +428,7 @@ std::vector<YulString> AsmAnalyzer::operator()(FunctionCall const& _funCall)
  if (functionName == "datasize" || functionName == "dataoffset")
  {
  auto const& argumentAsLiteral = std::get<Literal>(arg);
- if (!m_dataNames.count(YulString(formatLiteral(argumentAsLiteral))))
+ if (!m_dataNames.count(formatLiteral(argumentAsLiteral)))
  m_errorReporter.typeError(
  3517_error,
  nativeLocationOf(arg),

libyul/AsmAnalysis.h

@@ -61,7 +61,7 @@ class AsmAnalyzer
  langutil::ErrorReporter& _errorReporter,
  Dialect const& _dialect,
  ExternalIdentifierAccess::Resolver _resolver = ExternalIdentifierAccess::Resolver(),
- std::set<YulString> _dataNames = {}
+ std::set<std::string> _dataNames = {}
  ):
  m_resolver(std::move(_resolver)),
  m_info(_analysisInfo),
@@ -128,7 +128,7 @@ class AsmAnalyzer
  langutil::EVMVersion m_evmVersion;
  Dialect const& m_dialect;
  /// Names of data objects to be referenced by builtin functions with literal arguments.
- std::set<YulString> m_dataNames;
+ std::set<std::string> m_dataNames;
  ForLoop const* m_currentForLoop = nullptr;
  /// Worst side effects encountered during analysis (including within defined functions).
  SideEffects m_sideEffects;

libyul/Object.cpp

@@ -40,7 +40,7 @@ using namespace solidity::yul;
 
 std::string Data::toString(Dialect const*, DebugInfoSelection const&, CharStreamProvider const*) const
 {
- return "data \"" + name.str() + "\" hex\"" + util::toHex(data) + "\"";
+ return "data \"" + name + "\" hex\"" + util::toHex(data) + "\"";
 }
 
 std::string Object::toString(
@@ -72,7 +72,7 @@ std::string Object::toString(
  for (auto const& obj: subObjects)
  inner += "\n" + obj->toString(_dialect, _debugInfoSelection, _soliditySourceProvider);
 
- return useSrcComment + "object \"" + name.str() + "\" {\n" + indent(inner) + "\n}";
+ return useSrcComment + "object \"" + name + "\" {\n" + indent(inner) + "\n}";
 }
 
 Json Data::toJson() const
@@ -97,62 +97,61 @@ Json Object::toJson() const
 
  Json ret;
  ret["nodeType"] = "YulObject";
- ret["name"] = name.str();
+ ret["name"] = name;
  ret["code"] = codeJson;
  ret["subObjects"] = subObjectsJson;
  return ret;
 }
 
-std::set<YulString> Object::qualifiedDataNames() const
+std::set<std::string> Object::qualifiedDataNames() const
 {
- std::set<YulString> qualifiedNames =
- name.empty() || util::contains(name.str(), '.') ?
- std::set<YulString>{} :
- std::set<YulString>{name};
+ std::set<std::string> qualifiedNames =
+ name.empty() || util::contains(name, '.') ?
+ std::set<std::string>{} :
+ std::set<std::string>{name};
  for (std::shared_ptr<ObjectNode> const& subObjectNode: subObjects)
  {
  yulAssert(qualifiedNames.count(subObjectNode->name) == 0, "");
- if (util::contains(subObjectNode->name.str(), '.'))
+ if (util::contains(subObjectNode->name, '.'))
  continue;
  qualifiedNames.insert(subObjectNode->name);
  if (auto const* subObject = dynamic_cast<Object const*>(subObjectNode.get()))
- for (YulString const& subSubObj: subObject->qualifiedDataNames())
+ for (auto const& subSubObj: subObject->qualifiedDataNames())
  if (subObject->name != subSubObj)
  {
- yulAssert(qualifiedNames.count(YulString{subObject->name.str() + "." + subSubObj.str()}) == 0, "");
- qualifiedNames.insert(YulString{subObject->name.str() + "." + subSubObj.str()});
+ yulAssert(qualifiedNames.count(subObject->name + "." + subSubObj) == 0, "");
+ qualifiedNames.insert(subObject->name + "." + subSubObj);
  }
  }
 
- yulAssert(qualifiedNames.count(YulString{}) == 0, "");
- qualifiedNames.erase(YulString{});
+ yulAssert(qualifiedNames.count("") == 0, "");
  return qualifiedNames;
 }
 
-std::vector<size_t> Object::pathToSubObject(YulString _qualifiedName) const
+std::vector<size_t> Object::pathToSubObject(std::string_view _qualifiedName) const
 {
  yulAssert(_qualifiedName != name, "");
  yulAssert(subIndexByName.count(name) == 0, "");
 
- if (boost::algorithm::starts_with(_qualifiedName.str(), name.str() + "."))
- _qualifiedName = YulString{_qualifiedName.str().substr(name.str().length() + 1)};
+ if (boost::algorithm::starts_with(_qualifiedName, name + "."))
+ _qualifiedName = _qualifiedName.substr(name.length() + 1);
  yulAssert(!_qualifiedName.empty(), "");
 
  std::vector<std::string> subObjectPathComponents;
- boost::algorithm::split(subObjectPathComponents, _qualifiedName.str(), boost::is_any_of("."));
+ boost::algorithm::split(subObjectPathComponents, _qualifiedName, boost::is_any_of("."));
 
  std::vector<size_t> path;
  Object const* object = this;
  for (std::string const& currentSubObjectName: subObjectPathComponents)
  {
  yulAssert(!currentSubObjectName.empty(), "");
- auto subIndexIt = object->subIndexByName.find(YulString{currentSubObjectName});
+ auto subIndexIt = object->subIndexByName.find(currentSubObjectName);
  yulAssert(
  subIndexIt != object->subIndexByName.end(),
- "Assembly object <" + _qualifiedName.str() + "> not found or does not contain code."
+ "Assembly object <" + std::string(_qualifiedName) + "> not found or does not contain code."
  );
  object = dynamic_cast<Object const*>(object->subObjects[subIndexIt->second].get());
- yulAssert(object, "Assembly object <" + _qualifiedName.str() + "> not found or does not contain code.");
+ yulAssert(object, "Assembly object <" + std::string(_qualifiedName) + "> not found or does not contain code.");
  yulAssert(object->subId != std::numeric_limits<size_t>::max(), "");
  path.push_back({object->subId});
  }

libyul/Object.h

@@ -52,7 +52,7 @@ struct ObjectNode
 
  /// Name of the object.
  /// Can be empty since .yul files can also just contain code, without explicitly placing it in an object.
- YulString name;
+ std::string name;
  virtual std::string toString(
  Dialect const* _dialect,
  langutil::DebugInfoSelection const& _debugInfoSelection,
@@ -66,7 +66,7 @@ struct ObjectNode
  */
 struct Data: public ObjectNode
 {
- Data(YulString _name, bytes _data): data(std::move(_data)) { name = _name; }
+ Data(std::string _name, bytes _data): data(std::move(_data)) { name = _name; }
 
  bytes data;
 
@@ -102,7 +102,7 @@ struct Object: public ObjectNode
  /// @returns the set of names of data objects accessible from within the code of
  /// this object, including the name of object itself
  /// Handles all names containing dots as reserved identifiers, not accessible as data.
- std::set<YulString> qualifiedDataNames() const;
+ std::set<std::string> qualifiedDataNames() const;
 
  /// @returns vector of subIDs if possible to reach subobject with @a _qualifiedName, throws otherwise
  /// For "B.C" should return vector of two values if success (subId of B and subId of C in B).
@@ -114,14 +114,14 @@ struct Object: public ObjectNode
  /// pathToSubObject("E2.F3.H4") == {1, 0, 2}
  /// pathToSubObject("A1.E2") == {1}
  /// The path must not lead to a @a Data object (will throw in that case).
- std::vector<size_t> pathToSubObject(YulString _qualifiedName) const;
+ std::vector<size_t> pathToSubObject(std::string_view _qualifiedName) const;
 
  /// sub id for object if it is subobject of another object, max value if it is not subobject
  size_t subId = std::numeric_limits<size_t>::max();
 
  std::shared_ptr<Block> code;
  std::vector<std::shared_ptr<ObjectNode>> subObjects;
- std::map<YulString, size_t> subIndexByName;
+ std::map<std::string, size_t, std::less<>> subIndexByName;
  std::shared_ptr<yul::AsmAnalysisInfo> analysisInfo;
 
  std::shared_ptr<ObjectDebugData const> debugData;

libyul/ObjectParser.cpp

@@ -50,7 +50,7 @@ std::shared_ptr<Object> ObjectParser::parse(std::shared_ptr<Scanner> const& _sca
  {
  // Special case: Code-only form.
  object = std::make_shared<Object>();
- object->name = "object"_yulstring;
+ object->name = "object";
  auto sourceNameMapping = tryParseSourceNameMapping();
  object->debugData = std::make_shared<ObjectDebugData>(ObjectDebugData{sourceNameMapping});
  object->code = parseBlock(sourceNameMapping);
@@ -185,7 +185,7 @@ void ObjectParser::parseData(Object& _containingObject)
  );
  advance();
 
- YulString name = parseUniqueName(&_containingObject);
+ auto const name = parseUniqueName(&_containingObject);
 
  if (currentToken() == Token::HexStringLiteral)
  expectToken(Token::HexStringLiteral, false);
@@ -195,22 +195,26 @@ void ObjectParser::parseData(Object& _containingObject)
  advance();
 }
 
-YulString ObjectParser::parseUniqueName(Object const* _containingObject)
+std::string ObjectParser::parseUniqueName(Object const* _containingObject)
 {
  expectToken(Token::StringLiteral, false);
- YulString name{currentLiteral()};
+ auto const name = currentLiteral();
  if (name.empty())
  parserError(3287_error, "Object name cannot be empty.");
  else if (_containingObject && _containingObject->name == name)
  parserError(8311_error, "Object name cannot be the same as the name of the containing object.");
  else if (_containingObject && _containingObject->subIndexByName.count(name))
- parserError(8794_error, "Object name \"" + name.str() + "\" already exists inside the containing object.");
+ parserError(8794_error, "Object name \"" + name + "\" already exists inside the containing object.");
  advance();
  return name;
 }
 
-void ObjectParser::addNamedSubObject(Object& _container, YulString _name, std::shared_ptr<ObjectNode> _subObject)
+void ObjectParser::addNamedSubObject(Object& _container, std::string_view const _name, std::shared_ptr<ObjectNode> _subObject)
 {
- _container.subIndexByName[_name] = _container.subObjects.size();
+ _container.subIndexByName.emplace(
+ std::piecewise_construct,
+ std::forward_as_tuple(_name),
+ std::forward_as_tuple(_container.subObjects.size())
+ );
  _container.subObjects.emplace_back(std::move(_subObject));
 }

libyul/ObjectParser.h

@@ -63,8 +63,8 @@ class ObjectParser: public langutil::ParserBase
  void parseData(Object& _containingObject);
 
  /// Tries to parse a name that is non-empty and unique inside the containing object.
- YulString parseUniqueName(Object const* _containingObject);
- void addNamedSubObject(Object& _container, YulString _name, std::shared_ptr<ObjectNode> _subObject);
+ std::string parseUniqueName(Object const* _containingObject);
+ void addNamedSubObject(Object& _container, std::string_view _name, std::shared_ptr<ObjectNode> _subObject);
 
  Dialect const& m_dialect;
 };

libyul/YulStack.cpp

@@ -198,7 +198,7 @@ void YulStack::optimize(Object& _object, bool _isCreation)
  for (auto& subNode: _object.subObjects)
  if (auto subObject = dynamic_cast<Object*>(subNode.get()))
  {
- bool isCreation = !boost::ends_with(subObject->name.str(), "_deployed");
+ bool isCreation = !boost::ends_with(subObject->name, "_deployed");
  optimize(*subObject, isCreation);
  }
 

libyul/backends/evm/EVMDialect.cpp

@@ -249,14 +249,14 @@ std::map<YulString, BuiltinFunctionForEVM> createBuiltins(langutil::EVMVersion _
  yulAssert(_call.arguments.size() == 1, "");
  Expression const& arg = _call.arguments.front();
  YulString const dataName (formatLiteral(std::get<Literal>(arg)));
- if (_context.currentObject->name == dataName)
+ if (_context.currentObject->name == dataName.str())
  _assembly.appendAssemblySize();
  else
  {
  std::vector<size_t> subIdPath =
- _context.subIDs.count(dataName) == 0 ?
- _context.currentObject->pathToSubObject(dataName) :
- std::vector<size_t>{_context.subIDs.at(dataName)};
+ _context.subIDs.count(dataName.str()) == 0 ?
+ _context.currentObject->pathToSubObject(dataName.str()) :
+ std::vector<size_t>{_context.subIDs.at(dataName.str())};
  yulAssert(!subIdPath.empty(), "Could not find assembly object <" + dataName.str() + ">.");
  _assembly.appendDataSize(subIdPath);
  }
@@ -270,14 +270,14 @@ std::map<YulString, BuiltinFunctionForEVM> createBuiltins(langutil::EVMVersion _
  yulAssert(_call.arguments.size() == 1, "");
  Expression const& arg = _call.arguments.front();
  YulString const dataName (formatLiteral(std::get<Literal>(arg)));
- if (_context.currentObject->name == dataName)
+ if (_context.currentObject->name == dataName.str())
  _assembly.appendConstant(0);
  else
  {
  std::vector<size_t> subIdPath =
- _context.subIDs.count(dataName) == 0 ?
- _context.currentObject->pathToSubObject(dataName) :
- std::vector<size_t>{_context.subIDs.at(dataName)};
+ _context.subIDs.count(dataName.str()) == 0 ?
+ _context.currentObject->pathToSubObject(dataName.str()) :
+ std::vector<size_t>{_context.subIDs.at(dataName.str())};
  yulAssert(!subIdPath.empty(), "Could not find assembly object <" + dataName.str() + ">.");
  _assembly.appendDataOffset(subIdPath);
  }

libyul/backends/evm/EVMDialect.h

@@ -45,7 +45,7 @@ struct BuiltinContext
 {
  Object const* currentObject = nullptr;
  /// Mapping from named objects to abstract assembly sub IDs.
- std::map<YulString, AbstractAssembly::SubID> subIDs;
+ std::map<std::string, AbstractAssembly::SubID> subIDs;
 };
 
 struct BuiltinFunctionForEVM: public BuiltinFunction

libyul/backends/evm/EVMObjectCompiler.cpp

@@ -55,8 +55,8 @@ void EVMObjectCompiler::run(Object& _object, bool _optimize)
  for (auto const& subNode: _object.subObjects)
  if (auto* subObject = dynamic_cast<Object*>(subNode.get()))
  {
- bool isCreation = !boost::ends_with(subObject->name.str(), "_deployed");
- auto subAssemblyAndID = m_assembly.createSubAssembly(isCreation, subObject->name.str());
+ bool isCreation = !boost::ends_with(subObject->name, "_deployed");
+ auto subAssemblyAndID = m_assembly.createSubAssembly(isCreation, subObject->name);
  context.subIDs[subObject->name] = subAssemblyAndID.second;
  subObject->subId = subAssemblyAndID.second;
  compile(*subObject, *subAssemblyAndID.first, m_dialect, _optimize, m_eofVersion);
@@ -65,7 +65,7 @@ void EVMObjectCompiler::run(Object& _object, bool _optimize)
  {
  Data const& data = dynamic_cast<Data const&>(*subNode);
  // Special handling of metadata.
- if (data.name.str() == Object::metadataName())
+ if (data.name == Object::metadataName())
  m_assembly.appendToAuxiliaryData(data.data);
  else
  context.subIDs[data.name] = m_assembly.appendData(data.data);

test/libsolidity/MemoryGuardTest.cpp

@@ -80,7 +80,7 @@ TestCase::TestResult MemoryGuardTest::run(std::ostream& _stream, std::string con
  };
  handleObject("creation", *object);
  size_t deployedIndex = object->subIndexByName.at(
- YulString(IRNames::deployedObject(compiler().contractDefinition(contractName)))
+ IRNames::deployedObject(compiler().contractDefinition(contractName))
  );
  handleObject("runtime", dynamic_cast<Object const&>(*object->subObjects[deployedIndex]));
  }

tools/yulPhaser/Program.cpp

@@ -135,7 +135,7 @@ std::variant<std::unique_ptr<Block>, ErrorList> Program::parseObject(Dialect con
  // The other object references the nested one which makes analysis fail. Below we try to
  // extract just the nested one for that reason. This is just a heuristic. If there's no
  // subobject with such a suffix we fall back to accepting the whole object as is.
- if (subObject != nullptr && subObject->name.str() == object->name.str() + "_deployed")
+ if (subObject != nullptr && subObject->name == object->name + "_deployed")
  {
  deployedObject = dynamic_cast<Object*>(subObject.get());
  if (deployedObject != nullptr)