--allow-toplevel-iface-ports: Apply $static_assert iface param overrides

This allows users to pin iface port params, allowing for better LSP features outside of a design context.
The body will be inspected for $static_asserts, and will use those to fill in the expected parameter values for iface ports.
Related issue: hudson-trading/slang-server#401

stack-info: PR: #1910, branch: AndrewNolte/stack/24

Author: AndrewNolte

source/ast/symbols/InstanceSymbols.cpp

@@ -856,7 +856,170 @@ void InstanceSymbol::resolvePortConnections() const {
     connections = conns.copy(comp);
 }
 
+// A constraint extracted from a `$static_assert` that pins a parameter of an interface port. The
+// `operand` is the other side of the equality; for a value parameter it is the value expression,
+// and for a type parameter (`isType`) it is a `type(...)` reference to resolve into the type.
+struct IfaceParamConstraint {
+    std::string_view name;
+    const syntax::ExpressionSyntax* operand;
+    bool isType;
+};
+
+// Returns the parameter name if `expr` is `portName.<param>`. The access can parse either as a
+// member-access expression or, when the left side could be a scope, as a dotted scoped name.
+static std::string_view asPortParamAccess(const syntax::ExpressionSyntax& expr,
+                                          std::string_view portName) {
+    if (expr.kind == syntax::SyntaxKind::MemberAccessExpression) {
+        auto& access = expr.as<syntax::MemberAccessExpressionSyntax>();
+        if (access.left->kind != syntax::SyntaxKind::IdentifierName)
+            return {};
+        if (access.left->as<syntax::IdentifierNameSyntax>().identifier.valueText() != portName)
+            return {};
+        return access.name.valueText();
+    }
+
+    if (expr.kind == syntax::SyntaxKind::ScopedName) {
+        auto& scoped = expr.as<syntax::ScopedNameSyntax>();
+        if (scoped.separator.kind != parsing::TokenKind::Dot)
+            return {};
+        if (scoped.left->kind != syntax::SyntaxKind::IdentifierName ||
+            scoped.right->kind != syntax::SyntaxKind::IdentifierName) {
+            return {};
+        }
+        if (scoped.left->as<syntax::IdentifierNameSyntax>().identifier.valueText() != portName)
+            return {};
+        return scoped.right->as<syntax::IdentifierNameSyntax>().identifier.valueText();
+    }
+
+    return {};
+}
+
+// Given a `$static_assert` condition expression, see if it pins a parameter of the given
+// interface port to a constant. Two shapes are recognized (with either operand on the left):
+//   - value:  `<port>.<param> == <expr>`
+//   - type:   `type(<port>.<param>) == type(<expr>)`
+// On a match, returns the parameter name, the other operand, and whether it is a type constraint.
+static std::optional<IfaceParamConstraint> matchIfaceParamConstraint(
+    const syntax::ExpressionSyntax& condition, std::string_view portName) {
+    if (condition.kind != syntax::SyntaxKind::EqualityExpression)
+        return std::nullopt;
+
+    auto& binExpr = condition.as<syntax::BinaryExpressionSyntax>();
+    auto& left = *binExpr.left;
+    auto& right = *binExpr.right;
+
+    // Value form: `port.param == <expr>`.
+    if (auto param = asPortParamAccess(left, portName); !param.empty())
+        return IfaceParamConstraint{param, &right, /* isType */ false};
+    if (auto param = asPortParamAccess(right, portName); !param.empty())
+        return IfaceParamConstraint{param, &left, /* isType */ false};
+
+    // Type form: `type(port.param) == type(<expr>)`. Both operands are `type(...)` references; the
+    // caller resolves the non-port operand (still a `type(...)`) into the override type.
+    auto isTypeRef = [](const syntax::ExpressionSyntax& expr) {
+        return expr.kind == syntax::SyntaxKind::TypeReference;
+    };
+    auto typeRefPort = [&](const syntax::ExpressionSyntax& expr) -> std::string_view {
+        if (!isTypeRef(expr))
+            return {};
+        return asPortParamAccess(*expr.as<syntax::TypeReferenceSyntax>().expr, portName);
+    };
+
+    if (isTypeRef(left) && isTypeRef(right)) {
+        if (auto param = typeRefPort(left); !param.empty())
+            return IfaceParamConstraint{param, &right, /* isType */ true};
+        if (auto param = typeRefPort(right); !param.empty())
+            return IfaceParamConstraint{param, &left, /* isType */ true};
+    }
+
+    return std::nullopt;
+}
+
+// Scan the body of the instantiating module for `$static_assert` constraints that pin
+// parameters of the given default-instantiated interface port to specific values or types,
+// collecting them into @a overrides. This lets shallow / top-level interface-port elaboration
+// honor constraints like `$static_assert(my_if.PARAM == 2)` even though the port has no real
+// connection providing the value.
+//
+// Only asserts written directly in the module body are considered. Asserts nested in generate
+// blocks are skipped: their constraints are conditional, but the override has to be applied
+// before elaboration (so before we know which branches are taken), and pinning a parameter from
+// a possibly-untaken branch would be wrong.
+static void collectIfaceParamConstraints(const InterfacePortSymbol& port,
+                                         const syntax::ModuleDeclarationSyntax& topBody,
+                                         SmallVectorBase<IfaceParamConstraint>& constraints) {
+    auto& def = *port.interfaceDef;
+
+    for (auto member : topBody.members) {
+        if (member->kind != syntax::SyntaxKind::ElabSystemTask)
+            continue;
+
+        auto& task = member->as<syntax::ElabSystemTaskSyntax>();
+        if (SemanticFacts::getElabSystemTaskKind(task.name) != ElabSystemTaskKind::StaticAssert)
+            continue;
+        if (!task.arguments || task.arguments->parameters.empty())
+            continue;
+
+        auto firstArg = task.arguments->parameters[0];
+        if (firstArg->kind != syntax::SyntaxKind::OrderedArgument)
+            continue;
+
+        // Unwrap the property/sequence wrappers down to a plain expression.
+        auto& propExpr = *firstArg->as<syntax::OrderedArgumentSyntax>().expr;
+        if (propExpr.kind != syntax::SyntaxKind::SimplePropertyExpr)
+            continue;
+
+        auto& seqExpr = *propExpr.as<syntax::SimplePropertyExprSyntax>().expr;
+        if (seqExpr.kind != syntax::SyntaxKind::SimpleSequenceExpr)
+            continue;
+
+        auto& simpleSeq = seqExpr.as<syntax::SimpleSequenceExprSyntax>();
+        if (simpleSeq.repetition)
+            continue;
+
+        auto match = matchIfaceParamConstraint(*simpleSeq.expr, port.name);
+        if (!match)
+            continue;
+
+        // Only override parameters the interface actually declares.
+        for (auto& decl : def.parameters) {
+            if (decl.name == match->name) {
+                constraints.push_back(*match);
+                break;
+            }
+        }
+    }
+}
+
+// A parameter override for a default-instantiated interface port, with the value/type already
+// resolved in the instantiating scope. Applied directly to the parameter builder.
+struct IfaceParamOverride {
+    std::string_view name;
+    std::variant<ConstantValue, const Type*> value;
+};
+
+// Resolves each constraint's operand in the instantiating scope (where it was written) into a
+// concrete value or type.
+static void resolveIfaceParamOverrides(std::span<const IfaceParamConstraint> constraints,
+                                       const ASTContext& context,
+                                       SmallVectorBase<IfaceParamOverride>& overrides) {
+    for (auto& c : constraints) {
+        if (c.isType) {
+            auto& dataType = c.operand->as<syntax::DataTypeSyntax>();
+            auto& type = context.getCompilation().getType(dataType, context);
+            if (!type.isError())
+                overrides.push_back({c.name, &type});
+        }
+        else {
+            auto& expr = Expression::bind(*c.operand, context);
+            if (auto value = context.tryEval(expr))
+                overrides.push_back({c.name, std::move(value)});
+        }
+    }
+}
+
 static Symbol* recurseDefaultIfaceInst(Compilation& comp, const InterfacePortSymbol& port,
+                                       std::span<const IfaceParamOverride> paramOverrides,
                                        const InstanceSymbol*& firstInst,
                                        std::span<const ConstantRange>::iterator it,
                                        std::span<const ConstantRange>::iterator end) {
@@ -866,6 +1029,16 @@ static Symbol* recurseDefaultIfaceInst(Compilation& comp, const InterfacePortSym
         if (comp.hasFlag(CompilationFlags::AllowInvalidTop)) {
             paramBuilder.setSuppressErrors(true);
         }
+
+        // Apply any `$static_assert`-derived overrides. The values were already resolved in the
+        // instantiating scope, so they're applied directly without an instance context.
+        for (auto& ov : paramOverrides) {
+            if (auto type = std::get_if<const Type*>(&ov.value))
+                paramBuilder.addTypeOverride(ov.name, **type);
+            else
+                paramBuilder.addValueOverride(ov.name, std::get<ConstantValue>(ov.value));
+        }
+
         auto& body = InstanceBodySymbol::fromDefinition(comp, def, port.location, paramBuilder,
                                                         InstanceFlags::None);
 
@@ -882,7 +1055,7 @@ static Symbol* recurseDefaultIfaceInst(Compilation& comp, const InterfacePortSym
 
     SmallVector<const Symbol*> elements;
     for (uint32_t i = 0; i < range.width(); i++) {
-        auto symbol = recurseDefaultIfaceInst(comp, port, firstInst, it, end);
+        auto symbol = recurseDefaultIfaceInst(comp, port, paramOverrides, firstInst, it, end);
         symbol->name = "";
         elements.push_back(symbol);
     }
@@ -900,19 +1073,33 @@ void InstanceSymbol::connectDefaultIfacePorts() const {
     SLANG_ASSERT(parent);
 
     auto& comp = parent->getCompilation();
-    ASTContext context(*parent, LookupLocation::max);
+    ASTContext context(body, LookupLocation::max);
+
+    // The body of the instantiating module may contain `$static_assert` constraints that
+    // pin interface-port parameters to specific values; we honor those when synthesizing
+    // the default interface instances below. Ideally one day the LRM will allow
+    // specifying these constraints in the port declaration itself.
+    auto bodySyntax = body.getSyntax() ? body.getSyntax()->as_if<syntax::ModuleDeclarationSyntax>()
+                                       : nullptr;
 
     SmallVector<const PortConnection*> conns;
     for (auto port : body.getPortList()) {
         if (port->kind == SymbolKind::InterfacePort) {
             auto& ifacePort = port->as<InterfacePortSymbol>();
             if (ifacePort.interfaceDef) {
+                SmallVector<IfaceParamConstraint> constraints;
+                SmallVector<IfaceParamOverride> paramOverrides;
+                if (bodySyntax) {
+                    collectIfaceParamConstraints(ifacePort, *bodySyntax, constraints);
+                    resolveIfaceParamOverrides(constraints, context, paramOverrides);
+                }
+
                 Symbol* inst;
                 const ModportSymbol* modport = nullptr;
                 if (auto dims = ifacePort.getDeclaredRange()) {
                     const InstanceSymbol* firstInst = nullptr;
-                    inst = recurseDefaultIfaceInst(comp, ifacePort, firstInst, dims->begin(),
-                                                   dims->end());
+                    inst = recurseDefaultIfaceInst(comp, ifacePort, paramOverrides, firstInst,
+                                                   dims->begin(), dims->end());
 
                     if (firstInst) {
                         auto portRange = SourceRange{port->location,

source/ast/symbols/ParameterBuilder.cpp

@@ -177,6 +177,18 @@ const ParameterSymbolBase& ParameterBuilder::createParam(
         }
 
         auto& tt = param->targetType;
+
+        // A pre-resolved type override takes precedence and is applied directly, since it has
+        // already been resolved and doesn't depend on any instance context. Localparams can't be
+        // overridden, so fall through to normal resolution for those.
+        if (auto it = resolvedOverrides.find(decl.name);
+            it != resolvedOverrides.end() && !param->isLocalParam()) {
+            SLANG_ASSERT(std::holds_alternative<const Type*>(it->second));
+            tt.addFlags(DeclaredTypeFlags::TypeOverridden);
+            tt.setType(*std::get<const Type*>(it->second));
+            newScope.addMember(*param);
+            return *param;
+        }
         if (newInitializer) {
             // If this is a NameSyntax, the parser didn't know we were assigning to
             // a type parameter, so fix it up into a NamedTypeSyntax to get a type from it.
@@ -270,6 +282,15 @@ const ParameterSymbolBase& ParameterBuilder::createParam(
 
         newScope.addMember(*param);
 
+        // A pre-resolved value override takes precedence and is applied directly, since it has
+        // already been evaluated and doesn't depend on any instance context.
+        if (auto it = resolvedOverrides.find(decl.name);
+            it != resolvedOverrides.end() && !param->isLocalParam()) {
+            SLANG_ASSERT(std::holds_alternative<ConstantValue>(it->second));
+            param->setValue(comp, std::get<ConstantValue>(it->second), /* needsCoercion */ true);
+            return *param;
+        }
+
         // If there is an override node, see if this parameter is in it.
         // Note that we ignore the override node if this is from a configuration,
         // as the LRM says config overrides take precedence over defparams.

source/ast/symbols/ParameterBuilder.h

@@ -7,13 +7,17 @@
 //------------------------------------------------------------------------------
 #pragma once
 
+#include <variant>
+
 #include "slang/ast/symbols/CompilationUnitSymbols.h"
+#include "slang/numeric/ConstantValue.h"
 #include "slang/util/SmallMap.h"
 
 namespace slang::ast {
 
 class ParameterSymbolBase;
 class Scope;
+class Type;
 struct HierarchyOverrideNode;
 
 /// This is a helper type for turning parameter-related syntax nodes into actual
@@ -30,6 +34,21 @@ class ParameterBuilder {
     bool hasErrors() const { return anyErrors; }
 
     void setAssignments(const syntax::ParameterValueAssignmentSyntax& syntax, bool isFromConfig);
+
+    /// Adds a pre-resolved override for a value parameter. Unlike a syntactic assignment, the
+    /// value is already evaluated, so no instance context is needed and it is applied directly.
+    /// Useful for propagating an already-elaborated value (e.g. copied from another instance, or
+    /// derived from a constraint) onto the parameter of a freshly built instance.
+    void addValueOverride(std::string_view name, ConstantValue value) {
+        resolvedOverrides.emplace(name, std::move(value));
+    }
+
+    /// Adds a pre-resolved override for a type parameter. As with @a addValueOverride the type is
+    /// already resolved, so no instance context is needed.
+    void addTypeOverride(std::string_view name, const Type& type) {
+        resolvedOverrides.emplace(name, &type);
+    }
+
     void setOverrides(const HierarchyOverrideNode* newVal) { overrideNode = newVal; }
     void setForceInvalidValues(bool set) { forceInvalidValues = set; }
     void setSuppressErrors(bool set) { suppressErrors = set; }
@@ -54,6 +73,11 @@ class ParameterBuilder {
     std::string_view definitionName;
     std::span<const Decl> parameterDecls;
     SmallMap<std::string_view, std::pair<const syntax::ExpressionSyntax*, bool>, 8> assignments;
+
+    // Pre-resolved overrides keyed by parameter name: a ConstantValue for value parameters or a
+    // Type for type parameters. Applied directly, without needing an instance context.
+    SmallMap<std::string_view, std::variant<ConstantValue, const Type*>, 2> resolvedOverrides;
+
     const ASTContext* instanceContext = nullptr;
     const HierarchyOverrideNode* overrideNode = nullptr;
     const Scope* configScope = nullptr;