Pretty print statements

runtime/ast/block.go

@@ -20,6 +20,8 @@ package ast
 
 import (
 	"encoding/json"
+
+	"github.com/turbolent/prettier"
 )
 
 type Block struct {
@@ -39,6 +41,45 @@ func (b *Block) Walk(walkChild func(Element)) {
 	walkStatements(walkChild, b.Statements)
 }
 
+var blockStartDoc prettier.Doc = prettier.Text("{")
+var blockEndDoc prettier.Doc = prettier.Text("}")
+var blockEmptyDoc prettier.Doc = prettier.Text("{}")
+
+func (b *Block) Doc() prettier.Doc {
+	if b.IsEmpty() {
+		return blockEmptyDoc
+	}
+
+	return prettier.Concat{
+		blockStartDoc,
+		prettier.Indent{
+			Doc: StatementsDoc(b.Statements),
+		},
+		prettier.HardLine{},
+		blockEndDoc,
+	}
+}
+
+func StatementsDoc(statements []Statement) prettier.Doc {
+	var statementsDoc prettier.Concat
+
+	for _, statement := range statements {
+		// TODO: replace once Statement implements Doc
+		hasDoc, ok := statement.(interface{ Doc() prettier.Doc })
+		if !ok {
+			continue
+		}
+
+		statementsDoc = append(
+			statementsDoc,
+			prettier.HardLine{},
+			hasDoc.Doc(),
+		)
+	}
+
+	return statementsDoc
+}
+
 func (b *Block) MarshalJSON() ([]byte, error) {
 	type Alias Block
 	return json.Marshal(&struct {

runtime/ast/expression.go

@@ -45,6 +45,8 @@ type BoolExpression struct {
 	Range
 }
 
+var _ Expression = &BoolExpression{}
+
 func (*BoolExpression) isExpression() {}
 
 func (*BoolExpression) isIfStatementTest() {}
@@ -96,6 +98,8 @@ type NilExpression struct {
 	Pos Position `json:"-"`
 }
 
+var _ Expression = &NilExpression{}
+
 func (*NilExpression) isExpression() {}
 
 func (*NilExpression) isIfStatementTest() {}
@@ -150,6 +154,8 @@ type StringExpression struct {
 	Range
 }
 
+var _ Expression = &StringExpression{}
+
 func (*StringExpression) isExpression() {}
 
 func (*StringExpression) isIfStatementTest() {}
@@ -194,6 +200,8 @@ type IntegerExpression struct {
 	Range
 }
 
+var _ Expression = &IntegerExpression{}
+
 func (*IntegerExpression) isExpression() {}
 
 func (*IntegerExpression) isIfStatementTest() {}
@@ -250,6 +258,8 @@ type FixedPointExpression struct {
 	Range
 }
 
+var _ Expression = &FixedPointExpression{}
+
 func (*FixedPointExpression) isExpression() {}
 
 func (*FixedPointExpression) isIfStatementTest() {}
@@ -319,6 +329,8 @@ type ArrayExpression struct {
 	Range
 }
 
+var _ Expression = &ArrayExpression{}
+
 func (*ArrayExpression) isExpression() {}
 
 func (*ArrayExpression) isIfStatementTest() {}
@@ -386,6 +398,8 @@ type DictionaryExpression struct {
 	Range
 }
 
+var _ Expression = &DictionaryExpression{}
+
 func (*DictionaryExpression) isExpression() {}
 
 func (*DictionaryExpression) isIfStatementTest() {}
@@ -492,6 +506,8 @@ type IdentifierExpression struct {
 	Identifier Identifier
 }
 
+var _ Expression = &IdentifierExpression{}
+
 func (*IdentifierExpression) isExpression() {}
 
 func (*IdentifierExpression) isIfStatementTest() {}
@@ -564,6 +580,8 @@ type InvocationExpression struct {
 	EndPos            Position `json:"-"`
 }
 
+var _ Expression = &InvocationExpression{}
+
 func (*InvocationExpression) isExpression() {}
 
 func (*InvocationExpression) isIfStatementTest() {}
@@ -690,6 +708,8 @@ type MemberExpression struct {
 	Identifier Identifier
 }
 
+var _ Expression = &MemberExpression{}
+
 func (*MemberExpression) isExpression() {}
 
 func (*MemberExpression) isIfStatementTest() {}
@@ -781,6 +801,8 @@ type IndexExpression struct {
 	Range
 }
 
+var _ Expression = &IndexExpression{}
+
 func (*IndexExpression) isExpression() {}
 
 func (*IndexExpression) isIfStatementTest() {}
@@ -841,6 +863,8 @@ type ConditionalExpression struct {
 	Else Expression
 }
 
+var _ Expression = &ConditionalExpression{}
+
 func (*ConditionalExpression) isExpression() {}
 
 func (*ConditionalExpression) isIfStatementTest() {}
@@ -934,6 +958,8 @@ type UnaryExpression struct {
 	StartPos   Position `json:"-"`
 }
 
+var _ Expression = &UnaryExpression{}
+
 func (*UnaryExpression) isExpression() {}
 
 func (*UnaryExpression) isIfStatementTest() {}
@@ -995,6 +1021,8 @@ type BinaryExpression struct {
 	Right     Expression
 }
 
+var _ Expression = &BinaryExpression{}
+
 func (*BinaryExpression) isExpression() {}
 
 func (*BinaryExpression) isIfStatementTest() {}
@@ -1071,6 +1099,8 @@ type FunctionExpression struct {
 	StartPos             Position `json:"-"`
 }
 
+var _ Expression = &FunctionExpression{}
+
 func (*FunctionExpression) isExpression() {}
 
 func (*FunctionExpression) isIfStatementTest() {}
@@ -1101,8 +1131,6 @@ var functionExpressionParameterSeparatorDoc prettier.Doc = prettier.Concat{
 }
 
 var typeSeparatorDoc prettier.Doc = prettier.Text(": ")
-var functionExpressionBlockStartDoc prettier.Doc = prettier.Text(" {")
-var functionExpressionBlockEndDoc prettier.Doc = prettier.Text("}")
 var functionExpressionEmptyBlockDoc prettier.Doc = prettier.Text(" {}")
 
 func (e *FunctionExpression) Doc() prettier.Doc {
@@ -1128,21 +1156,18 @@ func (e *FunctionExpression) Doc() prettier.Doc {
 
 	if e.FunctionBlock.IsEmpty() {
 		return append(doc, functionExpressionEmptyBlockDoc)
-	}
-
-	// TODO: pre-conditions
-	// TODO: post-conditions
+	} else {
+		// TODO: pre-conditions
+		// TODO: post-conditions
 
-	statementsDoc := e.statementsDoc()
+		blockDoc := e.FunctionBlock.Block.Doc()
 
-	return append(doc,
-		functionExpressionBlockStartDoc,
-		prettier.Indent{
-			Doc: statementsDoc,
-		},
-		prettier.HardLine{},
-		functionExpressionBlockEndDoc,
-	)
+		return append(
+			doc,
+			prettier.Space,
+			blockDoc,
+		)
+	}
 }
 
 func (e *FunctionExpression) parametersDoc() prettier.Doc {
@@ -1165,7 +1190,8 @@ func (e *FunctionExpression) parametersDoc() prettier.Doc {
 			)
 		}
 
-		parameterDoc = append(parameterDoc,
+		parameterDoc = append(
+			parameterDoc,
 			prettier.Text(parameter.Identifier.Identifier),
 			typeSeparatorDoc,
 		)
@@ -1184,27 +1210,6 @@ func (e *FunctionExpression) parametersDoc() prettier.Doc {
 	)
 }
 
-func (e *FunctionExpression) statementsDoc() prettier.Doc {
-	var statementsDoc prettier.Concat
-
-	statements := e.FunctionBlock.Block.Statements
-
-	for _, statement := range statements {
-		// TODO: replace once Statement implements Doc
-		hasDoc, ok := statement.(interface{ Doc() prettier.Doc })
-		if !ok {
-			continue
-		}
-
-		statementsDoc = append(statementsDoc,
-			prettier.HardLine{},
-			hasDoc.Doc(),
-		)
-	}
-
-	return statementsDoc
-}
-
 func (e *FunctionExpression) StartPosition() Position {
 	return e.StartPos
 }
@@ -1235,6 +1240,8 @@ type CastingExpression struct {
 	ParentVariableDeclaration *VariableDeclaration `json:"-"`
 }
 
+var _ Expression = &CastingExpression{}
+
 func (*CastingExpression) isExpression() {}
 
 func (*CastingExpression) isIfStatementTest() {}
@@ -1303,6 +1310,8 @@ type CreateExpression struct {
 	StartPos             Position `json:"-"`
 }
 
+var _ Expression = &CreateExpression{}
+
 func (*CreateExpression) isExpression() {}
 
 func (*CreateExpression) isIfStatementTest() {}
@@ -1362,6 +1371,8 @@ type DestroyExpression struct {
 	StartPos   Position `json:"-"`
 }
 
+var _ Expression = &DestroyExpression{}
+
 func (*DestroyExpression) isExpression() {}
 
 func (*DestroyExpression) isIfStatementTest() {}
@@ -1424,6 +1435,8 @@ type ReferenceExpression struct {
 	StartPos   Position `json:"-"`
 }
 
+var _ Expression = &ReferenceExpression{}
+
 func (*ReferenceExpression) isExpression() {}
 
 func (*ReferenceExpression) isIfStatementTest() {}
@@ -1498,6 +1511,8 @@ type ForceExpression struct {
 	EndPos     Position `json:"-"`
 }
 
+var _ Expression = &ForceExpression{}
+
 func (*ForceExpression) isExpression() {}
 
 func (*ForceExpression) isIfStatementTest() {}
@@ -1557,6 +1572,8 @@ type PathExpression struct {
 	Identifier Identifier
 }
 
+var _ Expression = &PathExpression{}
+
 func (*PathExpression) isExpression() {}
 
 func (*PathExpression) isIfStatementTest() {}

runtime/ast/expression_test.go

@@ -2045,18 +2045,21 @@ func TestFunctionExpression_Doc(t *testing.T) {
 					// TODO: type
 				},
 			},
-			prettier.Text(" {"),
-			prettier.Indent{
-				Doc: prettier.Concat{
-					prettier.HardLine{},
-					prettier.Concat{
-						prettier.Text("return "),
-						prettier.Text("1"),
+			prettier.Text(" "),
+			prettier.Concat{
+				prettier.Text("{"),
+				prettier.Indent{
+					Doc: prettier.Concat{
+						prettier.HardLine{},
+						prettier.Concat{
+							prettier.Text("return "),
+							prettier.Text("1"),
+						},
 					},
 				},
+				prettier.HardLine{},
+				prettier.Text("}"),
 			},
-			prettier.HardLine{},
-			prettier.Text("}"),
 		}
 
 		assert.Equal(t, expected, expr.Doc())