protobuf: remove gogoproto

Removes gogo/protobuf from buildx and updates to a version of
moby/buildkit where gogo is removed.

This also changes how the proto files are generated. This is because
newer versions of protobuf are more strict about name conflicts. If two
files have the same name (even if they are relative paths) and are used
in different protoc commands, they'll conflict in the registry.

Since protobuf file generation doesn't work very well with
`paths=source_relative`, this removes the `go:generate` expression and
just relies on the dockerfile to perform the generation.

Signed-off-by: Jonathan A. Sternberg <jonathan.sternberg@docker.com>

vendor/github.com/moby/buildkit/frontend/dockerui/attr.go

@@ -74,11 +74,11 @@ func parseShmSize(v string) (int64, error) {
 	return kb, nil
 }
 
-func parseUlimits(v string) ([]pb.Ulimit, error) {
+func parseUlimits(v string) ([]*pb.Ulimit, error) {
 	if v == "" {
 		return nil, nil
 	}
-	out := make([]pb.Ulimit, 0)
+	out := make([]*pb.Ulimit, 0)
 	fields, err := csvvalue.Fields(v, nil)
 	if err != nil {
 		return nil, err
@@ -88,7 +88,7 @@ func parseUlimits(v string) ([]pb.Ulimit, error) {
 		if err != nil {
 			return nil, err
 		}
-		out = append(out, pb.Ulimit{
+		out = append(out, &pb.Ulimit{
 			Name: ulimit.Name,
 			Soft: ulimit.Soft,
 			Hard: ulimit.Hard,

vendor/github.com/moby/buildkit/frontend/dockerui/config.go

@@ -66,7 +66,7 @@ type Config struct {
 	NetworkMode      pb.NetMode
 	ShmSize          int64
 	Target           string
-	Ulimits          []pb.Ulimit
+	Ulimits          []*pb.Ulimit
 	LinterConfig     *linter.Config
 
 	CacheImports           []client.CacheOptionsEntry
@@ -222,7 +222,7 @@ func (bc *Client) init() error {
 	var cacheImports []client.CacheOptionsEntry
 	// new API
 	if cacheImportsStr := opts[keyCacheImports]; cacheImportsStr != "" {
-		var cacheImportsUM []controlapi.CacheOptionsEntry
+		var cacheImportsUM []*controlapi.CacheOptionsEntry
 		if err := json.Unmarshal([]byte(cacheImportsStr), &cacheImportsUM); err != nil {
 			return errors.Wrapf(err, "failed to unmarshal %s (%q)", keyCacheImports, cacheImportsStr)
 		}

vendor/github.com/moby/buildkit/frontend/gateway/client/attestation.go

@@ -3,6 +3,7 @@ package client
 import (
 	pb "github.com/moby/buildkit/frontend/gateway/pb"
 	"github.com/moby/buildkit/solver/result"
+	digest "github.com/opencontainers/go-digest"
 	"github.com/pkg/errors"
 )
 
@@ -16,7 +17,7 @@ func AttestationToPB[T any](a *result.Attestation[T]) (*pb.Attestation, error) {
 		subjects[i] = &pb.InTotoSubject{
 			Kind:   subject.Kind,
 			Name:   subject.Name,
-			Digest: subject.Digest,
+			Digest: digestSliceToPB(subject.Digest),
 		}
 	}
 
@@ -41,7 +42,7 @@ func AttestationFromPB[T any](a *pb.Attestation) (*result.Attestation[T], error)
 		subjects[i] = result.InTotoSubject{
 			Kind:   subject.Kind,
 			Name:   subject.Name,
-			Digest: subject.Digest,
+			Digest: digestSliceFromPB(subject.Digest),
 		}
 	}
 
@@ -55,3 +56,19 @@ func AttestationFromPB[T any](a *pb.Attestation) (*result.Attestation[T], error)
 		},
 	}, nil
 }
+
+func digestSliceToPB(elems []digest.Digest) []string {
+	clone := make([]string, len(elems))
+	for i, e := range elems {
+		clone[i] = string(e)
+	}
+	return clone
+}
+
+func digestSliceFromPB(elems []string) []digest.Digest {
+	clone := make([]digest.Digest, len(elems))
+	for i, e := range elems {
+		clone[i] = digest.Digest(e)
+	}
+	return clone
+}

vendor/github.com/moby/buildkit/frontend/gateway/grpcclient/client.go

@@ -13,9 +13,6 @@ import (
 	"time"
 
 	distreference "github.com/distribution/reference"
-	"github.com/gogo/googleapis/google/rpc"
-	gogotypes "github.com/gogo/protobuf/types"
-	"github.com/golang/protobuf/ptypes/any"
 	"github.com/moby/buildkit/client/llb"
 	"github.com/moby/buildkit/client/llb/sourceresolver"
 	"github.com/moby/buildkit/frontend/gateway/client"
@@ -36,6 +33,7 @@ import (
 	"google.golang.org/grpc/codes"
 	"google.golang.org/grpc/credentials/insecure"
 	"google.golang.org/grpc/status"
+	"google.golang.org/protobuf/proto"
 )
 
 const frontendPrefix = "BUILDKIT_FRONTEND_OPT_"
@@ -196,10 +194,10 @@ func (c *grpcClient) Run(ctx context.Context, f client.BuildFunc) (retError erro
 			if retError != nil {
 				st, _ := status.FromError(grpcerrors.ToGRPC(ctx, retError))
 				stp := st.Proto()
-				req.Error = &rpc.Status{
+				req.Error = &spb.Status{
 					Code:    stp.Code,
 					Message: stp.Message,
-					Details: convertToGogoAny(stp.Details),
+					Details: stp.Details,
 				}
 			}
 			if _, err := c.client.Return(ctx, req); err != nil && retError == nil {
@@ -251,8 +249,8 @@ func (c *grpcClient) Run(ctx context.Context, f client.BuildFunc) (retError erro
 
 // defaultCaps returns the capabilities that were implemented when capabilities
 // support was added. This list is frozen and should never be changed.
-func defaultCaps() []apicaps.PBCap {
-	return []apicaps.PBCap{
+func defaultCaps() []*apicaps.PBCap {
+	return []*apicaps.PBCap{
 		{ID: string(pb.CapSolveBase), Enabled: true},
 		{ID: string(pb.CapSolveInlineReturn), Enabled: true},
 		{ID: string(pb.CapResolveImage), Enabled: true},
@@ -262,8 +260,8 @@ func defaultCaps() []apicaps.PBCap {
 
 // defaultLLBCaps returns the LLB capabilities that were implemented when capabilities
 // support was added. This list is frozen and should never be changed.
-func defaultLLBCaps() []apicaps.PBCap {
-	return []apicaps.PBCap{
+func defaultLLBCaps() []*apicaps.PBCap {
+	return []*apicaps.PBCap{
 		{ID: string(opspb.CapSourceImage), Enabled: true},
 		{ID: string(opspb.CapSourceLocal), Enabled: true},
 		{ID: string(opspb.CapSourceLocalUnique), Enabled: true},
@@ -331,7 +329,7 @@ func (c *grpcClient) requestForRef(ref client.Reference) (*pb.SolveRequest, erro
 
 func (c *grpcClient) Warn(ctx context.Context, dgst digest.Digest, msg string, opts client.WarnOpts) error {
 	_, err := c.client.Warn(ctx, &pb.WarnRequest{
-		Digest: dgst,
+		Digest: string(dgst),
 		Level:  int64(opts.Level),
 		Short:  []byte(msg),
 		Info:   opts.SourceInfo,
@@ -346,7 +344,7 @@ func (c *grpcClient) Solve(ctx context.Context, creq client.SolveRequest) (res *
 	if creq.Definition != nil {
 		for _, md := range creq.Definition.Metadata {
 			for cap := range md.Caps {
-				if err := c.llbCaps.Supports(cap); err != nil {
+				if err := c.llbCaps.Supports(apicaps.CapID(cap)); err != nil {
 					return nil, err
 				}
 			}
@@ -538,7 +536,7 @@ func (c *grpcClient) ResolveSourceMetadata(ctx context.Context, op *opspb.Source
 	}
 	if resp.Image != nil {
 		r.Image = &sourceresolver.ResolveImageResponse{
-			Digest: resp.Image.Digest,
+			Digest: digest.Digest(resp.Image.Digest),
 			Config: resp.Image.Config,
 		}
 	}
@@ -576,7 +574,7 @@ func (c *grpcClient) resolveImageConfigViaSourceMetadata(ctx context.Context, re
 	}
 	ref = strings.TrimPrefix(resp.Source.Identifier, "docker-image://")
 	ref = strings.TrimPrefix(ref, "oci-layout://")
-	return ref, resp.Image.Digest, resp.Image.Config, nil
+	return ref, digest.Digest(resp.Image.Digest), resp.Image.Config, nil
 }
 
 func (c *grpcClient) ResolveImageConfig(ctx context.Context, ref string, opt sourceresolver.Opt) (string, digest.Digest, []byte, error) {
@@ -622,7 +620,7 @@ func (c *grpcClient) ResolveImageConfig(ctx context.Context, ref string, opt sou
 		// This could occur if the version of buildkitd is too old.
 		newRef = ref
 	}
-	return newRef, resp.Digest, resp.Config, nil
+	return newRef, digest.Digest(resp.Digest), resp.Config, nil
 }
 
 func (c *grpcClient) BuildOpts() client.BuildOpts {
@@ -646,7 +644,7 @@ func (c *grpcClient) CurrentFrontend() (*llb.State, error) {
 		return nil, err
 	}
 	var def opspb.Definition
-	if err := def.Unmarshal(dt); err != nil {
+	if err := proto.Unmarshal(dt, &def); err != nil {
 		return nil, err
 	}
 	op, err := llb.NewDefinitionOp(&def)
@@ -1095,7 +1093,7 @@ func (ctr *container) Start(ctx context.Context, req client.StartRequest) (clien
 				exitError = grpcerrors.FromGRPC(status.ErrorProto(&spb.Status{
 					Code:    exit.Error.Code,
 					Message: exit.Error.Message,
-					Details: convertGogoAny(exit.Error.Details),
+					Details: exit.Error.Details,
 				}))
 				if exit.Code != pb.UnknownExitStatus {
 					exitError = &pb.ExitError{ExitCode: exit.Code, Err: exitError}
@@ -1260,6 +1258,7 @@ func grpcClientConn(ctx context.Context) (context.Context, *grpc.ClientConn, err
 		grpc.WithDefaultCallOptions(grpc.MaxCallSendMsgSize(16 << 20)),
 	}
 
+	//nolint:staticcheck // ignore SA1019 NewClient has different behavior and needs to be tested
 	cc, err := grpc.DialContext(ctx, "localhost", dialOpts...)
 	if err != nil {
 		return ctx, nil, errors.Wrap(err, "failed to create grpc client")
@@ -1285,21 +1284,24 @@ type conn struct {
 func (s *conn) LocalAddr() net.Addr {
 	return dummyAddr{}
 }
+
 func (s *conn) RemoteAddr() net.Addr {
 	return dummyAddr{}
 }
+
 func (s *conn) SetDeadline(t time.Time) error {
 	return nil
 }
+
 func (s *conn) SetReadDeadline(t time.Time) error {
 	return nil
 }
+
 func (s *conn) SetWriteDeadline(t time.Time) error {
 	return nil
 }
 
-type dummyAddr struct {
-}
+type dummyAddr struct{}
 
 func (d dummyAddr) Network() string {
 	return "pipe"
@@ -1346,19 +1348,3 @@ func workers() []client.WorkerInfo {
 func product() string {
 	return os.Getenv("BUILDKIT_EXPORTEDPRODUCT")
 }
-
-func convertGogoAny(in []*gogotypes.Any) []*any.Any {
-	out := make([]*any.Any, len(in))
-	for i := range in {
-		out[i] = &any.Any{TypeUrl: in[i].TypeUrl, Value: in[i].Value}
-	}
-	return out
-}
-
-func convertToGogoAny(in []*any.Any) []*gogotypes.Any {
-	out := make([]*gogotypes.Any, len(in))
-	for i := range in {
-		out[i] = &gogotypes.Any{TypeUrl: in[i].TypeUrl, Value: in[i].Value}
-	}
-	return out
-}

vendor/github.com/moby/buildkit/frontend/gateway/pb/gateway.proto

@@ -2,17 +2,14 @@ syntax = "proto3";
 
 package moby.buildkit.v1.frontend;
 
-import "github.com/gogo/googleapis/google/rpc/status.proto";
-import "github.com/gogo/protobuf/gogoproto/gogo.proto";
+option go_package = "github.com/moby/buildkit/frontend/gateway/pb;moby_buildkit_v1_frontend";
+
 import "github.com/moby/buildkit/api/types/worker.proto";
 import "github.com/moby/buildkit/solver/pb/ops.proto";
 import "github.com/moby/buildkit/sourcepolicy/pb/policy.proto";
 import "github.com/moby/buildkit/util/apicaps/pb/caps.proto";
 import "github.com/tonistiigi/fsutil/types/stat.proto";
-
-option (gogoproto.sizer_all) = true;
-option (gogoproto.marshaler_all) = true;
-option (gogoproto.unmarshaler_all) = true;
+import "google/rpc/status.proto";
 
 service LLBBridge {
 	// apicaps:CapResolveImage
@@ -84,22 +81,20 @@ message Attestation {
 }
 
 enum AttestationKind {
-	option (gogoproto.goproto_enum_prefix) = false;
-	InToto = 0 [(gogoproto.enumvalue_customname) = "AttestationKindInToto"];
-	Bundle = 1 [(gogoproto.enumvalue_customname) = "AttestationKindBundle"];
+	InToto = 0;
+	Bundle = 1;
 }
 
 message InTotoSubject {
 	InTotoSubjectKind kind = 1;
 
-	repeated string digest = 2 [(gogoproto.customtype) = "github.com/opencontainers/go-digest.Digest", (gogoproto.nullable) = false];
+	repeated string digest = 2;
 	string name = 3;
 }
 
 enum InTotoSubjectKind {
-	option (gogoproto.goproto_enum_prefix) = false;
-	Self = 0 [(gogoproto.enumvalue_customname) = "InTotoSubjectKindSelf"];
-	Raw = 1 [(gogoproto.enumvalue_customname) = "InTotoSubjectKindRaw"];
+	Self = 0;
+	Raw = 1;
 }
 
 message ReturnRequest {
@@ -129,7 +124,7 @@ message ResolveImageConfigRequest {
 }
 
 message ResolveImageConfigResponse {
-	string Digest = 1 [(gogoproto.customtype) = "github.com/opencontainers/go-digest.Digest", (gogoproto.nullable) = false];
+	string Digest = 1;
 	bytes Config = 2;
 	string Ref = 3;
 }
@@ -148,7 +143,7 @@ message ResolveSourceMetaResponse {
 }
 
 message ResolveSourceImageResponse {
-	string Digest = 1 [(gogoproto.customtype) = "github.com/opencontainers/go-digest.Digest", (gogoproto.nullable) = false];
+	string Digest = 1;
 	bytes Config = 2;
 }
 
@@ -235,13 +230,13 @@ message EvaluateResponse {
 message PingRequest{
 }
 message PongResponse{
-	repeated moby.buildkit.v1.apicaps.APICap FrontendAPICaps = 1 [(gogoproto.nullable) = false];
-	repeated moby.buildkit.v1.apicaps.APICap LLBCaps = 2 [(gogoproto.nullable) = false];
+	repeated moby.buildkit.v1.apicaps.APICap FrontendAPICaps = 1;
+	repeated moby.buildkit.v1.apicaps.APICap LLBCaps = 2;
 	repeated moby.buildkit.v1.types.WorkerRecord Workers = 3;
 }
 
 message WarnRequest {
-	string digest = 1 [(gogoproto.customtype) = "github.com/opencontainers/go-digest.Digest", (gogoproto.nullable) = false];
+	string digest = 1;
 	int64 level = 2;
 	bytes short = 3;
 	repeated bytes detail = 4;

vendor/github.com/moby/buildkit/frontend/gateway/pb/gateway_grpc.pb.go

@@ -0,0 +1,626 @@
+// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
+// versions:
+// - protoc-gen-go-grpc v1.5.1
+// - protoc             v3.11.4
+// source: gateway.proto
+
+package moby_buildkit_v1_frontend
+
+import (
+	context "context"
+	grpc "google.golang.org/grpc"
+	codes "google.golang.org/grpc/codes"
+	status "google.golang.org/grpc/status"
+)
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the grpc package it is being compiled against.
+// Requires gRPC-Go v1.64.0 or later.
+const _ = grpc.SupportPackageIsVersion9
+
+const (
+	LLBBridge_ResolveImageConfig_FullMethodName = "/moby.buildkit.v1.frontend.LLBBridge/ResolveImageConfig"
+	LLBBridge_ResolveSourceMeta_FullMethodName  = "/moby.buildkit.v1.frontend.LLBBridge/ResolveSourceMeta"
+	LLBBridge_Solve_FullMethodName              = "/moby.buildkit.v1.frontend.LLBBridge/Solve"
+	LLBBridge_ReadFile_FullMethodName           = "/moby.buildkit.v1.frontend.LLBBridge/ReadFile"
+	LLBBridge_ReadDir_FullMethodName            = "/moby.buildkit.v1.frontend.LLBBridge/ReadDir"
+	LLBBridge_StatFile_FullMethodName           = "/moby.buildkit.v1.frontend.LLBBridge/StatFile"
+	LLBBridge_Evaluate_FullMethodName           = "/moby.buildkit.v1.frontend.LLBBridge/Evaluate"
+	LLBBridge_Ping_FullMethodName               = "/moby.buildkit.v1.frontend.LLBBridge/Ping"
+	LLBBridge_Return_FullMethodName             = "/moby.buildkit.v1.frontend.LLBBridge/Return"
+	LLBBridge_Inputs_FullMethodName             = "/moby.buildkit.v1.frontend.LLBBridge/Inputs"
+	LLBBridge_NewContainer_FullMethodName       = "/moby.buildkit.v1.frontend.LLBBridge/NewContainer"
+	LLBBridge_ReleaseContainer_FullMethodName   = "/moby.buildkit.v1.frontend.LLBBridge/ReleaseContainer"
+	LLBBridge_ExecProcess_FullMethodName        = "/moby.buildkit.v1.frontend.LLBBridge/ExecProcess"
+	LLBBridge_Warn_FullMethodName               = "/moby.buildkit.v1.frontend.LLBBridge/Warn"
+)
+
+// LLBBridgeClient is the client API for LLBBridge service.
+//
+// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
+type LLBBridgeClient interface {
+	// apicaps:CapResolveImage
+	ResolveImageConfig(ctx context.Context, in *ResolveImageConfigRequest, opts ...grpc.CallOption) (*ResolveImageConfigResponse, error)
+	// apicaps:CapSourceMetaResolver
+	ResolveSourceMeta(ctx context.Context, in *ResolveSourceMetaRequest, opts ...grpc.CallOption) (*ResolveSourceMetaResponse, error)
+	// apicaps:CapSolveBase
+	Solve(ctx context.Context, in *SolveRequest, opts ...grpc.CallOption) (*SolveResponse, error)
+	// apicaps:CapReadFile
+	ReadFile(ctx context.Context, in *ReadFileRequest, opts ...grpc.CallOption) (*ReadFileResponse, error)
+	// apicaps:CapReadDir
+	ReadDir(ctx context.Context, in *ReadDirRequest, opts ...grpc.CallOption) (*ReadDirResponse, error)
+	// apicaps:CapStatFile
+	StatFile(ctx context.Context, in *StatFileRequest, opts ...grpc.CallOption) (*StatFileResponse, error)
+	// apicaps:CapGatewayEvaluate
+	Evaluate(ctx context.Context, in *EvaluateRequest, opts ...grpc.CallOption) (*EvaluateResponse, error)
+	Ping(ctx context.Context, in *PingRequest, opts ...grpc.CallOption) (*PongResponse, error)
+	Return(ctx context.Context, in *ReturnRequest, opts ...grpc.CallOption) (*ReturnResponse, error)
+	// apicaps:CapFrontendInputs
+	Inputs(ctx context.Context, in *InputsRequest, opts ...grpc.CallOption) (*InputsResponse, error)
+	NewContainer(ctx context.Context, in *NewContainerRequest, opts ...grpc.CallOption) (*NewContainerResponse, error)
+	ReleaseContainer(ctx context.Context, in *ReleaseContainerRequest, opts ...grpc.CallOption) (*ReleaseContainerResponse, error)
+	ExecProcess(ctx context.Context, opts ...grpc.CallOption) (grpc.BidiStreamingClient[ExecMessage, ExecMessage], error)
+	// apicaps:CapGatewayWarnings
+	Warn(ctx context.Context, in *WarnRequest, opts ...grpc.CallOption) (*WarnResponse, error)
+}
+
+type lLBBridgeClient struct {
+	cc grpc.ClientConnInterface
+}
+
+func NewLLBBridgeClient(cc grpc.ClientConnInterface) LLBBridgeClient {
+	return &lLBBridgeClient{cc}
+}
+
+func (c *lLBBridgeClient) ResolveImageConfig(ctx context.Context, in *ResolveImageConfigRequest, opts ...grpc.CallOption) (*ResolveImageConfigResponse, error) {
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
+	out := new(ResolveImageConfigResponse)
+	err := c.cc.Invoke(ctx, LLBBridge_ResolveImageConfig_FullMethodName, in, out, cOpts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *lLBBridgeClient) ResolveSourceMeta(ctx context.Context, in *ResolveSourceMetaRequest, opts ...grpc.CallOption) (*ResolveSourceMetaResponse, error) {
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
+	out := new(ResolveSourceMetaResponse)
+	err := c.cc.Invoke(ctx, LLBBridge_ResolveSourceMeta_FullMethodName, in, out, cOpts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *lLBBridgeClient) Solve(ctx context.Context, in *SolveRequest, opts ...grpc.CallOption) (*SolveResponse, error) {
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
+	out := new(SolveResponse)
+	err := c.cc.Invoke(ctx, LLBBridge_Solve_FullMethodName, in, out, cOpts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *lLBBridgeClient) ReadFile(ctx context.Context, in *ReadFileRequest, opts ...grpc.CallOption) (*ReadFileResponse, error) {
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
+	out := new(ReadFileResponse)
+	err := c.cc.Invoke(ctx, LLBBridge_ReadFile_FullMethodName, in, out, cOpts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *lLBBridgeClient) ReadDir(ctx context.Context, in *ReadDirRequest, opts ...grpc.CallOption) (*ReadDirResponse, error) {
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
+	out := new(ReadDirResponse)
+	err := c.cc.Invoke(ctx, LLBBridge_ReadDir_FullMethodName, in, out, cOpts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *lLBBridgeClient) StatFile(ctx context.Context, in *StatFileRequest, opts ...grpc.CallOption) (*StatFileResponse, error) {
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
+	out := new(StatFileResponse)
+	err := c.cc.Invoke(ctx, LLBBridge_StatFile_FullMethodName, in, out, cOpts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *lLBBridgeClient) Evaluate(ctx context.Context, in *EvaluateRequest, opts ...grpc.CallOption) (*EvaluateResponse, error) {
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
+	out := new(EvaluateResponse)
+	err := c.cc.Invoke(ctx, LLBBridge_Evaluate_FullMethodName, in, out, cOpts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *lLBBridgeClient) Ping(ctx context.Context, in *PingRequest, opts ...grpc.CallOption) (*PongResponse, error) {
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
+	out := new(PongResponse)
+	err := c.cc.Invoke(ctx, LLBBridge_Ping_FullMethodName, in, out, cOpts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *lLBBridgeClient) Return(ctx context.Context, in *ReturnRequest, opts ...grpc.CallOption) (*ReturnResponse, error) {
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
+	out := new(ReturnResponse)
+	err := c.cc.Invoke(ctx, LLBBridge_Return_FullMethodName, in, out, cOpts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *lLBBridgeClient) Inputs(ctx context.Context, in *InputsRequest, opts ...grpc.CallOption) (*InputsResponse, error) {
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
+	out := new(InputsResponse)
+	err := c.cc.Invoke(ctx, LLBBridge_Inputs_FullMethodName, in, out, cOpts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *lLBBridgeClient) NewContainer(ctx context.Context, in *NewContainerRequest, opts ...grpc.CallOption) (*NewContainerResponse, error) {
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
+	out := new(NewContainerResponse)
+	err := c.cc.Invoke(ctx, LLBBridge_NewContainer_FullMethodName, in, out, cOpts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *lLBBridgeClient) ReleaseContainer(ctx context.Context, in *ReleaseContainerRequest, opts ...grpc.CallOption) (*ReleaseContainerResponse, error) {
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
+	out := new(ReleaseContainerResponse)
+	err := c.cc.Invoke(ctx, LLBBridge_ReleaseContainer_FullMethodName, in, out, cOpts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *lLBBridgeClient) ExecProcess(ctx context.Context, opts ...grpc.CallOption) (grpc.BidiStreamingClient[ExecMessage, ExecMessage], error) {
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
+	stream, err := c.cc.NewStream(ctx, &LLBBridge_ServiceDesc.Streams[0], LLBBridge_ExecProcess_FullMethodName, cOpts...)
+	if err != nil {
+		return nil, err
+	}
+	x := &grpc.GenericClientStream[ExecMessage, ExecMessage]{ClientStream: stream}
+	return x, nil
+}
+
+// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
+type LLBBridge_ExecProcessClient = grpc.BidiStreamingClient[ExecMessage, ExecMessage]
+
+func (c *lLBBridgeClient) Warn(ctx context.Context, in *WarnRequest, opts ...grpc.CallOption) (*WarnResponse, error) {
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
+	out := new(WarnResponse)
+	err := c.cc.Invoke(ctx, LLBBridge_Warn_FullMethodName, in, out, cOpts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+// LLBBridgeServer is the server API for LLBBridge service.
+// All implementations should embed UnimplementedLLBBridgeServer
+// for forward compatibility.
+type LLBBridgeServer interface {
+	// apicaps:CapResolveImage
+	ResolveImageConfig(context.Context, *ResolveImageConfigRequest) (*ResolveImageConfigResponse, error)
+	// apicaps:CapSourceMetaResolver
+	ResolveSourceMeta(context.Context, *ResolveSourceMetaRequest) (*ResolveSourceMetaResponse, error)
+	// apicaps:CapSolveBase
+	Solve(context.Context, *SolveRequest) (*SolveResponse, error)
+	// apicaps:CapReadFile
+	ReadFile(context.Context, *ReadFileRequest) (*ReadFileResponse, error)
+	// apicaps:CapReadDir
+	ReadDir(context.Context, *ReadDirRequest) (*ReadDirResponse, error)
+	// apicaps:CapStatFile
+	StatFile(context.Context, *StatFileRequest) (*StatFileResponse, error)
+	// apicaps:CapGatewayEvaluate
+	Evaluate(context.Context, *EvaluateRequest) (*EvaluateResponse, error)
+	Ping(context.Context, *PingRequest) (*PongResponse, error)
+	Return(context.Context, *ReturnRequest) (*ReturnResponse, error)
+	// apicaps:CapFrontendInputs
+	Inputs(context.Context, *InputsRequest) (*InputsResponse, error)
+	NewContainer(context.Context, *NewContainerRequest) (*NewContainerResponse, error)
+	ReleaseContainer(context.Context, *ReleaseContainerRequest) (*ReleaseContainerResponse, error)
+	ExecProcess(grpc.BidiStreamingServer[ExecMessage, ExecMessage]) error
+	// apicaps:CapGatewayWarnings
+	Warn(context.Context, *WarnRequest) (*WarnResponse, error)
+}
+
+// UnimplementedLLBBridgeServer should be embedded to have
+// forward compatible implementations.
+//
+// NOTE: this should be embedded by value instead of pointer to avoid a nil
+// pointer dereference when methods are called.
+type UnimplementedLLBBridgeServer struct{}
+
+func (UnimplementedLLBBridgeServer) ResolveImageConfig(context.Context, *ResolveImageConfigRequest) (*ResolveImageConfigResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method ResolveImageConfig not implemented")
+}
+func (UnimplementedLLBBridgeServer) ResolveSourceMeta(context.Context, *ResolveSourceMetaRequest) (*ResolveSourceMetaResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method ResolveSourceMeta not implemented")
+}
+func (UnimplementedLLBBridgeServer) Solve(context.Context, *SolveRequest) (*SolveResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method Solve not implemented")
+}
+func (UnimplementedLLBBridgeServer) ReadFile(context.Context, *ReadFileRequest) (*ReadFileResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method ReadFile not implemented")
+}
+func (UnimplementedLLBBridgeServer) ReadDir(context.Context, *ReadDirRequest) (*ReadDirResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method ReadDir not implemented")
+}
+func (UnimplementedLLBBridgeServer) StatFile(context.Context, *StatFileRequest) (*StatFileResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method StatFile not implemented")
+}
+func (UnimplementedLLBBridgeServer) Evaluate(context.Context, *EvaluateRequest) (*EvaluateResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method Evaluate not implemented")
+}
+func (UnimplementedLLBBridgeServer) Ping(context.Context, *PingRequest) (*PongResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method Ping not implemented")
+}
+func (UnimplementedLLBBridgeServer) Return(context.Context, *ReturnRequest) (*ReturnResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method Return not implemented")
+}
+func (UnimplementedLLBBridgeServer) Inputs(context.Context, *InputsRequest) (*InputsResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method Inputs not implemented")
+}
+func (UnimplementedLLBBridgeServer) NewContainer(context.Context, *NewContainerRequest) (*NewContainerResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method NewContainer not implemented")
+}
+func (UnimplementedLLBBridgeServer) ReleaseContainer(context.Context, *ReleaseContainerRequest) (*ReleaseContainerResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method ReleaseContainer not implemented")
+}
+func (UnimplementedLLBBridgeServer) ExecProcess(grpc.BidiStreamingServer[ExecMessage, ExecMessage]) error {
+	return status.Errorf(codes.Unimplemented, "method ExecProcess not implemented")
+}
+func (UnimplementedLLBBridgeServer) Warn(context.Context, *WarnRequest) (*WarnResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method Warn not implemented")
+}
+func (UnimplementedLLBBridgeServer) testEmbeddedByValue() {}
+
+// UnsafeLLBBridgeServer may be embedded to opt out of forward compatibility for this service.
+// Use of this interface is not recommended, as added methods to LLBBridgeServer will
+// result in compilation errors.
+type UnsafeLLBBridgeServer interface {
+	mustEmbedUnimplementedLLBBridgeServer()
+}
+
+func RegisterLLBBridgeServer(s grpc.ServiceRegistrar, srv LLBBridgeServer) {
+	// If the following call pancis, it indicates UnimplementedLLBBridgeServer was
+	// embedded by pointer and is nil.  This will cause panics if an
+	// unimplemented method is ever invoked, so we test this at initialization
+	// time to prevent it from happening at runtime later due to I/O.
+	if t, ok := srv.(interface{ testEmbeddedByValue() }); ok {
+		t.testEmbeddedByValue()
+	}
+	s.RegisterService(&LLBBridge_ServiceDesc, srv)
+}
+
+func _LLBBridge_ResolveImageConfig_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(ResolveImageConfigRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(LLBBridgeServer).ResolveImageConfig(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: LLBBridge_ResolveImageConfig_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(LLBBridgeServer).ResolveImageConfig(ctx, req.(*ResolveImageConfigRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _LLBBridge_ResolveSourceMeta_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(ResolveSourceMetaRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(LLBBridgeServer).ResolveSourceMeta(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: LLBBridge_ResolveSourceMeta_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(LLBBridgeServer).ResolveSourceMeta(ctx, req.(*ResolveSourceMetaRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _LLBBridge_Solve_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(SolveRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(LLBBridgeServer).Solve(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: LLBBridge_Solve_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(LLBBridgeServer).Solve(ctx, req.(*SolveRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _LLBBridge_ReadFile_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(ReadFileRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(LLBBridgeServer).ReadFile(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: LLBBridge_ReadFile_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(LLBBridgeServer).ReadFile(ctx, req.(*ReadFileRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _LLBBridge_ReadDir_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(ReadDirRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(LLBBridgeServer).ReadDir(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: LLBBridge_ReadDir_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(LLBBridgeServer).ReadDir(ctx, req.(*ReadDirRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _LLBBridge_StatFile_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(StatFileRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(LLBBridgeServer).StatFile(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: LLBBridge_StatFile_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(LLBBridgeServer).StatFile(ctx, req.(*StatFileRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _LLBBridge_Evaluate_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(EvaluateRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(LLBBridgeServer).Evaluate(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: LLBBridge_Evaluate_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(LLBBridgeServer).Evaluate(ctx, req.(*EvaluateRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _LLBBridge_Ping_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(PingRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(LLBBridgeServer).Ping(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: LLBBridge_Ping_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(LLBBridgeServer).Ping(ctx, req.(*PingRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _LLBBridge_Return_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(ReturnRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(LLBBridgeServer).Return(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: LLBBridge_Return_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(LLBBridgeServer).Return(ctx, req.(*ReturnRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _LLBBridge_Inputs_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(InputsRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(LLBBridgeServer).Inputs(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: LLBBridge_Inputs_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(LLBBridgeServer).Inputs(ctx, req.(*InputsRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _LLBBridge_NewContainer_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(NewContainerRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(LLBBridgeServer).NewContainer(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: LLBBridge_NewContainer_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(LLBBridgeServer).NewContainer(ctx, req.(*NewContainerRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _LLBBridge_ReleaseContainer_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(ReleaseContainerRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(LLBBridgeServer).ReleaseContainer(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: LLBBridge_ReleaseContainer_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(LLBBridgeServer).ReleaseContainer(ctx, req.(*ReleaseContainerRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _LLBBridge_ExecProcess_Handler(srv interface{}, stream grpc.ServerStream) error {
+	return srv.(LLBBridgeServer).ExecProcess(&grpc.GenericServerStream[ExecMessage, ExecMessage]{ServerStream: stream})
+}
+
+// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
+type LLBBridge_ExecProcessServer = grpc.BidiStreamingServer[ExecMessage, ExecMessage]
+
+func _LLBBridge_Warn_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(WarnRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(LLBBridgeServer).Warn(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: LLBBridge_Warn_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(LLBBridgeServer).Warn(ctx, req.(*WarnRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+// LLBBridge_ServiceDesc is the grpc.ServiceDesc for LLBBridge service.
+// It's only intended for direct use with grpc.RegisterService,
+// and not to be introspected or modified (even as a copy)
+var LLBBridge_ServiceDesc = grpc.ServiceDesc{
+	ServiceName: "moby.buildkit.v1.frontend.LLBBridge",
+	HandlerType: (*LLBBridgeServer)(nil),
+	Methods: []grpc.MethodDesc{
+		{
+			MethodName: "ResolveImageConfig",
+			Handler:    _LLBBridge_ResolveImageConfig_Handler,
+		},
+		{
+			MethodName: "ResolveSourceMeta",
+			Handler:    _LLBBridge_ResolveSourceMeta_Handler,
+		},
+		{
+			MethodName: "Solve",
+			Handler:    _LLBBridge_Solve_Handler,
+		},
+		{
+			MethodName: "ReadFile",
+			Handler:    _LLBBridge_ReadFile_Handler,
+		},
+		{
+			MethodName: "ReadDir",
+			Handler:    _LLBBridge_ReadDir_Handler,
+		},
+		{
+			MethodName: "StatFile",
+			Handler:    _LLBBridge_StatFile_Handler,
+		},
+		{
+			MethodName: "Evaluate",
+			Handler:    _LLBBridge_Evaluate_Handler,
+		},
+		{
+			MethodName: "Ping",
+			Handler:    _LLBBridge_Ping_Handler,
+		},
+		{
+			MethodName: "Return",
+			Handler:    _LLBBridge_Return_Handler,
+		},
+		{
+			MethodName: "Inputs",
+			Handler:    _LLBBridge_Inputs_Handler,
+		},
+		{
+			MethodName: "NewContainer",
+			Handler:    _LLBBridge_NewContainer_Handler,
+		},
+		{
+			MethodName: "ReleaseContainer",
+			Handler:    _LLBBridge_ReleaseContainer_Handler,
+		},
+		{
+			MethodName: "Warn",
+			Handler:    _LLBBridge_Warn_Handler,
+		},
+	},
+	Streams: []grpc.StreamDesc{
+		{
+			StreamName:    "ExecProcess",
+			Handler:       _LLBBridge_ExecProcess_Handler,
+			ServerStreams: true,
+			ClientStreams: true,
+		},
+	},
+	Metadata: "gateway.proto",
+}

vendor/github.com/moby/buildkit/frontend/gateway/pb/generate.go

@@ -1,3 +1,3 @@
 package moby_buildkit_v1_frontend //nolint:revive
 
-//go:generate protoc -I=. -I=../../../vendor/ -I=../../../../../../ --gogo_out=plugins=grpc:. gateway.proto
+//go:generate protoc -I=. -I=../../../vendor/ -I=../../../../../../ --go_out=paths=source_relative:. --go-grpc_out=paths=source_relative,require_unimplemented_servers=false:. gateway.proto

vendor/github.com/moby/buildkit/frontend/subrequests/lint/lint.go

@@ -34,11 +34,11 @@ var SubrequestLintDefinition = subrequests.Request{
 }
 
 type Warning struct {
-	RuleName    string      `json:"ruleName"`
-	Description string      `json:"description,omitempty"`
-	URL         string      `json:"url,omitempty"`
-	Detail      string      `json:"detail,omitempty"`
-	Location    pb.Location `json:"location,omitempty"`
+	RuleName    string       `json:"ruleName"`
+	Description string       `json:"description,omitempty"`
+	URL         string       `json:"url,omitempty"`
+	Detail      string       `json:"detail,omitempty"`
+	Location    *pb.Location `json:"location,omitempty"`
 }
 
 func (w *Warning) PrintTo(wr io.Writer, sources []*pb.SourceInfo, scb SourceInfoMap) error {
@@ -93,17 +93,17 @@ func (results *LintResults) AddWarning(rulename, description, url, fmtmsg string
 	sourceLocation := []*pb.Range{}
 	for _, loc := range location {
 		sourceLocation = append(sourceLocation, &pb.Range{
-			Start: pb.Position{
+			Start: &pb.Position{
 				Line:      int32(loc.Start.Line),
 				Character: int32(loc.Start.Character),
 			},
-			End: pb.Position{
+			End: &pb.Position{
 				Line:      int32(loc.End.Line),
 				Character: int32(loc.End.Character),
 			},
 		})
 	}
-	pbLocation := pb.Location{
+	pbLocation := &pb.Location{
 		SourceIndex: int32(sourceIndex),
 		Ranges:      sourceLocation,
 	}