WIP

Author: GordonSmith

test/generate_test_stubs.cpp

@@ -381,7 +381,20 @@ std::pair<bool, std::string> generate_stub(const fs::path &wit_file,
 
     if (status != 0)
     {
-        std::string error_msg = output.empty() ? "Unknown error" : output;
+        std::string error_msg;
+        if (output.empty())
+        {
+            error_msg = "Process exited with code " + std::to_string(status);
+            // Common Windows exit codes
+            if (status == -1073741819 || status == 3221225477) // 0xC0000005 = Access violation
+            {
+                error_msg += " (segmentation fault/access violation)";
+            }
+        }
+        else
+        {
+            error_msg = output;
+        }
         return {false, error_msg};
     }
 
@@ -717,10 +730,7 @@ int main(int argc, char *argv[])
         for (const auto &[file, error] : failures)
         {
             std::cout << "  - " << file << std::endl;
-            if (verbose)
-            {
-                std::cout << "    Error: " << error << std::endl;
-            }
+            std::cout << "    Error: " << error << std::endl;
         }
     }
 

tools/wit-codegen/package_registry.cpp

@@ -3,6 +3,7 @@
 #include <algorithm>
 #include <regex>
 #include <sstream>
+#include <fstream>
 
 // PackageId implementation
 
@@ -124,33 +125,56 @@ bool PackageRegistry::load_package(const std::filesystem::path &path)
         // Parse the WIT file
         auto parse_result = WitGrammarParser::parse(path.string());
 
-        // Skip if no package name defined (these are interface-only files that will be
-        // loaded as part of their parent package)
+        // If no package name defined, try to infer it from directory structure or sibling files
+        PackageId package_id_val;
         if (parse_result.packageName.empty())
         {
-            return true; // Not an error - just skip interface-only files
+            auto inferred_id = infer_package_from_path(path);
+            if (!inferred_id)
+            {
+                // Can't infer package - skip this file
+                return true; // Not an error, just skip
+            }
+            package_id_val = *inferred_id;
         }
-
-        // Parse package ID from package name
-        auto package_id = PackageId::parse(parse_result.packageName);
-        if (!package_id)
+        else
         {
-            return false;
+            // Parse package ID from package name
+            auto package_id = PackageId::parse(parse_result.packageName);
+            if (!package_id)
+            {
+                return false;
+            }
+            package_id_val = *package_id;
         }
 
-        // Create package
-        auto package = std::make_unique<WitPackage>();
-        package->id = *package_id;
-        package->source_path = path;
+        // Check if package already exists in registry
+        auto *existing_package = get_package(package_id_val);
 
-        // Add all interfaces
-        for (const auto &interface : parse_result.interfaces)
+        if (existing_package)
         {
-            package->add_interface(interface);
+            // Package already exists - merge interfaces into it
+            for (const auto &interface : parse_result.interfaces)
+            {
+                existing_package->add_interface(interface);
+            }
+        }
+        else
+        {
+            // Create new package
+            auto package = std::make_unique<WitPackage>();
+            package->id = package_id_val;
+            package->source_path = path;
+
+            // Add all interfaces
+            for (const auto &interface : parse_result.interfaces)
+            {
+                package->add_interface(interface);
+            }
+
+            // Add to registry
+            add_package(std::move(package));
         }
-
-        // Add to registry
-        add_package(std::move(package));
 
         return true;
     }
@@ -161,6 +185,81 @@ bool PackageRegistry::load_package(const std::filesystem::path &path)
     }
 }
 
+std::optional<PackageId> PackageRegistry::infer_package_from_path(const std::filesystem::path &path)
+{
+    // Check sibling files in the same directory for package declarations
+    auto parent_dir = path.parent_path();
+
+    try
+    {
+        for (const auto &entry : std::filesystem::directory_iterator(parent_dir))
+        {
+            if (entry.is_regular_file() &&
+                entry.path().extension() == ".wit" &&
+                entry.path() != path)
+            {
+                try
+                {
+                    // Read first 1KB of the file to check for package declaration
+                    // This avoids full parsing which could cause issues
+                    std::ifstream file(entry.path());
+                    if (!file.is_open())
+                        continue;
+
+                    std::string content;
+                    std::string line;
+                    size_t bytes_read = 0;
+                    const size_t MAX_BYTES = 1024;
+
+                    while (std::getline(file, line) && bytes_read < MAX_BYTES)
+                    {
+                        bytes_read += line.size() + 1;
+                        content += line + "\n";
+
+                        // Look for "package namespace:name@version;" pattern
+                        size_t package_pos = line.find("package");
+                        if (package_pos != std::string::npos)
+                        {
+                            // Extract the package name
+                            size_t start = package_pos + 7; // After "package"
+                            // Skip whitespace
+                            while (start < line.size() && std::isspace(line[start]))
+                                start++;
+
+                            // Find the semicolon
+                            size_t end = line.find(';', start);
+                            if (end != std::string::npos)
+                            {
+                                std::string package_spec = line.substr(start, end - start);
+                                // Trim trailing whitespace
+                                while (!package_spec.empty() && std::isspace(package_spec.back()))
+                                    package_spec.pop_back();
+
+                                auto package_id = PackageId::parse(package_spec);
+                                if (package_id)
+                                {
+                                    return package_id;
+                                }
+                            }
+                        }
+                    }
+                }
+                catch (...)
+                {
+                    // Ignore errors reading sibling files
+                    continue;
+                }
+            }
+        }
+    }
+    catch (...)
+    {
+        // Directory iteration error
+    }
+
+    return std::nullopt;
+}
+
 WitPackage *PackageRegistry::get_package(const PackageId &id)
 {
     auto key = id.to_string();

tools/wit-codegen/package_registry.hpp

@@ -137,6 +137,14 @@ class PackageRegistry
      */
     void clear();
 
+    /**
+     * Infer package ID from directory structure or sibling files
+     * Used when loading files without package declarations
+     * @param path Path to the WIT file
+     * @return Package ID if inferrable, nullopt otherwise
+     */
+    std::optional<PackageId> infer_package_from_path(const std::filesystem::path &path);
+
 private:
     std::vector<std::unique_ptr<WitPackage>> packages_;
     std::map<std::string, WitPackage *> package_map_; // "namespace:package@version" -> package

tools/wit-codegen/wit-codegen.cpp

@@ -102,7 +102,7 @@ int main(int argc, char *argv[])
                 // 3. Load all dependencies first
                 for (const auto &dep_file : dep_files)
                 {
-                    std::cout << "Loading dependency: " << dep_file << "\n";
+                    std::cout << "Loading dependency: \"" << dep_file.generic_string() << "\"\n";
                     if (!registry.load_package(dep_file))
                     {
                         throw std::runtime_error("Failed to load dependency: " + dep_file.string());
@@ -160,7 +160,7 @@ int main(int argc, char *argv[])
                     dep_files = resolver.sort_by_dependencies(dep_files);
                     for (const auto &dep_file : dep_files)
                     {
-                        std::cout << "Loading dependency: " << dep_file << "\n";
+                        std::cout << "Loading dependency: \"" << dep_file.generic_string() << "\"\n";
                         if (!registry.load_package(dep_file))
                         {
                             throw std::runtime_error("Failed to load dependency: " + dep_file.string());