 @@ -1,16 +1,16 @@
-# $NetBSD: Makefile,v 1.649 2020/05/24 19:12:29 rillig Exp $
+# $NetBSD: Makefile,v 1.650 2020/05/29 20:13:17 rillig Exp $
-PKGNAME=	pkglint-20.1.10
+PKGNAME=	pkglint-20.1.11
 CATEGORIES=	pkgtools
 DISTNAME=	tools
 MASTER_SITES=	${MASTER_SITE_GITHUB:=golang/}
 GITHUB_PROJECT=	tools
 GITHUB_TAG=	92d8274bd7b8a4c65f24bafe401a029e58392704
 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

 @@ -811,77 +811,74 @@ func (mkline *MkLine) VariableNeedsQuoti
 	// Good: LDADD+= ${LIBS:S,^,-l,}
 	if wantList {
 		return yes
+	}
 	if trace.Tracing {
 		trace.Step1("Don't know whether :Q is needed for %q", varuse.varname)
+	}
 	return unknown
+}
 // ForEachUsed calls the action for each variable that is used in the line.
 func (mkline *MkLine) ForEachUsed(action func(varUse *MkVarUse, time VucTime)) {
 	var searchIn func(text string, time VucTime) // mutually recursive with searchInVarUse
 	searchInVarUse := func(varuse *MkVarUse, time VucTime) {
 		varname := varuse.varname
 		if !varuse.IsExpression() {
 			action(varuse, time)
 		searchIn(varname, time)
 		for _, mod := range varuse.modifiers {
 			searchIn(mod.Text, time)
 	searchIn = func(text string, time VucTime) {
 		if !contains(text, "$") {
 			return
 		tokens, _ := NewMkLexer(text, nil).MkTokens()
 		for _, token := range tokens {
 			if token.Varuse != nil {
 				searchInVarUse(token.Varuse, time)
 	switch {
 	case mkline.IsVarassign():
-		searchIn(mkline.Varname(), VucLoadTime)
+		mkline.ForEachUsedText(mkline.Varname(), VucLoadTime, action)
-		searchIn(mkline.Value(), mkline.Op().Time())
+		mkline.ForEachUsedText(mkline.Value(), mkline.Op().Time(), action)
 	case mkline.IsDirective() && mkline.Directive() == "for":
-		searchIn(mkline.Args(), VucLoadTime)
+		mkline.ForEachUsedText(mkline.Args(), VucLoadTime, action)
 	case mkline.IsDirective() && (mkline.Directive() == "if" || mkline.Directive() == "elif") && mkline.Cond() != nil:
 		mkline.Cond().Walk(&MkCondCallback{
 			VarUse: func(varuse *MkVarUse) {
-				searchInVarUse(varuse, VucLoadTime)
+				mkline.ForEachUsedVarUse(varuse, VucLoadTime, action)
 			}})
 	case mkline.IsShellCommand():
-		searchIn(mkline.ShellCommand(), VucRunTime)
+		mkline.ForEachUsedText(mkline.ShellCommand(), VucRunTime, action)
 	case mkline.IsDependency():
-		searchIn(mkline.Targets(), VucLoadTime)
+		mkline.ForEachUsedText(mkline.Targets(), VucLoadTime, action)
-		searchIn(mkline.Sources(), VucLoadTime)
+		mkline.ForEachUsedText(mkline.Sources(), VucLoadTime, action)
 	case mkline.IsInclude():
-		searchIn(mkline.IncludedFile().String(), VucLoadTime)
+		mkline.ForEachUsedText(mkline.IncludedFile().String(), VucLoadTime, action)
+	}
+}
 func (mkline *MkLine) ForEachUsedText(text string, time VucTime, action func(varUse *MkVarUse, time VucTime)) {
 	if !contains(text, "$") {
 		return
+	}
 	tokens, _ := NewMkLexer(text, nil).MkTokens()
 	for _, token := range tokens {
 		if token.Varuse != nil {
 			mkline.ForEachUsedVarUse(token.Varuse, time, action)
+		}
+	}
+}
 func (mkline *MkLine) ForEachUsedVarUse(varuse *MkVarUse, time VucTime, action func(varUse *MkVarUse, time VucTime)) {
 	varname := varuse.varname
 	if !varuse.IsExpression() {
 		action(varuse, time)
+	}
 	mkline.ForEachUsedText(varname, time, action)
 	for _, mod := range varuse.modifiers {
 		mkline.ForEachUsedText(mod.Text, time, action)
+	}
+}
 // UnquoteShell removes one level of double and single quotes,
 // like in the shell.
 //
 // See ValueFields.
 func (mkline *MkLine) UnquoteShell(str string, warn bool) string {
 	sb := NewLazyStringBuilder(str)
 	lexer := NewMkTokensLexer(mkline.Tokenize(str, false))
 	plain := func() {
 		varUse := lexer.NextVarUse()

 @@ -91,37 +91,56 @@ func (ck *PatchChecker) Check(pkg *Packa
 	CheckLinesTrailingEmptyLines(ck.lines)
 	sha1Before := computePatchSha1Hex(ck.lines)
 	if SaveAutofixChanges(ck.lines) && pkg != nil {
 		linesAfter := Load(ck.lines.Filename, 0)
 		sha1After := computePatchSha1Hex(linesAfter)
 		pkg.AutofixDistinfo(sha1Before, sha1After)
+	}
+}
 // See https://www.gnu.org/software/diffutils/manual/html_node/Detailed-Unified.html
 func (ck *PatchChecker) checkUnifiedDiff(patchedFile Path) {
 	isConfigure := ck.isConfigure(patchedFile)
 	linesDiff := 0
 	hasHunks := false
 	for {
 		m := ck.llex.NextRegexp(rePatchUniHunk)
 		if m == nil {
 			break
+		}
 		text := m[0]
 		hasHunks = true
 		linenoDel := toInt(m[1], 0)
 		linesToDel := toInt(m[2], 1)
 		linenoAdd := toInt(m[3], 0)
 		linesToAdd := toInt(m[4], 1)
 		if linenoDel > 0 && linenoAdd > 0 && linenoDel+linesDiff != linenoAdd {
 			line := ck.llex.PreviousLine()
 			line.Notef("The difference between the line numbers %d and %d should be %d, not %d.",
 				linenoDel, linenoAdd, linesDiff, linenoAdd-linenoDel)
 			line.Explain(
 				"This only happens when patches are edited manually.",
 				"",
 				"To fix this, either regenerate the line numbers by first running",
 				bmake("patch"),
 				"and then \"mkpatches\", or edit the line numbers by hand.",
 				"",
 				"While here, it's a good idea to make the patch apply really cleanly,",
 				"by ensuring that the output from the patch command does not contain",
 				"the word \"offset\", like in \"Hunk #11 succeeded at 2598 (offset 10 lines).")
+		}
 		linesDiff += linesToAdd - linesToDel
 		ck.checktextUniHunkCr()
 		ck.checktextCvsID(text)
 		for !ck.llex.EOF() && (linesToDel > 0 || linesToAdd > 0 || hasPrefix(ck.llex.CurrentLine().Text, "\\")) {
 			line := ck.llex.CurrentLine()
 			ck.llex.Skip()
 			text := line.Text
 			switch {
 			case text == "":
 				// There should be a space here, but that was a trailing space and

 @@ -609,45 +609,69 @@ func (s *Suite) Test_PatchChecker_Check_
 		"@@ -1,1 +1,1 @@",
 		"- prefix := @prefix@",
 		"+ prefix := /usr/pkg")
 	CheckLinesPatch(lines, nil)
 	t.CheckOutputLines(
 		"ERROR: ~/patch-aa:9: Patches must not hard-code the pkgsrc PREFIX.")
+}
 func (s *Suite) Test_PatchChecker_checkUnifiedDiff__lines_at_end(c *check.C) {
 	t := s.Init(c)
-	lines := t.SetUpFileLines("patch-aa",
+	lines := t.NewLines("patch-aa",
 		CvsID,
 		"",
 		"Documentation",
 		"",
 		"--- old",
 		"+++ new",
 		"@@ -1,1 +1,1 @@",
 		"- old",
 		"+ new",
 		"",
 		"This line is not part of the patch. Since it is separated from",
 		"the patch by an empty line, there is no reason for a warning.")
 	CheckLinesPatch(lines, nil)
 	t.CheckOutputEmpty()
+}
 func (s *Suite) Test_PatchChecker_checkUnifiedDiff__line_number_mismatch(c *check.C) {
 	t := s.Init(c)
 	lines := t.NewLines("patch-aa",
 		CvsID,
 		"",
 		"Documentation",
 		"",
 		"--- old",
 		"+++ new",
 		"@@ -2,1 +1,1 @@",
 		"- old",
 		"+ new",
 		"@@ -5,1 +7,1 @@",
 		"- old",
 		"+ new")
 	CheckLinesPatch(lines, nil)
 	t.CheckOutputLines(
 		"NOTE: patch-aa:7: The difference between the line numbers 2 and 1 should be 0, not -1.",
 		"NOTE: patch-aa:10: The difference between the line numbers 5 and 7 should be 0, not 2.")
+}
 func (s *Suite) Test_PatchChecker_checkBeginDiff__multiple_patches_without_documentation(c *check.C) {
 	t := s.Init(c)
 	lines := t.SetUpFileLines("patch-aa",
 		CvsID,
 		"",
 		"--- old",
 		"+++ new",
 		"@@ -1,1 +1,1 @@",
 		"- old",
 		"+ new",
 		"",
 		"--- old",

 @@ -1132,26 +1132,34 @@ func (cv *VartypeCheck) PlistIdentifier(
 			"there should be a corresponding ${PLIST.identifier}",
 			"in any of the PLIST files of the package.")
+	}
+}
 // PrefixPathname checks for a pathname relative to ${PREFIX}.
 func (cv *VartypeCheck) PrefixPathname() {
 	if NewPath(cv.Value).IsAbs() {
 		cv.Errorf("The pathname %q in %s must be relative to ${PREFIX}.",
 			cv.Value, cv.Varname)
 		return
+	}
 	cv.MkLine.ForEachUsedText(cv.Value, VucRunTime, func(varUse *MkVarUse, time VucTime) {
 		varname := varUse.varname
 		if varname == "PKG_SYSCONFDIR" || varname == "VARBASE" {
 			cv.Errorf("%s must not be used in %s since it is not relative to PREFIX.",
 				varname, cv.Varname)
+		}
 	})
 	if m, manSubdir := match1(cv.Value, `^man/(.+)`); m {
 		from := "${PKGMANDIR}/" + manSubdir
 		fix := cv.Autofix()
 		fix.Warnf("Please use %q instead of %q.", from, cv.Value)
 		fix.Replace(cv.Value, from)
 		fix.Apply()
+	}
+}
 func (cv *VartypeCheck) PythonDependency() {
 	if cv.Value != cv.ValueNoVar {
 		cv.Warnf("Python dependencies should not contain variables.")
 	} else if !matches(cv.ValueNoVar, `^[+\-.0-9A-Z_a-z]+(?:|:link|:build|:test|:tool)$`) {

 @@ -1610,26 +1610,36 @@ func (s *Suite) Test_VartypeCheck_Prefix
 	vt := NewVartypeCheckTester(s.Init(c), BtPrefixPathname)
 	vt.Varname("PKGMANDIR")
 	vt.Values(
 		"man/man1",
 		"share/locale",
 		"/absolute")
 	vt.Output(
 		"WARN: filename.mk:1: "+
 			"Please use \"${PKGMANDIR}/man1\" instead of \"man/man1\".",
 		"ERROR: filename.mk:3: The pathname \"/absolute\" in PKGMANDIR "+
 			"must be relative to ${PREFIX}.")
 	vt.Varname("INSTALLATION_DIRS")
 	vt.Values(
 		"bin ${PKG_SYSCONFDIR} ${VARBASE}")
 	vt.Output(
 		"ERROR: filename.mk:11: PKG_SYSCONFDIR must not be used in INSTALLATION_DIRS "+
 			"since it is not relative to PREFIX.",
 		"ERROR: filename.mk:11: VARBASE must not be used in INSTALLATION_DIRS "+
 			"since it is not relative to PREFIX.")
+}
 func (s *Suite) Test_VartypeCheck_PythonDependency(c *check.C) {
 	vt := NewVartypeCheckTester(s.Init(c), BtPythonDependency)
 	vt.Varname("PYTHON_VERSIONED_DEPENDENCIES")
 	vt.Values(
 		"cairo",
 		"${PYDEP}",
 		"cairo,X")
 	vt.Output(
 		"WARN: filename.mk:2: Python dependencies should not contain variables.",