x/mod: add the ignore directive

This CL adds the ignore directive that will be used to support the
global ignore mechanism in http://go.dev/cl/643355

For golang/go#42965

Change-Id: I6d0b25de1b4d26185298f6e3aea5ba66651256cb
Reviewed-on: https://go-review.googlesource.com/c/mod/+/670656
Reviewed-by: Michael Matloob <[email protected]>
LUCI-TryBot-Result: Go LUCI <[email protected]>
Reviewed-by: Michael Matloob <[email protected]>

Author: samthanawalla

modfile/rule.go

@@ -45,6 +45,7 @@ type File struct {
 	Replace   []*Replace
 	Retract   []*Retract
 	Tool      []*Tool
+	Ignore    []*Ignore
 
 	Syntax *FileSyntax
 }
@@ -101,6 +102,12 @@ type Tool struct {
 	Syntax *Line
 }
 
+// An Ignore is a single ignore statement.
+type Ignore struct {
+	Path   string
+	Syntax *Line
+}
+
 // A VersionInterval represents a range of versions with upper and lower bounds.
 // Intervals are closed: both bounds are included. When Low is equal to High,
 // the interval may refer to a single version ('v1.2.3') or an interval
@@ -305,7 +312,7 @@ func parseToFile(file string, data []byte, fix VersionFixer, strict bool) (parse
 					})
 				}
 				continue
-			case "module", "godebug", "require", "exclude", "replace", "retract", "tool":
+			case "module", "godebug", "require", "exclude", "replace", "retract", "tool", "ignore":
 				for _, l := range x.Line {
 					f.add(&errs, x, l, x.Token[0], l.Token, fix, strict)
 				}
@@ -338,7 +345,7 @@ func (f *File) add(errs *ErrorList, block *LineBlock, line *Line, verb string, a
 	// and simply ignore those statements.
 	if !strict {
 		switch verb {
-		case "go", "module", "retract", "require":
+		case "go", "module", "retract", "require", "ignore":
 			// want these even for dependency go.mods
 		default:
 			return
@@ -532,6 +539,21 @@ func (f *File) add(errs *ErrorList, block *LineBlock, line *Line, verb string, a
 			Path:   s,
 			Syntax: line,
 		})
+
+	case "ignore":
+		if len(args) != 1 {
+			errorf("ignore directive expects exactly one argument")
+			return
+		}
+		s, err := parseString(&args[0])
+		if err != nil {
+			errorf("invalid quoted string: %v", err)
+			return
+		}
+		f.Ignore = append(f.Ignore, &Ignore{
+			Path:   s,
+			Syntax: line,
+		})
 	}
 }
 
@@ -1620,6 +1642,36 @@ func (f *File) DropTool(path string) error {
 	return nil
 }
 
