implemented ordering preservation

internal/builder/builder.go

@@ -71,87 +71,39 @@ func (b *Builder) writeNodeContent(f *os.File, node *index.ProjectNode, indent i
 	indentStr := strings.Repeat("  ", indent)
 
 	// If this node has a RealName (e.g. +App), we print it as an object definition
-	// UNLESS it is the top-level output file itself?
-	// If we are writing "App.marte", maybe we are writing the *body* of App?
-	// Spec: "unifying multi-file project into a single configuration output"
-
-	// Let's assume we print the Node itself.
 	if node.RealName != "" {
 		fmt.Fprintf(f, "%s%s = {\n", indentStr, node.RealName)
 		indent++
 		indentStr = strings.Repeat("  ", indent)
 	}
 
+	writtenChildren := make(map[string]bool)
+
 	// 2. Write definitions from fragments
 	for _, frag := range node.Fragments {
-		// Use formatter logic to print definitions
-		// We need a temporary Config to use Formatter?
-		// Or just reimplement basic printing? Formatter is better.
-		// But Formatter prints to io.Writer.
-
-		// We can reuse formatDefinition logic if we exposed it, or just copy basic logic.
-		// Since we need to respect indentation, using Formatter.Format might be tricky
-		// unless we wrap definitions in a dummy structure.
-
 		for _, def := range frag.Definitions {
-			// Basic formatting for now, referencing formatter style
-			b.writeDefinition(f, def, indent)
+			switch d := def.(type) {
+			case *parser.Field:
+				b.writeDefinition(f, d, indent)
+			case *parser.ObjectNode:
+				norm := index.NormalizeName(d.Name)
+				if child, ok := node.Children[norm]; ok {
+					if !writtenChildren[norm] {
+						b.writeNodeContent(f, child, indent)
+						writtenChildren[norm] = true
+					}
+				}
+			}
 		}
 	}
 
 	// 3. Write Children (recursively)
-	// Children are sub-nodes defined implicitly via #package A.B or explicitly +Sub
-	// Explicit +Sub are handled via Fragments logic (they are definitions in fragments).
-	// Implicit nodes (from #package A.B.C where B was never explicitly defined)
-	// show up in Children map but maybe not in Fragments?
-
-	// If a Child is NOT in fragments (implicit), we still need to write it.
-	// If it IS in fragments (explicit +Child), it was handled in loop above?
-	// Wait. My Indexer puts `+Sub` into `node.Children["Sub"]` AND adds a `Fragment` to `node` containing `+Sub` object?
-
-	// Let's check Indexer.
-	// Case ObjectNode:
-	//   Adds Fragment to `child` (the Sub node).
-	//   Does NOT add `ObjectNode` definition to `node`'s fragment list?
-	//   "pt.addObjectFragment(child...)"
-	//   It does NOT add to `fileFragment.Definitions`.
-
-	// So `node.Fragments` only contains Fields!
-	// Children are all in `node.Children`.
-
-	// So:
-	// 1. Write Fields (from Fragments).
-	// 2. Write Children (from Children map).
-
-	// But wait, Fragments might have order?
-	// "Relative ordering within a file is preserved."
-	// My Indexer splits Fields and Objects.
-	// Fields go to Fragments. Objects go to Children.
-	// This loses the relative order between Fields and Objects in the source file!
-
-	// Correct Indexer approach for preserving order:
-	// `Fragment` should contain a list of `Entry`.
-	// `Entry` can be `Field` OR `ChildNodeName`.
-
-	// But I just rewrote Indexer to split them.
-	// If strict order is required "within a file", my Indexer is slightly lossy regarding Field vs Object order.
-	// Spec: "Relative ordering within a file is preserved."
-
-	// To fix this without another full rewrite:
-	// Iterating `node.Children` alphabetically is arbitrary.
-	// We should ideally iterate them in the order they appear.
-
-	// For now, I will proceed with writing Children after Fields, which is a common convention,
-	// unless strict interleaving is required.
-	// Given "Class first" rule, reordering happens anyway.
-
-	// Sorting Children?
-	// Maybe keep a list of OrderedChildren in ProjectNode?
-
 	sortedChildren := make([]string, 0, len(node.Children))
 	for k := range node.Children {
+		if !writtenChildren[k] {
 			sortedChildren = append(sortedChildren, k)
 		}
+	}
 	sort.Strings(sortedChildren) // Alphabetical for determinism
 
 	for _, k := range sortedChildren {

internal/index/index.go

@@ -222,6 +222,7 @@ func (pt *ProjectTree) populateNode(node *ProjectNode, file string, config *pars
 			fileFragment.Definitions = append(fileFragment.Definitions, d)
 			pt.indexValue(file, d.Value)
 		case *parser.ObjectNode:
+			fileFragment.Definitions = append(fileFragment.Definitions, d)
 			norm := NormalizeName(d.Name)
 			if _, ok := node.Children[norm]; !ok {
 				node.Children[norm] = &ProjectNode{
@@ -276,6 +277,7 @@ func (pt *ProjectTree) addObjectFragment(node *ProjectNode, file string, obj *pa
 			pt.indexValue(file, d.Value)
 			pt.extractFieldMetadata(node, d)
 		case *parser.ObjectNode:
+			frag.Definitions = append(frag.Definitions, d)
 			norm := NormalizeName(d.Name)
 			if _, ok := node.Children[norm]; !ok {
 				node.Children[norm] = &ProjectNode{
@@ -390,25 +392,65 @@ func (pt *ProjectTree) ResolveReferences() {
 	for i := range pt.References {
 		ref := &pt.References[i]
 		if isoNode, ok := pt.IsolatedFiles[ref.File]; ok {
-			ref.Target = pt.findNode(isoNode, ref.Name)
+			ref.Target = pt.FindNode(isoNode, ref.Name, nil)
 		} else {
-			ref.Target = pt.findNode(pt.Root, ref.Name)
+			ref.Target = pt.FindNode(pt.Root, ref.Name, nil)
 		}
 	}
 }
 
-func (pt *ProjectTree) findNode(root *ProjectNode, name string) *ProjectNode {
+func (pt *ProjectTree) FindNode(root *ProjectNode, name string, predicate func(*ProjectNode) bool) *ProjectNode {
+	if strings.Contains(name, ".") {
+		parts := strings.Split(name, ".")
+		rootName := parts[0]
+
+		var candidates []*ProjectNode
+		pt.findAllNodes(root, rootName, &candidates)
+
+		for _, cand := range candidates {
+			curr := cand
+			valid := true
+			for i := 1; i < len(parts); i++ {
+				nextName := parts[i]
+				normNext := NormalizeName(nextName)
+				if child, ok := curr.Children[normNext]; ok {
+					curr = child
+				} else {
+					valid = false
+					break
+				}
+			}
+			if valid {
+				if predicate == nil || predicate(curr) {
+					return curr
+				}
+			}
+		}
+		return nil
+	}
+
 	if root.RealName == name || root.Name == name {
+		if predicate == nil || predicate(root) {
 			return root
 		}
+	}
 	for _, child := range root.Children {
-		if res := pt.findNode(child, name); res != nil {
+		if res := pt.FindNode(child, name, predicate); res != nil {
 			return res
 		}
 	}
 	return nil
 }
 
+func (pt *ProjectTree) findAllNodes(root *ProjectNode, name string, results *[]*ProjectNode) {
+	if root.RealName == name || root.Name == name {
+		*results = append(*results, root)
+	}
+	for _, child := range root.Children {
+		pt.findAllNodes(child, name, results)
+	}
+}
+
 type QueryResult struct {
 	Node      *ProjectNode
 	Field     *parser.Field

internal/validator/validator.go

@@ -509,7 +509,7 @@ func (v *Validator) getFieldValue(f *parser.Field) string {
 
 func (v *Validator) resolveReference(name string, file string, predicate func(*index.ProjectNode) bool) *index.ProjectNode {
 	if isoNode, ok := v.Tree.IsolatedFiles[file]; ok {
-		if found := v.findNodeRecursive(isoNode, name, predicate); found != nil {
+		if found := v.Tree.FindNode(isoNode, name, predicate); found != nil {
 			return found
 		}
 		return nil
@@ -517,24 +517,7 @@ func (v *Validator) resolveReference(name string, file string, predicate func(*i
 	if v.Tree.Root == nil {
 		return nil
 	}
-	return v.findNodeRecursive(v.Tree.Root, name, predicate)
-}
-
-func (v *Validator) findNodeRecursive(root *index.ProjectNode, name string, predicate func(*index.ProjectNode) bool) *index.ProjectNode {
-	// Simple recursive search matching name
-	if root.RealName == name || root.Name == index.NormalizeName(name) {
-		if predicate == nil || predicate(root) {
-			return root
-		}
-	}
-	
-	// Recursive
-	for _, child := range root.Children {
-		if found := v.findNodeRecursive(child, name, predicate); found != nil {
-			return found
-		}
-	}
-	return nil
+	return v.Tree.FindNode(v.Tree.Root, name, predicate)
 }
 
 func (v *Validator) getNodeClass(node *index.ProjectNode) string {

test/lsp_signal_test.go

@@ -52,13 +52,19 @@ func TestLSPSignalReferences(t *testing.T) {
 
 	// Traverse to MySig
 	dataNode := root.Children["Data"]
-	if dataNode == nil { t.Fatal("Data node not found") }
+	if dataNode == nil {
+		t.Fatal("Data node not found")
+	}
 
 	myDS := dataNode.Children["MyDS"]
-	if myDS == nil { t.Fatal("MyDS node not found") }
+	if myDS == nil {
+		t.Fatal("MyDS node not found")
+	}
 
 	signals := myDS.Children["Signals"]
-	if signals == nil { t.Fatal("Signals node not found") }
+	if signals == nil {
+		t.Fatal("Signals node not found")
+	}
 
 	mySigDef := signals.Children["MySig"]
 	if mySigDef == nil {