 @@ -1,16 +1,16 @@
-# $NetBSD: Makefile,v 1.580 2019/05/21 17:59:48 rillig Exp $
+# $NetBSD: Makefile,v 1.581 2019/05/22 16:07:16 rillig Exp $
-PKGNAME=	pkglint-5.7.10
+PKGNAME=	pkglint-5.7.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

 @@ -283,28 +283,28 @@ func (pkg *Package) loadPackageMakefile(
 	// TODO: Is this still necessary? This code is 20 years old and was introduced
 	//  when pkglint loaded the package Makefile including all included files into
 	//  a single string. Maybe it makes sense to print the file inclusion hierarchy
 	//  to quickly see files that cannot be included because of unresolved variables.
 	if G.Opts.DumpMakefile {
 		G.Logger.out.WriteLine("Whole Makefile (with all included files) follows:")
 		for _, line := range allLines.lines.Lines {
 			G.Logger.out.WriteLine(line.String())
+		}
+	}
 	// See mk/tools/cmake.mk
 	if pkg.vars.Defined("USE_CMAKE") {
-		mainLines.Tools.def("cmake", "", false, AtRunTime, nil)
+		allLines.Tools.def("cmake", "", false, AtRunTime, nil)
-		mainLines.Tools.def("cpack", "", false, AtRunTime, nil)
+		allLines.Tools.def("cpack", "", false, AtRunTime, nil)
+	}
 	allLines.collectUsedVariables()
 	pkg.Pkgdir = pkg.vars.LastValue("PKGDIR")
 	pkg.DistinfoFile = pkg.vars.LastValue("DISTINFO_FILE")
 	pkg.Filesdir = pkg.vars.LastValue("FILESDIR")
 	pkg.Patchdir = pkg.vars.LastValue("PATCHDIR")
 	// See lang/php/ext.mk
 	if pkg.vars.DefinedSimilar("PHPEXT_MK") {
 		if !pkg.vars.DefinedSimilar("USE_PHP_EXT_PATCHES") {
 			pkg.Patchdir = "patches"
 @@ -590,26 +590,28 @@ func (pkg *Package) checkfilePackageMake
 	if !vars.Defined("COMMENT") {
 		NewLineWhole(filename).Warnf("Each package should define a COMMENT.")
+	}
 	if imake := vars.FirstDefinition("USE_IMAKE"); imake != nil {
 		if x11 := vars.FirstDefinition("USE_X11"); x11 != nil {
 			if !hasSuffix(x11.Filename, "/mk/x11.buildlink3.mk") {
 				imake.Notef("USE_IMAKE makes USE_X11 in %s redundant.", imake.RefTo(x11))
+			}
+		}
+	}
 	pkg.checkUpdate()
 	allLines.collectDefinedVariables() // To get the tool definitions
 	mklines.Tools = allLines.Tools     // TODO: also copy the other collected data
 	mklines.Check()
 	pkg.CheckVarorder(mklines)
 	SaveAutofixChanges(mklines.lines)
+}
 func (pkg *Package) checkGnuConfigureUseLanguages(s *RedundantScope) {
 	gnuConfigure := s.vars["GNU_CONFIGURE"]
 	if gnuConfigure == nil || !gnuConfigure.vari.Constant() {
 		return
+	}
 	useLanguages := s.vars["USE_LANGUAGES"]

 @@ -292,45 +292,60 @@ func (tr *Tools) addAlias(tool *Tool, al
 // parseUseTools interprets a "USE_TOOLS+=" line from a Makefile fragment.
 // It determines the validity of the tool, i.e. in which places it may be used.
 //
 // If createIfAbsent is true and the tools is unknown, it is registered.
 // This can be done only in the pkgsrc infrastructure files, where the
 // actual definition is assumed to be in some other file. In packages
 // though, this assumption cannot be made and pkglint needs to be strict.
 func (tr *Tools) parseUseTools(mkline MkLine, createIfAbsent bool, addToUseTools bool) {
 	value := mkline.Value()
 	if containsVarRef(value) {
 		return
+	}
 	deps := mkline.ValueFields(value)
 	// See mk/tools/autoconf.mk:/^\.if !defined/
 	if matches(value, `\bautoconf213\b`) {
 		deps = append(deps, "autoconf-2.13", "autoheader-2.13", "autoreconf-2.13", "autoscan-2.13", "autoupdate-2.13", "ifnames-2.13")
 	if matches(value, `\bautoconf\b`) {
 		deps = append(deps, "autoheader", "autom4te", "autoreconf", "autoscan", "autoupdate", "ifnames")
 	validity := tr.validity(mkline.Basename, addToUseTools)
-	for _, dep := range deps {
+	for _, dep := range mkline.ValueFields(value) {
 		name := strings.Split(dep, ":")[0]
 		if createIfAbsent || tr.ByName(name) != nil {
 			tr.def(name, "", false, validity, nil)
 			for _, implicitName := range tr.implicitTools(name) {
 				tr.def(implicitName, "", false, validity, nil)
+			}
+		}
+	}
+}
 func (tr *Tools) implicitTools(toolName string) []string {
 	// See mk/tools/autoconf.mk:/^\.if !defined/
 	if toolName == "autoconf213" {
 		return []string{
 			"autoconf-2.13", "autoheader-2.13", "autoreconf-2.13",
 			"autoscan-2.13", "autoupdate-2.13", "ifnames-2.13",
 			"autoconf",
 			"autoheader", "autom4te", "autoreconf",
 			"autoscan", "autoupdate", "ifnames"}
+	}
 	if toolName == "autoconf" {
 		return []string{
 			"autoheader", "autom4te", "autoreconf",
 			"autoscan", "autoupdate", "ifnames"}
+	}
 	return nil
+}
 func (tr *Tools) validity(basename string, useTools bool) Validity {
 	switch {
 	case IsPrefs(basename): // IsPrefs is not 100% accurate here but good enough
 		return AfterPrefsMk
 	case basename == "Makefile" && !tr.SeenPrefs:
 		return AfterPrefsMk
 	case useTools, basename == "bsd.pkg.mk":
 		return AtRunTime
 	default:
 		return Nowhere
+	}
+}

 @@ -596,13 +596,31 @@ func (s *Suite) Test_Tools__gmake(c *che
 		".include \"make.mk\"")
 	t.CreateFileLines("mk/tools/make.mk",
 		"TOOLS_CREATE+=\tmake",
 		"TOOLS_PATH.make=\t/usr/bin/make")
 	t.CreateFileLines("mk/tools/replace.mk",
 		"TOOLS_CREATE+=\tgmake",
 		"TOOLS_PATH.gmake=\t/usr/bin/gnu-make")
 	t.FinishSetUp()
 	G.Check(t.File("category/package"))
 	t.CheckOutputEmpty()
+}
 func (s *Suite) Test_Tools__autoconf213(c *check.C) {
 	t := s.Init(c)
 	t.SetUpPackage("category/package",
 		"USE_TOOLS=\tautoconf213",
 		"",
 		"do-test:",
 		"\tautoconf")
 	t.CreateFileLines("mk/tools/defaults.mk",
 		"_TOOLS_DEPMETHOD.autoconf213=\tDEPENDS")
 	t.FinishSetUp()
 	G.Check(t.File("category/package"))
 	// No warning, since autoconf213 defines autoconf implicitly.
 	t.CheckOutputEmpty()
+}