Trivia index

Author: emcfarlane

experimental/ast/printer/decl.go

@@ -17,7 +17,6 @@ package printer
 import (
 	"github.com/bufbuild/protocompile/experimental/ast"
 	"github.com/bufbuild/protocompile/experimental/dom"
-	"github.com/bufbuild/protocompile/experimental/seq"
 )
 
 // printDecl dispatches to the appropriate printer based on declaration kind.
@@ -182,13 +181,15 @@ func (p *printer) printSignature(sig ast.Signature) {
 	inputs := sig.Inputs()
 	if !inputs.Brackets().IsZero() {
 		p.withGroup(func(p *printer) {
-			p.printFusedBrackets(inputs.Brackets(), gapNone, func(p *printer) {
-				p.withIndent(func(indented *printer) {
-					indented.push(dom.TextIf(dom.Broken, "\n"))
-					indented.printTypeListContents(inputs)
-					p.push(dom.TextIf(dom.Broken, "\n"))
-				})
+			openTok, closeTok := inputs.Brackets().StartEnd()
+			slots := p.trivia.scopeSlots(inputs.Brackets().ID())
+			p.printToken(openTok, gapNone)
+			p.withIndent(func(indented *printer) {
+				indented.push(dom.TextIf(dom.Broken, "\n"))
+				indented.printTypeListContents(inputs, slots)
+				p.push(dom.TextIf(dom.Broken, "\n"))
 			})
+			p.printToken(closeTok, gapNone)
 		})
 	}
 
@@ -197,45 +198,56 @@ func (p *printer) printSignature(sig ast.Signature) {
 		outputs := sig.Outputs()
 		if !outputs.Brackets().IsZero() {
 			p.withGroup(func(p *printer) {
-				p.printFusedBrackets(outputs.Brackets(), gapSpace, func(p *printer) {
-					p.withIndent(func(indented *printer) {
-						indented.push(dom.TextIf(dom.Broken, "\n"))
-						indented.printTypeListContents(outputs)
-						p.push(dom.TextIf(dom.Broken, "\n"))
-					})
+				openTok, closeTok := outputs.Brackets().StartEnd()
+				slots := p.trivia.scopeSlots(outputs.Brackets().ID())
+				p.printToken(openTok, gapSpace)
+				p.withIndent(func(indented *printer) {
+					indented.push(dom.TextIf(dom.Broken, "\n"))
+					indented.printTypeListContents(outputs, slots)
+					p.push(dom.TextIf(dom.Broken, "\n"))
 				})
+				p.printToken(closeTok, gapNone)
 			})
 		}
 	}
 }
 
-func (p *printer) printTypeListContents(list ast.TypeList) {
+func (p *printer) printTypeListContents(list ast.TypeList, slots []slot) {
 	gap := gapNone
 	for i := range list.Len() {
+		p.emitSlot(slots, i)
 		if i > 0 {
 			p.printToken(list.Comma(i-1), gapNone)
-			// Use Softline here so args break onto new lines if needed
 			gap = gapSoftline
 		}
 		p.printType(list.At(i), gap)
 	}
+	p.emitSlot(slots, list.Len())
 }
 
 func (p *printer) printBody(body ast.DeclBody) {
 	if body.IsZero() {
 		return
 	}
 
-	p.printFusedBrackets(body.Braces(), gapSpace, func(child *printer) {
-		if body.Decls().Len() > 0 {
-			child.withIndent(func(indented *printer) {
-				for d := range seq.Values(body.Decls()) {
-					indented.printDecl(d)
-				}
-				indented.printRemaining()
-			})
-		}
-	})
+	braces := body.Braces()
+	if braces.IsZero() {
+		return
+	}
+
+	openTok, closeTok := braces.StartEnd()
+	slots := p.trivia.scopeSlots(braces.ID())
+
+	p.printToken(openTok, gapSpace)
+
+	closeGap := gapNone
+	if body.Decls().Len() > 0 || len(slots) > 0 {
+		closeGap = gapNewline
+		p.withIndent(func(indented *printer) {
+			indented.printScopeDecls(slots, body.Decls())
+		})
+	}
+	p.printToken(closeTok, closeGap)
 }
 
 func (p *printer) printRange(r ast.DeclRange) {
@@ -258,25 +270,36 @@ func (p *printer) printCompactOptions(co ast.CompactOptions) {
 	if co.IsZero() {
 		return
 	}
+
+	brackets := co.Brackets()
+	if brackets.IsZero() {
+		return
+	}
+
+	openTok, closeTok := brackets.StartEnd()
+	slots := p.trivia.scopeSlots(brackets.ID())
+
 	p.withGroup(func(p *printer) {
-		p.printFusedBrackets(co.Brackets(), gapSpace, func(p *printer) {
-			entries := co.Entries()
-			p.withIndent(func(indented *printer) {
-				for i := range entries.Len() {
-					if i > 0 {
-						indented.printToken(entries.Comma(i-1), gapNone)
-						indented.printPath(entries.At(i).Path, gapSoftline)
-					} else {
-						indented.printPath(entries.At(i).Path, gapNone)
-					}
-
-					opt := entries.At(i)
-					if !opt.Equals.IsZero() {
-						indented.printToken(opt.Equals, gapSpace)
-						indented.printExpr(opt.Value, gapSpace)
-					}
+		p.printToken(openTok, gapSpace)
+		entries := co.Entries()
+		p.withIndent(func(indented *printer) {
+			for i := range entries.Len() {
+				indented.emitSlot(slots, i)
+				if i > 0 {
+					indented.printToken(entries.Comma(i-1), gapNone)
+					indented.printPath(entries.At(i).Path, gapSoftline)
+				} else {
+					indented.printPath(entries.At(i).Path, gapNone)
 				}
-			})
+
+				opt := entries.At(i)
+				if !opt.Equals.IsZero() {
+					indented.printToken(opt.Equals, gapSpace)
+					indented.printExpr(opt.Value, gapSpace)
+				}
+			}
+			p.emitSlot(slots, entries.Len())
 		})
+		p.printToken(closeTok, gapNone)
 	})
 }

experimental/ast/printer/expr.go

@@ -63,34 +63,55 @@ func (p *printer) printArray(expr ast.ExprArray, gap gapStyle) {
 		return
 	}
 
-	p.printFusedBrackets(expr.Brackets(), gap, func(child *printer) {
-		elements := expr.Elements()
-		for i := range elements.Len() {
-			elemGap := gapNone
-			if i > 0 {
-				child.printToken(elements.Comma(i-1), gapNone)
-				elemGap = gapSpace
-			}
-			child.printExpr(elements.At(i), elemGap)
+	brackets := expr.Brackets()
+	if brackets.IsZero() {
+		return
+	}
+
+	openTok, closeTok := brackets.StartEnd()
+	slots := p.trivia.scopeSlots(brackets.ID())
+
+	p.printToken(openTok, gap)
+	elements := expr.Elements()
+	for i := range elements.Len() {
+		p.emitSlot(slots, i)
+		elemGap := gapNone
+		if i > 0 {
+			p.printToken(elements.Comma(i-1), gapNone)
+			elemGap = gapSpace
 		}
-	})
+		p.printExpr(elements.At(i), elemGap)
+	}
+	p.emitSlot(slots, elements.Len())
+	p.printToken(closeTok, gapNone)
 }
 
 func (p *printer) printDict(expr ast.ExprDict, gap gapStyle) {
 	if expr.IsZero() {
 		return
 	}
 
-	p.printFusedBrackets(expr.Braces(), gap, func(child *printer) {
-		elements := expr.Elements()
-		if elements.Len() > 0 {
-			child.withIndent(func(indented *printer) {
-				for i := range elements.Len() {
-					indented.printExprField(elements.At(i), gapNewline)
-				}
-			})
-		}
-	})
+	braces := expr.Braces()
+	if braces.IsZero() {
+		return
+	}
+
+	openTok, closeTok := braces.StartEnd()
+	slots := p.trivia.scopeSlots(braces.ID())
+
+	p.printToken(openTok, gap)
+	elements := expr.Elements()
+	if elements.Len() > 0 || len(slots) > 0 {
+		p.withIndent(func(indented *printer) {
+			for i := range elements.Len() {
+				indented.emitSlot(slots, i)
+				indented.printExprField(elements.At(i), gapNewline)
+			}
+			indented.emitSlot(slots, elements.Len())
+		})
+	}
+
+	p.printToken(closeTok, gapSoftline)
 }
 
 func (p *printer) printExprField(expr ast.ExprField, gap gapStyle) {

experimental/ast/printer/path.go

@@ -38,10 +38,17 @@ func (p *printer) printPath(path ast.Path, gap gapStyle) {
 			}
 
 			if extn := pc.AsExtension(); !extn.IsZero() {
-				// Extension path component like (foo.bar)
-				p.printFusedBrackets(pc.Name(), componentGap, func(child *printer) {
-					child.printPath(extn, gapNone)
-				})
+				// Extension path component like (foo.bar).
+				// The parens are a scope.
+				parens := pc.Name()
+				openTok, closeTok := parens.StartEnd()
+				slots := p.trivia.scopeSlots(parens.ID())
+
+				p.printToken(openTok, componentGap)
+				p.emitSlot(slots, 0)
+				p.printPath(extn, gapNone)
+				p.emitSlot(slots, 1)
+				p.printToken(closeTok, gapNone)
 			} else {
 				// Simple identifier
 				p.printToken(pc.Name(), componentGap)