 @@ -90,26 +90,35 @@ func (fix *Autofix) Replace(from string,
 // ReplaceAfter replaces the text "prefix+from" with "prefix+to", a single time.
 // In the diagnostic, only the replacement of "from" with "to" is mentioned.
 func (fix *Autofix) ReplaceAfter(prefix, from string, to string) {
 	fix.assertRealLine()
 	if fix.skip() {
 		return
+	}
 	for _, rawLine := range fix.line.raw {
 		replaced := strings.Replace(rawLine.textnl, prefix+from, prefix+to, 1)
 		if replaced != rawLine.textnl {
 			if G.Logger.IsAutofix() {
 				rawLine.textnl = replaced
 				// Fix the parsed text as well.
 				// This is only approximate and won't work in some edge cases
 				// that involve escaped comments or replacements across line breaks.
 				//
 				// TODO: Do this properly by parsing the whole line again,
 				//  and ideally everything that depends on the parsed line.
 				//  This probably requires a generic notification mechanism.
 				fix.line.Text = strings.Replace(fix.line.Text, prefix+from, prefix+to, 1)
+			}
 			fix.Describef(rawLine.Lineno, "Replacing %q with %q.", from, to)
 			return
+		}
+	}
+}
 // ReplaceRegex replaces the first howOften or all occurrences (if negative)
 // of the `from` pattern with the fixed string `toText`.
 //
 // Placeholders like `$1` are _not_ expanded in the `toText`.
 // (If you know how to do the expansion correctly, feel free to implement it.)
 func (fix *Autofix) ReplaceRegex(from regex.Pattern, toText string, howOften int) {
 @@ -131,26 +140,45 @@ func (fix *Autofix) ReplaceRegex(from re
 			return toText
+		}
 		replaced := replaceAllFunc(rawLine.textnl, from, replace)
 		if replaced != rawLine.textnl {
 			if G.Logger.IsAutofix() {
 				rawLine.textnl = replaced
+			}
 			for _, fromText := range froms {
 				fix.Describef(rawLine.Lineno, "Replacing %q with %q.", fromText, toText)
+			}
+		}
+	}
 	// Fix the parsed text as well.
 	// This is only approximate and won't work in some edge cases
 	// that involve escaped comments or replacements across line breaks.
 	//
 	// TODO: Do this properly by parsing the whole line again,
 	//  and ideally everything that depends on the parsed line.
 	//  This probably requires a generic notification mechanism.
 	done = 0
 	fix.line.Text = replaceAllFunc(
 		fix.line.Text,
 		from,
 		func(fromText string) string {
 			if howOften >= 0 && done >= howOften {
 				return fromText
+			}
 			done++
 			return toText
 		})
+}
 // Custom runs a custom fix action, unless the fix is skipped anyway
 // because of the --only option.
 //
 // The fixer function must check whether it can actually fix something,
 // and if so, call Describef to describe the actual fix.
 //
 // If showAutofix and autofix are both false, the fix must only be
 // described by calling Describef. No observable modification must be done,
 // not even in memory.
 //
 // If showAutofix is true but autofix is false, the fix should be done in

 @@ -955,26 +955,74 @@ func (s *Suite) Test_Autofix_Apply__sour
 	t.CheckOutputLines(
 		"NOTE: filename:5: This line is quite short.",
 		"AUTOFIX: filename:5: Replacing \"text\" with \"replacement\".",
 		"-\ttext",
 		"+\treplacement",
 		"",
 		"WARN: filename:5: Follow-up warning, separated.",
 		"AUTOFIX: filename:5: Replacing \"replacement\" with \"text again\".",
 		"-\ttext",
 		"+\ttext again")
