util.go

// Copyright 2020-2023 Buf Technologies, Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//      http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

package bufbreakingcheck

import (
	"fmt"
	"sort"
	"strings"

	"github.com/bufbuild/buf/private/bufpkg/bufanalysis"
	"github.com/bufbuild/buf/private/bufpkg/bufcheck/internal"
	"github.com/bufbuild/buf/private/pkg/protosource"
	"google.golang.org/protobuf/types/descriptorpb"
)

var (
	// https://developers.google.com/protocol-buffers/docs/proto3#updating
	fieldDescriptorProtoTypeToWireCompatiblityGroup = map[descriptorpb.FieldDescriptorProto_Type]int{
		descriptorpb.FieldDescriptorProto_TYPE_INT32:  1,
		descriptorpb.FieldDescriptorProto_TYPE_INT64:  1,
		descriptorpb.FieldDescriptorProto_TYPE_UINT32: 1,
		descriptorpb.FieldDescriptorProto_TYPE_UINT64: 1,
		descriptorpb.FieldDescriptorProto_TYPE_BOOL:   1,
		descriptorpb.FieldDescriptorProto_TYPE_SINT32: 2,
		descriptorpb.FieldDescriptorProto_TYPE_SINT64: 2,
		// While string and bytes are compatible if the bytes are valid UTF-8, we cannot
		// determine if a field will actually be valid UTF-8, as we are concerned with the
		// definitions and not individual messages, so we have these in different
		// compatibility groups. We allow string to evolve to bytes, but not bytes to
		// string, but we need them to be in different compatibility groups so that
		// we have to manually detect this.
		descriptorpb.FieldDescriptorProto_TYPE_STRING:   3,
		descriptorpb.FieldDescriptorProto_TYPE_BYTES:    4,
		descriptorpb.FieldDescriptorProto_TYPE_FIXED32:  5,
		descriptorpb.FieldDescriptorProto_TYPE_SFIXED32: 5,
		descriptorpb.FieldDescriptorProto_TYPE_FIXED64:  6,
		descriptorpb.FieldDescriptorProto_TYPE_SFIXED64: 6,
		descriptorpb.FieldDescriptorProto_TYPE_DOUBLE:   7,
		descriptorpb.FieldDescriptorProto_TYPE_FLOAT:    8,
		descriptorpb.FieldDescriptorProto_TYPE_GROUP:    9,
		// Embedded messages are compatible with bytes if the bytes are serialized versions
		// of the message, but we have no way of verifying this.
		descriptorpb.FieldDescriptorProto_TYPE_MESSAGE: 10,
		// Enum is compatible with int32, uint32, int64, uint64 if the values match
		// an enum value, but we have no way of verifying this.
		descriptorpb.FieldDescriptorProto_TYPE_ENUM: 11,
	}

	// https://developers.google.com/protocol-buffers/docs/proto3#json
	// this is not just JSON-compatible, but also wire-compatible, i.e. the intersection
	fieldDescriptorProtoTypeToWireJSONCompatiblityGroup = map[descriptorpb.FieldDescriptorProto_Type]int{
		// fixed32 not compatible for wire so not included
		descriptorpb.FieldDescriptorProto_TYPE_INT32:  1,
		descriptorpb.FieldDescriptorProto_TYPE_UINT32: 1,
		// fixed64 not compatible for wire so not included
		descriptorpb.FieldDescriptorProto_TYPE_INT64:    2,
		descriptorpb.FieldDescriptorProto_TYPE_UINT64:   2,
		descriptorpb.FieldDescriptorProto_TYPE_FIXED32:  3,
		descriptorpb.FieldDescriptorProto_TYPE_SFIXED32: 3,
		descriptorpb.FieldDescriptorProto_TYPE_FIXED64:  4,
		descriptorpb.FieldDescriptorProto_TYPE_SFIXED64: 4,
		descriptorpb.FieldDescriptorProto_TYPE_BOOL:     5,
		descriptorpb.FieldDescriptorProto_TYPE_SINT32:   6,
		descriptorpb.FieldDescriptorProto_TYPE_SINT64:   7,
		descriptorpb.FieldDescriptorProto_TYPE_STRING:   8,
		descriptorpb.FieldDescriptorProto_TYPE_BYTES:    9,
		descriptorpb.FieldDescriptorProto_TYPE_DOUBLE:   10,
		descriptorpb.FieldDescriptorProto_TYPE_FLOAT:    11,
		descriptorpb.FieldDescriptorProto_TYPE_GROUP:    12,
		descriptorpb.FieldDescriptorProto_TYPE_MESSAGE:  14,
		descriptorpb.FieldDescriptorProto_TYPE_ENUM:     15,
	}
)

