diff --git a/common/formatting/align.cc b/common/formatting/align.cc
index 816bcb5..032a7e1 100644
--- a/common/formatting/align.cc
+++ b/common/formatting/align.cc
@@ -530,7 +530,7 @@
   }
 };
 
-static GroupAlignmentData AlignFilteredRows(
+static GroupAlignmentData CalculateAlignmentSpacings(
     const std::vector<TokenPartitionIterator>& rows,
     const AlignmentCellScannerFunction& cell_scanner_gen,
     MutableFormatTokenRange::iterator ftoken_base, int column_limit) {
@@ -660,15 +660,17 @@
   VLOG(1) << "end of " << __FUNCTION__;
 }
 
+// Select subset of iterators inside a partition range that are not ignored
+// by the predicate.
 static std::vector<TokenPartitionIterator> FilterAlignablePartitions(
-    const TokenPartitionRange& group,
+    const TokenPartitionRange& range,
     const IgnoreAlignmentRowPredicate& ignore_partition_predicate) {
-  // This partition group may contain partitions that should not be
+  // This partition range may contain partitions that should not be
   // considered for column alignment purposes, so filter those out.
   std::vector<TokenPartitionIterator> qualified_partitions;
-  qualified_partitions.reserve(group.size());
+  qualified_partitions.reserve(range.size());
   // like std::copy_if, but we want the iterators, not their pointees.
-  for (auto iter = group.begin(); iter != group.end(); ++iter) {
+  for (auto iter = range.begin(); iter != range.end(); ++iter) {
     if (!ignore_partition_predicate(*iter)) {
       VLOG(2) << "including partition: " << *iter;
       qualified_partitions.push_back(iter);
@@ -683,17 +685,19 @@
     const std::function<std::vector<TokenPartitionRange>(
         const TokenPartitionRange&)>& legacy_extractor,
     const IgnoreAlignmentRowPredicate& legacy_ignore_predicate,
-    const AlignmentCellScannerFunction& alignment_cell_scanner) {
-  return [legacy_extractor, legacy_ignore_predicate,
-          alignment_cell_scanner](const TokenPartitionRange& full_range) {
+    const AlignmentCellScannerFunction& alignment_cell_scanner,
+    AlignmentPolicy alignment_policy) {
+  return [legacy_extractor, legacy_ignore_predicate, alignment_cell_scanner,
+          alignment_policy](const TokenPartitionRange& full_range) {
     // must copy the closures, not just reference, to ensure valid lifetime
     const std::vector<TokenPartitionRange> ranges(legacy_extractor(full_range));
     std::vector<AlignablePartitionGroup> groups;
     groups.reserve(ranges.size());
     for (const auto& range : ranges) {
+      // Apply the same policy to all alignment groups.
       groups.emplace_back(AlignablePartitionGroup{
           FilterAlignablePartitions(range, legacy_ignore_predicate),
-          alignment_cell_scanner});
+          alignment_cell_scanner, alignment_policy});
       if (groups.back().alignable_rows.empty()) groups.pop_back();
     }
     return groups;
@@ -815,12 +819,56 @@
   return AlignmentPolicy::kPreserve;
 }
 
+static void AlignGroupUsingPolicy(
+    const AlignablePartitionGroup& alignment_group,
+    std::vector<PreFormatToken>* ftokens, absl::string_view full_text,
+    int column_limit) {
+  const TokenPartitionRange partition_range(alignment_group.Range());
+  // Compute dry-run of alignment spacings if it is needed.
+  AlignmentPolicy policy = alignment_group.alignment_policy;
+  VLOG(2) << "AlignmentPolicy: " << policy;
+  GroupAlignmentData align_data;
+  switch (policy) {
+    case AlignmentPolicy::kAlign:
+    case AlignmentPolicy::kInferUserIntent:
+      align_data =
+          CalculateAlignmentSpacings(alignment_group.alignable_rows,
+                                     alignment_group.alignment_cell_scanner,
+                                     ftokens->begin(), column_limit);
+      break;
+    default:
+      break;
+  }
+
+  // If enabled, try to decide automatically based on heurstics.
+  if (policy == AlignmentPolicy::kInferUserIntent) {
+    policy = InferUserIntendedAlignmentPolicy(partition_range, align_data);
+    VLOG(2) << "AlignmentPolicy (automatic): " << policy;
+  }
+
+  // Align or not, depending on user-elected or inferred policy.
+  switch (policy) {
+    case AlignmentPolicy::kAlign: {
+      if (!align_data.align_actions_2D.empty()) {
+        // This modifies format tokens' spacing values.
+        ApplyGroupAlignment(align_data, alignment_group, ftokens->begin());
+      }
+      break;
+    }
+    case AlignmentPolicy::kFlushLeft:
+      // This is already the default behavior elsewhere.  Nothing else to do.
+      break;
+    default:
+      IndentButPreserveOtherSpacing(partition_range, full_text, ftokens);
+      break;
+  }
+}
+
 void TabularAlignTokens(
     TokenPartitionTree* partition_ptr,
     const ExtractAlignmentGroupsFunction& extract_alignment_groups,
     std::vector<PreFormatToken>* ftokens, absl::string_view full_text,
-    const ByteOffsetSet& disabled_byte_ranges, AlignmentPolicy policy,
-    int column_limit) {
+    const ByteOffsetSet& disabled_byte_ranges, int column_limit) {
   VLOG(1) << __FUNCTION__;
   // Each subpartition is presumed to correspond to a list element or
   // possibly some other ignored element like comments.
@@ -835,9 +883,7 @@
   const std::vector<AlignablePartitionGroup> alignment_groups(
       extract_alignment_groups(subpartitions_range));
   for (const auto& alignment_group : alignment_groups) {
-    const TokenPartitionRange partition_range(
-        alignment_group.alignable_rows.front(),
-        alignment_group.alignable_rows.back() + 1);
+    const TokenPartitionRange partition_range(alignment_group.Range());
     if (partition_range.empty()) continue;
     if (AnyPartitionSubRangeIsDisabled(partition_range, full_text,
                                        disabled_byte_ranges)) {
@@ -856,42 +902,8 @@
       // TODO(b/159824483): attempt to detect and re-use pre-existing alignment
     }
 
-    // Compute dry-run of alignment spacings if it is needed.
-    VLOG(2) << "AlignmentPolicy: " << policy;
-    GroupAlignmentData align_data;
-    switch (policy) {
-      case AlignmentPolicy::kAlign:
-      case AlignmentPolicy::kInferUserIntent:
-        align_data = AlignFilteredRows(alignment_group.alignable_rows,
-                                       alignment_group.alignment_cell_scanner,
-                                       ftokens->begin(), column_limit);
-        break;
-      default:
-        break;
-    }
-
-    // If enabled, try to decide automatically based on heurstics.
-    if (policy == AlignmentPolicy::kInferUserIntent) {
-      policy = InferUserIntendedAlignmentPolicy(partition_range, align_data);
-      VLOG(2) << "AlignmentPolicy (automatic): " << policy;
-    }
-
-    // Align or not, depending on user-elected or inferred policy.
-    switch (policy) {
-      case AlignmentPolicy::kAlign: {
-        if (!align_data.align_actions_2D.empty()) {
-          // This modifies format tokens' spacing values.
-          ApplyGroupAlignment(align_data, alignment_group, ftokens->begin());
-        }
-        break;
-      }
-      case AlignmentPolicy::kFlushLeft:
-        // This is already the default behavior elsewhere.  Nothing else to do.
-        break;
-      default:
-        IndentButPreserveOtherSpacing(partition_range, full_text, ftokens);
-        break;
-    }
+    // Calculate alignment and possibly apply it depending on alignment policy.
+    AlignGroupUsingPolicy(alignment_group, ftokens, full_text, column_limit);
   }
   VLOG(1) << "end of " << __FUNCTION__;
 }
diff --git a/common/formatting/align.h b/common/formatting/align.h
index 6521aee..4d2e144 100644
--- a/common/formatting/align.h
+++ b/common/formatting/align.h
@@ -134,6 +134,36 @@
 using AlignmentCellScannerFunction =
     std::function<std::vector<ColumnPositionEntry>(const TokenPartitionTree&)>;
 
+// For sections of code that are deemed alignable, this enum controls
+// the formatter behavior.
+enum class AlignmentPolicy {
+  // Preserve text as-is.
+  kPreserve,
+
+  // No-align: flush text to left while obeying spacing constraints
+  kFlushLeft,
+
+  // Attempt tabular alignment.
+  kAlign,
+
+  // Infer whether user wanted flush-left or alignment, based on original
+  // spacing.
+  kInferUserIntent,
+};
+
+namespace internal {
+extern const std::initializer_list<
+    std::pair<const absl::string_view, AlignmentPolicy>>
+    kAlignmentPolicyNameMap;
+}  // namespace internal
+
+std::ostream& operator<<(std::ostream&, AlignmentPolicy);
+
+bool AbslParseFlag(absl::string_view text, AlignmentPolicy* policy,
+                   std::string* error);
+
+std::string AbslUnparseFlag(const AlignmentPolicy& policy);
+
 // This represents one unit of alignable work, which is usually a filtered
 // subset of partitions within a contiguous range of partitions.
 struct AlignablePartitionGroup {
@@ -143,6 +173,14 @@
   // This function scans each row to identify column positions and properties of
   // alignable cells (containing token ranges).
   AlignmentCellScannerFunction alignment_cell_scanner;
+
+  // Controls how this group should be aligned or flushed or preserved.
+  AlignmentPolicy alignment_policy;
+
+  TokenPartitionRange Range() const {
+    return TokenPartitionRange(alignable_rows.front(),
+                               alignable_rows.back() + 1);
+  }
 };
 
 // This is the interface used to sub-divide a range of token partitions into
@@ -163,7 +201,8 @@
     const std::function<std::vector<TokenPartitionRange>(
         const TokenPartitionRange&)>& legacy_extractor,
     const IgnoreAlignmentRowPredicate& legacy_ignore_predicate,
-    const AlignmentCellScannerFunction& alignment_cell_scanner);
+    const AlignmentCellScannerFunction& alignment_cell_scanner,
+    AlignmentPolicy alignment_policy);
 
 // Instantiates a ScannerType (implements ColumnSchemaScanner) and extracts
 // column alignment information, suitable as an AlignmentCellScannerFunction.
@@ -202,36 +241,6 @@
   };
 }
 
