Thu Mar 2 08:58:29 2023 UTC ()

pkgtools/pkglint: Update to 22.4.1

Changes since 22.4.0:

Allow pkglint to be run outside the pkgsrc top directory, in order to
allow individual makefiles to be formatted and checked as well. The many
pkgsrc-specific checks don't apply in this case. This mode is
experimental, there are still crashes to be expected.

Fix a crash for syntactically invalid conditions in '.if'.

Fix parsing of dependency lines that contain an escaped '#', which is
used for switching to another shell using a '.SHELL: ...' line.


(rillig)

--- pkgsrc/pkgtools/pkglint/Makefile 2023/02/16 15:02:04 1.739
+++ pkgsrc/pkgtools/pkglint/Makefile 2023/03/02 08:58:28 1.740

 @@ -1,17 +1,16 @@
-# $NetBSD: Makefile,v 1.739 2023/02/16 15:02:04 bsiegert Exp $
+# $NetBSD: Makefile,v 1.740 2023/03/02 08:58:28 rillig Exp $
-PKGNAME=	pkglint-22.4.0
+PKGNAME=	pkglint-22.4.1
 PKGREVISION=	1
 CATEGORIES=	pkgtools
 MAINTAINER=	rillig@NetBSD.org
 HOMEPAGE=	https://github.com/rillig/pkglint
 COMMENT=	Verifier for NetBSD packages
 LICENSE=	2-clause-bsd
 CONFLICTS+=	pkglint4-[0-9]*
 USE_TOOLS+=		pax
 CHECK_RELRO_SKIP+=	bin/pkglint
 SUBST_CLASSES+=		pkglint