// addFunc adds a FileAnnotation.
//
// Both the Descriptor and Location can be nil.
type addFunc func(protosource.Descriptor, []protosource.Descriptor, protosource.Location, string, ...interface{})

// corpus is a store of the previous files and files given to a check function.
//
// this is passed down so that pair functions have access to the original inputs.
type corpus struct {
	previousFiles []protosource.File
	files         []protosource.File
}

func newCorpus(
	previousFiles []protosource.File,
	files []protosource.File,
) *corpus {
	return &corpus{
		previousFiles: previousFiles,
		files:         files,
	}
}

func newFilesCheckFunc(
	f func(addFunc, *corpus) error,
) func(string, internal.IgnoreFunc, []protosource.File, []protosource.File) ([]bufanalysis.FileAnnotation, error) {
	return func(id string, ignoreFunc internal.IgnoreFunc, previousFiles []protosource.File, files []protosource.File) ([]bufanalysis.FileAnnotation, error) {
		helper := internal.NewHelper(id, ignoreFunc)
		if err := f(helper.AddFileAnnotationWithExtraIgnoreDescriptorsf, newCorpus(previousFiles, files)); err != nil {
			return nil, err
		}
		return helper.FileAnnotations(), nil
	}
}

func newFilePairCheckFunc(
	f func(addFunc, *corpus, protosource.File, protosource.File) error,
) func(string, internal.IgnoreFunc, []protosource.File, []protosource.File) ([]bufanalysis.FileAnnotation, error) {
	return newFilesCheckFunc(
		func(add addFunc, corpus *corpus) error {
			previousFilePathToFile, err := protosource.FilePathToFile(corpus.previousFiles...)
			if err != nil {
				return err
			}
			filePathToFile, err := protosource.FilePathToFile(corpus.files...)
			if err != nil {
				return err
			}
			for previousFilePath, previousFile := range previousFilePathToFile {
				if file, ok := filePathToFile[previousFilePath]; ok {
					if err := f(add, corpus, previousFile, file); err != nil {
						return err
					}
				}
			}
			return nil
		},
	)
}

func newEnumPairCheckFunc(
	f func(addFunc, *corpus, protosource.Enum, protosource.Enum) error,
) func(string, internal.IgnoreFunc, []protosource.File, []protosource.File) ([]bufanalysis.FileAnnotation, error) {
	return newFilesCheckFunc(
		func(add addFunc, corpus *corpus) error {
			previousFullNameToEnum, err := protosource.FullNameToEnum(corpus.previousFiles...)
			if err != nil {
				return err
			}
			fullNameToEnum, err := protosource.FullNameToEnum(corpus.files...)
			if err != nil {
				return err
			}
			for previousFullName, previousEnum := range previousFullNameToEnum {
				if enum, ok := fullNameToEnum[previousFullName]; ok {
					if err := f(add, corpus, previousEnum, enum); err != nil {
						return err
					}
				}
			}
			return nil
		},
	)
}

// compares all the enums that are of the same number
// map is from name to EnumValue for the given number
func newEnumValuePairCheckFunc(
	f func(addFunc, *corpus, map[string]protosource.EnumValue, map[string]protosource.EnumValue) error,
) func(string, internal.IgnoreFunc, []protosource.File, []protosource.File) ([]bufanalysis.FileAnnotation, error) {
	return newEnumPairCheckFunc(
		func(add addFunc, corpus *corpus, previousEnum protosource.Enum, enum protosource.Enum) error {
			previousNumberToNameToEnumValue, err := protosource.NumberToNameToEnumValue(previousEnum)
			if err != nil {
				return err
			}
			numberToNameToEnumValue, err := protosource.NumberToNameToEnumValue(enum)
			if err != nil {
				return err
			}
			for previousNumber, previousNameToEnumValue := range previousNumberToNameToEnumValue {
				if nameToEnumValue, ok := numberToNameToEnumValue[previousNumber]; ok {
					if err := f(add, corpus, previousNameToEnumValue, nameToEnumValue); err != nil {
						return err
					}
				}
			}
			return nil
		},
	)
}

func newMessagePairCheckFunc(
	f func(addFunc, *corpus, protosource.Message, protosource.Message) error,
) func(string, internal.IgnoreFunc, []protosource.File, []protosource.File) ([]bufanalysis.FileAnnotation, error) {
	return newFilesCheckFunc(
		func(add addFunc, corpus *corpus) error {
			previousFullNameToMessage, err := protosource.FullNameToMessage(corpus.previousFiles...)
			if err != nil {
				return err
			}
			fullNameToMessage, err := protosource.FullNameToMessage(corpus.files...)
			if err != nil {
				return err
			}
			for previousFullName, previousMessage := range previousFullNameToMessage {
				if message, ok := fullNameToMessage[previousFullName]; ok {
					if err := f(add, corpus, previousMessage, message); err != nil {
						return err
					}
				}
			}
			return nil
		},
	)
}