-// For sections of code that are deemed alignable, this enum controls
-// the formatter behavior.
-enum class AlignmentPolicy {
-  // Preserve text as-is.
-  kPreserve,
-
-  // No-align: flush text to left while obeying spacing constraints
-  kFlushLeft,
-
-  // Attempt tabular alignment.
-  kAlign,
-
-  // Infer whether user wanted flush-left or alignment, based on original
-  // spacing.
-  kInferUserIntent,
-};
-
-namespace internal {
-extern const std::initializer_list<
-    std::pair<const absl::string_view, AlignmentPolicy>>
-    kAlignmentPolicyNameMap;
-}  // namespace internal
-
-std::ostream& operator<<(std::ostream&, AlignmentPolicy);
-
-bool AbslParseFlag(absl::string_view text, AlignmentPolicy* policy,
-                   std::string* error);
-
-std::string AbslUnparseFlag(const AlignmentPolicy& policy);
-
 // This aligns sections of text by modifying the spacing between tokens.
 // 'partition_ptr' is a partition that can span one or more sections of
 // code to align.  The partitions themselves are not reshaped, however,
@@ -253,7 +262,6 @@
 // 'ftokens' points to the array of PreFormatTokens that spans 'full_text'.
 // 'disabled_byte_ranges' contains information about which ranges of text
 // are to preserve their original spacing (no-formatting).
