DualBrain/MinskVB

This system is a BASIC compiler and interpreter project, named Minsk, built on the .NET platform. It provides a complete toolchain that parses BASIC source code into an abstract syntax tree, performs semantic analysis with type checking, and generates executable .NET assemblies via IL code emission. The project includes a command-line compiler, a REPL interpreter with syntax highlighting, and a comprehensive test suite covering lexical, syntactic, and semantic validation.

13 changes.

This period established the foundational architecture for a BASIC compiler and interpreter targeting .NET Core, including the initial project structure, build tooling, and CI configuration. It focused on implementing the core language infrastructure, such as the lexer, parser, syntax tree, semantic binder, and symbol model, while adding comprehensive test coverage for these components.

5 changes.

This period established the foundational compiler infrastructure for the Minsk language, including the lexer, parser, and code analysis layers. It introduced initial IL code generation capabilities for BASIC programs using Mono.Cecil and implemented control flow lowering to basic blocks. The work also included adding sample projects and test suites to verify the new compiler components.

A new sample project has been added to demonstrate a basic 'Hello World' application. It includes a source file that declares a string variable and prints it, and a project file configured to build as an executable targeting .NET Core 3.1.

BASIC/Samples/Hello · high confidence

New console applications have been added to the lexer and parser projects to facilitate experimentation with the BASIC-language support. The lexer test demonstrates source text processing and line iteration, while the parser test validates syntax tree generation and diagnostic reporting for sample BASIC code.

lexer, parser · high confidence

The BASIC interpreter now provides visually distinct syntax highlighting in its output, using extension methods to color keywords (blue), identifiers (dark yellow), numbers (cyan), strings (magenta), and punctuation (dark gray). Additionally, diagnostic messages (errors and warnings) are formatted with detailed location information (filename, line, and character positions) and the offending code snippet is highlighted in red, improving the user's ability to locate and fix issues in their code.

BASIC/Basic/CodeAnalysis/IO · high confidence

The BASIC/Basic/CodeAnalysis/Syntax area now provides the foundational syntax tree (AST) and parsing infrastructure for the BASIC language. This includes a Lexer and Parser that tokenize source code and build a tree of SyntaxNodes, supporting expressions (binary, unary, assignment, calls, literals), statements (if/else, while, do-while, for, break, continue, return, variable declarations), and function declarations. The implementation introduces SyntaxKind enumerations, SyntaxFacts for operator precedence and keyword recognition, and a PrettyPrint utility for debugging the syntax tree structure.

BASIC/Basic/CodeAnalysis/Syntax · high confidence

The BASIC compiler now generates executable IL code for console applications. This change introduces the Emitter class, which uses Mono.Cecil to translate bound syntax trees into .NET assemblies, supporting features such as variable declarations, function calls, binary/unary expressions, string concatenation, and control flow statements like labels and gotos.

BASIC/Basic/CodeAnalysis/Emit · high confidence

This change introduces the foundational code analysis and binding layers for the Minsk language, including a Roslyn-based source generator that automatically implements the GetChildren method for syntax nodes to simplify tree traversal. It also establishes the build environment with strict nullable and features settings, and adds a comprehensive test suite covering the lexer, parser, and evaluator to verify tokenization, operator precedence, and expression evaluation.

Minsk · high confidence

This commit introduces the initial structure for a BASIC compiler targeting .NET Core, including the solution file, project definitions for the core compiler (Minsk), tests, and console utilities (msc, msi), along with build scripts (build.sh, buld.cmd) and CI configuration (azure-pipelines.yml) to automate building and testing.

(repo-wide) · high confidence

Added new classes and structures in the \Basic.CodeAnalysis.Text\ namespace to support multi-file source analysis. \SourceText\ manages the raw source string, parses it into \TextLine\ objects (handling various line-break formats), and provides character indexing. \TextSpan\ represents a range of characters within the text, and \TextLocation\ combines a span with file information to expose line and character positions for diagnostics.

BASIC/Basic/CodeAnalysis/Text · high confidence

A new executable entry point (Program.vb) is added to the BASIC/bc project, enabling users to compile BASIC source files into .exe assemblies via the command line. The tool accepts source file paths, optional assembly references (-r), and output module names (-o), performing syntax loading, compilation, and emission while reporting diagnostics to the console.

BASIC/bc · high confidence

The BASIC language now includes a full semantic analysis phase that transforms parsed syntax into a typed, bound tree. This change introduces the Binder, which resolves symbols, validates types, and produces a BoundProgram containing bound statements and expressions. Users can now write programs with variables, function calls, control flow (if, while, for), and binary/unary operators, with the compiler checking for errors like duplicate declarations or type mismatches before execution.

BASIC/Basic/CodeAnalysis/Binding · high confidence

The BASIC interpreter is now organized into a dedicated Visual Studio solution containing the core 'Basic' library, a 'bi' project (likely the REPL or main executable), and a 'Basic.Tests' project for unit testing. This restructuring separates the interpreter logic into its own assembly, facilitating its use as an API, while also introducing a test suite targeting .NET Core 2.1 to ensure code quality.

