internal/*: add support for parenthesized math expressions

Author: stephen

internal/ast/value.go

@@ -89,24 +89,33 @@ type MathExpression struct {
 	Right Value
 }
 
+// MathParenthesizedExpression is a parenthesized math expression.
+type MathParenthesizedExpression struct {
+	Span
+
+	Value Value
+}
+
 // Comma is a single comma. Some declarations require commas,
 // e.g. font-family fallbacks or transitions.
 type Comma struct {
 	Span
 }
 
-func (String) isValue()         {}
-func (Dimension) isValue()      {}
-func (Function) isValue()       {}
-func (MathExpression) isValue() {}
-func (Comma) isValue()          {}
-func (Identifier) isValue()     {}
-func (HexColor) isValue()       {}
+func (String) isValue()                      {}
+func (Dimension) isValue()                   {}
+func (Function) isValue()                    {}
+func (MathExpression) isValue()              {}
+func (MathParenthesizedExpression) isValue() {}
+func (Comma) isValue()                       {}
+func (Identifier) isValue()                  {}
+func (HexColor) isValue()                    {}
 
 var _ Value = String{}
 var _ Value = Dimension{}
 var _ Value = Function{}
 var _ Value = MathExpression{}
+var _ Value = MathParenthesizedExpression{}
 var _ Value = Comma{}
 var _ Value = Identifier{}
 var _ Value = HexColor{}

internal/ast/walk.go

@@ -74,6 +74,9 @@ func Walk(start Node, visit func(n Node)) {
 		Walk(s.LeftValue, visit)
 		Walk(s.RightValue, visit)
 
+	case *MathParenthesizedExpression:
+		Walk(s.Value, visit)
+
 	case *MathExpression:
 		Walk(s.Left, visit)
 		Walk(s.Right, visit)

internal/parser/parser.go

@@ -248,13 +248,13 @@ func (p *parser) parseMathSum() ast.Value {
 }
 
 func (p *parser) parseMathProduct() ast.Value {
-	left := p.parseValue()
+	left := p.parseMathParenthesizedExpression()
 
 	for p.lexer.Current == lexer.Delim && (p.lexer.CurrentString == "*" || p.lexer.CurrentString == "/") {
 		op := p.lexer.CurrentString
 		p.lexer.Expect(lexer.Delim)
 
-		right := p.parseValue()
+		right := p.parseMathParenthesizedExpression()
 
 		span := left.Location()
 		span.End = right.Location().End
@@ -270,6 +270,22 @@ func (p *parser) parseMathProduct() ast.Value {
 	return left
 }
 
+func (p *parser) parseMathParenthesizedExpression() ast.Value {
+	if p.lexer.Current != lexer.LParen {
+		return p.parseValue()
+	}
+
+	loc := p.lexer.TokenSpan()
+	p.lexer.Expect(lexer.LParen)
+	expr := &ast.MathParenthesizedExpression{
+		Span:  loc,
+		Value: p.parseMathSum(),
+	}
+	expr.End = p.lexer.TokenSpan().End
+	p.lexer.Expect(lexer.RParen)
+	return expr
+}
+
 // parseValue parses a possible ast value at the current position. Callers
 // can set allowMathOperators if the enclosing context allows math expressions.
 // See: https://www.w3.org/TR/css-values-4/#math-function.

internal/parser/span_test.go

@@ -45,6 +45,7 @@ func TestSpans(t *testing.T) {
 .big#THINGS + div, span::after, a:href, a:visited, not.a:problem + a[link="thing"], a[other] {
 	color: purple;
 	background-color: rgba(calc(0 + 1), 2, 3);
+	height: calc(2px / 2 + ( 1rem + 3rem + 6rem) * 8);
 	width: calc(2px / 2 + 1rem * 8)
 }