-// 'policy' allows selective enabling/disabling of alignment.
 // 'column_limit' is the column width beyond which the aligner should fallback
 // to a safer action, e.g. refusing to align and leaving spacing untouched.
 //
@@ -278,8 +286,7 @@
     TokenPartitionTree* partition_ptr,
     const ExtractAlignmentGroupsFunction& extract_alignment_groups,
     std::vector<PreFormatToken>* ftokens, absl::string_view full_text,
-    const ByteOffsetSet& disabled_byte_ranges, AlignmentPolicy policy,
-    int column_limit);
+    const ByteOffsetSet& disabled_byte_ranges, int column_limit);
 
 }  // namespace verible
 
diff --git a/common/formatting/align_test.cc b/common/formatting/align_test.cc
index 501ebea..6b1dd2f 100644
--- a/common/formatting/align_test.cc
+++ b/common/formatting/align_test.cc
@@ -111,7 +111,26 @@
 static const ExtractAlignmentGroupsFunction kDefaultAlignmentHandler =
     ExtractAlignmentGroupsAdapter(
         &verible::GetSubpartitionsBetweenBlankLines, &IgnoreNone,
-        AlignmentCellScannerGenerator<TokenColumnizer>());
+        AlignmentCellScannerGenerator<TokenColumnizer>(),
+        AlignmentPolicy::kAlign);
+
+static const ExtractAlignmentGroupsFunction kFlushLeftAlignmentHandler =
+    ExtractAlignmentGroupsAdapter(
+        &verible::GetSubpartitionsBetweenBlankLines, &IgnoreNone,
+        AlignmentCellScannerGenerator<TokenColumnizer>(),
+        AlignmentPolicy::kFlushLeft);
+
+static const ExtractAlignmentGroupsFunction kPreserveAlignmentHandler =
+    ExtractAlignmentGroupsAdapter(
+        &verible::GetSubpartitionsBetweenBlankLines, &IgnoreNone,
+        AlignmentCellScannerGenerator<TokenColumnizer>(),
+        AlignmentPolicy::kPreserve);
+
+static const ExtractAlignmentGroupsFunction kInferAlignmentHandler =
+    ExtractAlignmentGroupsAdapter(
+        &verible::GetSubpartitionsBetweenBlankLines, &IgnoreNone,
+        AlignmentCellScannerGenerator<TokenColumnizer>(),
+        AlignmentPolicy::kInferUserIntent);
 
 TEST_F(TabularAlignTokenTest, EmptyPartitionRange) {
   const auto begin = pre_format_tokens_.begin();
@@ -120,7 +139,7 @@
   using tree_type = TokenPartitionTree;
   tree_type partition{all};  // no children subpartitions
   TabularAlignTokens(&partition, kDefaultAlignmentHandler, &pre_format_tokens_,
-                     sample_, ByteOffsetSet(), AlignmentPolicy::kAlign, 40);
+                     sample_, ByteOffsetSet(), 40);
   // Not crashing is success.
   // Ideally, we would like to verify that partition was *not* modified
   // by making a deep copy and then checking DeepEqual, however,
