Invertible attributes

[neunenak]

This PR implements a not() syntax for certain OS-target attributes.

Resolves #1895

[neunenak]

@casey this is ready for review

[casey]

See some initial comments!

[casey]

I think this function should panic if we call it with a non-invertible attribute.

[casey]

Are these unix checks redundant with the ones below? I notice that the other Unix OS's don't have the same checks.

[casey]

I think this maybe all gets easier if we have a System enum which represents the current system:

enum System {
  Windows,
  Linux,
  Unix,
  ...
}

impl System {
  fn current() -> &'static [System] {
    if cfg(target_os = "linux") {
       &[Self::Linux, Self::Unix]
    }
  }
}

And then we can handle all these checks in the same way.

[casey]

I'm not sure I like introducing inverted status only to turn it back to a bool with matches!. I think it would probably be better to just use a bool the whole way.

[casey]

I think we should probably use:

Suggested change

	Linux { inverted: bool },
	Linux { enabled: bool },

And invert the meaning of the boolean, to make the downstream code make more sense.

[casey]

Suggested change

	(inverted, AttributeDiscriminant::Linux) => Self::Linux { inverted },
	(inverted, AttributeDiscriminant::Linux) => Self::Linux { enabled: !inverted },

[casey]

I think this is probably cleaner than using mutable variables:

Suggested change

	let (name, inverted) = {
	let (name, inverted) = {
	let name = self.parse_name()?;
	if name.lexeme() == "not" {
	self.expect(ParenL)?;
	let name = self.parse_name()?;
	(name, true)
	} else {
	(name, false)
	}
	}

[casey]

And I think we should actually, since we don't have any invertable variables which aren't system variables, change the argument to Attribute::new to be !inverted, and within Attribute::new it's called enabled.