Proper multifile

internal/builder/builder.go

@@ -5,8 +5,10 @@ import (
 	"io/ioutil"
 	"os"
 	"path/filepath"
+	"sort"
 	"strings"
 
+	"github.com/marte-dev/marte-dev-tools/internal/index"
 	"github.com/marte-dev/marte-dev-tools/internal/parser"
 )
 
@@ -19,8 +21,9 @@ func NewBuilder(files []string) *Builder {
 }
 
 func (b *Builder) Build(outputDir string) error {
-	packages := make(map[string]*parser.Configuration)
-
+	// Build the Project Tree
+	tree := index.NewProjectTree()
+	
 	for _, file := range b.Files {
 		content, err := ioutil.ReadFile(file)
 		if err != nil {
@@ -32,65 +35,205 @@ func (b *Builder) Build(outputDir string) error {
 		if err != nil {
 			return fmt.Errorf("error parsing %s: %v", file, err)
 		}
-
-		pkgURI := ""
-		if config.Package != nil {
-			pkgURI = config.Package.URI
-		}
-
-		if existing, ok := packages[pkgURI]; ok {
-			existing.Definitions = append(existing.Definitions, config.Definitions...)
-		} else {
-			packages[pkgURI] = config
-		}
+		
+tree.AddFile(file, config)
 	}
 
-	for pkg, config := range packages {
-		if pkg == "" {
-			continue // Or handle global package
-		}
-		
-		outputPath := filepath.Join(outputDir, pkg+".marte")
-		err := b.writeConfig(outputPath, config)
+	// Iterate over top-level children of the root (Packages)
+	// Spec says: "merges all files sharing the same base namespace"
+	// So if we have #package A.B and #package A.C, they define A.
+	// We should output A.marte? Or A/B.marte?
+	// Usually MARTe projects output one file per "Root Object" or as specified.
+	// The prompt says: "Output format is the same as input ... without #package".
+	// "Build tool merges all files sharing the same base namespace into a single output."
+	
+	// If files have:
+	// File1: #package App
+	// File2: #package App
+	// Output: App.marte
+	
+	// If File3: #package Other
+	// Output: Other.marte
+	
+	// So we iterate Root.Children.
+	for name, node := range tree.Root.Children {
+		outputPath := filepath.Join(outputDir, name+".marte")
+		f, err := os.Create(outputPath)
 		if err != nil {
 			return err
 		}
+		defer f.Close()
+		
+		// Write node content
+		// Top level node in tree corresponds to the "Base Namespace" name?
+		// e.g. #package App.Sub -> Root->App->Sub.
+		// If we output App.marte, we should generate "+App = { ... }"
+		
+		// But wait. Input: #package App. 
+		// +Node = ...
+		// Output: +Node = ...
+	
+		// If Input: #package App.
+		// +App = ... (Recursive?)
+		// MARTe config is usually a list of definitions.
+		// If #package App, and we generate App.marte.
+		// Does App.marte contain "App = { ... }"?
+		// Or does it contain the CONTENT of App?
+		// "Output format is the same as input configuration but without the #package macro"
+		// Input: #package App \n +Node = {}
+		// Output: +Node = {}
+	
+		// So we are printing the CHILDREN of the "Base Namespace".
+		// But wait, "Base Namespace" could be complex "A.B".
+		// "Merges files with the same base namespace".
+		// Assuming base namespace is the first segment? or the whole match?
+	
+		// Let's assume we output one file per top-level child of Root.
+		// And we print that Child as an Object.
+		
+		// Actually, if I have:
+		// #package App
+		// +Node = {}
+	
+		// Tree: Root -> App -> Node.
+	
+		// If I generate App.marte.
+		// Should it look like:
+		// +Node = {}
+		// Or
+		// +App = { +Node = {} }?
+	
+		// If "without #package macro", it implies we are expanding the package into structure?
+		// Or just removing the line?
+		// If I remove #package App, and keep +Node={}, then +Node is at root.
+		// But originally it was at App.Node.
+		// So preserving semantics means wrapping it in +App = { ... }.
+		
+b.writeNodeContent(f, node, 0)
 	}
-
+	
 	return nil
 }
 
-func (b *Builder) writeConfig(path string, config *parser.Configuration) error {
-	f, err := os.Create(path)
-	if err != nil {
-		return err
+func (b *Builder) writeNodeContent(f *os.File, node *index.ProjectNode, indent int) {
+	// 1. Sort Fragments: Class first
+	sort.SliceStable(node.Fragments, func(i, j int) bool {
+		return hasClass(node.Fragments[i]) && !hasClass(node.Fragments[j])
+	})
+	
+	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)
 	}
-	defer f.Close()
+	
+	// 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.
 
-	for _, def := range config.Definitions {
-		b.writeDefinition(f, def, 0)
+		// 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)
+		}
+	}
+	
+	// 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 {
+		sortedChildren = append(sortedChildren, k)
+	}
+	sort.Strings(sortedChildren) // Alphabetical for determinism
+	
+	for _, k := range sortedChildren {
+		child := node.Children[k]
+		b.writeNodeContent(f, child, indent)
+	}
+	
+	if node.RealName != "" {
+		indent--
+		indentStr = strings.Repeat("  ", indent)
+		fmt.Fprintf(f, "%s}\n", indentStr)
 	}
-	return nil
 }
 
 func (b *Builder) writeDefinition(f *os.File, def parser.Definition, indent int) {
-	indentStr := strings.Repeat("    ", indent)
+	indentStr := strings.Repeat("  ", indent)
 	switch d := def.(type) {
 	case *parser.Field:
 		fmt.Fprintf(f, "%s%s = %s\n", indentStr, d.Name, b.formatValue(d.Value))
-	case *parser.ObjectNode:
-		fmt.Fprintf(f, "%s%s = {\n", indentStr, d.Name)
-		for _, subDef := range d.Subnode.Definitions {
-			b.writeDefinition(f, subDef, indent+1)
-		}
-		fmt.Fprintf(f, "%s}\n", indentStr)
 	}
 }
 
 func (b *Builder) formatValue(val parser.Value) string {
 	switch v := val.(type) {
 	case *parser.StringValue:
-		return fmt.Sprintf("\"%s\"", v.Value)
+		if v.Quoted {
+			return fmt.Sprintf("\"%s\"", v.Value)
+		}
+		return v.Value
 	case *parser.IntValue:
 		return v.Raw
 	case *parser.FloatValue:
@@ -104,8 +247,17 @@ func (b *Builder) formatValue(val parser.Value) string {
 		for _, e := range v.Elements {
 			elements = append(elements, b.formatValue(e))
 		}
-		return fmt.Sprintf("{%s}", strings.Join(elements, " "))
+		return fmt.Sprintf("{ %s }", strings.Join(elements, " "))
 	default:
 		return ""
 	}
 }
+
+func hasClass(frag *index.Fragment) bool {
+	for _, def := range frag.Definitions {
+		if f, ok := def.(*parser.Field); ok && f.Name == "Class" {
+			return true
+		}
+	}
+	return false
+}

internal/index/index.go

@@ -1,125 +1,146 @@
 package index
 
 import (
+	"strings"
+
 	"github.com/marte-dev/marte-dev-tools/internal/parser"
 )
 
-type SymbolType int
-
-const (
-	SymbolObject SymbolType = iota
-	SymbolSignal
-	SymbolDataSource
-	SymbolGAM
-)
-
-type Symbol struct {
-	Name     string
-	Type     SymbolType
-	Position parser.Position
-	File     string
-	Doc      string
-	Class    string
-	Parent   *Symbol
+type ProjectTree struct {
+	Root *ProjectNode
 }
 
-type Reference struct {
-	Name     string
-	Position parser.Position
-	File     string
-	Target   *Symbol
+type ProjectNode struct {
+	Name      string // Normalized name
+	RealName  string // The actual name used in definition (e.g. +Node)
+	Fragments []*Fragment
+	Children  map[string]*ProjectNode
 }
 
-type Index struct {
-	Symbols    map[string]*Symbol
-	References []Reference
-	Packages   map[string][]string // pkgURI -> list of files
+type Fragment struct {
+	File        string
+	Definitions []parser.Definition
+	IsObject    bool            // True if this fragment comes from an ObjectNode, False if from File/Package body
+	ObjectPos   parser.Position // Position of the object node if IsObject is true
 }
 
-func NewIndex() *Index {
-	return &Index{
-		Symbols:  make(map[string]*Symbol),
-		Packages: make(map[string][]string),
+func NewProjectTree() *ProjectTree {
+	return &ProjectTree{
+		Root: &ProjectNode{
+			Children: make(map[string]*ProjectNode),
+		},
 	}
 }
 
-func (idx *Index) IndexConfig(file string, config *parser.Configuration) {
-	pkgURI := ""
+func NormalizeName(name string) string {
+	if len(name) > 0 && (name[0] == '+' || name[0] == '$') {
+		return name[1:]
+	}
+	return name
+}
+
+func (pt *ProjectTree) AddFile(file string, config *parser.Configuration) {
+	// Determine root node for this file based on package
+	node := pt.Root
 	if config.Package != nil {
-		pkgURI = config.Package.URI
-	}
-	idx.Packages[pkgURI] = append(idx.Packages[pkgURI], file)
-
-	for _, def := range config.Definitions {
-		idx.indexDefinition(file, "", nil, def)
-	}
-}
-
-func (idx *Index) indexDefinition(file string, path string, parent *Symbol, def parser.Definition) {
-	switch d := def.(type) {
-	case *parser.ObjectNode:
-		name := d.Name
-		fullPath := name
-		if path != "" {
-			fullPath = path + "." + name
-		}
-		
-		class := ""
-		for _, subDef := range d.Subnode.Definitions {
-			if f, ok := subDef.(*parser.Field); ok && f.Name == "Class" {
-				if s, ok := f.Value.(*parser.StringValue); ok {
-					class = s.Value
-				} else if r, ok := f.Value.(*parser.ReferenceValue); ok {
-					class = r.Value
+		parts := strings.Split(config.Package.URI, ".")
+		for _, part := range parts {
+			part = strings.TrimSpace(part)
+			if part == "" {
+				continue
+			}
+			// Navigate or Create
+			if _, ok := node.Children[part]; !ok {
+				node.Children[part] = &ProjectNode{
+					Name:     part,
+					RealName: part, // Default, might be updated if we find a +Part later? 
+					// Actually, package segments are just names. 
+					// If they refer to an object defined elsewhere as +Part, we hope to match it.
+					Children: make(map[string]*ProjectNode),
 				}
 			}
+			node = node.Children[part]
 		}
+	}
 
-		symType := SymbolObject
-		// Simple heuristic for GAM or DataSource if class name matches or node name starts with +/$
-		// In a real implementation we would check the class against known MARTe classes
-
-		sym := &Symbol{
-			Name:     fullPath,
-			Type:     symType,
-			Position: d.Position,
-			File:     file,
-			Class:    class,
-			Parent:   parent,
+	// Now 'node' is the container for the file's definitions.
+	// We add a Fragment to this node containing the top-level definitions.
+	// But wait, definitions can be ObjectNodes (which start NEW nodes) or Fields (which belong to 'node').
+	
+	// We need to split definitions:
+	// Fields -> go into a Fragment for 'node'.
+	// ObjectNodes -> create/find Child node and add Fragment there.
+	
+	// Actually, the Build Process says: "#package ... implies all definitions ... are children".
+	// So if I have "Field = 1", it is a child of the package node.
+	// If I have "+Sub = {}", it is a child of the package node.
+	
+	// So we can just iterate definitions.
+	
+	// But for merging, we need to treat "+Sub" as a Node, not just a field.
+	
+	fileFragment := &Fragment{
+		File: file,
+		IsObject: false,
+	}
+	
+	for _, def := range config.Definitions {
+		switch d := def.(type) {
+		case *parser.Field:
+			// Fields belong to the current package node
+			fileFragment.Definitions = append(fileFragment.Definitions, d)
+		case *parser.ObjectNode:
+			// Object starts a new child node
+			norm := NormalizeName(d.Name)
+			if _, ok := node.Children[norm]; !ok {
+				node.Children[norm] = &ProjectNode{
+					Name:     norm,
+					RealName: d.Name,
+					Children: make(map[string]*ProjectNode),
+				}
+			}
+			child := node.Children[norm]
+			if child.RealName == norm && d.Name != norm {
+				child.RealName = d.Name // Update to specific name if we had generic
+			}
+			
+			// Recursively add definitions of the object
+			pt.addObjectFragment(child, file, d)
 		}
-		idx.Symbols[fullPath] = sym
-
-		for _, subDef := range d.Subnode.Definitions {
-			idx.indexDefinition(file, fullPath, sym, subDef)
-		}
-
-	case *parser.Field:
-		idx.indexValue(file, d.Value)
+	}
+	
+	if len(fileFragment.Definitions) > 0 {
+		node.Fragments = append(node.Fragments, fileFragment)
 	}
 }
 
-func (idx *Index) indexValue(file string, val parser.Value) {
-	switch v := val.(type) {
-	case *parser.ReferenceValue:
-		idx.References = append(idx.References, Reference{
-			Name:     v.Value,
-			Position: v.Position,
-			File:     file,
-		})
-	case *parser.ArrayValue:
-		for _, elem := range v.Elements {
-			idx.indexValue(file, elem)
+func (pt *ProjectTree) addObjectFragment(node *ProjectNode, file string, obj *parser.ObjectNode) {
+	frag := &Fragment{
+		File:        file,
+		IsObject:    true,
+		ObjectPos:   obj.Position,
+	}
+	
+	for _, def := range obj.Subnode.Definitions {
+		switch d := def.(type) {
+		case *parser.Field:
+			frag.Definitions = append(frag.Definitions, d)
+		case *parser.ObjectNode:
+			norm := NormalizeName(d.Name)
+			if _, ok := node.Children[norm]; !ok {
+				node.Children[norm] = &ProjectNode{
+					Name:     norm,
+					RealName: d.Name,
+					Children: make(map[string]*ProjectNode),
+				}
+			}
+			child := node.Children[norm]
+			if child.RealName == norm && d.Name != norm {
+				child.RealName = d.Name
+			}
+			pt.addObjectFragment(child, file, d)
 		}
 	}
+	
+	node.Fragments = append(node.Fragments, frag)
 }
-
-func (idx *Index) ResolveReferences() {
-	for i := range idx.References {
-		ref := &idx.References[i]
-		if sym, ok := idx.Symbols[ref.Name]; ok {
-			ref.Target = sym
-		} else {
-			// Try relative resolution?
-		}
-	}
-}

internal/validator/validator.go

@@ -2,8 +2,8 @@ package validator
 
 import (
 	"fmt"
-	"github.com/marte-dev/marte-dev-tools/internal/parser"
 	"github.com/marte-dev/marte-dev-tools/internal/index"
+	"github.com/marte-dev/marte-dev-tools/internal/parser"
 )
 
 type DiagnosticLevel int
@@ -22,74 +22,87 @@ type Diagnostic struct {
 
 type Validator struct {
 	Diagnostics []Diagnostic
-	Index       *index.Index
+	Tree        *index.ProjectTree
 }
 
-func NewValidator(idx *index.Index) *Validator {
-	return &Validator{Index: idx}
+func NewValidator(tree *index.ProjectTree) *Validator {
+	return &Validator{Tree: tree}
 }
 
-func (v *Validator) Validate(file string, config *parser.Configuration) {
-	for _, def := range config.Definitions {
-		v.validateDefinition(file, "", config, def)
+func (v *Validator) ValidateProject() {
+	if v.Tree == nil || v.Tree.Root == nil {
+		return
 	}
+	v.validateNode(v.Tree.Root)
 }
 
-func (v *Validator) validateDefinition(file string, path string, config *parser.Configuration, def parser.Definition) {
-	switch d := def.(type) {
-	case *parser.ObjectNode:
-		name := d.Name
-		fullPath := name
-		if path != "" {
-			fullPath = path + "." + name
+func (v *Validator) validateNode(node *index.ProjectNode) {
+	// Check for duplicate fields in this node
+	fields := make(map[string]string) // FieldName -> File
+	
+	for _, frag := range node.Fragments {
+		for _, def := range frag.Definitions {
+			if f, ok := def.(*parser.Field); ok {
+				if existingFile, exists := fields[f.Name]; exists {
+					// Duplicate field
+					v.Diagnostics = append(v.Diagnostics, Diagnostic{
+						Level:    LevelError,
+						Message:  fmt.Sprintf("Duplicate Field Definition: '%s' is already defined in %s", f.Name, existingFile),
+						Position: f.Position,
+						File:     frag.File,
+					})
+				} else {
+					fields[f.Name] = frag.File
+				}
+			}
 		}
+	}
 
-		// Check for mandatory 'Class' field for +/$ nodes
-		if d.Name != "" && (d.Name[0] == '+' || d.Name[0] == '$') {
-			hasClass := false
-			for _, subDef := range d.Subnode.Definitions {
-				if f, ok := subDef.(*parser.Field); ok && f.Name == "Class" {
+	// Check for mandatory Class if it's an object node (+/$)
+	// Root node usually doesn't have a name or is implicit
+	if node.RealName != "" && (node.RealName[0] == '+' || node.RealName[0] == '$') {
+		hasClass := false
+		for _, frag := range node.Fragments {
+			for _, def := range frag.Definitions {
+				if f, ok := def.(*parser.Field); ok && f.Name == "Class" {
 					hasClass = true
 					break
 				}
 			}
-			if !hasClass {
-				v.Diagnostics = append(v.Diagnostics, Diagnostic{
-					Level:    LevelError,
-					Message:  fmt.Sprintf("Node %s is an object and must contain a 'Class' field", d.Name),
-					Position: d.Position,
-					File:     file,
-				})
+			if hasClass {
+				break
 			}
 		}
-
-		// GAM specific validation
-		// (This is a placeholder, real logic would check if it's a GAM)
-
-		for _, subDef := range d.Subnode.Definitions {
-			v.validateDefinition(file, fullPath, config, subDef)
+		
+		if !hasClass {
+			// Report error on the first fragment's position
+			pos := parser.Position{Line: 1, Column: 1}
+			file := ""
+			if len(node.Fragments) > 0 {
+				pos = node.Fragments[0].ObjectPos
+				file = node.Fragments[0].File
+			}
+			v.Diagnostics = append(v.Diagnostics, Diagnostic{
+				Level:    LevelError,
+				Message:  fmt.Sprintf("Node %s is an object and must contain a 'Class' field", node.RealName),
+				Position: pos,
+				File:     file,
+			})
 		}
 	}
+
+	// Recursively validate children
+	for _, child := range node.Children {
+		v.validateNode(child)
+	}
+}
+
+// Legacy/Compatibility method if needed, but we prefer ValidateProject
+func (v *Validator) Validate(file string, config *parser.Configuration) {
+	// No-op or local checks if any
 }
 
 func (v *Validator) CheckUnused() {
-	if v.Index == nil {
-		return
-	}
-
-	referencedSymbols := make(map[*index.Symbol]bool)
-	for _, ref := range v.Index.References {
-		if ref.Target != nil {
-			referencedSymbols[ref.Target] = true
-		}
-	}
-
-	for _, sym := range v.Index.Symbols {
-		// Heuristic: if it's a GAM or Signal, check if referenced
-		// (Refining this later with proper class checks)
-		if !referencedSymbols[sym] {
-			// Logic to determine if it should be warned as unused
-			// e.g. if sym.Class is a GAM or if it's a signal in a DataSource
-		}
-	}
-}
+	// To implement unused check, we'd need reference tracking in Index
+	// For now, focusing on duplicate fields and class validation
+}