Run git for-each-ref when explicit roots and no filters are specified

When explicit roots and reference filters specified, we want to make
sure that the optimisation don't kick in. As it we still want to iterate
over all references in order to apply the filters.

git-sizer.go

@@ -307,26 +307,33 @@ func mainImplementation(ctx context.Context, stdout, stderr io.Writer, args []st
 	}
 
 	var roots []sizes.Root
+	var explicitRoots []sizes.Root
 	// If arguments are provided, use them as explicit roots.
 	if len(flags.Args()) > 0 {
-		roots = make([]sizes.Root, 0, len(flags.Args()))
+		explicitRoots = make([]sizes.Root, 0, len(flags.Args()))
 		for _, arg := range flags.Args() {
 			oid, err := repo.ResolveObject(arg)
 			if err != nil {
 				return fmt.Errorf("resolving command-line argument %q: %w", arg, err)
 			}
-			roots = append(roots, sizes.NewExplicitRoot(arg, oid))
+			explicitRoots = append(explicitRoots, sizes.NewExplicitRoot(arg, oid))
 		}
+	}
+
+	// If no reference filters and no explicit roots were provided
+	if git.IsNoReferencesFilter(rgb.GetTopLevelGroup().GetFilter()) {
+		roots = explicitRoots
 	} else {
-		refs, err := sizes.CollectReferences(ctx, repo, rg)
+		refRoots, err := sizes.CollectReferences(ctx, repo, rg)
 		if err != nil {
 			return fmt.Errorf("determining which reference to scan: %w", err)
 		}
 
-		roots = make([]sizes.Root, 0, len(refs))
-		for _, ref := range refs {
-			roots = append(roots, ref)
+		roots = make([]sizes.Root, 0, len(refRoots)+len(explicitRoots))
+		for _, refRoot := range refRoots {
+			roots = append(roots, refRoot)
 		}
+		roots = append(roots, explicitRoots...)
 	}
 
 	historySize, err := sizes.ScanRepositoryUsingGraph(

git/ref_filter.go

@@ -140,3 +140,8 @@ type regexpFilter struct {
 func (f regexpFilter) Filter(refname string) bool {
 	return f.re.MatchString(refname)
 }
+
+func IsNoReferencesFilter(val interface{}) bool {
+	_, ok := val.(noReferencesFilter)
+	return ok
+}

internal/refopts/ref_group.go

@@ -30,6 +30,10 @@ type refGroup struct {
 	otherRefGroup *sizes.RefGroup
 }
 
+func (rg *refGroup) GetFilter() git.ReferenceFilter {
+	return rg.filter
+}
+
 func (rg *refGroup) collectSymbols(refname string) (bool, []sizes.RefGroupSymbol) {
 	walk := false
 	var symbols []sizes.RefGroupSymbol

internal/refopts/ref_group_builder.go

@@ -22,6 +22,10 @@ type RefGroupBuilder struct {
 	groups        map[sizes.RefGroupSymbol]*refGroup
 }
 
+func (rgb *RefGroupBuilder) GetTopLevelGroup() *refGroup {
+	return rgb.topLevelGroup
+}
+
 // NewRefGroupBuilder creates and returns a `RefGroupBuilder`
 // instance.
 func NewRefGroupBuilder(configger Configger) (*RefGroupBuilder, error) {