+}
 // After fixing part of a line, the whole line needs to be parsed again.
 //
 // As of May 2019, this is not done yet.
 func (s *Suite) Test_Autofix_Apply__text_after_replacing_string(c *check.C) {
 	t := s.Init(c)
 	t.SetUpCommandLine("-Wall", "--autofix")
 	mkline := t.NewMkLine("filename.mk", 123, "VAR=\tvalue")
 	fix := mkline.Autofix()
 	fix.Notef("Just a demo.")
 	fix.Replace("value", "new value")
 	fix.Apply()
 	t.CheckOutputLines(
 		"AUTOFIX: filename.mk:123: Replacing \"value\" with \"new value\".")
 	t.Check(mkline.raw[0].textnl, equals, "VAR=\tnew value\n")
 	t.Check(mkline.raw[0].orignl, equals, "VAR=\tvalue\n")
 	t.Check(mkline.Text, equals, "VAR=\tnew value")
 	// FIXME: should be updated as well.
 	t.Check(mkline.Value(), equals, "value")
+}
 // After fixing part of a line, the whole line needs to be parsed again.
 //
 // As of May 2019, this is not done yet.
 func (s *Suite) Test_Autofix_Apply__text_after_replacing_regex(c *check.C) {
 	t := s.Init(c)
 	t.SetUpCommandLine("-Wall", "--autofix")
 	mkline := t.NewMkLine("filename.mk", 123, "VAR=\tvalue")
 	fix := mkline.Autofix()
 	fix.Notef("Just a demo.")
 	fix.ReplaceRegex(`va...`, "new value", -1)
 	fix.Apply()
 	t.CheckOutputLines(
 		"AUTOFIX: filename.mk:123: Replacing \"value\" with \"new value\".")
 	t.Check(mkline.raw[0].textnl, equals, "VAR=\tnew value\n")
 	t.Check(mkline.raw[0].orignl, equals, "VAR=\tvalue\n")
 	t.Check(mkline.Text, equals, "VAR=\tnew value")
 	// FIXME: should be updated as well.
 	t.Check(mkline.Value(), equals, "value")
+}
 func (s *Suite) Test_Autofix_Realign__wrong_line_type(c *check.C) {
 	t := s.Init(c)
 	mklines := t.NewMkLines("file.mk",
 		MkRcsID,
 		".if \\",
 		"${PKGSRC_RUN_TESTS}")
 	mkline := mklines.mklines[1]
 	fix := mkline.Autofix()
 	t.ExpectPanic(
 		func() { fix.Realign(mkline, 16) },

 @@ -1,19 +1,16 @@
 package pkglint
-import (
+import "netbsd.org/pkglint/textproc"
 	"netbsd.org/pkglint/textproc"
 	"strings"
 // SubstContext records the state of a block of variable assignments
 // that make up a SUBST class (see `mk/subst.mk`).
 type SubstContext struct {
 	id            string
 	stage         string
 	message       string
 	curr          *SubstContextStats
 	inAllBranches SubstContextStats
 	filterCmd     string
 	vars          map[string]bool
+}
 @@ -37,26 +34,37 @@ func (st *SubstContextStats) And(other *
 	st.seenFiles = st.seenFiles && other.seenFiles
 	st.seenSed = st.seenSed && other.seenSed
 	st.seenVars = st.seenVars && other.seenVars
 	st.seenTransform = st.seenTransform && other.seenTransform
+}
 func (st *SubstContextStats) Or(other SubstContextStats) {
 	st.seenFiles = st.seenFiles || other.seenFiles
 	st.seenSed = st.seenSed || other.seenSed
 	st.seenVars = st.seenVars || other.seenVars
 	st.seenTransform = st.seenTransform || other.seenTransform
+}
 func (ctx *SubstContext) Process(mkline MkLine) {
 	switch {
 	case mkline.IsEmpty():
 		ctx.Finish(mkline)
 	case mkline.IsVarassign():
 		ctx.Varassign(mkline)
 	case mkline.IsDirective():
 		ctx.Directive(mkline)
+	}
+}
 func (ctx *SubstContext) Varassign(mkline MkLine) {
 	if trace.Tracing {
 		trace.Stepf("SubstContext.Varassign curr=%v all=%v", ctx.curr, ctx.inAllBranches)
+	}
 	varname := mkline.Varname()
 	varcanon := mkline.Varcanon()
 	varparam := mkline.Varparam()
 	op := mkline.Op()
 	value := mkline.Value()
 	if varcanon == "SUBST_CLASSES" || varcanon == "SUBST_CLASSES.*" {
 		classes := mkline.ValueFields(value)
 		if len(classes) > 1 {
 @@ -193,30 +201,27 @@ func (ctx *SubstContext) Directive(mklin
+	}
 	if dir == "if" || dir == "elif" || dir == "else" {
 		ctx.curr = ctx.curr.Copy()
+	}
 	if dir == "endif" {
 		ctx.curr.Or(ctx.inAllBranches)
+	}
 	if trace.Tracing {
 		trace.Stepf("- SubstContext.Directive %v %v", ctx.curr, ctx.inAllBranches)
+	}
+}
 func (ctx *SubstContext) IsComplete() bool {
-	return ctx.id != "" &&
+	return ctx.stage != "" && ctx.curr.seenFiles && ctx.curr.seenTransform
 		ctx.stage != "" &&
 		ctx.curr.seenFiles &&
 		ctx.curr.seenTransform
+}
 func (ctx *SubstContext) Finish(mkline MkLine) {
 	if ctx.id == "" {
 		return
+	}
 	id := ctx.id
 	if ctx.stage == "" {
 		mkline.Warnf("Incomplete SUBST block: SUBST_STAGE.%s missing.", id)
+	}
 	if !ctx.curr.seenFiles {
 		mkline.Warnf("Incomplete SUBST block: SUBST_FILES.%s missing.", id)
 @@ -285,25 +290,21 @@ func (ctx *SubstContext) suggestSubstVar
 		varop := sprintf("SUBST_VARS.%s%s%s",
 			ctx.id,
 			ifelseStr(hasSuffix(ctx.id, "+"), " ", ""),
 			ifelseStr(ctx.curr.seenVars, "+=", "="))
 		fix := mkline.Autofix()
 		fix.Notef("The substitution command %q can be replaced with \"%s %s\".",
 			token, varop, varname)
 		fix.Explain(
 			"Replacing @VAR@ with ${VAR} is such a typical pattern that pkgsrc has built-in support for it,",
 			"requiring only the variable name instead of the full sed command.")
 		if mkline.VarassignComment() == "" && len(tokens) == 2 && tokens[0] == "-e" {
-			// TODO: Extract the alignment computation somewhere else, so that it is generally available.
+			fix.Replace(mkline.Text, alignWith(varop, mkline.ValueAlign())+varname)
 			alignBefore := tabWidth(mkline.ValueAlign())
 			alignAfter := tabWidth(varop + "\t")
 			tabs := strings.Repeat("\t", imax((alignAfter-alignBefore)/8, 0))
 			fix.Replace(mkline.Text, varop+"\t"+tabs+varname)
+		}
 		fix.Anyway()
 		fix.Apply()
 		ctx.curr.seenVars = true
+	}
+}

 @@ -554,31 +554,26 @@ func (s *Suite) Test_MkLine_VariableNeed
 	mklines := t.NewMkLines("x11/mlterm/Makefile",
 		MkRcsID,
 		"SUBST_SED.link=-e 's|(LIBTOOL_LINK).*(LIBS)|& ${LDFLAGS:M*:Q}|g'",
 		"SUBST_SED.link=-e 's|(LIBTOOL_LINK).*(LIBS)|& '${LDFLAGS:M*:Q}'|g'")
 	MkLineChecker{mklines, mklines.mklines[1]}.Check()
 	MkLineChecker{mklines, mklines.mklines[2]}.Check()
 	t.CheckOutputLines(
 		"WARN: x11/mlterm/Makefile:2: Please move ${LDFLAGS:M*:Q} outside of any quoting characters.")
+}
 // No quoting is necessary when lists of options are appended to each other.
 // PKG_OPTIONS are declared as "lkShell" although they are processed
 // using make's .for loop, which splits them at whitespace and usually
 // requires the variable to be declared as "lkSpace".
 // In this case it doesn't matter though since each option is an identifier,
 // and these do not pose any quoting or escaping problems.
 func (s *Suite) Test_MkLine_VariableNeedsQuoting__package_options(c *check.C) {
 	t := s.Init(c)
 	t.SetUpVartypes()
 	mklines := t.NewMkLines("Makefile",
 		MkRcsID,
 		"PKG_SUGGESTED_OPTIONS+=\t${PKG_DEFAULT_OPTIONS:Mcdecimal} ${PKG_OPTIONS.py-trytond:Mcdecimal}")
 	MkLineChecker{mklines, mklines.mklines[1]}.Check()
 	// No warning about a missing :Q modifier.
 	t.CheckOutputEmpty()
+}
 @@ -1149,26 +1144,43 @@ func (s *Suite) Test_MkLine_ValueTokens(
 	test("value # comment",
 		tokens(
 			text("value")))
 	test("value ${UNFINISHED",
 		tokens(
 			text("value "),
 			varUseText("${UNFINISHED", "UNFINISHED")),
 		"WARN: Makefile:1: Missing closing \"}\" for \"UNFINISHED\".")
+}
 func (s *Suite) Test_MkLine_ValueTokens__parse_error(c *check.C) {
 	t := s.Init(c)
 	mkline := t.NewMkLine("filename.mk", 123, "VAR=\t$")
 	tokens, rest := mkline.ValueTokens()
 	t.Check(tokens, check.IsNil)
 	t.Check(rest, equals, "$")
 	// Returns the same values, this time from the cache.
 	tokens, rest = mkline.ValueTokens()
 	t.Check(tokens, check.IsNil)
 	t.Check(rest, equals, "$")
+}
 func (s *Suite) Test_MkLine_ValueTokens__caching(c *check.C) {
 	t := s.Init(c)
 	tokens := func(tokens ...*MkToken) []*MkToken { return tokens }
 	mkline := t.NewMkLine("Makefile", 1, "PATH=\tvalue ${UNFINISHED")
 	valueTokens, rest := mkline.ValueTokens()
 	c.Check(valueTokens, deepEquals,
 		tokens(
 			&MkToken{"value ", nil},
 			&MkToken{"${UNFINISHED", NewMkVarUse("UNFINISHED")}))
 	c.Check(rest, equals, "")

 @@ -214,28 +214,28 @@ func (ck MkLineChecker) checkDirectiveFo
 			} else {
 				mkline.Errorf("Invalid variable name %q.", forvar)
+			}
 			forVars[forvar] = true
+		}
 		// XXX: The type BtUnknown is very unspecific here. For known variables
 		// or constant values this could probably be improved.
 		//
 		// The guessed flag could also be determined more correctly. As of November 2018,
 		// running pkglint over the whole pkgsrc tree did not produce any different result
 		// whether guessed was true or false.
-		forLoopType := Vartype{btForLoop, List, []ACLEntry{{"*", aclpAllRead}}}
+		forLoopType := NewVartype(btForLoop, List, NewACLEntry("*", aclpAllRead))
-		forLoopContext := VarUseContext{&forLoopType, vucTimeParse, VucQuotPlain, false}
+		forLoopContext := VarUseContext{forLoopType, vucTimeParse, VucQuotPlain, false}
 		mkline.ForEachUsed(func(varUse *MkVarUse, time vucTime) {
 			ck.CheckVaruse(varUse, &forLoopContext)
 		})
+	}
+}
 func (ck MkLineChecker) checkDirectiveIndentation(expectedDepth int) {
 	if ck.MkLines == nil || !G.Opts.WarnSpace {
 		return
+	}
 	mkline := ck.MkLine
 	indent := mkline.Indent()
 	if expected := strings.Repeat(" ", expectedDepth); indent != expected {
 @@ -992,27 +992,27 @@ func (ck MkLineChecker) checkVarassignLe
 		ck.MkLine.Warnf("Variable names starting with an underscore (%s) are reserved for internal pkgsrc use.", varname)
+	}
 	ck.checkVarassignLeftNotUsed()
 	ck.checkVarassignLeftDeprecated()
 	ck.checkVarassignLeftBsdPrefs()
 	if !ck.checkVarassignLeftUserSettable() {
 		ck.checkVarassignLeftPermissions()
+	}
 	ck.checkVarassignLeftRationale()
 	ck.checkTextVarUse(
 		ck.MkLine.Varname(),
-		&Vartype{BtVariableName, NoVartypeOptions, []ACLEntry{{"*", aclpAll}}},
+		NewVartype(BtVariableName, NoVartypeOptions, NewACLEntry("*", aclpAll)),
 		vucTimeParse)
+}
 func (ck MkLineChecker) checkVarassignOp() {
 	ck.checkVarassignOpShell()
+}
 func (ck MkLineChecker) checkVarassignOpShell() {
 	mkline := ck.MkLine
 	switch {
 	case mkline.Op() != opAssignShell:
 		return

 @@ -1208,27 +1208,27 @@ func (s *Suite) Test_MkLineChecker_check
 	// Since the variable is usable at load time, pkglint assumes it is also
 	// usable at run time. This is not the case for VAR, but probably doesn't
 	// happen in practice anyway.
 	t.CheckOutputEmpty()
+}
 func (s *Suite) Test_MkLineChecker_checkVarusePermissions__assigned_to_infrastructure_variable(c *check.C) {
 	t := s.Init(c)
 	// This combination of BtUnknown and all permissions is typical for
 	// otherwise unknown variables from the pkgsrc infrastructure.
 	G.Pkgsrc.vartypes.Define("INFRA", BtUnknown, NoVartypeOptions,
-		ACLEntry{"*", aclpAll})
+		NewACLEntry("*", aclpAll))
 	G.Pkgsrc.vartypes.DefineParse("VAR", BtUnknown, NoVartypeOptions,
 		"buildlink3.mk: none",
 		"*: use")
 	mklines := t.NewMkLines("buildlink3.mk",
 		MkRcsID,
 		"INFRA=\t${VAR}")
 	mklines.Check()
 	// Since INFRA is defined in the infrastructure and pkglint
 	// knows nothing else about this variable, it assumes that INFRA
 	// may be used at load time. This is done to prevent wrong warnings.
 	//

 @@ -120,47 +120,44 @@ func (mklines *MkLinesImpl) checkAll() {
 	isHacksMk := mklines.lines.BaseName == "hacks.mk"
 	lineAction := func(mkline MkLine) bool {
 		if isHacksMk {
 			// Needs to be set here because it is reset in MkLines.ForEach.
 			mklines.Tools.SeenPrefs = true
+		}
 		ck := MkLineChecker{mklines, mkline}
 		ck.Check()
 		varalign.Process(mkline)
 		mklines.Tools.ParseToolLine(mklines, mkline, false, false)
 		substContext.Process(mkline)
 		switch {
 		case mkline.IsEmpty():
 			substContext.Finish(mkline)
 		case mkline.IsVarassign():
 			mklines.target = ""
 			mkline.Tokenize(mkline.Value(), true) // Just for the side-effect of the warnings.
 			substContext.Varassign(mkline)
 			mklines.checkVarassignPlist(mkline)
 		case mkline.IsInclude():
 			mklines.target = ""
 			if G.Pkg != nil {
 				G.Pkg.checkIncludeConditionally(mkline, mklines.indentation)
+			}
 		case mkline.IsDirective():
 			ck.checkDirective(mklines.forVars, mklines.indentation)
 			substContext.Directive(mkline)
 		case mkline.IsDependency():
 			ck.checkDependencyRule(allowedTargets)
 			mklines.target = mkline.Targets()
 		case mkline.IsShellCommand():
 			mkline.Tokenize(mkline.ShellCommand(), true) // Just for the side-effect of the warnings.
+		}
 		return true
+	}
 	atEnd := func(mkline MkLine) {

 @@ -524,33 +524,38 @@ func (s *Suite) Test_VartypeCheck_Filena
 	// There's no guarantee that a filename only contains [A-Za-z0-9.].
 	// Therefore there are no useful checks in this situation.
 	vt.Output(
 		"WARN: filename.mk:11: The filename pattern \"Filename with spaces.docx\" " +
 			"contains the invalid characters \"  \".")
+}
 func (s *Suite) Test_VartypeCheck_FileMask(c *check.C) {
 	vt := NewVartypeCheckTester(s.Init(c), (*VartypeCheck).FileMask)
 	vt.Varname("FNAME")
 	vt.Values(
 		"filename.txt",
 		"*.txt",
 		"[12345].txt",
 		"[0-9].txt",
 		"???.txt",
 		"FileMask with spaces.docx",
 		"OS/2-manual.txt")
 	vt.Output(
-		"WARN: filename.mk:1: The filename pattern \"FileMask with spaces.docx\" "+
+		"WARN: filename.mk:6: The filename pattern \"FileMask with spaces.docx\" "+
 			"contains the invalid characters \"  \".",
-		"WARN: filename.mk:2: The filename pattern \"OS/2-manual.txt\" "+
+		"WARN: filename.mk:7: The filename pattern \"OS/2-manual.txt\" "+
 			"contains the invalid character \"/\".")
 	vt.Op(opUseMatch)
 	vt.Values(
 		"FileMask with spaces.docx")
 	// There's no guarantee that a filename only contains [A-Za-z0-9.].
 	// Therefore it might be necessary to allow all characters here.
 	// TODO: Investigate whether this restriction is useful in practice.
 	vt.Output(
 		"WARN: filename.mk:11: The filename pattern \"FileMask with spaces.docx\" " +
 			"contains the invalid characters \"  \".")
+}

 @@ -337,51 +337,51 @@ func (src *Pkgsrc) loadTools() {
 		tools.Trace()
+	}
+}
 // loadUntypedVars scans all pkgsrc infrastructure files in mk/
 // to find variable definitions that are not yet covered in
 // Pkgsrc.InitVartypes.
 //
 // Even if pkglint cannot guess the type of each variable,
 // at least prevent the "used but not defined" warnings.
 func (src *Pkgsrc) loadUntypedVars() {
 	// Setting guessed to false prevents the vartype.guessed case in MkLineChecker.CheckVaruse.
-	unknownType := Vartype{BtUnknown, NoVartypeOptions, []ACLEntry{{"*", aclpAll}}}
+	unknownType := NewVartype(BtUnknown, NoVartypeOptions, NewACLEntry("*", aclpAll))
 	define := func(varcanon string, mkline MkLine) {
 		switch {
 		case src.vartypes.DefinedCanon(varcanon):
 			// Already defined, can also be a tool.
 		case hasPrefix(varcanon, "_"):
 			// Variables starting with an underscore are reserved for the
 			// infrastructure and are not available for use by packages.
 		case contains(varcanon, "$"):
 			// Indirect, but not the usual parameterized form. Variables of
 			// this form should not be unintentionally visible from outside
 			// the infrastructure since they don't follow the pkgsrc naming
 			// conventions.
 		case hasSuffix(varcanon, "_MK"):
 			// Multiple-inclusion guards are internal to the infrastructure.
 		default:
 			if trace.Tracing {
 				trace.Stepf("Untyped variable %q in %s", varcanon, mkline)
+			}
-			src.vartypes.DefineType(varcanon, &unknownType)
+			src.vartypes.DefineType(varcanon, unknownType)
+		}
+	}
 	handleMkFile := func(path string) {
 		mklines := LoadMk(path, 0)
 		if mklines != nil && len(mklines.mklines) > 0 {
 			mklines.collectDefinedVariables()
 			mklines.collectUsedVariables()
 			for varname, mkline := range mklines.vars.firstDef {
 				define(varnameCanon(varname), mkline)
+			}
 			for varname, mkline := range mklines.vars.used {
 				define(varnameCanon(varname), mkline)
 @@ -912,95 +912,104 @@ func (src *Pkgsrc) VariableType(mklines
 	vartype = src.vartypes.Canon(varname)
 	if vartype != nil && vartype.basicType != BtUnknown {
 		return vartype
+	}
 	if tool := G.ToolByVarname(mklines, varname); tool != nil {
 		if trace.Tracing {
 			trace.Stepf("Use of tool %+v", tool)
+		}
 		perms := aclpUse
 		if tool.Validity == AfterPrefsMk && mklines.Tools.SeenPrefs {
 			perms |= aclpUseLoadtime
+		}
-		return &Vartype{BtShellCommand, NoVartypeOptions, []ACLEntry{{"*", perms}}}
+		return NewVartype(BtShellCommand, NoVartypeOptions, NewACLEntry("*", perms))
+	}
 	if m, toolVarname := match1(varname, `^TOOLS_(.*)`); m {
 		if tool := G.ToolByVarname(mklines, toolVarname); tool != nil {
-			return &Vartype{BtPathname, NoVartypeOptions, []ACLEntry{{"*", aclpUse}}}
+			return NewVartype(BtPathname, NoVartypeOptions, NewACLEntry("*", aclpUse))
+		}
+	}
 	return src.guessVariableType(varname)
+}
 // guessVariableType guesses the data type of the variable based on naming conventions.
 func (src *Pkgsrc) guessVariableType(varname string) (vartype *Vartype) {
-	allowAll := []ACLEntry{{"*", aclpAll}}
+	plainType := func(basicType *BasicType, permissions ACLPermissions) *Vartype {
-	allowRuntime := []ACLEntry{{"*", aclpAllRuntime}}
+		gtype := NewVartype(basicType, Guessed, NewACLEntry("*", permissions))
 		trace.Step2("The guessed type of %q is %q.", varname, gtype.String())
 		return gtype
+	}
 	listType := func(basicType *BasicType, permissions ACLPermissions) *Vartype {
 		gtype := NewVartype(basicType, List|Guessed, NewACLEntry("*", permissions))
 		trace.Step2("The guessed type of %q is %q.", varname, gtype.String())
 		return gtype
+	}
 	// Guess the data type of the variable based on naming conventions.
 	varbase := varnameBase(varname)
 	var gtype *Vartype
 	switch {
 	case hasSuffix(varbase, "DIRS"):
-		gtype = &Vartype{BtPathmask, List | Guessed, allowRuntime}
+		return listType(BtPathmask, aclpAllRuntime)
 	case hasSuffix(varbase, "DIR") && !hasSuffix(varbase, "DESTDIR"), hasSuffix(varname, "_HOME"):
 		// TODO: hasSuffix(varbase, "BASE")
-		gtype = &Vartype{BtPathname, Guessed, allowRuntime}
+		return plainType(BtPathname, aclpAllRuntime)
 	case hasSuffix(varbase, "FILES"):
-		gtype = &Vartype{BtPathmask, List | Guessed, allowRuntime}
+		return listType(BtPathmask, aclpAllRuntime)
 	case hasSuffix(varbase, "FILE"):
-		gtype = &Vartype{BtPathname, Guessed, allowRuntime}
+		return plainType(BtPathname, aclpAllRuntime)
 	case hasSuffix(varbase, "PATH"):
-		gtype = &Vartype{BtPathlist, Guessed, allowRuntime}
+		return plainType(BtPathlist, aclpAllRuntime)
 	case hasSuffix(varbase, "PATHS"):
-		gtype = &Vartype{BtPathname, List | Guessed, allowRuntime}
+		return listType(BtPathname, aclpAllRuntime)
 	case hasSuffix(varbase, "_USER"):
-		gtype = &Vartype{BtUserGroupName, Guessed, allowAll}
+		return plainType(BtUserGroupName, aclpAll)
 	case hasSuffix(varbase, "_GROUP"):
-		gtype = &Vartype{BtUserGroupName, Guessed, allowAll}
+		return plainType(BtUserGroupName, aclpAll)
 	case hasSuffix(varbase, "_ENV"):
-		gtype = &Vartype{BtShellWord, List | Guessed, allowRuntime}
+		return listType(BtShellWord, aclpAllRuntime)
 	case hasSuffix(varbase, "_CMD"):
-		gtype = &Vartype{BtShellCommand, Guessed, allowRuntime}
+		return plainType(BtShellCommand, aclpAllRuntime)
 	case hasSuffix(varbase, "_ARGS"):
-		gtype = &Vartype{BtShellWord, List | Guessed, allowRuntime}
+		return listType(BtShellWord, aclpAllRuntime)
 	case hasSuffix(varbase, "_CFLAGS"), hasSuffix(varname, "_CPPFLAGS"), hasSuffix(varname, "_CXXFLAGS"):
-		gtype = &Vartype{BtCFlag, List | Guessed, allowRuntime}
+		return listType(BtCFlag, aclpAllRuntime)
 	case hasSuffix(varname, "_LDFLAGS"):
-		gtype = &Vartype{BtLdFlag, List | Guessed, allowRuntime}
+		return listType(BtLdFlag, aclpAllRuntime)
 	case hasSuffix(varbase, "_MK"):
 		// TODO: Add BtGuard for inclusion guards, since these variables may only be checked using defined().
-		gtype = &Vartype{BtUnknown, Guessed, allowAll}
+		return plainType(BtUnknown, aclpAll)
 	case hasSuffix(varbase, "_SKIP"):
-		gtype = &Vartype{BtPathmask, List | Guessed, allowRuntime}
+		return listType(BtPathmask, aclpAllRuntime)
+	}
-	if gtype == nil {
+	// Variables whose name doesn't match the above patterns may be
-		vartype = src.vartypes.Canon(varname)
+	// looked up from the pkgsrc infrastructure.
-		if vartype != nil {
+	//
-			return vartype
+	// As of May 2019, pkglint only distinguishes plain variables and
 	// list variables, but not "unknown". Therefore the above patterns
 	// must take precedence over this rule, because otherwise, list
 	// variables from the infrastructure would be guessed to be plain
 	// variables.
 	vartype = src.vartypes.Canon(varname)
 	if vartype != nil {
 		return vartype
+	}
 	if trace.Tracing {
-		if gtype != nil {
+		trace.Step1("No type definition found for %q.", varname)
 			trace.Step2("The guessed type of %q is %q.", varname, gtype.String())
 		} else {
 			trace.Step1("No type definition found for %q.", varname)
+	}
-	return gtype
+	return nil
+}
 // Change describes a modification to a single package, from the doc/CHANGES-* files.
 type Change struct {
 	Location Location
 	Action   string
 	Pkgpath  string
 	Version  string
 	Author   string
 	Date     string
+}
 // SuggestedUpdate describes a desired package update, from the doc/TODO file.

 @@ -19,35 +19,39 @@ type RedundantScope struct {
+}
 type redundantScopeVarinfo struct {
 	vari         *Var
 	includePaths []includePath
 	lastAction   uint8 // 0 = none, 1 = read, 2 = write
+}
 func NewRedundantScope() *RedundantScope {
 	return &RedundantScope{vars: make(map[string]*redundantScopeVarinfo)}
+}
 func (s *RedundantScope) Check(mklines MkLines) {
 	mklines.ForEach(func(mkline MkLine) {
-		s.updateIncludePath(mkline)
+		s.checkLine(mklines, mkline)
 	})
+}
-		switch {
+func (s *RedundantScope) checkLine(mklines MkLines, mkline MkLine) {
-		case mkline.IsVarassign():
+	s.updateIncludePath(mkline)
 			s.handleVarassign(mkline, mklines.indentation)
-		s.handleVarUse(mkline)
+	switch {
-	})
+	case mkline.IsVarassign():
 		s.handleVarassign(mkline, mklines.indentation)
+	}
 	s.handleVarUse(mkline)
+}
 func (s *RedundantScope) updateIncludePath(mkline MkLine) {
 	if mkline.firstLine == 1 {
 		s.includePath.push(mkline.Location.Filename)
 	} else {
 		s.includePath.popUntil(mkline.Location.Filename)
+	}
+}
 func (s *RedundantScope) handleVarassign(mkline MkLine, ind *Indentation) {
 	varname := mkline.Varname()
 	info := s.get(varname)

	@@ -25,27 +25,27 @@ type ShellLineChecker struct {		@@ -25,27 +25,27 @@ type ShellLineChecker struct {
25	}	25	}
26		26
27	func NewShellLineChecker(mklines MkLines, mkline MkLine) *ShellLineChecker {	27	func NewShellLineChecker(mklines MkLines, mkline MkLine) *ShellLineChecker {
28	return &ShellLineChecker{mklines, mkline, true}	28	return &ShellLineChecker{mklines, mkline, true}
29	}	29	}
30		30
31	func (ck *ShellLineChecker) Warnf(format string, args ...interface{}) {	31	func (ck *ShellLineChecker) Warnf(format string, args ...interface{}) {
32	ck.mkline.Warnf(format, args...)	32	ck.mkline.Warnf(format, args...)
33	}	33	}
34	func (ck *ShellLineChecker) Explain(explanation ...string) {	34	func (ck *ShellLineChecker) Explain(explanation ...string) {
35	ck.mkline.Explain(explanation...)	35	ck.mkline.Explain(explanation...)
36	}	36	}
37		37
38	var shellCommandsType = &Vartype{BtShellCommands, NoVartypeOptions, []ACLEntry{{"*", aclpAllRuntime}}}	38	var shellCommandsType = NewVartype(BtShellCommands, NoVartypeOptions, NewACLEntry("*", aclpAllRuntime))
39	var shellWordVuc = &VarUseContext{shellCommandsType, vucTimeUnknown, VucQuotPlain, false}	39	var shellWordVuc = &VarUseContext{shellCommandsType, vucTimeUnknown, VucQuotPlain, false}
40		40
41	func (ck *ShellLineChecker) CheckWord(token string, checkQuoting bool, time ToolTime) {	41	func (ck *ShellLineChecker) CheckWord(token string, checkQuoting bool, time ToolTime) {
42	if trace.Tracing {	42	if trace.Tracing {
43	defer trace.Call(token, checkQuoting)()	43	defer trace.Call(token, checkQuoting)()
44	}	44	}
45		45
46	if token == "" \|\| hasPrefix(token, "#") {	46	if token == "" \|\| hasPrefix(token, "#") {
47	return	47	return
48	}	48	}
49		49
50	var line = ck.mkline.Line	50	var line = ck.mkline.Line
51		51
	@@ -638,33 +638,33 @@ func (scc *SimpleCommandChecker) handleC		@@ -638,33 +638,33 @@ func (scc *SimpleCommandChecker) handleC
638	return true	638	return true
639	}	639	}
640		640
641	func (scc *SimpleCommandChecker) checkRegexReplace() {	641	func (scc *SimpleCommandChecker) checkRegexReplace() {
642	if trace.Tracing {	642	if trace.Tracing {
643	defer trace.Call0()()	643	defer trace.Call0()()
644	}	644	}
645		645
646	if !G.Testing {	646	if !G.Testing {
647	return	647	return
648	}	648	}
649		649
650	checkArg := func(arg string) {	650	checkArg := func(arg string) {
651	if matches(arg, `"^[\"\'].*[\"\']$`) {	651	if matches(arg, `^["'].*["']$`) {
652	return	652	return
653	}	653	}
654		654
655	// Substitution commands that consist only of safe characters cannot	655	// Substitution commands that consist only of safe characters cannot
656	// have any side effects, therefore they don't need to be quoted.	656	// have any side effects, therefore they don't need to be quoted.
657	if matches(arg, `^([\w,.]\|\\[.])+$`) {	657	if matches(arg, `^([\w,.]\|\\.)+$`) {
658	return	658	return
659	}	659	}
660		660
661	scc.Warnf("Substitution commands like %q should always be quoted.", arg)	661	scc.Warnf("Substitution commands like %q should always be quoted.", arg)
662	scc.Explain(	662	scc.Explain(
663	"Usually these substitution commands contain characters like '*' or",	663	"Usually these substitution commands contain characters like '*' or",
664	"other shell metacharacters that might lead to lookup of matching",	664	"other shell metacharacters that might lead to lookup of matching",
665	"filenames and then expand to more than one word.")	665	"filenames and then expand to more than one word.")
666	}	666	}
667		667
668	checkArgAfter := func(opt string) {	668	checkArgAfter := func(opt string) {
669	args := scc.strcmd.Args	669	args := scc.strcmd.Args
670	for i, arg := range args {	670	for i, arg := range args {

 @@ -1204,34 +1204,48 @@ func (s *Suite) Test_SimpleCommandChecke
 	test("${PAX} -s s,.*,, src dst",
 		"WARN: Makefile:3: Substitution commands like \"s,.*,,\" should always be quoted.")
 	test("pax -s s,.*,, src dst",
 		"WARN: Makefile:3: Substitution commands like \"s,.*,,\" should always be quoted.")
 	test("${SED} -e s,.*,, src dst",
 		"WARN: Makefile:3: Substitution commands like \"s,.*,,\" should always be quoted.")
 	test("sed -e s,.*,, src dst",
 		"WARN: Makefile:3: Substitution commands like \"s,.*,,\" should always be quoted.")
 	// The * is properly enclosed in quotes.
 	test("sed -e 's,.*,,' -e \"s,-*,,\"",
 		nil...)
 	// The * is properly escaped.
 	test("sed -e s,.\\*,,",
 		nil...)
 	test("pax -s s,\\.orig,, src dst",
 		nil...)
 	test("sed -e s,a,b,g src dst",
 		nil...)
 	// TODO: Merge the code with BtSedCommands.
 	// TODO: Finally, remove the G.Testing from the main code.
 	//  Then, remove this test case.
 	G.Testing = false
 	test("sed -e s,.*,match,",
 		nil...)
 	G.Testing = true
+}
 func (s *Suite) Test_ShellProgramChecker_checkSetE__simple_commands(c *check.C) {
 	t := s.Init(c)
 	t.SetUpTool("echo", "", AtRunTime)
 	t.SetUpTool("rm", "", AtRunTime)
 	t.SetUpTool("touch", "", AtRunTime)
 	mklines := t.NewMkLines("Makefile",
 		MkRcsID,
 		"pre-configure:",
 		"\techo 1; echo 2; echo 3",
 		"\techo 1; touch file; rm file",

 @@ -1,276 +1,401 @@
 package pkglint
 import (
 	"fmt"
 	"gopkg.in/check.v1"
+)
 func (s *Suite) Test_SubstContext__incomplete(c *check.C) {
 	t := s.Init(c)
 	t.SetUpCommandLine("-Wextra")
 	ctx := NewSubstContext()
-	ctx.Varassign(newSubstLine(t, 10, "PKGNAME=pkgname-1.0"))
+	ctx.Varassign(t.NewMkLine("Makefile", 10, "PKGNAME=pkgname-1.0"))
 	c.Check(ctx.id, equals, "")
-	ctx.Varassign(newSubstLine(t, 11, "SUBST_CLASSES+=interp"))
+	ctx.Varassign(t.NewMkLine("Makefile", 11, "SUBST_CLASSES+=interp"))
 	c.Check(ctx.id, equals, "interp")
-	ctx.Varassign(newSubstLine(t, 12, "SUBST_FILES.interp=Makefile"))
+	ctx.Varassign(t.NewMkLine("Makefile", 12, "SUBST_FILES.interp=Makefile"))
 	c.Check(ctx.IsComplete(), equals, false)
-	ctx.Varassign(newSubstLine(t, 13, "SUBST_SED.interp=s,@PREFIX@,${PREFIX},g"))
+	ctx.Varassign(t.NewMkLine("Makefile", 13, "SUBST_SED.interp=s,@PREFIX@,${PREFIX},g"))
 	c.Check(ctx.IsComplete(), equals, false)
-	ctx.Finish(newSubstLine(t, 14, ""))
+	ctx.Finish(t.NewMkLine("Makefile", 14, ""))
 	t.CheckOutputLines(
 		"NOTE: Makefile:13: The substitution command \"s,@PREFIX@,${PREFIX},g\" "+
 			"can be replaced with \"SUBST_VARS.interp= PREFIX\".",
 		"WARN: Makefile:14: Incomplete SUBST block: SUBST_STAGE.interp missing.")
+}
 func (s *Suite) Test_SubstContext__complete(c *check.C) {
 	t := s.Init(c)
 	t.SetUpCommandLine("-Wextra")
 	ctx := NewSubstContext()
-	ctx.Varassign(newSubstLine(t, 10, "PKGNAME=pkgname-1.0"))
+	ctx.Varassign(t.NewMkLine("Makefile", 10, "PKGNAME=pkgname-1.0"))
-	ctx.Varassign(newSubstLine(t, 11, "SUBST_CLASSES+=p"))
+	ctx.Varassign(t.NewMkLine("Makefile", 11, "SUBST_CLASSES+=p"))
-	ctx.Varassign(newSubstLine(t, 12, "SUBST_FILES.p=Makefile"))
+	ctx.Varassign(t.NewMkLine("Makefile", 12, "SUBST_FILES.p=Makefile"))
-	ctx.Varassign(newSubstLine(t, 13, "SUBST_SED.p=s,@PREFIX@,${PREFIX},g"))
+	ctx.Varassign(t.NewMkLine("Makefile", 13, "SUBST_SED.p=s,@PREFIX@,${PREFIX},g"))
 	c.Check(ctx.IsComplete(), equals, false)
-	ctx.Varassign(newSubstLine(t, 14, "SUBST_STAGE.p=post-configure"))
+	ctx.Varassign(t.NewMkLine("Makefile", 14, "SUBST_STAGE.p=post-configure"))
 	c.Check(ctx.IsComplete(), equals, true)
-	ctx.Finish(newSubstLine(t, 15, ""))
+	ctx.Finish(t.NewMkLine("Makefile", 15, ""))
 	t.CheckOutputLines(
 		"NOTE: Makefile:13: The substitution command \"s,@PREFIX@,${PREFIX},g\" " +
 			"can be replaced with \"SUBST_VARS.p= PREFIX\".")
+}
 func (s *Suite) Test_SubstContext__OPSYSVARS(c *check.C) {
 	t := s.Init(c)
 	G.Opts.WarnExtra = true
 	ctx := NewSubstContext()
 	// SUBST_CLASSES is added to OPSYSVARS in mk/bsd.pkg.mk.
-	ctx.Varassign(newSubstLine(t, 11, "SUBST_CLASSES.SunOS+=prefix"))
+	ctx.Varassign(t.NewMkLine("Makefile", 11, "SUBST_CLASSES.SunOS+=prefix"))
-	ctx.Varassign(newSubstLine(t, 12, "SUBST_CLASSES.NetBSD+=prefix"))
+	ctx.Varassign(t.NewMkLine("Makefile", 12, "SUBST_CLASSES.NetBSD+=prefix"))
-	ctx.Varassign(newSubstLine(t, 13, "SUBST_FILES.prefix=Makefile"))
+	ctx.Varassign(t.NewMkLine("Makefile", 13, "SUBST_FILES.prefix=Makefile"))
-	ctx.Varassign(newSubstLine(t, 14, "SUBST_SED.prefix=s,@PREFIX@,${PREFIX},g"))
+	ctx.Varassign(t.NewMkLine("Makefile", 14, "SUBST_SED.prefix=s,@PREFIX@,${PREFIX},g"))
-	ctx.Varassign(newSubstLine(t, 15, "SUBST_STAGE.prefix=post-configure"))
+	ctx.Varassign(t.NewMkLine("Makefile", 15, "SUBST_STAGE.prefix=post-configure"))
 	c.Check(ctx.IsComplete(), equals, true)
-	ctx.Finish(newSubstLine(t, 15, ""))
+	ctx.Finish(t.NewMkLine("Makefile", 15, ""))
 	t.CheckOutputLines(
 		"NOTE: Makefile:14: The substitution command \"s,@PREFIX@,${PREFIX},g\" " +
 			"can be replaced with \"SUBST_VARS.prefix= PREFIX\".")
+}
 func (s *Suite) Test_SubstContext__no_class(c *check.C) {
 	t := s.Init(c)
 	t.SetUpCommandLine("-Wextra")
 	ctx := NewSubstContext()
-	ctx.Varassign(newSubstLine(t, 10, "UNRELATED=anything"))
+	ctx.Varassign(t.NewMkLine("Makefile", 10, "UNRELATED=anything"))
-	ctx.Varassign(newSubstLine(t, 11, "SUBST_FILES.repl+=Makefile.in"))
+	ctx.Varassign(t.NewMkLine("Makefile", 11, "SUBST_FILES.repl+=Makefile.in"))
-	ctx.Varassign(newSubstLine(t, 12, "SUBST_SED.repl+=-e s,from,to,g"))
+	ctx.Varassign(t.NewMkLine("Makefile", 12, "SUBST_SED.repl+=-e s,from,to,g"))
-	ctx.Finish(newSubstLine(t, 13, ""))
+	ctx.Finish(t.NewMkLine("Makefile", 13, ""))
 	t.CheckOutputLines(
 		"WARN: Makefile:11: SUBST_CLASSES should come before the definition of \"SUBST_FILES.repl\".",
 		"WARN: Makefile:13: Incomplete SUBST block: SUBST_STAGE.repl missing.")
+}
 func (s *Suite) Test_SubstContext__multiple_classes_in_one_line(c *check.C) {
 	t := s.Init(c)
 	t.SetUpCommandLine("-Wextra")
 	simulateSubstLines(t,
 		"10: SUBST_CLASSES+=         one two",
 		"11: SUBST_STAGE.one=        post-configure",
 		"12: SUBST_FILES.one=        one.txt",
 		"13: SUBST_SED.one=          s,one,1,g",
 		"14: SUBST_STAGE.two=        post-configure",
-		"15: SUBST_FILES.two=        two.txt",
+		"15: SUBST_FILES.two=        two.txt")
 		"17: ")
 	t.CheckOutputLines(
 		"WARN: Makefile:10: Please add only one class at a time to SUBST_CLASSES.",
-		"WARN: Makefile:17: Incomplete SUBST block: SUBST_SED.two, SUBST_VARS.two or SUBST_FILTER_CMD.two missing.")
+		"WARN: Makefile:16: Incomplete SUBST block: SUBST_SED.two, SUBST_VARS.two or SUBST_FILTER_CMD.two missing.")
+}
 func (s *Suite) Test_SubstContext__multiple_classes_in_one_block(c *check.C) {
 	t := s.Init(c)
 	t.SetUpCommandLine("-Wextra")
 	simulateSubstLines(t,
 		"10: SUBST_CLASSES+=         one",
 		"11: SUBST_STAGE.one=        post-configure",
 		"12: SUBST_STAGE.one=        post-configure",
 		"13: SUBST_FILES.one=        one.txt",
 		"14: SUBST_CLASSES+=         two", // The block "one" is not finished yet.
 		"15: SUBST_SED.one=          s,one,1,g",
 		"16: SUBST_STAGE.two=        post-configure",
 		"17: SUBST_FILES.two=        two.txt",
-		"18: SUBST_SED.two=          s,two,2,g",
+		"18: SUBST_SED.two=          s,two,2,g")
 		"19: ")
 	t.CheckOutputLines(
 		"WARN: Makefile:12: Duplicate definition of \"SUBST_STAGE.one\".",
 		"WARN: Makefile:14: Incomplete SUBST block: SUBST_SED.one, SUBST_VARS.one or SUBST_FILTER_CMD.one missing.",
 		"WARN: Makefile:14: Subst block \"one\" should be finished before adding the next class to SUBST_CLASSES.",
 		"WARN: Makefile:15: Variable \"SUBST_SED.one\" does not match SUBST class \"two\".")
+}
 func (s *Suite) Test_SubstContext__files_missing(c *check.C) {
 	t := s.Init(c)
 	simulateSubstLines(t,
 		"10: SUBST_CLASSES+=         one",
 		"11: SUBST_STAGE.one=        pre-configure",
 		"12: SUBST_CLASSES+=         two",
 		"13: SUBST_STAGE.two=        pre-configure",
 		"14: SUBST_FILES.two=        two.txt",
 		"15: SUBST_SED.two=          s,two,2,g")
 	t.CheckOutputLines(
 		"WARN: Makefile:12: Incomplete SUBST block: SUBST_FILES.one missing.",
 		"WARN: Makefile:12: Incomplete SUBST block: "+
 			"SUBST_SED.one, SUBST_VARS.one or SUBST_FILTER_CMD.one missing.",
 		"WARN: Makefile:12: Subst block \"one\" should be finished "+
 			"before adding the next class to SUBST_CLASSES.")
+}
 func (s *Suite) Test_SubstContext__directives(c *check.C) {
 	t := s.Init(c)
 	t.SetUpCommandLine("-Wextra")
 	simulateSubstLines(t,
 		"10: SUBST_CLASSES+=         os",
 		"11: SUBST_STAGE.os=         post-configure",
 		"12: SUBST_MESSAGE.os=       Guessing operating system",
 		"13: SUBST_FILES.os=         guess-os.h",
 		"14: .if ${OPSYS} == NetBSD",
 		"15: SUBST_FILTER_CMD.os=    ${SED} -e s,@OPSYS@,NetBSD,",
 		"16: .elif ${OPSYS} == Darwin",
 		"17: SUBST_SED.os=           -e s,@OPSYS@,Darwin1,",
 		"18: SUBST_SED.os=           -e s,@OPSYS@,Darwin2,",
 		"19: .elif ${OPSYS} == Linux",
-		"18: SUBST_SED.os=           -e s,@OPSYS@,Linux,",
+		"20: SUBST_SED.os=           -e s,@OPSYS@,Linux,",
-		"19: .else",
+		"21: .else",
-		"20: SUBST_VARS.os=           OPSYS",
+		"22: SUBST_VARS.os=           OPSYS",
-		"21: .endif",
+		"23: .endif")
 		"22: ")
 	// All the other lines are correctly determined as being alternatives
 	// to each other. And since every branch contains some transformation
 	// (SED, VARS, FILTER_CMD), everything is fine.
 	t.CheckOutputLines(
 		"WARN: Makefile:18: All but the first \"SUBST_SED.os\" lines should use the \"+=\" operator.")
+}
 func (s *Suite) Test_SubstContext__directives_around_everything_then(c *check.C) {
 	t := s.Init(c)
 	t.SetUpCommandLine("-Wextra")
 	simulateSubstLines(t,
 		"10: SUBST_CLASSES+=         os",
 		"11: .if ${OPSYS} == NetBSD",
 		"12: SUBST_VARS.os=          OPSYS",
 		"13: SUBST_SED.os=           -e s,@OPSYS@,NetBSD,",
 		"14: SUBST_STAGE.os=         post-configure",
 		"15: SUBST_MESSAGE.os=       Guessing operating system",
 		"16: SUBST_FILES.os=         guess-os.h",
 		"17: .endif")
 	// TODO: The SUBST variables are not guaranteed to be defined in all cases.
 	t.CheckOutputEmpty()
+}
 func (s *Suite) Test_SubstContext__directives_around_everything_else(c *check.C) {
 	t := s.Init(c)
 	t.SetUpCommandLine("-Wextra")
 	simulateSubstLines(t,
 		"10: SUBST_CLASSES+=         os",
 		"11: .if ${OPSYS} == NetBSD",
 		"12: .else",
 		"13: SUBST_VARS.os=          OPSYS",
 		"14: SUBST_SED.os=           -e s,@OPSYS@,NetBSD,",
 		"15: SUBST_STAGE.os=         post-configure",
 		"16: SUBST_MESSAGE.os=       Guessing operating system",
 		"17: SUBST_FILES.os=         guess-os.h",
 		"18: .endif")
 	// FIXME: The warnings must be the same as in the "then" test case.
 	t.CheckOutputLines(
 		"WARN: Makefile:19: Incomplete SUBST block: SUBST_FILES.os missing.",
 		"WARN: Makefile:19: Incomplete SUBST block: SUBST_SED.os, SUBST_VARS.os or "+
 			"SUBST_FILTER_CMD.os missing.")
+}
 func (s *Suite) Test_SubstContext__empty_directive(c *check.C) {
 	t := s.Init(c)
 	t.SetUpCommandLine("-Wextra")
 	simulateSubstLines(t,
 		"10: SUBST_CLASSES+=         os",
 		"11: SUBST_VARS.os=          OPSYS",
 		"12: SUBST_SED.os=           -e s,@OPSYS@,NetBSD,",
 		"13: SUBST_STAGE.os=         post-configure",
 		"14: SUBST_MESSAGE.os=       Guessing operating system",
 		"15: SUBST_FILES.os=         guess-os.h",
 		"16: .if ${OPSYS} == NetBSD",
 		"17: .else",
 		"18: .endif")
 	t.CheckOutputEmpty()
+}
 func (s *Suite) Test_SubstContext__missing_transformation_in_one_branch(c *check.C) {
 	t := s.Init(c)
 	t.SetUpCommandLine("-Wextra")
 	simulateSubstLines(t,
 		"10: SUBST_CLASSES+=         os",
 		"11: SUBST_STAGE.os=         post-configure",
 		"12: SUBST_MESSAGE.os=       Guessing operating system",
 		"13: SUBST_FILES.os=         guess-os.h",
 		"14: .if ${OPSYS} == NetBSD",
 		"15: SUBST_FILES.os=         -e s,@OpSYS@,NetBSD,", // A simple typo, this should be SUBST_SED.
 		"16: .elif ${OPSYS} == Darwin",
 		"17: SUBST_SED.os=           -e s,@OPSYS@,Darwin1,",
 		"18: SUBST_SED.os=           -e s,@OPSYS@,Darwin2,",
 		"19: .else",
 		"20: SUBST_VARS.os=           OPSYS",
-		"21: .endif",
+		"21: .endif")
 		"22: ")
 	t.CheckOutputLines(
 		"WARN: Makefile:15: All but the first \"SUBST_FILES.os\" lines should use the \"+=\" operator.",
 		"WARN: Makefile:18: All but the first \"SUBST_SED.os\" lines should use the \"+=\" operator.",
 		"WARN: Makefile:22: Incomplete SUBST block: SUBST_SED.os, SUBST_VARS.os or SUBST_FILTER_CMD.os missing.")
+}
 func (s *Suite) Test_SubstContext__nested_conditionals(c *check.C) {
 	t := s.Init(c)
 	t.SetUpCommandLine("-Wextra")
 	simulateSubstLines(t,
 		"10: SUBST_CLASSES+=         os",
 		"11: SUBST_STAGE.os=         post-configure",
 		"12: SUBST_MESSAGE.os=       Guessing operating system",
-		"14: .if ${OPSYS} == NetBSD",
+		"13: .if ${OPSYS} == NetBSD",
-		"13: SUBST_FILES.os=         guess-netbsd.h",
+		"14: SUBST_FILES.os=         guess-netbsd.h",
 		"15: .  if ${ARCH} == i386",
 		"16: SUBST_FILTER_CMD.os=    ${SED} -e s,@OPSYS,NetBSD-i386,",
 		"17: .  elif ${ARCH} == x86_64",
 		"18: SUBST_VARS.os=          OPSYS",
 		"19: .  else",
 		"20: SUBST_SED.os=           -e s,@OPSYS,NetBSD-unknown",
 		"21: .  endif",
 		"22: .else",
 		"23: SUBST_SED.os=           -e s,@OPSYS@,unknown,",
-		"24: .endif",
+		"24: .endif")
 		"25: ")
 	// The branch in line 23 omits SUBST_FILES.
 	t.CheckOutputLines(
 		"WARN: Makefile:25: Incomplete SUBST block: SUBST_FILES.os missing.")
+}
 func (s *Suite) Test_SubstContext__pre_patch(c *check.C) {
 	t := s.Init(c)
 	t.SetUpCommandLine("-Wextra,no-space", "--show-autofix")
 	t.SetUpVartypes()
 	mklines := t.NewMkLines("os.mk",
 		MkRcsID,
 		"",
 		"SUBST_CLASSES+=         os",
 		"SUBST_STAGE.os=         pre-patch",
 		"SUBST_FILES.os=         guess-os.h",
 		"SUBST_SED.os=           -e s,@OPSYS@,Darwin,")
 	mklines.Check()
 	t.CheckOutputLines(
 		"WARN: os.mk:4: Substitutions should not happen in the patch phase.",
 		"AUTOFIX: os.mk:4: Replacing \"pre-patch\" with \"post-extract\".")
+}
 func (s *Suite) Test_SubstContext__post_patch(c *check.C) {
 	t := s.Init(c)
 	t.SetUpCommandLine("-Wextra,no-space", "--show-autofix")
 	t.SetUpVartypes()
 	mklines := t.NewMkLines("os.mk",
 		MkRcsID,
 		"",
 		"SUBST_CLASSES+=         os",
 		"SUBST_STAGE.os=         post-patch",
 		"SUBST_FILES.os=         guess-os.h",
 		"SUBST_SED.os=           -e s,@OPSYS@,Darwin,")
 	mklines.Check()
 	t.CheckOutputLines(
 		"WARN: os.mk:4: Substitutions should not happen in the patch phase.",
 		"AUTOFIX: os.mk:4: Replacing \"post-patch\" with \"pre-configure\".")
+}
-func (s *Suite) Test_SubstContext__pre_configure_with_NO_CONFIGURE(c *check.C) {
+func (s *Suite) Test_SubstContext__with_NO_CONFIGURE(c *check.C) {
 	t := s.Init(c)
 	t.SetUpCommandLine("-Wall,no-space")
 	pkg := t.SetUpPackage("category/package",
-		"SUBST_CLASSES+=         os",
+		"SUBST_CLASSES+=         pre",
-		"SUBST_STAGE.os=         pre-configure",
+		"SUBST_STAGE.pre=        pre-configure",
-		"SUBST_FILES.os=         guess-os.h",
+		"SUBST_FILES.pre=        guess-os.h",
-		"SUBST_SED.os=           -e s,@OPSYS@,Darwin,",
+		"SUBST_SED.pre=          -e s,@OPSYS@,Darwin,",
 		"",
 		"SUBST_CLASSES+=         post",
 		"SUBST_STAGE.post=       post-configure",
 		"SUBST_FILES.post=       guess-os.h",
 		"SUBST_SED.post=         -e s,@OPSYS@,Darwin,",
 		"",
 		"SUBST_CLASSES+=         e",
 		"SUBST_STAGE.e=          post-extract",
 		"SUBST_FILES.e=          guess-os.h",
 		"SUBST_SED.e=            -e s,@OPSYS@,Darwin,",
 		"",
 		"NO_CONFIGURE=           yes")
 	t.FinishSetUp()
 	G.Check(pkg)
 	t.CheckOutputLines(
-		"WARN: ~/category/package/Makefile:21: SUBST_STAGE pre-configure has no effect when NO_CONFIGURE is set (in line 25).")
+		"WARN: ~/category/package/Makefile:21: SUBST_STAGE pre-configure has no effect "+
 			"when NO_CONFIGURE is set (in line 35).",
 		"WARN: ~/category/package/Makefile:26: SUBST_STAGE post-configure has no effect "+
 			"when NO_CONFIGURE is set (in line 35).")
+}
 func (s *Suite) Test_SubstContext__without_NO_CONFIGURE(c *check.C) {
 	t := s.Init(c)
 	t.SetUpCommandLine("-Wall,no-space")
 	pkg := t.SetUpPackage("category/package",
 		"SUBST_CLASSES+=         pre",
 		"SUBST_STAGE.pre=        pre-configure",
 		"SUBST_FILES.pre=        guess-os.h",
 		"SUBST_SED.pre=          -e s,@OPSYS@,Darwin,")
 	t.FinishSetUp()
 	G.Check(pkg)
 	t.CheckOutputEmpty()
+}
 func (s *Suite) Test_SubstContext__adjacent(c *check.C) {
 	t := s.Init(c)
 	t.SetUpCommandLine("-Wextra")
 	t.SetUpVartypes()
 	mklines := t.NewMkLines("os.mk",
 		MkRcsID,
 		"",
 		"SUBST_CLASSES+=         1",
 		"SUBST_STAGE.1=          pre-configure",
 @@ -349,26 +474,71 @@ func (s *Suite) Test_SubstContext__SUBST
 		"SUBST_STAGE.os=         pre-configure",
 		"SUBST_FILES.os=         guess-os.h",
 		"SUBST_VARS.os=          TODAY1",
 		"",
 		"TODAY1!=                date",
 		"TODAY2!=                date")
 	mklines.Check()
 	t.CheckOutputLines(
 		"WARN: os.mk:9: TODAY2 is defined but not used.")
+}
 func (s *Suite) Test_SubstContext__multiple_SUBST_VARS(c *check.C) {
 	t := s.Init(c)
 	t.SetUpCommandLine("-Wextra,no-space")
 	t.SetUpVartypes()
 	mklines := t.NewMkLines("os.mk",
 		MkRcsID,
 		"",
 		"SUBST_CLASSES+=         os",
 		"SUBST_STAGE.os=         pre-configure",
 		"SUBST_FILES.os=         guess-os.h",
 		"SUBST_VARS.os=          PREFIX VARBASE")
 	mklines.Check()
 	t.CheckOutputEmpty()
+}
 // Since the SUBST_CLASSES definition starts the SUBST block, all
 // directives above it are ignored by the SUBST context.
 func (s *Suite) Test_SubstContext_Directive__before_SUBST_CLASSES(c *check.C) {
 	t := s.Init(c)
 	t.SetUpCommandLine("-Wextra,no-space")
 	t.SetUpVartypes()
 	t.DisableTracing() // Just for branch coverage.
 	mklines := t.NewMkLines("os.mk",
 		MkRcsID,
 		"",
 		".if 0",
 		".endif",
 		"SUBST_CLASSES+=         os",
 		".elif 0") // Just for branch coverage.
 	mklines.Check()
 	t.CheckOutputLines(
 		"WARN: os.mk:EOF: Incomplete SUBST block: SUBST_STAGE.os missing.",
 		"WARN: os.mk:EOF: Incomplete SUBST block: SUBST_FILES.os missing.",
 		"WARN: os.mk:EOF: Incomplete SUBST block: "+
 			"SUBST_SED.os, SUBST_VARS.os or SUBST_FILTER_CMD.os missing.")
+}
 func (s *Suite) Test_SubstContext_suggestSubstVars(c *check.C) {
 	t := s.Init(c)
 	t.SetUpVartypes()
 	t.SetUpTool("sh", "SH", AtRunTime)
 	mklines := t.NewMkLines("subst.mk",
 		MkRcsID,
 		"",
 		"SUBST_CLASSES+=\t\ttest",
 		"SUBST_STAGE.test=\tpre-configure",
 		"SUBST_FILES.test=\tfilename",
 		"SUBST_SED.test+=\t-e s,@SH@,${SH},g",            // Can be replaced.
 @@ -472,38 +642,219 @@ func (s *Suite) Test_SubstContext_sugges
 	mklines.Check()
 	t.CheckOutputLines(
 		"NOTE: subst.mk:6: The substitution command \"s,@SH@,${SH:Q},g\" "+
 			"can be replaced with \"SUBST_VARS.gtk+ = SH\".",
 		"AUTOFIX: subst.mk:6: Replacing \"SUBST_SED.gtk+ +=\\t-e s,@SH@,${SH:Q},g\" "+
 			"with \"SUBST_VARS.gtk+ =\\tSH\".",
 		"NOTE: subst.mk:7: The substitution command \"s,@SH@,${SH:Q},g\" "+
 			"can be replaced with \"SUBST_VARS.gtk+ += SH\".",
 		"AUTOFIX: subst.mk:7: Replacing \"SUBST_SED.gtk+ +=\\t-e s,@SH@,${SH:Q},g\" "+
 			"with \"SUBST_VARS.gtk+ +=\\tSH\".")
+}
 // The last of the SUBST_SED variables is 15 characters wide. When SUBST_SED
 // is replaced with SUBST_VARS, this becomes 16 characters and therefore
 // requires the whole paragraph to be indented by one more tab.
 func (s *Suite) Test_SubstContext_suggestSubstVars__autofix_realign_paragraph(c *check.C) {
 	t := s.Init(c)
 	t.SetUpVartypes()
 	t.Chdir(".")
 	mklines := t.SetUpFileMkLines("subst.mk",
 		MkRcsID,
 		"",
 		"SUBST_CLASSES+=\t\tpfx",
 		"SUBST_STAGE.pfx=\tpre-configure",
 		"SUBST_FILES.pfx=\tfilename",
 		"SUBST_SED.pfx=\t\t-e s,@PREFIX@,${PREFIX},g",
 		"SUBST_SED.pfx+=\t\t-e s,@PREFIX@,${PREFIX},g")
 	mklines.Check()
 	t.CheckOutputLines(
 		"NOTE: subst.mk:6: The substitution command \"s,@PREFIX@,${PREFIX},g\" "+
 			"can be replaced with \"SUBST_VARS.pfx= PREFIX\".",
 		"NOTE: subst.mk:7: The substitution command \"s,@PREFIX@,${PREFIX},g\" "+
 			"can be replaced with \"SUBST_VARS.pfx+= PREFIX\".")
 	t.SetUpCommandLine("--autofix")
 	mklines.Check()
 	t.CheckOutputLines(
 		"AUTOFIX: subst.mk:6: Replacing \"SUBST_SED.pfx=\\t\\t-e s,@PREFIX@,${PREFIX},g\" "+
 			"with \"SUBST_VARS.pfx=\\t\\tPREFIX\".",
 		"AUTOFIX: subst.mk:7: Replacing \"SUBST_SED.pfx+=\\t\\t-e s,@PREFIX@,${PREFIX},g\" "+
 			"with \"SUBST_VARS.pfx+=\\tPREFIX\".")
 	t.CheckFileLinesDetab("subst.mk",
 		"# $NetBSD: substcontext_test.go,v 1.25 2019/05/26 14:05:57 rillig Exp $",
 		"",
 		"SUBST_CLASSES+=         pfx",
 		"SUBST_STAGE.pfx=        pre-configure",
 		"SUBST_FILES.pfx=        filename",
 		"SUBST_VARS.pfx=         PREFIX",
 		"SUBST_VARS.pfx+=        PREFIX")
+}
 func (s *Suite) Test_SubstContext_suggestSubstVars__autofix_plus_sed(c *check.C) {
 	t := s.Init(c)
 	t.SetUpVartypes()
 	t.Chdir(".")
 	mklines := t.SetUpFileMkLines("subst.mk",
 		MkRcsID,
 		"",
 		"SUBST_CLASSES+=\t\tpfx",
 		"SUBST_STAGE.pfx=\tpre-configure",
 		"SUBST_FILES.pfx=\tfilename",
 		"SUBST_SED.pfx=\t\t-e s,@PREFIX@,${PREFIX},g",
 		"SUBST_SED.pfx+=\t\t-e s,@PREFIX@,other,g")
 	mklines.Check()
 	t.CheckOutputLines(
 		"NOTE: subst.mk:6: The substitution command \"s,@PREFIX@,${PREFIX},g\" " +
 			"can be replaced with \"SUBST_VARS.pfx= PREFIX\".")
 	t.SetUpCommandLine("-Wall", "--autofix")
 	mklines.Check()
 	t.CheckOutputLines(
 		"AUTOFIX: subst.mk:6: Replacing \"SUBST_SED.pfx=\\t\\t-e s,@PREFIX@,${PREFIX},g\" " +
 			"with \"SUBST_VARS.pfx=\\t\\tPREFIX\".")
 	t.CheckFileLinesDetab("subst.mk",
 		"# $NetBSD: substcontext_test.go,v 1.25 2019/05/26 14:05:57 rillig Exp $",
 		"",
 		"SUBST_CLASSES+=         pfx",
 		"SUBST_STAGE.pfx=        pre-configure",
 		"SUBST_FILES.pfx=        filename",
 		"SUBST_VARS.pfx=         PREFIX",
 		// TODO: If this subst class is used nowhere else, pkglint could
 		//  replace this += with a simple =.
 		"SUBST_SED.pfx+=         -e s,@PREFIX@,other,g")
+}
 func (s *Suite) Test_SubstContext_suggestSubstVars__autofix_plus_vars(c *check.C) {
 	t := s.Init(c)
 	t.SetUpCommandLine("-Wall", "--autofix")
 	t.SetUpVartypes()
 	t.Chdir(".")
 	mklines := t.SetUpFileMkLines("subst.mk",
 		MkRcsID,
 		"",
 		"SUBST_CLASSES+=\tid",
 		"SUBST_STAGE.id=\tpre-configure",
 		"SUBST_FILES.id=\tfilename",
 		"SUBST_SED.id=\t-e s,@PREFIX@,${PREFIX},g",
 		"SUBST_VARS.id=\tPKGMANDIR")
 	mklines.Check()
 	t.CheckOutputLines(
 		"AUTOFIX: subst.mk:6: Replacing \"SUBST_SED.id=\\t-e s,@PREFIX@,${PREFIX},g\" " +
 			"with \"SUBST_VARS.id=\\tPREFIX\".")
 	t.CheckFileLinesDetab("subst.mk",
 		"# $NetBSD: substcontext_test.go,v 1.25 2019/05/26 14:05:57 rillig Exp $",
 		"",
 		"SUBST_CLASSES+= id",
 		"SUBST_STAGE.id= pre-configure",
 		"SUBST_FILES.id= filename",
 		"SUBST_VARS.id=  PREFIX",
 		// FIXME: This must be += instead of = since the previous line already uses =.
 		//  Luckily the check for redundant assignments catches this already.
 		"SUBST_VARS.id=  PKGMANDIR")
+}
 func (s *Suite) Test_SubstContext_suggestSubstVars__autofix_indentation(c *check.C) {
 	t := s.Init(c)
 	t.SetUpCommandLine("-Wall", "--autofix")
 	t.SetUpVartypes()
 	t.Chdir(".")
 	mklines := t.SetUpFileMkLines("subst.mk",
 		MkRcsID,
 		"",
 		"SUBST_CLASSES+=\t\t\tfix-paths",
 		"SUBST_STAGE.fix-paths=\t\tpre-configure",
 		"SUBST_MESSAGE.fix-paths=\tMessage",
 		"SUBST_FILES.fix-paths=\t\tfilename",
 		"SUBST_SED.fix-paths=\t\t-e s,@PREFIX@,${PREFIX},g")
 	mklines.Check()
 	t.CheckOutputLines(
 		"AUTOFIX: subst.mk:7: Replacing \"SUBST_SED.fix-paths=\\t\\t-e s,@PREFIX@,${PREFIX},g\" " +
 			"with \"SUBST_VARS.fix-paths=\\t\\tPREFIX\".")
 	t.CheckFileLinesDetab("subst.mk",
 		"# $NetBSD: substcontext_test.go,v 1.25 2019/05/26 14:05:57 rillig Exp $",
 		"",
 		"SUBST_CLASSES+=                 fix-paths",
 		"SUBST_STAGE.fix-paths=          pre-configure",
 		"SUBST_MESSAGE.fix-paths=        Message",
 		"SUBST_FILES.fix-paths=          filename",
 		"SUBST_VARS.fix-paths=           PREFIX")
+}
 // As of May 2019, pkglint does not check the order of the variables in
 // a SUBST block. Enforcing this order, or at least suggesting it, would
 // make pkgsrc packages more uniform, which is a good idea, but not urgent.
 func (s *Suite) Test_SubstContext__unusual_variable_order(c *check.C) {
 	t := s.Init(c)
 	t.SetUpVartypes()
 	mklines := t.NewMkLines("subst.mk",
 		MkRcsID,
 		"",
 		"SUBST_CLASSES+=\t\tid",
 		"SUBST_SED.id=\t\t-e /deleteme/d",
 		"SUBST_FILES.id=\t\tfile",
 		"SUBST_MESSAGE.id=\tMessage",
 		"SUBST_STAGE.id=\t\tpre-configure")
 	mklines.Check()
 	t.CheckOutputEmpty()
+}
 // simulateSubstLines only tests some of the inner workings of SubstContext.
 // It is not realistic for all cases. If in doubt, use MkLines.Check.
 func simulateSubstLines(t *Tester, texts ...string) {
 	ctx := NewSubstContext()
 	lineno := 0
 	for _, lineText := range texts {
-		var lineno int
+		var curr int
-		_, err := fmt.Sscanf(lineText[0:4], "%d: ", &lineno)
+		_, err := fmt.Sscanf(lineText[0:4], "%d: ", &curr)
 		G.AssertNil(err, "")
 		if lineno != 0 {
 			t.Check(curr, equals, lineno)
+		}
 		text := lineText[4:]
-		line := newSubstLine(t, lineno, text)
+		line := t.NewMkLine("Makefile", curr, text)
 		switch {
 		case text == "":
 			ctx.Finish(line)
 		case hasPrefix(text, "."):
 			ctx.Directive(line)
 		default:
 			ctx.Varassign(line)
+		}
 		lineno = curr + 1
+	}
-func newSubstLine(t *Tester, lineno int, text string) MkLine {
+	ctx.Finish(t.NewMkLine("Makefile", lineno, ""))
 	return t.NewMkLine("Makefile", lineno, text)
+}

 @@ -282,27 +282,27 @@ func (tr *Tools) ParseToolLine(mklines M
 			tr.SeenPrefs = true
+		}
+	}
+}
 func (tr *Tools) addAlias(tool *Tool, alias string) {
 	tool.Aliases = append(tool.Aliases, alias)
 	tr.AliasOf[alias] = tool.Name
+}
 // 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.
+// If createIfAbsent is true and the tool 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
+	}
 	validity := tr.validity(mkline.Basename, addToUseTools)
 	for _, dep := range mkline.ValueFields(value) {
 		name := strings.Split(dep, ":")[0]
 		if createIfAbsent || tr.ByName(name) != nil {

 @@ -133,31 +133,46 @@ func (s *Suite) Test_VarTypeRegistry_par
 		"Pkglint internal error: At least one ACL entry must be given.")
+}
 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)
 	// No warning about a missing :Q operator.
 	// All PLATFORM variables must be either lkNone or lkSpace.
 	t.CheckOutputEmpty()
+}
 func (s *Suite) Test_VarTypeRegistry_Init__no_tracing(c *check.C) {
 	t := s.Init(c)
 	t.CreateFileLines("editors/emacs/modules.mk",
 		MkRcsID,
 		"",
 		"_EMACS_VERSIONS_ALL=    emacs31",
 		"_EMACS_VERSIONS_ALL+=   emacs29")
 	t.DisableTracing()
 	t.SetUpVartypes() // Just for code coverage.
 	t.CheckOutputEmpty()
+}
 func (s *Suite) Test_VarTypeRegistry_Init__MASTER_SITES(c *check.C) {
 	t := s.Init(c)
 	t.CreateFileLines("mk/fetch/sites.mk",
 		MkRcsID,
 		"",
 		"MASTER_SITE_GITHUB=\thttps://github.com/",
 		"",
 		"OTHER=\tvalue") // For branch coverage of hasPrefix.*MASTER_SITE_
 	t.SetUpVartypes()
 	vartype := G.Pkgsrc.VariableType(nil, "MASTER_SITE_GITHUB")
 	t.Check(vartype.String(), equals, "FetchURL (list, system-provided)")
+}

	@@ -255,32 +255,41 @@ func tabWidth(s string) int {		@@ -255,32 +255,41 @@ func tabWidth(s string) int {
255	} else {	255	} else {
256	length++	256	length++
257	}	257	}
258	}	258	}
259	return length	259	return length
260	}	260	}
261		261
262	func detab(s string) string {	262	func detab(s string) string {
263	var detabbed strings.Builder	263	var detabbed strings.Builder
264	for _, r := range s {	264	for _, r := range s {
265	if r == '\t' {	265	if r == '\t' {
266	detabbed.WriteString(" "[:8-detabbed.Len()%8])	266	detabbed.WriteString(" "[:8-detabbed.Len()%8])
267	} else {	267	} else {
268	detabbed.WriteString(string(r))	268	detabbed.WriteRune(r)
269	}	269	}
270	}	270	}
271	return detabbed.String()	271	return detabbed.String()
272	}	272	}
273		273
		274	// alignWith extends str with as many tabs as needed to reach
		275	// the same screen width as the other string.
		276	func alignWith(str, other string) string {
		277	alignBefore := (tabWidth(other) + 7) & -8
		278	alignAfter := tabWidth(str) & -8
		279	tabsNeeded := imax((alignBefore-alignAfter)/8, 1)
		280	return str + strings.Repeat("\t", tabsNeeded)
		281	}
		282
274	func shorten(s string, maxChars int) string {	283	func shorten(s string, maxChars int) string {
275	codePoints := 0	284	codePoints := 0
276	for i := range s {	285	for i := range s {
277	if codePoints >= maxChars {	286	if codePoints >= maxChars {
278	return s[:i] + "..."	287	return s[:i] + "..."
279	}	288	}
280	codePoints++	289	codePoints++
281	}	290	}
282	return s	291	return s
283	}	292	}
284		293
285	func varnameBase(varname string) string {	294	func varnameBase(varname string) string {
286	dot := strings.IndexByte(varname, '.')	295	dot := strings.IndexByte(varname, '.')
	@@ -358,27 +367,27 @@ func relpath(from, to string) (result st		@@ -358,27 +367,27 @@ func relpath(from, to string) (result st
358		367
359	if trace.Tracing {	368	if trace.Tracing {
360	defer trace.Call(from, to, trace.Result(&result))()	369	defer trace.Call(from, to, trace.Result(&result))()
361	}	370	}
362		371
363	cfrom := cleanpath(from)	372	cfrom := cleanpath(from)
364	cto := cleanpath(to)	373	cto := cleanpath(to)
365		374
366	if cfrom == cto {	375	if cfrom == cto {
367	return "."	376	return "."
368	}	377	}
369		378
370	// Take a shortcut for the common case from "dir" to "dir/subdir/...".	379	// Take a shortcut for the common case from "dir" to "dir/subdir/...".
371	if hasPrefix(cto, cfrom) && len(cto) > len(cfrom)+1 && cto[len(cfrom)] == '/' {	380	if hasPrefix(cto, cfrom) && hasPrefix(cto[len(cfrom):], "/") {
372	return cleanpath(cto[len(cfrom)+1:])	381	return cleanpath(cto[len(cfrom)+1:])
373	}	382	}
374		383
375	// Take a shortcut for the common case from "category/package" to ".".	384	// Take a shortcut for the common case from "category/package" to ".".
376	// This is the most common variant in a complete pkgsrc scan.	385	// This is the most common variant in a complete pkgsrc scan.
377	if cto == "." {	386	if cto == "." {
378	fromParts := strings.FieldsFunc(cfrom, func(r rune) bool { return r == '/' })	387	fromParts := strings.FieldsFunc(cfrom, func(r rune) bool { return r == '/' })
379	if len(fromParts) == 2 && !hasPrefix(fromParts[0], ".") && !hasPrefix(fromParts[1], ".") {	388	if len(fromParts) == 2 && !hasPrefix(fromParts[0], ".") && !hasPrefix(fromParts[1], ".") {
380	return "../.."	389	return "../.."
381	}	390	}
382	}	391	}
383		392
384	if cfrom == "." && !filepath.IsAbs(cto) {	393	if cfrom == "." && !filepath.IsAbs(cto) {
	@@ -673,33 +682,33 @@ func (s *Scope) LastDefinition(varname s		@@ -673,33 +682,33 @@ func (s *Scope) LastDefinition(varname s
673	// Commented returns whether the variable has only been defined in commented	682	// Commented returns whether the variable has only been defined in commented
674	// variable assignments. These are ignored by bmake but used heavily in	683	// variable assignments. These are ignored by bmake but used heavily in
675	// mk/defaults/mk.conf for documentation.	684	// mk/defaults/mk.conf for documentation.
676	func (s *Scope) Commented(varname string) MkLine {	685	func (s *Scope) Commented(varname string) MkLine {
677	var mklines []MkLine	686	var mklines []MkLine
678	if first := s.firstDef[varname]; first != nil {	687	if first := s.firstDef[varname]; first != nil {
679	mklines = append(mklines, first)	688	mklines = append(mklines, first)
680	}	689	}
681	if last := s.lastDef[varname]; last != nil {	690	if last := s.lastDef[varname]; last != nil {
682	mklines = append(mklines, last)	691	mklines = append(mklines, last)
683	}	692	}
684		693
685	for _, mkline := range mklines {	694	for _, mkline := range mklines {
686	if mkline != nil && mkline.IsVarassign() {	695	if mkline.IsVarassign() {
687	return nil	696	return nil
688	}	697	}
689	}	698	}
690		699
691	for _, mkline := range mklines {	700	for _, mkline := range mklines {
692	if mkline != nil && mkline.IsCommentedVarassign() {	701	if mkline.IsCommentedVarassign() {
693	return mkline	702	return mkline
694	}	703	}
695	}	704	}
696		705
697	return nil	706	return nil
698	}	707	}
699		708
700	func (s *Scope) FirstUse(varname string) MkLine {	709	func (s *Scope) FirstUse(varname string) MkLine {
701	return s.used[varname]	710	return s.used[varname]
702	}	711	}
703		712
704	// LastValue returns the value from the last variable definition.	713	// LastValue returns the value from the last variable definition.
705	//	714	//
	@@ -868,27 +877,29 @@ func (c *FileCache) Put(filename string,		@@ -868,27 +877,29 @@ func (c *FileCache) Put(filename string,
868		877
869	entry = new(fileCacheEntry)	878	entry = new(fileCacheEntry)
870	c.table = append(c.table, entry)	879	c.table = append(c.table, entry)
871	c.mapping[key] = entry	880	c.mapping[key] = entry
872	}	881	}
873		882
874	entry.count = 1	883	entry.count = 1
875	entry.key = key	884	entry.key = key
876	entry.options = options	885	entry.options = options
877	entry.lines = lines	886	entry.lines = lines
878	}	887	}
879		888
880	func (c *FileCache) removeOldEntries() {	889	func (c *FileCache) removeOldEntries() {
881	sort.Slice(c.table, func(i, j int) bool { return c.table[j].count < c.table[i].count })	890	sort.Slice(c.table, func(i, j int) bool {
		891	return c.table[j].count < c.table[i].count
		892	})
882		893
883	if G.Testing {	894	if G.Testing {
884	for _, e := range c.table {	895	for _, e := range c.table {
885	if trace.Tracing {	896	if trace.Tracing {
886	trace.Stepf("FileCache %q with count %d.", e.key, e.count)	897	trace.Stepf("FileCache %q with count %d.", e.key, e.count)
887	}	898	}
888	}	899	}
889	}	900	}
890		901
891	minCount := c.table[len(c.table)-1].count	902	minCount := c.table[len(c.table)-1].count
892	newLen := len(c.table)	903	newLen := len(c.table)
893	for newLen > 0 && c.table[newLen-1].count == minCount {	904	for newLen > 0 && c.table[newLen-1].count == minCount {
894	e := c.table[newLen-1]	905	e := c.table[newLen-1]

 @@ -112,35 +112,39 @@ func (s *Suite) Test_cleanpath(c *check.
+}
 func (s *Suite) Test_relpath(c *check.C) {
 	t := s.Init(c)
 	t.Chdir(".")
 	t.Check(G.Pkgsrc.topdir, equals, t.tmpdir)
 	test := func(from, to, result string) {
 		c.Check(relpath(from, to), equals, result)
+	}
 	test("some/dir", "some/directory", "../../some/directory")
 	test("some/directory", "some/dir", "../../some/dir")
 	test("category/package/.", ".", "../..")
 	// This case is handled by one of the shortcuts that avoid file system access.
 	test(
 		"./.",
 		"x11/frameworkintegration/../../meta-pkgs/kde/kf5.mk",
 		"meta-pkgs/kde/kf5.mk")
 	test(".hidden/dir", ".", "../..")
 	test("dir/.hidden", ".", "../..")
 	// This happens when "pkglint -r x11" is run.
 	G.Pkgsrc.topdir = "x11/.."
 	test(
 		"./.",
 		"x11/frameworkintegration/../../meta-pkgs/kde/kf5.mk",
 		"meta-pkgs/kde/kf5.mk")
 	test(
 		"x11/..",
 		"x11/frameworkintegration/../../meta-pkgs/kde/kf5.mk",
 		"meta-pkgs/kde/kf5.mk")
+}
 @@ -228,26 +232,45 @@ func (s *Suite) Test_getSubdirs(c *check
 	c.Check(os.Remove(t.File("empty/file")), check.IsNil)
 	c.Check(getSubdirs(t.File(".")), deepEquals, []string{"subdir"})
+}
 func (s *Suite) Test_detab(c *check.C) {
 	c.Check(detab(""), equals, "")
 	c.Check(detab("\t"), equals, "        ")
 	c.Check(detab("1234\t9"), equals, "1234    9")
 	c.Check(detab("1234567\t"), equals, "1234567 ")
 	c.Check(detab("12345678\t"), equals, "12345678        ")
+}
 func (s *Suite) Test_alignWith(c *check.C) {
 	t := s.Init(c)
 	test := func(str, other, expected string) {
 		t.Check(alignWith(str, other), equals, expected)
+	}
 	// At least one tab is _always_ added.
 	test("", "", "\t")
 	test("VAR=", "1234567", "VAR=\t")
 	test("VAR=", "12345678", "VAR=\t")
 	test("VAR=", "123456789", "VAR=\t\t")
 	// At least one tab is added in any case,
 	// even if the other string is shorter.
 	test("1234567890=", "V=", "1234567890=\t")
+}
 const reMkIncludeBenchmark = `^\.([\t ]*)(s?include)[\t ]+\"([^\"]+)\"[\t ]*(?:#.*)?$`
 const reMkIncludeBenchmarkPositive = `^\.([\t ]*)(s?include)[\t ]+\"(.+)\"[\t ]*(?:#.*)?$`
 func Benchmark_match3_buildlink3(b *testing.B) {
 	for i := 0; i < b.N; i++ {
 		match3(".include \"../../category/package/buildlink3.mk\"", reMkIncludeBenchmark)
+	}
+}
 func Benchmark_match3_bsd_pkg_mk(b *testing.B) {
 	for i := 0; i < b.N; i++ {
 		match3(".include \"../../mk/bsd.pkg.mk\"", reMkIncludeBenchmark)
+	}
 @@ -301,26 +324,57 @@ func emptyToNil(slice []string) []string
+	}
 	return slice
+}
 func (s *Suite) Test_trimHspace(c *check.C) {
 	t := s.Init(c)
 	t.Check(trimHspace("a b"), equals, "a b")
 	t.Check(trimHspace(" a b "), equals, "a b")
 	t.Check(trimHspace("\ta b\t"), equals, "a b")
 	t.Check(trimHspace(" \t a b\t \t"), equals, "a b")
+}
 func (s *Suite) Test_trimCommon(c *check.C) {
 	t := s.Init(c)
 	test := func(a, b, trimmedA, trimmedB string) {
 		ta, tb := trimCommon(a, b)
 		t.Check(ta, equals, trimmedA)
 		t.Check(tb, equals, trimmedB)
+	}
 	test("", "",
 		"", "")
 	test("equal", "equal",
 		"", "")
 	test("prefixA", "prefixB",
 		"A", "B")
 	test("ASuffix", "BSuffix",
 		"A", "B")
 	test("PreMiddlePost", "PreCenterPost",
 		"Middle", "Center")
 	test("", "b",
 		"", "b")
 	test("a", "",
 		"a", "")
+}
 func (s *Suite) Test_isLocallyModified(c *check.C) {
 	t := s.Init(c)
 	unmodified := t.CreateFileLines("unmodified")
 	modTime := time.Unix(1136239445, 0).UTC()
 	err := os.Chtimes(unmodified, modTime, modTime)
 	c.Check(err, check.IsNil)
 	st, err := os.Lstat(unmodified)
 	c.Check(err, check.IsNil)
 	// Make sure that the file system has second precision and accuracy.
 @@ -618,26 +672,48 @@ func (s *Suite) Test_FileCache(c *check.
 	c.Check(cache.mapping, check.HasLen, 1)
 	c.Check(cache.hits, equals, 7)
 	c.Check(cache.misses, equals, 5)
 	t.CheckOutputLines(
 		"TRACE:   FileCache \"Makefile\" with count 4.",
 		"TRACE:   FileCache \"file1.mk\" with count 2.",
 		"TRACE:   FileCache \"file2.mk\" with count 2.",
 		"TRACE:   FileCache.Evict \"file2.mk\" with count 2.",
 		"TRACE:   FileCache.Evict \"file1.mk\" with count 2.",
 		"TRACE:   FileCache.Halve \"Makefile\" with count 4.")
+}
 func (s *Suite) Test_FileCache_removeOldEntries__branch_coverage(c *check.C) {
 	t := s.Init(c)
 	t.EnableTracingToLog()
 	G.Testing = false
 	lines := t.NewLines("filename.mk",
 		MkRcsID)
 	cache := NewFileCache(3)
 	cache.Put("filename1.mk", 0, lines)
 	cache.Put("filename2.mk", 0, lines)
 	cache.Get("filename2.mk", 0)
 	cache.Get("filename2.mk", 0)
 	cache.Put("filename3.mk", 0, lines)
 	cache.Put("filename4.mk", 0, lines)
 	t.CheckOutputLines(
 		"TRACE:   FileCache.Evict \"filename3.mk\" with count 1.",
 		"TRACE:   FileCache.Evict \"filename1.mk\" with count 1.",
 		"TRACE:   FileCache.Halve \"filename2.mk\" with count 3.")
+}
 func (s *Suite) Test_makeHelp(c *check.C) {
 	c.Check(makeHelp("subst"), equals, confMake+" help topic=subst")
+}
 func (s *Suite) Test_hasAlnumPrefix(c *check.C) {
 	t := s.Init(c)
 	t.Check(hasAlnumPrefix(""), equals, false)
 	t.Check(hasAlnumPrefix("A"), equals, true)
 	t.Check(hasAlnumPrefix(","), equals, false)
+}
 func (s *Suite) Test_Once(c *check.C) {

 @@ -202,26 +202,49 @@ func (s *Suite) Test_Var_Value__initial_
 	v := NewVar("VARNAME")
 	v.Write(t.NewMkLine("write.mk", 124, "VARNAME:=\toverwritten conditionally"), true, "OPSYS")
 	// Since there is no previous value, the simplest choice is to just
 	// take the first seen value, no matter if that value is conditional
 	// or not.
 	t.Check(v.Conditional(), equals, true)
 	t.Check(v.Constant(), equals, false)
 	t.Check(v.Value(), equals, "overwritten conditionally")
+}
 func (s *Suite) Test_Var_Write__conditional_without_variables(c *check.C) {
 	t := s.Init(c)
 	mklines := t.NewMkLines("filename.mk",
 		MkRcsID,
 		".if exists(/usr/bin)",
 		"VAR=\tvalue",
 		".endif")
 	scope := NewRedundantScope()
 	mklines.ForEach(func(mkline MkLine) {
 		if mkline.IsVarassign() {
 			t.Check(scope.get("VAR").vari.Conditional(), equals, false)
+		}
 		scope.checkLine(mklines, mkline)
 		if mkline.IsVarassign() {
 			t.Check(scope.get("VAR").vari.Conditional(), equals, true)
+		}
 	})
+}
 func (s *Suite) Test_Var_Value__conditional_write_after_unconditional(c *check.C) {
 	t := s.Init(c)
 	v := NewVar("VARNAME")
 	v.Write(t.NewMkLine("write.mk", 123, "VARNAME=\tvalue"), false)
 	t.Check(v.Value(), equals, "value")
 	v.Write(t.NewMkLine("write.mk", 124, "VARNAME+=\tappended"), false)
 	t.Check(v.Value(), equals, "value appended")

 @@ -3,26 +3,35 @@ package pkglint
 import (
 	"path"
 	"strings"
+)
 // Vartype is a combination of a data type and a permission specification.
 // See vardefs.go for examples, and vartypecheck.go for the implementation.
 type Vartype struct {
 	basicType  *BasicType
 	options    vartypeOptions
 	aclEntries []ACLEntry
+}
 func NewVartype(basicType *BasicType, options vartypeOptions, aclEntries ...ACLEntry) *Vartype {
 	for _, aclEntry := range aclEntries {
 		_, err := path.Match(aclEntry.glob, "")
 		G.AssertNil(err, "path.Match")
+	}
 	return &Vartype{basicType, options, aclEntries}
+}
 type vartypeOptions uint8
 const (
 	// List is a compound type, consisting of several space-separated elements.
 	// Elements can have embedded spaces by enclosing them in double or single
 	// quotes, like in the shell.
 	//
 	// These lists are used in the :M, :S modifiers, in .for loops,
 	// and as lists of arbitrary things.
 	List vartypeOptions = 1 << iota
 	Guessed
 	PackageSettable
 @@ -32,26 +41,30 @@ const (
 	// NeedsRationale marks variables that should always contain a comment
 	// describing why they are set. Typical examples are NOT_FOR_* variables.
 	NeedsRationale
 	NoVartypeOptions = 0
+)
 type ACLEntry struct {
 	glob        string // Examples: "Makefile", "*.mk"
 	permissions ACLPermissions
+}
 func NewACLEntry(glob string, permissions ACLPermissions) ACLEntry {
 	return ACLEntry{glob, permissions}
+}
 type ACLPermissions uint8
 const (
 	aclpSet         ACLPermissions = 1 << iota // VAR = value
 	aclpSetDefault                             // VAR ?= value
 	aclpAppend                                 // VAR += value
 	aclpUseLoadtime                            // OTHER := ${VAR}, OTHER != ${VAR}
 	aclpUse                                    // OTHER = ${VAR}
 	aclpNone ACLPermissions = 0
 	aclpAllWrite   = aclpSet | aclpSetDefault | aclpAppend
 	aclpAllRead    = aclpUseLoadtime | aclpUse
 @@ -109,36 +122,37 @@ func (vt *Vartype) EffectivePermissions(
 func (vt *Vartype) Union() ACLPermissions {
 	var permissions ACLPermissions
 	for _, aclEntry := range vt.aclEntries {
 		permissions |= aclEntry.permissions
+	}
 	return permissions
+}
 // AlternativeFiles lists the file patterns in which all of the given
 // permissions are allowed, readily formatted to be used in a diagnostic.
 //
 // If the permission is allowed nowhere, an empty string is returned.
 func (vt *Vartype) AlternativeFiles(perms ACLPermissions) string {
-	pos := make([]string, 0, len(vt.aclEntries))
+	var pos []string
-	neg := make([]string, 0, len(vt.aclEntries))
+	var neg []string
 	merge := func(slice []string) []string {
 		di := 0
 		for si, early := range slice {
 			redundant := false
 			for _, late := range slice[si+1:] {
 				matched, err := path.Match(late, early)
-				if err == nil && matched {
+				G.AssertNil(err, "path.Match")
 				if matched {
 					redundant = true
 					break
+				}
+			}
 			if !redundant {
 				slice[di] = early
 				di++
+			}
+		}
 		return slice[:di]
+	}
 	for _, aclEntry := range vt.aclEntries {

 @@ -1,44 +1,44 @@
 package pkglint
 import (
 	"gopkg.in/check.v1"
+)
 func (s *Suite) Test_Vartype_EffectivePermissions(c *check.C) {
 	t := s.Init(c)
 	t.SetUpVartypes()
 	if typ := G.Pkgsrc.vartypes.Canon("PREFIX"); c.Check(typ, check.NotNil) {
 		c.Check(typ.basicType.name, equals, "Pathname")
-		c.Check(typ.aclEntries, check.DeepEquals, []ACLEntry{{"*", aclpUse}})
+		c.Check(typ.aclEntries, deepEquals, []ACLEntry{NewACLEntry("*", aclpUse)})
 		c.Check(typ.EffectivePermissions("Makefile"), equals, aclpUse)
 		c.Check(typ.EffectivePermissions("buildlink3.mk"), equals, aclpUse)
+	}
 	if typ := G.Pkgsrc.vartypes.Canon("EXTRACT_OPTS"); c.Check(typ, check.NotNil) {
 		c.Check(typ.basicType.name, equals, "ShellWord")
 		c.Check(typ.EffectivePermissions("Makefile"), equals, aclpAllWrite|aclpUse)
 		c.Check(typ.EffectivePermissions("options.mk"), equals, aclpAllWrite|aclpUse)
+	}
+}
 func (s *Suite) Test_Vartype_AlternativeFiles(c *check.C) {
 	// test generates the files description for the "set" permission.
 	test := func(rules []string, alternatives string) {
 		aclEntries := (*VarTypeRegistry).parseACLEntries(nil, "", rules...)
-		vartype := Vartype{BtYesNo, NoVartypeOptions, aclEntries}
+		vartype := NewVartype(BtYesNo, NoVartypeOptions, aclEntries...)
 		alternativeFiles := vartype.AlternativeFiles(aclpSet)
 		c.Check(alternativeFiles, equals, alternatives)
+	}
 	// rules parses the given permission rules.
 	//
 	// There is a built-in check that prevents repeated adjacent permissions.
 	// The "append" permission can be added alternatively to circumvent this
 	// check, since that permission is effectively ignore by this test.
 	rules := func(rules ...string) []string { return rules }

	@@ -50,33 +50,33 @@ func (reg *VarTypeRegistry) DefinedExact		@@ -50,33 +50,33 @@ func (reg *VarTypeRegistry) DefinedExact
50		50
51	func (reg *VarTypeRegistry) DefinedCanon(varname string) bool {	51	func (reg *VarTypeRegistry) DefinedCanon(varname string) bool {
52	return reg.Canon(varname) != nil	52	return reg.Canon(varname) != nil
53	}	53	}
54		54
55	func (reg VarTypeRegistry) DefineType(varcanon string, vartype Vartype) {	55	func (reg VarTypeRegistry) DefineType(varcanon string, vartype Vartype) {
56	reg.types[varcanon] = vartype	56	reg.types[varcanon] = vartype
57	}	57	}
58		58
59	func (reg VarTypeRegistry) Define(varname string, basicType BasicType, options vartypeOptions, aclEntries ...ACLEntry) {	59	func (reg VarTypeRegistry) Define(varname string, basicType BasicType, options vartypeOptions, aclEntries ...ACLEntry) {
60	m, varbase, varparam := match2(varname, `^([A-Z_.][A-Z0-9_]\|@)(\|\\|\.\*)$`)	60	m, varbase, varparam := match2(varname, `^([A-Z_.][A-Z0-9_]\|@)(\|\\|\.\*)$`)
61	G.Assertf(m, "invalid variable name")	61	G.Assertf(m, "invalid variable name")
62		62
63	vartype := Vartype{basicType, options, aclEntries}	63	vartype := NewVartype(basicType, options, aclEntries...)
64		64
65	if varparam == "" \|\| varparam == "*" {	65	if varparam == "" \|\| varparam == "*" {
66	reg.types[varbase] = &vartype	66	reg.types[varbase] = vartype
67	}	67	}
68	if varparam == "" \|\| varparam == "." {	68	if varparam == "" \|\| varparam == "." {
69	reg.types[varbase+".*"] = &vartype	69	reg.types[varbase+".*"] = vartype
70	}	70	}
71	}	71	}
72		72
73	// DefineParse defines a variable with the given type and permissions.	73	// DefineParse defines a variable with the given type and permissions.
74	//	74	//
75	// A permission entry looks like this:	75	// A permission entry looks like this:
76	// "Makefile, Makefile., .mk: default, set, append, use, use-loadtime"	76	// "Makefile, Makefile., .mk: default, set, append, use, use-loadtime"
77	// Only certain filenames are allowed in the part before the colon,	77	// Only certain filenames are allowed in the part before the colon,
78	// to prevent typos. To use arbitrary filenames, prefix them with	78	// to prevent typos. To use arbitrary filenames, prefix them with
79	// "special:".	79	// "special:".
80	//	80	//
81	// TODO: To be implemented: when prefixed with "infra:", the entry only	81	// TODO: To be implemented: when prefixed with "infra:", the entry only
82	// applies to files within the pkgsrc infrastructure. Without this prefix,	82	// applies to files within the pkgsrc infrastructure. Without this prefix,
	@@ -1719,27 +1719,27 @@ func (reg *VarTypeRegistry) parseACLEntr		@@ -1719,27 +1719,27 @@ func (reg *VarTypeRegistry) parseACLEntr
1719	default:	1719	default:
1720	withoutSpecial := strings.TrimPrefix(glob, "special:")	1720	withoutSpecial := strings.TrimPrefix(glob, "special:")
1721	if withoutSpecial == glob {	1721	if withoutSpecial == glob {
1722	G.Assertf(false, "Invalid ACL glob %q for %q.", glob, varname)	1722	G.Assertf(false, "Invalid ACL glob %q for %q.", glob, varname)
1723	} else {	1723	} else {
1724	glob = withoutSpecial	1724	glob = withoutSpecial
1725	}	1725	}
1726	}	1726	}
1727	for _, prev := range result {	1727	for _, prev := range result {
1728	matched, err := path.Match(prev.glob, glob)	1728	matched, err := path.Match(prev.glob, glob)
1729	G.AssertNil(err, "Invalid ACL pattern %q for %q", glob, varname)	1729	G.AssertNil(err, "Invalid ACL pattern %q for %q", glob, varname)
1730	G.Assertf(!matched, "Unreachable ACL pattern %q for %q.", glob, varname)	1730	G.Assertf(!matched, "Unreachable ACL pattern %q for %q.", glob, varname)
1731	}	1731	}
1732	result = append(result, ACLEntry{glob, permissions})	1732	result = append(result, NewACLEntry(glob, permissions))
1733	}	1733	}
1734	}	1734	}
1735		1735
1736	return result	1736	return result
1737	}	1737	}
1738		1738
1739	func (reg *VarTypeRegistry) parsePermissions(varname, globs, perms string) ACLPermissions {	1739	func (reg *VarTypeRegistry) parsePermissions(varname, globs, perms string) ACLPermissions {
1740	if perms == "none" {	1740	if perms == "none" {
1741	return aclpNone	1741	return aclpNone
1742	}	1742	}
1743		1743
1744	splitPerms := strings.Split(perms, ", ")	1744	splitPerms := strings.Split(perms, ", ")
1745	var permissions ACLPermissions	1745	var permissions ACLPermissions