Add number of deprecated types to protostat

private/buf/bufprint/stats_printer.go

@@ -38,20 +38,22 @@ func (p *statsPrinter) PrintStats(ctx context.Context, format Format, stats *pro
 	case FormatText:
 		_, err := fmt.Fprintf(
 			p.writer,
-			`Files:       %d
-Types:       %d
-Packages:    %d
-Messages:    %d
-Fields:      %d
-Enums:       %d
-Enum Values: %d
-Services:    %d
-RPCs:        %d
-Extensions:  %d
+			`Files:            %d
+Types:            %d
+Deprecated Types: %d
+Packages:         %d
+Messages:         %d
+Fields:           %d
+Enums:            %d
+Enum Values:      %d
+Services:         %d
+RPCs:             %d
+Extensions:       %d
 `,
 
 			stats.Files,
 			stats.Types,
+			stats.DeprecatedTypes,
 			stats.Packages,
 			stats.Messages,
 			stats.Fields,

private/pkg/protostat/protostat.go

@@ -30,6 +30,7 @@ import (
 type Stats struct {
 	Files                 int `json:"files" yaml:"files"`
 	Types                 int `json:"types" yaml:"types"`
+	DeprecatedTypes       int `json:"deprecated_types" yaml:"deprecated_types"`
 	Packages              int `json:"packages" yaml:"packages"`
 	Messages              int `json:"messages" yaml:"messages"`
 	Fields                int `json:"fields" yaml:"fields"`
@@ -98,6 +99,7 @@ func MergeStats(statsSlice ...*Stats) *Stats {
 		resultStats.FilesWithSyntaxErrors += stats.FilesWithSyntaxErrors
 		resultStats.Packages += stats.Packages
 		resultStats.Types += stats.Types
+		resultStats.DeprecatedTypes += stats.DeprecatedTypes
 		resultStats.Messages += stats.Messages
 		resultStats.Fields += stats.Fields
 		resultStats.Enums += stats.Enums
@@ -129,46 +131,54 @@ func examineFile(statsBuilder *statsBuilder, fileNode *ast.FileNode) {
 		case *ast.PackageNode:
 			statsBuilder.packages[decl.Name.AsIdentifier()] = struct{}{}
 		case *ast.MessageNode:
-			examineMessage(statsBuilder, &decl.MessageBody)
+			examineMessage(statsBuilder, &decl.MessageBody, decl)
 		case *ast.EnumNode:
 			examineEnum(statsBuilder, decl)
 		case *ast.ExtendNode:
 			examineExtend(statsBuilder, decl)
 		case *ast.ServiceNode:
 			statsBuilder.Services++
 			for _, decl := range decl.Decls {
-				_, ok := decl.(*ast.RPCNode)
+				rpcNode, ok := decl.(*ast.RPCNode)
 				if ok {
 					statsBuilder.RPCs++
 					statsBuilder.Types++
+					if isDeprecated(rpcNode) {
+						statsBuilder.DeprecatedTypes++
+					}
 				}
 			}
 		}
 	}
 }
 
-func examineMessage(statsBuilder *statsBuilder, messageBody *ast.MessageBody) {
+// examineMessage examines a message body and updates stats.
+// The node parameter is used to check for deprecated options, and can be a MessageNode or GroupNode.
+func examineMessage(statsBuilder *statsBuilder, messageBody *ast.MessageBody, node ast.NodeWithOptions) {
 	statsBuilder.Messages++
 	statsBuilder.Types++
+	if node != nil && isDeprecated(node) {
+		statsBuilder.DeprecatedTypes++
+	}
 	for _, decl := range messageBody.Decls {
 		switch decl := decl.(type) {
 		case *ast.FieldNode, *ast.MapFieldNode:
 			statsBuilder.Fields++
 		case *ast.GroupNode:
 			statsBuilder.Fields++
-			examineMessage(statsBuilder, &decl.MessageBody)
+			examineMessage(statsBuilder, &decl.MessageBody, decl)
 		case *ast.OneofNode:
 			for _, ooDecl := range decl.Decls {
 				switch ooDecl := ooDecl.(type) {
 				case *ast.FieldNode:
 					statsBuilder.Fields++
 				case *ast.GroupNode:
 					statsBuilder.Fields++
-					examineMessage(statsBuilder, &ooDecl.MessageBody)
+					examineMessage(statsBuilder, &ooDecl.MessageBody, ooDecl)
 				}
 			}
 		case *ast.MessageNode:
-			examineMessage(statsBuilder, &decl.MessageBody)
+			examineMessage(statsBuilder, &decl.MessageBody, decl)
 		case *ast.EnumNode:
 			examineEnum(statsBuilder, decl)
 		case *ast.ExtendNode:
@@ -180,6 +190,9 @@ func examineMessage(statsBuilder *statsBuilder, messageBody *ast.MessageBody) {
 func examineEnum(statsBuilder *statsBuilder, enumNode *ast.EnumNode) {
 	statsBuilder.Enums++
 	statsBuilder.Types++
+	if isDeprecated(enumNode) {
+		statsBuilder.DeprecatedTypes++
+	}
 	for _, decl := range enumNode.Decls {
 		_, ok := decl.(*ast.EnumValueNode)
 		if ok {
@@ -195,7 +208,34 @@ func examineExtend(statsBuilder *statsBuilder, extendNode *ast.ExtendNode) {
 			statsBuilder.Extensions++
 		case *ast.GroupNode:
 			statsBuilder.Extensions++
-			examineMessage(statsBuilder, &decl.MessageBody)
+			examineMessage(statsBuilder, &decl.MessageBody, decl)
 		}
 	}
 }
+
+func isDeprecated(node ast.NodeWithOptions) bool {
+	deprecated := false
+	node.RangeOptions(func(opt *ast.OptionNode) bool {
+		// Check if this is the "deprecated" option (simple name, not extension)
+		if opt.Name == nil || len(opt.Name.Parts) != 1 {
+			return true // continue
+		}
+		part := opt.Name.Parts[0]
+		if part.IsExtension() {
+			return true // continue
+		}
+		if part.Value() != "deprecated" {
+			return true // continue
+		}
+		// Check if the value is true
+		val := opt.Val.Value()
+		switch v := val.(type) {
+		case bool:
+			deprecated = v
+		case ast.Identifier:
+			deprecated = string(v) == "true"
+		}
+		return false // stop iterating once we find deprecated option
+	})
+	return deprecated
+}