-- a.cue --
@package("foo")

package bar

@file("foo")

a: {
	@decl(1)
	@decl(2)
} @field(2)

a: {
	@decl(1)
	@decl(3)
} @field(1) @field(4)

a: {} @field(1) @field(3)

doNotPropagate: {
	#A: {} @attr1()
	a: #A

	// Do not accumulated field attributes in embedding.
	#B: {} @attr1()
	b: {#B}
}

embedScalarField: {
	a: {2} @attr1()
	a: {_} @attr2()
}

embedScalarDecl: {
	b0: {2, @attr1()}
	b1: b0
	b2: {2, b0, @attr2()}
}

dontMergeForDef: {
	a: {@decl1()}
	b: a & {x: 1, @decl2()}
	c: a & {@decl2()}
	d: {a, @decl2()}
}

comprehensions: {
	@step(0)
	c1: {} @step(1)
	if true {
		c2: { @step(2a) } @step(2b)
		@step(2c)
	}
	c3: {} @step(3)
	if false {
		c4: { @step(4a) } @step(4b)
		@step(4c)
	}
}

dynamicComplex: {
	a: "foo"

	(a): "foo" @step(1)

	[string]: "foo" @step(2)

	a?: "foo" @step(3)

	b?: "foo" @step(4)

	if true {} // trigger isComplex
}

dynamicSimple: {
	a: "foo"

	a?: "foo" @step(3)

	b?: "foo" @step(4)
}
-- b.cue --
@package("b")

package bar

@file("bar")

a: {
	@decl(5)
} @field(5)
-- out/definition --
package bar

@file("foo")

@file("bar")
a: {
	@decl(1)
	@decl(2)
	@decl(3)
	@decl(5)
} @field(2) @field(1) @field(4) @field(3) @field(5)
doNotPropagate: {
	#A: {} @attr1()
	a: #A

	// Do not accumulated field attributes in embedding.
	#B: {} @attr1()
	b: #B
}
embedScalarField: {
	a: 2 @attr1() @attr2()
}
embedScalarDecl: {
	b0: {
		@attr1()
		2
	}
	b1: b0
	b2: {
		@attr2()
		b0
		2
	}
}
dontMergeForDef: {
	a: {
		@decl1()
	}
	b: a & {
		@decl2()
		x: 1
	}
	c: a & {
		@decl2()
	}
	d: {
		@decl2()
		a
	}
}
comprehensions: {
	@step(0)
	c1: {} @step(1)
	if true {
		@step(2c)
		c2: {
			@step(2a)
		} @step(2b)
	}
	c3: {} @step(3)
	if false {
		@step(4c)
		c4: {
			@step(4a)
		} @step(4b)
	}
}
dynamicComplex: {
	a:        "foo"
	(a):      "foo" @step(1)
	[string]: "foo" @step(2)
	a?:       "foo" @step(3)
	b?:       "foo" @step(4)

	if true {}
}
dynamicSimple: {
	a:  "foo" @step(3)
	b?: "foo" @step(4)
}
-- out/doc --
[]
[a]
[doNotPropagate]
[doNotPropagate #A]
[doNotPropagate a]
[doNotPropagate #B]
- Do not accumulated field attributes in embedding.

[doNotPropagate b]
[embedScalarField]
[embedScalarField a]
[embedScalarDecl]
[embedScalarDecl b0]
[embedScalarDecl b1]
[embedScalarDecl b2]
[dontMergeForDef]
[dontMergeForDef a]
[dontMergeForDef b]
[dontMergeForDef b x]
[dontMergeForDef c]
[dontMergeForDef d]
[comprehensions]
[comprehensions c1]
[comprehensions c2]
[comprehensions c3]
[dynamicComplex]
[dynamicComplex a]
[dynamicComplex b]
[dynamicComplex foo]
[dynamicSimple]
[dynamicSimple a]
[dynamicSimple b]
-- out/value-v3 --
== Simplified
{
	a: {}
	doNotPropagate: {
		a: {}
		b: {}
	}
	embedScalarField: {
		a: 2
	}
	embedScalarDecl: {
		b0: 2
		b1: 2
		b2: 2
	}
	dontMergeForDef: {
		a: {}
		b: {
			x: 1
		}
		c: {}
		d: {}
	}
	comprehensions: {
		c2: {}
		c1: {}
		c3: {}
	}
	dynamicComplex: {
		a:   "foo"
		foo: "foo"
	}
	dynamicSimple: {
		a: "foo"
	}
}
== Raw
{
	a: {}
	doNotPropagate: {
		#A: {}
		a: {}

		// Do not accumulated field attributes in embedding.
		#B: {}
		b: {}
	}
	embedScalarField: {
		a: 2
	}
	embedScalarDecl: {
		b0: 2
		b1: 2
		b2: 2
	}
	dontMergeForDef: {
		a: {}
		b: {
			x: 1
		}
		c: {}
		d: {}
	}
	comprehensions: {
		c2: {}
		c1: {}
		c3: {}
	}
	dynamicComplex: {
		a:   "foo"
		foo: "foo"
		b?:  "foo"
	}
	dynamicSimple: {
		a:  "foo"
		b?: "foo"
	}
}
== Final
{
	a: {}
	doNotPropagate: {
		a: {}
		b: {}
	}
	embedScalarField: {
		a: 2
	}
	embedScalarDecl: {
		b0: 2
		b1: 2
		b2: 2
	}
	dontMergeForDef: {
		a: {}
		b: {
			x: 1
		}
		c: {}
		d: {}
	}
	comprehensions: {
		c2: {}
		c1: {}
		c3: {}
	}
	dynamicComplex: {
		a:   "foo"
		foo: "foo"
	}
	dynamicSimple: {
		a: "foo"
	}
}
== All
{
	@file("foo")

	@file("bar")
	a: {
		@decl(1)
		@decl(2)
		@decl(3)
		@decl(5)
	} @field(2) @field(1) @field(4) @field(3) @field(5)
	doNotPropagate: {
		#A: {} @attr1()
		a: {}

		// Do not accumulated field attributes in embedding.
		#B: {} @attr1()
		b: {}
	}
	embedScalarField: {
		a: 2 @attr1() @attr2()
	}
	embedScalarDecl: {
		b0: {
			2, @attr1()
		}
		b1: {
			2, @attr1()
		}
		b2: {
			2, @attr2(), @attr1()
		}
	}
	dontMergeForDef: {
		a: {
			@decl1()
		}
		b: {
			@decl2(), @decl1()
			x: 1
		}
		c: {
			@decl2(), @decl1()
		}
		d: {
			@decl2(), @decl1()
		}
	}
	comprehensions: {
		@step(0)
		@step(2c)
		c2: {
			@step(2a)
		} @step(2b)
		c1: {} @step(1)
		c3: {} @step(3)
	}
	dynamicComplex: {
		a:   "foo" @step(3) @step(2)
		foo: "foo" @step(1) @step(2)
		b?:  "foo" @step(4) @step(2)
	}
	dynamicSimple: {
		a:  "foo" @step(3)
		b?: "foo" @step(4)
	}
}
== Eval
{
	@file("foo")

	@file("bar")
	a: {
		@decl(1)
		@decl(2)
		@decl(3)
		@decl(5)
	} @field(2) @field(1) @field(4) @field(3) @field(5)
	doNotPropagate: {
		#A: {} @attr1()
		a: {}
		#B: {} @attr1()
		b: {}
	}
	embedScalarField: {
		a: 2 @attr1() @attr2()
	}
	embedScalarDecl: {
		b0: {
			2, @attr1()
		}
		b1: {
			2, @attr1()
		}
		b2: {
			2, @attr2(), @attr1()
		}
	}
	dontMergeForDef: {
		a: {
			@decl1()
		}
		b: {
			@decl2(), @decl1()
			x: 1
		}
		c: {
			@decl2(), @decl1()
		}
		d: {
			@decl2(), @decl1()
		}
	}
	comprehensions: {
		@step(0)
		@step(2c)
		c2: {
			@step(2a)
		} @step(2b)
		c1: {} @step(1)
		c3: {} @step(3)
	}
	dynamicComplex: {
		a:   "foo" @step(3) @step(2)
		foo: "foo" @step(1) @step(2)
		b?:  "foo" @step(4) @step(2)
	}
	dynamicSimple: {
		a:  "foo" @step(3)
		b?: "foo" @step(4)
	}
}
-- diff/-out/value-v3<==>+out/value --
diff old new
--- old
+++ new
@@ -150,11 +150,11 @@
 			@decl1()
 		}
 		b: {
-			@decl1(), @decl2()
-			x: 1
-		}
-		c: {
-			@decl1(), @decl2()
+			@decl2(), @decl1()
+			x: 1
+		}
+		c: {
+			@decl2(), @decl1()
 		}
 		d: {
 			@decl2(), @decl1()
@@ -215,11 +215,11 @@
 			@decl1()
 		}
 		b: {
-			@decl1(), @decl2()
-			x: 1
-		}
-		c: {
-			@decl1(), @decl2()
+			@decl2(), @decl1()
+			x: 1
+		}
+		c: {
+			@decl2(), @decl1()
 		}
 		d: {
 			@decl2(), @decl1()
-- diff/value/todo/p3 --
Reordering of attributes.
-- out/value --
== Simplified
{
	a: {}
	doNotPropagate: {
		a: {}
		b: {}
	}
	embedScalarField: {
		a: 2
	}
	embedScalarDecl: {
		b0: 2
		b1: 2
		b2: 2
	}
	dontMergeForDef: {
		a: {}
		b: {
			x: 1
		}
		c: {}
		d: {}
	}
	comprehensions: {
		c2: {}
		c1: {}
		c3: {}
	}
	dynamicComplex: {
		a:   "foo"
		foo: "foo"
	}
	dynamicSimple: {
		a: "foo"
	}
}
== Raw
{
	a: {}
	doNotPropagate: {
		#A: {}
		a: {}

		// Do not accumulated field attributes in embedding.
		#B: {}
		b: {}
	}
	embedScalarField: {
		a: 2
	}
	embedScalarDecl: {
		b0: 2
		b1: 2
		b2: 2
	}
	dontMergeForDef: {
		a: {}
		b: {
			x: 1
		}
		c: {}
		d: {}
	}
	comprehensions: {
		c2: {}
		c1: {}
		c3: {}
	}
	dynamicComplex: {
		a:   "foo"
		foo: "foo"
		b?:  "foo"
	}
	dynamicSimple: {
		a:  "foo"
		b?: "foo"
	}
}
== Final
{
	a: {}
	doNotPropagate: {
		a: {}
		b: {}
	}
	embedScalarField: {
		a: 2
	}
	embedScalarDecl: {
		b0: 2
		b1: 2
		b2: 2
	}
	dontMergeForDef: {
		a: {}
		b: {
			x: 1
		}
		c: {}
		d: {}
	}
	comprehensions: {
		c2: {}
		c1: {}
		c3: {}
	}
	dynamicComplex: {
		a:   "foo"
		foo: "foo"
	}
	dynamicSimple: {
		a: "foo"
	}
}
== All
{
	@file("foo")

	@file("bar")
	a: {
		@decl(1)
		@decl(2)
		@decl(3)
		@decl(5)
	} @field(2) @field(1) @field(4) @field(3) @field(5)
	doNotPropagate: {
		#A: {} @attr1()
		a: {}

		// Do not accumulated field attributes in embedding.
		#B: {} @attr1()
		b: {}
	}
	embedScalarField: {
		a: 2 @attr1() @attr2()
	}
	embedScalarDecl: {
		b0: {
			2, @attr1()
		}
		b1: {
			2, @attr1()
		}
		b2: {
			2, @attr2(), @attr1()
		}
	}
	dontMergeForDef: {
		a: {
			@decl1()
		}
		b: {
			@decl1(), @decl2()
			x: 1
		}
		c: {
			@decl1(), @decl2()
		}
		d: {
			@decl2(), @decl1()
		}
	}
	comprehensions: {
		@step(0)
		@step(2c)
		c2: {
			@step(2a)
		} @step(2b)
		c1: {} @step(1)
		c3: {} @step(3)
	}
	dynamicComplex: {
		a:   "foo" @step(3) @step(2)
		foo: "foo" @step(1) @step(2)
		b?:  "foo" @step(4) @step(2)
	}
	dynamicSimple: {
		a:  "foo" @step(3)
		b?: "foo" @step(4)
	}
}
== Eval
{
	@file("foo")

	@file("bar")
	a: {
		@decl(1)
		@decl(2)
		@decl(3)
		@decl(5)
	} @field(2) @field(1) @field(4) @field(3) @field(5)
	doNotPropagate: {
		#A: {} @attr1()
		a: {}
		#B: {} @attr1()
		b: {}
	}
	embedScalarField: {
		a: 2 @attr1() @attr2()
	}
	embedScalarDecl: {
		b0: {
			2, @attr1()
		}
		b1: {
			2, @attr1()
		}
		b2: {
			2, @attr2(), @attr1()
		}
	}
	dontMergeForDef: {
		a: {
			@decl1()
		}
		b: {
			@decl1(), @decl2()
			x: 1
		}
		c: {
			@decl1(), @decl2()
		}
		d: {
			@decl2(), @decl1()
		}
	}
	comprehensions: {
		@step(0)
		@step(2c)
		c2: {
			@step(2a)
		} @step(2b)
		c1: {} @step(1)
		c3: {} @step(3)
	}
	dynamicComplex: {
		a:   "foo" @step(3) @step(2)
		foo: "foo" @step(1) @step(2)
		b?:  "foo" @step(4) @step(2)
	}
	dynamicSimple: {
		a:  "foo" @step(3)
		b?: "foo" @step(4)
	}
}
