WIP

Author: erak

test/libsolidity/util/compiler/Compiler.cpp

@@ -16,6 +16,16 @@ std::optional<CompiledContract> CompilerOutput::contract(
     if (pos != m_sourceUnits.end())
         contracts = pos->second;
 
+    std::cout << "_name: " << _name.source() << ":" << _name.contract() << std::endl;
+
+    for (auto su: m_sourceUnits)
+    {
+        std::cout << "sourceUnit: " << su.first << std::endl;
+        for (auto c: su.second) {
+            std::cout << "  name: " << c.name << std::endl;
+        }
+    }
+
     if (contracts.empty())
         return std::nullopt;
 

test/libsolidity/util/compiler/InternalCompiler.cpp

@@ -75,42 +75,37 @@ std::pair<MappedContracts, Errors> InternalCompiler::compile()
     m_stack.compile();
 
     auto mappedContracts = MappedContracts{};
-    for (auto sourceName: m_stack.sourceNames())
+
+    std::cout << std::endl << "[ENTER] InternalCompiler::compile()" << std::endl;
+    for (auto const& contractName: m_stack.contractNames())
     {
-        std::vector<CompiledContract> contracts;
+        auto compiledContract = assembleContract(contractName);
 
-        auto const& sourceUnit = m_stack.ast(sourceName);
-        for (auto const* contract: ASTNode::filteredNodes<ContractDefinition>(sourceUnit.nodes()))
+        ContractName name{contractName};
+        if (auto pos = mappedContracts.find(name.source()); pos != mappedContracts.end())
+            pos->second.emplace_back(compiledContract);
+        else
         {
-            auto contractName = contract->fullyQualifiedName();
-            auto object = m_stack.object(contractName);
-            auto runtimeObject = m_stack.runtimeObject(contractName);
-            auto hasUnlinkedReferences = !object.linkReferences.empty();
-            auto assemblyItems = m_stack.assemblyItems(contractName);
-            auto runtimeAssemblyItems = m_stack.runtimeAssemblyItems(contractName);
-            auto metadata = m_stack.metadata(contractName);
-            auto cborMetadata = m_stack.cborMetadata(contractName);
-            auto contractABI = m_stack.contractABI(contractName);
-            auto interfaceSymbols = m_stack.interfaceSymbols(contractName);
-            auto eventSignatures = generateEventSignatures(contractName);
-
-            auto compiledContract = CompiledContract{
-                contractName,
-                object.bytecode,
-                runtimeObject.bytecode,
-                hasUnlinkedReferences,
-                assemblyItems != nullptr ? *assemblyItems : evmasm::AssemblyItems{},
-                runtimeAssemblyItems != nullptr ? *runtimeAssemblyItems : evmasm::AssemblyItems{},
-                metadata,
-                cborMetadata,
-                contractABI,
-                interfaceSymbols,
-                eventSignatures
-            };
-            contracts.emplace_back(compiledContract);
+            std::vector<CompiledContract> contracts{compiledContract};
+            mappedContracts.insert(std::make_pair(name.source(), contracts));
         }
-        mappedContracts.insert(std::make_pair(sourceName, contracts));
     }
+        
+    
+    
+    // for (auto sourceName: m_stack.sourceNames())
+    // {
+    //     std::cout << "sourceName: " << sourceName << std::endl; 
+    //     std::vector<CompiledContract> contracts;
+
+    //     auto const& sourceUnit = m_stack.ast(sourceName);
+    //     for (auto const* contract: ASTNode::filteredNodes<ContractDefinition>(sourceUnit.nodes()))
+    //     {
+            
+    //         contracts.emplace_back(compiledContract);
+    //     }
+    //     mappedContracts.insert(std::make_pair(sourceName, contracts));
+    // }
 
     return std::make_pair(mappedContracts, m_stack.errors());
 }
@@ -163,3 +158,33 @@ std::string InternalCompiler::formatErrorInformation() const
 
     return errorInformation;
 }
+
+CompiledContract InternalCompiler::assembleContract(
+    std::string const& _contractName
+) const
+{
+    auto object = m_stack.object(_contractName);
+    auto runtimeObject = m_stack.runtimeObject(_contractName);
+    auto hasUnlinkedReferences = !object.linkReferences.empty();
+    auto assemblyItems = m_stack.assemblyItems(_contractName);
+    auto runtimeAssemblyItems = m_stack.runtimeAssemblyItems(_contractName);
+    auto metadata = m_stack.metadata(_contractName);
+    auto cborMetadata = m_stack.cborMetadata(_contractName);
+    auto contractABI = m_stack.contractABI(_contractName);
+    auto interfaceSymbols = m_stack.interfaceSymbols(_contractName);
+    auto eventSignatures = generateEventSignatures(_contractName);
+
+    return CompiledContract{
+        _contractName,
+        object.bytecode,
+        runtimeObject.bytecode,
+        hasUnlinkedReferences,
+        assemblyItems != nullptr ? *assemblyItems : evmasm::AssemblyItems{},
+        runtimeAssemblyItems != nullptr ? *runtimeAssemblyItems : evmasm::AssemblyItems{},
+        metadata,
+        cborMetadata,
+        contractABI,
+        interfaceSymbols,
+        eventSignatures
+    };
+}

test/libsolidity/util/compiler/InternalCompiler.h

@@ -61,6 +61,8 @@ class InternalCompiler
 		std::string const& _contractName
 	) const;
 
+	CompiledContract assembleContract(std::string const& _contractName) const;
+
 	/// @returns a formatted output of all errors that occurred during
 	/// compilation.
 	std::string formatErrorInformation() const;