Compilation: Add AllowInvalidTop flag

stack-info: PR: #1900, branch: AndrewNolte/stack/17

Author: AndrewNolte

include/slang/ast/Compilation.h

@@ -141,9 +141,12 @@ enum class SLANG_EXPORT CompilationFlags {
     /// instead of a net. By default slang follows the LRM and treats such ports as nets,
     /// which for example allows them to be connected to `inout` ports. Some tools treat them
     /// as variables instead; enabling this flag selects that behavior.
-    InferInputPortsAsVars = 1 << 19
+    InferInputPortsAsVars = 1 << 19,
+
+    /// Allow top-level modules to be selected even when their parameters have no defaults.
+    AllowInvalidTop = 1 << 20,
 };
-SLANG_BITMASK(CompilationFlags, InferInputPortsAsVars)
+SLANG_BITMASK(CompilationFlags, AllowInvalidTop)
 
 /// Contains various options that can control compilation behavior.
 struct SLANG_EXPORT CompilationOptions {

include/slang/ast/symbols/InstanceSymbols.h

@@ -145,8 +145,7 @@ class SLANG_EXPORT InstanceSymbol final : public InstanceSymbolBase {
     static InstanceSymbol& createDefault(
         Compilation& compilation, const DefinitionSymbol& definition,
         const HierarchyOverrideNode* hierarchyOverrideNode = nullptr,
-        const ConfigBlockSymbol* configBlock = nullptr, const ConfigRule* configRule = nullptr,
-        SourceLocation locationOverride = {});
+        const ConfigBlockSymbol* configBlock = nullptr, const ConfigRule* configRule = nullptr);
 
     /// Creates a placeholder instance for a virtual interface type declaration.
     static const InstanceSymbol& createVirtual(

source/ast/Compilation.cpp

@@ -316,6 +316,8 @@ const RootSymbol& Compilation::getRoot(bool skipDefParamsAndBinds) {
     auto guard = ScopeGuard([this] { finalizing = false; });
 
     auto isValidTop = [&](auto& definition) {
+        if (hasFlag(CompilationFlags::AllowInvalidTop))
+            return true;
         // All parameters must have defaults.
         for (auto& param : definition.parameters) {
             if (!param.hasDefault() &&

source/ast/symbols/InstanceSymbols.cpp

@@ -373,12 +373,11 @@ InstanceSymbol::InstanceSymbol(Compilation& compilation, std::string_view name,
 InstanceSymbol& InstanceSymbol::createDefault(Compilation& comp, const DefinitionSymbol& definition,
                                               const HierarchyOverrideNode* hierarchyOverrideNode,
                                               const ConfigBlockSymbol* configBlock,
-                                              const ConfigRule* configRule,
-                                              SourceLocation locationOverride) {
-    auto loc = locationOverride ? locationOverride : definition.location;
-    auto& body = InstanceBodySymbol::fromDefinition(comp, definition, loc, InstanceFlags::None,
-                                                    hierarchyOverrideNode, configBlock, configRule);
-    auto& result = *comp.emplace<InstanceSymbol>(definition.name, loc, body, 0u);
+                                              const ConfigRule* configRule) {
+    auto& body = InstanceBodySymbol::fromDefinition(comp, definition, definition.location,
+                                                    InstanceFlags::None, hierarchyOverrideNode,
+                                                    configBlock, configRule);
+    auto& result = *comp.emplace<InstanceSymbol>(definition.name, definition.location, body, 0u);
 
     if (configBlock) {
         auto rc = comp.emplace<ResolvedConfig>(*configBlock, result);
@@ -861,8 +860,13 @@ static Symbol* recurseDefaultIfaceInst(Compilation& comp, const InterfacePortSym
                                        std::span<const ConstantRange>::iterator it,
                                        std::span<const ConstantRange>::iterator end) {
     if (it == end) {
-        auto& result = InstanceSymbol::createDefault(comp, *port.interfaceDef, nullptr, nullptr,
-                                                     nullptr, port.location);
+        auto& def = *port.interfaceDef;
+        ParameterBuilder paramBuilder(*def.getParentScope(), def.name, def.parameters);
+        paramBuilder.setUseInvalidForMissing(true);
+        auto& body = InstanceBodySymbol::fromDefinition(comp, def, port.location, paramBuilder,
+                                                        InstanceFlags::None);
+
+        auto& result = *comp.emplace<InstanceSymbol>(port.name, port.location, body, 0u);
 
         if (!firstInst)
             firstInst = &result;
@@ -964,6 +968,10 @@ InstanceBodySymbol& InstanceBodySymbol::fromDefinition(
     ParameterBuilder paramBuilder(*definition.getParentScope(), definition.name,
                                   definition.parameters);
     paramBuilder.setForceInvalidValues(flags.has(InstanceFlags::Uninstantiated));
+    if (compilation.hasFlag(CompilationFlags::AllowInvalidTop) &&
+        instanceLoc == definition.location) {
+        paramBuilder.setUseInvalidForMissing(true);
+    }
     if (hierarchyOverrideNode)
         paramBuilder.setOverrides(hierarchyOverrideNode);
 

source/ast/symbols/ParameterBuilder.cpp

@@ -229,7 +229,12 @@ const ParameterSymbolBase& ParameterBuilder::createParam(
             }
             else if (param->isPortParam() && !tt.getTypeSyntax() &&
                      (decl.hasSyntax || !decl.givenType)) {
-                reportError(*param);
+                if (useInvalidForMissing) {
+                    tt.setType(comp.getErrorType());
+                }
+                else {
+                    reportError(*param);
+                }
             }
         }
 
@@ -308,7 +313,12 @@ const ParameterSymbolBase& ParameterBuilder::createParam(
                 }
             }
             else if (param->isPortParam() && !declType.getInitializerSyntax()) {
-                reportError(*param);
+                if (useInvalidForMissing) {
+                    param->setValue(comp, nullptr, /* needsCoercion */ false);
+                }
+                else {
+                    reportError(*param);
+                }
             }
         }
 

source/ast/symbols/ParameterBuilder.h

@@ -31,7 +31,12 @@ class ParameterBuilder {
 
     void setAssignments(const syntax::ParameterValueAssignmentSyntax& syntax, bool isFromConfig);
     void setOverrides(const HierarchyOverrideNode* newVal) { overrideNode = newVal; }
+    /// Force invalid values (error type) for all parameters.
     void setForceInvalidValues(bool set) { forceInvalidValues = set; }
+    /// Set invalid values (error type) for parameters that are missing values, rather than
+    /// reporting errors.
+    void setUseInvalidForMissing(bool set) { useInvalidForMissing = set; }
+    /// Suppress error reporting for missing parameter values.
     void setSuppressErrors(bool set) { suppressErrors = set; }
     void setInstanceContext(const ASTContext& context) { instanceContext = &context; }
     void setConfigScope(const Scope& confScope) { configScope = &confScope; }
@@ -58,6 +63,7 @@ class ParameterBuilder {
     const HierarchyOverrideNode* overrideNode = nullptr;
     const Scope* configScope = nullptr;
     bool forceInvalidValues = false;
+    bool useInvalidForMissing = false;
     bool suppressErrors = false;
     bool anyErrors = false;
 };

tests/unittests/ast/HierarchyTests.cpp

@@ -983,6 +983,43 @@ endmodule
     CHECK(unusedDefs[1]->name == "nottop");
 }
 
+TEST_CASE("Allow invalid top module parameters") {
+    auto text = R"(
+module top #(parameter int p, parameter type t);
+endmodule
+)";
+
+    // Without the flag the explicitly requested top is rejected for having
+    // non-defaulted parameters.
+    {
+        CompilationOptions options;
+        options.topModules.emplace("top"sv);
+
+        Compilation compilation(options);
+        compilation.addSyntaxTree(SyntaxTree::fromText(text));
+
+        auto& diags = compilation.getAllDiagnostics();
+        REQUIRE(diags.size() == 1);
+        CHECK(diags[0].code == diag::InvalidTopModule);
+    }
+
+    // With the flag it elaborates anyway; the missing parameters get error types
+    // rather than producing errors.
+    {
+        CompilationOptions options;
+        options.flags |= CompilationFlags::AllowInvalidTop;
+        options.topModules.emplace("top"sv);
+
+        Compilation compilation(options);
+        compilation.addSyntaxTree(SyntaxTree::fromText(text));
+        NO_COMPILATION_ERRORS;
+
+        auto& top = *compilation.getRoot().topInstances[0];
+        CHECK(top.body.find<ParameterSymbol>("p").getValue().bad());
+        CHECK(top.body.find<TypeParameterSymbol>("t").targetType.getType().isError());
+    }
+}
+
 TEST_CASE("No top warning") {
     auto tree = SyntaxTree::fromText(R"(
 )");

tests/unittests/ast/InterfaceTests.cpp

@@ -580,9 +580,8 @@ endmodule
     compilation.addSyntaxTree(tree);
 
     auto& diags = compilation.getAllDiagnostics();
-    REQUIRE(diags.size() == 2);
+    REQUIRE(diags.size() == 1);
     CHECK(diags[0].code == diag::InvalidModportAccess);
-    CHECK(diags[1].code == diag::ParamHasNoValue);
 }
 
 TEST_CASE("Interface-based typedef") {