Introduce --controller-clusters for zap regen that generates controller-clusters.matter based on the spec

Author: AryaHassanli

cmd/cli/zap.go

@@ -1,6 +1,10 @@
 package cli
 
 import (
+	"fmt"
+	"path/filepath"
+	"slices"
+
 	"github.com/project-chip/alchemy/cmd/common"
 	"github.com/project-chip/alchemy/internal/files"
 	"github.com/project-chip/alchemy/internal/pipeline"
@@ -220,10 +224,10 @@ type ZAPRegen struct {
 	spec.FilterOptions         `embed:""`
 	sdk.SDKOptions             `embed:""`
 	render.TemplateOptions     `embed:""`
+	ControllerClusters         bool `name:"controller-clusters" help:"Generate controller-clusters.matter from all spec clusters"`
 }
 
 func (z *ZAPRegen) Run(cc *Context) (err error) {
-	zapTargeter := regen.Targeter(z.SdkRoot)
 
 	var specification *spec.Specification
 	specification, _, err = spec.Parse(cc, z.ParserOptions, z.ProcessingOptions, []spec.BuilderOption{spec.PatchForSdk(true)}, z.ASCIIDocAttributes.ToList())
@@ -236,6 +240,12 @@ func (z *ZAPRegen) Run(cc *Context) (err error) {
 		return
 	}
 
+	if z.ControllerClusters {
+		return z.runControllerClusters(cc, specification)
+	}
+
+	zapTargeter := regen.Targeter(z.SdkRoot)
+
 	var zapPaths pipeline.Paths
 	zapPaths, err = pipeline.Start(cc, zapTargeter)
 	if err != nil {
@@ -272,3 +282,66 @@ func (z *ZAPRegen) Run(cc *Context) (err error) {
 
 	return
 }
+
+func (z *ZAPRegen) runControllerClusters(cc *Context, specification *spec.Specification) error {
+	var clusterRefs []zap.ClusterRef
+	for code, cluster := range specification.ClustersByID {
+		clusterRefs = append(clusterRefs, zap.ClusterRef{
+			Code: int(code),
+			Name: cluster.Name,
+			Side: "server",
+		})
+	}
+
+	slices.SortFunc(clusterRefs, func(a, b zap.ClusterRef) int {
+		return a.Code - b.Code
+	})
+
+	var validDeviceTypeCode uint64
+	for id := range specification.DeviceTypesByID {
+		validDeviceTypeCode = id
+		break
+	}
+
+	syntheticFile := &zap.File{
+		EndpointTypes: []zap.EndpointType{
+			{
+				ID:             0,
+				Name:           "Synthetic Endpoint",
+				DeviceTypeCode: int(validDeviceTypeCode),
+				Clusters:       clusterRefs,
+			},
+		},
+		Endpoints: []zap.Endpoint{
+			{
+				EndpointId:        0,
+				EndpointTypeIndex: 0,
+			},
+		},
+	}
+
+	renderer, err := regen.NewIdlRenderer(specification)
+	if err != nil {
+		return err
+	}
+	renderer.SuppressEndpoints = true
+
+	zapPath := filepath.Join(z.SdkRoot, "src/controller/data_model/controller-clusters.zap")
+	zapData := pipeline.NewData[*zap.File](zapPath, syntheticFile)
+
+	outputs, _, err := renderer.Process(cc, zapData, 0, 1)
+	if err != nil {
+		return err
+	}
+
+	if len(outputs) == 0 {
+		return fmt.Errorf("no output generated")
+	}
+
+	writer := files.NewWriter[string]("Writing controller-clusters.matter", z.OutputOptions)
+
+	outputSet := pipeline.StringSet(pipeline.NewMap[string, *pipeline.Data[string]]())
+	outputSet.Store(outputs[0].Path, outputs[0])
+
+	return writer.Write(cc, outputSet, z.ProcessingOptions)
+}

zap/regen/render.go

@@ -16,6 +16,7 @@ import (
 	"github.com/project-chip/alchemy/matter/conformance"
 	"github.com/project-chip/alchemy/matter/spec"
 	"github.com/project-chip/alchemy/matter/types"
+	"github.com/project-chip/alchemy/provisional"
 	"github.com/project-chip/alchemy/zap"
 )
 
@@ -26,6 +27,8 @@ type IdlRenderer struct {
 	spec *spec.Specification
 
 	commonAttributes matter.FieldSet
+
+	SuppressEndpoints bool
 }
 
 func NewIdlRenderer(spec *spec.Specification) (IdlRenderer, error) {
@@ -138,16 +141,7 @@ func (p IdlRenderer) Process(cxt context.Context, input *pipeline.Data[*zap.File
 	namespaces := make(map[string]*matter.Namespace)
 
 	spec.TraverseEntities(p.spec, func(parentCluster *matter.Cluster, parent, entity types.Entity) parse.SearchShould {
-		if parentCluster == nil {
-			switch entity := entity.(type) {
-			case *matter.Bitmap, *matter.Command, *matter.Enum, *matter.Struct:
-				_, ok := globalEntities[entity]
-				if ok {
-					globalEntities[entity] = true
-				}
-			}
-			return parse.SearchShouldContinue
-		}
+
 		ce, ok := clusterEntities[parentCluster]
 		if !ok {
 			return parse.SearchShouldSkip
@@ -172,6 +166,10 @@ func (p IdlRenderer) Process(cxt context.Context, input *pipeline.Data[*zap.File
 				return parse.SearchShouldSkip
 			}
 		}
+		if _, isGlobal := p.spec.GlobalObjects[entity]; isGlobal {
+			globalEntities[entity] = true
+			return parse.SearchShouldContinue
+		}
 		ce[entity] = struct{}{}
 		globalEntities[entity] = false
 		return parse.SearchShouldContinue
@@ -181,6 +179,9 @@ func (p IdlRenderer) Process(cxt context.Context, input *pipeline.Data[*zap.File
 		if !isGlobal {
 			continue
 		}
+		if provisional.Check(p.spec, entity, entity) == provisional.StateUnreferenced {
+			continue
+		}
 		switch entity := entity.(type) {
 		case *matter.Bitmap:
 			globalBitmaps = append(globalBitmaps, entity)
@@ -196,7 +197,11 @@ func (p IdlRenderer) Process(cxt context.Context, input *pipeline.Data[*zap.File
 
 	for fieldName, ns := range namespaces {
 		en := matter.NewEnum(ns.Source(), ns.Parent())
-		en.Name = fieldName + "Tag"
+		if strings.HasSuffix(fieldName, "Tag") {
+			en.Name = fieldName
+		} else {
+			en.Name = fieldName + "Tag"
+		}
 		en.Type = types.NewDataType(types.BaseDataTypeEnum8, types.DataTypeRankScalar)
 		for _, tag := range ns.SemanticTags {
 			nst := matter.NewEnumValue(tag.Source(), en)
@@ -235,6 +240,9 @@ func (p IdlRenderer) Process(cxt context.Context, input *pipeline.Data[*zap.File
 		"clusters":  clusterList,
 		"endpoints": endpoints,
 	}
+	if p.SuppressEndpoints {
+		tc["endpoints"] = nil
+	}
 
 	var t *raymond.Template
 	t, err = p.loadTemplate(p.spec)