Vars

d2compiler/compile_test.go

@@ -3411,6 +3411,64 @@ z: {
 					assert.Equal(t, 3, len(g.Objects[1].Children))
 				},
 			},
+			{
+				name: "array",
+				run: func(t *testing.T) {
+					g := assertCompile(t, `
+vars: {
+	base-constraints: [UNQ; NOT NULL]
+}
+a: {
+  shape: sql_table
+	b: int {constraint: ${base-constraints}}
+}
+`, "")
+					assert.Equal(t, "a", g.Objects[0].ID)
+					assert.Equal(t, 2, len(g.Objects[0].SQLTable.Columns[0].Constraint))
+				},
+			},
+			{
+				name: "spread-array",
+				run: func(t *testing.T) {
+					g := assertCompile(t, `
+vars: {
+	base-constraints: [UNQ; NOT NULL]
+}
+a: {
+  shape: sql_table
+	b: int {constraint: [PK; ...${base-constraints}]}
+}
+`, "")
+					assert.Equal(t, "a", g.Objects[0].ID)
+					assert.Equal(t, 3, len(g.Objects[0].SQLTable.Columns[0].Constraint))
+				},
+			},
+			{
+				name: "sub-array",
+				run: func(t *testing.T) {
+					g := assertCompile(t, `
+vars: {
+	x: all
+}
+z.class: [a; ${x}]
+`, "")
+					assert.Equal(t, "z", g.Objects[0].ID)
+					assert.Equal(t, "all", g.Objects[0].Attributes.Classes[1])
+				},
+			},
+			{
+				name: "multi-part-array",
+				run: func(t *testing.T) {
+					g := assertCompile(t, `
+vars: {
+	x: all
+}
+z.class: [a; ${x}together]
+`, "")
+					assert.Equal(t, "z", g.Objects[0].ID)
+					assert.Equal(t, "alltogether", g.Objects[0].Attributes.Classes[1])
+				},
+			},
 		}
 
 		for _, tc := range tca {
@@ -3742,7 +3800,35 @@ z: {
   ...${x}
   c
 }
-`, `d2/testdata/d2compiler/TestCompile2/vars/errors/spread-non-map.d2:6:3: cannot spread non-map into map`)
+`, `d2/testdata/d2compiler/TestCompile2/vars/errors/spread-non-map.d2:6:3: cannot spread non-composite into composite`)
+				},
+			},
+			{
+				name: "missing-array",
+				run: func(t *testing.T) {
+					assertCompile(t, `
+vars: {
+	x: b
+}
+z: {
+  class: [...${a}]
+}
+`, `d2/testdata/d2compiler/TestCompile2/vars/errors/missing-array.d2:6:3: could not resolve variable "a"`)
+				},
+			},
+			{
+				name: "spread-non-array",
+				run: func(t *testing.T) {
+					assertCompile(t, `
+vars: {
+	x: {
+    a: b
+  }
+}
+z: {
+  class: [...${x}]
+}
+`, `d2/testdata/d2compiler/TestCompile2/vars/errors/spread-non-array.d2:8:11: cannot spread non-array into array`)
 				},
 			},
 			{

d2ir/compile.go

@@ -106,6 +106,13 @@ func (c *compiler) compileSubstitutions(m *Map, varsStack []*Map) {
 		if f.Primary() != nil {
 			c.resolveSubstitutions(varsStack, f)
 		}
+		if arr, ok := f.Composite.(*Array); ok {
+			for _, val := range arr.Values {
+				if scalar, ok := val.(*Scalar); ok {
+					c.resolveSubstitutions(varsStack, scalar)
+				}
+			}
+		}
 		if f.Map() != nil {
 			// don't resolve substitutions in vars with the current scope of vars
 			if f.Name == "vars" {
@@ -145,20 +152,34 @@ func (c *compiler) resolveSubstitutions(varsStack []*Map, node Node) {
 				}
 				if box.Substitution.Spread {
 					if resolvedField.Composite == nil {
-						c.errorf(box.Substitution, "cannot spread non-map into map")
+						c.errorf(box.Substitution, "cannot spread non-composite into composite")
 						continue
 					}
-					// TODO arrays
-					if resolvedField.Map() != nil {
-						OverlayMap(ParentMap(node), resolvedField.Map())
-					}
-					// Remove the placeholder field
-					f := node.(*Field)
-					m := f.parent.(*Map)
-					for i, f2 := range m.Fields {
-						if f == f2 {
-							m.Fields = append(m.Fields[:i], m.Fields[i+1:]...)
-							break
+					switch n := node.(type) {
+					case *Scalar: // Array value
+						resolvedArr, ok := resolvedField.Composite.(*Array)
+						if !ok {
+							c.errorf(box.Substitution, "cannot spread non-array into array")
+							continue
+						}
+						arr := n.parent.(*Array)
+						for i, s := range arr.Values {
+							if s == n {
+								arr.Values = append(append(arr.Values[:i], resolvedArr.Values...), arr.Values[i+1:]...)
+								break
+							}
+						}
+					case *Field:
+						if resolvedField.Map() != nil {
+							OverlayMap(ParentMap(n), resolvedField.Map())
+						}
+						// Remove the placeholder field
+						m := n.parent.(*Map)
+						for i, f2 := range m.Fields {
+							if n == f2 {
+								m.Fields = append(m.Fields[:i], m.Fields[i+1:]...)
+								break
+							}
 						}
 					}
 				}
@@ -167,6 +188,12 @@ func (c *compiler) resolveSubstitutions(varsStack []*Map, node Node) {
 						c.errorf(node.LastRef().AST(), `cannot substitute map variable "%s" as part of a string`, strings.Join(box.Substitution.IDA(), "."))
 						return
 					}
+					switch n := node.(type) {
+					case *Field:
+						n.Primary_ = nil
+					case *Edge:
+						n.Primary_ = nil
+					}
 				} else {
 					if len(s.Value) == 1 {
 						// If lone and unquoted, replace with value of sub
@@ -276,7 +303,9 @@ func (c *compiler) compileMap(dst *Map, ast, scopeAST *d2ast.Map) {
 			})
 		case n.Substitution != nil:
 			if !n.Substitution.Spread {
-				c.errorf(n.Import, "invalid non-spread substitution in map")
+				// TODO parser parses ${x} as a field with name "$" and map of child x
+				// So this is never reached. But that parser behavior could change
+				c.errorf(n.Substitution, "invalid non-spread substitution in map")
 				continue
 			}
 			// placeholder field to be resolved at the end
@@ -653,8 +682,12 @@ func (c *compiler) compileArray(dst *Array, a *d2ast.Array, scopeAST *d2ast.Map)
 				irv = n
 			}
 		case *d2ast.Substitution:
-			// TODO
-			// panic("TODO")
+			irv = &Scalar{
+				parent: dst,
+				Value: &d2ast.UnquotedString{
+					Value: []d2ast.InterpolationBox{{Substitution: an.Substitution}},
+				},
+			}
 		}
 
 		dst.Values = append(dst.Values, irv)

d2parser/parse.go

@@ -1560,7 +1560,8 @@ func (p *parser) parseArrayNode(r rune) d2ast.ArrayNodeBox {
 
 	p.replay(r)
 	vbox := p.parseValue()
-	if vbox.UnquotedString != nil && vbox.UnquotedString.ScalarString() == "" {
+	if vbox.UnquotedString != nil && vbox.UnquotedString.ScalarString() == "" &&
+		!(len(vbox.UnquotedString.Value) > 0 && vbox.UnquotedString.Value[0].Substitution != nil) {
 		p.errorf(p.pos, p.pos.Advance(r, p.utf16), "unquoted strings cannot start on %q", r)
 	}
 	box.Null = vbox.Null