@@ -205,7 +224,7 @@
 
 TEST_F(Sparse3x3MatrixAlignmentTest, ZeroInterTokenPadding) {
   TabularAlignTokens(&partition_, kDefaultAlignmentHandler, &pre_format_tokens_,
-                     sample_, ByteOffsetSet(), AlignmentPolicy::kAlign, 40);
+                     sample_, ByteOffsetSet(), 40);
 
   // Sanity check: "three" (length 5) is the long-pole of the first column:
   EXPECT_EQ(pre_format_tokens_[0].before.spaces_required, tokens_[2].length());
@@ -220,8 +239,8 @@
 }
 
 TEST_F(Sparse3x3MatrixAlignmentTest, AlignmentPolicyFlushLeft) {
-  TabularAlignTokens(&partition_, kDefaultAlignmentHandler, &pre_format_tokens_,
-                     sample_, ByteOffsetSet(), AlignmentPolicy::kFlushLeft, 40);
+  TabularAlignTokens(&partition_, kFlushLeftAlignmentHandler,
+                     &pre_format_tokens_, sample_, ByteOffsetSet(), 40);
 
   EXPECT_EQ(Render(),  // minimum spaces in this example is 0
             "onetwo\n"
@@ -234,8 +253,8 @@
   ConnectPreFormatTokensPreservedSpaceStarts(sample_.data(),
                                              &pre_format_tokens_);
 
-  TabularAlignTokens(&partition_, kDefaultAlignmentHandler, &pre_format_tokens_,
-                     sample_, ByteOffsetSet(), AlignmentPolicy::kPreserve, 40);
+  TabularAlignTokens(&partition_, kPreserveAlignmentHandler,
+                     &pre_format_tokens_, sample_, ByteOffsetSet(), 40);
 
   EXPECT_EQ(Render(),  // original spacing was 1
             "one two\n"
@@ -251,7 +270,7 @@
   }
 
   TabularAlignTokens(&partition_, kDefaultAlignmentHandler, &pre_format_tokens_,
-                     sample_, ByteOffsetSet(), AlignmentPolicy::kAlign, 40);
+                     sample_, ByteOffsetSet(), 40);
 
   // Verify string rendering of result.
   EXPECT_EQ(Render(),  //
@@ -270,7 +289,7 @@
   pre_format_tokens_[4].before.spaces_required = 0;
 
   TabularAlignTokens(&partition_, kDefaultAlignmentHandler, &pre_format_tokens_,
-                     sample_, ByteOffsetSet(), AlignmentPolicy::kAlign, 40);
+                     sample_, ByteOffsetSet(), 40);
 
   // Verify string rendering of result.
   EXPECT_EQ(Render(),  //
@@ -282,7 +301,8 @@
 static const ExtractAlignmentGroupsFunction kFlushRightAlignmentHandler =
     ExtractAlignmentGroupsAdapter(
         &verible::GetSubpartitionsBetweenBlankLines, &IgnoreNone,
-        AlignmentCellScannerGenerator<TokenColumnizerRightFlushed>());
+        AlignmentCellScannerGenerator<TokenColumnizerRightFlushed>(),
+        AlignmentPolicy::kAlign);
 
 TEST_F(Sparse3x3MatrixAlignmentTest, RightFlushed) {
   // Require 1 space between tokens.
@@ -291,8 +311,7 @@
   }
 
   TabularAlignTokens(&partition_, kFlushRightAlignmentHandler,
-                     &pre_format_tokens_, sample_, ByteOffsetSet(),
-                     AlignmentPolicy::kAlign, 40);
+                     &pre_format_tokens_, sample_, ByteOffsetSet(), 40);
 
   // Verify string rendering of result.
   EXPECT_EQ(Render(),  //
@@ -312,7 +331,7 @@
   }
 
   TabularAlignTokens(&partition_, kDefaultAlignmentHandler, &pre_format_tokens_,
-                     sample_, ByteOffsetSet(), AlignmentPolicy::kAlign, 40);
+                     sample_, ByteOffsetSet(), 40);
 
   // Verify string rendering of result.
   EXPECT_EQ(Render(),  //
@@ -337,9 +356,10 @@
 
   const ExtractAlignmentGroupsFunction handler = ExtractAlignmentGroupsAdapter(
       &verible::GetSubpartitionsBetweenBlankLines, ignore_threes,
-      AlignmentCellScannerGenerator<TokenColumnizer>());
+      AlignmentCellScannerGenerator<TokenColumnizer>(),
+      AlignmentPolicy::kAlign);
   TabularAlignTokens(&partition_, handler, &pre_format_tokens_, sample_,
-                     ByteOffsetSet(), AlignmentPolicy::kAlign, 40);
+                     ByteOffsetSet(), 40);
 
   // Verify string rendering of result.
   EXPECT_EQ(Render(),         //
@@ -355,11 +375,10 @@
     ftoken.before.spaces_required = 1;
   }
 