+// AddIgnore adds a new ignore directive with the given path.
+// It does nothing if the ignore line already exists.
+func (f *File) AddIgnore(path string) error {
+	for _, t := range f.Ignore {
+		if t.Path == path {
+			return nil
+		}
+	}
+
+	f.Ignore = append(f.Ignore, &Ignore{
+		Path:   path,
+		Syntax: f.Syntax.addLine(nil, "ignore", path),
+	})
+
+	f.SortBlocks()
+	return nil
+}
+
+// DropIgnore removes a ignore directive with the given path.
+// It does nothing if no such ignore directive exists.
+func (f *File) DropIgnore(path string) error {
+	for _, t := range f.Ignore {
+		if t.Path == path {
+			t.Syntax.markRemoved()
+			*t = Ignore{}
+		}
+	}
+	return nil
+}
+
 func (f *File) SortBlocks() {
 	f.removeDups() // otherwise sorting is unsafe
 
@@ -1656,10 +1708,10 @@ func (f *File) SortBlocks() {
 // retract directives are not de-duplicated since comments are
 // meaningful, and versions may be retracted multiple times.
 func (f *File) removeDups() {
-	removeDups(f.Syntax, &f.Exclude, &f.Replace, &f.Tool)
+	removeDups(f.Syntax, &f.Exclude, &f.Replace, &f.Tool, &f.Ignore)
 }
 
-func removeDups(syntax *FileSyntax, exclude *[]*Exclude, replace *[]*Replace, tool *[]*Tool) {
+func removeDups(syntax *FileSyntax, exclude *[]*Exclude, replace *[]*Replace, tool *[]*Tool, ignore *[]*Ignore) {
 	kill := make(map[*Line]bool)
 
 	// Remove duplicate excludes.
@@ -1718,6 +1770,24 @@ func removeDups(syntax *FileSyntax, exclude *[]*Exclude, replace *[]*Replace, to
 		*tool = newTool
 	}
 
+	if ignore != nil {
+		haveIgnore := make(map[string]bool)
+		for _, i := range *ignore {
+			if haveIgnore[i.Path] {
+				kill[i.Syntax] = true
+				continue
+			}
+			haveIgnore[i.Path] = true
+		}
+		var newIgnore []*Ignore
+		for _, i := range *ignore {
+			if !kill[i.Syntax] {
+				newIgnore = append(newIgnore, i)
+			}
+		}
+		*ignore = newIgnore
+	}
+
 	// Duplicate require and retract directives are not removed.
 
 	// Drop killed statements from the syntax tree.

modfile/rule_test.go

@@ -1780,6 +1780,72 @@ var dropToolTests = []struct {
 	},
 }
 
+var addIgnoreTests = []struct {
+	desc, in, path, want string
+}{
+	{
+		`add_first`,
+		`module example.com/m`,
+		`foo/bar`,
+		`module example.com/m
+		ignore foo/bar`,
+	},
+	{
+		`sorted_correctly`,
+		`module example.com/m
+		ignore foo/bar
+		`,
+		`./foo/bar/path`,
+		`module example.com/m
+		ignore (
+			./foo/bar/path
+			foo/bar
+		)`,
+	},
+	{
+		`duplicates_ignored`,
+		`module example.com/m
+		ignore foo/bar
+		`,
+		`foo/bar`,
+		`module example.com/m
+		ignore foo/bar`,
+	},
+}
+
+var dropIgnoreTests = []struct {
+	desc, in, path, want string
+}{
+	{
+		`only`,
+		`module example.com/m
+		ignore foo/bar`,
+		`foo/bar`,
+		`module example.com/m`,
+	},
+	{
+		`parenthesized`,
+		`module example.com/m
+		ignore (
+			./foo/bar
+			foo/bar
+		)`,
+		`foo/bar`,
+		`module example.com/m
+		ignore ./foo/bar`,
+	},
+	{
+		`missing`,
+		`module example.com/m
+		ignore (
+		foo/bar
+		)`,
+		`./foo/bar`,
+		`module example.com/m
+		ignore foo/bar`,
+	},
+}
+
 func fixV(path, version string) (string, error) {
 	if path != "example.com/m" {
 		return "", fmt.Errorf("module path must be example.com/m")
@@ -2190,3 +2256,65 @@ func TestDropTool(t *testing.T) {
 		})
 	}
 }
+
+func TestAddIgnore(t *testing.T) {
+	for _, tt := range addIgnoreTests {
+		t.Run(tt.desc, func(t *testing.T) {
+			inFile, err := Parse("in", []byte(tt.in), nil)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if err := inFile.AddIgnore(tt.path); err != nil {
+				t.Fatal(err)
+			}
+			inFile.Cleanup()
+			got, err := inFile.Format()
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			outFile, err := Parse("out", []byte(tt.want), nil)
+			if err != nil {
+				t.Fatal(err)
+			}
+			want, err := outFile.Format()
+			if err != nil {
+				t.Fatal(err)
+			}
+			if !bytes.Equal(got, want) {
+				t.Fatalf("got:\n%s\nwant:\n%s", got, want)
+			}
+		})
+	}
+}
+
+func TestDropIgnore(t *testing.T) {
+	for _, tt := range dropIgnoreTests {
+		t.Run(tt.desc, func(t *testing.T) {
+			inFile, err := Parse("in", []byte(tt.in), nil)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if err := inFile.DropIgnore(tt.path); err != nil {
+				t.Fatal(err)
+			}
+			inFile.Cleanup()
+			got, err := inFile.Format()
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			outFile, err := Parse("out", []byte(tt.want), nil)
+			if err != nil {
+				t.Fatal(err)
+			}
+			want, err := outFile.Format()
+			if err != nil {
+				t.Fatal(err)
+			}
+			if !bytes.Equal(got, want) {
+				t.Fatalf("got:\n%s\nwant:\n%s", got, want)
+			}
+		})
+	}
+}

modfile/work.go

@@ -329,5 +329,5 @@ func (f *WorkFile) SortBlocks() {
 // retract directives are not de-duplicated since comments are
 // meaningful, and versions may be retracted multiple times.
 func (f *WorkFile) removeDups() {
-	removeDups(f.Syntax, nil, &f.Replace, nil)
+	removeDups(f.Syntax, nil, &f.Replace, nil, nil)
 }