--- pkgsrc/pkgtools/pkglint/files/Attic/check_test.go 2023/01/29 13:36:31 1.81
+++ pkgsrc/pkgtools/pkglint/files/Attic/check_test.go 2023/03/02 08:58:29 1.82

 @@ -147,30 +147,33 @@ func Test__qa(t *testing.T) {
 	// They are tested indirectly by the tests of their corresponding checks.
 	ck.Configure("*", "*", "warn[A-Z]*", -intqa.EMissingTest)
 	// Generated code doesn't need a unit test.
 	// If any, every grammar production in the corresponding yacc file
 	// should have a unit test.
 	ck.Configure("*yacc.go", "*", "*", intqa.ENone)
 	// Type definitions don't need a unit test.
 	// Only functions and methods do.
 	ck.Configure("*", "*", "", -intqa.EMissingTest)
 	// The Suite type is used for testing all parts of pkglint.
-	// Therefore its test methods may be everywhere.
+	// Therefore, its test methods may be everywhere.
 	ck.Configure("*.go", "Suite", "*", -intqa.EMethodsSameFile)
 	ck.Configure("*.go", "Tester", "*", -intqa.EMethodsSameFile)
 	// When running gobco, it inserts the function 'GobcoCover'.
 	ck.Configure("*", "", "GobcoCover", -intqa.EMissingTest)
 	ck.Check()
+}
 var _ = check.Suite(new(Suite))
 func Test(t *testing.T) { check.TestingT(t) }
 // Tester provides utility methods for testing pkglint.
 // It is separated from the Suite since the latter contains
 // all the test methods, which makes it difficult to find
 // a method by auto-completion.
 type Tester struct {
 	c        *check.C // Only usable during the test method itself
 @@ -218,27 +221,27 @@ func (t *Tester) SetUpCommandLine(args .
 	G.Logger.verbose = true
 	t.seenSetUpCommandLine = true
+}
 // SetUpVartypes registers a few hundred variables like MASTER_SITES,
 // WRKSRC, SUBST_SED.*, so that their data types are known to pkglint.
 //
 // Without calling this, there will be many warnings about undefined
 // or unused variables, or unknown shell commands.
 //
 // See SetUpTool for registering tools like echo, awk, perl.
 func (t *Tester) SetUpVartypes() {
-	G.Pkgsrc.vartypes.Init(&G.Pkgsrc)
+	G.Pkgsrc.vartypes.Init(G.Pkgsrc)
+}
 func (t *Tester) SetUpMasterSite(varname string, urls ...string) {
 	if !G.Pkgsrc.vartypes.IsDefinedExact(varname) {
 		t.SetUpVarType(varname, BtFetchURL,
 			List|SystemProvided,
 			"buildlink3.mk: none",
 			"*: use")
+	}
 	for _, url := range urls {
 		G.Pkgsrc.registerMasterSite(varname, url)
+	}
 @@ -1088,32 +1091,34 @@ func (t *Tester) NewLinesAt(filename Cur
 // not exist." because an intermediate directory in the path does not exist.
 //
 // If the filename is irrelevant for the particular test, just use filename.mk.
 func (t *Tester) NewMkLines(filename CurrPath, lines ...string) *MkLines {
 	return t.NewMkLinesPkg(filename, nil, lines...)
+}
 func (t *Tester) NewMkLinesPkg(filename CurrPath, pkg *Package, lines ...string) *MkLines {
 	basename := filename.Base()
 	assertf(
 		basename.HasSuffixText(".mk") || basename == "Makefile" || basename.HasPrefixText("Makefile."),
 		"filename %q must be realistic, otherwise the variable permissions are wrong", filename)
-	var rawText strings.Builder
+	var sb strings.Builder
 	for _, line := range lines {
-		rawText.WriteString(line)
+		sb.WriteString(line)
-		rawText.WriteString("\n")
+		sb.WriteString("\n")
+	}
-	return NewMkLines(convertToLogicalLines(filename, rawText.String(), true), pkg, nil)
+	rawText := sb.String()
 	logicalLines := convertToLogicalLines(filename, rawText, true)
 	return NewMkLines(logicalLines, pkg, nil)
+}
 // Returns and consumes the output from both stdout and stderr.
 // In the output, the temporary directory is replaced with a tilde (~).
 func (t *Tester) Output() string {
 	stdout := t.stdout.String()
 	stderr := t.stderr.String()
 	t.stdout.Reset()
 	t.stderr.Reset()
 	if G.isUsable() {
 		G.Logger.logged = Once{}
 		if G.Logger.out != nil { // Necessary because Main resets the G variable.

--- pkgsrc/pkgtools/pkglint/files/Attic/files.go 2020/02/15 13:48:40 1.32
+++ pkgsrc/pkgtools/pkglint/files/Attic/files.go 2023/03/02 08:58:29 1.33

	@@ -49,26 +49,29 @@ func Load(filename CurrPath, options Loa		@@ -49,26 +49,29 @@ func Load(filename CurrPath, options Loa
49	}	49	}
50		50
51	if G.Profiling {	51	if G.Profiling {
52	G.loaded.Add(filename.Clean().String(), 1)	52	G.loaded.Add(filename.Clean().String(), 1)
53	}	53	}
54		54
55	result := convertToLogicalLines(filename, rawText, options&Makefile != 0)	55	result := convertToLogicalLines(filename, rawText, options&Makefile != 0)
56	if filename.HasSuffixText(".mk") {	56	if filename.HasSuffixText(".mk") {
57	G.fileCache.Put(filename, options, result)	57	G.fileCache.Put(filename, options, result)
58	}	58	}
59	return result	59	return result
60	}	60	}
61		61
		62	// convertToLogicalLines splits the raw text into lines.
		63	// If joinBackslashes is true, lines that end with an odd number of backslashes
		64	// are joined with the following line.
62	func convertToLogicalLines(filename CurrPath, rawText string, joinBackslashLines bool) *Lines {	65	func convertToLogicalLines(filename CurrPath, rawText string, joinBackslashLines bool) *Lines {
63	var rawLines []*RawLine	66	var rawLines []*RawLine
64	for _, rawLine := range strings.SplitAfter(rawText, "\n") {	67	for _, rawLine := range strings.SplitAfter(rawText, "\n") {
65	if rawLine != "" {	68	if rawLine != "" {
66	rawLines = append(rawLines, &RawLine{rawLine})	69	rawLines = append(rawLines, &RawLine{rawLine})
67	}	70	}
68	}	71	}
69		72
70	var loglines []*Line	73	var loglines []*Line
71	if joinBackslashLines {	74	if joinBackslashLines {
72	for lineno := 0; lineno < len(rawLines); {	75	for lineno := 0; lineno < len(rawLines); {
73	line, nextLineno := nextLogicalLine(filename, rawLines, lineno)	76	line, nextLineno := nextLogicalLine(filename, rawLines, lineno)
74	loglines = append(loglines, line)	77	loglines = append(loglines, line)

--- pkgsrc/pkgtools/pkglint/files/Attic/mkassignchecker.go 2022/08/19 17:35:43 1.16
+++ pkgsrc/pkgtools/pkglint/files/Attic/mkassignchecker.go 2023/03/02 08:58:29 1.17

 @@ -19,36 +19,40 @@ func NewMkAssignChecker(mkLine *MkLine,
 func (ck *MkAssignChecker) check() {
 	ck.checkLeft()
 	ck.checkOp()
 	ck.checkRight()
+}
 // checkLeft checks everything to the left of the assignment operator.
 func (ck *MkAssignChecker) checkLeft() {
 	varname := ck.MkLine.Varname()
 	if !ck.mayBeDefined(varname) {
 		ck.MkLine.Warnf("Variable names starting with an underscore (%s) are reserved for internal pkgsrc use.", varname)
+	}
 	if G.Pkgsrc == nil {
 		goto checkVarUse
+	}
 	ck.checkLeftNotUsed()
 	ck.checkLeftOpsys()
 	ck.checkLeftDeprecated()
 	ck.checkLeftBsdPrefs()
 	if !ck.checkLeftUserSettable() {
 		ck.checkLeftPermissions()
 		ck.checkLeftAbiDepends()
+	}
 	ck.checkLeftRationale()
 checkVarUse:
 	NewMkLineChecker(ck.MkLines, ck.MkLine).checkTextVarUse(
 		varname,
 		NewVartype(BtVariableName, NoVartypeOptions, NewACLEntry("*", aclpAll)),
 		VucLoadTime)
+}
 // checkLeftNotUsed checks whether the left-hand side of a variable
 // assignment is not used. If it is unused and also doesn't have a predefined
 // data type, it may be a spelling mistake.
 func (ck *MkAssignChecker) checkLeftNotUsed() {
 	varname := ck.MkLine.Varname()
 	varcanon := varnameCanon(varname)
 @@ -689,27 +693,27 @@ func (ck *MkAssignChecker) checkVaruseSh
 			vuc := VarUseContext{vartype, time, atom.Quoting.ToVarUseContext(), wordPart}
 			NewMkVarUseChecker(varuse, ck.MkLines, mkline).Check(&vuc)
+		}
+	}
+}
 func (ck *MkAssignChecker) mayBeDefined(varname string) bool {
 	if !hasPrefix(varname, "_") {
 		return true
+	}
 	if G.Infrastructure {
 		return true
+	}
-	if G.Pkgsrc.vartypes.Canon(varname) != nil {
+	if G.Pkgsrc == nil || G.Pkgsrc.vartypes.Canon(varname) != nil {
 		return true
+	}
 	// Defining the group 'cmake' allows the variable names '_CMAKE_*',
 	// it's kind of a namespace declaration.
 	vargroups := ck.MkLines.allVars.FirstDefinition("_VARGROUPS")
 	if vargroups != nil {
 		prefix := "_" + strings.ToUpper(vargroups.Value()) + "_"
 		if hasPrefix(varname, prefix) {
 			return true
+		}
+	}

--- pkgsrc/pkgtools/pkglint/files/Attic/mkcondchecker.go 2022/11/28 23:33:28 1.15
+++ pkgsrc/pkgtools/pkglint/files/Attic/mkcondchecker.go 2023/03/02 08:58:29 1.16

 @@ -15,27 +15,27 @@ type MkCondChecker struct {
 func NewMkCondChecker(mkLine *MkLine, mkLines *MkLines) *MkCondChecker {
 	return &MkCondChecker{MkLine: mkLine, MkLines: mkLines}
+}
 func (ck *MkCondChecker) Check() {
 	mkline := ck.MkLine
 	if trace.Tracing {
 		defer trace.Call1(mkline.Args())()
+	}
 	p := NewMkParser(nil, mkline.Args()) // No emitWarnings here, see the code below.
 	cond := p.MkCond()
-	if !p.EOF() {
+	if !p.EOF() || cond == nil {
 		mkline.Warnf("Invalid condition, unrecognized part: %q.", p.Rest())
 		return
+	}
 	checkVarUse := func(varuse *MkVarUse) {
 		var vartype *Vartype // TODO: Insert a better type guess here.
 		// See Test_MkVarUseChecker_checkAssignable__shell_command_in_exists.
 		vuc := VarUseContext{vartype, VucLoadTime, VucQuotPlain, false}
 		NewMkVarUseChecker(varuse, ck.MkLines, mkline).Check(&vuc)
+	}
 	// Skip subconditions that have already been handled as part of the !(...).
 	done := make(map[interface{}]bool)
 @@ -155,27 +155,27 @@ func (ck *MkCondChecker) checkEmptyType(
 // that may be used without surrounding quotes in a comparison such as
 // ${PKGPATH} == category/package.
 // TODO: Check whether the ',' really needs to be here.
 var mkCondStringLiteralUnquoted = textproc.NewByteSet("-+,./0-9@A-Z_a-z")
 // mkCondModifierPatternLiteral contains a safe subset of the characters
 // that are interpreted literally in the :M and :N modifiers.
 // TODO: Check whether the ',' really needs to be here.
 var mkCondModifierPatternLiteral = textproc.NewByteSet("-+,./0-9<=>@A-Z_a-z")
 func (ck *MkCondChecker) checkCompare(left *MkCondTerm, op string, right *MkCondTerm) {
 	switch {
 	case right.Num != "":
-		ck.checkCompareVarNum(left, op, right.Num)
+		ck.checkCompareWithNum(left, op, right.Num)
 	case left.Var != nil && right.Var == nil:
 		ck.checkCompareVarStr(left.Var, op, right.Str)
+	}
+}
 func (ck *MkCondChecker) checkCompareVarStr(varuse *MkVarUse, op string, str string) {
 	varname := varuse.varname
 	varmods := varuse.modifiers
 	switch len(varmods) {
 	case 0:
 		mkLineChecker := NewMkLineChecker(ck.MkLines, ck.MkLine)
 		mkLineChecker.checkVartype(varname, opUseCompare, str, "")
 @@ -199,54 +199,54 @@ func (ck *MkCondChecker) checkCompareVar
 		// This case covers ${VAR:Mfilter:O:u} or similar uses in conditions.
 		// To check these properly, pkglint first needs to know the most common
 		// modifiers and how they interact.
 		// As of March 2019, the modifiers are not modeled.
 		// The following tracing statement makes it easy to discover these cases,
 		// in order to decide whether checking them is worthwhile.
 		if trace.Tracing {
 			trace.Stepf("checkCompareVarStr ${%s%s} %s %s",
 				varuse.varname, varuse.Mod(), op, str)
+		}
+	}
+}
-func (ck *MkCondChecker) checkCompareVarNum(left *MkCondTerm, op string, num string) {
+func (ck *MkCondChecker) checkCompareWithNum(left *MkCondTerm, op string, num string) {
-	ck.checkCompareVarNumVersion(op, num)
+	ck.checkCompareWithNumVersion(op, num)
-	ck.checkCompareVarNumPython(left, op, num)
+	ck.checkCompareWithNumPython(left, op, num)
+}
-func (ck *MkCondChecker) checkCompareVarNumVersion(op string, num string) {
+func (ck *MkCondChecker) checkCompareWithNumVersion(op string, num string) {
 	if !contains(num, ".") {
 		return
+	}
 	mkline := ck.MkLine
 	mkline.Warnf("Numeric comparison %s %s.", op, num)
 	mkline.Explain(
 		"The numeric comparison of bmake is not suitable for version numbers",
 		"since 5.1 == 5.10 == 5.1000000.",
 		"",
 		"To fix this, either enclose the number in double quotes,",
 		"or use pattern matching:",
 		"",
 		"\t${OS_VERSION} == \"6.5\"",
 		"\t${OS_VERSION:M1.[1-9]} || ${OS_VERSION:M1.[1-9].*}",
 		"",
 		"The second example needs to be split into two parts",
 		"since with a single comparison of the form ${OS_VERSION:M1.[1-9]*},",
 		"the version number 1.11 would also match, which is not intended.")
+}
-func (ck *MkCondChecker) checkCompareVarNumPython(left *MkCondTerm, op string, num string) {
+func (ck *MkCondChecker) checkCompareWithNumPython(left *MkCondTerm, op string, num string) {
 	if left.Var != nil && left.Var.varname == "_PYTHON_VERSION" &&
 		op != "==" && op != "!=" &&
 		matches(num, `^\d+$`) {
 		ck.MkLine.Errorf("The Python version must not be compared numerically.")
 		ck.MkLine.Explain(
 			"The variable _PYTHON_VERSION must not be compared",
 			"against an integer number, as these comparisons are",
 			"not meaningful.",
 			"For example, 27 < 39 < 40 < 41 < 310, which means that",
 			"Python 3.10 would be considered newer than a",
 			"possible future Python 4.0.",
 			"",
 @@ -279,37 +279,41 @@ func (ck *MkCondChecker) checkCompareVar
 func (ck *MkCondChecker) checkNotCompare(not *MkCond) {
 	if not.Compare == nil {
 		return
+	}
 	ck.MkLine.Warnf("The ! should use parentheses or be merged into the comparison operator.")
+}
 func (ck *MkCondChecker) checkContradictions() {
 	mkline := ck.MkLine
 	byVarname := make(map[string][]VarFact)
 	levels := ck.MkLines.indentation.levels
 	if len(levels) == 0 {
 		goto skip // For .elif outside .if
+	}
 	for _, level := range levels[:len(levels)-1] {
 		if !level.mkline.NeedsCond() {
 			continue
+		}
 		prevFacts := ck.collectFacts(level.mkline)
 		for _, prevFact := range prevFacts {
 			varname := prevFact.Varname
 			byVarname[varname] = append(byVarname[varname], prevFact)
+		}
+	}
 skip:
 	facts := ck.collectFacts(mkline)
 	for _, curr := range facts {
 		varname := curr.Varname
 		for _, prev := range byVarname[varname] {
 			both := makepat.Intersect(prev.Matches, curr.Matches)
 			if !both.CanMatch() {
 				if prev.MkLine != mkline {
 					mkline.Errorf("The patterns %q from %s and %q cannot match at the same time.",
 						prev.Text, mkline.RelMkLine(prev.MkLine), curr.Text)
 				} else {
 					mkline.Errorf("The patterns %q and %q cannot match at the same time.",
 						prev.Text, curr.Text)
+				}

--- pkgsrc/pkgtools/pkglint/files/Attic/mkcondchecker_test.go 2022/11/28 23:33:28 1.14
+++ pkgsrc/pkgtools/pkglint/files/Attic/mkcondchecker_test.go 2023/03/02 08:58:29 1.15

 @@ -119,26 +119,33 @@ func (s *Suite) Test_MkCondChecker_Check
 	test(".if ${VAR} == 3",
 		"WARN: filename.mk:4: VAR is used but not defined.")
 	test(".if \"value\" == ${VAR}",
 		"WARN: filename.mk:4: VAR is used but not defined.")
 	test(".if ${MASTER_SITES:Mftp://*} == \"ftp://netbsd.org/\"",
 		// XXX: duplicate diagnostic, see MkParser.MkCond.
 		"WARN: filename.mk:4: Invalid variable modifier \"//*\" for \"MASTER_SITES\".",
 		"WARN: filename.mk:4: Invalid variable modifier \"//*\" for \"MASTER_SITES\".",
 		"WARN: filename.mk:4: \"ftp\" is not a valid URL.",
 		"WARN: filename.mk:4: MASTER_SITES should not be used at load time in any file.")
 	test(".if !",
 		"WARN: filename.mk:4: Invalid condition, unrecognized part: \"\".")
 	// TODO: There should be another error for the '.elif' outside '.if'.
 	test(".elif 0",
 		"ERROR: filename.mk:5: Unmatched .endif.")
+}
 func (s *Suite) Test_MkCondChecker_Check__tracing(c *check.C) {
 	t := s.Init(c)
 	t.EnableTracingToLog()
 	mklines := t.NewMkLines("filename.mk",
 		MkCvsID,
 		".if ${VAR:Mpattern1:Mpattern2} == comparison",
 		".endif")
 	mklines.Check()
 @@ -589,89 +596,88 @@ func (s *Suite) Test_MkCondChecker_check
 	t.SetUpVartypes()
 	mklines := t.NewMkLines("filename.mk",
 		".if ${DISTFILES:Mpattern:O:u} == NetBSD")
 	t.DisableTracing()
 	ck := NewMkCondChecker(mklines.mklines[0], mklines)
 	varUse := b.VarUse("DISTFILES", "Mpattern", "O", "u")
 	// TODO: mklines.ForEach
 	ck.checkCompareVarStr(varUse, "==", "distfile-1.0.tar.gz")
 	t.CheckOutputEmpty()
+}
-func (s *Suite) Test_MkCondChecker_checkCompareVarNum(c *check.C) {
+func (s *Suite) Test_MkCondChecker_checkCompareWithNum(c *check.C) {
 	t := s.Init(c)
 	mklines := t.NewMkLines("filename.mk",
 		MkCvsID,
 		"",
 		"OS_VERSION=\t6.0",
 		".if ${OS_VERSION} > 6.5 || ${_PYTHON_VERSION} < 38",
 		".endif")
 	mklines.Check()
 	t.CheckOutputLines(
 		"WARN: filename.mk:4: Numeric comparison > 6.5.",
 		"ERROR: filename.mk:4: The Python version must not be compared numerically.",
 		"WARN: filename.mk:4: _PYTHON_VERSION is used but not defined.")
+}
-func (s *Suite) Test_MkCondChecker_checkCompareVarNumVersion(c *check.C) {
+func (s *Suite) Test_MkCondChecker_checkCompareWithNumVersion(c *check.C) {
 	t := s.Init(c)
 	mklines := t.NewMkLines("filename.mk",
 		MkCvsID,
 		"",
 		"OS_VERSION=\t9.0",
 		"",
 		".if ${OS_VERSION} > 6.5",
 		".endif",
 		"",
 		".if ${OS_VERSION} == 6.5",
 		".endif")
 	mklines.Check()
 	t.CheckOutputLines(
 		"WARN: filename.mk:5: Numeric comparison > 6.5.",
 		"WARN: filename.mk:8: Numeric comparison == 6.5.")
+}
-func (s *Suite) Test_MkCondChecker_checkCompareVarNumPython(c *check.C) {
+func (s *Suite) Test_MkCondChecker_checkCompareWithNumPython(c *check.C) {
 	t := s.Init(c)
 	mklines := t.NewMkLines("filename.mk",
 		MkCvsID,
 		"",
 		"_PYTHON_VERSION=\tnone",
 		"",
 		".if ${_PYTHON_VERSION} < 38",
-		".endif",
+		".elif ${_PYTHON_VERSION} < 310",
-		"",
+		".elif \"\" < 310",
 		".if ${_PYTHON_VERSION} < 310",
 		".endif")
 	mklines.Check()
 	t.CheckOutputLines(
 		"WARN: filename.mk:3: "+
 			"Variable names starting with an underscore "+
 			"(_PYTHON_VERSION) are reserved "+
 			"for internal pkgsrc use.",
 		"ERROR: filename.mk:5: "+
 			"The Python version must not be compared numerically.",
-		"ERROR: filename.mk:8: "+
+		"ERROR: filename.mk:6: "+
 			"The Python version must not be compared numerically.")
+}
 func (s *Suite) Test_MkCondChecker_checkCompareVarStrCompiler(c *check.C) {
 	t := s.Init(c)
 	t.SetUpPkgsrc()
 	t.Chdir("category/package")
 	t.FinishSetUp()
 	doTest := func(cond string) {
 		mklines := t.SetUpFileMkLines("filename.mk",
 			MkCvsID,

--- pkgsrc/pkgtools/pkglint/files/Attic/mklineparser.go 2020/06/06 20:42:56 1.14
+++ pkgsrc/pkgtools/pkglint/files/Attic/mklineparser.go 2023/03/02 08:58:29 1.15

--- pkgsrc/pkgtools/pkglint/files/Attic/mkvarusechecker.go 2021/06/06 07:41:34 1.14
+++ pkgsrc/pkgtools/pkglint/files/Attic/mkvarusechecker.go 2023/03/02 08:58:29 1.15

 @@ -23,31 +23,35 @@ func NewMkVarUseChecker(use *MkVarUse, m
 func (ck *MkVarUseChecker) Check(vuc *VarUseContext) {
 	if ck.use.IsExpression() {
 		return
+	}
 	ck.checkUndefined()
 	ck.checkPermissions(vuc)
 	ck.checkVarname(vuc.time)
 	ck.checkModifiers()
 	ck.checkAssignable(vuc)
 	ck.checkQuoting(vuc)
 	if G.Pkgsrc == nil {
 		goto checkVarUse
+	}
 	ck.checkToolsPlatform()
 	ck.checkBuildDefs()
 	ck.checkDeprecated()
 	ck.checkPkgBuildOptions()
 checkVarUse:
 	NewMkLineChecker(ck.MkLines, ck.MkLine).
 		checkTextVarUse(ck.use.varname, ck.vartype, vuc.time)
+}
 func (ck *MkVarUseChecker) checkUndefined() {
 	varuse := ck.use
 	vartype := ck.vartype
 	varname := varuse.varname
 	switch {
 	case !G.WarnExtra,
 		// Well-known variables are probably defined by the infrastructure.
 		vartype != nil && !vartype.IsGuessed(),

--- pkgsrc/pkgtools/pkglint/files/Attic/mkline.go 2023/01/29 13:36:31 1.86
+++ pkgsrc/pkgtools/pkglint/files/Attic/mkline.go 2023/03/02 08:58:29 1.87

	@@ -1295,26 +1295,29 @@ func (ind *Indentation) TrackAfter(mklin		@@ -1295,26 +1295,29 @@ func (ind *Indentation) TrackAfter(mklin
1295	ind.Pop()	1295	ind.Pop()
1296	}	1296	}
1297	}	1297	}
1298		1298
1299	switch directive {	1299	switch directive {
1300	case "if", "elif":	1300	case "if", "elif":
1301	cond := mkline.Cond()	1301	cond := mkline.Cond()
1302	if cond == nil {	1302	if cond == nil {
1303	break	1303	break
1304	}	1304	}
1305		1305
1306	ind.RememberUsedVariables(cond)	1306	ind.RememberUsedVariables(cond)
1307		1307
		1308	if G.Pkgsrc == nil {
		1309	break
		1310	}
1308	cond.Walk(&MkCondCallback{	1311	cond.Walk(&MkCondCallback{
1309	Call: func(name string, arg string) {	1312	Call: func(name string, arg string) {
1310	if name == "exists" && !NewPath(arg).IsAbs() {	1313	if name == "exists" && !NewPath(arg).IsAbs() {
1311	rel := G.Pkgsrc.Rel(mkline.File(NewRelPathString(arg)))	1314	rel := G.Pkgsrc.Rel(mkline.File(NewRelPathString(arg)))
1312	ind.AddCheckedFile(rel)	1315	ind.AddCheckedFile(rel)
1313	}	1316	}
1314	}})	1317	}})
1315	}	1318	}
1316	}	1319	}
1317		1320
1318	func (ind *Indentation) CheckFinish(filename CurrPath) {	1321	func (ind *Indentation) CheckFinish(filename CurrPath) {
1319	if ind.IsEmpty() {	1322	if ind.IsEmpty() {
1320	return	1323	return

--- pkgsrc/pkgtools/pkglint/files/Attic/mkline_test.go 2023/01/29 13:36:31 1.85
+++ pkgsrc/pkgtools/pkglint/files/Attic/mkline_test.go 2023/03/02 08:58:29 1.86

 @@ -323,26 +323,40 @@ func (s *Suite) Test_MkLine_ValueFields_
 	t.CheckEquals(rest, "")
 	words = mkline.ValueFields(url)
 	t.CheckDeepEquals(words, []string{url})
 	words = mkline.ValueFields("a b \"c  c  c\" d;;d;; \"e\"''`` 'rest")
 	t.CheckDeepEquals(words, []string{"a", "b", "\"c  c  c\"", "d;;d;;", "\"e\"''``"})
 	// The rest "'rest" is silently discarded.
 	// Most probably, the shell will complain about it when it is executed.
+}
 func (s *Suite) Test_MkLine_ValueFields__escaped_number_sign(c *check.C) {
 	t := s.Init(c)
 	mklines := t.NewMkLines("filename.mk",
 		".SHELL: \\",
 		"\tname=sh \\",
 		"\tpath=${.SHELL} \\",
 		"\tquiet=\"\\# .echoOff\"")
 	mkline := mklines.mklines[0]
 	words := mkline.ValueFields(mkline.Sources())
 	t.CheckDeepEquals(words, []string{"name=sh", "path=${.SHELL}", "quiet=\"# .echoOff\""})
+}
 func (s *Suite) Test_MkLine_ValueTokens(c *check.C) {
 	t := s.Init(c)
 	b := NewMkTokenBuilder()
 	text := b.TextToken
 	varUseText := b.VaruseTextToken
 	tokens := b.Tokens
 	test := func(value string, expected []*MkToken, diagnostics ...string) {
 		mkline := t.NewMkLine("Makefile", 1, "PATH=\t"+value)
 		actualTokens, _ := mkline.ValueTokens()
 		t.CheckDeepEquals(actualTokens, expected)
 		t.CheckOutput(diagnostics)
+	}
 @@ -629,27 +643,27 @@ func (s *Suite) Test_MkLine_VariableNeed
 		"MASTER_SITES=\t${HOMEPAGE}")
 	mkline := mklines.mklines[1]
 	vuc := VarUseContext{G.Pkgsrc.vartypes.Canon("MASTER_SITES"), VucRunTime, VucQuotPlain, false}
 	nq := mkline.VariableNeedsQuoting(nil, NewMkVarUse("HOMEPAGE"), G.Pkgsrc.vartypes.Canon("HOMEPAGE"), &vuc)
 	t.CheckEquals(nq, no)
 	NewMkAssignChecker(mkline, mklines).check()
 	t.CheckOutputEmpty() // Up to version 5.3.6, pkglint warned about a missing :Q here, which was wrong.
+}
-func (s *Suite) Test_MkLine_VariableNeedsQuoting__append_list_to_list(c *check.C) {
+func (s *Suite) Test_MkLine_VariableNeedsQuoting__assign_list_to_list(c *check.C) {
 	t := s.Init(c)
 	t.SetUpVartypes()
 	t.SetUpMasterSite("MASTER_SITE_SOURCEFORGE", "http://downloads.sourceforge.net/sourceforge/")
 	mklines := t.NewMkLines("Makefile",
 		MkCvsID,
 		"MASTER_SITES=\t${MASTER_SITE_SOURCEFORGE:=squirrel-sql/}")
 	NewMkAssignChecker(mklines.mklines[1], mklines).check()
 	// Assigning lists to lists is ok.
 	t.CheckOutputEmpty()
+}

--- pkgsrc/pkgtools/pkglint/files/Attic/mklinechecker.go 2023/01/29 13:36:31 1.71
+++ pkgsrc/pkgtools/pkglint/files/Attic/mklinechecker.go 2023/03/02 08:58:29 1.72

 @@ -237,26 +237,29 @@ func (ck MkLineChecker) checkInclude() {
 		defer trace.Call0()()
+	}
 	mkline := ck.MkLine
 	if mkline.Indent() != "" {
 		ck.checkDirectiveIndentation(ck.MkLines.indentation.Depth("include"))
+	}
 	includedFile := mkline.IncludedFile()
 	mustExist := mkline.MustExist()
 	if trace.Tracing {
 		trace.Stepf("includingFile=%s includedFile=%s", mkline.Filename(), includedFile)
+	}
 	if G.Pkgsrc == nil {
 		return
+	}
 	ck.CheckRelativePath(NewPackagePath(includedFile), includedFile, mustExist)
 	switch {
 	case includedFile.HasBase("Makefile"):
 		mkline.Errorf("Other Makefiles must not be included directly.")
 		mkline.Explain(
 			"To include portions of another Makefile, extract the common parts",
 			"and put them into a Makefile.common or a Makefile fragment called",
 			"module.mk or similar.",
 			"After that, both this one and the other package should include the newly created file.")
 	case mkline.Basename != "Makefile" && includedFile.HasBase("bsd.pkg.mk"):
 		mkline.Errorf("The file bsd.pkg.mk must only be included by package Makefiles, not by other Makefile fragments.")

--- pkgsrc/pkgtools/pkglint/files/Attic/mklines.go 2022/10/02 15:11:19 1.76
+++ pkgsrc/pkgtools/pkglint/files/Attic/mklines.go 2023/03/02 08:58:29 1.77

 @@ -52,27 +52,29 @@ type mklinesCheckAll struct {
 	forVars map[string]bool
 	// Custom action that is run after checking each line
 	postLine func(mkline *MkLine)
+}
 func NewMkLines(lines *Lines, pkg *Package, extraScope *Scope) *MkLines {
 	mklines := make([]*MkLine, lines.Len())
 	for i, line := range lines.Lines {
 		mklines[i] = NewMkLineParser().Parse(line)
+	}
 	tools := NewTools()
-	tools.Fallback(G.Pkgsrc.Tools)
+	if G.Pkgsrc != nil {
 		tools.Fallback(G.Pkgsrc.Tools)
+	}
 	return &MkLines{
 		mklines,
 		lines,
 		pkg,
 		extraScope,
 		NewScope(),
 		make(map[string]bool),
 		make(map[string]*MkLine),
 		make(map[string]*MkLine),
 		false,
 		tools,
 		nil,

--- pkgsrc/pkgtools/pkglint/files/Attic/mkparser_test.go 2022/07/09 06:40:55 1.43
+++ pkgsrc/pkgtools/pkglint/files/Attic/mkparser_test.go 2023/03/02 08:58:29 1.44

 @@ -292,26 +292,31 @@ func (s *Suite) Test_MkParser_MkCond(c *
 	// Function calls need round parentheses instead of curly braces.
 	// As of July 2019, bmake silently accepts this wrong expression
 	// and interprets it as !defined(empty{USE_CROSS_COMPILE:M[yY][eE][sS]}),
 	// which is always true, except if a variable of this strange name
 	// were actually defined.
 	testRest("!empty{USE_CROSS_COMPILE:M[yY][eE][sS]}",
 		nil,
 		"empty{USE_CROSS_COMPILE:M[yY][eE][sS]}")
 	testRest("unknown(arg)",
 		nil,
 		"unknown(arg)")
 	// The '!' is consumed by the parser.
 	testRest("!",
 		nil,
 		"")
+}
 func (s *Suite) Test_MkParser_mkCondCompare(c *check.C) {
 	t := s.Init(c)
 	b := NewMkTokenBuilder()
 	mkline := t.NewMkLine("Makefile", 123, ".if ${PKGPATH} == category/pack.age-3+")
 	p := NewMkParser(mkline.Line, mkline.Args())
 	cond := p.MkCond()
 	t.CheckEquals(p.Rest(), "")
 	t.CheckDeepEquals(
 		cond,

--- pkgsrc/pkgtools/pkglint/files/Attic/package_test.go 2023/01/29 13:36:31 1.93
+++ pkgsrc/pkgtools/pkglint/files/Attic/package_test.go 2023/03/02 08:58:29 1.94

 @@ -3143,27 +3143,27 @@ func (s *Suite) Test_Package_pkgnameFrom
 		"WARN: ~/category/package/Makefile:4: "+
 			"Missing closing \"}\" for \"DISTNAME\".")
 	// Parse error with an unparseable rest.
 	test("$", "package-1.0", "",
 		nil...)
+}
 func (s *Suite) Test_Package_checkPossibleDowngrade(c *check.C) {
 	t := s.Init(c)
 	t.CreateFileLines("doc/CHANGES-2018",
 		"\tUpdated category/pkgbase to 1.8 [committer 2018-01-05]")
-	G.Pkgsrc.changes.load(&G.Pkgsrc)
+	G.Pkgsrc.changes.load(G.Pkgsrc)
 	t.Chdir("category/pkgbase")
 	pkg := NewPackage(".")
 	pkg.EffectivePkgname = "package-1.0nb15"
 	pkg.EffectivePkgnameLine = t.NewMkLine("Makefile", 5, "PKGNAME=dummy")
 	pkg.checkPossibleDowngrade()
 	t.CheckOutputLines(
 		"WARN: Makefile:5: The package is being downgraded from 1.8 (see ../../doc/CHANGES-2018:1) to 1.0nb15.")
 	G.Pkgsrc.changes.LastChange["category/pkgbase"].target = "1.0nb22"

--- pkgsrc/pkgtools/pkglint/files/Attic/patches.go 2022/07/06 06:14:24 1.47
+++ pkgsrc/pkgtools/pkglint/files/Attic/patches.go 2023/03/02 08:58:29 1.48

 @@ -173,28 +173,29 @@ func (ck *PatchChecker) checkUnifiedDiff
 			default:
 				line.Errorf("Invalid line in unified patch hunk: %s", text)
 				return
+			}
+		}
 		// When these two counts are equal, they may refer to context
 		// lines that consist only of whitespace and have therefore
 		// been lost during transmission. There is no way to detect
 		// this by looking only at the patch file.
 		if linesToAdd != linesToDel {
 			line := ck.llex.PreviousLine()
-			line.Warnf("Premature end of patch hunk (expected %d lines to be deleted and %d lines to be added).",
+			line.Warnf("Premature end of patch hunk (expected %d %s to be deleted and %d %s to be added).",
-				linesToDel, linesToAdd)
+				linesToDel, condStr(linesToDel != 1, "lines", "line"),
 				linesToAdd, condStr(linesToAdd != 1, "lines", "line"))
+		}
+	}
 	if !hasHunks {
 		ck.llex.CurrentLine().Errorf("No patch hunks for %q.", patchedFile.String())
+	}
 	if !ck.llex.EOF() {
 		line := ck.llex.CurrentLine()
 		if !ck.isEmptyLine(line.Text) && !matches(line.Text, rePatchUniFileDel) {
 			line.Warnf("Empty line or end of file expected.")
 			line.Explain(
 				"This line is not part of the patch anymore, although it may look so.",

--- pkgsrc/pkgtools/pkglint/files/Attic/pkglint.go 2023/01/29 13:36:31 1.87
+++ pkgsrc/pkgtools/pkglint/files/Attic/pkglint.go 2023/03/02 08:58:29 1.88

 @@ -22,27 +22,27 @@ const confVersion = "@VERSION@"
 type Pkglint struct {
 	CheckGlobal bool
 	WarnExtra,
 	WarnPerm,
 	WarnQuoting bool
 	Profiling,
 	DumpMakefile,
 	Import,
 	Network,
 	Recursive bool
-	Pkgsrc Pkgsrc // Global data, mostly extracted from mk/*.
+	Pkgsrc *Pkgsrc // Global data, mostly extracted from mk/*.
 	Todo CurrPathQueue // The files or directories that still need to be checked.
 	Wip            bool   // Is the currently checked file or package from pkgsrc-wip?
 	Infrastructure bool   // Is the currently checked file from the pkgsrc infrastructure?
 	Testing        bool   // Is pkglint in self-testing mode (only during development)?
 	Experimental   bool   // For experimental features, only enabled individually in tests
 	Username       string // For checking against OWNER and MAINTAINER
 	cvsEntriesDir CurrPath // Cached to avoid I/O
 	cvsEntries    map[RelPath]CvsEntry
 	Logger Logger
 @@ -180,43 +180,47 @@ func (p *Pkglint) setUpProfiling() func(
 		p.loaded.PrintStats(p.Logger.out.out, "loaded", 10)
 		p.Logger.out.WriteLine(sprintf("fileCache: %d hits, %d misses", p.fileCache.hits, p.fileCache.misses))
 	})
 	return func() {
 		for i := range cleanups {
 			cleanups[len(cleanups)-1-i]()
+		}
+	}
+}
 func (p *Pkglint) prepareMainLoop() {
 	firstDir := p.Todo.Front()
-	if firstDir.IsFile() {
+	isFile := firstDir.IsFile()
 	if isFile {
 		firstDir = firstDir.Dir()
+	}
 	relTopdir := p.findPkgsrcTopdir(firstDir)
 	if relTopdir.IsEmpty() {
 		// If the first argument to pkglint is not inside a pkgsrc tree,
-		// pkglint doesn't know where to load the infrastructure files from,
+		// pkglint doesn't know where to load the infrastructure files from.
-		// Since virtually every single check needs these files,
+		if isFile {
-		// the only sensible thing to do is to quit immediately.
+			// Allow this mode nevertheless, for checking the basic syntax
-		G.Logger.TechFatalf(firstDir, "Must be inside a pkgsrc tree.")
+			// and for formatting individual makefiles outside pkgsrc.
 		} else {
 			G.Logger.TechFatalf(firstDir, "Must be inside a pkgsrc tree.")
+		}
 	} else {
 		p.Pkgsrc = NewPkgsrc(firstDir.JoinNoClean(relTopdir))
 		p.Wip = p.Pkgsrc.IsWip(firstDir) // See Pkglint.checkMode.
 		p.Pkgsrc.LoadInfrastructure()
+	}
 	p.Pkgsrc = NewPkgsrc(firstDir.JoinNoClean(relTopdir))
 	p.Wip = p.Pkgsrc.IsWip(firstDir) // See Pkglint.checkMode.
 	p.Pkgsrc.LoadInfrastructure()
 	currentUser, err := user.Current()
 	assertNil(err, "user.Current")
 	// On Windows, this is `Computername\Username`.
 	p.Username = replaceAll(currentUser.Username, `^.*\\`, "")
+}
 func (p *Pkglint) ParseCommandLine(args []string) int {
 	lopts := &p.Logger.Opts
 	opts := getopt.NewOptions()
 	var showHelp bool
 	var showVersion bool
 @@ -298,26 +302,31 @@ func (p *Pkglint) checkMode(dirent CurrP
 	// TODO: merge duplicate code in Package.checkDirent
 	isDir := mode.IsDir()
 	isReg := mode.IsRegular()
 	if !isDir && !isReg {
 		NewLineWhole(dirent).Errorf("No such file or directory.")
 		return
+	}
 	dir := dirent
 	if !isDir {
 		dir = dirent.Dir()
+	}
 	if isReg && p.Pkgsrc == nil {
 		CheckFileMk(dirent, nil)
 		return
+	}
 	pkgsrcRel := p.Pkgsrc.Rel(dirent)
 	p.Wip = pkgsrcRel.HasPrefixPath("wip")
 	p.Infrastructure = pkgsrcRel.HasPrefixPath("mk") ||
 		pkgsrcRel.HasPrefixPath("wip/mk")
 	pkgsrcdir := p.findPkgsrcTopdir(dir)
 	if pkgsrcdir.IsEmpty() {
 		G.Logger.TechErrorf("",
 			"Cannot determine the pkgsrc root directory for %q.",
 			dirent)
 		return
+	}

--- pkgsrc/pkgtools/pkglint/files/Attic/pkglint_test.go 2023/01/29 13:36:31 1.73
+++ pkgsrc/pkgtools/pkglint/files/Attic/pkglint_test.go 2023/03/02 08:58:29 1.74

 @@ -234,27 +234,27 @@ func (s *Suite) Test_Pkglint_Main__compl
 	t.Main("-Wall", "-Call", "sysutils/checkperms")
 	t.CheckOutputLines(
 		"NOTE: ~/sysutils/checkperms/Makefile:3: "+
 			"Package version \"1.11\" is greater than the latest \"1.10\" "+
 			"from ../../doc/CHANGES-2018:5.",
 		"WARN: ~/sysutils/checkperms/Makefile:3: "+
 			"This package should be updated to 1.13 (supports more file formats; see ../../doc/TODO:5).",
 		"ERROR: ~/sysutils/checkperms/Makefile:4: Invalid category \"tools\".",
 		"ERROR: ~/sysutils/checkperms/TODO: Packages in main pkgsrc must not have a TODO file.",
 		"ERROR: ~/sysutils/checkperms/distinfo:6: SHA1 hash of patches/patch-checkperms.c differs "+
 			"(distinfo has asdfasdf, patch file has bcfb79696cb6bf4d2222a6d78a530e11bf1c0cea).",
 		"WARN: ~/sysutils/checkperms/patches/patch-checkperms.c:12: Premature end of patch hunk "+
-			"(expected 1 lines to be deleted and 0 lines to be added).",
+			"(expected 1 line to be deleted and 0 lines to be added).",
 		"3 errors, 2 warnings and 1 note found.",
 		t.Shquote("(Run \"pkglint -e -Wall -Call %s\" to show explanations.)", "sysutils/checkperms"),
 		t.Shquote("(Run \"pkglint -fs -Wall -Call %s\" to show what can be fixed automatically.)", "sysutils/checkperms"),
 		t.Shquote("(Run \"pkglint -F -Wall -Call %s\" to automatically fix some issues.)", "sysutils/checkperms"))
+}
 func (s *Suite) Test_Pkglint_Main__autofix_exitcode(c *check.C) {
 	t := s.Init(c)
 	t.SetUpPkgsrc()
 	t.CreateFileLines("filename.mk",
 		"")

--- pkgsrc/pkgtools/pkglint/files/Attic/pkgsrc.go 2023/01/29 13:36:31 1.69
+++ pkgsrc/pkgtools/pkglint/files/Attic/pkgsrc.go 2023/03/02 08:58:29 1.70

 @@ -37,28 +37,28 @@ type Pkgsrc struct {
 	listVersions map[string][]string // See Pkgsrc.ListVersions
 	// Variables that may be overridden by the pkgsrc user.
 	// They are typically defined in mk/defaults/mk.conf.
 	//
 	// Whenever a package uses such a variable, it must add the variable name
 	// to BUILD_DEFS.
 	UserDefinedVars Scope
 	Deprecated map[string]string
 	vartypes   VarTypeRegistry
+}
-func NewPkgsrc(dir CurrPath) Pkgsrc {
+func NewPkgsrc(dir CurrPath) *Pkgsrc {
-	return Pkgsrc{
+	return &Pkgsrc{
 		dir,
 		make(map[string]bool),
 		NewTools(),
 		make(map[string]string),
 		make(map[string]string),
 		make(map[string]string),
 		nil,
 		nil,
 		Changes{},
 		make(map[string][]string),
 		NewScope(),
 		make(map[string]string),
 		NewVarTypeRegistry()}
 @@ -726,26 +726,29 @@ func (src *Pkgsrc) ListVersions(category
 	var repls = make([]string, len(names))
 	for i, name := range names {
 		repls[i] = replaceAll(name, re, repl)
+	}
 	src.listVersions[cacheKey] = repls
 	return repls
+}
 // VariableType returns the type of the variable
 // (possibly guessed based on the variable name),
 // or nil if the type cannot even be guessed.
 func (src *Pkgsrc) VariableType(mklines *MkLines, varname string) (vartype *Vartype) {
 	if src == nil {
 		return nil
+	}
 	if trace.Tracing {
 		defer trace.Call(varname, trace.Result(&vartype))()
+	}
 	// When scanning mk/** for otherwise unknown variables, their type
 	// is set to BtUnknown. These variables must not override the guess
 	// based on the variable name.
 	vartype = src.vartypes.Canon(varname)
 	if vartype != nil && vartype.basicType != BtUnknown {
 		return vartype
+	}
 	if tool := G.ToolByVarname(mklines, varname); tool != nil {

--- pkgsrc/pkgtools/pkglint/files/Attic/var.go 2023/01/29 13:36:31 1.10
+++ pkgsrc/pkgtools/pkglint/files/Attic/var.go 2023/03/02 08:58:29 1.11

 @@ -177,27 +177,27 @@ func (v *Var) Write(mkline *MkLine, cond
 	v.writeLocations = append(v.writeLocations, mkline)
 	if conditional {
 		v.conditional = true
+	}
 	v.conditionalVars.AddAll(conditionVarnames)
 	mkline.ForEachUsed(func(varUse *MkVarUse, time VucTime) {
 		v.refs.Add(varUse.varname)
 	})
 	v.refs.AddAll(conditionVarnames)
 	v.update(mkline, &v.valueInfra)
-	if !G.Pkgsrc.IsInfra(mkline.Line.Filename()) {
+	if G.Pkgsrc != nil && !G.Pkgsrc.IsInfra(mkline.Line.Filename()) {
 		v.update(mkline, &v.value)
+	}
 	v.updateConstantValue(mkline)
+}
 func (v *Var) update(mkline *MkLine, update *string) {
 	firstWrite := len(v.writeLocations) == 1
 	if v.IsConditional() && !firstWrite {
 		return
+	}
 	value := mkline.Value()

--- pkgsrc/pkgtools/pkglint/files/Attic/vardefs_test.go 2020/06/07 15:49:23 1.29
+++ pkgsrc/pkgtools/pkglint/files/Attic/vardefs_test.go 2023/03/02 08:58:29 1.30

 @@ -31,27 +31,27 @@ func (s *Suite) Test_VarTypeRegistry_com
 		".if ${USE_LANGUAGES:Mexpr-lang} || !empty(USE_LANGUAGES:Mempty-lang)",
 		".endif",
 		"",
 		// Just for code coverage
 		".if ${OTHER} || ${USE_LANGUAGES} \\",
 		" || ${USE_LANGUAGES:O} || ${USE_LANGUAGES:Mc++-*}",
 		".endif",
 		"",
 		// Just for code coverage
 		".if", // missing condition
 		".endif")
 	reg := NewVarTypeRegistry()
-	compilerLanguages := reg.compilerLanguages(&G.Pkgsrc)
+	compilerLanguages := reg.compilerLanguages(G.Pkgsrc)
 	enumValues := compilerLanguages.AllowedEnums()
 	t.CheckEquals(enumValues, "empty-lang expr-lang gnu++14")
+}
 func (s *Suite) Test_VarTypeRegistry_enumFrom(c *check.C) {
 	t := s.Init(c)
 	t.CreateFileLines("editors/emacs/modules.mk",
 		MkCvsID,
 		"",
 		"_EMACS_VERSIONS_ALL=    emacs31",
 		"_EMACS_VERSIONS_ALL+=   emacs29")
 @@ -91,29 +91,29 @@ func (s *Suite) Test_VarTypeRegistry_enu
 		"gnu++03 gnu++0x gnu++11 gnu++14  (list, package-settable)")
 	test("PKGSRC_COMPILER", "enum: ccache distcc f2c g95 gcc ido mipspro-ucode sunpro  (list, user-settable)")
+}
 func (s *Suite) Test_VarTypeRegistry_enumFrom__no_tracing(c *check.C) {
 	t := s.Init(c)
 	t.CreateFileLines("mk/existing.mk",
 		MkCvsID,
 		"VAR=\tfirst second")
 	reg := NewVarTypeRegistry()
 	t.DisableTracing()
-	existingType := reg.enumFrom(&G.Pkgsrc, "mk/existing.mk", "defval", "VAR")
+	existingType := reg.enumFrom(G.Pkgsrc, "mk/existing.mk", "defval", "VAR")
-	noAssignmentsType := reg.enumFrom(&G.Pkgsrc, "mk/existing.mk", "defval", "OTHER_VAR")
+	noAssignmentsType := reg.enumFrom(G.Pkgsrc, "mk/existing.mk", "defval", "OTHER_VAR")
-	nonexistentType := reg.enumFrom(&G.Pkgsrc, "mk/nonexistent.mk", "defval", "VAR")
+	nonexistentType := reg.enumFrom(G.Pkgsrc, "mk/nonexistent.mk", "defval", "VAR")
 	t.CheckEquals(existingType.AllowedEnums(), "first second")
 	t.CheckEquals(noAssignmentsType.AllowedEnums(), "defval")
 	t.CheckEquals(nonexistentType.AllowedEnums(), "defval")
+}
 func (s *Suite) Test_VarTypeRegistry_enumFrom__no_testing(c *check.C) {
 	t := s.Init(c)
 	G.Testing = false
 	t.ExpectFatal(
 		t.SetUpVartypes,
 @@ -152,27 +152,27 @@ func (s *Suite) Test_VarTypeRegistry_enu
+	}
 	test("PYPKGPREFIX", "enum: py28 py33  (system-provided)")
+}
 func (s *Suite) Test_VarTypeRegistry_enumFromDirs__no_testing(c *check.C) {
 	t := s.Init(c)
 	G.Testing = false
 	t.ExpectFatal(
 		func() {
 			G.Pkgsrc.vartypes.enumFromDirs(
-				&G.Pkgsrc, "category", `^pack.*`, "$0", "default")
+				G.Pkgsrc, "category", `^pack.*`, "$0", "default")
 		},
 		"FATAL: ~/category: Must contain at least 1 "+
 			"subdirectory matching \"^pack.*\".")
+}
 func (s *Suite) Test_VarTypeRegistry_enumFromFiles(c *check.C) {
 	t := s.Init(c)
 	t.CreateFileLines("mk/platform/NetBSD.mk")
 	t.CreateFileLines("mk/platform/README")
 	t.CreateFileLines("mk/platform/SunOS.mk")
 	t.CreateFileLines("mk/platform/SunOS.mk~")
 @@ -183,50 +183,50 @@ func (s *Suite) Test_VarTypeRegistry_enu
 		t.CheckEquals(vartype, values)
+	}
 	test("OPSYS", "enum: NetBSD SunOS  (system-provided)")
+}
 func (s *Suite) Test_VarTypeRegistry_enumFromFiles__no_testing(c *check.C) {
 	t := s.Init(c)
 	G.Testing = false
 	t.ExpectFatal(
 		func() {
-			G.Pkgsrc.vartypes.enumFromFiles(&G.Pkgsrc,
+			G.Pkgsrc.vartypes.enumFromFiles(G.Pkgsrc,
 				"mk/platform", `^(\w+)\.mk$`, "$1", "default")
 		},
 		"FATAL: ~/mk/platform: Must contain at least 1 "+
 			"file matching \"^(\\\\w+)\\\\.mk$\".")
+}
 func (s *Suite) Test_VarTypeRegistry_options__assertion(c *check.C) {
 	t := s.Init(c)
 	reg := NewVarTypeRegistry()
 	t.ExpectAssert(func() {
 		reg.options(
 			SystemProvided,
 			[]vartypeOptions{DefinedIfInScope, NonemptyIfDefined})
 	})
+}
 func (s *Suite) Test_VarTypeRegistry_Init(c *check.C) {
 	t := s.Init(c)
 	src := NewPkgsrc(t.File("."))
-	src.vartypes.Init(&src)
+	src.vartypes.Init(src)
 	t.CheckEquals(src.vartypes.Canon("BSD_MAKE_ENV").basicType.name, "ShellWord")
 	t.CheckEquals(src.vartypes.Canon("USE_BUILTIN.*").basicType.name, "YesNoIndirectly")
+}
 func (s *Suite) Test_VarTypeRegistry_Init__LP64PLATFORMS(c *check.C) {
 	t := s.Init(c)
 	pkg := t.SetUpPackage("category/package",
 		"BROKEN_ON_PLATFORM=\t${LP64PLATFORMS}")
 	t.FinishSetUp()
 	G.Check(pkg)

	@@ -250,27 +250,27 @@ func (p MkLineParser) parseInclude(line		@@ -250,27 +250,27 @@ func (p MkLineParser) parseInclude(line
250		250
251	func (p MkLineParser) parseSysinclude(line Line, splitResult mkLineSplitResult) MkLine {	251	func (p MkLineParser) parseSysinclude(line Line, splitResult mkLineSplitResult) MkLine {
252	m, indent, directive, includedFile := match3(splitResult.main, `^\.([\t ]*)(s?include)[\t ]+<([^>]+)>$`)	252	m, indent, directive, includedFile := match3(splitResult.main, `^\.([\t ]*)(s?include)[\t ]+<([^>]+)>$`)
253	if !m {	253	if !m {
254	return nil	254	return nil
255	}	255	}
256		256
257	return &MkLine{line, splitResult, &mkLineInclude{directive == "include", true, indent, NewRelPathString(includedFile), nil}}	257	return &MkLine{line, splitResult, &mkLineInclude{directive == "include", true, indent, NewRelPathString(includedFile), nil}}
258	}	258	}
259		259
260	func (p MkLineParser) parseDependency(line Line, splitResult mkLineSplitResult) MkLine {	260	func (p MkLineParser) parseDependency(line Line, splitResult mkLineSplitResult) MkLine {
261	// XXX: Replace this regular expression with proper parsing.	261	// XXX: Replace this regular expression with proper parsing.
262	// There might be a ${VAR:M*.c} in these variables, which the below regular expression cannot handle.	262	// There might be a ${VAR:M*.c} in these variables, which the below regular expression cannot handle.
263	m, targets, whitespace, sources := match3(line.Text, `^([^\t :]+(?:[\t ][^\t :]+))([\t ]):[\t ]([^#]?)(?:[\t ]#.*)?$`)	263	m, targets, whitespace, sources := match3(splitResult.main, `^([^\t :]+(?:[\t ][^\t :]+))([\t ]):[\t ](.*)$`)
264	if !m {	264	if !m {
265	return nil	265	return nil
266	}	266	}
267		267
268	if whitespace != "" {	268	if whitespace != "" {
269	line.Notef("Space before colon in dependency line.")	269	line.Notef("Space before colon in dependency line.")
270	}	270	}
271	return &MkLine{line, splitResult, mkLineDependency{targets, sources}}	271	return &MkLine{line, splitResult, mkLineDependency{targets, sources}}
272	}	272	}
273		273
274	func (p MkLineParser) parseMergeConflict(line Line, splitResult mkLineSplitResult) MkLine {	274	func (p MkLineParser) parseMergeConflict(line Line, splitResult mkLineSplitResult) MkLine {
275	if !matches(line.Text, `^(<<<<<<<\|=======\|>>>>>>>)`) {	275	if !matches(line.Text, `^(<<<<<<<\|=======\|>>>>>>>)`) {
276	return nil	276	return nil