pkgtools/pkglint: Update to 5.5.16

Changes since 5.5.15:

* Add checks for options.mk files

* Treat redundant variable definitions as notes, not as warnings

* Check doc/CHANGES-* for typos in the dates (only for 2018 and later)

* Lots of cleanup in the test code


(rillig)

package main

import "netbsd.org/pkglint/trace"

func ChecklinesOptionsMk(mklines *MkLines) {
	if trace.Tracing {
		defer trace.Call1(mklines.lines[0].Filename)()
	}

	mklines.Check()

	exp := NewMkExpecter(mklines)
	exp.AdvanceWhile(func(mkline MkLine) bool { return mkline.IsComment() || mkline.IsEmpty() })

	if exp.EOF() || !(exp.CurrentMkLine().IsVarassign() && exp.CurrentMkLine().Varname() == "PKG_OPTIONS_VAR") {
		exp.CurrentLine().Warnf("Expected definition of PKG_OPTIONS_VAR.")
		Explain(
			"The input variables in an options.mk file should always be",
			"mentioned in the same order: PKG_OPTIONS_VAR, ",
			"PKG_SUPPORTED_OPTIONS, PKG_SUGGESTED_OPTIONS.  This way, the",
			"options.mk files have the same structure and are easy to understand.")
		return
	}
	exp.Advance()

	declaredOptions := make(map[string]MkLine)
	handledOptions := make(map[string]MkLine)
	var optionsInDeclarationOrder []string

	// The conditionals are typically for OPSYS and MACHINE_ARCH.
loop:
	for ; !exp.EOF(); exp.Advance() {
		mkline := exp.CurrentMkLine()
		switch {
		case mkline.IsComment():
		case mkline.IsEmpty():
		case mkline.IsVarassign():
			varname := mkline.Varname()
			if varname == "PKG_SUPPORTED_OPTIONS" || hasPrefix(varname, "PKG_OPTIONS_GROUP.") {
				for _, option := range splitOnSpace(mkline.Value()) {
					if option == mkline.WithoutMakeVariables(option) {
						declaredOptions[option] = mkline
						optionsInDeclarationOrder = append(optionsInDeclarationOrder, option)
					}
				}
			}
		case mkline.IsCond():
		case mkline.IsInclude():
			includedFile := mkline.IncludeFile()
			switch {
			case matches(includedFile, `/[^/]+\.buildlink3\.mk$`):
			case matches(includedFile, `/[^/]+\.builtin\.mk$`):
			case includedFile == "../../mk/bsd.prefs.mk":
			case includedFile == "../../mk/bsd.fast.prefs.mk":

			case includedFile == "../../mk/bsd.options.mk":
				exp.Advance()
				break loop
			}
		default:
			exp.CurrentLine().Warnf("Expected inclusion of \"../../mk/bsd.options.mk\".")
			Explain(
				"After defining the input variables (PKG_OPTIONS_VAR, etc.),",
				"bsd.options.mk should be included to do the actual processing.",
				"No other actions should take place in this part of the file",
				"in order to have the same structure in all options.mk files.")
			return
		}
	}

	for ; !exp.EOF(); exp.Advance() {
		mkline := exp.CurrentMkLine()
		if mkline.IsCond() && mkline.Directive() == "if" {
			cond := NewMkParser(mkline.Line, mkline.Args(), false).MkCond()
			if cond != nil {
				cond.Visit("empty", func(t *Tree) {
					varuse := t.args[0].(MkVarUse)
					if varuse.varname == "PKG_OPTIONS" && len(varuse.modifiers) == 1 && hasPrefix(varuse.modifiers[0], "M") {
						option := varuse.modifiers[0][1:]
						handledOptions[option] = mkline
						optionsInDeclarationOrder = append(optionsInDeclarationOrder, option)
					}
				})
			}
		}
	}

	for _, option := range optionsInDeclarationOrder {
		declared := declaredOptions[option]
		handled := handledOptions[option]
		if declared != nil && handled == nil {
			declared.Warnf("Option %q should be handled below in an .if block.", option)
			Explain(
				"If an option is not processed in this file, it may either be a",
				"typo, or the option does not have any effect.")
		}
		if declared == nil && handled != nil {
			handled.Warnf("Option %q is handled but not declared above.", option)
			Explain(
				"This block of code will never be run since PKG_OPTIONS cannot",
				"contain this value.  This is most probably a typo.")
		}
	}

	SaveAutofixChanges(mklines.lines)
}

package main

import "gopkg.in/check.v1"

func (s *Suite) Test_ChecklinesOptionsMk(c *check.C) {
	t := s.Init(c)

	t.SetupCommandLine("-Wno-space")
	t.SetupVartypes()
	t.SetupOption("mc-charset", "")
	t.SetupOption("ncurses", "")
	t.SetupOption("slang", "")
	t.SetupOption("x11", "")

	t.SetupFileMkLines("mk/bsd.options.mk",
		MkRcsID)

	mklines := t.SetupFileMkLines("category/package/options.mk",
		MkRcsID,
		"",
		"PKG_OPTIONS_VAR=                PKG_OPTIONS.mc",
		"PKG_OPTIONS_REQUIRED_GROUPS=    screen",
		"PKG_OPTIONS_GROUP.screen=       ncurses slang",
		"PKG_SUPPORTED_OPTIONS=          mc-charset x11 lang-${l}",
		"PKG_SUGGESTED_OPTIONS=          mc-charset slang",
		"",
		".include \"../../mk/bsd.options.mk\"",
		"",
		".if !empty(PKG_OPTIONS:Mx11)",
		".endif",
		"",
		".if !empty(PKG_OPTIONS:Mundeclared)",
		".endif")

	G.CurrentDir = t.TmpDir()
	G.CurPkgsrcdir = "."

	ChecklinesOptionsMk(mklines)

	t.CheckOutputLines(
		"WARN: ~/category/package/options.mk:14: Unknown option \"undeclared\".",
		"WARN: ~/category/package/options.mk:5: Option \"ncurses\" should be handled below in an .if block.",
		"WARN: ~/category/package/options.mk:5: Option \"slang\" should be handled below in an .if block.",
		"WARN: ~/category/package/options.mk:6: Option \"mc-charset\" should be handled below in an .if block.",
		"WARN: ~/category/package/options.mk:14: Option \"undeclared\" is handled but not declared above.")
}

func (s *Suite) Test_ChecklinesOptionsMk__unexpected_line(c *check.C) {
	t := s.Init(c)

	t.SetupCommandLine("-Wno-space")
	t.SetupVartypes()
	t.SetupOption("mc-charset", "")
	t.SetupOption("ncurses", "")
	t.SetupOption("slang", "")
	t.SetupOption("x11", "")

	t.SetupFileMkLines("mk/bsd.options.mk",
		MkRcsID)

	mklines := t.SetupFileMkLines("category/package/options.mk",
		MkRcsID,
		"",
		"PKG_OPTIONS_VAR=                PKG_OPTIONS.mc",
		"PKG_SUPPORTED_OPTIONS=          mc-charset x11 lang-${l}",
		"PKG_SUGGESTED_OPTIONS=          mc-charset",
		"",
		"pre-configure:",
		"\techo \"In the pre-configure stage.\"")

	G.CurrentDir = t.TmpDir()
	G.CurPkgsrcdir = "."

	ChecklinesOptionsMk(mklines)

	t.CheckOutputLines(
		"WARN: ~/category/package/options.mk:7: Expected inclusion of \"../../mk/bsd.options.mk\".")
}