func newFieldPairCheckFunc(
	f func(addFunc, *corpus, protosource.Field, protosource.Field) error,
) func(string, internal.IgnoreFunc, []protosource.File, []protosource.File) ([]bufanalysis.FileAnnotation, error) {
	return newMessagePairCheckFunc(
		func(add addFunc, corpus *corpus, previousMessage protosource.Message, message protosource.Message) error {
			previousNumberToField, err := protosource.NumberToMessageField(previousMessage)
			if err != nil {
				return err
			}
			numberToField, err := protosource.NumberToMessageField(message)
			if err != nil {
				return err
			}
			for previousNumber, previousField := range previousNumberToField {
				if field, ok := numberToField[previousNumber]; ok {
					if err := f(add, corpus, previousField, field); err != nil {
						return err
					}
				}
			}
			return nil
		},
	)
}

func newServicePairCheckFunc(
	f func(addFunc, *corpus, protosource.Service, protosource.Service) error,
) func(string, internal.IgnoreFunc, []protosource.File, []protosource.File) ([]bufanalysis.FileAnnotation, error) {
	return newFilesCheckFunc(
		func(add addFunc, corpus *corpus) error {
			previousFullNameToService, err := protosource.FullNameToService(corpus.previousFiles...)
			if err != nil {
				return err
			}
			fullNameToService, err := protosource.FullNameToService(corpus.files...)
			if err != nil {
				return err
			}
			for previousFullName, previousService := range previousFullNameToService {
				if service, ok := fullNameToService[previousFullName]; ok {
					if err := f(add, corpus, previousService, service); err != nil {
						return err
					}
				}
			}
			return nil
		},
	)
}

func newMethodPairCheckFunc(
	f func(addFunc, *corpus, protosource.Method, protosource.Method) error,
) func(string, internal.IgnoreFunc, []protosource.File, []protosource.File) ([]bufanalysis.FileAnnotation, error) {
	return newServicePairCheckFunc(
		func(add addFunc, corpus *corpus, previousService protosource.Service, service protosource.Service) error {
			previousNameToMethod, err := protosource.NameToMethod(previousService)
			if err != nil {
				return err
			}
			nameToMethod, err := protosource.NameToMethod(service)
			if err != nil {
				return err
			}
			for previousName, previousMethod := range previousNameToMethod {
				if method, ok := nameToMethod[previousName]; ok {
					if err := f(add, corpus, previousMethod, method); err != nil {
						return err
					}
				}
			}
			return nil
		},
	)
}

func getDescriptorAndLocationForDeletedEnum(file protosource.File, previousNestedName string) (protosource.Descriptor, protosource.Location, error) {
	if strings.Contains(previousNestedName, ".") {
		nestedNameToMessage, err := protosource.NestedNameToMessage(file)
		if err != nil {
			return nil, nil, err
		}
		split := strings.Split(previousNestedName, ".")
		for i := len(split) - 1; i > 0; i-- {
			if message, ok := nestedNameToMessage[strings.Join(split[0:i], ".")]; ok {
				return message, message.Location(), nil
			}
		}
	}
	return file, nil, nil
}

func getDescriptorAndLocationForDeletedMessage(file protosource.File, nestedNameToMessage map[string]protosource.Message, previousNestedName string) (protosource.Descriptor, protosource.Location) {
	if strings.Contains(previousNestedName, ".") {
		split := strings.Split(previousNestedName, ".")
		for i := len(split) - 1; i > 0; i-- {
			if message, ok := nestedNameToMessage[strings.Join(split[0:i], ".")]; ok {
				return message, message.Location()
			}
		}
	}
	return file, nil
}

func getSortedEnumValueNames(nameToEnumValue map[string]protosource.EnumValue) []string {
	names := make([]string, 0, len(nameToEnumValue))
	for name := range nameToEnumValue {
		names = append(names, name)
	}
	sort.Strings(names)
	return names
}

func getEnumByFullName(files []protosource.File, enumFullName string) (protosource.Enum, error) {
	fullNameToEnum, err := protosource.FullNameToEnum(files...)
	if err != nil {
		return nil, err
	}
	enum, ok := fullNameToEnum[enumFullName]
	if !ok {
		return nil, fmt.Errorf("expected enum %q to exist but was not found", enumFullName)
	}
	return enum, nil
}

func withBackupLocation(primary protosource.Location, secondary protosource.Location) protosource.Location {
	if primary != nil {
		return primary
	}
	return secondary
}