SQ fix

Author: antoineatstariongroup

SysML2.NET.Semantics/Implied/ImpliedRelationshipProvider.cs

@@ -86,8 +86,9 @@ public class ImpliedRelationshipProvider : IImpliedRelationshipProvider
         /// </summary>
         /// <remarks>
         /// Every input is fixed for the lifetime of the instance, so the answer is too. Computing it per
-        /// access allocated a fresh list on a property that reads as a field — and <see cref="IsCoveredByRule" />
-        /// consults it per constraint, so the copy was on a hot path rather than an occasional one.
+        /// access allocated a fresh list on a property that reads as a field — and
+        /// <see cref="IsConstraintCovered" /> consults it per constraint, so the copy was on a hot path
+        /// rather than an occasional one.
         /// </remarks>
         private readonly IReadOnlyList<string> notCoveredConstraints;
 

SysML2.NET.Serializer.TextualNotation/Writers/NameResolutionCache.cs

@@ -1539,11 +1539,8 @@ private List<IMembership> QueryBindingMemberships(INamespace scope, bool visible
 
             foreach (var impliedGeneral in this.QueryImpliedGeneralClosure(type, declaredSupertypes))
             {
-                if (impliedGeneral is INamespace impliedGeneralAsNamespace)
-                {
-                    memberships.AddRange(QueryOwnedMembershipsSafe(impliedGeneralAsNamespace)
-                        .Where(ownedMember => ownedMember.Visibility != VisibilityKind.Private && PassesVisibilityFilter(ownedMember, visibleOnly)));
-                }
+                memberships.AddRange(QueryOwnedMembershipsSafe(impliedGeneral)
+                    .Where(ownedMember => ownedMember.Visibility != VisibilityKind.Private && PassesVisibilityFilter(ownedMember, visibleOnly)));
 
                 memberships.AddRange(QueryInheritedMembershipsSafe(impliedGeneral).Where(inheritedMember => PassesVisibilityFilter(inheritedMember, visibleOnly)));
             }
@@ -2207,10 +2204,7 @@ private void BuildInheritedEntries(IType type, Dictionary<string, HashSet<IEleme
                 // `pending` feeds INDEX construction only — it is not the traversal that emits output — so
                 // indexing the general as a scope in its own right keeps the fix lookup-only while making
                 // the names it owns resolvable.
-                if (impliedGeneral is INamespace impliedGeneralAsNamespace)
-                {
-                    pending.Enqueue((impliedGeneralAsNamespace, isGlobal));
-                }
+                pending.Enqueue((impliedGeneral, isGlobal));
 
                 AddImpliedLookupEntries(impliedGeneral, index, isGlobal);
             }
@@ -2346,22 +2340,17 @@ private List<IType> QueryImpliedGeneralClosure(IType type, List<IType> declaredS
         /// <param name="isGlobal">Whether the owning scope is reached through the global namespace.</param>
         private static void AddImpliedLookupEntries(IType impliedGeneral, Dictionary<string, HashSet<IElement>> index, bool isGlobal)
         {
-            var contributed = new List<IMembership>();
-
-            switch (impliedGeneral)
+            if (impliedGeneral == null)
             {
-                case null:
-                    return;
-                case INamespace impliedGeneralAsNamespace:
-                    // Stricter than the declared-supertype walk on purpose: an implied general is reached
-                    // without any authored relationship, so its private internals are never exposed, even in a
-                    // non-global scope where PassesVisibilityFilter alone would admit them.
-                    contributed.AddRange(impliedGeneralAsNamespace.ownedMembership
-                        .Where(ownedMember => ownedMember.Visibility != VisibilityKind.Private));
-
-                    break;
+                return;
             }
 
+            // Stricter than the declared-supertype walk on purpose: an implied general is reached without
+            // any authored relationship, so its private internals are never exposed, even in a non-global
+            // scope where PassesVisibilityFilter alone would admit them.
+            var contributed = new List<IMembership>(impliedGeneral.ownedMembership
+                .Where(ownedMember => ownedMember.Visibility != VisibilityKind.Private));
+
             try
             {
                 contributed.AddRange(impliedGeneral.inheritedMembership);