feat(code-action): add pack dotted path to nested set refactor action

[takeokunn]

Summary

Add a new code action that converts dotted attribute paths to nested attribute sets - the inverse of the "Flatten nested attribute set" action from #757.

Single Pack:

{ foo.bar = 1; }
→ { foo = { bar = 1; }; }

Bulk Pack (multiple sibling bindings with same prefix):

{ foo.bar = 1; foo.baz = 2; }
→ { foo = { bar = 1; baz = 2; }; }

Changes

File	Description
nixd/lib/Controller/CodeAction.cpp	Add packAttrs function implementing the pack transformation with single and bulk modes
Single Pack Tests
pack-attrs.md	Basic test for dotted path packing
pack-attrs-deep.md	Test for multi-level dotted paths (packs one level at a time)
pack-attrs-quoted.md	Test for preserving quoted attribute names
pack-attrs-multiline.md	Test for multiline attribute set formatting
pack-attrs-values.md	Test for various value types (empty sets, let expressions, nested sets)
Bulk Pack Tests
pack-attrs-bulk.md	Test for bulk pack with sibling bindings
pack-attrs-bulk-quoted.md	Test for bulk pack with quoted keys requiring proper quoting
pack-attrs-escape.md	Test for escaping special characters (", \, $) in quoted keys
pack-attrs-sibling-inherit.md	Test for pack with inherit sibling (non-conflicting)
pack-attrs-sibling-different-prefix.md	Test for pack with different prefix siblings
Negative Tests
pack-attrs-single.md	Negative test for single-segment paths
pack-attrs-rec.md	Negative test for recursive attribute sets
pack-attrs-dynamic.md	Negative test for dynamic interpolation in paths
pack-attrs-conflict.md	Negative test for non-path binding conflicts (e.g., { foo = 1; foo.bar = 2; })
pack-attrs-sibling-dynamic.md	Negative test for dynamic attributes in sibling bindings
flatten-attrs-deep.md	Updated to verify both Pack and Flatten actions offered together

Behavior

Single Pack Action ("Pack dotted path to nested set")

Action is offered when:

• Cursor is on a dotted attribute path with 2+ segments (e.g., foo.bar)
• The attribute is inside a non-recursive attribute set
• No sibling bindings share the same first segment prefix

Bulk Pack Action ("Pack all 'X' bindings to nested set")

Action is offered when:

• Multiple sibling bindings share the same first segment prefix (e.g., foo.bar and foo.baz)
• All sibling binding paths are static (no dynamic interpolation)
• No conflicting non-path binding exists for the prefix

Transformation combines all matching siblings:

{ foo.bar = 1; foo.baz = 2; foo.qux = 3; }
→ { foo = { bar = 1; baz = 2; qux = 3; }; }

Explicitly Excluded

• Single-segment paths (e.g., foo = 1): Nothing to pack
• Recursive attribute sets (rec { ... }): Packing would change semantics
• Dynamic attribute paths (e.g., foo.${bar}): Cannot safely transform interpolated paths
• Conflicting non-path bindings (e.g., { foo = 1; foo.bar = 2; }): Would create invalid Nix code
• Dynamic sibling attributes: When any sibling has dynamic interpolation, bulk pack is disabled

Deep Path Handling

Deep paths are packed one level at a time:

• a.b.c = 1 → a = { b.c = 1; } (first application)
• a = { b.c = 1; } → a = { b = { c = 1; }; } (second application)

Key Quoting and Escaping

The action correctly handles:

• Quoted keys: Keys requiring quotes (e.g., "1foo") are properly quoted in output
• Special character escaping: Characters like ", \, and $ are correctly escaped

Test Plan

• ✅ All CI checks passing
• 16 test files covering positive and negative cases
• Positive tests verify correct transformation output for:
  • Basic single pack
  • Deep paths (multi-level)
  • Quoted attribute names
  • Multiline formatting
  • Various value types (empty sets, let expressions, nested sets)
  • Bulk pack with multiple siblings
  • Bulk pack with special characters in keys
  • Non-conflicting sibling scenarios (inherit, different prefixes)
• Negative tests verify action is NOT offered in excluded scenarios:
  • Single-segment paths
  • Recursive attribute sets
  • Dynamic interpolation
  • Conflicting non-path bindings
  • Dynamic sibling attributes

Related

• Part of nixd: code actions #466
• Inverse of feat(code-action): add flatten nested attribute set refactor action #757 (flatten nested attribute set)
• Draft PR: [DRAFT] feat(code-action): add refactoring and quickfix actions for Nix code #755 (this implements Split 3)

[inclyc]

Is this possible? #755 (comment)

nixd has SemaAttrs where attributes are lowered into nested structure.

[takeokunn]

It seems implementable, so I'll give it a try.

[takeokunn]

I haven't thoroughly reviewed the source code yet, but it now runs on my local machine.

[inclyc]

The current implementation LGTM. However, I think we can further improve the UX.

I suggest we handle this as a follow-up task in a separate PR to keep this one focused.

[inclyc]

Offer both 'Pack One' and 'Pack All' options?

e.g. sometimes user may just want to "pack one"

{
  a.b = 1;
  a.c = 2;
}

->

{
  a = { b = 1; };
  a.c = 2;
}

[inclyc]

Suggested change

	"Pack all '" + FirstSeg + "' bindings to nested set",
	"Recursively pack all '" + FirstSeg + "' bindings to nested set",

Right now, the 'Pack All' operation actually behaves like a recursive pack (matching SemaAttrs logic).

i.e.

{
  a.a = 1;
  a.f = {
    a.x.x2.x3.x4 = 1;
  };
}

currently it will be packed into this:

{
  a = {
    a = 1;
    f = {
      a = {
        x = {
          x2 = {
            x3 = {
              x4 = 1;
            };
          };
        };
      };
    };
  };
}

Sometimes, users might prefer a 'shallow pack' that only expands the first level of attributes.

[takeokunn]

This PR ended up with too many changes, so I'll split it into a separate PR!!

Thanks for the review!!

I learned a lot about C++ again this time