BASIC · high confidence

The BASIC REPL now supports persistent submissions where each new script execution chains off the previous compilation, allowing variables and functions defined in earlier inputs to remain available. Error reporting has been refactored from simple strings into a structured Diagnostic system, providing precise location information and specific error messages for issues like undefined variables, type mismatches, and syntax errors.

BASIC/Basic/CodeAnalysis · high confidence

The code analysis layer now uses a dedicated symbol hierarchy (FunctionSymbol, VariableSymbol, ParameterSymbol, TypeSymbol) to represent program elements, replacing the previous System.Type usage with a custom TypeSymbol that includes an 'any' type and an error state. This change enables the language to support function declarations with parameters and return types, and introduces a set of built-in functions (such as HEX$, OCT$, ASC, CHR$, INSTR, LCase$, LEN, MID$, RIGHT$, SPACE$, STR$, STRING$, UCase$, VAL, PRINT, INPUT, and RND) that are now recognized by the analyzer.

BASIC/Basic/CodeAnalysis/Symbol · high confidence

The code analysis lowering phase now transforms high-level control flow structures (if/else, while, do-while) into a flat sequence of basic blocks using explicit labels and conditional/unconditional jumps. This transformation automatically inserts implicit void returns at the end of functions where control can fall through, and removes unreachable (dead) code from the resulting statement list.

BASIC/Basic/CodeAnalysis/Lowering · high confidence

The BASIC interpreter's REPL now provides visual feedback by colorizing code elements such as keywords, identifiers, numbers, strings, and comments. This is achieved through a new classification system that analyzes the syntax tree and applies specific console colors during rendering. Additionally, the REPL's internal commands (like \#exit, \#cls, \#reset, \#load, \#ls, and \#dump) are now defined using a MetaCommand attribute, making them easier to extend and maintain.

BASIC/bi · high confidence

Added test coverage for BASIC syntax analysis; Added test coverage for code analysis and evaluation features.

This change introduces the initial project files for the BASIC and Minsk language tooling, establishing the build configuration and dependencies for the core libraries, command-line tools, and test suites. The BASIC library targets .NET Standard 2.1 and relies on Mono.Cecil and System.Collections.Immutable, while the Minsk core library also targets .NET Standard 2.1 with similar dependencies. Command-line executables (bc, bi, msc, msi) and experimental tools (lexer, parser) are configured for .NET 6.0. Test projects (Basic.Tests, Minsk.Tests) are added using xUnit and Microsoft.NET.Test.Sdk, targeting .NET 6.0. The Minsk.Generators project targets .NET Standard 2.0 and includes a reference to Microsoft.CodeAnalysis.CSharp.Workspaces.

(dependencies) · high confidence

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

• First survey — no prior run to compare against. CAI 56.

• Code Health 74
• Architecture 99
• Maturity 42
• Readiness 55
• Security 88

• 185 commits — 166 feature/other, 19 fixes

• BASIC/Basic — 109 commits
• BASIC/bc — 30 commits
• BASIC/Basic.Tests — 13 commits
• (root) — 10 commits
• BASIC/Samples — 8 commits
• (repo) — 6 commits
• BASIC/bi — 6 commits
• Minsk/Minsk — 3 commits

• fix: Add support for ==, !=, = and <>. Also fixes an error in the binder that doesn't correctly compute the resuling expression. It should have used the operator's type but still uses the hardcoded operand/left resulting types.
• fix: Add test coverage for recent bugs found.
• fix: Fix BoundTreeWriter.
• fix: Fix annoying issue in REPL where our last line would keep scrolling.
• fix: Fix bug where #reset crashes when no submissions exist. Introduce Compilation.IsScript and use it to restrict expression statements.
• fix: Fix exception when declaring variables with inserted names.
• fix: Fix test break after enabling converting arguments.
• fix: Fix where pretty printing fails with null. Add support for if-statements.
• fix: Fixed failing test.
• fix: Fixed issue with constant folding (==). All tests now pass.
• fix: Fixed issue with the pipe symbol not printing using the correct color for the tree.
• fix: Fixed multi-line comment not being rendered correctly in the repl.
• fix: Fixed not supporting parenthesized expressions with the recent changes added.
• fix: Fixed null reference for cases where the "missing/expected" token was inserted.
• fix: Fixed several issues that were failing due to somehow missing some steps in episode 12 (not sure how that happened). Went through the commits and got everything sorted. Rename bc to bi. Make REPL delete entire document on escape. Add basic string tests.
• fix: Fixed test that was broken due to changes made in last push.
• fix: Fixed usage of NumberExpression.
• fix: Make precedences data driven. (Which fixes the 1+2*3 problem I discussed before.)
• fix: Minor fixes to binding of call arguments #65
• change: .
• …and 165 more

• 6 containers · 0 bounded contexts · 0 dependency edges (baseline)

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

DualBrain/MinskVB 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.