Skip to content

Issue#8 limit happy to less than 2.1 #46

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Closed

Conversation

yav
Copy link

@yav yav commented Oct 18, 2024

Fixes #8. Adds an upper bound to happy to not use 2.1

yav and others added 15 commits May 8, 2023 16:54
Previously the instance was incorrect because it'd cause an infinite loop.

This version rearranges the fields of the records to ensure that the
hash field is first, which makes it possible to derive Eq and Ord.

We also do a bunch of refactoring to use record notation instead of
constructor pattern matching, to make it easier to do similar refactoring
in the future.
This reverts commit 9ff9176.

Per the discussion in #6, having the `Eq` and `Ord` instances ignore the `raw`
field of `Ident` causes more trouble than it's worth, as it causes the parser
to incorrectly deem raw identifiers like `r#return` to be keywords. While we
could fix this issue by changing the parser, this would take quite a bit of
code changes to accomplish. As such, we revert the change here, and we make a
note in the Haddocks for the `Eq` and `Ord` instances to beware of the fact
that `raw` is taken into account.

After this change, the `rustc-tests` test suite passes once more. As such, this
change fixes #6.
Make tests pass, migrate to GitHub Actions
The previous lexer implementation in `Language.Rust.Parser.Lexer` was broken
for Unicode characters with sufficiently large codepoints, as the previous
implementation incorrectly attempted to port UTF-16–encoded codepoints over to
`alex`, which is UTF-8–encoded. Rather than try to fix the previous
implementation (which was based on old `rustc` code that is no longer used),
this ports the lexer to a new implementation that is based on the Rust
`unicode-xid` crate (which is how modern versions of `rustc` lex Unicode
characters). Specifically:

* This adapts `unicode-xid`'s lexer generation script to generate an
  `alex`-based lexer instead of a Rust-based one.

* The new lexer is generated to support codepoints from Unicode 15.1.0.
  (It is unclear which exact Unicode version the previous lexer targeted, but
  given that it was last updated in 2016, it was likely quite an old version.)

* I have verified that the new lexer can lex exotic Unicode characters such as
  `𝑂` and `𐌝` by adding them as regression tests.

Fixes #3.
Lexer: Properly support Unicode 15.1.0
@yav yav closed this Oct 18, 2024
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
Labels
None yet
Projects
None yet
Development

Successfully merging this pull request may close these issues.

Add support for 128-bit integers
2 participants