fsprojects/FsLexYacc

This system is a compiler toolset for generating lexical and syntactic parsers, specifically providing the FsLex and FsYacc utilities for F\# developers. It manages the build process and runtime support for these tools, including configuration for .NET 6 compatibility and NuGet distribution. The codebase also includes comprehensive test suites and examples to validate parsing logic and Unicode handling.

9 changes.

The project underwent a significant infrastructure upgrade to .NET 6, updating build scripts, MSBuild tasks, and dependency management. This period also introduced new features for command-line argument parsing and configurable parser cache capacities, alongside expanded test coverage for both legacy and modern tooling.

5 changes.

This period focused on refactoring the FsLex and FsYacc tooling by extracting their core domain logic into separate, versioned libraries (FsLex.Core and FsYacc.Core). This architectural shift improved modularity and enabled independent testing, supported by new test suites for Unicode handling and CLI options.

The FsLexYacc package definition is now explicitly configured via a new FsLexYacc.template file, which maps source files to the correct NuGet package structure (build, src, and dependencies). A new publish.cmd script has been added to automate the pushing of generated .nupkg files to the NuGet feed.

nuget · high confidence

The FsLex.Core library has been extracted into a separate project, containing the core domain logic, AST definitions, and code generation drivers. This new core library is versioned at 11.3.0, and includes the lexer and parser implementations for the FsLex tooling.

src/FsLex.Core · high confidence

Users can now tune the performance of the generated parser by specifying the initial capacity of the association table lookup caches via the new --assoc-cache-capacity CLI option. This allows for optimization of memory usage and lookup speed, addressing issue \#54.

src/FsYacc · high confidence

The FsLexYacc.Runtime package now includes a new ArgParser utility for processing command-line arguments, exposing types like ArgInfo and ArgParser for building CLI tools. Additionally, the parser runtime now supports configuring the initial capacity of the AssocTable lookup cache used during parsing. This is exposed via a new overload of Tables.Interpret that accepts an explicit cache capacity, and a global ParseSettings.AssocTableCacheInitialCapacity property (defaulting to 2000) to tune performance for parsers invoked over many small inputs.

src/FsLexYacc.Runtime · high confidence

The core domain logic and generation code for FsYacc have been refactored out of the main FsLexYacc project into a new FsYacc.Core library. This change separates the parser generation engine from the command-line interface and other tooling, improving modularity and allowing the core logic to be reused or tested independently.

src/FsYacc.Core · high confidence

The FsLex lexer generator tooling has been updated with version 11.3.0, including the addition of an App.config file that enforces .NET Framework 4.5 compatibility and redirects FSharp.Core to version 4.3.0. The FsLex source code (fslex.fs) has been modified to support the --internal and --module command-line arguments, allowing users to generate internal modules and specify custom module names for the generated lexer code.

src/FsLex · medium confidence

The FsLexYacc.Build.Tasks package has been updated to version 7.0.0. The MSBuild targets file (FsLexYacc.targets) now configures FsLex and FsYacc tools to use .NET 6 runtime paths (net6.0) and utilizes modern MSBuild constructs. This change ensures the build tasks correctly locate and execute the lexer and parser generation tools using the .NET 6 tool runner.

src/FsLexYacc.Build.Tasks · medium confidence

The project's build infrastructure has been modernized: the FAKE build script now targets .NET 6.0 and utilizes the .NET 6 SDK, while the solution file has been updated for Visual Studio 2019. Additionally, the repository now includes an .editorconfig for code formatting, a .fantomasignore file, and updated .gitignore and .gitattributes configurations to better manage generated files and line endings.

(repo-wide) · high confidence

Added Expecto-based test suite for Unicode handling; Added FsLex/FsYacc JSON parser example with capacity-invariance tests; Added LexAndYaccMiniProject test harness; Added legacy FsLexYacc regression tests; Added unit tests for the --assoc-cache-capacity CLI option.

The project has been upgraded to target .NET 6, with all build scripts, project files, and test suites updated to use the .NET 6.0 framework. The dependency management system has been standardized on Paket, introducing a new paket.dependencies and paket.lock file that pin specific package versions (such as Expecto 9.0.4 and FSharp.Core 4.6.2) and enforce a strict .NET 6.0 and netstandard2.0 target framework restriction.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 50 → 51 (+0.5)
• Rubric changed (rubric-2026.08.17 → rubric-2026.08.19) — scores are not directly comparable.

• Code Health 98 → 86 (-12.3)
• Architecture 100 → 100 (+0.0)
• Maturity 30 → 33 (+3.1)
• Readiness 56 → 56 (+0.0)
• Security 67 → 67 (+0.0)

• Coverage not measured — test suite did not build
• Duplicated block (10 lines × 2) (src/FsLex.Core/fslexdriver.fs)
• Duplicated block (12 lines × 2) (src/FsLex.Core/fslexdriver.fs)
• Duplicated block (7 lines × 2) (src/FsLex.Core/fslexlex.fs)
• Duplicated block (7 lines × 2) (src/FsLex.Core/fslexlex.fs)
• Duplicated block (8 lines × 2) (src/FsLex/fslex.fs)
• Duplicated block (9 lines × 2) (src/FsYacc.Core/fsyaccast.fs)
• Further orphaned files (smaller)
• LLM evaluation failed
• Off-boarding risk: anonymized user #1
• Orphaned knowledge (src/FsLexYacc.Runtime/Lexing.fs)

• Coverage not measured — test suite did not build
• Duplicated block (10 lines × 2) (src/FsLex.Core/fslexdriver.fs)
• Duplicated block (12 lines × 2) (src/FsLex.Core/fslexdriver.fs)
• Duplicated block (6 lines × 2) (src/FsLex.Core/fslexlex.fs)
• Duplicated block (6 lines × 2) (src/FsLex.Core/fslexlex.fs)
• Duplicated block (7 lines × 2) (src/FsLex/fslex.fs)
• Duplicated block (8 lines × 2) (src/FsYacc.Core/fsyaccast.fs)
• FileTooLong: FsLex.Core/fslexlex.fs (src/FsLex.Core/fslexlex.fs)
• FileTooLong: FsYacc.Core/fsyaccast.fs (src/FsYacc.Core/fsyaccast.fs)
• FileTooLong: FsYacc.Core/fsyaccdriver.fs (src/FsYacc.Core/fsyaccdriver.fs)
• FileTooLong: FsYacc.Core/fsyacclex.fs (src/FsYacc.Core/fsyacclex.fs)
• Off-boarding risk: anonymized user #1
• PR-triggered workflow without a permissions block
• Secret passed as a command-line argument
• The header/trailer section of the lexer is described but no example shows how headers are used (e.g. declaring values/functions in the header). (docs/content/fslex.md)

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

fsprojects/FsLexYacc was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.