-  TabularAlignTokens(&partition_, kDefaultAlignmentHandler, &pre_format_tokens_,
-                     sample_,
-                     // Alignment disabled over entire range.
-                     ByteOffsetSet({{0, static_cast<int>(sample_.length())}}),
-                     AlignmentPolicy::kAlign, 40);
+  TabularAlignTokens(
+      &partition_, kDefaultAlignmentHandler, &pre_format_tokens_, sample_,
+      // Alignment disabled over entire range.
+      ByteOffsetSet({{0, static_cast<int>(sample_.length())}}), 40);
 
   // Verify string rendering of result.
   EXPECT_EQ(Render(),  //
@@ -380,11 +399,10 @@
   pre_format_tokens_[2].before.break_decision = SpacingOptions::MustWrap;
   pre_format_tokens_[4].before.break_decision = SpacingOptions::MustWrap;
 
-  TabularAlignTokens(&partition_, kDefaultAlignmentHandler, &pre_format_tokens_,
-                     sample_,
-                     // Alignment disabled over entire range.
-                     ByteOffsetSet({{0, static_cast<int>(sample_.length())}}),
-                     AlignmentPolicy::kAlign, 40);
+  TabularAlignTokens(
+      &partition_, kDefaultAlignmentHandler, &pre_format_tokens_, sample_,
+      // Alignment disabled over entire range.
+      ByteOffsetSet({{0, static_cast<int>(sample_.length())}}), 40);
 
   // Verify string rendering of result.
   EXPECT_EQ(Render(),  //
@@ -422,7 +440,7 @@
       // Alignment disabled over line 2
       ByteOffsetSet({{static_cast<int>(sample_.find_first_of("\n") + 1),
                       static_cast<int>(sample_.find("four") + 4)}}),
-      AlignmentPolicy::kAlign, 40);
+      40);
 
   EXPECT_EQ(pre_format_tokens_[1].before.break_decision,
             SpacingOptions::Preserve);
@@ -446,10 +464,10 @@
   }
 
   int midpoint = sample_.length() / 2;
-  TabularAlignTokens(
-      &partition_, kDefaultAlignmentHandler, &pre_format_tokens_, sample_,
-      // Alignment disabled over partial range.
-      ByteOffsetSet({{midpoint, midpoint + 1}}), AlignmentPolicy::kAlign, 40);
+  TabularAlignTokens(&partition_, kDefaultAlignmentHandler, &pre_format_tokens_,
+                     sample_,
+                     // Alignment disabled over partial range.
+                     ByteOffsetSet({{midpoint, midpoint + 1}}), 40);
 
   // Verify string rendering of result.
   EXPECT_EQ(Render(),  //
@@ -465,7 +483,7 @@
   }
 
   TabularAlignTokens(&partition_, kDefaultAlignmentHandler, &pre_format_tokens_,
-                     sample_, ByteOffsetSet(), AlignmentPolicy::kAlign,
+                     sample_, ByteOffsetSet(),
                      // Column limit chosen to be smaller than sum of columns'
                      // widths. 5 (no left padding) +4 +5 = 14, so we choose 13
                      13);
@@ -488,7 +506,7 @@
 
   TabularAlignTokens(
       &partition_, kDefaultAlignmentHandler, &pre_format_tokens_, sample_,
-      ByteOffsetSet(), AlignmentPolicy::kAlign,
+      ByteOffsetSet(),
       // Column limit chosen to be smaller than sum of columns' widths.
       // 3 (indent) +5 (no left padding) +4 +5 = 17, so we choose 16
       16);
