@Override
			public int visit(DisjointPattern sibDP, Constructor sibcons) {
				// Do not forbid myself.
				if (sibcons == cons) {
					return CONTINUE;
				}

				/**
				 * I had misunderstood the precedence rules originally.
				 * 
				 * 1. If one pattern defines a subset of the other pattern, then the more-specific
				 * one is preferred.
				 * 
				 * 2. Otherwise, preference is by line number
				 * 
				 * Thus, I need to check if there is any overlap at all. If not, then I don't need
				 * to worry about forbidding anything. Then, I'll check if it defines a strict
				 * subset, and forbid it if so. Then, I'll check if it defines a strict overset, and
				 * skip the line check if so. Then, I'll check if its line number *precedes* mine,
				 * and forbid it if so.
				 * 
				 * (I originally though the pattern with the most bits won, no matter whether or not
				 * those bits overlapped.)
				 * 
				 * There's an additional nuance. Because context is an *input* to the assembler, it
				 * may still cause the selection of a later constructor, despite line number. Thus,
				 * we can't apply the line number rule unless the earlier one also has an overset in
				 * terms of context.
				 */

				// If the two patterns cannot be combined, then they are disjoint.
				AssemblyResolvedPatterns sibpat = factory.fromPattern(sibDP,
					sibcons.getMinimumLength(), "For specialization check", sibcons);
				AssemblyResolvedPatterns comb = pat.combine(sibpat);
				if (null == comb) {
					return CONTINUE;
				}

				// OK, they overlap. Let's see if its a strict subset
				if (comb.bitsEqual(sibpat)) {
					// My sibling is a strict subset, so it will win the overlap
					forbids.add(sibpat.withDescription(getLocation(sibcons) + " forbids " +
						getLocation(cons) + " by pattern specificity"));
					return CONTINUE;
				}
				else if (comb.bitsEqual(pat)) {
					// I'm a strict subset, so I will win the overlap
					return CONTINUE;
				}

				// We can't apply the line number rule unless the sibling's context is an overset
				if (!comb.getContext().equals(pat.getContext())) {
					return CONTINUE;
				}

				// Finally, check the line number
				if (sibcons.getId() < cons.getId()) {
					forbids.add(sibpat.withDescription(getLocation(sibcons) + " forbids " +
						getLocation(cons) + " by rule position"));
					return CONTINUE;
				}

				// I guess, I have the more-specific pattern, or I appear higher... 
				return CONTINUE;
			}
Add the list of forbidden patterns to one of the constructor's patterns

<p>
SLEIGH disambiguates multiple matching pattern by two rules. First, if one is more specific
than ("specializes") another, i.e., it matches on more bits than another pattern, the more
specific pattern is chosen. Second, if the two are equally special, then the one that occurs
first in the SLEIGH specification is taken. So, during resolution, if a less-special or
later-occurring constructor is chosen, we must prevent continued resolution from matching the
more-special or earlier-occurring pattern(s).

<p>
Essentially, this states, "you may choose any value matching my pattern, except those that
match these forbidden patterns."

<p>
This takes a given pattern, and searches the rest of the language for any patterns that would
take precedence, and combines them as forbidden patterns with the given pattern.

@param pat the given pattern
@return the same pattern with forbidden records added
Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/app/plugin/assembler/sleigh/sem/AssemblyConstructorSemantic.java