diff --git a/authz/rbac_translator.go b/authz/rbac_translator.go
index 8dc76489..fe305a1a 100644
--- a/authz/rbac_translator.go
+++ b/authz/rbac_translator.go
@@ -140,7 +140,7 @@ func getHeaderMatcher(key, value string) *v3routepb.HeaderMatcher {
 }
 
 func parsePrincipalNames(principalNames []string) []*v3rbacpb.Principal {
-	var ps []*v3rbacpb.Principal
+	ps := make([]*v3rbacpb.Principal, 0, len(principalNames))
 	for _, principalName := range principalNames {
 		newPrincipalName := &v3rbacpb.Principal{
 			Identifier: &v3rbacpb.Principal_Authenticated_{
@@ -165,7 +165,7 @@ func parsePeer(source peer) (*v3rbacpb.Principal, error) {
 }
 
 func parsePaths(paths []string) []*v3rbacpb.Permission {
-	var ps []*v3rbacpb.Permission
+	ps := make([]*v3rbacpb.Permission, 0, len(paths))
 	for _, path := range paths {
 		newPath := &v3rbacpb.Permission{
 			Rule: &v3rbacpb.Permission_UrlPath{
@@ -177,7 +177,7 @@ func parsePaths(paths []string) []*v3rbacpb.Permission {
 }
 
 func parseHeaderValues(key string, values []string) []*v3rbacpb.Permission {
-	var vs []*v3rbacpb.Permission
+	vs := make([]*v3rbacpb.Permission, 0, len(values))
 	for _, value := range values {
 		newHeader := &v3rbacpb.Permission{
 			Rule: &v3rbacpb.Permission_Header{
@@ -204,7 +204,7 @@ func unsupportedHeader(key string) bool {
 }
 
 func parseHeaders(headers []header) ([]*v3rbacpb.Permission, error) {
-	var hs []*v3rbacpb.Permission
+	hs := make([]*v3rbacpb.Permission, 0, len(headers))
 	for i, header := range headers {
 		if header.Key == "" {
 			return nil, fmt.Errorf(`"headers" %d: "key" is not present`, i)
diff --git a/balancer/rls/internal/keys/builder.go b/balancer/rls/internal/keys/builder.go
index 5ce5a9da..24767b40 100644
--- a/balancer/rls/internal/keys/builder.go
+++ b/balancer/rls/internal/keys/builder.go
@@ -218,7 +218,7 @@ func (b builder) keys(md metadata.MD) KeyMap {
 }
 
 func mapToString(kv map[string]string) string {
-	var keys []string
+	keys := make([]string, 0, len(kv))
 	for k := range kv {
 		keys = append(keys, k)
 	}
diff --git a/balancer/roundrobin/roundrobin.go b/balancer/roundrobin/roundrobin.go
index 43c2a153..3c163f3b 100644
--- a/balancer/roundrobin/roundrobin.go
+++ b/balancer/roundrobin/roundrobin.go
@@ -51,7 +51,7 @@ func (*rrPickerBuilder) Build(info base.PickerBuildInfo) balancer.Picker {
 	if len(info.ReadySCs) == 0 {
 		return base.NewErrPicker(balancer.ErrNoSubConnAvailable)
 	}
-	var scs []balancer.SubConn
+	scs := make([]balancer.SubConn, 0, len(info.ReadySCs))
 	for sc := range info.ReadySCs {
 		scs = append(scs, sc)
 	}
diff --git a/channelz/service/service.go b/channelz/service/service.go
index c60ab604..c1639de8 100644
--- a/channelz/service/service.go
+++ b/channelz/service/service.go
@@ -78,7 +78,7 @@ func channelTraceToProto(ct *channelz.ChannelTrace) *channelzpb.ChannelTrace {
 	if ts, err := ptypes.TimestampProto(ct.CreationTime); err == nil {
 		pbt.CreationTimestamp = ts
 	}
-	var events []*channelzpb.ChannelTraceEvent
+	events := make([]*channelzpb.ChannelTraceEvent, 0, len(ct.Events))
 	for _, e := range ct.Events {
 		cte := &channelzpb.ChannelTraceEvent{
 			Description: e.Desc,
diff --git a/cmd/protoc-gen-go-grpc/grpc.go b/cmd/protoc-gen-go-grpc/grpc.go
index 24ad747c..f45e0403 100644
--- a/cmd/protoc-gen-go-grpc/grpc.go
+++ b/cmd/protoc-gen-go-grpc/grpc.go
@@ -207,7 +207,7 @@ func genService(gen *protogen.Plugin, file *protogen.File, g *protogen.Generated
 	g.P()
 
 	// Server handler implementations.
-	var handlerNames []string
+	handlerNames := make([]string, 0, len(service.Methods))
 	for _, method := range service.Methods {
 		hname := genServerMethod(gen, file, g, method)
 		handlerNames = append(handlerNames, hname)
diff --git a/internal/channelz/funcs.go b/internal/channelz/funcs.go
index f7314139..6d5760d9 100644
--- a/internal/channelz/funcs.go
+++ b/internal/channelz/funcs.go
@@ -630,7 +630,7 @@ func (c *channelMap) GetServerSockets(id int64, startID int64, maxResults int64)
 	if count == 0 {
 		end = true
 	}
-	var s []*SocketMetric
+	s := make([]*SocketMetric, 0, len(sks))
 	for _, ns := range sks {
 		sm := &SocketMetric{}
 		sm.SocketData = ns.s.ChannelzMetric()
diff --git a/internal/resolver/dns/dns_resolver.go b/internal/resolver/dns/dns_resolver.go
index 03825bbe..fa1f21aa 100644
--- a/internal/resolver/dns/dns_resolver.go
+++ b/internal/resolver/dns/dns_resolver.go
@@ -323,12 +323,12 @@ func (d *dnsResolver) lookupTXT() *serviceconfig.ParseResult {
 }
 
 func (d *dnsResolver) lookupHost() ([]resolver.Address, error) {
-	var newAddrs []resolver.Address
 	addrs, err := d.resolver.LookupHost(d.ctx, d.host)
 	if err != nil {
 		err = handleDNSError(err, "A")
 		return nil, err
 	}
+	newAddrs := make([]resolver.Address, 0, len(addrs))
 	for _, a := range addrs {
 		ip, ok := formatIP(a)
 		if !ok {
diff --git a/internal/resolver/dns/dns_resolver_test.go b/internal/resolver/dns/dns_resolver_test.go
index 73749eca..69307a98 100644
--- a/internal/resolver/dns/dns_resolver_test.go
+++ b/internal/resolver/dns/dns_resolver_test.go
@@ -30,6 +30,8 @@ import (
 	"testing"
 	"time"
 
+	"github.com/google/go-cmp/cmp"
+	"github.com/google/go-cmp/cmp/cmpopts"
 	"google.golang.org/grpc/balancer"
 	grpclbstate "google.golang.org/grpc/balancer/grpclb/state"
 	"google.golang.org/grpc/internal/envconfig"
@@ -748,7 +750,7 @@ func testDNSResolver(t *testing.T) {
 		if cnt == 0 {
 			t.Fatalf("UpdateState not called after 2s; aborting")
 		}
-		if !reflect.DeepEqual(a.addrWant, state.Addresses) {
+		if !cmp.Equal(a.addrWant, state.Addresses, cmpopts.EquateEmpty()) {
 			t.Errorf("Resolved addresses of target: %q = %+v, want %+v", a.target, state.Addresses, a.addrWant)
 		}
 		sc := scFromState(state)
@@ -976,7 +978,7 @@ func testDNSResolverWithSRV(t *testing.T) {
 		if cnt == 0 {
 			t.Fatalf("UpdateState not called after 2s; aborting")
 		}
-		if !reflect.DeepEqual(a.addrWant, state.Addresses) {
+		if !cmp.Equal(a.addrWant, state.Addresses, cmpopts.EquateEmpty()) {
 			t.Errorf("Resolved addresses of target: %q = %+v, want %+v", a.target, state.Addresses, a.addrWant)
 		}
 		gs := grpclbstate.Get(state)
diff --git a/internal/xds/rbac/rbac_engine.go b/internal/xds/rbac/rbac_engine.go
index f08228f7..269edabe 100644
--- a/internal/xds/rbac/rbac_engine.go
+++ b/internal/xds/rbac/rbac_engine.go
@@ -49,7 +49,7 @@ type ChainEngine struct {
 // NewChainEngine returns a chain of RBAC engines, used to make authorization
 // decisions on incoming RPCs. Returns a non-nil error for invalid policies.
 func NewChainEngine(policies []*v3rbacpb.RBAC) (*ChainEngine, error) {
-	var engines []*engine
+	engines := make([]*engine, 0, len(policies))
 	for _, policy := range policies {
 		engine, err := newEngine(policy)
 		if err != nil {
diff --git a/interop/xds/client/client.go b/interop/xds/client/client.go
index 92999b21..190c8a7d 100644
--- a/interop/xds/client/client.go
+++ b/interop/xds/client/client.go
@@ -314,12 +314,13 @@ const (
 	emptyCall string = "EmptyCall"
 )
 
-func parseRPCTypes(rpcStr string) (ret []string) {
+func parseRPCTypes(rpcStr string) []string {
 	if len(rpcStr) == 0 {
 		return []string{unaryCall}
 	}
 
 	rpcs := strings.Split(rpcStr, ",")
+	ret := make([]string, 0, len(rpcStr))
 	for _, r := range rpcs {
 		switch r {
 		case unaryCall, emptyCall:
@@ -329,7 +330,7 @@ func parseRPCTypes(rpcStr string) (ret []string) {
 			log.Fatalf("unsupported RPC type: %v", r)
 		}
 	}
-	return
+	return ret
 }
 
 type rpcConfig struct {
diff --git a/xds/csds/csds.go b/xds/csds/csds.go
index 1b54a3a4..c4477a55 100644
--- a/xds/csds/csds.go
+++ b/xds/csds/csds.go
@@ -164,7 +164,7 @@ func nodeProtoToV3(n proto.Message) *v3corepb.Node {
 
 func (s *ClientStatusDiscoveryServer) buildLDSPerXDSConfig() *v3statuspb.PerXdsConfig {
 	version, dump := s.xdsClient.DumpLDS()
-	var resources []*v3adminpb.ListenersConfigDump_DynamicListener
+	resources := make([]*v3adminpb.ListenersConfigDump_DynamicListener, 0, len(dump))
 	for name, d := range dump {
 		configDump := &v3adminpb.ListenersConfigDump_DynamicListener{
 			Name:         name,
@@ -198,7 +198,7 @@ func (s *ClientStatusDiscoveryServer) buildLDSPerXDSConfig() *v3statuspb.PerXdsC
 
 func (s *ClientStatusDiscoveryServer) buildRDSPerXDSConfig() *v3statuspb.PerXdsConfig {
 	_, dump := s.xdsClient.DumpRDS()
-	var resources []*v3adminpb.RoutesConfigDump_DynamicRouteConfig
+	resources := make([]*v3adminpb.RoutesConfigDump_DynamicRouteConfig, 0, len(dump))
 	for _, d := range dump {
 		configDump := &v3adminpb.RoutesConfigDump_DynamicRouteConfig{
 			VersionInfo:  d.MD.Version,
@@ -228,7 +228,7 @@ func (s *ClientStatusDiscoveryServer) buildRDSPerXDSConfig() *v3statuspb.PerXdsC
 
 func (s *ClientStatusDiscoveryServer) buildCDSPerXDSConfig() *v3statuspb.PerXdsConfig {
 	version, dump := s.xdsClient.DumpCDS()
-	var resources []*v3adminpb.ClustersConfigDump_DynamicCluster
+	resources := make([]*v3adminpb.ClustersConfigDump_DynamicCluster, 0, len(dump))
 	for _, d := range dump {
 		configDump := &v3adminpb.ClustersConfigDump_DynamicCluster{
 			VersionInfo:  d.MD.Version,
@@ -259,7 +259,7 @@ func (s *ClientStatusDiscoveryServer) buildCDSPerXDSConfig() *v3statuspb.PerXdsC
 
 func (s *ClientStatusDiscoveryServer) buildEDSPerXDSConfig() *v3statuspb.PerXdsConfig {
 	_, dump := s.xdsClient.DumpEDS()
-	var resources []*v3adminpb.EndpointsConfigDump_DynamicEndpointConfig
+	resources := make([]*v3adminpb.EndpointsConfigDump_DynamicEndpointConfig, 0, len(dump))
 	for _, d := range dump {
 		configDump := &v3adminpb.EndpointsConfigDump_DynamicEndpointConfig{
 			VersionInfo:  d.MD.Version,
diff --git a/xds/internal/balancer/clusterresolver/configbuilder.go b/xds/internal/balancer/clusterresolver/configbuilder.go
index e1242f3b..475497d4 100644
--- a/xds/internal/balancer/clusterresolver/configbuilder.go
+++ b/xds/internal/balancer/clusterresolver/configbuilder.go
@@ -152,7 +152,7 @@ func buildPriorityConfig(priorities []priorityConfig, xdsLBPolicy *internalservi
 func buildClusterImplConfigForDNS(parentPriority int, addrStrs []string) (string, *clusterimpl.LBConfig, []resolver.Address) {
 	// Endpoint picking policy for DNS is hardcoded to pick_first.
 	const childPolicy = "pick_first"
-	var retAddrs []resolver.Address
+	retAddrs := make([]resolver.Address, 0, len(addrStrs))
 	pName := fmt.Sprintf("priority-%v", parentPriority)
 	for _, addrStr := range addrStrs {
 		retAddrs = append(retAddrs, hierarchy.Set(resolver.Address{Addr: addrStr}, []string{pName}))
@@ -170,12 +170,6 @@ func buildClusterImplConfigForDNS(parentPriority int, addrStrs []string) (string
 // - [p0_address_0, p0_address_1, p1_address_0, p1_address_1]
 //   - p0 addresses' hierarchy attributes are set to p0
 func buildClusterImplConfigForEDS(parentPriority int, edsResp xdsclient.EndpointsUpdate, mechanism DiscoveryMechanism, xdsLBPolicy *internalserviceconfig.BalancerConfig) ([]string, map[string]*clusterimpl.LBConfig, []resolver.Address, error) {
-	var (
-		retNames   []string
-		retAddrs   []resolver.Address
-		retConfigs = make(map[string]*clusterimpl.LBConfig)
-	)
-
 	drops := make([]clusterimpl.DropConfig, 0, len(edsResp.Drops))
 	for _, d := range edsResp.Drops {
 		drops = append(drops, clusterimpl.DropConfig{
@@ -185,6 +179,9 @@ func buildClusterImplConfigForEDS(parentPriority int, edsResp xdsclient.Endpoint
 	}
 
 	priorityChildNames, priorities := groupLocalitiesByPriority(edsResp.Localities)
+	retNames := make([]string, 0, len(priorityChildNames))
+	retAddrs := make([]resolver.Address, 0, len(priorityChildNames))
+	retConfigs := make(map[string]*clusterimpl.LBConfig, len(priorityChildNames))
 	for _, priorityName := range priorityChildNames {
 		priorityLocalities := priorities[priorityName]
 		// Prepend parent priority to the priority names, to avoid duplicates.
diff --git a/xds/internal/resolver/matcher.go b/xds/internal/resolver/matcher.go
index 6e09d93a..4a0a0ca1 100644
--- a/xds/internal/resolver/matcher.go
+++ b/xds/internal/resolver/matcher.go
@@ -43,7 +43,7 @@ func routeToMatcher(r *xdsclient.Route) (*compositeMatcher, error) {
 		return nil, fmt.Errorf("illegal route: missing path_matcher")
 	}
 
-	var headerMatchers []matcher.HeaderMatcher
+	headerMatchers := make([]matcher.HeaderMatcher, 0, len(r.Headers))
 	for _, h := range r.Headers {
 		var matcherT matcher.HeaderMatcher
 		switch {
diff --git a/xds/internal/testutils/protos.go b/xds/internal/testutils/protos.go
index e0dba0e2..fc3cdf30 100644
--- a/xds/internal/testutils/protos.go
+++ b/xds/internal/testutils/protos.go
@@ -59,7 +59,7 @@ type ClusterLoadAssignmentBuilder struct {
 
 // NewClusterLoadAssignmentBuilder creates a ClusterLoadAssignmentBuilder.
 func NewClusterLoadAssignmentBuilder(clusterName string, dropPercents map[string]uint32) *ClusterLoadAssignmentBuilder {
-	var drops []*v2xdspb.ClusterLoadAssignment_Policy_DropOverload
+	drops := make([]*v2xdspb.ClusterLoadAssignment_Policy_DropOverload, 0, len(dropPercents))
 	for n, d := range dropPercents {
 		drops = append(drops, &v2xdspb.ClusterLoadAssignment_Policy_DropOverload{
 			Category: n,
@@ -88,7 +88,7 @@ type AddLocalityOptions struct {
 
 // AddLocality adds a locality to the builder.
 func (clab *ClusterLoadAssignmentBuilder) AddLocality(subzone string, weight uint32, priority uint32, addrsWithPort []string, opts *AddLocalityOptions) {
-	var lbEndPoints []*v2endpointpb.LbEndpoint
+	lbEndPoints := make([]*v2endpointpb.LbEndpoint, 0, len(addrsWithPort))
 	for i, a := range addrsWithPort {
 		host, portStr, err := net.SplitHostPort(a)
 		if err != nil {
diff --git a/xds/internal/xdsclient/filter_chain.go b/xds/internal/xdsclient/filter_chain.go
index 49ebe887..c8230d69 100644
--- a/xds/internal/xdsclient/filter_chain.go
+++ b/xds/internal/xdsclient/filter_chain.go
@@ -242,8 +242,9 @@ func (fci *FilterChainManager) addFilterChains(fcs []*v3listenerpb.FilterChain)
 }
 
 func (fci *FilterChainManager) addFilterChainsForDestPrefixes(fc *v3listenerpb.FilterChain) error {
-	var dstPrefixes []*net.IPNet
-	for _, pr := range fc.GetFilterChainMatch().GetPrefixRanges() {
+	ranges := fc.GetFilterChainMatch().GetPrefixRanges()
+	dstPrefixes := make([]*net.IPNet, 0, len(ranges))
+	for _, pr := range ranges {
 		cidr := fmt.Sprintf("%s/%d", pr.GetAddressPrefix(), pr.GetPrefixLen().GetValue())
 		_, ipnet, err := net.ParseCIDR(cidr)
 		if err != nil {
@@ -342,7 +343,8 @@ func (fci *FilterChainManager) addFilterChainsForSourceType(dstEntry *destPrefix
 // structures and delegates control to addFilterChainsForSourcePorts to continue
 // building the internal data structure.
 func (fci *FilterChainManager) addFilterChainsForSourcePrefixes(srcPrefixMap map[string]*sourcePrefixEntry, fc *v3listenerpb.FilterChain) error {
-	var srcPrefixes []*net.IPNet
+	ranges := fc.GetFilterChainMatch().GetSourcePrefixRanges()
+	srcPrefixes := make([]*net.IPNet, 0, len(ranges))
 	for _, pr := range fc.GetFilterChainMatch().GetSourcePrefixRanges() {
 		cidr := fmt.Sprintf("%s/%d", pr.GetAddressPrefix(), pr.GetPrefixLen().GetValue())
 		_, ipnet, err := net.ParseCIDR(cidr)
@@ -382,8 +384,9 @@ func (fci *FilterChainManager) addFilterChainsForSourcePrefixes(srcPrefixMap map
 // It is here that we determine if there are multiple filter chains with
 // overlapping matching rules.
 func (fci *FilterChainManager) addFilterChainsForSourcePorts(srcEntry *sourcePrefixEntry, fcProto *v3listenerpb.FilterChain) error {
-	var srcPorts []int
-	for _, port := range fcProto.GetFilterChainMatch().GetSourcePorts() {
+	ports := fcProto.GetFilterChainMatch().GetSourcePorts()
+	srcPorts := make([]int, 0, len(ports))
+	for _, port := range ports {
 		srcPorts = append(srcPorts, int(port))
 	}
 
diff --git a/xds/internal/xdsclient/transport_helper.go b/xds/internal/xdsclient/transport_helper.go
index 1e3caa60..4c56daaf 100644
--- a/xds/internal/xdsclient/transport_helper.go
+++ b/xds/internal/xdsclient/transport_helper.go
@@ -342,11 +342,12 @@ func (t *TransportHelper) recv(stream grpc.ClientStream) bool {
 	}
 }
 
-func mapToSlice(m map[string]bool) (ret []string) {
+func mapToSlice(m map[string]bool) []string {
+	ret := make([]string, 0, len(m))
 	for i := range m {
 		ret = append(ret, i)
 	}
-	return
+	return ret
 }
 
 type watchAction struct {
diff --git a/xds/internal/xdsclient/v2/loadreport.go b/xds/internal/xdsclient/v2/loadreport.go
index 77db5eb9..f0034e21 100644
--- a/xds/internal/xdsclient/v2/loadreport.go
+++ b/xds/internal/xdsclient/v2/loadreport.go
@@ -99,24 +99,22 @@ func (v2c *client) SendLoadStatsRequest(s grpc.ClientStream, loads []*load.Data)
 		return fmt.Errorf("lrs: Attempt to send request on unsupported stream type: %T", s)
 	}
 
-	var clusterStats []*v2endpointpb.ClusterStats
+	clusterStats := make([]*v2endpointpb.ClusterStats, 0, len(loads))
 	for _, sd := range loads {
-		var (
-			droppedReqs   []*v2endpointpb.ClusterStats_DroppedRequests
-			localityStats []*v2endpointpb.UpstreamLocalityStats
-		)
+		droppedReqs := make([]*v2endpointpb.ClusterStats_DroppedRequests, 0, len(sd.Drops))
 		for category, count := range sd.Drops {
 			droppedReqs = append(droppedReqs, &v2endpointpb.ClusterStats_DroppedRequests{
 				Category:     category,
 				DroppedCount: count,
 			})
 		}
+		localityStats := make([]*v2endpointpb.UpstreamLocalityStats, 0, len(sd.LocalityStats))
 		for l, localityData := range sd.LocalityStats {
 			lid, err := internal.LocalityIDFromString(l)
 			if err != nil {
 				return err
 			}
-			var loadMetricStats []*v2endpointpb.EndpointLoadMetricStats
+			loadMetricStats := make([]*v2endpointpb.EndpointLoadMetricStats, 0, len(localityData.LoadStats))
 			for name, loadData := range localityData.LoadStats {
 				loadMetricStats = append(loadMetricStats, &v2endpointpb.EndpointLoadMetricStats{
 					MetricName:                    name,
diff --git a/xds/internal/xdsclient/v3/loadreport.go b/xds/internal/xdsclient/v3/loadreport.go
index 147751ba..8cdb5476 100644
--- a/xds/internal/xdsclient/v3/loadreport.go
+++ b/xds/internal/xdsclient/v3/loadreport.go
@@ -99,24 +99,22 @@ func (v3c *client) SendLoadStatsRequest(s grpc.ClientStream, loads []*load.Data)
 		return fmt.Errorf("lrs: Attempt to send request on unsupported stream type: %T", s)
 	}
 
-	var clusterStats []*v3endpointpb.ClusterStats
+	clusterStats := make([]*v3endpointpb.ClusterStats, 0, len(loads))
 	for _, sd := range loads {
-		var (
-			droppedReqs   []*v3endpointpb.ClusterStats_DroppedRequests
-			localityStats []*v3endpointpb.UpstreamLocalityStats
-		)
+		droppedReqs := make([]*v3endpointpb.ClusterStats_DroppedRequests, 0, len(sd.Drops))
 		for category, count := range sd.Drops {
 			droppedReqs = append(droppedReqs, &v3endpointpb.ClusterStats_DroppedRequests{
 				Category:     category,
 				DroppedCount: count,
 			})
 		}
+		localityStats := make([]*v3endpointpb.UpstreamLocalityStats, 0, len(sd.LocalityStats))
 		for l, localityData := range sd.LocalityStats {
 			lid, err := internal.LocalityIDFromString(l)
 			if err != nil {
 				return err
 			}
-			var loadMetricStats []*v3endpointpb.EndpointLoadMetricStats
+			loadMetricStats := make([]*v3endpointpb.EndpointLoadMetricStats, 0, len(localityData.LoadStats))
 			for name, loadData := range localityData.LoadStats {
 				loadMetricStats = append(loadMetricStats, &v3endpointpb.EndpointLoadMetricStats{
 					MetricName:                    name,
diff --git a/xds/internal/xdsclient/xds.go b/xds/internal/xdsclient/xds.go
index c3b090fe..656ad854 100644
--- a/xds/internal/xdsclient/xds.go
+++ b/xds/internal/xdsclient/xds.go
@@ -324,7 +324,7 @@ func unmarshalRouteConfigResource(r *anypb.Any, logger *grpclog.PrefixLogger) (s
 // message, the cluster field will contain the clusterName or weighted clusters
 // we are looking for.
 func generateRDSUpdateFromRouteConfiguration(rc *v3routepb.RouteConfiguration, logger *grpclog.PrefixLogger, v2 bool) (RouteConfigUpdate, error) {
-	var vhs []*VirtualHost
+	vhs := make([]*VirtualHost, 0, len(rc.GetVirtualHosts()))
 	for _, vh := range rc.GetVirtualHosts() {
 		routes, err := routesProtoToSlice(vh.Routes, logger, v2)
 		if err != nil {
@@ -348,7 +348,6 @@ func generateRDSUpdateFromRouteConfiguration(rc *v3routepb.RouteConfiguration, l
 
 func routesProtoToSlice(routes []*v3routepb.Route, logger *grpclog.PrefixLogger, v2 bool) ([]*Route, error) {
 	var routesRet []*Route
-
 	for _, r := range routes {
 		match := r.GetMatch()
 		if match == nil {