 @@ -118,27 +118,26 @@ func Test__qa(t *testing.T) {
 	ck.Configure("mkparser.go", "*", "*", -intqa.EMissingTest)       // TODO
 	ck.Configure("mkshparser.go", "*", "*", -intqa.EMissingTest)     // TODO
 	ck.Configure("mkshtypes.go", "*", "*", -intqa.EMissingTest)      // TODO
 	ck.Configure("mkshwalker.go", "*", "*", -intqa.EMissingTest)     // TODO
 	ck.Configure("mktokenslexer.go", "*", "*", -intqa.EMissingTest)  // TODO
 	ck.Configure("mktypes.go", "*", "*", -intqa.EMissingTest)        // TODO
 	ck.Configure("options.go", "*", "*", -intqa.EMissingTest)        // TODO
 	ck.Configure("package.go", "*", "*", -intqa.EMissingTest)        // TODO
 	ck.Configure("paragraph.go", "*", "*", -intqa.EMissingTest)      // TODO
 	ck.Configure("patches.go", "*", "*", -intqa.EMissingTest)        // TODO
 	ck.Configure("pkglint.go", "*", "*", -intqa.EMissingTest)        // TODO
 	ck.Configure("pkgsrc.go", "*", "*", -intqa.EMissingTest)         // TODO
 	ck.Configure("redundantscope.go", "*", "*", -intqa.EMissingTest) // TODO
 	ck.Configure("scope.go", "*", "*", -intqa.EMissingTest)          // TODO
 	ck.Configure("shell.go", "*", "*", -intqa.EMissingTest)          // TODO
 	ck.Configure("shtokenizer.go", "*", "*", -intqa.EMissingTest)    // TODO
 	ck.Configure("shtypes.go", "*", "*", -intqa.EMissingTest)        // TODO
 	ck.Configure("substcontext.go", "*", "*", -intqa.EMissingTest)   // TODO
 	ck.Configure("tools.go", "*", "*", -intqa.EMissingTest)          // TODO
 	ck.Configure("util.go", "*", "*", -intqa.EMissingTest)           // TODO
 	ck.Configure("var.go", "*", "*", -intqa.EMissingTest)            // TODO
 	ck.Configure("varalignblock.go", "*", "*", -intqa.EMissingTest)            // TODO
 	ck.Configure("varalignblock.go", "varalignLine", "*", +intqa.EMissingTest) // TODO: remove as redundant
 	ck.Configure("vardefs.go", "*", "*", -intqa.EMissingTest)   // TODO
 	ck.Configure("vargroups.go", "*", "*", -intqa.EMissingTest) // TODO

 @@ -24,26 +24,63 @@ func (s *Suite) Test_Scope__commented_va
 	t.CheckEquals(scope.IsDefined("VAR"), false)
 	t.Check(scope.FirstDefinition("VAR"), check.IsNil)
 	t.Check(scope.LastDefinition("VAR"), check.IsNil)
 	t.CheckEquals(scope.Mentioned("VAR"), mkline)
 	t.CheckEquals(scope.Commented("VAR"), mkline)
 	value, found, indeterminate := scope.LastValueFound("VAR")
 	t.CheckEquals(value, "")
 	t.CheckEquals(found, false)
 	t.CheckEquals(indeterminate, false)
+}
 func (s *Suite) Test_NewScope(c *check.C) {
 	t := s.Init(c)
 	scope := NewScope()
 	t.Check(scope.names, check.IsNil)
 	t.Check(scope.vs, check.NotNil)
 	t.Check(scope.vs, check.HasLen, 0)
+}
 func (s *Suite) Test_Scope_varnames(c *check.C) {
 	t := s.Init(c)
 	scope := NewScope()
 	mkline := t.NewMkLine("filename.mk", 3, "DEFINED=\t${USED}")
 	t.Check(scope.varnames(), check.IsNil)
 	scope.Define("DEFINED", mkline)
 	scope.Use("USED", mkline, VucRunTime)
 	t.CheckDeepEquals(scope.varnames(), []string{"DEFINED", "USED"})
 	scope.varnames()[0] = "modified" // just to demonstrate the caching
 	t.CheckDeepEquals(scope.varnames(), []string{"modified", "USED"})
+}
 func (s *Suite) Test_Scope_create(c *check.C) {
 	t := s.Init(c)
 	scope := NewScope()
 	v1 := scope.create("VAR")
 	v2 := scope.create("VAR")
 	t.CheckEquals(v1, v2)
+}
 func (s *Suite) Test_Scope_Define(c *check.C) {
 	t := s.Init(c)
 	scope := NewScope()
 	test := func(line string, found, indeterminate bool, value string) {
 		mkline := t.NewMkLine("file.mk", 123, line)
 		scope.Define("BUILD_DIRS", mkline)
 		actualValue, actualFound, actualIndeterminate := scope.LastValueFound("BUILD_DIRS")
 		t.CheckDeepEquals(
 			[]interface{}{actualFound, actualIndeterminate, actualValue},
 @@ -65,26 +102,65 @@ func (s *Suite) Test_Scope_Define(c *che
 	// Later default assignments do not have an effect.
 	test("BUILD_DIRS?=\tdefault",
 		true, false, "one two three four")
 	test("BUILD_DIRS!=\techo dynamic",
 		true, true, "")
 	// The shell assignment above sets the variable to an indeterminate
 	// value, after which all further default assignments are ignored.
 	test("BUILD_DIRS?=\tdefault after shell assignment",
 		true, true, "")
+}
 func (s *Suite) Test_Scope_def(c *check.C) {
 	t := s.Init(c)
 	mkline := t.NewMkLine("filename.mk", 3, "VAR=\tvalue")
 	scope := NewScope()
 	scope.def("VAR.param", mkline)
 	t.Check(scope.FirstDefinition("VAR"), check.IsNil)
 	t.CheckEquals(scope.FirstDefinition("VAR.param"), mkline)
 	t.Check(scope.FirstDefinition("VAR.*"), check.IsNil)
+}
 func (s *Suite) Test_Scope_Fallback(c *check.C) {
 	t := s.Init(c)
 	mkline := t.NewMkLine("filename.mk", 3, "VAR=\tvalue")
 	scope := NewScope()
 	scope.def("VAR.param", mkline)
 	scope.Fallback("FALLBACK", "fallback")
 	t.CheckEquals(scope.LastValue("VAR.param"), "value")
 	t.CheckEquals(scope.LastValue("FALLBACK"), "fallback")
 	t.CheckEquals(scope.LastValue("UNDEFINED"), "")
+}
 func (s *Suite) Test_Scope_Use(c *check.C) {
 	t := s.Init(c)
 	mkline := t.NewMkLine("filename.mk", 3, "VAR=\t${USED}")
 	scope := NewScope()
 	scope.Define("VAR", mkline)
 	scope.Use("USED", mkline, VucRunTime)
 	t.CheckEquals(scope.LastValue("VAR"), "${USED}")
 	t.CheckEquals(scope.LastValue("USED"), "")
+}
 func (s *Suite) Test_Scope_Mentioned(c *check.C) {
 	t := s.Init(c)
 	assigned := t.NewMkLine("filename.mk", 3, "VAR=\tvalue")
 	commented := t.NewMkLine("filename.mk", 4, "#COMMENTED=\tvalue")
 	documented := t.NewMkLine("filename.mk", 5, "# DOCUMENTED is a variable.")
 	scope := NewScope()
 	scope.Define("VAR", assigned)
 	scope.Define("COMMENTED", commented)
 	scope.Define("DOCUMENTED", documented)
 	t.CheckEquals(scope.Mentioned("VAR"), assigned)
 @@ -92,87 +168,159 @@ func (s *Suite) Test_Scope_Mentioned(c *
 	t.CheckEquals(scope.Mentioned("DOCUMENTED"), documented)
 	t.Check(scope.Mentioned("UNKNOWN"), check.IsNil)
+}
 func (s *Suite) Test_Scope_IsDefined(c *check.C) {
 	t := s.Init(c)
 	scope := NewScope()
 	scope.Define("VAR.param", t.NewMkLine("file.mk", 1, "VAR.param=value"))
 	t.CheckEquals(scope.IsDefined("VAR.param"), true)
 	t.CheckEquals(scope.IsDefined("VAR.other"), false)
 	t.CheckEquals(scope.IsDefined("VARIABLE.*"), false)
+}
 func (s *Suite) Test_Scope_IsDefinedSimilar(c *check.C) {
 	t := s.Init(c)
 	scope := NewScope()
 	scope.Define("VAR.param", t.NewMkLine("file.mk", 1, "VAR.param=value"))
 	t.CheckEquals(scope.IsDefinedSimilar("VAR.param"), true)
 	t.CheckEquals(scope.IsDefinedSimilar("VAR.other"), true)
 	t.CheckEquals(scope.IsDefinedSimilar("VARIABLE.*"), false)
+}
 func (s *Suite) Test_Scope_IsUsed(c *check.C) {
 	t := s.Init(c)
 	scope := NewScope()
 	mkline := t.NewMkLine("file.mk", 1, "\techo ${VAR.param}")
 	scope.Use("VAR.param", mkline, VucRunTime)
 	t.CheckEquals(scope.IsUsed("VAR.param"), true)
 	t.CheckEquals(scope.IsUsed("VAR.other"), false)
 	t.CheckEquals(scope.IsUsed("VARIABLE.*"), false)
+}
 func (s *Suite) Test_Scope_IsUsedSimilar(c *check.C) {
 	t := s.Init(c)
 	scope := NewScope()
 	mkline := t.NewMkLine("file.mk", 1, "\techo ${VAR.param}")
 	scope.Use("VAR.param", mkline, VucRunTime)
 	t.CheckEquals(scope.IsUsedSimilar("VAR.param"), true)
 	t.CheckEquals(scope.IsUsedSimilar("VAR.other"), true)
 	t.CheckEquals(scope.IsUsedSimilar("VARIABLE.*"), false)
+}
 func (s *Suite) Test_Scope_IsUsedAtLoadTime(c *check.C) {
 	t := s.Init(c)
 	scope := NewScope()
 	mkline := t.NewMkLine("file.mk", 1, "\techo ${VAR.param}")
 	scope.Use("LOAD_TIME", mkline, VucLoadTime)
 	scope.Use("RUN_TIME", mkline, VucRunTime)
 	t.CheckEquals(scope.IsUsedAtLoadTime("LOAD_TIME"), true)
 	t.CheckEquals(scope.IsUsedAtLoadTime("RUN_TIME"), false)
 	t.CheckEquals(scope.IsUsedAtLoadTime("UNDEFINED"), false)
+}
 func (s *Suite) Test_Scope_FirstDefinition(c *check.C) {
 	t := s.Init(c)
-	mkline1 := t.NewMkLine("fname.mk", 3, "VAR=\tvalue")
+	mkline3 := t.NewMkLine("fname.mk", 3, "VAR=\tvalue")
-	mkline2 := t.NewMkLine("fname.mk", 3, ".if ${SNEAKY::=value}")
+	mkline4 := t.NewMkLine("fname.mk", 4, ".if ${SNEAKY::=value}")
 	mkline5 := t.NewMkLine("fname.mk", 5, ".if ${USED}")
 	scope := NewScope()
-	scope.Define("VAR", mkline1)
+	scope.Define("VAR", mkline3)
-	scope.Define("SNEAKY", mkline2)
+	scope.Define("SNEAKY", mkline4)
 	scope.Use("USED", mkline5, VucLoadTime)
-	t.CheckEquals(scope.FirstDefinition("VAR"), mkline1)
+	t.CheckEquals(scope.FirstDefinition("VAR"), mkline3)
 	// This call returns nil because it's not a variable assignment
 	// and the calling code typically assumes a variable definition.
 	// These sneaky variables with implicit definition are an edge
 	// case that only few people actually know. It's better that way.
 	t.Check(scope.FirstDefinition("SNEAKY"), check.IsNil)
 	t.Check(scope.FirstDefinition("USED"), check.IsNil)
 	t.CheckOutputLines(
-		"ERROR: fname.mk:3: Assignment modifiers like \":=\" " +
+		"ERROR: fname.mk:4: Assignment modifiers like \":=\" " +
 			"must not be used at all.")
+}
 func (s *Suite) Test_Scope_LastDefinition(c *check.C) {
 	t := s.Init(c)
 	mkline3 := t.NewMkLine("fname.mk", 3, "VAR=\tfirst")
 	mkline4 := t.NewMkLine("fname.mk", 4, "VAR=\t${USED}")
 	scope := NewScope()
 	scope.Define("VAR", mkline3)
 	scope.Define("VAR", mkline4)
 	scope.Use("USED", mkline4, VucRunTime)
 	t.CheckEquals(scope.LastDefinition("VAR"), mkline4)
 	t.Check(scope.LastDefinition("UNDEFINED"), check.IsNil)
 	t.Check(scope.LastDefinition("USED"), check.IsNil)
+}
 func (s *Suite) Test_Scope_Commented(c *check.C) {
 	t := s.Init(c)
 	assigned := t.NewMkLine("filename.mk", 3, "VAR=\tvalue")
 	commented := t.NewMkLine("filename.mk", 4, "#COMMENTED=\tvalue")
 	documented := t.NewMkLine("filename.mk", 5, "# DOCUMENTED is a variable.")
 	used := t.NewMkLine("filename.mk", 6, "ANY=\t${USED}")
 	scope := NewScope()
 	scope.Define("VAR", assigned)
 	scope.Define("COMMENTED", commented)
 	scope.Define("DOCUMENTED", documented)
 	scope.Use("USED", used, VucRunTime)
 	t.Check(scope.Commented("VAR"), check.IsNil)
 	t.CheckEquals(scope.Commented("COMMENTED"), commented)
 	t.Check(scope.Commented("DOCUMENTED"), check.IsNil)
 	t.Check(scope.Commented("UNKNOWN"), check.IsNil)
 	t.Check(scope.Commented("USED"), check.IsNil)
+}
 func (s *Suite) Test_Scope_FirstUse(c *check.C) {
 	t := s.Init(c)
 	mklines := t.NewMkLines("file.mk",
 		MkCvsID,
 		"VAR1=\t${USED}",
 		"VAR2=\t${USED}")
 	mklines.Check()
 	scope := mklines.allVars
 	t.CheckEquals(scope.FirstUse("USED"), mklines.mklines[1])
 	t.Check(scope.FirstUse("UNUSED"), check.IsNil)
 	t.CheckOutputLines(
 		"WARN: file.mk:2: VAR1 is defined but not used.",
 		"WARN: file.mk:2: USED is used but not defined.",
 		"WARN: file.mk:3: VAR2 is defined but not used.")
+}
 func (s *Suite) Test_Scope_LastValue(c *check.C) {
 	t := s.Init(c)
 	mklines := t.NewMkLines("file.mk",
 		MkCvsID,
 		"VAR=\tfirst",
 		"VAR=\tsecond",
 		".if 1",
 		"VAR=\tthird (conditional)",
 		".endif")
 @@ -200,28 +348,74 @@ func (s *Suite) Test_Scope_LastValue__ap
 		"${PLIST.one}${PLIST.two}bin/program")
 	t.CreateFileLines("Makefile.common",
 		MkCvsID,
 		"PLIST_VARS=\tone",
 		"PLIST.one=\tyes")
 	pkg := NewPackage(".")
 	t.FinishSetUp()
 	pkg.Check()
 	t.CheckEquals(pkg.vars.LastValue("PLIST_VARS"), "one two")
+}
 func (s *Suite) Test_Scope_LastValueFound(c *check.C) {
 	t := s.Init(c)
 	mklines := t.NewMkLines("file.mk",
 		MkCvsID,
 		"VAR=\tfirst",
 		"VAR=\tsecond",
 		".if 1",
 		"VAR=\tthird (conditional)",
 		".endif")
 	mklines.Check()
 	value, found, indeterminate := mklines.allVars.LastValueFound("VAR")
 	t.CheckEquals(value, "third (conditional)")
 	t.CheckEquals(found, true)
 	t.CheckEquals(indeterminate, false) // TODO: why?
 	t.CheckOutputLines(
 		"WARN: file.mk:2: VAR is defined but not used.")
+}
 // Scope.DefineAll copies only the variable definitions,
 // but not the uses of variables.
 func (s *Suite) Test_Scope_DefineAll(c *check.C) {
 	t := s.Init(c)
 	mkline := t.NewMkLine("filename.mk", 123, "VAR=\t${USED}")
 	src := NewScope()
 	src.Use("USED", mkline, VucRunTime)
 	dst := NewScope()
 	dst.DefineAll(&src)
 	c.Check(dst.vs, check.HasLen, 0)
 	src.Define("VAR", t.NewMkLine("file.mk", 1, "VAR=value"))
 	dst.DefineAll(&src)
 	t.CheckEquals(dst.IsDefined("VAR"), true)
+}
 func (s *Suite) Test_Scope_forEach(c *check.C) {
 	t := s.Init(c)
 	mkline := t.NewMkLine("filename.mk", 123, "VAR=\t${USED}")
 	scope := NewScope()
 	scope.Define("VAR", mkline)
 	scope.Use("USED", mkline, VucRunTime)
 	var result []string
 	scope.forEach(func(varname string, data *scopeVar) {
 		result = append(result, varname+"="+data.value)
 	})
 	t.CheckDeepEquals(result, []string{
 		"USED=",
 		"VAR=${USED}"})
+}

 @@ -410,26 +410,28 @@ func (b *substBlock) varassign(mkline *M
 	case "SUBST_STAGE.*":
 		b.varassignStage(mkline, pkg)
 	case "SUBST_MESSAGE.*":
 		b.varassignMessages(mkline)
 	case "SUBST_FILES.*":
 		b.varassignFiles(mkline)
 	case "SUBST_SED.*":
 		b.varassignSed(mkline)
 	case "SUBST_VARS.*":
 		b.varassignVars(mkline)
 	case "SUBST_FILTER_CMD.*":
 		b.varassignFilterCmd(mkline)
+	}
 	b.varassignAllowForeign(mkline)
+}
 func (b *substBlock) varassignStage(mkline *MkLine, pkg *Package) {
 	if b.isConditional() {
 		mkline.Warnf("%s should not be defined conditionally.", mkline.Varname())
+	}
 	b.dupString(mkline, ssStage)
 	value := mkline.Value()
 	if value == "pre-patch" || value == "post-patch" {
 		fix := mkline.Autofix()
 		fix.Warnf("Substitutions should not happen in the patch phase.")
 @@ -481,26 +483,32 @@ func (b *substBlock) varassignVars(mklin
 	b.dupList(mkline, ssVars, ssVarsAutofix)
 	b.addSeen(ssTransform)
 	for _, substVar := range mkline.Fields() {
 		b.allowVar(substVar)
+	}
+}
 func (b *substBlock) varassignFilterCmd(mkline *MkLine) {
 	b.dupString(mkline, ssFilterCmd)
 	b.addSeen(ssTransform)
+}
 func (b *substBlock) varassignAllowForeign(mkline *MkLine) {
 	mkline.ForEachUsed(func(varUse *MkVarUse, time VucTime) {
 		b.allowVar(varUse.varname)
 	})
+}
 func (b *substBlock) suggestSubstVars(mkline *MkLine) {
 	tokens, _ := splitIntoShellTokens(mkline.Line, mkline.Value())
 	for _, token := range tokens {
 		varname := b.extractVarname(mkline.UnquoteShell(token, false))
 		if varname == "" {
 			continue
+		}
 		id := b.id
 		varop := sprintf("SUBST_VARS.%s%s%s",
 			id,
 			condStr(hasSuffix(id, "+"), " ", ""),

 @@ -17,185 +17,265 @@ type state struct {
 	end         bool
+}
 type transition struct {
 	min, max byte
 	to       StateID
+}
 type StateID uint16
 // Compile parses a pattern, including the error checking that is missing
 // from bmake.
 func Compile(pattern string) (*Pattern, error) {
-	var a Pattern
+	var p Pattern
-	s := a.AddState(false)
+	s := p.AddState(false)
 	var deadEnd StateID
 	lex := textproc.NewLexer(pattern)
 	for !lex.EOF() {
 		if lex.SkipByte('*') {
-			a.AddTransition(s, 0, 255, s)
+			p.AddTransition(s, 0, 255, s)
 			continue
+		}
 		if lex.SkipByte('?') {
-			next := a.AddState(false)
+			next := p.AddState(false)
-			a.AddTransition(s, 0, 255, next)
+			p.AddTransition(s, 0, 255, next)
 			s = next
 			continue
+		}
 		if lex.SkipByte('\\') {
 			if lex.EOF() {
 				return nil, errors.New("unfinished escape sequence")
+			}
 			ch := lex.NextByte()
-			next := a.AddState(false)
+			next := p.AddState(false)
-			a.AddTransition(s, ch, ch, next)
+			p.AddTransition(s, ch, ch, next)
 			s = next
 			continue
+		}
 		ch := lex.NextByte()
 		if ch != '[' {
-			next := a.AddState(false)
+			next := p.AddState(false)
-			a.AddTransition(s, ch, ch, next)
+			p.AddTransition(s, ch, ch, next)
 			s = next
 			continue
+		}
-		negate := lex.SkipByte('^')
+		next, err := compileCharClass(&p, lex, ch, s)
-		if negate && deadEnd == 0 {
+		if err != nil {
-			deadEnd = a.AddState(false)
+			return nil, err
+		}
 		s = next
+	}
 	p.states[s].end = true
 	return &p, nil
+}
 func compileCharClass(p *Pattern, lex *textproc.Lexer, ch byte, s StateID) (StateID, error) {
 	negate := lex.SkipByte('^')
 	chars := make([]bool, 256)
 	next := p.AddState(false)
 	for {
 		if lex.EOF() {
 			return 0, errors.New("unfinished character class")
+		}
 		ch = lex.NextByte()
 		if ch == ']' {
 			break
+		}
-		next := a.AddState(false)
+		if lex.SkipByte('-') {
 		for {
 			if lex.EOF() {
-				return nil, errors.New("unfinished character class")
+				return 0, errors.New("unfinished character range")
+			}
-			ch = lex.NextByte()
+			max := lex.NextByte()
-			if ch == ']' {
+			if ch > max {
-				break
+				ch, max = max, ch
 			max := ch
 			if lex.SkipByte('-') {
 				if lex.EOF() {
 					return nil, errors.New("unfinished character range")
 				max = lex.NextByte()
+			}
 			for i := int(ch); i <= int(max); i++ {
-			to := next
+				chars[i] = true
 			if negate {
 				to = deadEnd
+			}
-			a.AddTransition(s, bmin(ch, max), bmax(ch, max), to)
+		} else {
 			chars[ch] = true
+		}
 		if negate {
-			a.AddTransition(s, 0, 255, next)
+	if negate {
 		for i, b := range chars {
 			chars[i] = !b
+		}
 		s = next
+	}
-	a.states[s].end = true
+	start := 0
-	return &a, nil
+	for start < len(chars) && !chars[start] {
 		start++
+	}
 	for start < len(chars) {
 		end := start
 		for end < len(chars) && chars[end] {
 			end++
+		}
 		if start < end {
 			p.AddTransition(s, byte(start), byte(end-1), next)
+		}
 		start = end
 		for start < len(chars) && !chars[start] {
 			start++
+		}
+	}
 	return next, nil
+}
-func (a *Pattern) AddState(end bool) StateID {
+func (p *Pattern) AddState(end bool) StateID {
-	a.states = append(a.states, state{nil, end})
+	p.states = append(p.states, state{nil, end})
-	return StateID(len(a.states) - 1)
+	return StateID(len(p.states) - 1)
+}
-func (a *Pattern) AddTransition(from StateID, min, max byte, to StateID) {
+func (p *Pattern) AddTransition(from StateID, min, max byte, to StateID) {
-	state := &a.states[from]
+	state := &p.states[from]
 	state.transitions = append(state.transitions, transition{min, max, to})
+}
 // Match tests whether a pattern matches the given string.
-func (a *Pattern) Match(s string) bool {
+func (p *Pattern) Match(s string) bool {
-	state := StateID(0)
+	curr := make([]bool, len(p.states))
 	next := make([]bool, len(p.states))
 	curr[0] = true
 	for _, ch := range []byte(s) {
-		for _, tr := range a.states[state].transitions {
+		ok := false
-			if tr.min <= ch && ch <= tr.max {
+		for i, _ := range next {
-				state = tr.to
+			next[i] = false
 				goto nextByte
 		for si := range curr {
 			if !curr[si] {
 				continue
+			}
 			for _, tr := range p.states[si].transitions {
 				if tr.min <= ch && ch <= tr.max {
 					next[tr.to] = true
 					ok = true
+				}
+			}
+		}
-		return false
+		if !ok {
-	nextByte:
+			return false
+		}
 		curr, next = next, curr
+	}
 	return a.states[state].end
 	for i, curr := range curr {
 		if curr && p.states[i].end {
 			return true
+		}
+	}
 	return false
+}
 // Intersect computes a pattern that only matches if both given patterns
 // match at the same time.
-func Intersect(a, b *Pattern) *Pattern {
+func Intersect(p1, p2 *Pattern) *Pattern {
-	var is Pattern
+	var res Pattern
-	for i := 0; i < len(a.states); i++ {
+	for i1 := 0; i1 < len(p1.states); i1++ {
-		for j := 0; j < len(b.states); j++ {
+		for i2 := 0; i2 < len(p2.states); i2++ {
-			is.AddState(a.states[i].end && b.states[j].end)
+			res.AddState(p1.states[i1].end && p2.states[i2].end)
+		}
+	}
-	for i := 0; i < len(a.states); i++ {
+	for i1 := 0; i1 < len(p1.states); i1++ {
-		for j := 0; j < len(b.states); j++ {
+		for i2 := 0; i2 < len(p2.states); i2++ {
-			for _, at := range a.states[i].transitions {
+			for _, t1 := range p1.states[i1].transitions {
-				for _, bt := range b.states[j].transitions {
+				for _, t2 := range p2.states[i2].transitions {
-					min := bmax(at.min, bt.min)
+					min := bmax(t1.min, t2.min)
-					max := bmin(at.max, bt.max)
+					max := bmin(t1.max, t2.max)
 					if min <= max {
-						from := StateID(i*len(b.states) + j)
+						from := StateID(i1*len(p2.states) + i2)
-						to := at.to*StateID(len(b.states)) + bt.to
+						to := t1.to*StateID(len(p2.states)) + t2.to
-						is.AddTransition(from, min, max, to)
+						res.AddTransition(from, min, max, to)
+					}
+				}
+			}
+		}
+	}
-	// TODO: optimize: remove transitions that point to a dead end
+	return res.optimized()
+}
 func (p *Pattern) optimized() *Pattern {
 	var opt Pattern
 	var todo []StateID
 	hasNewID := make([]bool, len(p.states))
 	newIDs := make([]StateID, len(p.states))
 	todo = append(todo, 0)
 	newIDs[0] = opt.AddState(p.states[0].end)
 	hasNewID[0] = true
 	for len(todo) > 0 {
 		oldStateID := todo[len(todo)-1]
 		todo = todo[:len(todo)-1]
 		oldState := p.states[oldStateID]
 		for _, t := range oldState.transitions {
 			if !hasNewID[t.to] {
 				hasNewID[t.to] = true
 				newIDs[t.to] = opt.AddState(p.states[t.to].end)
 				todo = append(todo, t.to)
+			}
 			opt.AddTransition(newIDs[oldStateID], t.min, t.max, newIDs[t.to])
+		}
+	}
 	// TODO: remove transitions that point to a dead end
-	return &is
+	return &opt
+}
 // CanMatch tests whether the pattern can match some string.
 // Most patterns can do that.
 // Typical counterexamples are:
 //  [^]
 //  Intersect("*.c", "*.h")
-func (a *Pattern) CanMatch() bool {
+func (p *Pattern) CanMatch() bool {
-	reachable := make([]bool, len(a.states))
+	reachable := make([]bool, len(p.states))
 	reachable[0] = true
 again:
 	changed := false
-	for i, s := range a.states {
+	for i, s := range p.states {
 		if reachable[i] {
 			for _, t := range s.transitions {
 				if !reachable[t.to] {
 					reachable[t.to] = true
 					changed = true
+				}
+			}
+		}
+	}
 	if changed {
 		goto again
+	}
-	for i, s := range a.states {
+	for i, s := range p.states {
 		if reachable[i] && s.end {
 			return true
+		}
+	}
 	return false
+}
 func bmin(a, b byte) byte {
 	if a < b {
 		return a
+	}
 	return b
+}

 @@ -1,20 +1,97 @@
 package makepat
 import (
 	"netbsd.org/pkglint/intqa"
 	"reflect"
 	"testing"
+)
-func Test_Automaton_Match(t *testing.T) {
+func Test_Compile__errors(t *testing.T) {
 	tests := []struct {
 		pattern string
 		msg     string
 	}{
 		{"\\", "unfinished escape sequence"},
 		{"[", "unfinished character class"},
 		{"[a-", "unfinished character range"},
 		{"[\\", "unfinished character class"},
+	}
 	for _, tt := range tests {
 		t.Run(tt.pattern, func(t *testing.T) {
 			_, err := Compile(tt.pattern)
 			if err == nil {
 				t.Fail()
 			} else if err.Error() != tt.msg {
 				t.Errorf("err = %v, want %v", err, tt.msg)
+			}
 		})
+	}
+}
 func Test_compileCharClass(t *testing.T) {
 	tests := []struct {
 		pattern string
 		str     string
 		want    bool
 	}{
 		{"[0-9]", "/", false},
 		{"[0-9]", "0", true},
 		{"[0-9]", "9", true},
 		{"[0-9]", ":", false},
+	}
 	for _, tt := range tests {
 		t.Run(tt.pattern, func(t *testing.T) {
 			p, err := Compile(tt.pattern)
 			if err != nil {
 				t.Fail()
+			}
 			got := p.Match(tt.str)
 			if got != tt.want {
 				t.Errorf("got %v, want %v", got, tt.want)
+			}
 		})
+	}
+}
 func Test_Pattern_AddState(t *testing.T) {
 	var p Pattern
 	p.AddState(false)
 	p.AddState(true)
 	expected := Pattern{states: []state{{nil, false}, {nil, true}}}
 	if !reflect.DeepEqual(p, expected) {
 		t.Errorf("%#v", p)
+	}
+}
 func Test_Pattern_AddTransition(t *testing.T) {
 	var p Pattern
 	p.AddState(false)
 	p.AddState(true)
 	p.AddTransition(0, '0', '9', 1)
 	p.AddTransition(1, '0', '9', 0)
 	expected := Pattern{states: []state{
 		{[]transition{{'0', '9', 1}}, false},
 		{[]transition{{'0', '9', 0}}, true}}}
 	if !reflect.DeepEqual(p, expected) {
 		t.Errorf("%#v", p)
+	}
+}
 func Test_Pattern_Match(t *testing.T) {
 	tests := []struct {
 		pattern string
 		str     string
 		want    bool
 	}{
 		{"a-[0-9]*", "", false},
 		{"a-[0-9]*", "a", false},
 		{"a-[0-9]*", "b", false},
 		{"a-[0-9]*", "a-", false},
 		{"a-[0-9]*", "a-0", true},
 		{"a-[0-9]*", "a-13", true},
 		{"a-[0-9]*", "a-3* matches arbitrary text", true},
 		{"a-[0-9]*", "a+", false},
 @@ -57,62 +134,46 @@ func Test_Automaton_Match(t *testing.T)
 		{"[0-9A-Za-z]", "z", true},
 		{"[0-9A-Za-z]", "{", false},
 		{"[\\-]]", "{", false},
 		{"[\\-]]", "\\", true},
 		{"[\\-]]", "]", true},
 		{"[\\-]]", "^", false},
 		{"[9-0]", "", false},
 		{"[9-0]", "55", false},
 		{"[9-0]", "/", false},
 		{"[9-0]", "0", true},
 		{"[9-0]", "5", true},
 		{"[9-0]", "9", true},
 		{"[9-0]", ":", false},
 		{"*.c", ".c", true},
 		{"*.c", "a.c", true},
 		{"*.c", "c.c", true},
 		{"*.c", "..c", true},
 		{"*.c", ".c.c", true},
 		{"*.c", "a.c.c", true},
+	}
 	for _, tt := range tests {
 		t.Run(tt.pattern+" "+tt.str, func(t *testing.T) {
 			a, err := Compile(tt.pattern)
 			if err != nil {
 				t.Fatal(err)
+			}
 			if got := a.Match(tt.str); got != tt.want {
 				t.Errorf("Match() = %v, want %v", got, tt.want)
+			}
 		})
+	}
+}
 func Test_Automaton_Compile__errors(t *testing.T) {
 	tests := []struct {
 		pattern string
 		msg     string
 	}{
 		{"\\", "unfinished escape sequence"},
 		{"[", "unfinished character class"},
 		{"[a-", "unfinished character range"},
 		{"[\\", "unfinished character class"},
 	for _, tt := range tests {
 		t.Run(tt.pattern, func(t *testing.T) {
 			_, err := Compile(tt.pattern)
 			if err == nil {
 				t.Fail()
 			} else if err.Error() != tt.msg {
 				t.Errorf("err = %v, want %v", err, tt.msg)
 		})
 func Test_Intersect(t *testing.T) {
 	tests := []struct {
 		pattern1 string
 		pattern2 string
 		str      string
 		matches  bool
 		canMatch bool
 	}{
 		{"N-*", "N-*", "N-*", true, true},
 		{"N-9.99.*", "N-[1-9].*", "", false, true},
 		{"N-9.99.*", "N-[1-9][0-9].*", "", false, false},
+	}
 	for _, tt := range tests {
 @@ -127,13 +188,89 @@ func Test_Intersect(t *testing.T) {
+			}
 			a := Intersect(a1, a2)
 			matches := a.Match(tt.str)
 			if matches != tt.matches {
 				t.Errorf("Match() = %v, want %v", matches, tt.matches)
+			}
 			canMatch := a.CanMatch()
 			if canMatch != tt.canMatch {
 				t.Errorf("CanMatch() = %v, want %v", canMatch, tt.canMatch)
+			}
 		})
+	}
+}
 func Test_Pattern_optimized(t *testing.T) {
 	var p Pattern
 	p.AddState(false)
 	p.AddState(false)
 	p.AddState(false)
 	p.AddState(true)
 	p.AddTransition(0, '1', '1', 1)
 	p.AddTransition(1, '2', '2', 3)
 	opt := p.optimized()
 	expected := Pattern{[]state{
 		{[]transition{{'1', '1', 1}}, false},
 		{[]transition{{'2', '2', 2}}, false},
 		{nil, true}}}
 	if !reflect.DeepEqual(opt, &expected) {
 		t.Errorf("%#v", p)
+	}
+}
 func Test_Pattern_CanMatch(t *testing.T) {
 	tests := []struct {
 		p1   string
 		p2   string
 		want bool
 	}{
 		{"*.c", "*.h", false},
 		{"*.c", "????.?", true},
 		{"[1-9]", "5", true},
 		{"[1-9]", ":", false},
 		{"[1-9A-Za-z]", "[ -/]", false},
+	}
 	for _, tt := range tests {
 		t.Run(tt.p1+" "+tt.p2, func(t *testing.T) {
 			p1, err1 := Compile(tt.p1)
 			p2, err2 := Compile(tt.p2)
 			if err1 != nil {
 				t.Fatal(err1)
+			}
 			if err2 != nil {
 				t.Fatal(err2)
+			}
 			both := Intersect(p1, p2)
 			got := both.CanMatch()
 			if got != tt.want {
 				t.Errorf("CanMatch() = %v, want %v", got, tt.want)
+			}
 		})
+	}
+}
 func Test_bmin(t *testing.T) {
 	if bmin(0, 255) != 0 {
 		t.Error()
+	}
 	if bmin(128, 127) != 127 {
 		t.Error()
+	}
+}
 func Test_bmax(t *testing.T) {
 	if bmax(0, 255) != 255 {
 		t.Error()
+	}
 	if bmax(128, 127) != 128 {
 		t.Error()
+	}
+}
 func Test(t *testing.T) {
 	ck := intqa.NewQAChecker(t.Errorf)
 	ck.Configure("*", "*", "", -intqa.EMissingTest)
 	ck.Check()
+}

 @@ -1,17 +1,16 @@
-# $NetBSD: Makefile,v 1.657 2020/06/17 09:54:12 bsiegert Exp $
+# $NetBSD: Makefile,v 1.658 2020/06/20 07:00:44 rillig Exp $
-PKGNAME=	pkglint-20.1.17
+PKGNAME=	pkglint-20.1.18
 PKGREVISION=	1
 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

	@@ -104,33 +104,33 @@ func (s *Scope) def(name string, mkline		@@ -104,33 +104,33 @@ func (s *Scope) def(name string, mkline
104	case opAssignShell:	104	case opAssignShell:
105	v.value = ""	105	v.value = ""
106	v.indeterminate = true	106	v.indeterminate = true
107	default:	107	default:
108	v.value = mkline.Value()	108	v.value = mkline.Value()
109	}	109	}
110	}	110	}
111		111
112	func (s *Scope) Fallback(varname string, value string) {	112	func (s *Scope) Fallback(varname string, value string) {
113	s.create(varname).fallback = value	113	s.create(varname).fallback = value
114	}	114	}
115		115
116	// Use marks the variable and its canonicalized form as used.	116	// Use marks the variable and its canonicalized form as used.
117	func (s Scope) Use(varname string, line MkLine, time VucTime) {	117	func (s Scope) Use(varname string, mkline MkLine, time VucTime) {
118	use := func(name string) {	118	use := func(name string) {
119	v := s.create(name)	119	v := s.create(name)
120	if v.used == nil {	120	if v.used == nil {
121	v.used = line	121	v.used = mkline
122	if trace.Tracing {	122	if trace.Tracing {
123	trace.Step2("Using %q in %s", name, line.String())	123	trace.Step2("Using %q in %s", name, mkline.String())
124	}	124	}
125	}	125	}
126	if time == VucLoadTime {	126	if time == VucLoadTime {
127	v.usedAtLoadTime = true	127	v.usedAtLoadTime = true
128	}	128	}
129	}	129	}
130		130
131	use(varname)	131	use(varname)
132	use(varnameCanon(varname))	132	use(varnameCanon(varname))
133	}	133	}
134		134
135	// Mentioned returns the first line in which the variable is either:	135	// Mentioned returns the first line in which the variable is either:
136	// - defined,	136	// - defined,

 @@ -968,26 +968,42 @@ func (s *Suite) Test_substScope_finish__
 		"VAR2=           value2",
 		"SUBST_FILES.1=  files",
 		"SUBST_VARS.1=   VAR1",
 		"SUBST_STAGE.2=  pre-configure",
 		"SUBST_FILES.2=  files",
 		"VAR1=           value1",
 		"SUBST_VARS.2=   VAR2")
 	t.CheckOutputLines(
 		"NOTE: filename.mk:1: " +
 			"Please add only one class at a time to SUBST_CLASSES.")
+}
 func (s *Suite) Test_substScope_finish__indirect_SUBST_FILES(c *check.C) {
 	t := s.Init(c)
 	t.RunSubst(
 		"SUBST_CLASSES+= 1",
 		"SUBST_STAGE.1=  pre-configure",
 		"S1_CMD=         echo file",
 		"SUBST_FILES.1=  ${S1_CMD:sh}",
 		"SUBST_VARS.1=   PREFIX")
 	// Since S1_CMD is used in SUBST_FILES, it is not foreign
 	// but obviously belongs to the SUBST block.
 	// Before 2020-06-20, pkglint had warned about this.
 	t.CheckOutputEmpty()
+}
 func (s *Suite) Test_substScope_prepareSubstClasses(c *check.C) {
 	t := s.Init(c)
 	t.RunSubst(
 		"SUBST_CLASSES+= 1",
 		"SUBST_STAGE.1=  post-configure",
 		".if 0")
 	// There's no need to warn about unbalanced conditionals
 	// since that is already done by MkLines.Check.
 	t.CheckOutputLines(
 		"WARN: filename.mk:EOF: Incomplete SUBST block: SUBST_FILES.1 missing.",
 		"WARN: filename.mk:EOF: Incomplete SUBST block: "+

 @@ -1145,27 +1145,27 @@ func (reg *VarTypeRegistry) Init(src *Pk
 	reg.sys("EMUL_OPSYS", enum("darwin freebsd hpux irix linux osf1 solaris sunos none"))
 	reg.pkg("EMUL_PKG_FMT", enum("plain rpm"))
 	reg.usr("EMUL_PLATFORM", BtEmulPlatform)
 	reg.pkglist("EMUL_PLATFORMS", BtEmulPlatform)
 	reg.usrlist("EMUL_PREFER", BtEmulPlatform)
 	reg.pkglist("EMUL_REQD", BtDependencyPattern)
 	reg.usr("EMUL_TYPE.*", enum("native builtin suse suse-10.0 suse-12.1 suse-13.1"))
 	reg.sys("ERROR_CAT", BtShellCommand)
 	reg.sys("ERROR_MSG", BtShellCommand)
 	reg.syslist("EXPORT_SYMBOLS_LDFLAGS", BtLdFlag)
 	reg.sys("EXTRACT_CMD", BtShellCommand)
 	reg.pkg("EXTRACT_DIR", BtPathname)
 	reg.pkg("EXTRACT_DIR.*", BtPathname)
-	reg.pkglist("EXTRACT_ELEMENTS", BtPathPattern) // TODO: No slashes allowed
+	reg.pkglist("EXTRACT_ELEMENTS", BtPathPattern)
 	reg.pkglist("EXTRACT_ENV", BtShellWord)
 	reg.pkglist("EXTRACT_ONLY", BtPathname)
 	reg.pkglist("EXTRACT_OPTS", BtShellWord)
 	reg.pkglist("EXTRACT_OPTS_BIN", BtShellWord)
 	reg.pkglist("EXTRACT_OPTS_LHA", BtShellWord)
 	reg.pkglist("EXTRACT_OPTS_PAX", BtShellWord)
 	reg.pkglist("EXTRACT_OPTS_RAR", BtShellWord)
 	reg.pkglist("EXTRACT_OPTS_TAR", BtShellWord)
 	reg.pkglist("EXTRACT_OPTS_ZIP", BtShellWord)
 	reg.pkglist("EXTRACT_OPTS_ZOO", BtShellWord)
 	reg.pkg("EXTRACT_SUFX", BtDistSuffix)
 	reg.sys("FAIL_MSG", BtShellCommand)
 	reg.sys("FAMBASE", BtPathname)