@@ -595,7 +613,7 @@
   }
 
   TabularAlignTokens(&partition_, kDefaultAlignmentHandler, &pre_format_tokens_,
-                     sample_, ByteOffsetSet(), AlignmentPolicy::kAlign, 40);
+                     sample_, ByteOffsetSet(), 40);
 
   // Verify string rendering of result.
   EXPECT_EQ(Render(),  //
@@ -767,9 +785,8 @@
   // flushed-left looks only different by a maximum of 2 spaces ("one" vs.
   // "three", so just align it.
 
-  TabularAlignTokens(&partition_, kDefaultAlignmentHandler, &pre_format_tokens_,
-                     sample_, ByteOffsetSet(),
-                     AlignmentPolicy::kInferUserIntent, 40);
+  TabularAlignTokens(&partition_, kInferAlignmentHandler, &pre_format_tokens_,
+                     sample_, ByteOffsetSet(), 40);
 
   EXPECT_EQ(Render(),      //
             "one   two\n"  //
@@ -792,9 +809,8 @@
   // The original text contains no error greater than 2 spaces relative to
   // flush-left, therefore flush-left.
 
-  TabularAlignTokens(&partition_, kDefaultAlignmentHandler, &pre_format_tokens_,
-                     sample_, ByteOffsetSet(),
-                     AlignmentPolicy::kInferUserIntent, 40);
+  TabularAlignTokens(&partition_, kInferAlignmentHandler, &pre_format_tokens_,
+                     sample_, ByteOffsetSet(), 40);
 
   EXPECT_EQ(Render(),    //
             "one two\n"  //
@@ -815,9 +831,8 @@
   // The original text contains 4 excess spaces before "four" which should
   // trigger alignment.
 
-  TabularAlignTokens(&partition_, kDefaultAlignmentHandler, &pre_format_tokens_,
-                     sample_, ByteOffsetSet(),
-                     AlignmentPolicy::kInferUserIntent, 40);
+  TabularAlignTokens(&partition_, kInferAlignmentHandler, &pre_format_tokens_,
+                     sample_, ByteOffsetSet(), 40);
 
   EXPECT_EQ(Render(),         //
             "one      two\n"  //
@@ -838,9 +853,8 @@
   // The original text contains only 3 excess spaces before "four" which should
   // not trigger alignment, but fall back to preserving original spacing.
 
-  TabularAlignTokens(&partition_, kDefaultAlignmentHandler, &pre_format_tokens_,
-                     sample_, ByteOffsetSet(),
-                     AlignmentPolicy::kInferUserIntent, 40);
+  TabularAlignTokens(&partition_, kInferAlignmentHandler, &pre_format_tokens_,
+                     sample_, ByteOffsetSet(), 40);
 
   EXPECT_EQ(Render(),    //
             "one two\n"  //
diff --git a/verilog/formatting/align.cc b/verilog/formatting/align.cc
index 08d7781..a1e3556 100644
--- a/verilog/formatting/align.cc
+++ b/verilog/formatting/align.cc
@@ -23,6 +23,7 @@
 
 #include "common/formatting/align.h"
 #include "common/formatting/format_token.h"
+#include "common/formatting/token_partition_tree.h"
 #include "common/formatting/unwrapped_line.h"
 #include "common/text/concrete_syntax_leaf.h"
 #include "common/text/concrete_syntax_tree.h"
@@ -41,10 +42,10 @@
 namespace verilog {
 namespace formatter {
 
+using verible::AlignablePartitionGroup;
 using verible::AlignmentCellScannerGenerator;
 using verible::AlignmentColumnProperties;
 using verible::AlignmentGroupAction;
-using verible::AlignmentPolicy;
 using verible::ByteOffsetSet;
 using verible::ColumnSchemaScanner;
 using verible::down_cast;
@@ -778,58 +779,75 @@
   bool previous_token_was_case_colon_ = false;
 };
 
-static const ExtractAlignmentGroupsFunction kPortDeclarationAligner =
-    verible::ExtractAlignmentGroupsAdapter(
-        &verible::GetSubpartitionsBetweenBlankLines,
-        &IgnoreWithinPortDeclarationPartitionGroup,
-        AlignmentCellScannerGenerator<PortDeclarationColumnSchemaScanner>());
+using AlignSyntaxGroupsFunction =
+    std::function<std::vector<AlignablePartitionGroup>(
+        const TokenPartitionRange& range, const FormatStyle& style)>;
 
-static const ExtractAlignmentGroupsFunction kActualNamedParameterAligner =
-    verible::ExtractAlignmentGroupsAdapter(
-        &verible::GetSubpartitionsBetweenBlankLines,
-        &IgnoreWithinActualNamedParameterPartitionGroup,
-        AlignmentCellScannerGenerator<
-            ActualNamedParameterColumnSchemaScanner>());
+static std::vector<AlignablePartitionGroup> AlignPortDeclarations(
+    const TokenPartitionRange& full_range, const FormatStyle& vstyle) {
+  return verible::ExtractAlignmentGroupsAdapter(
+      &verible::GetSubpartitionsBetweenBlankLines,
+      &IgnoreWithinPortDeclarationPartitionGroup,
+      AlignmentCellScannerGenerator<PortDeclarationColumnSchemaScanner>(),
+      vstyle.port_declarations_alignment)(full_range);
+}
 
-static const ExtractAlignmentGroupsFunction kActualNamedPortAligner =
-    verible::ExtractAlignmentGroupsAdapter(
-        &verible::GetSubpartitionsBetweenBlankLines,
-        &IgnoreWithinActualNamedPortPartitionGroup,
-        AlignmentCellScannerGenerator<ActualNamedPortColumnSchemaScanner>());
+static std::vector<AlignablePartitionGroup> AlignActualNamedParameters(
+    const TokenPartitionRange& full_range, const FormatStyle& vstyle) {
+  return verible::ExtractAlignmentGroupsAdapter(
+      &verible::GetSubpartitionsBetweenBlankLines,
+      &IgnoreWithinActualNamedParameterPartitionGroup,
+      AlignmentCellScannerGenerator<ActualNamedParameterColumnSchemaScanner>(),
+      vstyle.named_parameter_alignment)(full_range);
+}
 
-static const ExtractAlignmentGroupsFunction kDataDeclarationAligner =
-    verible::ExtractAlignmentGroupsAdapter(
-        &GetConsecutiveDataDeclarationGroups,
-        &IgnoreCommentsAndPreprocessingDirectives,
-        AlignmentCellScannerGenerator<DataDeclarationColumnSchemaScanner>());
+static std::vector<AlignablePartitionGroup> AlignActualNamedPorts(
+    const TokenPartitionRange& full_range, const FormatStyle& vstyle) {
+  return verible::ExtractAlignmentGroupsAdapter(
+      &verible::GetSubpartitionsBetweenBlankLines,
+      &IgnoreWithinActualNamedPortPartitionGroup,
+      AlignmentCellScannerGenerator<ActualNamedPortColumnSchemaScanner>(),
+      vstyle.named_port_alignment)(full_range);
+}
 
-static const ExtractAlignmentGroupsFunction kClassPropertyAligner =
-    verible::ExtractAlignmentGroupsAdapter(
-        &GetConsecutiveDataDeclarationGroups,
-        &IgnoreCommentsAndPreprocessingDirectives,
-        AlignmentCellScannerGenerator<ClassPropertyColumnSchemaScanner>());
+static std::vector<AlignablePartitionGroup> AlignModuleItems(
+    const TokenPartitionRange& full_range, const FormatStyle& vstyle) {
+  // Currently, this only handles data/net/variable declarations.
+  // TODO(b/161814377): align continuous assignments
+  return verible::ExtractAlignmentGroupsAdapter(
+      &GetConsecutiveDataDeclarationGroups,
+      &IgnoreCommentsAndPreprocessingDirectives,
+      AlignmentCellScannerGenerator<DataDeclarationColumnSchemaScanner>(),
+      vstyle.module_net_variable_alignment)(full_range);
+}
 
-static const ExtractAlignmentGroupsFunction kCaseItemAligner =
-    verible::ExtractAlignmentGroupsAdapter(
-        &verible::GetSubpartitionsBetweenBlankLines,
-        &IgnoreMultilineCaseStatements,
-        AlignmentCellScannerGenerator<CaseItemColumnSchemaScanner>());
+static std::vector<AlignablePartitionGroup> AlignClassItems(
+    const TokenPartitionRange& full_range, const FormatStyle& vstyle) {
+  // TODO(fangism): align other class items besides member variables.
+  return verible::ExtractAlignmentGroupsAdapter(
+      &GetConsecutiveDataDeclarationGroups,
+      &IgnoreCommentsAndPreprocessingDirectives,
+      AlignmentCellScannerGenerator<ClassPropertyColumnSchemaScanner>(),
+      vstyle.class_member_variable_alignment)(full_range);
+}
 
-static const ExtractAlignmentGroupsFunction kParameterDeclarationAligner =
-    verible::ExtractAlignmentGroupsAdapter(
-        &verible::GetSubpartitionsBetweenBlankLines,
-        &IgnoreWithinPortDeclarationPartitionGroup,
-        AlignmentCellScannerGenerator<
-            ParameterDeclarationColumnSchemaScanner>());
+static std::vector<AlignablePartitionGroup> AlignCaseItems(
+    const TokenPartitionRange& full_range, const FormatStyle& vstyle) {
+  return verible::ExtractAlignmentGroupsAdapter(
+      &verible::GetSubpartitionsBetweenBlankLines,
+      &IgnoreMultilineCaseStatements,
+      AlignmentCellScannerGenerator<CaseItemColumnSchemaScanner>(),
+      vstyle.case_items_alignment)(full_range);
+}
 
-struct AlignedFormattingConfiguration {
-  // Set of functions for driving specific code aligners.
-  ExtractAlignmentGroupsFunction handler;
-
-  // This function extracts a specific alignment policy from the
-  // Verilog-specific style structure.
-  std::function<AlignmentPolicy(const FormatStyle&)> policy;
-};
+static std::vector<AlignablePartitionGroup> AlignParameterDeclarations(
+    const TokenPartitionRange& full_range, const FormatStyle& vstyle) {
+  return verible::ExtractAlignmentGroupsAdapter(
+      &verible::GetSubpartitionsBetweenBlankLines,
+      &IgnoreWithinPortDeclarationPartitionGroup,
+      AlignmentCellScannerGenerator<ParameterDeclarationColumnSchemaScanner>(),
+      vstyle.formal_parameters_alignment)(full_range);
+}
 
 void TabularAlignTokenPartitions(TokenPartitionTree* partition_ptr,
                                  std::vector<PreFormatToken>* ftokens,
@@ -847,53 +865,28 @@
   if (node == nullptr) return;
   // Dispatch aligning function based on syntax tree node type.
 
-  static const auto* const kAlignHandlers = new std::map<
-      NodeEnum, AlignedFormattingConfiguration>{
-      {NodeEnum::kPortDeclarationList,
-       {kPortDeclarationAligner,
-        [](const FormatStyle& vstyle) {
-          return vstyle.port_declarations_alignment;
-        }}},
-      {NodeEnum::kActualParameterByNameList,
-       {kActualNamedParameterAligner,
-        [](const FormatStyle& vstyle) {
-          return vstyle.named_parameter_alignment;
-        }}},
-      {NodeEnum::kPortActualList,
-       {kActualNamedPortAligner,
-        [](const FormatStyle& vstyle) { return vstyle.named_port_alignment; }}},
-      {NodeEnum::kModuleItemList,
-       {kDataDeclarationAligner,
-        [](const FormatStyle& vstyle) {
-          return vstyle.module_net_variable_alignment;
-        }}},
-      {NodeEnum::kFormalParameterList,
-       {kParameterDeclarationAligner,
-        [](const FormatStyle& vstyle) {
-          return vstyle.formal_parameters_alignment;
-        }}},
-      {NodeEnum::kClassItems,
-       {kClassPropertyAligner,
-        [](const FormatStyle& vstyle) {
-          return vstyle.class_member_variable_alignment;
-        }}},
-      // various case-like constructs:
-      {NodeEnum::kCaseItemList,
-       {kCaseItemAligner,
-        [](const FormatStyle& vstyle) { return vstyle.case_items_alignment; }}},
-      {NodeEnum::kCaseInsideItemList,
-       {kCaseItemAligner,
-        [](const FormatStyle& vstyle) { return vstyle.case_items_alignment; }}},
-      {NodeEnum::kGenerateCaseItemList,
-       {kCaseItemAligner,
-        [](const FormatStyle& vstyle) { return vstyle.case_items_alignment; }}},
-  };
+  static const auto* const kAlignHandlers =
+      new std::map<NodeEnum, AlignSyntaxGroupsFunction>{
+          {NodeEnum::kPortDeclarationList, &AlignPortDeclarations},
+          {NodeEnum::kActualParameterByNameList, &AlignActualNamedParameters},
+          {NodeEnum::kPortActualList, &AlignActualNamedPorts},
+          {NodeEnum::kModuleItemList, &AlignModuleItems},
+          {NodeEnum::kFormalParameterList, &AlignParameterDeclarations},
+          {NodeEnum::kClassItems, &AlignClassItems},
+          // various case-like constructs:
+          {NodeEnum::kCaseItemList, &AlignCaseItems},
+          {NodeEnum::kCaseInsideItemList, &AlignCaseItems},
+          {NodeEnum::kGenerateCaseItemList, &AlignCaseItems},
+      };
   const auto handler_iter = kAlignHandlers->find(NodeEnum(node->Tag().tag));
   if (handler_iter == kAlignHandlers->end()) return;
-  verible::TabularAlignTokens(partition_ptr, handler_iter->second.handler,
-                              ftokens, full_text, disabled_byte_ranges,
-                              handler_iter->second.policy(style),
-                              style.column_limit);
+  verible::TabularAlignTokens(
+      partition_ptr,
+      [&style, handler_iter](const TokenPartitionRange& range) {
+        // Return a closure bound to the current formatting style.
+        return handler_iter->second(range, style);
+      },
+      ftokens, full_text, disabled_byte_ranges, style.column_limit);
   VLOG(1) << "end of " << __FUNCTION__;
 }